cloudforce_one

package
v2.1.0 Latest Latest
Warning

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

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

Documentation

Index

Constants

View Source 
const AuditLogActorTypeAdmin = shared.AuditLogActorTypeAdmin

This is an alias to an internal value.

View Source 
const AuditLogActorTypeCloudflare = shared.AuditLogActorTypeCloudflare

This is an alias to an internal value.

View Source 
const AuditLogActorTypeUser = shared.AuditLogActorTypeUser

This is an alias to an internal value.

View Source 
const CloudflareTunnelTunTypeCNI = shared.CloudflareTunnelTunTypeCNI

This is an alias to an internal value.

View Source 
const CloudflareTunnelTunTypeCfdTunnel = shared.CloudflareTunnelTunTypeCfdTunnel

This is an alias to an internal value.

View Source 
const CloudflareTunnelTunTypeGRE = shared.CloudflareTunnelTunTypeGRE

This is an alias to an internal value.

View Source 
const CloudflareTunnelTunTypeIPSec = shared.CloudflareTunnelTunTypeIPSec

This is an alias to an internal value.

View Source 
const CloudflareTunnelTunTypeWARPConnector = shared.CloudflareTunnelTunTypeWARPConnector

This is an alias to an internal value.

Variables

This section is empty.

Functions

This section is empty.

Types

type ASN added in v2.1.0 

type ASN = shared.ASN

This is an alias to an internal type.

type ASNParam added in v2.1.0 

type ASNParam = shared.ASNParam

This is an alias to an internal type.

type AuditLog 

type AuditLog = shared.AuditLog

This is an alias to an internal type.

type AuditLogAction 

type AuditLogAction = shared.AuditLogAction

This is an alias to an internal type.

type AuditLogActor 

type AuditLogActor = shared.AuditLogActor

This is an alias to an internal type.

type AuditLogActorType 

type AuditLogActorType = shared.AuditLogActorType

The type of actor, whether a User, Cloudflare Admin, or an Automated System.

This is an alias to an internal type.

type AuditLogOwner 

type AuditLogOwner = shared.AuditLogOwner

This is an alias to an internal type.

type AuditLogResource 

type AuditLogResource = shared.AuditLogResource

This is an alias to an internal type.

type CloudflareTunnel 

type CloudflareTunnel = shared.CloudflareTunnel

A Cloudflare Tunnel that connects your origin to Cloudflare's edge.

This is an alias to an internal type.

type CloudflareTunnelConnection 

type CloudflareTunnelConnection = shared.CloudflareTunnelConnection

This is an alias to an internal type.

type CloudflareTunnelTunType 

type CloudflareTunnelTunType = shared.CloudflareTunnelTunType

The type of tunnel.

This is an alias to an internal type.

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 ErrorData 

type ErrorData = shared.ErrorData

This is an alias to an internal type.

type Item 

