cloudforce_one

package
v2.0.0-beta.5 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Mar 13, 2024 License: Apache-2.0 Imports: 12 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type CloudforceOnePriorityItem 

type CloudforceOnePriorityItem struct {
	// UUID
	ID string `json:"id,required"`
	// Priority creation time
	Created time.Time `json:"created,required" format:"date-time"`
	// List of labels
	Labels []string `json:"labels,required"`
	// Priority
	Priority int64 `json:"priority,required"`
	// Requirement
	Requirement string `json:"requirement,required"`
	// The CISA defined Traffic Light Protocol (TLP)
	Tlp CloudforceOnePriorityItemTlp `json:"tlp,required"`
	// Priority last updated time
	Updated time.Time                     `json:"updated,required" format:"date-time"`
	JSON    cloudforceOnePriorityItemJSON `json:"-"`
}

func (*CloudforceOnePriorityItem) UnmarshalJSON 

func (r *CloudforceOnePriorityItem) UnmarshalJSON(data []byte) (err error)

type CloudforceOnePriorityItemTlp 

type CloudforceOnePriorityItemTlp string

The CISA defined Traffic Light Protocol (TLP) 

const (
	CloudforceOnePriorityItemTlpClear       CloudforceOnePriorityItemTlp = "clear"
	CloudforceOnePriorityItemTlpAmber       CloudforceOnePriorityItemTlp = "amber"
	CloudforceOnePriorityItemTlpAmberStrict CloudforceOnePriorityItemTlp = "amber-strict"
	CloudforceOnePriorityItemTlpGreen       CloudforceOnePriorityItemTlp = "green"
	CloudforceOnePriorityItemTlpRed         CloudforceOnePriorityItemTlp = "red"
)

type CloudforceOneQuota 

type CloudforceOneQuota struct {
	// Anniversary date is when annual quota limit is refresh
	AnniversaryDate time.Time `json:"anniversary_date" format:"date-time"`
	// Quater anniversary date is when quota limit is refreshed each quarter
	QuarterAnniversaryDate time.Time `json:"quarter_anniversary_date" format:"date-time"`
	// Tokens for the quarter
	Quota int64 `json:"quota"`
	// Tokens remaining for the quarter
	Remaining int64                  `json:"remaining"`
	JSON      cloudforceOneQuotaJSON `json:"-"`
}

func (*CloudforceOneQuota) UnmarshalJSON 

func (r *CloudforceOneQuota) UnmarshalJSON(data []byte) (err error)

type CloudforceOneRequestConstants 

type CloudforceOneRequestConstants struct {
	Priority []CloudforceOneRequestConstantsPriority `json:"priority"`
	Status   []CloudforceOneRequestConstantsStatus   `json:"status"`
	Tlp      []CloudforceOneRequestConstantsTlp      `json:"tlp"`
	JSON     cloudforceOneRequestConstantsJSON       `json:"-"`
}

func (*CloudforceOneRequestConstants) UnmarshalJSON 

func (r *CloudforceOneRequestConstants) UnmarshalJSON(data []byte) (err error)

type CloudforceOneRequestConstantsPriority 

type CloudforceOneRequestConstantsPriority string
const (
	CloudforceOneRequestConstantsPriorityRoutine CloudforceOneRequestConstantsPriority = "routine"
	CloudforceOneRequestConstantsPriorityHigh    CloudforceOneRequestConstantsPriority = "high"
	CloudforceOneRequestConstantsPriorityUrgent  CloudforceOneRequestConstantsPriority = "urgent"
)

type CloudforceOneRequestConstantsStatus 

type CloudforceOneRequestConstantsStatus string

Request Status 

const (
	CloudforceOneRequestConstantsStatusOpen      CloudforceOneRequestConstantsStatus = "open"
	CloudforceOneRequestConstantsStatusAccepted  CloudforceOneRequestConstantsStatus = "accepted"
	CloudforceOneRequestConstantsStatusReported  CloudforceOneRequestConstantsStatus = "reported"
	CloudforceOneRequestConstantsStatusApproved  CloudforceOneRequestConstantsStatus = "approved"
	CloudforceOneRequestConstantsStatusCompleted CloudforceOneRequestConstantsStatus = "completed"
	CloudforceOneRequestConstantsStatusDeclined  CloudforceOneRequestConstantsStatus = "declined"
)

type CloudforceOneRequestConstantsTlp 

type CloudforceOneRequestConstantsTlp string

The CISA defined Traffic Light Protocol (TLP) 

const (
	CloudforceOneRequestConstantsTlpClear       CloudforceOneRequestConstantsTlp = "clear"
	CloudforceOneRequestConstantsTlpAmber       CloudforceOneRequestConstantsTlp = "amber"
	CloudforceOneRequestConstantsTlpAmberStrict CloudforceOneRequestConstantsTlp = "amber-strict"
	CloudforceOneRequestConstantsTlpGreen       CloudforceOneRequestConstantsTlp = "green"
	CloudforceOneRequestConstantsTlpRed         CloudforceOneRequestConstantsTlp = "red"
)

type CloudforceOneRequestItem 

type CloudforceOneRequestItem struct {
	// UUID
	ID string `json:"id,required"`
	// Request content
	Content  string    `json:"content,required"`
	Created  time.Time `json:"created,required" format:"date-time"`
	Priority time.Time `json:"priority,required" format:"date-time"`
	// Requested information from request
	Request string `json:"request,required"`
	// Brief description of the request
	Summary string `json:"summary,required"`
	// The CISA defined Traffic Light Protocol (TLP)
	Tlp       CloudforceOneRequestItemTlp `json:"tlp,required"`
	Updated   time.Time                   `json:"updated,required" format:"date-time"`
	Completed time.Time                   `json:"completed" format:"date-time"`
	// Tokens for the request messages
	MessageTokens int64 `json:"message_tokens"`
	// Readable Request ID
	ReadableID string `json:"readable_id"`
	// Request Status
	Status CloudforceOneRequestItemStatus `json:"status"`
	// Tokens for the request
	Tokens int64                        `json:"tokens"`
	JSON   cloudforceOneRequestItemJSON `json:"-"`
}

func (*CloudforceOneRequestItem) UnmarshalJSON 

func (r *CloudforceOneRequestItem) UnmarshalJSON(data []byte) (err error)

type CloudforceOneRequestItemStatus 

type CloudforceOneRequestItemStatus string

Request Status 

const (
	CloudforceOneRequestItemStatusOpen      CloudforceOneRequestItemStatus = "open"
	CloudforceOneRequestItemStatusAccepted  CloudforceOneRequestItemStatus = "accepted"
	CloudforceOneRequestItemStatusReported  CloudforceOneRequestItemStatus = "reported"
	CloudforceOneRequestItemStatusApproved  CloudforceOneRequestItemStatus = "approved"
	CloudforceOneRequestItemStatusCompleted CloudforceOneRequestItemStatus = "completed"
	CloudforceOneRequestItemStatusDeclined  CloudforceOneRequestItemStatus = "declined"
)

type CloudforceOneRequestItemTlp 

type CloudforceOneRequestItemTlp string

The CISA defined Traffic Light Protocol (TLP) 

const (
	CloudforceOneRequestItemTlpClear       CloudforceOneRequestItemTlp = "clear"
	CloudforceOneRequestItemTlpAmber       CloudforceOneRequestItemTlp = "amber"
	CloudforceOneRequestItemTlpAmberStrict CloudforceOneRequestItemTlp = "amber-strict"
	CloudforceOneRequestItemTlpGreen       CloudforceOneRequestItemTlp = "green"
	CloudforceOneRequestItemTlpRed         CloudforceOneRequestItemTlp = "red"
)

type CloudforceOneRequestListItem 

