@keboola/api-client 25.0.0 → 27.0.0

package/dist/index.d.ts

@@ -1,60 +1,68 @@
 import { c as createDefaultBranch, R as RegisteredComponentId } from './registry-CcKlB-yY.js';
-import { P as Project } from './project-CXqPYo4T.js';
-import { ServiceId, StackInfo, Service, StackComponent, ConfigurationPath, BaseComponentConfig, CreateConfigurationInput, UpdateConfigurationInput, CreateTableAsyncBody, TableCreateJob, CreateTableDefinitionBody, JobStatus, Table, TableImportAsyncBody, TableImportJob, TableExportAsyncBody, TableExportJob, BucketListing, CreateBucketListingInput, UpdateBucketListingInput, ShareBucketToProjectsBody, ShareBucketToUsersBody, RegisterBucketBody, RefreshExternalBucketQuery, CreateSnapshotInput, AddTableColumnBody, DeleteTableColumnQuery, CreateTablePrimaryKeyBody, GetBucketsQuery, Bucket, GetBucketInput, BucketDetail, CreateBucketBody, UpdateBucketBody, CreateScheduledRefreshPath, CreateScheduledRefreshBody, ScheduledTask, Job, GetBucketOwnerInput, UpdateBucketOwnerBody, BucketRegistrationGuideQuery, SaveBucketMetadataBody, GetEventsQuery, StorageEvent, GetTableEventsInput, TableEvent, GetBucketEventsInput, CreateEventBody, File, GetFilesQuery, DeleteFileTagPath, PrepareFileBody, PreparedFile, GetTablesQuery, GetTableInput, TableDetail, GetDataPreviewInput, PreviewData, DeleteTableRows, JobUnion, UpdateTableDefinitionInput, UpdateTableBody, CreateAliasTableBody, SetAliasTableFilterBody, LoadTableSnapshotsInput, 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, ConfigType, PartialKey, ComponentConfig, ConfigurationDiffPath, ConfigurationDiff, ConfigurationRowDiffPath, ConfigurationRowDiff, RebaseConfigurationInput, GetConfigurationsPath, CreateConfigurationRowInput, Row, CreateConfigurationRowsInput, CreateConfigurationRowBody, DeleteConfigurationRowInput, DeleteConfigurationRowsInput, CreateConfigurationWorkspaceBody, ConfigurationUseCaseType, SaveConfigurationMetadataInput, ConfigurationMetadataItem, ConfigurationVersionPath, ConfigurationVersion, ConfigurationVersionDetailPath, ConfigurationVersionDetail, RollbackConfigurationToVersionInput, CopyConfigurationFromVersionInput, ListTriggersQuery, CreateTriggerBody, UpdateTriggerBody, GlobalSearchQuery, GlobalSearchResponse, RunIdStats, GetStackInfoQuery } from './storage/types.js';
+import { P as Project } from './project-Dmr-zrQG.js';
+import { ServiceId, StackInfo, Service, StackComponent, ConfigurationPath, BaseComponentConfig, CreateConfigurationInput, UpdateConfigurationInput, CreateTableAsyncBody, TableCreateJob, CreateTableDefinitionBody, JobStatus, Table, TableImportAsyncBody, TableImportJob, TableExportAsyncBody, TableExportJob, CreateBucketListingBody, UpdateBucketListingBody, ShareBucketToOrganizationInput, ShareBucketToOrganizationProjectInput, ShareBucketToProjectsInput, ShareBucketToUsersInput, UnshareBucketInput, ForceUnlinkBucketInput, RegisterBucketBody, RefreshExternalBucketQuery, CreateSnapshotInput, PullTableAsyncInput, AddTableColumnBody, DeleteTableColumnQuery, CreateTablePrimaryKeyBody, GetStackInfoQuery, GetBucketsInput, Bucket, GetBucketInput, BucketDetail, CreateBucketBody, UpdateBucketInput, DeleteBucketAsyncInput, GetBucketOwnerInput, UpdateBucketOwnerInput, SaveBucketMetadataInput, DeleteBucketMetadataInput, LinkBucketBody, CreateBucketListingInput, UpdateBucketListingInput, BucketRegistrationGuideQuery, RefreshExternalBucketInput, CreateScheduledRefreshInput, ScheduledTask, GetTablesInput, GetTableInput, TableDetail, GetDataPreviewInput, PreviewData, DeleteTableRowsInput, JobUnion, ExportAsyncInput, CreateTableAsyncInput, CreateTableDefinitionInput, ImportAsyncInput, UpdateTableDefinitionInput, UpdateTableInput, CreateAliasTableInput, SetAliasTableFilterInput, SaveTableMetadataInput, DeleteTableMetadataInput, AddTableColumnInput, DeleteTableColumnInput, CreateTablePrimaryKeyInput, SaveColumnMetadataInput, DeleteColumnMetadataInput, Snapshot, GetTableSnapshotsInput, DevBranch, UpdateDevBranchInput, CreateDevBranchBody, SaveDevBranchMetadataInput, DeleteDevBranchMetadataPath, MergeRequestDetail, MergeRequestDetailWithActivityLog, CreateMergeRequestParams, UpdateMergeRequestParams, GetEventsQuery, StorageEvent, GetTableEventsInput, TableEvent, GetBucketEventsInput, CreateEventBody, File, GetFilesQuery, DeleteFileTagPath, PrepareFileBody, PreparedFile, WorkspacePath, Workspace, WorkspacesPath, ResetWorkspacePassword, SetWorkspacePublicInput, GetWorkspaceSaml2LoginPath, WorkspaceSaml2Login, WorkspaceObject, DeleteWorkspaceObjectInput, UnloadWorkspaceInput, WorkspaceInputMappingLoadPreviewInput, JobOperation, GetJobPath, Job, GetJobsQuery, GetTriggersQuery, CreateTriggerBody, UpdateTriggerInput, Trigger, GlobalSearchQuery, GlobalSearchResponse, SearchTablesQuery, RunIdStats, GetComponentPath, Component, GetComponentsInput, ConfigType, PartialKey, UpdateConfigurationResult, UpdateConfigurationStateInput, ComponentConfig, ConfigurationDiffPath, ConfigurationDiff, RebaseConfigurationInput, DeleteConfigurationInput, PurgeConfigurationInput, PurgeConfigurationsInput, GetConfigurationsPath, SearchComponentConfigurationsInput, SearchComponentConfiguration, CreateConfigurationRowInput, Row, CreateConfigurationRowsInput, CreateConfigurationRowBody, GetConfigurationRowInput, UpdateConfigurationRowInput, UpdateConfigurationRowStateInput, DeleteConfigurationRowInput, DeleteConfigurationRowsInput, CreateConfigurationWorkspaceInput, ConfigurationUseCaseType, GetConfigurationWorkspacesPath, GetConfigurationMetadataInput, ConfigurationMetadataItem, SaveConfigurationMetadataInput, DeleteConfigurationMetadataInput, ConfigurationVersionPath, ConfigurationVersion, ConfigurationVersionDetailPath, ConfigurationVersionDetail, RollbackConfigurationToVersionInput, RollbackConfigurationToVersionResult, CopyConfigurationFromVersionInput, CopyConfigurationFromVersionResult, ConfigurationRowVersionPath, ConfigurationRowVersion, ConfigurationRowVersionDetailPath, ConfigurationRowVersionDetail, RollbackConfigurationRowToVersionInput, CopyConfigurationRowFromVersionInput } from './storage/types.js';
 import { createStorageTable } from './domain/storageTable/index.js';
 import { M as MiddlewareFn, A as ApiResponse, H as HttpMethod } from './types-UwuKN9Kx.js';
 export { a as ApiError, c as AuthStrategy, d as BaseClientOptions } from './types-UwuKN9Kx.js';
 import { createAuthClient } from './auth/index.js';
 import { createManagementClient } from './management/index.js';
 export { isManagementClientAuthError } from './management/index.js';
-import { C as ConcurrentOptions, M as MiddlewareFn$1 } from './storageClient-Cd4jVt58.js';
-export { a as concurrent } from './storageClient-Cd4jVt58.js';
+import { C as ConcurrentOptions, M as MiddlewareFn$1 } from './storageClient-BX50Attd.js';
+export { a as concurrent } from './storageClient-BX50Attd.js';
 import { K as KeboolaObjectId } from './keboolaUID-D1DGSbge.js';
 export { k as keboolaUID } from './keboolaUID-D1DGSbge.js';
 import * as zod from 'zod';
 import { z } from 'zod';