type Item 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       ItemTlp   `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 ItemStatus `json:"status"`
	// Tokens for the request
	Tokens int64    `json:"tokens"`
	JSON   itemJSON `json:"-"`
}

func (*Item) UnmarshalJSON 

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

type ItemStatus 

type ItemStatus string

Request Status 

const (
	ItemStatusOpen      ItemStatus = "open"
	ItemStatusAccepted  ItemStatus = "accepted"
	ItemStatusReported  ItemStatus = "reported"
	ItemStatusApproved  ItemStatus = "approved"
	ItemStatusCompleted ItemStatus = "completed"
	ItemStatusDeclined  ItemStatus = "declined"
)

func (ItemStatus) IsKnown 

func (r ItemStatus) IsKnown() bool

type ItemTlp 

type ItemTlp string

The CISA defined Traffic Light Protocol (TLP) 

const (
	ItemTlpClear       ItemTlp = "clear"
	ItemTlpAmber       ItemTlp = "amber"
	ItemTlpAmberStrict ItemTlp = "amber-strict"
	ItemTlpGreen       ItemTlp = "green"
	ItemTlpRed         ItemTlp = "red"
)

func (ItemTlp) IsKnown 

func (r ItemTlp) IsKnown() bool

type Label 

type Label = string

type LabelParam 

type LabelParam = string

type ListItem 

type ListItem struct {
	// UUID
	ID string `json:"id,required"`
	// Request creation time
	Created  time.Time        `json:"created,required" format:"date-time"`
	Priority ListItemPriority `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 ListItemTlp `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 ListItemStatus `json:"status"`
	// Tokens for the request
	Tokens int64        `json:"tokens"`
	JSON   listItemJSON `json:"-"`
}

func (*ListItem) UnmarshalJSON 

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

type ListItemPriority 

type ListItemPriority string
const (
	ListItemPriorityRoutine ListItemPriority = "routine"
	ListItemPriorityHigh    ListItemPriority = "high"
	ListItemPriorityUrgent  ListItemPriority = "urgent"
)

func (ListItemPriority) IsKnown 

func (r ListItemPriority) IsKnown() bool

type ListItemStatus 

type ListItemStatus string

Request Status 

const (
	ListItemStatusOpen      ListItemStatus = "open"
	ListItemStatusAccepted  ListItemStatus = "accepted"
	ListItemStatusReported  ListItemStatus = "reported"
	ListItemStatusApproved  ListItemStatus = "approved"
	ListItemStatusCompleted ListItemStatus = "completed"
	ListItemStatusDeclined  ListItemStatus = "declined"
)

func (ListItemStatus) IsKnown 

func (r ListItemStatus) IsKnown() bool

type ListItemTlp 

type ListItemTlp string

The CISA defined Traffic Light Protocol (TLP) 

const (
	ListItemTlpClear       ListItemTlp = "clear"
	ListItemTlpAmber       ListItemTlp = "amber"
	ListItemTlpAmberStrict ListItemTlp = "amber-strict"
	ListItemTlpGreen       ListItemTlp = "green"
	ListItemTlpRed         ListItemTlp = "red"
)

func (ListItemTlp) IsKnown 

func (r ListItemTlp) IsKnown() bool

type Member added in v2.1.0 

type Member = shared.Member

This is an alias to an internal type.

type MemberParam added in v2.1.0 

type MemberParam = shared.MemberParam

This is an alias to an internal type.

type MemberRole added in v2.1.0 

type MemberRole = shared.MemberRole

This is an alias to an internal type.

type MemberRoleParam added in v2.1.0 

type MemberRoleParam = shared.MemberRoleParam

This is an alias to an internal type.

type MemberRolesPermissions added in v2.1.0 

type MemberRolesPermissions = shared.MemberRolesPermissions

This is an alias to an internal type.

type MemberRolesPermissionsParam added in v2.1.0 

type MemberRolesPermissionsParam = shared.MemberRolesPermissionsParam

This is an alias to an internal type.

type MemberUser added in v2.1.0 

type MemberUser = shared.MemberUser

This is an alias to an internal type.

type MemberUserParam added in v2.1.0 

type MemberUserParam = shared.MemberUserParam

This is an alias to an internal type.

type Message 

type Message 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    messageJSON `json:"-"`
}

func (*Message) UnmarshalJSON 

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

type Permission 

type Permission = shared.Permission

This is an alias to an internal type.

type PermissionGrant 

type PermissionGrant = shared.PermissionGrant

This is an alias to an internal type.

type PermissionGrantParam 

type PermissionGrantParam = shared.PermissionGrantParam

This is an alias to an internal type.

type Priority 

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

func (*Priority) UnmarshalJSON 

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

type PriorityEditParam 

type PriorityEditParam struct {
	// List of labels
	Labels param.Field[[]LabelParam] `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[PriorityEditTlp] `json:"tlp,required"`
}

func (PriorityEditParam) MarshalJSON 

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

type PriorityEditTlp 

type PriorityEditTlp string

The CISA defined Traffic Light Protocol (TLP) 

const (
	PriorityEditTlpClear       PriorityEditTlp = "clear"
	PriorityEditTlpAmber       PriorityEditTlp = "amber"
	PriorityEditTlpAmberStrict PriorityEditTlp = "amber-strict"
	PriorityEditTlpGreen       PriorityEditTlp = "green"
	PriorityEditTlpRed         PriorityEditTlp = "red"
)

func (PriorityEditTlp) IsKnown 

func (r PriorityEditTlp) IsKnown() bool

type PriorityTlp 

type PriorityTlp string

The CISA defined Traffic Light Protocol (TLP) 

const (
	PriorityTlpClear       PriorityTlp = "clear"
	PriorityTlpAmber       PriorityTlp = "amber"
	PriorityTlpAmberStrict PriorityTlp = "amber-strict"
	PriorityTlpGreen       PriorityTlp = "green"
	PriorityTlpRed         PriorityTlp = "red"
)

func (PriorityTlp) IsKnown 

func (r PriorityTlp) IsKnown() bool

type Quota 