type CloudforceOneRequestListItem struct {
	// UUID
	ID string `json:"id,required"`
	// Request creation time
	Created  time.Time                            `json:"created,required" format:"date-time"`
	Priority CloudforceOneRequestListItemPriority `json:"priority,required"`
	// Requested information from request
	Request string `json:"request,required"`
	// Brief description of the request
	Summary string `json:"summary,required"`
	// The CISA defined Traffic Light Protocol (TLP)
	Tlp CloudforceOneRequestListItemTlp `json:"tlp,required"`
	// Request last updated time
	Updated time.Time `json:"updated,required" format:"date-time"`
	// Request completion time
	Completed time.Time `json:"completed" format:"date-time"`
	// Tokens for the request messages
	MessageTokens int64 `json:"message_tokens"`
	// Readable Request ID
	ReadableID string `json:"readable_id"`
	// Request Status
	Status CloudforceOneRequestListItemStatus `json:"status"`
	// Tokens for the request
	Tokens int64                            `json:"tokens"`
	JSON   cloudforceOneRequestListItemJSON `json:"-"`
}

func (*CloudforceOneRequestListItem) UnmarshalJSON 

func (r *CloudforceOneRequestListItem) UnmarshalJSON(data []byte) (err error)

type CloudforceOneRequestListItemPriority 

type CloudforceOneRequestListItemPriority string
const (
	CloudforceOneRequestListItemPriorityRoutine CloudforceOneRequestListItemPriority = "routine"
	CloudforceOneRequestListItemPriorityHigh    CloudforceOneRequestListItemPriority = "high"
	CloudforceOneRequestListItemPriorityUrgent  CloudforceOneRequestListItemPriority = "urgent"
)

type CloudforceOneRequestListItemStatus 

type CloudforceOneRequestListItemStatus string

Request Status 

const (
	CloudforceOneRequestListItemStatusOpen      CloudforceOneRequestListItemStatus = "open"
	CloudforceOneRequestListItemStatusAccepted  CloudforceOneRequestListItemStatus = "accepted"
	CloudforceOneRequestListItemStatusReported  CloudforceOneRequestListItemStatus = "reported"
	CloudforceOneRequestListItemStatusApproved  CloudforceOneRequestListItemStatus = "approved"
	CloudforceOneRequestListItemStatusCompleted CloudforceOneRequestListItemStatus = "completed"
	CloudforceOneRequestListItemStatusDeclined  CloudforceOneRequestListItemStatus = "declined"
)

type CloudforceOneRequestListItemTlp 

type CloudforceOneRequestListItemTlp string

The CISA defined Traffic Light Protocol (TLP) 

const (
	CloudforceOneRequestListItemTlpClear       CloudforceOneRequestListItemTlp = "clear"
	CloudforceOneRequestListItemTlpAmber       CloudforceOneRequestListItemTlp = "amber"
	CloudforceOneRequestListItemTlpAmberStrict CloudforceOneRequestListItemTlp = "amber-strict"
	CloudforceOneRequestListItemTlpGreen       CloudforceOneRequestListItemTlp = "green"
	CloudforceOneRequestListItemTlpRed         CloudforceOneRequestListItemTlp = "red"
)

type CloudforceOneRequestMessageItem 

type CloudforceOneRequestMessageItem struct {
	// Message ID
	ID int64 `json:"id,required"`
	// Author of message
	Author string `json:"author,required"`
	// Content of message
	Content string `json:"content,required"`
	// Message is a follow-on request
	IsFollowOnRequest bool `json:"is_follow_on_request,required"`
	// Message last updated time
	Updated time.Time `json:"updated,required" format:"date-time"`
	// Message creation time
	Created time.Time                           `json:"created" format:"date-time"`
	JSON    cloudforceOneRequestMessageItemJSON `json:"-"`
}

func (*CloudforceOneRequestMessageItem) UnmarshalJSON 

func (r *CloudforceOneRequestMessageItem) UnmarshalJSON(data []byte) (err error)

type CloudforceOneRequestTypes 

type CloudforceOneRequestTypes []string

type CloudforceOneService 

type CloudforceOneService struct {
	Options  []option.RequestOption
	Requests *RequestService
}

CloudforceOneService contains methods and other services that help with interacting with the cloudflare API. Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewCloudforceOneService method instead.

func NewCloudforceOneService 

func NewCloudforceOneService(opts ...option.RequestOption) (r *CloudforceOneService)

NewCloudforceOneService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

type Error 

type Error = apierror.Error

type RequestConstantsResponseEnvelope 

type RequestConstantsResponseEnvelope struct {
	Errors   []RequestConstantsResponseEnvelopeErrors   `json:"errors,required"`
	Messages []RequestConstantsResponseEnvelopeMessages `json:"messages,required"`
	Result   CloudforceOneRequestConstants              `json:"result,required"`
	// Whether the API call was successful
	Success RequestConstantsResponseEnvelopeSuccess `json:"success,required"`
	JSON    requestConstantsResponseEnvelopeJSON    `json:"-"`
}

func (*RequestConstantsResponseEnvelope) UnmarshalJSON 

func (r *RequestConstantsResponseEnvelope) UnmarshalJSON(data []byte) (err error)

type RequestConstantsResponseEnvelopeErrors 

type RequestConstantsResponseEnvelopeErrors struct {
	Code    int64                                      `json:"code,required"`
	Message string                                     `json:"message,required"`
	JSON    requestConstantsResponseEnvelopeErrorsJSON `json:"-"`
}

func (*RequestConstantsResponseEnvelopeErrors) UnmarshalJSON 

func (r *RequestConstantsResponseEnvelopeErrors) UnmarshalJSON(data []byte) (err error)

type RequestConstantsResponseEnvelopeMessages 

type RequestConstantsResponseEnvelopeMessages struct {
	Code    int64                                        `json:"code,required"`
	Message string                                       `json:"message,required"`
	JSON    requestConstantsResponseEnvelopeMessagesJSON `json:"-"`
}

func (*RequestConstantsResponseEnvelopeMessages) UnmarshalJSON 

func (r *RequestConstantsResponseEnvelopeMessages) UnmarshalJSON(data []byte) (err error)

type RequestConstantsResponseEnvelopeSuccess 

type RequestConstantsResponseEnvelopeSuccess bool

Whether the API call was successful 

const (
	RequestConstantsResponseEnvelopeSuccessTrue RequestConstantsResponseEnvelopeSuccess = true
)

type RequestDeleteResponse added in v2.2.0 

type RequestDeleteResponse interface {
	ImplementsCloudforceOneRequestDeleteResponse()
}

Union satisfied by cloudforce_one.RequestDeleteResponseUnknown, cloudforce_one.RequestDeleteResponseArray or shared.UnionString.

type RequestDeleteResponseArray 

type RequestDeleteResponseArray []interface{}

func (RequestDeleteResponseArray) ImplementsCloudforceOneRequestDeleteResponse 

func (r RequestDeleteResponseArray) ImplementsCloudforceOneRequestDeleteResponse()

type RequestDeleteResponseEnvelope 

type RequestDeleteResponseEnvelope struct {
	Errors   []RequestDeleteResponseEnvelopeErrors   `json:"errors,required"`
	Messages []RequestDeleteResponseEnvelopeMessages `json:"messages,required"`
	Result   RequestDeleteResponse                   `json:"result,required"`
	// Whether the API call was successful
	Success RequestDeleteResponseEnvelopeSuccess `json:"success,required"`
	JSON    requestDeleteResponseEnvelopeJSON    `json:"-"`
}

func (*RequestDeleteResponseEnvelope) UnmarshalJSON 

func (r *RequestDeleteResponseEnvelope) UnmarshalJSON(data []byte) (err error)

type RequestDeleteResponseEnvelopeErrors 

type RequestDeleteResponseEnvelopeErrors struct {
	Code    int64                                   `json:"code,required"`
	Message string                                  `json:"message,required"`
	JSON    requestDeleteResponseEnvelopeErrorsJSON `json:"-"`
}

