@keboola/api-client 1.0.1 → 3.0.0

package/dist/index.js

@@ -1,39 +1,36 @@
-import qs from 'qs';
-import * as z5 from 'zod';
+import { createProject } from './chunk-UABYNGBZ.js';
+import { generateUUID, createTagSdk } from './chunk-JURD5MC3.js';
+export { generateUUID, keboolaUID } from './chunk-JURD5MC3.js';
+import { delay, createStorageSdk } from './chunk-R7PD3BRA.js';
+export { PollException, createStorageSdk, delay, poll } from './chunk-R7PD3BRA.js';
+import { createTelemetryClient } from './chunk-TXFQ4YIK.js';
+import { createVaultClient } from './chunk-SAEG42HW.js';
+export { UserError } from './chunk-SAEG42HW.js';
+import { createManagementClient } from './chunk-ZEMKE6DI.js';
+export { ManagementClientAuthError, isManagementClientAuthError } from './chunk-ZEMKE6DI.js';
+import { createVerifyClient } from './chunk-GNPQB3MT.js';
+import { createMetastoreClient } from './chunk-GO6SOMGL.js';
+import { createOauthClient } from './chunk-7FY6COWG.js';
+import { createQueryServiceClient } from './chunk-LV3ZWNDC.js';
+import { createQueueClient } from './chunk-3Y6NK7TC.js';
+import { createStatusClient } from './chunk-VAOCYA6B.js';
+import './chunk-7J2R6XHB.js';
+import { createStorageTokenMiddleware, createStorageClient } from './chunk-TNJWOHPM.js';
+export { series } from './chunk-TNJWOHPM.js';
+export { concurrent } from './chunk-EBCZUGUX.js';
+import { createSyncActionsClient } from './chunk-3B7L6MCG.js';
+import { createAiClient } from './chunk-VS5PM7KL.js';
+import { createAssetsClient } from './chunk-WQ7EZWBF.js';
+import { createChatClient } from './chunk-PV4HIVW2.js';
+import { suggestionsApiResponseSchema } from './chunk-4RC5E3SL.js';
+import { createDataScienceClient } from './chunk-UXF53ZOV.js';
+export { parseLogLines } from './chunk-UXF53ZOV.js';
+import { createEditorClient } from './chunk-OKVYLO6C.js';
+import { createEncryptionClient } from './chunk-IJMQCOBC.js';
+import { createImportClient } from './chunk-FBQHHAL5.js';
+import { KeboolaHttpHeader, HttpStatus, ApiError, createCallbackMiddleware, normalizeBaseUrl, createOpenapiFetchClient, createGenericFetchClient } from './chunk-PD3LJYS2.js';
+export { ApiError, HttpContentType, HttpHeader, KeboolaHttpHeader, createGenericFetchClient, isAbortError, isApiError, isFetchClientError, normalizeBaseUrl } from './chunk-PD3LJYS2.js';
 import { z } from 'zod';
-import dayjs from 'dayjs';
-import utc from 'dayjs/plugin/utc';
-
-// src/errors/UserError.ts
-var UserError = class extends Error {
-  constructor(message2) {
-    super(message2);
-  }
-};
-
-// 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/errors/ManagementClientAuthError.ts
-var ManagementClientAuthError = class extends ApiError {
-  title;
-  message;
-  constructor(title, message2, res) {
-    super(res);
-    this.title = title;
-    this.message = message2;
-  }
-};
 
 // src/errors/ServiceUnavailableError.ts
 var ServiceUnavailableError = class _ServiceUnavailableError extends Error {
@@ -45,399 +42,6 @@ var ServiceUnavailableError = class _ServiceUnavailableError extends Error {
     Object.setPrototypeOf(this, _ServiceUnavailableError.prototype);
   }
 };
