logs

type ASN = shared.ASN

type ASNParam = shared.ASNParam

type AuditLog = shared.AuditLog

type AuditLogAction = shared.AuditLogAction

type AuditLogActor = shared.AuditLogActor

type AuditLogActorType = shared.AuditLogActorType

type AuditLogOwner = shared.AuditLogOwner

type AuditLogResource = shared.AuditLogResource

type CertificateCA = shared.CertificateCA

type CertificateRequestType = shared.CertificateRequestType

type CloudflareTunnel = shared.CloudflareTunnel

type CloudflareTunnelConnection = shared.CloudflareTunnelConnection

type CloudflareTunnelStatus = shared.CloudflareTunnelStatus

type CloudflareTunnelTunType = shared.CloudflareTunnelTunType

type CmbConfig struct {
	// Allow out of region access
	AllowOutOfRegionAccess bool `json:"allow_out_of_region_access"`
	// Name of the region.
	Regions string        `json:"regions"`
	JSON    cmbConfigJSON `json:"-"`
}

type CmbConfigParam struct {
	// Allow out of region access
	AllowOutOfRegionAccess param.Field[bool] `json:"allow_out_of_region_access"`
	// Name of the region.
	Regions param.Field[string] `json:"regions"`
}

type ControlCmbConfigDeleteParams struct {
	// Identifier.
	AccountID param.Field[string] `path:"account_id,required"`
}

type ControlCmbConfigDeleteResponse = interface{}

type ControlCmbConfigDeleteResponseEnvelope struct {
	Errors   []ControlCmbConfigDeleteResponseEnvelopeErrors   `json:"errors,required"`
	Messages []ControlCmbConfigDeleteResponseEnvelopeMessages `json:"messages,required"`
	// Whether the API call was successful.
	Success ControlCmbConfigDeleteResponseEnvelopeSuccess `json:"success,required"`
	Result  ControlCmbConfigDeleteResponse                `json:"result,nullable"`
	JSON    controlCmbConfigDeleteResponseEnvelopeJSON    `json:"-"`
}

type ControlCmbConfigDeleteResponseEnvelopeErrors struct {
	Code             int64                                              `json:"code,required"`
	Message          string                                             `json:"message,required"`
	DocumentationURL string                                             `json:"documentation_url"`
	Source           ControlCmbConfigDeleteResponseEnvelopeErrorsSource `json:"source"`
	JSON             controlCmbConfigDeleteResponseEnvelopeErrorsJSON   `json:"-"`
}

type ControlCmbConfigDeleteResponseEnvelopeErrorsSource struct {
	Pointer string                                                 `json:"pointer"`
	JSON    controlCmbConfigDeleteResponseEnvelopeErrorsSourceJSON `json:"-"`
}

type ControlCmbConfigDeleteResponseEnvelopeMessages struct {
	Code             int64                                                `json:"code,required"`
	Message          string                                               `json:"message,required"`
	DocumentationURL string                                               `json:"documentation_url"`
	Source           ControlCmbConfigDeleteResponseEnvelopeMessagesSource `json:"source"`
	JSON             controlCmbConfigDeleteResponseEnvelopeMessagesJSON   `json:"-"`
}

type ControlCmbConfigDeleteResponseEnvelopeMessagesSource struct {
	Pointer string                                                   `json:"pointer"`
	JSON    controlCmbConfigDeleteResponseEnvelopeMessagesSourceJSON `json:"-"`
}

type ControlCmbConfigDeleteResponseEnvelopeSuccess bool

type ControlCmbConfigGetParams struct {
	// Identifier.
	AccountID param.Field[string] `path:"account_id,required"`
}

type ControlCmbConfigGetResponseEnvelope struct {
	Errors   []ControlCmbConfigGetResponseEnvelopeErrors   `json:"errors,required"`
	Messages []ControlCmbConfigGetResponseEnvelopeMessages `json:"messages,required"`
	// Whether the API call was successful.
	Success ControlCmbConfigGetResponseEnvelopeSuccess `json:"success,required"`
	Result  CmbConfig                                  `json:"result,nullable"`
	JSON    controlCmbConfigGetResponseEnvelopeJSON    `json:"-"`
}