func (*RequestDeleteResponseEnvelopeErrors) UnmarshalJSON 

func (r *RequestDeleteResponseEnvelopeErrors) UnmarshalJSON(data []byte) (err error)

type RequestDeleteResponseEnvelopeMessages 

type RequestDeleteResponseEnvelopeMessages struct {
	Code    int64                                     `json:"code,required"`
	Message string                                    `json:"message,required"`
	JSON    requestDeleteResponseEnvelopeMessagesJSON `json:"-"`
}

func (*RequestDeleteResponseEnvelopeMessages) UnmarshalJSON 

func (r *RequestDeleteResponseEnvelopeMessages) UnmarshalJSON(data []byte) (err error)

type RequestDeleteResponseEnvelopeSuccess 

type RequestDeleteResponseEnvelopeSuccess bool

Whether the API call was successful 

const (
	RequestDeleteResponseEnvelopeSuccessTrue RequestDeleteResponseEnvelopeSuccess = true
)

type RequestGetResponseEnvelope 

type RequestGetResponseEnvelope struct {
	Errors   []RequestGetResponseEnvelopeErrors   `json:"errors,required"`
	Messages []RequestGetResponseEnvelopeMessages `json:"messages,required"`
	Result   CloudforceOneRequestItem             `json:"result,required"`
	// Whether the API call was successful
	Success RequestGetResponseEnvelopeSuccess `json:"success,required"`
	JSON    requestGetResponseEnvelopeJSON    `json:"-"`
}

func (*RequestGetResponseEnvelope) UnmarshalJSON 

func (r *RequestGetResponseEnvelope) UnmarshalJSON(data []byte) (err error)

type RequestGetResponseEnvelopeErrors 

type RequestGetResponseEnvelopeErrors struct {
	Code    int64                                `json:"code,required"`
	Message string                               `json:"message,required"`
	JSON    requestGetResponseEnvelopeErrorsJSON `json:"-"`
}

func (*RequestGetResponseEnvelopeErrors) UnmarshalJSON 

func (r *RequestGetResponseEnvelopeErrors) UnmarshalJSON(data []byte) (err error)

type RequestGetResponseEnvelopeMessages 

type RequestGetResponseEnvelopeMessages struct {
	Code    int64                                  `json:"code,required"`
	Message string                                 `json:"message,required"`
	JSON    requestGetResponseEnvelopeMessagesJSON `json:"-"`
}

func (*RequestGetResponseEnvelopeMessages) UnmarshalJSON 

func (r *RequestGetResponseEnvelopeMessages) UnmarshalJSON(data []byte) (err error)

type RequestGetResponseEnvelopeSuccess 

type RequestGetResponseEnvelopeSuccess bool

Whether the API call was successful 

const (
	RequestGetResponseEnvelopeSuccessTrue RequestGetResponseEnvelopeSuccess = true
)

type RequestListParams 

type RequestListParams struct {
	// Page number of results
	Page param.Field[int64] `json:"page,required"`
	// Number of results per page
	PerPage param.Field[int64] `json:"per_page,required"`
	// Retrieve requests completed after this time
	CompletedAfter param.Field[time.Time] `json:"completed_after" format:"date-time"`
	// Retrieve requests completed before this time
	CompletedBefore param.Field[time.Time] `json:"completed_before" format:"date-time"`
	// Retrieve requests created after this time
	CreatedAfter param.Field[time.Time] `json:"created_after" format:"date-time"`
	// Retrieve requests created before this time
	CreatedBefore param.Field[time.Time] `json:"created_before" format:"date-time"`
	// Requested information from request
	RequestType param.Field[string] `json:"request_type"`
	// Field to sort results by
	SortBy param.Field[string] `json:"sort_by"`
	// Sort order (asc or desc)
	SortOrder param.Field[RequestListParamsSortOrder] `json:"sort_order"`
	// Request Status
	Status param.Field[RequestListParamsStatus] `json:"status"`
}

func (RequestListParams) MarshalJSON 

func (r RequestListParams) MarshalJSON() (data []byte, err error)

type RequestListParamsSortOrder 

type RequestListParamsSortOrder string

Sort order (asc or desc) 

const (
	RequestListParamsSortOrderAsc  RequestListParamsSortOrder = "asc"
	RequestListParamsSortOrderDesc RequestListParamsSortOrder = "desc"
)

type RequestListParamsStatus 

type RequestListParamsStatus string

Request Status 

const (
	RequestListParamsStatusOpen      RequestListParamsStatus = "open"
	RequestListParamsStatusAccepted  RequestListParamsStatus = "accepted"
	RequestListParamsStatusReported  RequestListParamsStatus = "reported"
	RequestListParamsStatusApproved  RequestListParamsStatus = "approved"
	RequestListParamsStatusCompleted RequestListParamsStatus = "completed"
	RequestListParamsStatusDeclined  RequestListParamsStatus = "declined"
)

type RequestMessageDeleteResponse added in v2.2.0 

type RequestMessageDeleteResponse interface {
	ImplementsCloudforceOneRequestMessageDeleteResponse()
}

Union satisfied by cloudforce_one.RequestMessageDeleteResponseUnknown, cloudforce_one.RequestMessageDeleteResponseArray or shared.UnionString.

type RequestMessageDeleteResponseArray 

type RequestMessageDeleteResponseArray []interface{}

func (RequestMessageDeleteResponseArray) ImplementsCloudforceOneRequestMessageDeleteResponse 

func (r RequestMessageDeleteResponseArray) ImplementsCloudforceOneRequestMessageDeleteResponse()

type RequestMessageDeleteResponseEnvelope 

type RequestMessageDeleteResponseEnvelope struct {
	Errors   []RequestMessageDeleteResponseEnvelopeErrors   `json:"errors,required"`
	Messages []RequestMessageDeleteResponseEnvelopeMessages `json:"messages,required"`
	Result   RequestMessageDeleteResponse                   `json:"result,required"`
	// Whether the API call was successful
	Success RequestMessageDeleteResponseEnvelopeSuccess `json:"success,required"`
	JSON    requestMessageDeleteResponseEnvelopeJSON    `json:"-"`
}

func (*RequestMessageDeleteResponseEnvelope) UnmarshalJSON 

func (r *RequestMessageDeleteResponseEnvelope) UnmarshalJSON(data []byte) (err error)

type RequestMessageDeleteResponseEnvelopeErrors 

type RequestMessageDeleteResponseEnvelopeErrors struct {
	Code    int64                                          `json:"code,required"`
	Message string                                         `json:"message,required"`
	JSON    requestMessageDeleteResponseEnvelopeErrorsJSON `json:"-"`
}

func (*RequestMessageDeleteResponseEnvelopeErrors) UnmarshalJSON 

func (r *RequestMessageDeleteResponseEnvelopeErrors) UnmarshalJSON(data []byte) (err error)

type RequestMessageDeleteResponseEnvelopeMessages 

type RequestMessageDeleteResponseEnvelopeMessages struct {
	Code    int64                                            `json:"code,required"`
	Message string                                           `json:"message,required"`
	JSON    requestMessageDeleteResponseEnvelopeMessagesJSON `json:"-"`
}

func (*RequestMessageDeleteResponseEnvelopeMessages) UnmarshalJSON 

func (r *RequestMessageDeleteResponseEnvelopeMessages) UnmarshalJSON(data []byte) (err error)

type RequestMessageDeleteResponseEnvelopeSuccess 

type RequestMessageDeleteResponseEnvelopeSuccess bool

Whether the API call was successful 

const (
	RequestMessageDeleteResponseEnvelopeSuccessTrue RequestMessageDeleteResponseEnvelopeSuccess = true
)

type RequestMessageGetParams 

