r2

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 Bucket struct {
	// Creation timestamp.
	CreationDate string `json:"creation_date"`
	// Jurisdiction where objects in this bucket are guaranteed to be stored.
	Jurisdiction BucketJurisdiction `json:"jurisdiction"`
	// Location of the bucket.
	Location BucketLocation `json:"location"`
	// Name of the bucket.
	Name string `json:"name"`
	// Storage class for newly uploaded objects, unless specified otherwise.
	StorageClass BucketStorageClass `json:"storage_class"`
	JSON         bucketJSON         `json:"-"`
}

type BucketCORSDeleteParams struct {
	// Account ID.
	AccountID param.Field[string] `path:"account_id,required"`
	// Jurisdiction where objects in this bucket are guaranteed to be stored.
	Jurisdiction param.Field[BucketCORSDeleteParamsCfR2Jurisdiction] `header:"cf-r2-jurisdiction"`
}

type BucketCORSDeleteParamsCfR2Jurisdiction string

type BucketCORSDeleteResponse = interface{}

type BucketCORSDeleteResponseEnvelope struct {
	Errors   []shared.ResponseInfo    `json:"errors,required"`
	Messages []string                 `json:"messages,required"`
	Result   BucketCORSDeleteResponse `json:"result,required"`
	// Whether the API call was successful.
	Success BucketCORSDeleteResponseEnvelopeSuccess `json:"success,required"`
	JSON    bucketCORSDeleteResponseEnvelopeJSON    `json:"-"`
}

type BucketCORSDeleteResponseEnvelopeSuccess bool

type BucketCORSGetParams struct {
	// Account ID.
	AccountID param.Field[string] `path:"account_id,required"`
	// Jurisdiction where objects in this bucket are guaranteed to be stored.
	Jurisdiction param.Field[BucketCORSGetParamsCfR2Jurisdiction] `header:"cf-r2-jurisdiction"`
}

type BucketCORSGetParamsCfR2Jurisdiction string

type BucketCORSGetResponse struct {
	Rules []BucketCORSGetResponseRule `json:"rules"`
	JSON  bucketCORSGetResponseJSON   `json:"-"`
}

type BucketCORSGetResponseEnvelope struct {
	Errors   []shared.ResponseInfo `json:"errors,required"`
	Messages []string              `json:"messages,required"`
	Result   BucketCORSGetResponse `json:"result,required"`
	// Whether the API call was successful.
	Success BucketCORSGetResponseEnvelopeSuccess `json:"success,required"`
	JSON    bucketCORSGetResponseEnvelopeJSON    `json:"-"`
}

type BucketCORSGetResponseEnvelopeSuccess bool

type BucketCORSGetResponseRule struct {
	// Object specifying allowed origins, methods and headers for this CORS rule.
	Allowed BucketCORSGetResponseRulesAllowed `json:"allowed,required"`
	// Identifier for this rule.
	ID string `json:"id"`
	// Specifies the headers that can be exposed back, and accessed by, the JavaScript
	// making the cross-origin request. If you need to access headers beyond the
	// safelisted response headers, such as Content-Encoding or cf-cache-status, you
	// must specify it here.
	ExposeHeaders []string `json:"exposeHeaders"`
	// Specifies the amount of time (in seconds) browsers are allowed to cache CORS
	// preflight responses. Browsers may limit this to 2 hours or less, even if the
	// maximum value (86400) is specified.
	MaxAgeSeconds float64                       `json:"maxAgeSeconds"`
	JSON          bucketCORSGetResponseRuleJSON `json:"-"`
}

type BucketCORSGetResponseRulesAllowed struct {
	// Specifies the value for the Access-Control-Allow-Methods header R2 sets when
	// requesting objects in a bucket from a browser.
	Methods []BucketCORSGetResponseRulesAllowedMethod `json:"methods,required"`
	// Specifies the value for the Access-Control-Allow-Origin header R2 sets when
	// requesting objects in a bucket from a browser.
	Origins []string `json:"origins,required"`
	// Specifies the value for the Access-Control-Allow-Headers header R2 sets when
	// requesting objects in this bucket from a browser. Cross-origin requests that
	// include custom headers (e.g. x-user-id) should specify these headers as
	// AllowedHeaders.
	Headers []string                              `json:"headers"`
	JSON    bucketCORSGetResponseRulesAllowedJSON `json:"-"`
}

type BucketCORSGetResponseRulesAllowedMethod string

type BucketCORSService struct {
	Options []option.RequestOption
}

type BucketCORSUpdateParams struct {
	// Account ID.
	AccountID param.Field[string]                       `path:"account_id,required"`
	Rules     param.Field[[]BucketCORSUpdateParamsRule] `json:"rules"`
	// Jurisdiction where objects in this bucket are guaranteed to be stored.
	Jurisdiction param.Field[BucketCORSUpdateParamsCfR2Jurisdiction] `header:"cf-r2-jurisdiction"`
}

type BucketCORSUpdateParamsCfR2Jurisdiction string

type BucketCORSUpdateParamsRule struct {
	// Object specifying allowed origins, methods and headers for this CORS rule.
	Allowed param.Field[BucketCORSUpdateParamsRulesAllowed] `json:"allowed,required"`
	// Identifier for this rule.
	ID param.Field[string] `json:"id"`
	// Specifies the headers that can be exposed back, and accessed by, the JavaScript
	// making the cross-origin request. If you need to access headers beyond the
	// safelisted response headers, such as Content-Encoding or cf-cache-status, you
	// must specify it here.
	ExposeHeaders param.Field[[]string] `json:"exposeHeaders"`
	// Specifies the amount of time (in seconds) browsers are allowed to cache CORS
	// preflight responses. Browsers may limit this to 2 hours or less, even if the
	// maximum value (86400) is specified.
	MaxAgeSeconds param.Field[float64] `json:"maxAgeSeconds"`
}