type ControlCmbConfigGetResponseEnvelopeErrors struct {
	Code             int64                                           `json:"code,required"`
	Message          string                                          `json:"message,required"`
	DocumentationURL string                                          `json:"documentation_url"`
	Source           ControlCmbConfigGetResponseEnvelopeErrorsSource `json:"source"`
	JSON             controlCmbConfigGetResponseEnvelopeErrorsJSON   `json:"-"`
}

type ControlCmbConfigGetResponseEnvelopeErrorsSource struct {
	Pointer string                                              `json:"pointer"`
	JSON    controlCmbConfigGetResponseEnvelopeErrorsSourceJSON `json:"-"`
}

type ControlCmbConfigGetResponseEnvelopeMessages struct {
	Code             int64                                             `json:"code,required"`
	Message          string                                            `json:"message,required"`
	DocumentationURL string                                            `json:"documentation_url"`
	Source           ControlCmbConfigGetResponseEnvelopeMessagesSource `json:"source"`
	JSON             controlCmbConfigGetResponseEnvelopeMessagesJSON   `json:"-"`
}

type ControlCmbConfigGetResponseEnvelopeMessagesSource struct {
	Pointer string                                                `json:"pointer"`
	JSON    controlCmbConfigGetResponseEnvelopeMessagesSourceJSON `json:"-"`
}

type ControlCmbConfigGetResponseEnvelopeSuccess bool

type ControlCmbConfigNewParams struct {
	// Identifier.
	AccountID param.Field[string] `path:"account_id,required"`
	CmbConfig CmbConfigParam      `json:"cmb_config,required"`
}

type ControlCmbConfigNewResponseEnvelope struct {
	Errors   []ControlCmbConfigNewResponseEnvelopeErrors   `json:"errors,required"`
	Messages []ControlCmbConfigNewResponseEnvelopeMessages `json:"messages,required"`
	// Whether the API call was successful.
	Success ControlCmbConfigNewResponseEnvelopeSuccess `json:"success,required"`
	Result  CmbConfig                                  `json:"result,nullable"`
	JSON    controlCmbConfigNewResponseEnvelopeJSON    `json:"-"`
}

type ControlCmbConfigNewResponseEnvelopeErrors struct {
	Code             int64                                           `json:"code,required"`
	Message          string                                          `json:"message,required"`
	DocumentationURL string                                          `json:"documentation_url"`
	Source           ControlCmbConfigNewResponseEnvelopeErrorsSource `json:"source"`
	JSON             controlCmbConfigNewResponseEnvelopeErrorsJSON   `json:"-"`
}

type ControlCmbConfigNewResponseEnvelopeErrorsSource struct {
	Pointer string                                              `json:"pointer"`
	JSON    controlCmbConfigNewResponseEnvelopeErrorsSourceJSON `json:"-"`
}

type ControlCmbConfigNewResponseEnvelopeMessages struct {
	Code             int64                                             `json:"code,required"`
	Message          string                                            `json:"message,required"`
	DocumentationURL string                                            `json:"documentation_url"`
	Source           ControlCmbConfigNewResponseEnvelopeMessagesSource `json:"source"`
	JSON             controlCmbConfigNewResponseEnvelopeMessagesJSON   `json:"-"`
}

type ControlCmbConfigNewResponseEnvelopeMessagesSource struct {
	Pointer string                                                `json:"pointer"`
	JSON    controlCmbConfigNewResponseEnvelopeMessagesSourceJSON `json:"-"`
}

type ControlCmbConfigNewResponseEnvelopeSuccess bool

type ControlCmbConfigService struct {
	Options []option.RequestOption
}

type ControlCmbService struct {
	Options []option.RequestOption
	Config  *ControlCmbConfigService
}

type ControlRetentionGetParams struct {
	// Identifier.
	ZoneID param.Field[string] `path:"zone_id,required"`
}

type ControlRetentionGetResponse struct {
	// The log retention flag for Logpull API.
	Flag bool                            `json:"flag"`
	JSON controlRetentionGetResponseJSON `json:"-"`
}