type RequestMessageGetParams struct {
	// Page number of results
	Page param.Field[int64] `json:"page,required"`
	// Number of results per page
	PerPage param.Field[int64] `json:"per_page,required"`
	// Retrieve messages created after this time
	After param.Field[time.Time] `json:"after" format:"date-time"`
	// Retrieve messages created before this time
	Before param.Field[time.Time] `json:"before" format:"date-time"`
	// Field to sort results by
	SortBy param.Field[string] `json:"sort_by"`
	// Sort order (asc or desc)
	SortOrder param.Field[RequestMessageGetParamsSortOrder] `json:"sort_order"`
}

func (RequestMessageGetParams) MarshalJSON 

func (r RequestMessageGetParams) MarshalJSON() (data []byte, err error)

type RequestMessageGetParamsSortOrder 

type RequestMessageGetParamsSortOrder string

Sort order (asc or desc) 

const (
	RequestMessageGetParamsSortOrderAsc  RequestMessageGetParamsSortOrder = "asc"
	RequestMessageGetParamsSortOrderDesc RequestMessageGetParamsSortOrder = "desc"
)

type RequestMessageGetResponseEnvelope 

type RequestMessageGetResponseEnvelope struct {
	Errors   []RequestMessageGetResponseEnvelopeErrors   `json:"errors,required"`
	Messages []RequestMessageGetResponseEnvelopeMessages `json:"messages,required"`
	Result   []CloudforceOneRequestMessageItem           `json:"result,required"`
	// Whether the API call was successful
	Success RequestMessageGetResponseEnvelopeSuccess `json:"success,required"`
	JSON    requestMessageGetResponseEnvelopeJSON    `json:"-"`
}

func (*RequestMessageGetResponseEnvelope) UnmarshalJSON 

func (r *RequestMessageGetResponseEnvelope) UnmarshalJSON(data []byte) (err error)

type RequestMessageGetResponseEnvelopeErrors 

type RequestMessageGetResponseEnvelopeErrors struct {
	Code    int64                                       `json:"code,required"`
	Message string                                      `json:"message,required"`
	JSON    requestMessageGetResponseEnvelopeErrorsJSON `json:"-"`
}

func (*RequestMessageGetResponseEnvelopeErrors) UnmarshalJSON 

func (r *RequestMessageGetResponseEnvelopeErrors) UnmarshalJSON(data []byte) (err error)

type RequestMessageGetResponseEnvelopeMessages 

type RequestMessageGetResponseEnvelopeMessages struct {
	Code    int64                                         `json:"code,required"`
	Message string                                        `json:"message,required"`
	JSON    requestMessageGetResponseEnvelopeMessagesJSON `json:"-"`
}

func (*RequestMessageGetResponseEnvelopeMessages) UnmarshalJSON 

func (r *RequestMessageGetResponseEnvelopeMessages) UnmarshalJSON(data []byte) (err error)

type RequestMessageGetResponseEnvelopeSuccess 

type RequestMessageGetResponseEnvelopeSuccess bool

Whether the API call was successful 

const (
	RequestMessageGetResponseEnvelopeSuccessTrue RequestMessageGetResponseEnvelopeSuccess = true
)

type RequestMessageNewParams 

type RequestMessageNewParams struct {
	// Content of message
	Content param.Field[string] `json:"content"`
}

func (RequestMessageNewParams) MarshalJSON 

func (r RequestMessageNewParams) MarshalJSON() (data []byte, err error)

type RequestMessageNewResponseEnvelope 

type RequestMessageNewResponseEnvelope struct {
	Errors   []RequestMessageNewResponseEnvelopeErrors   `json:"errors,required"`
	Messages []RequestMessageNewResponseEnvelopeMessages `json:"messages,required"`
	Result   CloudforceOneRequestMessageItem             `json:"result,required"`
	// Whether the API call was successful
	Success RequestMessageNewResponseEnvelopeSuccess `json:"success,required"`
	JSON    requestMessageNewResponseEnvelopeJSON    `json:"-"`
}

func (*RequestMessageNewResponseEnvelope) UnmarshalJSON 

func (r *RequestMessageNewResponseEnvelope) UnmarshalJSON(data []byte) (err error)

type RequestMessageNewResponseEnvelopeErrors 

type RequestMessageNewResponseEnvelopeErrors struct {
	Code    int64                                       `json:"code,required"`
	Message string                                      `json:"message,required"`
	JSON    requestMessageNewResponseEnvelopeErrorsJSON `json:"-"`
}

func (*RequestMessageNewResponseEnvelopeErrors) UnmarshalJSON 

func (r *RequestMessageNewResponseEnvelopeErrors) UnmarshalJSON(data []byte) (err error)

type RequestMessageNewResponseEnvelopeMessages 

type RequestMessageNewResponseEnvelopeMessages struct {
	Code    int64                                         `json:"code,required"`
	Message string                                        `json:"message,required"`
	JSON    requestMessageNewResponseEnvelopeMessagesJSON `json:"-"`
}

func (*RequestMessageNewResponseEnvelopeMessages) UnmarshalJSON 

func (r *RequestMessageNewResponseEnvelopeMessages) UnmarshalJSON(data []byte) (err error)

type RequestMessageNewResponseEnvelopeSuccess 

type RequestMessageNewResponseEnvelopeSuccess bool

Whether the API call was successful 

const (
	RequestMessageNewResponseEnvelopeSuccessTrue RequestMessageNewResponseEnvelopeSuccess = true
)

type RequestMessageService 

type RequestMessageService struct {
	Options []option.RequestOption
}

RequestMessageService contains methods and other services that help with interacting with the cloudflare API. Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewRequestMessageService method instead.

func NewRequestMessageService 

func NewRequestMessageService(opts ...option.RequestOption) (r *RequestMessageService)

NewRequestMessageService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*RequestMessageService) Delete 

func (r *RequestMessageService) Delete(ctx context.Context, accountIdentifier string, requestIdentifier string, messageIdentifer int64, opts ...option.RequestOption) (res *RequestMessageDeleteResponse, err error)

Delete a Request Message

func (*RequestMessageService) Get 

func (r *RequestMessageService) Get(ctx context.Context, accountIdentifier string, requestIdentifier string, body RequestMessageGetParams, opts ...option.RequestOption) (res *[]CloudforceOneRequestMessageItem, err error)

List Request Messages

func (*RequestMessageService) New 

func (r *RequestMessageService) New(ctx context.Context, accountIdentifier string, requestIdentifier string, body RequestMessageNewParams, opts ...option.RequestOption) (res *CloudforceOneRequestMessageItem, err error)

Creating a request adds the request into the Cloudforce One queue for analysis. In addition to the content, a short title, type, priority, and releasability should be provided. If one is not provided a default will be assigned.

func (*RequestMessageService) Update 

func (r *RequestMessageService) Update(ctx context.Context, accountIdentifier string, requestIdentifier string, messageIdentifer int64, body RequestMessageUpdateParams, opts ...option.RequestOption) (res *CloudforceOneRequestMessageItem, err error)

Update a Request Message

type RequestMessageUpdateParams 

type RequestMessageUpdateParams struct {
	// Request content
	Content param.Field[string] `json:"content"`
	// Priority for analyzing the request
	Priority param.Field[string] `json:"priority"`
	// Requested information from request
	RequestType param.Field[string] `json:"request_type"`
	// Brief description of the request
	Summary param.Field[string] `json:"summary"`
	// The CISA defined Traffic Light Protocol (TLP)
	Tlp param.Field[RequestMessageUpdateParamsTlp] `json:"tlp"`
}

func (RequestMessageUpdateParams) MarshalJSON 

func (r RequestMessageUpdateParams) MarshalJSON() (data []byte, err error)

type RequestMessageUpdateParamsTlp 

type RequestMessageUpdateParamsTlp string

The CISA defined Traffic Light Protocol (TLP) 

