/**
 * Cloudflare R2 API
 *
 * Generated from Cloudflare TypeScript SDK.
 * DO NOT EDIT - regenerate with: bun scripts/generate.ts --service r2
 */
import * as Schema from "effect/Schema";
import type * as HttpClient from "effect/unstable/http/HttpClient";
import * as API from "../client/api.ts";
import type { Credentials } from "../credentials.ts";
import { type DefaultErrors } from "../errors.ts";
import type * as Stream from "effect/Stream";
import type * as HttpClientError from "effect/unstable/http/HttpClientError";
declare const BucketAlreadyExists_base: Schema.Class<BucketAlreadyExists, Schema.TaggedStruct<"BucketAlreadyExists", {
    readonly code: Schema.Number;
    readonly message: Schema.String;
}>, import("effect/Cause").YieldableError>;
export declare class BucketAlreadyExists extends BucketAlreadyExists_base {
}
declare const BucketNotFound_base: Schema.Class<BucketNotFound, Schema.TaggedStruct<"BucketNotFound", {
    readonly code: Schema.Number;
    readonly message: Schema.String;
}>, import("effect/Cause").YieldableError>;
export declare class BucketNotFound extends BucketNotFound_base {
}
declare const DomainNotFound_base: Schema.Class<DomainNotFound, Schema.TaggedStruct<"DomainNotFound", {
    readonly code: Schema.Number;
    readonly message: Schema.String;
}>, import("effect/Cause").YieldableError>;
export declare class DomainNotFound extends DomainNotFound_base {
}
declare const EventNotificationConfigNotFound_base: Schema.Class<EventNotificationConfigNotFound, Schema.TaggedStruct<"EventNotificationConfigNotFound", {
    readonly code: Schema.Number;
    readonly message: Schema.String;
}>, import("effect/Cause").YieldableError>;
export declare class EventNotificationConfigNotFound extends EventNotificationConfigNotFound_base {
}
declare const EventNotificationRuleConflict_base: Schema.Class<EventNotificationRuleConflict, Schema.TaggedStruct<"EventNotificationRuleConflict", {
    readonly code: Schema.Number;
    readonly message: Schema.String;
}>, import("effect/Cause").YieldableError>;
export declare class EventNotificationRuleConflict extends EventNotificationRuleConflict_base {
}
declare const InvalidBucketName_base: Schema.Class<InvalidBucketName, Schema.TaggedStruct<"InvalidBucketName", {
    readonly code: Schema.Number;
    readonly message: Schema.String;
}>, import("effect/Cause").YieldableError>;
export declare class InvalidBucketName extends InvalidBucketName_base {
}
declare const InvalidEventNotificationConfig_base: Schema.Class<InvalidEventNotificationConfig, Schema.TaggedStruct<"InvalidEventNotificationConfig", {
    readonly code: Schema.Number;
    readonly message: Schema.String;
}>, import("effect/Cause").YieldableError>;
export declare class InvalidEventNotificationConfig extends InvalidEventNotificationConfig_base {
}
declare const InvalidRoute_base: Schema.Class<InvalidRoute, Schema.TaggedStruct<"InvalidRoute", {
    readonly code: Schema.Number;
    readonly message: Schema.String;
}>, import("effect/Cause").YieldableError>;
export declare class InvalidRoute extends InvalidRoute_base {
}
declare const InvalidUpstreamCredentials_base: Schema.Class<InvalidUpstreamCredentials, Schema.TaggedStruct<"InvalidUpstreamCredentials", {
    readonly code: Schema.Number;
    readonly message: Schema.String;
}>, import("effect/Cause").YieldableError>;
export declare class InvalidUpstreamCredentials extends InvalidUpstreamCredentials_base {
}
declare const NoCorsConfiguration_base: Schema.Class<NoCorsConfiguration, Schema.TaggedStruct<"NoCorsConfiguration", {
    readonly code: Schema.Number;
    readonly message: Schema.String;
}>, import("effect/Cause").YieldableError>;
export declare class NoCorsConfiguration extends NoCorsConfiguration_base {
}
declare const NoEventNotificationConfig_base: Schema.Class<NoEventNotificationConfig, Schema.TaggedStruct<"NoEventNotificationConfig", {
    readonly code: Schema.Number;
    readonly message: Schema.String;
}>, import("effect/Cause").YieldableError>;
export declare class NoEventNotificationConfig extends NoEventNotificationConfig_base {
}
declare const NoRoute_base: Schema.Class<NoRoute, Schema.TaggedStruct<"NoRoute", {
    readonly code: Schema.Number;
    readonly message: Schema.String;
}>, import("effect/Cause").YieldableError>;
export declare class NoRoute extends NoRoute_base {
}
declare const NoSuchBucket_base: Schema.Class<NoSuchBucket, Schema.TaggedStruct<"NoSuchBucket", {
    readonly code: Schema.Number;
    readonly message: Schema.String;
}>, import("effect/Cause").YieldableError>;
export declare class NoSuchBucket extends NoSuchBucket_base {
}
declare const QueueNotFound_base: Schema.Class<QueueNotFound, Schema.TaggedStruct<"QueueNotFound", {
    readonly code: Schema.Number;
    readonly message: Schema.String;
}>, import("effect/Cause").YieldableError>;
export declare class QueueNotFound extends QueueNotFound_base {
}
export interface AbortAllSuperSlurperJobRequest {
    accountId: string;
}
export declare const AbortAllSuperSlurperJobRequest: Schema.Schema<AbortAllSuperSlurperJobRequest>;
export type AbortAllSuperSlurperJobResponse = string;
export declare const AbortAllSuperSlurperJobResponse: Schema.Schema<AbortAllSuperSlurperJobResponse>;
export type AbortAllSuperSlurperJobError = DefaultErrors;
export declare const abortAllSuperSlurperJob: API.OperationMethod<AbortAllSuperSlurperJobRequest, AbortAllSuperSlurperJobResponse, AbortAllSuperSlurperJobError, Credentials | HttpClient.HttpClient>;
export interface GetBucketRequest {
    bucketName: string;
    /** Path param: Account ID. */
    accountId: string;
    /** Header param: Jurisdiction where objects in this bucket are guaranteed to be stored. */
    jurisdiction?: "default" | "eu" | "fedramp";
}
export declare const GetBucketRequest: Schema.Schema<GetBucketRequest>;
export interface GetBucketResponse {
    /** Creation timestamp. */
    creationDate?: string | null;
    /** Jurisdiction where objects in this bucket are guaranteed to be stored. */
    jurisdiction?: "default" | "eu" | "fedramp" | null;
    /** Location of the bucket. */
    location?: "apac" | "eeur" | "enam" | "weur" | "wnam" | "oc" | "APAC" | "EEUR" | "ENAM" | "WEUR" | "WNAM" | "OC" | null;
    /** Name of the bucket. */
    name?: string | null;
    /** Storage class for newly uploaded objects, unless specified otherwise. */
    storageClass?: "Standard" | "InfrequentAccess" | null;
}
export declare const GetBucketResponse: Schema.Schema<GetBucketResponse>;
export type GetBucketError = DefaultErrors | NoSuchBucket | InvalidRoute;
export declare const getBucket: API.OperationMethod<GetBucketRequest, GetBucketResponse, GetBucketError, Credentials | HttpClient.HttpClient>;
export interface ListBucketsRequest {
    /** Path param: Account ID. */
    accountId: string;
    /** Query param: Pagination cursor received during the last List Buckets call. R2 buckets are paginated using cursors instead of page numbers. */
    cursor?: string;
    /** Query param: Direction to order buckets. */
    direction?: "asc" | "desc";
    /** Query param: Bucket names to filter by. Only buckets with this phrase in their name will be returned. */
    nameContains?: string;
    /** Query param: Field to order buckets by. */
    order?: "name";
    /** Query param: Maximum number of buckets to return in a single call. */
    perPage?: number;
    /** Query param: Bucket name to start searching after. Buckets are ordered lexicographically. */
    startAfter?: string;
    /** Header param: Jurisdiction where objects in this bucket are guaranteed to be stored. */
    jurisdiction?: "default" | "eu" | "fedramp";
}
export declare const ListBucketsRequest: Schema.Schema<ListBucketsRequest>;
export interface ListBucketsResponse {
    buckets?: {
        creationDate?: string | null;
        jurisdiction?: "default" | "eu" | "fedramp" | null;
        location?: "apac" | "eeur" | "enam" | "weur" | "wnam" | "oc" | "APAC" | "EEUR" | "ENAM" | "WEUR" | "WNAM" | "OC" | null;
        name?: string | null;
        storageClass?: "Standard" | "InfrequentAccess" | null;
    }[] | null;
}
export declare const ListBucketsResponse: Schema.Schema<ListBucketsResponse>;
export type ListBucketsError = DefaultErrors | InvalidRoute;
export declare const listBuckets: API.OperationMethod<ListBucketsRequest, ListBucketsResponse, ListBucketsError, Credentials | HttpClient.HttpClient>;
export interface CreateBucketRequest {
    /** Path param: Account ID. */
    accountId: string;
    /** Header param: Jurisdiction where objects in this bucket are guaranteed to be stored. */
    jurisdiction?: "default" | "eu" | "fedramp";
    /** Body param: Name of the bucket. */
    name: string;
    /** Body param: Location of the bucket. */
    locationHint?: "apac" | "eeur" | "enam" | "weur" | "wnam" | "oc";
    /** Body param: Storage class for newly uploaded objects, unless specified otherwise. */
    storageClass?: "Standard" | "InfrequentAccess";
}
export declare const CreateBucketRequest: Schema.Schema<CreateBucketRequest>;
export interface CreateBucketResponse {
    /** Creation timestamp. */
    creationDate?: string | null;
    /** Jurisdiction where objects in this bucket are guaranteed to be stored. */
    jurisdiction?: "default" | "eu" | "fedramp" | null;
    /** Location of the bucket. */
    location?: "apac" | "eeur" | "enam" | "weur" | "wnam" | "oc" | "APAC" | "EEUR" | "ENAM" | "WEUR" | "WNAM" | "OC" | null;
    /** Name of the bucket. */
    name?: string | null;
    /** Storage class for newly uploaded objects, unless specified otherwise. */
    storageClass?: "Standard" | "InfrequentAccess" | null;
}
export declare const CreateBucketResponse: Schema.Schema<CreateBucketResponse>;
export type CreateBucketError = DefaultErrors | InvalidBucketName | BucketAlreadyExists | InvalidRoute;
export declare const createBucket: API.OperationMethod<CreateBucketRequest, CreateBucketResponse, CreateBucketError, Credentials | HttpClient.HttpClient>;
export interface PatchBucketRequest {
    bucketName: string;
    /** Path param: Account ID. */
    accountId: string;
    /** Header param: Storage class for newly uploaded objects, unless specified otherwise. */
    storageClass: "Standard" | "InfrequentAccess";
    /** Header param: Jurisdiction where objects in this bucket are guaranteed to be stored. */
    jurisdiction?: "default" | "eu" | "fedramp";
}
export declare const PatchBucketRequest: Schema.Schema<PatchBucketRequest>;
export interface PatchBucketResponse {
    /** Creation timestamp. */
    creationDate?: string | null;
    /** Jurisdiction where objects in this bucket are guaranteed to be stored. */
    jurisdiction?: "default" | "eu" | "fedramp" | null;
    /** Location of the bucket. */
    location?: "apac" | "eeur" | "enam" | "weur" | "wnam" | "oc" | "APAC" | "EEUR" | "ENAM" | "WEUR" | "WNAM" | "OC" | null;
    /** Name of the bucket. */
    name?: string | null;
    /** Storage class for newly uploaded objects, unless specified otherwise. */
    storageClass?: "Standard" | "InfrequentAccess" | null;
}
export declare const PatchBucketResponse: Schema.Schema<PatchBucketResponse>;
export type PatchBucketError = DefaultErrors | NoSuchBucket | InvalidRoute;
export declare const patchBucket: API.OperationMethod<PatchBucketRequest, PatchBucketResponse, PatchBucketError, Credentials | HttpClient.HttpClient>;
export interface DeleteBucketRequest {
    bucketName: string;
    /** Path param: Account ID. */
    accountId: string;
    /** Header param: Jurisdiction where objects in this bucket are guaranteed to be stored. */
    jurisdiction?: "default" | "eu" | "fedramp";
}
export declare const DeleteBucketRequest: Schema.Schema<DeleteBucketRequest>;
export type DeleteBucketResponse = unknown;
export declare const DeleteBucketResponse: Schema.Schema<DeleteBucketResponse>;
export type DeleteBucketError = DefaultErrors | NoSuchBucket | InvalidRoute | NoRoute;
export declare const deleteBucket: API.OperationMethod<DeleteBucketRequest, DeleteBucketResponse, DeleteBucketError, Credentials | HttpClient.HttpClient>;
export interface GetBucketCorsRequest {
    bucketName: string;
    /** Path param: Account ID. */
    accountId: string;
    /** Header param: Jurisdiction where objects in this bucket are guaranteed to be stored. */
    jurisdiction?: "default" | "eu" | "fedramp";
}
export declare const GetBucketCorsRequest: Schema.Schema<GetBucketCorsRequest>;
export interface GetBucketCorsResponse {
    rules?: {
        allowed: {
            methods: ("GET" | "PUT" | "POST" | "DELETE" | "HEAD")[];
            origins: string[];
            headers?: string[] | null;
        };
        id?: string | null;
        exposeHeaders?: string[] | null;
        maxAgeSeconds?: number | null;
    }[] | null;
}
export declare const GetBucketCorsResponse: Schema.Schema<GetBucketCorsResponse>;
export type GetBucketCorsError = DefaultErrors | NoSuchBucket | InvalidRoute | NoCorsConfiguration;
export declare const getBucketCors: API.OperationMethod<GetBucketCorsRequest, GetBucketCorsResponse, GetBucketCorsError, Credentials | HttpClient.HttpClient>;
export interface PutBucketCorsRequest {
    bucketName: string;
    /** Path param: Account ID. */
    accountId: string;
    /** Header param: Jurisdiction where objects in this bucket are guaranteed to be stored. */
    jurisdiction?: "default" | "eu" | "fedramp";
    /** Body param: */
    rules?: {
        allowed: {
            methods: ("GET" | "PUT" | "POST" | "DELETE" | "HEAD")[];
            origins: string[];
            headers?: string[];
        };
        id?: string;
        exposeHeaders?: string[];
        maxAgeSeconds?: number;
    }[];
}
export declare const PutBucketCorsRequest: Schema.Schema<PutBucketCorsRequest>;
export type PutBucketCorsResponse = unknown;
export declare const PutBucketCorsResponse: Schema.Schema<PutBucketCorsResponse>;
export type PutBucketCorsError = DefaultErrors | NoSuchBucket | InvalidRoute;
export declare const putBucketCors: API.OperationMethod<PutBucketCorsRequest, PutBucketCorsResponse, PutBucketCorsError, Credentials | HttpClient.HttpClient>;
export interface DeleteBucketCorsRequest {
    bucketName: string;
    /** Path param: Account ID. */
    accountId: string;
    /** Header param: Jurisdiction where objects in this bucket are guaranteed to be stored. */
    jurisdiction?: "default" | "eu" | "fedramp";
}
export declare const DeleteBucketCorsRequest: Schema.Schema<DeleteBucketCorsRequest>;
export type DeleteBucketCorsResponse = unknown;
export declare const DeleteBucketCorsResponse: Schema.Schema<DeleteBucketCorsResponse>;
export type DeleteBucketCorsError = DefaultErrors | NoSuchBucket | InvalidRoute;
export declare const deleteBucketCors: API.OperationMethod<DeleteBucketCorsRequest, DeleteBucketCorsResponse, DeleteBucketCorsError, Credentials | HttpClient.HttpClient>;
export interface GetBucketDomainCustomRequest {
    bucketName: string;
    domain: string;
    /** Path param: Account ID. */
    accountId: string;
    /** Header param: Jurisdiction where objects in this bucket are guaranteed to be stored. */
    jurisdiction?: "default" | "eu" | "fedramp";
}
export declare const GetBucketDomainCustomRequest: Schema.Schema<GetBucketDomainCustomRequest>;
export interface GetBucketDomainCustomResponse {
    /** Domain name of the custom domain to be added. */
    domain: string;
    /** Whether this bucket is publicly accessible at the specified custom domain. */
    enabled: boolean;
    status: {
        ownership: "pending" | "active" | "deactivated" | "blocked" | "error" | "unknown";
        ssl: "initializing" | "pending" | "active" | "deactivated" | "error" | "unknown";
    };
    /** An allowlist of ciphers for TLS termination. These ciphers must be in the BoringSSL format. */
    ciphers?: string[] | null;
    /** Minimum TLS Version the custom domain will accept for incoming connections. If not set, defaults to 1.0. */
    minTLS?: "1.0" | "1.1" | "1.2" | "1.3" | null;
    /** Zone ID of the custom domain resides in. */
    zoneId?: string | null;
    /** Zone that the custom domain resides in. */
    zoneName?: string | null;
}
export declare const GetBucketDomainCustomResponse: Schema.Schema<GetBucketDomainCustomResponse>;
export type GetBucketDomainCustomError = DefaultErrors | DomainNotFound | NoSuchBucket | InvalidRoute;
export declare const getBucketDomainCustom: API.OperationMethod<GetBucketDomainCustomRequest, GetBucketDomainCustomResponse, GetBucketDomainCustomError, Credentials | HttpClient.HttpClient>;
export interface ListBucketDomainCustomsRequest {
    bucketName: string;
    /** Path param: Account ID. */
    accountId: string;
    /** Header param: Jurisdiction where objects in this bucket are guaranteed to be stored. */
    jurisdiction?: "default" | "eu" | "fedramp";
}
export declare const ListBucketDomainCustomsRequest: Schema.Schema<ListBucketDomainCustomsRequest>;
export interface ListBucketDomainCustomsResponse {
    domains: {
        domain: string;
        enabled: boolean;
        status: {
            ownership: "pending" | "active" | "deactivated" | "blocked" | "error" | "unknown";
            ssl: "initializing" | "pending" | "active" | "deactivated" | "error" | "unknown";
        };
        ciphers?: string[] | null;
        minTLS?: "1.0" | "1.1" | "1.2" | "1.3" | null;
        zoneId?: string | null;
        zoneName?: string | null;
    }[];
}
export declare const ListBucketDomainCustomsResponse: Schema.Schema<ListBucketDomainCustomsResponse>;
export type ListBucketDomainCustomsError = DefaultErrors | NoSuchBucket | InvalidRoute;
export declare const listBucketDomainCustoms: API.OperationMethod<ListBucketDomainCustomsRequest, ListBucketDomainCustomsResponse, ListBucketDomainCustomsError, Credentials | HttpClient.HttpClient>;
export interface CreateBucketDomainCustomRequest {
    bucketName: string;
    /** Path param: Account ID. */
    accountId: string;
    /** Header param: Jurisdiction where objects in this bucket are guaranteed to be stored. */
    jurisdiction?: "default" | "eu" | "fedramp";
    /** Body param: Name of the custom domain to be added. */
    domain: string;
    /** Body param: Whether to enable public bucket access at the custom domain. If undefined, the domain will be enabled. */
    enabled: boolean;
    /** Body param: Zone ID of the custom domain. */
    zoneId: string;
    /** Body param: An allowlist of ciphers for TLS termination. These ciphers must be in the BoringSSL format. */
    ciphers?: string[];
    /** Body param: Minimum TLS Version the custom domain will accept for incoming connections. If not set, defaults to 1.0. */
    minTLS?: "1.0" | "1.1" | "1.2" | "1.3";
}
export declare const CreateBucketDomainCustomRequest: Schema.Schema<CreateBucketDomainCustomRequest>;
export interface CreateBucketDomainCustomResponse {
    /** Domain name of the affected custom domain. */
    domain: string;
    /** Whether this bucket is publicly accessible at the specified custom domain. */
    enabled: boolean;
    /** An allowlist of ciphers for TLS termination. These ciphers must be in the BoringSSL format. */
    ciphers?: string[] | null;
    /** Minimum TLS Version the custom domain will accept for incoming connections. If not set, defaults to 1.0. */
    minTLS?: "1.0" | "1.1" | "1.2" | "1.3" | null;
}
export declare const CreateBucketDomainCustomResponse: Schema.Schema<CreateBucketDomainCustomResponse>;
export type CreateBucketDomainCustomError = DefaultErrors | NoSuchBucket | InvalidBucketName;
export declare const createBucketDomainCustom: API.OperationMethod<CreateBucketDomainCustomRequest, CreateBucketDomainCustomResponse, CreateBucketDomainCustomError, Credentials | HttpClient.HttpClient>;
export interface UpdateBucketDomainCustomRequest {
    bucketName: string;
    domain: string;
    /** Path param: Account ID. */
    accountId: string;
    /** Header param: Jurisdiction where objects in this bucket are guaranteed to be stored. */
    jurisdiction?: "default" | "eu" | "fedramp";
    /** Body param: An allowlist of ciphers for TLS termination. These ciphers must be in the BoringSSL format. */
    ciphers?: string[];
    /** Body param: Whether to enable public bucket access at the specified custom domain. */
    enabled?: boolean;
    /** Body param: Minimum TLS Version the custom domain will accept for incoming connections. If not set, defaults to previous value. */
    minTLS?: "1.0" | "1.1" | "1.2" | "1.3";
}
export declare const UpdateBucketDomainCustomRequest: Schema.Schema<UpdateBucketDomainCustomRequest>;
export interface UpdateBucketDomainCustomResponse {
    /** Domain name of the affected custom domain. */
    domain: string;
    /** An allowlist of ciphers for TLS termination. These ciphers must be in the BoringSSL format. */
    ciphers?: string[] | null;
    /** Whether this bucket is publicly accessible at the specified custom domain. */
    enabled?: boolean | null;
    /** Minimum TLS Version the custom domain will accept for incoming connections. If not set, defaults to 1.0. */
    minTLS?: "1.0" | "1.1" | "1.2" | "1.3" | null;
}
export declare const UpdateBucketDomainCustomResponse: Schema.Schema<UpdateBucketDomainCustomResponse>;
export type UpdateBucketDomainCustomError = DefaultErrors;
export declare const updateBucketDomainCustom: API.OperationMethod<UpdateBucketDomainCustomRequest, UpdateBucketDomainCustomResponse, UpdateBucketDomainCustomError, Credentials | HttpClient.HttpClient>;
export interface DeleteBucketDomainCustomRequest {
    bucketName: string;
    domain: string;
    /** Path param: Account ID. */
    accountId: string;
    /** Header param: Jurisdiction where objects in this bucket are guaranteed to be stored. */
    jurisdiction?: "default" | "eu" | "fedramp";
}
export declare const DeleteBucketDomainCustomRequest: Schema.Schema<DeleteBucketDomainCustomRequest>;
export interface DeleteBucketDomainCustomResponse {
    /** Name of the removed custom domain. */
    domain: string;
}
export declare const DeleteBucketDomainCustomResponse: Schema.Schema<DeleteBucketDomainCustomResponse>;
export type DeleteBucketDomainCustomError = DefaultErrors;
export declare const deleteBucketDomainCustom: API.OperationMethod<DeleteBucketDomainCustomRequest, DeleteBucketDomainCustomResponse, DeleteBucketDomainCustomError, Credentials | HttpClient.HttpClient>;
export interface ListBucketDomainManagedsRequest {
    bucketName: string;
    /** Path param: Account ID. */
    accountId: string;
    /** Header param: Jurisdiction where objects in this bucket are guaranteed to be stored. */
    jurisdiction?: "default" | "eu" | "fedramp";
}
export declare const ListBucketDomainManagedsRequest: Schema.Schema<ListBucketDomainManagedsRequest>;
export interface ListBucketDomainManagedsResponse {
    /** Bucket ID. */
    bucketId: string;
    /** Domain name of the bucket's r2.dev domain. */
    domain: string;
    /** Whether this bucket is publicly accessible at the r2.dev domain. */
    enabled: boolean;
}
export declare const ListBucketDomainManagedsResponse: Schema.Schema<ListBucketDomainManagedsResponse>;
export type ListBucketDomainManagedsError = DefaultErrors | NoSuchBucket | InvalidRoute;
export declare const listBucketDomainManageds: API.OperationMethod<ListBucketDomainManagedsRequest, ListBucketDomainManagedsResponse, ListBucketDomainManagedsError, Credentials | HttpClient.HttpClient>;
export interface PutBucketDomainManagedRequest {
    bucketName: string;
    /** Path param: Account ID. */
    accountId: string;
    /** Header param: Jurisdiction where objects in this bucket are guaranteed to be stored. */
    jurisdiction?: "default" | "eu" | "fedramp";
    /** Body param: Whether to enable public bucket access at the r2.dev domain. */
    enabled: boolean;
}
export declare const PutBucketDomainManagedRequest: Schema.Schema<PutBucketDomainManagedRequest>;
export interface PutBucketDomainManagedResponse {
    /** Bucket ID. */
    bucketId: string;
    /** Domain name of the bucket's r2.dev domain. */
    domain: string;
    /** Whether this bucket is publicly accessible at the r2.dev domain. */
    enabled: boolean;
}
export declare const PutBucketDomainManagedResponse: Schema.Schema<PutBucketDomainManagedResponse>;
export type PutBucketDomainManagedError = DefaultErrors | NoSuchBucket | InvalidRoute;
export declare const putBucketDomainManaged: API.OperationMethod<PutBucketDomainManagedRequest, PutBucketDomainManagedResponse, PutBucketDomainManagedError, Credentials | HttpClient.HttpClient>;
export interface GetBucketEventNotificationRequest {
    bucketName: string;
    queueId: string;
    /** Path param: Account ID. */
    accountId: string;
    /** Header param: The bucket jurisdiction. */
    jurisdiction?: "default" | "eu" | "fedramp";
}
export declare const GetBucketEventNotificationRequest: Schema.Schema<GetBucketEventNotificationRequest>;
export interface GetBucketEventNotificationResponse {
    /** Queue ID. */
    queueId?: string | null;
    /** Name of the queue. */
    queueName?: string | null;
    rules?: {
        actions: ("PutObject" | "CopyObject" | "DeleteObject" | "CompleteMultipartUpload" | "LifecycleDeletion")[];
        createdAt?: string | null;
        description?: string | null;
        prefix?: string | null;
        ruleId?: string | null;
        suffix?: string | null;
    }[] | null;
}
export declare const GetBucketEventNotificationResponse: Schema.Schema<GetBucketEventNotificationResponse>;
export type GetBucketEventNotificationError = DefaultErrors | BucketNotFound | NoEventNotificationConfig | EventNotificationConfigNotFound | QueueNotFound | InvalidRoute;
export declare const getBucketEventNotification: API.OperationMethod<GetBucketEventNotificationRequest, GetBucketEventNotificationResponse, GetBucketEventNotificationError, Credentials | HttpClient.HttpClient>;
export interface ListBucketEventNotificationsRequest {
    bucketName: string;
    /** Path param: Account ID. */
    accountId: string;
    /** Header param: Jurisdiction where objects in this bucket are guaranteed to be stored. */
    jurisdiction?: "default" | "eu" | "fedramp";
}
export declare const ListBucketEventNotificationsRequest: Schema.Schema<ListBucketEventNotificationsRequest>;
export interface ListBucketEventNotificationsResponse {
    /** Name of the bucket. */
    bucketName?: string | null;
    /** List of queues associated with the bucket. */
    queues?: {
        queueId?: string | null;
        queueName?: string | null;
        rules?: {
            actions: ("PutObject" | "CopyObject" | "DeleteObject" | "CompleteMultipartUpload" | "LifecycleDeletion")[];
            createdAt?: string | null;
            description?: string | null;
            prefix?: string | null;
            ruleId?: string | null;
            suffix?: string | null;
        }[] | null;
    }[] | null;
}
export declare const ListBucketEventNotificationsResponse: Schema.Schema<ListBucketEventNotificationsResponse>;
export type ListBucketEventNotificationsError = DefaultErrors | NoSuchBucket | InvalidRoute | NoEventNotificationConfig | BucketNotFound;
export declare const listBucketEventNotifications: API.OperationMethod<ListBucketEventNotificationsRequest, ListBucketEventNotificationsResponse, ListBucketEventNotificationsError, Credentials | HttpClient.HttpClient>;
export interface PutBucketEventNotificationRequest {
    bucketName: string;
    queueId: string;
    /** Path param: Account ID. */
    accountId: string;
    /** Header param: Jurisdiction where objects in this bucket are guaranteed to be stored. */
    jurisdiction?: "default" | "eu" | "fedramp";
    /** Body param: Array of rules to drive notifications. */
    rules: {
        actions: ("PutObject" | "CopyObject" | "DeleteObject" | "CompleteMultipartUpload" | "LifecycleDeletion")[];
        description?: string;
        prefix?: string;
        suffix?: string;
    }[];
}
export declare const PutBucketEventNotificationRequest: Schema.Schema<PutBucketEventNotificationRequest>;
export type PutBucketEventNotificationResponse = unknown;
export declare const PutBucketEventNotificationResponse: Schema.Schema<PutBucketEventNotificationResponse>;
export type PutBucketEventNotificationError = DefaultErrors | BucketNotFound | InvalidEventNotificationConfig | EventNotificationRuleConflict | QueueNotFound | InvalidRoute;
export declare const putBucketEventNotification: API.OperationMethod<PutBucketEventNotificationRequest, PutBucketEventNotificationResponse, PutBucketEventNotificationError, Credentials | HttpClient.HttpClient>;
export interface DeleteBucketEventNotificationRequest {
    bucketName: string;
    queueId: string;
    /** Path param: Account ID. */
    accountId: string;
    /** Header param: Jurisdiction where objects in this bucket are guaranteed to be stored. */
    jurisdiction?: "default" | "eu" | "fedramp";
}
export declare const DeleteBucketEventNotificationRequest: Schema.Schema<DeleteBucketEventNotificationRequest>;
export type DeleteBucketEventNotificationResponse = unknown;
export declare const DeleteBucketEventNotificationResponse: Schema.Schema<DeleteBucketEventNotificationResponse>;
export type DeleteBucketEventNotificationError = DefaultErrors | BucketNotFound | EventNotificationConfigNotFound | QueueNotFound | InvalidRoute;
export declare const deleteBucketEventNotification: API.OperationMethod<DeleteBucketEventNotificationRequest, DeleteBucketEventNotificationResponse, DeleteBucketEventNotificationError, Credentials | HttpClient.HttpClient>;
export interface GetBucketLifecycleRequest {
    bucketName: string;
    /** Path param: Account ID. */
    accountId: string;
    /** Header param: Jurisdiction where objects in this bucket are guaranteed to be stored. */
    jurisdiction?: "default" | "eu" | "fedramp";
}
export declare const GetBucketLifecycleRequest: Schema.Schema<GetBucketLifecycleRequest>;
export interface GetBucketLifecycleResponse {
    rules?: {
        id: string;
        conditions: {
            prefix?: string | null;
        };
        enabled: boolean;
        abortMultipartUploadsTransition?: {
            condition?: {
                maxAge: number;
                type: "Age";
            } | null;
        } | null;
        deleteObjectsTransition?: {
            condition?: {
                maxAge: number;
                type: "Age";
            } | {
                date: string;
                type: "Date";
            } | null;
        } | null;
        storageClassTransitions?: {
            condition: {
                maxAge: number;
                type: "Age";
            } | {
                date: string;
                type: "Date";
            };
            storageClass: "InfrequentAccess";
        }[] | null;
    }[] | null;
}
export declare const GetBucketLifecycleResponse: Schema.Schema<GetBucketLifecycleResponse>;
export type GetBucketLifecycleError = DefaultErrors | NoSuchBucket | InvalidRoute;
export declare const getBucketLifecycle: API.OperationMethod<GetBucketLifecycleRequest, GetBucketLifecycleResponse, GetBucketLifecycleError, Credentials | HttpClient.HttpClient>;
export interface PutBucketLifecycleRequest {
    bucketName: string;
    /** Path param: Account ID. */
    accountId: string;
    /** Header param: Jurisdiction where objects in this bucket are guaranteed to be stored. */
    jurisdiction?: "default" | "eu" | "fedramp";
    /** Body param: */
    rules?: {
        id: string;
        conditions: {
            prefix: string;
        };
        enabled: boolean;
        abortMultipartUploadsTransition?: {
            condition?: {
                maxAge: number;
                type: "Age";
            };
        };
        deleteObjectsTransition?: {
            condition?: {
                maxAge: number;
                type: "Age";
            } | {
                date: string;
                type: "Date";
            };
        };
        storageClassTransitions?: {
            condition: {
                maxAge: number;
                type: "Age";
            } | {
                date: string;
                type: "Date";
            };
            storageClass: "InfrequentAccess";
        }[];
    }[];
}
export declare const PutBucketLifecycleRequest: Schema.Schema<PutBucketLifecycleRequest>;
export type PutBucketLifecycleResponse = unknown;
export declare const PutBucketLifecycleResponse: Schema.Schema<PutBucketLifecycleResponse>;
export type PutBucketLifecycleError = DefaultErrors | NoSuchBucket | InvalidRoute;
export declare const putBucketLifecycle: API.OperationMethod<PutBucketLifecycleRequest, PutBucketLifecycleResponse, PutBucketLifecycleError, Credentials | HttpClient.HttpClient>;
export interface GetBucketLockRequest {
    bucketName: string;
    /** Path param: Account ID. */
    accountId: string;
    /** Header param: Jurisdiction where objects in this bucket are guaranteed to be stored. */
    jurisdiction?: "default" | "eu" | "fedramp";
}
export declare const GetBucketLockRequest: Schema.Schema<GetBucketLockRequest>;
export interface GetBucketLockResponse {
    rules?: {
        id: string;
        condition: {
            maxAgeSeconds: number;
            type: "Age";
        } | {
            date: string;
            type: "Date";
        } | {
            type: "Indefinite";
        };
        enabled: boolean;
        prefix?: string | null;
    }[] | null;
}
export declare const GetBucketLockResponse: Schema.Schema<GetBucketLockResponse>;
export type GetBucketLockError = DefaultErrors | NoSuchBucket | InvalidRoute;
export declare const getBucketLock: API.OperationMethod<GetBucketLockRequest, GetBucketLockResponse, GetBucketLockError, Credentials | HttpClient.HttpClient>;
export interface PutBucketLockRequest {
    bucketName: string;
    /** Path param: Account ID. */
    accountId: string;
    /** Header param: Jurisdiction where objects in this bucket are guaranteed to be stored. */
    jurisdiction?: "default" | "eu" | "fedramp";
    /** Body param: */
    rules?: {
        id: string;
        condition: {
            maxAgeSeconds: number;
            type: "Age";
        } | {
            date: string;
            type: "Date";
        } | {
            type: "Indefinite";
        };
        enabled: boolean;
        prefix?: string;
    }[];
}
export declare const PutBucketLockRequest: Schema.Schema<PutBucketLockRequest>;
export type PutBucketLockResponse = unknown;
export declare const PutBucketLockResponse: Schema.Schema<PutBucketLockResponse>;
export type PutBucketLockError = DefaultErrors | NoSuchBucket | InvalidRoute;
export declare const putBucketLock: API.OperationMethod<PutBucketLockRequest, PutBucketLockResponse, PutBucketLockError, Credentials | HttpClient.HttpClient>;
export interface ListBucketMetricsRequest {
    /** Account ID. */
    accountId: string;
}
export declare const ListBucketMetricsRequest: Schema.Schema<ListBucketMetricsRequest>;
export interface ListBucketMetricsResponse {
    /** Metrics based on what state they are in(uploaded or published). */
    infrequentAccess?: {
        published?: {
            metadataSize?: number | null;
            objects?: number | null;
            payloadSize?: number | null;
        } | null;
        uploaded?: {
            metadataSize?: number | null;
            objects?: number | null;
            payloadSize?: number | null;
        } | null;
    } | null;
    /** Metrics based on what state they are in(uploaded or published). */
    standard?: {
        published?: {
            metadataSize?: number | null;
            objects?: number | null;
            payloadSize?: number | null;
        } | null;
        uploaded?: {
            metadataSize?: number | null;
            objects?: number | null;
            payloadSize?: number | null;
        } | null;
    } | null;
}
export declare const ListBucketMetricsResponse: Schema.Schema<ListBucketMetricsResponse>;
export type ListBucketMetricsError = DefaultErrors | InvalidRoute;
export declare const listBucketMetrics: API.OperationMethod<ListBucketMetricsRequest, ListBucketMetricsResponse, ListBucketMetricsError, Credentials | HttpClient.HttpClient>;
export interface GetBucketSippyRequest {
    bucketName: string;
    /** Path param: Account ID. */
    accountId: string;
    /** Header param: Jurisdiction where objects in this bucket are guaranteed to be stored. */
    jurisdiction?: "default" | "eu" | "fedramp";
}
export declare const GetBucketSippyRequest: Schema.Schema<GetBucketSippyRequest>;
export interface GetBucketSippyResponse {
    /** Details about the configured destination bucket. */
    destination?: {
        accessKeyId?: string | null;
        account?: string | null;
        bucket?: string | null;
        provider?: "r2" | null;
    } | null;
    /** State of Sippy for this bucket. */
    enabled?: boolean | null;
    /** Details about the configured source bucket. */
    source?: {
        bucket?: string | null;
        bucketUrl?: string | null;
        provider?: "aws" | "gcs" | "s3" | null;
        region?: string | null;
    } | null;
}
export declare const GetBucketSippyResponse: Schema.Schema<GetBucketSippyResponse>;
export type GetBucketSippyError = DefaultErrors | NoSuchBucket | InvalidRoute;
export declare const getBucketSippy: API.OperationMethod<GetBucketSippyRequest, GetBucketSippyResponse, GetBucketSippyError, Credentials | HttpClient.HttpClient>;
export interface PutBucketSippyRequest {
    bucketName: string;
    /** Path param: Account ID. */
    accountId: string;
    /** Header param: Jurisdiction where objects in this bucket are guaranteed to be stored. */
    jurisdiction?: "default" | "eu" | "fedramp";
    /** Body param: R2 bucket to copy objects to. */
    destination?: {
        accessKeyId?: string;
        provider?: "r2";
        secretAccessKey?: string;
    };
    /** Body param: AWS S3 bucket to copy objects from. */
    source?: {
        accessKeyId?: string;
        bucket?: string;
        provider?: "aws";
        region?: string;
        secretAccessKey?: string;
    };
}
export declare const PutBucketSippyRequest: Schema.Schema<PutBucketSippyRequest>;
export interface PutBucketSippyResponse {
    /** Details about the configured destination bucket. */
    destination?: {
        accessKeyId?: string | null;
        account?: string | null;
        bucket?: string | null;
        provider?: "r2" | null;
    } | null;
    /** State of Sippy for this bucket. */
    enabled?: boolean | null;
    /** Details about the configured source bucket. */
    source?: {
        bucket?: string | null;
        bucketUrl?: string | null;
        provider?: "aws" | "gcs" | "s3" | null;
        region?: string | null;
    } | null;
}
export declare const PutBucketSippyResponse: Schema.Schema<PutBucketSippyResponse>;
export type PutBucketSippyError = DefaultErrors | InvalidUpstreamCredentials | InvalidRoute;
export declare const putBucketSippy: API.OperationMethod<PutBucketSippyRequest, PutBucketSippyResponse, PutBucketSippyError, Credentials | HttpClient.HttpClient>;
export interface DeleteBucketSippyRequest {
    bucketName: string;
    /** Path param: Account ID. */
    accountId: string;
    /** Header param: Jurisdiction where objects in this bucket are guaranteed to be stored. */
    jurisdiction?: "default" | "eu" | "fedramp";
}
export declare const DeleteBucketSippyRequest: Schema.Schema<DeleteBucketSippyRequest>;
export interface DeleteBucketSippyResponse {
    enabled?: false | null;
}
export declare const DeleteBucketSippyResponse: Schema.Schema<DeleteBucketSippyResponse>;
export type DeleteBucketSippyError = DefaultErrors | NoSuchBucket | InvalidRoute;
export declare const deleteBucketSippy: API.OperationMethod<DeleteBucketSippyRequest, DeleteBucketSippyResponse, DeleteBucketSippyError, Credentials | HttpClient.HttpClient>;
export interface GetObjectRequest {
    /** Name of the R2 bucket. */
    bucketName: string;
    /** Key (name) of the object. */
    objectName: string;
    /** Account ID. */
    accountId: string;
    /** Jurisdiction where objects in this bucket are guaranteed to be stored. */
    cfR2Jurisdiction?: "default" | "eu" | "fedramp";
}
export declare const GetObjectRequest: Schema.Schema<GetObjectRequest>;
export interface GetObjectResponse {
    /** Raw object body as an Effect Stream. */
    body: Stream.Stream<Uint8Array, HttpClientError.HttpClientError>;
    /** Entity tag of the object (raw hex digest). */
    etag?: string;
    /** MIME type of the object. */
    contentType?: string;
    /** Object size in bytes. */
    contentLength?: number;
    /** Content encoding of the object (e.g. `gzip`). */
    contentEncoding?: string;
    /** Content disposition header for the object. */
    contentDisposition?: string;
    /** Content language of the object. */
    contentLanguage?: string;
    /** Byte range returned (set when the request used `Range`). */
    contentRange?: string;
    /** Cache-Control directives associated with the object. */
    cacheControl?: string;
    /** Expiration date of the object. */
    expires?: string;
    /** When the object was last modified (RFC 7231 date). */
    lastModified?: string;
    /** Storage class of the object (`Standard` or `InfrequentAccess`). */
    cfR2StorageClass?: "Standard" | "InfrequentAccess";
}
export declare const GetObjectResponse: Schema.Schema<GetObjectResponse>;
export type GetObjectError = DefaultErrors | NoSuchBucket | InvalidRoute | NoRoute;
export declare const getObject: API.OperationMethod<GetObjectRequest, GetObjectResponse, GetObjectError, Credentials | HttpClient.HttpClient>;
export interface ListObjectsRequest {
    /** Name of the R2 bucket. */
    bucketName: string;
    /** Account ID. */
    accountId: string;
    /** Maximum number of objects to return per page (1-1000). */
    perPage?: number;
    /** Restrict results to keys beginning with this prefix. */
    prefix?: string;
    /** Single character used to group keys. */
    delimiter?: string;
    /** Pagination cursor returned by a previous List Objects call. */
    cursor?: string;
    /** Returns keys lexicographically after this key. */
    startAfter?: string;
    /** Jurisdiction where objects in this bucket are guaranteed to be stored. */
    cfR2Jurisdiction?: "default" | "eu" | "fedramp";
}
export declare const ListObjectsRequest: Schema.Schema<ListObjectsRequest>;
export interface ListObjectsResponse {
    result: {
        key?: string | null;
        size?: number | null;
        etag?: string | null;
        lastModified?: string | null;
        storageClass?: "Standard" | "InfrequentAccess" | null;
        ssec?: boolean | null;
        customMetadata?: unknown | null;
        httpMetadata?: unknown | null;
    }[];
    resultInfo?: {
        count?: number | null;
        cursor?: string | null;
        perPage?: number | null;
    } | null;
}
export declare const ListObjectsResponse: Schema.Schema<ListObjectsResponse>;
export type ListObjectsError = DefaultErrors | NoSuchBucket | InvalidRoute | NoRoute;
export declare const listObjects: API.PaginatedOperationMethod<ListObjectsRequest, ListObjectsResponse, ListObjectsError, Credentials | HttpClient.HttpClient>;
export interface PutObjectRequest {
    /** Name of the R2 bucket. */
    bucketName: string;
    /** Key (name) of the object. */
    objectName: string;
    /** Account ID. */
    accountId: string;
    /** Jurisdiction where objects in this bucket are guaranteed to be stored. */
    cfR2Jurisdiction?: "default" | "eu" | "fedramp";
    /** MIME type of the object. */
    contentType?: string;
    /** Content disposition of the object. */
    contentDisposition?: string;
    /** Content encoding of the object. */
    contentEncoding?: string;
    /** Content language of the object. */
    contentLanguage?: string;
    /** Content length of the object in bytes. */
    contentLength?: string;
    /** Cache control directives for the object. */
    cacheControl?: string;
    /** Expiration date of the object. */
    expires?: string;
    /** Storage class for the object. */
    cfR2StorageClass?: "Standard" | "InfrequentAccess";
    body: Blob | Uint8Array | ArrayBuffer | string;
}
export declare const PutObjectRequest: Schema.Schema<PutObjectRequest>;
export type PutObjectResponse = unknown;
export declare const PutObjectResponse: Schema.Schema<PutObjectResponse>;
export type PutObjectError = DefaultErrors | NoSuchBucket | InvalidRoute | NoRoute;
export declare const putObject: API.OperationMethod<PutObjectRequest, PutObjectResponse, PutObjectError, Credentials | HttpClient.HttpClient>;
export interface DeleteObjectsRequest {
    /** Name of the R2 bucket. */
    bucketName: string;
    /** Account ID. */
    accountId: string;
    /** When set, switches to "delete by prefix" mode and asynchronously deletes every object whose key begins with the given prefix. The response is a prefix-delete job descriptor instead of a per-key list.  */
    prefix?: string;
    /** Jurisdiction where objects in this bucket are guaranteed to be stored. */
    cfR2Jurisdiction?: "default" | "eu" | "fedramp";
    body?: string[];
}
export declare const DeleteObjectsRequest: Schema.Schema<DeleteObjectsRequest>;
export type DeleteObjectsResponse = {
    key?: string | null;
}[] | {
    id?: string | null;
    jobType?: "prefixDelete" | null;
    status?: "ENQUEUED" | "RUNNING" | "COMPLETED" | "FAILED" | "CANCELLED" | null;
    startTime?: string | null;
    endTime?: string | null;
    prefixDelete?: {
        prefix?: string | null;
        deletedObjects?: number | null;
        isBucketClear?: boolean | null;
    } | null;
};
export declare const DeleteObjectsResponse: Schema.Schema<DeleteObjectsResponse>;
export type DeleteObjectsError = DefaultErrors | NoSuchBucket | InvalidRoute | NoRoute;
export declare const deleteObjects: API.OperationMethod<DeleteObjectsRequest, DeleteObjectsResponse, DeleteObjectsError, Credentials | HttpClient.HttpClient>;
export interface DeleteObjectRequest {
    /** Name of the R2 bucket. */
    bucketName: string;
    /** Key (name) of the object. */
    objectName: string;
    /** Account ID. */
    accountId: string;
    /** Jurisdiction where objects in this bucket are guaranteed to be stored. */
    cfR2Jurisdiction?: "default" | "eu" | "fedramp";
}
export declare const DeleteObjectRequest: Schema.Schema<DeleteObjectRequest>;
export type DeleteObjectResponse = unknown;
export declare const DeleteObjectResponse: Schema.Schema<DeleteObjectResponse>;
export type DeleteObjectError = DefaultErrors | NoSuchBucket | InvalidRoute | NoRoute;
export declare const deleteObject: API.OperationMethod<DeleteObjectRequest, DeleteObjectResponse, DeleteObjectError, Credentials | HttpClient.HttpClient>;
export interface SourceSuperSlurperConnectivityPrecheckRequest {
    /** Path param: */
    accountId: string;
    /** Body param: */
    bucket: string;
    /** Body param: */
    secret: {
        accessKeyId: string;
        secretAccessKey: string;
    };
    /** Body param: */
    vendor: "s3";
    /** Body param: */
    endpoint?: string | null;
    /** Body param: */
    pathPrefix?: string | null;
    /** Body param: */
    region?: string | null;
}
export declare const SourceSuperSlurperConnectivityPrecheckRequest: Schema.Schema<SourceSuperSlurperConnectivityPrecheckRequest>;
export interface SourceSuperSlurperConnectivityPrecheckResponse {
    connectivityStatus?: "success" | "error" | null;
}
export declare const SourceSuperSlurperConnectivityPrecheckResponse: Schema.Schema<SourceSuperSlurperConnectivityPrecheckResponse>;
export type SourceSuperSlurperConnectivityPrecheckError = DefaultErrors;
export declare const sourceSuperSlurperConnectivityPrecheck: API.OperationMethod<SourceSuperSlurperConnectivityPrecheckRequest, SourceSuperSlurperConnectivityPrecheckResponse, SourceSuperSlurperConnectivityPrecheckError, Credentials | HttpClient.HttpClient>;
export interface TargetSuperSlurperConnectivityPrecheckRequest {
    /** Path param: */
    accountId: string;
    /** Body param: */
    bucket: string;
    /** Body param: */
    secret: {
        accessKeyId: string;
        secretAccessKey: string;
    };
    /** Body param: */
    vendor: "r2";
    /** Body param: */
    jurisdiction?: "default" | "eu" | "fedramp";
}
export declare const TargetSuperSlurperConnectivityPrecheckRequest: Schema.Schema<TargetSuperSlurperConnectivityPrecheckRequest>;
export interface TargetSuperSlurperConnectivityPrecheckResponse {
    connectivityStatus?: "success" | "error" | null;
}
export declare const TargetSuperSlurperConnectivityPrecheckResponse: Schema.Schema<TargetSuperSlurperConnectivityPrecheckResponse>;
export type TargetSuperSlurperConnectivityPrecheckError = DefaultErrors;
export declare const targetSuperSlurperConnectivityPrecheck: API.OperationMethod<TargetSuperSlurperConnectivityPrecheckRequest, TargetSuperSlurperConnectivityPrecheckResponse, TargetSuperSlurperConnectivityPrecheckError, Credentials | HttpClient.HttpClient>;
export interface GetSuperSlurperJobRequest {
    jobId: string;
    accountId: string;
}
export declare const GetSuperSlurperJobRequest: Schema.Schema<GetSuperSlurperJobRequest>;
export interface GetSuperSlurperJobResponse {
    id?: string | null;
    createdAt?: string | null;
    finishedAt?: string | null;
    overwrite?: boolean | null;
    source?: {
        bucket?: string | null;
        endpoint?: string | null;
        keys?: string[] | null;
        pathPrefix?: string | null;
        vendor?: "s3" | null;
    } | {
        bucket?: string | null;
        keys?: string[] | null;
        pathPrefix?: string | null;
        vendor?: "gcs" | null;
    } | {
        bucket?: string | null;
        jurisdiction?: "default" | "eu" | "fedramp" | null;
        keys?: string[] | null;
        pathPrefix?: string | null;
        vendor?: "r2" | null;
    } | null;
    status?: "running" | "paused" | "aborted" | "completed" | null;
    target?: {
        bucket?: string | null;
        jurisdiction?: "default" | "eu" | "fedramp" | null;
        vendor?: "r2" | null;
    } | null;
}
export declare const GetSuperSlurperJobResponse: Schema.Schema<GetSuperSlurperJobResponse>;
export type GetSuperSlurperJobError = DefaultErrors;
export declare const getSuperSlurperJob: API.OperationMethod<GetSuperSlurperJobRequest, GetSuperSlurperJobResponse, GetSuperSlurperJobError, Credentials | HttpClient.HttpClient>;
export interface ListSuperSlurperJobsRequest {
    /** Path param: */
    accountId: string;
    /** Query param: */
    limit?: number;
    /** Query param: */
    offset?: number;
}
export declare const ListSuperSlurperJobsRequest: Schema.Schema<ListSuperSlurperJobsRequest>;
export interface ListSuperSlurperJobsResponse {
    result: {
        id?: string | null;
        createdAt?: string | null;
        finishedAt?: string | null;
        overwrite?: boolean | null;
        source?: {
            bucket?: string | null;
            endpoint?: string | null;
            keys?: string[] | null;
            pathPrefix?: string | null;
            vendor?: "s3" | null;
        } | {
            bucket?: string | null;
            keys?: string[] | null;
            pathPrefix?: string | null;
            vendor?: "gcs" | null;
        } | {
            bucket?: string | null;
            jurisdiction?: "default" | "eu" | "fedramp" | null;
            keys?: string[] | null;
            pathPrefix?: string | null;
            vendor?: "r2" | null;
        } | null;
        status?: "running" | "paused" | "aborted" | "completed" | null;
        target?: {
            bucket?: string | null;
            jurisdiction?: "default" | "eu" | "fedramp" | null;
            vendor?: "r2" | null;
        } | null;
    }[];
}
export declare const ListSuperSlurperJobsResponse: Schema.Schema<ListSuperSlurperJobsResponse>;
export type ListSuperSlurperJobsError = DefaultErrors;
export declare const listSuperSlurperJobs: API.PaginatedOperationMethod<ListSuperSlurperJobsRequest, ListSuperSlurperJobsResponse, ListSuperSlurperJobsError, Credentials | HttpClient.HttpClient>;
export interface CreateSuperSlurperJobRequest {
    /** Path param: */
    accountId: string;
    /** Body param: */
    overwrite?: boolean;
    /** Body param: */
    source?: {
        bucket: string;
        secret: {
            accessKeyId: string;
            secretAccessKey: string;
        };
        vendor: "s3";
        endpoint?: string | null;
        pathPrefix?: string | null;
        region?: string | null;
    } | {
        bucket: string;
        secret: {
            clientEmail: string;
            privateKey: string;
        };
        vendor: "gcs";
        pathPrefix?: string | null;
    } | {
        bucket: string;
        secret: {
            accessKeyId: string;
            secretAccessKey: string;
        };
        vendor: "r2";
        jurisdiction?: "default" | "eu" | "fedramp";
        pathPrefix?: string | null;
    };
    /** Body param: */
    target?: {
        bucket: string;
        secret: {
            accessKeyId: string;
            secretAccessKey: string;
        };
        vendor: "r2";
        jurisdiction?: "default" | "eu" | "fedramp";
    };
}
export declare const CreateSuperSlurperJobRequest: Schema.Schema<CreateSuperSlurperJobRequest>;
export interface CreateSuperSlurperJobResponse {
    id?: string | null;
}
export declare const CreateSuperSlurperJobResponse: Schema.Schema<CreateSuperSlurperJobResponse>;
export type CreateSuperSlurperJobError = DefaultErrors;
export declare const createSuperSlurperJob: API.OperationMethod<CreateSuperSlurperJobRequest, CreateSuperSlurperJobResponse, CreateSuperSlurperJobError, Credentials | HttpClient.HttpClient>;
export interface AbortSuperSlurperJobRequest {
    jobId: string;
    accountId: string;
}
export declare const AbortSuperSlurperJobRequest: Schema.Schema<AbortSuperSlurperJobRequest>;
export type AbortSuperSlurperJobResponse = string;
export declare const AbortSuperSlurperJobResponse: Schema.Schema<AbortSuperSlurperJobResponse>;
export type AbortSuperSlurperJobError = DefaultErrors;
export declare const abortSuperSlurperJob: API.OperationMethod<AbortSuperSlurperJobRequest, AbortSuperSlurperJobResponse, AbortSuperSlurperJobError, Credentials | HttpClient.HttpClient>;
export interface PauseSuperSlurperJobRequest {
    jobId: string;
    accountId: string;
}
export declare const PauseSuperSlurperJobRequest: Schema.Schema<PauseSuperSlurperJobRequest>;
export type PauseSuperSlurperJobResponse = string;
export declare const PauseSuperSlurperJobResponse: Schema.Schema<PauseSuperSlurperJobResponse>;
export type PauseSuperSlurperJobError = DefaultErrors;
export declare const pauseSuperSlurperJob: API.OperationMethod<PauseSuperSlurperJobRequest, PauseSuperSlurperJobResponse, PauseSuperSlurperJobError, Credentials | HttpClient.HttpClient>;
export interface ProgressSuperSlurperJobRequest {
    jobId: string;
    accountId: string;
}
export declare const ProgressSuperSlurperJobRequest: Schema.Schema<ProgressSuperSlurperJobRequest>;
export interface ProgressSuperSlurperJobResponse {
    id?: string | null;
    createdAt?: string | null;
    failedObjects?: number | null;
    objects?: number | null;
    skippedObjects?: number | null;
    status?: "running" | "paused" | "aborted" | "completed" | null;
    transferredObjects?: number | null;
}
export declare const ProgressSuperSlurperJobResponse: Schema.Schema<ProgressSuperSlurperJobResponse>;
export type ProgressSuperSlurperJobError = DefaultErrors;
export declare const progressSuperSlurperJob: API.OperationMethod<ProgressSuperSlurperJobRequest, ProgressSuperSlurperJobResponse, ProgressSuperSlurperJobError, Credentials | HttpClient.HttpClient>;
export interface ResumeSuperSlurperJobRequest {
    jobId: string;
    accountId: string;
}
export declare const ResumeSuperSlurperJobRequest: Schema.Schema<ResumeSuperSlurperJobRequest>;
export type ResumeSuperSlurperJobResponse = string;
export declare const ResumeSuperSlurperJobResponse: Schema.Schema<ResumeSuperSlurperJobResponse>;
export type ResumeSuperSlurperJobError = DefaultErrors;
export declare const resumeSuperSlurperJob: API.OperationMethod<ResumeSuperSlurperJobRequest, ResumeSuperSlurperJobResponse, ResumeSuperSlurperJobError, Credentials | HttpClient.HttpClient>;
export interface ListSuperSlurperJobLogsRequest {
    jobId: string;
    /** Path param: */
    accountId: string;
    /** Query param: */
    limit?: number;
    /** Query param: */
    offset?: number;
}
export declare const ListSuperSlurperJobLogsRequest: Schema.Schema<ListSuperSlurperJobLogsRequest>;
export interface ListSuperSlurperJobLogsResponse {
    result: {
        createdAt?: string | null;
        job?: string | null;
        logType?: "migrationStart" | "migrationComplete" | "migrationAbort" | "migrationError" | "migrationPause" | "migrationResume" | "migrationErrorFailedContinuation" | "importErrorRetryExhaustion" | "importSkippedStorageClass" | "importSkippedOversized" | "importSkippedEmptyObject" | "importSkippedUnsupportedContentType" | "importSkippedExcludedContentType" | "importSkippedInvalidMedia" | "importSkippedRequiresRetrieval" | null;
        message?: string | null;
        objectKey?: string | null;
    }[];
}
export declare const ListSuperSlurperJobLogsResponse: Schema.Schema<ListSuperSlurperJobLogsResponse>;
export type ListSuperSlurperJobLogsError = DefaultErrors;
export declare const listSuperSlurperJobLogs: API.PaginatedOperationMethod<ListSuperSlurperJobLogsRequest, ListSuperSlurperJobLogsResponse, ListSuperSlurperJobLogsError, Credentials | HttpClient.HttpClient>;
export interface CreateTemporaryCredentialRequest {
    /** Path param: Account ID. */
    accountId: string;
    /** Body param: Name of the R2 bucket. */
    bucket: string;
    /** Body param: The parent access key id to use for signing. */
    parentAccessKeyId: string;
    /** Body param: Permissions allowed on the credentials. */
    permission: "admin-read-write" | "admin-read-only" | "object-read-write" | "object-read-only";
    /** Body param: How long the credentials will live for in seconds. */
    ttlSeconds: number;
    /** Body param: Optional object paths to scope the credentials to. */
    objects?: string[];
    /** Body param: Optional prefix paths to scope the credentials to. */
    prefixes?: string[];
}
export declare const CreateTemporaryCredentialRequest: Schema.Schema<CreateTemporaryCredentialRequest>;
export interface CreateTemporaryCredentialResponse {
    /** ID for new access key. */
    accessKeyId?: string | null;
    /** Secret access key. */
    secretAccessKey?: string | null;
    /** Security token. */
    sessionToken?: string | null;
}
export declare const CreateTemporaryCredentialResponse: Schema.Schema<CreateTemporaryCredentialResponse>;
export type CreateTemporaryCredentialError = DefaultErrors;
export declare const createTemporaryCredential: API.OperationMethod<CreateTemporaryCredentialRequest, CreateTemporaryCredentialResponse, CreateTemporaryCredentialError, Credentials | HttpClient.HttpClient>;
export {};
//# sourceMappingURL=r2.d.ts.map