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 AvailableDataset struct {
	// Dataset type name (e.g. `http_requests`).
	Dataset string `json:"dataset" api:"required"`
	// Whether this dataset type is account-scoped or zone-scoped.
	ObjectType AvailableDatasetObjectType `json:"object_type" api:"required"`
	// JSON Schema that describes the fields this dataset exposes.
	Schema AvailableDatasetSchema `json:"schema" api:"required"`
	// The primary timestamp field name for this dataset.
	TimestampField string               `json:"timestamp_field" api:"required"`
	JSON           availableDatasetJSON `json:"-"`
}

type AvailableDatasetObjectType string

type AvailableDatasetSchema struct {
	Properties map[string]interface{}     `json:"properties"`
	Required   []string                   `json:"required"`
	Type       AvailableDatasetSchemaType `json:"type"`
	JSON       availableDatasetSchemaJSON `json:"-"`
}

type AvailableDatasetSchemaType string

type AvailableList struct {
	Errors   []shared.ResponseInfo `json:"errors" api:"required"`
	Messages []string              `json:"messages" api:"required"`
	Success  bool                  `json:"success" api:"required"`
	Result   []AvailableDataset    `json:"result" api:"nullable"`
	JSON     availableListJSON     `json:"-"`
}

type CertificateCA = shared.CertificateCA

type CertificateRequestType = shared.CertificateRequestType

type CloudflareTunnel = shared.CloudflareTunnel

type CloudflareTunnelConfigSrc = shared.CloudflareTunnelConfigSrc

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" api:"required"`
}

type ControlCmbConfigDeleteResponse = interface{}

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

type ControlCmbConfigDeleteResponseEnvelopeErrors struct {
	Code             int64                                              `json:"code" api:"required"`
	Message          string                                             `json:"message" api:"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" api:"required"`
	Message          string                                               `json:"message" api:"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" api:"required"`
}

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

type ControlCmbConfigGetResponseEnvelopeErrors struct {
	Code             int64                                           `json:"code" api:"required"`
	Message          string                                          `json:"message" api:"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" api:"required"`
	Message          string                                            `json:"message" api:"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" api:"required"`
	CmbConfig CmbConfigParam      `json:"cmb_config" api:"required"`
}

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

type ControlCmbConfigNewResponseEnvelopeErrors struct {
	Code             int64                                           `json:"code" api:"required"`
	Message          string                                          `json:"message" api:"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" api:"required"`
	Message          string                                            `json:"message" api:"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" api:"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" api:"required"`
	Messages []ControlRetentionGetResponseEnvelopeMessages `json:"messages" api:"required"`
	// Whether the API call was successful.
	Success ControlRetentionGetResponseEnvelopeSuccess `json:"success" api:"required"`
	Result  ControlRetentionGetResponse                `json:"result" api:"nullable"`
	JSON    controlRetentionGetResponseEnvelopeJSON    `json:"-"`
}

type ControlRetentionGetResponseEnvelopeErrors struct {
	Code             int64                                           `json:"code" api:"required"`
	Message          string                                          `json:"message" api:"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" api:"required"`
	Message          string                                            `json:"message" api:"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" api:"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" api:"required"`
	Messages []ControlRetentionNewResponseEnvelopeMessages `json:"messages" api:"required"`
	// Whether the API call was successful.
	Success ControlRetentionNewResponseEnvelopeSuccess `json:"success" api:"required"`
	Result  ControlRetentionNewResponse                `json:"result" api:"nullable"`
	JSON    controlRetentionNewResponseEnvelopeJSON    `json:"-"`
}