type BucketCORSUpdateParamsRulesAllowed struct {
	// Specifies the value for the Access-Control-Allow-Methods header R2 sets when
	// requesting objects in a bucket from a browser.
	Methods param.Field[[]BucketCORSUpdateParamsRulesAllowedMethod] `json:"methods,required"`
	// Specifies the value for the Access-Control-Allow-Origin header R2 sets when
	// requesting objects in a bucket from a browser.
	Origins param.Field[[]string] `json:"origins,required"`
	// Specifies the value for the Access-Control-Allow-Headers header R2 sets when
	// requesting objects in this bucket from a browser. Cross-origin requests that
	// include custom headers (e.g. x-user-id) should specify these headers as
	// AllowedHeaders.
	Headers param.Field[[]string] `json:"headers"`
}

type BucketCORSUpdateParamsRulesAllowedMethod string

type BucketCORSUpdateResponse = interface{}

type BucketCORSUpdateResponseEnvelope struct {
	Errors   []shared.ResponseInfo    `json:"errors,required"`
	Messages []string                 `json:"messages,required"`
	Result   BucketCORSUpdateResponse `json:"result,required"`
	// Whether the API call was successful.
	Success BucketCORSUpdateResponseEnvelopeSuccess `json:"success,required"`
	JSON    bucketCORSUpdateResponseEnvelopeJSON    `json:"-"`
}

type BucketCORSUpdateResponseEnvelopeSuccess bool

type BucketDeleteParams struct {
	// Account ID.
	AccountID param.Field[string] `path:"account_id,required"`
	// Jurisdiction where objects in this bucket are guaranteed to be stored.
	Jurisdiction param.Field[BucketDeleteParamsCfR2Jurisdiction] `header:"cf-r2-jurisdiction"`
}

type BucketDeleteParamsCfR2Jurisdiction string

type BucketDeleteResponse = interface{}

type BucketDeleteResponseEnvelope struct {
	Errors   []shared.ResponseInfo `json:"errors,required"`
	Messages []string              `json:"messages,required"`
	Result   BucketDeleteResponse  `json:"result,required"`
	// Whether the API call was successful.
	Success BucketDeleteResponseEnvelopeSuccess `json:"success,required"`
	JSON    bucketDeleteResponseEnvelopeJSON    `json:"-"`
}

type BucketDeleteResponseEnvelopeSuccess bool

type BucketDomainCustomDeleteParams struct {
	// Account ID.
	AccountID param.Field[string] `path:"account_id,required"`
	// Jurisdiction where objects in this bucket are guaranteed to be stored.
	Jurisdiction param.Field[BucketDomainCustomDeleteParamsCfR2Jurisdiction] `header:"cf-r2-jurisdiction"`
}

type BucketDomainCustomDeleteParamsCfR2Jurisdiction string

type BucketDomainCustomDeleteResponse struct {
	// Name of the removed custom domain.
	Domain string                               `json:"domain,required"`
	JSON   bucketDomainCustomDeleteResponseJSON `json:"-"`
}

type BucketDomainCustomDeleteResponseEnvelope struct {
	Errors   []shared.ResponseInfo            `json:"errors,required"`
	Messages []string                         `json:"messages,required"`
	Result   BucketDomainCustomDeleteResponse `json:"result,required"`
	// Whether the API call was successful.
	Success BucketDomainCustomDeleteResponseEnvelopeSuccess `json:"success,required"`
	JSON    bucketDomainCustomDeleteResponseEnvelopeJSON    `json:"-"`
}

type BucketDomainCustomDeleteResponseEnvelopeSuccess bool

type BucketDomainCustomGetParams struct {
	// Account ID.
	AccountID param.Field[string] `path:"account_id,required"`
	// Jurisdiction where objects in this bucket are guaranteed to be stored.
	Jurisdiction param.Field[BucketDomainCustomGetParamsCfR2Jurisdiction] `header:"cf-r2-jurisdiction"`
}

type BucketDomainCustomGetParamsCfR2Jurisdiction string

type BucketDomainCustomGetResponse struct {
	// Domain name of the custom domain to be added.
	Domain string `json:"domain,required"`
	// Whether this bucket is publicly accessible at the specified custom domain.
	Enabled bool                                `json:"enabled,required"`
	Status  BucketDomainCustomGetResponseStatus `json:"status,required"`
	// Minimum TLS Version the custom domain will accept for incoming connections. If
	// not set, defaults to 1.0.
	MinTLS BucketDomainCustomGetResponseMinTLS `json:"minTLS"`
	// Zone ID of the custom domain resides in.
	ZoneID string `json:"zoneId"`
	// Zone that the custom domain resides in.
	ZoneName string                            `json:"zoneName"`
	JSON     bucketDomainCustomGetResponseJSON `json:"-"`
}

type BucketDomainCustomGetResponseEnvelope struct {
	Errors   []shared.ResponseInfo         `json:"errors,required"`
	Messages []string                      `json:"messages,required"`
	Result   BucketDomainCustomGetResponse `json:"result,required"`
	// Whether the API call was successful.
	Success BucketDomainCustomGetResponseEnvelopeSuccess `json:"success,required"`
	JSON    bucketDomainCustomGetResponseEnvelopeJSON    `json:"-"`
}

type BucketDomainCustomGetResponseEnvelopeSuccess bool

type BucketDomainCustomGetResponseMinTLS string

type BucketDomainCustomGetResponseStatus struct {
	// Ownership status of the domain.
	Ownership BucketDomainCustomGetResponseStatusOwnership `json:"ownership,required"`
	// SSL certificate status.
	SSL  BucketDomainCustomGetResponseStatusSSL  `json:"ssl,required"`
	JSON bucketDomainCustomGetResponseStatusJSON `json:"-"`
}

