@keboola/api-client 0.1.0

package/dist/index.d.cts

@@ -0,0 +1,3108 @@
+import { G as GetAllFeaturesQuery, F as Feature, c as components$5, C as CreateMaintainerBody, U as UpdateMaintainerBody, M as MaintainerUser, A as AddMaintainerUserBody, a as CreateMaintainerInvitationBody, b as CreateMaintainerOrganizationBody, d as MetadataItem, S as SetMaintainerMetadataBody, e as UpdateOrganizationBody, f as AddOrganizationUserBody, g as CreateOrganizationInvitationBody, P as Project, h as CreateOrganizationProjectBody, i as SetOrganizationMetadataBody, j as GetProjectPath, k as CreateProjectFeaturePath, l as CreateProjectFeatureBody, R as RemoveProjectFeaturePath, m as User, L as ListProjectUsersPath, n as GetProjectMetadataPath, o as ProjectMetadataItem, p as SetProjectMetadataPath, q as SetProjectMetadataBody, r as GetProjectReviewersPath, s as Reviewer, t as SetProjectReviewersPath, u as SetProjectReviewersBody, v as AddUserFeatureBody, w as AddUserFeaturePath, x as RemoveUserFeaturePath } from './types-BeShtGlc.cjs';
+import { M as MiddlewareFn, B as BaseClientOptions, A as ApiResponse, H as HttpMethod } from './types-DgaMV8FF.cjs';
+export { c as ApiError, d as CreateCallbackMiddlewareOptions, e as FetchClientError, i as isAbortError, f as isApiError, g as isFetchClientError } from './types-DgaMV8FF.cjs';
+import { StatusSummary } from './status/types.cjs';
+import { Post } from './assets/types.cjs';
+import * as zod from 'zod';
+import { c as OpenapiQueryType, d as OpenapiPathType, b as OpenapiBodyType, a as OpenapiReturnType } from './types-C7mpAfq-.cjs';
+import { U as UploadFileParams, a as UploadedFile } from './types-Dg1tEsVR.cjs';
+import { D as DescribeConfigurationVersionBody, a as DescribeConfigurationMergeBody, E as ExplainErrorBody, b as DescribeConfigurationBody, S as SuggestComponentBody, c as components$4, F as FeedbackBody } from './types-Dws8mFNY.cjs';
+import { SuggestionsRequestBody, SuggestionsApiResponse } from './chat/suggestions.cjs';
+import { G as GetHistoryQuery$1, c as components$3, a as GetChatPath$1, C as ChatRequest$1, b as GetVotesQuery$1, V as VoteRequest$1, U as UsageResponse$1, A as AgentSettings, d as UpdateAgentSettingsRequest, e as UserAgentSettings, f as UpdateUserAgentSettingsRequest, T as ToolsListResponse } from './types-DJ6nbNq5.cjs';
+import { G as GetQueueJobPath, c as components$2, S as SearchJobsQuery } from './types-CRSKcua9.cjs';
+import { P as PostQueryPath, a as PostQueryBody, b as PostCancelQueryJobPath, G as GetQueryJobPath, c as components$1, d as GetQueryResultsPath, e as GetQueryResutsQuery, f as GetQueriesPath, g as GetQueriesHistoryQuery, h as GetExportResultsQuery, E as ExportResultsResponse } from './types-DJkU9gvB.cjs';
+import { CreateCredentialsBody, WorkspaceData } from './telemetry/types.cjs';
+import { EnrollMFAInput, GetDataAppPublicGitRepositoryInput, GetDataAppPasswordPrivateGitRepositoryInput, GetDataAppSSHKeyPrivateGitRepositoryInput, GetPublicGitRepositoryInput, GetGitPrivateRepositoryInput } from './syncActions/types.cjs';
+import { C as CreateSqlSessionBody, G as GetSqlSessionPath, a as GetSqlSessionsQuery, b as GetSqlSessionSchemaPath, c as GetSqlSessionSchemaQuery, d as components, P as PostSqlRunQueryPath, e as PostSqlRunQueryBody, f as PostSqlTablePreviewPath, g as PostSqlTablePreviewBody, h as GetSqlSessionTableDdlPath, i as GetSqlSessionTableDdlQuery, j as PostSqlSessionLoadPath, k as PostSqlSessionLoadBody, l as PostSqlSessionUnloadPath, m as PostSqlSessionUnloadBody } from './types-BNQK_jR_.cjs';
+import { EncryptQuery } from './encryption/types.cjs';
+import { G as GetDataAppRunsPath, a as GetDataAppRunsQuery, b as GetDataAppRunPath, c as GetDataAppLogsDownloadPath, d as GetDataAppLogsTailPath, e as GetDataAppLogsTailQuery, L as LogEntry, f as GetAppsQuery, g as GetDataAppPath, C as CreateDataAppBody, P as PatchDataAppPath, h as PatchDataAppBody, D as DeleteDataAppPath, i as GetDataAppPasswordPath, R as ResetDataAppPasswordPath, j as GetSandboxPath } from './utils-DE09pDTi.cjs';
+export { p as parseLogLines } from './utils-DE09pDTi.cjs';
+import { CreateVariableBody, DeleteVariablePath, VariableWithHash, GetVariablesQuery, GetVariablesByBranchId } from './vault/types.cjs';
+import { ServiceId, CreateTableAsyncBody, TableCreateJob, TableImportAsyncBody, TableImportJob, TableExportAsyncBody, TableExportJob, Service, StackComponent, GetBucketsQuery, Bucket, BucketDetail, CreateBucketBody, UpdateBucketBody, CreateScheduledRefreshPath, CreateScheduledRefreshBody, ScheduledTask, GetEventsQuery, StorageEvent, CreateEventBody, File as File$1, GetFilesQuery, DeleteFileTagPath, PrepareFileBody, PreparedFile, GetTablesQuery, Table, TableDetail, GetDataPreview, PrevieData, DeleteTableRows, JobUnion, DevBranch, CreateDevBranchJobBody, DevBranchPath, BranchMetadata, BranchMetadataEntry, WorkspacePath, Workspace, WorkspacesPath, ResetWorkspacePassword, SetWorkspacePublicInput, GetWorkspaceSaml2LoginPath, WorkspaceSaml2Login, WorkspaceObject, DeleteWorkspaceObjectInput, MergeRequestDetail, MergeRequestDetailWithActivityLog, CreateMergeRequestParams, UpdateMergeRequestParams, JobOperation, GetJobPath, Job, GetJobsQuery, GetComponentPath, Component, GetComponentsPath, GetComponentsQuery, GetSearchComponentConfigurationsPath, SearchComponentConfigurationsQuery, SearchComponentConfiguration, PartialKey, CreateConfigurationInput, BaseComponentConfig, ConfigType, ConfigurationPath, ComponentConfig, GetConfigurationsPath, CreateConfigurationRowInput, Row, CreateConfigurationRowsInput, CreateConfigurationRowBody, DeleteConfigurationRowInput, DeleteConfigurationRowsInput, CreateConfigurationWorkspaceBody, ConfigurationUseCaseType, ConfigurationVersionPath, ConfigurationVersion, ConfigurationVersionDetailPath, ConfigurationVersionDetail, GetStackInfoQuery, StackInfo } from './storage/types.cjs';
+import { M as MetaObject } from './types-C-bd4ArM.cjs';
+import { C as ConcurrentOptions, M as MiddlewareFn$1 } from './storageClient-DPLh_p0V.cjs';
+export { a as concurrent } from './storageClient-DPLh_p0V.cjs';
+import { K as KeboolaObjectId } from './keboolaUID-D1DGSbge.cjs';
+export { k as keboolaUID } from './keboolaUID-D1DGSbge.cjs';
+import { TagWithBindings, TagData, CreateMetaObjectMetaDataInput, UpdateMetaObjectMetaDataInput } from './sdk/tag/types.cjs';
+import { B as Backend, S as StorageToken } from './types-DYMMsuU0.cjs';
+export { c as createGenericFetchClient } from './createGenericFetchClient-CLUzu-jY.cjs';
+export { M as ManagementClientAuthError, i as isManagementClientAuthError } from './authMiddleware-BteBe1Bt.cjs';
+import { ManagementToken } from './verify/types.cjs';
+export { createStorageSdk } from './sdk/storage/index.cjs';
+import 'qs';
+import './createOpenapiFetchClient-CpXmAIFB.cjs';
+import './metastore/index.cjs';
+
+declare class UserError extends Error {
+    constructor(message: string);
+}
+
+declare class ServiceUnavailableError extends Error {
+    constructor(serviceId: string, path: string[], clientName: string);
+}
+
+declare const HttpHeader: {
+    CONTENT_TYPE: string;
+    CONTENT_DISPOSITION: string;
+};
+declare const HttpContentType: {
+    JSON: string;
+    TEXT_PLAIN: string;
+    FORM_DATA: string;
+    TEXT_HTML: string;
+};
+
+/**
+ * This file was auto-generated by openapi-typescript.
+ * Do not make direct changes to the file.
+ */
+
+type paths = {
+  '/ping': {
+    parameters: {
+      query?: never;
+      header?: never;
+      path?: never;
+      cookie?: never;
+    };
+    /** Readiness probe */
+    get: {
+      parameters: {
+        query?: never;
+        header?: never;
+        path?: never;
+        cookie?: never;
+      };
+      requestBody?: never;
+      responses: {
+        /** @description Server is ready */
+        200: {
+          headers: {
+            [name: string]: unknown;
+          };
+          content: {
+            'application/json': {
+              /** Format: date-time */
+              timestamp: string;
+            };
+          };
+        };
+      };
+    };
+    put?: never;
+    post?: never;
+    delete?: never;
+    options?: never;
+    head?: never;
+    patch?: never;
+    trace?: never;
+  };
+  '/api': {
+    parameters: {
+      query?: never;
+      header?: never;
+      path?: never;
+      cookie?: never;
+    };
+    /** Application info and health status */
+    get: {
+      parameters: {
+        query?: never;
+        header?: never;
+        path?: never;
+        cookie?: never;
+      };
+      requestBody?: never;
+      responses: {
+        /** @description Application info */
+        200: {
+          headers: {
+            [name: string]: unknown;
+          };
+          content: {
+            'application/json': {
+              /** Format: date-time */
+              timestamp: string;
+              uptime: number;
+              appName: string;
+              appVersion: string;
+              serverVersion: string;
+              connectedMcp: {
+                url: string;
+                /** @enum {string} */
+                status: 'ok' | 'error';
+                details?: unknown;
+                error?: string;
+              };
+            };
+          };
+        };
+      };
+    };
+    put?: never;
+    post?: never;
+    delete?: never;
+    options?: never;
+    head?: never;
+    patch?: never;
+    trace?: never;
+  };
+  '/api/history': {
+    parameters: {
+      query?: never;
+      header?: never;
+      path?: never;
+      cookie?: never;
+    };
+    /**
+     * Get chat history
+     * @description Retrieve paginated list of user's chats
+     */
+    get: {
+      parameters: {
+        query?: {
+          limit?: number;
+          starting_after?: string;
+          ending_before?: string;
+        };
+        header?: never;
+        path?: never;
+        cookie?: never;
+      };
+      requestBody?: never;
+      responses: {
+        /** @description List of chats with pagination info */
+        200: {
+          headers: {
+            [name: string]: unknown;
+          };
+          content: {
+            'application/json': {
+              chats: {
+                /** Format: uuid */
+                id: string;
+                title: string;
+                userId: string;
+                /** Format: date-time */
+                createdAt: string;
+                /**
+                 * Format: date-time
+                 * @description Timestamp of the last message in this chat
+                 */
+                lastMessageAt: string;
+                /** @enum {string} */
+                visibility: 'public' | 'private';
+                branchId?: number | null;
+              }[];
+              hasMore: boolean;
+            };
+          };
+        };
+        /** @description Bad request */
+        400: {
+          headers: {
+            [name: string]: unknown;
+          };
+          content: {
+            'application/json': {
+              error: {
+                type: string;
+                surface: string;
+                message: string;
+              };
+            };
+          };
+        };
+        /** @description Unauthorized */
+        401: {
+          headers: {
+            [name: string]: unknown;
+          };
+          content: {
+            'application/json': {
+              error: {
+                type: string;
+                surface: string;
+                message: string;
+              };
+            };
+          };
+        };
+      };
+    };
+    put?: never;
+    post?: never;
+    delete?: never;
+    options?: never;
+    head?: never;
+    patch?: never;
+    trace?: never;
+  };
+  '/api/chat': {
+    parameters: {
+      query?: never;
+      header?: never;
+      path?: never;
+      cookie?: never;
+    };
+    get?: never;
+    put?: never;
+    /**
+     * Send a message and get streaming SSE response
+     * @description Send a user message to the chat and receive a streaming Server-Sent Events response
+     */
+    post: {
+      parameters: {
+        query?: never;
+        header?: never;
+        path?: never;
+        cookie?: never;
+      };
+      requestBody?: {
+        content: {
+          'application/json': {
+            /** Format: uuid */
+            id: string;
+            message: {
+              /** Format: uuid */
+              id: string;
+              /** @enum {string} */
+              role: 'user' | 'assistant';
+              parts: {
+                [key: string]: unknown;
+              }[];
+              metadata?: {
+                hidden?: boolean;
+                requestContext?: {
+                  path?: string;
+                };
+              };
+            };
+            selectedChatModel?: string;
+            /** @enum {string} */
+            selectedVisibilityType?: 'public' | 'private';
+            branchId?: number;
+            telemetryMetadata?: {
+              [key: string]: string | number | boolean;
+            };
+          };
+        };
+      };
+      responses: {
+        /** @description SSE stream of chat events */
+        200: {
+          headers: {
+            [name: string]: unknown;
+          };
+          content: {
+            'text/event-stream': unknown;
+          };
+        };
+        /** @description Bad request */
+        400: {
+          headers: {
+            [name: string]: unknown;
+          };
+          content: {
+            'application/json': {
+              error: {
+                type: string;
+                surface: string;
+                message: string;
+              };
+            };
+          };
+        };
+        /** @description Unauthorized */
+        401: {
+          headers: {
+            [name: string]: unknown;
+          };
+          content: {
+            'application/json': {
+              error: {
+                type: string;
+                surface: string;
+                message: string;
+              };
+            };
+          };
+        };
+        /** @description Rate limit exceeded */
+        429: {
+          headers: {
+            [name: string]: unknown;
+          };
+          content: {
+            'application/json': {
+              error: {
+                type: string;
+                surface: string;
+                message: string;
+              };
+            };
+          };
+        };
+      };
+    };
+    /**
+     * Delete a chat
+     * @description Delete a chat by ID
+     */
+    delete: {
+      parameters: {
+        query: {
+          id: string;
+        };
+        header?: never;
+        path?: never;
+        cookie?: never;
+      };
+      requestBody?: never;
+      responses: {
+        /** @description Chat deleted successfully */
+        200: {
+          headers: {
+            [name: string]: unknown;
+          };
+          content: {
+            'application/json': {
+              /** Format: uuid */
+              id: string;
+              title: string;
+              userId: string;
+              /** Format: date-time */
+              createdAt: string;
+              /**
+               * Format: date-time
+               * @description Timestamp of the last message in this chat
+               */
+              lastMessageAt: string;
+              /** @enum {string} */
+              visibility: 'public' | 'private';
+              branchId?: number | null;
+            };
+          };
+        };
+        /** @description Bad request */
+        400: {
+          headers: {
+            [name: string]: unknown;
+          };
+          content: {
+            'application/json': {
+              error: {
+                type: string;
+                surface: string;
+                message: string;
+              };
+            };
+          };
+        };
+        /** @description Unauthorized */
+        401: {
+          headers: {
+            [name: string]: unknown;
+          };
+          content: {
+            'application/json': {
+              error: {
+                type: string;
+                surface: string;
+                message: string;
+              };
+            };
+          };
+        };
+        /** @description Forbidden */
+        403: {
+          headers: {
+            [name: string]: unknown;
+          };
+          content: {
+            'application/json': {
+              error: {
+                type: string;
+                surface: string;
+                message: string;
+              };
+            };
+          };
+        };
+      };
+    };
+    options?: never;
+    head?: never;
+    patch?: never;
+    trace?: never;
+  };
+  '/api/chat/{id}': {
+    parameters: {
+      query?: never;
+      header?: never;
+      path?: never;
+      cookie?: never;
+    };
+    /**
+     * Get chat details and message history
+     * @description Retrieve complete chat details including all messages in the conversation
+     */
+    get: {
+      parameters: {
+        query?: never;
+        header?: never;
+        path: {
+          id: string;
+        };
+        cookie?: never;
+      };
+      requestBody?: never;
+      responses: {
+        /** @description Chat details with message history */
+        200: {
+          headers: {
+            [name: string]: unknown;
+          };
+          content: {
+            'application/json': {
+              /** Format: uuid */
+              id: string;
+              title: string;
+              userId: string;
+              /** Format: date-time */
+              createdAt: string;
+              /**
+               * Format: date-time
+               * @description Timestamp of the last message in this chat
+               */
+              lastMessageAt: string;
+              /** @enum {string} */
+              visibility: 'public' | 'private';
+              branchId?: number | null;
+              messages: {
+                /** Format: uuid */
+                id: string;
+                /** @enum {string} */
+                role: 'user' | 'assistant';
+                parts: (
+                  | {
+                      /** @enum {string} */
+                      type: 'text';
+                      text: string;
+                      /** @enum {string} */
+                      state?: 'done';
+                    }
+                  | {
+                      /** @enum {string} */
+                      type: 'tool-result';
+                      toolCallId: string;
+                      toolName: string;
+                      result: string;
+                    }
+                  | {
+                      /** @enum {string} */
+                      type: 'step-start';
+                    }
+                  | {
+                      type: string;
+                      toolCallId: string;
+                      /** @enum {string} */
+                      state: 'output-available' | 'input-available' | 'input-streaming';
+                      input?: {
+                        [key: string]: unknown;
+                      };
+                      output?: unknown;
+                    }
+                )[];
+                metadata?: {
+                  /** Format: date-time */
+                  createdAt?: string;
+                  hidden?: boolean;
+                  requestContext?: {
+                    path?: string;
+                  };
+                  /** Format: uuid */
+                  compactedTo?: string;
+                  /** Format: uuid */
+                  compactedFrom?: string;
+                };
+                /** @enum {string} */
+                status?: 'pending' | 'completed' | 'interrupted' | 'failed';
+              }[];
+            };
+          };
+        };
+        /** @description Bad request */
+        400: {
+          headers: {
+            [name: string]: unknown;
+          };
+          content: {
+            'application/json': {
+              error: {
+                type: string;
+                surface: string;
+                message: string;
+              };
+            };
+          };
+        };
+        /** @description Unauthorized */
+        401: {
+          headers: {
+            [name: string]: unknown;
+          };
+          content: {
+            'application/json': {
+              error: {
+                type: string;
+                surface: string;
+                message: string;
+              };
+            };
+          };
+        };
+        /** @description Forbidden */
+        403: {
+          headers: {
+            [name: string]: unknown;
+          };
+          content: {
+            'application/json': {
+              error: {
+                type: string;
+                surface: string;
+                message: string;
+              };
+            };
+          };
+        };
+        /** @description Chat not found */
+        404: {
+          headers: {
+            [name: string]: unknown;
+          };
+          content: {
+            'application/json': {
+              error: {
+                type: string;
+                surface: string;
+                message: string;
+              };
+            };
+          };
+        };
+      };
+    };
+    put?: never;
+    post?: never;
+    delete?: never;
+    options?: never;
+    head?: never;
+    patch?: never;
+    trace?: never;
+  };
+  '/api/vote': {
+    parameters: {
+      query?: never;
+      header?: never;
+      path?: never;
+      cookie?: never;
+    };
+    /**
+     * Get votes for a chat
+     * @description Retrieve all votes for messages in a specific chat
+     */
+    get: {
+      parameters: {
+        query: {
+          chatId: string;
+        };
+        header?: never;
+        path?: never;
+        cookie?: never;
+      };
+      requestBody?: never;
+      responses: {
+        /** @description List of votes */
+        200: {
+          headers: {
+            [name: string]: unknown;
+          };
+          content: {
+            'application/json': {
+              /** Format: uuid */
+              chatId: string;
+              /** Format: uuid */
+              messageId: string;
+              isUpvoted: boolean;
+            }[];
+          };
+        };
+        /** @description Bad request */
+        400: {
+          headers: {
+            [name: string]: unknown;
+          };
+          content: {
+            'application/json': {
+              error: {
+                type: string;
+                surface: string;
+                message: string;
+              };
+            };
+          };
+        };
+        /** @description Unauthorized */
+        401: {
+          headers: {
+            [name: string]: unknown;
+          };
+          content: {
+            'application/json': {
+              error: {
+                type: string;
+                surface: string;
+                message: string;
+              };
+            };
+          };
+        };
+        /** @description Forbidden */
+        403: {
+          headers: {
+            [name: string]: unknown;
+          };
+          content: {
+            'application/json': {
+              error: {
+                type: string;
+                surface: string;
+                message: string;
+              };
+            };
+          };
+        };
+        /** @description Chat not found */
+        404: {
+          headers: {
+            [name: string]: unknown;
+          };
+          content: {
+            'application/json': {
+              error: {
+                type: string;
+                surface: string;
+                message: string;
+              };
+            };
+          };
+        };
+      };
+    };
+    put?: never;
+    post?: never;
+    delete?: never;
+    options?: never;
+    head?: never;
+    /**
+     * Vote on a message
+     * @description Add or update a vote on a specific message
+     */
+    patch: {
+      parameters: {
+        query?: never;
+        header?: never;
+        path?: never;
+        cookie?: never;
+      };
+      requestBody?: {
+        content: {
+          'application/json': {
+            /** Format: uuid */
+            chatId: string;
+            /** Format: uuid */
+            messageId: string;
+            /** @enum {string} */
+            type: 'up' | 'down';
+          };
+        };
+      };
+      responses: {
+        /** @description Vote recorded successfully */
+        200: {
+          headers: {
+            [name: string]: unknown;
+          };
+          content?: never;
+        };
+        /** @description Bad request */
+        400: {
+          headers: {
+            [name: string]: unknown;
+          };
+          content: {
+            'application/json': {
+              error: {
+                type: string;
+                surface: string;
+                message: string;
+              };
+            };
+          };
+        };
+        /** @description Unauthorized */
+        401: {
+          headers: {
+            [name: string]: unknown;
+          };
+          content: {
+            'application/json': {
+              error: {
+                type: string;
+                surface: string;
+                message: string;
+              };
+            };
+          };
+        };
+        /** @description Forbidden */
+        403: {
+          headers: {
+            [name: string]: unknown;
+          };
+          content: {
+            'application/json': {
+              error: {
+                type: string;
+                surface: string;
+                message: string;
+              };
+            };
+          };
+        };
+        /** @description Chat not found */
+        404: {
+          headers: {
+            [name: string]: unknown;
+          };
+          content: {
+            'application/json': {
+              error: {
+                type: string;
+                surface: string;
+                message: string;
+              };
+            };
+          };
+        };
+      };
+    };
+    trace?: never;
+  };
+  '/api/chat/{id}/approval': {
+    parameters: {
+      query?: never;
+      header?: never;
+      path?: never;
+      cookie?: never;
+    };
+    get?: never;
+    put?: never;
+    /**
+     * Approve or deny a pending tool execution
+     * @description Submit approval decision for a tool that requires human-in-the-loop confirmation
+     */
+    post: {
+      parameters: {
+        query?: never;
+        header?: never;
+        path: {
+          id: string;
+        };
+        cookie?: never;
+      };
+      requestBody?: {
+        content: {
+          'application/json': {
+            toolUseId: string;
+            approved: boolean;
+            reason?: string;
+            updatedInput?: {
+              [key: string]: unknown;
+            };
+            answers?: {
+              [key: string]: string | string[];
+            };
+          };
+        };
+      };
+      responses: {
+        /** @description Approval processed */
+        200: {
+          headers: {
+            [name: string]: unknown;
+          };
+          content: {
+            'application/json': {
+              success: boolean;
+              toolUseId: string;
+              approved: boolean;
+            };
+          };
+        };
+        /** @description Bad request */
+        400: {
+          headers: {
+            [name: string]: unknown;
+          };
+          content: {
+            'application/json': {
+              error: {
+                type: string;
+                surface: string;
+                message: string;
+              };
+            };
+          };
+        };
+        /** @description Unauthorized */
+        401: {
+          headers: {
+            [name: string]: unknown;
+          };
+          content: {
+            'application/json': {
+              error: {
+                type: string;
+                surface: string;
+                message: string;
+              };
+            };
+          };
+        };
+        /** @description Forbidden — approval belongs to different chat */
+        403: {
+          headers: {
+            [name: string]: unknown;
+          };
+          content: {
+            'application/json': {
+              error: {
+                type: string;
+                surface: string;
+                message: string;
+              };
+            };
+          };
+        };
+        /** @description No pending approval found */
+        404: {
+          headers: {
+            [name: string]: unknown;
+          };
+          content: {
+            'application/json': {
+              error: {
+                type: string;
+                surface: string;
+                message: string;
+              };
+            };
+          };
+        };
+      };
+    };
+    delete?: never;
+    options?: never;
+    head?: never;
+    patch?: never;
+    trace?: never;
+  };
+  '/api/chat/{id}/ui-tool-result': {
+    parameters: {
+      query?: never;
+      header?: never;
+      path?: never;
+      cookie?: never;
+    };
+    get?: never;
+    put?: never;
+    /**
+     * Submit the result of a UI tool (e.g. SQL editor) invocation
+     * @description The frontend executes ui_sql_editor_* tools in the browser and returns the result here. The backend writes the result into the sandbox so the sandbox MCP server unblocks and returns it to the agent.
+     */
+    post: {
+      parameters: {
+        query?: never;
+        header?: never;
+        path: {
+          id: string;
+        };
+        cookie?: never;
+      };
+      requestBody?: {
+        content: {
+          'application/json': {
+            toolUseId: string;
+            output?: string;
+            errorText?: string;
+          };
+        };
+      };
+      responses: {
+        /** @description Result accepted */
+        200: {
+          headers: {
+            [name: string]: unknown;
+          };
+          content: {
+            'application/json': {
+              success: boolean;
+              toolUseId: string;
+            };
+          };
+        };
+        /** @description Bad request */
+        400: {
+          headers: {
+            [name: string]: unknown;
+          };
+          content: {
+            'application/json': {
+              error: {
+                type: string;
+                surface: string;
+                message: string;
+              };
+            };
+          };
+        };
+        /** @description Unauthorized */
+        401: {
+          headers: {
+            [name: string]: unknown;
+          };
+          content: {
+            'application/json': {
+              error: {
+                type: string;
+                surface: string;
+                message: string;
+              };
+            };
+          };
+        };
+        /** @description Forbidden — request belongs to a different chat */
+        403: {
+          headers: {
+            [name: string]: unknown;
+          };
+          content: {
+            'application/json': {
+              error: {
+                type: string;
+                surface: string;
+                message: string;
+              };
+            };
+          };
+        };
+        /** @description No pending UI tool request found */
+        404: {
+          headers: {
+            [name: string]: unknown;
+          };
+          content: {
+            'application/json': {
+              error: {
+                type: string;
+                surface: string;
+                message: string;
+              };
+            };
+          };
+        };
+      };
+    };
+    delete?: never;
+    options?: never;
+    head?: never;
+    patch?: never;
+    trace?: never;
+  };
+  '/api/usage': {
+    parameters: {
+      query?: never;
+      header?: never;
+      path?: never;
+      cookie?: never;
+    };
+    /**
+     * Get rate limit usage information
+     * @description Returns the current rate limit usage for the authenticated user in the current project.
+     */
+    get: {
+      parameters: {
+        query?: never;
+        header?: never;
+        path?: never;
+        cookie?: never;
+      };
+      requestBody?: never;
+      responses: {
+        /** @description Rate limit usage information */
+        200: {
+          headers: {
+            [name: string]: unknown;
+          };
+          content: {
+            'application/json': {
+              messagesUsed: number;
+              messagesLimit: number;
+              /** Format: date-time */
+              resetDate: string;
+            };
+          };
+        };
+        /** @description Unauthorized */
+        401: {
+          headers: {
+            [name: string]: unknown;
+          };
+          content: {
+            'application/json': {
+              error: {
+                type: string;
+                surface: string;
+                message: string;
+              };
+            };
+          };
+        };
+        /** @description Internal server error */
+        500: {
+          headers: {
+            [name: string]: unknown;
+          };
+          content: {
+            'application/json': {
+              error: {
+                type: string;
+                surface: string;
+                message: string;
+              };
+            };
+          };
+        };
+      };
+    };
+    put?: never;
+    post?: never;
+    delete?: never;
+    options?: never;
+    head?: never;
+    patch?: never;
+    trace?: never;
+  };
+};
+
+type GetHistoryQuery = OpenapiQueryType<paths['/api/history']['get']>;
+type GetVotesQuery = OpenapiQueryType<paths['/api/vote']['get']>;
+type GetChatPath = OpenapiPathType<paths['/api/chat/{id}']['get']>;
+type ChatRequest = OpenapiBodyType<paths['/api/chat']['post']>;
+type VoteRequest = OpenapiBodyType<paths['/api/vote']['patch']>;
+type ApprovalBody = OpenapiBodyType<paths['/api/chat/{id}/approval']['post']>;
+type UsageResponse = OpenapiReturnType<paths['/api/usage']['get']>;
+
+declare function assert<T>(value: T | undefined | null, message: string): asserts value is T;
+
+declare const delay: (timeout: number, signal?: AbortSignal) => Promise<unknown>;
+
+type PollResult<T> = {
+    data: T;
+    callCount: number;
+};
+type PollErrorType = 'PollPredicateError' | 'PollTimeoutError' | 'PollPollTimeoutError';
+declare class PollException<T> extends Error {
+    result: PollResult<T>;
+    constructor(type: PollErrorType, result: PollResult<T>);
+}
+type Options<T> = {
+    pollFn: (abortSignal?: AbortSignal) => Promise<T>;
+    isDone: (result: T) => boolean;
+    isFailed?: (result: T) => boolean;
+    interval: number;
+    abortSignal?: AbortSignal;
+    maxAttempts?: number;
+};
+declare const poll: <T>({ pollFn, interval, isDone, isFailed, abortSignal, maxAttempts, }: Options<T>) => Promise<PollResult<T>>;
+
+declare const generateUUID: () => `${string}-${string}-${string}-${string}-${string}`;
+
+/**
+ * Executes an asynchronous callback function on an array of items in series (one at a time).
+ * It behaves similarly to Promise.all(), failing on the first rejected promise.
+ * The order of the results matches the order of the promises.
+ */
+declare const series: <T, R>(options: Omit<ConcurrentOptions<T, R>, "concurrency">) => Promise<R[]>;
+
+type ServiceUrls = Partial<Record<ServiceId, (url: string) => string | undefined | null>>;
+
+type ApiClientOptions = {
+    token: {
+        storageApi: string;
+        managementApi?: string;
+    };
+    assetsBaseUrl: string;
+    statusBaseUrl: string;
+    metastoreBaseUrl: string;
+    storageMiddlewares?: MiddlewareFn[];
+    clientServiceUrls?: ServiceUrls;
+} & BaseClientOptions;
+declare const createClients: ({ baseUrl, token, callbacks, assetsBaseUrl, statusBaseUrl, metastoreBaseUrl, clientServiceUrls, storageMiddlewares, }: ApiClientOptions) => Promise<{
+    sdk: {
+        tag: {
+            getTags: (signal?: AbortSignal) => Promise<TagWithBindings[]>;
+            getTagsByObjectId: (objectId: KeboolaObjectId, signal?: AbortSignal) => Promise<TagWithBindings[]>;
+            createTag: (data: TagData, meta?: CreateMetaObjectMetaDataInput) => Promise<MetaObject<TagData, false>>;
+            updateTag: (tagUUID: string, data: TagData, meta?: UpdateMetaObjectMetaDataInput) => Promise<MetaObject<TagData, false>>;
+            deleteTag: (tagUUID: string) => Promise<void>;
+            assignTags: (tagUUIDs: string[], objectId: KeboolaObjectId, meta?: CreateMetaObjectMetaDataInput) => Promise<void>;
+            unassignTags: (tagUUIDs: string[], objectID: KeboolaObjectId) => Promise<void>;
+            unassignAllTags: (objectID: KeboolaObjectId, signal?: AbortSignal) => Promise<void>;
+            createAndAssignTag: (data: TagData, objectId: KeboolaObjectId, meta?: CreateMetaObjectMetaDataInput) => Promise<MetaObject<TagData, false>>;
+        };
+        storage: {
+            createTable: (bucketId: string, body: CreateTableAsyncBody, options?: {
+                interval?: number;
+                maxAttempts?: number;
+                abortSignal?: AbortSignal;
+            }) => Promise<TableCreateJob>;
+            importFromFile: (tableId: string, body: TableImportAsyncBody, options?: {
+                interval?: number;
+                maxAttempts?: number;
+                abortSignal?: AbortSignal;
+            }) => Promise<TableImportJob>;
+            exportToFile: (tableId: string, body?: TableExportAsyncBody, options?: {
+                interval?: number;
+                maxAttempts?: number;
+                abortSignal?: AbortSignal;
+            }) => Promise<TableExportJob>;
+        };
+    };
+    vault: {
+        createVariable: (body: CreateVariableBody, signal?: AbortSignal) => Promise<{
+            key: string;
+            value: string;
+            flags: ("encrypted" | "oauthCredentialsId")[];
+            group?: string;
+            attributes: {
+                branchId?: string;
+            } & {
+                [key: string]: string;
+            };
+        } & {
+            hash?: string;
+        }>;
+        deleteVariable: (hash: DeleteVariablePath["hash"], signal?: AbortSignal) => Promise<void>;
+        getProjectWideVariables: (signal?: AbortSignal) => Promise<VariableWithHash[]>;
+        getVariables: (query: GetVariablesQuery, signal?: AbortSignal) => Promise<VariableWithHash[]>;
+        getVariablesByBranchId: (branchId: GetVariablesByBranchId["branchId"], signal?: AbortSignal) => Promise<VariableWithHash[]>;
+    };
+    dataScience: {
+        getAppRuns: (appId: GetDataAppRunsPath["appId"], query?: GetDataAppRunsQuery, signal?: AbortSignal) => Promise<{
+            state: "failed" | "starting" | "running" | "finished";
+            id: string;
+            appId: string;
+            createdAt?: string | null;
+            startedAt?: string | null;
+            stoppedAt?: string | null;
+            startupLogs?: string | null;
+            runtimeSize?: string | null;
+            configVersion?: string | null;
+        }[]>;
+        getAppRun: (appId: GetDataAppRunPath["appId"], runId: GetDataAppRunPath["runId"], signal?: AbortSignal) => Promise<{
+            state: "failed" | "starting" | "running" | "finished";
+            id: string;
+            appId: string;
+            createdAt?: string | null;
+            startedAt?: string | null;
+            stoppedAt?: string | null;
+            startupLogs?: string | null;
+            runtimeSize?: string | null;
+            configVersion?: string | null;
+        }>;
+        getAppLogsDownload: (id: GetDataAppLogsDownloadPath["appId"], signal?: AbortSignal) => Promise<{
+            logs: string;
+            fileName: string;
+        }>;
+        getAppLogsTail: (id: GetDataAppLogsTailPath["appId"], { query, signal }?: {
+            query?: GetDataAppLogsTailQuery;
+            signal?: AbortSignal;
+        }) => Promise<{
+            entries: LogEntry[];
+            nextLogTimestamp: string | null;
+        }>;
+        getApps: (query: GetAppsQuery, signal?: AbortSignal) => Promise<{
+            id: string;
+            type?: string | null;
+            projectId: string;
+            componentId: string;
+            branchId: string | null;
+            configId: string;
+            configVersion: string;
+            state: "created" | "starting" | "restarting" | "running" | "stopping" | "stopped" | "deleting" | "deleted";
+            desiredState: "running" | "stopped" | "deleted";
+            lastRequestTimestamp: string | null;
+            lastStartTimestamp?: string | null;
+            url?: string | null;
+            autoSuspendAfterSeconds?: number;
+            autoRestartEnabled?: boolean;
+            size?: string | null;
+            provisioningStrategy: "jobQueue" | "operator";
+        }[]>;
+        getApp: (appId: GetDataAppPath["appId"], signal?: AbortSignal) => Promise<{
+            id: string;
+            type?: string | null;
+            projectId: string;
+            componentId: string;
+            branchId: string | null;
+            configId: string;
+            configVersion: string;
+            state: "created" | "starting" | "restarting" | "running" | "stopping" | "stopped" | "deleting" | "deleted";
+            desiredState: "running" | "stopped" | "deleted";
+            lastRequestTimestamp: string | null;
+            lastStartTimestamp?: string | null;
+            url?: string | null;
+            autoSuspendAfterSeconds?: number;
+            autoRestartEnabled?: boolean;
+            size?: string | null;
+            provisioningStrategy: "jobQueue" | "operator";
+        }>;
+        createApp: (body: CreateDataAppBody, signal?: AbortSignal) => Promise<{
+            id: string;
+            type?: string | null;
+            projectId: string;
+            componentId: string;
+            branchId: string | null;
+            configId: string;
+            configVersion: string;
+            state: "created" | "starting" | "restarting" | "running" | "stopping" | "stopped" | "deleting" | "deleted";
+            desiredState: "running" | "stopped" | "deleted";
+            lastRequestTimestamp: string | null;
+            lastStartTimestamp?: string | null;
+            url?: string | null;
+            autoSuspendAfterSeconds?: number;
+            autoRestartEnabled?: boolean;
+            size?: string | null;
+            provisioningStrategy: "jobQueue" | "operator";
+        }>;
+        patchApp: (appId: PatchDataAppPath["appId"], body: PatchDataAppBody, signal?: AbortSignal) => Promise<{
+            id: string;
+            type?: string | null;
+            projectId: string;
+            componentId: string;
+            branchId: string | null;
+            configId: string;
+            configVersion: string;
+            state: "created" | "starting" | "restarting" | "running" | "stopping" | "stopped" | "deleting" | "deleted";
+            desiredState: "running" | "stopped" | "deleted";
+            lastRequestTimestamp: string | null;
+            lastStartTimestamp?: string | null;
+            url?: string | null;
+            autoSuspendAfterSeconds?: number;
+            autoRestartEnabled?: boolean;
+            size?: string | null;
+            provisioningStrategy: "jobQueue" | "operator";
+        }>;
+        deleteApp: (appId: DeleteDataAppPath["appId"], signal?: AbortSignal) => Promise<ApiResponse<unknown>>;
+        getAppPassword: (appId: GetDataAppPasswordPath["appId"], signal?: AbortSignal) => Promise<{
+            password?: string;
+        }>;
+        resetAppPassword: (appId: ResetDataAppPasswordPath["appId"], signal?: AbortSignal) => Promise<{
+            id: string;
+            type?: string | null;
+            projectId: string;
+            componentId: string;
+            branchId: string | null;
+            configId: string;
+            configVersion: string;
+            state: "created" | "starting" | "restarting" | "running" | "stopping" | "stopped" | "deleting" | "deleted";
+            desiredState: "running" | "stopped" | "deleted";
+            lastRequestTimestamp: string | null;
+            lastStartTimestamp?: string | null;
+            url?: string | null;
+            autoSuspendAfterSeconds?: number;
+            autoRestartEnabled?: boolean;
+            size?: string | null;
+            provisioningStrategy: "jobQueue" | "operator";
+        }>;
+        getRuntimes: (signal?: AbortSignal) => Promise<{
+            description: string;
+            type: string;
+            isTypeDefault: boolean;
+            releaseDate: string;
+            endOfLifeDate?: string | null;
+            imageName?: string | null;
+            imageTag?: string | null;
+            transformationComponentId?: string | null;
+            transformationComponentTag?: string | null;
+            sandboxImageName?: string | null;
+            sandboxImageTag?: string | null;
+        }[]>;
+        getSandbox: (appId: GetSandboxPath["appId"], signal?: AbortSignal) => Promise<{
+            id?: string;
+            projectId?: string;
+            tokenId?: string;
+            branchId?: string | null;
+            configurationId?: string;
+            physicalId?: string;
+            type?: string;
+            active?: boolean;
+            createdTimestamp?: string;
+            startTimestamp?: string;
+            updatedTimestamp?: string;
+            persistentStorage?: {
+                pvcName?: string | null;
+                k8sManifest?: string | null;
+                isEnabled?: boolean;
+                ready?: boolean | null;
+                k8sStorageClassName?: string | null;
+            };
+            shared?: boolean;
+            componentId?: string;
+            configurationVersion?: string;
+            size?: string | null;
+            lastAutosaveTimestamp?: string | null;
+            expirationTimestamp?: string | null;
+            autoSuspendAfterSeconds?: number;
+            expirationAfterHours?: number;
+            user?: string | null;
+            url?: string | null;
+            password?: string | null;
+            autosaveTokenId?: string | null;
+            host?: string | null;
+            imageVersion?: string | null;
+            packages?: string[] | null;
+            sizeParameters?: unknown;
+            stagingWorkspaceId?: unknown;
+            stagingWorkspaceType?: unknown;
+            workspaceDetails?: unknown;
+            databricks?: unknown;
+            credentials?: unknown;
+        }>;
+    };
+    encryption: {
+        encryptSecrets: <T extends Record<string, unknown>>(data: EncryptQuery & {
+            data: T;
+        }, signal?: AbortSignal) => Promise<T>;
+        encrypt: (data: EncryptQuery & {
+            data: string;
+        }, signal?: AbortSignal) => Promise<string>;
+    };
+    editor: {
+        createSession: (body: CreateSqlSessionBody) => Promise<{
+            id: string;
+            createdAt: string;
+            updatedAt: string;
+            status: string;
+            userId: string;
+            branchId: string;
+            componentId: string;
+            configurationId: string;
+            workspaceSchema: string;
+            workspaceDatabase: string;
+            workspaceId: string;
+            workspaceCreateJobId: string | null;
+            workspaceLoadJobs: {
+                id: string;
+                type: string;
+            }[];
+            snowflakePrivateKey?: string;
+            readOnlyStorageAccess?: boolean;
+            backendType?: "snowflake" | "bigquery" | null;
+            backendSize?: string | null;
+            lastError?: string | null;
+            shared: boolean;
+            workspaceLoginType?: "snowflake-person-sso" | "snowflake-legacy-service" | "snowflake-person-keypair" | "snowflake-service-keypair" | "default" | null;
+            lastLoadedAt?: string | null;
+        }>;
+        getSession: ({ id }: GetSqlSessionPath, signal?: AbortSignal) => Promise<{
+            id: string;
+            createdAt: string;
+            updatedAt: string;
+            status: string;
+            userId: string;
+            branchId: string;
+            componentId: string;
+            configurationId: string;
+            workspaceSchema: string;
+            workspaceDatabase: string;
+            workspaceId: string;
+            workspaceCreateJobId: string | null;
+            workspaceLoadJobs: {
+                id: string;
+                type: string;
+            }[];
+            snowflakePrivateKey?: string;
+            readOnlyStorageAccess?: boolean;
+            backendType?: "snowflake" | "bigquery" | null;
+            backendSize?: string | null;
+            lastError?: string | null;
+            shared: boolean;
+            workspaceLoginType?: "snowflake-person-sso" | "snowflake-legacy-service" | "snowflake-person-keypair" | "snowflake-service-keypair" | "default" | null;
+            lastLoadedAt?: string | null;
+        }>;
+        getSessions: (query: GetSqlSessionsQuery, signal?: AbortSignal) => Promise<{
+            id: string;
+            createdAt: string;
+            updatedAt: string;
+            status: string;
+            userId: string;
+            branchId: string;
+            componentId: string;
+            configurationId: string;
+            workspaceSchema: string;
+            workspaceDatabase: string;
+            workspaceId: string;
+            workspaceCreateJobId: string | null;
+            workspaceLoadJobs: {
+                id: string;
+                type: string;
+            }[];
+            snowflakePrivateKey?: string;
+            readOnlyStorageAccess?: boolean;
+            backendType?: "snowflake" | "bigquery" | null;
+            backendSize?: string | null;
+            lastError?: string | null;
+            shared: boolean;
+            workspaceLoginType?: "snowflake-person-sso" | "snowflake-legacy-service" | "snowflake-person-keypair" | "snowflake-service-keypair" | "default" | null;
+            lastLoadedAt?: string | null;
+        }[]>;
+        getSessionSchema: ({ id, onlyWorkspaceSchema, loadTables, }: GetSqlSessionSchemaPath & GetSqlSessionSchemaQuery, signal?: AbortSignal) => Promise<{
+            databases: components["schemas"]["Catalog"][];
+        }>;
+        createQueryJob: ({ id }: PostSqlRunQueryPath, body: PostSqlRunQueryBody) => Promise<{
+            queryJobId: string;
+            url: string;
+        }>;
+        tablePreview: ({ id }: PostSqlTablePreviewPath, body: PostSqlTablePreviewBody) => Promise<{
+            queryJobId: string;
+            url: string;
+        }>;
+        tableDefinition: ({ id, ...query }: GetSqlSessionTableDdlPath & GetSqlSessionTableDdlQuery, signal?: AbortSignal) => Promise<{
+            ddl: string;
+        }>;
+        load: ({ id }: PostSqlSessionLoadPath, body: PostSqlSessionLoadBody) => Promise<{
+            id: string;
+            createdAt: string;
+            updatedAt: string;
+            status: string;
+            userId: string;
+            branchId: string;
+            componentId: string;
+            configurationId: string;
+            workspaceSchema: string;
+            workspaceDatabase: string;
+            workspaceId: string;
+            workspaceCreateJobId: string | null;
+            workspaceLoadJobs: {
+                id: string;
+                type: string;
+            }[];
+            snowflakePrivateKey?: string;
+            readOnlyStorageAccess?: boolean;
+            backendType?: "snowflake" | "bigquery" | null;
+            backendSize?: string | null;
+            lastError?: string | null;
+            shared: boolean;
+            workspaceLoginType?: "snowflake-person-sso" | "snowflake-legacy-service" | "snowflake-person-keypair" | "snowflake-service-keypair" | "default" | null;
+            lastLoadedAt?: string | null;
+        }>;
+        unload: ({ id }: PostSqlSessionUnloadPath, body?: PostSqlSessionUnloadBody) => Promise<{
+            id: string;
+            createdAt: string;
+            updatedAt: string;
+            status: string;
+            userId: string;
+            branchId: string;
+            componentId: string;
+            configurationId: string;
+            workspaceSchema: string;
+            workspaceDatabase: string;
+            workspaceId: string;
+            workspaceCreateJobId: string | null;
+            workspaceLoadJobs: {
+                id: string;
+                type: string;
+            }[];
+            snowflakePrivateKey?: string;
+            readOnlyStorageAccess?: boolean;
+            backendType?: "snowflake" | "bigquery" | null;
+            backendSize?: string | null;
+            lastError?: string | null;
+            shared: boolean;
+            workspaceLoginType?: "snowflake-person-sso" | "snowflake-legacy-service" | "snowflake-person-keypair" | "snowflake-service-keypair" | "default" | null;
+            lastLoadedAt?: string | null;
+        }>;
+        getWorkspacePassword: (id: string, signal?: AbortSignal) => Promise<{
+            username: string;
+            password: string;
+            host: string;
+            database: string;
+            schema: string;
+            warehouse: string;
+        }>;
+        resetWorkspacePassword: (id: string) => Promise<{
+            username: string;
+            password: string;
+            host: string;
+            database: string;
+            schema: string;
+            warehouse: string;
+        }>;
+        getSessionCredentials: (id: string, signal?: AbortSignal) => Promise<{
+            [key: string]: unknown;
+        }>;
+    };
+    syncActions: {
+        enrollMFA: ({ email, ...rest }: EnrollMFAInput, signal?: AbortSignal) => Promise<Record<string, never>>;
+        gitRepository: {
+            getDataAppPublicGitRepository: ({ repositoryUrl, ...other }: GetDataAppPublicGitRepositoryInput, signal?: AbortSignal) => Promise<{
+                repository: {
+                    url: string;
+                };
+                branches: {
+                    sha: string;
+                    date: string;
+                    comment: string;
+                    branch: string;
+                    author: {
+                        name: string;
+                        email: string;
+                    };
+                }[];
+            }>;
+            getDataAppPasswordPrivateGitRepository: ({ repositoryUrl, username, password, ...other }: GetDataAppPasswordPrivateGitRepositoryInput, signal?: AbortSignal) => Promise<{
+                repository: {
+                    url: string;
+                };
+                branches: {
+                    sha: string;
+                    date: string;
+                    comment: string;
+                    branch: string;
+                    author: {
+                        name: string;
+                        email: string;
+                    };
+                }[];
+            }>;
+            getDataAppSSHKeyPrivateGitRepository: ({ repositoryUrl, username, sshKey, ...other }: GetDataAppSSHKeyPrivateGitRepositoryInput, signal?: AbortSignal) => Promise<{
+                repository: {
+                    url: string;
+                };
+                branches: {
+                    sha: string;
+                    date: string;
+                    comment: string;
+                    branch: string;
+                    author: {
+                        name: string;
+                        email: string;
+                    };
+                }[];
+            }>;
+            getPublicGitRepository: ({ repositoryUrl, componentId, ...other }: GetPublicGitRepositoryInput, signal?: AbortSignal) => Promise<{
+                repository: {
+                    url: string;
+                };
+                branches: {
+                    sha: string;
+                    date: string;
+                    comment: string;
+                    branch: string;
+                    author: {
+                        name: string;
+                        email: string;
+                    };
+                }[];
+            }>;
+            getPrivateGitRepository: ({ repositoryUrl, username, password, componentId, ...other }: GetGitPrivateRepositoryInput, signal?: AbortSignal) => Promise<{
+                repository: {
+                    url: string;
+                };
+                branches: {
+                    sha: string;
+                    date: string;
+                    comment: string;
+                    branch: string;
+                    author: {
+                        name: string;
+                        email: string;
+                    };
+                }[];
+            }>;
+        };
+    };
+    telemetry: {
+        provisioning: {
+            createCredentials: (body: CreateCredentialsBody, signal?: AbortSignal) => Promise<WorkspaceData>;
+        };
+    };
+    queryService: {
+        createQueryJob: (branchId: PostQueryPath["branchId"], workspaceId: PostQueryPath["workspaceId"], body: PostQueryBody) => Promise<{
+            queryJobId: string;
+            sessionId?: string;
+        }>;
+        cancelQueryJob: (queryJobId: PostCancelQueryJobPath["queryJobId"]) => Promise<{
+            queryJobId: string;
+        }>;
+        getQueryJob: (queryJobId: GetQueryJobPath["queryJobId"]) => Promise<{
+            actorType: components$1["schemas"]["models.ActorType"];
+            canceledAt?: string;
+            cancellationReason?: string;
+            changedAt: string;
+            createdAt: string;
+            expiration?: string;
+            queryJobId: string;
+            statements: components$1["schemas"]["handlers.Statement"][];
+            status: components$1["schemas"]["models.JobState"];
+        }>;
+        getQueryResults: (queryJobId: GetQueryResultsPath["queryJobId"], statementId: GetQueryResultsPath["statementId"], query?: GetQueryResutsQuery) => Promise<{
+            columns?: components$1["schemas"]["handlers.Column"][];
+            data?: string[][];
+            message?: string;
+            numberOfRows?: number;
+            rowsAffected?: number;
+            status: components$1["schemas"]["models.StatementState"];
+        }>;
+        getQueryHistory: (branchId: GetQueriesPath["branchId"], workspaceId: GetQueriesPath["workspaceId"], query?: GetQueriesHistoryQuery) => Promise<{
+            statements: components$1["schemas"]["handlers.StatementWithWorkspaceInfo"][];
+        }>;
+        exportResults: (queryJobId: GetQueryResultsPath["queryJobId"], statementId: GetQueryResultsPath["statementId"], query: GetExportResultsQuery, signal?: AbortSignal) => Promise<ExportResultsResponse>;
+    };
+    queue: {
+        getJob: (jobId: GetQueueJobPath["jobId"], signal?: AbortSignal) => Promise<{
+            id: string;
+            runId: string;
+            branchId?: string;
+            project: {
+                id: string;
+            };
+            token: {
+                id?: string;
+                description?: string;
+            };
+            status: components$2["schemas"]["JobStatus"];
+            desiredStatus?: "processing" | "terminating" | null;
+            component: string;
+            mode: "run" | "debug";
+            tag?: string | null;
+            config?: string | null;
+            configRow?: string | null;
+            configData?: Record<string, never> | null;
+            result?: {
+                images?: {
+                    digests?: string[];
+                    id?: string;
+                }[];
+                configVersion?: number;
+                message?: string;
+            } | null;
+            createdTime: string;
+            startTime?: string | null;
+            endTime?: string | null;
+            delayedStartTime?: string | null;
+            durationSeconds?: number | null;
+            isFinished: boolean;
+            url: string;
+            variableValuesId?: string | null;
+            variableValuesData?: {
+                values?: {
+                    name?: string;
+                    value?: string;
+                }[];
+            } | null;
+            backend?: {
+                type?: string;
+                containerType?: string;
+                context?: string;
+            } | null;
+            metrics?: {
+                storage?: {
+                    inputTablesBytesSum?: number;
+                    outputTablesBytesSum?: number;
+                };
+                backend?: {
+                    type?: string;
+                    containerType?: string;
+                    context?: string;
+                };
+            } | null;
+            type?: components$2["schemas"]["JobType"];
+            orchestrationTaskId?: string | null;
+            previousJobId?: string | null;
+            onlyOrchestrationTaskIds?: string[] | null;
+        }>;
+        searchJobs: (query?: SearchJobsQuery, signal?: AbortSignal) => Promise<{
+            id: string;
+            runId: string;
+            branchId?: string;
+            project: {
+                id: string;
+            };
+            token: {
+                id?: string;
+                description?: string;
+            };
+            status: components$2["schemas"]["JobStatus"];
+            desiredStatus?: "processing" | "terminating" | null;
+            component: string;
+            mode: "run" | "debug";
+            tag?: string | null;
+            config?: string | null;
+            configRow?: string | null;
+            configData?: Record<string, never> | null;
+            result?: {
+                images?: {
+                    digests?: string[];
+                    id?: string;
+                }[];
+                configVersion?: number;
+                message?: string;
+            } | null;
+            createdTime: string;
+            startTime?: string | null;
+            endTime?: string | null;
+            delayedStartTime?: string | null;
+            durationSeconds?: number | null;
+            isFinished: boolean;
+            url: string;
+            variableValuesId?: string | null;
+            variableValuesData?: {
+                values?: {
+                    name?: string;
+                    value?: string;
+                }[];
+            } | null;
+            backend?: {
+                type?: string;
+                containerType?: string;
+                context?: string;
+            } | null;
+            metrics?: {
+                storage?: {
+                    inputTablesBytesSum?: number;
+                    outputTablesBytesSum?: number;
+                };
+                backend?: {
+                    type?: string;
+                    containerType?: string;
+                    context?: string;
+                };
+            } | null;
+            type?: components$2["schemas"]["JobType"];
+            orchestrationTaskId?: string | null;
+            previousJobId?: string | null;
+            onlyOrchestrationTaskIds?: string[] | null;
+        }[]>;
+    };
+    chat: {
+        getHistory: (params?: GetHistoryQuery$1) => Promise<{
+            chats: components$3["schemas"]["Chat"][];
+            hasMore: boolean;
+        }>;
+        getChat: (chatId: GetChatPath$1["id"], signal?: AbortSignal) => Promise<{
+            id: string;
+            title: string;
+            userId: string;
+            createdAt: string;
+            lastMessageAt: string;
+            visibility: "public" | "private";
+            branchId?: number | null;
+            messages: components$3["schemas"]["Message"][];
+        }>;
+        deleteChat: (chatId: string) => Promise<{
+            id: string;
+            title: string;
+            userId: string;
+            createdAt: string;
+            lastMessageAt: string;
+            visibility: "public" | "private";
+            branchId?: number | null;
+        }>;
+        createChat: (request: ChatRequest$1) => Promise<Response>;
+        getVotes: (chatId: GetVotesQuery$1["chatId"]) => Promise<{
+            chatId: string;
+            messageId: string;
+            isUpvoted: boolean;
+        }[]>;
+        submitVote: (params: VoteRequest$1) => Promise<void>;
+        getUsage: (signal?: AbortSignal) => Promise<UsageResponse$1>;
+        getSuggestions: (request: SuggestionsRequestBody, signal?: AbortSignal) => Promise<SuggestionsApiResponse>;
+        getAgentSettings: (signal?: AbortSignal) => Promise<AgentSettings>;
+        updateAgentSettings: (request: UpdateAgentSettingsRequest, signal?: AbortSignal) => Promise<AgentSettings>;
+        getUserAgentSettings: (signal?: AbortSignal) => Promise<UserAgentSettings>;
+        updateUserAgentSettings: (request: UpdateUserAgentSettingsRequest, signal?: AbortSignal) => Promise<UserAgentSettings>;
+        getToolsList: (signal?: AbortSignal) => Promise<ToolsListResponse>;
+    };
+    ai: {
+        describeConfigurationVersion: (body: DescribeConfigurationVersionBody) => Promise<{
+            description: string;
+            correlationId: string;
+        }>;
+        describeConfigurationMerge: (body: DescribeConfigurationMergeBody) => Promise<{
+            description: string;
+            correlationId: string;
+        }>;
+        explainError: (body: ExplainErrorBody) => Promise<{
+            answer: string;
+            correlationId: string;
+        }>;
+        describeConfiguration: (body: DescribeConfigurationBody) => Promise<{
+            description: string;
+            correlationId: string;
+        }>;
+        suggestComponent: (body: SuggestComponentBody) => Promise<{
+            components: components$4["schemas"]["SuggestedComponent"][];
+            correlationId: string;
+        }>;
+        feedback: (body: FeedbackBody) => Promise<{
+            error: string;
+            code: number;
+            status: "error";
+            exceptionId?: string;
+        }>;
+    };
+    import: {
+        uploadFile: (file: File, params?: UploadFileParams, signal?: AbortSignal) => Promise<UploadedFile>;
+    };
+    kaiAgent: {
+        getHistory: (params?: GetHistoryQuery) => Promise<{
+            chats: {
+                id: string;
+                title: string;
+                userId: string;
+                createdAt: string;
+                lastMessageAt: string;
+                visibility: "public" | "private";
+                branchId?: number | null;
+            }[];
+            hasMore: boolean;
+        }>;
+        getChat: (chatId: GetChatPath["id"], signal?: AbortSignal) => Promise<{
+            id: string;
+            title: string;
+            userId: string;
+            createdAt: string;
+            lastMessageAt: string;
+            visibility: "public" | "private";
+            branchId?: number | null;
+            messages: {
+                id: string;
+                role: "user" | "assistant";
+                parts: ({
+                    type: "text";
+                    text: string;
+                    state?: "done";
+                } | {
+                    type: "tool-result";
+                    toolCallId: string;
+                    toolName: string;
+                    result: string;
+                } | {
+                    type: "step-start";
+                } | {
+                    type: string;
+                    toolCallId: string;
+                    state: "output-available" | "input-available" | "input-streaming";
+                    input?: {
+                        [key: string]: unknown;
+                    };
+                    output?: unknown;
+                })[];
+                metadata?: {
+                    createdAt?: string;
+                    hidden?: boolean;
+                    requestContext?: {
+                        path?: string;
+                    };
+                    compactedTo?: string;
+                    compactedFrom?: string;
+                };
+                status?: "pending" | "completed" | "interrupted" | "failed";
+            }[];
+        }>;
+        deleteChat: (chatId: string) => Promise<{
+            id: string;
+            title: string;
+            userId: string;
+            createdAt: string;
+            lastMessageAt: string;
+            visibility: "public" | "private";
+            branchId?: number | null;
+        }>;
+        createChat: (request: ChatRequest) => Promise<Response>;
+        getVotes: (chatId: GetVotesQuery["chatId"]) => Promise<{
+            chatId: string;
+            messageId: string;
+            isUpvoted: boolean;
+        }[]>;
+        submitVote: (params: VoteRequest) => Promise<void>;
+        getUsage: (signal?: AbortSignal) => Promise<UsageResponse>;
+        approveToolCall: (chatId: string, body: ApprovalBody) => Promise<void>;
+        submitToolOutput: (chatId: string, body: {
+            toolUseId: string;
+            output?: string;
+            errorText?: string;
+        }) => Promise<void>;
+        getSuggestions: (request: SuggestionsRequestBody, signal?: AbortSignal) => Promise<SuggestionsApiResponse>;
+        getAgentSettings: (signal?: AbortSignal) => Promise<{
+            projectId: string;
+            customInstructions: string | null;
+            createdAt: string;
+            updatedAt: string;
+        }>;
+        updateAgentSettings: (request: {
+            customInstructions?: string | null;
+        }, signal?: AbortSignal) => Promise<{
+            projectId: string;
+            customInstructions: string | null;
+            createdAt: string;
+            updatedAt: string;
+        }>;
+        getUserAgentSettings: (signal?: AbortSignal) => Promise<{
+            projectId: string;
+            userId: string;
+            customInstructions: string | null;
+            toolPermissions: Record<string, "always_allow" | "always_ask" | "blocked"> | null;
+            createdAt: string;
+            updatedAt: string;
+        }>;
+        updateUserAgentSettings: (request: {
+            customInstructions?: string | null;
+            toolPermissions?: Record<string, zod.infer<zod.ZodEnum<{
+                always_allow: "always_allow";
+                always_ask: "always_ask";
+                blocked: "blocked";
+            }>>> | null;
+        }, signal?: AbortSignal) => Promise<{
+            projectId: string;
+            userId: string;
+            customInstructions: string | null;
+            toolPermissions: Record<string, "always_allow" | "always_ask" | "blocked"> | null;
+            createdAt: string;
+            updatedAt: string;
+        }>;
+        getToolsList: (signal?: AbortSignal) => Promise<{
+            tools: {
+                name: string;
+                description: string;
+                readOnly: boolean;
+            }[];
+        }>;
+        chatStreamUrl: string;
+    };
+    stack: {
+        services: Service[];
+        features: string[];
+        components: StackComponent[];
+        hasFeature: (...feature: string[]) => boolean;
+        getServiceUrl: (serviceId: ServiceId) => string | null;
+        hasService: (serviceId: ServiceId) => boolean;
+        getComponent: (componentId: string) => StackComponent | null;
+        hasComponent: (...componentId: string[]) => boolean;
+        api: string;
+        documentation: string;
+        host: string;
+        revision: string;
+        stack: string;
+        urlTemplates: {
+            orchestrationJob: string;
+        };
+        version: string;
+    };
+    project: {
+        hasFeature: (...feature: string[]) => boolean;
+        hasAdminFeature: (...feature: string[]) => boolean;
+        hasBackend: (backend: Backend) => boolean;
+        sapiToken: StorageToken;
+    };
+    serviceMeta: {
+        clientName: string;
+        serviceId: ServiceId;
+        isAvailable: boolean;
+    }[];
+    storage: {
+        buckets: {
+            getBuckets: (query?: GetBucketsQuery, signal?: AbortSignal) => Promise<Bucket[]>;
+            getBucket: (id: string, signal?: AbortSignal) => Promise<BucketDetail>;
+            createBucket: (body: CreateBucketBody) => Promise<BucketDetail>;
+            updateBucket: (id: string, body: UpdateBucketBody) => Promise<BucketDetail>;
+            deleteBucket: (id: string) => Promise<void>;
+            deleteBucketAsync: (id: string, options?: {
+                force?: boolean;
+            }) => Promise<{
+                id: number;
+                tableId: string | null;
+                runId: string;
+                url: string;
+                createdTime: string;
+                creatorToken: {
+                    id: string;
+                    description: string;
+                };
+                endTime: string | null;
+                startTime: string | null;
+                operationName: "bucketDelete";
+                operationParams: {
+                    queue: string;
+                } & {
+                    id: string;
+                };
+                metrics: {
+                    inCompressed: boolean;
+                    inBytes: number;
+                    inBytesUncompressed: number;
+                    outCompressed: boolean;
+                    outBytes: number;
+                    outBytesUncompressed: number;
+                };
+            } & ({
+                status: Exclude<"error" | "success" | "warning" | "created" | "waiting" | "processing" | "terminating" | "terminated" | "cancelled", "success" | "error">;
+                results: null;
+            } | {
+                status: "error";
+                results: null;
+                error: {
+                    code: string;
+                    message: string;
+                    exceptionId?: string;
+                };
+            } | {
+                status: "success";
+                results: null;
+            })>;
+            createScheduledRefresh: (input: CreateScheduledRefreshPath & CreateScheduledRefreshBody) => Promise<ScheduledTask>;
+            deleteScheduledTask: (taskId: string) => Promise<void>;
+        };
+        events: {
+            getEvents: (query?: GetEventsQuery, signal?: AbortSignal) => Promise<StorageEvent[]>;
+            getEvent: (eventId: string | number, signal?: AbortSignal) => Promise<StorageEvent>;
+            createEvent: (body: CreateEventBody, signal?: AbortSignal) => Promise<StorageEvent>;
+        };
+        files: {
+            getFile: (fileId: number, signal?: AbortSignal) => Promise<File$1>;
+            getFileContent: (fileId: number, signal?: AbortSignal) => Promise<string>;
+            getFiles: (query?: GetFilesQuery, signal?: AbortSignal) => Promise<File$1[]>;
+            deleteFile: (fileId: number) => Promise<void>;
+            addFileTag: (fileId: number, tag: string) => Promise<void>;
+            deleteFileTag: (fileId: DeleteFileTagPath["fileId"], tag: DeleteFileTagPath["tag"]) => Promise<void>;
+            prepareFile: (body: PrepareFileBody, signal?: AbortSignal) => Promise<PreparedFile>;
+        };
+        tables: {
+            getTables: (query?: GetTablesQuery, signal?: AbortSignal) => Promise<Table[]>;
+            getTable: (id: string, signal?: AbortSignal) => Promise<TableDetail>;
+            getDataPreview: (id: string, query?: GetDataPreview, signal?: AbortSignal) => Promise<PrevieData>;
+            deleteTable: (id: string, signal?: AbortSignal) => Promise<void>;
+            deleteTables: (ids: string[]) => Promise<void>;
+            deleteTableRows: (id: string, query?: DeleteTableRows, signal?: AbortSignal) => Promise<JobUnion>;
+            exportAsync: (tableId: string, body?: TableExportAsyncBody, signal?: AbortSignal) => Promise<TableExportJob>;
+            createTableAsync: (bucketId: string, body: CreateTableAsyncBody, signal?: AbortSignal) => Promise<TableCreateJob>;
+            importAsync: (tableId: string, body: TableImportAsyncBody, signal?: AbortSignal) => Promise<TableImportJob>;
+        };
+        branches: {
+            getDevBranches: (signal?: AbortSignal) => Promise<DevBranch[]>;
+            createDevBranchJob: (body: CreateDevBranchJobBody) => Promise<{
+                id: number;
+                tableId: string | null;
+                runId: string;
+                url: string;
+                createdTime: string;
+                creatorToken: {
+                    id: string;
+                    description: string;
+                };
+                endTime: string | null;
+                startTime: string | null;
+                operationName: "devBranchCreate";
+                operationParams: {
+                    queue: string;
+                } & {
+                    values: {
+                        name: string;
+                        description: string;
+                    };
+                };
+                metrics: {
+                    inCompressed: boolean;
+                    inBytes: number;
+                    inBytesUncompressed: number;
+                    outCompressed: boolean;
+                    outBytes: number;
+                    outBytesUncompressed: number;
+                };
+            } & ({
+                status: Exclude<"error" | "success" | "warning" | "created" | "waiting" | "processing" | "terminating" | "terminated" | "cancelled", "success" | "error">;
+                results: null;
+            } | {
+                status: "success";
+                results: DevBranch;
+            } | {
+                status: "error";
+                results: null;
+                error: {
+                    code: string;
+                    message: string;
+                    exceptionId?: string;
+                };
+            })>;
+            updateDevBranch: ({ id, name, description, }: CreateDevBranchJobBody & DevBranchPath) => Promise<DevBranch>;
+            deleteDevBranchJob: (id: number) => Promise<{
+                id: number;
+                tableId: string | null;
+                runId: string;
+                url: string;
+                createdTime: string;
+                creatorToken: {
+                    id: string;
+                    description: string;
+                };
+                endTime: string | null;
+                startTime: string | null;
+                operationName: "devBranchDelete";
+                operationParams: {
+                    queue: string;
+                } & {
+                    values: {
+                        id: number;
+                    };
+                };
+                metrics: {
+                    inCompressed: boolean;
+                    inBytes: number;
+                    inBytesUncompressed: number;
+                    outCompressed: boolean;
+                    outBytes: number;
+                    outBytesUncompressed: number;
+                };
+            } & ({
+                status: Exclude<"error" | "success" | "warning" | "created" | "waiting" | "processing" | "terminating" | "terminated" | "cancelled", "success" | "error">;
+                results: null;
+            } | {
+                status: "error";
+                results: null;
+                error: {
+                    code: string;
+                    message: string;
+                    exceptionId?: string;
+                };
+            } | {
+                status: "success";
+                results: null;
+            })>;
+            getDevBranchMetadata: (id: string, signal?: AbortSignal) => Promise<BranchMetadata[]>;
+            saveDevBranchMetadata: (id: string, metadata: BranchMetadataEntry[], signal?: AbortSignal) => Promise<BranchMetadata[]>;
+            deleteDevBranchMetadata: (id: string, metadataId: string, signal?: AbortSignal) => Promise<void>;
+        };
+        workspaces: {
+            getWorkspace: (path: WorkspacePath, signal?: AbortSignal) => Promise<Workspace>;
+            getWorkspaces: (branchId: WorkspacesPath["branchId"], signal?: AbortSignal) => Promise<Workspace[]>;
+            deleteWorkspace: (path: WorkspacePath) => Promise<void>;
+            resetWorkspacePassword: ({ branchId, workspaceId }: WorkspacePath) => Promise<ResetWorkspacePassword>;
+            deleteWorkspaces: ({ workspaceIds, branchId, }: Omit<WorkspacePath, "workspaceId"> & {
+                workspaceIds: WorkspacePath["workspaceId"][];
+            }) => Promise<void>;
+            deleteWorkspaceJob: (path: WorkspacePath) => Promise<{
+                id: number;
+                tableId: string | null;
+                runId: string;
+                url: string;
+                createdTime: string;
+                creatorToken: {
+                    id: string;
+                    description: string;
+                };
+                endTime: string | null;
+                startTime: string | null;
+                operationName: "workspaceDrop";
+                operationParams: {
+                    queue: string;
+                } & {
+                    workspaceId: string;
+                    backendConfiguration: [];
+                };
+                metrics: {
+                    inCompressed: boolean;
+                    inBytes: number;
+                    inBytesUncompressed: number;
+                    outCompressed: boolean;
+                    outBytes: number;
+                    outBytesUncompressed: number;
+                };
+            } & ({
+                status: Exclude<"error" | "success" | "warning" | "created" | "waiting" | "processing" | "terminating" | "terminated" | "cancelled", "success" | "error">;
+                results: null;
+            } | {
+                status: "error";
+                results: null;
+                error: {
+                    code: string;
+                    message: string;
+                    exceptionId?: string;
+                };
+            } | {
+                status: "success";
+                results: null;
+            })>;
+            setWorkspacePublicKey: ({ branchId, workspaceId, publicKey, }: SetWorkspacePublicInput) => Promise<Workspace>;
+            getWorkspaceSaml2Login: (path: GetWorkspaceSaml2LoginPath, signal?: AbortSignal) => Promise<WorkspaceSaml2Login>;
+            getWorkspaceObjects: (path: WorkspacePath, signal?: AbortSignal) => Promise<WorkspaceObject[]>;
+            deleteWorkspaceObjectsAsync: ({ branchId, workspaceId, ...body }: DeleteWorkspaceObjectInput) => Promise<{
+                id: number;
+                tableId: string | null;
+                runId: string;
+                url: string;
+                createdTime: string;
+                creatorToken: {
+                    id: string;
+                    description: string;
+                };
+                endTime: string | null;
+                startTime: string | null;
+                operationName: "workspaceBatchDeleteObject";
+                operationParams: {
+                    queue: string;
+                } & {
+                    workspaceId: string;
+                    objects: string[];
+                };
+                metrics: {
+                    inCompressed: boolean;
+                    inBytes: number;
+                    inBytesUncompressed: number;
+                    outCompressed: boolean;
+                    outBytes: number;
+                    outBytesUncompressed: number;
+                };
+            } & ({
+                status: Exclude<"error" | "success" | "warning" | "created" | "waiting" | "processing" | "terminating" | "terminated" | "cancelled", "success" | "error">;
+                results: null;
+            } | {
+                status: "success";
+                results: {
+                    deleted: {
+                        objectName: string;
+                    }[];
+                    failed: {
+                        objectName: string;
+                        error: string;
+                    }[];
+                };
+            } | {
+                status: "error";
+                results: {
+                    deleted: {
+                        objectName: string;
+                    }[];
+                    failed: {
+                        objectName: string;
+                        error: string;
+                    }[];
+                };
+                error: {
+                    code: string;
+                    message: string;
+                    exceptionId?: string;
+                };
+            })>;
+        };
+        mergeRequests: {
+            getMergeRequests: (signal?: AbortSignal) => Promise<{
+                id: number;
+                creator: {
+                    id?: number;
+                    name?: string;
+                };
+                title: string;
+                description: string;
+                state: "development" | "in_review" | "approved" | "in_merge" | "published" | "canceled";
+                branches: {
+                    branchFromId?: number | null;
+                    branchIntoId?: number | null;
+                };
+                merge: {
+                    mergedAt?: string | null;
+                    mergerId?: number | null;
+                    mergerName?: string;
+                };
+                createdAt: string;
+                externalId: string;
+                autoMergeStrategy: "immediately" | "scheduled" | "none";
+                autoMergeAt?: string | null;
+                approvals: {
+                    approverId?: string;
+                    approverName?: string;
+                    createdAt?: string;
+                }[];
+                reviewers: {
+                    id?: number;
+                    name?: string;
+                    email?: string;
+                }[];
+            }[]>;
+            getMergeRequest: (id: number, signal?: AbortSignal) => Promise<MergeRequestDetail>;
+            getMergeRequestWithActivityLog: (id: number, signal?: AbortSignal) => Promise<MergeRequestDetailWithActivityLog>;
+            createMergeRequest: (params: CreateMergeRequestParams) => Promise<{
+                id: number;
+                creator: {
+                    id?: number;
+                    name?: string;
+                };
+                title: string;
+                description: string;
+                state: "development" | "in_review" | "approved" | "in_merge" | "published" | "canceled";
+                branches: {
+                    branchFromId?: number | null;
+                    branchIntoId?: number | null;
+                };
+                merge: {
+                    mergedAt?: string | null;
+                    mergerId?: number | null;
+                    mergerName?: string;
+                };
+                createdAt: string;
+                externalId: string;
+                autoMergeStrategy: "immediately" | "scheduled" | "none";
+                autoMergeAt?: string | null;
+                approvals: {
+                    approverId?: string;
+                    approverName?: string;
+                    createdAt?: string;
+                }[];
+                reviewers: {
+                    id?: number;
+                    name?: string;
+                    email?: string;
+                }[];
+            }>;
+            updateMergeRequest: (id: number, params: UpdateMergeRequestParams) => Promise<{
+                id: number;
+                creator: {
+                    id?: number;
+                    name?: string;
+                };
+                title: string;
+                description: string;
+                state: "development" | "in_review" | "approved" | "in_merge" | "published" | "canceled";
+                branches: {
+                    branchFromId?: number | null;
+                    branchIntoId?: number | null;
+                };
+                merge: {
+                    mergedAt?: string | null;
+                    mergerId?: number | null;
+                    mergerName?: string;
+                };
+                createdAt: string;
+                externalId: string;
+                autoMergeStrategy: "immediately" | "scheduled" | "none";
+                autoMergeAt?: string | null;
+                approvals: {
+                    approverId?: string;
+                    approverName?: string;
+                    createdAt?: string;
+                }[];
+                reviewers: {
+                    id?: number;
+                    name?: string;
+                    email?: string;
+                }[];
+            }>;
+            requestReview: (id: number) => Promise<{
+                id: number;
+                creator: {
+                    id?: number;
+                    name?: string;
+                };
+                title: string;
+                description: string;
+                state: "development" | "in_review" | "approved" | "in_merge" | "published" | "canceled";
+                branches: {
+                    branchFromId?: number | null;
+                    branchIntoId?: number | null;
+                };
+                merge: {
+                    mergedAt?: string | null;
+                    mergerId?: number | null;
+                    mergerName?: string;
+                };
+                createdAt: string;
+                externalId: string;
+                autoMergeStrategy: "immediately" | "scheduled" | "none";
+                autoMergeAt?: string | null;
+                approvals: {
+                    approverId?: string;
+                    approverName?: string;
+                    createdAt?: string;
+                }[];
+                reviewers: {
+                    id?: number;
+                    name?: string;
+                    email?: string;
+                }[];
+            } & {
+                changeLog?: Record<string, never>;
+            }>;
+            approveMergeRequest: (id: number) => Promise<{
+                id: number;
+                creator: {
+                    id?: number;
+                    name?: string;
+                };
+                title: string;
+                description: string;
+                state: "development" | "in_review" | "approved" | "in_merge" | "published" | "canceled";
+                branches: {
+                    branchFromId?: number | null;
+                    branchIntoId?: number | null;
+                };
+                merge: {
+                    mergedAt?: string | null;
+                    mergerId?: number | null;
+                    mergerName?: string;
+                };
+                createdAt: string;
+                externalId: string;
+                autoMergeStrategy: "immediately" | "scheduled" | "none";
+                autoMergeAt?: string | null;
+                approvals: {
+                    approverId?: string;
+                    approverName?: string;
+                    createdAt?: string;
+                }[];
+                reviewers: {
+                    id?: number;
+                    name?: string;
+                    email?: string;
+                }[];
+            } & {
+                changeLog?: Record<string, never>;
+            }>;
+            requestChangesMergeRequest: (id: number, reason?: string) => Promise<{
+                id: number;
+                creator: {
+                    id?: number;
+                    name?: string;
+                };
+                title: string;
+                description: string;
+                state: "development" | "in_review" | "approved" | "in_merge" | "published" | "canceled";
+                branches: {
+                    branchFromId?: number | null;
+                    branchIntoId?: number | null;
+                };
+                merge: {
+                    mergedAt?: string | null;
+                    mergerId?: number | null;
+                    mergerName?: string;
+                };
+                createdAt: string;
+                externalId: string;
+                autoMergeStrategy: "immediately" | "scheduled" | "none";
+                autoMergeAt?: string | null;
+                approvals: {
+                    approverId?: string;
+                    approverName?: string;
+                    createdAt?: string;
+                }[];
+                reviewers: {
+                    id?: number;
+                    name?: string;
+                    email?: string;
+                }[];
+            } & {
+                changeLog?: Record<string, never>;
+            }>;
+        };
+        jobs: {
+            getJob: <T extends JobOperation | string = string>(id: GetJobPath["id"], signal?: AbortSignal) => Promise<Job<T>>;
+            getJobs: <T extends JobOperation | string = string>(query?: GetJobsQuery, signal?: AbortSignal) => Promise<Job<T>[]>;
+        };
+        componentsAndConfigurations: {
+            getComponent: ({ componentId, branchId }: GetComponentPath, signal?: AbortSignal) => Promise<Component>;
+            getComponents: ({ branchId, ...query }?: GetComponentsPath & GetComponentsQuery, signal?: AbortSignal) => Promise<Component[]>;
+            searchComponentConfigurations: ({ branchId }?: GetSearchComponentConfigurationsPath, query?: SearchComponentConfigurationsQuery, signal?: AbortSignal) => Promise<SearchComponentConfiguration[]>;
+            createConfiguration: ({ branchId, componentId, ...body }: PartialKey<CreateConfigurationInput, "branchId">) => Promise<BaseComponentConfig>;
+            getConfiguration: <T extends ConfigType = "unknown">({ componentId, configId, branchId }: ConfigurationPath, signal?: AbortSignal) => Promise<ComponentConfig<T>>;
+            deleteConfiguration: (path: Required<ConfigurationPath>) => Promise<void>;
+            deleteConfigurations: ({ configIds, ...rest }: Required<Omit<ConfigurationPath, "configId">> & {
+                configIds: string[];
+            }) => Promise<void>;
+            getConfigurations: <T extends ConfigType = "unknown">({ componentId, branchId }: GetConfigurationsPath, signal?: AbortSignal) => Promise<ComponentConfig<T>[]>;
+            createConfigurationRow: ({ branchId, componentId, configId, ...body }: PartialKey<CreateConfigurationRowInput, "branchId">) => Promise<Row>;
+            createConfigurationRows: ({ branchId, componentId, configId, data, }: PartialKey<CreateConfigurationRowsInput, "branchId">, options?: {
+                middlewares: MiddlewareFn$1<CreateConfigurationRowBody, Row>[];
+            }) => Promise<Row[]>;
+            deleteConfigurationRow: ({ changeDescription, ...path }: DeleteConfigurationRowInput) => Promise<void>;
+            deleteConfigurationRows: ({ rowIds, changeDescription, ...input }: DeleteConfigurationRowsInput, options?: {
+                middlewares: MiddlewareFn$1<string, void>[];
+            }) => Promise<void>;
+            createConfigurationWorkspace: ({ componentId, branchId, configId, ...body }: Required<ConfigurationPath> & CreateConfigurationWorkspaceBody) => Promise<Workspace>;
+            createConfigurationWorkspaceJob: ({ componentId, branchId, configId, ...body }: Required<ConfigurationPath> & CreateConfigurationWorkspaceBody) => Promise<{
+                id: number;
+                tableId: string | null;
+                runId: string;
+                url: string;
+                createdTime: string;
+                creatorToken: {
+                    id: string;
+                    description: string;
+                };
+                endTime: string | null;
+                startTime: string | null;
+                operationName: "workspaceCreate";
+                operationParams: {
+                    queue: string;
+                } & {
+                    backend: string;
+                    backendConfiguration: [];
+                    backendSize: null;
+                    branchId: number;
+                    componentId: string;
+                    configurationId: string;
+                    loginType: number;
+                    networkPolicy: string;
+                    publicKey: string;
+                    readOnlyStorageAccess: boolean;
+                    useCase: ConfigurationUseCaseType;
+                };
+                metrics: {
+                    inCompressed: boolean;
+                    inBytes: number;
+                    inBytesUncompressed: number;
+                    outCompressed: boolean;
+                    outBytes: number;
+                    outBytesUncompressed: number;
+                };
+            } & ({
+                status: Exclude<"error" | "success" | "warning" | "created" | "waiting" | "processing" | "terminating" | "terminated" | "cancelled", "success" | "error">;
+                results: null;
+            } | {
+                status: "error";
+                results: null;
+                error: {
+                    code: string;
+                    message: string;
+                    exceptionId?: string;
+                };
+            } | {
+                status: "success";
+                results: Workspace;
+            })>;
+            getConfigurationWorkspaces: ({ componentId, branchId, configId, }: ConfigurationPath) => Promise<Workspace[]>;
+        };
+        configurationVersions: {
+            listConfigurationVersions: ({ branchId, componentId, configId }: ConfigurationVersionPath, signal?: AbortSignal) => Promise<ConfigurationVersion[]>;
+            getConfigurationVersion: ({ branchId, componentId, configId, versionId }: ConfigurationVersionDetailPath, signal?: AbortSignal) => Promise<ConfigurationVersionDetail>;
+        };
+        tokens: {
+            verify: (signal?: AbortSignal) => Promise<StorageToken>;
+            refresh: (id: string, signal?: AbortSignal) => Promise<StorageToken>;
+        };
+        getStackInfo: (query?: GetStackInfoQuery, signal?: AbortSignal) => Promise<StackInfo>;
+    };
+    assets: {
+        getPublishedChangelogPosts: (signal?: AbortSignal) => Promise<Post[]>;
+    };
+    status: {
+        getSummary: (signal?: AbortSignal) => Promise<StatusSummary>;
+    };
+    management: {
+        currentUser: {
+            getMaintainerInvitations: (signal?: AbortSignal) => Promise<{
+                id: number;
+                created: string;
+                maintainer: {
+                    id?: number;
+                    name?: string;
+                };
+                creator: {
+                    id?: number;
+                    name?: string;
+                    email?: string;
+                };
+            }[]>;
+            getMaintainerInvitation: (id: number, signal?: AbortSignal) => Promise<{
+                id: number;
+                created: string;
+                maintainer: {
+                    id?: number;
+                    name?: string;
+                };
+                creator: {
+                    id?: number;
+                    name?: string;
+                    email?: string;
+                };
+            }>;
+            acceptMaintainerInvitation: (id: number) => Promise<void>;
+            rejectMaintainerInvitation: (id: number) => Promise<void>;
+            getOrganizationInvitations: (signal?: AbortSignal) => Promise<{
+                id: number;
+                created: string;
+                organization: {
+                    id?: number;
+                    name?: string;
+                };
+                creator: {
+                    id?: number;
+                    name?: string;
+                    email?: string;
+                };
+            }[]>;
+            getOrganizationInvitation: (id: number, signal?: AbortSignal) => Promise<{
+                id: number;
+                created: string;
+                organization: {
+                    id?: number;
+                    name?: string;
+                };
+                creator: {
+                    id?: number;
+                    name?: string;
+                    email?: string;
+                };
+            }>;
+            acceptOrganizationInvitation: (id: number) => Promise<void>;
+            rejectOrganizationInvitation: (id: number) => Promise<void>;
+            getProjectInvitations: (signal?: AbortSignal) => Promise<Record<string, never>[]>;
+            getProjectInvitation: (id: number, signal?: AbortSignal) => Promise<{
+                id: number;
+                created: string;
+                expires?: string | null;
+                reason?: string | null;
+                role?: string | null;
+                project: {
+                    id?: number;
+                    name?: string;
+                };
+                creator: {
+                    id?: number;
+                    name?: string;
+                    email?: string;
+                };
+            }>;
+            acceptProjectInvitation: (id: number) => Promise<void>;
+            rejectProjectInvitation: (id: number) => Promise<void>;
+            getProjectJoinRequests: (signal?: AbortSignal) => Promise<Record<string, never>[]>;
+            deleteProjectJoinRequest: (id: number) => Promise<void>;
+        };
+        features: {
+            getAllFeatures: (query: GetAllFeaturesQuery, signal?: AbortSignal) => Promise<Feature[]>;
+        };
+        maintainers: {
+            getMaintainers: (signal?: AbortSignal) => Promise<Record<string, never>[]>;
+            getMaintainer: (maintainerId: number, signal?: AbortSignal) => Promise<{
+                id: number;
+                name: string;
+                created: string;
+                defaultConnectionMysqlId?: number | null;
+                defaultConnectionSnowflakeId?: number | null;
+                defaultConnectionSynapseId?: number | null;
+                defaultConnectionExasolId?: number | null;
+                defaultConnectionBigqueryId?: number | null;
+                defaultConnectionTeradataId?: number | null;
+                defaultFileStorageId?: number | null;
+                zendeskUrl?: string | null;
+            } & {
+                organizations?: components$5["schemas"]["OrganizationResponse"][];
+            }>;
+            createMaintainer: (body: CreateMaintainerBody) => Promise<{
+                id: number;
+                name: string;
+                created: string;
+                defaultConnectionMysqlId?: number | null;
+                defaultConnectionSnowflakeId?: number | null;
+                defaultConnectionSynapseId?: number | null;
+                defaultConnectionExasolId?: number | null;
+                defaultConnectionBigqueryId?: number | null;
+                defaultConnectionTeradataId?: number | null;
+                defaultFileStorageId?: number | null;
+                zendeskUrl?: string | null;
+            }>;
+            updateMaintainer: ({ maintainerId, ...body }: {
+                maintainerId: number;
+            } & UpdateMaintainerBody) => Promise<{
+                id: number;
+                name: string;
+                created: string;
+                defaultConnectionMysqlId?: number | null;
+                defaultConnectionSnowflakeId?: number | null;
+                defaultConnectionSynapseId?: number | null;
+                defaultConnectionExasolId?: number | null;
+                defaultConnectionBigqueryId?: number | null;
+                defaultConnectionTeradataId?: number | null;
+                defaultFileStorageId?: number | null;
+                zendeskUrl?: string | null;
+            }>;
+            deleteMaintainer: (maintainerId: number) => Promise<void>;
+            getMaintainerUsers: (maintainerId: number, signal?: AbortSignal) => Promise<MaintainerUser[]>;
+            addMaintainerUser: ({ maintainerId, ...body }: {
+                maintainerId: number;
+            } & AddMaintainerUserBody) => Promise<{
+                id: number;
+                name: string;
+                email: string;
+                mfaEnabled: boolean;
+                features: string[];
+                canAccessLogs: boolean;
+                isSuperAdmin: boolean;
+            }>;
+            removeMaintainerUser: ({ maintainerId, adminId, }: {
+                maintainerId: number;
+                adminId: number;
+            }) => Promise<void>;
+            getMaintainerInvitations: (maintainerId: number, signal?: AbortSignal) => Promise<Record<string, never>[]>;
+            getMaintainerInvitation: ({ maintainerId, invitationId }: {
+                maintainerId: number;
+                invitationId: number;
+            }, signal?: AbortSignal) => Promise<{
+                id: number;
+                created?: string | null;
+                user: {
+                    id?: number;
+                    name?: string;
+                    email?: string;
+                };
+                creator: {
+                    id?: number;
+                    name?: string;
+                    email?: string;
+                };
+            }>;
+            createMaintainerInvitation: ({ maintainerId, ...body }: {
+                maintainerId: number;
+            } & CreateMaintainerInvitationBody) => Promise<{
+                id: number;
+                created?: string | null;
+                user: {
+                    id?: number;
+                    name?: string;
+                    email?: string;
+                };
+                creator: {
+                    id?: number;
+                    name?: string;
+                    email?: string;
+                };
+            }>;
+            deleteMaintainerInvitation: ({ maintainerId, invitationId, }: {
+                maintainerId: number;
+                invitationId: number;
+            }) => Promise<void>;
+            getMaintainerOrganizations: (maintainerId: number, signal?: AbortSignal) => Promise<{
+                id: number;
+                name: string;
+                created: string;
+                allowAutoJoin: boolean;
+                crmId?: string | null;
+                activityCenterProjectId?: number | null;
+                mfaRequired: boolean;
+            }[]>;
+            createMaintainerOrganization: ({ maintainerId, ...body }: {
+                maintainerId: number;
+            } & CreateMaintainerOrganizationBody) => Promise<{
+                id: number;
+                name: string;
+                created: string;
+                allowAutoJoin: boolean;
+                crmId?: string | null;
+                activityCenterProjectId?: number | null;
+                mfaRequired: boolean;
+            }>;
+            getMaintainerMetadata: (maintainerId: number, signal?: AbortSignal) => Promise<MetadataItem[]>;
+            setMaintainerMetadata: ({ maintainerId, ...body }: {
+                maintainerId: number;
+            } & SetMaintainerMetadataBody) => Promise<MetadataItem[]>;
+            deleteMaintainerMetadata: ({ maintainerId, metadataId, }: {
+                maintainerId: number;
+                metadataId: number;
+            }) => Promise<void>;
+        };
+        organizations: {
+            getOrganizations: (signal?: AbortSignal) => Promise<{
+                id: number;
+                name: string;
+                created: string;
+                allowAutoJoin: boolean;
+                crmId: string;
+                activityCenterProjectId?: number | null;
+                mfaRequired: boolean;
+                maintainer: {
+                    id?: number;
+                    name?: string;
+                    created?: string;
+                    defaultConnectionMysqlId?: number | null;
+                    defaultConnectionSnowflakeId?: number | null;
+                    defaultConnectionSynapseId?: number | null;
+                    defaultConnectionExasolId?: number | null;
+                    defaultConnectionBigqueryId?: number | null;
+                    defaultConnectionTeradataId?: number | null;
+                    defaultFileStorageId?: number | null;
+                    zendeskUrl?: string | null;
+                };
+            }[]>;
+            getOrganization: (organizationId: number, signal?: AbortSignal) => Promise<{
+                id: number;
+                name: string;
+                created: string;
+                allowAutoJoin: boolean;
+                crmId?: string | null;
+                activityCenterProjectId?: number | null;
+                mfaRequired: boolean;
+            } & {
+                projects?: Record<string, never>[];
+                maintainer?: Record<string, never>;
+            }>;
+            updateOrganization: ({ organizationId, ...body }: {
+                organizationId: number;
+            } & UpdateOrganizationBody) => Promise<{
+                id: number;
+                name: string;
+                created: string;
+                allowAutoJoin: boolean;
+                crmId?: string | null;
+                activityCenterProjectId?: number | null;
+                mfaRequired: boolean;
+            }>;
+            deleteOrganization: (organizationId: number) => Promise<void>;
+            forceMfa: (organizationId: number) => Promise<{
+                id: number;
+                name: string;
+                created: string;
+                allowAutoJoin: boolean;
+                crmId?: string | null;
+                activityCenterProjectId?: number | null;
+                mfaRequired: boolean;
+            }>;
+            joinOrganization: (organizationId: number) => Promise<void>;
+            getOrganizationUsers: (organizationId: number, signal?: AbortSignal) => Promise<{
+                id: number;
+                name: string;
+                email: string;
+                mfaEnabled: boolean;
+                features: string[];
+                canAccessLogs: boolean;
+                isSuperAdmin: boolean;
+            }[]>;
+            addOrganizationUser: ({ organizationId, ...body }: {
+                organizationId: number;
+            } & AddOrganizationUserBody) => Promise<{
+                id: number;
+                name: string;
+                email: string;
+                mfaEnabled: boolean;
+                features: string[];
+                canAccessLogs: boolean;
+                isSuperAdmin: boolean;
+            }>;
+            removeOrganizationUser: ({ organizationId, userId, }: {
+                organizationId: number;
+                userId: number;
+            }) => Promise<void>;
+            getOrganizationProjectsUsers: (organizationId: number, signal?: AbortSignal) => Promise<{
+                id: number;
+                name: string;
+                email: string;
+                mfaEnabled: boolean;
+                features: string[];
+                canAccessLogs: boolean;
+                isSuperAdmin: boolean;
+            }[]>;
+            getOrganizationInvitations: (organizationId: number, signal?: AbortSignal) => Promise<{
+                id: number;
+                created?: string | null;
+                user: {
+                    id?: number;
+                    name?: string;
+                    email?: string;
+                };
+                creator: {
+                    id?: number;
+                    name?: string;
+                    email?: string;
+                };
+            }[]>;
+            getOrganizationInvitation: ({ organizationId, invitationId }: {
+                organizationId: number;
+                invitationId: number;
+            }, signal?: AbortSignal) => Promise<{
+                id: number;
+                created?: string | null;
+                user: {
+                    id?: number;
+                    name?: string;
+                    email?: string;
+                };
+                creator: {
+                    id?: number;
+                    name?: string;
+                    email?: string;
+                };
+            }>;
+            createOrganizationInvitation: ({ organizationId, ...body }: {
+                organizationId: number;
+            } & CreateOrganizationInvitationBody) => Promise<{
+                id: number;
+                created?: string | null;
+                user: {
+                    id?: number;
+                    name?: string;
+                    email?: string;
+                };
+                creator: {
+                    id?: number;
+                    name?: string;
+                    email?: string;
+                };
+            }>;
+            deleteOrganizationInvitation: ({ organizationId, invitationId, }: {
+                organizationId: number;
+                invitationId: number;
+            }) => Promise<void>;
+            getOrganizationProjects: (organizationId: number, signal?: AbortSignal) => Promise<Project[]>;
+            createOrganizationProject: ({ organizationId, ...body }: {
+                organizationId: number;
+            } & CreateOrganizationProjectBody) => Promise<{
+                id: number;
+                name: string;
+                type: string;
+                region: string;
+                created?: string | null;
+                expires?: string | null;
+                features: string[];
+                dataSizeBytes: number;
+                rowsCount: number;
+                hasMysql: boolean;
+                hasSynapse: boolean;
+                hasSnowflake: boolean;
+                hasExasol: boolean;
+                hasTeradata: boolean;
+                hasBigquery: boolean;
+                defaultBackend: string;
+                hasTryModeOn: string;
+                limits: {
+                    [key: string]: Record<string, never>;
+                };
+                metrics: {
+                    [key: string]: Record<string, never>;
+                };
+                isDisabled: boolean;
+                billedMonthlyPrice?: number | null;
+                dataRetentionTimeInDays: number;
+                isBYODB: boolean;
+                assignedBackends: string[];
+                fileStorageProvider?: string | null;
+                payAsYouGo?: {
+                    purchasedCredits?: number;
+                } | null;
+                disabled?: {
+                    reason?: string;
+                    estimatedEndTime?: string | null;
+                } | null;
+            } & {
+                fileStorage?: Record<string, never>;
+                backends?: Record<string, never>;
+            }>;
+            getOrganizationMetadata: (organizationId: number, signal?: AbortSignal) => Promise<MetadataItem[]>;
+            setOrganizationMetadata: ({ organizationId, ...body }: {
+                organizationId: number;
+            } & SetOrganizationMetadataBody) => Promise<MetadataItem[]>;
+            deleteOrganizationMetadata: ({ organizationId, metadataId, }: {
+                organizationId: number;
+                metadataId: number;
+            }) => Promise<void>;
+        };
+        projects: {
+            getProject: (projectId: GetProjectPath["projectId"], signal?: AbortSignal) => Promise<Project>;
+            addProjectFeature: ({ projectId, feature, }: CreateProjectFeaturePath & CreateProjectFeatureBody) => Promise<Project>;
+            removeProjectFeature: (path: RemoveProjectFeaturePath) => Promise<null>;
+            changeProjectUserRole: ({ projectId, userId, role, }: {
+                projectId: number;
+                userId: number;
+                role: User["role"];
+            }) => Promise<User>;
+            getProjectUsers: (projectId: ListProjectUsersPath["projectId"], signal?: AbortSignal) => Promise<User[]>;
+            getProjectMetadata: (projectId: GetProjectMetadataPath["projectId"], signal?: AbortSignal) => Promise<ProjectMetadataItem[]>;
+            setProjectMetadata: ({ projectId, provider, metadata, }: SetProjectMetadataPath & SetProjectMetadataBody) => Promise<ProjectMetadataItem[]>;
+            getProjectReviewers: (projectId: GetProjectReviewersPath["projectId"], signal?: AbortSignal) => Promise<Reviewer[]>;
+            setProjectReviewers: ({ projectId, adminIds, }: SetProjectReviewersPath & SetProjectReviewersBody) => Promise<void>;
+        };
+        users: {
+            addUserAdminFeature: ({ feature, userIdOrMail }: AddUserFeatureBody & AddUserFeaturePath, signal?: AbortSignal) => Promise<User>;
+            removeUserAdminFeature: ({ userIdOrMail, feature }: RemoveUserFeaturePath, signal?: AbortSignal) => Promise<User>;
+        };
+    };
+}>;
+type Clients = Awaited<ReturnType<typeof createClients>>;
+type ApiClient = {
+    init: (options: ApiClientOptions) => Promise<void>;
+} & Clients;
+declare const createApiClient: () => ApiClient;
+
+type RequestLog = {
+    url: string;
+    headers: Record<string, string>;
+};
+type ResponseLog = {
+    status: number;
+    statusText: string;
+    headers: Record<string, string>;
+};
+type Log = {
+    correlationId: string;
+    method: HttpMethod;
+    durationMs: number;
+    request: RequestLog;
+    response?: ResponseLog;
+    error?: Error;
+};
+type Logger = {
+    info: (log: Log) => void;
+    error: (log: Log) => void;
+};
+type LogLevel = 'error-only' | 'all';
+type LoggingOptions = {
+    logger?: Logger;
+    level?: LogLevel;
+    redactHeaders?: string[];
+};
+declare const consoleLogger: Logger;
+declare const createLoggingMiddleware: (options?: LoggingOptions) => MiddlewareFn;
+
+type RetryOptions = {
+    maxRetries?: number;
+    backoffFactor?: number;
+    shouldRetry?: (error: unknown, attempt: number) => boolean;
+};
+declare const createRetryMiddleware: (options?: RetryOptions) => MiddlewareFn;
+
+declare const KeboolaHttpHeader: {
+    STORAGE_API_TOKEN: string;
+    MANAGEMENT_API_TOKEN: string;
+    STORAGE_API_URL: string;
+};
+
+declare const createDevApiClient: () => {
+    verify: {
+        storageApiToken: (host: string, token: string, signal?: AbortSignal) => Promise<StorageToken>;
+        managementApiToken: (host: string, token: string, signal?: AbortSignal) => Promise<ManagementToken>;
+    };
+};
+
+export { type ApiClient, type ApiClientOptions, ConcurrentOptions, HttpContentType, HttpHeader, KeboolaHttpHeader, KeboolaObjectId, type Log, type LogLevel, type Logger, type LoggingOptions, MiddlewareFn, PollException, type RequestLog, type ResponseLog, type RetryOptions, ServiceUnavailableError, UserError, assert, consoleLogger, createApiClient, createDevApiClient, createLoggingMiddleware, createRetryMiddleware, delay, generateUUID, poll, series };