type ControlRetentionNewResponseEnvelopeErrors struct {
	Code             int64                                           `json:"code" api:"required"`
	Message          string                                          `json:"message" api:"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" api:"required"`
	Message          string                                            `json:"message" api:"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 CreateRequestFieldParam struct {
	// Whether the API includes this field in log ingest.
	Enabled param.Field[bool] `json:"enabled" api:"required"`
	// Field name in lowercase.
	Name param.Field[string] `json:"name" api:"required"`
}

type CreateRequestParam struct {
	// Dataset type name to create (e.g. `http_requests`).
	Dataset param.Field[string] `json:"dataset" api:"required"`
	// Controls which fields the API ingests. Defaults to all available fields when
	// absent.
	Fields param.Field[[]CreateRequestFieldParam] `json:"fields"`
}

type Dataset struct {
	// RFC3339 timestamp recording when the API created this dataset.
	CreatedAt time.Time `json:"created_at" api:"required" format:"date-time"`
	// Dataset type name (e.g. `http_requests`).
	Dataset string `json:"dataset" api:"required"`
	// Unique dataset ID.
	DatasetID string `json:"dataset_id" api:"required"`
	// Whether log ingest is currently active for this dataset.
	Enabled bool `json:"enabled" api:"required"`
	// Public ID of the account or zone that owns this dataset.
	ObjectID string `json:"object_id" api:"required"`
	// Whether this dataset belongs to an account or a zone.
	ObjectType DatasetObjectType `json:"object_type" api:"required"`
	// RFC3339 timestamp recording when the API last updated this dataset.
	UpdatedAt time.Time `json:"updated_at" api:"required" format:"date-time"`
	// The field configuration for this dataset.
	Fields []DatasetField `json:"fields"`
	JSON   datasetJSON    `json:"-"`
}

type DatasetField struct {
	// Whether the API includes this field in log ingest.
	Enabled bool `json:"enabled" api:"required"`
	// Field name in lowercase.
	Name string           `json:"name" api:"required"`
	JSON datasetFieldJSON `json:"-"`
}

type DatasetObjectType string

type DatasetSummary struct {
	// RFC3339 timestamp recording when the API created this dataset.
	CreatedAt time.Time `json:"created_at" api:"required" format:"date-time"`
	// Dataset type name (e.g. `http_requests`).
	Dataset string `json:"dataset" api:"required"`
	// Unique dataset ID.
	DatasetID string `json:"dataset_id" api:"required"`
	// Whether log ingest is currently active for this dataset.
	Enabled bool `json:"enabled" api:"required"`
	// Public ID of the account or zone that owns this dataset.
	ObjectID string `json:"object_id" api:"required"`
	// Whether this dataset belongs to an account or a zone.
	ObjectType DatasetSummaryObjectType `json:"object_type" api:"required"`
	// RFC3339 timestamp recording when the API last updated this dataset.
	UpdatedAt time.Time          `json:"updated_at" api:"required" format:"date-time"`
	JSON      datasetSummaryJSON `json:"-"`
}

type DatasetSummaryObjectType string

type Error = apierror.Error

type ErrorData = shared.ErrorData

type ErrorDataSource = shared.ErrorDataSource

type LogExplorerDatasetAvailableListParams struct {
	// The Account ID to use for this endpoint. Mutually exclusive with the Zone ID.
	AccountID param.Field[string] `path:"account_id"`
	// The Zone ID to use for this endpoint. Mutually exclusive with the Account ID.
	ZoneID param.Field[string] `path:"zone_id"`
}

type LogExplorerDatasetAvailableService struct {
	Options []option.RequestOption
}

type LogExplorerDatasetGetParams struct {
	// The Account ID to use for this endpoint. Mutually exclusive with the Zone ID.
	AccountID param.Field[string] `path:"account_id"`
	// The Zone ID to use for this endpoint. Mutually exclusive with the Account ID.
	ZoneID param.Field[string] `path:"zone_id"`
}

type LogExplorerDatasetGetResponseEnvelope struct {
	Errors   []shared.ResponseInfo `json:"errors" api:"required"`
	Messages []string              `json:"messages" api:"required"`
	Success  bool                  `json:"success" api:"required"`
	// A Log Explorer dataset summary. List endpoints return this type and omit field
	// configuration; use the single-dataset endpoint to retrieve it.
	Result Dataset                                   `json:"result"`
	JSON   logExplorerDatasetGetResponseEnvelopeJSON `json:"-"`
}

type LogExplorerDatasetListParams struct {
	// The Account ID to use for this endpoint. Mutually exclusive with the Zone ID.
	AccountID param.Field[string] `path:"account_id"`
	// The Zone ID to use for this endpoint. Mutually exclusive with the Account ID.
	ZoneID param.Field[string] `path:"zone_id"`
	// Set to true to include zone-scoped datasets belonging to this account.
	IncludeZones param.Field[bool] `query:"include_zones"`
}

type LogExplorerDatasetNewParams struct {
	CreateRequest CreateRequestParam `json:"create_request" api:"required"`
	// The Account ID to use for this endpoint. Mutually exclusive with the Zone ID.
	AccountID param.Field[string] `path:"account_id"`
	// The Zone ID to use for this endpoint. Mutually exclusive with the Account ID.
	ZoneID param.Field[string] `path:"zone_id"`
}

type LogExplorerDatasetNewResponseEnvelope struct {
	Errors   []shared.ResponseInfo `json:"errors" api:"required"`
	Messages []string              `json:"messages" api:"required"`
	Success  bool                  `json:"success" api:"required"`
	// A Log Explorer dataset summary. List endpoints return this type and omit field
	// configuration; use the single-dataset endpoint to retrieve it.
	Result Dataset                                   `json:"result"`
	JSON   logExplorerDatasetNewResponseEnvelopeJSON `json:"-"`
}

type LogExplorerDatasetService struct {
	Options   []option.RequestOption
	Available *LogExplorerDatasetAvailableService
}

type LogExplorerDatasetUpdateParams struct {
	UpdateRequest UpdateRequestParam `json:"update_request" api:"required"`
	// The Account ID to use for this endpoint. Mutually exclusive with the Zone ID.
	AccountID param.Field[string] `path:"account_id"`
	// The Zone ID to use for this endpoint. Mutually exclusive with the Account ID.
	ZoneID param.Field[string] `path:"zone_id"`
}

type LogExplorerDatasetUpdateResponseEnvelope struct {
	Errors   []shared.ResponseInfo `json:"errors" api:"required"`
	Messages []string              `json:"messages" api:"required"`
	Success  bool                  `json:"success" api:"required"`
	// A Log Explorer dataset summary. List endpoints return this type and omit field
	// configuration; use the single-dataset endpoint to retrieve it.
	Result Dataset                                      `json:"result"`
	JSON   logExplorerDatasetUpdateResponseEnvelopeJSON `json:"-"`
}

type LogExplorerQueryService struct {
	Options []option.RequestOption
}

type LogExplorerQuerySqlParams struct {
	// The Account ID to use for this endpoint. Mutually exclusive with the Zone ID.
	AccountID param.Field[string] `path:"account_id"`
	// The Zone ID to use for this endpoint. Mutually exclusive with the Account ID.
	ZoneID param.Field[string] `path:"zone_id"`
}

type LogExplorerQuerySqlResponse map[string]interface{}

type LogExplorerService struct {
	Options  []option.RequestOption
	Query    *LogExplorerQueryService
	Datasets *LogExplorerDatasetService
}

type LogService struct {
	Options     []option.RequestOption
	LogExplorer *LogExplorerService
	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" api:"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" api:"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" api:"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" api:"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 TokenPolicyResourcesIAMResourcesTypeObjectNested = shared.TokenPolicyResourcesIAMResourcesTypeObjectNested

type TokenPolicyResourcesIAMResourcesTypeObjectNestedParam = shared.TokenPolicyResourcesIAMResourcesTypeObjectNestedParam

type TokenPolicyResourcesIAMResourcesTypeObjectString = shared.TokenPolicyResourcesIAMResourcesTypeObjectString

type TokenPolicyResourcesIAMResourcesTypeObjectStringParam = shared.TokenPolicyResourcesIAMResourcesTypeObjectStringParam

type TokenPolicyResourcesUnion = shared.TokenPolicyResourcesUnion

type TokenPolicyResourcesUnionParam = shared.TokenPolicyResourcesUnionParam

type TokenStatus = shared.TokenStatus

type TokenValue = shared.TokenValue

type UpdateRequestFieldParam struct {
	// Whether the API includes this field in log ingest.
	Enabled param.Field[bool] `json:"enabled" api:"required"`
	// Field name in lowercase.
	Name param.Field[string] `json:"name" api:"required"`
}

type UpdateRequestParam struct {
	// Whether to enable or disable log ingest for this dataset.
	Enabled param.Field[bool] `json:"enabled" api:"required"`
	// Controls which fields the API ingests after the update. Defaults to all
	// available fields when absent.
	Fields param.Field[[]UpdateRequestFieldParam] `json:"fields"`
}