@keboola/api-client 0.1.0

package/dist/storage/types.js

@@ -0,0 +1,3 @@
+
+//# sourceMappingURL=types.js.map
+//# sourceMappingURL=types.js.map

package/dist/storage/types.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"types.js"}

package/dist/storageClient-DPLh_p0V.d.cts

@@ -0,0 +1,608 @@
+import { GetBucketsQuery, Bucket, BucketDetail, CreateBucketBody, UpdateBucketBody, CreateScheduledRefreshPath, CreateScheduledRefreshBody, ScheduledTask, GetEventsQuery, StorageEvent, CreateEventBody, File, GetFilesQuery, DeleteFileTagPath, PrepareFileBody, PreparedFile, GetTablesQuery, Table, TableDetail, GetDataPreview, PrevieData, DeleteTableRows, JobUnion, TableExportAsyncBody, TableExportJob, CreateTableAsyncBody, TableCreateJob, TableImportAsyncBody, TableImportJob, DevBranch, CreateDevBranchJobBody, DevBranchPath, BranchMetadata, BranchMetadataEntry, WorkspacePath, Workspace, WorkspacesPath, ResetWorkspacePassword, SetWorkspacePublicInput, GetWorkspaceSaml2LoginPath, WorkspaceSaml2Login, WorkspaceObject, DeleteWorkspaceObjectInput, MergeRequestDetail, MergeRequestDetailWithActivityLog, CreateMergeRequestParams, UpdateMergeRequestParams, JobOperation, GetJobPath, Job, GetJobsQuery, GetComponentPath, Component, GetComponentsPath, GetComponentsQuery, GetSearchComponentConfigurationsPath, SearchComponentConfigurationsQuery, SearchComponentConfiguration, PartialKey, CreateConfigurationInput, BaseComponentConfig, ConfigType, ConfigurationPath, ComponentConfig, GetConfigurationsPath, CreateConfigurationRowInput, Row, CreateConfigurationRowsInput, CreateConfigurationRowBody, DeleteConfigurationRowInput, DeleteConfigurationRowsInput, CreateConfigurationWorkspaceBody, ConfigurationUseCaseType, ConfigurationVersionPath, ConfigurationVersion, ConfigurationVersionDetailPath, ConfigurationVersionDetail, GetStackInfoQuery, StackInfo } from './storage/types.cjs';
+import { C as ClientInitOptions, M as MiddlewareFn$1 } from './types-DgaMV8FF.cjs';
+import { c as createGenericFetchClient } from './createGenericFetchClient-CLUzu-jY.cjs';
+import { c as createOpenapiFetchClient } from './createOpenapiFetchClient-CpXmAIFB.cjs';
+import { S as StorageToken } from './types-DYMMsuU0.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 = ClientInitOptions & {
+    middlewares?: MiddlewareFn$1[];
+};
+declare const createStorageClient: ({ baseUrl, middlewares }: StorageClientInitOptions) => {
+    buckets: {
+        getBuckets: (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>;
+    };
+    events: {
+        getEvents: (query?: GetEventsQuery, signal?: AbortSignal) => Promise<StorageEvent[]>;
+        getEvent: (eventId: string | number, signal?: AbortSignal) => Promise<StorageEvent>;
+        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: (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>;
+        importAsync: (tableId: string, body: TableImportAsyncBody, signal?: AbortSignal) => Promise<TableImportJob>;
+    };
+    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;
+            };
+        })>;
+    };
+    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;
+            }[];
+        }[]>;
+        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;
+            }[];
+        }>;
+        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;
+            }[];
+        }>;
+        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;
+            }[];
+        } & {
+            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;
+            }[];
+        } & {
+            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;
+            }[];
+        } & {
+            changeLog?: Record<string, never>;
+        }>;
+    };
+    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>;
+        getConfiguration: <T extends ConfigType = "unknown">({ componentId, configId, branchId }: ConfigurationPath, signal?: AbortSignal) => Promise<ComponentConfig<T>>;
+        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>;
+    };
+    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 };