@distilled.cloud/cloudflare 0.0.0-john

package/lib/services/r2.d.ts

@@ -0,0 +1,1087 @@
+/**
+ * Cloudflare R2 API
+ *
+ * Generated from Cloudflare TypeScript SDK.
+ * DO NOT EDIT - regenerate with: bun scripts/generate.ts --service r2
+ */
+import * as stream from "effect/Stream";
+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";
+declare const BucketAlreadyExists_base: Schema.ErrorClass<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.ErrorClass<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 InvalidBucketName_base: Schema.ErrorClass<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 InvalidRoute_base: Schema.ErrorClass<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 NoCorsConfiguration_base: Schema.ErrorClass<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.ErrorClass<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.ErrorClass<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.ErrorClass<NoSuchBucket, Schema.TaggedStruct<"NoSuchBucket", {
+    readonly code: Schema.Number;
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class NoSuchBucket extends NoSuchBucket_base {
+}
+export interface AbortAllSuperSlurperJobRequest {
+    accountId: string;
+}
+export declare const AbortAllSuperSlurperJobRequest: Schema.Schema<AbortAllSuperSlurperJobRequest>;
+export type AbortAllSuperSlurperJobResponse = string;
+export declare const AbortAllSuperSlurperJobResponse: Schema.Schema<string>;
+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<unknown>;
+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<unknown>;
+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<unknown>;
+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;
+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;
+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<unknown>;
+export type PutBucketEventNotificationError = DefaultErrors;
+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<unknown>;
+export type DeleteBucketEventNotificationError = DefaultErrors;
+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<unknown>;
+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<unknown>;
+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;
+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 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> & {
+    pages: (input: ListSuperSlurperJobsRequest) => stream.Stream<ListSuperSlurperJobsResponse, ListSuperSlurperJobsError, Credentials | HttpClient.HttpClient>;
+    items: (input: ListSuperSlurperJobsRequest) => stream.Stream<{
+        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;
+    }, 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<string>;
+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<string>;
+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<string>;
+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> & {
+    pages: (input: ListSuperSlurperJobLogsRequest) => stream.Stream<ListSuperSlurperJobLogsResponse, ListSuperSlurperJobLogsError, Credentials | HttpClient.HttpClient>;
+    items: (input: ListSuperSlurperJobLogsRequest) => stream.Stream<{
+        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;
+    }, 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