-
-// src/constants.ts
-var KeboolaHttpHeader = {
-  STORAGE_API_TOKEN: "X-StorageApi-Token",
-  MANAGEMENT_API_TOKEN: "X-Kbc-Manageapitoken",
-  STORAGE_API_URL: "x-storageapi-url"
-};
-var HttpStatus = {
-  NO_CONTENT: 204,
-  BAD_REQUEST: 400,
-  UNPROCESSABLE_ENTITY: 422,
-  INTERNAL_SERVER_ERROR: 500,
-  BAD_GATEWAY: 502,
-  SERVICE_UNAVAILABLE: 503,
-  GATEWAY_TIMEOUT: 504
-};
-var ENCRYPTED_VALUE_PREFIX = "KBC::";
-
-// src/fetchClient/createFetchClient/utils.ts
-var HttpHeader = {
-  CONTENT_TYPE: "content-type",
-  CONTENT_DISPOSITION: "content-disposition"
-};
-var HttpContentType = {
-  JSON: "application/json",
-  TEXT_PLAIN: "text/plain",
-  FORM_DATA: "multipart/form-data",
-  TEXT_HTML: "text/html"
-};
-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 parseContentDispositionHeader = (contentDisposition) => {
-  const type = (() => {
-    const typeMatch = contentDisposition?.match(/^\s*(inline|attachment)\s*;/i);
-    return typeMatch?.[1]?.toLowerCase() ?? "unknown";
-  })();
-  const filename = (() => {
-    const filenameMatch = contentDisposition?.match(/filename="([^"]+)"/i);
-    if (filenameMatch) return filenameMatch[1];
-    const encodedFilenameMatch = contentDisposition?.match(/filename\*=(?:UTF-8'')?([^;]+)/i);
-    if (encodedFilenameMatch?.[1]) return decodeURIComponent(encodedFilenameMatch[1]);
-    const unquotedFilenameMatch = contentDisposition?.match(/filename=([^;]+)/i);
-    return unquotedFilenameMatch?.[1] ?? null;
-  })();
-  return { type, filename };
-};
-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 isAbortError = (error) => error instanceof DOMException && error.name === "AbortError";
-var isFetchClientError = (error) => error instanceof TypeError || error instanceof SyntaxError || isApiError(error);
-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/createFetchClient/middlewares.ts
-var createCallbackMiddleware = ({ onError, onSettled, onSuccess } = {}) => (next) => async (request) => {
-  let response;
-  try {
-    response = await next(request);
-    onSuccess?.();
-  } catch (error) {
-    onError?.(error);
-    throw error;
-  } finally {
-    onSettled?.();
-  }
-  return response;
-};
-
-// src/fetchClient/createGenericFetchClient.ts
-var createGenericFetchClient = (defaultOptions) => createFetchClient(defaultOptions);
-
-// src/fetchClient/createOpenapiFetchClient.ts
-var createOpenapiFetchClient = (defaultOptions) => createFetchClient(defaultOptions);
-
-// src/clients/ai/aiClient.ts
-var createAiClient = ({ baseUrl, middlewares }) => {
-  const client = createOpenapiFetchClient({
-    baseUrl,
-    middlewares
-  });
-  const describeConfigurationVersion = async (body) => {
-    const { data } = await client.post("/describe/configuration-version", { body });
-    return data;
-  };
-  const describeConfigurationMerge = async (body) => {
-    const { data } = await client.post("/describe/configuration-merge", { body });
-    return data;
-  };
-  const explainError = async (body) => {
-    const { data } = await client.post("/explain", { body });
-    return data;
-  };
-  const describeConfiguration = async (body) => {
-    const { data } = await client.post("/describe/configuration", { body });
-    return data;
-  };
-  const suggestComponent = async (body) => {
-    const { data } = await client.post("/suggest/component", { body });
-    return data;
-  };
-  const feedback = async (body) => {
-    const { data } = await client.post("/feedback", { body });
-    return data;
-  };
-  return {
-    describeConfigurationVersion,
-    describeConfigurationMerge,
-    explainError,
-    describeConfiguration,
-    suggestComponent,
-    feedback
-  };
-};
-
-// src/clients/assets/assetsClient.ts
-var createAssetsClient = ({ baseUrl, middlewares }) => {
-  const client = createGenericFetchClient({
-    baseUrl,
-    middlewares
-  });
-  const getPublishedChangelogPosts = async (signal) => {
-    const { data } = await client.get(
-      "/platform-changelog/published-posts.json",
-      {},
-      { signal }
-    );
-    return data;
-  };
-  return {
-    getPublishedChangelogPosts
-  };
-};
-var SUGGESTION_CATEGORIES = ["error", "maintenance", "documentation"];
-var suggestionCategorySchema = z.enum(SUGGESTION_CATEGORIES);
-var suggestionSchema = z.object({
-  label: z.preprocess((v) => typeof v === "string" ? v.slice(0, 80) : v, z.string().max(80)),
-  prompt: z.string(),
-  priority: z.number().int().min(1).max(3),
-  category: suggestionCategorySchema,
-  reasoning: z.string()
-});
-z.object({
-  suggestions: z.array(suggestionSchema).max(4)
-});
-var suggestionWithIdSchema = suggestionSchema.extend({
-  id: z.string()
-});
-var suggestionsApiResponseSchema = z.object({
-  suggestions: z.array(suggestionWithIdSchema).max(4),
-  suggestionSessionId: z.string()
-});
-var recentFailedJobSchema = z.object({
-  id: z.string(),
-  status: z.enum(["error", "warning"]),
-  component: z.string(),
-  configId: z.string(),
-  configName: z.string().optional(),
-  createdTime: z.string(),
-  durationSeconds: z.number().int().nonnegative().optional(),
-  errorMessage: z.string().max(200).optional()
-});
-var deprecatedComponentSchema = z.object({
-  id: z.string(),
-  name: z.string(),
-  type: z.string(),
-  expiredOn: z.string(),
-  configCount: z.number().int().nonnegative()
-});
-var userRecentEditSchema = z.object({
-  component: z.string(),
-  configId: z.string(),
-  configName: z.string(),
-  lastEdited: z.string()
-});
-var dashboardContextDataSchema = z.object({
-  recentFailedJobs: z.array(recentFailedJobSchema).max(5),
-  deprecatedComponents: z.array(deprecatedComponentSchema).max(5),
-  userRecentEdits: z.array(userRecentEditSchema).max(5),
-  currentUserEmail: z.string().email()
-});
-var JOB_STATUSES = [
-  "created",
-  "waiting",
-  "processing",
-  "success",
-  "error",
-  "terminating",
-  "terminated",
-  "cancelled",
-  "warning"
-];
-var jobDetailContextDataSchema = z.object({
-  job: z.object({
-    id: z.string(),
-    status: z.enum(JOB_STATUSES),
-    component: z.string(),
-    configId: z.string().optional(),
-    configName: z.string().optional(),
-    createdTime: z.string(),
-    startTime: z.string().optional(),
-    endTime: z.string().optional(),
-    durationSeconds: z.number().int().nonnegative().optional(),
-    errorMessage: z.string().max(500).optional(),
-    errorType: z.enum(["user", "application"]).optional(),
-    backendSize: z.string().optional()
-  }),
-  component: z.object({
-    id: z.string(),
-    name: z.string(),
-    type: z.string()
-  }).optional(),
-  runtimeHistory: z.object({
-    averageDurationSeconds: z.number().nonnegative().optional(),
-    minDurationSeconds: z.number().nonnegative().optional(),
-    maxDurationSeconds: z.number().nonnegative().optional(),
-    recentJobsCount: z.number().int().nonnegative(),
-    isSlowerThanAverage: z.boolean().optional(),
-    isFasterThanAverage: z.boolean().optional(),
-    percentageDifference: z.number().optional()
-  }).optional(),
-  currentUserEmail: z.string().email()
-});
-var configurationDetailContextDataSchema = z.object({
-  configuration: z.object({
-    id: z.string(),
-    name: z.string(),
-    description: z.string().max(500).optional(),
-    component: z.string(),
-    hasRows: z.boolean(),
-    rowCount: z.number().int().nonnegative().optional(),
-    lastChangeDescription: z.string().max(200).optional()
-  }),
-  component: z.object({
-    id: z.string(),
-    name: z.string(),
-    type: z.string()
-  }).optional(),
-  latestJobs: z.array(
-    z.object({
-      id: z.string(),
-      status: z.enum(JOB_STATUSES),
-      durationSeconds: z.number().int().nonnegative().optional(),
-      errorMessage: z.string().max(200).optional(),
-      createdTime: z.string()
-    })
-  ).max(5).optional(),
-  currentUserEmail: z.string().email()
-});
-var dashboardSuggestionsRequestSchema = z.object({
-  context: z.literal("dashboard"),
-  data: dashboardContextDataSchema
-});
-var jobDetailSuggestionsRequestSchema = z.object({
-  context: z.literal("job-detail"),
-  data: jobDetailContextDataSchema
-});
-var configurationDetailSuggestionsRequestSchema = z.object({
-  context: z.literal("configuration-detail"),
-  data: configurationDetailContextDataSchema
-});
-z.discriminatedUnion("context", [
-  dashboardSuggestionsRequestSchema,
-  jobDetailSuggestionsRequestSchema,
-  configurationDetailSuggestionsRequestSchema
-]);
-
-// src/clients/chat/chatClient.ts
 var agentSettingsSchema = z.object({
   projectId: z.string(),
   customInstructions: z.string().nullable(),
@@ -461,43 +65,71 @@ var toolInfoSchema = z.object({
 var toolsListResponseSchema = z.object({
   tools: z.array(toolInfoSchema)
 });
-var createChatClient = ({ baseUrl, middlewares, storageApiUrl }) => {
-  const client = createOpenapiFetchClient({
-    baseUrl,
-    headers: new Headers({
-      [KeboolaHttpHeader.STORAGE_API_URL]: storageApiUrl
-    }),
-    middlewares
-  });
+var sandboxFileEntrySchema = z.object({
+  name: z.string(),
+  path: z.string(),
+  type: z.enum(["file", "dir"]),
+  size: z.number().int().nonnegative().optional()
+});
+var sandboxFileListingSchema = z.object({
+  entries: z.array(sandboxFileEntrySchema)
+});
+var sandboxFileContentSchema = z.object({
+  content: z.string(),
+  encoding: z.enum(["utf-8", "binary"]),
+  truncated: z.boolean(),
+  size: z.number().int().nonnegative()
+});
+var sandboxGitBranchSchema = z.object({
+  branch: z.string().nullable()
+});
+var createKaiAgentClient = ({ baseUrl, middlewares }) => {
+  const clientOptions = { baseUrl: normalizeBaseUrl(baseUrl), middlewares };
+  const client = createOpenapiFetchClient(clientOptions);
+  const genericClient = createGenericFetchClient(clientOptions);
   const getHistory = async (params) => {
-    const { data } = await client.get("/history", { query: params });
+    const { data } = await client.get("/api/history", { query: params });
     return data;
   };
   const getChat = async (chatId, signal) => {
-    const { data } = await client.get("/chat/{id}", { path: { id: chatId } }, { signal });
+    const { data } = await client.get("/api/chat/{id}", { path: { id: chatId } }, { signal });
     return data;
   };
   const deleteChat = async (chatId) => {
-    const { data } = await client.delete("/chat", { query: { id: chatId } });
+    const { data } = await client.delete("/api/chat", { query: { id: chatId } });
     return data;
   };
+  const createChat = async (request) => {
+    const { response } = await client.post("/api/chat", { body: request });
+    return response;
+  };
   const getVotes = async (chatId) => {
-    const { data } = await client.get("/vote", { query: { chatId } });
+    const { data } = await client.get("/api/vote", { query: { chatId } });
     return data;
   };
   const submitVote = async (params) => {
-    await client.patch("/vote", { body: params });
-  };
-  const createChat = async (request) => {
-    const { response } = await client.post("/chat", { body: request });
-    return response;
+    await client.patch("/api/vote", { body: params });
   };
   const getUsage = async (signal) => {
-    const { data } = await client.get("/usage", {}, { signal });
+    const { data } = await client.get("/api/usage", {}, { signal });
+    return data;
+  };
+  const approveToolCall = async (chatId, body) => {
+    await client.post("/api/chat/{id}/approval", { path: { id: chatId }, body });
+  };
+  const submitToolOutput = async (chatId, body) => {
+    await client.post("/api/chat/{id}/ui-tool-result", { path: { id: chatId }, body });
+  };
+  const stopChat = async (chatId) => {
+    const { data } = await client.post("/api/chat/{id}/stop", { path: { id: chatId } });
     return data;
   };
   const getSuggestions = async (request, signal) => {
-    const { data } = await client.post("/suggestions", { body: request }, { signal });
+    const { data } = await genericClient.post(
+      "/api/suggestions",
+      { body: request },
+      { signal }
+    );
     const result = suggestionsApiResponseSchema.safeParse(data);
     if (!result.success) {
       throw new Error("Invalid suggestions response format");
@@ -505,7 +137,7 @@ var createChatClient = ({ baseUrl, middlewares, storageApiUrl }) => {
     return result.data;
   };
   const getAgentSettings = async (signal) => {
-    const { data } = await client.get("/settings", {}, { signal });
+    const { data } = await genericClient.get("/api/settings", {}, { signal });
     const result = agentSettingsSchema.safeParse(data);
     if (!result.success) {
       throw new Error("Invalid agent settings response format");
@@ -513,7 +145,11 @@ var createChatClient = ({ baseUrl, middlewares, storageApiUrl }) => {
     return result.data;
   };
   const updateAgentSettings = async (request, signal) => {
-    const { data } = await client.patch("/settings", { body: request }, { signal });
+    const { data } = await genericClient.patch(
+      "/api/settings",
+      { body: request },
+      { signal }
+    );
     const result = agentSettingsSchema.safeParse(data);
     if (!result.success) {
       throw new Error("Invalid agent settings response format");
@@ -521,7 +157,11 @@ var createChatClient = ({ baseUrl, middlewares, storageApiUrl }) => {
     return result.data;
   };
   const getUserAgentSettings = async (signal) => {
-    const { data } = await client.get("/settings/user", {}, { signal });
+    const { data } = await genericClient.get(
+      "/api/settings/user",
+      {},
+      { signal }
+    );
     const result = userAgentSettingsSchema.safeParse(data);
     if (!result.success) {
       throw new Error("Invalid user agent settings response format");
@@ -529,7 +169,11 @@ var createChatClient = ({ baseUrl, middlewares, storageApiUrl }) => {
     return result.data;
   };
   const updateUserAgentSettings = async (request, signal) => {
-    const { data } = await client.patch("/settings/user", { body: request }, { signal });
+    const { data } = await genericClient.patch(
+      "/api/settings/user",
+      { body: request },
+      { signal }
+    );
     const result = userAgentSettingsSchema.safeParse(data);
     if (!result.success) {
       throw new Error("Invalid user agent settings response format");
@@ -537,13 +181,54 @@ var createChatClient = ({ baseUrl, middlewares, storageApiUrl }) => {
     return result.data;
   };
   const getToolsList = async (signal) => {
-    const { data } = await client.get("/settings/tools", {}, { signal });
+    const { data } = await genericClient.get(
+      "/api/settings/tools",
+      {},
+      { signal }
+    );
     const result = toolsListResponseSchema.safeParse(data);
     if (!result.success) {
       throw new Error("Invalid tools list response format");
     }
     return result.data;
   };
+  const listSandboxFiles = async (chatId, path, signal) => {
+    const { data } = await genericClient.get(
+      `/api/chat/${encodeURIComponent(chatId)}/sandbox/files`,
+      { query: path ? { path } : void 0 },
+      { signal }
+    );
+    const result = sandboxFileListingSchema.safeParse(data);
+    if (!result.success) {
+      throw new Error("Invalid sandbox files response format");
+    }
+    return result.data;
+  };
+  const readSandboxFile = async (chatId, path, signal) => {
+    const { data } = await genericClient.get(
+      `/api/chat/${encodeURIComponent(chatId)}/sandbox/file`,
+      { query: { path } },
+      { signal }
+    );
+    const result = sandboxFileContentSchema.safeParse(data);
+    if (!result.success) {
+      throw new Error("Invalid sandbox file response format");
+    }
+    return result.data;
+  };
+  const getSandboxGitBranch = async (chatId, signal) => {
+    const { data } = await genericClient.get(
+      `/api/chat/${encodeURIComponent(chatId)}/sandbox/git-branch`,
+      {},
+      { signal }
+    );
+    const result = sandboxGitBranchSchema.safeParse(data);
+    if (!result.success) {
+      throw new Error("Invalid sandbox git-branch response format");
+    }
+    return result.data;
+  };
+  const chatStreamUrl = clientOptions.baseUrl + "/api/chat";
   return {
     getHistory,
     getChat,
@@ -552,2988 +237,54 @@ var createChatClient = ({ baseUrl, middlewares, storageApiUrl }) => {
     getVotes,
     submitVote,
     getUsage,
+    approveToolCall,
+    submitToolOutput,
+    stopChat,
     getSuggestions,
     getAgentSettings,
     updateAgentSettings,
     getUserAgentSettings,
     updateUserAgentSettings,
-    getToolsList
-  };
-};
-var TailError = z5.object({
-  context: z5.object({
-    code: z5.string()
-  })
-});
-dayjs.extend(utc);
-var ISO_TIMESTAMP_REGEX = /\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?Z/;
-var LEADING_ISO_TIMESTAMP_REGEX = /^(\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?Z)\s?/;
-var tryParseJsonl = (line) => {
-  if (!line.startsWith("{")) return null;
-  let parsed;
-  try {
-    parsed = JSON.parse(line);
-  } catch {
-    return null;
-  }
-  if (typeof parsed !== "object" || parsed === null) return null;
-  const record = parsed;
-  const { timestamp, message: message2 } = record;
-  if (typeof timestamp !== "string" || typeof message2 !== "string") return null;
-  return {
-    timestamp,
-    message: message2
+    getToolsList,
+    listSandboxFiles,
+    readSandboxFile,
+    getSandboxGitBranch,
+    chatStreamUrl
   };
 };
-var parsePlainTextLine = (line) => {
-  const match = line.match(LEADING_ISO_TIMESTAMP_REGEX);
-  if (match) {
-    return { timestamp: match[1], message: line.slice(match[0].length) };
+
+// src/utils/assert.ts
+function assert(value, message) {
+  if (value == null) {
+    throw new Error(message);
   }
-  return { timestamp: null, message: line };
+}
+
+// src/domain/stack.ts
+var SERVICE_URL_OVERRIDES = {
+  // The service URL for the Kai Assistant is incomplete; we need to add the `/api` suffix to get the full URL for the API.
+  // I assume the service is versioned.
+  "kai-assistant": (url) => `${url}/api`
 };
-var parseLogLine = (line) => tryParseJsonl(line) ?? parsePlainTextLine(line);
-var toLogEntryFromObject = (raw) => {
-  if (typeof raw.message !== "string") return null;
-  return {
-    timestamp: typeof raw.timestamp === "string" ? raw.timestamp : null,
-    message: raw.message
+var createStack = ({ stackInfo, clientServiceUrls }) => {
+  const { services, components, features, ...infoRest } = stackInfo;
+  const serviceMap = new Map(
+    services.map((service) => {
+      const devOverride = clientServiceUrls?.[service.id]?.(service.url);
+      const prodOverride = SERVICE_URL_OVERRIDES[service.id]?.(service.url);
+      const url = devOverride ?? prodOverride ?? service.url;
+      return [service.id, url];
+    })
+  );
+  const componentMap = new Map(components.map((component) => [component.id, component]));
+  const featureSet = new Set(features);
+  const hasFeature = (...feature) => {
+    if (feature.length === 0) return false;
+    return feature.every((x) => featureSet.has(x));
   };
-};
-var isPlainObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
-var parseLogLines = (raw) => {
-  if (raw === null || raw === void 0 || raw === "") return [];
-  if (Array.isArray(raw)) {
-    return raw.flatMap((item) => {
-      if (typeof item === "string") return item === "" ? [] : [parseLogLine(item)];
-      if (isPlainObject(item)) {
-        const entry = toLogEntryFromObject(item);
-        return entry ? [entry] : [];
-      }
-      return [];
-    });
-  }
-  if (isPlainObject(raw)) {
-    const entry = toLogEntryFromObject(raw);
-    return entry ? [entry] : [];
-  }
-  if (typeof raw !== "string") return [];
-  const lines = raw.split("\n");
-  const entries = [];
-  for (const line of lines) {
-    if (line === "") continue;
-    entries.push(parseLogLine(line));
-  }
-  return entries;
-};
-var parseLastLogTimestamp = (logs) => {
-  const entries = parseLogLines(logs);
-  for (let i = entries.length - 1; i >= 0; i--) {
-    const entry = entries[i];
-    if (!entry) continue;
-    if (entry.timestamp) return entry.timestamp;
-    const match = entry.message.match(ISO_TIMESTAMP_REGEX);
-    if (match) return match[0];
-  }
-  return null;
-};
-var calculateNextLogTimestamp = (timestamp) => {
-  if (timestamp === null) return null;
-  return dayjs(timestamp).utc().add(1, "second").utc().format();
-};
-var prepareAppRun = (appRun) => {
-  return {
-    ...appRun,
-    state: appRun.state ?? (appRun.stoppedAt ? "finished" : "running")
-    // fallback state for historic non migrated runs
-  };
-};
-
-// src/clients/dataScience/dataScienceClient.ts
-var createDataScienceClient = ({ baseUrl, middlewares }) => {
-  const client = createOpenapiFetchClient({
-    baseUrl,
-    middlewares
-  });
-  const getAppRuns = async (appId, query, signal) => {
-    const { data } = await client.get("/apps/{appId}/runs", { path: { appId }, query }, { signal });
-    return data.map(prepareAppRun);
-  };
-  const getAppRun = async (appId, runId, signal) => {
-    const { data } = await client.get(
-      "/apps/{appId}/runs/{runId}",
-      { path: { appId, runId } },
-      { signal }
-    );
-    return prepareAppRun(data);
-  };
-  const getAppLogsDownload = async (id, signal) => {
-    const { data, response } = await client.get(
-      "/apps/{appId}/logs/download",
-      { path: { appId: id } },
-      { signal }
-    );
-    const contentDisposition = parseContentDispositionHeader(
-      response.headers.get(HttpHeader.CONTENT_DISPOSITION)
-    );
-    return {
-      logs: data,
-      fileName: contentDisposition?.filename ?? "logs.txt"
-    };
-  };
-  const getAppLogsTail = async (id, { query, signal } = {}) => {
-    try {
-      const { data } = await client.get(
-        "/apps/{appId}/logs/tail",
-        {
-          query,
-          path: {
-            appId: id
-          }
-        },
-        {
-          signal
-        }
-      );
-      const logs = data === "" ? null : data;
-      const lastLogTimestamp = parseLastLogTimestamp(logs);
-      const nextLogTimestamp = calculateNextLogTimestamp(lastLogTimestamp);
-      return {
-        entries: parseLogLines(logs),
-        nextLogTimestamp
-      };
-    } catch (error) {
-      if (isApiError(error) && error.response.status === HttpStatus.BAD_REQUEST && TailError.safeParse(error.data).data?.context?.code === "apps.appNotRunning") {
-        return { entries: [], nextLogTimestamp: null };
-      }
-      throw error;
-    }
-  };
-  const getApps = async (query, signal) => {
-    const { data } = await client.get("/apps", { query }, { signal });
-    return data;
-  };
-  const getApp = async (appId, signal) => {
-    const { data } = await client.get("/apps/{appId}", { path: { appId } }, { signal });
-    return data;
-  };
-  const createApp = async (body, signal) => {
-    const { data } = await client.post("/apps", { body }, { signal });
-    return data;
-  };
-  const patchApp = async (appId, body, signal) => {
-    const { data } = await client.patch(
-      "/apps/{appId}",
-      {
-        path: { appId },
-        body
-      },
-      { signal }
-    );
-    return data;
-  };
-  const deleteApp = async (appId, signal) => {
-    return client.delete("/apps/{appId}", { path: { appId } }, { signal });
-  };
-  const getAppPassword = async (appId, signal) => {
-    const { data } = await client.get("/apps/{appId}/password", { path: { appId } }, { signal });
-    return data;
-  };
-  const resetAppPassword = async (appId, signal) => {
-    const { data } = await client.post(
-      "/apps/{appId}/reset-password",
-      { path: { appId } },
-      { signal }
-    );
-    return data;
-  };
-  const getRuntimes = async (signal) => {
-    const { data } = await client.get("/runtimes", {}, { signal });
-    return data;
-  };
-  const getSandbox = async (appId, signal) => {
-    const { data } = await client.get("/sandboxes/{appId}", { path: { appId } }, { signal });
-    return data;
-  };
-  return {
-    getAppRuns,
-    getAppRun,
-    getAppLogsDownload,
-    getAppLogsTail,
-    getApps,
-    getApp,
-    createApp,
-    patchApp,
-    deleteApp,
-    getAppPassword,
-    resetAppPassword,
-    getRuntimes,
-    getSandbox
-  };
-};
-
-// src/clients/editor/editorClient.ts
-var createEditorClient = ({ baseUrl, middlewares }) => {
-  const client = createOpenapiFetchClient({
-    baseUrl,
-    middlewares
-  });
-  const createSession = async (body) => {
-    const { data } = await client.post("/sql/sessions", {
-      body
-    });
-    return data;
-  };
-  const getSession = async ({ id }, signal) => {
-    const { data } = await client.get(`/sql/sessions/{id}`, { path: { id } }, { signal });
-    return data;
-  };
-  const getSessions = async (query, signal) => {
-    const { data } = await client.get(`/sql/sessions`, { query }, { signal });
-    return data;
-  };
-  const getSessionSchema = async ({
-    id,
-    onlyWorkspaceSchema = "1",
-    loadTables = "1"
-  }, signal) => {
-    const { data } = await client.get(
-      `/sql/sessions/{id}/schema`,
-      {
-        path: { id },
-        query: { onlyWorkspaceSchema, loadTables }
-      },
-      { signal }
-    );
-    return data;
-  };
-  const createQueryJob = async ({ id }, body) => {
-    const { data } = await client.post(`/sql/sessions/{id}/run-query`, {
-      path: { id },
-      body
-    });
-    return data;
-  };
-  const tablePreview = async ({ id }, body) => {
-    const { data } = await client.post(`/sql/sessions/{id}/table-preview`, {
-      path: { id },
-      body
-    });
-    return data;
-  };
-  const tableDefinition = async ({ id, ...query }, signal) => {
-    const { data } = await client.get(
-      `/sql/sessions/{id}/table-ddl`,
-      { path: { id }, query },
-      { signal }
-    );
-    return data;
-  };
-  const load = async ({ id }, body) => {
-    const { data } = await client.post(`/sql/sessions/{id}/load`, {
-      path: { id },
-      body
-    });
-    return data;
-  };
-  const unload = async ({ id }, body) => {
-    const { data } = await client.post(`/sql/sessions/{id}/unload`, {
-      path: { id },
-      // BE error: The body is optional; however, without it, the request will fail with the message "Request content type must be application/json."
-      // This is expected, as our client cannot correctly determine the content type without the body.
-      // This issue should be addressed to indicate that the body is required in their Swagger schema.
-      body: body ?? { tableId: null }
-    });
-    return data;
-  };
-  const resetWorkspacePassword = async (id) => {
-    const { data } = await client.post(`/sql/sessions/{id}/reset-password`, {
-      path: { id }
-    });
-    return data;
-  };
-  const getSessionCredentials = async (id, signal) => {
-    const { data } = await client.get(
-      `/sql/sessions/{id}/credentials`,
-      { path: { id } },
-      { signal }
-    );
-    return data;
-  };
-  return {
-    createSession,
-    getSession,
-    getSessions,
-    getSessionSchema,
-    createQueryJob,
-    tablePreview,
-    tableDefinition,
-    load,
-    unload,
-    resetWorkspacePassword,
-    getSessionCredentials
-  };
-};
-
-// src/clients/encryption/encryptionClient.ts
-var createEncryptionClient = ({ baseUrl, middlewares }) => {
-  const client = createGenericFetchClient({
-    baseUrl,
-    middlewares
-  });
-  const _encrypt = async (data, signal) => {
-    const response = await client.post(
-      "/encrypt",
-      {
-        query: {
-          projectId: data.projectId,
-          branchType: data.branchType,
-          componentId: data.componentId
-        },
-        body: data.data
-      },
-      { signal }
-    );
-    return response.data;
-  };
-  const encrypt = (data, signal) => _encrypt(data, signal);
-  const encryptSecrets = (data, signal) => _encrypt(data, signal);
-  return {
-    encryptSecrets,
-    encrypt
-  };
-};
-
-// src/clients/import/importClient.ts
-var createImportClient = ({ baseUrl, middlewares }) => {
-  const client = createGenericFetchClient({
-    baseUrl,
-    middlewares
-  });
-  const uploadFile = async (file, params = {}, signal) => {
-    const formData = new FormData();
-    formData.append("data", file);
-    if (params.isPermanent) {
-      formData.append("isPermanent", "1");
-    }
-    if (params.notify) {
-      formData.append("notify", "1");
-    }
-    if (params.branchId) {
-      formData.append("branchId", params.branchId);
-    }
-    if (params.tags) {
-      for (const tag of params.tags) {
-        formData.append("tags[]", tag);
-      }
-    }
-    const { data } = await client.post(
-      "/upload-file",
-      { body: formData },
-      { signal }
-    );
-    return data;
-  };
-  return {
-    uploadFile
-  };
-};
-var agentSettingsSchema2 = z.object({
-  projectId: z.string(),
-  customInstructions: z.string().nullable(),
-  createdAt: z.string(),
-  updatedAt: z.string()
-});
-var toolPermissionValueSchema2 = z.enum(["always_allow", "always_ask", "blocked"]);
-var userAgentSettingsSchema2 = z.object({
-  projectId: z.string(),
-  userId: z.string(),
-  customInstructions: z.string().nullable(),
-  toolPermissions: z.record(z.string(), toolPermissionValueSchema2).nullable(),
-  createdAt: z.string(),
-  updatedAt: z.string()
-});
-var toolInfoSchema2 = z.object({
-  name: z.string(),
-  description: z.string(),
-  readOnly: z.boolean()
-});
-var toolsListResponseSchema2 = z.object({
-  tools: z.array(toolInfoSchema2)
-});
-var sandboxFileEntrySchema = z.object({
-  name: z.string(),
-  path: z.string(),
-  type: z.enum(["file", "dir"]),
-  size: z.number().int().nonnegative().optional()
-});
-var sandboxFileListingSchema = z.object({
-  entries: z.array(sandboxFileEntrySchema)
-});
-var sandboxFileContentSchema = z.object({
-  content: z.string(),
-  encoding: z.enum(["utf-8", "binary"]),
-  truncated: z.boolean(),
-  size: z.number().int().nonnegative()
-});
-var sandboxGitBranchSchema = z.object({
-  branch: z.string().nullable()
-});
-var createKaiAgentClient = ({ baseUrl, middlewares }) => {
-  const clientOptions = { baseUrl, middlewares };
-  const client = createOpenapiFetchClient(clientOptions);
-  const genericClient = createGenericFetchClient(clientOptions);
-  const getHistory = async (params) => {
-    const { data } = await client.get("/api/history", { query: params });
-    return data;
-  };
-  const getChat = async (chatId, signal) => {
-    const { data } = await client.get("/api/chat/{id}", { path: { id: chatId } }, { signal });
-    return data;
-  };
-  const deleteChat = async (chatId) => {
-    const { data } = await client.delete("/api/chat", { query: { id: chatId } });
-    return data;
-  };
-  const createChat = async (request) => {
-    const { response } = await client.post("/api/chat", { body: request });
-    return response;
-  };
-  const getVotes = async (chatId) => {
-    const { data } = await client.get("/api/vote", { query: { chatId } });
-    return data;
-  };
-  const submitVote = async (params) => {
-    await client.patch("/api/vote", { body: params });
-  };
-  const getUsage = async (signal) => {
-    const { data } = await client.get("/api/usage", {}, { signal });
-    return data;
-  };
-  const approveToolCall = async (chatId, body) => {
-    await client.post("/api/chat/{id}/approval", { path: { id: chatId }, body });
-  };
-  const submitToolOutput = async (chatId, body) => {
-    await client.post("/api/chat/{id}/ui-tool-result", { path: { id: chatId }, body });
-  };
-  const stopChat = async (chatId) => {
-    const { data } = await client.post("/api/chat/{id}/stop", { path: { id: chatId } });
-    return data;
-  };
-  const getSuggestions = async (request, signal) => {
-    const { data } = await genericClient.post(
-      "/api/suggestions",
-      { body: request },
-      { signal }
-    );
-    const result = suggestionsApiResponseSchema.safeParse(data);
-    if (!result.success) {
-      throw new Error("Invalid suggestions response format");
-    }
-    return result.data;
-  };
-  const getAgentSettings = async (signal) => {
-    const { data } = await genericClient.get("/api/settings", {}, { signal });
-    const result = agentSettingsSchema2.safeParse(data);
-    if (!result.success) {
-      throw new Error("Invalid agent settings response format");
-    }
-    return result.data;
-  };
-  const updateAgentSettings = async (request, signal) => {
-    const { data } = await genericClient.patch(
-      "/api/settings",
-      { body: request },
-      { signal }
-    );
-    const result = agentSettingsSchema2.safeParse(data);
-    if (!result.success) {
-      throw new Error("Invalid agent settings response format");
-    }
-    return result.data;
-  };
-  const getUserAgentSettings = async (signal) => {
-    const { data } = await genericClient.get(
-      "/api/settings/user",
-      {},
-      { signal }
-    );
-    const result = userAgentSettingsSchema2.safeParse(data);
-    if (!result.success) {
-      throw new Error("Invalid user agent settings response format");
-    }
-    return result.data;
-  };
-  const updateUserAgentSettings = async (request, signal) => {
-    const { data } = await genericClient.patch(
-      "/api/settings/user",
-      { body: request },
-      { signal }
-    );
-    const result = userAgentSettingsSchema2.safeParse(data);
-    if (!result.success) {
-      throw new Error("Invalid user agent settings response format");
-    }
-    return result.data;
-  };
-  const getToolsList = async (signal) => {
-    const { data } = await genericClient.get(
-      "/api/settings/tools",
-      {},
-      { signal }
-    );
-    const result = toolsListResponseSchema2.safeParse(data);
-    if (!result.success) {
-      throw new Error("Invalid tools list response format");
-    }
-    return result.data;
-  };
-  const listSandboxFiles = async (chatId, path, signal) => {
-    const { data } = await genericClient.get(
-      `/api/chat/${encodeURIComponent(chatId)}/sandbox/files`,
-      { query: path ? { path } : void 0 },
-      { signal }
-    );
-    const result = sandboxFileListingSchema.safeParse(data);
-    if (!result.success) {
-      throw new Error("Invalid sandbox files response format");
-    }
-    return result.data;
-  };
-  const readSandboxFile = async (chatId, path, signal) => {
-    const { data } = await genericClient.get(
-      `/api/chat/${encodeURIComponent(chatId)}/sandbox/file`,
-      { query: { path } },
-      { signal }
-    );
-    const result = sandboxFileContentSchema.safeParse(data);
-    if (!result.success) {
-      throw new Error("Invalid sandbox file response format");
-    }
-    return result.data;
-  };
-  const getSandboxGitBranch = async (chatId, signal) => {
-    const { data } = await genericClient.get(
-      `/api/chat/${encodeURIComponent(chatId)}/sandbox/git-branch`,
-      {},
-      { signal }
-    );
-    const result = sandboxGitBranchSchema.safeParse(data);
-    if (!result.success) {
-      throw new Error("Invalid sandbox git-branch response format");
-    }
-    return result.data;
-  };
-  const chatStreamUrl = baseUrl + "/api/chat";
-  return {
-    getHistory,
-    getChat,
-    deleteChat,
-    createChat,
-    getVotes,
-    submitVote,
-    getUsage,
-    approveToolCall,
-    submitToolOutput,
-    stopChat,
-    getSuggestions,
-    getAgentSettings,
-    updateAgentSettings,
-    getUserAgentSettings,
-    updateUserAgentSettings,
-    getToolsList,
-    listSandboxFiles,
-    readSandboxFile,
-    getSandboxGitBranch,
-    chatStreamUrl
-  };
-};
-
-// src/clients/verify/createVerifyClient.ts
-var createVerifyClient = () => {
-  const storageApiToken = async (host, token, signal) => {
-    const { data } = await createGenericFetchClient({
-      baseUrl: `${host}/v2/storage`,
-      headers: new Headers({ [KeboolaHttpHeader.STORAGE_API_TOKEN]: token })
-    }).get("/tokens/verify", {}, { signal });
-    return data;
-  };
-  const managementApiToken = async (host, token, signal) => {
-    const { data } = await createGenericFetchClient({
-      baseUrl: host,
-      headers: new Headers({ [KeboolaHttpHeader.MANAGEMENT_API_TOKEN]: token })
-    }).get("/manage/tokens/verify", {}, { signal });
-    return data;
-  };
-  return {
-    storageApiToken,
-    managementApiToken
-  };
-};
-
-// src/clients/management/authMiddleware.ts
-var TOKEN_CACHE_TTL_MS = 6e4;
-var isManagementClientAuthError = (error) => error instanceof ManagementClientAuthError;
-var createAuth = (baseUrl) => {
-  const fetchClient = createGenericFetchClient({ baseUrl });
-  const createCurrentUserSessionToken = async (accessToken) => {
-    const headers = new Headers({ [KeboolaHttpHeader.MANAGEMENT_API_TOKEN]: accessToken });
-    const { data } = await fetchClient.post(
-      "/manage/current-user/session-token",
-      {},
-      { headers }
-    );
-    return data.token;
-  };
-  const createAdminAccountSessionToken = async () => {
-    const { data } = await fetchClient.post(
-      "/admin/account/session-token",
-      {},
-      {
-        // transform valid response, to invalid and throw custom error
-        validateStatus: (apiResponse) => {
-          const { response } = apiResponse;
-          const isTextContent = response.headers.get(HttpHeader.CONTENT_TYPE)?.includes(HttpContentType.TEXT_HTML);
-          if (isTextContent)
-            return new ManagementClientAuthError(
-              "Your session expired",
-              "You will be logged out automatically.",
-              apiResponse
-            );
-          return defaultValidateStatus(apiResponse);
-        }
-      }
-    );
-    return data.token;
-  };
-  return {
-    createCurrentUserSessionToken,
-    createAdminAccountSessionToken
-  };
-};
-var createAuthMiddleware = ({
-  accessToken,
-  baseUrl
-}) => {
-  const auth = createAuth(baseUrl);
-  const verify = createVerifyClient();
-  let token = accessToken;
-  let tokenValidUntil = 0;
-  let inflightAuth = null;
-  const isDevelopment = process.env.NODE_ENV === "development";
-  const ensureValidToken = async () => {
-    if (token && Date.now() < tokenValidUntil) return token;
-    if (token) {
-      const tokenInfo = await verify.managementApiToken(baseUrl, token);
-      const isTokenValid = !tokenInfo.isDisabled && !tokenInfo.isExpired;
-      if (isTokenValid) {
-        tokenValidUntil = Date.now() + TOKEN_CACHE_TTL_MS;
-        return token;
-      }
-      token = isDevelopment ? await auth.createCurrentUserSessionToken(token) : await auth.createAdminAccountSessionToken();
-      tokenValidUntil = Date.now() + TOKEN_CACHE_TTL_MS;
-      return token;
-    }
-    token = await auth.createAdminAccountSessionToken();
-    tokenValidUntil = Date.now() + TOKEN_CACHE_TTL_MS;
-    return token;
-  };
-  return (next) => async (request) => {
-    if (!inflightAuth) {
-      inflightAuth = ensureValidToken().finally(() => {
-        inflightAuth = null;
-      });
-    }
-    const validToken = await inflightAuth;
-    request.request.headers.set(KeboolaHttpHeader.MANAGEMENT_API_TOKEN, validToken);
-    return next(request);
-  };
-};
-
-// src/clients/management/currentUser/currentUser.ts
-var createCurrentUser = (client) => {
-  const getMaintainerInvitations = async (signal) => {
-    const { data } = await client.get(
-      "/manage/current-user/maintainers-invitations",
-      {},
-      { signal }
-    );
-    return data;
-  };
-  const getMaintainerInvitation = async (id, signal) => {
-    const { data } = await client.get(
-      "/manage/current-user/maintainers-invitations/{id}",
-      { path: { id } },
-      { signal }
-    );
-    return data;
-  };
-  const acceptMaintainerInvitation = async (id) => {
-    await client.put("/manage/current-user/maintainers-invitations/{id}", { path: { id } });
-  };
-  const rejectMaintainerInvitation = async (id) => {
-    await client.delete("/manage/current-user/maintainers-invitations/{id}", { path: { id } });
-  };
-  const getOrganizationInvitations = async (signal) => {
-    const { data } = await client.get(
-      "/manage/current-user/organizations-invitations",
-      {},
-      { signal }
-    );
-    return data;
-  };
-  const getOrganizationInvitation = async (id, signal) => {
-    const { data } = await client.get(
-      "/manage/current-user/organizations-invitations/{id}",
-      { path: { id } },
-      { signal }
-    );
-    return data;
-  };
-  const acceptOrganizationInvitation = async (id) => {
-    await client.put("/manage/current-user/organizations-invitations/{id}", { path: { id } });
-  };
-  const rejectOrganizationInvitation = async (id) => {
-    await client.delete("/manage/current-user/organizations-invitations/{id}", { path: { id } });
-  };
-  const getProjectInvitations = async (signal) => {
-    const { data } = await client.get("/manage/current-user/projects-invitations", {}, { signal });
-    return data;
-  };
-  const getProjectInvitation = async (id, signal) => {
-    const { data } = await client.get(
-      "/manage/current-user/projects-invitations/{id}",
-      { path: { id } },
-      { signal }
-    );
-    return data;
-  };
-  const acceptProjectInvitation = async (id) => {
-    await client.put("/manage/current-user/projects-invitations/{id}", { path: { id } });
-  };
-  const rejectProjectInvitation = async (id) => {
-    await client.delete("/manage/current-user/projects-invitations/{id}", { path: { id } });
-  };
-  const getProjectJoinRequests = async (signal) => {
-    const { data } = await client.get(
-      "/manage/current-user/projects-join-requests",
-      {},
-      { signal }
-    );
-    return data;
-  };
-  const deleteProjectJoinRequest = async (id) => {
-    await client.delete("/manage/current-user/projects-join-requests/{id}", { path: { id } });
-  };
-  return {
-    getMaintainerInvitations,
-    getMaintainerInvitation,
-    acceptMaintainerInvitation,
-    rejectMaintainerInvitation,
-    getOrganizationInvitations,
-    getOrganizationInvitation,
-    acceptOrganizationInvitation,
-    rejectOrganizationInvitation,
-    getProjectInvitations,
-    getProjectInvitation,
-    acceptProjectInvitation,
-    rejectProjectInvitation,
-    getProjectJoinRequests,
-    deleteProjectJoinRequest
-  };
-};
-
-// src/clients/management/features/features.ts
-var createFeatures = (client) => {
-  const getAllFeatures = async (query, signal) => {
-    const { data } = await client.get(
-      "/features",
-      { query },
-      { signal }
-    );
-    return data;
-  };
-  return {
-    getAllFeatures
-  };
-};
-
-// src/clients/management/maintainers/maintainers.ts
-var createMaintainers = (client) => {
-  const getMaintainers = async (signal) => {
-    const { data } = await client.get("/manage/maintainers", {}, { signal });
-    return data;
-  };
-  const getMaintainer = async (maintainerId, signal) => {
-    const { data } = await client.get(
-      "/manage/maintainers/{id}",
-      { path: { id: maintainerId } },
-      { signal }
-    );
-    return data;
-  };
-  const createMaintainer = async (body) => {
-    const { data } = await client.post("/manage/maintainers", { body });
-    return data;
-  };
-  const updateMaintainer = async ({
-    maintainerId,
-    ...body
-  }) => {
-    const { data } = await client.patch("/manage/maintainers/{id}", {
-      path: { id: maintainerId },
-      body
-    });
-    return data;
-  };
-  const deleteMaintainer = async (maintainerId) => {
-    await client.delete("/manage/maintainers/{id}", { path: { id: maintainerId } });
-  };
-  const getMaintainerUsers = async (maintainerId, signal) => {
-    const { data } = await client.get(
-      "/manage/maintainers/{id}/users",
-      { path: { id: maintainerId } },
-      { signal }
-    );
-    return data;
-  };
-  const addMaintainerUser = async ({
-    maintainerId,
-    ...body
-  }) => {
-    const { data } = await client.post("/manage/maintainers/{id}/users", {
-      path: { id: maintainerId },
-      body
-    });
-    return data;
-  };
-  const removeMaintainerUser = async ({
-    maintainerId,
-    adminId
-  }) => {
-    await client.delete("/manage/maintainers/{id}/users/{adminId}", {
-      path: { id: maintainerId, adminId }
-    });
-  };
-  const getMaintainerInvitations = async (maintainerId, signal) => {
-    const { data } = await client.get(
-      "/manage/maintainers/{id}/invitations",
-      { path: { id: maintainerId } },
-      { signal }
-    );
-    return data;
-  };
-  const getMaintainerInvitation = async ({ maintainerId, invitationId }, signal) => {
-    const { data } = await client.get(
-      "/manage/maintainers/{id}/invitations/{invitationId}",
-      { path: { id: maintainerId, invitationId } },
-      { signal }
-    );
-    return data;
-  };
-  const createMaintainerInvitation = async ({
-    maintainerId,
-    ...body
-  }) => {
-    const { data } = await client.post("/manage/maintainers/{id}/invitations", {
-      path: { id: maintainerId },
-      body
-    });
-    return data;
-  };
-  const deleteMaintainerInvitation = async ({
-    maintainerId,
-    invitationId
-  }) => {
-    await client.delete("/manage/maintainers/{id}/invitations/{invitationId}", {
-      path: { id: maintainerId, invitationId }
-    });
-  };
-  const createMaintainerOrganization = async ({
-    maintainerId,
-    ...body
-  }) => {
-    const { data } = await client.post("/manage/maintainers/{id}/organizations", {
-      path: { id: maintainerId },
-      body
-    });
-    return data;
-  };
-  const getMaintainerMetadata = async (maintainerId, signal) => {
-    const { data } = await client.get(
-      "/manage/maintainers/{id}/metadata",
-      { path: { id: maintainerId } },
-      { signal }
-    );
-    return data;
-  };
-  const setMaintainerMetadata = async ({
-    maintainerId,
-    ...body
-  }) => {
-    const { data } = await client.post("/manage/maintainers/{id}/metadata", {
-      path: { id: maintainerId },
-      body
-    });
-    return data;
-  };
-  const deleteMaintainerMetadata = async ({
-    maintainerId,
-    metadataId
-  }) => {
-    await client.delete("/manage/maintainers/{id}/metadata/{metadataId}", {
-      path: { id: maintainerId, metadataId }
-    });
-  };
-  return {
-    getMaintainers,
-    getMaintainer,
-    createMaintainer,
-    updateMaintainer,
-    deleteMaintainer,
-    getMaintainerUsers,
-    addMaintainerUser,
-    removeMaintainerUser,
-    getMaintainerInvitations,
-    getMaintainerInvitation,
-    createMaintainerInvitation,
-    deleteMaintainerInvitation,
-    createMaintainerOrganization,
-    getMaintainerMetadata,
-    setMaintainerMetadata,
-    deleteMaintainerMetadata
-  };
-};
-
-// src/clients/management/organizations/organizations.ts
-var createOrganizations = (client) => {
-  const getOrganizations = async (signal) => {
-    const { data } = await client.get("/manage/organizations", {}, { signal });
-    return data;
-  };
-  const getOrganization = async (organizationId, signal) => {
-    const { data } = await client.get(
-      "/manage/organizations/{id}",
-      { path: { id: organizationId } },
-      { signal }
-    );
-    return data;
-  };
-  const updateOrganization = async ({
-    organizationId,
-    ...body
-  }) => {
-    const { data } = await client.patch("/manage/organizations/{id}", {
-      path: { id: organizationId },
-      body
-    });
-    return data;
-  };
-  const deleteOrganization = async (organizationId) => {
-    await client.delete("/manage/organizations/{id}", { path: { id: organizationId } });
-  };
-  const forceMfa = async (organizationId) => {
-    const { data } = await client.patch("/manage/organizations/{id}/force-mfa", {
-      path: { id: organizationId }
-    });
-    return data;
-  };
-  const joinOrganization = async (organizationId) => {
-    await client.post("/manage/organizations/{id}/join-organization", {
-      path: { id: organizationId }
-    });
-  };
-  const getOrganizationUsers = async (organizationId, signal) => {
-    const { data } = await client.get(
-      "/manage/organizations/{id}/users",
-      { path: { id: organizationId } },
-      { signal }
-    );
-    return data;
-  };
-  const addOrganizationUser = async ({
-    organizationId,
-    ...body
-  }) => {
-    const { data } = await client.post("/manage/organizations/{id}/users", {
-      path: { id: organizationId },
-      body
-    });
-    return data;
-  };
-  const removeOrganizationUser = async ({
-    organizationId,
-    userId
-  }) => {
-    await client.delete("/manage/organizations/{id}/users/{userId}", {
-      path: { id: organizationId, userId }
-    });
-  };
-  const getOrganizationProjectsUsers = async (organizationId, signal) => {
-    const { data } = await client.get(
-      "/manage/organizations/{id}/projects-users",
-      { path: { id: organizationId } },
-      { signal }
-    );
-    return data;
-  };
-  const getOrganizationInvitations = async (organizationId, signal) => {
-    const { data } = await client.get(
-      "/manage/organizations/{id}/invitations",
-      { path: { id: organizationId } },
-      { signal }
-    );
-    return data;
-  };
-  const getOrganizationInvitation = async ({ organizationId, invitationId }, signal) => {
-    const { data } = await client.get(
-      "/manage/organizations/{id}/invitations/{invitationId}",
-      { path: { id: organizationId, invitationId } },
-      { signal }
-    );
-    return data;
-  };
-  const createOrganizationInvitation = async ({
-    organizationId,
-    ...body
-  }) => {
-    const { data } = await client.post("/manage/organizations/{id}/invitations", {
-      path: { id: organizationId },
-      body
-    });
-    return data;
-  };
-  const deleteOrganizationInvitation = async ({
-    organizationId,
-    invitationId
-  }) => {
-    await client.delete("/manage/organizations/{id}/invitations/{invitationId}", {
-      path: { id: organizationId, invitationId }
-    });
-  };
-  const getOrganizationProjects = async (organizationId, signal) => {
-    const { data } = await client.get(
-      "/manage/organizations/{id}/projects",
-      { path: { id: organizationId } },
-      { signal }
-    );
-    return data;
-  };
-  const createOrganizationProject = async ({
-    organizationId,
-    ...body
-  }) => {
-    const { data } = await client.post("/manage/organizations/{id}/projects", {
-      path: { id: organizationId },
-      body
-    });
-    return data;
-  };
-  const getOrganizationMetadata = async (organizationId, signal) => {
-    const { data } = await client.get(
-      "/manage/organizations/{id}/metadata",
-      { path: { id: organizationId } },
-      { signal }
-    );
-    return data;
-  };
-  const setOrganizationMetadata = async ({
-    organizationId,
-    ...body
-  }) => {
-    const { data } = await client.post("/manage/organizations/{id}/metadata", {
-      path: { id: organizationId },
-      body
-    });
-    return data;
-  };
-  const deleteOrganizationMetadata = async ({
-    organizationId,
-    metadataId
-  }) => {
-    await client.delete("/manage/organizations/{id}/metadata/{metadataId}", {
-      path: { id: organizationId, metadataId }
-    });
-  };
-  return {
-    getOrganizations,
-    getOrganization,
-    updateOrganization,
-    deleteOrganization,
-    forceMfa,
-    joinOrganization,
-    getOrganizationUsers,
-    addOrganizationUser,
-    removeOrganizationUser,
-    getOrganizationProjectsUsers,
-    getOrganizationInvitations,
-    getOrganizationInvitation,
-    createOrganizationInvitation,
-    deleteOrganizationInvitation,
-    getOrganizationProjects,
-    createOrganizationProject,
-    getOrganizationMetadata,
-    setOrganizationMetadata,
-    deleteOrganizationMetadata
-  };
-};
-
-// src/clients/management/projects/projects.ts
-var createProjects = (client) => {
-  const getProject = async (projectId, signal) => {
-    const { data } = await client.get(
-      "/projects/{projectId}",
-      { path: { projectId } },
-      { signal }
-    );
-    return data;
-  };
-  const addProjectFeature = async ({
-    projectId,
-    feature
-  }) => {
-    const { data } = await client.post("/projects/{projectId}/features", { path: { projectId }, body: { feature } });
-    return data;
-  };
-  const removeProjectFeature = async (path) => {
-    const { data } = await client.delete(
-      "/projects/{projectId}/features/{feature}",
-      { path }
-    );
-    return data;
-  };
-  const changeProjectUserRole = async ({
-    projectId,
-    userId,
-    role
-  }) => {
-    const { data } = await client.patch("/projects/{projectId}/users/{userId}", {
-      path: { projectId, userId },
-      body: { role }
-    });
-    return data;
-  };
-  const getProjectUsers = async (projectId, signal) => {
-    const { data } = await client.get(
-      "/projects/{projectId}/users",
-      { path: { projectId } },
-      { signal }
-    );
-    return data;
-  };
-  const getProjectMetadata = async (projectId, signal) => {
-    const { data } = await client.get(
-      "/projects/{projectId}/metadata",
-      { path: { projectId } },
-      { signal }
-    );
-    return data;
-  };
-  const setProjectMetadata = async ({
-    projectId,
-    provider,
-    metadata
-  }) => {
-    const { data } = await client.post("/projects/{projectId}/metadata", {
-      path: { projectId },
-      body: { provider, metadata }
-    });
-    return data;
-  };
-  const getProjectReviewers = async (projectId, signal) => {
-    const { data } = await client.get(
-      "/projects/{projectId}/reviewers",
-      { path: { projectId } },
-      { signal }
-    );
-    return data;
-  };
-  const setProjectReviewers = async ({
-    projectId,
-    adminIds
-  }) => {
-    const { data } = await client.put("/projects/{projectId}/reviewers", {
-      path: { projectId },
-      body: { adminIds }
-    });
-    return data;
-  };
-  return {
-    getProject,
-    addProjectFeature,
-    removeProjectFeature,
-    changeProjectUserRole,
-    getProjectUsers,
-    getProjectMetadata,
-    setProjectMetadata,
-    getProjectReviewers,
-    setProjectReviewers
-  };
-};
-
-// src/clients/management/users/users.ts
-var createUsers = (client) => {
-  const addUserAdminFeature = async ({ feature, userIdOrMail }, signal) => {
-    const { data } = await client.post(
-      "/users/{userIdOrMail}/features",
-      { path: { userIdOrMail: encodeURIComponent(userIdOrMail) }, body: { feature } },
-      { signal }
-    );
-    return data;
-  };
-  const removeUserAdminFeature = async ({ userIdOrMail, feature }, signal) => {
-    const { data } = await client.delete(
-      "/users/{userIdOrMail}/features/{feature}",
-      { path: { userIdOrMail: encodeURIComponent(userIdOrMail), feature } },
-      { signal }
-    );
-    return data;
-  };
-  return {
-    addUserAdminFeature,
-    removeUserAdminFeature
-  };
-};
-
-// src/clients/management/managementClient.ts
-var createManagementClient = ({
-  baseUrl,
-  callbacks,
-  token
-}) => {
-  const callbackMiddleware = createCallbackMiddleware(callbacks);
-  const authMiddleware = createAuthMiddleware({
-    baseUrl,
-    accessToken: token
-  });
-  const middlewares = [
-    callbackMiddleware,
-    authMiddleware
-    // 👈  beware order of middlewares always matter
-  ];
-  const client = createGenericFetchClient({
-    baseUrl: `${baseUrl}/manage`,
-    middlewares
-  });
-  const openApiClient = createOpenapiFetchClient({
-    baseUrl,
-    middlewares
-  });
-  const verifyToken = async (signal) => {
-    const { data } = await openApiClient.get("/manage/tokens/verify", {}, { signal });
-    return data;
-  };
-  return {
-    currentUser: createCurrentUser(openApiClient),
-    features: createFeatures(client),
-    maintainers: createMaintainers(openApiClient),
-    organizations: createOrganizations(openApiClient),
-    projects: createProjects(client),
-    users: createUsers(client),
-    verifyToken
-  };
-};
-
-// src/clients/metastore/repository/repository.ts
-var createRepository = (client) => {
-  const getMetaObjects = async (input, signal) => {
-    const { data } = await client.get(
-      "/api/v1/repository/{objectType}",
-      {
-        path: input
-      },
-      { signal }
-    );
-    return data;
-  };
-  const getMetaObjectRevisions = async (input, signal) => {
-    const { data } = await client.get(
-      "/api/v1/repository/{objectType}/revisions",
-      {
-        path: input
-      },
-      { signal }
-    );
-    return data;
-  };
-  const getMetaObject = async (input, signal) => {
-    const { data } = await client.get(
-      "/api/v1/repository/{objectType}/{UUID}",
-      {
-        path: input
-      },
-      {
-        signal
-      }
-    );
-    return data;
-  };
-  const createMetaObject = async ({
-    objectType,
-    data,
-    ...body
-  }) => {
-    const { data: createdMetaObject } = await client.post("/api/v1/repository/{objectType}", {
-      path: { objectType },
-      body: {
-        data,
-        ...body
-      }
-    });
-    return createdMetaObject;
-  };
-  const deleteMetaObject = async (input) => {
-    const { data } = await client.delete("/api/v1/repository/{objectType}/{UUID}", {
-      path: input
-    });
-    return data;
-  };
-  const updateMetaObject = async ({
-    objectType,
-    UUID,
-    data,
-    ...body
-  }) => {
-    const { data: updatedMetaObject } = await client.patch(
-      "/api/v1/repository/{objectType}/{UUID}",
-      {
-        path: {
-          objectType,
-          UUID
-        },
-        body: {
-          data,
-          ...body
-        }
-      }
-    );
-    return updatedMetaObject;
-  };
-  const replaceMetaObject = async ({
-    objectType,
-    UUID,
-    data,
-    ...body
-  }) => {
-    const { data: replacedMetaObject } = await client.put(
-      "/api/v1/repository/{objectType}/{UUID}",
-      {
-        path: {
-          objectType,
-          UUID
-        },
-        body: {
-          data,
-          ...body
-        }
-      }
-    );
-    return replacedMetaObject;
-  };
-  const getMetaObjectRevision = async (input, signal) => {
-    const { data } = await client.get(
-      "/api/v1/repository/{objectType}/{UUID}/revisions/{revision}",
-      {
-        path: input
-      },
-      { signal }
-    );
-    return data;
-  };
-  const deleteMetaObjectRevision = async (input) => {
-    const { data } = await client.delete(
-      "/api/v1/repository/{objectType}/{UUID}/revisions/{revision}",
-      {
-        path: input
-      }
-    );
-    return data;
-  };
-  return {
-    // lists
-    getMetaObjects,
-    getMetaObjectRevisions,
-    // objects
-    getMetaObject,
-    createMetaObject,
-    deleteMetaObject,
-    updateMetaObject,
-    replaceMetaObject,
-    // revisons
-    getMetaObjectRevision,
-    deleteMetaObjectRevision
-  };
-};
-
-// src/clients/metastore/schema/schema.ts
-var createSchema = (client) => {
-  const getSchema = async (input, signal) => {
-    const { data } = await client.get(
-      "/api/v1/schema/{objectType}",
-      {
-        path: input
-      },
-      { signal }
-    );
-    return data;
-  };
-  const getVersionedSchema = async (input, signal) => {
-    const { data } = await client.get(
-      "/api/v1/schema/{objectType}/{version}",
-      {
-        path: input
-      },
-      { signal }
-    );
-    return data;
-  };
-  return {
-    getSchema,
-    getVersionedSchema
-  };
-};
-
-// src/clients/metastore/metastoreClient.ts
-var createMetastoreClient = ({ baseUrl, middlewares }) => {
-  const client = createOpenapiFetchClient({
-    baseUrl,
-    middlewares
-  });
-  const healthCheck = async (signal) => {
-    const { data } = await client.get("/health-check", {}, { signal });
-    return data;
-  };
-  return {
-    healthCheck,
-    repository: createRepository(client),
-    schema: createSchema(client)
-  };
-};
-
-// src/clients/oauth/oauthClient.ts
-var createOauthClient = ({ baseUrl, middlewares }) => {
-  const client = createGenericFetchClient({ baseUrl, middlewares });
-  const getCredentials = async (query, signal) => {
-    const { data } = await client.get(
-      "/credentials",
-      { query },
-      { signal }
-    );
-    return data;
-  };
-  const getCredential = async (componentId, id, signal) => {
-    const { data } = await client.get(
-      "/credentials/{componentId}/{id}",
-      { path: { componentId, id } },
-      { signal }
-    );
-    return data;
-  };
-  const _createCredentials = async (componentId, body, signal) => {
-    const { data } = await client.post(
-      "/credentials/{componentId}",
-      { path: { componentId }, body },
-      { signal }
-    );
-    return data;
-  };
-  const _createLegacyCredentials = async (componentId, { data: credentialsData, ...rest }, signal) => {
-    const { data } = await client.post(
-      "/credentials/{componentId}",
-      {
-        path: { componentId },
-        body: {
-          ...rest,
-          "#data": JSON.stringify(credentialsData)
-        }
-      },
-      { signal }
-    );
-    return data;
-  };
-  const createCredential = async (componentId, body, signal) => {
-    try {
-      return await _createCredentials(componentId, body, signal);
-    } catch (error) {
-      if (isApiError(error) && error.response.status === HttpStatus.UNPROCESSABLE_ENTITY) {
-        return _createLegacyCredentials(componentId, body, signal);
-      }
-      throw error;
-    }
-  };
-  const deleteCredential = async (componentId, id, signal) => {
-    await client.delete(
-      "/credentials/{componentId}/{id}",
-      { path: { componentId, id } },
-      { signal }
-    );
-  };
-  return {
-    getCredentials,
-    getCredential,
-    createCredential,
-    deleteCredential
-  };
-};
-
-// src/clients/queryService/queryServiceClient.ts
-var createQueryServiceClient = ({ baseUrl, middlewares }) => {
-  const client = createOpenapiFetchClient({
-    baseUrl,
-    middlewares
-  });
-  const createQueryJob = async (branchId, workspaceId, body) => {
-    const { data } = await client.post(
-      "/api/v1/branches/{branchId}/workspaces/{workspaceId}/queries",
-      { path: { branchId, workspaceId }, body }
-    );
-    return data;
-  };
-  const cancelQueryJob = async (queryJobId) => {
-    const { data } = await client.post("/api/v1/queries/{queryJobId}/cancel", {
-      path: { queryJobId },
-      body: { reason: "Cancelled by user" }
-    });
-    return data;
-  };
-  const getQueryJob = async (queryJobId) => {
-    const { data } = await client.get("/api/v1/queries/{queryJobId}", { path: { queryJobId } });
-    return data;
-  };
-  const getQueryResults = async (queryJobId, statementId, query) => {
-    const { data } = await client.get("/api/v1/queries/{queryJobId}/{statementId}/results", {
-      path: { queryJobId, statementId },
-      query
-    });
-    return data;
-  };
-  const getQueryHistory = async (branchId, workspaceId, query) => {
-    const { data } = await client.get(
-      "/api/v1/branches/{branchId}/workspaces/{workspaceId}/queries",
-      {
-        path: { branchId, workspaceId },
-        query
-      }
-    );
-    return data;
-  };
-  const exportResults = async (queryJobId, statementId, query, signal) => {
-    const { data, response } = await client.get(
-      "/api/v1/queries/{queryJobId}/{statementId}/export",
-      {
-        path: { queryJobId, statementId },
-        query
-      },
-      { signal }
-    );
-    const mimeType = response.headers.get(HttpHeader.CONTENT_TYPE) ?? "text/csv";
-    const contentDisposition = parseContentDispositionHeader(
-      response.headers.get(HttpHeader.CONTENT_DISPOSITION)
-    );
-    return {
-      mimeType,
-      content: data,
-      fileName: contentDisposition?.filename ?? "export.csv"
-    };
-  };
-  return {
-    createQueryJob,
-    cancelQueryJob,
-    getQueryJob,
-    getQueryResults,
-    getQueryHistory,
-    exportResults
-  };
-};
-
-// src/clients/queue/queueClient.ts
-var createQueueClient = ({ baseUrl, middlewares }) => {
-  const client = createOpenapiFetchClient({
-    baseUrl,
-    middlewares
-  });
-  const getJob = async (jobId, signal) => {
-    const { data } = await client.get(
-      "/jobs/{jobId}",
-      {
-        path: { jobId }
-      },
-      { signal }
-    );
-    return data;
-  };
-  const searchJobs = async (query, signal) => {
-    const { data } = await client.get(
-      "/search/jobs",
-      {
-        query
-      },
-      { signal }
-    );
-    return data;
-  };
-  return { getJob, searchJobs };
-};
-
-// src/clients/status/statusClient.ts
-var createStatusClient = ({ baseUrl, middlewares }) => {
-  const client = createGenericFetchClient({
-    baseUrl,
-    middlewares
-  });
-  const getSummary = async (signal) => {
-    const { data } = await client.get("/summary.json", {}, { signal });
-    return data;
-  };
-  return {
-    getSummary
-  };
-};
-
-// 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 email2 = entry.slice(colon + 1);
-    if (prefix !== "user" && prefix !== "group") continue;
-    if (email2.length === 0) continue;
-    result.push({ type: prefix, email: email2 });
-  }
-  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/assert.ts
-function assert(value, message2) {
-  if (value == null) {
-    throw new Error(message2);
-  }
-}
-
-// src/utils/concurrent.ts
-var concurrent = async ({
-  items,
-  process: process2,
-  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) => process2(item, index, items.length)));
-  const n = items.length;
-  const results = new Array(n);
-  const processWithMiddlewares = middlewares.reduceRight(
-    (next, middleware) => middleware(next),
-    process2
-  );
-  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/createAbortError.ts
-var createAbortError = (reason) => new DOMException(reason, "AbortError");
-
-// src/utils/delay.ts
-var delay = (timeout, signal) => new Promise((resolve, reject) => {
-  if (signal?.aborted) return reject(createAbortError(signal.reason));
-  const timeoutId = setTimeout(resolve, timeout);
-  signal?.addEventListener(
-    "abort",
-    () => {
-      clearTimeout(timeoutId);
-      reject(createAbortError(signal.reason));
-    },
-    { once: true }
-  );
-});
-
-// src/utils/poll.ts
-var message = {
-  PollPredicateError: "Poll predicate failed",
-  PollTimeoutError: "Poll timeout exceeded",
-  PollPollTimeoutError: "Poll data failed condition"
-};
-var PollException = class extends Error {
-  result;
-  constructor(type, result) {
-    super(type, { cause: message[type] });
-    this.result = result;
-  }
-};
-var poll = async ({
-  pollFn,
-  interval,
-  isDone,
-  isFailed,
-  abortSignal,
-  maxAttempts = Infinity
-}) => {
-  if (abortSignal?.aborted) throw createAbortError(abortSignal.reason);
-  if (interval < 1) throw new Error("Invalid poll interval");
-  if (maxAttempts < 1) throw new Error("Invalid poll maxAttempts");
-  let callCount = 0;
-  while (true) {
-    callCount++;
-    const data = await pollFn(abortSignal);
-    const result = { data, callCount };
-    try {
-      if (isDone(data)) return result;
-      if (isFailed?.(data) ?? false) throw new PollException("PollPollTimeoutError", result);
-    } catch (error) {
-      if (error instanceof PollException) throw error;
-      throw new PollException("PollPredicateError", result);
-    }
-    if (callCount >= maxAttempts) throw new PollException("PollTimeoutError", result);
-    await delay(interval, abortSignal);
-  }
-};
-
-// src/utils/keboolaUID.ts
-var KEBOOLA_OBJECT_ID_DELIMITER = "--";
-var keboolaUID = {
-  serialize: (input) => {
-    if (input.uid === "")
-      throw new Error("Invalid Keboola Object ID: uid of an object cannot be empty");
-    return ["KID", input.projectId, input.type, input.uid].join(KEBOOLA_OBJECT_ID_DELIMITER);
-  },
-  deserialize: (input) => {
-    const [identifier, projectId, type, uid] = input.split(KEBOOLA_OBJECT_ID_DELIMITER);
-    if (identifier !== "KID" || !projectId || !type || !uid)
-      throw new Error("Invalid Keboola Object ID");
-    return {
-      projectId: Number(projectId),
-      type,
-      uid
-    };
-  }
-};
-
-// src/utils/generateUUID.ts
-var generateUUID = () => crypto.randomUUID();
-
-// 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;
-  };
-};
-
-// src/clients/syncActions/constants.ts
-var SyncAction = {
-  DATA_APP_GIT_REPOSITORY: "git-repository",
-  GIT_REPOSITORY: "gitRepository",
-  ENROLL_MFA: "enrollMFA"
-};
-var Component = {
-  DATA_APP: "keboola.data-apps"
-};
-var Author = z5.object({
-  name: z5.string(),
-  email: z5.email()
-});
-var RepositoryBranch = z5.object({
-  sha: z5.string(),
-  date: z5.string(),
-  comment: z5.string(),
-  branch: z5.string(),
-  author: Author
-});
-var Repository = z5.object({
-  repository: z5.object({
-    url: z5.string()
-  }),
-  branches: z5.array(RepositoryBranch)
-});
-
-// src/clients/syncActions/gitRepository/utils.ts
-var GitRepoConfigDataBuilder = class {
-  repositoryUrl;
-  config = {};
-  constructor(repositoryUrl) {
-    this.repositoryUrl = repositoryUrl;
-  }
-  withCredentials(username, password) {
-    this.config.username = username;
-    delete this.config["#sshKey"];
-    this.config["#password"] = password;
-    return this;
-  }
-  withSshKey(username, sshKey) {
-    this.config.username = username;
-    delete this.config["#password"];
-    this.config["#sshKey"] = sshKey;
-    return this;
-  }
-  build() {
-    return {
-      parameters: {
-        git: {
-          repo: this.repositoryUrl,
-          ...this.config
-        }
-      }
-    };
-  }
-  buildForDataApp() {
-    return {
-      parameters: {
-        dataApp: {
-          git: {
-            repository: this.repositoryUrl,
-            ...this.config
-          }
-        }
-      }
-    };
-  }
-};
-var createGitRepoConfigDataBuilder = (repositoryUrl) => new GitRepoConfigDataBuilder(repositoryUrl);
-
-// src/clients/syncActions/gitRepository/gitRepository.ts
-var createGitRepository = (sendSyncAction) => {
-  const getDataAppPublicGitRepository = async ({ repositoryUrl, ...other }, signal) => {
-    const data = await sendSyncAction(
-      {
-        ...other,
-        action: SyncAction.DATA_APP_GIT_REPOSITORY,
-        componentId: Component.DATA_APP,
-        configData: createGitRepoConfigDataBuilder(repositoryUrl).buildForDataApp()
-      },
-      signal
-    );
-    return Repository.parse(data);
-  };
-  const getDataAppPasswordPrivateGitRepository = async ({ repositoryUrl, username, password, ...other }, signal) => {
-    const data = await sendSyncAction(
-      {
-        ...other,
-        action: SyncAction.DATA_APP_GIT_REPOSITORY,
-        componentId: Component.DATA_APP,
-        configData: createGitRepoConfigDataBuilder(repositoryUrl).withCredentials(username, password).buildForDataApp()
-      },
-      signal
-    );
-    return Repository.parse(data);
-  };
-  const getDataAppSSHKeyPrivateGitRepository = async ({ repositoryUrl, username, sshKey, ...other }, signal) => {
-    const data = await sendSyncAction(
-      {
-        ...other,
-        action: SyncAction.DATA_APP_GIT_REPOSITORY,
-        componentId: Component.DATA_APP,
-        configData: createGitRepoConfigDataBuilder(repositoryUrl).withSshKey(username, sshKey).buildForDataApp()
-      },
-      signal
-    );
-    return Repository.parse(data);
-  };
-  const getPublicGitRepository = async ({ repositoryUrl, componentId, ...other }, signal) => {
-    const data = await sendSyncAction(
-      {
-        ...other,
-        action: SyncAction.GIT_REPOSITORY,
-        componentId,
-        configData: createGitRepoConfigDataBuilder(repositoryUrl).build()
-      },
-      signal
-    );
-    return Repository.parse(data);
-  };
-  const getPrivateGitRepository = async ({ repositoryUrl, username, password, componentId, ...other }, signal) => {
-    const data = await sendSyncAction(
-      {
-        ...other,
-        action: SyncAction.GIT_REPOSITORY,
-        componentId,
-        configData: createGitRepoConfigDataBuilder(repositoryUrl).withCredentials(username, password).build()
-      },
-      signal
-    );
-    return Repository.parse(data);
-  };
-  return {
-    getDataAppPublicGitRepository,
-    getDataAppPasswordPrivateGitRepository,
-    getDataAppSSHKeyPrivateGitRepository,
-    getPublicGitRepository,
-    getPrivateGitRepository
-  };
-};
-
-// src/clients/syncActions/syncActionsClient.ts
-var createSendSyncAction = (client) => {
-  return async (body, signal) => {
-    const { data } = await client.post(
-      "/actions",
-      {
-        body
-      },
-      { signal }
-    );
-    return data;
-  };
-};
-var createSyncActionsClient = ({ baseUrl, middlewares }) => {
-  const client = createOpenapiFetchClient({
-    baseUrl,
-    middlewares
-  });
-  const sendSyncAction = createSendSyncAction(client);
-  const enrollMFA = ({ email: email2, ...rest }, signal) => {
-    return sendSyncAction(
-      {
-        ...rest,
-        action: SyncAction.ENROLL_MFA,
-        configData: {
-          parameters: {
-            user: {
-              email: email2
-            }
-          }
-        }
-      },
-      signal
-    );
-  };
-  return {
-    enrollMFA,
-    gitRepository: createGitRepository(sendSyncAction)
-  };
-};
-
-// src/clients/telemetry/provisioning/provisioning.ts
-var createProvisioning = (client) => {
-  const createCredentials = async (body, signal) => {
-    const { data } = await client.post(
-      "/provisioning/workspace",
-      { body },
-      { signal }
-    );
-    return data;
-  };
-  return {
-    createCredentials
-  };
-};
-
-// src/clients/telemetry/telemetryClient.ts
-var createTelemetryClient = ({ baseUrl, middlewares }) => {
-  const client = createGenericFetchClient({
-    baseUrl,
-    middlewares
-  });
-  return {
-    provisioning: createProvisioning(client)
-  };
-};
-
-// src/clients/vault/vaultClient.ts
-var createVaultClient = ({ baseUrl, middlewares }) => {
-  const client = createOpenapiFetchClient({
-    baseUrl,
-    middlewares
-  });
-  const getVariables = async (query, signal) => {
-    const { data } = await client.get(
-      "/variables",
-      { query },
-      {
-        signal
-      }
-    );
-    return data;
-  };
-  const deleteVariable = async (hash, signal) => {
-    await client.delete(
-      "/variables/{hash}",
-      {
-        path: { hash }
-      },
-      { signal }
-    );
-  };
-  const createVariable = async (body, signal) => {
-    if (body.flags.includes("encrypted") && !body.value.startsWith(ENCRYPTED_VALUE_PREFIX)) {
-      throw new UserError("Encryption of a value failed. Please contact our support.");
-    }
-    const { data } = await client.post("/variables", { body }, { signal });
-    return data;
-  };
-  const getVariablesByBranchId = async (branchId, signal) => {
-    const { data } = await client.get(
-      "/variables/scoped/branch/{branchId}",
-      {
-        path: { branchId }
-      },
-      { signal }
-    );
-    return data;
-  };
-  const getProjectWideVariables = (signal) => getVariablesByBranchId("null", signal);
-  return {
-    createVariable,
-    deleteVariable,
-    getProjectWideVariables,
-    getVariables,
-    getVariablesByBranchId
-  };
-};
-
-// src/domain/project.ts
-var createProject = ({ sapiToken }) => {
-  const { owner, admin } = sapiToken;
-  const projectFeatureSet = new Set(owner.features);
-  const adminFeatureSet = new Set(admin.features);
-  const hasFeature = (...feature) => {
-    if (feature.length === 0) return false;
-    return feature.every((x) => projectFeatureSet.has(x));
-  };
-  const hasAdminFeature = (...feature) => {
-    if (feature.length === 0) return false;
-    return feature.every((x) => adminFeatureSet.has(x));
-  };
-  const hasBackend = (backend) => {
-    if (backend === "bigquery") return owner.hasBigquery;
-    if (backend === "snowflake") return owner.hasSnowflake;
-    return false;
-  };
-  return {
-    hasFeature,
-    hasAdminFeature,
-    hasBackend,
-    sapiToken
-  };
-};
-
-// src/domain/stack.ts
-var SERVICE_URL_OVERRIDES = {
-  // The service URL for the Kai Assistant is incomplete; we need to add the `/api` suffix to get the full URL for the API.
-  // I assume the service is versioned.
-  "kai-assistant": (url) => `${url}/api`
-};
-var createStack = ({ stackInfo, clientServiceUrls }) => {
-  const { services, components, features, ...infoRest } = stackInfo;
-  const serviceMap = new Map(
-    services.map((service) => {
-      const devOverride = clientServiceUrls?.[service.id]?.(service.url);
-      const prodOverride = SERVICE_URL_OVERRIDES[service.id]?.(service.url);
-      const url = devOverride ?? prodOverride ?? service.url;
-      return [service.id, url];
-    })
-  );
-  const componentMap = new Map(components.map((component) => [component.id, component]));
-  const featureSet = new Set(features);
-  const hasFeature = (...feature) => {
-    if (feature.length === 0) return false;
-    return feature.every((x) => featureSet.has(x));
-  };
-  const hasComponent = (...componentId) => {
-    if (componentId.length === 0) return false;
-    return componentId.every((x) => componentMap.has(x));
+  const hasComponent = (...componentId) => {
+    if (componentId.length === 0) return false;
+    return componentId.every((x) => componentMap.has(x));
   };
   const getComponent = (componentId) => componentMap.get(componentId) ?? null;
   const hasService = (serviceId) => serviceMap.has(serviceId);
@@ -3551,208 +302,6 @@ var createStack = ({ stackInfo, clientServiceUrls }) => {
   };
 };
 
-// src/sdks/storage/storageSdk.ts
-var DEFAULT_POLL_INTERVAL = 2e3;
-var JOB_TERMINAL_STATUSES = /* @__PURE__ */ new Set(["success", "warning", "error", "terminated", "cancelled"]);
-var createStorageSdk = ({ storageClient }) => {
-  const waitForJob = async (job, options) => {
-    const { data } = await poll({
-      pollFn: (abortSignal) => storageClient.jobs.getJob(job.id, abortSignal),
-      isDone: (j) => JOB_TERMINAL_STATUSES.has(j.status),
-      interval: options?.interval ?? DEFAULT_POLL_INTERVAL,
-      maxAttempts: options?.maxAttempts,
-      abortSignal: options?.abortSignal
-    });
-    return data;
-  };
-  const createTable = async (bucketId, body, options) => {
-    const job = await storageClient.tables.createTableAsync(bucketId, body, options?.abortSignal);
-    return waitForJob(job, options);
-  };
-  const importFromFile = async (tableId, body, options) => {
-    const job = await storageClient.tables.importAsync(tableId, body, options?.abortSignal);
-    return waitForJob(job, options);
-  };
-  const exportToFile = async (tableId, body, options) => {
-    const job = await storageClient.tables.exportAsync(tableId, body, options?.abortSignal);
-    return waitForJob(job, options);
-  };
-  const getBucketListing = async (bucketId, signal) => storageClient.buckets.getListing(bucketId, signal);
-  const listBucketListings = async (signal) => storageClient.buckets.listListings(signal);
-  const createBucketListing = async (bucketId, input, options) => {
-    const job = await storageClient.buckets.createListing(bucketId, input, options?.abortSignal);
-    return waitForJob(job, options);
-  };
-  const updateBucketListing = async (bucketId, input, options) => {
-    const job = await storageClient.buckets.updateListing(bucketId, input, options?.abortSignal);
-    return waitForJob(job, options);
-  };
-  const deleteBucketListing = async (bucketId, options) => {
-    const job = await storageClient.buckets.deleteListing(bucketId, options?.abortSignal);
-    return waitForJob(job, options);
-  };
-  return {
-    createTable,
-    importFromFile,
-    exportToFile,
-    getBucketListing,
-    listBucketListings,
-    createBucketListing,
-    updateBucketListing,
-    deleteBucketListing
-  };
-};
-
-// src/sdks/tag/tagSdk.ts
-var ObjectType = {
-  TAG: "tag",
-  TAG_BINDING: "tag-binding"
-};
-var createTagSdk = ({ metastoreClient }) => {
-  const _getTagMetaObjects = async (type, signal) => {
-    const response = await metastoreClient.repository.getMetaObjects(
-      {
-        objectType: type
-      },
-      signal
-    );
-    return response.data.map(({ attributes }) => attributes);
-  };
-  const _getAllTagBindingMapByTagId = async (signal) => {
-    const tagBindings = await _getTagMetaObjects(ObjectType.TAG_BINDING, signal);
-    return Object.groupBy(tagBindings, (binding) => binding.data.tagUUID);
-  };
-  const _getTagBindingMapByTagId = async (tagUUIDs, objectId, signal) => {
-    const tagBindingMapByTagId = await _getAllTagBindingMapByTagId(signal);
-    const objectUID = keboolaUID.serialize(objectId);
-    return tagUUIDs.reduce((acc, tagUUID) => {
-      if (acc[tagUUID]) return acc;
-      const tagBindings = tagBindingMapByTagId[tagUUID] ?? [];
-      acc[tagUUID] = tagBindings.find((binding) => binding.data.objectUID === objectUID) ?? null;
-      return acc;
-    }, {});
-  };
-  const _deleteTagBindings = async (tagBindings) => {
-    await concurrent({
-      items: tagBindings,
-      process: async (binding) => metastoreClient.repository.deleteMetaObject({
-        objectType: ObjectType.TAG_BINDING,
-        UUID: binding.uuid
-      }),
-      concurrency: 5
-    });
-  };
-  const getTags = async (signal) => {
-    const [tags, tagBindingMapByTagId] = await Promise.all([
-      _getTagMetaObjects(ObjectType.TAG, signal),
-      _getAllTagBindingMapByTagId(signal)
-    ]);
-    return tags.map((tag) => ({
-      tag,
-      bindings: tagBindingMapByTagId[tag.uuid] ?? []
-    }));
-  };
-  const getTagsByObjectId = async (objectId, signal) => {
-    const tags = await getTags(signal);
-    const keboolaObjectUID = keboolaUID.serialize(objectId);
-    const mapByTagId = tags.reduce((acc, { tag, bindings }) => {
-      acc[tag.uuid] = new Set(bindings.map((binding) => binding.data.objectUID));
-      return acc;
-    }, {});
-    return tags.filter(({ tag }) => mapByTagId[tag.uuid]?.has(keboolaObjectUID));
-  };
-  const createTag = async (data, meta = {}) => {
-    const {
-      data: { attributes: tag }
-    } = await metastoreClient.repository.createMetaObject({
-      objectType: ObjectType.TAG,
-      data,
-      name: generateUUID(),
-      ...meta
-    });
-    return tag;
-  };
-  const updateTag = async (tagUUID, data, meta = {}) => {
-    const {
-      data: { attributes: tag }
-    } = await metastoreClient.repository.updateMetaObject({
-      objectType: ObjectType.TAG,
-      UUID: tagUUID,
-      data,
-      ...meta
-    });
-    return tag;
-  };
-  const deleteTag = async (tagUUID) => {
-    const allBindings = await _getTagMetaObjects(ObjectType.TAG_BINDING);
-    const tagBindings = allBindings.filter(({ data }) => data.tagUUID === tagUUID);
-    await Promise.all([
-      // delete tag itself
-      metastoreClient.repository.deleteMetaObject({
-        objectType: ObjectType.TAG,
-        UUID: tagUUID
-      }),
-      // delete all tag associations
-      _deleteTagBindings(tagBindings)
-    ]);
-  };
-  const assignTags = async (tagUUIDs, objectId, meta = {}) => {
-    const tagBindingMapByTagId = await _getTagBindingMapByTagId(tagUUIDs, objectId);
-    const unassignedTagUUIDs = tagUUIDs.filter((tagUUID) => tagBindingMapByTagId[tagUUID] === null);
-    await concurrent({
-      items: unassignedTagUUIDs,
-      process: async (tagUUID) => metastoreClient.repository.createMetaObject({
-        objectType: ObjectType.TAG_BINDING,
-        data: {
-          objectUID: keboolaUID.serialize(objectId),
-          tagUUID
-        },
-        name: generateUUID(),
-        ...meta
-      }),
-      concurrency: 5
-    });
-  };
-  const unassignTags = async (tagUUIDs, objectID) => {
-    const tagBindingMapByTagId = await _getTagBindingMapByTagId(tagUUIDs, objectID);
-    const assignedTagUUIDs = tagUUIDs.filter((tagUUID) => tagBindingMapByTagId[tagUUID] !== null);
-    const tagBindings = assignedTagUUIDs.map((tagUUID) => tagBindingMapByTagId[tagUUID]);
-    await concurrent({
-      items: tagBindings,
-      process: async (tagBinding) => metastoreClient.repository.deleteMetaObject({
-        objectType: ObjectType.TAG_BINDING,
-        UUID: tagBinding.uuid
-      }),
-      concurrency: 5
-    });
-  };
-  const unassignAllTags = async (objectID, signal) => {
-    const tagBindings = await _getTagMetaObjects(ObjectType.TAG_BINDING, signal);
-    const objectsTagBindings = tagBindings.filter(
-      ({ data }) => data.objectUID === keboolaUID.serialize(objectID)
-    );
-    await _deleteTagBindings(objectsTagBindings);
-  };
-  const createAndAssignTag = async (data, objectId, meta = {}) => {
-    const tag = await createTag(data, meta);
-    await assignTags([tag.uuid], objectId, meta);
-    return tag;
-  };
-  return {
-    // retrievals
-    getTags,
-    getTagsByObjectId,
-    // modifications
-    createTag,
-    updateTag,
-    deleteTag,
-    assignTags,
-    unassignTags,
-    unassignAllTags,
-    createAndAssignTag
-  };
-};
-
 // src/serviceClientRegistry/utils.ts
 var isBuiltInProperty = (property) => typeof property === "symbol" || property === "then" || property === "constructor" || property === "toString" || property === "valueOf";
 var createDummyClient = ({
@@ -4119,6 +668,6 @@ var createDevApiClient = () => ({
   verify: createVerifyClient()
 });
 
-export { ApiError, HttpContentType, HttpHeader, KeboolaHttpHeader, ManagementClientAuthError, PollException, ServiceUnavailableError, UserError, assert, concurrent, consoleLogger, createApiClient, createDevApiClient, createGenericFetchClient, createLoggingMiddleware, createRetryMiddleware, createStorageSdk, delay, generateUUID, isAbortError, isApiError, isFetchClientError, isManagementClientAuthError, keboolaUID, parseLogLines, poll, series };
+export { ServiceUnavailableError, assert, consoleLogger, createApiClient, createDevApiClient, createLoggingMiddleware, createRetryMiddleware };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map