type BucketDomainCustomGetResponseStatusOwnership string

type BucketDomainCustomGetResponseStatusSSL string

type BucketDomainCustomListParams struct {
	// Account ID.
	AccountID param.Field[string] `path:"account_id,required"`
	// Jurisdiction where objects in this bucket are guaranteed to be stored.
	Jurisdiction param.Field[BucketDomainCustomListParamsCfR2Jurisdiction] `header:"cf-r2-jurisdiction"`
}

type BucketDomainCustomListParamsCfR2Jurisdiction string

type BucketDomainCustomListResponse struct {
	Domains []BucketDomainCustomListResponseDomain `json:"domains,required"`
	JSON    bucketDomainCustomListResponseJSON     `json:"-"`
}

type BucketDomainCustomListResponseDomain struct {
	// Domain name of the custom domain to be added.
	Domain string `json:"domain,required"`
	// Whether this bucket is publicly accessible at the specified custom domain.
	Enabled bool                                        `json:"enabled,required"`
	Status  BucketDomainCustomListResponseDomainsStatus `json:"status,required"`
	// Minimum TLS Version the custom domain will accept for incoming connections. If
	// not set, defaults to 1.0.
	MinTLS BucketDomainCustomListResponseDomainsMinTLS `json:"minTLS"`
	// Zone ID of the custom domain resides in.
	ZoneID string `json:"zoneId"`
	// Zone that the custom domain resides in.
	ZoneName string                                   `json:"zoneName"`
	JSON     bucketDomainCustomListResponseDomainJSON `json:"-"`
}

type BucketDomainCustomListResponseDomainsMinTLS string

type BucketDomainCustomListResponseDomainsStatus struct {
	// Ownership status of the domain.
	Ownership BucketDomainCustomListResponseDomainsStatusOwnership `json:"ownership,required"`
	// SSL certificate status.
	SSL  BucketDomainCustomListResponseDomainsStatusSSL  `json:"ssl,required"`
	JSON bucketDomainCustomListResponseDomainsStatusJSON `json:"-"`
}

type BucketDomainCustomListResponseDomainsStatusOwnership string

type BucketDomainCustomListResponseDomainsStatusSSL string

type BucketDomainCustomListResponseEnvelope struct {
	Errors   []shared.ResponseInfo          `json:"errors,required"`
	Messages []string                       `json:"messages,required"`
	Result   BucketDomainCustomListResponse `json:"result,required"`
	// Whether the API call was successful.
	Success BucketDomainCustomListResponseEnvelopeSuccess `json:"success,required"`
	JSON    bucketDomainCustomListResponseEnvelopeJSON    `json:"-"`
}

type BucketDomainCustomListResponseEnvelopeSuccess bool

type BucketDomainCustomNewParams struct {
	// Account ID.
	AccountID param.Field[string] `path:"account_id,required"`
	// Name of the custom domain to be added.
	Domain param.Field[string] `json:"domain,required"`
	// Whether to enable public bucket access at the custom domain. If undefined, the
	// domain will be enabled.
	Enabled param.Field[bool] `json:"enabled,required"`
	// Zone ID of the custom domain.
	ZoneID param.Field[string] `json:"zoneId,required"`
	// Minimum TLS Version the custom domain will accept for incoming connections. If
	// not set, defaults to 1.0.
	MinTLS param.Field[BucketDomainCustomNewParamsMinTLS] `json:"minTLS"`
	// Jurisdiction where objects in this bucket are guaranteed to be stored.
	Jurisdiction param.Field[BucketDomainCustomNewParamsCfR2Jurisdiction] `header:"cf-r2-jurisdiction"`
}

type BucketDomainCustomNewParamsCfR2Jurisdiction string

type BucketDomainCustomNewParamsMinTLS string

type BucketDomainCustomNewResponse struct {
	// Domain name of the affected custom domain.
	Domain string `json:"domain,required"`
	// Whether this bucket is publicly accessible at the specified custom domain.
	Enabled bool `json:"enabled,required"`
	// Minimum TLS Version the custom domain will accept for incoming connections. If
	// not set, defaults to 1.0.
	MinTLS BucketDomainCustomNewResponseMinTLS `json:"minTLS"`
	JSON   bucketDomainCustomNewResponseJSON   `json:"-"`
}

type BucketDomainCustomNewResponseEnvelope struct {
	Errors   []shared.ResponseInfo         `json:"errors,required"`
	Messages []string                      `json:"messages,required"`
	Result   BucketDomainCustomNewResponse `json:"result,required"`
	// Whether the API call was successful.
	Success BucketDomainCustomNewResponseEnvelopeSuccess `json:"success,required"`
	JSON    bucketDomainCustomNewResponseEnvelopeJSON    `json:"-"`
}

type BucketDomainCustomNewResponseEnvelopeSuccess bool

type BucketDomainCustomNewResponseMinTLS string

type BucketDomainCustomService struct {
	Options []option.RequestOption
}

type BucketDomainCustomUpdateParams struct {
	// Account ID.
	AccountID param.Field[string] `path:"account_id,required"`
	// Whether to enable public bucket access at the specified custom domain.
	Enabled param.Field[bool] `json:"enabled"`
	// Minimum TLS Version the custom domain will accept for incoming connections. If
	// not set, defaults to previous value.
	MinTLS param.Field[BucketDomainCustomUpdateParamsMinTLS] `json:"minTLS"`
	// Jurisdiction where objects in this bucket are guaranteed to be stored.
	Jurisdiction param.Field[BucketDomainCustomUpdateParamsCfR2Jurisdiction] `header:"cf-r2-jurisdiction"`
}

type BucketDomainCustomUpdateParamsCfR2Jurisdiction string

type BucketDomainCustomUpdateParamsMinTLS string

