@keboola/api-client 4.0.0 → 5.0.0

package/dist/index-KHRrA2IR.d.cts

@@ -0,0 +1,1511 @@
+import { c as components, S as StorageToken, C as CreateTokenBody, U as UpdateTokenBody, b as ShareTokenBody } from './types-DcL25GqY.cjs';
+import { GetBucketsQuery, Bucket, BucketDetail, CreateBucketBody, UpdateBucketBody, CreateScheduledRefreshPath, CreateScheduledRefreshBody, ScheduledTask, BucketListing, CreateBucketListingInput, Job, UpdateBucketListingInput, ShareBucketToProjectsBody, ShareBucketToUsersBody, UpdateBucketOwnerBody, RefreshExternalBucketQuery, RegisterBucketBody, BucketRegistrationGuideQuery, SaveBucketMetadataBody, GetEventsQuery, StorageEvent, GetTableEventsQuery, TableEvent, CreateEventBody, File, GetFilesQuery, DeleteFileTagPath, PrepareFileBody, PreparedFile, GetTablesQuery, Table, TableDetail, GetDataPreview, PrevieData, DeleteTableRows, JobUnion, TableExportAsyncBody, TableExportJob, CreateTableAsyncBody, TableCreateJob, CreateTableDefinitionBody, TableImportAsyncBody, TableImportJob, UpdateTableDefinitionInput, UpdateTableBody, CreateAliasTableBody, SetAliasTableFilterBody, CreateSnapshotBody, Snapshot, SaveMetadataBody, Metadata, AddTableColumnBody, DeleteTableColumnQuery, CreateTablePrimaryKeyBody, DevBranch, CreateDevBranchJobBody, DevBranchPath, BranchMetadata, BranchMetadataEntry, WorkspacePath, Workspace, WorkspacesPath, ResetWorkspacePassword, SetWorkspacePublicInput, GetWorkspaceSaml2LoginPath, WorkspaceSaml2Login, WorkspaceObject, DeleteWorkspaceObjectInput, UnloadWorkspaceInput, WorkspaceInputMappingLoadPreviewInput, MergeRequestDetail, MergeRequestDetailWithActivityLog, CreateMergeRequestParams, UpdateMergeRequestParams, JobOperation, GetJobPath, GetJobsQuery, GetComponentPath, Component, GetComponentsPath, GetComponentsQuery, GetSearchComponentConfigurationsPath, SearchComponentConfigurationsQuery, SearchComponentConfiguration, PartialKey, CreateConfigurationInput, BaseComponentConfig, ConfigType, UpdateConfigurationInput, ComponentConfig, ConfigurationPath, ConfigurationDiffPath, ConfigurationDiff, ConfigurationRowDiffPath, ConfigurationRowDiff, RebaseConfigurationInput, GetConfigurationsPath, CreateConfigurationRowInput, Row, CreateConfigurationRowsInput, CreateConfigurationRowBody, DeleteConfigurationRowInput, DeleteConfigurationRowsInput, CreateConfigurationWorkspaceBody, ConfigurationUseCaseType, ConfigurationVersionPath, ConfigurationVersion, ConfigurationVersionDetailPath, ConfigurationVersionDetail, ListTriggersQuery, CreateTriggerBody, UpdateTriggerBody, GlobalSearchQuery, GlobalSearchResponse, RunIdStats, GetStackInfoQuery, StackInfo } from './storage/types.cjs';
+import { C as ClientInitOptions, M as MiddlewareFn$1 } from './types-DxJD6LIN.cjs';
+import { c as createGenericFetchClient } from './createGenericFetchClient-yfcpR7qD.cjs';
+import { c as createOpenapiFetchClient } from './createOpenapiFetchClient-Ci0-Qe53.cjs';
+
+type ProcessFn<T, R> = (item: T, index: number, arrayLength: number) => Promise<R>;
+type MiddlewareFn<T, R> = (next: ProcessFn<T, R>) => ProcessFn<T, R>;
+type ConcurrentOptions<T, R> = {
+    items: T[];
+    process: ProcessFn<T, R>;
+    concurrency?: number;
+    middlewares?: MiddlewareFn<T, R>[];
+};
+/**
+ * Executes an asynchronous callback function on an array of items, processing multiple items concurrently with a specified concurrency limit.
+ * It behaves similarly to Promise.all(), failing on the first rejected promise.
+ * The order of the results matches the order of the promises.
+ * The API is the same as Bluebird.map().
+ */
+declare const concurrent: <T, R>({ items, process, concurrency, middlewares, }: ConcurrentOptions<T, R>) => Promise<R[]>;
+
+type GenericFetchClient = ReturnType<typeof createGenericFetchClient>;
+type StorageOpenApiFetchClient = ReturnType<typeof createOpenapiFetchClient<paths>>;
+type StorageClientInitOptions = Omit<ClientInitOptions, 'middlewares'> & {
+    middlewares?: MiddlewareFn$1[];
+    onRefreshToken?: (newToken: string) => void;
+};
+declare const createStorageClient: ({ baseUrl, token, middlewares, onRefreshToken, }: StorageClientInitOptions) => {
+    buckets: {
+        getBuckets: (branchId: string, query?: GetBucketsQuery, signal?: AbortSignal) => Promise<Bucket[]>;
+        getBucket: (id: string, signal?: AbortSignal) => Promise<BucketDetail>;
+        createBucket: (body: CreateBucketBody) => Promise<BucketDetail>;
+        updateBucket: (id: string, body: UpdateBucketBody) => Promise<BucketDetail>;
+        deleteBucket: (id: string) => Promise<void>;
+        deleteBucketAsync: (id: string, options?: {
+            force?: boolean;
+        }) => Promise<{
+            id: number;
+            tableId: string | null;
+            runId: string;
+            url: string;
+            createdTime: string;
+            creatorToken: {
+                id: string;
+                description: string;
+            };
+            endTime: string | null;
+            startTime: string | null;
+            operationName: "bucketDelete";
+            operationParams: {
+                queue: string;
+            } & {
+                id: string;
+            };
+            metrics: {
+                inCompressed: boolean;
+                inBytes: number;
+                inBytesUncompressed: number;
+                outCompressed: boolean;
+                outBytes: number;
+                outBytesUncompressed: number;
+            };
+        } & ({
+            status: Exclude<"error" | "success" | "warning" | "created" | "waiting" | "processing" | "terminating" | "terminated" | "cancelled", "success" | "error">;
+            results: null;
+        } | {
+            status: "error";
+            results: null;
+            error: {
+                code: string;
+                message: string;
+                exceptionId?: string;
+            };
+        } | {
+            status: "success";
+            results: null;
+        })>;
+        createScheduledRefresh: (input: CreateScheduledRefreshPath & CreateScheduledRefreshBody) => Promise<ScheduledTask>;
+        deleteScheduledTask: (taskId: string) => Promise<void>;
+        getListing: (bucketId: string, signal?: AbortSignal) => Promise<BucketListing | null>;
+        createListing: (bucketId: string, input: CreateBucketListingInput, signal?: AbortSignal) => Promise<Job<"bucketListingCreate">>;
+        updateListing: (bucketId: string, input: UpdateBucketListingInput, signal?: AbortSignal) => Promise<Job<"bucketListingUpdate">>;
+        deleteListing: (bucketId: string, signal?: AbortSignal) => Promise<Job<"bucketListingDelete">>;
+        listListings: (signal?: AbortSignal) => Promise<BucketListing[]>;
+        shareBucketToOrganization: (bucketId: string, signal?: AbortSignal) => Promise<{
+            id: number;
+            tableId: string | null;
+            runId: string;
+            url: string;
+            createdTime: string;
+            creatorToken: {
+                id: string;
+                description: string;
+            };
+            endTime: string | null;
+            startTime: string | null;
+            operationName: "bucketShareToOrganization";
+            operationParams: {
+                queue: string;
+            } & Record<string, unknown>;
+            metrics: {
+                inCompressed: boolean;
+                inBytes: number;
+                inBytesUncompressed: number;
+                outCompressed: boolean;
+                outBytes: number;
+                outBytesUncompressed: number;
+            };
+        } & ({
+            status: Exclude<"error" | "success" | "warning" | "created" | "waiting" | "processing" | "terminating" | "terminated" | "cancelled", "success" | "error">;
+            results: null;
+        } | {
+            status: "error";
+            results: null;
+            error: {
+                code: string;
+                message: string;
+                exceptionId?: string;
+            };
+        } | {
+            status: "success";
+            results: null;
+        })>;
+        shareBucketToOrganizationProject: (bucketId: string, signal?: AbortSignal) => Promise<{
+            id: number;
+            tableId: string | null;
+            runId: string;
+            url: string;
+            createdTime: string;
+            creatorToken: {
+                id: string;
+                description: string;
+            };
+            endTime: string | null;
+            startTime: string | null;
+            operationName: "bucketShareToOrganizationProject";
+            operationParams: {
+                queue: string;
+            } & Record<string, unknown>;
+            metrics: {
+                inCompressed: boolean;
+                inBytes: number;
+                inBytesUncompressed: number;
+                outCompressed: boolean;
+                outBytes: number;
+                outBytesUncompressed: number;
+            };
+        } & ({
+            status: Exclude<"error" | "success" | "warning" | "created" | "waiting" | "processing" | "terminating" | "terminated" | "cancelled", "success" | "error">;
+            results: null;
+        } | {
+            status: "error";
+            results: null;
+            error: {
+                code: string;
+                message: string;
+                exceptionId?: string;
+            };
+        } | {
+            status: "success";
+            results: null;
+        })>;
+        shareBucketToProjects: (bucketId: string, body: ShareBucketToProjectsBody, signal?: AbortSignal) => Promise<{
+            id: number;
+            tableId: string | null;
+            runId: string;
+            url: string;
+            createdTime: string;
+            creatorToken: {
+                id: string;
+                description: string;
+            };
+            endTime: string | null;
+            startTime: string | null;
+            operationName: "bucketShareToProjects";
+            operationParams: {
+                queue: string;
+            } & Record<string, unknown>;
+            metrics: {
+                inCompressed: boolean;
+                inBytes: number;
+                inBytesUncompressed: number;
+                outCompressed: boolean;
+                outBytes: number;
+                outBytesUncompressed: number;
+            };
+        } & ({
+            status: Exclude<"error" | "success" | "warning" | "created" | "waiting" | "processing" | "terminating" | "terminated" | "cancelled", "success" | "error">;
+            results: null;
+        } | {
+            status: "error";
+            results: null;
+            error: {
+                code: string;
+                message: string;
+                exceptionId?: string;
+            };
+        } | {
+            status: "success";
+            results: null;
+        })>;
+        shareBucketToUsers: (bucketId: string, body: ShareBucketToUsersBody, signal?: AbortSignal) => Promise<{
+            id: number;
+            tableId: string | null;
+            runId: string;
+            url: string;
+            createdTime: string;
+            creatorToken: {
+                id: string;
+                description: string;
+            };
+            endTime: string | null;
+            startTime: string | null;
+            operationName: "bucketShareToAdmins";
+            operationParams: {
+                queue: string;
+            } & Record<string, unknown>;
+            metrics: {
+                inCompressed: boolean;
+                inBytes: number;
+                inBytesUncompressed: number;
+                outCompressed: boolean;
+                outBytes: number;
+                outBytesUncompressed: number;
+            };
+        } & ({
+            status: Exclude<"error" | "success" | "warning" | "created" | "waiting" | "processing" | "terminating" | "terminated" | "cancelled", "success" | "error">;
+            results: null;
+        } | {
+            status: "error";
+            results: null;
+            error: {
+                code: string;
+                message: string;
+                exceptionId?: string;
+            };
+        } | {
+            status: "success";
+            results: null;
+        })>;
+        unshareBucket: (bucketId: string, signal?: AbortSignal) => Promise<{
+            id: number;
+            tableId: string | null;
+            runId: string;
+            url: string;
+            createdTime: string;
+            creatorToken: {
+                id: string;
+                description: string;
+            };
+            endTime: string | null;
+            startTime: string | null;
+            operationName: "bucketRemoveShare";
+            operationParams: {
+                queue: string;
+            } & Record<string, unknown>;
+            metrics: {
+                inCompressed: boolean;
+                inBytes: number;
+                inBytesUncompressed: number;
+                outCompressed: boolean;
+                outBytes: number;
+                outBytesUncompressed: number;
+            };
+        } & ({
+            status: Exclude<"error" | "success" | "warning" | "created" | "waiting" | "processing" | "terminating" | "terminated" | "cancelled", "success" | "error">;
+            results: null;
+        } | {
+            status: "error";
+            results: null;
+            error: {
+                code: string;
+                message: string;
+                exceptionId?: string;
+            };
+        } | {
+            status: "success";
+            results: null;
+        })>;
+        forceUnlinkBucket: (bucketId: string, linkedProjectId: string, signal?: AbortSignal) => Promise<{
+            id: number;
+            tableId: string | null;
+            runId: string;
+            url: string;
+            createdTime: string;
+            creatorToken: {
+                id: string;
+                description: string;
+            };
+            endTime: string | null;
+            startTime: string | null;
+            operationName: "bucketForceUnlink";
+            operationParams: {
+                queue: string;
+            } & Record<string, unknown>;
+            metrics: {
+                inCompressed: boolean;
+                inBytes: number;
+                inBytesUncompressed: number;
+                outCompressed: boolean;
+                outBytes: number;
+                outBytesUncompressed: number;
+            };
+        } & ({
+            status: Exclude<"error" | "success" | "warning" | "created" | "waiting" | "processing" | "terminating" | "terminated" | "cancelled", "success" | "error">;
+            results: null;
+        } | {
+            status: "error";
+            results: null;
+            error: {
+                code: string;
+                message: string;
+                exceptionId?: string;
+            };
+        } | {
+            status: "success";
+            results: null;
+        })>;
+        getBucketOwner: (bucketId: string, signal?: AbortSignal) => Promise<{
+            id: number;
+            name: string;
+            email: string;
+        }>;
+        updateBucketOwner: (bucketId: string, body: UpdateBucketOwnerBody, signal?: AbortSignal) => Promise<void>;
+        refreshExternalBucket: (bucketId: string, query?: RefreshExternalBucketQuery, signal?: AbortSignal) => Promise<{
+            id: number;
+            tableId: string | null;
+            runId: string;
+            url: string;
+            createdTime: string;
+            creatorToken: {
+                id: string;
+                description: string;
+            };
+            endTime: string | null;
+            startTime: string | null;
+            operationName: "bucketRefresh";
+            operationParams: {
+                queue: string;
+            } & Record<string, unknown>;
+            metrics: {
+                inCompressed: boolean;
+                inBytes: number;
+                inBytesUncompressed: number;
+                outCompressed: boolean;
+                outBytes: number;
+                outBytesUncompressed: number;
+            };
+        } & ({
+            status: Exclude<"error" | "success" | "warning" | "created" | "waiting" | "processing" | "terminating" | "terminated" | "cancelled", "success" | "error">;
+            results: null;
+        } | {
+            status: "error";
+            results: null;
+            error: {
+                code: string;
+                message: string;
+                exceptionId?: string;
+            };
+        } | {
+            status: "success";
+            results: null;
+        })>;
+        registerBucket: (body: RegisterBucketBody, signal?: AbortSignal) => Promise<{
+            id: number;
+            tableId: string | null;
+            runId: string;
+            url: string;
+            createdTime: string;
+            creatorToken: {
+                id: string;
+                description: string;
+            };
+            endTime: string | null;
+            startTime: string | null;
+            operationName: "bucketRegister";
+            operationParams: {
+                queue: string;
+            } & Record<string, unknown>;
+            metrics: {
+                inCompressed: boolean;
+                inBytes: number;
+                inBytesUncompressed: number;
+                outCompressed: boolean;
+                outBytes: number;
+                outBytesUncompressed: number;
+            };
+        } & ({
+            status: Exclude<"error" | "success" | "warning" | "created" | "waiting" | "processing" | "terminating" | "terminated" | "cancelled", "success" | "error">;
+            results: null;
+        } | {
+            status: "error";
+            results: null;
+            error: {
+                code: string;
+                message: string;
+                exceptionId?: string;
+            };
+        } | {
+            status: "success";
+            results: null;
+        })>;
+        getBucketRegistrationGuide: (query: BucketRegistrationGuideQuery, signal?: AbortSignal) => Promise<{
+            markdown: string;
+        }>;
+        sharedBuckets: (signal?: AbortSignal) => Promise<Record<string, never>[]>;
+        saveBucketMetadata: (bucketId: string, body: SaveBucketMetadataBody, signal?: AbortSignal) => Promise<{
+            id: number;
+            key: string;
+            value: string | null;
+            provider: string;
+            timestamp: string;
+        }[]>;
+        deleteBucketMetadata: (bucketId: string, metadataId: string, signal?: AbortSignal) => Promise<void>;
+    };
+    events: {
+        getEvents: (query?: GetEventsQuery, signal?: AbortSignal) => Promise<StorageEvent[]>;
+        getEvent: (eventId: string | number, signal?: AbortSignal) => Promise<StorageEvent>;
+        getTableEvents: (tableId: string, query?: GetTableEventsQuery, signal?: AbortSignal) => Promise<TableEvent[]>;
+        createEvent: (body: CreateEventBody, signal?: AbortSignal) => Promise<StorageEvent>;
+    };
+    files: {
+        getFile: (fileId: number, signal?: AbortSignal) => Promise<File>;
+        getFileContent: (fileId: number, signal?: AbortSignal) => Promise<string>;
+        getFiles: (query?: GetFilesQuery, signal?: AbortSignal) => Promise<File[]>;
+        deleteFile: (fileId: number) => Promise<void>;
+        addFileTag: (fileId: number, tag: string) => Promise<void>;
+        deleteFileTag: (fileId: DeleteFileTagPath["fileId"], tag: DeleteFileTagPath["tag"]) => Promise<void>;
+        prepareFile: (body: PrepareFileBody, signal?: AbortSignal) => Promise<PreparedFile>;
+    };
+    tables: {
+        getTables: (branchId: string, query?: GetTablesQuery, signal?: AbortSignal) => Promise<Table[]>;
+        getTable: (id: string, signal?: AbortSignal) => Promise<TableDetail>;
+        getDataPreview: (id: string, query?: GetDataPreview, signal?: AbortSignal) => Promise<PrevieData>;
+        deleteTable: (id: string, signal?: AbortSignal) => Promise<void>;
+        deleteTables: (ids: string[]) => Promise<void>;
+        deleteTableRows: (id: string, query?: DeleteTableRows, signal?: AbortSignal) => Promise<JobUnion>;
+        exportAsync: (tableId: string, body?: TableExportAsyncBody, signal?: AbortSignal) => Promise<TableExportJob>;
+        createTableAsync: (bucketId: string, body: CreateTableAsyncBody, signal?: AbortSignal) => Promise<TableCreateJob>;
+        createTableDefinitionAsync: (bucketId: string, body: CreateTableDefinitionBody, signal?: AbortSignal) => Promise<{
+            id: number;
+            tableId: string | null;
+            runId: string;
+            url: string;
+            createdTime: string;
+            creatorToken: {
+                id: string;
+                description: string;
+            };
+            endTime: string | null;
+            startTime: string | null;
+            operationName: "tableDefinitionCreate";
+            operationParams: {
+                queue: string;
+            } & {
+                timestampType: string;
+                primaryKeysNames: string[];
+                name: string;
+                backendConfiguration: unknown[];
+                columns: unknown[];
+            };
+            metrics: {
+                inCompressed: boolean;
+                inBytes: number;
+                inBytesUncompressed: number;
+                outCompressed: boolean;
+                outBytes: number;
+                outBytesUncompressed: number;
+            };
+        } & ({
+            status: Exclude<"error" | "success" | "warning" | "created" | "waiting" | "processing" | "terminating" | "terminated" | "cancelled", "success" | "error">;
+            results: null;
+        } | {
+            status: "error";
+            results: null;
+            error: {
+                code: string;
+                message: string;
+                exceptionId?: string;
+            };
+        } | {
+            status: "success";
+            results: Table;
+        })>;
+        importAsync: (tableId: string, body: TableImportAsyncBody, signal?: AbortSignal) => Promise<TableImportJob>;
+        updateTableDefinition: ({ branchId, tableId, ...body }: UpdateTableDefinitionInput, signal?: AbortSignal) => Promise<{
+            id: number;
+            tableId: string | null;
+            runId: string;
+            url: string;
+            createdTime: string;
+            creatorToken: {
+                id: string;
+                description: string;
+            };
+            endTime: string | null;
+            startTime: string | null;
+            operationName: "tableDefinitionUpdate";
+            operationParams: {
+                queue: string;
+            } & {
+                tableId: string;
+                displayName: string;
+                description?: string | null;
+                columns: unknown[];
+            };
+            metrics: {
+                inCompressed: boolean;
+                inBytes: number;
+                inBytesUncompressed: number;
+                outCompressed: boolean;
+                outBytes: number;
+                outBytesUncompressed: number;
+            };
+        } & ({
+            status: Exclude<"error" | "success" | "warning" | "created" | "waiting" | "processing" | "terminating" | "terminated" | "cancelled", "success" | "error">;
+            results: null;
+        } | {
+            status: "error";
+            results: null;
+            error: {
+                code: string;
+                message: string;
+                exceptionId?: string;
+            };
+        } | {
+            status: "success";
+            results: Table;
+        })>;
+        updateTable: (tableId: string, body: UpdateTableBody, signal?: AbortSignal) => Promise<Table>;
+        pullTable: (tableId: string, signal?: AbortSignal) => Promise<{
+            id: number;
+            tableId: string | null;
+            runId: string;
+            url: string;
+            createdTime: string;
+            creatorToken: {
+                id: string;
+                description: string;
+            };
+            endTime: string | null;
+            startTime: string | null;
+            operationName: "devBranchTablePull";
+            operationParams: {
+                queue: string;
+            } & {
+                id: string;
+            };
+            metrics: {
+                inCompressed: boolean;
+                inBytes: number;
+                inBytesUncompressed: number;
+                outCompressed: boolean;
+                outBytes: number;
+                outBytesUncompressed: number;
+            };
+        } & ({
+            status: Exclude<"error" | "success" | "warning" | "created" | "waiting" | "processing" | "terminating" | "terminated" | "cancelled", "success" | "error">;
+            results: null;
+        } | {
+            status: "error";
+            results: null;
+            error: {
+                code: string;
+                message: string;
+                exceptionId?: string;
+            };
+        } | {
+            status: "success";
+            results: null;
+        })>;
+        createAliasTable: (bucketId: string, body: CreateAliasTableBody, signal?: AbortSignal) => Promise<Table | ({
+            id: number;
+            tableId: string | null;
+            runId: string;
+            url: string;
+            createdTime: string;
+            creatorToken: {
+                id: string;
+                description: string;
+            };
+            endTime: string | null;
+            startTime: string | null;
+            operationName: "aliasCreate";
+            operationParams: {
+                queue: string;
+            } & {
+                name: string;
+                sourceTable: string;
+            };
+            metrics: {
+                inCompressed: boolean;
+                inBytes: number;
+                inBytesUncompressed: number;
+                outCompressed: boolean;
+                outBytes: number;
+                outBytesUncompressed: number;
+            };
+        } & ({
+            status: Exclude<"error" | "success" | "warning" | "created" | "waiting" | "processing" | "terminating" | "terminated" | "cancelled", "success" | "error">;
+            results: null;
+        } | {
+            status: "error";
+            results: null;
+            error: {
+                code: string;
+                message: string;
+                exceptionId?: string;
+            };
+        } | {
+            status: "success";
+            results: null;
+        }))>;
+        setAliasTableFilter: (tableId: string, body: SetAliasTableFilterBody, signal?: AbortSignal) => Promise<Table>;
+        removeAliasTableFilter: (tableId: string, signal?: AbortSignal) => Promise<void>;
+        createSnapshot: (tableId: string, body?: CreateSnapshotBody, signal?: AbortSignal) => Promise<{
+            id: number;
+            tableId: string | null;
+            runId: string;
+            url: string;
+            createdTime: string;
+            creatorToken: {
+                id: string;
+                description: string;
+            };
+            endTime: string | null;
+            startTime: string | null;
+            operationName: "tableSnapshotCreate";
+            operationParams: {
+                queue: string;
+            } & {
+                id: string;
+            };
+            metrics: {
+                inCompressed: boolean;
+                inBytes: number;
+                inBytesUncompressed: number;
+                outCompressed: boolean;
+                outBytes: number;
+                outBytesUncompressed: number;
+            };
+        } & ({
+            status: Exclude<"error" | "success" | "warning" | "created" | "waiting" | "processing" | "terminating" | "terminated" | "cancelled", "success" | "error">;
+            results: null;
+        } | {
+            status: "error";
+            results: null;
+            error: {
+                code: string;
+                message: string;
+                exceptionId?: string;
+            };
+        } | {
+            status: "success";
+            results: null;
+        })>;
+        deleteSnapshot: (snapshotId: string, signal?: AbortSignal) => Promise<void>;
+        loadTableSnapshots: (tableId: string, signal?: AbortSignal) => Promise<Snapshot[]>;
+        saveTableMetadata: (tableId: string, body: SaveMetadataBody, signal?: AbortSignal) => Promise<Metadata[]>;
+        deleteTableMetadata: (tableId: string, metadataId: string, signal?: AbortSignal) => Promise<void>;
+    };
+    columns: {
+        addTableColumn: (tableId: string, body: AddTableColumnBody, signal?: AbortSignal) => Promise<{
+            id: number;
+            tableId: string | null;
+            runId: string;
+            url: string;
+            createdTime: string;
+            creatorToken: {
+                id: string;
+                description: string;
+            };
+            endTime: string | null;
+            startTime: string | null;
+            operationName: "tableColumnAdd";
+            operationParams: {
+                queue: string;
+            } & {
+                id: string;
+            };
+            metrics: {
+                inCompressed: boolean;
+                inBytes: number;
+                inBytesUncompressed: number;
+                outCompressed: boolean;
+                outBytes: number;
+                outBytesUncompressed: number;
+            };
+        } & ({
+            status: Exclude<"error" | "success" | "warning" | "created" | "waiting" | "processing" | "terminating" | "terminated" | "cancelled", "success" | "error">;
+            results: null;
+        } | {
+            status: "error";
+            results: null;
+            error: {
+                code: string;
+                message: string;
+                exceptionId?: string;
+            };
+        } | {
+            status: "success";
+            results: null;
+        })>;
+        deleteTableColumn: (tableId: string, columnName: string, query?: DeleteTableColumnQuery, signal?: AbortSignal) => Promise<{
+            id: number;
+            tableId: string | null;
+            runId: string;
+            url: string;
+            createdTime: string;
+            creatorToken: {
+                id: string;
+                description: string;
+            };
+            endTime: string | null;
+            startTime: string | null;
+            operationName: "tableColumnDelete";
+            operationParams: {
+                queue: string;
+            } & {
+                id: string;
+            };
+            metrics: {
+                inCompressed: boolean;
+                inBytes: number;
+                inBytesUncompressed: number;
+                outCompressed: boolean;
+                outBytes: number;
+                outBytesUncompressed: number;
+            };
+        } & ({
+            status: Exclude<"error" | "success" | "warning" | "created" | "waiting" | "processing" | "terminating" | "terminated" | "cancelled", "success" | "error">;
+            results: null;
+        } | {
+            status: "error";
+            results: null;
+            error: {
+                code: string;
+                message: string;
+                exceptionId?: string;
+            };
+        } | {
+            status: "success";
+            results: null;
+        })>;
+        createTablePrimaryKey: (tableId: string, body: CreateTablePrimaryKeyBody, signal?: AbortSignal) => Promise<{
+            id: number;
+            tableId: string | null;
+            runId: string;
+            url: string;
+            createdTime: string;
+            creatorToken: {
+                id: string;
+                description: string;
+            };
+            endTime: string | null;
+            startTime: string | null;
+            operationName: "tablePrimaryKeyAdd";
+            operationParams: {
+                queue: string;
+            } & {
+                id: string;
+            };
+            metrics: {
+                inCompressed: boolean;
+                inBytes: number;
+                inBytesUncompressed: number;
+                outCompressed: boolean;
+                outBytes: number;
+                outBytesUncompressed: number;
+            };
+        } & ({
+            status: Exclude<"error" | "success" | "warning" | "created" | "waiting" | "processing" | "terminating" | "terminated" | "cancelled", "success" | "error">;
+            results: null;
+        } | {
+            status: "error";
+            results: null;
+            error: {
+                code: string;
+                message: string;
+                exceptionId?: string;
+            };
+        } | {
+            status: "success";
+            results: null;
+        })>;
+        removeTablePrimaryKey: (tableId: string, signal?: AbortSignal) => Promise<{
+            id: number;
+            tableId: string | null;
+            runId: string;
+            url: string;
+            createdTime: string;
+            creatorToken: {
+                id: string;
+                description: string;
+            };
+            endTime: string | null;
+            startTime: string | null;
+            operationName: "tablePrimaryKeyDelete";
+            operationParams: {
+                queue: string;
+            } & {
+                id: string;
+            };
+            metrics: {
+                inCompressed: boolean;
+                inBytes: number;
+                inBytesUncompressed: number;
+                outCompressed: boolean;
+                outBytes: number;
+                outBytesUncompressed: number;
+            };
+        } & ({
+            status: Exclude<"error" | "success" | "warning" | "created" | "waiting" | "processing" | "terminating" | "terminated" | "cancelled", "success" | "error">;
+            results: null;
+        } | {
+            status: "error";
+            results: null;
+            error: {
+                code: string;
+                message: string;
+                exceptionId?: string;
+            };
+        } | {
+            status: "success";
+            results: null;
+        })>;
+        saveColumnMetadata: (columnId: string, body: SaveMetadataBody, signal?: AbortSignal) => Promise<Metadata[]>;
+        deleteColumnMetadata: (columnId: string, metadataId: string, signal?: AbortSignal) => Promise<void>;
+    };
+    branches: {
+        getDevBranches: (signal?: AbortSignal) => Promise<DevBranch[]>;
+        createDevBranchJob: (body: CreateDevBranchJobBody) => Promise<{
+            id: number;
+            tableId: string | null;
+            runId: string;
+            url: string;
+            createdTime: string;
+            creatorToken: {
+                id: string;
+                description: string;
+            };
+            endTime: string | null;
+            startTime: string | null;
+            operationName: "devBranchCreate";
+            operationParams: {
+                queue: string;
+            } & {
+                values: {
+                    name: string;
+                    description: string;
+                };
+            };
+            metrics: {
+                inCompressed: boolean;
+                inBytes: number;
+                inBytesUncompressed: number;
+                outCompressed: boolean;
+                outBytes: number;
+                outBytesUncompressed: number;
+            };
+        } & ({
+            status: Exclude<"error" | "success" | "warning" | "created" | "waiting" | "processing" | "terminating" | "terminated" | "cancelled", "success" | "error">;
+            results: null;
+        } | {
+            status: "success";
+            results: DevBranch;
+        } | {
+            status: "error";
+            results: null;
+            error: {
+                code: string;
+                message: string;
+                exceptionId?: string;
+            };
+        })>;
+        updateDevBranch: ({ id, name, description, }: CreateDevBranchJobBody & DevBranchPath) => Promise<DevBranch>;
+        deleteDevBranchJob: (id: number) => Promise<{
+            id: number;
+            tableId: string | null;
+            runId: string;
+            url: string;
+            createdTime: string;
+            creatorToken: {
+                id: string;
+                description: string;
+            };
+            endTime: string | null;
+            startTime: string | null;
+            operationName: "devBranchDelete";
+            operationParams: {
+                queue: string;
+            } & {
+                values: {
+                    id: number;
+                };
+            };
+            metrics: {
+                inCompressed: boolean;
+                inBytes: number;
+                inBytesUncompressed: number;
+                outCompressed: boolean;
+                outBytes: number;
+                outBytesUncompressed: number;
+            };
+        } & ({
+            status: Exclude<"error" | "success" | "warning" | "created" | "waiting" | "processing" | "terminating" | "terminated" | "cancelled", "success" | "error">;
+            results: null;
+        } | {
+            status: "error";
+            results: null;
+            error: {
+                code: string;
+                message: string;
+                exceptionId?: string;
+            };
+        } | {
+            status: "success";
+            results: null;
+        })>;
+        getDevBranchMetadata: (id: string, signal?: AbortSignal) => Promise<BranchMetadata[]>;
+        saveDevBranchMetadata: (id: string, metadata: BranchMetadataEntry[], signal?: AbortSignal) => Promise<BranchMetadata[]>;
+        deleteDevBranchMetadata: (id: string, metadataId: string, signal?: AbortSignal) => Promise<void>;
+    };
+    workspaces: {
+        getWorkspace: (path: WorkspacePath, signal?: AbortSignal) => Promise<Workspace>;
+        getWorkspaces: (branchId: WorkspacesPath["branchId"], signal?: AbortSignal) => Promise<Workspace[]>;
+        deleteWorkspace: (path: WorkspacePath) => Promise<void>;
+        resetWorkspacePassword: ({ branchId, workspaceId }: WorkspacePath) => Promise<ResetWorkspacePassword>;
+        deleteWorkspaces: ({ workspaceIds, branchId, }: Omit<WorkspacePath, "workspaceId"> & {
+            workspaceIds: WorkspacePath["workspaceId"][];
+        }) => Promise<void>;
+        deleteWorkspaceJob: (path: WorkspacePath) => Promise<{
+            id: number;
+            tableId: string | null;
+            runId: string;
+            url: string;
+            createdTime: string;
+            creatorToken: {
+                id: string;
+                description: string;
+            };
+            endTime: string | null;
+            startTime: string | null;
+            operationName: "workspaceDrop";
+            operationParams: {
+                queue: string;
+            } & {
+                workspaceId: string;
+                backendConfiguration: [];
+            };
+            metrics: {
+                inCompressed: boolean;
+                inBytes: number;
+                inBytesUncompressed: number;
+                outCompressed: boolean;
+                outBytes: number;
+                outBytesUncompressed: number;
+            };
+        } & ({
+            status: Exclude<"error" | "success" | "warning" | "created" | "waiting" | "processing" | "terminating" | "terminated" | "cancelled", "success" | "error">;
+            results: null;
+        } | {
+            status: "error";
+            results: null;
+            error: {
+                code: string;
+                message: string;
+                exceptionId?: string;
+            };
+        } | {
+            status: "success";
+            results: null;
+        })>;
+        setWorkspacePublicKey: ({ branchId, workspaceId, publicKey, }: SetWorkspacePublicInput) => Promise<Workspace>;
+        getWorkspaceSaml2Login: (path: GetWorkspaceSaml2LoginPath, signal?: AbortSignal) => Promise<WorkspaceSaml2Login>;
+        getWorkspaceObjects: (path: WorkspacePath, signal?: AbortSignal) => Promise<WorkspaceObject[]>;
+        deleteWorkspaceObjectsAsync: ({ branchId, workspaceId, ...body }: DeleteWorkspaceObjectInput) => Promise<{
+            id: number;
+            tableId: string | null;
+            runId: string;
+            url: string;
+            createdTime: string;
+            creatorToken: {
+                id: string;
+                description: string;
+            };
+            endTime: string | null;
+            startTime: string | null;
+            operationName: "workspaceBatchDeleteObject";
+            operationParams: {
+                queue: string;
+            } & {
+                workspaceId: string;
+                objects: string[];
+            };
+            metrics: {
+                inCompressed: boolean;
+                inBytes: number;
+                inBytesUncompressed: number;
+                outCompressed: boolean;
+                outBytes: number;
+                outBytesUncompressed: number;
+            };
+        } & ({
+            status: Exclude<"error" | "success" | "warning" | "created" | "waiting" | "processing" | "terminating" | "terminated" | "cancelled", "success" | "error">;
+            results: null;
+        } | {
+            status: "success";
+            results: {
+                deleted: {
+                    objectName: string;
+                }[];
+                failed: {
+                    objectName: string;
+                    error: string;
+                }[];
+            };
+        } | {
+            status: "error";
+            results: {
+                deleted: {
+                    objectName: string;
+                }[];
+                failed: {
+                    objectName: string;
+                    error: string;
+                }[];
+            };
+            error: {
+                code: string;
+                message: string;
+                exceptionId?: string;
+            };
+        })>;
+        unloadWorkspace: ({ branchId, workspaceId, ...query }: UnloadWorkspaceInput) => Promise<Record<string, never>[]>;
+        inputMappingLoadPreview: ({ branchId, body, backend }: WorkspaceInputMappingLoadPreviewInput, signal?: AbortSignal) => Promise<{
+            input: {
+                source: string;
+                destination: string;
+                loadType: "COPY" | "CLONE" | "VIEW";
+                possibleLoadTypes: ("COPY" | "CLONE" | "VIEW")[];
+            }[];
+        }>;
+    };
+    mergeRequests: {
+        getMergeRequests: (signal?: AbortSignal) => Promise<{
+            id: number;
+            creator: {
+                id?: number;
+                name?: string;
+            };
+            title: string;
+            description: string;
+            state: "development" | "in_review" | "approved" | "in_merge" | "published" | "canceled";
+            branches: {
+                branchFromId?: number | null;
+                branchIntoId?: number | null;
+            };
+            merge: {
+                mergedAt?: string | null;
+                mergerId?: number | null;
+                mergerName?: string;
+            };
+            createdAt: string;
+            externalId: string;
+            autoMergeStrategy: "immediately" | "scheduled" | "none";
+            autoMergeAt?: string | null;
+            approvals: {
+                approverId?: string;
+                approverName?: string;
+                createdAt?: string;
+            }[];
+            reviewers: {
+                id?: number;
+                name?: string;
+                email?: string;
+                status?: "approved" | "rejected" | null;
+            }[];
+        }[]>;
+        getMergeRequest: (id: number, signal?: AbortSignal) => Promise<MergeRequestDetail>;
+        getMergeRequestWithActivityLog: (id: number, signal?: AbortSignal) => Promise<MergeRequestDetailWithActivityLog>;
+        createMergeRequest: (params: CreateMergeRequestParams) => Promise<{
+            id: number;
+            creator: {
+                id?: number;
+                name?: string;
+            };
+            title: string;
+            description: string;
+            state: "development" | "in_review" | "approved" | "in_merge" | "published" | "canceled";
+            branches: {
+                branchFromId?: number | null;
+                branchIntoId?: number | null;
+            };
+            merge: {
+                mergedAt?: string | null;
+                mergerId?: number | null;
+                mergerName?: string;
+            };
+            createdAt: string;
+            externalId: string;
+            autoMergeStrategy: "immediately" | "scheduled" | "none";
+            autoMergeAt?: string | null;
+            approvals: {
+                approverId?: string;
+                approverName?: string;
+                createdAt?: string;
+            }[];
+            reviewers: {
+                id?: number;
+                name?: string;
+                email?: string;
+                status?: "approved" | "rejected" | null;
+            }[];
+        }>;
+        updateMergeRequest: (id: number, params: UpdateMergeRequestParams) => Promise<{
+            id: number;
+            creator: {
+                id?: number;
+                name?: string;
+            };
+            title: string;
+            description: string;
+            state: "development" | "in_review" | "approved" | "in_merge" | "published" | "canceled";
+            branches: {
+                branchFromId?: number | null;
+                branchIntoId?: number | null;
+            };
+            merge: {
+                mergedAt?: string | null;
+                mergerId?: number | null;
+                mergerName?: string;
+            };
+            createdAt: string;
+            externalId: string;
+            autoMergeStrategy: "immediately" | "scheduled" | "none";
+            autoMergeAt?: string | null;
+            approvals: {
+                approverId?: string;
+                approverName?: string;
+                createdAt?: string;
+            }[];
+            reviewers: {
+                id?: number;
+                name?: string;
+                email?: string;
+                status?: "approved" | "rejected" | null;
+            }[];
+        }>;
+        requestReview: (id: number) => Promise<{
+            id: number;
+            creator: {
+                id?: number;
+                name?: string;
+            };
+            title: string;
+            description: string;
+            state: "development" | "in_review" | "approved" | "in_merge" | "published" | "canceled";
+            branches: {
+                branchFromId?: number | null;
+                branchIntoId?: number | null;
+            };
+            merge: {
+                mergedAt?: string | null;
+                mergerId?: number | null;
+                mergerName?: string;
+            };
+            createdAt: string;
+            externalId: string;
+            autoMergeStrategy: "immediately" | "scheduled" | "none";
+            autoMergeAt?: string | null;
+            approvals: {
+                approverId?: string;
+                approverName?: string;
+                createdAt?: string;
+            }[];
+            reviewers: {
+                id?: number;
+                name?: string;
+                email?: string;
+                status?: "approved" | "rejected" | null;
+            }[];
+        } & {
+            changeLog?: Record<string, never>;
+        }>;
+        approveMergeRequest: (id: number) => Promise<{
+            id: number;
+            creator: {
+                id?: number;
+                name?: string;
+            };
+            title: string;
+            description: string;
+            state: "development" | "in_review" | "approved" | "in_merge" | "published" | "canceled";
+            branches: {
+                branchFromId?: number | null;
+                branchIntoId?: number | null;
+            };
+            merge: {
+                mergedAt?: string | null;
+                mergerId?: number | null;
+                mergerName?: string;
+            };
+            createdAt: string;
+            externalId: string;
+            autoMergeStrategy: "immediately" | "scheduled" | "none";
+            autoMergeAt?: string | null;
+            approvals: {
+                approverId?: string;
+                approverName?: string;
+                createdAt?: string;
+            }[];
+            reviewers: {
+                id?: number;
+                name?: string;
+                email?: string;
+                status?: "approved" | "rejected" | null;
+            }[];
+        } & {
+            changeLog?: Record<string, never>;
+        }>;
+        requestChangesMergeRequest: (id: number, reason?: string) => Promise<{
+            id: number;
+            creator: {
+                id?: number;
+                name?: string;
+            };
+            title: string;
+            description: string;
+            state: "development" | "in_review" | "approved" | "in_merge" | "published" | "canceled";
+            branches: {
+                branchFromId?: number | null;
+                branchIntoId?: number | null;
+            };
+            merge: {
+                mergedAt?: string | null;
+                mergerId?: number | null;
+                mergerName?: string;
+            };
+            createdAt: string;
+            externalId: string;
+            autoMergeStrategy: "immediately" | "scheduled" | "none";
+            autoMergeAt?: string | null;
+            approvals: {
+                approverId?: string;
+                approverName?: string;
+                createdAt?: string;
+            }[];
+            reviewers: {
+                id?: number;
+                name?: string;
+                email?: string;
+                status?: "approved" | "rejected" | null;
+            }[];
+        } & {
+            changeLog?: Record<string, never>;
+        }>;
+        mergeMergeRequest: (id: number) => Promise<{
+            id: string;
+            status: string;
+            url: string;
+            tableId: string;
+            operationName: string;
+            operationParams: Record<string, never>;
+            createdTime: string;
+            startTime?: string | null;
+            endTime?: string | null;
+            runId: string;
+            results?: components["schemas"]["BucketListingUpdateJobResponse"] | components["schemas"]["BucketListingCreateJobResult"] | components["schemas"]["BucketListingDeleteResponse"] | components["schemas"]["RefreshJobResponse"] | components["schemas"]["FileDeleteResponse"] | components["schemas"]["TableSnapshotCreateJobResult"] | components["schemas"]["TableSwapResult"] | components["schemas"]["TableCreateResponse"] | components["schemas"]["TableExportJobResponse"];
+            creatorToken: {
+                id?: string;
+                description?: string;
+            };
+            metrics: {
+                inCompressed?: boolean;
+                inBytes?: number;
+                inBytesUncompressed?: number;
+                outCompressed?: boolean;
+                outBytes?: number;
+                outBytesUncompressed?: number;
+            };
+            error?: {
+                code?: string;
+                message?: string;
+                exceptionId?: string;
+                contextParams?: Record<string, never> | null;
+                uuid?: string | null;
+            } | null;
+        }>;
+        getMergeRequestConflicts: (id: number, signal?: AbortSignal) => Promise<{
+            message: string;
+            componentId: string;
+            configurationId: string;
+            isDeleted: boolean;
+            devBranchVersionIdentifier: string;
+            defaultBranchVersionIdentifier: string;
+        }[]>;
+    };
+    jobs: {
+        getJob: <T extends JobOperation | string = string>(id: GetJobPath["id"], signal?: AbortSignal) => Promise<Job<T>>;
+        getJobs: <T extends JobOperation | string = string>(query?: GetJobsQuery, signal?: AbortSignal) => Promise<Job<T>[]>;
+    };
+    componentsAndConfigurations: {
+        getComponent: ({ componentId, branchId }: GetComponentPath, signal?: AbortSignal) => Promise<Component>;
+        getComponents: ({ branchId, ...query }?: GetComponentsPath & GetComponentsQuery, signal?: AbortSignal) => Promise<Component[]>;
+        searchComponentConfigurations: ({ branchId }?: GetSearchComponentConfigurationsPath, query?: SearchComponentConfigurationsQuery, signal?: AbortSignal) => Promise<SearchComponentConfiguration[]>;
+        createConfiguration: ({ branchId, componentId, ...body }: PartialKey<CreateConfigurationInput, "branchId">) => Promise<BaseComponentConfig>;
+        updateConfiguration: <T extends ConfigType = "unknown">({ branchId, componentId, configId, configuration, ...rest }: PartialKey<UpdateConfigurationInput, "branchId">, signal?: AbortSignal) => Promise<ComponentConfig<T>>;
+        getConfiguration: <T extends ConfigType = "unknown">({ componentId, configId, branchId }: ConfigurationPath, signal?: AbortSignal) => Promise<ComponentConfig<T>>;
+        getConfigurationDiff: ({ componentId, configId, branchId }: ConfigurationDiffPath, signal?: AbortSignal) => Promise<ConfigurationDiff>;
+        getConfigurationRowDiff: ({ componentId, configId, rowId, branchId }: ConfigurationRowDiffPath, signal?: AbortSignal) => Promise<ConfigurationRowDiff>;
+        rebaseConfiguration: ({ branchId, componentId, configId, ...body }: RebaseConfigurationInput) => Promise<BaseComponentConfig>;
+        deleteConfiguration: (path: Required<ConfigurationPath>) => Promise<void>;
+        deleteConfigurations: ({ configIds, ...rest }: Required<Omit<ConfigurationPath, "configId">> & {
+            configIds: string[];
+        }) => Promise<void>;
+        getConfigurations: <T extends ConfigType = "unknown">({ componentId, branchId }: GetConfigurationsPath, signal?: AbortSignal) => Promise<ComponentConfig<T>[]>;
+        createConfigurationRow: ({ branchId, componentId, configId, ...body }: PartialKey<CreateConfigurationRowInput, "branchId">) => Promise<Row>;
+        createConfigurationRows: ({ branchId, componentId, configId, data, }: PartialKey<CreateConfigurationRowsInput, "branchId">, options?: {
+            middlewares: MiddlewareFn<CreateConfigurationRowBody, Row>[];
+        }) => Promise<Row[]>;
+        deleteConfigurationRow: ({ changeDescription, ...path }: DeleteConfigurationRowInput) => Promise<void>;
+        deleteConfigurationRows: ({ rowIds, changeDescription, ...input }: DeleteConfigurationRowsInput, options?: {
+            middlewares: MiddlewareFn<string, void>[];
+        }) => Promise<void>;
+        createConfigurationWorkspace: ({ componentId, branchId, configId, ...body }: Required<ConfigurationPath> & CreateConfigurationWorkspaceBody) => Promise<Workspace>;
+        createConfigurationWorkspaceJob: ({ componentId, branchId, configId, ...body }: Required<ConfigurationPath> & CreateConfigurationWorkspaceBody) => Promise<{
+            id: number;
+            tableId: string | null;
+            runId: string;
+            url: string;
+            createdTime: string;
+            creatorToken: {
+                id: string;
+                description: string;
+            };
+            endTime: string | null;
+            startTime: string | null;
+            operationName: "workspaceCreate";
+            operationParams: {
+                queue: string;
+            } & {
+                backend: string;
+                backendConfiguration: [];
+                backendSize: null;
+                branchId: number;
+                componentId: string;
+                configurationId: string;
+                loginType: number;
+                networkPolicy: string;
+                publicKey: string;
+                readOnlyStorageAccess: boolean;
+                useCase: ConfigurationUseCaseType;
+            };
+            metrics: {
+                inCompressed: boolean;
+                inBytes: number;
+                inBytesUncompressed: number;
+                outCompressed: boolean;
+                outBytes: number;
+                outBytesUncompressed: number;
+            };
+        } & ({
+            status: Exclude<"error" | "success" | "warning" | "created" | "waiting" | "processing" | "terminating" | "terminated" | "cancelled", "success" | "error">;
+            results: null;
+        } | {
+            status: "error";
+            results: null;
+            error: {
+                code: string;
+                message: string;
+                exceptionId?: string;
+            };
+        } | {
+            status: "success";
+            results: Workspace;
+        })>;
+        getConfigurationWorkspaces: ({ componentId, branchId, configId, }: ConfigurationPath) => Promise<Workspace[]>;
+    };
+    configurationVersions: {
+        listConfigurationVersions: ({ branchId, componentId, configId }: ConfigurationVersionPath, signal?: AbortSignal) => Promise<ConfigurationVersion[]>;
+        getConfigurationVersion: ({ branchId, componentId, configId, versionId }: ConfigurationVersionDetailPath, signal?: AbortSignal) => Promise<ConfigurationVersionDetail>;
+    };
+    tokens: {
+        verify: (signal?: AbortSignal) => Promise<StorageToken>;
+        refresh: (id: string, signal?: AbortSignal) => Promise<StorageToken>;
+        getTokens: (signal?: AbortSignal) => Promise<{
+            id: string;
+            created: string;
+            refreshed: string;
+            description?: string | null;
+            uri: string;
+            isMasterToken: boolean;
+            canManageBuckets: boolean;
+            canManageTokens: boolean;
+            canReadAllFileUploads: boolean;
+            canPurgeTrash: boolean;
+            canManageProtectedDefaultBranch: boolean;
+            canCreateJobs: boolean;
+            canReadAllProjectEvents: boolean;
+            canManageDevBranches: boolean;
+            expires?: string | null;
+            isExpired: boolean;
+            isDisabled: boolean;
+            dailyCapacity: number;
+            token?: string | null;
+            creatorToken?: {
+                id?: number;
+                description?: string;
+            } | null;
+            componentAccess?: string[] | null;
+            bucketPermissions: {
+                [key: string]: string;
+            };
+            admin?: {
+                name?: string;
+                id?: number;
+                role?: string;
+            } | null;
+        }[]>;
+        createToken: (body: CreateTokenBody, signal?: AbortSignal) => Promise<{
+            id: string;
+            token: string;
+            created: string;
+            refreshed: string;
+            description?: string | null;
+            uri: string;
+            isMasterToken: boolean;
+            canManageBuckets: boolean;
+            canManageTokens: boolean;
+            canReadAllFileUploads: boolean;
+            canPurgeTrash: boolean;
+            expires?: string | null;
+            isExpired: boolean;
+            isDisabled: boolean;
+            dailyCapacity: number;
+            creatorToken: {
+                id?: number;
+                description?: string;
+            };
+            bucketPermissions: {
+                [key: string]: string;
+            };
+            canManageProtectedDefaultBranch: boolean;
+            canCreateJobs: boolean;
+            canReadAllProjectEvents: boolean;
+            canManageDevBranches: boolean;
+        }>;
+        updateToken: (id: string, body: UpdateTokenBody, signal?: AbortSignal) => Promise<StorageToken>;
+        deleteToken: (id: string, signal?: AbortSignal) => Promise<void>;
+        shareToken: (id: string, body: ShareTokenBody, signal?: AbortSignal) => Promise<void>;
+    };
+    triggers: {
+        listTriggers: (query?: ListTriggersQuery, signal?: AbortSignal) => Promise<{
+            id: string;
+            runWithTokenId: number;
+            component: string;
+            configurationId: string;
+            lastRun?: string | null;
+            creatorToken: {
+                id: number;
+                description: string;
+            };
+            coolDownPeriodMinutes: number;
+            tables: {
+                tableId: string;
+            }[];
+        }[]>;
+        createTrigger: (body: CreateTriggerBody, signal?: AbortSignal) => Promise<{
+            id: string;
+            runWithTokenId: number;
+            component: string;
+            configurationId: string;
+            lastRun?: string | null;
+            creatorToken: {
+                id: number;
+                description: string;
+            };
+            coolDownPeriodMinutes: number;
+            tables: {
+                tableId: string;
+            }[];
+        }>;
+        updateTrigger: (triggerId: string, body: UpdateTriggerBody, signal?: AbortSignal) => Promise<{
+            id: string;
+            runWithTokenId: number;
+            component: string;
+            configurationId: string;
+            lastRun?: string | null;
+            creatorToken: {
+                id: number;
+                description: string;
+            };
+            coolDownPeriodMinutes: number;
+            tables: {
+                tableId: string;
+            }[];
+        }>;
+        deleteTrigger: (triggerId: string, signal?: AbortSignal) => Promise<void>;
+    };
+    search: {
+        globalSearch: (query: GlobalSearchQuery, signal?: AbortSignal) => Promise<GlobalSearchResponse>;
+    };
+    stats: {
+        getRunIdStats: (runId: string, signal?: AbortSignal) => Promise<RunIdStats>;
+    };
+    getStackInfo: (query?: GetStackInfoQuery, signal?: AbortSignal) => Promise<StackInfo>;
+};
+
+export { type ConcurrentOptions as C, type GenericFetchClient as G, type MiddlewareFn as M, type StorageOpenApiFetchClient as S, concurrent as a, createStorageClient as c };