const (
	RequestMessageUpdateParamsTlpClear       RequestMessageUpdateParamsTlp = "clear"
	RequestMessageUpdateParamsTlpAmber       RequestMessageUpdateParamsTlp = "amber"
	RequestMessageUpdateParamsTlpAmberStrict RequestMessageUpdateParamsTlp = "amber-strict"
	RequestMessageUpdateParamsTlpGreen       RequestMessageUpdateParamsTlp = "green"
	RequestMessageUpdateParamsTlpRed         RequestMessageUpdateParamsTlp = "red"
)

type RequestMessageUpdateResponseEnvelope 

type RequestMessageUpdateResponseEnvelope struct {
	Errors   []RequestMessageUpdateResponseEnvelopeErrors   `json:"errors,required"`
	Messages []RequestMessageUpdateResponseEnvelopeMessages `json:"messages,required"`
	Result   CloudforceOneRequestMessageItem                `json:"result,required"`
	// Whether the API call was successful
	Success RequestMessageUpdateResponseEnvelopeSuccess `json:"success,required"`
	JSON    requestMessageUpdateResponseEnvelopeJSON    `json:"-"`
}

func (*RequestMessageUpdateResponseEnvelope) UnmarshalJSON 

func (r *RequestMessageUpdateResponseEnvelope) UnmarshalJSON(data []byte) (err error)

type RequestMessageUpdateResponseEnvelopeErrors 

type RequestMessageUpdateResponseEnvelopeErrors struct {
	Code    int64                                          `json:"code,required"`
	Message string                                         `json:"message,required"`
	JSON    requestMessageUpdateResponseEnvelopeErrorsJSON `json:"-"`
}

func (*RequestMessageUpdateResponseEnvelopeErrors) UnmarshalJSON 

func (r *RequestMessageUpdateResponseEnvelopeErrors) UnmarshalJSON(data []byte) (err error)

type RequestMessageUpdateResponseEnvelopeMessages 

type RequestMessageUpdateResponseEnvelopeMessages struct {
	Code    int64                                            `json:"code,required"`
	Message string                                           `json:"message,required"`
	JSON    requestMessageUpdateResponseEnvelopeMessagesJSON `json:"-"`
}

func (*RequestMessageUpdateResponseEnvelopeMessages) UnmarshalJSON 

func (r *RequestMessageUpdateResponseEnvelopeMessages) UnmarshalJSON(data []byte) (err error)

type RequestMessageUpdateResponseEnvelopeSuccess 

type RequestMessageUpdateResponseEnvelopeSuccess bool

Whether the API call was successful 

const (
	RequestMessageUpdateResponseEnvelopeSuccessTrue RequestMessageUpdateResponseEnvelopeSuccess = true
)

type RequestNewParams 

type RequestNewParams struct {
	// Request content
	Content param.Field[string] `json:"content"`
	// Priority for analyzing the request
	Priority param.Field[string] `json:"priority"`
	// Requested information from request
	RequestType param.Field[string] `json:"request_type"`
	// Brief description of the request
	Summary param.Field[string] `json:"summary"`
	// The CISA defined Traffic Light Protocol (TLP)
	Tlp param.Field[RequestNewParamsTlp] `json:"tlp"`
}

func (RequestNewParams) MarshalJSON 

func (r RequestNewParams) MarshalJSON() (data []byte, err error)

type RequestNewParamsTlp 

type RequestNewParamsTlp string

The CISA defined Traffic Light Protocol (TLP) 

const (
	RequestNewParamsTlpClear       RequestNewParamsTlp = "clear"
	RequestNewParamsTlpAmber       RequestNewParamsTlp = "amber"
	RequestNewParamsTlpAmberStrict RequestNewParamsTlp = "amber-strict"
	RequestNewParamsTlpGreen       RequestNewParamsTlp = "green"
	RequestNewParamsTlpRed         RequestNewParamsTlp = "red"
)

type RequestNewResponseEnvelope 

type RequestNewResponseEnvelope struct {
	Errors   []RequestNewResponseEnvelopeErrors   `json:"errors,required"`
	Messages []RequestNewResponseEnvelopeMessages `json:"messages,required"`
	Result   CloudforceOneRequestItem             `json:"result,required"`
	// Whether the API call was successful
	Success RequestNewResponseEnvelopeSuccess `json:"success,required"`
	JSON    requestNewResponseEnvelopeJSON    `json:"-"`
}

func (*RequestNewResponseEnvelope) UnmarshalJSON 

func (r *RequestNewResponseEnvelope) UnmarshalJSON(data []byte) (err error)

type RequestNewResponseEnvelopeErrors 

type RequestNewResponseEnvelopeErrors struct {
	Code    int64                                `json:"code,required"`
	Message string                               `json:"message,required"`
	JSON    requestNewResponseEnvelopeErrorsJSON `json:"-"`
}

func (*RequestNewResponseEnvelopeErrors) UnmarshalJSON 

func (r *RequestNewResponseEnvelopeErrors) UnmarshalJSON(data []byte) (err error)

type RequestNewResponseEnvelopeMessages 

type RequestNewResponseEnvelopeMessages struct {
	Code    int64                                  `json:"code,required"`
	Message string                                 `json:"message,required"`
	JSON    requestNewResponseEnvelopeMessagesJSON `json:"-"`
}

func (*RequestNewResponseEnvelopeMessages) UnmarshalJSON 

func (r *RequestNewResponseEnvelopeMessages) UnmarshalJSON(data []byte) (err error)

type RequestNewResponseEnvelopeSuccess 

type RequestNewResponseEnvelopeSuccess bool

Whether the API call was successful 

const (
	RequestNewResponseEnvelopeSuccessTrue RequestNewResponseEnvelopeSuccess = true
)

type RequestPriorityDeleteResponse added in v2.2.0 

type RequestPriorityDeleteResponse interface {
	ImplementsCloudforceOneRequestPriorityDeleteResponse()
}

Union satisfied by cloudforce_one.RequestPriorityDeleteResponseUnknown, cloudforce_one.RequestPriorityDeleteResponseArray or shared.UnionString.

type RequestPriorityDeleteResponseArray 

type RequestPriorityDeleteResponseArray []interface{}

func (RequestPriorityDeleteResponseArray) ImplementsCloudforceOneRequestPriorityDeleteResponse 

func (r RequestPriorityDeleteResponseArray) ImplementsCloudforceOneRequestPriorityDeleteResponse()

type RequestPriorityDeleteResponseEnvelope 

type RequestPriorityDeleteResponseEnvelope struct {
	Errors   []RequestPriorityDeleteResponseEnvelopeErrors   `json:"errors,required"`
	Messages []RequestPriorityDeleteResponseEnvelopeMessages `json:"messages,required"`
	Result   RequestPriorityDeleteResponse                   `json:"result,required"`
	// Whether the API call was successful
	Success RequestPriorityDeleteResponseEnvelopeSuccess `json:"success,required"`
	JSON    requestPriorityDeleteResponseEnvelopeJSON    `json:"-"`
}

func (*RequestPriorityDeleteResponseEnvelope) UnmarshalJSON 

func (r *RequestPriorityDeleteResponseEnvelope) UnmarshalJSON(data []byte) (err error)

type RequestPriorityDeleteResponseEnvelopeErrors 

type RequestPriorityDeleteResponseEnvelopeErrors struct {
	Code    int64                                           `json:"code,required"`
	Message string                                          `json:"message,required"`
	JSON    requestPriorityDeleteResponseEnvelopeErrorsJSON `json:"-"`
}

func (*RequestPriorityDeleteResponseEnvelopeErrors) UnmarshalJSON 

func (r *RequestPriorityDeleteResponseEnvelopeErrors) UnmarshalJSON(data []byte) (err error)

type RequestPriorityDeleteResponseEnvelopeMessages 