type ControlRetentionGetResponseEnvelope struct {
	Errors   []ControlRetentionGetResponseEnvelopeErrors   `json:"errors,required"`
	Messages []ControlRetentionGetResponseEnvelopeMessages `json:"messages,required"`
	// Whether the API call was successful.
	Success ControlRetentionGetResponseEnvelopeSuccess `json:"success,required"`
	Result  ControlRetentionGetResponse                `json:"result,nullable"`
	JSON    controlRetentionGetResponseEnvelopeJSON    `json:"-"`
}

type ControlRetentionGetResponseEnvelopeErrors struct {
	Code             int64                                           `json:"code,required"`
	Message          string                                          `json:"message,required"`
	DocumentationURL string                                          `json:"documentation_url"`
	Source           ControlRetentionGetResponseEnvelopeErrorsSource `json:"source"`
	JSON             controlRetentionGetResponseEnvelopeErrorsJSON   `json:"-"`
}

type ControlRetentionGetResponseEnvelopeErrorsSource struct {
	Pointer string                                              `json:"pointer"`
	JSON    controlRetentionGetResponseEnvelopeErrorsSourceJSON `json:"-"`
}

type ControlRetentionGetResponseEnvelopeMessages struct {
	Code             int64                                             `json:"code,required"`
	Message          string                                            `json:"message,required"`
	DocumentationURL string                                            `json:"documentation_url"`
	Source           ControlRetentionGetResponseEnvelopeMessagesSource `json:"source"`
	JSON             controlRetentionGetResponseEnvelopeMessagesJSON   `json:"-"`
}

type ControlRetentionGetResponseEnvelopeMessagesSource struct {
	Pointer string                                                `json:"pointer"`
	JSON    controlRetentionGetResponseEnvelopeMessagesSourceJSON `json:"-"`
}

type ControlRetentionGetResponseEnvelopeSuccess bool

type ControlRetentionNewParams struct {
	// Identifier.
	ZoneID param.Field[string] `path:"zone_id,required"`
	// The log retention flag for Logpull API.
	Flag param.Field[bool] `json:"flag"`
}

type ControlRetentionNewResponse struct {
	// The log retention flag for Logpull API.
	Flag bool                            `json:"flag"`
	JSON controlRetentionNewResponseJSON `json:"-"`
}

type ControlRetentionNewResponseEnvelope struct {
	Errors   []ControlRetentionNewResponseEnvelopeErrors   `json:"errors,required"`
	Messages []ControlRetentionNewResponseEnvelopeMessages `json:"messages,required"`
	// Whether the API call was successful.
	Success ControlRetentionNewResponseEnvelopeSuccess `json:"success,required"`
	Result  ControlRetentionNewResponse                `json:"result,nullable"`
	JSON    controlRetentionNewResponseEnvelopeJSON    `json:"-"`
}

type ControlRetentionNewResponseEnvelopeErrors struct {
	Code             int64                                           `json:"code,required"`
	Message          string                                          `json:"message,required"`
	DocumentationURL string                                          `json:"documentation_url"`
	Source           ControlRetentionNewResponseEnvelopeErrorsSource `json:"source"`
	JSON             controlRetentionNewResponseEnvelopeErrorsJSON   `json:"-"`
}

type ControlRetentionNewResponseEnvelopeErrorsSource struct {
	Pointer string                                              `json:"pointer"`
	JSON    controlRetentionNewResponseEnvelopeErrorsSourceJSON `json:"-"`
}

type ControlRetentionNewResponseEnvelopeMessages struct {
	Code             int64                                             `json:"code,required"`
	Message          string                                            `json:"message,required"`
	DocumentationURL string                                            `json:"documentation_url"`
	Source           ControlRetentionNewResponseEnvelopeMessagesSource `json:"source"`
	JSON             controlRetentionNewResponseEnvelopeMessagesJSON   `json:"-"`
}

type ControlRetentionNewResponseEnvelopeMessagesSource struct {
	Pointer string                                                `json:"pointer"`
	JSON    controlRetentionNewResponseEnvelopeMessagesSourceJSON `json:"-"`
}

type ControlRetentionNewResponseEnvelopeSuccess bool

type ControlRetentionService struct {
	Options []option.RequestOption
}