type BucketDomainCustomUpdateResponse struct {
	// Domain name of the affected custom domain.
	Domain string `json:"domain,required"`
	// Whether this bucket is publicly accessible at the specified custom domain.
	Enabled bool `json:"enabled"`
	// Minimum TLS Version the custom domain will accept for incoming connections. If
	// not set, defaults to 1.0.
	MinTLS BucketDomainCustomUpdateResponseMinTLS `json:"minTLS"`
	JSON   bucketDomainCustomUpdateResponseJSON   `json:"-"`
}

type BucketDomainCustomUpdateResponseEnvelope struct {
	Errors   []shared.ResponseInfo            `json:"errors,required"`
	Messages []string                         `json:"messages,required"`
	Result   BucketDomainCustomUpdateResponse `json:"result,required"`
	// Whether the API call was successful.
	Success BucketDomainCustomUpdateResponseEnvelopeSuccess `json:"success,required"`
	JSON    bucketDomainCustomUpdateResponseEnvelopeJSON    `json:"-"`
}

type BucketDomainCustomUpdateResponseEnvelopeSuccess bool

type BucketDomainCustomUpdateResponseMinTLS string

type BucketDomainManagedListParams struct {
	// Account ID.
	AccountID param.Field[string] `path:"account_id,required"`
	// Jurisdiction where objects in this bucket are guaranteed to be stored.
	Jurisdiction param.Field[BucketDomainManagedListParamsCfR2Jurisdiction] `header:"cf-r2-jurisdiction"`
}

type BucketDomainManagedListParamsCfR2Jurisdiction string

type BucketDomainManagedListResponse struct {
	// Bucket ID.
	BucketID string `json:"bucketId,required"`
	// Domain name of the bucket's r2.dev domain.
	Domain string `json:"domain,required"`
	// Whether this bucket is publicly accessible at the r2.dev domain.
	Enabled bool                                `json:"enabled,required"`
	JSON    bucketDomainManagedListResponseJSON `json:"-"`
}

type BucketDomainManagedListResponseEnvelope struct {
	Errors   []shared.ResponseInfo           `json:"errors,required"`
	Messages []string                        `json:"messages,required"`
	Result   BucketDomainManagedListResponse `json:"result,required"`
	// Whether the API call was successful.
	Success BucketDomainManagedListResponseEnvelopeSuccess `json:"success,required"`
	JSON    bucketDomainManagedListResponseEnvelopeJSON    `json:"-"`
}

type BucketDomainManagedListResponseEnvelopeSuccess bool

type BucketDomainManagedService struct {
	Options []option.RequestOption
}

type BucketDomainManagedUpdateParams struct {
	// Account ID.
	AccountID param.Field[string] `path:"account_id,required"`
	// Whether to enable public bucket access at the r2.dev domain.
	Enabled param.Field[bool] `json:"enabled,required"`
	// Jurisdiction where objects in this bucket are guaranteed to be stored.
	Jurisdiction param.Field[BucketDomainManagedUpdateParamsCfR2Jurisdiction] `header:"cf-r2-jurisdiction"`
}

type BucketDomainManagedUpdateParamsCfR2Jurisdiction string

type BucketDomainManagedUpdateResponse struct {
	// Bucket ID.
	BucketID string `json:"bucketId,required"`
	// Domain name of the bucket's r2.dev domain.
	Domain string `json:"domain,required"`
	// Whether this bucket is publicly accessible at the r2.dev domain.
	Enabled bool                                  `json:"enabled,required"`
	JSON    bucketDomainManagedUpdateResponseJSON `json:"-"`
}

type BucketDomainManagedUpdateResponseEnvelope struct {
	Errors   []shared.ResponseInfo             `json:"errors,required"`
	Messages []string                          `json:"messages,required"`
	Result   BucketDomainManagedUpdateResponse `json:"result,required"`
	// Whether the API call was successful.
	Success BucketDomainManagedUpdateResponseEnvelopeSuccess `json:"success,required"`
	JSON    bucketDomainManagedUpdateResponseEnvelopeJSON    `json:"-"`
}

type BucketDomainManagedUpdateResponseEnvelopeSuccess bool

type BucketDomainService struct {
	Options []option.RequestOption
	Custom  *BucketDomainCustomService
	Managed *BucketDomainManagedService
}

type BucketEditParams struct {
	// Account ID.
	AccountID param.Field[string] `path:"account_id,required"`
	// Storage class for newly uploaded objects, unless specified otherwise.
	StorageClass param.Field[BucketEditParamsCfR2StorageClass] `header:"cf-r2-storage-class,required"`
	// Jurisdiction where objects in this bucket are guaranteed to be stored.
	Jurisdiction param.Field[BucketEditParamsCfR2Jurisdiction] `header:"cf-r2-jurisdiction"`
}

type BucketEditParamsCfR2Jurisdiction string

type BucketEditParamsCfR2StorageClass string

type BucketEditResponseEnvelope struct {
	Errors   []shared.ResponseInfo `json:"errors,required"`
	Messages []string              `json:"messages,required"`
	// A single R2 bucket.
	Result Bucket `json:"result,required"`
	// Whether the API call was successful.
	Success BucketEditResponseEnvelopeSuccess `json:"success,required"`
	JSON    bucketEditResponseEnvelopeJSON    `json:"-"`
}

type BucketEditResponseEnvelopeSuccess bool

type BucketEventNotificationDeleteParams struct {
	// Account ID.
	AccountID param.Field[string] `path:"account_id,required"`
	// Jurisdiction where objects in this bucket are guaranteed to be stored.
	Jurisdiction param.Field[BucketEventNotificationDeleteParamsCfR2Jurisdiction] `header:"cf-r2-jurisdiction"`
}

type BucketEventNotificationDeleteParamsCfR2Jurisdiction string

type BucketEventNotificationDeleteResponse = interface{}