type RequestPriorityDeleteResponseEnvelopeMessages struct {
	Code    int64                                             `json:"code,required"`
	Message string                                            `json:"message,required"`
	JSON    requestPriorityDeleteResponseEnvelopeMessagesJSON `json:"-"`
}

func (*RequestPriorityDeleteResponseEnvelopeMessages) UnmarshalJSON 

func (r *RequestPriorityDeleteResponseEnvelopeMessages) UnmarshalJSON(data []byte) (err error)

type RequestPriorityDeleteResponseEnvelopeSuccess 

type RequestPriorityDeleteResponseEnvelopeSuccess bool

Whether the API call was successful 

const (
	RequestPriorityDeleteResponseEnvelopeSuccessTrue RequestPriorityDeleteResponseEnvelopeSuccess = true
)

type RequestPriorityGetResponseEnvelope 

type RequestPriorityGetResponseEnvelope struct {
	Errors   []RequestPriorityGetResponseEnvelopeErrors   `json:"errors,required"`
	Messages []RequestPriorityGetResponseEnvelopeMessages `json:"messages,required"`
	Result   CloudforceOneRequestItem                     `json:"result,required"`
	// Whether the API call was successful
	Success RequestPriorityGetResponseEnvelopeSuccess `json:"success,required"`
	JSON    requestPriorityGetResponseEnvelopeJSON    `json:"-"`
}

func (*RequestPriorityGetResponseEnvelope) UnmarshalJSON 

func (r *RequestPriorityGetResponseEnvelope) UnmarshalJSON(data []byte) (err error)

type RequestPriorityGetResponseEnvelopeErrors 

type RequestPriorityGetResponseEnvelopeErrors struct {
	Code    int64                                        `json:"code,required"`
	Message string                                       `json:"message,required"`
	JSON    requestPriorityGetResponseEnvelopeErrorsJSON `json:"-"`
}

func (*RequestPriorityGetResponseEnvelopeErrors) UnmarshalJSON 

func (r *RequestPriorityGetResponseEnvelopeErrors) UnmarshalJSON(data []byte) (err error)

type RequestPriorityGetResponseEnvelopeMessages 

type RequestPriorityGetResponseEnvelopeMessages struct {
	Code    int64                                          `json:"code,required"`
	Message string                                         `json:"message,required"`
	JSON    requestPriorityGetResponseEnvelopeMessagesJSON `json:"-"`
}

func (*RequestPriorityGetResponseEnvelopeMessages) UnmarshalJSON 

func (r *RequestPriorityGetResponseEnvelopeMessages) UnmarshalJSON(data []byte) (err error)

type RequestPriorityGetResponseEnvelopeSuccess 

type RequestPriorityGetResponseEnvelopeSuccess bool

Whether the API call was successful 

const (
	RequestPriorityGetResponseEnvelopeSuccessTrue RequestPriorityGetResponseEnvelopeSuccess = true
)

type RequestPriorityNewParams 

type RequestPriorityNewParams struct {
	// List of labels
	Labels param.Field[[]string] `json:"labels,required"`
	// Priority
	Priority param.Field[int64] `json:"priority,required"`
	// Requirement
	Requirement param.Field[string] `json:"requirement,required"`
	// The CISA defined Traffic Light Protocol (TLP)
	Tlp param.Field[RequestPriorityNewParamsTlp] `json:"tlp,required"`
}

func (RequestPriorityNewParams) MarshalJSON 

func (r RequestPriorityNewParams) MarshalJSON() (data []byte, err error)

type RequestPriorityNewParamsTlp 

type RequestPriorityNewParamsTlp string

The CISA defined Traffic Light Protocol (TLP) 

const (
	RequestPriorityNewParamsTlpClear       RequestPriorityNewParamsTlp = "clear"
	RequestPriorityNewParamsTlpAmber       RequestPriorityNewParamsTlp = "amber"
	RequestPriorityNewParamsTlpAmberStrict RequestPriorityNewParamsTlp = "amber-strict"
	RequestPriorityNewParamsTlpGreen       RequestPriorityNewParamsTlp = "green"
	RequestPriorityNewParamsTlpRed         RequestPriorityNewParamsTlp = "red"
)

type RequestPriorityNewResponseEnvelope 

type RequestPriorityNewResponseEnvelope struct {
	Errors   []RequestPriorityNewResponseEnvelopeErrors   `json:"errors,required"`
	Messages []RequestPriorityNewResponseEnvelopeMessages `json:"messages,required"`
	Result   CloudforceOnePriorityItem                    `json:"result,required"`
	// Whether the API call was successful
	Success RequestPriorityNewResponseEnvelopeSuccess `json:"success,required"`
	JSON    requestPriorityNewResponseEnvelopeJSON    `json:"-"`
}

func (*RequestPriorityNewResponseEnvelope) UnmarshalJSON 

func (r *RequestPriorityNewResponseEnvelope) UnmarshalJSON(data []byte) (err error)

type RequestPriorityNewResponseEnvelopeErrors 

type RequestPriorityNewResponseEnvelopeErrors struct {
	Code    int64                                        `json:"code,required"`
	Message string                                       `json:"message,required"`
	JSON    requestPriorityNewResponseEnvelopeErrorsJSON `json:"-"`
}

func (*RequestPriorityNewResponseEnvelopeErrors) UnmarshalJSON 

func (r *RequestPriorityNewResponseEnvelopeErrors) UnmarshalJSON(data []byte) (err error)

type RequestPriorityNewResponseEnvelopeMessages 

type RequestPriorityNewResponseEnvelopeMessages struct {
	Code    int64                                          `json:"code,required"`
	Message string                                         `json:"message,required"`
	JSON    requestPriorityNewResponseEnvelopeMessagesJSON `json:"-"`
}

func (*RequestPriorityNewResponseEnvelopeMessages) UnmarshalJSON 

func (r *RequestPriorityNewResponseEnvelopeMessages) UnmarshalJSON(data []byte) (err error)

type RequestPriorityNewResponseEnvelopeSuccess 

type RequestPriorityNewResponseEnvelopeSuccess bool

Whether the API call was successful 

const (
	RequestPriorityNewResponseEnvelopeSuccessTrue RequestPriorityNewResponseEnvelopeSuccess = true
)

type RequestPriorityQuotaResponseEnvelope 

type RequestPriorityQuotaResponseEnvelope struct {
	Errors   []RequestPriorityQuotaResponseEnvelopeErrors   `json:"errors,required"`
	Messages []RequestPriorityQuotaResponseEnvelopeMessages `json:"messages,required"`
	Result   CloudforceOneQuota                             `json:"result,required"`
	// Whether the API call was successful
	Success RequestPriorityQuotaResponseEnvelopeSuccess `json:"success,required"`
	JSON    requestPriorityQuotaResponseEnvelopeJSON    `json:"-"`
}

func (*RequestPriorityQuotaResponseEnvelope) UnmarshalJSON 

func (r *RequestPriorityQuotaResponseEnvelope) UnmarshalJSON(data []byte) (err error)

type RequestPriorityQuotaResponseEnvelopeErrors 

type RequestPriorityQuotaResponseEnvelopeErrors struct {
	Code    int64                                          `json:"code,required"`
	Message string                                         `json:"message,required"`
	JSON    requestPriorityQuotaResponseEnvelopeErrorsJSON `json:"-"`
}

func (*RequestPriorityQuotaResponseEnvelopeErrors) UnmarshalJSON 

func (r *RequestPriorityQuotaResponseEnvelopeErrors) UnmarshalJSON(data []byte) (err error)

type RequestPriorityQuotaResponseEnvelopeMessages 

type RequestPriorityQuotaResponseEnvelopeMessages struct {
	Code    int64                                            `json:"code,required"`
	Message string                                           `json:"message,required"`
	JSON    requestPriorityQuotaResponseEnvelopeMessagesJSON `json:"-"`
}

