@keboola/api-client 4.0.0 → 5.0.0

package/dist/index.d.ts

@@ -1,41 +1,44 @@
-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, O as OrganizationDetail, 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-BTcT8Q0T.js';
-import { b as ApiError, M as MiddlewareFn, c as BaseClientOptions, A as ApiResponse, H as HttpMethod } from './types-Bom8wyth.js';
+import { M as Maintainer, a as MaintainerDetail, C as CreateMaintainerBody, U as UpdateMaintainerBody, b as MaintainerUser, A as AddMaintainerUserBody, c as CreateMaintainerInvitationBody, d as CreateMaintainerOrganizationBody, e as MetadataItem, S as SetMaintainerMetadataBody, O as OrganizationDetail, f as UpdateOrganizationBody, g as AddOrganizationUserBody, h as CreateOrganizationInvitationBody, P as Project, i as CreateOrganizationProjectBody, j as SetOrganizationMetadataBody, G as GetAllFeaturesQuery, F as Feature, k as FeatureProject, l as FeatureAdmin, m as GetProjectPath, n as CreateProjectFeaturePath, o as CreateProjectFeatureBody, R as RemoveProjectFeaturePath, p as User, L as ListProjectUsersPath, q as ListProjectInvitationsPath, r as CreateProjectInvitationPath, s as CreateProjectInvitationBody, D as DeleteProjectInvitationPath, t as AddProjectUserPath, u as AddProjectUserBody, v as RemoveProjectUserPath, w as GetProjectMetadataPath, x as ProjectMetadataItem, y as SetProjectMetadataPath, z as SetProjectMetadataBody, B as GetProjectReviewersPath, E as Reviewer, H as SetProjectReviewersPath, I as SetProjectReviewersBody, J as UpdateProjectBody, K as MoveProjectBody, N as SetProjectDisabledBody, Q as AddUserFeatureBody, T as AddUserFeaturePath, V as RemoveUserFeaturePath } from './types-DMC601TE.js';
+import { b as ApiError, M as MiddlewareFn, c as BaseClientOptions, A as ApiResponse, H as HttpMethod } from './types-DxJD6LIN.js';
 import { StatusSummary } from './status/types.js';
 import { Post } from './assets/types.js';
+import { B as Backend, S as StorageToken, c as components$6, C as CreateTokenBody, U as UpdateTokenBody, b as ShareTokenBody } from './types-Dfw6a58i.js';
+export { K as KeboolaHttpHeader } from './types-Dfw6a58i.js';
+import { StorageTableScope as StorageTable } from './domain/storageTable/index.js';
+import { P as PaginationQuery, c as components$5, C as CreateSourceRequestBody, U as UpdateSourceRequestBody, D as DeleteSourceQuery, a as UpdateSourceSettingsRequestBody, T as TestSourceQuery, b as CreateSinkRequestBody, d as UpdateSinkRequestBody, e as UpdateSinkSettingsRequestBody, S as SinkStatisticsFilesQuery } from './types-Dv3vN7M9.js';
 import { GetCredentialsQuery, Credential, CreateCredentialBody } from './oauth/types.js';
 import * as zod from 'zod';
-import { c as OpenapiQueryType, d as OpenapiPathType, b as OpenapiBodyType, a as OpenapiReturnType } from './types-C7mpAfq-.js';
+import { c as OpenapiQueryType, d as OpenapiPathType, b as OpenapiBodyType, a as OpenapiReturnType } from './types-jKnx7Tm_.js';
 import { U as UploadFileParams, a as UploadedFile } from './types-Dg1tEsVR.js';
-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-B51cQMrX.js';
+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-DFbHRDdR.js';
 import { SuggestionsRequestBody, SuggestionsApiResponse } from './chat/suggestions.js';
-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-DzwzVgyG.js';
-import { G as GetQueueJobPath, c as components$2, S as SearchJobsQuery } from './types-cH0_hkCW.js';
-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-CGMJT3JL.js';
+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-JvKRS8Qd.js';
+import { G as GetQueueJobPath, c as components$2, S as SearchJobsQuery } from './types-DacFMc6L.js';
+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-yKV1EX6f.js';
 import { CreateCredentialsBody, WorkspaceData } from './telemetry/types.js';
 import { PostActionsBody, EnrollMFAInput, GetDataAppPublicGitRepositoryInput, GetDataAppPasswordPrivateGitRepositoryInput, GetDataAppSSHKeyPrivateGitRepositoryInput, GetPublicGitRepositoryInput, GetGitPrivateRepositoryInput } from './syncActions/types.js';
-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-CqWXdTMg.js';
+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-CFd7q2ed.js';
 import { EncryptQuery } from './encryption/types.js';
-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-BNQZiNOu.js';
-export { p as parseLogLines } from './utils-BNQZiNOu.js';
+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-Cl4emy8g.js';
+export { p as parseLogLines } from './utils-Cl4emy8g.js';
 import { CreateVariableBody, VariableWithHash, DeleteVariablePath, GetVariablesQuery, GetVariablesByBranchId } from './vault/types.js';
 import { a as EncryptionCtx } from './types-D4CDCW-Y.js';
-import { ServiceId, CreateTableAsyncBody, TableCreateJob, TableImportAsyncBody, TableImportJob, TableExportAsyncBody, TableExportJob, BucketListing, CreateBucketListingInput, UpdateBucketListingInput, Service, StackComponent, GetBucketsQuery, Bucket, BucketDetail, CreateBucketBody, UpdateBucketBody, CreateScheduledRefreshPath, CreateScheduledRefreshBody, ScheduledTask, Job, GetEventsQuery, StorageEvent, GetTableEventsQuery, TableEvent, 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, UnloadWorkspaceInput, MergeRequestDetail, MergeRequestDetailWithActivityLog, CreateMergeRequestParams, UpdateMergeRequestParams, JobOperation, GetJobPath, GetJobsQuery, GetComponentPath, Component, GetComponentsPath, GetComponentsQuery, GetSearchComponentConfigurationsPath, SearchComponentConfigurationsQuery, SearchComponentConfiguration, PartialKey, CreateConfigurationInput, BaseComponentConfig, ConfigType, UpdateConfigurationInput, ComponentConfig, ConfigurationPath, ConfigurationDiffPath, ConfigurationDiff, ConfigurationRowDiffPath, ConfigurationRowDiff, RebaseConfigurationInput, GetConfigurationsPath, CreateConfigurationRowInput, Row, CreateConfigurationRowsInput, CreateConfigurationRowBody, DeleteConfigurationRowInput, DeleteConfigurationRowsInput, CreateConfigurationWorkspaceBody, ConfigurationUseCaseType, ConfigurationVersionPath, ConfigurationVersion, ConfigurationVersionDetailPath, ConfigurationVersionDetail, GetStackInfoQuery, StackInfo } from './storage/types.js';
-import { M as MetaObject } from './types-BY0tjg2Q.js';
-import { C as ConcurrentOptions, M as MiddlewareFn$1 } from './storageClient-xm0yUrNc.js';
-export { a as concurrent } from './storageClient-xm0yUrNc.js';
+import { M as MetaObject } from './types-Mghz1gMD.js';
+import { TagWithBindings, TagData, CreateMetaObjectMetaDataInput, UpdateMetaObjectMetaDataInput } from './sdk/tag/types.js';
+import { C as ConcurrentOptions, M as MiddlewareFn$1 } from './index-BEE_qeId.js';
+export { a as concurrent } from './index-BEE_qeId.js';
 import { K as KeboolaObjectId } from './keboolaUID-D1DGSbge.js';
 export { k as keboolaUID } from './keboolaUID-D1DGSbge.js';
-import { TagWithBindings, TagData, CreateMetaObjectMetaDataInput, UpdateMetaObjectMetaDataInput } from './sdk/tag/types.js';
-import { B as Backend, S as StorageToken } from './types-DYMMsuU0.js';
-export { c as createGenericFetchClient } from './createGenericFetchClient-Cp2By_KQ.js';
-export { M as ManagementClientAuthError, i as isManagementClientAuthError } from './authMiddleware-Dcy9gRT9.js';
+import { ServiceId, CreateTableAsyncBody, TableCreateJob, CreateTableDefinitionBody, Table, TableImportAsyncBody, TableImportJob, TableExportAsyncBody, TableExportJob, BucketListing, CreateBucketListingInput, UpdateBucketListingInput, ShareBucketToProjectsBody, ShareBucketToUsersBody, RegisterBucketBody, RefreshExternalBucketQuery, CreateSnapshotBody, AddTableColumnBody, DeleteTableColumnQuery, CreateTablePrimaryKeyBody, Service, StackComponent, GetBucketsQuery, Bucket, BucketDetail, CreateBucketBody, UpdateBucketBody, CreateScheduledRefreshPath, CreateScheduledRefreshBody, ScheduledTask, Job, UpdateBucketOwnerBody, BucketRegistrationGuideQuery, SaveBucketMetadataBody, GetEventsQuery, StorageEvent, GetTableEventsQuery, TableEvent, CreateEventBody, File as File$1, GetFilesQuery, DeleteFileTagPath, PrepareFileBody, PreparedFile, GetTablesQuery, TableDetail, GetDataPreview, PrevieData, DeleteTableRows, JobUnion, UpdateTableDefinitionInput, UpdateTableBody, CreateAliasTableBody, SetAliasTableFilterBody, Snapshot, SaveMetadataBody, Metadata, DevBranch, CreateDevBranchJobBody, DevBranchPath, BranchMetadata, BranchMetadataEntry, WorkspacePath, Workspace, WorkspacesPath, ResetWorkspacePassword, SetWorkspacePublicInput, GetWorkspaceSaml2LoginPath, WorkspaceSaml2Login, WorkspaceObject, DeleteWorkspaceObjectInput, UnloadWorkspaceInput, WorkspaceInputMappingLoadPreviewInput, MergeRequestDetail, MergeRequestDetailWithActivityLog, CreateMergeRequestParams, UpdateMergeRequestParams, JobOperation, GetJobPath, GetJobsQuery, GetComponentPath, Component, GetComponentsPath, GetComponentsQuery, GetSearchComponentConfigurationsPath, SearchComponentConfigurationsQuery, SearchComponentConfiguration, PartialKey, CreateConfigurationInput, BaseComponentConfig, ConfigType, UpdateConfigurationInput, ComponentConfig, ConfigurationPath, ConfigurationDiffPath, ConfigurationDiff, ConfigurationRowDiffPath, ConfigurationRowDiff, RebaseConfigurationInput, GetConfigurationsPath, CreateConfigurationRowInput, Row, CreateConfigurationRowsInput, CreateConfigurationRowBody, DeleteConfigurationRowInput, DeleteConfigurationRowsInput, CreateConfigurationWorkspaceBody, ConfigurationUseCaseType, ConfigurationVersionPath, ConfigurationVersion, ConfigurationVersionDetailPath, ConfigurationVersionDetail, ListTriggersQuery, CreateTriggerBody, UpdateTriggerBody, GlobalSearchQuery, GlobalSearchResponse, RunIdStats, GetStackInfoQuery, StackInfo } from './storage/types.js';
+export { c as createGenericFetchClient } from './createGenericFetchClient-Gpom91V-.js';
+export { M as ManagementClientAuthError, i as isManagementClientAuthError } from './authMiddleware-B0p06GYQ.js';
 import { ManagementToken } from './verify/types.js';