type BucketEventNotificationDeleteResponseEnvelope struct {
	Errors   []shared.ResponseInfo                 `json:"errors,required"`
	Messages []string                              `json:"messages,required"`
	Result   BucketEventNotificationDeleteResponse `json:"result,required"`
	// Whether the API call was successful.
	Success BucketEventNotificationDeleteResponseEnvelopeSuccess `json:"success,required"`
	JSON    bucketEventNotificationDeleteResponseEnvelopeJSON    `json:"-"`
}

type BucketEventNotificationDeleteResponseEnvelopeSuccess bool

type BucketEventNotificationGetParams struct {
	// Account ID.
	AccountID param.Field[string] `path:"account_id,required"`
	// The bucket jurisdiction.
	Jurisdiction param.Field[BucketEventNotificationGetParamsCfR2Jurisdiction] `header:"cf-r2-jurisdiction"`
}

type BucketEventNotificationGetParamsCfR2Jurisdiction string

type BucketEventNotificationGetResponse struct {
	// Queue ID.
	QueueID string `json:"queueId"`
	// Name of the queue.
	QueueName string                                   `json:"queueName"`
	Rules     []BucketEventNotificationGetResponseRule `json:"rules"`
	JSON      bucketEventNotificationGetResponseJSON   `json:"-"`
}

type BucketEventNotificationGetResponseEnvelope struct {
	Errors   []shared.ResponseInfo              `json:"errors,required"`
	Messages []string                           `json:"messages,required"`
	Result   BucketEventNotificationGetResponse `json:"result,required"`
	// Whether the API call was successful.
	Success BucketEventNotificationGetResponseEnvelopeSuccess `json:"success,required"`
	JSON    bucketEventNotificationGetResponseEnvelopeJSON    `json:"-"`
}

type BucketEventNotificationGetResponseEnvelopeSuccess bool

type BucketEventNotificationGetResponseRule struct {
	// Array of R2 object actions that will trigger notifications.
	Actions []BucketEventNotificationGetResponseRulesAction `json:"actions,required"`
	// Timestamp when the rule was created.
	CreatedAt string `json:"createdAt"`
	// A description that can be used to identify the event notification rule after
	// creation.
	Description string `json:"description"`
	// Notifications will be sent only for objects with this prefix.
	Prefix string `json:"prefix"`
	// Rule ID.
	RuleID string `json:"ruleId"`
	// Notifications will be sent only for objects with this suffix.
	Suffix string                                     `json:"suffix"`
	JSON   bucketEventNotificationGetResponseRuleJSON `json:"-"`
}

type BucketEventNotificationGetResponseRulesAction string

type BucketEventNotificationListParams struct {
	// Account ID.
	AccountID param.Field[string] `path:"account_id,required"`
	// Jurisdiction where objects in this bucket are guaranteed to be stored.
	Jurisdiction param.Field[BucketEventNotificationListParamsCfR2Jurisdiction] `header:"cf-r2-jurisdiction"`
}

type BucketEventNotificationListParamsCfR2Jurisdiction string

type BucketEventNotificationListResponse struct {
	// Name of the bucket.
	BucketName string `json:"bucketName"`
	// List of queues associated with the bucket.
	Queues []BucketEventNotificationListResponseQueue `json:"queues"`
	JSON   bucketEventNotificationListResponseJSON    `json:"-"`
}

type BucketEventNotificationListResponseEnvelope struct {
	Errors   []shared.ResponseInfo               `json:"errors,required"`
	Messages []string                            `json:"messages,required"`
	Result   BucketEventNotificationListResponse `json:"result,required"`
	// Whether the API call was successful.
	Success BucketEventNotificationListResponseEnvelopeSuccess `json:"success,required"`
	JSON    bucketEventNotificationListResponseEnvelopeJSON    `json:"-"`
}

type BucketEventNotificationListResponseEnvelopeSuccess bool

type BucketEventNotificationListResponseQueue struct {
	// Queue ID.
	QueueID string `json:"queueId"`
	// Name of the queue.
	QueueName string                                          `json:"queueName"`
	Rules     []BucketEventNotificationListResponseQueuesRule `json:"rules"`
	JSON      bucketEventNotificationListResponseQueueJSON    `json:"-"`
}

type BucketEventNotificationListResponseQueuesRule struct {
	// Array of R2 object actions that will trigger notifications.
	Actions []BucketEventNotificationListResponseQueuesRulesAction `json:"actions,required"`
	// Timestamp when the rule was created.
	CreatedAt string `json:"createdAt"`
	// A description that can be used to identify the event notification rule after
	// creation.
	Description string `json:"description"`
	// Notifications will be sent only for objects with this prefix.
	Prefix string `json:"prefix"`
	// Rule ID.
	RuleID string `json:"ruleId"`
	// Notifications will be sent only for objects with this suffix.
	Suffix string                                            `json:"suffix"`
	JSON   bucketEventNotificationListResponseQueuesRuleJSON `json:"-"`
}

type BucketEventNotificationListResponseQueuesRulesAction string

type BucketEventNotificationService struct {
	Options []option.RequestOption
}

type BucketEventNotificationUpdateParams struct {
	// Account ID.
	AccountID param.Field[string] `path:"account_id,required"`
	// Array of rules to drive notifications.
	Rules param.Field[[]BucketEventNotificationUpdateParamsRule] `json:"rules"`
	// Jurisdiction where objects in this bucket are guaranteed to be stored.
	Jurisdiction param.Field[BucketEventNotificationUpdateParamsCfR2Jurisdiction] `header:"cf-r2-jurisdiction"`
}

type BucketEventNotificationUpdateParamsCfR2Jurisdiction string

