// Retrieve A collection of attachments for this event which provide supplementary information to impacted users some examples are RFO (Reason For Outage) and root cause analysis documents.
355994
func (r Notification_Occurrence_Event) GetAttachments() (resp []datatypes.Notification_Occurrence_Event_Attachment, err error) {
	err = r.Session.DoRequest("SoftLayer_Notification_Occurrence_Event", "getAttachments", nil, &r.Options, &resp)
	return
}
1017227
func (mc MongoClient) getEvents(q bson.M) (me []models.Event, err error) {
	s := mc.getSessionCopy()
	defer s.Close()

	err = s.DB(mc.database.Name).C(db.EventsCollection).Find(q).All(&me)
	if err != nil {
		return []models.Event{}, errorMap(err)
	}
	return
}
244966
func (c *Client) GetAPIEvents(i *GetAPIEventsFilterInput) (GetAPIEventsResponse, error) {
	eventsResponse := GetAPIEventsResponse{
		Events: []*Event{},
		Links:  EventsPaginationInfo{},
	}

	path := fmt.Sprintf("/events")

	filters := &RequestOptions{Params: i.formatEventFilters()}

	resp, err := c.Get(path, filters)

	if err != nil {
		return eventsResponse, err
	}

	err = c.interpretAPIEventsPage(&eventsResponse, i.PageNumber, resp)
	// NOTE: It's possible for eventsResponse to be partially completed before an error
	// was encountered, so the presence of a statusResponse doesn't preclude the presence of
	// an error.
	// }
	return eventsResponse, err
}
839044
func (s *Sensu) GetEventsForClient(client string) ([]interface{}, error) {
	//return s.get("events", client)
	// TODO  is this the correct way? need validation??
	return s.getList(fmt.Sprintf("events/%s", client), 0, 0)
}
73120
func (c *Client) GetAPIEvent(i *GetAPIEventInput) (*Event, error) {
	if i.EventID == "" {
		return nil, ErrMissingEventID
	}

	path := fmt.Sprintf("/events/%s", i.EventID)
	resp, err := c.Get(path, nil)
	if err != nil {
		return nil, err
	}

	var event Event
	if err := jsonapi.UnmarshalPayload(resp.Body, &event); err != nil {
		return nil, err
	}
	return &event, nil
}
660981
func (obj *Doc) GetFolderItemsForConnection(ctx context.Context, connectionId string, relativePath string) ([]*FolderItem, error) {
	result := &struct {
		FolderItems []*FolderItem	`json:"qFolderItems"`
	} {}
	err := obj.rpc(ctx, "GetFolderItemsForConnection", result, connectionId, relativePath)
	return result.FolderItems, err 
}
114466
func (t *Template) GetAllAWSSecretsManagerSecretTargetAttachmentResources() map[string]*resources.AWSSecretsManagerSecretTargetAttachment {
	results := map[string]*resources.AWSSecretsManagerSecretTargetAttachment{}
	for name, untyped := range t.Resources {
		switch resource := untyped.(type) {
		case *resources.AWSSecretsManagerSecretTargetAttachment:
			results[name] = resource
		}
	}
	return results
}
379602
func (h *handler) fetchDocumentByPages(pages []blob.Ref) (*document, error) {
	return h.fetchDocumentFunc(pages, h.searchDocumentByPages)
}
1006565
func (c *ChatPostMessageCall) Attachment(attachment *objects.Attachment) *ChatPostMessageCall {
	c.attachments.Append(attachment)
	return c
}
1248215
func (r Network_Storage_Backup_Evault) GetFilePendingDeleteCount() (resp int, err error) {
	err = r.Session.DoRequest("SoftLayer_Network_Storage_Backup_Evault", "getFilePendingDeleteCount", nil, &r.Options, &resp)
	return
}
312305
func (st *State) cleanupAttachmentsForDyingVolume(volumeId string) (err error) {
	volumeTag := names.NewVolumeTag(volumeId)

	// This won't miss attachments, because a Dying volume cannot have
	// attachments added to it. But we do have to remove the attachments
	// themselves via individual transactions, because they could be in
	// any state at all.
	coll, closer := st.db().GetCollection(volumeAttachmentsC)
	defer closer()

	sb, err := NewStorageBackend(st)
	if err != nil {
		return errors.Trace(err)
	}

	var doc volumeAttachmentDoc
	fields := bson.D{{"hostid", 1}}
	iter := coll.Find(bson.D{{"volumeid", volumeId}}).Select(fields).Iter()
	defer closeIter(iter, &err, "reading volume attachment document")
	for iter.Next(&doc) {
		hostTag := storageAttachmentHost(doc.Host)
		if err := sb.DetachVolume(hostTag, volumeTag); err != nil {
			return errors.Annotate(err, "destroying volume attachment")
		}
	}
	return nil
}
1341478
func (a *API) AttachDocs(filename string) {
	d := apiDocumentation{API: a}

	f, err := os.Open(filename)
	defer f.Close()
	if err != nil {
		panic(err)
	}
	err = json.NewDecoder(f).Decode(&d)
	if err != nil {
		panic(err)
	}

	d.setup()

}
455428
func (r Notification_Occurrence_Event) GetUpdates() (resp []datatypes.Notification_Occurrence_Update, err error) {
	err = r.Session.DoRequest("SoftLayer_Notification_Occurrence_Event", "getUpdates", nil, &r.Options, &resp)
	return
}
1036631
func (ew *EventsWriter) GetPastEvents(request *Request) ([]*Event, error) {
	if ew.H != nil {
		return ew.H.GetEvents(request)
	}
	return nil, nil
}
1220060
func (d *domainClient) GetFlattenedDocument(ctx context.Context, args *GetFlattenedDocumentArgs) (reply *GetFlattenedDocumentReply, err error) {
	reply = new(GetFlattenedDocumentReply)
	if args != nil {
		err = rpcc.Invoke(ctx, "DOM.getFlattenedDocument", args, reply, d.conn)
	} else {
		err = rpcc.Invoke(ctx, "DOM.getFlattenedDocument", nil, reply, d.conn)
	}
	if err != nil {
		err = &internal.OpError{Domain: "DOM", Op: "GetFlattenedDocument", Err: err}
	}
	return
}
879646
func (r Event_Log) GetAllEventNames(objectName *string) (resp []string, err error) {
	params := []interface{}{
		objectName,
	}
	err = r.Session.DoRequest("SoftLayer_Event_Log", "getAllEventNames", params, &r.Options, &resp)
	return
}
355869
func (mc MongoClient) GetNotifications() ([]contract.Notification, error) {
	return mc.getNotifications(bson.M{})
}