@keboola/api-client 27.0.0 → 31.0.0

package/dist/chunk-ON4ILCHP.js

@@ -1,1822 +0,0 @@
-import { concurrent } from './chunk-ERZEQ5JR.js';
-import { createAuthHeaders } from './chunk-5A3AQIXR.js';
-import { createGenericFetchClient, createOpenapiFetchClient, KeboolaHttpHeader, isApiError, HttpHeader } from './chunk-2BQBKU6E.js';
-
-// src/errors/ServiceUnavailableError.ts
-var ServiceUnavailableError = class _ServiceUnavailableError extends Error {
-  constructor(serviceId, path, clientName) {
-    super(
-      `Service "${serviceId}" is not available in this stack. Caused by: ${clientName}.${path.join(".")}()`
-    );
-    this.name = "ServiceUnavailableError";
-    Object.setPrototypeOf(this, _ServiceUnavailableError.prototype);
-  }
-};
-
-// src/clients/storage/mergeRequests/mergeRequests.ts
-var createMergeRequests = (client) => {
-  const getMergeRequests = async (signal) => {
-    const { data } = await client.get("/v2/storage/merge-request", {}, { signal });
-    return data;
-  };
-  const getMergeRequest = async (id, signal) => {
-    const { data } = await client.get(
-      "/v2/storage/merge-request/{id}",
-      { path: { id } },
-      { signal }
-    );
-    return data;
-  };
-  const getMergeRequestWithActivityLog = async (id, signal) => {
-    const { data } = await client.get(
-      "/v2/storage/merge-request/{id}",
-      { path: { id }, query: { include: "activityLog" } },
-      { signal }
-    );
-    return data;
-  };
-  const createMergeRequest = async (params) => {
-    const { data } = await client.post("/v2/storage/merge-request", { body: params });
-    return data;
-  };
-  const updateMergeRequest = async (id, params) => {
-    const { data } = await client.put("/v2/storage/merge-request/{id}", {
-      path: { id },
-      body: params
-    });
-    return data;
-  };
-  const requestReview = async (id) => {
-    const { data } = await client.put("/v2/storage/merge-request/{id}/request-review", {
-      path: { id }
-    });
-    return data;
-  };
-  const approveMergeRequest = async (id) => {
-    const { data } = await client.put("/v2/storage/merge-request/{id}/approve", {
-      path: { id }
-    });
-    return data;
-  };
-  const requestChangesMergeRequest = async (id, reason) => {
-    const { data } = await client.put("/v2/storage/merge-request/{id}/request-changes", {
-      path: { id },
-      body: reason ? { reason } : void 0
-    });
-    return data;
-  };
-  const mergeMergeRequest = async (id) => {
-    const { data } = await client.put("/v2/storage/merge-request/{id}/merge", {
-      path: { id }
-    });
-    return data;
-  };
-  const getMergeRequestConflicts = async (id, signal) => {
-    const { data } = await client.get(
-      "/v2/storage/merge-request/{id}/conflicts",
-      { path: { id } },
-      { signal }
-    );
-    return data;
-  };
-  return {
-    getMergeRequests,
-    getMergeRequest,
-    getMergeRequestWithActivityLog,
-    createMergeRequest,
-    updateMergeRequest,
-    requestReview,
-    approveMergeRequest,
-    requestChangesMergeRequest,
-    mergeMergeRequest,
-    getMergeRequestConflicts
-  };
-};
-
-// src/clients/storage/branches/branches.ts
-var createBranches = (client) => {
-  const getDevBranches = async (signal) => {
-    const { data } = await client.get("/v2/storage/dev-branches", {}, { signal });
-    return data;
-  };
-  const createDevBranchAsync = async (body) => {
-    const { data } = await client.post("/v2/storage/dev-branches", {
-      body
-    });
-    return data;
-  };
-  const updateDevBranch = async ({ id, name, description }) => {
-    const { data } = await client.put("/v2/storage/dev-branches/{id}", {
-      path: { id: String(id) },
-      body: { name, description }
-    });
-    return data;
-  };
-  const deleteDevBranchAsync = async (id) => {
-    const { data } = await client.delete("/v2/storage/dev-branches/{id}", {
-      path: { id: String(id) }
-    });
-    return data;
-  };
-  const getDevBranchMetadata = async (branchId, signal) => {
-    const { data } = await client.get(
-      "/v2/storage/branch/{branchId}/metadata",
-      { path: { branchId } },
-      { signal }
-    );
-    return data;
-  };
-  const saveDevBranchMetadata = async ({ branchId, metadata }, signal) => {
-    const { data } = await client.post(
-      "/v2/storage/branch/{branchId}/metadata",
-      { path: { branchId }, body: { metadata } },
-      { signal }
-    );
-    return data;
-  };
-  const deleteDevBranchMetadata = async ({ branchId, metadataId }, signal) => {
-    await client.delete(
-      "/v2/storage/branch/{branchId}/metadata/{metadataId}",
-      { path: { branchId, metadataId } },
-      { signal }
-    );
-  };
-  return {
-    getDevBranches,
-    updateDevBranch,
-    createDevBranchAsync,
-    deleteDevBranchAsync,
-    getDevBranchMetadata,
-    saveDevBranchMetadata,
-    deleteDevBranchMetadata
-  };
-};
-
-// src/clients/storage/bucketExternal/bucketExternal.ts
-var createBucketExternal = (openApiClient) => {
-  const registerBucketAsync = async (body, signal) => {
-    const { data } = await openApiClient.post(
-      "/v2/storage/buckets/register",
-      {
-        query: { async: true },
-        body
-      },
-      { signal }
-    );
-    return data;
-  };
-  const getBucketRegistrationGuide = async (query, signal) => {
-    const { data } = await openApiClient.get(
-      "/v2/storage/buckets/register-guide",
-      // `brackets` appends the `[]` the API wants, so `path` stays unbracketed at the call site. The
-      // default `indices` would send `path[0]=…&path[1]=…`, which the API rejects with a 400 ("This
-      // value should be of type string").
-      { query },
-      { signal, queryArrayFormat: "brackets" }
-    );
-    return data;
-  };
-  const refreshExternalBucketAsync = async ({ bucketId, ...query }, signal) => {
-    const { data } = await openApiClient.put(
-      "/v2/storage/buckets/{bucketId}/refresh",
-      { path: { bucketId }, query },
-      { signal }
-    );
-    return data;
-  };
-  const createScheduledRefresh = async ({
-    branchId,
-    bucketId,
-    ...body
-  }) => {
-    const { data } = await openApiClient.post(
-      "/v2/storage/branch/{branchId}/buckets/{bucketId}/scheduled-tasks/refresh",
-      { path: { branchId, bucketId }, body }
-    );
-    return data;
-  };
-  const deleteScheduledTask = async (taskId) => {
-    await openApiClient.delete("/v2/storage/scheduled-tasks/{taskId}", { path: { taskId } });
-  };
-  return {
-    registerBucketAsync,
-    getBucketRegistrationGuide,
-    refreshExternalBucketAsync,
-    createScheduledRefresh,
-    deleteScheduledTask
-  };
-};
-
-// src/clients/storage/bucketListings/utils.ts
-var toBackendSubscribers = (subscribers) => subscribers.map((s) => `${s.type}:${s.email}`);
-var fromBackendSubscribers = (raw) => {
-  const result = [];
-  for (const entry of raw) {
-    const colon = entry.indexOf(":");
-    if (colon === -1) continue;
-    const prefix = entry.slice(0, colon);
-    const email = entry.slice(colon + 1);
-    if (prefix !== "user" && prefix !== "group") continue;
-    if (email.length === 0) continue;
-    result.push({ type: prefix, email });
-  }
-  return result;
-};
-var toUpdateListingBody = (input) => {
-  const body = {};
-  if (input.name !== void 0) body.exposureName = input.name;
-  if (input.description !== void 0) {
-    body.exposureDescription = input.description?.trim() || null;
-  }
-  if (input.subscribers !== void 0) {
-    body.bigquery = { subscribers: toBackendSubscribers(input.subscribers) };
-  }
-  if (Object.keys(body).length === 0) {
-    throw new Error("updateListingAsync requires at least one field");
-  }
-  return body;
-};
-
-// src/clients/storage/bucketListings/bucketListings.ts
-var createBucketListings = (openApiClient) => {
-  const getListing = async (bucketId, signal) => {
-    try {
-      const { data } = await openApiClient.get(
-        "/v2/storage/buckets/{bucketId}/listing",
-        { path: { bucketId } },
-        { signal }
-      );
-      return data;
-    } catch (error) {
-      if (isApiError(error) && error.response.status === 404) return null;
-      throw error;
-    }
-  };
-  const createListingAsync = async ({ bucketId, ...input }, signal) => {
-    const { data } = await openApiClient.post(
-      "/v2/storage/buckets/{bucketId}/listing",
-      {
-        path: { bucketId },
-        body: {
-          listingName: input.name,
-          listingDescription: input.description?.trim() || null,
-          bigquery: {
-            listingId: input.listingId,
-            subscribers: toBackendSubscribers(input.subscribers)
-          }
-        }
-      },
-      { signal }
-    );
-    return data;
-  };
-  const updateListingAsync = async ({ bucketId, ...input }, signal) => {
-    const { data } = await openApiClient.patch(
-      "/v2/storage/buckets/{bucketId}/listing",
-      {
-        path: { bucketId },
-        body: toUpdateListingBody(input)
-      },
-      { signal }
-    );
-    return data;
-  };
-  const deleteListingAsync = async (bucketId, signal) => {
-    const { data } = await openApiClient.delete(
-      "/v2/storage/buckets/{bucketId}/listing",
-      { path: { bucketId } },
-      { signal }
-    );
-    return data;
-  };
-  const getListings = async (signal) => {
-    const { data } = await openApiClient.get("/v2/storage/listings", {}, { signal });
-    return data;
-  };
-  return {
-    getListing,
-    createListingAsync,
-    updateListingAsync,
-    deleteListingAsync,
-    getListings
-  };
-};
-
-// src/clients/storage/buckets/buckets.ts
-var createBuckets = (openApiClient, client) => {
-  const getBuckets = async ({ branchId, ...query }, signal) => {
-    const { data } = await openApiClient.get(
-      "/v2/storage/branch/{branchId}/buckets",
-      { path: { branchId }, query },
-      { signal, queryArrayFormat: "comma" }
-    );
-    return data;
-  };
-  const getBucket = async ({ branchId, bucketId, include }, signal) => {
-    const { data } = await openApiClient.get(
-      "/v2/storage/branch/{branchId}/buckets/{bucketId}",
-      { path: { branchId, bucketId }, query: { include: include?.join(",") } },
-      { signal }
-    );
-    return data;
-  };
-  const createBucket = async (body) => {
-    const { data } = await openApiClient.post("/v2/storage/buckets", {
-      body
-    });
-    return data;
-  };
-  const updateBucket = async ({ bucketId, ...body }) => {
-    const { data } = await client.put(
-      `/v2/storage/buckets/{id}`,
-      { path: { id: bucketId }, body }
-    );
-    return data;
-  };
-  const deleteBucket = async (id) => {
-    await openApiClient.delete("/v2/storage/buckets/{bucketId}", { path: { bucketId: id } });
-  };
-  const deleteBucketAsync = async ({ bucketId, ...query }) => {
-    const { data } = await openApiClient.delete("/v2/storage/buckets/{bucketId}", {
-      path: { bucketId },
-      query: { async: true, ...query }
-    });
-    return data;
-  };
-  const getBucketOwner = async ({ branchId, bucketId }, signal) => {
-    const { data } = await openApiClient.get(
-      "/v2/storage/branch/{branchId}/buckets/{bucketId}/owner",
-      { path: { branchId, bucketId } },
-      { signal }
-    );
-    return data;
-  };
-  const updateBucketOwner = async ({ bucketId, ...body }, signal) => {
-    await openApiClient.post(
-      "/v2/storage/buckets/{bucketId}/owner",
-      { path: { bucketId }, body },
-      { signal }
-    );
-  };
-  const saveBucketMetadata = async ({ branchId, bucketId, ...body }, signal) => {
-    const { data } = await openApiClient.post(
-      "/v2/storage/branch/{branchId}/buckets/{bucketId}/metadata",
-      { path: { branchId, bucketId }, body },
-      { signal }
-    );
-    return data;
-  };
-  const deleteBucketMetadata = async ({ branchId, bucketId, metadataId }, signal) => {
-    await openApiClient.delete(
-      "/v2/storage/branch/{branchId}/buckets/{bucketId}/metadata/{metadataId}",
-      { path: { branchId, bucketId, metadataId } },
-      { signal }
-    );
-  };
-  return {
-    getBuckets,
-    getBucket,
-    createBucket,
-    updateBucket,
-    deleteBucket,
-    deleteBucketAsync,
-    getBucketOwner,
-    updateBucketOwner,
-    saveBucketMetadata,
-    deleteBucketMetadata
-  };
-};
-
-// src/clients/storage/bucketSharing/bucketSharing.ts
-var createBucketSharing = (openApiClient) => {
-  const shareBucketToOrganizationAsync = async ({ branchId, bucketId }, signal) => {
-    const { data } = await openApiClient.post(
-      "/v2/storage/branch/{branchId}/buckets/{bucketId}/share-organization",
-      {
-        path: { branchId, bucketId },
-        query: { async: true }
-      },
-      { signal }
-    );
-    return data;
-  };
-  const shareBucketToOrganizationProjectAsync = async ({ branchId, bucketId }, signal) => {
-    const { data } = await openApiClient.post(
-      "/v2/storage/branch/{branchId}/buckets/{bucketId}/share-organization-project",
-      {
-        path: { branchId, bucketId },
-        query: { async: true }
-      },
-      { signal }
-    );
-    return data;
-  };
-  const shareBucketToProjectsAsync = async ({ branchId, bucketId, ...body }, signal) => {
-    const { data } = await openApiClient.post(
-      "/v2/storage/branch/{branchId}/buckets/{bucketId}/share-to-projects",
-      {
-        path: { branchId, bucketId },
-        query: { async: true },
-        body
-      },
-      { signal }
-    );
-    return data;
-  };
-  const shareBucketToUsersAsync = async ({ branchId, bucketId, ...body }, signal) => {
-    const { data } = await openApiClient.post(
-      "/v2/storage/branch/{branchId}/buckets/{bucketId}/share-to-users",
-      {
-        path: { branchId, bucketId },
-        query: { async: true },
-        body
-      },
-      { signal }
-    );
-    return data;
-  };
-  const unshareBucketAsync = async ({ branchId, bucketId }, signal) => {
-    const { data } = await openApiClient.delete(
-      "/v2/storage/branch/{branchId}/buckets/{bucketId}/share",
-      {
-        path: { branchId, bucketId },
-        query: { async: true }
-      },
-      { signal }
-    );
-    return data;
-  };
-  const forceUnlinkBucketAsync = async ({ branchId, bucketId, linkedProjectId }, signal) => {
-    const { data } = await openApiClient.delete(
-      "/v2/storage/branch/{branchId}/buckets/{bucketId}/links/{linkedProjectId}",
-      {
-        path: { branchId, bucketId, linkedProjectId },
-        query: { async: true }
-      },
-      { signal }
-    );
-    return data;
-  };
-  const linkBucketAsync = async (body, signal) => {
-    const { data } = await openApiClient.post(
-      "/v2/storage/buckets",
-      { query: { async: true }, body },
-      { signal }
-    );
-    return data;
-  };
-  const sharedBuckets = async (signal) => {
-    const { data } = await openApiClient.get("/v2/storage/shared-buckets", {}, { signal });
-    return data;
-  };
-  return {
-    shareBucketToOrganizationAsync,
-    shareBucketToOrganizationProjectAsync,
-    shareBucketToProjectsAsync,
-    shareBucketToUsersAsync,
-    unshareBucketAsync,
-    forceUnlinkBucketAsync,
-    linkBucketAsync,
-    sharedBuckets
-  };
-};
-
-// src/clients/storage/columns/columns.ts
-var createColumns = (client) => {
-  const addTableColumnAsync = async ({ id, ...body }, signal) => {
-    const { data } = await client.post(
-      "/v2/storage/tables/{id}/columns",
-      { path: { id }, body },
-      { signal }
-    );
-    return data;
-  };
-  const deleteTableColumnAsync = async ({ tableId, columnName, ...query }, signal) => {
-    const { data } = await client.delete(
-      "/v2/storage/tables/{tableId}/columns/{columnName}",
-      { path: { tableId, columnName }, query },
-      { signal }
-    );
-    return data;
-  };
-  const createTablePrimaryKeyAsync = async ({ tableId, ...body }, signal) => {
-    const { data } = await client.post(
-      "/v2/storage/tables/{tableId}/primary-key",
-      { path: { tableId }, body },
-      { signal }
-    );
-    return data;
-  };
-  const removeTablePrimaryKeyAsync = async (tableId, signal) => {
-    const { data } = await client.delete(
-      "/v2/storage/tables/{tableId}/primary-key",
-      { path: { tableId } },
-      { signal }
-    );
-    return data;
-  };
-  const saveColumnMetadata = async ({ branchId, columnId, ...body }, signal) => {
-    const { data } = await client.post(
-      "/v2/storage/branch/{branchId}/columns/{id}/metadata",
-      { path: { branchId, id: columnId }, body },
-      { signal }
-    );
-    return data;
-  };
-  const deleteColumnMetadata = async ({ branchId, columnId, metadataId }, signal) => {
-    await client.delete(
-      "/v2/storage/branch/{branchId}/columns/{id}/metadata/{metadataId}",
-      { path: { branchId, id: columnId, metadataId } },
-      { signal }
-    );
-  };
-  return {
-    addTableColumnAsync,
-    deleteTableColumnAsync,
-    createTablePrimaryKeyAsync,
-    removeTablePrimaryKeyAsync,
-    saveColumnMetadata,
-    deleteColumnMetadata
-  };
-};
-
-// src/clients/storage/components/components.ts
-var createComponents = (client) => {
-  const getComponent = async ({ componentId, branchId = "default" }, signal) => {
-    const { data } = await client.get(
-      "/v2/storage/branch/{branchId}/components/{componentId}",
-      // The spec types this segment as a number, but `default` is a valid branch id,
-      // so it cannot be converted — only asserted.
-      { path: { componentId, branchId } },
-      { signal }
-    );
-    return data;
-  };
-  const getComponents = async ({ branchId = "default", ...query } = {}, signal) => {
-    const { data } = await client.get(
-      "/v2/storage/branch/{branchId}/components",
-      { path: { branchId: String(branchId) }, query },
-      { signal, queryArrayFormat: "comma" }
-    );
-    return data;
-  };
-  return {
-    getComponent,
-    getComponents
-  };
-};
-
-// src/clients/storage/configurationMetadata/configurationMetadata.ts
-var createConfigurationMetadata = (client) => {
-  const getConfigurationMetadata = async ({
-    branchId = "default",
-    componentId,
-    configurationId
-  }, signal) => {
-    const { data } = await client.get(
-      "/v2/storage/branch/{branchId}/components/{componentId}/configs/{configurationId}/metadata",
-      { path: { branchId, componentId, configurationId } },
-      { signal }
-    );
-    return data;
-  };
-  const saveConfigurationMetadata = async ({
-    branchId = "default",
-    componentId,
-    configurationId,
-    ...body
-  }) => {
-    const { data } = await client.post(
-      "/v2/storage/branch/{branchId}/components/{componentId}/configs/{configurationId}/metadata",
-      {
-        path: { branchId, componentId, configurationId },
-        body
-      }
-    );
-    return data;
-  };
-  const deleteConfigurationMetadata = async ({
-    branchId = "default",
-    componentId,
-    configurationId,
-    metadataId
-  }, signal) => {
-    await client.delete(
-      "/v2/storage/branch/{branchId}/components/{componentId}/configs/{configurationId}/metadata/{metadataId}",
-      { path: { branchId, componentId, configurationId, metadataId } },
-      { signal }
-    );
-  };
-  return { getConfigurationMetadata, saveConfigurationMetadata, deleteConfigurationMetadata };
-};
-
-// src/utils/async/series.ts
-var series = async (options) => concurrent({
-  ...options,
-  concurrency: 1
-});
-
-// src/clients/storage/configurationRows/configurationRows.ts
-var createConfigurationRows = (client) => {
-  const createConfigurationRow = async ({
-    branchId = "default",
-    componentId,
-    configurationId,
-    ...body
-  }) => {
-    const { data } = await client.post(
-      "/v2/storage/branch/{branchId}/components/{componentId}/configs/{configurationId}/rows",
-      {
-        path: { branchId, componentId, configurationId },
-        body
-      }
-    );
-    return data;
-  };
-  const createConfigurationRows2 = async ({
-    branchId = "default",
-    componentId,
-    configurationId,
-    data
-  }, options) => {
-    return series({
-      items: data,
-      process: (rowBody) => {
-        return createConfigurationRow({
-          branchId,
-          componentId,
-          configurationId,
-          ...rowBody
-        });
-      },
-      middlewares: options?.middlewares
-    });
-  };
-  const getConfigurationRow = async ({ branchId = "default", ...path }, signal) => {
-    const { data } = await client.get(
-      "/v2/storage/branch/{branchId}/components/{componentId}/configs/{configurationId}/rows/{rowId}",
-      { path: { branchId, ...path } },
-      { signal }
-    );
-    return data;
-  };
-  const updateConfigurationRow = async ({
-    branchId = "default",
-    componentId,
-    configurationId,
-    rowId,
-    ...body
-  }, signal) => {
-    const { data } = await client.put(
-      "/v2/storage/branch/{branchId}/components/{componentId}/configs/{configurationId}/rows/{rowId}",
-      {
-        path: { branchId, componentId, configurationId, rowId },
-        body
-      },
-      { signal }
-    );
-    return data;
-  };
-  const updateConfigurationRowState = async ({
-    branchId = "default",
-    componentId,
-    configurationId,
-    rowId,
-    ...body
-  }, signal) => {
-    const { data } = await client.put(
-      "/v2/storage/branch/{branchId}/components/{componentId}/configs/{configurationId}/rows/{rowId}/state",
-      {
-        path: { branchId, componentId, configurationId, rowId },
-        body
-      },
-      { signal }
-    );
-    return data;
-  };
-  const deleteConfigurationRow = async ({
-    changeDescription,
-    ...path
-  }) => {
-    await client.delete(
-      "/v2/storage/branch/{branchId}/components/{componentId}/configs/{configurationId}/rows/{rowId}",
-      { path, body: { changeDescription } }
-    );
-  };
-  const deleteConfigurationRows = async ({ rowIds, changeDescription, ...input }, options) => {
-    await concurrent({
-      items: rowIds,
-      process: (rowId) => {
-        const resolvedDescription = typeof changeDescription === "string" ? changeDescription : changeDescription?.(rowId);
-        return deleteConfigurationRow({
-          rowId,
-          changeDescription: resolvedDescription,
-          ...input
-        });
-      },
-      concurrency: 5,
-      middlewares: options?.middlewares
-    });
-  };
-  return {
-    createConfigurationRow,
-    createConfigurationRows: createConfigurationRows2,
-    getConfigurationRow,
-    updateConfigurationRow,
-    updateConfigurationRowState,
-    deleteConfigurationRow,
-    deleteConfigurationRows
-  };
-};
-
-// src/clients/storage/configurations/utils.ts
-var createVersionPrecondition = (expectedVersion) => expectedVersion === void 0 ? {} : { [HttpHeader.IF_MATCH]: `"${expectedVersion}"` };
-var parseSyncJobId = (headers) => {
-  const jobId = Number(headers.get(KeboolaHttpHeader.STORAGE_API_JOB_ID));
-  return Number.isInteger(jobId) && jobId > 0 ? jobId : null;
-};
-
-// src/clients/storage/configurations/configurations.ts
-var createConfigurations = (client) => {
-  const getConfiguration = async ({ componentId, configId, branchId = "default" }, signal) => {
-    const { data } = await client.get(
-      "/v2/storage/branch/{branchId}/components/{componentId}/configs/{configurationId}",
-      { path: { componentId, configurationId: configId, branchId: String(branchId) } },
-      { signal }
-    );
-    return data;
-  };
-  const getConfigurationDiff = async ({ componentId, configId, branchId }, signal) => {
-    const { data } = await client.get(
-      "/v2/storage/branch/{branchId}/components/{componentId}/configs/{configurationId}/diff",
-      { path: { componentId, configurationId: configId, branchId: String(branchId) } },
-      { signal }
-    );
-    return data;
-  };
-  const rebaseConfiguration = async ({
-    branchId,
-    componentId,
-    configId,
-    ...body
-  }) => {
-    const { data } = await client.post(
-      "/v2/storage/branch/{branchId}/components/{componentId}/configs/{configurationId}/rebase",
-      {
-        path: { branchId: String(branchId), componentId, configurationId: configId },
-        body
-      }
-    );
-    return data;
-  };
-  const createConfiguration = async ({
-    branchId = "default",
-    componentId,
-    ...body
-  }) => {
-    const { data } = await client.post(
-      "/v2/storage/branch/{branchId}/components/{componentId}/configs",
-      {
-        path: { branchId: String(branchId), componentId },
-        body
-      }
-    );
-    return data;
-  };
-  const updateConfiguration = async ({
-    branchId = "default",
-    componentId,
-    configId,
-    configuration,
-    workspaceId,
-    ...rest
-  }, signal) => {
-    const body = {
-      ...rest,
-      configuration
-    };
-    const { data, response } = await client.put(
-      "/v2/storage/branch/{branchId}/components/{componentId}/configs/{configurationId}",
-      {
-        path: { branchId: String(branchId), componentId, configurationId: configId },
-        query: { workspaceId },
-        body
-      },
-      { signal }
-    );
-    return {
-      configuration: data,
-      syncJobId: parseSyncJobId(response.headers)
-    };
-  };
-  const updateConfigurationState = async ({ branchId = "default", componentId, configId, ...body }, signal) => {
-    const { data } = await client.put(
-      "/v2/storage/branch/{branchId}/components/{componentId}/configs/{configurationId}/state",
-      {
-        path: { branchId: String(branchId), componentId, configurationId: configId },
-        body
-      },
-      { signal }
-    );
-    return data;
-  };
-  const deleteConfiguration = async ({
-    branchId,
-    componentId,
-    configId,
-    expectedVersion
-  }) => {
-    await client.delete(
-      "/v2/storage/branch/{branchId}/components/{componentId}/configs/{configurationId}",
-      { path: { branchId: String(branchId), componentId, configurationId: configId } },
-      { headers: { ...createVersionPrecondition(expectedVersion) } }
-    );
-  };
-  const purgeConfiguration = async ({
-    branchId = "default",
-    componentId,
-    configId,
-    expectedVersion
-  }) => {
-    await client.post(
-      "/v2/storage/branch/{branchId}/components/{componentId}/configs/{configurationId}/purge",
-      { path: { branchId: String(branchId), componentId, configurationId: configId } },
-      { headers: { ...createVersionPrecondition(expectedVersion) } }
-    );
-  };
-  const purgeConfigurations = async ({ branchId, configs }) => {
-    await concurrent({
-      items: configs,
-      concurrency: 10,
-      process: (config) => purgeConfiguration({ branchId, ...config })
-    });
-  };
-  const restoreConfiguration = async ({
-    branchId = "default",
-    componentId,
-    configId
-  }) => {
-    const { data } = await client.post(
-      "/v2/storage/branch/{branchId}/components/{componentId}/configs/{configurationId}/restore",
-      { path: { branchId: String(branchId), componentId, configurationId: configId } }
-    );
-    return data;
-  };
-  const resetConfigurationToDefault = async ({
-    branchId = "default",
-    componentId,
-    configId
-  }) => {
-    await client.post(
-      "/v2/storage/branch/{branchId}/components/{componentId}/configs/{configurationId}/reset-to-default",
-      { path: { branchId: String(branchId), componentId, configurationId: configId } }
-    );
-  };
-  const deleteConfigurations = async ({
-    configIds,
-    ...rest
-  }) => {
-    await concurrent({
-      items: configIds,
-      process: async (configId) => deleteConfiguration({ ...rest, configId })
-    });
-  };
-  const getConfigurations = async ({ componentId, branchId = "default" }, signal) => {
-    const { data } = await client.get(
-      "/v2/storage/branch/{branchId}/components/{componentId}/configs",
-      { path: { componentId, branchId: String(branchId) } },
-      { signal }
-    );
-    return data;
-  };
-  const searchComponentConfigurations = async ({ branchId = "default", include, ...query } = {}, signal) => {
-    const { data } = await client.get(
-      "/v2/storage/branch/{branchId}/search/component-configurations",
-      {
-        path: { branchId: String(branchId) },
-        // `include` is comma-separated on the wire (the spec types it `include?: string`), so it is
-        // joined here rather than pinning the whole query to `queryArrayFormat: 'comma'` — that pin
-        // is what used to break `metadataKeys`, which the API wants as a real array. Guard on
-        // `length`, not truthiness: `[]` is truthy and would send a bare `include=`, which is a
-        // different request from omitting the parameter.
-        //
-        // The component filter is `idComponent`, not `componentId`: the API rejects the latter with
-        // "This field was not expected" (the live nightly caught it, and kbc-ui's legacy client has
-        // always sent `idComponent` in production), so the previous divergence from the spec was a
-        // bug rather than a deliberate choice.
-        query: {
-          ...query,
-          ...include?.length && { include: include.join(",") }
-        }
-      },
-      { signal }
-    );
-    return data;
-  };
-  return {
-    createConfiguration,
-    updateConfiguration,
-    updateConfigurationState,
-    getConfiguration,
-    getConfigurationDiff,
-    rebaseConfiguration,
-    deleteConfiguration,
-    deleteConfigurations,
-    purgeConfiguration,
-    purgeConfigurations,
-    getConfigurations,
-    restoreConfiguration,
-    resetConfigurationToDefault,
-    searchComponentConfigurations
-  };
-};
-
-// src/clients/storage/configurationVersions/configurationVersions.ts
-var createConfigurationVersions = (client) => {
-  const getConfigurationVersions = async ({ branchId, componentId, configurationId }, signal) => {
-    const { data } = await client.get(
-      "/v2/storage/branch/{branchId}/components/{componentId}/configs/{configurationId}/versions",
-      { path: { branchId: String(branchId), componentId, configurationId } },
-      { signal }
-    );
-    return data;
-  };
-  const getConfigurationVersion = async ({ branchId, componentId, configurationId, versionId }, signal) => {
-    const { data } = await client.get(
-      "/v2/storage/branch/{branchId}/components/{componentId}/configs/{configurationId}/versions/{versionId}",
-      {
-        path: {
-          branchId: String(branchId),
-          componentId,
-          configurationId,
-          versionId: String(versionId)
-        }
-      },
-      { signal }
-    );
-    return data;
-  };
-  const rollbackConfigurationToVersion = async ({
-    branchId = "default",
-    componentId,
-    configurationId,
-    versionId
-  }) => {
-    const { data } = await client.post(
-      "/v2/storage/branch/{branchId}/components/{componentId}/configs/{configurationId}/versions/{versionId}/rollback",
-      {
-        path: {
-          branchId: String(branchId),
-          componentId,
-          configurationId,
-          versionId: String(versionId)
-        },
-        // The spec declares a required body for this operation; it takes none, and
-        // an empty object is dropped before the request is built.
-        body: {}
-      }
-    );
-    return data;
-  };
-  const copyConfigurationFromVersion = async ({
-    branchId = "default",
-    componentId,
-    configurationId,
-    versionId,
-    ...body
-  }) => {
-    const { data } = await client.post(
-      "/v2/storage/branch/{branchId}/components/{componentId}/configs/{configurationId}/versions/{versionId}/create",
-      {
-        path: {
-          branchId: String(branchId),
-          componentId,
-          configurationId,
-          versionId: String(versionId)
-        },
-        body
-      }
-    );
-    return data;
-  };
-  const getConfigurationRowVersions = async ({ branchId, componentId, configurationId, rowId }, signal) => {
-    const { data } = await client.get(
-      "/v2/storage/branch/{branchId}/components/{componentId}/configs/{configurationId}/rows/{rowId}/versions",
-      { path: { branchId: String(branchId), componentId, configurationId, rowId } },
-      { signal }
-    );
-    return data;
-  };
-  const getConfigurationRowVersion = async ({ branchId, componentId, configurationId, rowId, versionId }, signal) => {
-    const { data } = await client.get(
-      "/v2/storage/branch/{branchId}/components/{componentId}/configs/{configurationId}/rows/{rowId}/versions/{versionId}",
-      {
-        path: {
-          branchId: String(branchId),
-          componentId,
-          configurationId,
-          rowId,
-          versionId: String(versionId)
-        }
-      },
-      { signal }
-    );
-    return data;
-  };
-  const rollbackConfigurationRowToVersion = async ({
-    branchId = "default",
-    componentId,
-    configurationId,
-    rowId,
-    versionId
-  }) => {
-    const { data } = await client.post(
-      "/v2/storage/branch/{branchId}/components/{componentId}/configs/{configurationId}/rows/{rowId}/versions/{versionId}/rollback",
-      {
-        path: {
-          branchId: String(branchId),
-          componentId,
-          configurationId,
-          rowId,
-          versionId: String(versionId)
-        },
-        // Required-but-empty body, same as the configuration-level rollback above.
-        body: {}
-      }
-    );
-    return data;
-  };
-  const copyConfigurationRowFromVersion = async ({
-    branchId = "default",
-    componentId,
-    configurationId,
-    rowId,
-    versionId
-  }) => {
-    const { data } = await client.post(
-      "/v2/storage/branch/{branchId}/components/{componentId}/configs/{configurationId}/rows/{rowId}/versions/{versionId}/create",
-      {
-        path: {
-          branchId: String(branchId),
-          componentId,
-          configurationId,
-          rowId,
-          versionId: String(versionId)
-        },
-        body: {}
-      }
-    );
-    return data;
-  };
-  return {
-    getConfigurationVersions,
-    getConfigurationVersion,
-    rollbackConfigurationToVersion,
-    copyConfigurationFromVersion,
-    getConfigurationRowVersions,
-    getConfigurationRowVersion,
-    rollbackConfigurationRowToVersion,
-    copyConfigurationRowFromVersion
-  };
-};
-
-// src/clients/storage/configurationWorkspaces/configurationWorkspaces.ts
-var createConfigurationWorkspaces = (client) => {
-  const getConfigurationWorkspaces = async ({
-    componentId,
-    branchId,
-    configurationId
-  }) => {
-    const { data } = await client.get(
-      "/v2/storage/branch/{branchId}/components/{componentId}/configs/{configurationId}/workspaces",
-      { path: { componentId, branchId, configurationId } }
-    );
-    return data;
-  };
-  const createConfigurationWorkspace = async ({
-    componentId,
-    branchId,
-    configurationId,
-    ...body
-  }) => {
-    const { data } = await client.post(
-      "/v2/storage/branch/{branchId}/components/{componentId}/configs/{configurationId}/workspaces",
-      { path: { componentId, branchId, configurationId }, body }
-    );
-    return data;
-  };
-  const createConfigurationWorkspaceJob = async ({
-    componentId,
-    branchId,
-    configurationId,
-    ...body
-  }) => {
-    const { data } = await client.post(
-      "/v2/storage/branch/{branchId}/components/{componentId}/configs/{configurationId}/workspaces",
-      {
-        path: { componentId, branchId, configurationId },
-        body,
-        query: { async: true }
-      }
-    );
-    return data;
-  };
-  return {
-    createConfigurationWorkspace,
-    createConfigurationWorkspaceJob,
-    getConfigurationWorkspaces
-  };
-};
-
-// src/clients/storage/events/events.ts
-var createEvents = (client, openApiClient) => {
-  const getEvents = async (query, signal) => {
-    const { data } = await client.get(
-      "/v2/storage/events",
-      { query },
-      { signal }
-    );
-    return data;
-  };
-  const getEvent = async (eventId, signal) => {
-    const { data } = await client.get(
-      "/v2/storage/events/{eventId}",
-      {
-        path: { eventId }
-      },
-      { signal }
-    );
-    return data;
-  };
-  const getTableEvents = async ({ branchId, tableId, ...query }, signal) => {
-    const { data } = await openApiClient.get(
-      "/v2/storage/branch/{branchId}/tables/{tableId}/events",
-      { path: { branchId, tableId }, query },
-      { signal }
-    );
-    return data;
-  };
-  const getBucketEvents = async ({ branchId, bucketId, ...query }, signal) => {
-    const { data } = await openApiClient.get(
-      "/v2/storage/branch/{branchId}/buckets/{bucketId}/events",
-      { path: { branchId, bucketId }, query },
-      { signal }
-    );
-    return data;
-  };
-  const createEvent = async (body, signal) => {
-    const { data } = await client.post(
-      "/v2/storage/events",
-      {
-        body
-      },
-      { signal }
-    );
-    return data;
-  };
-  return {
-    getEvents,
-    getEvent,
-    getTableEvents,
-    getBucketEvents,
-    createEvent
-  };
-};
-
-// src/clients/storage/files/files.ts
-var createFiles = (client) => {
-  const getFile = async (fileId, signal) => {
-    const { data } = await client.get(
-      `/v2/storage/files/{fileId}`,
-      {
-        path: { fileId }
-      },
-      { signal }
-    );
-    return data;
-  };
-  const getFiles = async (query, signal) => {
-    const { data } = await client.get(
-      "/v2/storage/files",
-      { query },
-      { signal, queryArrayFormat: "brackets" }
-    );
-    return data;
-  };
-  const deleteFile = async (fileId) => {
-    const { data } = await client.delete(`/v2/storage/files/{fileId}`, {
-      path: { fileId }
-    });
-    return data;
-  };
-  const addFileTag = async (fileId, tag) => {
-    const { data } = await client.post(
-      `/v2/storage/files/{fileId}/tags`,
-      {
-        path: { fileId },
-        body: { tag }
-      }
-    );
-    return data;
-  };
-  const getFileContent = async (fileId, signal) => {
-    const { data } = await client.get(
-      `/v2/storage/files/{fileId}/content`,
-      {
-        path: { fileId }
-      },
-      { signal }
-    );
-    return typeof data === "string" ? data : JSON.stringify(data, null, 2);
-  };
-  const deleteFileTag = async (fileId, tag) => {
-    const { data } = await client.delete(
-      "/v2/storage/files/{fileId}/tags/{tag}",
-      {
-        path: { fileId, tag }
-      }
-    );
-    return data;
-  };
-  const prepareFile = async (body, signal) => {
-    const { data } = await client.post(
-      "/v2/storage/files/prepare",
-      { body },
-      { signal }
-    );
-    return data;
-  };
-  return {
-    getFile,
-    getFileContent,
-    getFiles,
-    deleteFile,
-    addFileTag,
-    deleteFileTag,
-    prepareFile
-  };
-};
-
-// src/clients/storage/jobs/jobs.ts
-var createJobs = (client) => {
-  const getJob = async (id, signal) => {
-    const { data } = await client.get(
-      `/v2/storage/jobs/{id}`,
-      {
-        path: { id }
-      },
-      { signal }
-    );
-    return data;
-  };
-  const getJobs = async (query, signal) => {
-    const { data } = await client.get(
-      "/v2/storage/jobs",
-      { query },
-      { signal, queryArrayFormat: "brackets" }
-    );
-    return data;
-  };
-  return { getJob, getJobs };
-};
-
-// src/clients/storage/refreshTokenMiddleware.ts
-var isTokenRefreshEndpoint = (request) => {
-  const url = new URL(request.url);
-  return request.method === "POST" && /\/tokens\/[^/]+\/refresh$/.test(url.pathname);
-};
-var tryParseNewToken = (data) => {
-  if (data === null || typeof data !== "object") return null;
-  const token = data.token;
-  return typeof token === "string" ? token : null;
-};
-var createRefreshTokenMiddlware = ({ accessToken, onRefresh }) => {
-  let current = accessToken;
-  return (next) => async (request) => {
-    request.request.headers.set(KeboolaHttpHeader.STORAGE_API_TOKEN, current);
-    if (!isTokenRefreshEndpoint(request.request)) return next(request);
-    const response = await next(request);
-    const newToken = tryParseNewToken(response.data);
-    if (newToken === null) return response;
-    current = newToken;
-    onRefresh?.(current);
-    return response;
-  };
-};
-
-// src/clients/storage/search/search.ts
-var createSearch = (client) => {
-  const globalSearch = async (query, signal) => {
-    const { data } = await client.get(
-      "/v2/storage/global-search",
-      { query },
-      { signal }
-    );
-    return data;
-  };
-  const searchTables = async (query, signal) => {
-    const { data } = await client.get(
-      "/v2/storage/search/tables",
-      { query },
-      { signal, queryArrayFormat: "comma" }
-    );
-    return data;
-  };
-  return { globalSearch, searchTables };
-};
-
-// src/clients/storage/snapshots/snapshots.ts
-var createSnapshots = (client) => {
-  const createSnapshotAsync = async ({ branchId, tableId, ...body }, signal) => {
-    const { data } = await client.post(
-      "/v2/storage/branch/{branchId}/tables/{id}/snapshots",
-      { path: { branchId, id: tableId }, body },
-      { signal }
-    );
-    return data;
-  };
-  const getSnapshot = async (snapshotId, signal) => {
-    const { data } = await client.get(
-      "/v2/storage/snapshots/{snapshotId}",
-      { path: { snapshotId } },
-      { signal }
-    );
-    return data;
-  };
-  const deleteSnapshotAsync = async (snapshotId, signal) => {
-    const { data } = await client.delete(
-      "/v2/storage/snapshots/{snapshotId}",
-      { path: { snapshotId } },
-      { signal }
-    );
-    return data;
-  };
-  const getTableSnapshots = async ({ branchId, tableId, ...query }, signal) => {
-    const { data } = await client.get(
-      "/v2/storage/branch/{branchId}/tables/{id}/snapshots",
-      { path: { branchId, id: tableId }, query },
-      { signal }
-    );
-    return data;
-  };
-  return {
-    createSnapshotAsync,
-    deleteSnapshotAsync,
-    getSnapshot,
-    getTableSnapshots
-  };
-};
-
-// src/clients/storage/stats/stats.ts
-var createStats = (client) => {
-  const getRunIdStats = async (runId, signal) => {
-    const { data } = await client.get("/v2/storage/stats", { query: { runId } }, { signal });
-    return data;
-  };
-  return { getRunIdStats };
-};
-
-// src/clients/storage/tables/tables.ts
-var createTables = (openApiClient, client) => {
-  const getTables = async ({ branchId, include = [], ...query }, signal) => {
-    const { data } = await openApiClient.get(
-      "/v2/storage/branch/{branchId}/tables",
-      { path: { branchId }, query: { include, ...query } },
-      { signal, queryArrayFormat: "comma" }
-    );
-    return data;
-  };
-  const getTable = async ({ branchId, tableId }, signal) => {
-    const { data } = await openApiClient.get(
-      "/v2/storage/branch/{branchId}/tables/{id}",
-      { path: { branchId, id: tableId } },
-      { signal }
-    );
-    return data;
-  };
-  const deleteTable = async (id, signal) => {
-    await openApiClient.delete("/v2/storage/tables/{id}", { path: { id } }, { signal });
-  };
-  const deleteTables = async (ids) => {
-    await concurrent({
-      items: ids,
-      process: (id) => deleteTable(id)
-    });
-  };
-  const deleteTableRows = async ({ tableId, ...query }, signal) => {
-    const { data } = await openApiClient.delete(
-      "/v2/storage/tables/{id}/rows",
-      { path: { id: tableId }, query },
-      { signal }
-    );
-    return data;
-  };
-  const getDataPreview = async ({ branchId, tableId, ...query }, signal) => {
-    const { data } = await openApiClient.get(
-      "/v2/storage/branch/{branchId}/tables/{tableId}/data-preview",
-      {
-        path: { branchId, tableId },
-        query: { format: "json", ...query }
-      },
-      { signal }
-    );
-    return data;
-  };
-  const exportAsync = async ({ tableId, ...body }, signal) => {
-    const { data } = await client.post(
-      "/v2/storage/tables/{id}/export-async",
-      { path: { id: tableId }, body },
-      { signal }
-    );
-    return data;
-  };
-  const createTableAsync = async ({ bucketId, ...body }, signal) => {
-    const { data } = await client.post("/v2/storage/buckets/{bucketId}/tables-async", { path: { bucketId }, body }, { signal });
-    return data;
-  };
-  const createTableDefinitionAsync = async ({ bucketId, ...body }, signal) => {
-    const { data } = await openApiClient.post(
-      "/v2/storage/buckets/{bucketId}/tables-definition",
-      { path: { bucketId }, body },
-      { signal }
-    );
-    return data;
-  };
-  const importAsync = async ({ tableId, ...body }, signal) => {
-    const { data } = await openApiClient.post(
-      "/v2/storage/tables/{id}/import-async",
-      { path: { id: tableId }, body },
-      { signal }
-    );
-    return data;
-  };
-  const updateTableDefinition = async ({ branchId = "default", tableId, ...body }, signal) => {
-    const { data } = await openApiClient.put(
-      "/v2/storage/branch/{branchId}/tables/{tableId}/definition",
-      { path: { branchId, tableId }, body },
-      { signal }
-    );
-    return data;
-  };
-  const updateTable = async ({ tableId, ...body }, signal) => {
-    const { data } = await client.put(
-      "/v2/storage/tables/{id}",
-      { path: { id: tableId }, body },
-      { signal }
-    );
-    return data;
-  };
-  const pullTableAsync = async ({ branchId = "default", tableId }, signal) => {
-    const { data } = await openApiClient.post(
-      "/v2/storage/branch/{branchId}/tables/{id}/pull",
-      { path: { branchId, id: tableId } },
-      { signal }
-    );
-    return data;
-  };
-  const createAliasTable = async ({ bucketId, ...body }, signal) => {
-    const { data } = await client.post("/v2/storage/buckets/{bucketId}/table-aliases", { path: { bucketId }, body }, { signal });
-    return data;
-  };
-  const setAliasTableFilter = async ({ tableId, ...body }, signal) => {
-    const { data } = await client.post(
-      "/v2/storage/tables/{id}/alias-filter",
-      { path: { id: tableId }, body },
-      { signal }
-    );
-    return data;
-  };
-  const removeAliasTableFilter = async (tableId, signal) => {
-    await client.delete(
-      "/v2/storage/tables/{id}/alias-filter",
-      { path: { id: tableId } },
-      { signal }
-    );
-  };
-  const saveTableMetadata = async ({ branchId, tableId, ...body }, signal) => {
-    const { data } = await openApiClient.post(
-      "/v2/storage/branch/{branchId}/tables/{id}/metadata",
-      // The spec models the body as the empty `CreateTableMetadataRequest`, so it cannot describe
-      // the provider + items this endpoint requires; `SaveMetadataBody` is the real shape.
-      { path: { branchId, id: tableId }, body },
-      { signal }
-    );
-    return data;
-  };
-  const deleteTableMetadata = async ({ branchId, tableId, metadataId }, signal) => {
-    await openApiClient.delete(
-      "/v2/storage/branch/{branchId}/tables/{id}/metadata/{metadataId}",
-      { path: { branchId, id: tableId, metadataId } },
-      { signal }
-    );
-  };
-  return {
-    getTables,
-    getTable,
-    getDataPreview,
-    deleteTable,
-    deleteTables,
-    deleteTableRows,
-    exportAsync,
-    createTableAsync,
-    createTableDefinitionAsync,
-    importAsync,
-    updateTableDefinition,
-    updateTable,
-    pullTableAsync,
-    createAliasTable,
-    setAliasTableFilter,
-    removeAliasTableFilter,
-    saveTableMetadata,
-    deleteTableMetadata
-  };
-};
-
-// src/clients/storage/tokens/tokens.ts
-var createTokens = (openApiClient) => {
-  const verify = async (signal) => {
-    const { data } = await openApiClient.get("/v2/storage/tokens/verify", {}, { signal });
-    return data;
-  };
-  const refresh = async (id, signal) => {
-    const { data } = await openApiClient.post(
-      "/v2/storage/tokens/{id}/refresh",
-      { path: { id } },
-      { signal }
-    );
-    return data;
-  };
-  const getTokens = async (signal) => {
-    const { data } = await openApiClient.get("/v2/storage/tokens", {}, { signal });
-    return data;
-  };
-  const createToken = async (body, signal) => {
-    const { data } = await openApiClient.post(
-      "/v2/storage/tokens",
-      { body },
-      { signal }
-    );
-    return data;
-  };
-  const updateToken = async ({ id, ...body }, signal) => {
-    const { data } = await openApiClient.put(
-      "/v2/storage/tokens/{id}",
-      { path: { id }, body },
-      { signal }
-    );
-    return data;
-  };
-  const deleteToken = async (id, signal) => {
-    await openApiClient.delete(
-      "/v2/storage/tokens/{id}",
-      { path: { id } },
-      { signal }
-    );
-  };
-  const shareToken = async ({ id, ...body }, signal) => {
-    await openApiClient.post(
-      "/v2/storage/tokens/{id}/share",
-      { path: { id }, body },
-      { signal }
-    );
-  };
-  return {
-    verify,
-    refresh,
-    getTokens,
-    createToken,
-    updateToken,
-    deleteToken,
-    shareToken
-  };
-};
-
-// src/clients/storage/triggers/triggers.ts
-var createTriggers = (client) => {
-  const getTriggers = async (query, signal) => {
-    const { data } = await client.get("/v2/storage/triggers", { query }, { signal });
-    return data;
-  };
-  const createTrigger = async (body, signal) => {
-    const { data } = await client.post("/v2/storage/triggers", { body }, { signal });
-    return data;
-  };
-  const updateTrigger = async ({ triggerId, ...body }, signal) => {
-    const { data } = await client.put(
-      "/v2/storage/triggers/{triggerId}",
-      {
-        path: { triggerId },
-        body
-      },
-      { signal }
-    );
-    return data;
-  };
-  const deleteTrigger = async (triggerId, signal) => {
-    await client.delete(
-      "/v2/storage/triggers/{triggerId}",
-      { path: { triggerId } },
-      { signal }
-    );
-  };
-  return {
-    getTriggers,
-    createTrigger,
-    updateTrigger,
-    deleteTrigger
-  };
-};
-
-// src/clients/storage/workspaces/workspaces.ts
-var createWorkspaces = (client, openApiClient) => {
-  const getWorkspaces = async (branchId, signal) => {
-    const { data } = await client.get(
-      "/v2/storage/branch/{branchId}/workspaces",
-      { path: { branchId } },
-      { signal }
-    );
-    return data;
-  };
-  const getWorkspace = async (path, signal) => {
-    const { data } = await client.get(
-      "/v2/storage/branch/{branchId}/workspaces/{workspaceId}",
-      { path },
-      { signal }
-    );
-    return data;
-  };
-  const deleteWorkspace = async (path) => {
-    await client.delete(
-      "/v2/storage/branch/{branchId}/workspaces/{workspaceId}",
-      { path }
-    );
-  };
-  const deleteWorkspaces = async ({
-    workspaceIds,
-    branchId
-  }) => {
-    await concurrent({
-      items: workspaceIds,
-      process: async (workspaceId) => deleteWorkspace({ branchId, workspaceId }),
-      concurrency: 5
-    });
-  };
-  const deleteWorkspaceJob = async (path) => {
-    const { data } = await client.delete(
-      "/v2/storage/branch/{branchId}/workspaces/{workspaceId}",
-      { path, query: { async: true } },
-      {}
-    );
-    return data;
-  };
-  const resetWorkspacePassword = async ({ branchId, workspaceId }) => {
-    const { data } = await client.post(
-      "/v2/storage/branch/{branchId}/workspaces/{workspaceId}/password",
-      {
-        path: { branchId, workspaceId }
-      }
-    );
-    return data;
-  };
-  const getWorkspaceSaml2Login = async (path, signal) => {
-    const { data } = await client.get(
-      "/v2/storage/branch/{branchId}/workspaces/{workspaceId}/saml2-login",
-      { path },
-      { signal }
-    );
-    return data;
-  };
-  const setWorkspacePublicKey = async ({
-    branchId,
-    workspaceId,
-    publicKey
-  }) => {
-    const { data } = await client.post("/v2/storage/branch/{branchId}/workspaces/{workspaceId}/public-key", {
-      path: { branchId, workspaceId },
-      body: { publicKey }
-    });
-    return data;
-  };
-  const getWorkspaceObjects = async (path, signal) => {
-    const { data } = await client.get(
-      "/v2/storage/branch/{branchId}/workspaces/{workspaceId}/objects",
-      { path },
-      { signal }
-    );
-    return data;
-  };
-  const deleteWorkspaceObjectsAsync = async ({
-    branchId,
-    workspaceId,
-    ...body
-  }) => {
-    const { data } = await client.post("/v2/storage/branch/{branchId}/workspaces/{workspaceId}/objects/batch-delete", {
-      path: { branchId, workspaceId },
-      body
-    });
-    return data;
-  };
-  const unloadWorkspace = async ({ branchId, workspaceId, ...query }) => {
-    const { data } = await openApiClient.post(
-      "/v2/storage/branch/{branchId}/workspaces/{workspaceId}/unload",
-      {
-        path: { branchId, workspaceId },
-        query
-      }
-    );
-    return data;
-  };
-  const inputMappingLoadPreview = async ({ branchId, body, backend }, signal) => {
-    const { data } = await openApiClient.post(
-      "/v2/storage/branch/{branchId}/input-mapping-load/preview",
-      {
-        path: { branchId: String(branchId) },
-        query: backend ? { backend } : void 0,
-        body
-      },
-      { signal }
-    );
-    return data;
-  };
-  return {
-    getWorkspace,
-    getWorkspaces,
-    deleteWorkspace,
-    resetWorkspacePassword,
-    deleteWorkspaces,
-    deleteWorkspaceJob,
-    setWorkspacePublicKey,
-    getWorkspaceSaml2Login,
-    getWorkspaceObjects,
-    deleteWorkspaceObjectsAsync,
-    unloadWorkspace,
-    inputMappingLoadPreview
-  };
-};
-
-// src/clients/storage/storageClient.ts
-var createStorageClient = ({
-  baseUrl,
-  auth,
-  middlewares = [],
-  onRefreshToken
-}) => {
-  const headers = createAuthHeaders(auth);
-  const allMiddlewares = onRefreshToken && auth.type === "sapi-token" ? [
-    ...middlewares,
-    createRefreshTokenMiddlware({ accessToken: auth.token, onRefresh: onRefreshToken })
-  ] : middlewares;
-  const client = createGenericFetchClient({
-    baseUrl,
-    middlewares: allMiddlewares,
-    headers
-  });
-  const openApiClient = createOpenapiFetchClient({
-    baseUrl,
-    middlewares: allMiddlewares,
-    headers
-  });
-  const getStackInfo = async (query, signal) => {
-    const { data } = await client.get(
-      "/v2/storage",
-      { query },
-      { signal }
-    );
-    return data;
-  };
-  const healthCheck = async (signal) => {
-    const { data } = await client.get("/health-check", {}, { signal });
-    return data;
-  };
-  return {
-    healthCheck,
-    getStackInfo,
-    buckets: createBuckets(openApiClient, client),
-    bucketSharing: createBucketSharing(openApiClient),
-    bucketListings: createBucketListings(openApiClient),
-    bucketExternal: createBucketExternal(openApiClient),
-    tables: createTables(openApiClient, client),
-    columns: createColumns(openApiClient),
-    snapshots: createSnapshots(openApiClient),
-    branches: createBranches(openApiClient),
-    mergeRequests: createMergeRequests(openApiClient),
-    events: createEvents(client, openApiClient),
-    files: createFiles(client),
-    workspaces: createWorkspaces(client, openApiClient),
-    jobs: createJobs(client),
-    tokens: createTokens(openApiClient),
-    triggers: createTriggers(openApiClient),
-    search: createSearch(openApiClient),
-    stats: createStats(openApiClient),
-    components: createComponents(openApiClient),
-    configurations: createConfigurations(openApiClient),
-    configurationRows: createConfigurationRows(openApiClient),
-    configurationWorkspaces: createConfigurationWorkspaces(openApiClient),
-    configurationMetadata: createConfigurationMetadata(openApiClient),
-    configurationVersions: createConfigurationVersions(openApiClient)
-  };
-};
-
-export { ServiceUnavailableError, createStorageClient, fromBackendSubscribers, series, toBackendSubscribers };
-//# sourceMappingURL=chunk-ON4ILCHP.js.map
-//# sourceMappingURL=chunk-ON4ILCHP.js.map