type BucketEventNotificationUpdateParamsRule struct {
	// Array of R2 object actions that will trigger notifications.
	Actions param.Field[[]BucketEventNotificationUpdateParamsRulesAction] `json:"actions,required"`
	// A description that can be used to identify the event notification rule after
	// creation.
	Description param.Field[string] `json:"description"`
	// Notifications will be sent only for objects with this prefix.
	Prefix param.Field[string] `json:"prefix"`
	// Notifications will be sent only for objects with this suffix.
	Suffix param.Field[string] `json:"suffix"`
}

type BucketEventNotificationUpdateParamsRulesAction string

type BucketEventNotificationUpdateResponse = interface{}

type BucketEventNotificationUpdateResponseEnvelope struct {
	Errors   []shared.ResponseInfo                 `json:"errors,required"`
	Messages []string                              `json:"messages,required"`
	Result   BucketEventNotificationUpdateResponse `json:"result,required"`
	// Whether the API call was successful.
	Success BucketEventNotificationUpdateResponseEnvelopeSuccess `json:"success,required"`
	JSON    bucketEventNotificationUpdateResponseEnvelopeJSON    `json:"-"`
}

type BucketEventNotificationUpdateResponseEnvelopeSuccess bool

type BucketGetParams struct {
	// Account ID.
	AccountID param.Field[string] `path:"account_id,required"`
	// Jurisdiction where objects in this bucket are guaranteed to be stored.
	Jurisdiction param.Field[BucketGetParamsCfR2Jurisdiction] `header:"cf-r2-jurisdiction"`
}

type BucketGetParamsCfR2Jurisdiction string

type BucketGetResponseEnvelope struct {
	Errors   []shared.ResponseInfo `json:"errors,required"`
	Messages []string              `json:"messages,required"`
	// A single R2 bucket.
	Result Bucket `json:"result,required"`
	// Whether the API call was successful.
	Success BucketGetResponseEnvelopeSuccess `json:"success,required"`
	JSON    bucketGetResponseEnvelopeJSON    `json:"-"`
}

type BucketGetResponseEnvelopeSuccess bool

type BucketJurisdiction string

type BucketLifecycleGetParams struct {
	// Account ID.
	AccountID param.Field[string] `path:"account_id,required"`
	// Jurisdiction where objects in this bucket are guaranteed to be stored.
	Jurisdiction param.Field[BucketLifecycleGetParamsCfR2Jurisdiction] `header:"cf-r2-jurisdiction"`
}

type BucketLifecycleGetParamsCfR2Jurisdiction string

type BucketLifecycleGetResponse struct {
	Rules []BucketLifecycleGetResponseRule `json:"rules"`
	JSON  bucketLifecycleGetResponseJSON   `json:"-"`
}

type BucketLifecycleGetResponseEnvelope struct {
	Errors   []shared.ResponseInfo      `json:"errors,required"`
	Messages []string                   `json:"messages,required"`
	Result   BucketLifecycleGetResponse `json:"result,required"`
	// Whether the API call was successful.
	Success BucketLifecycleGetResponseEnvelopeSuccess `json:"success,required"`
	JSON    bucketLifecycleGetResponseEnvelopeJSON    `json:"-"`
}

type BucketLifecycleGetResponseEnvelopeSuccess bool

type BucketLifecycleGetResponseRule struct {
	// Unique identifier for this rule.
	ID string `json:"id,required"`
	// Conditions that apply to all transitions of this rule.
	Conditions BucketLifecycleGetResponseRulesConditions `json:"conditions,required"`
	// Whether or not this rule is in effect.
	Enabled bool `json:"enabled,required"`
	// Transition to abort ongoing multipart uploads.
	AbortMultipartUploadsTransition BucketLifecycleGetResponseRulesAbortMultipartUploadsTransition `json:"abortMultipartUploadsTransition"`
	// Transition to delete objects.
	DeleteObjectsTransition BucketLifecycleGetResponseRulesDeleteObjectsTransition `json:"deleteObjectsTransition"`
	// Transitions to change the storage class of objects.
	StorageClassTransitions []BucketLifecycleGetResponseRulesStorageClassTransition `json:"storageClassTransitions"`
	JSON                    bucketLifecycleGetResponseRuleJSON                      `json:"-"`
}

type BucketLifecycleGetResponseRulesAbortMultipartUploadsTransition struct {
	// Condition for lifecycle transitions to apply after an object reaches an age in
	// seconds.
	Condition BucketLifecycleGetResponseRulesAbortMultipartUploadsTransitionCondition `json:"condition"`
	JSON      bucketLifecycleGetResponseRulesAbortMultipartUploadsTransitionJSON      `json:"-"`
}

type BucketLifecycleGetResponseRulesAbortMultipartUploadsTransitionCondition struct {
	MaxAge int64                                                                       `json:"maxAge,required"`
	Type   BucketLifecycleGetResponseRulesAbortMultipartUploadsTransitionConditionType `json:"type,required"`
	JSON   bucketLifecycleGetResponseRulesAbortMultipartUploadsTransitionConditionJSON `json:"-"`
}

type BucketLifecycleGetResponseRulesAbortMultipartUploadsTransitionConditionType string

type BucketLifecycleGetResponseRulesConditions struct {
	// Transitions will only apply to objects/uploads in the bucket that start with the
	// given prefix, an empty prefix can be provided to scope rule to all
	// objects/uploads.
	Prefix string                                        `json:"prefix,required"`
	JSON   bucketLifecycleGetResponseRulesConditionsJSON `json:"-"`
}

type BucketLifecycleGetResponseRulesDeleteObjectsTransition struct {
	// Condition for lifecycle transitions to apply after an object reaches an age in
	// seconds.
	Condition BucketLifecycleGetResponseRulesDeleteObjectsTransitionCondition `json:"condition"`
	JSON      bucketLifecycleGetResponseRulesDeleteObjectsTransitionJSON      `json:"-"`
}