func (*RequestPriorityQuotaResponseEnvelopeMessages) UnmarshalJSON 

func (r *RequestPriorityQuotaResponseEnvelopeMessages) UnmarshalJSON(data []byte) (err error)

type RequestPriorityQuotaResponseEnvelopeSuccess 

type RequestPriorityQuotaResponseEnvelopeSuccess bool

Whether the API call was successful 

const (
	RequestPriorityQuotaResponseEnvelopeSuccessTrue RequestPriorityQuotaResponseEnvelopeSuccess = true
)

type RequestPriorityService 

type RequestPriorityService struct {
	Options []option.RequestOption
}

RequestPriorityService contains methods and other services that help with interacting with the cloudflare API. Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewRequestPriorityService method instead.

func NewRequestPriorityService 

func NewRequestPriorityService(opts ...option.RequestOption) (r *RequestPriorityService)

NewRequestPriorityService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*RequestPriorityService) Delete 

func (r *RequestPriorityService) Delete(ctx context.Context, accountIdentifier string, priorityIdentifer string, opts ...option.RequestOption) (res *RequestPriorityDeleteResponse, err error)

Delete a Priority Intelligence Report

func (*RequestPriorityService) Get 

func (r *RequestPriorityService) Get(ctx context.Context, accountIdentifier string, priorityIdentifer string, opts ...option.RequestOption) (res *CloudforceOneRequestItem, err error)

Get a Priority Intelligence Requirement

func (*RequestPriorityService) New 

func (r *RequestPriorityService) New(ctx context.Context, accountIdentifier string, body RequestPriorityNewParams, opts ...option.RequestOption) (res *CloudforceOnePriorityItem, err error)

Create a New Priority Requirement

func (*RequestPriorityService) Quota 

func (r *RequestPriorityService) Quota(ctx context.Context, accountIdentifier string, opts ...option.RequestOption) (res *CloudforceOneQuota, err error)

Get Priority Intelligence Requirement Quota

func (*RequestPriorityService) Update 

func (r *RequestPriorityService) Update(ctx context.Context, accountIdentifier string, priorityIdentifer string, body RequestPriorityUpdateParams, opts ...option.RequestOption) (res *CloudforceOneRequestItem, err error)

Update a Priority Intelligence Requirement

type RequestPriorityUpdateParams 

type RequestPriorityUpdateParams struct {
	// List of labels
	Labels param.Field[[]string] `json:"labels,required"`
	// Priority
	Priority param.Field[int64] `json:"priority,required"`
	// Requirement
	Requirement param.Field[string] `json:"requirement,required"`
	// The CISA defined Traffic Light Protocol (TLP)
	Tlp param.Field[RequestPriorityUpdateParamsTlp] `json:"tlp,required"`
}

func (RequestPriorityUpdateParams) MarshalJSON 

func (r RequestPriorityUpdateParams) MarshalJSON() (data []byte, err error)

type RequestPriorityUpdateParamsTlp 

type RequestPriorityUpdateParamsTlp string

The CISA defined Traffic Light Protocol (TLP) 

const (
	RequestPriorityUpdateParamsTlpClear       RequestPriorityUpdateParamsTlp = "clear"
	RequestPriorityUpdateParamsTlpAmber       RequestPriorityUpdateParamsTlp = "amber"
	RequestPriorityUpdateParamsTlpAmberStrict RequestPriorityUpdateParamsTlp = "amber-strict"
	RequestPriorityUpdateParamsTlpGreen       RequestPriorityUpdateParamsTlp = "green"
	RequestPriorityUpdateParamsTlpRed         RequestPriorityUpdateParamsTlp = "red"
)

type RequestPriorityUpdateResponseEnvelope 

type RequestPriorityUpdateResponseEnvelope struct {
	Errors   []RequestPriorityUpdateResponseEnvelopeErrors   `json:"errors,required"`
	Messages []RequestPriorityUpdateResponseEnvelopeMessages `json:"messages,required"`
	Result   CloudforceOneRequestItem                        `json:"result,required"`
	// Whether the API call was successful
	Success RequestPriorityUpdateResponseEnvelopeSuccess `json:"success,required"`
	JSON    requestPriorityUpdateResponseEnvelopeJSON    `json:"-"`
}

func (*RequestPriorityUpdateResponseEnvelope) UnmarshalJSON 

func (r *RequestPriorityUpdateResponseEnvelope) UnmarshalJSON(data []byte) (err error)

type RequestPriorityUpdateResponseEnvelopeErrors 

type RequestPriorityUpdateResponseEnvelopeErrors struct {
	Code    int64                                           `json:"code,required"`
	Message string                                          `json:"message,required"`
	JSON    requestPriorityUpdateResponseEnvelopeErrorsJSON `json:"-"`
}

func (*RequestPriorityUpdateResponseEnvelopeErrors) UnmarshalJSON 

func (r *RequestPriorityUpdateResponseEnvelopeErrors) UnmarshalJSON(data []byte) (err error)

type RequestPriorityUpdateResponseEnvelopeMessages 

type RequestPriorityUpdateResponseEnvelopeMessages struct {
	Code    int64                                             `json:"code,required"`
	Message string                                            `json:"message,required"`
	JSON    requestPriorityUpdateResponseEnvelopeMessagesJSON `json:"-"`
}

func (*RequestPriorityUpdateResponseEnvelopeMessages) UnmarshalJSON 

func (r *RequestPriorityUpdateResponseEnvelopeMessages) UnmarshalJSON(data []byte) (err error)

type RequestPriorityUpdateResponseEnvelopeSuccess 

type RequestPriorityUpdateResponseEnvelopeSuccess bool

Whether the API call was successful 

const (
	RequestPriorityUpdateResponseEnvelopeSuccessTrue RequestPriorityUpdateResponseEnvelopeSuccess = true
)

type RequestQuotaResponseEnvelope 

type RequestQuotaResponseEnvelope struct {
	Errors   []RequestQuotaResponseEnvelopeErrors   `json:"errors,required"`
	Messages []RequestQuotaResponseEnvelopeMessages `json:"messages,required"`
	Result   CloudforceOneQuota                     `json:"result,required"`
	// Whether the API call was successful
	Success RequestQuotaResponseEnvelopeSuccess `json:"success,required"`
	JSON    requestQuotaResponseEnvelopeJSON    `json:"-"`
}

func (*RequestQuotaResponseEnvelope) UnmarshalJSON 

func (r *RequestQuotaResponseEnvelope) UnmarshalJSON(data []byte) (err error)

type RequestQuotaResponseEnvelopeErrors 

type RequestQuotaResponseEnvelopeErrors struct {
	Code    int64                                  `json:"code,required"`
	Message string                                 `json:"message,required"`
	JSON    requestQuotaResponseEnvelopeErrorsJSON `json:"-"`
}

func (*RequestQuotaResponseEnvelopeErrors) UnmarshalJSON 

func (r *RequestQuotaResponseEnvelopeErrors) UnmarshalJSON(data []byte) (err error)

type RequestQuotaResponseEnvelopeMessages 

type RequestQuotaResponseEnvelopeMessages struct {
	Code    int64                                    `json:"code,required"`
	Message string                                   `json:"message,required"`
	JSON    requestQuotaResponseEnvelopeMessagesJSON `json:"-"`
}

func (*RequestQuotaResponseEnvelopeMessages) UnmarshalJSON 

func (r *RequestQuotaResponseEnvelopeMessages) UnmarshalJSON(data []byte) (err error)

type RequestQuotaResponseEnvelopeSuccess 

type RequestQuotaResponseEnvelopeSuccess bool

Whether the API call was successful 

const (
	RequestQuotaResponseEnvelopeSuccessTrue RequestQuotaResponseEnvelopeSuccess = true
)

type RequestService 

