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 CloudflareTunnel = shared.CloudflareTunnel

type CloudflareTunnelConnection = shared.CloudflareTunnelConnection

type CloudflareTunnelTunType = shared.CloudflareTunnelTunType

type CmbConfig struct {
	// Comma-separated list of regions.
	Regions string        `json:"regions"`
	JSON    cmbConfigJSON `json:"-"`
}

type CmbConfigParam struct {
	// Comma-separated list of regions.
	Regions param.Field[string] `json:"regions"`
}

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

type ControlCmbConfigDeleteResponse = interface{}

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

type ControlCmbConfigDeleteResponseEnvelopeSuccess bool

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

type ControlCmbConfigGetResponseEnvelope struct {
	Errors   []shared.ResponseInfo `json:"errors,required"`
	Messages []shared.ResponseInfo `json:"messages,required"`
	// Whether the API call was successful
	Success ControlCmbConfigGetResponseEnvelopeSuccess `json:"success,required"`
	Result  CmbConfig                                  `json:"result,nullable"`
	JSON    controlCmbConfigGetResponseEnvelopeJSON    `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   []shared.ResponseInfo `json:"errors,required"`
	Messages []shared.ResponseInfo `json:"messages,required"`
	// Whether the API call was successful
	Success ControlCmbConfigNewResponseEnvelopeSuccess `json:"success,required"`
	Result  CmbConfig                                  `json:"result,nullable"`
	JSON    controlCmbConfigNewResponseEnvelopeJSON    `json:"-"`
}

type ControlCmbConfigNewResponseEnvelopeSuccess bool

type ControlCmbConfigService struct {
	Options []option.RequestOption
}

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

type ControlRetentionFlagGetResponse struct {
	Flag bool                                `json:"flag"`
	JSON controlRetentionFlagGetResponseJSON `json:"-"`
}

type ControlRetentionFlagGetResponseEnvelope struct {
	Errors   []shared.ResponseInfo           `json:"errors,required"`
	Messages []shared.ResponseInfo           `json:"messages,required"`
	Result   ControlRetentionFlagGetResponse `json:"result,required"`
	// Whether the API call was successful
	Success ControlRetentionFlagGetResponseEnvelopeSuccess `json:"success,required"`
	JSON    controlRetentionFlagGetResponseEnvelopeJSON    `json:"-"`
}

type ControlRetentionFlagGetResponseEnvelopeSuccess bool

type ControlRetentionFlagNewParams struct {
	// The log retention flag for Logpull API.
	Flag param.Field[bool] `json:"flag,required"`
}

type ControlRetentionFlagNewResponse struct {
	Flag bool                                `json:"flag"`
	JSON controlRetentionFlagNewResponseJSON `json:"-"`
}

type ControlRetentionFlagNewResponseEnvelope struct {
	Errors   []shared.ResponseInfo           `json:"errors,required"`
	Messages []shared.ResponseInfo           `json:"messages,required"`
	Result   ControlRetentionFlagNewResponse `json:"result,required"`
	// Whether the API call was successful
	Success ControlRetentionFlagNewResponseEnvelopeSuccess `json:"success,required"`
	JSON    controlRetentionFlagNewResponseEnvelopeJSON    `json:"-"`
}

type ControlRetentionFlagNewResponseEnvelopeSuccess bool

type ControlRetentionFlagService struct {
	Options []option.RequestOption
}

type ControlRetentionService struct {
	Options []option.RequestOption
	Flag    *ControlRetentionFlagService
}

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

type Error = apierror.Error

type ErrorData = shared.ErrorData

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

type Member = shared.Member

type MemberParam = shared.MemberParam

type MemberRole = shared.MemberRole

type MemberRoleParam = shared.MemberRoleParam

type MemberRolesPermissions = shared.MemberRolesPermissions

type MemberRolesPermissionsParam = shared.MemberRolesPermissionsParam

type MemberUser = shared.MemberUser

type MemberUserParam = shared.MemberUserParam

type Permission = shared.Permission

type PermissionGrant = shared.PermissionGrant

type PermissionGrantParam = shared.PermissionGrantParam

type RayIDGetParams struct {
	// 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 RayIDGetResponseUnion interface {
	ImplementsLogsRayIDGetResponseUnion()
}

type RayIDService struct {
	Options []option.RequestOption
}

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

type ReceivedFieldService struct {
	Options []option.RequestOption
}

type ReceivedGetParams struct {
	// 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 {
	ImplementsLogsReceivedGetParamsEndUnion()
}

type ReceivedGetParamsStartUnion interface {
	ImplementsLogsReceivedGetParamsStartUnion()
}

type ReceivedGetParamsTimestamps string

type ReceivedGetResponseUnion interface {
	ImplementsLogsReceivedGetResponseUnion()
}

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

type ResponseInfo = shared.ResponseInfo

type Role = shared.Role