@keboola/api-client 0.1.0

package/dist/index.cjs

@@ -0,0 +1,3910 @@
+'use strict';
+
+var qs = require('qs');
+var z5 = require('zod');
+var dayjs = require('dayjs');
+var utc = require('dayjs/plugin/utc');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var qs__default = /*#__PURE__*/_interopDefault(qs);
+var z5__namespace = /*#__PURE__*/_interopNamespace(z5);
+var dayjs__default = /*#__PURE__*/_interopDefault(dayjs);
+var utc__default = /*#__PURE__*/_interopDefault(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 {
+  constructor(serviceId, path, clientName) {
+    super(
+      `Service "${serviceId}" is not available in this stack. Caused by: ${clientName}.${path.join(".")}()`
+    );
+    this.name = "ServiceUnavailableError";
+    Object.setPrototypeOf(this, _ServiceUnavailableError.prototype);
+  }
+};
+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 === 204) 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__default.default.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
+  };
+};
+
+// src/constants.ts
+var KeboolaHttpHeader = {
+  STORAGE_API_TOKEN: "X-StorageApi-Token",
+  MANAGEMENT_API_TOKEN: "X-Kbc-Manageapitoken",
+  STORAGE_API_URL: "x-storageapi-url"
+};
+var ENCRYPTED_VALUE_PREFIX = "KBC::";
+var SUGGESTION_CATEGORIES = ["error", "maintenance", "documentation"];
+var suggestionCategorySchema = z5.z.enum(SUGGESTION_CATEGORIES);
+var suggestionSchema = z5.z.object({
+  label: z5.z.preprocess((v) => typeof v === "string" ? v.slice(0, 80) : v, z5.z.string().max(80)),
+  prompt: z5.z.string(),
+  priority: z5.z.number().int().min(1).max(3),
+  category: suggestionCategorySchema,
+  reasoning: z5.z.string()
+});
+z5.z.object({
+  suggestions: z5.z.array(suggestionSchema).max(4)
+});
+var suggestionWithIdSchema = suggestionSchema.extend({
+  id: z5.z.string()
+});
+var suggestionsApiResponseSchema = z5.z.object({
+  suggestions: z5.z.array(suggestionWithIdSchema).max(4),
+  suggestionSessionId: z5.z.string()
+});
+var recentFailedJobSchema = z5.z.object({
+  id: z5.z.string(),
+  status: z5.z.enum(["error", "warning"]),
+  component: z5.z.string(),
+  configId: z5.z.string(),
+  configName: z5.z.string().optional(),
+  createdTime: z5.z.string(),
+  durationSeconds: z5.z.number().int().nonnegative().optional(),
+  errorMessage: z5.z.string().max(200).optional()
+});
+var deprecatedComponentSchema = z5.z.object({
+  id: z5.z.string(),
+  name: z5.z.string(),
+  type: z5.z.string(),
+  expiredOn: z5.z.string(),
+  configCount: z5.z.number().int().nonnegative()
+});
+var userRecentEditSchema = z5.z.object({
+  component: z5.z.string(),
+  configId: z5.z.string(),
+  configName: z5.z.string(),
+  lastEdited: z5.z.string()
+});
+var dashboardContextDataSchema = z5.z.object({
+  recentFailedJobs: z5.z.array(recentFailedJobSchema).max(5),
+  deprecatedComponents: z5.z.array(deprecatedComponentSchema).max(5),
+  userRecentEdits: z5.z.array(userRecentEditSchema).max(5),
+  currentUserEmail: z5.z.string().email()
+});
+var JOB_STATUSES = [
+  "created",
+  "waiting",
+  "processing",
+  "success",
+  "error",
+  "terminating",
+  "terminated",
+  "cancelled",
+  "warning"
+];
+var jobDetailContextDataSchema = z5.z.object({
+  job: z5.z.object({
+    id: z5.z.string(),
+    status: z5.z.enum(JOB_STATUSES),
+    component: z5.z.string(),
+    configId: z5.z.string().optional(),
+    configName: z5.z.string().optional(),
+    createdTime: z5.z.string(),
+    startTime: z5.z.string().optional(),
+    endTime: z5.z.string().optional(),
+    durationSeconds: z5.z.number().int().nonnegative().optional(),
+    errorMessage: z5.z.string().max(500).optional(),
+    errorType: z5.z.enum(["user", "application"]).optional(),
+    backendSize: z5.z.string().optional()
+  }),
+  component: z5.z.object({
+    id: z5.z.string(),
+    name: z5.z.string(),
+    type: z5.z.string()
+  }).optional(),
+  runtimeHistory: z5.z.object({
+    averageDurationSeconds: z5.z.number().nonnegative().optional(),
+    minDurationSeconds: z5.z.number().nonnegative().optional(),
+    maxDurationSeconds: z5.z.number().nonnegative().optional(),
+    recentJobsCount: z5.z.number().int().nonnegative(),
+    isSlowerThanAverage: z5.z.boolean().optional(),
+    isFasterThanAverage: z5.z.boolean().optional(),
+    percentageDifference: z5.z.number().optional()
+  }).optional(),
+  currentUserEmail: z5.z.string().email()
+});
+var configurationDetailContextDataSchema = z5.z.object({
+  configuration: z5.z.object({
+    id: z5.z.string(),
+    name: z5.z.string(),
+    description: z5.z.string().max(500).optional(),
+    component: z5.z.string(),
+    hasRows: z5.z.boolean(),
+    rowCount: z5.z.number().int().nonnegative().optional(),
+    lastChangeDescription: z5.z.string().max(200).optional()
+  }),
+  component: z5.z.object({
+    id: z5.z.string(),
+    name: z5.z.string(),
+    type: z5.z.string()
+  }).optional(),
+  latestJobs: z5.z.array(
+    z5.z.object({
+      id: z5.z.string(),
+      status: z5.z.enum(JOB_STATUSES),
+      durationSeconds: z5.z.number().int().nonnegative().optional(),
+      errorMessage: z5.z.string().max(200).optional(),
+      createdTime: z5.z.string()
+    })
+  ).max(5).optional(),
+  currentUserEmail: z5.z.string().email()
+});
+var dashboardSuggestionsRequestSchema = z5.z.object({
+  context: z5.z.literal("dashboard"),
+  data: dashboardContextDataSchema
+});
+var jobDetailSuggestionsRequestSchema = z5.z.object({
+  context: z5.z.literal("job-detail"),
+  data: jobDetailContextDataSchema
+});
+var configurationDetailSuggestionsRequestSchema = z5.z.object({
+  context: z5.z.literal("configuration-detail"),
+  data: configurationDetailContextDataSchema
+});
+z5.z.discriminatedUnion("context", [
+  dashboardSuggestionsRequestSchema,
+  jobDetailSuggestionsRequestSchema,
+  configurationDetailSuggestionsRequestSchema
+]);
+
+// src/clients/chat/chatClient.ts
+var agentSettingsSchema = z5.z.object({
+  projectId: z5.z.string(),
+  customInstructions: z5.z.string().nullable(),
+  createdAt: z5.z.string(),
+  updatedAt: z5.z.string()
+});
+var toolPermissionValueSchema = z5.z.enum(["always_allow", "always_ask", "blocked"]);
+var userAgentSettingsSchema = z5.z.object({
+  projectId: z5.z.string(),
+  userId: z5.z.string(),
+  customInstructions: z5.z.string().nullable(),
+  toolPermissions: z5.z.record(z5.z.string(), toolPermissionValueSchema).nullable(),
+  createdAt: z5.z.string(),
+  updatedAt: z5.z.string()
+});
+var toolInfoSchema = z5.z.object({
+  name: z5.z.string(),
+  description: z5.z.string(),
+  readOnly: z5.z.boolean()
+});
+var toolsListResponseSchema = z5.z.object({
+  tools: z5.z.array(toolInfoSchema)
+});
+var createChatClient = ({ baseUrl, middlewares, storageApiUrl }) => {
+  const client = createOpenapiFetchClient({
+    baseUrl,
+    headers: new Headers({
+      [KeboolaHttpHeader.STORAGE_API_URL]: storageApiUrl
+    }),
+    middlewares
+  });
+  const getHistory = async (params) => {
+    const { data } = await client.get("/history", { query: params });
+    return data;
+  };
+  const getChat = async (chatId, signal) => {
+    const { data } = await client.get("/chat/{id}", { path: { id: chatId } }, { signal });
+    return data;
+  };
+  const deleteChat = async (chatId) => {
+    const { data } = await client.delete("/chat", { query: { id: chatId } });
+    return data;
+  };
+  const getVotes = async (chatId) => {
+    const { data } = await client.get("/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;
+  };
+  const getUsage = async (signal) => {
+    const { data } = await client.get("/usage", {}, { signal });
+    return data;
+  };
+  const getSuggestions = async (request, signal) => {
+    const { data } = await client.post("/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 client.get("/settings", {}, { signal });
+    const result = agentSettingsSchema.safeParse(data);
+    if (!result.success) {
+      throw new Error("Invalid agent settings response format");
+    }
+    return result.data;
+  };
+  const updateAgentSettings = async (request, signal) => {
+    const { data } = await client.patch("/settings", { body: request }, { signal });
+    const result = agentSettingsSchema.safeParse(data);
+    if (!result.success) {
+      throw new Error("Invalid agent settings response format");
+    }
+    return result.data;
+  };
+  const getUserAgentSettings = async (signal) => {
+    const { data } = await client.get("/settings/user", {}, { signal });
+    const result = userAgentSettingsSchema.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 client.patch("/settings/user", { body: request }, { signal });
+    const result = userAgentSettingsSchema.safeParse(data);
+    if (!result.success) {
+      throw new Error("Invalid user agent settings response format");
+    }
+    return result.data;
+  };
+  const getToolsList = async (signal) => {
+    const { data } = await client.get("/settings/tools", {}, { signal });
+    const result = toolsListResponseSchema.safeParse(data);
+    if (!result.success) {
+      throw new Error("Invalid tools list response format");
+    }
+    return result.data;
+  };
+  return {
+    getHistory,
+    getChat,
+    deleteChat,
+    createChat,
+    getVotes,
+    submitVote,
+    getUsage,
+    getSuggestions,
+    getAgentSettings,
+    updateAgentSettings,
+    getUserAgentSettings,
+    updateUserAgentSettings,
+    getToolsList
+  };
+};
+var TailError = z5__namespace.object({
+  context: z5__namespace.object({
+    code: z5__namespace.string()
+  })
+});
+dayjs__default.default.extend(utc__default.default);
+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
+  };
+};
+var parsePlainTextLine = (line) => {
+  const match = line.match(LEADING_ISO_TIMESTAMP_REGEX);
+  if (match) {
+    return { timestamp: match[1], message: line.slice(match[0].length) };
+  }
+  return { timestamp: null, message: line };
+};
+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 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__default.default(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 === 400 && 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 getWorkspacePassword = async (id, signal) => {
+    const { data } = await client.get(
+      `/sql/sessions/{id}/workspace-password`,
+      { path: { id } },
+      { signal }
+    );
+    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,
+    getWorkspacePassword,
+    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 = z5.z.object({
+  projectId: z5.z.string(),
+  customInstructions: z5.z.string().nullable(),
+  createdAt: z5.z.string(),
+  updatedAt: z5.z.string()
+});
+var toolPermissionValueSchema2 = z5.z.enum(["always_allow", "always_ask", "blocked"]);
+var userAgentSettingsSchema2 = z5.z.object({
+  projectId: z5.z.string(),
+  userId: z5.z.string(),
+  customInstructions: z5.z.string().nullable(),
+  toolPermissions: z5.z.record(z5.z.string(), toolPermissionValueSchema2).nullable(),
+  createdAt: z5.z.string(),
+  updatedAt: z5.z.string()
+});
+var toolInfoSchema2 = z5.z.object({
+  name: z5.z.string(),
+  description: z5.z.string(),
+  readOnly: z5.z.boolean()
+});
+var toolsListResponseSchema2 = z5.z.object({
+  tools: z5.z.array(toolInfoSchema2)
+});
+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 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 chatStreamUrl = baseUrl + "/api/chat";
+  return {
+    getHistory,
+    getChat,
+    deleteChat,
+    createChat,
+    getVotes,
+    submitVote,
+    getUsage,
+    approveToolCall,
+    submitToolOutput,
+    getSuggestions,
+    getAgentSettings,
+    updateAgentSettings,
+    getUserAgentSettings,
+    updateUserAgentSettings,
+    getToolsList,
+    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 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;
+  const isDevelopment = process.env.NODE_ENV === "development";
+  return (next) => async (request) => {
+    if (!!token) {
+      const tokenInfo = await verify.managementApiToken(baseUrl, token);
+      const isTokenValid = !tokenInfo.isDisabled && !tokenInfo.isExpired;
+      if (!isTokenValid) {
+        token = isDevelopment ? await auth.createCurrentUserSessionToken(token) : await auth.createAdminAccountSessionToken();
+      }
+    } else {
+      token = await auth.createAdminAccountSessionToken();
+    }
+    request.request.headers.set(KeboolaHttpHeader.MANAGEMENT_API_TOKEN, token);
+    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 getMaintainerOrganizations = async (maintainerId, signal) => {
+    const { data } = await client.get(
+      "/manage/maintainers/{id}/organizations",
+      { path: { id: maintainerId } },
+      { signal }
+    );
+    return data;
+  };
+  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,
+    getMaintainerOrganizations,
+    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
+  });
+  return {
+    currentUser: createCurrentUser(openApiClient),
+    features: createFeatures(client),
+    maintainers: createMaintainers(openApiClient),
+    organizations: createOrganizations(openApiClient),
+    projects: createProjects(client),
+    users: createUsers(client)
+  };
+};
+
+// 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/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}",
+      // @ts-expect-error backend accepts `?include=activityLog`; OpenAPI schema regen pending (connection#7250).
+      { 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 },
+      // @ts-expect-error backend accepts optional `{ reason }` body; OpenAPI schema regen pending (connection#7250).
+      body: reason ? { reason } : void 0
+    });
+    return data;
+  };
+  return {
+    getMergeRequests,
+    getMergeRequest,
+    getMergeRequestWithActivityLog,
+    createMergeRequest,
+    updateMergeRequest,
+    requestReview,
+    approveMergeRequest,
+    requestChangesMergeRequest
+  };
+};
+
+// 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/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 }
+    });
+  };
+  return {
+    getBuckets,
+    getBucket,
+    createBucket,
+    updateBucket,
+    deleteBucket,
+    deleteBucketAsync,
+    createScheduledRefresh,
+    deleteScheduledTask
+  };
+};
+
+// 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__namespace.object({
+  name: z5__namespace.string(),
+  email: z5__namespace.email()
+});
+var RepositoryBranch = z5__namespace.object({
+  sha: z5__namespace.string(),
+  date: z5__namespace.string(),
+  comment: z5__namespace.string(),
+  branch: z5__namespace.string(),
+  author: Author
+});
+var Repository = z5__namespace.object({
+  repository: z5__namespace.object({
+    url: z5__namespace.string()
+  }),
+  branches: z5__namespace.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 getComponent = (componentId) => componentMap.get(componentId) ?? null;
+  const hasService = (serviceId) => serviceMap.has(serviceId);
+  const getServiceUrl = (serviceId) => serviceMap.get(serviceId) ?? null;
+  return {
+    ...infoRest,
+    services,
+    features,
+    components,
+    hasFeature,
+    getServiceUrl,
+    hasService,
+    getComponent,
+    hasComponent
+  };
+};
+
+// 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);
+  };
+  return {
+    createTable,
+    importFromFile,
+    exportToFile
+  };
+};
+
+// 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 = ({
+  onCall
+}) => {
+  const createProxy = (path = []) => new Proxy(() => {
+  }, {
+    // Create a new proxy for nested property access
+    get: (_target, prop) => {
+      if (isBuiltInProperty(prop)) return void 0;
+      return createProxy([...path, prop]);
+    },
+    // When called as a function, invoke the interceptor
+    apply: (_target, _thisArgs, args) => onCall(path, args)
+  });
+  return createProxy();
+};
+
+// src/serviceClientRegistry/createServiceClientRegistry.ts
+var createServiceClientRegistry = () => ({
+  getServiceBaseUrl,
+  onUnavailable,
+  clients
+}) => {
+  const dummy = (serviceId, clientName) => createDummyClient({
+    onCall: (path, args) => {
+      onUnavailable?.({
+        serviceId,
+        path,
+        args,
+        clientName
+      });
+    }
+  });
+  const clientMap = {};
+  const meta = [];
+  clients.forEach(({ serviceId, clientFn, clientName }) => {
+    const serviceBaseUrl = getServiceBaseUrl(serviceId);
+    clientMap[clientName] = serviceBaseUrl ? clientFn(serviceBaseUrl) : dummy(serviceId, clientName);
+    meta.push({ clientName, serviceId, isAvailable: !!serviceBaseUrl });
+  });
+  const client = clientMap;
+  return {
+    client,
+    meta
+  };
+};
+
+// src/client.ts
+var createClients = async ({
+  baseUrl,
+  token,
+  callbacks,
+  assetsBaseUrl,
+  statusBaseUrl,
+  metastoreBaseUrl,
+  clientServiceUrls,
+  storageMiddlewares
+}) => {
+  const callbackMiddleware = createCallbackMiddleware(callbacks);
+  const storageTokenMiddleware = createStorageTokenMiddleware(token.storageApi);
+  const commonMiddlewares = [callbackMiddleware, storageTokenMiddleware];
+  const storage = createStorageClient({
+    baseUrl,
+    middlewares: [...commonMiddlewares, ...storageMiddlewares || []]
+  });
+  const management = createManagementClient({
+    baseUrl,
+    token: token.managementApi,
+    callbacks
+  });
+  const [stackInfo, sapiToken] = await Promise.all([
+    storage.getStackInfo({
+      exclude: "componentDetails"
+    }),
+    storage.tokens.verify()
+  ]);
+  const stack = createStack({ stackInfo, clientServiceUrls });
+  const project = createProject({ sapiToken });
+  const { client, meta } = createServiceClientRegistry()({
+    getServiceBaseUrl: (serviceId) => stack.getServiceUrl(serviceId),
+    onUnavailable: ({ serviceId, path, clientName }) => {
+      throw new ServiceUnavailableError(serviceId, path, clientName);
+    },
+    clients: [
+      {
+        serviceId: "vault",
+        clientName: "vault",
+        clientFn: (serviceBaseUrl) => createVaultClient({ baseUrl: serviceBaseUrl, middlewares: commonMiddlewares })
+      },
+      {
+        serviceId: "data-science",
+        clientName: "dataScience",
+        clientFn: (serviceBaseUrl) => createDataScienceClient({ baseUrl: serviceBaseUrl, middlewares: commonMiddlewares })
+      },
+      {
+        serviceId: "encryption",
+        clientName: "encryption",
+        clientFn: (serviceBaseUrl) => createEncryptionClient({ baseUrl: serviceBaseUrl, middlewares: [callbackMiddleware] })
+      },
+      {
+        serviceId: "editor",
+        clientName: "editor",
+        clientFn: (serviceBaseUrl) => createEditorClient({ baseUrl: serviceBaseUrl, middlewares: commonMiddlewares })
+      },
+      {
+        serviceId: "sync-actions",
+        clientName: "syncActions",
+        clientFn: (serviceBaseUrl) => createSyncActionsClient({ baseUrl: serviceBaseUrl, middlewares: commonMiddlewares })
+      },
+      {
+        serviceId: "telemetry",
+        clientName: "telemetry",
+        clientFn: (serviceBaseUrl) => createTelemetryClient({ baseUrl: serviceBaseUrl, middlewares: commonMiddlewares })
+      },
+      {
+        serviceId: "query",
+        clientName: "queryService",
+        clientFn: (serviceBaseUrl) => createQueryServiceClient({ baseUrl: serviceBaseUrl, middlewares: commonMiddlewares })
+      },
+      {
+        serviceId: "queue",
+        clientName: "queue",
+        clientFn: (serviceBaseUrl) => createQueueClient({ baseUrl: serviceBaseUrl, middlewares: commonMiddlewares })
+      },
+      {
+        serviceId: "kai-assistant",
+        clientName: "chat",
+        clientFn: (serviceBaseUrl) => createChatClient({
+          storageApiUrl: baseUrl,
+          baseUrl: serviceBaseUrl,
+          middlewares: commonMiddlewares
+        })
+      },
+      {
+        serviceId: "ai",
+        clientName: "ai",
+        clientFn: (serviceBaseUrl) => createAiClient({ baseUrl: serviceBaseUrl, middlewares: commonMiddlewares })
+      },
+      {
+        serviceId: "import",
+        clientName: "import",
+        clientFn: (serviceBaseUrl) => createImportClient({ baseUrl: serviceBaseUrl, middlewares: commonMiddlewares })
+      },
+      {
+        serviceId: "kai-agent",
+        clientName: "kaiAgent",
+        clientFn: (serviceBaseUrl) => createKaiAgentClient({
+          baseUrl: serviceBaseUrl,
+          middlewares: commonMiddlewares
+        })
+      }
+    ]
+  });
+  const metastore = createMetastoreClient({
+    baseUrl: metastoreBaseUrl,
+    middlewares: commonMiddlewares
+  });
+  const assets = createAssetsClient({
+    baseUrl: assetsBaseUrl,
+    middlewares: [callbackMiddleware]
+  });
+  const status = createStatusClient({
+    baseUrl: statusBaseUrl,
+    middlewares: [callbackMiddleware]
+  });
+  const tag = createTagSdk({
+    metastoreClient: metastore
+  });
+  const storageSdk = createStorageSdk({
+    storageClient: storage
+  });
+  return {
+    // info
+    stack,
+    project,
+    serviceMeta: meta,
+    // clients
+    storage,
+    assets,
+    status,
+    management,
+    ...client,
+    sdk: {
+      tag,
+      storage: storageSdk
+    }
+  };
+};
+var createApiClient = () => {
+  let clients = null;
+  const init = async (options) => {
+    if (clients) throw new Error("API is already initialized.");
+    clients = await createClients(options);
+  };
+  const result = { init };
+  const handler = {
+    get(_, property) {
+      if (isBuiltInProperty(property)) return void 0;
+      if (property === "init") return init;
+      assert(clients, `API is not initialized. Call init() before accessing ${String(property)}`);
+      return clients[property];
+    }
+  };
+  return new Proxy(result, handler);
+};
+
+// src/middlewares/loggingMiddleware.ts
+var CORRELATION_ID_HEADER = "X-Correlation-ID";
+var ALWAYS_REDACTED_HEADERS = [
+  KeboolaHttpHeader.MANAGEMENT_API_TOKEN,
+  KeboolaHttpHeader.STORAGE_API_TOKEN
+];
+var ALWAYS_REDACTED_QUERY_PARAMS = /* @__PURE__ */ new Set([
+  "token",
+  "apikey",
+  "api_key",
+  "access_token",
+  "refresh_token",
+  "code",
+  "state",
+  "signature",
+  "sig",
+  "x-amz-signature",
+  "x-amz-credential",
+  "x-amz-security-token",
+  "password",
+  "secret"
+]);
+var REDACTED = "[REDACTED]";
+var getRedactedUrl = (rawUrl) => {
+  const url = new URL(rawUrl);
+  if (url.username) url.username = REDACTED;
+  if (url.password) url.password = REDACTED;
+  url.searchParams.forEach((_value, key) => {
+    if (ALWAYS_REDACTED_QUERY_PARAMS.has(key.toLowerCase())) {
+      url.searchParams.set(key, REDACTED);
+    }
+  });
+  return url.toString();
+};
+var ensureCorrelationId = (request) => {
+  const correlationId = request.headers.get(CORRELATION_ID_HEADER) ?? generateUUID();
+  request.headers.set(CORRELATION_ID_HEADER, correlationId);
+  return correlationId;
+};
+var getRedactedHeaders = (headers, redacted) => {
+  const redactedSet = new Set(
+    [...ALWAYS_REDACTED_HEADERS, ...redacted].map((h) => h.toLowerCase())
+  );
+  const result = {};
+  headers.forEach((value, name) => {
+    result[name] = redactedSet.has(name.toLowerCase()) ? REDACTED : value;
+  });
+  return result;
+};
+var getRequestLog = (request, redactedHeaders) => ({
+  url: getRedactedUrl(request.url),
+  headers: getRedactedHeaders(request.headers, redactedHeaders)
+});
+var getResponseLog = (response, redactedHeaders) => ({
+  status: response.status,
+  statusText: response.statusText,
+  headers: getRedactedHeaders(response.headers, redactedHeaders)
+});
+var formatLog = (level, log) => {
+  const parts = [`[${level.toUpperCase()}]`, `${Math.round(log.durationMs)}ms`, log.method];
+  parts.push(log.request.url);
+  if (log.response) parts.push(String(log.response.status));
+  return parts.join(" ");
+};
+var consoleLogger = {
+  info: (log) => console.info(formatLog("info", log)),
+  error: (log) => console.error(formatLog("error", log))
+};
+var wrapSafe = (logger, level) => ({
+  info: (log) => {
+    if (level !== "all") return;
+    try {
+      logger.info(log);
+    } catch {
+    }
+  },
+  error: (log) => {
+    try {
+      logger.error(log);
+    } catch {
+    }
+  }
+});
+var createLoggingMiddleware = (options = {}) => {
+  const safeLogger = wrapSafe(options.logger ?? consoleLogger, options.level ?? "error-only");
+  const redactHeaders = options.redactHeaders ?? [];
+  return (next) => async (fetchRequest) => {
+    const correlationId = ensureCorrelationId(fetchRequest.request);
+    const start = performance.now();
+    const method = fetchRequest.request.method.toLowerCase();
+    const requestLog = getRequestLog(fetchRequest.request, redactHeaders);
+    try {
+      const result = await next(fetchRequest);
+      safeLogger.info({
+        correlationId,
+        method,
+        durationMs: performance.now() - start,
+        request: requestLog,
+        response: getResponseLog(result.response, redactHeaders)
+      });
+      return result;
+    } catch (error) {
+      const durationMs = performance.now() - start;
+      if (error instanceof Error) {
+        safeLogger.error({ correlationId, method, durationMs, request: requestLog, error });
+      }
+      throw error;
+    }
+  };
+};
+
+// src/middlewares/retryMiddleware.ts
+var DEFAULT_MAX_RETRIES = 5;
+var DEFAULT_RETRYABLE_STATUSES = [500, 502, 503, 504];
+var DEFAULT_BACKOFF_FACTOR = 0.3;
+var defaultShouldRetry = (error) => error instanceof ApiError && DEFAULT_RETRYABLE_STATUSES.includes(error.response.status);
+var createRetryMiddleware = (options) => {
+  const {
+    maxRetries = DEFAULT_MAX_RETRIES,
+    backoffFactor = DEFAULT_BACKOFF_FACTOR,
+    shouldRetry = defaultShouldRetry
+  } = options ?? {};
+  if (!Number.isInteger(maxRetries) || maxRetries < 0) {
+    throw new RangeError("maxRetries must be a non-negative integer");
+  }
+  if (!Number.isFinite(backoffFactor) || backoffFactor < 0) {
+    throw new RangeError("backoffFactor must be a finite non-negative number");
+  }
+  return (next) => async (request) => {
+    for (let attempt = 0; attempt <= maxRetries; attempt++) {
+      try {
+        return await next({ ...request, request: request.request.clone() });
+      } catch (error) {
+        if (attempt === maxRetries || !shouldRetry(error, attempt)) {
+          throw error;
+        }
+        const delayMs = backoffFactor * 1e3 * Math.pow(2, attempt);
+        await delay(delayMs, request.request.signal ?? void 0);
+      }
+    }
+    throw new Error("unreachable");
+  };
+};
+
+// src/devClient.ts
+var createDevApiClient = () => ({
+  verify: createVerifyClient()
+});
+
+exports.ApiError = ApiError;
+exports.HttpContentType = HttpContentType;
+exports.HttpHeader = HttpHeader;
+exports.KeboolaHttpHeader = KeboolaHttpHeader;
+exports.ManagementClientAuthError = ManagementClientAuthError;
+exports.PollException = PollException;
+exports.ServiceUnavailableError = ServiceUnavailableError;
+exports.UserError = UserError;
+exports.assert = assert;
+exports.concurrent = concurrent;
+exports.consoleLogger = consoleLogger;
+exports.createApiClient = createApiClient;
+exports.createDevApiClient = createDevApiClient;
+exports.createGenericFetchClient = createGenericFetchClient;
+exports.createLoggingMiddleware = createLoggingMiddleware;
+exports.createRetryMiddleware = createRetryMiddleware;
+exports.createStorageSdk = createStorageSdk;
+exports.delay = delay;
+exports.generateUUID = generateUUID;
+exports.isAbortError = isAbortError;
+exports.isApiError = isApiError;
+exports.isFetchClientError = isFetchClientError;
+exports.isManagementClientAuthError = isManagementClientAuthError;
+exports.keboolaUID = keboolaUID;
+exports.parseLogLines = parseLogLines;
+exports.poll = poll;
+exports.series = series;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map