-export { c as createStorageSdk } from './storageSdk-bwKHEMB4.js';
+export { c as createStorageSdk } from './storageSdk--0Hh4UCE.js';
 import 'qs';
 import './encryption/index.js';
 import './vault/index.js';
-import './createOpenapiFetchClient-DhL2gQvd.js';
 import './metastore/index.js';
+import './createOpenapiFetchClient-B44nXiti.js';
 
 declare class UserError extends Error {
     constructor(message: string);
@@ -3559,20 +3562,24 @@ type UsageResponse = OpenapiReturnType<paths['/api/usage']['get']>;
 
 declare function assert<T>(value: T | undefined | null, message: string): asserts value is T;
 
+type TaskFn<T> = () => T;
 /**
- * Request coalescing for a single fire-and-forget task. The first call runs the
- * task immediately. Calls made *while* it runs don't start a second run — they
- * mark a single pending rerun, so once the in-flight run settles the task runs
- * exactly once more (looping until no call arrived mid-run). The returned
- * trigger returns `void`: callers fire it and never await.
+ * Coalesces concurrent triggers onto a single, never-parallel run of `task`.
+ * Triggers fired while a run is busy collapse into one trailing run, and each
+ * resolves with the first run that started after it — so it never sees stale state.
  *
- * Unlike a single-flight/dedup helper (where concurrent callers share and await
- * the in-flight promise), `coalesce` guarantees a post-change pass — the final
- * run always reflects the latest trigger. Task rejections and synchronous
- * throws are forwarded to `onError` and never destabilize the coalescer. (An
- * `onError` that itself throws is the caller's responsibility.)
+ * Example — A triggers, then B and C trigger while A's run is still going:
+ *   1. trigger A      → run #1 starts
+ *   2. trigger B, C   → run #1 busy, so they wait
+ *   3. run #1 done    → A resolves
+ *   4. run #2 starts  → covers B and C together (one trailing run, not two)
+ *   5. run #2 done    → B and C resolve
+ *
+ * @returns a trigger; each call returns a promise of the task result.
+ * @throws The returned promise rejects with whatever `task` throws or rejects
+ * with — the caller handles it (try/catch, or `.catch` on `void trigger()`).
  */
-declare const coalesce: (task: () => unknown, onError?: (error: unknown) => void) => (() => void);
+declare const coalesce: <T>(task: TaskFn<T>) => (() => Promise<Awaited<T>>);
 
 declare const delay: (timeout: number, signal?: AbortSignal) => Promise<unknown>;
 
@@ -3605,17 +3612,22 @@ declare const generateUUID: () => `${string}-${string}-${string}-${string}-${str
 declare const series: <T, R>(options: Omit<ConcurrentOptions<T, R>, "concurrency">) => Promise<R[]>;
 
 type Listener<T> = (value: T) => void;
-/**
- * A minimal subscribable value holder: read the current value, replace it, and
- * be notified when it changes. `set` notifies listeners only when the value
- * actually changes (`Object.is`), and `subscribe` returns an unsubscribe fn.
- */
-type Store<T> = {
+type ReadableStore<T> = {
     get: () => T;
-    set: (value: T) => void;
     subscribe: (listener: Listener<T>) => () => void;
 };
+type Store<T> = ReadableStore<T> & {
+    set: (value: T) => void;
+};
 declare const createStore: <T>(initial: T) => Store<T>;
+declare const shallowEqual: <T>(a: T, b: T) => boolean;
+type DerivedStoreOptions<S, K, T> = {
+    source: ReadableStore<S>;
+    dependsOn: (state: S) => K;
+    build: (key: K) => T;
+    keyEquals?: (a: K, b: K) => boolean;
+};
+declare const createDerivedStore: <S, K, T>({ source, dependsOn, build, keyEquals, }: DerivedStoreOptions<S, K, T>) => ReadableStore<T>;
 
 type ServiceUrls = Partial<Record<ServiceId, (url: string) => string | undefined | null>>;
 
@@ -3623,7 +3635,7 @@ type ServiceUrls = Partial<Record<ServiceId, (url: string) => string | undefined
  * Service clients reached through the registry — the key is the `clientName`
  * the user accesses them by (e.g. `api.dataScience`), not the `serviceId`.
  */
-type ServiceClientName = 'vault' | 'dataScience' | 'encryption' | 'editor' | 'syncActions' | 'telemetry' | 'queryService' | 'queue' | 'chat' | 'ai' | 'import' | 'kaiAgent' | 'oauth';
+type ServiceClientName = 'vault' | 'dataScience' | 'encryption' | 'editor' | 'syncActions' | 'telemetry' | 'queryService' | 'queue' | 'chat' | 'ai' | 'import' | 'kaiAgent' | 'oauth' | 'stream';
 /** Clients instantiated directly (not stack-discovered), keyed by their property name. */
 type NonServiceClientName = 'storage' | 'management' | 'assets' | 'status' | 'metastore';
 type MiddlewareTarget = ServiceClientName | NonServiceClientName;
@@ -3642,6 +3654,31 @@ type ApiClientOptions = {
     middlewares?: Middlewares;
     clientServiceUrls?: ServiceUrls;
 } & BaseClientOptions;
+declare const isStorageTokenMutatingRequest: (request: Request) => boolean;
+declare const createLiveProject: ({ initialToken, verify, }: {
+    initialToken: StorageToken;
+    verify: () => Promise<StorageToken>;
+}) => {
+    store: Store<{
+        hasFeature: (...feature: string[]) => boolean;
+        hasAdminFeature: (...feature: string[]) => boolean;
+        hasBackend: (backend: Backend) => boolean;
+        sapiToken: StorageToken;
+    }>;
+    getProject: () => {
+        hasFeature: (...feature: string[]) => boolean;
+        hasAdminFeature: (...feature: string[]) => boolean;
+        hasBackend: (backend: Backend) => boolean;
+        sapiToken: StorageToken;
+    };
+    subscribe: (listener: (value: {
+        hasFeature: (...feature: string[]) => boolean;
+        hasAdminFeature: (...feature: string[]) => boolean;
+        hasBackend: (backend: Backend) => boolean;
+        sapiToken: StorageToken;
+    }) => void) => () => void;
+    middleware: MiddlewareFn;
+};
 declare const createClients: ({ baseUrl, token, assetsBaseUrl, statusBaseUrl, metastoreBaseUrl, clientServiceUrls, middlewares, }: ApiClientOptions) => Promise<{
     sdk: {
         tag: {
@@ -3661,6 +3698,55 @@ declare const createClients: ({ baseUrl, token, assetsBaseUrl, statusBaseUrl, me
                 maxAttempts?: number;
                 abortSignal?: AbortSignal;
             }) => Promise<TableCreateJob>;
+            createTableDefinition: (bucketId: string, body: CreateTableDefinitionBody, options?: {
+                interval?: number;
+                maxAttempts?: number;
+                abortSignal?: AbortSignal;
+            }) => Promise<{
+                id: number;
+                tableId: string | null;
+                runId: string;
+                url: string;
+                createdTime: string;
+                creatorToken: {
+                    id: string;
+                    description: string;
+                };
+                endTime: string | null;
+                startTime: string | null;
+                operationName: "tableDefinitionCreate";
+                operationParams: {
+                    queue: string;
+                } & {
+                    timestampType: string;
+                    primaryKeysNames: string[];
+                    name: string;
+                    backendConfiguration: unknown[];
+                    columns: unknown[];
+                };
+                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: Table;
+            })>;
             importFromFile: (tableId: string, body: TableImportAsyncBody, options?: {
                 interval?: number;
                 maxAttempts?: number;
@@ -3808,167 +3894,822 @@ declare const createClients: ({ baseUrl, token, assetsBaseUrl, statusBaseUrl, me
                 status: "success";
                 results: null;
             })>;
-        };
-        vault: {
-            createVariable: (variable: CreateVariableBody, encryption: EncryptionCtx) => Promise<{
-                key: string;
-                value: string;
-                flags: ("encrypted" | "oauthCredentialsId")[];
-                group?: string;
-                attributes: {
-                    branchId?: string;
-                } & {
-                    [key: string]: string;
+            shareBucketToOrganization: (bucketId: string, options?: {
+                interval?: number;
+                maxAttempts?: number;
+                abortSignal?: AbortSignal;
+            }) => Promise<{
+                id: number;
+                tableId: string | null;
+                runId: string;
+                url: string;
+                createdTime: string;
+                creatorToken: {
+                    id: string;
+                    description: string;
                 };
-            } & {
-                hash?: string;
-            }>;
-            deleteVariable: (variable: VariableWithHash, signal?: AbortSignal) => Promise<void>;
-            updateVariable: (variable: VariableWithHash, encryption: EncryptionCtx, signal?: AbortSignal) => Promise<{
-                key: string;
-                value: string;
-                flags: ("encrypted" | "oauthCredentialsId")[];
-                group?: string;
-                attributes: {
-                    branchId?: string;
-                } & {
-                    [key: string]: string;
+                endTime: string | null;
+                startTime: string | null;
+                operationName: "bucketShareToOrganization";
+                operationParams: {
+                    queue: string;
+                } & Record<string, unknown>;
+                metrics: {
+                    inCompressed: boolean;
+                    inBytes: number;
+                    inBytesUncompressed: number;
+                    outCompressed: boolean;
+                    outBytes: number;
+                    outBytesUncompressed: number;
                 };
-            } & {
-                hash?: string;
-            }>;
-            setVariablesGroup: (group: string, variables: VariableWithHash[], encryption: EncryptionCtx, signal?: AbortSignal) => Promise<({
-                key: string;
-                value: string;
-                flags: ("encrypted" | "oauthCredentialsId")[];
-                group?: string;
-                attributes: {
-                    branchId?: string;
-                } & {
-                    [key: string]: string;
+            } & ({
+                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;
                 };
-            } & {
-                hash?: string;
-            })[]>;
-        };
-    };
-    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";
+            } | {
+                status: "success";
+                results: null;
+            })>;
+            shareBucketToOrganizationProject: (bucketId: string, options?: {
+                interval?: number;
+                maxAttempts?: number;
+                abortSignal?: AbortSignal;
+            }) => Promise<{
+                id: number;
+                tableId: string | null;
+                runId: string;
+                url: string;
+                createdTime: string;
+                creatorToken: {
+                    id: string;
+                    description: string;
+                };
+                endTime: string | null;
+                startTime: string | null;
+                operationName: "bucketShareToOrganizationProject";
+                operationParams: {
+                    queue: string;
+                } & Record<string, unknown>;
+                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;
+            })>;
+            shareBucketToProjects: (bucketId: string, body: ShareBucketToProjectsBody, options?: {
+                interval?: number;
+                maxAttempts?: number;
+                abortSignal?: AbortSignal;
+            }) => Promise<{
+                id: number;
+                tableId: string | null;
+                runId: string;
+                url: string;
+                createdTime: string;
+                creatorToken: {
+                    id: string;
+                    description: string;
+                };
+                endTime: string | null;
+                startTime: string | null;
+                operationName: "bucketShareToProjects";
+                operationParams: {
+                    queue: string;
+                } & Record<string, unknown>;
+                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;
+            })>;
+            shareBucketToUsers: (bucketId: string, body: ShareBucketToUsersBody, options?: {
+                interval?: number;
+                maxAttempts?: number;
+                abortSignal?: AbortSignal;
+            }) => Promise<{
+                id: number;
+                tableId: string | null;
+                runId: string;
+                url: string;
+                createdTime: string;
+                creatorToken: {
+                    id: string;
+                    description: string;
+                };
+                endTime: string | null;
+                startTime: string | null;
+                operationName: "bucketShareToAdmins";
+                operationParams: {
+                    queue: string;
+                } & Record<string, unknown>;
+                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;
+            })>;
+            unshareBucket: (bucketId: string, options?: {
+                interval?: number;
+                maxAttempts?: number;
+                abortSignal?: AbortSignal;
+            }) => Promise<{
+                id: number;
+                tableId: string | null;
+                runId: string;
+                url: string;
+                createdTime: string;
+                creatorToken: {
+                    id: string;
+                    description: string;
+                };
+                endTime: string | null;
+                startTime: string | null;
+                operationName: "bucketRemoveShare";
+                operationParams: {
+                    queue: string;
+                } & Record<string, unknown>;
+                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;
+            })>;
+            forceUnlinkBucket: (bucketId: string, linkedProjectId: string, options?: {
+                interval?: number;
+                maxAttempts?: number;
+                abortSignal?: AbortSignal;
+            }) => Promise<{
+                id: number;
+                tableId: string | null;
+                runId: string;
+                url: string;
+                createdTime: string;
+                creatorToken: {
+                    id: string;
+                    description: string;
+                };
+                endTime: string | null;
+                startTime: string | null;
+                operationName: "bucketForceUnlink";
+                operationParams: {
+                    queue: string;
+                } & Record<string, unknown>;
+                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;
+            })>;
+            registerBucket: (body: RegisterBucketBody, options?: {
+                interval?: number;
+                maxAttempts?: number;
+                abortSignal?: AbortSignal;
+            }) => Promise<{
+                id: number;
+                tableId: string | null;
+                runId: string;
+                url: string;
+                createdTime: string;
+                creatorToken: {
+                    id: string;
+                    description: string;
+                };
+                endTime: string | null;
+                startTime: string | null;
+                operationName: "bucketRegister";
+                operationParams: {
+                    queue: string;
+                } & Record<string, unknown>;
+                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;
+            })>;
+            refreshExternalBucket: (bucketId: string, query?: RefreshExternalBucketQuery, options?: {
+                interval?: number;
+                maxAttempts?: number;
+                abortSignal?: AbortSignal;
+            }) => Promise<{
+                id: number;
+                tableId: string | null;
+                runId: string;
+                url: string;
+                createdTime: string;
+                creatorToken: {
+                    id: string;
+                    description: string;
+                };
+                endTime: string | null;
+                startTime: string | null;
+                operationName: "bucketRefresh";
+                operationParams: {
+                    queue: string;
+                } & Record<string, unknown>;
+                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;
+            })>;
+            createSnapshot: (tableId: string, body?: CreateSnapshotBody, options?: {
+                interval?: number;
+                maxAttempts?: number;
+                abortSignal?: AbortSignal;
+            }) => Promise<{
+                id: number;
+                tableId: string | null;
+                runId: string;
+                url: string;
+                createdTime: string;
+                creatorToken: {
+                    id: string;
+                    description: string;
+                };
+                endTime: string | null;
+                startTime: string | null;
+                operationName: "tableSnapshotCreate";
+                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;
+            })>;
+            pullTable: (tableId: string, options?: {
+                interval?: number;
+                maxAttempts?: number;
+                abortSignal?: AbortSignal;
+            }) => Promise<{
+                id: number;
+                tableId: string | null;
+                runId: string;
+                url: string;
+                createdTime: string;
+                creatorToken: {
+                    id: string;
+                    description: string;
+                };
+                endTime: string | null;
+                startTime: string | null;
+                operationName: "devBranchTablePull";
+                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;
+            })>;
+            addTableColumn: (tableId: string, body: AddTableColumnBody, options?: {
+                interval?: number;
+                maxAttempts?: number;
+                abortSignal?: AbortSignal;
+            }) => Promise<{
+                id: number;
+                tableId: string | null;
+                runId: string;
+                url: string;
+                createdTime: string;
+                creatorToken: {
+                    id: string;
+                    description: string;
+                };
+                endTime: string | null;
+                startTime: string | null;
+                operationName: "tableColumnAdd";
+                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;
+            })>;
+            deleteTableColumn: (tableId: string, columnName: string, query?: DeleteTableColumnQuery, options?: {
+                interval?: number;
+                maxAttempts?: number;
+                abortSignal?: AbortSignal;
+            }) => Promise<{
+                id: number;
+                tableId: string | null;
+                runId: string;
+                url: string;
+                createdTime: string;
+                creatorToken: {
+                    id: string;
+                    description: string;
+                };
+                endTime: string | null;
+                startTime: string | null;
+                operationName: "tableColumnDelete";
+                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;
+            })>;
+            createTablePrimaryKey: (tableId: string, body: CreateTablePrimaryKeyBody, options?: {
+                interval?: number;
+                maxAttempts?: number;
+                abortSignal?: AbortSignal;
+            }) => Promise<{
+                id: number;
+                tableId: string | null;
+                runId: string;
+                url: string;
+                createdTime: string;
+                creatorToken: {
+                    id: string;
+                    description: string;
+                };
+                endTime: string | null;
+                startTime: string | null;
+                operationName: "tablePrimaryKeyAdd";
+                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;
+            })>;
+            removeTablePrimaryKey: (tableId: string, options?: {
+                interval?: number;
+                maxAttempts?: number;
+                abortSignal?: AbortSignal;
+            }) => Promise<{
+                id: number;
+                tableId: string | null;
+                runId: string;
+                url: string;
+                createdTime: string;
+                creatorToken: {
+                    id: string;
+                    description: string;
+                };
+                endTime: string | null;
+                startTime: string | null;
+                operationName: "tablePrimaryKeyDelete";
+                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;
+            })>;
+        };
+        vault: {
+            createVariable: (variable: CreateVariableBody, encryption: EncryptionCtx) => Promise<{
+                key: string;
+                value: string;
+                flags: ("encrypted" | "oauthCredentialsId")[];
+                group?: string;
+                attributes: {
+                    branchId?: string;
+                } & {
+                    [key: string]: string;
+                };
+            } & {
+                hash?: string;
+            }>;
+            deleteVariable: (variable: VariableWithHash, signal?: AbortSignal) => Promise<void>;
+            updateVariable: (variable: VariableWithHash, encryption: EncryptionCtx, signal?: AbortSignal) => Promise<{
+                key: string;
+                value: string;
+                flags: ("encrypted" | "oauthCredentialsId")[];
+                group?: string;
+                attributes: {
+                    branchId?: string;
+                } & {
+                    [key: string]: string;
+                };
+            } & {
+                hash?: string;
+            }>;
+            setVariablesGroup: (group: string, variables: VariableWithHash[], encryption: EncryptionCtx, signal?: AbortSignal) => Promise<({
+                key: string;
+                value: string;
+                flags: ("encrypted" | "oauthCredentialsId")[];
+                group?: string;
+                attributes: {
+                    branchId?: string;
+                } & {
+                    [key: string]: string;
+                };
+            } & {
+                hash?: string;
+            })[]>;
+        };
+    };
+    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;
+            failureReason?: {
+                reason?: string | null;
+                message?: string | null;
+            } | null;
+            mode: "prod" | "dev";
+        }[]>;
+        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;
+            failureReason?: {
+                reason?: string | null;
+                message?: string | null;
+            } | null;
+            mode: "prod" | "dev";
+        }>;
+        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";
+            mode: "prod" | "dev";
+            lastRequestTimestamp: string | null;
+            lastStartTimestamp?: string | null;
+            url?: string | null;
+            autoSuspendAfterSeconds?: number;
+            autoRestartEnabled?: boolean;
+            size?: string | null;
+            provisioningStrategy: "jobQueue" | "operator";
+            hasManagedGitRepo?: boolean;
+        }[]>;
+        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";
+            mode: "prod" | "dev";
+            lastRequestTimestamp: string | null;
+            lastStartTimestamp?: string | null;
+            url?: string | null;
+            autoSuspendAfterSeconds?: number;
+            autoRestartEnabled?: boolean;
+            size?: string | null;
+            provisioningStrategy: "jobQueue" | "operator";
+            hasManagedGitRepo?: boolean;
+        }>;
+        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";
+            mode: "prod" | "dev";
+            lastRequestTimestamp: string | null;
+            lastStartTimestamp?: string | null;
+            url?: string | null;
+            autoSuspendAfterSeconds?: number;
+            autoRestartEnabled?: boolean;
+            size?: string | null;
+            provisioningStrategy: "jobQueue" | "operator";
+            hasManagedGitRepo?: boolean;
+        }>;
+        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";
+            mode: "prod" | "dev";
+            lastRequestTimestamp: string | null;
+            lastStartTimestamp?: string | null;
+            url?: string | null;
+            autoSuspendAfterSeconds?: number;
+            autoRestartEnabled?: boolean;
+            size?: string | null;
+            provisioningStrategy: "jobQueue" | "operator";
+            hasManagedGitRepo?: boolean;
+        }>;
+        deleteApp: (appId: DeleteDataAppPath["appId"], signal?: AbortSignal) => Promise<ApiResponse<never>>;
+        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";
+            mode: "prod" | "dev";
             lastRequestTimestamp: string | null;
             lastStartTimestamp?: string | null;
             url?: string | null;
@@ -3976,772 +4717,1857 @@ declare const createClients: ({ baseUrl, token, assetsBaseUrl, statusBaseUrl, me
             autoRestartEnabled?: boolean;
             size?: string | null;
             provisioningStrategy: "jobQueue" | "operator";
+            hasManagedGitRepo?: boolean;
+        }>;
+        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: "initializing" | "ready" | "loading" | "unloading" | "failed" | "deleted";
+            userId: string;
+            branchId: string;
+            componentId: string;
+            configurationId: string;
+            workspaceSchema: string;
+            workspaceDatabase?: string | null;
+            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: "initializing" | "ready" | "loading" | "unloading" | "failed" | "deleted";
+            userId: string;
+            branchId: string;
+            componentId: string;
+            configurationId: string;
+            workspaceSchema: string;
+            workspaceDatabase?: string | null;
+            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: "initializing" | "ready" | "loading" | "unloading" | "failed" | "deleted";
+            userId: string;
+            branchId: string;
+            componentId: string;
+            configurationId: string;
+            workspaceSchema: string;
+            workspaceDatabase?: string | null;
+            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: "initializing" | "ready" | "loading" | "unloading" | "failed" | "deleted";
+            userId: string;
+            branchId: string;
+            componentId: string;
+            configurationId: string;
+            workspaceSchema: string;
+            workspaceDatabase?: string | null;
+            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: "initializing" | "ready" | "loading" | "unloading" | "failed" | "deleted";
+            userId: string;
+            branchId: string;
+            componentId: string;
+            configurationId: string;
+            workspaceSchema: string;
+            workspaceDatabase?: string | null;
+            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;
+        }>;
+        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: {
+        sendSyncAction: (body: PostActionsBody, signal?: AbortSignal) => Promise<Record<string, never>>;
+        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<never>;
+    };
+    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: "data-compact-boundary";
+                    data: {
+                        trigger: "manual" | "auto";
+                        preTokens: number;
+                        preservedSegment?: {
+                            headUuid: string;
+                            anchorUuid: string;
+                            tailUuid: string;
+                        };
+                        summary: string;
+                        sdkSessionId: string;
+                    };
+                } | {
+                    type: string;
+                    toolCallId: string;
+                    state: "output-available" | "output-error" | "output-denied" | "input-available" | "input-streaming" | "approval-requested" | "approval-responded";
+                    input?: {
+                        [key: string]: unknown;
+                    };
+                    output?: unknown;
+                    errorText?: string;
+                    approval?: {
+                        id: string;
+                        approved: boolean;
+                        reason?: string;
+                    };
+                })[];
+                metadata?: {
+                    createdAt?: string;
+                    hidden?: boolean;
+                    requestContext?: {
+                        path?: string;
+                        sqlEditorActive?: boolean;
+                    };
+                };
+                status?: "pending" | "completed" | "interrupted" | "failed";
+            }[];
+        }>;
+        deleteChat: (chatId: string) => Promise<{
+            id?: string;
+            title?: string;
+            userId?: string;
+            createdAt?: string;
+            visibility?: "public" | "private";
+            branchId?: number | null;
         }>;
-        deleteApp: (appId: DeleteDataAppPath["appId"], signal?: AbortSignal) => Promise<ApiResponse<unknown>>;
-        getAppPassword: (appId: GetDataAppPasswordPath["appId"], signal?: AbortSignal) => Promise<{
-            password?: string;
+        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>;
+        stopChat: (chatId: string) => Promise<{
+            stopped: boolean;
         }>;
-        resetAppPassword: (appId: ResetDataAppPasswordPath["appId"], signal?: AbortSignal) => Promise<{
-            id: string;
-            type?: string | null;
+        getSuggestions: (request: SuggestionsRequestBody, signal?: AbortSignal) => Promise<SuggestionsApiResponse>;
+        getAgentSettings: (signal?: AbortSignal) => Promise<{
             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";
+            customInstructions: string | null;
+            createdAt: string;
+            updatedAt: string;
         }>;
-        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;
+        updateAgentSettings: (request: {
+            customInstructions?: string | null;
+        }, signal?: AbortSignal) => Promise<{
+            projectId: string;
+            customInstructions: string | null;
+            createdAt: string;
+            updatedAt: string;
         }>;
-    };
-    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;
+        getUserAgentSettings: (signal?: AbortSignal) => Promise<{
+            projectId: string;
+            userId: string;
+            customInstructions: string | null;
+            toolPermissions: Record<string, "always_allow" | "always_ask" | "blocked"> | null;
             createdAt: string;
             updatedAt: string;
-            status: "initializing" | "ready" | "loading" | "unloading" | "failed" | "deleted";
+        }>;
+        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;
-            branchId: string;
-            componentId: string;
-            configurationId: string;
-            workspaceSchema: string;
-            workspaceDatabase?: string | null;
-            workspaceId: string;
-            workspaceCreateJobId: string | null;
-            workspaceLoadJobs: {
-                id: string;
-                type: 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;
             }[];
-            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;
+        getSkillsList: (signal?: AbortSignal) => Promise<{
+            skills: {
+                name: string;
+                description: string | null;
+                source: "first-party" | "vendored" | "project";
+            }[];
+            commands: {
+                name: string;
+                description: string;
+            }[];
+        }>;
+        listSandboxFiles: (chatId: string, path?: string, signal?: AbortSignal) => Promise<{
+            entries: {
+                name: string;
+                path: string;
+                type: "file" | "dir";
+                size?: number | undefined;
+            }[];
+        }>;
+        readSandboxFile: (chatId: string, path: string, signal?: AbortSignal) => Promise<{
+            content: string;
+            encoding: "utf-8" | "binary";
+            truncated: boolean;
+            size: number;
+        }>;
+        getSandboxGitBranch: (chatId: string, signal?: AbortSignal) => Promise<{
+            branch: string | null;
+        }>;
+        chatStreamUrl: string;
+    };
+    oauth: {
+        getCredentials: (query?: GetCredentialsQuery, signal?: AbortSignal) => Promise<Credential[]>;
+        getCredential: (componentId: string, id: string, signal?: AbortSignal) => Promise<Credential>;
+        createCredential: (componentId: string, body: CreateCredentialBody, signal?: AbortSignal) => Promise<Credential>;
+        deleteCredential: (componentId: string, id: string, signal?: AbortSignal) => Promise<void>;
+    };
+    stream: {
+        getSources: (branchId: string, query?: PaginationQuery, signal?: AbortSignal) => Promise<{
+            branchId: number;
+            page: components$5["schemas"]["PaginatedResponse"];
+            projectId: number;
+            sources: components$5["schemas"]["Sources"];
+        }>;
+        getDeletedSources: (branchId: string, query?: PaginationQuery, signal?: AbortSignal) => Promise<{
+            branchId: number;
+            page: components$5["schemas"]["PaginatedResponse"];
+            projectId: number;
+            sources: components$5["schemas"]["Sources"];
+        }>;
+        getAggregatedSources: (branchId: string, query?: PaginationQuery, signal?: AbortSignal) => Promise<{
+            branchId: number;
+            page: components$5["schemas"]["PaginatedResponse"];
+            projectId: number;
+            sources: components$5["schemas"]["AggregatedSources"];
+        }>;
+        getSource: (branchId: string, sourceId: string, signal?: AbortSignal) => Promise<{
+            branchId: number;
+            created: components$5["schemas"]["CreatedEntity"];
+            deleted?: components$5["schemas"]["DeletedEntity"];
+            description: string;
+            disabled?: components$5["schemas"]["DisabledEntity"];
+            http?: components$5["schemas"]["HTTPSource"];
+            name: string;
+            otlp?: components$5["schemas"]["OTLPSource"];
+            projectId: number;
+            sourceId: string;
+            type: "http" | "otlp";
+            version: components$5["schemas"]["Version"];
+        }>;
+        createSource: (branchId: string, body: CreateSourceRequestBody, signal?: AbortSignal) => Promise<{
+            createdAt: string;
+            duration?: number;
+            error?: string;
+            finishedAt?: string;
+            isFinished: boolean;
+            outputs?: components$5["schemas"]["TaskOutputs"];
+            result?: string;
+            status: "processing" | "success" | "error";
+            taskId: string;
+            type: string;
+            url: string;
+        }>;
+        updateSource: (branchId: string, sourceId: string, body: UpdateSourceRequestBody, signal?: AbortSignal) => Promise<{
+            createdAt: string;
+            duration?: number;
+            error?: string;
+            finishedAt?: string;
+            isFinished: boolean;
+            outputs?: components$5["schemas"]["TaskOutputs"];
+            result?: string;
+            status: "processing" | "success" | "error";
+            taskId: string;
+            type: string;
+            url: string;
+        }>;
+        deleteSource: (branchId: string, sourceId: string, query?: DeleteSourceQuery, signal?: AbortSignal) => Promise<{
+            createdAt: string;
+            duration?: number;
+            error?: string;
+            finishedAt?: string;
+            isFinished: boolean;
+            outputs?: components$5["schemas"]["TaskOutputs"];
+            result?: string;
+            status: "processing" | "success" | "error";
+            taskId: string;
+            type: string;
+            url: string;
+        }>;
+        disableSource: (branchId: string, sourceId: string, signal?: AbortSignal) => Promise<{
+            createdAt: string;
+            duration?: number;
+            error?: string;
+            finishedAt?: string;
+            isFinished: boolean;
+            outputs?: components$5["schemas"]["TaskOutputs"];
+            result?: string;
+            status: "processing" | "success" | "error";
+            taskId: string;
+            type: string;
+            url: string;
+        }>;
+        enableSource: (branchId: string, sourceId: string, signal?: AbortSignal) => Promise<{
+            createdAt: string;
+            duration?: number;
+            error?: string;
+            finishedAt?: string;
+            isFinished: boolean;
+            outputs?: components$5["schemas"]["TaskOutputs"];
+            result?: string;
+            status: "processing" | "success" | "error";
+            taskId: string;
+            type: string;
+            url: string;
+        }>;
+        undeleteSource: (branchId: string, sourceId: string, signal?: AbortSignal) => Promise<{
+            createdAt: string;
+            duration?: number;
+            error?: string;
+            finishedAt?: string;
+            isFinished: boolean;
+            outputs?: components$5["schemas"]["TaskOutputs"];
+            result?: string;
+            status: "processing" | "success" | "error";
+            taskId: string;
+            type: string;
+            url: string;
+        }>;
+        rotateSourceSecret: (branchId: string, sourceId: string, signal?: AbortSignal) => Promise<{
+            branchId: number;
+            created: components$5["schemas"]["CreatedEntity"];
+            deleted?: components$5["schemas"]["DeletedEntity"];
+            description: string;
+            disabled?: components$5["schemas"]["DisabledEntity"];
+            http?: components$5["schemas"]["HTTPSource"];
+            name: string;
+            otlp?: components$5["schemas"]["OTLPSource"];
+            projectId: number;
+            sourceId: string;
+            type: "http" | "otlp";
+            version: components$5["schemas"]["Version"];
+        }>;
+        getSourceSettings: (branchId: string, sourceId: string, signal?: AbortSignal) => Promise<{
+            settings?: components$5["schemas"]["SettingResult"][];
+        }>;
+        updateSourceSettings: (branchId: string, sourceId: string, body: UpdateSourceSettingsRequestBody, signal?: AbortSignal) => Promise<{
+            createdAt: string;
+            duration?: number;
+            error?: string;
+            finishedAt?: string;
+            isFinished: boolean;
+            outputs?: components$5["schemas"]["TaskOutputs"];
+            result?: string;
+            status: "processing" | "success" | "error";
+            taskId: string;
+            type: string;
+            url: string;
+        }>;
+        clearSourceStatistics: (branchId: string, sourceId: string, signal?: AbortSignal) => Promise<void>;
+        testSource: (branchId: string, sourceId: string, payload: Record<string, unknown>, query?: TestSourceQuery, signal?: AbortSignal) => Promise<{
+            branchId: number;
+            projectId: number;
+            sourceId: string;
+            tables: components$5["schemas"]["TestResultTable"][];
+        }>;
+        getSourceVersions: (branchId: string, sourceId: string, query?: PaginationQuery, signal?: AbortSignal) => Promise<{
+            page: components$5["schemas"]["PaginatedResponse"];
+            versions: components$5["schemas"]["Version"][];
+        }>;
+        getSourceVersion: (branchId: string, sourceId: string, versionNumber: number, signal?: AbortSignal) => Promise<{
+            at: string;
+            by: components$5["schemas"]["By"];
+            description: string;
+            hash: string;
+            number: number;
+        }>;
+        rollbackSourceVersion: (branchId: string, sourceId: string, versionNumber: number, signal?: AbortSignal) => Promise<{
+            createdAt: string;
+            duration?: number;
+            error?: string;
+            finishedAt?: string;
+            isFinished: boolean;
+            outputs?: components$5["schemas"]["TaskOutputs"];
+            result?: string;
+            status: "processing" | "success" | "error";
+            taskId: string;
+            type: string;
+            url: string;
+        }>;
+        getSinks: (branchId: string, sourceId: string, query?: PaginationQuery, signal?: AbortSignal) => Promise<{
+            branchId: number;
+            page: components$5["schemas"]["PaginatedResponse"];
+            projectId: number;
+            sinks: components$5["schemas"]["Sinks"];
+            sourceId: string;
+        }>;
+        getDeletedSinks: (branchId: string, sourceId: string, query?: PaginationQuery, signal?: AbortSignal) => Promise<{
+            branchId: number;
+            page: components$5["schemas"]["PaginatedResponse"];
+            projectId: number;
+            sinks: components$5["schemas"]["Sinks"];
+            sourceId: string;
+        }>;
+        getSink: (branchId: string, sourceId: string, sinkId: string, signal?: AbortSignal) => Promise<{
+            allowedSignals?: ("logs" | "metrics" | "traces")[];
+            branchId: number;
+            created: components$5["schemas"]["CreatedEntity"];
+            deleted?: components$5["schemas"]["DeletedEntity"];
+            description: string;
+            disabled?: components$5["schemas"]["DisabledEntity"];
+            name: string;
+            projectId: number;
+            sinkId: string;
+            sourceId: string;
+            table?: components$5["schemas"]["TableSink"];
+            type: "table";
+            version: components$5["schemas"]["Version"];
+        }>;
+        createSink: (branchId: string, sourceId: string, body: CreateSinkRequestBody, signal?: AbortSignal) => Promise<{
+            createdAt: string;
+            duration?: number;
+            error?: string;
+            finishedAt?: string;
+            isFinished: boolean;
+            outputs?: components$5["schemas"]["TaskOutputs"];
+            result?: string;
+            status: "processing" | "success" | "error";
+            taskId: string;
+            type: string;
+            url: string;
+        }>;
+        updateSink: (branchId: string, sourceId: string, sinkId: string, body: UpdateSinkRequestBody, signal?: AbortSignal) => Promise<{
+            createdAt: string;
+            duration?: number;
+            error?: string;
+            finishedAt?: string;
+            isFinished: boolean;
+            outputs?: components$5["schemas"]["TaskOutputs"];
+            result?: string;
+            status: "processing" | "success" | "error";
+            taskId: string;
+            type: string;
+            url: string;
+        }>;
+        deleteSink: (branchId: string, sourceId: string, sinkId: string, signal?: AbortSignal) => Promise<{
+            createdAt: string;
+            duration?: number;
+            error?: string;
+            finishedAt?: string;
+            isFinished: boolean;
+            outputs?: components$5["schemas"]["TaskOutputs"];
+            result?: string;
+            status: "processing" | "success" | "error";
+            taskId: string;
+            type: string;
+            url: string;
+        }>;
+        disableSink: (branchId: string, sourceId: string, sinkId: string, signal?: AbortSignal) => Promise<{
             createdAt: string;
-            updatedAt: string;
-            status: "initializing" | "ready" | "loading" | "unloading" | "failed" | "deleted";
-            userId: string;
-            branchId: string;
-            componentId: string;
-            configurationId: string;
-            workspaceSchema: string;
-            workspaceDatabase?: string | null;
-            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;
+            duration?: number;
+            error?: string;
+            finishedAt?: string;
+            isFinished: boolean;
+            outputs?: components$5["schemas"]["TaskOutputs"];
+            result?: string;
+            status: "processing" | "success" | "error";
+            taskId: string;
+            type: string;
+            url: string;
         }>;
-        getSessions: (query: GetSqlSessionsQuery, signal?: AbortSignal) => Promise<{
-            id: string;
+        enableSink: (branchId: string, sourceId: string, sinkId: string, signal?: AbortSignal) => Promise<{
             createdAt: string;
-            updatedAt: string;
-            status: "initializing" | "ready" | "loading" | "unloading" | "failed" | "deleted";
-            userId: string;
-            branchId: string;
-            componentId: string;
-            configurationId: string;
-            workspaceSchema: string;
-            workspaceDatabase?: string | null;
-            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"][];
+            duration?: number;
+            error?: string;
+            finishedAt?: string;
+            isFinished: boolean;
+            outputs?: components$5["schemas"]["TaskOutputs"];
+            result?: string;
+            status: "processing" | "success" | "error";
+            taskId: string;
+            type: string;
+            url: string;
         }>;
-        createQueryJob: ({ id }: PostSqlRunQueryPath, body: PostSqlRunQueryBody) => Promise<{
-            queryJobId: string;
+        undeleteSink: (branchId: string, sourceId: string, sinkId: string, signal?: AbortSignal) => Promise<{
+            createdAt: string;
+            duration?: number;
+            error?: string;
+            finishedAt?: string;
+            isFinished: boolean;
+            outputs?: components$5["schemas"]["TaskOutputs"];
+            result?: string;
+            status: "processing" | "success" | "error";
+            taskId: string;
+            type: string;
             url: string;
         }>;
-        tablePreview: ({ id }: PostSqlTablePreviewPath, body: PostSqlTablePreviewBody) => Promise<{
-            queryJobId: string;
+        getSinkSettings: (branchId: string, sourceId: string, sinkId: string, signal?: AbortSignal) => Promise<{
+            settings?: components$5["schemas"]["SettingResult"][];
+        }>;
+        updateSinkSettings: (branchId: string, sourceId: string, sinkId: string, body: UpdateSinkSettingsRequestBody, signal?: AbortSignal) => Promise<{
+            createdAt: string;
+            duration?: number;
+            error?: string;
+            finishedAt?: string;
+            isFinished: boolean;
+            outputs?: components$5["schemas"]["TaskOutputs"];
+            result?: string;
+            status: "processing" | "success" | "error";
+            taskId: string;
+            type: string;
             url: string;
         }>;
-        tableDefinition: ({ id, ...query }: GetSqlSessionTableDdlPath & GetSqlSessionTableDdlQuery, signal?: AbortSignal) => Promise<{
-            ddl: string;
+        getSinkStatisticsTotal: (branchId: string, sourceId: string, sinkId: string, signal?: AbortSignal) => Promise<{
+            levels: components$5["schemas"]["Levels"];
+            total: components$5["schemas"]["Level"];
         }>;
-        load: ({ id }: PostSqlSessionLoadPath, body: PostSqlSessionLoadBody) => Promise<{
-            id: string;
+        getSinkStatisticsFiles: (branchId: string, sourceId: string, sinkId: string, query?: SinkStatisticsFilesQuery, signal?: AbortSignal) => Promise<{
+            files: components$5["schemas"]["SinkFiles"];
+        }>;
+        clearSinkStatistics: (branchId: string, sourceId: string, sinkId: string, signal?: AbortSignal) => Promise<void>;
+        getSinkVersions: (branchId: string, sourceId: string, sinkId: string, query?: PaginationQuery, signal?: AbortSignal) => Promise<{
+            page: components$5["schemas"]["PaginatedResponse"];
+            versions: components$5["schemas"]["Version"][];
+        }>;
+        getSinkVersion: (branchId: string, sourceId: string, sinkId: string, versionNumber: number, signal?: AbortSignal) => Promise<{
+            at: string;
+            by: components$5["schemas"]["By"];
+            description: string;
+            hash: string;
+            number: number;
+        }>;
+        rollbackSinkVersion: (branchId: string, sourceId: string, sinkId: string, versionNumber: number, signal?: AbortSignal) => Promise<{
             createdAt: string;
-            updatedAt: string;
-            status: "initializing" | "ready" | "loading" | "unloading" | "failed" | "deleted";
-            userId: string;
-            branchId: string;
-            componentId: string;
-            configurationId: string;
-            workspaceSchema: string;
-            workspaceDatabase?: string | null;
-            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;
+            duration?: number;
+            error?: string;
+            finishedAt?: string;
+            isFinished: boolean;
+            outputs?: components$5["schemas"]["TaskOutputs"];
+            result?: string;
+            status: "processing" | "success" | "error";
+            taskId: string;
+            type: string;
+            url: string;
         }>;
-        unload: ({ id }: PostSqlSessionUnloadPath, body?: PostSqlSessionUnloadBody) => Promise<{
-            id: string;
+        getTask: (taskId: string, signal?: AbortSignal) => Promise<{
             createdAt: string;
-            updatedAt: string;
-            status: "initializing" | "ready" | "loading" | "unloading" | "failed" | "deleted";
-            userId: string;
-            branchId: string;
-            componentId: string;
-            configurationId: string;
-            workspaceSchema: string;
-            workspaceDatabase?: string | null;
-            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;
+            duration?: number;
+            error?: string;
+            finishedAt?: string;
+            isFinished: boolean;
+            outputs?: components$5["schemas"]["TaskOutputs"];
+            result?: string;
+            status: "processing" | "success" | "error";
+            taskId: string;
+            type: string;
+            url: string;
         }>;
-        resetWorkspacePassword: (id: string) => Promise<{
-            username: string;
-            password: string;
+    };
+    context: {
+        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;
-            database: string;
-            schema: string;
-            warehouse: string;
-        }>;
-        getSessionCredentials: (id: string, signal?: AbortSignal) => Promise<{
-            [key: string]: unknown;
-        }>;
+            revision: string;
+            stack: string;
+            urlTemplates: {
+                orchestrationJob: string;
+            };
+            version: string;
+        };
+        defaultBranch: {
+            id: number;
+            name: string;
+            getType: (branchId?: string | number) => "default" | "dev";
+            isDev: (branchId?: string | number) => boolean;
+            isDefault: (branchId?: string | number) => boolean;
+        };
+        readonly project: {
+            hasFeature: (...feature: string[]) => boolean;
+            hasAdminFeature: (...feature: string[]) => boolean;
+            hasBackend: (backend: Backend) => boolean;
+            sapiToken: StorageToken;
+        };
+        readonly st: StorageTable;
+        serviceMeta: {
+            clientName: string;
+            serviceId: ServiceId;
+            isAvailable: boolean;
+        }[];
     };
-    syncActions: {
-        sendSyncAction: (body: PostActionsBody, signal?: AbortSignal) => Promise<Record<string, never>>;
-        enrollMFA: ({ email, ...rest }: EnrollMFAInput, signal?: AbortSignal) => Promise<Record<string, never>>;
-        gitRepository: {
-            getDataAppPublicGitRepository: ({ repositoryUrl, ...other }: GetDataAppPublicGitRepositoryInput, signal?: AbortSignal) => Promise<{
-                repository: {
-                    url: string;
+    storage: {
+        buckets: {
+            getBuckets: (branchId: string, 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>;
+            getListing: (bucketId: string, signal?: AbortSignal) => Promise<BucketListing | null>;
+            createListing: (bucketId: string, input: CreateBucketListingInput, signal?: AbortSignal) => Promise<Job<"bucketListingCreate">>;
+            updateListing: (bucketId: string, input: UpdateBucketListingInput, signal?: AbortSignal) => Promise<Job<"bucketListingUpdate">>;
+            deleteListing: (bucketId: string, signal?: AbortSignal) => Promise<Job<"bucketListingDelete">>;
+            listListings: (signal?: AbortSignal) => Promise<BucketListing[]>;
+            shareBucketToOrganization: (bucketId: string, signal?: AbortSignal) => Promise<{
+                id: number;
+                tableId: string | null;
+                runId: string;
+                url: string;
+                createdTime: string;
+                creatorToken: {
+                    id: string;
+                    description: string;
+                };
+                endTime: string | null;
+                startTime: string | null;
+                operationName: "bucketShareToOrganization";
+                operationParams: {
+                    queue: string;
+                } & Record<string, unknown>;
+                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;
+            })>;
+            shareBucketToOrganizationProject: (bucketId: string, signal?: AbortSignal) => Promise<{
+                id: number;
+                tableId: string | null;
+                runId: string;
+                url: string;
+                createdTime: string;
+                creatorToken: {
+                    id: string;
+                    description: string;
+                };
+                endTime: string | null;
+                startTime: string | null;
+                operationName: "bucketShareToOrganizationProject";
+                operationParams: {
+                    queue: string;
+                } & Record<string, unknown>;
+                metrics: {
+                    inCompressed: boolean;
+                    inBytes: number;
+                    inBytesUncompressed: number;
+                    outCompressed: boolean;
+                    outBytes: number;
+                    outBytesUncompressed: number;
                 };
-                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;
+            } & ({
+                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;
                 };
-                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;
+            } | {
+                status: "success";
+                results: null;
+            })>;
+            shareBucketToProjects: (bucketId: string, body: ShareBucketToProjectsBody, signal?: AbortSignal) => Promise<{
+                id: number;
+                tableId: string | null;
+                runId: string;
+                url: string;
+                createdTime: string;
+                creatorToken: {
+                    id: string;
+                    description: string;
                 };
-                branches: {
-                    sha: string;
-                    date: string;
-                    comment: string;
-                    branch: string;
-                    author: {
-                        name: string;
-                        email: string;
-                    };
-                }[];
+                endTime: string | null;
+                startTime: string | null;
+                operationName: "bucketShareToProjects";
+                operationParams: {
+                    queue: string;
+                } & Record<string, unknown>;
+                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;
+            })>;
+            shareBucketToUsers: (bucketId: string, body: ShareBucketToUsersBody, signal?: AbortSignal) => Promise<{
+                id: number;
+                tableId: string | null;
+                runId: string;
+                url: string;
+                createdTime: string;
+                creatorToken: {
+                    id: string;
+                    description: string;
+                };
+                endTime: string | null;
+                startTime: string | null;
+                operationName: "bucketShareToAdmins";
+                operationParams: {
+                    queue: string;
+                } & Record<string, unknown>;
+                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;
+            })>;
+            unshareBucket: (bucketId: string, signal?: AbortSignal) => Promise<{
+                id: number;
+                tableId: string | null;
+                runId: string;
+                url: string;
+                createdTime: string;
+                creatorToken: {
+                    id: string;
+                    description: string;
+                };
+                endTime: string | null;
+                startTime: string | null;
+                operationName: "bucketRemoveShare";
+                operationParams: {
+                    queue: string;
+                } & Record<string, unknown>;
+                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;
+            })>;
+            forceUnlinkBucket: (bucketId: string, linkedProjectId: string, signal?: AbortSignal) => Promise<{
+                id: number;
+                tableId: string | null;
+                runId: string;
+                url: string;
+                createdTime: string;
+                creatorToken: {
+                    id: string;
+                    description: string;
+                };
+                endTime: string | null;
+                startTime: string | null;
+                operationName: "bucketForceUnlink";
+                operationParams: {
+                    queue: string;
+                } & Record<string, unknown>;
+                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;
+            })>;
+            getBucketOwner: (bucketId: string, signal?: AbortSignal) => Promise<{
+                id: number;
+                name: string;
+                email: string;
             }>;
-            getPublicGitRepository: ({ repositoryUrl, componentId, ...other }: GetPublicGitRepositoryInput, signal?: AbortSignal) => Promise<{
-                repository: {
-                    url: string;
+            updateBucketOwner: (bucketId: string, body: UpdateBucketOwnerBody, signal?: AbortSignal) => Promise<void>;
+            refreshExternalBucket: (bucketId: string, query?: RefreshExternalBucketQuery, signal?: AbortSignal) => Promise<{
+                id: number;
+                tableId: string | null;
+                runId: string;
+                url: string;
+                createdTime: string;
+                creatorToken: {
+                    id: string;
+                    description: string;
+                };
+                endTime: string | null;
+                startTime: string | null;
+                operationName: "bucketRefresh";
+                operationParams: {
+                    queue: string;
+                } & Record<string, unknown>;
+                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;
+            })>;
+            registerBucket: (body: RegisterBucketBody, signal?: AbortSignal) => Promise<{
+                id: number;
+                tableId: string | null;
+                runId: string;
+                url: string;
+                createdTime: string;
+                creatorToken: {
+                    id: string;
+                    description: string;
+                };
+                endTime: string | null;
+                startTime: string | null;
+                operationName: "bucketRegister";
+                operationParams: {
+                    queue: string;
+                } & Record<string, unknown>;
+                metrics: {
+                    inCompressed: boolean;
+                    inBytes: number;
+                    inBytesUncompressed: number;
+                    outCompressed: boolean;
+                    outBytes: number;
+                    outBytesUncompressed: number;
                 };
-                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;
+            } & ({
+                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;
                 };
-                branches: {
-                    sha: string;
-                    date: string;
-                    comment: string;
-                    branch: string;
-                    author: {
-                        name: string;
-                        email: string;
-                    };
-                }[];
+            } | {
+                status: "success";
+                results: null;
+            })>;
+            getBucketRegistrationGuide: (query: BucketRegistrationGuideQuery, signal?: AbortSignal) => Promise<{
+                markdown: string;
             }>;
+            sharedBuckets: (signal?: AbortSignal) => Promise<Record<string, never>[]>;
+            saveBucketMetadata: (bucketId: string, body: SaveBucketMetadataBody, signal?: AbortSignal) => Promise<{
+                id: number;
+                key: string;
+                value: string | null;
+                provider: string;
+                timestamp: string;
+            }[]>;
+            deleteBucketMetadata: (bucketId: string, metadataId: string, signal?: AbortSignal) => Promise<void>;
         };
-    };
-    telemetry: {
-        provisioning: {
-            createCredentials: (body: CreateCredentialsBody, signal?: AbortSignal) => Promise<WorkspaceData>;
+        events: {
+            getEvents: (query?: GetEventsQuery, signal?: AbortSignal) => Promise<StorageEvent[]>;
+            getEvent: (eventId: string | number, signal?: AbortSignal) => Promise<StorageEvent>;
+            getTableEvents: (tableId: string, query?: GetTableEventsQuery, signal?: AbortSignal) => Promise<TableEvent[]>;
+            createEvent: (body: CreateEventBody, signal?: AbortSignal) => Promise<StorageEvent>;
         };
-    };
-    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;
+        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: (branchId: string, 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>;
+            createTableDefinitionAsync: (bucketId: string, body: CreateTableDefinitionBody, signal?: AbortSignal) => Promise<{
+                id: number;
+                tableId: string | null;
+                runId: string;
+                url: string;
+                createdTime: string;
+                creatorToken: {
+                    id: string;
+                    description: string;
+                };
+                endTime: string | null;
+                startTime: string | null;
+                operationName: "tableDefinitionCreate";
+                operationParams: {
+                    queue: string;
+                } & {
+                    timestampType: string;
+                    primaryKeysNames: string[];
+                    name: string;
+                    backendConfiguration: unknown[];
+                    columns: unknown[];
+                };
+                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: Table;
+            })>;
+            importAsync: (tableId: string, body: TableImportAsyncBody, signal?: AbortSignal) => Promise<TableImportJob>;
+            updateTableDefinition: ({ branchId, tableId, ...body }: UpdateTableDefinitionInput, signal?: AbortSignal) => Promise<{
+                id: number;
+                tableId: string | null;
+                runId: string;
+                url: string;
+                createdTime: string;
+                creatorToken: {
+                    id: string;
+                    description: string;
+                };
+                endTime: string | null;
+                startTime: string | null;
+                operationName: "tableDefinitionUpdate";
+                operationParams: {
+                    queue: string;
+                } & {
+                    tableId: string;
+                    displayName: string;
+                    description?: string | null;
+                    columns: unknown[];
+                };
+                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: Table;
+            })>;
+            updateTable: (tableId: string, body: UpdateTableBody, signal?: AbortSignal) => Promise<Table>;
+            pullTable: (tableId: string, signal?: AbortSignal) => Promise<{
+                id: number;
+                tableId: string | null;
+                runId: string;
+                url: string;
+                createdTime: string;
+                creatorToken: {
+                    id: string;
+                    description: string;
+                };
+                endTime: string | null;
+                startTime: string | null;
+                operationName: "devBranchTablePull";
+                operationParams: {
+                    queue: string;
+                } & {
+                    id: string;
+                };
+                metrics: {
+                    inCompressed: boolean;
+                    inBytes: number;
+                    inBytesUncompressed: number;
+                    outCompressed: boolean;
+                    outBytes: number;
+                    outBytesUncompressed: number;
                 };
-                backend?: {
-                    type?: string;
-                    containerType?: string;
-                    context?: string;
+            } & ({
+                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;
                 };
-            } | 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;
+            } | {
+                status: "success";
+                results: null;
+            })>;
+            createAliasTable: (bucketId: string, body: CreateAliasTableBody, signal?: AbortSignal) => Promise<Table | ({
+                id: number;
+                tableId: string | null;
+                runId: string;
+                url: string;
+                createdTime: string;
+                creatorToken: {
+                    id: string;
+                    description: string;
                 };
-                backend?: {
-                    type?: string;
-                    containerType?: string;
-                    context?: string;
+                endTime: string | null;
+                startTime: string | null;
+                operationName: "aliasCreate";
+                operationParams: {
+                    queue: string;
+                } & {
+                    name: string;
+                    sourceTable: 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: "data-compact-boundary";
-                    data: {
-                        trigger: "manual" | "auto";
-                        preTokens: number;
-                        preservedSegment?: {
-                            headUuid: string;
-                            anchorUuid: string;
-                            tailUuid: string;
-                        };
-                        summary: string;
-                        sdkSessionId: string;
-                    };
-                } | {
-                    type: string;
-                    toolCallId: string;
-                    state: "output-available" | "output-error" | "output-denied" | "input-available" | "input-streaming" | "approval-requested" | "approval-responded";
-                    input?: {
-                        [key: string]: unknown;
-                    };
-                    output?: unknown;
-                    errorText?: string;
-                    approval?: {
-                        id: string;
-                        approved: boolean;
-                        reason?: string;
-                    };
-                })[];
-                metadata?: {
-                    createdAt?: string;
-                    hidden?: boolean;
-                    requestContext?: {
-                        path?: string;
-                        sqlEditorActive?: boolean;
-                    };
+                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;
+            }))>;
+            setAliasTableFilter: (tableId: string, body: SetAliasTableFilterBody, signal?: AbortSignal) => Promise<Table>;
+            removeAliasTableFilter: (tableId: string, signal?: AbortSignal) => Promise<void>;
+            createSnapshot: (tableId: string, body?: CreateSnapshotBody, signal?: AbortSignal) => Promise<{
+                id: number;
+                tableId: string | null;
+                runId: string;
+                url: string;
+                createdTime: string;
+                creatorToken: {
+                    id: string;
+                    description: string;
                 };
-                status?: "pending" | "completed" | "interrupted" | "failed";
-            }[];
-        }>;
-        deleteChat: (chatId: string) => Promise<{
-            id?: string;
-            title?: string;
-            userId?: string;
-            createdAt?: 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>;
-        stopChat: (chatId: string) => Promise<{
-            stopped: boolean;
-        }>;
-        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;
-            }[];
-        }>;
-        listSandboxFiles: (chatId: string, path?: string, signal?: AbortSignal) => Promise<{
-            entries: {
-                name: string;
-                path: string;
-                type: "file" | "dir";
-                size?: number | undefined;
-            }[];
-        }>;
-        readSandboxFile: (chatId: string, path: string, signal?: AbortSignal) => Promise<{
-            content: string;
-            encoding: "utf-8" | "binary";
-            truncated: boolean;
-            size: number;
-        }>;
-        getSandboxGitBranch: (chatId: string, signal?: AbortSignal) => Promise<{
-            branch: string | null;
-        }>;
-        chatStreamUrl: string;
-    };
-    oauth: {
-        getCredentials: (query?: GetCredentialsQuery, signal?: AbortSignal) => Promise<Credential[]>;
-        getCredential: (componentId: string, id: string, signal?: AbortSignal) => Promise<Credential>;
-        createCredential: (componentId: string, body: CreateCredentialBody, signal?: AbortSignal) => Promise<Credential>;
-        deleteCredential: (componentId: string, id: string, signal?: AbortSignal) => Promise<void>;
-    };
-    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<{
+                endTime: string | null;
+                startTime: string | null;
+                operationName: "tableSnapshotCreate";
+                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;
+            })>;
+            deleteSnapshot: (snapshotId: string, signal?: AbortSignal) => Promise<void>;
+            loadTableSnapshots: (tableId: string, signal?: AbortSignal) => Promise<Snapshot[]>;
+            saveTableMetadata: (tableId: string, body: SaveMetadataBody, signal?: AbortSignal) => Promise<Metadata[]>;
+            deleteTableMetadata: (tableId: string, metadataId: string, signal?: AbortSignal) => Promise<void>;
+        };
+        columns: {
+            addTableColumn: (tableId: string, body: AddTableColumnBody, signal?: AbortSignal) => Promise<{
+                id: number;
+                tableId: string | null;
+                runId: string;
+                url: string;
+                createdTime: string;
+                creatorToken: {
+                    id: string;
+                    description: string;
+                };
+                endTime: string | null;
+                startTime: string | null;
+                operationName: "tableColumnAdd";
+                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;
+            })>;
+            deleteTableColumn: (tableId: string, columnName: string, query?: DeleteTableColumnQuery, signal?: AbortSignal) => Promise<{
+                id: number;
+                tableId: string | null;
+                runId: string;
+                url: string;
+                createdTime: string;
+                creatorToken: {
+                    id: string;
+                    description: string;
+                };
+                endTime: string | null;
+                startTime: string | null;
+                operationName: "tableColumnDelete";
+                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;
+            })>;
+            createTablePrimaryKey: (tableId: string, body: CreateTablePrimaryKeyBody, signal?: AbortSignal) => Promise<{
+                id: number;
+                tableId: string | null;
+                runId: string;
+                url: string;
+                createdTime: string;
+                creatorToken: {
+                    id: string;
+                    description: string;
+                };
+                endTime: string | null;
+                startTime: string | null;
+                operationName: "tablePrimaryKeyAdd";
+                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;
+            })>;
+            removeTablePrimaryKey: (tableId: string, signal?: AbortSignal) => Promise<{
                 id: number;
                 tableId: string | null;
                 runId: string;
@@ -4753,7 +6579,7 @@ declare const createClients: ({ baseUrl, token, assetsBaseUrl, statusBaseUrl, me
                 };
                 endTime: string | null;
                 startTime: string | null;
-                operationName: "bucketDelete";
+                operationName: "tablePrimaryKeyDelete";
                 operationParams: {
                     queue: string;
                 } & {
@@ -4782,39 +6608,8 @@ declare const createClients: ({ baseUrl, token, assetsBaseUrl, statusBaseUrl, me
                 status: "success";
                 results: null;
             })>;
-            createScheduledRefresh: (input: CreateScheduledRefreshPath & CreateScheduledRefreshBody) => Promise<ScheduledTask>;
-            deleteScheduledTask: (taskId: string) => Promise<void>;
-            getListing: (bucketId: string, signal?: AbortSignal) => Promise<BucketListing | null>;
-            createListing: (bucketId: string, input: CreateBucketListingInput, signal?: AbortSignal) => Promise<Job<"bucketListingCreate">>;
-            updateListing: (bucketId: string, input: UpdateBucketListingInput, signal?: AbortSignal) => Promise<Job<"bucketListingUpdate">>;
-            deleteListing: (bucketId: string, signal?: AbortSignal) => Promise<Job<"bucketListingDelete">>;
-            listListings: (signal?: AbortSignal) => Promise<BucketListing[]>;
-        };
-        events: {
-            getEvents: (query?: GetEventsQuery, signal?: AbortSignal) => Promise<StorageEvent[]>;
-            getEvent: (eventId: string | number, signal?: AbortSignal) => Promise<StorageEvent>;
-            getTableEvents: (tableId: string, query?: GetTableEventsQuery, signal?: AbortSignal) => Promise<TableEvent[]>;
-            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>;
+            saveColumnMetadata: (columnId: string, body: SaveMetadataBody, signal?: AbortSignal) => Promise<Metadata[]>;
+            deleteColumnMetadata: (columnId: string, metadataId: string, signal?: AbortSignal) => Promise<void>;
         };
         branches: {
             getDevBranches: (signal?: AbortSignal) => Promise<DevBranch[]>;
@@ -5021,7 +6816,15 @@ declare const createClients: ({ baseUrl, token, assetsBaseUrl, statusBaseUrl, me
                     exceptionId?: string;
                 };
             })>;
-            unloadWorkspace: ({ branchId, workspaceId, ...query }: UnloadWorkspaceInput) => Promise<unknown>;
+            unloadWorkspace: ({ branchId, workspaceId, ...query }: UnloadWorkspaceInput) => Promise<Record<string, never>[]>;
+            inputMappingLoadPreview: ({ branchId, body, backend }: WorkspaceInputMappingLoadPreviewInput, signal?: AbortSignal) => Promise<{
+                input: {
+                    source: string;
+                    destination: string;
+                    loadType: "COPY" | "CLONE" | "VIEW";
+                    possibleLoadTypes: ("COPY" | "CLONE" | "VIEW")[];
+                }[];
+            }>;
         };
         mergeRequests: {
             getMergeRequests: (signal?: AbortSignal) => Promise<{
@@ -5236,6 +7039,38 @@ declare const createClients: ({ baseUrl, token, assetsBaseUrl, statusBaseUrl, me
             } & {
                 changeLog?: Record<string, never>;
             }>;
+            mergeMergeRequest: (id: number) => Promise<{
+                id: string;
+                status: string;
+                url: string;
+                tableId: string;
+                operationName: string;
+                operationParams: Record<string, never>;
+                createdTime: string;
+                startTime?: string | null;
+                endTime?: string | null;
+                runId: string;
+                results?: components$6["schemas"]["BucketListingUpdateJobResponse"] | components$6["schemas"]["BucketListingCreateJobResult"] | components$6["schemas"]["BucketListingDeleteResponse"] | components$6["schemas"]["RefreshJobResponse"] | components$6["schemas"]["FileDeleteResponse"] | components$6["schemas"]["TableSnapshotCreateJobResult"] | components$6["schemas"]["TableSwapResult"] | components$6["schemas"]["TableCreateResponse"] | components$6["schemas"]["TableExportJobResponse"];
+                creatorToken: {
+                    id?: string;
+                    description?: string;
+                };
+                metrics: {
+                    inCompressed?: boolean;
+                    inBytes?: number;
+                    inBytesUncompressed?: number;
+                    outCompressed?: boolean;
+                    outBytes?: number;
+                    outBytesUncompressed?: number;
+                };
+                error?: {
+                    code?: string;
+                    message?: string;
+                    exceptionId?: string;
+                    contextParams?: Record<string, never> | null;
+                    uuid?: string | null;
+                } | null;
+            }>;
             getMergeRequestConflicts: (id: number, signal?: AbortSignal) => Promise<{
                 message: string;
                 componentId: string;
@@ -5333,6 +7168,125 @@ declare const createClients: ({ baseUrl, token, assetsBaseUrl, statusBaseUrl, me
         tokens: {
             verify: (signal?: AbortSignal) => Promise<StorageToken>;
             refresh: (id: string, signal?: AbortSignal) => Promise<StorageToken>;
+            getTokens: (signal?: AbortSignal) => Promise<{
+                id: string;
+                created: string;
+                refreshed: string;
+                description?: string | null;
+                uri: string;
+                isMasterToken: boolean;
+                canManageBuckets: boolean;
+                canManageTokens: boolean;
+                canReadAllFileUploads: boolean;
+                canPurgeTrash: boolean;
+                canManageProtectedDefaultBranch: boolean;
+                canCreateJobs: boolean;
+                canReadAllProjectEvents: boolean;
+                canManageDevBranches: boolean;
+                expires?: string | null;
+                isExpired: boolean;
+                isDisabled: boolean;
+                dailyCapacity: number;
+                token?: string | null;
+                creatorToken?: {
+                    id?: number;
+                    description?: string;
+                } | null;
+                componentAccess?: string[] | null;
+                bucketPermissions: {
+                    [key: string]: string;
+                };
+                admin?: {
+                    name?: string;
+                    id?: number;
+                    role?: string;
+                } | null;
+            }[]>;
+            createToken: (body: CreateTokenBody, signal?: AbortSignal) => Promise<{
+                id: string;
+                token: string;
+                created: string;
+                refreshed: string;
+                description?: string | null;
+                uri: string;
+                isMasterToken: boolean;
+                canManageBuckets: boolean;
+                canManageTokens: boolean;
+                canReadAllFileUploads: boolean;
+                canPurgeTrash: boolean;
+                expires?: string | null;
+                isExpired: boolean;
+                isDisabled: boolean;
+                dailyCapacity: number;
+                creatorToken: {
+                    id?: number;
+                    description?: string;
+                };
+                bucketPermissions: {
+                    [key: string]: string;
+                };
+                canManageProtectedDefaultBranch: boolean;
+                canCreateJobs: boolean;
+                canReadAllProjectEvents: boolean;
+                canManageDevBranches: boolean;
+            }>;
+            updateToken: (id: string, body: UpdateTokenBody, signal?: AbortSignal) => Promise<StorageToken>;
+            deleteToken: (id: string, signal?: AbortSignal) => Promise<void>;
+            shareToken: (id: string, body: ShareTokenBody, signal?: AbortSignal) => Promise<void>;
+        };
+        triggers: {
+            listTriggers: (query?: ListTriggersQuery, signal?: AbortSignal) => Promise<{
+                id: string;
+                runWithTokenId: number;
+                component: string;
+                configurationId: string;
+                lastRun?: string | null;
+                creatorToken: {
+                    id: number;
+                    description: string;
+                };
+                coolDownPeriodMinutes: number;
+                tables: {
+                    tableId: string;
+                }[];
+            }[]>;
+            createTrigger: (body: CreateTriggerBody, signal?: AbortSignal) => Promise<{
+                id: string;
+                runWithTokenId: number;
+                component: string;
+                configurationId: string;
+                lastRun?: string | null;
+                creatorToken: {
+                    id: number;
+                    description: string;
+                };
+                coolDownPeriodMinutes: number;
+                tables: {
+                    tableId: string;
+                }[];
+            }>;
+            updateTrigger: (triggerId: string, body: UpdateTriggerBody, signal?: AbortSignal) => Promise<{
+                id: string;
+                runWithTokenId: number;
+                component: string;
+                configurationId: string;
+                lastRun?: string | null;
+                creatorToken: {
+                    id: number;
+                    description: string;
+                };
+                coolDownPeriodMinutes: number;
+                tables: {
+                    tableId: string;
+                }[];
+            }>;
+            deleteTrigger: (triggerId: string, signal?: AbortSignal) => Promise<void>;
+        };
+        search: {
+            globalSearch: (query: GlobalSearchQuery, signal?: AbortSignal) => Promise<GlobalSearchResponse>;
+        };
+        stats: {
+            getRunIdStats: (runId: string, signal?: AbortSignal) => Promise<RunIdStats>;
         };
         getStackInfo: (query?: GetStackInfoQuery, signal?: AbortSignal) => Promise<StackInfo>;
     };
@@ -5400,7 +7354,22 @@ declare const createClients: ({ baseUrl, token, assetsBaseUrl, statusBaseUrl, me
             }>;
             acceptOrganizationInvitation: (id: number) => Promise<void>;
             rejectOrganizationInvitation: (id: number) => Promise<void>;
-            getProjectInvitations: (signal?: AbortSignal) => Promise<Record<string, never>[]>;
+            getProjectInvitations: (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;
+                };
+            }[]>;
             getProjectInvitation: (id: number, signal?: AbortSignal) => Promise<{
                 id: number;
                 created: string;
@@ -5419,49 +7388,21 @@ declare const createClients: ({ baseUrl, token, assetsBaseUrl, statusBaseUrl, me
             }>;
             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<{
+            getProjectJoinRequests: (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: {
-                    id: number;
-                    name: string;
-                }[];
+                expires?: string | null;
+                reason?: string | null;
+                project: {
+                    id?: number;
+                    name?: string;
+                };
             }[]>;
-            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: {
-                    id: number;
-                    name: string;
-                }[];
-            } & {
-                organizations?: components$5["schemas"]["OrganizationResponse"][];
-            }>;
+            deleteProjectJoinRequest: (id: number) => Promise<void>;
+        };
+        maintainers: {
+            getMaintainers: (signal?: AbortSignal) => Promise<Maintainer[]>;
+            getMaintainer: (maintainerId: number, signal?: AbortSignal) => Promise<MaintainerDetail>;
             createMaintainer: (body: CreateMaintainerBody) => Promise<{
                 id: number;
                 name: string;
@@ -5475,8 +7416,8 @@ declare const createClients: ({ baseUrl, token, assetsBaseUrl, statusBaseUrl, me
                 defaultFileStorageId?: number | null;
                 zendeskUrl?: string | null;
                 organizations: {
-                    id: number;
-                    name: string;
+                    id?: number;
+                    name?: string;
                 }[];
             }>;
             updateMaintainer: ({ maintainerId, ...body }: {
@@ -5494,8 +7435,8 @@ declare const createClients: ({ baseUrl, token, assetsBaseUrl, statusBaseUrl, me
                 defaultFileStorageId?: number | null;
                 zendeskUrl?: string | null;
                 organizations: {
-                    id: number;
-                    name: string;
+                    id?: number;
+                    name?: string;
                 }[];
             }>;
             deleteMaintainer: (maintainerId: number) => Promise<void>;
@@ -5515,7 +7456,20 @@ declare const createClients: ({ baseUrl, token, assetsBaseUrl, statusBaseUrl, me
                 maintainerId: number;
                 adminId: number;
             }) => Promise<void>;
-            getMaintainerInvitations: (maintainerId: number, signal?: AbortSignal) => Promise<Record<string, never>[]>;
+            getMaintainerInvitations: (maintainerId: number, signal?: AbortSignal) => Promise<{
+                id: number;
+                created?: string | null;
+                user: {
+                    id?: number;
+                    name?: string;
+                    email?: string;
+                };
+                creator: {
+                    id?: number;
+                    name?: string;
+                    email?: string;
+                };
+            }[]>;
             getMaintainerInvitation: ({ maintainerId, invitationId }: {
                 maintainerId: number;
                 invitationId: number;
@@ -5563,7 +7517,6 @@ declare const createClients: ({ baseUrl, token, assetsBaseUrl, statusBaseUrl, me
                 crmId?: string | null;
                 activityCenterProjectId?: number | null;
                 mfaRequired: boolean;
-                projectsCount: number;
             }>;
             getMaintainerMetadata: (maintainerId: number, signal?: AbortSignal) => Promise<MetadataItem[]>;
             setMaintainerMetadata: ({ maintainerId, ...body }: {
@@ -5608,7 +7561,12 @@ declare const createClients: ({ baseUrl, token, assetsBaseUrl, statusBaseUrl, me
                 crmId?: string | null;
                 activityCenterProjectId?: number | null;
                 mfaRequired: boolean;
-                projectsCount: number;
+            } & {
+                projects: {
+                    id: number;
+                    name: string;
+                    created: string;
+                }[];
             }>;
             deleteOrganization: (organizationId: number) => Promise<void>;
             forceMfa: (organizationId: number) => Promise<{
@@ -5619,7 +7577,12 @@ declare const createClients: ({ baseUrl, token, assetsBaseUrl, statusBaseUrl, me
                 crmId?: string | null;
                 activityCenterProjectId?: number | null;
                 mfaRequired: boolean;
-                projectsCount: number;
+            } & {
+                projects: {
+                    id: number;
+                    name: string;
+                    created: string;
+                }[];
             }>;
             joinOrganization: (organizationId: number) => Promise<void>;
             getOrganizationUsers: (organizationId: number, signal?: AbortSignal) => Promise<{
@@ -5728,10 +7691,16 @@ declare const createClients: ({ baseUrl, token, assetsBaseUrl, statusBaseUrl, me
                 defaultBackend: string;
                 hasTryModeOn: string;
                 limits: {
-                    [key: string]: Record<string, never>;
+                    [key: string]: {
+                        name?: string;
+                        value?: number;
+                    };
                 };
                 metrics: {
-                    [key: string]: Record<string, never>;
+                    [key: string]: {
+                        name?: string;
+                        value?: number;
+                    };
                 };
                 isDisabled: boolean;
                 billedMonthlyPrice?: number | null;
@@ -5759,6 +7728,12 @@ declare const createClients: ({ baseUrl, token, assetsBaseUrl, statusBaseUrl, me
                 metadataId: number;
             }) => Promise<void>;
         };
+        features: {
+            getAllFeatures: (query: GetAllFeaturesQuery, signal?: AbortSignal) => Promise<Feature[]>;
+            getFeature: (featureId: number, signal?: AbortSignal) => Promise<Feature>;
+            getFeatureProjects: (featureId: number, signal?: AbortSignal) => Promise<FeatureProject[]>;
+            getFeatureAdmins: (featureId: number, signal?: AbortSignal) => Promise<FeatureAdmin[]>;
+        };
         projects: {
             getProject: (projectId: GetProjectPath["projectId"], signal?: AbortSignal) => Promise<Project>;
             addProjectFeature: ({ projectId, feature, }: CreateProjectFeaturePath & CreateProjectFeatureBody) => Promise<Project>;
@@ -5769,10 +7744,57 @@ declare const createClients: ({ baseUrl, token, assetsBaseUrl, statusBaseUrl, me
                 role: User["role"];
             }) => Promise<User>;
             getProjectUsers: (projectId: ListProjectUsersPath["projectId"], signal?: AbortSignal) => Promise<User[]>;
+            getProjectInvitations: (projectId: ListProjectInvitationsPath["projectId"], signal?: AbortSignal) => Promise<{
+                id: number;
+                created?: string | null;
+                expires?: string | null;
+                reason?: string | null;
+                role?: string | null;
+                user: {
+                    id?: number;
+                    name?: string;
+                    email?: string;
+                };
+                creator: {
+                    id?: number;
+                    name?: string;
+                    email?: string;
+                };
+            }[]>;
+            createProjectInvitation: ({ projectId, ...body }: CreateProjectInvitationPath & CreateProjectInvitationBody) => Promise<{
+                id: number;
+                created?: string | null;
+                expires?: string | null;
+                reason?: string | null;
+                role?: string | null;
+                user: {
+                    id?: number;
+                    name?: string;
+                    email?: string;
+                };
+                creator: {
+                    id?: number;
+                    name?: string;
+                    email?: string;
+                };
+            }>;
+            deleteProjectInvitation: ({ projectId, invitationId, }: DeleteProjectInvitationPath) => Promise<null>;
+            addProjectUser: ({ projectId, ...body }: AddProjectUserPath & AddProjectUserBody) => Promise<User>;
+            removeProjectUser: ({ projectId, idOrEmail }: RemoveProjectUserPath) => Promise<null>;
             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>;
+            updateProject: ({ projectId, ...body }: {
+                projectId: number;
+            } & UpdateProjectBody) => Promise<Project>;
+            deleteProject: (projectId: number) => Promise<null>;
+            moveProject: ({ projectId, organizationId, }: {
+                projectId: number;
+            } & MoveProjectBody) => Promise<Project>;
+            setProjectDisabled: ({ projectId, ...body }: {
+                projectId: number;
+            } & SetProjectDisabledBody) => Promise<Project>;
         };
         users: {
             addUserAdminFeature: ({ feature, userIdOrMail }: AddUserFeatureBody & AddUserFeaturePath, signal?: AbortSignal) => Promise<User>;
@@ -5782,30 +7804,31 @@ declare const createClients: ({ baseUrl, token, assetsBaseUrl, statusBaseUrl, me
             id: number;
             description: string;
             created: string;
-            lastUsed?: string | null;
-            expires?: string | null;
+            lastUsed: string | null;
+            expires: string | null;
             isSessionToken: boolean;
             isExpired: boolean;
             isDisabled: boolean;
             scopes: string[];
             type: string;
             creator: {
-                id?: number;
-                name?: string;
+                id: number;
+                name: string;
             };
             user?: {
-                id?: number;
-                name?: string;
-                email?: string;
-                mfaEnabled?: boolean;
-                features?: string[];
-                canAccessLogs?: boolean;
-                isSuperAdmin?: boolean;
+                id: number;
+                name: string;
+                email: string;
+                mfaEnabled: boolean;
+                features: string[];
+                canAccessLogs: boolean;
+                isSuperAdmin: boolean;
             } | null;
         }>;
     };
 }>;
 type Clients = Awaited<ReturnType<typeof createClients>>;
+type ClientContext = Clients['context'];
 type ApiClient = {
     init: (options: ApiClientOptions) => Promise<void>;
 } & Clients;
@@ -5852,12 +7875,6 @@ type RetryOptions = {
 };
 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>;
@@ -5865,4 +7882,4 @@ declare const createDevApiClient: () => {
     };
 };
 
-export { type ApiClient, type ApiClientOptions, ApiError, ConcurrentOptions, type FetchClientError, HttpContentType, HttpHeader, KeboolaHttpHeader, KeboolaObjectId, type Log, type LogLevel, type Logger, type LoggingOptions, MiddlewareFn, PollException, type RequestLog, type ResponseLog, type RetryOptions, ServiceUnavailableError, type Store, UserError, assert, coalesce, createApiClient, createDevApiClient, createLoggingMiddleware, createRetryMiddleware, createStore, delay, generateUUID, isAbortError, isApiError, isFetchClientError, poll, series };
+export { type ApiClient, type ApiClientOptions, ApiError, type ClientContext, ConcurrentOptions, type FetchClientError, HttpContentType, HttpHeader, KeboolaObjectId, type Log, type LogLevel, type Logger, type LoggingOptions, MiddlewareFn, PollException, type ReadableStore, type RequestLog, type ResponseLog, type RetryOptions, ServiceUnavailableError, type Store, UserError, assert, coalesce, createApiClient, createDerivedStore, createDevApiClient, createLiveProject, createLoggingMiddleware, createRetryMiddleware, createStore, delay, generateUUID, isAbortError, isApiError, isFetchClientError, isStorageTokenMutatingRequest, poll, series, shallowEqual };