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"`
	// 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"`
	// The bucket jurisdiction
	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"`
	// The bucket jurisdiction
	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"`
	// The bucket jurisdiction
	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"`
	// The bucket jurisdiction
	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"`
	// The bucket jurisdiction
	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"`
	// The bucket jurisdiction
	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"`
	// The bucket jurisdiction
	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"`
	// The bucket jurisdiction
	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"`
	// The bucket jurisdiction
	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"`
	// The bucket jurisdiction
	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"`
	// The bucket jurisdiction
	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 BucketEventNotificationConfigurationGetParams struct {
	// Account ID
	AccountID param.Field[string] `path:"account_id,required"`
	// The bucket jurisdiction
	Jurisdiction param.Field[BucketEventNotificationConfigurationGetParamsCfR2Jurisdiction] `header:"cf-r2-jurisdiction"`
}

type BucketEventNotificationConfigurationGetParamsCfR2Jurisdiction string

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

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

type BucketEventNotificationConfigurationGetResponseEnvelopeSuccess bool

type BucketEventNotificationConfigurationGetResponseQueue struct {
	// Queue ID
	QueueID string `json:"queueId"`
	// Name of the queue
	QueueName string                                                      `json:"queueName"`
	Rules     []BucketEventNotificationConfigurationGetResponseQueuesRule `json:"rules"`
	JSON      bucketEventNotificationConfigurationGetResponseQueueJSON    `json:"-"`
}