type BucketLifecycleGetResponseRulesDeleteObjectsTransitionCondition struct {
	Type   BucketLifecycleGetResponseRulesDeleteObjectsTransitionConditionType `json:"type,required"`
	Date   time.Time                                                           `json:"date" format:"date"`
	MaxAge int64                                                               `json:"maxAge"`
	JSON   bucketLifecycleGetResponseRulesDeleteObjectsTransitionConditionJSON `json:"-"`
	// contains filtered or unexported fields
}

type BucketLifecycleGetResponseRulesDeleteObjectsTransitionConditionR2LifecycleAgeCondition struct {
	MaxAge int64                                                                                      `json:"maxAge,required"`
	Type   BucketLifecycleGetResponseRulesDeleteObjectsTransitionConditionR2LifecycleAgeConditionType `json:"type,required"`
	JSON   bucketLifecycleGetResponseRulesDeleteObjectsTransitionConditionR2LifecycleAgeConditionJSON `json:"-"`
}

type BucketLifecycleGetResponseRulesDeleteObjectsTransitionConditionR2LifecycleAgeConditionType string

type BucketLifecycleGetResponseRulesDeleteObjectsTransitionConditionR2LifecycleDateCondition struct {
	Date time.Time                                                                                   `json:"date,required" format:"date"`
	Type BucketLifecycleGetResponseRulesDeleteObjectsTransitionConditionR2LifecycleDateConditionType `json:"type,required"`
	JSON bucketLifecycleGetResponseRulesDeleteObjectsTransitionConditionR2LifecycleDateConditionJSON `json:"-"`
}

type BucketLifecycleGetResponseRulesDeleteObjectsTransitionConditionR2LifecycleDateConditionType string

type BucketLifecycleGetResponseRulesDeleteObjectsTransitionConditionType string

type BucketLifecycleGetResponseRulesDeleteObjectsTransitionConditionUnion interface {
	// contains filtered or unexported methods
}

type BucketLifecycleGetResponseRulesStorageClassTransition struct {
	// Condition for lifecycle transitions to apply after an object reaches an age in
	// seconds.
	Condition    BucketLifecycleGetResponseRulesStorageClassTransitionsCondition    `json:"condition,required"`
	StorageClass BucketLifecycleGetResponseRulesStorageClassTransitionsStorageClass `json:"storageClass,required"`
	JSON         bucketLifecycleGetResponseRulesStorageClassTransitionJSON          `json:"-"`
}

type BucketLifecycleGetResponseRulesStorageClassTransitionsCondition struct {
	Type   BucketLifecycleGetResponseRulesStorageClassTransitionsConditionType `json:"type,required"`
	Date   time.Time                                                           `json:"date" format:"date"`
	MaxAge int64                                                               `json:"maxAge"`
	JSON   bucketLifecycleGetResponseRulesStorageClassTransitionsConditionJSON `json:"-"`
	// contains filtered or unexported fields
}

type BucketLifecycleGetResponseRulesStorageClassTransitionsConditionR2LifecycleAgeCondition struct {
	MaxAge int64                                                                                      `json:"maxAge,required"`
	Type   BucketLifecycleGetResponseRulesStorageClassTransitionsConditionR2LifecycleAgeConditionType `json:"type,required"`
	JSON   bucketLifecycleGetResponseRulesStorageClassTransitionsConditionR2LifecycleAgeConditionJSON `json:"-"`
}

type BucketLifecycleGetResponseRulesStorageClassTransitionsConditionR2LifecycleAgeConditionType string

type BucketLifecycleGetResponseRulesStorageClassTransitionsConditionR2LifecycleDateCondition struct {
	Date time.Time                                                                                   `json:"date,required" format:"date"`
	Type BucketLifecycleGetResponseRulesStorageClassTransitionsConditionR2LifecycleDateConditionType `json:"type,required"`
	JSON bucketLifecycleGetResponseRulesStorageClassTransitionsConditionR2LifecycleDateConditionJSON `json:"-"`
}

type BucketLifecycleGetResponseRulesStorageClassTransitionsConditionR2LifecycleDateConditionType string

type BucketLifecycleGetResponseRulesStorageClassTransitionsConditionType string

type BucketLifecycleGetResponseRulesStorageClassTransitionsConditionUnion interface {
	// contains filtered or unexported methods
}

type BucketLifecycleGetResponseRulesStorageClassTransitionsStorageClass string

type BucketLifecycleService struct {
	Options []option.RequestOption
}

type BucketLifecycleUpdateParams struct {
	// Account ID.
	AccountID param.Field[string]                            `path:"account_id,required"`
	Rules     param.Field[[]BucketLifecycleUpdateParamsRule] `json:"rules"`
	// Jurisdiction where objects in this bucket are guaranteed to be stored.
	Jurisdiction param.Field[BucketLifecycleUpdateParamsCfR2Jurisdiction] `header:"cf-r2-jurisdiction"`
}

type BucketLifecycleUpdateParamsCfR2Jurisdiction string

type BucketLifecycleUpdateParamsRule struct {
	// Unique identifier for this rule.
	ID param.Field[string] `json:"id,required"`
	// Conditions that apply to all transitions of this rule.
	Conditions param.Field[BucketLifecycleUpdateParamsRulesConditions] `json:"conditions,required"`
	// Whether or not this rule is in effect.
	Enabled param.Field[bool] `json:"enabled,required"`
	// Transition to abort ongoing multipart uploads.
	AbortMultipartUploadsTransition param.Field[BucketLifecycleUpdateParamsRulesAbortMultipartUploadsTransition] `json:"abortMultipartUploadsTransition"`
	// Transition to delete objects.
	DeleteObjectsTransition param.Field[BucketLifecycleUpdateParamsRulesDeleteObjectsTransition] `json:"deleteObjectsTransition"`
	// Transitions to change the storage class of objects.
	StorageClassTransitions param.Field[[]BucketLifecycleUpdateParamsRulesStorageClassTransition] `json:"storageClassTransitions"`
}