-import { c as components$8, S as StorageToken, C as CreateTokenBody, U as UpdateTokenBody, a as ShareTokenBody } from './types-00IaLn3S.js';
-import { M as MetaObject, G as GetMetaObjectsPath, a as MetaStoreListResponse, b as GetMetaObjectRevisionsPath, c as GetMetaObjectPath, d as MetaStoreObjectResponse, C as CreateMetaObjectInput, D as DeleteMetaObjectPath, U as UpdateMetaObjectInput, R as ReplaceMetaObjectInput, e as GetMetaObjectRevisionPath, f as DeleteMetaObjectRevisionPath, g as GetSchemaPath, h as components$7, i as GetVersionedSchemaPath } from './types-B30y9Lhc.js';
-import { L as ListSubscriptionsQuery, c as components$6, S as SubscriptionId, C as CreateSubscriptionBody } from './types-DpUcInCX.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-CiJ5ULtS.js';
+import { c as components$a, S as StorageToken, C as CreateTokenBody, U as UpdateTokenInput, a as ShareTokenInput } from './types-EZBBpiFU.js';
+import { M as MetaObject, G as GetMetaObjectsPath, a as MetaStoreListResponse, b as GetMetaObjectRevisionsPath, c as GetMetaObjectPath, d as MetaStoreObjectResponse, C as CreateMetaObjectInput, D as DeleteMetaObjectPath, U as UpdateMetaObjectInput, R as ReplaceMetaObjectInput, e as ReplaceTargetProjectsInput, f as GetMetaObjectRevisionPath, g as DeleteMetaObjectRevisionPath, h as GetSchemaPath, i as components$9, j as GetVersionedSchemaPath } from './types-D6dnnju2.js';
+import { L as ListSubscriptionsQuery, c as components$8, S as SubscriptionId, C as CreateSubscriptionBody } from './types-COti0FGo.js';
+import { P as PaginationQuery, c as components$7, 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-CfzHhZVG.js';
 import { GetSchedulesQuery, ActivateScheduleBody, SchedulePath, ConfigurationPath as ConfigurationPath$1 } from './scheduler/types.js';
 import { GetCredentialsInput, CredentialInput, CreateCredentialInput } from './oauth/types.js';
-import { c as OpenapiQueryType, d as OpenapiPathType, O as OpenapiBodyType, b as OpenapiReturnType } from './types-gcShAmmi.js';
-import { U as UploadFileInput, a as UploadProgress, W as WriteTableInput } from './types-YzkNUuYo.js';
-import { D as DescribeConfigurationVersionBody, a as DescribeConfigurationMergeBody, E as ExplainErrorBody, b as DescribeConfigurationBody, S as SuggestComponentBody, c as components$4, F as FeedbackBody, d as DocsQuestionBody } from './types-CrLjE5xf.js';
+import { c as OpenapiQueryType, d as OpenapiPathType, O as OpenapiBodyType, b as OpenapiReturnType } from './types-f8dUjMX4.js';
+import { U as UploadFileInput, a as UploadProgress, W as WriteTableInput } from './types-DrGnvgkB.js';
+import { G as GetProjectsLineageQuery, c as components$6, a as GetTablesLineageQuery, T as TablesLineageResponse } from './types-DOc5_aYZ.js';
+import { D as DescribeConfigurationVersionBody, a as DescribeConfigurationMergeBody, E as ExplainErrorBody, b as DescribeConfigurationBody, S as SuggestComponentBody, c as components$5, F as FeedbackBody, d as DocsQuestionBody } from './types-DM1glEQI.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 Vote, d as VoteRequest$1, U as UsageResponse$1, A as AgentSettings, e as UpdateAgentSettingsRequest, f as UserAgentSettings, g as UpdateUserAgentSettingsRequest, T as ToolsListResponse } from './types-DbAO-Tgk.js';
-import { G as GetQueueJobPath, c as components$2, S as SearchJobsQuery, a as SearchAllJobsQuery, C as CreateJobBody, K as KillJobPath, b as SearchGroupedJobsQuery, O as OrchestrationRerunPlanPath } from './types-DwMezEHT.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-DeS-oVdn.js';
+import { G as GetHistoryQuery$1, c as components$4, a as GetChatPath$1, C as ChatRequest$1, b as GetVotesQuery$1, V as Vote, d as VoteRequest$1, U as UsageResponse$1, A as AgentSettings, e as UpdateAgentSettingsRequest, f as UserAgentSettings, g as UpdateUserAgentSettingsRequest, T as ToolsListResponse } from './types-BALUbGA5.js';
+import { G as GetQueueJobPath, c as components$3, S as SearchJobsQuery, a as SearchAllJobsQuery, C as CreateJobBody, K as KillJobPath, b as SearchGroupedJobsQuery, O as OrchestrationRerunPlanPath } from './types-D2qGShlS.js';
+import { P as PostQueryPath, a as PostQueryBody, b as PostCancelQueryJobPath, G as GetQueryJobPath, c as components$2, d as GetQueryResultsPath, e as GetQueryResutsQuery, f as GetQueriesPath, g as GetQueriesHistoryQuery, h as GetExportResultsQuery, E as ExportResultsResponse } from './types-ebolWqn1.js';
 import { CreateCredentialsBody, WorkspaceData } from './telemetry/types.js';
-import { SyncActionBody, EnrollMFAInput, ApifyObjectsInput, GetDataAppPublicGitRepositoryInput, GetDataAppPasswordPrivateGitRepositoryInput, GetDataAppSSHKeyPrivateGitRepositoryInput, GetPublicGitRepositoryInput, GetGitPrivateRepositoryInput } from './syncActions/types.js';
+import { SyncActionBody, EnrollMFAInput, ApifyObjectsInput, DbtActionInput, GetBranchesInput, GetEntrypointsInput, TestLookerCredentialsInput } from './syncActions/types.js';
 import { SendSyncActionOptions } from './syncActions/index.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-DHXZZKb3.js';
+import { C as CreateSqlSessionBody, G as GetSqlSessionPath, a as GetSqlSessionsQuery, b as GetSqlSessionSchemaPath, c as GetSqlSessionSchemaQuery, d as components$1, 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-Dpwb4dD0.js';
 import { EncryptQuery, ScopedSecrets } 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, k as DeleteSandboxPath } from './utils-B_SOM1XR.js';
-export { p as parseLogLines } from './utils-B_SOM1XR.js';
+import { G as GetAppsQuery$1, A as AppId, C as CreateAppBody, a as App, b as GetAppRunsQuery, R as RunId, c as CreateDeploymentBody, D as DeploymentId, d as GetLogsTailQuery, e as components, f as CredentialId, g as CreateCredentialBody } from './types-BsejtGjZ.js';
+import { L as LogEntry } from './appLogs-BbgAJ5I8.js';
+export { p as parseLogLines } from './appLogs-BbgAJ5I8.js';
+import { GetDataAppRunsPath, GetDataAppRunsQuery, GetDataAppRunPath, GetDataAppLogsDownloadPath, GetDataAppLogsTailPath, GetDataAppLogsTailQuery, GetAppsQuery, GetDataAppPath, CreateDataAppBody, PatchDataAppPath, PatchDataAppBody, DeleteDataAppPath, GetDataAppPasswordPath, ResetDataAppPasswordPath, GetSandboxPath, DeleteSandboxPath } from './dataScience/types.js';
 import { CreateVariableBody, VariableWithHash, DeleteVariablePath, GetVariablesQuery, GetVariablesByBranchId } from './vault/types.js';
-import { a as EncryptionCtx } from './types-Dkipk6NN.js';
-import { SemanticObject, SemanticModelData, CreateSemanticObjectMeta, UpdateSemanticObjectMeta, SemanticChildObjectDataMap, SemanticChildObjectType, SemanticDatasetData, SemanticMetricData, SemanticRelationshipData, SemanticGlossaryData, SemanticConstraintData } from './sdk/semanticLayer/types.js';
+import { a as EncryptionCtx } from './types-C_jxWM7A.js';
+import { SemanticObject, SemanticModelData, CreateSemanticObjectMeta, UpdateSemanticObjectMeta, SemanticModelChildRef, SemanticChildObjectType, SemanticChildObjectDataMap, SemanticDatasetData, SemanticMetricData, SemanticRelationshipData, SemanticGlossaryData, SemanticConstraintData, SemanticObjectType } from './sdk/semanticLayer/types.js';
 import { TagWithBindings, TagData, CreateMetaObjectMetaDataInput, UpdateMetaObjectMetaDataInput } from './sdk/tag/types.js';
 import * as zod_v4_core from 'zod/v4/core';
-export { FetchClientError, ServiceUnavailableError, SyncActionError, UserError, isAbortError, isApiError, isFetchClientError, isSyncActionError } from './storage/index.js';
+export { F as FetchClientError, Q as QueryJobError, a as QueryJobTimeoutError, S as ServiceUnavailableError, b as SyncActionError, U as UserError, V as ValidationError, i as isAbortError, c as isApiError, d as isFetchClientError, e as isQueryJobError, f as isQueryJobTimeoutError, g as isSyncActionError, h as isValidationError, p as parseOrThrow } from './createFetchClient-CFIwc6Lh.js';
 export { c as createGenericFetchClient } from './createGenericFetchClient-ZGG5wbAC.js';
 export { M as ManagementClientAuthError } from './ManagementClientAuthError-4J0S5tV-.js';
-export { c as createStorageSdk } from './storageSdk-L6NOdgSJ.js';
-import './adminRoles-Cil1lavB.js';
+export { c as createStorageSdk } from './storageSdk-BeJcnEIO.js';
+export { createQueryServiceSdk } from './sdk/queryService/index.js';
+import './backends-UNp_e5y9.js';
+import './adminRoles-BSUPLfNf.js';
 import 'qs';
-import './types-CM1zHzgm.js';
-import './createOpenapiFetchClient-6RX67Hws.js';
-import './types-Hj1CaKtV.js';
+import './types-Cffam0Nw.js';
+import './createOpenapiFetchClient-wLlVgp3k.js';
+import './types-BuEkMmKT.js';
 import './encryption/index.js';
 import './vault/index.js';
 import './metastore/index.js';
+import './queryService/index.js';
 
 declare const HttpHeader: {
     CONTENT_TYPE: string;
     CONTENT_DISPOSITION: string;
     AUTHORIZATION: string;
+    IDEMPOTENCY_KEY: string;
+    IF_MATCH: string;
 };
 declare const HttpContentType: {
     JSON: string;
@@ -140,7 +148,7 @@ declare const createSessionStorage: () => StorageAdapter;
  * 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' | 'stream' | 'notifications' | 'scheduler' | 'metastore';
+type ServiceClientName = 'vault' | 'dataScience' | 'apps' | 'encryption' | 'editor' | 'syncActions' | 'telemetry' | 'queryService' | 'queue' | 'chat' | 'ai' | 'import' | 'kaiAgent' | 'oauth' | 'omnisearch' | 'stream' | 'notifications' | 'scheduler' | 'metastore';
 /** Clients instantiated directly (not stack-discovered), keyed by their property name. */
 type NonServiceClientName = 'storage' | 'management' | 'auth';
 type MiddlewareTarget = ServiceClientName | NonServiceClientName;
@@ -211,6 +219,24 @@ declare const dedupe: <T>(task: TaskFn<T>) => (() => Promise<Awaited<T>>);
 
 declare const delay: (timeout: number, signal?: AbortSignal) => Promise<unknown>;
 
+/**
+ * Computes `task` on first call and hands that one value to every later caller —
+ * the async `Lazy<T>`. While the first run is in flight every call shares it; once
+ * it resolves, every call — right after, or long after — replays the same promise.
+ * (Contrast `dedupe`, which shares only an *in-flight* run and lets the next
+ * trigger start a fresh one, success or not.)
+ *
+ * A rejection is *not* kept: the slot is cleared, so the next call starts a fresh
+ * run. Lazy init over the network — a stack index, JWKS, feature flags — must not
+ * be bricked forever by one transient failure. Callers that joined the failed run
+ * all reject with its error; only a call made after it settles retries.
+ *
+ * @returns a getter; each call returns the promise of the computed value.
+ * @throws The returned promise rejects with whatever `task` throws or rejects
+ * with — the caller handles it (try/catch, or `.catch` on `void get()`).
+ */
+declare const lazy: <T>(task: TaskFn<T>) => (() => Promise<Awaited<T>>);
+
 type PollResult<T> = {
     data: T;
     callCount: number;
@@ -231,9 +257,10 @@ type Options<T> = {
 declare const poll: <T>({ pollFn, interval, isDone, isFailed, abortSignal, maxAttempts, }: Options<T>) => Promise<PollResult<T>>;
 
 /**
- * Executes an asynchronous callback function on an array of items in series (one at a time).
+ * Executes a callback function on an array of items in series (one at a time).
  * It behaves similarly to Promise.all(), failing on the first rejected promise.
  * The order of the results matches the order of the promises.
+ * Resolves with the mapped results, not with the original items.
  */
 declare const series: <T, R>(options: Omit<ConcurrentOptions<T, R>, "concurrency">) => Promise<R[]>;
 
@@ -11170,11 +11197,7 @@ declare const createProjectClients: ({ baseUrl, projectId, authMiddleware, middl
             createModel: (data: SemanticModelData, meta?: CreateSemanticObjectMeta) => Promise<SemanticObject<SemanticModelData>>;
             updateModel: (modelUUID: string, data: Partial<SemanticModelData>, meta?: UpdateSemanticObjectMeta) => Promise<SemanticObject<SemanticModelData>>;
             deleteModel: (modelUUID: string) => Promise<void>;
-            listModelChildren: (modelUUID: string, signal?: AbortSignal) => Promise<{
-                objectType: keyof SemanticChildObjectDataMap;
-                objectUUID: string;
-                name: string | undefined;
-            }[]>;
+            listModelChildren: (modelUUID: string, signal?: AbortSignal) => Promise<SemanticModelChildRef[]>;
             listObjects: <T extends SemanticChildObjectType>(objectType: T, modelUUID: string, signal?: AbortSignal) => Promise<SemanticObject<SemanticChildObjectDataMap[T]>[]>;
             findObjectsByName: <T extends SemanticChildObjectType>(objectType: T, name: string, modelUUID: string, signal?: AbortSignal) => Promise<SemanticObject<SemanticChildObjectDataMap[T]>[]>;
             createObject: <T extends SemanticChildObjectType>(objectType: T, data: SemanticChildObjectDataMap[T], meta?: CreateSemanticObjectMeta) => Promise<SemanticObject<SemanticChildObjectDataMap[T]>>;
@@ -11185,6 +11208,8 @@ declare const createProjectClients: ({ baseUrl, projectId, authMiddleware, middl
             }>;
             updateObject: <T extends SemanticChildObjectType>(objectType: T, objectUUID: string, data: Partial<SemanticChildObjectDataMap[T]>, meta?: UpdateSemanticObjectMeta) => Promise<SemanticObject<SemanticChildObjectDataMap[T]>>;
             deleteObject: (objectType: SemanticChildObjectType, objectUUID: string) => Promise<void>;
+            replaceTargetProjects: (objectType: SemanticObjectType, objectUUID: string, targetProjectIds: number[]) => Promise<void>;
+            promoteToOrganizationScope: (objectType: SemanticObjectType, objectUUID: string) => Promise<SemanticObject<Record<string, unknown>>>;
         };
         storage: {
             createTable: (bucketId: string, body: CreateTableAsyncBody, options?: {
@@ -11251,9 +11276,7 @@ declare const createProjectClients: ({ baseUrl, projectId, authMiddleware, middl
                 maxAttempts?: number;
                 abortSignal?: AbortSignal;
             }) => Promise<TableExportJob>;
-            getBucketListing: (bucketId: string, signal?: AbortSignal) => Promise<BucketListing | null>;
-            listBucketListings: (signal?: AbortSignal) => Promise<BucketListing[]>;
-            createBucketListing: (bucketId: string, input: CreateBucketListingInput, options?: {
+            createBucketListing: (bucketId: string, input: CreateBucketListingBody, options?: {
                 interval?: number;
                 maxAttempts?: number;
                 abortSignal?: AbortSignal;
@@ -11298,7 +11321,7 @@ declare const createProjectClients: ({ baseUrl, projectId, authMiddleware, middl
                 status: "success";
                 results: null;
             })>;
-            updateBucketListing: (bucketId: string, input: UpdateBucketListingInput, options?: {
+            updateBucketListing: (bucketId: string, input: UpdateBucketListingBody, options?: {
                 interval?: number;
                 maxAttempts?: number;
                 abortSignal?: AbortSignal;
@@ -11388,7 +11411,7 @@ declare const createProjectClients: ({ baseUrl, projectId, authMiddleware, middl
                 status: "success";
                 results: null;
             })>;
-            shareBucketToOrganization: (bucketId: string, options?: {
+            shareBucketToOrganization: (input: ShareBucketToOrganizationInput, options?: {
                 interval?: number;
                 maxAttempts?: number;
                 abortSignal?: AbortSignal;
@@ -11431,7 +11454,7 @@ declare const createProjectClients: ({ baseUrl, projectId, authMiddleware, middl
                 status: "success";
                 results: null;
             })>;
-            shareBucketToOrganizationProject: (bucketId: string, options?: {
+            shareBucketToOrganizationProject: (input: ShareBucketToOrganizationProjectInput, options?: {
                 interval?: number;
                 maxAttempts?: number;
                 abortSignal?: AbortSignal;
@@ -11474,7 +11497,7 @@ declare const createProjectClients: ({ baseUrl, projectId, authMiddleware, middl
                 status: "success";
                 results: null;
             })>;
-            shareBucketToProjects: (bucketId: string, body: ShareBucketToProjectsBody, options?: {
+            shareBucketToProjects: (input: ShareBucketToProjectsInput, options?: {
                 interval?: number;
                 maxAttempts?: number;
                 abortSignal?: AbortSignal;
@@ -11517,7 +11540,7 @@ declare const createProjectClients: ({ baseUrl, projectId, authMiddleware, middl
                 status: "success";
                 results: null;
             })>;
-            shareBucketToUsers: (bucketId: string, body: ShareBucketToUsersBody, options?: {
+            shareBucketToUsers: (input: ShareBucketToUsersInput, options?: {
                 interval?: number;
                 maxAttempts?: number;
                 abortSignal?: AbortSignal;
@@ -11560,7 +11583,7 @@ declare const createProjectClients: ({ baseUrl, projectId, authMiddleware, middl
                 status: "success";
                 results: null;
             })>;
-            unshareBucket: (bucketId: string, options?: {
+            unshareBucket: (input: UnshareBucketInput, options?: {
                 interval?: number;
                 maxAttempts?: number;
                 abortSignal?: AbortSignal;
@@ -11603,7 +11626,7 @@ declare const createProjectClients: ({ baseUrl, projectId, authMiddleware, middl
                 status: "success";
                 results: null;
             })>;
-            forceUnlinkBucket: (bucketId: string, linkedProjectId: string, options?: {
+            forceUnlinkBucket: (input: ForceUnlinkBucketInput, options?: {
                 interval?: number;
                 maxAttempts?: number;
                 abortSignal?: AbortSignal;
@@ -11687,7 +11710,12 @@ declare const createProjectClients: ({ baseUrl, projectId, authMiddleware, middl
                 };
             } | {
                 status: "success";
-                results: null;
+                results: {
+                    id: string;
+                    warnings?: {
+                        message: string;
+                    }[];
+                };
             })>;
             refreshExternalBucket: (bucketId: string, query?: RefreshExternalBucketQuery, options?: {
                 interval?: number;
@@ -11730,7 +11758,11 @@ declare const createProjectClients: ({ baseUrl, projectId, authMiddleware, middl
                 };
             } | {
                 status: "success";
-                results: null;
+                results: {
+                    warnings?: {
+                        message: string;
+                    }[];
+                };
             })>;
             createSnapshot: (input: CreateSnapshotInput, options?: {
                 interval?: number;
@@ -11777,7 +11809,7 @@ declare const createProjectClients: ({ baseUrl, projectId, authMiddleware, middl
                 status: "success";
                 results: null;
             })>;
-            pullTable: (tableId: string, options?: {
+            pullTable: (input: PullTableAsyncInput, options?: {
                 interval?: number;
                 maxAttempts?: number;
                 abortSignal?: AbortSignal;
@@ -12067,6 +12099,7 @@ declare const createProjectClients: ({ baseUrl, projectId, authMiddleware, middl
         };
     };
     vault: {
+        healthCheck: (signal?: AbortSignal) => Promise<unknown>;
         createVariable: (body: CreateVariableBody, signal?: AbortSignal) => Promise<{
             key: string;
             value: string;
@@ -12086,8 +12119,9 @@ declare const createProjectClients: ({ baseUrl, projectId, authMiddleware, middl
         getVariablesByBranchId: (branchId: GetVariablesByBranchId["branchId"], signal?: AbortSignal) => Promise<VariableWithHash[]>;
     };
     dataScience: {
+        healthCheck: (signal?: AbortSignal) => Promise<unknown>;
         getAppRuns: (appId: GetDataAppRunsPath["appId"], query?: GetDataAppRunsQuery, signal?: AbortSignal) => Promise<{
-            state: "failed" | "starting" | "running" | "finished";
+            state: "starting" | "running" | "failed" | "finished";
             id: string;
             appId: string;
             createdAt?: string | null;
@@ -12103,7 +12137,7 @@ declare const createProjectClients: ({ baseUrl, projectId, authMiddleware, middl
             mode: "prod" | "dev";
         }[]>;
         getAppRun: (appId: GetDataAppRunPath["appId"], runId: GetDataAppRunPath["runId"], signal?: AbortSignal) => Promise<{
-            state: "failed" | "starting" | "running" | "finished";
+            state: "starting" | "running" | "failed" | "finished";
             id: string;
             appId: string;
             createdAt?: string | null;
@@ -12284,7 +12318,232 @@ declare const createProjectClients: ({ baseUrl, projectId, authMiddleware, middl
         }>;
         deleteSandbox: (appId: DeleteSandboxPath["appId"], signal?: AbortSignal) => Promise<ApiResponse<never>>;
     };
+    apps: {
+        healthCheck: (signal?: AbortSignal) => Promise<{
+            appName?: string;
+            appVersion?: string;
+            apiDocs?: string;
+        }>;
+        getApps: (query?: GetAppsQuery$1, signal?: AbortSignal) => Promise<{
+            id: string;
+            projectId: string;
+            componentId: string;
+            branchId: string | null;
+            configId: string;
+            configVersion: string;
+            type?: "streamlit" | "python-js" | null;
+            mode?: "prod" | "dev";
+            url: string | null;
+            production: {
+                desiredNumber?: number | null;
+                desiredId?: string | null;
+                actualNumber?: number | null;
+                actualId?: string | null;
+            };
+            undeployedChanges?: boolean;
+            state: "NOT_DEPLOYED" | "STARTING" | "RUNNING" | "SLEEPING" | "SUSPENDED";
+        }[]>;
+        getApp: (appId: AppId, signal?: AbortSignal) => Promise<{
+            id: string;
+            projectId: string;
+            componentId: string;
+            branchId: string | null;
+            configId: string;
+            configVersion: string;
+            type?: "streamlit" | "python-js" | null;
+            mode?: "prod" | "dev";
+            url: string | null;
+            production: {
+                desiredNumber?: number | null;
+                desiredId?: string | null;
+                actualNumber?: number | null;
+                actualId?: string | null;
+            };
+            undeployedChanges?: boolean;
+            state: "NOT_DEPLOYED" | "STARTING" | "RUNNING" | "SLEEPING" | "SUSPENDED";
+        }>;
+        createApp: (body: CreateAppBody, options?: {
+            signal?: AbortSignal;
+        }) => Promise<{
+            id: string;
+            projectId: string;
+            componentId: string;
+            branchId: string | null;
+            configId: string;
+            configVersion: string;
+            type?: "streamlit" | "python-js" | null;
+            mode?: "prod" | "dev";
+            url: string | null;
+            production: {
+                desiredNumber?: number | null;
+                desiredId?: string | null;
+                actualNumber?: number | null;
+                actualId?: string | null;
+            };
+            undeployedChanges?: boolean;
+            state: "NOT_DEPLOYED" | "STARTING" | "RUNNING" | "SLEEPING" | "SUSPENDED";
+        }>;
+        deleteApp: (appId: AppId, signal?: AbortSignal) => Promise<void>;
+        unpublishApp: (appId: AppId, signal?: AbortSignal) => Promise<App | null>;
+        suspendApp: (appId: AppId, signal?: AbortSignal) => Promise<App | null>;
+        resumeApp: (appId: AppId, signal?: AbortSignal) => Promise<App | null>;
+        getAppPassword: (appId: AppId, signal?: AbortSignal) => Promise<{
+            password?: string | null;
+        }>;
+        resetAppPassword: (appId: AppId, signal?: AbortSignal) => Promise<{
+            id: string;
+            projectId: string;
+            componentId: string;
+            branchId: string | null;
+            configId: string;
+            configVersion: string;
+            type?: "streamlit" | "python-js" | null;
+            mode?: "prod" | "dev";
+            url: string | null;
+            production: {
+                desiredNumber?: number | null;
+                desiredId?: string | null;
+                actualNumber?: number | null;
+                actualId?: string | null;
+            };
+            undeployedChanges?: boolean;
+            state: "NOT_DEPLOYED" | "STARTING" | "RUNNING" | "SLEEPING" | "SUSPENDED";
+        }>;
+        getAppRuns: (appId: AppId, query?: GetAppRunsQuery, signal?: AbortSignal) => Promise<{
+            id: string;
+            appId: string;
+            deploymentId: string | null;
+            state?: "starting" | "running" | "failed" | "finished" | null;
+            createdAt?: string | null;
+            startedAt?: string | null;
+            stoppedAt?: string | null;
+            startupLogs?: string | null;
+            runtimeSize?: string | null;
+            runtimeBackendType?: string | null;
+            configVersion?: string | null;
+            imageVersion?: string | null;
+            failureReason?: {
+                reason?: string | null;
+                message?: string | null;
+            } | null;
+            mode?: string;
+        }[]>;
+        getAppRun: (appId: AppId, runId: RunId, signal?: AbortSignal) => Promise<{
+            id: string;
+            appId: string;
+            deploymentId: string | null;
+            state?: "starting" | "running" | "failed" | "finished" | null;
+            createdAt?: string | null;
+            startedAt?: string | null;
+            stoppedAt?: string | null;
+            startupLogs?: string | null;
+            runtimeSize?: string | null;
+            runtimeBackendType?: string | null;
+            configVersion?: string | null;
+            imageVersion?: string | null;
+            failureReason?: {
+                reason?: string | null;
+                message?: string | null;
+            } | null;
+            mode?: string;
+        }>;
+        createDeployment: (appId: AppId, body?: CreateDeploymentBody, options?: {
+            signal?: AbortSignal;
+        }) => Promise<{
+            id: string;
+            number: number;
+            configId: string;
+            configVersion: string;
+            gitCommitSha: string | null;
+            size?: "micro" | "tiny" | "small" | "medium" | "large" | "external" | null;
+            buildState: "PREBUILT" | "PENDING" | "BUILDING" | "BUILT" | "FAILED";
+            runState: "NEVER_RUN" | "PENDING" | "STARTING" | "RUNNING" | "STOPPING" | "STOPPED" | "FAILED";
+            archived: boolean;
+            archivedAt: string | null;
+            createdAt: string;
+        }>;
+        getDeployments: (appId: AppId, signal?: AbortSignal) => Promise<{
+            id: string;
+            number: number;
+            configId: string;
+            configVersion: string;
+            gitCommitSha: string | null;
+            size?: "micro" | "tiny" | "small" | "medium" | "large" | "external" | null;
+            buildState: "PREBUILT" | "PENDING" | "BUILDING" | "BUILT" | "FAILED";
+            runState: "NEVER_RUN" | "PENDING" | "STARTING" | "RUNNING" | "STOPPING" | "STOPPED" | "FAILED";
+            archived: boolean;
+            archivedAt: string | null;
+            createdAt: string;
+        }[]>;
+        getDeployment: (appId: AppId, deploymentId: DeploymentId, signal?: AbortSignal) => Promise<{
+            id: string;
+            number: number;
+            configId: string;
+            configVersion: string;
+            gitCommitSha: string | null;
+            size?: "micro" | "tiny" | "small" | "medium" | "large" | "external" | null;
+            buildState: "PREBUILT" | "PENDING" | "BUILDING" | "BUILT" | "FAILED";
+            runState: "NEVER_RUN" | "PENDING" | "STARTING" | "RUNNING" | "STOPPING" | "STOPPED" | "FAILED";
+            archived: boolean;
+            archivedAt: string | null;
+            createdAt: string;
+        }>;
+        deleteDeployment: (appId: AppId, deploymentId: DeploymentId, signal?: AbortSignal) => Promise<void>;
+        promoteDeployment: (appId: AppId, deploymentId: DeploymentId, signal?: AbortSignal) => Promise<App | null>;
+        getAppLogsTail: (appId: AppId, { query, signal }?: {
+            query?: GetLogsTailQuery;
+            signal?: AbortSignal;
+        }) => Promise<{
+            entries: LogEntry[];
+            nextLogTimestamp: string | null;
+        }>;
+        getAppLogsDownload: (appId: AppId, signal?: AbortSignal) => Promise<{
+            logs: string;
+            fileName: string;
+        }>;
+        getDeploymentLogsTail: (appId: AppId, deploymentId: DeploymentId, { query, signal }?: {
+            query?: GetLogsTailQuery;
+            signal?: AbortSignal;
+        }) => Promise<{
+            entries: LogEntry[];
+            nextLogTimestamp: string | null;
+        }>;
+        getDeploymentLogsDownload: (appId: AppId, deploymentId: DeploymentId, signal?: AbortSignal) => Promise<{
+            logs: string;
+            fileName: string;
+        }>;
+        getAppGitRepo: (appId: AppId, signal?: AbortSignal) => Promise<{
+            sshUrl: string | null;
+            httpsUrl: string | null;
+            isManagedGitRepo: boolean;
+        }>;
+        getAppGitRepoCredentials: (appId: AppId, signal?: AbortSignal) => Promise<{
+            credentials: components["schemas"]["Credential"][];
+        }>;
+        getAppGitRepoCredential: (appId: AppId, credentialId: CredentialId, signal?: AbortSignal) => Promise<{
+            id: string;
+            type: "ssh_key" | "http_token";
+            name: string;
+            permissions: "readOnly" | "readWrite";
+            ownerAdminId: string;
+            createdAt: string;
+        }>;
+        createAppGitRepoCredential: (appId: AppId, body: CreateCredentialBody, options?: {
+            signal?: AbortSignal;
+        }) => Promise<{
+            id: string;
+            type: "ssh_key" | "http_token";
+            name: string;
+            permissions: "readOnly" | "readWrite";
+            ownerAdminId: string;
+            createdAt: string;
+        } & {
+            secret?: string;
+        }>;
+        deleteAppGitRepoCredential: (appId: AppId, credentialId: CredentialId, signal?: AbortSignal) => Promise<void>;
+    };
     encryption: {
+        healthCheck: (signal?: AbortSignal) => Promise<unknown>;
         encryptSecrets: <T extends Record<string, unknown>>(data: EncryptQuery & {
             data: T;
         }, signal?: AbortSignal) => Promise<T>;
@@ -12294,6 +12553,9 @@ declare const createProjectClients: ({ baseUrl, projectId, authMiddleware, middl
         }, signal?: AbortSignal) => Promise<string>;
     };
     editor: {
+        healthCheck: (signal?: AbortSignal) => Promise<{
+            status: "ok";
+        }>;
         createSession: (body: CreateSqlSessionBody) => Promise<{
             id: string;
             createdAt: string;
@@ -12373,7 +12635,7 @@ declare const createProjectClients: ({ baseUrl, projectId, authMiddleware, middl
             lastLoadedAt?: string | null;
         }[]>;
         getSessionSchema: ({ id, onlyWorkspaceSchema, loadTables, }: GetSqlSessionSchemaPath & GetSqlSessionSchemaQuery, signal?: AbortSignal) => Promise<{
-            databases: components["schemas"]["Catalog"][];
+            databases: components$1["schemas"]["Catalog"][];
         }>;
         createQueryJob: ({ id }: PostSqlRunQueryPath, body: PostSqlRunQueryBody) => Promise<{
             queryJobId: string;
@@ -12451,6 +12713,7 @@ declare const createProjectClients: ({ baseUrl, projectId, authMiddleware, middl
         }>;
     };
     syncActions: {
+        healthCheck: (signal?: AbortSignal) => Promise<unknown>;
         sendSyncAction: (body: SyncActionBody, options?: SendSyncActionOptions) => Promise<Record<string, never>>;
         enrollMFA: ({ email, ...rest }: EnrollMFAInput, signal?: AbortSignal) => Promise<Record<string, never>>;
         apify: {
@@ -12463,81 +12726,35 @@ declare const createProjectClients: ({ baseUrl, projectId, authMiddleware, middl
                 name: string;
             }[]>;
         };
-        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;
+        dbt: {
+            compile: (input: DbtActionInput, signal?: AbortSignal) => Promise<Record<string, string>>;
+            runResults: (input: DbtActionInput, signal?: AbortSignal) => Promise<{
+                id: string;
+                name: string;
+                thread: number;
+                timeStarted: string;
+                timeCompleted: string;
+            }[]>;
+        };
+        git: {
+            getBranches: (input: GetBranchesInput, signal?: AbortSignal) => Promise<{
+                branch: string;
+                sha: string;
+                date: string;
+                comment: string;
+                author: {
+                    name: string;
+                    email: string;
                 };
-                branches: {
-                    sha: string;
-                    date: string;
-                    comment: string;
-                    branch: string;
-                    author: {
-                        name: string;
-                        email: string;
-                    };
-                }[];
+            }[]>;
+            getEntrypoints: (input: GetEntrypointsInput, signal?: AbortSignal) => Promise<{
+                entrypoints: 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;
-                    };
-                }[];
+        };
+        looker: {
+            testCredentials: (input: TestLookerCredentialsInput, signal?: AbortSignal) => Promise<{
+                status?: string | undefined;
+                message?: string | undefined;
             }>;
         };
     };
@@ -12547,6 +12764,7 @@ declare const createProjectClients: ({ baseUrl, projectId, authMiddleware, middl
         };
     };
     queryService: {
+        healthCheck: (signal?: AbortSignal) => Promise<unknown>;
         createQueryJob: (branchId: PostQueryPath["branchId"], workspaceId: PostQueryPath["workspaceId"], body: PostQueryBody) => Promise<{
             queryJobId: string;
             sessionId?: string;
@@ -12555,30 +12773,31 @@ declare const createProjectClients: ({ baseUrl, projectId, authMiddleware, middl
             queryJobId: string;
         }>;
         getQueryJob: (queryJobId: GetQueryJobPath["queryJobId"]) => Promise<{
-            actorType: components$1["schemas"]["models.ActorType"];
+            actorType: components$2["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"];
+            statements: components$2["schemas"]["handlers.Statement"][];
+            status: components$2["schemas"]["models.JobState"];
         }>;
         getQueryResults: (queryJobId: GetQueryResultsPath["queryJobId"], statementId: GetQueryResultsPath["statementId"], query?: GetQueryResutsQuery) => Promise<{
-            columns?: components$1["schemas"]["handlers.Column"][];
+            columns?: components$2["schemas"]["handlers.Column"][];
             data?: string[][];
             message?: string;
             numberOfRows?: number;
             rowsAffected?: number;
-            status: components$1["schemas"]["models.StatementState"];
+            status: components$2["schemas"]["models.StatementState"];
         }>;
         getQueryHistory: (branchId: GetQueriesPath["branchId"], workspaceId: GetQueriesPath["workspaceId"], query?: GetQueriesHistoryQuery) => Promise<{
-            statements: components$1["schemas"]["handlers.StatementWithWorkspaceInfo"][];
+            statements: components$2["schemas"]["handlers.StatementWithWorkspaceInfo"][];
         }>;
         exportResults: (queryJobId: GetQueryResultsPath["queryJobId"], statementId: GetQueryResultsPath["statementId"], query: GetExportResultsQuery, signal?: AbortSignal) => Promise<ExportResultsResponse>;
     };
     queue: {
+        healthCheck: (signal?: AbortSignal) => Promise<unknown>;
         getJob: (jobId: GetQueueJobPath["jobId"], signal?: AbortSignal) => Promise<{
             id: string;
             runId: string;
@@ -12590,7 +12809,7 @@ declare const createProjectClients: ({ baseUrl, projectId, authMiddleware, middl
                 id?: string;
                 description?: string;
             };
-            status: components$2["schemas"]["JobStatus"];
+            status: components$3["schemas"]["JobStatus"];
             desiredStatus?: "processing" | "terminating" | null;
             component: string;
             mode: "run" | "debug";
@@ -12636,10 +12855,11 @@ declare const createProjectClients: ({ baseUrl, projectId, authMiddleware, middl
                     context?: string;
                 };
             } | null;
-            type?: components$2["schemas"]["JobType"];
+            type?: components$3["schemas"]["JobType"];
             orchestrationTaskId?: string | null;
             previousJobId?: string | null;
             onlyOrchestrationTaskIds?: string[] | null;
+            onlyFlowTaskIds?: string[] | null;
         }>;
         searchJobs: (query?: SearchJobsQuery, signal?: AbortSignal) => Promise<{
             id: string;
@@ -12652,7 +12872,7 @@ declare const createProjectClients: ({ baseUrl, projectId, authMiddleware, middl
                 id?: string;
                 description?: string;
             };
-            status: components$2["schemas"]["JobStatus"];
+            status: components$3["schemas"]["JobStatus"];
             desiredStatus?: "processing" | "terminating" | null;
             component: string;
             mode: "run" | "debug";
@@ -12698,10 +12918,11 @@ declare const createProjectClients: ({ baseUrl, projectId, authMiddleware, middl
                     context?: string;
                 };
             } | null;
-            type?: components$2["schemas"]["JobType"];
+            type?: components$3["schemas"]["JobType"];
             orchestrationTaskId?: string | null;
             previousJobId?: string | null;
             onlyOrchestrationTaskIds?: string[] | null;
+            onlyFlowTaskIds?: string[] | null;
         }[]>;
         searchAllJobs: (query: SearchAllJobsQuery, signal?: AbortSignal) => Promise<{
             id: string;
@@ -12714,7 +12935,7 @@ declare const createProjectClients: ({ baseUrl, projectId, authMiddleware, middl
                 id?: string;
                 description?: string;
             };
-            status: components$2["schemas"]["JobStatus"];
+            status: components$3["schemas"]["JobStatus"];
             desiredStatus?: "processing" | "terminating" | null;
             component: string;
             mode: "run" | "debug";
@@ -12760,10 +12981,11 @@ declare const createProjectClients: ({ baseUrl, projectId, authMiddleware, middl
                     context?: string;
                 };
             } | null;
-            type?: components$2["schemas"]["JobType"];
+            type?: components$3["schemas"]["JobType"];
             orchestrationTaskId?: string | null;
             previousJobId?: string | null;
             onlyOrchestrationTaskIds?: string[] | null;
+            onlyFlowTaskIds?: string[] | null;
         }[]>;
         createJob: (body: CreateJobBody, signal?: AbortSignal) => Promise<{
             id: string;
@@ -12776,7 +12998,7 @@ declare const createProjectClients: ({ baseUrl, projectId, authMiddleware, middl
                 id?: string;
                 description?: string;
             };
-            status: components$2["schemas"]["JobStatus"];
+            status: components$3["schemas"]["JobStatus"];
             desiredStatus?: "processing" | "terminating" | null;
             component: string;
             mode: "run" | "debug";
@@ -12822,10 +13044,11 @@ declare const createProjectClients: ({ baseUrl, projectId, authMiddleware, middl
                     context?: string;
                 };
             } | null;
-            type?: components$2["schemas"]["JobType"];
+            type?: components$3["schemas"]["JobType"];
             orchestrationTaskId?: string | null;
             previousJobId?: string | null;
             onlyOrchestrationTaskIds?: string[] | null;
+            onlyFlowTaskIds?: string[] | null;
         }>;
         killJob: (jobId: KillJobPath["jobId"], signal?: AbortSignal) => Promise<{
             id: string;
@@ -12838,7 +13061,7 @@ declare const createProjectClients: ({ baseUrl, projectId, authMiddleware, middl
                 id?: string;
                 description?: string;
             };
-            status: components$2["schemas"]["JobStatus"];
+            status: components$3["schemas"]["JobStatus"];
             desiredStatus?: "processing" | "terminating" | null;
             component: string;
             mode: "run" | "debug";
@@ -12884,16 +13107,17 @@ declare const createProjectClients: ({ baseUrl, projectId, authMiddleware, middl
                     context?: string;
                 };
             } | null;
-            type?: components$2["schemas"]["JobType"];
+            type?: components$3["schemas"]["JobType"];
             orchestrationTaskId?: string | null;
             previousJobId?: string | null;
             onlyOrchestrationTaskIds?: string[] | null;
+            onlyFlowTaskIds?: string[] | null;
         }>;
         searchGroupedJobs: (query: SearchGroupedJobsQuery, signal?: AbortSignal) => Promise<{
             group?: {
                 [key: string]: string;
             };
-            jobs?: components$2["schemas"]["Job"][];
+            jobs?: components$3["schemas"]["Job"][];
         }[]>;
         getOrchestrationRerunPlan: (jobId: OrchestrationRerunPlanPath["jobId"], signal?: AbortSignal) => Promise<{
             jobId?: string;
@@ -12904,13 +13128,16 @@ declare const createProjectClients: ({ baseUrl, projectId, authMiddleware, middl
                 jobId?: string | null;
                 componentId?: string | null;
                 configId?: string | null;
-                status?: components$2["schemas"]["JobStatus"] & unknown;
+                status?: components$3["schemas"]["JobStatus"] & unknown;
             }[];
         }>;
     };
     chat: {
+        healthCheck: (signal?: AbortSignal) => Promise<{
+            timestamp: string;
+        }>;
         getHistory: (params?: GetHistoryQuery$1) => Promise<{
-            chats: components$3["schemas"]["Chat"][];
+            chats: components$4["schemas"]["Chat"][];
             hasMore: boolean;
         }>;
         getChat: (chatId: GetChatPath$1["id"], signal?: AbortSignal) => Promise<{
@@ -12926,7 +13153,7 @@ declare const createProjectClients: ({ baseUrl, projectId, authMiddleware, middl
                 maxTokens: number;
                 percentage: number;
             } | null;
-            messages: components$3["schemas"]["Message"][];
+            messages: components$4["schemas"]["Message"][];
         }>;
         deleteChat: (chatId: string) => Promise<{
             id: string;
@@ -12949,6 +13176,9 @@ declare const createProjectClients: ({ baseUrl, projectId, authMiddleware, middl
         getToolsList: (signal?: AbortSignal) => Promise<ToolsListResponse>;
     };
     ai: {
+        healthCheck: (signal?: AbortSignal) => Promise<{
+            status: "ok";
+        }>;
         describeConfigurationVersion: (body: DescribeConfigurationVersionBody) => Promise<{
             description: string;
             correlationId: string;
@@ -12966,7 +13196,7 @@ declare const createProjectClients: ({ baseUrl, projectId, authMiddleware, middl
             correlationId: string;
         }>;
         suggestComponent: (body: SuggestComponentBody) => Promise<{
-            components: components$4["schemas"]["SuggestedComponent"][];
+            components: components$5["schemas"]["SuggestedComponent"][];
             correlationId: string;
         }>;
         feedback: (body: FeedbackBody) => Promise<never>;
@@ -12994,7 +13224,19 @@ declare const createProjectClients: ({ baseUrl, projectId, authMiddleware, middl
             synchronousActions?: string[] | null;
         }>;
     };
+    omnisearch: {
+        healthCheck: (signal?: AbortSignal) => Promise<{
+            status: string;
+        }>;
+        getProjectsLineage: (query?: GetProjectsLineageQuery, signal?: AbortSignal) => Promise<{
+            graph: components$6["schemas"]["ProjectLineageGraph"];
+        }>;
+        getTablesLineage: (query: GetTablesLineageQuery, signal?: AbortSignal) => Promise<TablesLineageResponse>;
+    };
     import: {
+        healthCheck: (signal?: AbortSignal) => Promise<{
+            status: "ok";
+        }>;
         uploadFile: ({ file, ...fields }: UploadFileInput, { signal, onProgress }?: {
             signal?: AbortSignal;
             onProgress?: (progress: UploadProgress) => void;
@@ -13033,6 +13275,7 @@ declare const createProjectClients: ({ baseUrl, projectId, authMiddleware, middl
         }>;
     };
     kaiAgent: {
+        healthCheck: (signal?: AbortSignal) => Promise<unknown>;
         getHistory: (params?: GetHistoryQuery) => Promise<{
             chats: {
                 id?: string;
@@ -13212,6 +13455,7 @@ declare const createProjectClients: ({ baseUrl, projectId, authMiddleware, middl
         chatStreamUrl: string;
     };
     oauth: {
+        healthCheck: (signal?: AbortSignal) => Promise<unknown>;
         getCredentials: (scope: GetCredentialsInput, signal?: AbortSignal) => Promise<{
             id: string;
             branchId: string | null;
@@ -13257,6 +13501,7 @@ declare const createProjectClients: ({ baseUrl, projectId, authMiddleware, middl
         deleteCredential: ({ componentId, id }: CredentialInput, signal?: AbortSignal) => Promise<void>;
     };
     scheduler: {
+        healthCheck: (signal?: AbortSignal) => Promise<unknown>;
         getSchedules: (query?: GetSchedulesQuery, signal?: AbortSignal) => Promise<{
             id: string;
             tokenId: string;
@@ -13326,37 +13571,38 @@ declare const createProjectClients: ({ baseUrl, projectId, authMiddleware, middl
         deleteSchedulesForConfigurations: (configurationIds: ConfigurationPath$1["configurationId"][], signal?: AbortSignal) => Promise<void>;
     };
     stream: {
+        healthCheck: (signal?: AbortSignal) => Promise<unknown>;
         getSources: (branchId: string, query?: PaginationQuery, signal?: AbortSignal) => Promise<{
             branchId: number;
-            page: components$5["schemas"]["PaginatedResponse"];
+            page: components$7["schemas"]["PaginatedResponse"];
             projectId: number;
-            sources: components$5["schemas"]["Sources"];
+            sources: components$7["schemas"]["Sources"];
         }>;
         getDeletedSources: (branchId: string, query?: PaginationQuery, signal?: AbortSignal) => Promise<{
             branchId: number;
-            page: components$5["schemas"]["PaginatedResponse"];
+            page: components$7["schemas"]["PaginatedResponse"];
             projectId: number;
-            sources: components$5["schemas"]["Sources"];
+            sources: components$7["schemas"]["Sources"];
         }>;
         getAggregatedSources: (branchId: string, query?: PaginationQuery, signal?: AbortSignal) => Promise<{
             branchId: number;
-            page: components$5["schemas"]["PaginatedResponse"];
+            page: components$7["schemas"]["PaginatedResponse"];
             projectId: number;
-            sources: components$5["schemas"]["AggregatedSources"];
+            sources: components$7["schemas"]["AggregatedSources"];
         }>;
         getSource: (branchId: string, sourceId: string, signal?: AbortSignal) => Promise<{
             branchId: number;
-            created: components$5["schemas"]["CreatedEntity"];
-            deleted?: components$5["schemas"]["DeletedEntity"];
+            created: components$7["schemas"]["CreatedEntity"];
+            deleted?: components$7["schemas"]["DeletedEntity"];
             description: string;
-            disabled?: components$5["schemas"]["DisabledEntity"];
-            http?: components$5["schemas"]["HTTPSource"];
+            disabled?: components$7["schemas"]["DisabledEntity"];
+            http?: components$7["schemas"]["HTTPSource"];
             name: string;
-            otlp?: components$5["schemas"]["OTLPSource"];
+            otlp?: components$7["schemas"]["OTLPSource"];
             projectId: number;
             sourceId: string;
             type: "http" | "otlp";
-            version: components$5["schemas"]["Version"];
+            version: components$7["schemas"]["Version"];
         }>;
         createSource: (branchId: string, body: CreateSourceRequestBody, signal?: AbortSignal) => Promise<{
             createdAt: string;
@@ -13364,7 +13610,7 @@ declare const createProjectClients: ({ baseUrl, projectId, authMiddleware, middl
             error?: string;
             finishedAt?: string;
             isFinished: boolean;
-            outputs?: components$5["schemas"]["TaskOutputs"];
+            outputs?: components$7["schemas"]["TaskOutputs"];
             result?: string;
             status: "processing" | "success" | "error";
             taskId: string;
@@ -13377,7 +13623,7 @@ declare const createProjectClients: ({ baseUrl, projectId, authMiddleware, middl
             error?: string;
             finishedAt?: string;
             isFinished: boolean;
-            outputs?: components$5["schemas"]["TaskOutputs"];
+            outputs?: components$7["schemas"]["TaskOutputs"];
             result?: string;
             status: "processing" | "success" | "error";
             taskId: string;
@@ -13390,7 +13636,7 @@ declare const createProjectClients: ({ baseUrl, projectId, authMiddleware, middl
             error?: string;
             finishedAt?: string;
             isFinished: boolean;
-            outputs?: components$5["schemas"]["TaskOutputs"];
+            outputs?: components$7["schemas"]["TaskOutputs"];
             result?: string;
             status: "processing" | "success" | "error";
             taskId: string;
@@ -13403,7 +13649,7 @@ declare const createProjectClients: ({ baseUrl, projectId, authMiddleware, middl
             error?: string;
             finishedAt?: string;
             isFinished: boolean;
-            outputs?: components$5["schemas"]["TaskOutputs"];
+            outputs?: components$7["schemas"]["TaskOutputs"];
             result?: string;
             status: "processing" | "success" | "error";
             taskId: string;
@@ -13416,7 +13662,7 @@ declare const createProjectClients: ({ baseUrl, projectId, authMiddleware, middl
             error?: string;
             finishedAt?: string;
             isFinished: boolean;
-            outputs?: components$5["schemas"]["TaskOutputs"];
+            outputs?: components$7["schemas"]["TaskOutputs"];
             result?: string;
             status: "processing" | "success" | "error";
             taskId: string;
@@ -13429,7 +13675,7 @@ declare const createProjectClients: ({ baseUrl, projectId, authMiddleware, middl
             error?: string;
             finishedAt?: string;
             isFinished: boolean;
-            outputs?: components$5["schemas"]["TaskOutputs"];
+            outputs?: components$7["schemas"]["TaskOutputs"];
             result?: string;
             status: "processing" | "success" | "error";
             taskId: string;
@@ -13438,20 +13684,20 @@ declare const createProjectClients: ({ baseUrl, projectId, authMiddleware, middl
         }>;
         rotateSourceSecret: (branchId: string, sourceId: string, signal?: AbortSignal) => Promise<{
             branchId: number;
-            created: components$5["schemas"]["CreatedEntity"];
-            deleted?: components$5["schemas"]["DeletedEntity"];
+            created: components$7["schemas"]["CreatedEntity"];
+            deleted?: components$7["schemas"]["DeletedEntity"];
             description: string;
-            disabled?: components$5["schemas"]["DisabledEntity"];
-            http?: components$5["schemas"]["HTTPSource"];
+            disabled?: components$7["schemas"]["DisabledEntity"];
+            http?: components$7["schemas"]["HTTPSource"];
             name: string;
-            otlp?: components$5["schemas"]["OTLPSource"];
+            otlp?: components$7["schemas"]["OTLPSource"];
             projectId: number;
             sourceId: string;
             type: "http" | "otlp";
-            version: components$5["schemas"]["Version"];
+            version: components$7["schemas"]["Version"];
         }>;
         getSourceSettings: (branchId: string, sourceId: string, signal?: AbortSignal) => Promise<{
-            settings?: components$5["schemas"]["SettingResult"][];
+            settings?: components$7["schemas"]["SettingResult"][];
         }>;
         updateSourceSettings: (branchId: string, sourceId: string, body: UpdateSourceSettingsRequestBody, signal?: AbortSignal) => Promise<{
             createdAt: string;
@@ -13459,7 +13705,7 @@ declare const createProjectClients: ({ baseUrl, projectId, authMiddleware, middl
             error?: string;
             finishedAt?: string;
             isFinished: boolean;
-            outputs?: components$5["schemas"]["TaskOutputs"];
+            outputs?: components$7["schemas"]["TaskOutputs"];
             result?: string;
             status: "processing" | "success" | "error";
             taskId: string;
@@ -13471,15 +13717,15 @@ declare const createProjectClients: ({ baseUrl, projectId, authMiddleware, middl
             branchId: number;
             projectId: number;
             sourceId: string;
-            tables: components$5["schemas"]["TestResultTable"][];
+            tables: components$7["schemas"]["TestResultTable"][];
         }>;
         getSourceVersions: (branchId: string, sourceId: string, query?: PaginationQuery, signal?: AbortSignal) => Promise<{
-            page: components$5["schemas"]["PaginatedResponse"];
-            versions: components$5["schemas"]["Version"][];
+            page: components$7["schemas"]["PaginatedResponse"];
+            versions: components$7["schemas"]["Version"][];
         }>;
         getSourceVersion: (branchId: string, sourceId: string, versionNumber: number, signal?: AbortSignal) => Promise<{
             at: string;
-            by: components$5["schemas"]["By"];
+            by: components$7["schemas"]["By"];
             description: string;
             hash: string;
             number: number;
@@ -13490,7 +13736,7 @@ declare const createProjectClients: ({ baseUrl, projectId, authMiddleware, middl
             error?: string;
             finishedAt?: string;
             isFinished: boolean;
-            outputs?: components$5["schemas"]["TaskOutputs"];
+            outputs?: components$7["schemas"]["TaskOutputs"];
             result?: string;
             status: "processing" | "success" | "error";
             taskId: string;
@@ -13499,32 +13745,32 @@ declare const createProjectClients: ({ baseUrl, projectId, authMiddleware, middl
         }>;
         getSinks: (branchId: string, sourceId: string, query?: PaginationQuery, signal?: AbortSignal) => Promise<{
             branchId: number;
-            page: components$5["schemas"]["PaginatedResponse"];
+            page: components$7["schemas"]["PaginatedResponse"];
             projectId: number;
-            sinks: components$5["schemas"]["Sinks"];
+            sinks: components$7["schemas"]["Sinks"];
             sourceId: string;
         }>;
         getDeletedSinks: (branchId: string, sourceId: string, query?: PaginationQuery, signal?: AbortSignal) => Promise<{
             branchId: number;
-            page: components$5["schemas"]["PaginatedResponse"];
+            page: components$7["schemas"]["PaginatedResponse"];
             projectId: number;
-            sinks: components$5["schemas"]["Sinks"];
+            sinks: components$7["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"];
+            created: components$7["schemas"]["CreatedEntity"];
+            deleted?: components$7["schemas"]["DeletedEntity"];
             description: string;
-            disabled?: components$5["schemas"]["DisabledEntity"];
+            disabled?: components$7["schemas"]["DisabledEntity"];
             name: string;
             projectId: number;
             sinkId: string;
             sourceId: string;
-            table?: components$5["schemas"]["TableSink"];
+            table?: components$7["schemas"]["TableSink"];
             type: "table";
-            version: components$5["schemas"]["Version"];
+            version: components$7["schemas"]["Version"];
         }>;
         createSink: (branchId: string, sourceId: string, body: CreateSinkRequestBody, signal?: AbortSignal) => Promise<{
             createdAt: string;
@@ -13532,7 +13778,7 @@ declare const createProjectClients: ({ baseUrl, projectId, authMiddleware, middl
             error?: string;
             finishedAt?: string;
             isFinished: boolean;
-            outputs?: components$5["schemas"]["TaskOutputs"];
+            outputs?: components$7["schemas"]["TaskOutputs"];
             result?: string;
             status: "processing" | "success" | "error";
             taskId: string;
@@ -13545,7 +13791,7 @@ declare const createProjectClients: ({ baseUrl, projectId, authMiddleware, middl
             error?: string;
             finishedAt?: string;
             isFinished: boolean;
-            outputs?: components$5["schemas"]["TaskOutputs"];
+            outputs?: components$7["schemas"]["TaskOutputs"];
             result?: string;
             status: "processing" | "success" | "error";
             taskId: string;
@@ -13558,7 +13804,7 @@ declare const createProjectClients: ({ baseUrl, projectId, authMiddleware, middl
             error?: string;
             finishedAt?: string;
             isFinished: boolean;
-            outputs?: components$5["schemas"]["TaskOutputs"];
+            outputs?: components$7["schemas"]["TaskOutputs"];
             result?: string;
             status: "processing" | "success" | "error";
             taskId: string;
@@ -13571,7 +13817,7 @@ declare const createProjectClients: ({ baseUrl, projectId, authMiddleware, middl
             error?: string;
             finishedAt?: string;
             isFinished: boolean;
-            outputs?: components$5["schemas"]["TaskOutputs"];
+            outputs?: components$7["schemas"]["TaskOutputs"];
             result?: string;
             status: "processing" | "success" | "error";
             taskId: string;
@@ -13584,7 +13830,7 @@ declare const createProjectClients: ({ baseUrl, projectId, authMiddleware, middl
             error?: string;
             finishedAt?: string;
             isFinished: boolean;
-            outputs?: components$5["schemas"]["TaskOutputs"];
+            outputs?: components$7["schemas"]["TaskOutputs"];
             result?: string;
             status: "processing" | "success" | "error";
             taskId: string;
@@ -13597,7 +13843,7 @@ declare const createProjectClients: ({ baseUrl, projectId, authMiddleware, middl
             error?: string;
             finishedAt?: string;
             isFinished: boolean;
-            outputs?: components$5["schemas"]["TaskOutputs"];
+            outputs?: components$7["schemas"]["TaskOutputs"];
             result?: string;
             status: "processing" | "success" | "error";
             taskId: string;
@@ -13605,7 +13851,7 @@ declare const createProjectClients: ({ baseUrl, projectId, authMiddleware, middl
             url: string;
         }>;
         getSinkSettings: (branchId: string, sourceId: string, sinkId: string, signal?: AbortSignal) => Promise<{
-            settings?: components$5["schemas"]["SettingResult"][];
+            settings?: components$7["schemas"]["SettingResult"][];
         }>;
         updateSinkSettings: (branchId: string, sourceId: string, sinkId: string, body: UpdateSinkSettingsRequestBody, signal?: AbortSignal) => Promise<{
             createdAt: string;
@@ -13613,7 +13859,7 @@ declare const createProjectClients: ({ baseUrl, projectId, authMiddleware, middl
             error?: string;
             finishedAt?: string;
             isFinished: boolean;
-            outputs?: components$5["schemas"]["TaskOutputs"];
+            outputs?: components$7["schemas"]["TaskOutputs"];
             result?: string;
             status: "processing" | "success" | "error";
             taskId: string;
@@ -13621,20 +13867,20 @@ declare const createProjectClients: ({ baseUrl, projectId, authMiddleware, middl
             url: string;
         }>;
         getSinkStatisticsTotal: (branchId: string, sourceId: string, sinkId: string, signal?: AbortSignal) => Promise<{
-            levels: components$5["schemas"]["Levels"];
-            total: components$5["schemas"]["Level"];
+            levels: components$7["schemas"]["Levels"];
+            total: components$7["schemas"]["Level"];
         }>;
         getSinkStatisticsFiles: (branchId: string, sourceId: string, sinkId: string, query?: SinkStatisticsFilesQuery, signal?: AbortSignal) => Promise<{
-            files: components$5["schemas"]["SinkFiles"];
+            files: components$7["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"][];
+            page: components$7["schemas"]["PaginatedResponse"];
+            versions: components$7["schemas"]["Version"][];
         }>;
         getSinkVersion: (branchId: string, sourceId: string, sinkId: string, versionNumber: number, signal?: AbortSignal) => Promise<{
             at: string;
-            by: components$5["schemas"]["By"];
+            by: components$7["schemas"]["By"];
             description: string;
             hash: string;
             number: number;
@@ -13645,7 +13891,7 @@ declare const createProjectClients: ({ baseUrl, projectId, authMiddleware, middl
             error?: string;
             finishedAt?: string;
             isFinished: boolean;
-            outputs?: components$5["schemas"]["TaskOutputs"];
+            outputs?: components$7["schemas"]["TaskOutputs"];
             result?: string;
             status: "processing" | "success" | "error";
             taskId: string;
@@ -13658,7 +13904,7 @@ declare const createProjectClients: ({ baseUrl, projectId, authMiddleware, middl
             error?: string;
             finishedAt?: string;
             isFinished: boolean;
-            outputs?: components$5["schemas"]["TaskOutputs"];
+            outputs?: components$7["schemas"]["TaskOutputs"];
             result?: string;
             status: "processing" | "success" | "error";
             taskId: string;
@@ -13667,61 +13913,60 @@ declare const createProjectClients: ({ baseUrl, projectId, authMiddleware, middl
         }>;
     };
     notifications: {
+        healthCheck: (signal?: AbortSignal) => Promise<unknown>;
         getSubscriptions: (query?: ListSubscriptionsQuery, signal?: AbortSignal) => Promise<({
-            id: components$6["schemas"]["NumericString"];
+            id: components$8["schemas"]["NumericString"];
         } & {
-            event: components$6["schemas"]["EventName"];
+            event: components$8["schemas"]["EventName"];
             expiresAt?: string;
             filters?: {
                 field: string;
                 value: string | number | boolean;
                 operator?: "==" | ">=";
             }[];
-            recipient: components$6["schemas"]["RecipientChannel_Email"] | components$6["schemas"]["RecipientChannel_Webhook"];
+            recipient: components$8["schemas"]["RecipientChannel_Email"] | components$8["schemas"]["RecipientChannel_Webhook"];
         })[]>;
         getSubscription: (subscriptionId: SubscriptionId, signal?: AbortSignal) => Promise<{
-            id: components$6["schemas"]["NumericString"];
+            id: components$8["schemas"]["NumericString"];
         } & {
-            event: components$6["schemas"]["EventName"];
+            event: components$8["schemas"]["EventName"];
             expiresAt?: string;
             filters?: {
                 field: string;
                 value: string | number | boolean;
                 operator?: "==" | ">=";
             }[];
-            recipient: components$6["schemas"]["RecipientChannel_Email"] | components$6["schemas"]["RecipientChannel_Webhook"];
+            recipient: components$8["schemas"]["RecipientChannel_Email"] | components$8["schemas"]["RecipientChannel_Webhook"];
         }>;
         createSubscription: (body: CreateSubscriptionBody, signal?: AbortSignal) => Promise<{
-            id: components$6["schemas"]["NumericString"];
+            id: components$8["schemas"]["NumericString"];
         } & {
-            event: components$6["schemas"]["EventName"];
+            event: components$8["schemas"]["EventName"];
             expiresAt?: string;
             filters?: {
                 field: string;
                 value: string | number | boolean;
                 operator?: "==" | ">=";
             }[];
-            recipient: components$6["schemas"]["RecipientChannel_Email"] | components$6["schemas"]["RecipientChannel_Webhook"];
+            recipient: components$8["schemas"]["RecipientChannel_Email"] | components$8["schemas"]["RecipientChannel_Webhook"];
         }>;
         createSubscriptions: (bodies: CreateSubscriptionBody[], signal?: AbortSignal) => Promise<({
-            id: components$6["schemas"]["NumericString"];
+            id: components$8["schemas"]["NumericString"];
         } & {
-            event: components$6["schemas"]["EventName"];
+            event: components$8["schemas"]["EventName"];
             expiresAt?: string;
             filters?: {
                 field: string;
                 value: string | number | boolean;
                 operator?: "==" | ">=";
             }[];
-            recipient: components$6["schemas"]["RecipientChannel_Email"] | components$6["schemas"]["RecipientChannel_Webhook"];
+            recipient: components$8["schemas"]["RecipientChannel_Email"] | components$8["schemas"]["RecipientChannel_Webhook"];
         })[]>;
         deleteSubscription: (subscriptionId: SubscriptionId, signal?: AbortSignal) => Promise<void>;
         deleteSubscriptions: (subscriptionIds: SubscriptionId[], signal?: AbortSignal) => Promise<void>;
     };
     metastore: {
-        healthCheck: (signal?: AbortSignal) => Promise<{
-            [key: string]: string;
-        }>;
+        healthCheck: (signal?: AbortSignal) => Promise<unknown>;
         repository: {
             getMetaObjects: <TData extends Record<string, unknown>>(input: GetMetaObjectsPath, signal?: AbortSignal) => Promise<MetaStoreListResponse<TData>>;
             getMetaObjectRevisions: <TData extends Record<string, unknown>>(input: GetMetaObjectRevisionsPath, signal?: AbortSignal) => Promise<MetaStoreListResponse<TData>>;
@@ -13730,12 +13975,13 @@ declare const createProjectClients: ({ baseUrl, projectId, authMiddleware, middl
             deleteMetaObject: (input: DeleteMetaObjectPath) => Promise<never>;
             updateMetaObject: <TData extends Record<string, unknown>>({ objectType, UUID, data, ...body }: UpdateMetaObjectInput<TData>) => Promise<MetaStoreObjectResponse<TData>>;
             replaceMetaObject: <TData extends Record<string, unknown>>({ objectType, UUID, data, ...body }: ReplaceMetaObjectInput<TData>) => Promise<MetaStoreObjectResponse<TData>>;
+            replaceTargetProjects: ({ objectType, UUID, ...body }: ReplaceTargetProjectsInput) => Promise<void>;
             getMetaObjectRevision: <TData extends Record<string, unknown>>(input: GetMetaObjectRevisionPath, signal?: AbortSignal) => Promise<MetaStoreObjectResponse<TData>>;
             deleteMetaObjectRevision: (input: DeleteMetaObjectRevisionPath) => Promise<never>;
         };
         schema: {
             getSchema: (input: GetSchemaPath, signal?: AbortSignal) => Promise<{
-                versions?: components$7["schemas"]["models.SchemaInfo"][];
+                versions?: components$9["schemas"]["models.SchemaInfo"][];
             }>;
             getVersionedSchema: (input: GetVersionedSchemaPath, signal?: AbortSignal) => Promise<{
                 [key: string]: unknown;
@@ -13749,15 +13995,15 @@ declare const createProjectClients: ({ baseUrl, projectId, authMiddleware, middl
         isAvailable: boolean;
     }[];
     storage: {
+        healthCheck: (signal?: AbortSignal) => Promise<unknown>;
+        getStackInfo: (query?: GetStackInfoQuery, signal?: AbortSignal) => Promise<StackInfo>;
         buckets: {
-            getBuckets: (branchId: string, query?: GetBucketsQuery, signal?: AbortSignal) => Promise<Bucket[]>;
+            getBuckets: ({ branchId, ...query }: GetBucketsInput, signal?: AbortSignal) => Promise<Bucket[]>;
             getBucket: ({ branchId, bucketId, include }: GetBucketInput, signal?: AbortSignal) => Promise<BucketDetail>;
             createBucket: (body: CreateBucketBody) => Promise<BucketDetail>;
-            updateBucket: (id: string, body: UpdateBucketBody) => Promise<BucketDetail>;
+            updateBucket: ({ bucketId, ...body }: UpdateBucketInput) => Promise<BucketDetail>;
             deleteBucket: (id: string) => Promise<void>;
-            deleteBucketAsync: (id: string, options?: {
-                force?: boolean;
-            }) => Promise<{
+            deleteBucketAsync: ({ bucketId, ...query }: DeleteBucketAsyncInput) => Promise<{
                 id: number;
                 tableId: string | null;
                 runId: string;
@@ -13798,14 +14044,23 @@ declare const createProjectClients: ({ baseUrl, projectId, authMiddleware, middl
                 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<{
+            getBucketOwner: ({ branchId, bucketId }: GetBucketOwnerInput, signal?: AbortSignal) => Promise<{
+                id: number;
+                name: string;
+                email: string;
+            }>;
+            updateBucketOwner: ({ bucketId, ...body }: UpdateBucketOwnerInput, signal?: AbortSignal) => Promise<void>;
+            saveBucketMetadata: ({ branchId, bucketId, ...body }: SaveBucketMetadataInput, signal?: AbortSignal) => Promise<{
+                id: number;
+                key: string;
+                value: string | null;
+                provider: string;
+                timestamp: string;
+            }[]>;
+            deleteBucketMetadata: ({ branchId, bucketId, metadataId }: DeleteBucketMetadataInput, signal?: AbortSignal) => Promise<void>;
+        };
+        bucketSharing: {
+            shareBucketToOrganizationAsync: ({ branchId, bucketId }: ShareBucketToOrganizationInput, signal?: AbortSignal) => Promise<{
                 id: number;
                 tableId: string | null;
                 runId: string;
@@ -13844,7 +14099,7 @@ declare const createProjectClients: ({ baseUrl, projectId, authMiddleware, middl
                 status: "success";
                 results: null;
             })>;
-            shareBucketToOrganizationProject: (bucketId: string, signal?: AbortSignal) => Promise<{
+            shareBucketToOrganizationProjectAsync: ({ branchId, bucketId }: ShareBucketToOrganizationProjectInput, signal?: AbortSignal) => Promise<{
                 id: number;
                 tableId: string | null;
                 runId: string;
@@ -13883,7 +14138,7 @@ declare const createProjectClients: ({ baseUrl, projectId, authMiddleware, middl
                 status: "success";
                 results: null;
             })>;
-            shareBucketToProjects: (bucketId: string, body: ShareBucketToProjectsBody, signal?: AbortSignal) => Promise<{
+            shareBucketToProjectsAsync: ({ branchId, bucketId, ...body }: ShareBucketToProjectsInput, signal?: AbortSignal) => Promise<{
                 id: number;
                 tableId: string | null;
                 runId: string;
@@ -13922,7 +14177,7 @@ declare const createProjectClients: ({ baseUrl, projectId, authMiddleware, middl
                 status: "success";
                 results: null;
             })>;
-            shareBucketToUsers: (bucketId: string, body: ShareBucketToUsersBody, signal?: AbortSignal) => Promise<{
+            shareBucketToUsersAsync: ({ branchId, bucketId, ...body }: ShareBucketToUsersInput, signal?: AbortSignal) => Promise<{
                 id: number;
                 tableId: string | null;
                 runId: string;
@@ -13961,7 +14216,7 @@ declare const createProjectClients: ({ baseUrl, projectId, authMiddleware, middl
                 status: "success";
                 results: null;
             })>;
-            unshareBucket: (bucketId: string, signal?: AbortSignal) => Promise<{
+            unshareBucketAsync: ({ branchId, bucketId }: UnshareBucketInput, signal?: AbortSignal) => Promise<{
                 id: number;
                 tableId: string | null;
                 runId: string;
@@ -14000,7 +14255,7 @@ declare const createProjectClients: ({ baseUrl, projectId, authMiddleware, middl
                 status: "success";
                 results: null;
             })>;
-            forceUnlinkBucket: (bucketId: string, linkedProjectId: string, signal?: AbortSignal) => Promise<{
+            forceUnlinkBucketAsync: ({ branchId, bucketId, linkedProjectId }: ForceUnlinkBucketInput, signal?: AbortSignal) => Promise<{
                 id: number;
                 tableId: string | null;
                 runId: string;
@@ -14039,13 +14294,7 @@ declare const createProjectClients: ({ baseUrl, projectId, authMiddleware, middl
                 status: "success";
                 results: null;
             })>;
-            getBucketOwner: ({ branchId, bucketId }: GetBucketOwnerInput, signal?: AbortSignal) => Promise<{
-                id: number;
-                name: string;
-                email: string;
-            }>;
-            updateBucketOwner: (bucketId: string, body: UpdateBucketOwnerBody, signal?: AbortSignal) => Promise<void>;
-            refreshExternalBucket: (bucketId: string, query?: RefreshExternalBucketQuery, signal?: AbortSignal) => Promise<{
+            linkBucketAsync: (body: LinkBucketBody, signal?: AbortSignal) => Promise<{
                 id: number;
                 tableId: string | null;
                 runId: string;
@@ -14057,7 +14306,7 @@ declare const createProjectClients: ({ baseUrl, projectId, authMiddleware, middl
                 };
                 endTime: string | null;
                 startTime: string | null;
-                operationName: "bucketRefresh";
+                operationName: "bucketLink";
                 operationParams: {
                     queue: string;
                 } & Record<string, unknown>;
@@ -14082,9 +14331,19 @@ declare const createProjectClients: ({ baseUrl, projectId, authMiddleware, middl
                 };
             } | {
                 status: "success";
-                results: null;
+                results: BucketDetail;
             })>;
-            registerBucket: (body: RegisterBucketBody, signal?: AbortSignal) => Promise<{
+            sharedBuckets: (signal?: AbortSignal) => Promise<Record<string, never>[]>;
+        };
+        bucketListings: {
+            getListing: (bucketId: string, signal?: AbortSignal) => Promise<{
+                name: string;
+                description?: string | null;
+                backend: "bigquery";
+                bigquery?: components$a["schemas"]["BigQueryBucketListingDetailResponse"] | null;
+                createdAt: string;
+            } | null>;
+            createListingAsync: ({ bucketId, ...input }: CreateBucketListingInput, signal?: AbortSignal) => Promise<{
                 id: number;
                 tableId: string | null;
                 runId: string;
@@ -14096,10 +14355,12 @@ declare const createProjectClients: ({ baseUrl, projectId, authMiddleware, middl
                 };
                 endTime: string | null;
                 startTime: string | null;
-                operationName: "bucketRegister";
+                operationName: "bucketListingCreate";
                 operationParams: {
                     queue: string;
-                } & Record<string, unknown>;
+                } & {
+                    bucketId: string;
+                };
                 metrics: {
                     inCompressed: boolean;
                     inBytes: number;
@@ -14123,45 +14384,7 @@ declare const createProjectClients: ({ baseUrl, projectId, authMiddleware, middl
                 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>;
-        };
-        events: {
-            getEvents: (query?: GetEventsQuery, signal?: AbortSignal) => Promise<StorageEvent[]>;
-            getEvent: (eventId: string | number, signal?: AbortSignal) => Promise<StorageEvent>;
-            getTableEvents: ({ branchId, tableId, ...query }: GetTableEventsInput, signal?: AbortSignal) => Promise<TableEvent[]>;
-            getBucketEvents: ({ branchId, bucketId, ...query }: GetBucketEventsInput, signal?: AbortSignal) => Promise<TableEvent[]>;
-            createEvent: (body: CreateEventBody, signal?: AbortSignal) => Promise<StorageEvent>;
-        };
-        files: {
-            getFile: (fileId: number, signal?: AbortSignal) => Promise<File>;
-            getFileContent: (fileId: number, signal?: AbortSignal) => Promise<string>;
-            getFiles: (query?: GetFilesQuery, signal?: AbortSignal) => Promise<File[]>;
-            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: ({ branchId, tableId }: GetTableInput, signal?: AbortSignal) => Promise<TableDetail>;
-            getDataPreview: ({ branchId, tableId, ...query }: GetDataPreviewInput, signal?: AbortSignal) => Promise<PreviewData>;
-            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<{
+            updateListingAsync: ({ bucketId, ...input }: UpdateBucketListingInput, signal?: AbortSignal) => Promise<{
                 id: number;
                 tableId: string | null;
                 runId: string;
@@ -14173,15 +14396,11 @@ declare const createProjectClients: ({ baseUrl, projectId, authMiddleware, middl
                 };
                 endTime: string | null;
                 startTime: string | null;
-                operationName: "tableDefinitionCreate";
+                operationName: "bucketListingUpdate";
                 operationParams: {
                     queue: string;
                 } & {
-                    timestampType: string;
-                    primaryKeysNames: string[];
-                    name: string;
-                    backendConfiguration: unknown[];
-                    columns: unknown[];
+                    bucketId: string;
                 };
                 metrics: {
                     inCompressed: boolean;
@@ -14204,10 +14423,9 @@ declare const createProjectClients: ({ baseUrl, projectId, authMiddleware, middl
                 };
             } | {
                 status: "success";
-                results: Table;
+                results: null;
             })>;
-            importAsync: (tableId: string, body: TableImportAsyncBody, signal?: AbortSignal) => Promise<TableImportJob>;
-            updateTableDefinition: ({ branchId, tableId, ...body }: UpdateTableDefinitionInput, signal?: AbortSignal) => Promise<{
+            deleteListingAsync: (bucketId: string, signal?: AbortSignal) => Promise<{
                 id: number;
                 tableId: string | null;
                 runId: string;
@@ -14219,14 +14437,11 @@ declare const createProjectClients: ({ baseUrl, projectId, authMiddleware, middl
                 };
                 endTime: string | null;
                 startTime: string | null;
-                operationName: "tableDefinitionUpdate";
+                operationName: "bucketListingDelete";
                 operationParams: {
                     queue: string;
                 } & {
-                    tableId: string;
-                    displayName: string;
-                    description?: string | null;
-                    columns: unknown[];
+                    bucketId: string;
                 };
                 metrics: {
                     inCompressed: boolean;
@@ -14249,10 +14464,20 @@ declare const createProjectClients: ({ baseUrl, projectId, authMiddleware, middl
                 };
             } | {
                 status: "success";
-                results: Table;
+                results: null;
             })>;
-            updateTable: (tableId: string, body: UpdateTableBody, signal?: AbortSignal) => Promise<Table>;
-            pullTable: (tableId: string, signal?: AbortSignal) => Promise<{
+            getListings: (signal?: AbortSignal) => Promise<{
+                bucketId: string;
+                name: string;
+                description?: string | null;
+                backend: "bigquery";
+                bigquery?: components$a["schemas"]["BigQueryBucketListingDetailResponse"] | null;
+                createdAt: string;
+                detail: components$a["schemas"]["BucketListingDetailResponse"];
+            }[]>;
+        };
+        bucketExternal: {
+            registerBucketAsync: (body: RegisterBucketBody, signal?: AbortSignal) => Promise<{
                 id: number;
                 tableId: string | null;
                 runId: string;
@@ -14264,12 +14489,57 @@ declare const createProjectClients: ({ baseUrl, projectId, authMiddleware, middl
                 };
                 endTime: string | null;
                 startTime: string | null;
-                operationName: "devBranchTablePull";
+                operationName: "bucketRegister";
                 operationParams: {
                     queue: string;
-                } & {
+                } & Record<string, unknown>;
+                metrics: {
+                    inCompressed: boolean;
+                    inBytes: number;
+                    inBytesUncompressed: number;
+                    outCompressed: boolean;
+                    outBytes: number;
+                    outBytesUncompressed: number;
+                };
+            } & ({
+                status: Exclude<JobStatus, "success" | "error">;
+                results: null;
+            } | {
+                status: "error";
+                results: null;
+                error: {
+                    code: string;
+                    message: string;
+                    exceptionId?: string;
+                };
+            } | {
+                status: "success";
+                results: {
+                    id: string;
+                    warnings?: {
+                        message: string;
+                    }[];
+                };
+            })>;
+            getBucketRegistrationGuide: (query: BucketRegistrationGuideQuery, signal?: AbortSignal) => Promise<{
+                markdown: string;
+            }>;
+            refreshExternalBucketAsync: ({ bucketId, ...query }: RefreshExternalBucketInput, 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;
@@ -14291,9 +14561,25 @@ declare const createProjectClients: ({ baseUrl, projectId, authMiddleware, middl
                 };
             } | {
                 status: "success";
-                results: null;
+                results: {
+                    warnings?: {
+                        message: string;
+                    }[];
+                };
             })>;
-            createAliasTable: (bucketId: string, body: CreateAliasTableBody, signal?: AbortSignal) => Promise<Table | ({
+            createScheduledRefresh: ({ branchId, bucketId, ...body }: CreateScheduledRefreshInput) => Promise<ScheduledTask>;
+            deleteScheduledTask: (taskId: string) => Promise<void>;
+        };
+        tables: {
+            getTables: ({ branchId, include, ...query }: GetTablesInput, signal?: AbortSignal) => Promise<Table[]>;
+            getTable: ({ branchId, tableId }: GetTableInput, signal?: AbortSignal) => Promise<TableDetail>;
+            getDataPreview: ({ branchId, tableId, ...query }: GetDataPreviewInput, signal?: AbortSignal) => Promise<PreviewData>;
+            deleteTable: (id: string, signal?: AbortSignal) => Promise<void>;
+            deleteTables: (ids: string[]) => Promise<void>;
+            deleteTableRows: ({ tableId, ...query }: DeleteTableRowsInput, signal?: AbortSignal) => Promise<JobUnion>;
+            exportAsync: ({ tableId, ...body }: ExportAsyncInput, signal?: AbortSignal) => Promise<TableExportJob>;
+            createTableAsync: ({ bucketId, ...body }: CreateTableAsyncInput, signal?: AbortSignal) => Promise<TableCreateJob>;
+            createTableDefinitionAsync: ({ bucketId, ...body }: CreateTableDefinitionInput, signal?: AbortSignal) => Promise<{
                 id: number;
                 tableId: string | null;
                 runId: string;
@@ -14305,12 +14591,15 @@ declare const createProjectClients: ({ baseUrl, projectId, authMiddleware, middl
                 };
                 endTime: string | null;
                 startTime: string | null;
-                operationName: "aliasCreate";
+                operationName: "tableDefinitionCreate";
                 operationParams: {
                     queue: string;
                 } & {
+                    timestampType: string;
+                    primaryKeysNames: string[];
                     name: string;
-                    sourceTable: string;
+                    backendConfiguration: unknown[];
+                    columns: unknown[];
                 };
                 metrics: {
                     inCompressed: boolean;
@@ -14333,11 +14622,10 @@ declare const createProjectClients: ({ baseUrl, projectId, authMiddleware, middl
                 };
             } | {
                 status: "success";
-                results: null;
-            }))>;
-            setAliasTableFilter: (tableId: string, body: SetAliasTableFilterBody, signal?: AbortSignal) => Promise<Table>;
-            removeAliasTableFilter: (tableId: string, signal?: AbortSignal) => Promise<void>;
-            createSnapshot: ({ branchId, tableId, ...body }: CreateSnapshotInput, signal?: AbortSignal) => Promise<{
+                results: Table;
+            })>;
+            importAsync: ({ tableId, ...body }: ImportAsyncInput, signal?: AbortSignal) => Promise<TableImportJob>;
+            updateTableDefinition: ({ branchId, tableId, ...body }: UpdateTableDefinitionInput, signal?: AbortSignal) => Promise<{
                 id: number;
                 tableId: string | null;
                 runId: string;
@@ -14349,11 +14637,14 @@ declare const createProjectClients: ({ baseUrl, projectId, authMiddleware, middl
                 };
                 endTime: string | null;
                 startTime: string | null;
-                operationName: "tableSnapshotCreate";
+                operationName: "tableDefinitionUpdate";
                 operationParams: {
                     queue: string;
                 } & {
-                    id: string;
+                    tableId: string;
+                    displayName: string;
+                    description?: string | null;
+                    columns: unknown[];
                 };
                 metrics: {
                     inCompressed: boolean;
@@ -14376,15 +14667,10 @@ declare const createProjectClients: ({ baseUrl, projectId, authMiddleware, middl
                 };
             } | {
                 status: "success";
-                results: null;
+                results: Table;
             })>;
-            deleteSnapshot: (snapshotId: string, signal?: AbortSignal) => Promise<JobUnion | null>;
-            loadTableSnapshots: ({ branchId, tableId, ...query }: LoadTableSnapshotsInput, 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<{
+            updateTable: ({ tableId, ...body }: UpdateTableInput, signal?: AbortSignal) => Promise<Table>;
+            pullTableAsync: ({ branchId, tableId }: PullTableAsyncInput, signal?: AbortSignal) => Promise<{
                 id: number;
                 tableId: string | null;
                 runId: string;
@@ -14396,7 +14682,7 @@ declare const createProjectClients: ({ baseUrl, projectId, authMiddleware, middl
                 };
                 endTime: string | null;
                 startTime: string | null;
-                operationName: "tableColumnAdd";
+                operationName: "devBranchTablePull";
                 operationParams: {
                     queue: string;
                 } & {
@@ -14425,7 +14711,7 @@ declare const createProjectClients: ({ baseUrl, projectId, authMiddleware, middl
                 status: "success";
                 results: null;
             })>;
-            deleteTableColumn: (tableId: string, columnName: string, query?: DeleteTableColumnQuery, signal?: AbortSignal) => Promise<{
+            createAliasTable: ({ bucketId, ...body }: CreateAliasTableInput, signal?: AbortSignal) => Promise<Table | ({
                 id: number;
                 tableId: string | null;
                 runId: string;
@@ -14437,11 +14723,12 @@ declare const createProjectClients: ({ baseUrl, projectId, authMiddleware, middl
                 };
                 endTime: string | null;
                 startTime: string | null;
-                operationName: "tableColumnDelete";
+                operationName: "aliasCreate";
                 operationParams: {
                     queue: string;
                 } & {
-                    id: string;
+                    name: string;
+                    sourceTable: string;
                 };
                 metrics: {
                     inCompressed: boolean;
@@ -14465,8 +14752,19 @@ declare const createProjectClients: ({ baseUrl, projectId, authMiddleware, middl
             } | {
                 status: "success";
                 results: null;
-            })>;
-            createTablePrimaryKey: (tableId: string, body: CreateTablePrimaryKeyBody, signal?: AbortSignal) => Promise<{
+            }))>;
+            setAliasTableFilter: ({ tableId, ...body }: SetAliasTableFilterInput, signal?: AbortSignal) => Promise<Table>;
+            removeAliasTableFilter: (tableId: string, signal?: AbortSignal) => Promise<void>;
+            saveTableMetadata: ({ branchId, tableId, ...body }: SaveTableMetadataInput, signal?: AbortSignal) => Promise<{
+                metadata: components$a["schemas"]["MetadataItemResponse"][];
+                columnsMetadata: {
+                    [key: string]: components$a["schemas"]["MetadataItemResponse"][];
+                };
+            }>;
+            deleteTableMetadata: ({ branchId, tableId, metadataId }: DeleteTableMetadataInput, signal?: AbortSignal) => Promise<void>;
+        };
+        columns: {
+            addTableColumnAsync: ({ id, ...body }: AddTableColumnInput, signal?: AbortSignal) => Promise<{
                 id: number;
                 tableId: string | null;
                 runId: string;
@@ -14478,7 +14776,7 @@ declare const createProjectClients: ({ baseUrl, projectId, authMiddleware, middl
                 };
                 endTime: string | null;
                 startTime: string | null;
-                operationName: "tablePrimaryKeyAdd";
+                operationName: "tableColumnAdd";
                 operationParams: {
                     queue: string;
                 } & {
@@ -14507,7 +14805,7 @@ declare const createProjectClients: ({ baseUrl, projectId, authMiddleware, middl
                 status: "success";
                 results: null;
             })>;
-            removeTablePrimaryKey: (tableId: string, signal?: AbortSignal) => Promise<{
+            deleteTableColumnAsync: ({ tableId, columnName, ...query }: DeleteTableColumnInput, signal?: AbortSignal) => Promise<{
                 id: number;
                 tableId: string | null;
                 runId: string;
@@ -14519,7 +14817,7 @@ declare const createProjectClients: ({ baseUrl, projectId, authMiddleware, middl
                 };
                 endTime: string | null;
                 startTime: string | null;
-                operationName: "tablePrimaryKeyDelete";
+                operationName: "tableColumnDelete";
                 operationParams: {
                     queue: string;
                 } & {
@@ -14548,12 +14846,7 @@ declare const createProjectClients: ({ baseUrl, projectId, authMiddleware, middl
                 status: "success";
                 results: null;
             })>;
-            saveColumnMetadata: (columnId: string, body: SaveMetadataBody, signal?: AbortSignal) => Promise<Metadata[]>;
-            deleteColumnMetadata: (columnId: string, metadataId: string, signal?: AbortSignal) => Promise<void>;
-        };
-        branches: {
-            getDevBranches: (signal?: AbortSignal) => Promise<DevBranch[]>;
-            createDevBranchJob: (body: CreateDevBranchJobBody) => Promise<{
+            createTablePrimaryKeyAsync: ({ tableId, ...body }: CreateTablePrimaryKeyInput, signal?: AbortSignal) => Promise<{
                 id: number;
                 tableId: string | null;
                 runId: string;
@@ -14565,14 +14858,11 @@ declare const createProjectClients: ({ baseUrl, projectId, authMiddleware, middl
                 };
                 endTime: string | null;
                 startTime: string | null;
-                operationName: "devBranchCreate";
+                operationName: "tablePrimaryKeyAdd";
                 operationParams: {
                     queue: string;
                 } & {
-                    values: {
-                        name: string;
-                        description: string;
-                    };
+                    id: string;
                 };
                 metrics: {
                     inCompressed: boolean;
@@ -14585,9 +14875,6 @@ declare const createProjectClients: ({ baseUrl, projectId, authMiddleware, middl
             } & ({
                 status: Exclude<JobStatus, "success" | "error">;
                 results: null;
-            } | {
-                status: "success";
-                results: DevBranch;
             } | {
                 status: "error";
                 results: null;
@@ -14596,9 +14883,11 @@ declare const createProjectClients: ({ baseUrl, projectId, authMiddleware, middl
                     message: string;
                     exceptionId?: string;
                 };
+            } | {
+                status: "success";
+                results: null;
             })>;
-            updateDevBranch: ({ id, name, description, }: CreateDevBranchJobBody & DevBranchPath) => Promise<DevBranch>;
-            deleteDevBranchJob: (id: number) => Promise<{
+            removeTablePrimaryKeyAsync: (tableId: string, signal?: AbortSignal) => Promise<{
                 id: number;
                 tableId: string | null;
                 runId: string;
@@ -14610,13 +14899,11 @@ declare const createProjectClients: ({ baseUrl, projectId, authMiddleware, middl
                 };
                 endTime: string | null;
                 startTime: string | null;
-                operationName: "devBranchDelete";
+                operationName: "tablePrimaryKeyDelete";
                 operationParams: {
                     queue: string;
                 } & {
-                    values: {
-                        id: number;
-                    };
+                    id: string;
                 };
                 metrics: {
                     inCompressed: boolean;
@@ -14641,19 +14928,17 @@ declare const createProjectClients: ({ baseUrl, projectId, authMiddleware, middl
                 status: "success";
                 results: null;
             })>;
-            getDevBranchMetadata: (id: string, signal?: AbortSignal) => Promise<BranchMetadata[]>;
-            saveDevBranchMetadata: (id: string, metadata: BranchMetadataEntry[], signal?: AbortSignal) => Promise<BranchMetadata[]>;
-            deleteDevBranchMetadata: (id: string, metadataId: string, signal?: AbortSignal) => Promise<void>;
+            saveColumnMetadata: ({ branchId, columnId, ...body }: SaveColumnMetadataInput, signal?: AbortSignal) => Promise<{
+                id: number;
+                key: string;
+                value: string | null;
+                provider: string;
+                timestamp: string;
+            }[]>;
+            deleteColumnMetadata: ({ branchId, columnId, metadataId }: DeleteColumnMetadataInput, signal?: AbortSignal) => Promise<void>;
         };
-        workspaces: {
-            getWorkspace: (path: WorkspacePath, signal?: AbortSignal) => Promise<Workspace>;
-            getWorkspaces: (branchId: WorkspacesPath["branchId"], signal?: AbortSignal) => Promise<Workspace[]>;
-            deleteWorkspace: (path: WorkspacePath) => Promise<void>;
-            resetWorkspacePassword: ({ branchId, workspaceId }: WorkspacePath) => Promise<ResetWorkspacePassword>;
-            deleteWorkspaces: ({ workspaceIds, branchId, }: Omit<WorkspacePath, "workspaceId"> & {
-                workspaceIds: WorkspacePath["workspaceId"][];
-            }) => Promise<void>;
-            deleteWorkspaceJob: (path: WorkspacePath) => Promise<{
+        snapshots: {
+            createSnapshotAsync: ({ branchId, tableId, ...body }: CreateSnapshotInput, signal?: AbortSignal) => Promise<{
                 id: number;
                 tableId: string | null;
                 runId: string;
@@ -14665,12 +14950,11 @@ declare const createProjectClients: ({ baseUrl, projectId, authMiddleware, middl
                 };
                 endTime: string | null;
                 startTime: string | null;
-                operationName: "workspaceDrop";
+                operationName: "tableSnapshotCreate";
                 operationParams: {
                     queue: string;
                 } & {
-                    workspaceId: string;
-                    backendConfiguration: [];
+                    id: string;
                 };
                 metrics: {
                     inCompressed: boolean;
@@ -14695,10 +14979,14 @@ declare const createProjectClients: ({ baseUrl, projectId, authMiddleware, middl
                 status: "success";
                 results: null;
             })>;
-            setWorkspacePublicKey: ({ branchId, workspaceId, publicKey, }: SetWorkspacePublicInput) => Promise<Workspace>;
-            getWorkspaceSaml2Login: (path: GetWorkspaceSaml2LoginPath, signal?: AbortSignal) => Promise<WorkspaceSaml2Login>;
-            getWorkspaceObjects: (path: WorkspacePath, signal?: AbortSignal) => Promise<WorkspaceObject[]>;
-            deleteWorkspaceObjectsAsync: ({ branchId, workspaceId, ...body }: DeleteWorkspaceObjectInput) => Promise<{
+            deleteSnapshotAsync: (snapshotId: string, signal?: AbortSignal) => Promise<JobUnion | null>;
+            getSnapshot: (snapshotId: string, signal?: AbortSignal) => Promise<Snapshot>;
+            getTableSnapshots: ({ branchId, tableId, ...query }: GetTableSnapshotsInput, signal?: AbortSignal) => Promise<Snapshot[]>;
+        };
+        branches: {
+            getDevBranches: (signal?: AbortSignal) => Promise<DevBranch[]>;
+            updateDevBranch: ({ id, name, description }: UpdateDevBranchInput) => Promise<DevBranch>;
+            createDevBranchAsync: (body: CreateDevBranchBody) => Promise<{
                 id: number;
                 tableId: string | null;
                 runId: string;
@@ -14710,12 +14998,14 @@ declare const createProjectClients: ({ baseUrl, projectId, authMiddleware, middl
                 };
                 endTime: string | null;
                 startTime: string | null;
-                operationName: "workspaceBatchDeleteObject";
+                operationName: "devBranchCreate";
                 operationParams: {
                     queue: string;
                 } & {
-                    workspaceId: string;
-                    objects: string[];
+                    values: {
+                        name: string;
+                        description: string;
+                    };
                 };
                 metrics: {
                     inCompressed: boolean;
@@ -14730,41 +15020,72 @@ declare const createProjectClients: ({ baseUrl, projectId, authMiddleware, middl
                 results: null;
             } | {
                 status: "success";
-                results: {
-                    deleted: {
-                        objectName: string;
-                    }[];
-                    failed: {
-                        objectName: string;
-                        error: string;
-                    }[];
-                };
+                results: DevBranch;
             } | {
                 status: "error";
-                results: {
-                    deleted: {
-                        objectName: string;
-                    }[];
-                    failed: {
-                        objectName: string;
-                        error: string;
-                    }[];
+                results: null;
+                error: {
+                    code: string;
+                    message: string;
+                    exceptionId?: string;
+                };
+            })>;
+            deleteDevBranchAsync: (id: number) => Promise<{
+                id: number;
+                tableId: string | null;
+                runId: string;
+                url: string;
+                createdTime: string;
+                creatorToken: {
+                    id: string;
+                    description: string;
+                };
+                endTime: string | null;
+                startTime: string | null;
+                operationName: "devBranchDelete";
+                operationParams: {
+                    queue: string;
+                } & {
+                    values: {
+                        id: number;
+                    };
+                };
+                metrics: {
+                    inCompressed: boolean;
+                    inBytes: number;
+                    inBytesUncompressed: number;
+                    outCompressed: boolean;
+                    outBytes: number;
+                    outBytesUncompressed: number;
                 };
+            } & ({
+                status: Exclude<JobStatus, "success" | "error">;
+                results: null;
+            } | {
+                status: "error";
+                results: null;
                 error: {
                     code: string;
                     message: string;
                     exceptionId?: string;
                 };
+            } | {
+                status: "success";
+                results: null;
             })>;
-            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")[];
-                }[];
-            }>;
+            getDevBranchMetadata: (branchId: string, signal?: AbortSignal) => Promise<{
+                id: string;
+                key: string;
+                value: string | null;
+                timestamp: string;
+            }[]>;
+            saveDevBranchMetadata: ({ branchId, metadata }: SaveDevBranchMetadataInput, signal?: AbortSignal) => Promise<{
+                id: string;
+                key: string;
+                value: string | null;
+                timestamp: string;
+            }[]>;
+            deleteDevBranchMetadata: ({ branchId, metadataId }: DeleteDevBranchMetadataPath, signal?: AbortSignal) => Promise<void>;
         };
         mergeRequests: {
             getMergeRequests: (signal?: AbortSignal) => Promise<{
@@ -14990,7 +15311,7 @@ declare const createProjectClients: ({ baseUrl, projectId, authMiddleware, middl
                 startTime?: string | null;
                 endTime?: string | null;
                 runId: string;
-                results?: components$8["schemas"]["BucketListingUpdateJobResponse"] | components$8["schemas"]["BucketListingCreateJobResult"] | components$8["schemas"]["BucketListingDeleteResponse"] | components$8["schemas"]["BucketDeleteResponse"] | components$8["schemas"]["RefreshJobResponse"] | components$8["schemas"]["FileDeleteResponse"] | components$8["schemas"]["TableSnapshotCreateJobResult"] | components$8["schemas"]["TableExportAsyncJobResponse"] | components$8["schemas"]["PrimaryKeyDeleteJobResult"] | components$8["schemas"]["TableSwapResult"] | components$8["schemas"]["TableCreateResponse"] | components$8["schemas"]["TableExportJobResponse"];
+                results?: components$a["schemas"]["BucketForceUnlinkJobResult"] | components$a["schemas"]["BucketListingUpdateJobResponse"] | components$a["schemas"]["BucketListingCreateJobResult"] | components$a["schemas"]["BucketListingDeleteResponse"] | components$a["schemas"]["BucketDeleteResponse"] | components$a["schemas"]["RefreshJobResponse"] | components$a["schemas"]["FileDeleteResponse"] | components$a["schemas"]["TableSnapshotCreateJobResult"] | components$a["schemas"]["TableExportAsyncJobResponse"] | components$a["schemas"]["PrimaryKeyDeleteJobResult"] | components$a["schemas"]["TableSwapResult"] | components$a["schemas"]["TableCreateResponse"] | components$a["schemas"]["ColumnDeleteJobResult"] | components$a["schemas"]["TableExportJobResponse"];
                 creatorToken: {
                     id?: string;
                     description?: string;
@@ -15020,37 +15341,31 @@ declare const createProjectClients: ({ baseUrl, projectId, authMiddleware, middl
                 defaultBranchVersionIdentifier: string;
             }[]>;
         };
-        jobs: {
-            getJob: <T extends JobOperation | string = string>(id: GetJobPath["id"], signal?: AbortSignal) => Promise<Job<T>>;
-            getJobs: <T extends JobOperation | string = string>(query?: GetJobsQuery, signal?: AbortSignal) => Promise<Job<T>[]>;
+        events: {
+            getEvents: (query?: GetEventsQuery, signal?: AbortSignal) => Promise<StorageEvent[]>;
+            getEvent: (eventId: string | number, signal?: AbortSignal) => Promise<StorageEvent>;
+            getTableEvents: ({ branchId, tableId, ...query }: GetTableEventsInput, signal?: AbortSignal) => Promise<TableEvent[]>;
+            getBucketEvents: ({ branchId, bucketId, ...query }: GetBucketEventsInput, signal?: AbortSignal) => Promise<TableEvent[]>;
+            createEvent: (body: CreateEventBody, signal?: AbortSignal) => Promise<StorageEvent>;
         };
-        componentsAndConfigurations: {
-            getComponent: ({ componentId, branchId }: GetComponentPath, signal?: AbortSignal) => Promise<Component>;
-            getComponents: ({ branchId, ...query }?: GetComponentsPath & GetComponentsQuery, signal?: AbortSignal) => Promise<Component[]>;
-            searchComponentConfigurations: ({ branchId }?: GetSearchComponentConfigurationsPath, query?: SearchComponentConfigurationsQuery, signal?: AbortSignal) => Promise<SearchComponentConfiguration[]>;
-            createConfiguration: ({ branchId, componentId, ...body }: CreateConfigurationInput) => Promise<BaseComponentConfig<Record<string, unknown>>>;
-            updateConfiguration: <T extends ConfigType = "unknown">({ branchId, componentId, configId, configuration, ...rest }: PartialKey<UpdateConfigurationInput, "branchId">, signal?: AbortSignal) => Promise<ComponentConfig<T>>;
-            getConfiguration: <T extends ConfigType = "unknown">({ componentId, configId, branchId }: ConfigurationPath, signal?: AbortSignal) => Promise<ComponentConfig<T>>;
-            getConfigurationDiff: ({ componentId, configId, branchId }: ConfigurationDiffPath, signal?: AbortSignal) => Promise<ConfigurationDiff>;
-            getConfigurationRowDiff: ({ componentId, configId, rowId, branchId }: ConfigurationRowDiffPath, signal?: AbortSignal) => Promise<ConfigurationRowDiff>;
-            rebaseConfiguration: ({ branchId, componentId, configId, ...body }: RebaseConfigurationInput) => Promise<BaseComponentConfig<Record<string, unknown>>>;
-            deleteConfiguration: (path: Required<ConfigurationPath>) => Promise<void>;
-            deleteConfigurations: ({ configIds, ...rest }: Required<Omit<ConfigurationPath, "configId">> & {
-                configIds: string[];
-            }) => Promise<void>;
-            getConfigurations: <T extends ConfigType = "unknown">({ componentId, branchId }: GetConfigurationsPath, signal?: AbortSignal) => Promise<ComponentConfig<T>[]>;
-            restoreConfiguration: ({ branchId, componentId, configId, }: ConfigurationPath) => Promise<BaseComponentConfig<Record<string, unknown>>>;
-            resetConfigurationToDefault: ({ branchId, componentId, configId, }: ConfigurationPath) => Promise<BaseComponentConfig<Record<string, unknown>>>;
-            createConfigurationRow: ({ branchId, componentId, configId, ...body }: PartialKey<CreateConfigurationRowInput, "branchId">) => Promise<Row>;
-            createConfigurationRows: ({ branchId, componentId, configId, data, }: PartialKey<CreateConfigurationRowsInput, "branchId">, options?: {
-                middlewares: MiddlewareFn$1<CreateConfigurationRowBody, Row>[];
-            }) => Promise<Row[]>;
-            deleteConfigurationRow: ({ changeDescription, ...path }: DeleteConfigurationRowInput) => Promise<void>;
-            deleteConfigurationRows: ({ rowIds, changeDescription, ...input }: DeleteConfigurationRowsInput, options?: {
-                middlewares: MiddlewareFn$1<string, void>[];
+        files: {
+            getFile: (fileId: number, signal?: AbortSignal) => Promise<File>;
+            getFileContent: (fileId: number, signal?: AbortSignal) => Promise<string>;
+            getFiles: (query?: GetFilesQuery, signal?: AbortSignal) => Promise<File[]>;
+            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>;
+        };
+        workspaces: {
+            getWorkspace: (path: WorkspacePath, signal?: AbortSignal) => Promise<Workspace>;
+            getWorkspaces: (branchId: WorkspacesPath["branchId"], signal?: AbortSignal) => Promise<Workspace[]>;
+            deleteWorkspace: (path: WorkspacePath) => Promise<void>;
+            resetWorkspacePassword: ({ branchId, workspaceId }: WorkspacePath) => Promise<ResetWorkspacePassword>;
+            deleteWorkspaces: ({ workspaceIds, branchId, }: Omit<WorkspacePath, "workspaceId"> & {
+                workspaceIds: WorkspacePath["workspaceId"][];
             }) => Promise<void>;
-            createConfigurationWorkspace: ({ componentId, branchId, configId, ...body }: Required<ConfigurationPath> & CreateConfigurationWorkspaceBody) => Promise<Workspace>;
-            createConfigurationWorkspaceJob: ({ componentId, branchId, configId, ...body }: Required<ConfigurationPath> & CreateConfigurationWorkspaceBody) => Promise<{
+            deleteWorkspaceJob: (path: WorkspacePath) => Promise<{
                 id: number;
                 tableId: string | null;
                 runId: string;
@@ -15062,21 +15377,12 @@ declare const createProjectClients: ({ baseUrl, projectId, authMiddleware, middl
                 };
                 endTime: string | null;
                 startTime: string | null;
-                operationName: "workspaceCreate";
+                operationName: "workspaceDrop";
                 operationParams: {
                     queue: string;
                 } & {
-                    backend: string;
+                    workspaceId: string;
                     backendConfiguration: [];
-                    backendSize: null;
-                    branchId: number;
-                    componentId: string;
-                    configurationId: string;
-                    loginType: number;
-                    networkPolicy: string;
-                    publicKey: string;
-                    readOnlyStorageAccess: boolean;
-                    useCase: ConfigurationUseCaseType;
                 };
                 metrics: {
                     inCompressed: boolean;
@@ -15099,18 +15405,82 @@ declare const createProjectClients: ({ baseUrl, projectId, authMiddleware, middl
                 };
             } | {
                 status: "success";
-                results: Workspace;
+                results: null;
             })>;
-            getConfigurationWorkspaces: ({ componentId, branchId, configId, }: ConfigurationPath) => Promise<Workspace[]>;
-        };
-        configurationMetadata: {
-            saveConfigurationMetadata: ({ branchId, componentId, configId, ...body }: SaveConfigurationMetadataInput) => Promise<ConfigurationMetadataItem[]>;
+            setWorkspacePublicKey: ({ branchId, workspaceId, publicKey, }: SetWorkspacePublicInput) => Promise<Workspace>;
+            getWorkspaceSaml2Login: (path: GetWorkspaceSaml2LoginPath, signal?: AbortSignal) => Promise<WorkspaceSaml2Login>;
+            getWorkspaceObjects: (path: WorkspacePath, signal?: AbortSignal) => Promise<WorkspaceObject[]>;
+            deleteWorkspaceObjectsAsync: ({ branchId, workspaceId, ...body }: DeleteWorkspaceObjectInput) => Promise<{
+                id: number;
+                tableId: string | null;
+                runId: string;
+                url: string;
+                createdTime: string;
+                creatorToken: {
+                    id: string;
+                    description: string;
+                };
+                endTime: string | null;
+                startTime: string | null;
+                operationName: "workspaceBatchDeleteObjects";
+                operationParams: {
+                    queue: string;
+                } & {
+                    workspaceId: string;
+                    objects: string[];
+                };
+                metrics: {
+                    inCompressed: boolean;
+                    inBytes: number;
+                    inBytesUncompressed: number;
+                    outCompressed: boolean;
+                    outBytes: number;
+                    outBytesUncompressed: number;
+                };
+            } & ({
+                status: Exclude<JobStatus, "success" | "error">;
+                results: null;
+            } | {
+                status: "success";
+                results: {
+                    deleted: {
+                        objectName: string;
+                    }[];
+                    failed: {
+                        objectName: string;
+                        error: string;
+                    }[];
+                };
+            } | {
+                status: "error";
+                results: {
+                    deleted: {
+                        objectName: string;
+                    }[];
+                    failed: {
+                        objectName: string;
+                        error: string;
+                    }[];
+                };
+                error: {
+                    code: string;
+                    message: string;
+                    exceptionId?: string;
+                };
+            })>;
+            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")[];
+                }[];
+            }>;
         };
-        configurationVersions: {
-            getConfigurationVersions: ({ branchId, componentId, configId }: ConfigurationVersionPath, signal?: AbortSignal) => Promise<ConfigurationVersion[]>;
-            getConfigurationVersion: ({ branchId, componentId, configId, versionId }: ConfigurationVersionDetailPath, signal?: AbortSignal) => Promise<ConfigurationVersionDetail>;
-            rollbackConfigurationToVersion: ({ branchId, componentId, configId, versionId, }: RollbackConfigurationToVersionInput) => Promise<BaseComponentConfig<Record<string, unknown>>>;
-            copyConfigurationFromVersion: ({ branchId, componentId, configId, versionId, ...body }: CopyConfigurationFromVersionInput) => Promise<BaseComponentConfig<Record<string, unknown>>>;
+        jobs: {
+            getJob: <T extends JobOperation | string = string>(id: GetJobPath["id"], signal?: AbortSignal) => Promise<Job<T>>;
+            getJobs: <T extends JobOperation | string = string>(query?: GetJobsQuery, signal?: AbortSignal) => Promise<Job<T>[]>;
         };
         tokens: {
             verify: (signal?: AbortSignal) => Promise<StorageToken>;
@@ -15177,12 +15547,12 @@ declare const createProjectClients: ({ baseUrl, projectId, authMiddleware, middl
                 canReadAllProjectEvents: boolean;
                 canManageDevBranches: boolean;
             }>;
-            updateToken: (id: string, body: UpdateTokenBody, signal?: AbortSignal) => Promise<StorageToken>;
+            updateToken: ({ id, ...body }: UpdateTokenInput, signal?: AbortSignal) => Promise<StorageToken>;
             deleteToken: (id: string, signal?: AbortSignal) => Promise<void>;
-            shareToken: (id: string, body: ShareTokenBody, signal?: AbortSignal) => Promise<void>;
+            shareToken: ({ id, ...body }: ShareTokenInput, signal?: AbortSignal) => Promise<void>;
         };
         triggers: {
-            listTriggers: (query?: ListTriggersQuery, signal?: AbortSignal) => Promise<{
+            getTriggers: (query?: GetTriggersQuery, signal?: AbortSignal) => Promise<{
                 id: string;
                 runWithTokenId: number;
                 component: string;
@@ -15212,7 +15582,7 @@ declare const createProjectClients: ({ baseUrl, projectId, authMiddleware, middl
                     tableId: string;
                 }[];
             }>;
-            updateTrigger: (triggerId: string, body: UpdateTriggerBody, signal?: AbortSignal) => Promise<{
+            updateTrigger: ({ triggerId, ...body }: UpdateTriggerInput, signal?: AbortSignal) => Promise<{
                 id: string;
                 runWithTokenId: number;
                 component: string;
@@ -15227,15 +15597,120 @@ declare const createProjectClients: ({ baseUrl, projectId, authMiddleware, middl
                     tableId: string;
                 }[];
             }>;
-            deleteTrigger: (triggerId: string, signal?: AbortSignal) => Promise<void>;
+            deleteTrigger: (triggerId: Trigger["id"], signal?: AbortSignal) => Promise<void>;
         };
         search: {
             globalSearch: (query: GlobalSearchQuery, signal?: AbortSignal) => Promise<GlobalSearchResponse>;
+            searchTables: (query: SearchTablesQuery, signal?: AbortSignal) => Promise<Table[]>;
         };
         stats: {
             getRunIdStats: (runId: string, signal?: AbortSignal) => Promise<RunIdStats>;
         };
-        getStackInfo: (query?: GetStackInfoQuery, signal?: AbortSignal) => Promise<StackInfo>;
+        components: {
+            getComponent: ({ componentId, branchId }: GetComponentPath, signal?: AbortSignal) => Promise<Component>;
+            getComponents: ({ branchId, ...query }?: GetComponentsInput, signal?: AbortSignal) => Promise<Component[]>;
+        };
+        configurations: {
+            createConfiguration: ({ branchId, componentId, ...body }: CreateConfigurationInput) => Promise<BaseComponentConfig<Record<string, unknown>>>;
+            updateConfiguration: <T extends ConfigType = "unknown">({ branchId, componentId, configId, configuration, workspaceId, ...rest }: PartialKey<UpdateConfigurationInput, "branchId">, signal?: AbortSignal) => Promise<UpdateConfigurationResult<T>>;
+            updateConfigurationState: <T extends ConfigType = "unknown">({ branchId, componentId, configId, ...body }: UpdateConfigurationStateInput, signal?: AbortSignal) => Promise<ComponentConfig<T>>;
+            getConfiguration: <T extends ConfigType = "unknown">({ componentId, configId, branchId }: ConfigurationPath, signal?: AbortSignal) => Promise<ComponentConfig<T>>;
+            getConfigurationDiff: ({ componentId, configId, branchId }: ConfigurationDiffPath, signal?: AbortSignal) => Promise<ConfigurationDiff>;
+            rebaseConfiguration: ({ branchId, componentId, configId, ...body }: RebaseConfigurationInput) => Promise<BaseComponentConfig<Record<string, unknown>>>;
+            deleteConfiguration: ({ branchId, componentId, configId, expectedVersion, }: DeleteConfigurationInput) => Promise<void>;
+            deleteConfigurations: ({ configIds, ...rest }: Required<Omit<ConfigurationPath, "configId">> & {
+                configIds: string[];
+            }) => Promise<void>;
+            purgeConfiguration: ({ branchId, componentId, configId, expectedVersion, }: PurgeConfigurationInput) => Promise<void>;
+            purgeConfigurations: ({ branchId, configs }: PurgeConfigurationsInput) => Promise<void>;
+            getConfigurations: <T extends ConfigType = "unknown">({ componentId, branchId }: GetConfigurationsPath, signal?: AbortSignal) => Promise<ComponentConfig<T>[]>;
+            restoreConfiguration: ({ branchId, componentId, configId, }: ConfigurationPath) => Promise<BaseComponentConfig<Record<string, unknown>>>;
+            resetConfigurationToDefault: ({ branchId, componentId, configId, }: ConfigurationPath) => Promise<void>;
+            searchComponentConfigurations: ({ branchId, include, ...query }?: SearchComponentConfigurationsInput, signal?: AbortSignal) => Promise<SearchComponentConfiguration[]>;
+        };
+        configurationRows: {
+            createConfigurationRow: ({ branchId, componentId, configurationId, ...body }: PartialKey<CreateConfigurationRowInput, "branchId">) => Promise<Row>;
+            createConfigurationRows: ({ branchId, componentId, configurationId, data, }: PartialKey<CreateConfigurationRowsInput, "branchId">, options?: {
+                middlewares: MiddlewareFn$1<CreateConfigurationRowBody, Row>[];
+            }) => Promise<Row[]>;
+            getConfigurationRow: ({ branchId, ...path }: PartialKey<GetConfigurationRowInput, "branchId">, signal?: AbortSignal) => Promise<Row>;
+            updateConfigurationRow: ({ branchId, componentId, configurationId, rowId, ...body }: PartialKey<UpdateConfigurationRowInput, "branchId">, signal?: AbortSignal) => Promise<Row>;
+            updateConfigurationRowState: ({ branchId, componentId, configurationId, rowId, ...body }: PartialKey<UpdateConfigurationRowStateInput, "branchId">, signal?: AbortSignal) => Promise<Row>;
+            deleteConfigurationRow: ({ changeDescription, ...path }: DeleteConfigurationRowInput) => Promise<void>;
+            deleteConfigurationRows: ({ rowIds, changeDescription, ...input }: DeleteConfigurationRowsInput, options?: {
+                middlewares: MiddlewareFn$1<string, void>[];
+            }) => Promise<void>;
+        };
+        configurationWorkspaces: {
+            createConfigurationWorkspace: ({ componentId, branchId, configurationId, ...body }: CreateConfigurationWorkspaceInput) => Promise<Workspace>;
+            createConfigurationWorkspaceJob: ({ componentId, branchId, configurationId, ...body }: CreateConfigurationWorkspaceInput) => Promise<{
+                id: number;
+                tableId: string | null;
+                runId: string;
+                url: string;
+                createdTime: string;
+                creatorToken: {
+                    id: string;
+                    description: string;
+                };
+                endTime: string | null;
+                startTime: string | null;
+                operationName: "workspaceCreate";
+                operationParams: {
+                    queue: string;
+                } & {
+                    backend: string;
+                    backendConfiguration: [];
+                    backendSize: null;
+                    branchId: number;
+                    componentId: string;
+                    configurationId: string;
+                    loginType: number;
+                    networkPolicy: string;
+                    publicKey: string;
+                    readOnlyStorageAccess: boolean;
+                    useCase: ConfigurationUseCaseType;
+                };
+                metrics: {
+                    inCompressed: boolean;
+                    inBytes: number;
+                    inBytesUncompressed: number;
+                    outCompressed: boolean;
+                    outBytes: number;
+                    outBytesUncompressed: number;
+                };
+            } & ({
+                status: Exclude<JobStatus, "success" | "error">;
+                results: null;
+            } | {
+                status: "error";
+                results: null;
+                error: {
+                    code: string;
+                    message: string;
+                    exceptionId?: string;
+                };
+            } | {
+                status: "success";
+                results: Workspace;
+            })>;
+            getConfigurationWorkspaces: ({ componentId, branchId, configurationId, }: GetConfigurationWorkspacesPath) => Promise<Workspace[]>;
+        };
+        configurationMetadata: {
+            getConfigurationMetadata: ({ branchId, componentId, configurationId, }: PartialKey<GetConfigurationMetadataInput, "branchId">, signal?: AbortSignal) => Promise<ConfigurationMetadataItem[]>;
+            saveConfigurationMetadata: ({ branchId, componentId, configurationId, ...body }: PartialKey<SaveConfigurationMetadataInput, "branchId">) => Promise<ConfigurationMetadataItem[]>;
+            deleteConfigurationMetadata: ({ branchId, componentId, configurationId, metadataId, }: PartialKey<DeleteConfigurationMetadataInput, "branchId">, signal?: AbortSignal) => Promise<void>;
+        };
+        configurationVersions: {
+            getConfigurationVersions: ({ branchId, componentId, configurationId }: ConfigurationVersionPath, signal?: AbortSignal) => Promise<ConfigurationVersion[]>;
+            getConfigurationVersion: ({ branchId, componentId, configurationId, versionId }: ConfigurationVersionDetailPath, signal?: AbortSignal) => Promise<ConfigurationVersionDetail>;
+            rollbackConfigurationToVersion: ({ branchId, componentId, configurationId, versionId, }: RollbackConfigurationToVersionInput) => Promise<RollbackConfigurationToVersionResult>;
+            copyConfigurationFromVersion: ({ branchId, componentId, configurationId, versionId, ...body }: CopyConfigurationFromVersionInput) => Promise<CopyConfigurationFromVersionResult>;
+            getConfigurationRowVersions: ({ branchId, componentId, configurationId, rowId }: ConfigurationRowVersionPath, signal?: AbortSignal) => Promise<ConfigurationRowVersion[]>;
+            getConfigurationRowVersion: ({ branchId, componentId, configurationId, rowId, versionId }: ConfigurationRowVersionDetailPath, signal?: AbortSignal) => Promise<ConfigurationRowVersionDetail>;
+            rollbackConfigurationRowToVersion: ({ branchId, componentId, configurationId, rowId, versionId, }: RollbackConfigurationRowToVersionInput) => Promise<Row>;
+            copyConfigurationRowFromVersion: ({ branchId, componentId, configurationId, rowId, versionId, }: CopyConfigurationRowFromVersionInput) => Promise<Row>;
+        };
     };
 }>;
 
@@ -15296,6 +15771,8 @@ declare const KeboolaHttpHeader: {
     readonly MANAGEMENT_API_TOKEN: "X-Kbc-Manageapitoken";
     readonly STORAGE_API_URL: "x-storageapi-url";
     readonly PROJECT_ID: "X-KBC-ProjectId";
+    /** Storage job a request enqueued, reported on the response rather than in its body. */
+    readonly STORAGE_API_JOB_ID: "X-StorageApi-Job-Id";
 };
 
-export { type AsyncState, type BearerSession, type ClientContext, type CollectOptions, ConcurrentOptions, HttpContentType, HttpHeader, type KeboolaApi, KeboolaError, KeboolaErrorType, KeboolaHttpHeader, KeboolaObjectId, type KeboolaOptions, type LegacySession, type Log, type LogLevel, type Logger, type LoggingOptions, MiddlewareFn, type Persistor, PollException, type ReadableStore, type RequestLog, type ResponseLog, type RetryOptions, type StorageAdapter, type Store, type TaskFn, assert, coalesce, collect, createDerivedAsyncStore, createDerivedStore, createKeboola, createLegacyKeboola, createLocalStorage, createLoggingMiddleware, createMemoryStorage, createNullStorage, createPersistor, createRetryMiddleware, createSessionStorage, createStore, dedupe, deepMerge, delay, generateUUID, isEmptyDeep, isKeboolaError, isPlainObject, isStorageTokenMutatingRequest, poll, schemaGuidedMerge, series, shallowEqual };
+export { type AsyncState, type BearerSession, type ClientContext, type CollectOptions, ConcurrentOptions, HttpContentType, HttpHeader, type KeboolaApi, KeboolaError, KeboolaErrorType, KeboolaHttpHeader, KeboolaObjectId, type KeboolaOptions, type LegacySession, type Log, type LogLevel, type Logger, type LoggingOptions, MiddlewareFn, type Persistor, PollException, type ReadableStore, type RequestLog, type ResponseLog, type RetryOptions, type StorageAdapter, type Store, type TaskFn, assert, coalesce, collect, createDerivedAsyncStore, createDerivedStore, createKeboola, createLegacyKeboola, createLocalStorage, createLoggingMiddleware, createMemoryStorage, createNullStorage, createPersistor, createRetryMiddleware, createSessionStorage, createStore, dedupe, deepMerge, delay, generateUUID, isEmptyDeep, isKeboolaError, isPlainObject, isStorageTokenMutatingRequest, lazy, poll, schemaGuidedMerge, series, shallowEqual };