type BucketEventNotificationConfigurationGetResponseQueuesRule struct {
	// Array of R2 object actions that will trigger notifications
	Actions []BucketEventNotificationConfigurationGetResponseQueuesRulesAction `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   bucketEventNotificationConfigurationGetResponseQueuesRuleJSON `json:"-"`
}

type BucketEventNotificationConfigurationGetResponseQueuesRulesAction string

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

type BucketEventNotificationConfigurationQueueDeleteParamsCfR2Jurisdiction string

type BucketEventNotificationConfigurationQueueDeleteResponse = interface{}

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

type BucketEventNotificationConfigurationQueueDeleteResponseEnvelopeSuccess bool

type BucketEventNotificationConfigurationQueueService struct {
	Options []option.RequestOption
}

type BucketEventNotificationConfigurationQueueUpdateParams struct {
	// Account ID
	AccountID param.Field[string] `path:"account_id,required"`
	// Array of rules to drive notifications
	Rules param.Field[[]BucketEventNotificationConfigurationQueueUpdateParamsRule] `json:"rules"`
	// The bucket jurisdiction
	Jurisdiction param.Field[BucketEventNotificationConfigurationQueueUpdateParamsCfR2Jurisdiction] `header:"cf-r2-jurisdiction"`
}

type BucketEventNotificationConfigurationQueueUpdateParamsCfR2Jurisdiction string

type BucketEventNotificationConfigurationQueueUpdateParamsRule struct {
	// Array of R2 object actions that will trigger notifications
	Actions param.Field[[]BucketEventNotificationConfigurationQueueUpdateParamsRulesAction] `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 BucketEventNotificationConfigurationQueueUpdateParamsRulesAction string

type BucketEventNotificationConfigurationQueueUpdateResponse = interface{}

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

type BucketEventNotificationConfigurationQueueUpdateResponseEnvelopeSuccess bool

type BucketEventNotificationConfigurationService struct {
	Options []option.RequestOption
	Queues  *BucketEventNotificationConfigurationQueueService
}

type BucketEventNotificationService struct {
	Options       []option.RequestOption
	Configuration *BucketEventNotificationConfigurationService
}

type BucketGetParams struct {
	// Account ID
	AccountID param.Field[string] `path:"account_id,required"`
	// The bucket jurisdiction
	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 BucketLifecycleGetParams struct {
	// Account ID
	AccountID param.Field[string] `path:"account_id,required"`
	// The bucket jurisdiction
	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"`
	// The bucket jurisdiction
	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:"-"`
}

type BucketLifecycleUpdateResponseEnvelopeSuccess bool

type BucketListParams struct {
	// Account ID
	AccountID param.Field[string] `path:"account_id,required"`
	// Pagination cursor received during the last List Buckets call. R2 buckets are
	// paginated using cursors instead of page numbers.
	Cursor param.Field[string] `query:"cursor"`
	// Direction to order buckets
	Direction param.Field[BucketListParamsDirection] `query:"direction"`
	// Bucket names to filter by. Only buckets with this phrase in their name will be
	// returned.
	NameContains param.Field[string] `query:"name_contains"`
	// Field to order buckets by
	Order param.Field[BucketListParamsOrder] `query:"order"`
	// Maximum number of buckets to return in a single call
	PerPage param.Field[float64] `query:"per_page"`
	// Bucket name to start searching after. Buckets are ordered lexicographically.
	StartAfter param.Field[string] `query:"start_after"`
	// Lists buckets in the provided jurisdiction
	Jurisdiction param.Field[BucketListParamsCfR2Jurisdiction] `header:"cf-r2-jurisdiction"`
}

type BucketListParamsCfR2Jurisdiction string

type BucketListParamsDirection string

type BucketListParamsOrder string

type BucketListResponse struct {
	Buckets []Bucket               `json:"buckets"`
	JSON    bucketListResponseJSON `json:"-"`
}

type BucketListResponseEnvelope struct {
	Errors   []shared.ResponseInfo `json:"errors,required"`
	Messages []string              `json:"messages,required"`
	Result   BucketListResponse    `json:"result,required"`
	// Whether the API call was successful
	Success    BucketListResponseEnvelopeSuccess    `json:"success,required"`
	ResultInfo BucketListResponseEnvelopeResultInfo `json:"result_info"`
	JSON       bucketListResponseEnvelopeJSON       `json:"-"`
}

type BucketListResponseEnvelopeResultInfo struct {
	// A continuation token that should be used to fetch the next page of results
	Cursor string `json:"cursor"`
	// Maximum number of results on this page
	PerPage float64                                  `json:"per_page"`
	JSON    bucketListResponseEnvelopeResultInfoJSON `json:"-"`
}

type BucketListResponseEnvelopeSuccess bool

type BucketLocation string

type BucketNewParams struct {
	// Account ID
	AccountID param.Field[string] `path:"account_id,required"`
	// Name of the bucket
	Name param.Field[string] `json:"name,required"`
	// Location of the bucket
	LocationHint param.Field[BucketNewParamsLocationHint] `json:"locationHint"`
	// Storage class for newly uploaded objects, unless specified otherwise.
	StorageClass param.Field[BucketNewParamsStorageClass] `json:"storageClass"`
	// Creates the bucket in the provided jurisdiction
	Jurisdiction param.Field[BucketNewParamsCfR2Jurisdiction] `header:"cf-r2-jurisdiction"`
}

type BucketNewParamsCfR2Jurisdiction string

type BucketNewParamsLocationHint string

type BucketNewParamsStorageClass string

type BucketNewResponseEnvelope 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 BucketNewResponseEnvelopeSuccess `json:"success,required"`
	JSON    bucketNewResponseEnvelopeJSON    `json:"-"`
}

type BucketNewResponseEnvelopeSuccess bool

type BucketService struct {
	Options            []option.RequestOption
	Lifecycle          *BucketLifecycleService
	CORS               *BucketCORSService
	Domains            *BucketDomainService
	EventNotifications *BucketEventNotificationService
	Sippy              *BucketSippyService
}

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

type BucketSippyDeleteParamsCfR2Jurisdiction string

type BucketSippyDeleteResponse struct {
	Enabled BucketSippyDeleteResponseEnabled `json:"enabled"`
	JSON    bucketSippyDeleteResponseJSON    `json:"-"`
}

type BucketSippyDeleteResponseEnabled bool

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

type BucketSippyDeleteResponseEnvelopeSuccess bool

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

type BucketSippyGetParamsCfR2Jurisdiction string

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

type BucketSippyGetResponseEnvelopeSuccess bool

type BucketSippyService struct {
	Options []option.RequestOption
}

type BucketSippyUpdateParams struct {
	// Account ID
	AccountID param.Field[string]              `path:"account_id,required"`
	Body      BucketSippyUpdateParamsBodyUnion `json:"body,required"`
	// The bucket jurisdiction
	Jurisdiction param.Field[BucketSippyUpdateParamsCfR2Jurisdiction] `header:"cf-r2-jurisdiction"`
}

type BucketSippyUpdateParamsBody struct {
	Destination param.Field[interface{}] `json:"destination"`
	Source      param.Field[interface{}] `json:"source"`
}

type BucketSippyUpdateParamsBodyR2EnableSippyAws struct {
	// R2 bucket to copy objects to
	Destination param.Field[BucketSippyUpdateParamsBodyR2EnableSippyAwsDestination] `json:"destination"`
	// AWS S3 bucket to copy objects from
	Source param.Field[BucketSippyUpdateParamsBodyR2EnableSippyAwsSource] `json:"source"`
}

type BucketSippyUpdateParamsBodyR2EnableSippyAwsDestination struct {
	// ID of a Cloudflare API token. This is the value labelled "Access Key ID" when
	// creating an API token from the
	// [R2 dashboard](https://dash.cloudflare.com/?to=/:account/r2/api-tokens).
	//
	// Sippy will use this token when writing objects to R2, so it is best to scope
	// this token to the bucket you're enabling Sippy for.
	AccessKeyID param.Field[string]   `json:"accessKeyId"`
	Provider    param.Field[Provider] `json:"provider"`
	// Value of a Cloudflare API token. This is the value labelled "Secret Access Key"
	// when creating an API token from the
	// [R2 dashboard](https://dash.cloudflare.com/?to=/:account/r2/api-tokens).
	//
	// Sippy will use this token when writing objects to R2, so it is best to scope
	// this token to the bucket you're enabling Sippy for.
	SecretAccessKey param.Field[string] `json:"secretAccessKey"`
}

type BucketSippyUpdateParamsBodyR2EnableSippyAwsSource struct {
	// Access Key ID of an IAM credential (ideally scoped to a single S3 bucket)
	AccessKeyID param.Field[string] `json:"accessKeyId"`
	// Name of the AWS S3 bucket
	Bucket   param.Field[string]                                                    `json:"bucket"`
	Provider param.Field[BucketSippyUpdateParamsBodyR2EnableSippyAwsSourceProvider] `json:"provider"`
	// Name of the AWS availability zone
	Region param.Field[string] `json:"region"`
	// Secret Access Key of an IAM credential (ideally scoped to a single S3 bucket)
	SecretAccessKey param.Field[string] `json:"secretAccessKey"`
}

type BucketSippyUpdateParamsBodyR2EnableSippyAwsSourceProvider string

type BucketSippyUpdateParamsBodyR2EnableSippyGcs struct {
	// R2 bucket to copy objects to
	Destination param.Field[BucketSippyUpdateParamsBodyR2EnableSippyGcsDestination] `json:"destination"`
	// GCS bucket to copy objects from
	Source param.Field[BucketSippyUpdateParamsBodyR2EnableSippyGcsSource] `json:"source"`
}

type BucketSippyUpdateParamsBodyR2EnableSippyGcsDestination struct {
	// ID of a Cloudflare API token. This is the value labelled "Access Key ID" when
	// creating an API token from the
	// [R2 dashboard](https://dash.cloudflare.com/?to=/:account/r2/api-tokens).
	//
	// Sippy will use this token when writing objects to R2, so it is best to scope
	// this token to the bucket you're enabling Sippy for.
	AccessKeyID param.Field[string]   `json:"accessKeyId"`
	Provider    param.Field[Provider] `json:"provider"`
	// Value of a Cloudflare API token. This is the value labelled "Secret Access Key"
	// when creating an API token from the
	// [R2 dashboard](https://dash.cloudflare.com/?to=/:account/r2/api-tokens).
	//
	// Sippy will use this token when writing objects to R2, so it is best to scope
	// this token to the bucket you're enabling Sippy for.
	SecretAccessKey param.Field[string] `json:"secretAccessKey"`
}

type BucketSippyUpdateParamsBodyR2EnableSippyGcsSource struct {
	// Name of the GCS bucket
	Bucket param.Field[string] `json:"bucket"`
	// Client email of an IAM credential (ideally scoped to a single GCS bucket)
	ClientEmail param.Field[string] `json:"clientEmail"`
	// Private Key of an IAM credential (ideally scoped to a single GCS bucket)
	PrivateKey param.Field[string]                                                    `json:"privateKey"`
	Provider   param.Field[BucketSippyUpdateParamsBodyR2EnableSippyGcsSourceProvider] `json:"provider"`
}

type BucketSippyUpdateParamsBodyR2EnableSippyGcsSourceProvider string

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

type BucketSippyUpdateParamsCfR2Jurisdiction string

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

type BucketSippyUpdateResponseEnvelopeSuccess bool

type BucketStorageClass string

type CertificateCA = shared.CertificateCA

type CertificateRequestType = shared.CertificateRequestType

type CloudflareTunnel = shared.CloudflareTunnel

type CloudflareTunnelConnection = shared.CloudflareTunnelConnection

type CloudflareTunnelStatus = shared.CloudflareTunnelStatus