type ControlService struct {
	Options   []option.RequestOption
	Retention *ControlRetentionService
	Cmb       *ControlCmbService
}

type Error = apierror.Error

type ErrorData = shared.ErrorData

type ErrorDataSource = shared.ErrorDataSource

type LogService struct {
	Options  []option.RequestOption
	Control  *ControlService
	RayID    *RayIDService
	Received *ReceivedService
}

type Member = shared.Member

type MemberPoliciesAccess = shared.MemberPoliciesAccess

type MemberPoliciesPermissionGroup = shared.MemberPoliciesPermissionGroup

type MemberPoliciesPermissionGroupsMeta = shared.MemberPoliciesPermissionGroupsMeta

type MemberPoliciesResourceGroup = shared.MemberPoliciesResourceGroup

type MemberPoliciesResourceGroupsMeta = shared.MemberPoliciesResourceGroupsMeta

type MemberPoliciesResourceGroupsScope = shared.MemberPoliciesResourceGroupsScope

type MemberPoliciesResourceGroupsScopeObject = shared.MemberPoliciesResourceGroupsScopeObject

type MemberPolicy = shared.MemberPolicy

type MemberStatus = shared.MemberStatus

type MemberUser = shared.MemberUser

type Permission = shared.Permission

type PermissionGrant = shared.PermissionGrant

type PermissionGrantParam = shared.PermissionGrantParam

type RatePlan = shared.RatePlan

type RatePlanID = shared.RatePlanID

type RatePlanParam = shared.RatePlanParam

type RayIDGetParams struct {
	// Identifier
	ZoneID param.Field[string] `path:"zone_id,required"`
	// The `/received` route by default returns a limited set of fields, and allows
	// customers to override the default field set by specifying individual fields. The
	// reasons for this are: 1. Most customers require only a small subset of fields,
	// but that subset varies from customer to customer; 2. Flat schema is much easier
	// to work with downstream (importing into BigTable etc); 3. Performance (time to
	// process, file size). If `?fields=` is not specified, default field set is
	// returned. This default field set may change at any time. When `?fields=` is
	// provided, each record is returned with the specified fields. `fields` must be
	// specified as a comma separated list without any whitespaces, and all fields must
	// exist. The order in which fields are specified does not matter, and the order of
	// fields in the response is not specified.
	Fields param.Field[string] `query:"fields"`
	// By default, timestamps in responses are returned as Unix nanosecond integers.
	// The `?timestamps=` argument can be set to change the format in which response
	// timestamps are returned. Possible values are: `unix`, `unixnano`, `rfc3339`.
	// Note that `unix` and `unixnano` return timestamps as integers; `rfc3339` returns
	// timestamps as strings.
	Timestamps param.Field[RayIDGetParamsTimestamps] `query:"timestamps"`
}

type RayIDGetParamsTimestamps string

type RayIDService struct {
	Options []option.RequestOption
}

type ReceivedFieldGetParams struct {
	// Identifier
	ZoneID param.Field[string] `path:"zone_id,required"`
}

type ReceivedFieldGetResponse struct {
	Key  string                       `json:"key"`
	JSON receivedFieldGetResponseJSON `json:"-"`
}

type ReceivedFieldService struct {
	Options []option.RequestOption
}