type Quota 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      quotaJSON `json:"-"`
}

func (*Quota) UnmarshalJSON 

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

type RequestConstants 

type RequestConstants struct {
	Priority []RequestConstantsPriority `json:"priority"`
	Status   []RequestConstantsStatus   `json:"status"`
	Tlp      []RequestConstantsTlp      `json:"tlp"`
	JSON     requestConstantsJSON       `json:"-"`
}

func (*RequestConstants) UnmarshalJSON 

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

type RequestConstantsPriority 

type RequestConstantsPriority string
const (
	RequestConstantsPriorityRoutine RequestConstantsPriority = "routine"
	RequestConstantsPriorityHigh    RequestConstantsPriority = "high"
	RequestConstantsPriorityUrgent  RequestConstantsPriority = "urgent"
)

func (RequestConstantsPriority) IsKnown 

func (r RequestConstantsPriority) IsKnown() bool

type RequestConstantsResponseEnvelope 

type RequestConstantsResponseEnvelope struct {
	Errors   []shared.ResponseInfo `json:"errors,required"`
	Messages []shared.ResponseInfo `json:"messages,required"`
	Result   RequestConstants      `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 RequestConstantsResponseEnvelopeSuccess 

type RequestConstantsResponseEnvelopeSuccess bool

Whether the API call was successful 

const (
	RequestConstantsResponseEnvelopeSuccessTrue RequestConstantsResponseEnvelopeSuccess = true
)

func (RequestConstantsResponseEnvelopeSuccess) IsKnown 

func (r RequestConstantsResponseEnvelopeSuccess) IsKnown() bool

type RequestConstantsStatus 

type RequestConstantsStatus string

Request Status 

const (
	RequestConstantsStatusOpen      RequestConstantsStatus = "open"
	RequestConstantsStatusAccepted  RequestConstantsStatus = "accepted"
	RequestConstantsStatusReported  RequestConstantsStatus = "reported"
	RequestConstantsStatusApproved  RequestConstantsStatus = "approved"
	RequestConstantsStatusCompleted RequestConstantsStatus = "completed"
	RequestConstantsStatusDeclined  RequestConstantsStatus = "declined"
)

func (RequestConstantsStatus) IsKnown 

func (r RequestConstantsStatus) IsKnown() bool

type RequestConstantsTlp 

type RequestConstantsTlp string

The CISA defined Traffic Light Protocol (TLP) 

const (
	RequestConstantsTlpClear       RequestConstantsTlp = "clear"
	RequestConstantsTlpAmber       RequestConstantsTlp = "amber"
	RequestConstantsTlpAmberStrict RequestConstantsTlp = "amber-strict"
	RequestConstantsTlpGreen       RequestConstantsTlp = "green"
	RequestConstantsTlpRed         RequestConstantsTlp = "red"
)

func (RequestConstantsTlp) IsKnown 

func (r RequestConstantsTlp) IsKnown() bool

type RequestDeleteResponseArray 

type RequestDeleteResponseArray []interface{}

func (RequestDeleteResponseArray) ImplementsCloudforceOneRequestDeleteResponseUnion 

func (r RequestDeleteResponseArray) ImplementsCloudforceOneRequestDeleteResponseUnion()

type RequestDeleteResponseEnvelope 

type RequestDeleteResponseEnvelope struct {
	Errors   []shared.ResponseInfo      `json:"errors,required"`
	Messages []shared.ResponseInfo      `json:"messages,required"`
	Result   RequestDeleteResponseUnion `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 RequestDeleteResponseEnvelopeSuccess 

type RequestDeleteResponseEnvelopeSuccess bool

Whether the API call was successful 

const (
	RequestDeleteResponseEnvelopeSuccessTrue RequestDeleteResponseEnvelopeSuccess = true
)

func (RequestDeleteResponseEnvelopeSuccess) IsKnown 

func (r RequestDeleteResponseEnvelopeSuccess) IsKnown() bool

type RequestDeleteResponseUnion 

type RequestDeleteResponseUnion interface {
	ImplementsCloudforceOneRequestDeleteResponseUnion()
}

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

type RequestGetResponseEnvelope 

type RequestGetResponseEnvelope struct {
	Errors   []shared.ResponseInfo `json:"errors,required"`
	Messages []shared.ResponseInfo `json:"messages,required"`
	Result   Item                  `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 RequestGetResponseEnvelopeSuccess 

type RequestGetResponseEnvelopeSuccess bool

Whether the API call was successful 

const (
	RequestGetResponseEnvelopeSuccessTrue RequestGetResponseEnvelopeSuccess = true
)

func (RequestGetResponseEnvelopeSuccess) IsKnown 

func (r RequestGetResponseEnvelopeSuccess) IsKnown() bool

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"
)

func (RequestListParamsSortOrder) IsKnown 

func (r RequestListParamsSortOrder) IsKnown() bool

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"
)

func (RequestListParamsStatus) IsKnown 

func (r RequestListParamsStatus) IsKnown() bool

type RequestMessageDeleteResponseArray 

type RequestMessageDeleteResponseArray []interface{}

func (RequestMessageDeleteResponseArray) ImplementsCloudforceOneRequestMessageDeleteResponseUnion 

func (r RequestMessageDeleteResponseArray) ImplementsCloudforceOneRequestMessageDeleteResponseUnion()

type RequestMessageDeleteResponseEnvelope 

type RequestMessageDeleteResponseEnvelope struct {
	Errors   []shared.ResponseInfo             `json:"errors,required"`
	Messages []shared.ResponseInfo             `json:"messages,required"`
	Result   RequestMessageDeleteResponseUnion `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 RequestMessageDeleteResponseEnvelopeSuccess 

type RequestMessageDeleteResponseEnvelopeSuccess bool

Whether the API call was successful 

const (
	RequestMessageDeleteResponseEnvelopeSuccessTrue RequestMessageDeleteResponseEnvelopeSuccess = true
)

func (RequestMessageDeleteResponseEnvelopeSuccess) IsKnown 

func (r RequestMessageDeleteResponseEnvelopeSuccess) IsKnown() bool

type RequestMessageDeleteResponseUnion 

type RequestMessageDeleteResponseUnion interface {
	ImplementsCloudforceOneRequestMessageDeleteResponseUnion()
}

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

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"
)

func (RequestMessageGetParamsSortOrder) IsKnown 

func (r RequestMessageGetParamsSortOrder) IsKnown() bool

type RequestMessageGetResponseEnvelope 

type RequestMessageGetResponseEnvelope struct {
	Errors   []shared.ResponseInfo `json:"errors,required"`
	Messages []shared.ResponseInfo `json:"messages,required"`
	Result   []Message             `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 RequestMessageGetResponseEnvelopeSuccess 

type RequestMessageGetResponseEnvelopeSuccess bool

Whether the API call was successful 

const (
	RequestMessageGetResponseEnvelopeSuccessTrue RequestMessageGetResponseEnvelopeSuccess = true
)

func (RequestMessageGetResponseEnvelopeSuccess) IsKnown 

func (r RequestMessageGetResponseEnvelopeSuccess) IsKnown() bool

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   []shared.ResponseInfo `json:"errors,required"`
	Messages []shared.ResponseInfo `json:"messages,required"`
	Result   Message               `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 RequestMessageNewResponseEnvelopeSuccess 

type RequestMessageNewResponseEnvelopeSuccess bool

Whether the API call was successful 

const (
	RequestMessageNewResponseEnvelopeSuccessTrue RequestMessageNewResponseEnvelopeSuccess = true
)

func (RequestMessageNewResponseEnvelopeSuccess) IsKnown 

func (r RequestMessageNewResponseEnvelopeSuccess) IsKnown() bool

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 *RequestMessageDeleteResponseUnion, 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 *[]Message, 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 *Message, 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 *Message, 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"
)

func (RequestMessageUpdateParamsTlp) IsKnown 

func (r RequestMessageUpdateParamsTlp) IsKnown() bool

type RequestMessageUpdateResponseEnvelope 

type RequestMessageUpdateResponseEnvelope struct {
	Errors   []shared.ResponseInfo `json:"errors,required"`
	Messages []shared.ResponseInfo `json:"messages,required"`
	Result   Message               `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 RequestMessageUpdateResponseEnvelopeSuccess 

type RequestMessageUpdateResponseEnvelopeSuccess bool

Whether the API call was successful 

const (
	RequestMessageUpdateResponseEnvelopeSuccessTrue RequestMessageUpdateResponseEnvelopeSuccess = true
)

func (RequestMessageUpdateResponseEnvelopeSuccess) IsKnown 

func (r RequestMessageUpdateResponseEnvelopeSuccess) IsKnown() bool

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"
)

func (RequestNewParamsTlp) IsKnown 

func (r RequestNewParamsTlp) IsKnown() bool

type RequestNewResponseEnvelope 

type RequestNewResponseEnvelope struct {
	Errors   []shared.ResponseInfo `json:"errors,required"`
	Messages []shared.ResponseInfo `json:"messages,required"`
	Result   Item                  `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 RequestNewResponseEnvelopeSuccess 

type RequestNewResponseEnvelopeSuccess bool

Whether the API call was successful 

const (
	RequestNewResponseEnvelopeSuccessTrue RequestNewResponseEnvelopeSuccess = true
)

func (RequestNewResponseEnvelopeSuccess) IsKnown 

func (r RequestNewResponseEnvelopeSuccess) IsKnown() bool

type RequestPriorityDeleteResponseArray 

type RequestPriorityDeleteResponseArray []interface{}

func (RequestPriorityDeleteResponseArray) ImplementsCloudforceOneRequestPriorityDeleteResponseUnion 

func (r RequestPriorityDeleteResponseArray) ImplementsCloudforceOneRequestPriorityDeleteResponseUnion()

type RequestPriorityDeleteResponseEnvelope 

type RequestPriorityDeleteResponseEnvelope struct {
	Errors   []shared.ResponseInfo              `json:"errors,required"`
	Messages []shared.ResponseInfo              `json:"messages,required"`
	Result   RequestPriorityDeleteResponseUnion `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 RequestPriorityDeleteResponseEnvelopeSuccess 

type RequestPriorityDeleteResponseEnvelopeSuccess bool

Whether the API call was successful 

const (
	RequestPriorityDeleteResponseEnvelopeSuccessTrue RequestPriorityDeleteResponseEnvelopeSuccess = true
)

func (RequestPriorityDeleteResponseEnvelopeSuccess) IsKnown 

func (r RequestPriorityDeleteResponseEnvelopeSuccess) IsKnown() bool

type RequestPriorityDeleteResponseUnion 

type RequestPriorityDeleteResponseUnion interface {
	ImplementsCloudforceOneRequestPriorityDeleteResponseUnion()
}

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

type RequestPriorityGetResponseEnvelope 

type RequestPriorityGetResponseEnvelope struct {
	Errors   []shared.ResponseInfo `json:"errors,required"`
	Messages []shared.ResponseInfo `json:"messages,required"`
	Result   Item                  `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 RequestPriorityGetResponseEnvelopeSuccess 

type RequestPriorityGetResponseEnvelopeSuccess bool

Whether the API call was successful 

const (
	RequestPriorityGetResponseEnvelopeSuccessTrue RequestPriorityGetResponseEnvelopeSuccess = true
)

func (RequestPriorityGetResponseEnvelopeSuccess) IsKnown 

func (r RequestPriorityGetResponseEnvelopeSuccess) IsKnown() bool

type RequestPriorityNewParams 

type RequestPriorityNewParams struct {
	PriorityEdit PriorityEditParam `json:"priority_edit,required"`
}

func (RequestPriorityNewParams) MarshalJSON 

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

type RequestPriorityNewResponseEnvelope 

type RequestPriorityNewResponseEnvelope struct {
	Errors   []shared.ResponseInfo `json:"errors,required"`
	Messages []shared.ResponseInfo `json:"messages,required"`
	Result   Priority              `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 RequestPriorityNewResponseEnvelopeSuccess 

type RequestPriorityNewResponseEnvelopeSuccess bool

Whether the API call was successful 

const (
	RequestPriorityNewResponseEnvelopeSuccessTrue RequestPriorityNewResponseEnvelopeSuccess = true
)

func (RequestPriorityNewResponseEnvelopeSuccess) IsKnown 

func (r RequestPriorityNewResponseEnvelopeSuccess) IsKnown() bool

type RequestPriorityQuotaResponseEnvelope 

type RequestPriorityQuotaResponseEnvelope struct {
	Errors   []shared.ResponseInfo `json:"errors,required"`
	Messages []shared.ResponseInfo `json:"messages,required"`
	Result   Quota                 `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 RequestPriorityQuotaResponseEnvelopeSuccess 

type RequestPriorityQuotaResponseEnvelopeSuccess bool

Whether the API call was successful 

const (
	RequestPriorityQuotaResponseEnvelopeSuccessTrue RequestPriorityQuotaResponseEnvelopeSuccess = true
)

func (RequestPriorityQuotaResponseEnvelopeSuccess) IsKnown 

func (r RequestPriorityQuotaResponseEnvelopeSuccess) IsKnown() bool

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 *RequestPriorityDeleteResponseUnion, 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 *Item, 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 *Priority, err error)

Create a New Priority Requirement

func (*RequestPriorityService) Quota 

func (r *RequestPriorityService) Quota(ctx context.Context, accountIdentifier string, opts ...option.RequestOption) (res *Quota, 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 *Item, err error)

Update a Priority Intelligence Requirement

type RequestPriorityUpdateParams 

type RequestPriorityUpdateParams struct {
	PriorityEdit PriorityEditParam `json:"priority_edit,required"`
}

func (RequestPriorityUpdateParams) MarshalJSON 

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

type RequestPriorityUpdateResponseEnvelope 

type RequestPriorityUpdateResponseEnvelope struct {
	Errors   []shared.ResponseInfo `json:"errors,required"`
	Messages []shared.ResponseInfo `json:"messages,required"`
	Result   Item                  `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 RequestPriorityUpdateResponseEnvelopeSuccess 

type RequestPriorityUpdateResponseEnvelopeSuccess bool

Whether the API call was successful 

const (
	RequestPriorityUpdateResponseEnvelopeSuccessTrue RequestPriorityUpdateResponseEnvelopeSuccess = true
)

func (RequestPriorityUpdateResponseEnvelopeSuccess) IsKnown 

func (r RequestPriorityUpdateResponseEnvelopeSuccess) IsKnown() bool

type RequestQuotaResponseEnvelope 

type RequestQuotaResponseEnvelope struct {
	Errors   []shared.ResponseInfo `json:"errors,required"`
	Messages []shared.ResponseInfo `json:"messages,required"`
	Result   Quota                 `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 RequestQuotaResponseEnvelopeSuccess 

type RequestQuotaResponseEnvelopeSuccess bool

Whether the API call was successful 

const (
	RequestQuotaResponseEnvelopeSuccessTrue RequestQuotaResponseEnvelopeSuccess = true
)

func (RequestQuotaResponseEnvelopeSuccess) IsKnown 

func (r RequestQuotaResponseEnvelopeSuccess) IsKnown() bool

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 *RequestConstants, 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 *RequestDeleteResponseUnion, err error)

Delete a Request

func (*RequestService) Get 

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

Get a Request

func (*RequestService) List 

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

List Requests

func (*RequestService) ListAutoPaging 

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

List Requests

func (*RequestService) New 

func (r *RequestService) New(ctx context.Context, accountIdentifier string, body RequestNewParams, opts ...option.RequestOption) (res *Item, 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 *Quota, err error)

Get Request Quota

func (*RequestService) Types 

func (r *RequestService) Types(ctx context.Context, accountIdentifier string, opts ...option.RequestOption) (res *RequestTypes, 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 *Item, 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 RequestTypes 

type RequestTypes []string

type RequestTypesResponseEnvelope 

type RequestTypesResponseEnvelope struct {
	Errors   []shared.ResponseInfo `json:"errors,required"`
	Messages []shared.ResponseInfo `json:"messages,required"`
	Result   RequestTypes          `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 RequestTypesResponseEnvelopeSuccess 

type RequestTypesResponseEnvelopeSuccess bool

Whether the API call was successful 

const (
	RequestTypesResponseEnvelopeSuccessTrue RequestTypesResponseEnvelopeSuccess = true
)

func (RequestTypesResponseEnvelopeSuccess) IsKnown 

func (r RequestTypesResponseEnvelopeSuccess) IsKnown() bool

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"
)

func (RequestUpdateParamsTlp) IsKnown 

func (r RequestUpdateParamsTlp) IsKnown() bool

type RequestUpdateResponseEnvelope 

type RequestUpdateResponseEnvelope struct {
	Errors   []shared.ResponseInfo `json:"errors,required"`
	Messages []shared.ResponseInfo `json:"messages,required"`
	Result   Item                  `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 RequestUpdateResponseEnvelopeSuccess 

type RequestUpdateResponseEnvelopeSuccess bool

Whether the API call was successful 

const (
	RequestUpdateResponseEnvelopeSuccessTrue RequestUpdateResponseEnvelopeSuccess = true
)

func (RequestUpdateResponseEnvelopeSuccess) IsKnown 

func (r RequestUpdateResponseEnvelopeSuccess) IsKnown() bool

type ResponseInfo 

type ResponseInfo = shared.ResponseInfo

This is an alias to an internal type.

type Role 

type Role = shared.Role

This is an alias to an internal type.

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.