type RequestService struct {
	Options  []option.RequestOption
	Message  *RequestMessageService
	Priority *RequestPriorityService
}

RequestService contains methods and other services that help with interacting with the cloudflare API. Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewRequestService method instead.

func NewRequestService 

func NewRequestService(opts ...option.RequestOption) (r *RequestService)

NewRequestService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*RequestService) Constants 

func (r *RequestService) Constants(ctx context.Context, accountIdentifier string, opts ...option.RequestOption) (res *CloudforceOneRequestConstants, err error)

Get Request Priority, Status, and TLP constants

func (*RequestService) Delete 

func (r *RequestService) Delete(ctx context.Context, accountIdentifier string, requestIdentifier string, opts ...option.RequestOption) (res *RequestDeleteResponse, err error)

Delete a Request

func (*RequestService) Get 

func (r *RequestService) Get(ctx context.Context, accountIdentifier string, requestIdentifier string, opts ...option.RequestOption) (res *CloudforceOneRequestItem, err error)

Get a Request

func (*RequestService) List 

func (r *RequestService) List(ctx context.Context, accountIdentifier string, body RequestListParams, opts ...option.RequestOption) (res *shared.V4PagePaginationArray[CloudforceOneRequestListItem], err error)

List Requests

func (*RequestService) ListAutoPaging 

func (r *RequestService) ListAutoPaging(ctx context.Context, accountIdentifier string, body RequestListParams, opts ...option.RequestOption) *shared.V4PagePaginationArrayAutoPager[CloudforceOneRequestListItem]

List Requests

func (*RequestService) New 

func (r *RequestService) New(ctx context.Context, accountIdentifier string, body RequestNewParams, opts ...option.RequestOption) (res *CloudforceOneRequestItem, err error)

Creating a request adds the request into the Cloudforce One queue for analysis. In addition to the content, a short title, type, priority, and releasability should be provided. If one is not provided a default will be assigned.

func (*RequestService) Quota 

func (r *RequestService) Quota(ctx context.Context, accountIdentifier string, opts ...option.RequestOption) (res *CloudforceOneQuota, err error)

Get Request Quota

func (*RequestService) Types 

func (r *RequestService) Types(ctx context.Context, accountIdentifier string, opts ...option.RequestOption) (res *CloudforceOneRequestTypes, err error)

Get Request Types

func (*RequestService) Update 

func (r *RequestService) Update(ctx context.Context, accountIdentifier string, requestIdentifier string, body RequestUpdateParams, opts ...option.RequestOption) (res *CloudforceOneRequestItem, err error)

Updating a request alters the request in the Cloudforce One queue. This API may be used to update any attributes of the request after the initial submission. Only fields that you choose to update need to be add to the request body

type RequestTypesResponseEnvelope 

type RequestTypesResponseEnvelope struct {
	Errors   []RequestTypesResponseEnvelopeErrors   `json:"errors,required"`
	Messages []RequestTypesResponseEnvelopeMessages `json:"messages,required"`
	Result   CloudforceOneRequestTypes              `json:"result,required"`
	// Whether the API call was successful
	Success RequestTypesResponseEnvelopeSuccess `json:"success,required"`
	JSON    requestTypesResponseEnvelopeJSON    `json:"-"`
}

func (*RequestTypesResponseEnvelope) UnmarshalJSON 

func (r *RequestTypesResponseEnvelope) UnmarshalJSON(data []byte) (err error)

type RequestTypesResponseEnvelopeErrors 

type RequestTypesResponseEnvelopeErrors struct {
	Code    int64                                  `json:"code,required"`
	Message string                                 `json:"message,required"`
	JSON    requestTypesResponseEnvelopeErrorsJSON `json:"-"`
}

func (*RequestTypesResponseEnvelopeErrors) UnmarshalJSON 

func (r *RequestTypesResponseEnvelopeErrors) UnmarshalJSON(data []byte) (err error)

type RequestTypesResponseEnvelopeMessages 

type RequestTypesResponseEnvelopeMessages struct {
	Code    int64                                    `json:"code,required"`
	Message string                                   `json:"message,required"`
	JSON    requestTypesResponseEnvelopeMessagesJSON `json:"-"`
}

func (*RequestTypesResponseEnvelopeMessages) UnmarshalJSON 

func (r *RequestTypesResponseEnvelopeMessages) UnmarshalJSON(data []byte) (err error)

type RequestTypesResponseEnvelopeSuccess 

type RequestTypesResponseEnvelopeSuccess bool

Whether the API call was successful 

const (
	RequestTypesResponseEnvelopeSuccessTrue RequestTypesResponseEnvelopeSuccess = true
)

type RequestUpdateParams 

type RequestUpdateParams struct {
	// Request content
	Content param.Field[string] `json:"content"`
	// Priority for analyzing the request
	Priority param.Field[string] `json:"priority"`
	// Requested information from request
	RequestType param.Field[string] `json:"request_type"`
	// Brief description of the request
	Summary param.Field[string] `json:"summary"`
	// The CISA defined Traffic Light Protocol (TLP)
	Tlp param.Field[RequestUpdateParamsTlp] `json:"tlp"`
}

func (RequestUpdateParams) MarshalJSON 

func (r RequestUpdateParams) MarshalJSON() (data []byte, err error)

type RequestUpdateParamsTlp 

type RequestUpdateParamsTlp string

The CISA defined Traffic Light Protocol (TLP) 

const (
	RequestUpdateParamsTlpClear       RequestUpdateParamsTlp = "clear"
	RequestUpdateParamsTlpAmber       RequestUpdateParamsTlp = "amber"
	RequestUpdateParamsTlpAmberStrict RequestUpdateParamsTlp = "amber-strict"
	RequestUpdateParamsTlpGreen       RequestUpdateParamsTlp = "green"
	RequestUpdateParamsTlpRed         RequestUpdateParamsTlp = "red"
)

type RequestUpdateResponseEnvelope 

type RequestUpdateResponseEnvelope struct {
	Errors   []RequestUpdateResponseEnvelopeErrors   `json:"errors,required"`
	Messages []RequestUpdateResponseEnvelopeMessages `json:"messages,required"`
	Result   CloudforceOneRequestItem                `json:"result,required"`
	// Whether the API call was successful
	Success RequestUpdateResponseEnvelopeSuccess `json:"success,required"`
	JSON    requestUpdateResponseEnvelopeJSON    `json:"-"`
}

func (*RequestUpdateResponseEnvelope) UnmarshalJSON 

func (r *RequestUpdateResponseEnvelope) UnmarshalJSON(data []byte) (err error)

type RequestUpdateResponseEnvelopeErrors 

type RequestUpdateResponseEnvelopeErrors struct {
	Code    int64                                   `json:"code,required"`
	Message string                                  `json:"message,required"`
	JSON    requestUpdateResponseEnvelopeErrorsJSON `json:"-"`
}

func (*RequestUpdateResponseEnvelopeErrors) UnmarshalJSON 

func (r *RequestUpdateResponseEnvelopeErrors) UnmarshalJSON(data []byte) (err error)

type RequestUpdateResponseEnvelopeMessages 

type RequestUpdateResponseEnvelopeMessages struct {
	Code    int64                                     `json:"code,required"`
	Message string                                    `json:"message,required"`
	JSON    requestUpdateResponseEnvelopeMessagesJSON `json:"-"`
}

func (*RequestUpdateResponseEnvelopeMessages) UnmarshalJSON 

func (r *RequestUpdateResponseEnvelopeMessages) UnmarshalJSON(data []byte) (err error)

type RequestUpdateResponseEnvelopeSuccess 

type RequestUpdateResponseEnvelopeSuccess bool

Whether the API call was successful 

const (
	RequestUpdateResponseEnvelopeSuccessTrue RequestUpdateResponseEnvelopeSuccess = true
)

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.