type ReceivedGetParams struct {
	// Identifier
	ZoneID param.Field[string] `path:"zone_id,required"`
	// Sets the (exclusive) end of the requested time frame. This can be a unix
	// timestamp (in seconds or nanoseconds), or an absolute timestamp that conforms to
	// RFC 3339. `end` must be at least five minutes earlier than now and must be later
	// than `start`. Difference between `start` and `end` must be not greater than one
	// hour.
	End param.Field[ReceivedGetParamsEndUnion] `query:"end,required"`
	// When `?count=` is provided, the response will contain up to `count` results.
	// Since results are not sorted, you are likely to get different data for repeated
	// requests. `count` must be an integer > 0.
	Count param.Field[int64] `query:"count"`
	// The `/received` route by default returns a limited set of fields, and allows
	// customers to override the default field set by specifying individual fields. The
	// reasons for this are: 1. Most customers require only a small subset of fields,
	// but that subset varies from customer to customer; 2. Flat schema is much easier
	// to work with downstream (importing into BigTable etc); 3. Performance (time to
	// process, file size). If `?fields=` is not specified, default field set is
	// returned. This default field set may change at any time. When `?fields=` is
	// provided, each record is returned with the specified fields. `fields` must be
	// specified as a comma separated list without any whitespaces, and all fields must
	// exist. The order in which fields are specified does not matter, and the order of
	// fields in the response is not specified.
	Fields param.Field[string] `query:"fields"`
	// When `?sample=` is provided, a sample of matching records is returned. If
	// `sample=0.1` then 10% of records will be returned. Sampling is random: repeated
	// calls will not only return different records, but likely will also vary slightly
	// in number of returned records. When `?count=` is also specified, `count` is
	// applied to the number of returned records, not the sampled records. So, with
	// `sample=0.05` and `count=7`, when there is a total of 100 records available,
	// approximately five will be returned. When there are 1000 records, seven will be
	// returned. When there are 10,000 records, seven will be returned.
	Sample param.Field[float64] `query:"sample"`
	// Sets the (inclusive) beginning of the requested time frame. This can be a unix
	// timestamp (in seconds or nanoseconds), or an absolute timestamp that conforms to
	// RFC 3339. At this point in time, it cannot exceed a time in the past greater
	// than seven days.
	Start param.Field[ReceivedGetParamsStartUnion] `query:"start"`
	// By default, timestamps in responses are returned as Unix nanosecond integers.
	// The `?timestamps=` argument can be set to change the format in which response
	// timestamps are returned. Possible values are: `unix`, `unixnano`, `rfc3339`.
	// Note that `unix` and `unixnano` return timestamps as integers; `rfc3339` returns
	// timestamps as strings.
	Timestamps param.Field[ReceivedGetParamsTimestamps] `query:"timestamps"`
}

type ReceivedGetParamsEndUnion interface {
	ImplementsReceivedGetParamsEndUnion()
}

type ReceivedGetParamsStartUnion interface {
	ImplementsReceivedGetParamsStartUnion()
}

type ReceivedGetParamsTimestamps string

type ReceivedService struct {
	Options []option.RequestOption
	Fields  *ReceivedFieldService
}

type ResponseInfo = shared.ResponseInfo

type ResponseInfoSource = shared.ResponseInfoSource

type Role = shared.Role

type RoleParam = shared.RoleParam

type RolePermissions = shared.RolePermissions

type RolePermissionsParam = shared.RolePermissionsParam

type SortDirection = shared.SortDirection

type Subscription = shared.Subscription

type SubscriptionFrequency = shared.SubscriptionFrequency

type SubscriptionParam = shared.SubscriptionParam

type SubscriptionState = shared.SubscriptionState

type Token = shared.Token

type TokenCondition = shared.TokenCondition

type TokenConditionCIDRList = shared.TokenConditionCIDRList

type TokenConditionCIDRListParam = shared.TokenConditionCIDRListParam

type TokenConditionParam = shared.TokenConditionParam

type TokenConditionRequestIP = shared.TokenConditionRequestIP

type TokenConditionRequestIPParam = shared.TokenConditionRequestIPParam

type TokenParam = shared.TokenParam

type TokenPolicy = shared.TokenPolicy

type TokenPolicyEffect = shared.TokenPolicyEffect

type TokenPolicyParam = shared.TokenPolicyParam

type TokenPolicyPermissionGroup = shared.TokenPolicyPermissionGroup

type TokenPolicyPermissionGroupParam = shared.TokenPolicyPermissionGroupParam

type TokenPolicyPermissionGroupsMeta = shared.TokenPolicyPermissionGroupsMeta

type TokenPolicyPermissionGroupsMetaParam = shared.TokenPolicyPermissionGroupsMetaParam

type TokenPolicyResourcesMap = shared.TokenPolicyResourcesMap

type TokenPolicyResourcesMapParam = shared.TokenPolicyResourcesMapParam

type TokenPolicyResourcesUnion = shared.TokenPolicyResourcesUnion

type TokenPolicyResourcesUnionParam = shared.TokenPolicyResourcesUnionParam

type TokenStatus = shared.TokenStatus

type TokenValue = shared.TokenValue