@keboola/api-client 24.0.0 → 27.0.0

package/dist/{chunk-WFXW4XU3.js → chunk-ON4ILCHP.js}

@@ -1,6 +1,6 @@
-import { concurrent } from './chunk-SJZ66FD5.js';
-import { createAuthHeaders } from './chunk-EDX5D6UY.js';
-import { createGenericFetchClient, createOpenapiFetchClient, KeboolaHttpHeader, isApiError } from './chunk-XHDYLUM4.js';
+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 {
@@ -93,84 +93,121 @@ var createMergeRequests = (client) => {
   };
 };
 
-// src/clients/storage/branches/mappers.ts
-var mapBranchMetadata = (data) => ({
-  ...data,
-  timestamp: new Date(data.timestamp)
-});
-
 // 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 createDevBranchJob = async (body) => {
-    const { data } = await client.post(
-      "/v2/storage/dev-branches",
-      {
-        body
-      }
-    );
+  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 },
-        body: {
-          name,
-          description
-        }
-      }
-    );
+  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 deleteDevBranchJob = async (id) => {
-    const { data } = await client.delete(
-      "/v2/storage/dev-branches/{id}",
-      {
-        path: { id }
-      }
-    );
+  const deleteDevBranchAsync = async (id) => {
+    const { data } = await client.delete("/v2/storage/dev-branches/{id}", {
+      path: { id: String(id) }
+    });
     return data;
   };
-  const getDevBranchMetadata = async (id, signal) => {
+  const getDevBranchMetadata = async (branchId, signal) => {
     const { data } = await client.get(
-      "/v2/storage/branch/{id}/metadata",
-      { path: { id } },
+      "/v2/storage/branch/{branchId}/metadata",
+      { path: { branchId } },
       { signal }
     );
-    return data.map(mapBranchMetadata);
+    return data;
   };
-  const saveDevBranchMetadata = async (id, metadata, signal) => {
-    const { data } = await client.post("/v2/storage/branch/{id}/metadata", { path: { id }, body: { metadata } }, { signal });
-    return data.map(mapBranchMetadata);
+  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 (id, metadataId, signal) => {
+  const deleteDevBranchMetadata = async ({ branchId, metadataId }, signal) => {
     await client.delete(
-      "/v2/storage/branch/{id}/metadata/{metadataId}",
-      { path: { id, metadataId } },
+      "/v2/storage/branch/{branchId}/metadata/{metadataId}",
+      { path: { branchId, metadataId } },
       { signal }
     );
   };
   return {
     getDevBranches,
-    createDevBranchJob,
     updateDevBranch,
-    deleteDevBranchJob,
+    createDevBranchAsync,
+    deleteDevBranchAsync,
     getDevBranchMetadata,
     saveDevBranchMetadata,
     deleteDevBranchMetadata
   };
 };
 
-// src/clients/storage/buckets/listingConversion.ts
+// 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 = [];
@@ -185,85 +222,39 @@ var fromBackendSubscribers = (raw) => {
   }
   return result;
 };
-var toBucketListing = (raw, bucketId) => ({
-  bucketId,
-  name: raw.name,
-  description: raw.description ?? null,
-  listingId: raw.bigquery.listingId,
-  subscribers: fromBackendSubscribers(raw.bigquery.subscribers),
-  createdAt: raw.createdAt
-});
+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/buckets/buckets.ts
-var createBuckets = (client) => {
-  const getBuckets = async (branchId, query = {}, signal) => {
-    const { data } = await client.get(
-      `/v2/storage/branch/{branchId}/buckets`,
-      { path: { branchId }, query },
-      { signal, queryArrayFormat: "comma" }
-    );
-    return data;
-  };
-  const getBucket = async (id, signal) => {
-    const { data } = await client.get(
-      `/v2/storage/buckets/{id}`,
-      { path: { id } },
-      { signal }
-    );
-    return data;
-  };
-  const createBucket = async (body) => {
-    const { data } = await client.post(
-      `/v2/storage/buckets`,
-      {
-        body
-      }
-    );
-    return data;
-  };
-  const updateBucket = async (id, body) => {
-    const { data } = await client.put(
-      `/v2/storage/buckets/{id}`,
-      { path: { id }, body }
-    );
-    return data;
-  };
-  const deleteBucket = async (id) => {
-    await client.delete(`/v2/storage/buckets/{id}`, { path: { id } });
-  };
-  const deleteBucketAsync = async (id, options = {}) => {
-    const { data } = await client.delete(`/v2/storage/buckets/{id}`, { path: { id }, query: { async: true, ...options } });
-    return data;
-  };
-  const createScheduledRefresh = async (input) => {
-    const { branchId, bucketId, cronExpression } = input;
-    const { data } = await client.post(`/v2/storage/branch/{branchId}/buckets/{bucketId}/scheduled-tasks/refresh`, {
-      path: { branchId, bucketId },
-      body: { cronExpression }
-    });
-    return data;
-  };
-  const deleteScheduledTask = async (taskId) => {
-    await client.delete(`/v2/storage/scheduled-tasks/{taskId}`, {
-      path: { taskId }
-    });
-  };
+// src/clients/storage/bucketListings/bucketListings.ts
+var createBucketListings = (openApiClient) => {
   const getListing = async (bucketId, signal) => {
     try {
-      const { data } = await client.get(
-        `/v2/storage/buckets/{bucketId}/listing`,
+      const { data } = await openApiClient.get(
+        "/v2/storage/buckets/{bucketId}/listing",
         { path: { bucketId } },
         { signal }
       );
-      return toBucketListing(data, bucketId);
+      return data;
     } catch (error) {
       if (isApiError(error) && error.response.status === 404) return null;
       throw error;
     }
   };
-  const createListing = async (bucketId, input, signal) => {
-    const { data } = await client.post(
-      `/v2/storage/buckets/{bucketId}/listing`,
+  const createListingAsync = async ({ bucketId, ...input }, signal) => {
+    const { data } = await openApiClient.post(
+      "/v2/storage/buckets/{bucketId}/listing",
       {
         path: { bucketId },
         body: {
@@ -279,224 +270,283 @@ var createBuckets = (client) => {
     );
     return data;
   };
-  const updateListing = async (bucketId, input, signal) => {
-    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("updateListing requires at least one field");
-    }
-    const { data } = await client.patch(`/v2/storage/buckets/{bucketId}/listing`, { path: { bucketId }, body }, { signal });
+  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 deleteListing = async (bucketId, signal) => {
-    const { data } = await client.delete(
-      `/v2/storage/buckets/{bucketId}/listing`,
+  const deleteListingAsync = async (bucketId, signal) => {
+    const { data } = await openApiClient.delete(
+      "/v2/storage/buckets/{bucketId}/listing",
       { path: { bucketId } },
       { signal }
     );
     return data;
   };
-  const listListings = async (signal) => {
-    const { data } = await client.get(
-      `/v2/storage/listings`,
-      {},
-      { signal }
+  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.map((row) => toBucketListing(row, row.bucketId));
+    return data;
   };
-  const shareBucketToOrganization = async (bucketId, signal) => {
-    const { data } = await client.post(
-      `/v2/storage/buckets/{bucketId}/share-organization`,
-      { path: { bucketId }, query: { async: true } },
+  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 shareBucketToOrganizationProject = async (bucketId, signal) => {
-    const { data } = await client.post(
-      `/v2/storage/buckets/{bucketId}/share-organization-project`,
-      { path: { bucketId }, query: { async: true } },
-      { signal }
+  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 shareBucketToProjects = async (bucketId, body, signal) => {
-    const { data } = await client.post(
-      `/v2/storage/buckets/{bucketId}/share-to-projects`,
-      { path: { bucketId }, query: { async: true }, body },
+  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 shareBucketToUsers = async (bucketId, body, signal) => {
-    const { data } = await client.post(
-      `/v2/storage/buckets/{bucketId}/share-to-users`,
-      { path: { bucketId }, query: { async: true }, body },
+  const updateBucketOwner = async ({ bucketId, ...body }, signal) => {
+    await openApiClient.post(
+      "/v2/storage/buckets/{bucketId}/owner",
+      { path: { bucketId }, body },
       { signal }
     );
-    return data;
   };
-  const unshareBucket = async (bucketId, signal) => {
-    const { data } = await client.delete(
-      `/v2/storage/buckets/{bucketId}/share`,
-      { path: { bucketId }, query: { async: true } },
+  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 forceUnlinkBucket = async (bucketId, linkedProjectId, signal) => {
-    const { data } = await client.delete(
-      `/v2/storage/buckets/{bucketId}/links/{linkedProjectId}`,
-      { path: { bucketId, linkedProjectId }, query: { async: true } },
+  const deleteBucketMetadata = async ({ branchId, bucketId, metadataId }, signal) => {
+    await openApiClient.delete(
+      "/v2/storage/branch/{branchId}/buckets/{bucketId}/metadata/{metadataId}",
+      { path: { branchId, bucketId, metadataId } },
       { signal }
     );
-    return data;
   };
-  const getBucketOwner = async (bucketId, signal) => {
-    const { data } = await client.get(
-      `/v2/storage/buckets/{bucketId}/owner`,
-      { path: { bucketId } },
+  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 updateBucketOwner = async (bucketId, body, signal) => {
-    await client.post(
-      `/v2/storage/buckets/{bucketId}/owner`,
-      { path: { bucketId }, body },
+  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 }
     );
-  };
-  const refreshExternalBucket = async (bucketId, query = {}, signal) => {
-    const { data } = await client.put(`/v2/storage/buckets/{bucketId}/refresh`, { path: { bucketId }, query }, { signal });
     return data;
   };
-  const registerBucket = async (body, signal) => {
-    const { data } = await client.post(`/v2/storage/buckets/register`, { query: { async: true }, body }, { signal });
+  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 getBucketRegistrationGuide = async (query, signal) => {
-    const { data } = await client.get(
-      `/v2/storage/buckets/register-guide`,
-      { query },
+  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 sharedBuckets = async (signal) => {
-    const { data } = await client.get(`/v2/storage/shared-buckets`, {}, { signal });
+  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 saveBucketMetadata = async (bucketId, body, signal) => {
-    const { data } = await client.post(`/v2/storage/buckets/{bucketId}/metadata`, { path: { bucketId }, body }, { signal });
+  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 deleteBucketMetadata = async (bucketId, metadataId, signal) => {
-    await client.delete(
-      `/v2/storage/buckets/{bucketId}/metadata/{metadataId}`,
-      { path: { bucketId, metadataId } },
+  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 {
-    getBuckets,
-    getBucket,
-    createBucket,
-    updateBucket,
-    deleteBucket,
-    deleteBucketAsync,
-    createScheduledRefresh,
-    deleteScheduledTask,
-    getListing,
-    createListing,
-    updateListing,
-    deleteListing,
-    listListings,
-    shareBucketToOrganization,
-    shareBucketToOrganizationProject,
-    shareBucketToProjects,
-    shareBucketToUsers,
-    unshareBucket,
-    forceUnlinkBucket,
-    getBucketOwner,
-    updateBucketOwner,
-    refreshExternalBucket,
-    registerBucket,
-    getBucketRegistrationGuide,
-    sharedBuckets,
-    saveBucketMetadata,
-    deleteBucketMetadata
+    shareBucketToOrganizationAsync,
+    shareBucketToOrganizationProjectAsync,
+    shareBucketToProjectsAsync,
+    shareBucketToUsersAsync,
+    unshareBucketAsync,
+    forceUnlinkBucketAsync,
+    linkBucketAsync,
+    sharedBuckets
   };
 };
 
 // src/clients/storage/columns/columns.ts
 var createColumns = (client) => {
-  const addTableColumn = async (tableId, body, signal) => {
-    const { data } = await client.post("/v2/storage/tables/{id}/columns", { path: { id: tableId }, body }, { signal });
+  const addTableColumnAsync = async ({ id, ...body }, signal) => {
+    const { data } = await client.post(
+      "/v2/storage/tables/{id}/columns",
+      { path: { id }, body },
+      { signal }
+    );
     return data;
   };
-  const deleteTableColumn = async (tableId, columnName, query, signal) => {
+  const deleteTableColumnAsync = async ({ tableId, columnName, ...query }, signal) => {
     const { data } = await client.delete(
-      "/v2/storage/tables/{id}/columns/{column}",
-      { path: { id: tableId, column: columnName }, query },
+      "/v2/storage/tables/{tableId}/columns/{columnName}",
+      { path: { tableId, columnName }, query },
       { signal }
     );
     return data;
   };
-  const createTablePrimaryKey = async (tableId, body, signal) => {
-    const { data } = await client.post("/v2/storage/tables/{id}/primary-key", { path: { id: tableId }, body }, { signal });
+  const createTablePrimaryKeyAsync = async ({ tableId, ...body }, signal) => {
+    const { data } = await client.post(
+      "/v2/storage/tables/{tableId}/primary-key",
+      { path: { tableId }, body },
+      { signal }
+    );
     return data;
   };
-  const removeTablePrimaryKey = async (tableId, signal) => {
+  const removeTablePrimaryKeyAsync = async (tableId, signal) => {
     const { data } = await client.delete(
-      "/v2/storage/tables/{id}/primary-key",
-      { path: { id: tableId } },
+      "/v2/storage/tables/{tableId}/primary-key",
+      { path: { tableId } },
       { signal }
     );
     return data;
   };
-  const saveColumnMetadata = async (columnId, body, signal) => {
+  const saveColumnMetadata = async ({ branchId, columnId, ...body }, signal) => {
     const { data } = await client.post(
-      "/v2/storage/columns/{id}/metadata",
-      { path: { id: columnId }, body },
+      "/v2/storage/branch/{branchId}/columns/{id}/metadata",
+      { path: { branchId, id: columnId }, body },
       { signal }
     );
     return data;
   };
-  const deleteColumnMetadata = async (columnId, metadataId, signal) => {
+  const deleteColumnMetadata = async ({ branchId, columnId, metadataId }, signal) => {
     await client.delete(
-      "/v2/storage/columns/{id}/metadata/{metadataId}",
-      { path: { id: columnId, metadataId } },
+      "/v2/storage/branch/{branchId}/columns/{id}/metadata/{metadataId}",
+      { path: { branchId, id: columnId, metadataId } },
       { signal }
     );
   };
   return {
-    addTableColumn,
-    deleteTableColumn,
-    createTablePrimaryKey,
-    removeTablePrimaryKey,
+    addTableColumnAsync,
+    deleteTableColumnAsync,
+    createTablePrimaryKeyAsync,
+    removeTablePrimaryKeyAsync,
     saveColumnMetadata,
     deleteColumnMetadata
   };
 };
 
-// src/utils/async/series.ts
-var series = async (options) => concurrent({
-  ...options,
-  concurrency: 1
-});
-
-// src/clients/storage/componentsAndConfigurations/componentsAndConfigurations.ts
-var createComponentsAndConfigurations = (client) => {
+// 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 }
     );
@@ -505,285 +555,403 @@ var createComponentsAndConfigurations = (client) => {
   const getComponents = async ({ branchId = "default", ...query } = {}, signal) => {
     const { data } = await client.get(
       "/v2/storage/branch/{branchId}/components",
-      { path: { branchId }, query },
+      { path: { branchId: String(branchId) }, query },
       { signal, queryArrayFormat: "comma" }
     );
     return data;
   };
-  const getConfiguration = async ({ componentId, configId, branchId = "default" }, signal) => {
-    const { data } = await client.get(
-      "/v2/storage/branch/{branchId}/components/{componentId}/configs/{configId}",
-      { path: { componentId, configId, branchId } },
-      { signal }
-    );
-    return data;
+  return {
+    getComponent,
+    getComponents
   };
-  const getConfigurationDiff = async ({ componentId, configId, branchId }, signal) => {
+};
+
+// 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/{configId}/diff",
-      { path: { componentId, configId, branchId } },
+      "/v2/storage/branch/{branchId}/components/{componentId}/configs/{configurationId}/metadata",
+      { path: { branchId, componentId, configurationId } },
       { signal }
     );
     return data;
   };
-  const rebaseConfiguration = async ({
-    branchId,
+  const saveConfigurationMetadata = async ({
+    branchId = "default",
     componentId,
-    configId,
+    configurationId,
     ...body
   }) => {
-    const { data } = await client.post("/v2/storage/branch/{branchId}/components/{componentId}/configs/{configId}/rebase", {
-      path: { branchId, componentId, configId },
-      body
-    });
+    const { data } = await client.post(
+      "/v2/storage/branch/{branchId}/components/{componentId}/configs/{configurationId}/metadata",
+      {
+        path: { branchId, componentId, configurationId },
+        body
+      }
+    );
     return data;
   };
-  const getConfigurationRowDiff = async ({ componentId, configId, rowId, branchId }, signal) => {
-    const { data } = await client.get(
-      "/v2/storage/branch/{branchId}/components/{componentId}/configs/{configId}/rows/{rowId}/diff",
-      { path: { componentId, configId, rowId, branchId } },
+  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 data;
   };
-  const createConfiguration = async ({
+  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", {
-      path: { branchId, componentId },
-      body
-    });
+    const { data } = await client.post(
+      "/v2/storage/branch/{branchId}/components/{componentId}/configs/{configurationId}/rows",
+      {
+        path: { branchId, componentId, configurationId },
+        body
+      }
+    );
     return data;
   };
-  const updateConfiguration = async ({
+  const createConfigurationRows2 = async ({
     branchId = "default",
     componentId,
-    configId,
-    configuration,
-    ...rest
-  }, signal) => {
-    const body = {
-      ...rest,
-      ...configuration !== void 0 && { configuration: JSON.stringify(configuration) }
-    };
-    const { data } = await client.put(
-      "/v2/storage/branch/{branchId}/components/{componentId}/configs/{configId}",
-      { path: { branchId, componentId, configId }, body },
+    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 deleteConfiguration = async (path) => {
-    await client.delete(
-      "/v2/storage/branch/{branchId}/components/{componentId}/configs/{configId}",
-      { path }
-    );
-  };
-  const restoreConfiguration = async ({
+  const updateConfigurationRow = async ({
     branchId = "default",
     componentId,
-    configId
-  }) => {
-    const { data } = await client.post(
-      "/v2/storage/branch/{branchId}/components/{componentId}/configs/{configId}/restore",
-      { path: { branchId, componentId, configId } }
+    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 resetConfigurationToDefault = async ({
+  const updateConfigurationRowState = async ({
     branchId = "default",
     componentId,
-    configId
-  }) => {
-    const { data } = await client.post(
-      "/v2/storage/branch/{branchId}/components/{componentId}/configs/{configId}/reset-to-default",
-      { path: { branchId, componentId, configId } }
+    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 deleteConfigurations = async ({
-    configIds,
-    ...rest
+  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: configIds,
-      process: async (configId) => deleteConfiguration({ ...rest, configId })
+      items: rowIds,
+      process: (rowId) => {
+        const resolvedDescription = typeof changeDescription === "string" ? changeDescription : changeDescription?.(rowId);
+        return deleteConfigurationRow({
+          rowId,
+          changeDescription: resolvedDescription,
+          ...input
+        });
+      },
+      concurrency: 5,
+      middlewares: options?.middlewares
     });
   };
-  const getConfigurations = async ({ componentId, branchId = "default" }, signal) => {
+  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",
-      { path: { componentId, branchId } },
+      "/v2/storage/branch/{branchId}/components/{componentId}/configs/{configurationId}",
+      { path: { componentId, configurationId: configId, branchId: String(branchId) } },
       { signal }
     );
     return data;
   };
-  const getConfigurationWorkspaces = async ({
-    componentId,
+  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,
-    configId
+    componentId,
+    configId,
+    ...body
   }) => {
-    const { data } = await client.get(
-      "/v2/storage/branch/{branchId}/components/{componentId}/configs/{configId}/workspaces",
+    const { data } = await client.post(
+      "/v2/storage/branch/{branchId}/components/{componentId}/configs/{configurationId}/rebase",
       {
-        path: { componentId, branchId, configId }
+        path: { branchId: String(branchId), componentId, configurationId: configId },
+        body
       }
     );
     return data;
   };
-  const createConfigurationWorkspace = async ({
+  const createConfiguration = async ({
+    branchId = "default",
     componentId,
-    branchId,
-    configId,
     ...body
   }) => {
-    const { data } = await client.post("/v2/storage/branch/{branchId}/components/{componentId}/configs/{configId}/workspaces", {
-      path: { componentId, branchId, configId },
-      body
-    });
+    const { data } = await client.post(
+      "/v2/storage/branch/{branchId}/components/{componentId}/configs",
+      {
+        path: { branchId: String(branchId), componentId },
+        body
+      }
+    );
     return data;
   };
-  const createConfigurationWorkspaceJob = async ({
+  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,
-    ...body
+    expectedVersion
   }) => {
-    const { data } = await client.post("/v2/storage/branch/{branchId}/components/{componentId}/configs/{configId}/workspaces", {
-      path: { componentId, branchId, configId },
-      body,
-      query: { async: true }
-    });
-    return data;
+    await client.delete(
+      "/v2/storage/branch/{branchId}/components/{componentId}/configs/{configurationId}",
+      { path: { branchId: String(branchId), componentId, configurationId: configId } },
+      { headers: { ...createVersionPrecondition(expectedVersion) } }
+    );
   };
-  const createConfigurationRow = async ({
+  const purgeConfiguration = async ({
     branchId = "default",
     componentId,
     configId,
-    ...body
+    expectedVersion
   }) => {
-    const { data } = await client.post("/v2/storage/branch/{branchId}/components/{componentId}/configs/{configId}/rows", {
-      path: { branchId, componentId, configId },
-      body
+    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 })
     });
-    return data;
   };
-  const createConfigurationRows = async ({
+  const restoreConfiguration = async ({
     branchId = "default",
     componentId,
-    configId,
-    data
-  }, options) => {
-    return series({
-      items: data,
-      process: (rowBody) => {
-        return createConfigurationRow({
-          branchId,
-          componentId,
-          configId,
-          ...rowBody
-        });
-      },
-      middlewares: options?.middlewares
-    });
+    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 deleteConfigurationRow = async ({
-    changeDescription,
-    ...path
+  const resetConfigurationToDefault = async ({
+    branchId = "default",
+    componentId,
+    configId
   }) => {
-    await client.delete(
-      "/v2/storage/branch/{branchId}/components/{componentId}/configs/{configId}/rows/{rowId}",
-      {
-        path,
-        body: { changeDescription }
-      }
+    await client.post(
+      "/v2/storage/branch/{branchId}/components/{componentId}/configs/{configurationId}/reset-to-default",
+      { path: { branchId: String(branchId), componentId, configurationId: configId } }
     );
   };
-  const deleteConfigurationRows = async ({ rowIds, changeDescription, ...input }, options) => {
+  const deleteConfigurations = async ({
+    configIds,
+    ...rest
+  }) => {
     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
+      items: configIds,
+      process: async (configId) => deleteConfiguration({ ...rest, configId })
     });
   };
-  const searchComponentConfigurations = async ({ branchId = "default" } = {}, query, signal) => {
+  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 }, query },
-      { signal, queryArrayFormat: "comma" }
+      {
+        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 {
-    // components
-    getComponent,
-    getComponents,
-    searchComponentConfigurations,
-    // configurations
     createConfiguration,
     updateConfiguration,
+    updateConfigurationState,
     getConfiguration,
     getConfigurationDiff,
-    getConfigurationRowDiff,
     rebaseConfiguration,
     deleteConfiguration,
     deleteConfigurations,
+    purgeConfiguration,
+    purgeConfigurations,
     getConfigurations,
     restoreConfiguration,
     resetConfigurationToDefault,
-    // configuration's rows
-    createConfigurationRow,
-    createConfigurationRows,
-    deleteConfigurationRow,
-    deleteConfigurationRows,
-    // configuration's workspaces
-    createConfigurationWorkspace,
-    createConfigurationWorkspaceJob,
-    getConfigurationWorkspaces
-  };
-};
-
-// src/clients/storage/configurationMetadata/configurationMetadata.ts
-var createConfigurationMetadata = (client) => {
-  const saveConfigurationMetadata = async ({
-    branchId = "default",
-    componentId,
-    configId,
-    ...body
-  }) => {
-    const { data } = await client.post("/v2/storage/branch/{branchId}/components/{componentId}/configs/{configId}/metadata", {
-      path: { branchId, componentId, configId },
-      body
-    });
-    return data;
+    searchComponentConfigurations
   };
-  return { saveConfigurationMetadata };
 };
 
 // src/clients/storage/configurationVersions/configurationVersions.ts
 var createConfigurationVersions = (client) => {
-  const getConfigurationVersions = async ({ branchId, componentId, configId }, signal) => {
+  const getConfigurationVersions = async ({ branchId, componentId, configurationId }, signal) => {
     const { data } = await client.get(
-      "/v2/storage/branch/{branchId}/components/{componentId}/configs/{configId}/versions",
-      { path: { branchId, componentId, configId } },
+      "/v2/storage/branch/{branchId}/components/{componentId}/configs/{configurationId}/versions",
+      { path: { branchId: String(branchId), componentId, configurationId } },
       { signal }
     );
     return data;
   };
-  const getConfigurationVersion = async ({ branchId, componentId, configId, versionId }, signal) => {
+  const getConfigurationVersion = async ({ branchId, componentId, configurationId, versionId }, signal) => {
     const { data } = await client.get(
-      "/v2/storage/branch/{branchId}/components/{componentId}/configs/{configId}/versions/{versionId}",
-      { path: { branchId, componentId, configId, versionId } },
+      "/v2/storage/branch/{branchId}/components/{componentId}/configs/{configurationId}/versions/{versionId}",
+      {
+        path: {
+          branchId: String(branchId),
+          componentId,
+          configurationId,
+          versionId: String(versionId)
+        }
+      },
       { signal }
     );
     return data;
@@ -791,25 +959,112 @@ var createConfigurationVersions = (client) => {
   const rollbackConfigurationToVersion = async ({
     branchId = "default",
     componentId,
-    configId,
+    configurationId,
     versionId
   }) => {
     const { data } = await client.post(
-      "/v2/storage/branch/{branchId}/components/{componentId}/configs/{configId}/versions/{versionId}/rollback",
-      { path: { branchId, componentId, configId, versionId } }
+      "/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,
-    configId,
+    configurationId,
     versionId,
     ...body
   }) => {
     const { data } = await client.post(
-      "/v2/storage/branch/{branchId}/components/{componentId}/configs/{configId}/versions/{versionId}/create",
-      { path: { branchId, componentId, configId, versionId }, body }
+      "/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;
   };
@@ -817,12 +1072,64 @@ var createConfigurationVersions = (client) => {
     getConfigurationVersions,
     getConfigurationVersion,
     rollbackConfigurationToVersion,
-    copyConfigurationFromVersion
+    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) => {
+var createEvents = (client, openApiClient) => {
   const getEvents = async (query, signal) => {
     const { data } = await client.get(
       "/v2/storage/events",
@@ -841,10 +1148,18 @@ var createEvents = (client) => {
     );
     return data;
   };
-  const getTableEvents = async (tableId, query, signal) => {
-    const { data } = await client.get(
-      "/v2/storage/tables/{tableId}/events",
-      { path: { tableId }, query },
+  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;
@@ -863,6 +1178,7 @@ var createEvents = (client) => {
     getEvents,
     getEvent,
     getTableEvents,
+    getBucketEvents,
     createEvent
   };
 };
@@ -998,46 +1314,88 @@ var createSearch = (client) => {
     );
     return data;
   };
-  return { globalSearch };
+  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/stats/stats.ts
-var createStats = (client) => {
-  const getRunIdStats = async (runId, signal) => {
+// 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/stats",
-      { query: { runId } },
+      "/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 = (client) => {
-  const getTables = async (branchId, query = { include: [] }, signal) => {
-    const { data } = await client.get(
-      `/v2/storage/branch/{branchId}/tables`,
-      { path: { branchId }, query },
+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 (id, signal) => {
-    const { data } = await client.get(
-      `/v2/storage/tables/{id}`,
-      { path: { id } },
+  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 client.delete(
-      `/v2/storage/tables/{id}`,
-      { path: { id } },
-      { signal }
-    );
+    await openApiClient.delete("/v2/storage/tables/{id}", { path: { id } }, { signal });
   };
   const deleteTables = async (ids) => {
     await concurrent({
@@ -1045,23 +1403,26 @@ var createTables = (client) => {
       process: (id) => deleteTable(id)
     });
   };
-  const deleteTableRows = async (id, query, signal) => {
-    const { data } = await client.delete(
-      `/v2/storage/tables/{id}/rows`,
-      { path: { id }, query },
+  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 (id, query, signal) => {
-    const { data } = await client.get(
-      `/v2/storage/tables/{id}/data-preview`,
-      { path: { id }, query: { format: "json", ...query } },
+  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 exportAsync = async ({ tableId, ...body }, signal) => {
     const { data } = await client.post(
       "/v2/storage/tables/{id}/export-async",
       { path: { id: tableId }, body },
@@ -1069,16 +1430,20 @@ var createTables = (client) => {
     );
     return data;
   };
-  const createTableAsync = async (bucketId, body, signal) => {
+  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 client.post("/v2/storage/buckets/{bucketId}/tables-definition", { path: { bucketId }, body }, { signal });
+  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 client.post(
+  const importAsync = async ({ tableId, ...body }, signal) => {
+    const { data } = await openApiClient.post(
       "/v2/storage/tables/{id}/import-async",
       { path: { id: tableId }, body },
       { signal }
@@ -1086,14 +1451,14 @@ var createTables = (client) => {
     return data;
   };
   const updateTableDefinition = async ({ branchId = "default", tableId, ...body }, signal) => {
-    const { data } = await client.put(
+    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 updateTable = async ({ tableId, ...body }, signal) => {
     const { data } = await client.put(
       "/v2/storage/tables/{id}",
       { path: { id: tableId }, body },
@@ -1101,19 +1466,19 @@ var createTables = (client) => {
     );
     return data;
   };
-  const pullTable = async (tableId, signal) => {
-    const { data } = await client.post(
-      "/v2/storage/tables/{id}/pull",
-      { path: { id: tableId } },
+  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 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 setAliasTableFilter = async ({ tableId, ...body }, signal) => {
     const { data } = await client.post(
       "/v2/storage/tables/{id}/alias-filter",
       { path: { id: tableId }, body },
@@ -1128,37 +1493,20 @@ var createTables = (client) => {
       { signal }
     );
   };
-  const createSnapshot = async (tableId, body, signal) => {
-    const { data } = await client.post("/v2/storage/tables/{id}/snapshots", { path: { id: tableId }, body }, { signal });
-    return data;
-  };
-  const deleteSnapshot = async (snapshotId, signal) => {
-    await client.delete(
-      "/v2/storage/snapshots/{snapshotId}",
-      { path: { snapshotId } },
-      { signal }
-    );
-  };
-  const loadTableSnapshots = async (tableId, signal) => {
-    const { data } = await client.get(
-      "/v2/storage/tables/{id}/snapshots",
-      { path: { id: tableId } },
-      { signal }
-    );
-    return data;
-  };
-  const saveTableMetadata = async (tableId, body, signal) => {
-    const { data } = await client.post(
-      "/v2/storage/tables/{id}/metadata",
-      { path: { id: tableId }, body },
+  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 (tableId, metadataId, signal) => {
-    await client.delete(
-      "/v2/storage/tables/{id}/metadata/{metadataId}",
-      { path: { id: tableId, metadataId } },
+  const deleteTableMetadata = async ({ branchId, tableId, metadataId }, signal) => {
+    await openApiClient.delete(
+      "/v2/storage/branch/{branchId}/tables/{id}/metadata/{metadataId}",
+      { path: { branchId, id: tableId, metadataId } },
       { signal }
     );
   };
@@ -1175,54 +1523,43 @@ var createTables = (client) => {
     importAsync,
     updateTableDefinition,
     updateTable,
-    pullTable,
+    pullTableAsync,
     createAliasTable,
     setAliasTableFilter,
     removeAliasTableFilter,
-    createSnapshot,
-    deleteSnapshot,
-    loadTableSnapshots,
     saveTableMetadata,
     deleteTableMetadata
   };
 };
 
 // src/clients/storage/tokens/tokens.ts
-var createTokens = (client) => {
+var createTokens = (openApiClient) => {
   const verify = async (signal) => {
-    const { data } = await client.get(
-      "/v2/storage/tokens/verify",
-      {},
-      { signal }
-    );
+    const { data } = await openApiClient.get("/v2/storage/tokens/verify", {}, { signal });
     return data;
   };
   const refresh = async (id, signal) => {
-    const { data } = await client.post(
-      `/v2/storage/tokens/${id}/refresh`,
-      {},
+    const { data } = await openApiClient.post(
+      "/v2/storage/tokens/{id}/refresh",
+      { path: { id } },
       { signal }
     );
     return data;
   };
   const getTokens = async (signal) => {
-    const { data } = await client.get(
-      "/v2/storage/tokens",
-      {},
-      { signal }
-    );
+    const { data } = await openApiClient.get("/v2/storage/tokens", {}, { signal });
     return data;
   };
   const createToken = async (body, signal) => {
-    const { data } = await client.post(
+    const { data } = await openApiClient.post(
       "/v2/storage/tokens",
       { body },
       { signal }
     );
     return data;
   };
-  const updateToken = async (id, body, signal) => {
-    const { data } = await client.put(
+  const updateToken = async ({ id, ...body }, signal) => {
+    const { data } = await openApiClient.put(
       "/v2/storage/tokens/{id}",
       { path: { id }, body },
       { signal }
@@ -1230,14 +1567,14 @@ var createTokens = (client) => {
     return data;
   };
   const deleteToken = async (id, signal) => {
-    await client.delete(
+    await openApiClient.delete(
       "/v2/storage/tokens/{id}",
       { path: { id } },
       { signal }
     );
   };
-  const shareToken = async (id, body, signal) => {
-    await client.post(
+  const shareToken = async ({ id, ...body }, signal) => {
+    await openApiClient.post(
       "/v2/storage/tokens/{id}/share",
       { path: { id }, body },
       { signal }
@@ -1256,26 +1593,21 @@ var createTokens = (client) => {
 
 // src/clients/storage/triggers/triggers.ts
 var createTriggers = (client) => {
-  const listTriggers = async (query, signal) => {
-    const { data } = await client.get(
-      "/v2/storage/triggers",
-      { query },
-      { signal }
-    );
+  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 }
-    );
+    const { data } = await client.post("/v2/storage/triggers", { body }, { signal });
     return data;
   };
-  const updateTrigger = async (triggerId, body, signal) => {
+  const updateTrigger = async ({ triggerId, ...body }, signal) => {
     const { data } = await client.put(
       "/v2/storage/triggers/{triggerId}",
-      { path: { triggerId }, body },
+      {
+        path: { triggerId },
+        body
+      },
       { signal }
     );
     return data;
@@ -1288,7 +1620,7 @@ var createTriggers = (client) => {
     );
   };
   return {
-    listTriggers,
+    getTriggers,
     createTrigger,
     updateTrigger,
     deleteTrigger
@@ -1452,27 +1784,39 @@ var createStorageClient = ({
     );
     return data;
   };
+  const healthCheck = async (signal) => {
+    const { data } = await client.get("/health-check", {}, { signal });
+    return data;
+  };
   return {
-    buckets: createBuckets(client),
-    events: createEvents(client),
+    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),
-    tables: createTables(client),
-    columns: createColumns(client),
-    branches: createBranches(client),
     workspaces: createWorkspaces(client, openApiClient),
-    mergeRequests: createMergeRequests(openApiClient),
     jobs: createJobs(client),
-    componentsAndConfigurations: createComponentsAndConfigurations(client),
-    configurationMetadata: createConfigurationMetadata(client),
-    configurationVersions: createConfigurationVersions(client),
-    tokens: createTokens(client),
-    triggers: createTriggers(client),
-    search: createSearch(client),
-    stats: createStats(client),
-    getStackInfo
+    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, series };
-//# sourceMappingURL=chunk-WFXW4XU3.js.map
-//# sourceMappingURL=chunk-WFXW4XU3.js.map
+export { ServiceUnavailableError, createStorageClient, fromBackendSubscribers, series, toBackendSubscribers };
+//# sourceMappingURL=chunk-ON4ILCHP.js.map
+//# sourceMappingURL=chunk-ON4ILCHP.js.map