@keboola/api-client 1.0.1 → 3.0.0

package/dist/storage/index.js

@@ -1,1112 +1,5 @@
-import qs from 'qs';
-
-// src/errors/ApiError.ts
-var ApiError = class extends Error {
-  response;
-  request;
-  data;
-  constructor({ response, request, data }) {
-    super(response.statusText);
-    this.response = response;
-    this.request = request;
-    this.data = data;
-  }
-};
-
-// src/constants.ts
-var KeboolaHttpHeader = {
-  STORAGE_API_TOKEN: "X-StorageApi-Token"};
-var HttpStatus = {
-  NO_CONTENT: 204};
-
-// src/fetchClient/createFetchClient/utils.ts
-var HttpHeader = {
-  CONTENT_TYPE: "content-type"};
-var HttpContentType = {
-  JSON: "application/json"};
-var defaultValidateStatus = ({ response }) => response.status >= 200 && response.status <= 299;
-function removeUndefined(obj) {
-  const objCopy = { ...obj };
-  for (const [key, value] of Object.entries(objCopy)) {
-    if (value == null) delete objCopy[key];
-  }
-  return objCopy;
-}
-var parseData = async (response) => {
-  if (response.status === HttpStatus.NO_CONTENT) return null;
-  const contentType = response.headers.get(HttpHeader.CONTENT_TYPE);
-  if (contentType && contentType == HttpContentType.JSON) {
-    return response.json();
-  }
-  const text = await response.text();
-  try {
-    return JSON.parse(text);
-  } catch {
-    return text;
-  }
-};
-var cleanHeadersInit = (headersInit) => {
-  if (Array.isArray(headersInit)) return headersInit;
-  if (headersInit instanceof Headers) return headersInit;
-  if (headersInit == null) return headersInit;
-  return removeUndefined(headersInit);
-};
-var createHeaders = (headersInitA, headersInitB) => {
-  const headersA = new Headers(cleanHeadersInit(headersInitA));
-  const headersB = new Headers(cleanHeadersInit(headersInitB));
-  headersB.forEach((value, key) => {
-    headersA.set(key, value);
-  });
-  return headersA;
-};
-var createPath = (path, pathParam = {}) => path.replace(/\{([^}]+)}/g, (_, key) => {
-  if (!(key in pathParam))
-    throw new Error(`Path parameter "${key}" is missing in the path "${path}"`);
-  return encodeURIComponent(pathParam[key]);
-});
-var createSearch = (query, options = {}) => {
-  return qs.stringify(query, {
-    encodeValuesOnly: true,
-    skipNulls: true,
-    ...options
-  });
-};
-var createBody = (body, headers) => {
-  if (body == null) return null;
-  if (body instanceof FormData) return body;
-  if (typeof body === "string") return body;
-  const stringifyBody = JSON.stringify(body);
-  const stringBody = stringifyBody === "{}" ? null : stringifyBody;
-  if (stringBody) headers.set(HttpHeader.CONTENT_TYPE, HttpContentType.JSON);
-  return stringBody;
-};
-var createFetchRequest = ({
-  url,
-  method,
-  params,
-  options = {},
-  defaultOptions
-}) => {
-  const {
-    baseUrl,
-    validateStatus: defValidateStatus = defaultValidateStatus,
-    headers: defaultHeaders,
-    ...restDefaultOptions
-  } = defaultOptions;
-  const { validateStatus, queryArrayFormat, headers: endpointHeaders, ...restOptions } = options;
-  const headers = createHeaders(defaultHeaders, endpointHeaders);
-  const path = createPath(url, params.path);
-  const search = createSearch(params.query ?? {}, { arrayFormat: queryArrayFormat });
-  const body = createBody(params.body, headers);
-  const urlInstance = new URL(baseUrl + path);
-  urlInstance.search = search;
-  const request = new Request(urlInstance, {
-    ...restDefaultOptions,
-    ...restOptions,
-    headers,
-    method: method.toUpperCase(),
-    body
-  });
-  return { request, validateStatus: validateStatus ?? defValidateStatus };
-};
-
-// src/fetchClient/createFetchClient/createFetchClient.ts
-var isApiError = (error) => error instanceof ApiError;
-var createCoreFetch = (fetchFn) => async ({ request, validateStatus }) => {
-  const response = await fetchFn(request);
-  const data = await parseData(response);
-  const apiResponse = {
-    request,
-    response,
-    data
-  };
-  const boolOrError = validateStatus(apiResponse);
-  if (isApiError(boolOrError)) throw boolOrError;
-  if (!boolOrError) throw new ApiError(apiResponse);
-  return apiResponse;
-};
-var createFetchClient = ({
-  middlewares = [],
-  ...defaultOptions
-}) => {
-  const coreFetch = createCoreFetch(defaultOptions.fetchFn ?? fetch);
-  const fetchWithMiddlewares = middlewares.reduceRight(
-    (next, middleware) => middleware(next),
-    coreFetch
-  );
-  const createFetchMethod = (method) => async (url, params, options = {}) => {
-    const request = createFetchRequest({
-      url,
-      method,
-      params,
-      defaultOptions,
-      options
-    });
-    const methodMiddlewares = options?.middlewares ?? [];
-    return methodMiddlewares.reduceRight(
-      (next, middleware) => middleware(next),
-      fetchWithMiddlewares
-    )(request);
-  };
-  return {
-    get: createFetchMethod("get"),
-    post: createFetchMethod("post"),
-    put: createFetchMethod("put"),
-    patch: createFetchMethod("patch"),
-    delete: createFetchMethod("delete")
-  };
-};
-
-// src/fetchClient/createGenericFetchClient.ts
-var createGenericFetchClient = (defaultOptions) => createFetchClient(defaultOptions);
-
-// src/fetchClient/createOpenapiFetchClient.ts
-var createOpenapiFetchClient = (defaultOptions) => createFetchClient(defaultOptions);
-
-// src/clients/storage/configurationVersions/configurationVersions.ts
-var createConfigurationVersions = (client) => {
-  const listConfigurationVersions = async ({ branchId, componentId, configId }, signal) => {
-    const { data } = await client.get(
-      "/branch/{branchId}/components/{componentId}/configs/{configId}/versions",
-      { path: { branchId, componentId, configId } },
-      { signal }
-    );
-    return data;
-  };
-  const getConfigurationVersion = async ({ branchId, componentId, configId, versionId }, signal) => {
-    const { data } = await client.get(
-      "/branch/{branchId}/components/{componentId}/configs/{configId}/versions/{versionId}",
-      { path: { branchId, componentId, configId, versionId } },
-      { signal }
-    );
-    return data;
-  };
-  return {
-    listConfigurationVersions,
-    getConfigurationVersion
-  };
-};
-
-// 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 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,
-    getMergeRequestConflicts
-  };
-};
-
-// 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("/dev-branches", {}, { signal });
-    return data;
-  };
-  const createDevBranchJob = async (body) => {
-    const { data } = await client.post(
-      "/dev-branches",
-      {
-        body
-      }
-    );
-    return data;
-  };
-  const updateDevBranch = async ({
-    id,
-    name,
-    description
-  }) => {
-    const { data } = await client.put(
-      "/dev-branches/{id}",
-      {
-        path: { id },
-        body: {
-          name,
-          description
-        }
-      }
-    );
-    return data;
-  };
-  const deleteDevBranchJob = async (id) => {
-    const { data } = await client.delete(
-      "/dev-branches/{id}",
-      {
-        path: { id }
-      }
-    );
-    return data;
-  };
-  const getDevBranchMetadata = async (id, signal) => {
-    const { data } = await client.get(
-      "/branch/{id}/metadata",
-      { path: { id } },
-      { signal }
-    );
-    return data.map(mapBranchMetadata);
-  };
-  const saveDevBranchMetadata = async (id, metadata, signal) => {
-    const { data } = await client.post("/branch/{id}/metadata", { path: { id }, body: { metadata } }, { signal });
-    return data.map(mapBranchMetadata);
-  };
-  const deleteDevBranchMetadata = async (id, metadataId, signal) => {
-    await client.delete(
-      "/branch/{id}/metadata/{metadataId}",
-      { path: { id, metadataId } },
-      { signal }
-    );
-  };
-  return {
-    getDevBranches,
-    createDevBranchJob,
-    updateDevBranch,
-    deleteDevBranchJob,
-    getDevBranchMetadata,
-    saveDevBranchMetadata,
-    deleteDevBranchMetadata
-  };
-};
-
-// src/clients/storage/buckets/listingConversion.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 toBucketListing = (raw, bucketId) => ({
-  bucketId,
-  name: raw.name,
-  description: raw.description ?? null,
-  listingId: raw.bigquery.listingId,
-  subscribers: fromBackendSubscribers(raw.bigquery.subscribers),
-  createdAt: raw.createdAt
-});
-
-// src/clients/storage/buckets/buckets.ts
-var createBuckets = (client) => {
-  const getBuckets = async (query = {}, signal) => {
-    const { data } = await client.get(
-      `/buckets`,
-      { query },
-      { signal, queryArrayFormat: "comma" }
-    );
-    return data;
-  };
-  const getBucket = async (id, signal) => {
-    const { data } = await client.get(
-      `/buckets/{id}`,
-      { path: { id } },
-      { signal }
-    );
-    return data;
-  };
-  const createBucket = async (body) => {
-    const { data } = await client.post(`/buckets`, {
-      body
-    });
-    return data;
-  };
-  const updateBucket = async (id, body) => {
-    const { data } = await client.patch(
-      `/buckets/{id}`,
-      { path: { id }, body }
-    );
-    return data;
-  };
-  const deleteBucket = async (id) => {
-    await client.delete(`/buckets/{id}`, { path: { id } });
-  };
-  const deleteBucketAsync = async (id, options = {}) => {
-    const { data } = await client.delete(`/buckets/{id}`, { path: { id }, query: { async: true, ...options } });
-    return data;
-  };
-  const createScheduledRefresh = async (input) => {
-    const { branchId, bucketId, cronExpression } = input;
-    const { data } = await client.post(`/branch/{branchId}/buckets/{bucketId}/scheduled-tasks/refresh`, {
-      path: { branchId, bucketId },
-      body: { cronExpression }
-    });
-    return data;
-  };
-  const deleteScheduledTask = async (taskId) => {
-    await client.delete(`/scheduled-tasks/{taskId}`, {
-      path: { taskId }
-    });
-  };
-  const getListing = async (bucketId, signal) => {
-    try {
-      const { data } = await client.get(
-        `/buckets/{bucketId}/listing`,
-        { path: { bucketId } },
-        { signal }
-      );
-      return toBucketListing(data, bucketId);
-    } catch (error) {
-      if (isApiError(error) && error.response.status === 404) return null;
-      throw error;
-    }
-  };
-  const createListing = async (bucketId, input, signal) => {
-    const { data } = await client.post(
-      `/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 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(`/buckets/{bucketId}/listing`, { path: { bucketId }, body }, { signal });
-    return data;
-  };
-  const deleteListing = async (bucketId, signal) => {
-    const { data } = await client.delete(
-      `/buckets/{bucketId}/listing`,
-      { path: { bucketId } },
-      { signal }
-    );
-    return data;
-  };
-  const listListings = async (signal) => {
-    const { data } = await client.get(`/listings`, {}, { signal });
-    return data.map((row) => toBucketListing(row, row.bucketId));
-  };
-  return {
-    getBuckets,
-    getBucket,
-    createBucket,
-    updateBucket,
-    deleteBucket,
-    deleteBucketAsync,
-    createScheduledRefresh,
-    deleteScheduledTask,
-    getListing,
-    createListing,
-    updateListing,
-    deleteListing,
-    listListings
-  };
-};
-
-// src/utils/concurrent.ts
-var concurrent = async ({
-  items,
-  process,
-  concurrency = 2,
-  middlewares = []
-}) => {
-  if (concurrency < 1) throw new Error("Concurrency must be greater than 0");
-  if (items.length === 0) return [];
-  if (concurrency === Infinity)
-    return Promise.all(items.map((item, index) => process(item, index, items.length)));
-  const n = items.length;
-  const results = new Array(n);
-  const processWithMiddlewares = middlewares.reduceRight(
-    (next, middleware) => middleware(next),
-    process
-  );
-  const queue = items.map((item, index) => async () => {
-    results[index] = await processWithMiddlewares(item, index, items.length);
-  });
-  const workers = Array.from(
-    { length: Math.min(concurrency, items.length) },
-    async function processQueue() {
-      while (queue.length) {
-        await queue.shift()?.();
-      }
-    }
-  );
-  await Promise.all(workers);
-  return results;
-};
-
-// src/utils/series.ts
-var series = async (options) => concurrent({
-  ...options,
-  concurrency: 1
-});
-
-// src/clients/storage/componentsAndConfigurations/componentsAndConfigurations.ts
-var createComponentsAndConfigurations = (client) => {
-  const getComponent = async ({ componentId, branchId = "default" }, signal) => {
-    const { data } = await client.get(
-      "/branch/{branchId}/components/{componentId}",
-      { path: { componentId, branchId } },
-      { signal }
-    );
-    return data;
-  };
-  const getComponents = async ({ branchId = "default", ...query } = {}, signal) => {
-    const { data } = await client.get(
-      "/branch/{branchId}/components",
-      { path: { branchId }, query },
-      { signal, queryArrayFormat: "comma" }
-    );
-    return data;
-  };
-  const getConfiguration = async ({ componentId, configId, branchId = "default" }, signal) => {
-    const { data } = await client.get(
-      "/branch/{branchId}/components/{componentId}/configs/{configId}",
-      { path: { componentId, configId, branchId } },
-      { signal }
-    );
-    return data;
-  };
-  const createConfiguration = async ({
-    branchId = "default",
-    componentId,
-    ...body
-  }) => {
-    const { data } = await client.post("/branch/{branchId}/components/{componentId}/configs", {
-      path: { branchId, componentId },
-      body
-    });
-    return data;
-  };
-  const deleteConfiguration = async (path) => {
-    await client.delete(
-      "/branch/{branchId}/components/{componentId}/configs/{configId}",
-      { path }
-    );
-  };
-  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(
-      "/branch/{branchId}/components/{componentId}/configs",
-      { path: { componentId, branchId } },
-      { signal }
-    );
-    return data;
-  };
-  const getConfigurationWorkspaces = async ({
-    componentId,
-    branchId,
-    configId
-  }) => {
-    const { data } = await client.get(
-      "/branch/{branchId}/components/{componentId}/configs/{configId}/workspaces",
-      {
-        path: { componentId, branchId, configId }
-      }
-    );
-    return data;
-  };
-  const createConfigurationWorkspace = async ({
-    componentId,
-    branchId,
-    configId,
-    ...body
-  }) => {
-    const { data } = await client.post("/branch/{branchId}/components/{componentId}/configs/{configId}/workspaces", {
-      path: { componentId, branchId, configId },
-      body
-    });
-    return data;
-  };
-  const createConfigurationWorkspaceJob = async ({
-    componentId,
-    branchId,
-    configId,
-    ...body
-  }) => {
-    const { data } = await client.post("/branch/{branchId}/components/{componentId}/configs/{configId}/workspaces", {
-      path: { componentId, branchId, configId },
-      body,
-      query: { async: true }
-    });
-    return data;
-  };
-  const createConfigurationRow = async ({
-    branchId = "default",
-    componentId,
-    configId,
-    ...body
-  }) => {
-    const { data } = await client.post("/branch/{branchId}/components/{componentId}/configs/{configId}/rows", {
-      path: { branchId, componentId, configId },
-      body
-    });
-    return data;
-  };
-  const createConfigurationRows = async ({
-    branchId = "default",
-    componentId,
-    configId,
-    data
-  }, options) => {
-    return series({
-      items: data,
-      process: (rowBody) => {
-        return createConfigurationRow({
-          branchId,
-          componentId,
-          configId,
-          ...rowBody
-        });
-      },
-      middlewares: options?.middlewares
-    });
-  };
-  const deleteConfigurationRow = async ({
-    changeDescription,
-    ...path
-  }) => {
-    await client.delete(
-      "/branch/{branchId}/components/{componentId}/configs/{configId}/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
-    });
-  };
-  const searchComponentConfigurations = async ({ branchId = "default" } = {}, query, signal) => {
-    const { data } = await client.get(
-      "/branch/{branchId}/search/component-configurations",
-      { path: { branchId }, query },
-      { signal, queryArrayFormat: "comma" }
-    );
-    return data;
-  };
-  return {
-    // components
-    getComponent,
-    getComponents,
-    searchComponentConfigurations,
-    // configurations
-    createConfiguration,
-    getConfiguration,
-    deleteConfiguration,
-    deleteConfigurations,
-    getConfigurations,
-    // configuration's rows
-    createConfigurationRow,
-    createConfigurationRows,
-    deleteConfigurationRow,
-    deleteConfigurationRows,
-    // configuration's workspaces
-    createConfigurationWorkspace,
-    createConfigurationWorkspaceJob,
-    getConfigurationWorkspaces
-  };
-};
-
-// src/clients/storage/events/events.ts
-var createEvents = (client) => {
-  const getEvents = async (query, signal) => {
-    const { data } = await client.get(
-      "/events",
-      { query },
-      { signal }
-    );
-    return data;
-  };
-  const getEvent = async (eventId, signal) => {
-    const { data } = await client.get(
-      "/events/{eventId}",
-      {
-        path: { eventId }
-      },
-      { signal }
-    );
-    return data;
-  };
-  const createEvent = async (body, signal) => {
-    const { data } = await client.post(
-      "/events",
-      {
-        body
-      },
-      { signal }
-    );
-    return data;
-  };
-  return {
-    getEvents,
-    getEvent,
-    createEvent
-  };
-};
-
-// src/clients/storage/files/files.ts
-var createFiles = (client) => {
-  const getFile = async (fileId, signal) => {
-    const { data } = await client.get(
-      `/files/{fileId}`,
-      {
-        path: { fileId }
-      },
-      { signal }
-    );
-    return data;
-  };
-  const getFiles = async (query, signal) => {
-    const { data } = await client.get(
-      "/files",
-      { query },
-      { signal, queryArrayFormat: "brackets" }
-    );
-    return data;
-  };
-  const deleteFile = async (fileId) => {
-    const { data } = await client.delete(`/files/{fileId}`, {
-      path: { fileId }
-    });
-    return data;
-  };
-  const addFileTag = async (fileId, tag) => {
-    const { data } = await client.post(
-      `/files/{fileId}/tags`,
-      {
-        path: { fileId },
-        body: { tag }
-      }
-    );
-    return data;
-  };
-  const getFileContent = async (fileId, signal) => {
-    const { data } = await client.get(
-      `/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(
-      "/files/{fileId}/tags/{tag}",
-      {
-        path: { fileId, tag }
-      }
-    );
-    return data;
-  };
-  const prepareFile = async (body, signal) => {
-    const { data } = await client.post(
-      "/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(
-      `/jobs/{id}`,
-      {
-        path: { id }
-      },
-      { signal }
-    );
-    return data;
-  };
-  const getJobs = async (query, signal) => {
-    const { data } = await client.get(
-      "/jobs",
-      { query },
-      { signal, queryArrayFormat: "brackets" }
-    );
-    return data;
-  };
-  return { getJob, getJobs };
-};
-
-// src/clients/storage/tables/tables.ts
-var createTables = (client) => {
-  const getTables = async (query = { include: [] }, signal) => {
-    const { data } = await client.get(
-      `/tables`,
-      { query },
-      { signal, queryArrayFormat: "comma" }
-    );
-    return data;
-  };
-  const getTable = async (id, signal) => {
-    const { data } = await client.get(
-      `/tables/{id}`,
-      { path: { id } },
-      { signal }
-    );
-    return data;
-  };
-  const deleteTable = async (id, signal) => {
-    await client.delete(`/tables/{id}`, { path: { id } }, { signal });
-  };
-  const deleteTables = async (ids) => {
-    await concurrent({
-      items: ids,
-      process: (id) => deleteTable(id)
-    });
-  };
-  const deleteTableRows = async (id, query, signal) => {
-    const { data } = await client.delete(
-      `/tables/{id}/rows`,
-      { path: { id }, query },
-      { signal }
-    );
-    return data;
-  };
-  const getDataPreview = async (id, query, signal) => {
-    const { data } = await client.get(
-      `/tables/{id}/data-preview`,
-      { path: { id }, query: { format: "json", ...query } },
-      { signal }
-    );
-    return data;
-  };
-  const exportAsync = async (tableId, body, signal) => {
-    const { data } = await client.post(
-      "/tables/{id}/export-async",
-      { path: { id: tableId }, body },
-      { signal }
-    );
-    return data;
-  };
-  const createTableAsync = async (bucketId, body, signal) => {
-    const { data } = await client.post("/buckets/{bucketId}/tables-async", { path: { bucketId }, body }, { signal });
-    return data;
-  };
-  const importAsync = async (tableId, body, signal) => {
-    const { data } = await client.post(
-      "/tables/{id}/import-async",
-      { path: { id: tableId }, body },
-      { signal }
-    );
-    return data;
-  };
-  return {
-    getTables,
-    getTable,
-    getDataPreview,
-    deleteTable,
-    deleteTables,
-    deleteTableRows,
-    exportAsync,
-    createTableAsync,
-    importAsync
-  };
-};
-
-// src/clients/storage/tokens/tokens.ts
-var createTokens = (client) => {
-  const verify = async (signal) => {
-    const { data } = await client.get(
-      "/tokens/verify",
-      {},
-      { signal }
-    );
-    return data;
-  };
-  const refresh = async (id, signal) => {
-    const { data } = await client.post(
-      `/tokens/${id}/refresh`,
-      {},
-      { signal }
-    );
-    return data;
-  };
-  return {
-    verify,
-    refresh
-  };
-};
-
-// src/clients/storage/workspaces/workspaces.ts
-var createWorkspaces = (client) => {
-  const getWorkspaces = async (branchId, signal) => {
-    const { data } = await client.get(
-      "/branch/{branchId}/workspaces",
-      { path: { branchId } },
-      { signal }
-    );
-    return data;
-  };
-  const getWorkspace = async (path, signal) => {
-    const { data } = await client.get(
-      "/branch/{branchId}/workspaces/{workspaceId}",
-      { path },
-      { signal }
-    );
-    return data;
-  };
-  const deleteWorkspace = async (path) => {
-    await client.delete(
-      "/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(
-      "/branch/{branchId}/workspaces/{workspaceId}",
-      { path, query: { async: true } },
-      {}
-    );
-    return data;
-  };
-  const resetWorkspacePassword = async ({ branchId, workspaceId }) => {
-    const { data } = await client.post(
-      "/branch/{branchId}/workspaces/{workspaceId}/password",
-      {
-        path: { branchId, workspaceId }
-      }
-    );
-    return data;
-  };
-  const getWorkspaceSaml2Login = async (path, signal) => {
-    const { data } = await client.get(
-      "/branch/{branchId}/workspaces/{workspaceId}/saml2-login",
-      { path },
-      { signal }
-    );
-    return data;
-  };
-  const setWorkspacePublicKey = async ({
-    branchId,
-    workspaceId,
-    publicKey
-  }) => {
-    const { data } = await client.post("/branch/{branchId}/workspaces/{workspaceId}/public-key", {
-      path: { branchId, workspaceId },
-      body: { publicKey }
-    });
-    return data;
-  };
-  const getWorkspaceObjects = async (path, signal) => {
-    const { data } = await client.get(
-      "/branch/{branchId}/workspaces/{workspaceId}/objects",
-      { path },
-      { signal }
-    );
-    return data;
-  };
-  const deleteWorkspaceObjectsAsync = async ({
-    branchId,
-    workspaceId,
-    ...body
-  }) => {
-    const { data } = await client.post("/branch/{branchId}/workspaces/{workspaceId}/objects/batch-delete", {
-      path: { branchId, workspaceId },
-      body
-    });
-    return data;
-  };
-  return {
-    getWorkspace,
-    getWorkspaces,
-    deleteWorkspace,
-    resetWorkspacePassword,
-    deleteWorkspaces,
-    deleteWorkspaceJob,
-    setWorkspacePublicKey,
-    getWorkspaceSaml2Login,
-    getWorkspaceObjects,
-    deleteWorkspaceObjectsAsync
-  };
-};
-
-// src/clients/storage/storageClient.ts
-var createStorageClient = ({ baseUrl, middlewares = [] }) => {
-  const storageBaseUrl = `${baseUrl}/v2/storage`;
-  const client = createGenericFetchClient({
-    baseUrl: storageBaseUrl,
-    middlewares
-  });
-  const openApiClient = createOpenapiFetchClient({
-    baseUrl,
-    middlewares
-  });
-  const getStackInfo = async (query, signal) => {
-    const { data } = await client.get(
-      "",
-      { query },
-      { signal }
-    );
-    return data;
-  };
-  return {
-    buckets: createBuckets(client),
-    events: createEvents(client),
-    files: createFiles(client),
-    tables: createTables(client),
-    branches: createBranches(client),
-    workspaces: createWorkspaces(client),
-    mergeRequests: createMergeRequests(openApiClient),
-    jobs: createJobs(client),
-    componentsAndConfigurations: createComponentsAndConfigurations(client),
-    configurationVersions: createConfigurationVersions(client),
-    tokens: createTokens(client),
-    getStackInfo
-  };
-};
-
-// src/clients/storage/storageTokenMiddleware.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 createStorageTokenMiddleware = (initialToken) => {
-  let current = initialToken;
-  return (next) => async (request) => {
-    request.request.headers.set(KeboolaHttpHeader.STORAGE_API_TOKEN, current);
-    const response = await next(request);
-    if (isTokenRefreshEndpoint(request.request)) {
-      const newToken = tryParseNewToken(response.data);
-      if (newToken !== null) current = newToken;
-    }
-    return response;
-  };
-};
-
-export { createStorageClient, createStorageTokenMiddleware };
+export { createStorageClient, createStorageTokenMiddleware } from '../chunk-TNJWOHPM.js';
+import '../chunk-EBCZUGUX.js';
+import '../chunk-PD3LJYS2.js';
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map