type BucketLifecycleUpdateParamsRulesAbortMultipartUploadsTransition struct {
	// Condition for lifecycle transitions to apply after an object reaches an age in
	// seconds.
	Condition param.Field[BucketLifecycleUpdateParamsRulesAbortMultipartUploadsTransitionCondition] `json:"condition"`
}

type BucketLifecycleUpdateParamsRulesAbortMultipartUploadsTransitionCondition struct {
	MaxAge param.Field[int64]                                                                        `json:"maxAge,required"`
	Type   param.Field[BucketLifecycleUpdateParamsRulesAbortMultipartUploadsTransitionConditionType] `json:"type,required"`
}

type BucketLifecycleUpdateParamsRulesAbortMultipartUploadsTransitionConditionType string

type BucketLifecycleUpdateParamsRulesConditions struct {
	// Transitions will only apply to objects/uploads in the bucket that start with the
	// given prefix, an empty prefix can be provided to scope rule to all
	// objects/uploads.
	Prefix param.Field[string] `json:"prefix,required"`
}

type BucketLifecycleUpdateParamsRulesDeleteObjectsTransition struct {
	// Condition for lifecycle transitions to apply after an object reaches an age in
	// seconds.
	Condition param.Field[BucketLifecycleUpdateParamsRulesDeleteObjectsTransitionConditionUnion] `json:"condition"`
}

type BucketLifecycleUpdateParamsRulesDeleteObjectsTransitionCondition struct {
	Type   param.Field[BucketLifecycleUpdateParamsRulesDeleteObjectsTransitionConditionType] `json:"type,required"`
	Date   param.Field[time.Time]                                                            `json:"date" format:"date"`
	MaxAge param.Field[int64]                                                                `json:"maxAge"`
}

type BucketLifecycleUpdateParamsRulesDeleteObjectsTransitionConditionR2LifecycleAgeCondition struct {
	MaxAge param.Field[int64]                                                                                       `json:"maxAge,required"`
	Type   param.Field[BucketLifecycleUpdateParamsRulesDeleteObjectsTransitionConditionR2LifecycleAgeConditionType] `json:"type,required"`
}

type BucketLifecycleUpdateParamsRulesDeleteObjectsTransitionConditionR2LifecycleAgeConditionType string

type BucketLifecycleUpdateParamsRulesDeleteObjectsTransitionConditionR2LifecycleDateCondition struct {
	Date param.Field[time.Time]                                                                                    `json:"date,required" format:"date"`
	Type param.Field[BucketLifecycleUpdateParamsRulesDeleteObjectsTransitionConditionR2LifecycleDateConditionType] `json:"type,required"`
}

type BucketLifecycleUpdateParamsRulesDeleteObjectsTransitionConditionR2LifecycleDateConditionType string

type BucketLifecycleUpdateParamsRulesDeleteObjectsTransitionConditionType string

type BucketLifecycleUpdateParamsRulesDeleteObjectsTransitionConditionUnion interface {
	// contains filtered or unexported methods
}

type BucketLifecycleUpdateParamsRulesStorageClassTransition struct {
	// Condition for lifecycle transitions to apply after an object reaches an age in
	// seconds.
	Condition    param.Field[BucketLifecycleUpdateParamsRulesStorageClassTransitionsConditionUnion] `json:"condition,required"`
	StorageClass param.Field[BucketLifecycleUpdateParamsRulesStorageClassTransitionsStorageClass]   `json:"storageClass,required"`
}

type BucketLifecycleUpdateParamsRulesStorageClassTransitionsCondition struct {
	Type   param.Field[BucketLifecycleUpdateParamsRulesStorageClassTransitionsConditionType] `json:"type,required"`
	Date   param.Field[time.Time]                                                            `json:"date" format:"date"`
	MaxAge param.Field[int64]                                                                `json:"maxAge"`
}

type BucketLifecycleUpdateParamsRulesStorageClassTransitionsConditionR2LifecycleAgeCondition struct {
	MaxAge param.Field[int64]                                                                                       `json:"maxAge,required"`
	Type   param.Field[BucketLifecycleUpdateParamsRulesStorageClassTransitionsConditionR2LifecycleAgeConditionType] `json:"type,required"`
}

type BucketLifecycleUpdateParamsRulesStorageClassTransitionsConditionR2LifecycleAgeConditionType string

type BucketLifecycleUpdateParamsRulesStorageClassTransitionsConditionR2LifecycleDateCondition struct {
	Date param.Field[time.Time]                                                                                    `json:"date,required" format:"date"`
	Type param.Field[BucketLifecycleUpdateParamsRulesStorageClassTransitionsConditionR2LifecycleDateConditionType] `json:"type,required"`
}

type BucketLifecycleUpdateParamsRulesStorageClassTransitionsConditionR2LifecycleDateConditionType string

type BucketLifecycleUpdateParamsRulesStorageClassTransitionsConditionType string

type BucketLifecycleUpdateParamsRulesStorageClassTransitionsConditionUnion interface {
	// contains filtered or unexported methods
}

type BucketLifecycleUpdateParamsRulesStorageClassTransitionsStorageClass string

type BucketLifecycleUpdateResponse = interface{}

type BucketLifecycleUpdateResponseEnvelope struct {
	Errors   []shared.ResponseInfo         `json:"errors,required"`
	Messages []string                      `json:"messages,required"`
	Result   BucketLifecycleUpdateResponse `json:"result,required"`
	// Whether the API call was successful.
	Success BucketLifecycleUpdateResponseEnvelopeSuccess `json:"success,required"`
	JSON    bucketLifecycleUpdateResponseEnvelopeJSON    `json:"-"`
}