@keboola/api-client 20.0.0 → 23.0.0

package/dist/index.d.ts

@@ -1,51 +1,54 @@
-import { c as components$9, A as AssertSamlBody, I as InitiateSamlBody, C as CreatePatBody, E as ExchangePatBody, R as RevokePatPath, a as CreateDeviceAuthorizationBody, b as ApproveDeviceAuthorizationBody, G as GetDeviceAuthorizationTokenBody, S as SudoBody, d as GetPkceTokenBody, e as RevokeSessionPath, f as RevokeTokenBody } from './types-oJnjpvPi.js';
-import { L as LoginInput, O as OidcInput, M as MfaCodeInput, a as MfaWebauthnInput } from './schemas-CraXbXke.js';
-import { D as DeletedProjectsListQuery, a as DeletedProject, b as DeletedProjectPurgeResult, M as Maintainer, c as MaintainerDetail, C as CreateMaintainerBody, U as UpdateMaintainerBody, d as MaintainerUser, A as AddMaintainerUserBody, e as CreateMaintainerInvitationBody, f as CreateMaintainerOrganizationBody, g as MetadataItem, S as SetMaintainerMetadataBody, O as OrganizationDetail, h as UpdateOrganizationBody, i as AddOrganizationUserBody, j as CreateOrganizationInvitationBody, P as Project, k as CreateOrganizationProjectBody, l as SetOrganizationMetadataBody, G as GetAllFeaturesQuery, F as Feature, m as FeatureProject, n as FeatureAdmin, o as GetProjectPath, p as CreateProjectFeaturePath, q as CreateProjectFeatureBody, R as RemoveProjectFeaturePath, r as User, L as ListProjectUsersPath, s as ListProjectInvitationsPath, t as CreateProjectInvitationPath, u as CreateProjectInvitationBody, v as DeleteProjectInvitationPath, w as AddProjectUserPath, x as AddProjectUserBody, y as RemoveProjectUserPath, z as GetProjectMetadataPath, B as ProjectMetadataItem, E as SetProjectMetadataPath, H as SetProjectMetadataBody, I as GetProjectReviewersPath, J as Reviewer, K as SetProjectReviewersPath, N as SetProjectReviewersBody, Q as UpdateProjectBody, T as MoveProjectBody, V as SetProjectDisabledBody, W as AddUserFeatureBody, X as AddUserFeaturePath, Y as RemoveUserFeaturePath } from './types-YEfQ5pAy.js';
-import { S as StorageToken, c as components$8, C as CreateTokenBody, U as UpdateTokenBody, a as ShareTokenBody } from './types-o8eTf_G9.js';
-import { StorageTableScope as StorageTable } from './domain/storageTable/index.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-BowqtZ7v.js';
-import { L as ListSubscriptionsQuery, c as components$6, G as GetSubscriptionPath, C as CreateSubscriptionBody, D as DeleteSubscriptionPath } from './types-CS8MYc2k.js';
-import { P as PaginationQuery, c as components$5, C as CreateSourceRequestBody, U as UpdateSourceRequestBody, D as DeleteSourceQuery, a as UpdateSourceSettingsRequestBody, T as TestSourceQuery, b as CreateSinkRequestBody, d as UpdateSinkRequestBody, e as UpdateSinkSettingsRequestBody, S as SinkStatisticsFilesQuery } from './types-Dv3vN7M9.js';
+import { DevBranch, ServiceId, StackInfo, Service, StackComponent, ConfigurationPath, BaseComponentConfig, CreateConfigurationInput, UpdateConfigurationInput, CreateTableAsyncBody, TableCreateJob, CreateTableDefinitionBody, JobStatus, Table, TableImportAsyncBody, TableImportJob, TableExportAsyncBody, TableExportJob, BucketListing, CreateBucketListingInput, UpdateBucketListingInput, ShareBucketToProjectsBody, ShareBucketToUsersBody, RegisterBucketBody, RefreshExternalBucketQuery, CreateSnapshotBody, AddTableColumnBody, DeleteTableColumnQuery, CreateTablePrimaryKeyBody, GetBucketsQuery, Bucket, BucketDetail, CreateBucketBody, UpdateBucketBody, CreateScheduledRefreshPath, CreateScheduledRefreshBody, ScheduledTask, Job, UpdateBucketOwnerBody, BucketRegistrationGuideQuery, SaveBucketMetadataBody, GetEventsQuery, StorageEvent, GetTableEventsQuery, TableEvent, CreateEventBody, File as File$1, GetFilesQuery, DeleteFileTagPath, PrepareFileBody, PreparedFile, GetTablesQuery, TableDetail, GetDataPreview, PreviewData, DeleteTableRows, JobUnion, UpdateTableDefinitionInput, UpdateTableBody, CreateAliasTableBody, SetAliasTableFilterBody, Snapshot, SaveMetadataBody, Metadata, 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-BV-vseKc.js';
+import { createStorageTable } from './domain/storageTable/index.js';
+import { M as MiddlewareFn, A as ApiResponse, H as HttpMethod } from './types-DqxZDbM1.js';
+export { a as ApiError, c as AuthStrategy, d as BaseClientOptions } from './types-DqxZDbM1.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-Dz4tTWOc.js';
+export { a as concurrent } from './storageClient-Dz4tTWOc.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-CJ0RgA57.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-Dz4Yc-Mu.js';
+import { L as ListSubscriptionsQuery, c as components$6, S as SubscriptionId, C as CreateSubscriptionBody } from './types-B-3bBl2q.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-Bj3fLP0h.js';
 import { GetSchedulesQuery, ActivateScheduleBody, SchedulePath, ConfigurationPath as ConfigurationPath$1 } from './scheduler/types.js';
-import { GetCredentialsQuery, Credential, CreateCredentialBody } from './oauth/types.js';
-import { c as OpenapiQueryType, d as OpenapiPathType, b as OpenapiBodyType, a as OpenapiReturnType } from './types-jKnx7Tm_.js';
+import { GetCredentialsQuery, Credential as Credential$1, CreateCredentialBody } from './oauth/types.js';
+import { c as OpenapiQueryType, d as OpenapiPathType, O as OpenapiBodyType, b as OpenapiReturnType } from './types-BbM5WDSR.js';
 import { U as UploadFileParams, a as UploadedFile } from './types-Dg1tEsVR.js';
-import { D as DescribeConfigurationVersionBody, a as DescribeConfigurationMergeBody, E as ExplainErrorBody, b as DescribeConfigurationBody, S as SuggestComponentBody, c as components$4, F as FeedbackBody, d as DocsQuestionBody } from './types-D3Kkh6yW.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-BjNd012m.js';
 import { SuggestionsRequestBody, SuggestionsApiResponse } from './chat/suggestions.js';
-import { G as GetHistoryQuery$1, c as components$3, a as GetChatPath$1, C as ChatRequest$1, b as GetVotesQuery$1, V as VoteRequest$1, U as UsageResponse$1, A as AgentSettings, d as UpdateAgentSettingsRequest, e as UserAgentSettings, f as UpdateUserAgentSettingsRequest, T as ToolsListResponse } from './types-BbeZapCu.js';
-import { G as GetQueueJobPath, c as components$2, S as SearchJobsQuery } from './types-DacFMc6L.js';
-import { P as PostQueryPath, a as PostQueryBody, b as PostCancelQueryJobPath, G as GetQueryJobPath, c as components$1, d as GetQueryResultsPath, e as GetQueryResutsQuery, f as GetQueriesPath, g as GetQueriesHistoryQuery, h as GetExportResultsQuery, E as ExportResultsResponse } from './types-yKV1EX6f.js';
+import { 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-DXFcF3_c.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-Dq5jIMye.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-BjdcqqvT.js';
 import { CreateCredentialsBody, WorkspaceData } from './telemetry/types.js';
 import { PostActionsBody, EnrollMFAInput, GetDataAppPublicGitRepositoryInput, GetDataAppPasswordPrivateGitRepositoryInput, GetDataAppSSHKeyPrivateGitRepositoryInput, GetPublicGitRepositoryInput, GetGitPrivateRepositoryInput } from './syncActions/types.js';
-import { C as CreateSqlSessionBody, G as GetSqlSessionPath, a as GetSqlSessionsQuery, b as GetSqlSessionSchemaPath, c as GetSqlSessionSchemaQuery, d as components, P as PostSqlRunQueryPath, e as PostSqlRunQueryBody, f as PostSqlTablePreviewPath, g as PostSqlTablePreviewBody, h as GetSqlSessionTableDdlPath, i as GetSqlSessionTableDdlQuery, j as PostSqlSessionLoadPath, k as PostSqlSessionLoadBody, l as PostSqlSessionUnloadPath, m as PostSqlSessionUnloadBody } from './types-CFd7q2ed.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-PG_v0QyH.js';
 import { EncryptQuery, ScopedSecrets } from './encryption/types.js';
-import { M as MiddlewareFn, c as BaseClientOptions, A as ApiResponse, H as HttpMethod } from './types-0yn6OefX.js';
-export { a as ApiError, d as AuthStrategy } from './types-0yn6OefX.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-C7eSJKtG.js';
-export { p as parseLogLines } from './utils-C7eSJKtG.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-zcz60drL.js';
+export { p as parseLogLines } from './utils-zcz60drL.js';
 import { CreateVariableBody, VariableWithHash, DeleteVariablePath, GetVariablesQuery, GetVariablesByBranchId } from './vault/types.js';
-import { a as EncryptionCtx } from './types-l_pP5J0H.js';
+import { a as EncryptionCtx } from './types-Cnsa5tWp.js';
+import { SemanticObject, SemanticModelData, CreateSemanticObjectMeta, UpdateSemanticObjectMeta, SemanticChildObjectDataMap, SemanticChildObjectType, SemanticDatasetData, SemanticMetricData, SemanticRelationshipData, SemanticGlossaryData, SemanticConstraintData } from './sdk/semanticLayer/types.js';
 import { TagWithBindings, TagData, CreateMetaObjectMetaDataInput, UpdateMetaObjectMetaDataInput } from './sdk/tag/types.js';
 import * as zod_v4_core from 'zod/v4/core';
-import * as zod from 'zod';
-import { z } from 'zod';
-import { ServiceId, ConfigurationPath, BaseComponentConfig, CreateConfigurationInput, UpdateConfigurationInput, CreateTableAsyncBody, TableCreateJob, CreateTableDefinitionBody, JobStatus, Table, TableImportAsyncBody, TableImportJob, TableExportAsyncBody, TableExportJob, BucketListing, CreateBucketListingInput, UpdateBucketListingInput, ShareBucketToProjectsBody, ShareBucketToUsersBody, RegisterBucketBody, RefreshExternalBucketQuery, CreateSnapshotBody, AddTableColumnBody, DeleteTableColumnQuery, CreateTablePrimaryKeyBody, Service, StackComponent, GetBucketsQuery, Bucket, BucketDetail, CreateBucketBody, UpdateBucketBody, CreateScheduledRefreshPath, CreateScheduledRefreshBody, ScheduledTask, Job, UpdateBucketOwnerBody, BucketRegistrationGuideQuery, SaveBucketMetadataBody, GetEventsQuery, StorageEvent, GetTableEventsQuery, TableEvent, CreateEventBody, File as File$1, GetFilesQuery, DeleteFileTagPath, PrepareFileBody, PreparedFile, GetTablesQuery, TableDetail, GetDataPreview, PreviewData, DeleteTableRows, JobUnion, UpdateTableDefinitionInput, UpdateTableBody, CreateAliasTableBody, SetAliasTableFilterBody, Snapshot, SaveMetadataBody, Metadata, DevBranch, CreateDevBranchJobBody, DevBranchPath, BranchMetadata, BranchMetadataEntry, WorkspacePath, Workspace, WorkspacesPath, ResetWorkspacePassword, SetWorkspacePublicInput, GetWorkspaceSaml2LoginPath, WorkspaceSaml2Login, WorkspaceObject, DeleteWorkspaceObjectInput, UnloadWorkspaceInput, WorkspaceInputMappingLoadPreviewInput, MergeRequestDetail, MergeRequestDetailWithActivityLog, CreateMergeRequestParams, UpdateMergeRequestParams, JobOperation, GetJobPath, GetJobsQuery, GetComponentPath, Component, GetComponentsPath, GetComponentsQuery, GetSearchComponentConfigurationsPath, SearchComponentConfigurationsQuery, SearchComponentConfiguration, ConfigType, PartialKey, ComponentConfig, ConfigurationDiffPath, ConfigurationDiff, ConfigurationRowDiffPath, ConfigurationRowDiff, RebaseConfigurationInput, GetConfigurationsPath, CreateConfigurationRowInput, Row, CreateConfigurationRowsInput, CreateConfigurationRowBody, DeleteConfigurationRowInput, DeleteConfigurationRowsInput, CreateConfigurationWorkspaceBody, ConfigurationUseCaseType, ConfigurationVersionPath, ConfigurationVersion, ConfigurationVersionDetailPath, ConfigurationVersionDetail, ListTriggersQuery, CreateTriggerBody, UpdateTriggerBody, GlobalSearchQuery, GlobalSearchResponse, RunIdStats, GetStackInfoQuery, StackInfo } from './storage/types.js';
-import { R as RegisteredComponentId } from './registry-BLItWxbK.js';
-import { C as ConcurrentOptions, M as MiddlewareFn$1 } from './storageClient-Cwr5Vl45.js';
-export { a as concurrent } from './storageClient-Cwr5Vl45.js';
-import { K as KeboolaObjectId } from './keboolaUID-D1DGSbge.js';
-export { k as keboolaUID } from './keboolaUID-D1DGSbge.js';
-import { B as Backend } from './backends-Bofq_Nr0.js';
+import { R as RegisteredComponentId } from './registry-v_1krdcs.js';
 export { FetchClientError, ServiceUnavailableError, UserError, isAbortError, isApiError, isFetchClientError } from './storage/index.js';
-export { c as createGenericFetchClient } from './createGenericFetchClient-D4tfhW6Z.js';
-export { i as isManagementClientAuthError } from './authMiddleware-CirRGURb.js';
-export { M as ManagementClientAuthError } from './ManagementClientAuthError-BMOhz4mx.js';
-export { c as createStorageSdk } from './storageSdk-Um7iSJMs.js';
+export { c as createGenericFetchClient } from './createGenericFetchClient-B2Gp1a8f.js';
+export { M as ManagementClientAuthError } from './ManagementClientAuthError-B3PZRWBU.js';
+export { c as createStorageSdk } from './storageSdk-PRaSLkD6.js';
+import './adminRoles-Cil1lavB.js';
 import 'qs';
+import './types-qCMu5X9I.js';
+import './createOpenapiFetchClient-BX7_szVZ.js';
+import './types-GecGaYgv.js';
 import './encryption/index.js';
 import './vault/index.js';
 import './metastore/index.js';
-import './createOpenapiFetchClient-DLA4-_yg.js';
 
 declare const HttpHeader: {
     CONTENT_TYPE: string;
@@ -59,6 +62,396 @@ declare const HttpContentType: {
     TEXT_HTML: string;
 };
 
+type BranchType = 'default' | 'dev';
+type Options$2 = {
+    devBranches: DevBranch[];
+};
+declare const createDefaultBranch: ({ devBranches }: Options$2) => {
+    id: number;
+    name: string;
+    getType: (branchId?: string | number) => BranchType;
+    isDev: (branchId?: string | number) => boolean;
+    isDefault: (branchId?: string | number) => boolean;
+};
+
+type ServiceUrls = Partial<Record<ServiceId, (url: string) => string | undefined | null>>;
+type Options$1 = {
+    stackInfo: StackInfo;
+    clientServiceUrls?: ServiceUrls;
+};
+declare const createStack: ({ stackInfo, clientServiceUrls }: Options$1) => {
+    services: Service[];
+    features: string[];
+    components: StackComponent[];
+    hasFeature: (...feature: string[]) => boolean;
+    getServiceUrl: (serviceId: ServiceId) => string | null;
+    hasService: (serviceId: ServiceId) => boolean;
+    getComponent: (componentId: string) => StackComponent | null;
+    hasComponent: (...componentId: string[]) => boolean;
+    api: string;
+    documentation: string;
+    host: string;
+    revision: string;
+    stack: string;
+    urlTemplates: {
+        orchestrationJob: string;
+    };
+    version: string;
+};
+
+declare const isStorageTokenMutatingRequest: (request: Request) => boolean;
+type ClientContext = {
+    /**
+     * The stack this client is configured against, canonical form (absolute, no trailing slash) — the
+     * `baseUrl` every request is built on. Distinct from `stack.host`, which is a bare hostname the
+     * stack reports about itself in its index response and is never used to route a request.
+     */
+    baseUrl: string;
+    stack: ReturnType<typeof createStack>;
+    defaultBranch: ReturnType<typeof createDefaultBranch>;
+    readonly project: Project;
+    readonly st: ReturnType<typeof createStorageTable>;
+};
+
+/**
+ * The single error the keboola client / session throws. It carries a stable `type` (the switchable
+ * contract) and a human-readable message derived from that type — no per-call message strings.
+ */
+declare const KeboolaErrorType: {
+    readonly Unconfigured: "unconfigured";
+    readonly NotAuthenticated: "not-authenticated";
+    readonly AlreadyAuthenticated: "already-authenticated";
+    readonly NoStorageToken: "no-storage-token";
+    readonly NoManagementToken: "no-management-token";
+    readonly MissingProject: "missing-project";
+    readonly NotBearer: "not-bearer";
+    readonly NotReady: "not-ready";
+    readonly InvalidBuildTransition: "invalid-build-transition";
+};
+type KeboolaErrorType = (typeof KeboolaErrorType)[keyof typeof KeboolaErrorType];
+declare class KeboolaError extends Error {
+    readonly type: KeboolaErrorType;
+    constructor(type: KeboolaErrorType);
+}
+declare const isKeboolaError: (error: unknown) => error is KeboolaError;
+
+type StorageAdapter = {
+    getItem: (key: string) => string | null;
+    setItem: (key: string, value: string) => void;
+    removeItem: (key: string) => void;
+};
+declare const createNullStorage: () => StorageAdapter;
+declare const createMemoryStorage: () => StorageAdapter;
+declare const createLocalStorage: () => StorageAdapter;
+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';
+/** Clients instantiated directly (not stack-discovered), keyed by their property name. */
+type NonServiceClientName = 'storage' | 'management' | 'auth';
+type MiddlewareTarget = ServiceClientName | NonServiceClientName;
+type Middlewares = MiddlewareFn[] | ({
+    all?: MiddlewareFn[];
+} & Partial<Record<MiddlewareTarget, MiddlewareFn[]>>);
+declare const createMiddlewareFor: (middlewares: Middlewares | undefined) => (target: MiddlewareTarget, baseline?: MiddlewareFn[]) => MiddlewareFn[];
+type MiddlewareFor = ReturnType<typeof createMiddlewareFor>;
+
+type KeboolaOptions = {
+    baseUrl?: string;
+    middlewares?: Middlewares;
+    clientServiceUrls?: ServiceUrls;
+    storage?: StorageAdapter;
+};
+
+declare function assert<T>(value: T | undefined | null, message: string): asserts value is T;
+
+/** A deferred unit of async work: a no-arg function returning a value or promise. */
+type TaskFn<T> = () => T | PromiseLike<T>;
+
+/**
+ * Coalesces concurrent triggers onto a single, never-parallel run of `task`.
+ * Triggers fired while a run is busy collapse into one trailing run, and each
+ * resolves with the first run that started after it — so it never sees stale state.
+ *
+ * Example — A triggers, then B and C trigger while A's run is still going:
+ *   1. trigger A      → run #1 starts
+ *   2. trigger B, C   → run #1 busy, so they wait
+ *   3. run #1 done    → A resolves
+ *   4. run #2 starts  → covers B and C together (one trailing run, not two)
+ *   5. run #2 done    → B and C resolve
+ *
+ * @returns a trigger; each call returns a promise of the task result.
+ * @throws The returned promise rejects with whatever `task` throws or rejects
+ * with — the caller handles it (try/catch, or `.catch` on `void trigger()`).
+ */
+declare const coalesce: <T>(task: TaskFn<T>) => (() => Promise<Awaited<T>>);
+
+type CollectOptions<T> = {
+    fetchFrom: (offset: number, pageSize?: number, signal?: AbortSignal) => Promise<T[]>;
+    pageSize?: number;
+    limit?: number;
+    signal?: AbortSignal;
+};
+/**
+ * Collects items from an offset-paginated endpoint — up to `limit` of them, or all of them when
+ * `limit` is omitted. Calls `fetchFrom` sequentially with the offset advancing by the number of
+ * items received, and hands it `pageSize` so the request and the traversal agree on one value.
+ *
+ * Traversal ends on a page shorter than `pageSize`, or — when `pageSize` is omitted — only on an
+ * empty page. Passing it therefore saves the trailing request, at the cost of stopping early if the
+ * endpoint returns fewer items per page than asked for.
+ */
+declare const collect: <T>({ fetchFrom, pageSize, limit, signal, }: CollectOptions<T>) => Promise<T[]>;
+
+/**
+ * Deduplicates concurrent triggers by sharing one in-flight run of `task`.
+ * While a run is in flight every trigger returns that same promise; once it
+ * settles the next trigger starts a fresh run. (Contrast `coalesce`, which
+ * runs a *trailing* pass for triggers that arrive mid-run.)
+ *
+ * @returns a trigger; each call returns a promise of the task result.
+ * @throws The returned promise rejects with whatever `task` throws or rejects
+ * with — the caller handles it (try/catch, or `.catch` on `void trigger()`).
+ */
+declare const dedupe: <T>(task: TaskFn<T>) => (() => Promise<Awaited<T>>);
+
+declare const delay: (timeout: number, signal?: AbortSignal) => Promise<unknown>;
+
+type PollResult<T> = {
+    data: T;
+    callCount: number;
+};
+type PollErrorType = 'PollPredicateError' | 'PollTimeoutError' | 'PollPollTimeoutError';
+declare class PollException<T> extends Error {
+    result: PollResult<T>;
+    constructor(type: PollErrorType, result: PollResult<T>);
+}
+type Options<T> = {
+    pollFn: (abortSignal?: AbortSignal) => Promise<T>;
+    isDone: (result: T) => boolean;
+    isFailed?: (result: T) => boolean;
+    interval: number;
+    abortSignal?: AbortSignal;
+    maxAttempts?: number;
+};
+declare const poll: <T>({ pollFn, interval, isDone, isFailed, abortSignal, maxAttempts, }: Options<T>) => Promise<PollResult<T>>;
+
+/**
+ * Executes an asynchronous callback function on an array of items in series (one at a time).
+ * It behaves similarly to Promise.all(), failing on the first rejected promise.
+ * The order of the results matches the order of the promises.
+ */
+declare const series: <T, R>(options: Omit<ConcurrentOptions<T, R>, "concurrency">) => Promise<R[]>;
+
+declare const generateUUID: () => `${string}-${string}-${string}-${string}-${string}`;
+
+type Listener<T> = (value: T) => void;
+type ReadableStore<T> = {
+    get: () => T;
+    subscribe: (listener: Listener<T>) => () => void;
+    dispose: () => void;
+};
+type Store<T> = ReadableStore<T> & {
+    set: (value: T) => void;
+};
+declare const createStore: <T>(initial: T) => Store<T>;
+declare const shallowEqual: <T>(a: T, b: T) => boolean;
+type DerivedStoreOptions<S, K, T> = {
+    source: ReadableStore<S>;
+    dependsOn: (state: S) => K;
+    build: (key: K) => T;
+    keyEquals?: (a: K, b: K) => boolean;
+};
+declare const createDerivedStore: <S, K, T>({ source, dependsOn, build, keyEquals, }: DerivedStoreOptions<S, K, T>) => ReadableStore<T>;
+type AsyncState<T> = {
+    state: 'idle';
+} | {
+    state: 'pending';
+} | {
+    state: 'ready';
+    value: T;
+} | {
+    state: 'errored';
+    error: unknown;
+};
+type SettledState<T> = Extract<AsyncState<T>, {
+    state: 'ready';
+} | {
+    state: 'errored';
+}>;
+type DerivedAsyncStoreOptions<S, K, T> = {
+    source: ReadableStore<S>;
+    dependsOn: (state: S) => K | null;
+    build: (key: K, signal: AbortSignal) => Promise<T>;
+    keyEquals?: (a: K, b: K) => boolean;
+};
+declare const createDerivedAsyncStore: <S, K, T>({ source, dependsOn, build, keyEquals, }: DerivedAsyncStoreOptions<S, K, T>) => {
+    store: ReadableStore<AsyncState<T>>;
+    settled: () => Promise<SettledState<T>>;
+};
+
+/**
+ * Narrows `unknown` to a string-keyed object — a non-null value of `typeof 'object'`
+ * that is not an array. Note it does not distinguish class instances (e.g. `Date`) from
+ * object literals; it only rules out `null`, arrays, and primitives.
+ */
+declare const isPlainObject: (value: unknown) => value is Record<string, unknown>;
+
+/**
+ * Is `value` "deeply empty" — i.e. carries no leaf data? `null`/`undefined`, `{}`, `[]`, and
+ * nested structures whose every leaf is itself empty (e.g. `{ parameters: {} }`) are empty.
+ * Any present primitive (string, number, boolean — including `''`) counts as content.
+ *
+ * Used to skip a pointless encryption round-trip when a validated configuration has nothing
+ * to encrypt.
+ */
+declare const isEmptyDeep: (value: unknown) => boolean;
+
+/**
+ * Recursively merge `patch` into `base`. Plain-object values are merged key-by-key; every
+ * other value (primitives, arrays, or a type mismatch between the two sides) replaces the
+ * base value. `undefined` patch values are skipped, so a partial patch leaves untouched
+ * fields alone. Pure — neither argument is mutated; the result preserves `base`'s type.
+ */
+declare const deepMerge: <T extends Record<string, unknown>>(base: T, patch: Record<string, unknown>) => T;
+
+/**
+ * Merge `patch` into `base`, guided by `schema`: descend only through object schemas, merging
+ * key-by-key. At every non-object node — a `z.union` (e.g. Snowflake's password|keypair auth),
+ * an array, or a primitive — the patch REPLACES the base wholesale. That replace is what lets an
+ * update *delete* keys the additive `deepMerge` cannot: switching a credential union to the other
+ * variant drops the abandoned variant's secret, because the entire union subtree is swapped.
+ *
+ * Consequence: a union (or array) subtree is all-or-nothing — the caller must send the complete
+ * block, since a partial patch replaces (and so loses) the omitted siblings.
+ *
+ * Object keys present only in `base` (e.g. `storage`, `processors`, anything the schema omits) are
+ * preserved at every level; `undefined` patch values are skipped. Assumes `patch` is already
+ * schema-validated (so every object-valued patch key has a matching schema node). Pure — neither
+ * argument is mutated.
+ */
+declare const schemaGuidedMerge: <T extends Record<string, unknown>>(schema: z.core.$ZodType, base: T, patch: Record<string, unknown>) => T;
+
+type Schema<T> = {
+    safeParse: (value: unknown) => {
+        success: true;
+        data: T;
+    } | {
+        success: false;
+    };
+};
+type Persistor<T> = {
+    /** Read + validate the stored value; returns `defaultValue` when empty or corrupt. */
+    hydrate: () => T;
+    /** Serialize + write the value. */
+    persist: (value: T) => void;
+    /** Remove the stored value. */
+    clear: () => void;
+    /** Whether a value is currently persisted under the key. */
+    hasPersistedValue: () => boolean;
+};
+type PersistorOptions<T> = {
+    storage?: StorageAdapter;
+    key: string;
+    schema: Schema<T>;
+    defaultValue: T;
+    encode?: (value: T) => string;
+    decode?: (raw: string) => unknown;
+};
+declare const createPersistor: <T>({ storage, key, schema, defaultValue, encode, decode, }: PersistorOptions<T>) => Persistor<T>;
+
+type TokenSet = {
+    accessToken: string;
+    refreshToken: string;
+    expiresIn: number;
+};
+type Credential = TokenSet & {
+    issuedAt: number;
+};
+type State$1 = {
+    status: 'anonymous';
+    baseUrl: string | null;
+} | {
+    status: 'authenticated';
+    baseUrl: string;
+    credential: Credential;
+} | {
+    status: 'scoped';
+    baseUrl: string;
+    credential: Credential;
+    projectId: number;
+};
+
+type SessionSnapshot$1 = {
+    type: 'Bearer';
+    config: State$1;
+    authReady: boolean;
+    managementReady: boolean;
+    storage: AsyncState<unknown>['state'];
+};
+type RestoreResult = {
+    status: 'empty' | 'restored' | 'expired';
+};
+
+declare const createKeboola: (options?: KeboolaOptions) => {
+    api: KeboolaApi;
+    session: {
+        hasPersistedValue: () => boolean;
+        setBaseUrl: (baseUrl: string) => void;
+        isStorageReady: () => boolean;
+        authenticate: (tokens: TokenSet) => void;
+        setProject: (projectId: number) => void;
+        setProjectAsync: (projectId: number) => Promise<void>;
+        /**
+         * Leave the current project but stay signed in — the storage build returns to `idle`, so a
+         * consumer gating on it falls back to its project picker. The persisted session is rewritten with
+         * `projectId: null` by the subscription above, so a reload lands on the picker rather than
+         * re-entering the project. Use `reset` to sign out instead.
+         */
+        clearProject: () => void;
+        reset: () => void;
+        /**
+         * Dev/test only: mark the current access token as expired so the bearer credential rotates it on
+         * the next request. Pair with any authenticated call (e.g. `api.storage.tokens.verify()`) to force
+         * the rotation immediately and observe the new credential.
+         */
+        debugForceRefresh: () => void;
+        restore: () => Promise<RestoreResult>;
+        subscribe: (listener: (snapshot: SessionSnapshot$1) => void) => () => void;
+        debug: () => SessionSnapshot$1;
+    };
+};
+
+type State = {
+    baseUrl: string | null;
+    sapiToken: string | null;
+    managementToken: string | null;
+};
+
+type SessionSnapshot = {
+    type: 'Sapi';
+    config: State;
+    authReady: boolean;
+    managementReady: boolean;
+    storage: AsyncState<unknown>['state'];
+};
+
+declare const createLegacyKeboola: (options?: KeboolaOptions) => {
+    api: KeboolaApi;
+    session: {
+        setBaseUrl: (baseUrl: string) => void;
+        isStorageReady: () => boolean;
+        authenticateStorage: (sapiToken: string) => void;
+        authenticateStorageAsync: (sapiToken: string) => Promise<void>;
+        authenticateManagement: (managementToken: string) => void;
+        subscribe: (listener: (snapshot: SessionSnapshot) => void) => () => void;
+        debug: () => SessionSnapshot;
+    };
+};
+
 /**
  * This file was auto-generated by openapi-typescript.
  * Do not make direct changes to the file.
@@ -341,15 +734,27 @@ type paths = {
                   path?: string;
                   sqlEditorActive?: boolean;
                 };
+                tableContext?: {
+                  tableName: string;
+                  tableId: string;
+                  bucketId: string;
+                  fileName: string;
+                }[];
               };
             };
             selectedChatModel?: string;
             /** @enum {string} */
             selectedVisibilityType?: 'public' | 'private';
             branchId?: number;
+            toolRestrictions?: {
+              allowedTools?: string[];
+              disallowedTools?: string[];
+              readOnlyMode?: boolean;
+            };
             telemetryMetadata?: {
               [key: string]: string | number | boolean;
             };
+            supportsApprovalRequestedEvent?: boolean;
           };
         };
       };
@@ -1040,6 +1445,11 @@ type paths = {
               /** @enum {string} */
               visibility: 'public' | 'private';
               branchId?: number | null;
+              contextWindow?: {
+                usedTokens: number;
+                maxTokens: number;
+                percentage: number;
+              } | null;
               messages: {
                 /** Format: uuid */
                 id: string;
@@ -2603,7 +3013,7 @@ type paths = {
           content: {
             'application/json': {
               messagesUsed: number;
-              messagesLimit: number;
+              messagesLimit: number | null;
               /** Format: date-time */
               resetDate: string;
             };
@@ -3545,175 +3955,111 @@ type paths = {
     patch?: never;
     trace?: never;
   };
+  '/api/skills': {
+    parameters: {
+      query?: never;
+      header?: never;
+      path?: never;
+      cookie?: never;
+    };
+    /**
+     * List skills and built-in slash commands available to the agent
+     * @description Returns the full set of `/`-invokable items the chat UI surfaces in its slash-command menu: built-in slash commands kai-agent itself recognises (`/plan`, `/compact`) plus every skill (first-party + vendored bundled with the sandbox, project-tagged files uploaded to Keboola Storage). Names and descriptions are normalised server-side — the UI does no merging.
+     */
+    get: {
+      parameters: {
+        query?: never;
+        header?: never;
+        path?: never;
+        cookie?: never;
+      };
+      requestBody?: never;
+      responses: {
+        /** @description List of skills */
+        200: {
+          headers: {
+            [name: string]: unknown;
+          };
+          content: {
+            'application/json': {
+              skills: {
+                name: string;
+                description: string | null;
+                /** @enum {string} */
+                source: 'first-party' | 'vendored' | 'project';
+              }[];
+              commands: {
+                name: string;
+                description: string;
+              }[];
+            };
+          };
+        };
+        /** @description Unauthorized */
+        401: {
+          headers: {
+            [name: string]: unknown;
+          };
+          content: {
+            'application/json': {
+              error: {
+                /** @enum {string} */
+                type:
+                  | 'bad_request'
+                  | 'unauthorized'
+                  | 'forbidden'
+                  | 'not_found'
+                  | 'conflict'
+                  | 'payload_too_large'
+                  | 'rate_limit'
+                  | 'offline'
+                  | 'bad_response'
+                  | 'internal';
+                /** @enum {string} */
+                surface: 'chat' | 'auth' | 'api' | 'stream' | 'database' | 'history' | 'vote';
+                message: string;
+                /** @enum {string} */
+                subtype?: 'burst' | 'monthly';
+                exceptionId?: string;
+              };
+            };
+          };
+        };
+      };
+    };
+    put?: never;
+    post?: never;
+    delete?: never;
+    options?: never;
+    head?: never;
+    patch?: never;
+    trace?: never;
+  };
 };
 
-type GetHistoryQuery = OpenapiQueryType<paths['/api/history']['get']>;
-type GetVotesQuery = OpenapiQueryType<paths['/api/vote']['get']>;
-type GetChatPath = OpenapiPathType<paths['/api/chat/{id}']['get']>;
-type ChatRequest = OpenapiBodyType<paths['/api/chat']['post']>;
-type VoteRequest = OpenapiBodyType<paths['/api/vote']['patch']>;
-type ApprovalBody = OpenapiBodyType<paths['/api/chat/{id}/approval']['post']>;
-type UsageResponse = OpenapiReturnType<paths['/api/usage']['get']>;
-
-declare function assert<T>(value: T | undefined | null, message: string): asserts value is T;
-
-type TaskFn<T> = () => T;
-/**
- * Coalesces concurrent triggers onto a single, never-parallel run of `task`.
- * Triggers fired while a run is busy collapse into one trailing run, and each
- * resolves with the first run that started after it — so it never sees stale state.
- *
- * Example — A triggers, then B and C trigger while A's run is still going:
- *   1. trigger A      → run #1 starts
- *   2. trigger B, C   → run #1 busy, so they wait
- *   3. run #1 done    → A resolves
- *   4. run #2 starts  → covers B and C together (one trailing run, not two)
- *   5. run #2 done    → B and C resolve
- *
- * @returns a trigger; each call returns a promise of the task result.
- * @throws The returned promise rejects with whatever `task` throws or rejects
- * with — the caller handles it (try/catch, or `.catch` on `void trigger()`).
- */
-declare const coalesce: <T>(task: TaskFn<T>) => (() => Promise<Awaited<T>>);
-
-declare const delay: (timeout: number, signal?: AbortSignal) => Promise<unknown>;
-
-type PollResult<T> = {
-    data: T;
-    callCount: number;
-};
-type PollErrorType = 'PollPredicateError' | 'PollTimeoutError' | 'PollPollTimeoutError';
-declare class PollException<T> extends Error {
-    result: PollResult<T>;
-    constructor(type: PollErrorType, result: PollResult<T>);
-}
-type Options<T> = {
-    pollFn: (abortSignal?: AbortSignal) => Promise<T>;
-    isDone: (result: T) => boolean;
-    isFailed?: (result: T) => boolean;
-    interval: number;
-    abortSignal?: AbortSignal;
-    maxAttempts?: number;
-};
-declare const poll: <T>({ pollFn, interval, isDone, isFailed, abortSignal, maxAttempts, }: Options<T>) => Promise<PollResult<T>>;
-
-declare const generateUUID: () => `${string}-${string}-${string}-${string}-${string}`;
-
-/**
- * Executes an asynchronous callback function on an array of items in series (one at a time).
- * It behaves similarly to Promise.all(), failing on the first rejected promise.
- * The order of the results matches the order of the promises.
- */
-declare const series: <T, R>(options: Omit<ConcurrentOptions<T, R>, "concurrency">) => Promise<R[]>;
-
-type Listener<T> = (value: T) => void;
-type ReadableStore<T> = {
-    get: () => T;
-    subscribe: (listener: Listener<T>) => () => void;
-};
-type Store<T> = ReadableStore<T> & {
-    set: (value: T) => void;
-};
-declare const createStore: <T>(initial: T) => Store<T>;
-declare const shallowEqual: <T>(a: T, b: T) => boolean;
-type DerivedStoreOptions<S, K, T> = {
-    source: ReadableStore<S>;
-    dependsOn: (state: S) => K;
-    build: (key: K) => T;
-    keyEquals?: (a: K, b: K) => boolean;
-};
-declare const createDerivedStore: <S, K, T>({ source, dependsOn, build, keyEquals, }: DerivedStoreOptions<S, K, T>) => ReadableStore<T>;
-
-/**
- * Narrows `unknown` to a string-keyed object — a non-null value of `typeof 'object'`
- * that is not an array. Note it does not distinguish class instances (e.g. `Date`) from
- * object literals; it only rules out `null`, arrays, and primitives.
- */
-declare const isPlainObject: (value: unknown) => value is Record<string, unknown>;
-
-/**
- * Is `value` "deeply empty" — i.e. carries no leaf data? `null`/`undefined`, `{}`, `[]`, and
- * nested structures whose every leaf is itself empty (e.g. `{ parameters: {} }`) are empty.
- * Any present primitive (string, number, boolean — including `''`) counts as content.
- *
- * Used to skip a pointless encryption round-trip when a validated configuration has nothing
- * to encrypt.
- */
-declare const isEmptyDeep: (value: unknown) => boolean;
-
-/**
- * Recursively merge `patch` into `base`. Plain-object values are merged key-by-key; every
- * other value (primitives, arrays, or a type mismatch between the two sides) replaces the
- * base value. `undefined` patch values are skipped, so a partial patch leaves untouched
- * fields alone. Pure — neither argument is mutated; the result preserves `base`'s type.
- */
-declare const deepMerge: <T extends Record<string, unknown>>(base: T, patch: Record<string, unknown>) => T;
-
-/**
- * Merge `patch` into `base`, guided by `schema`: descend only through object schemas, merging
- * key-by-key. At every non-object node — a `z.union` (e.g. Snowflake's password|keypair auth),
- * an array, or a primitive — the patch REPLACES the base wholesale. That replace is what lets an
- * update *delete* keys the additive `deepMerge` cannot: switching a credential union to the other
- * variant drops the abandoned variant's secret, because the entire union subtree is swapped.
- *
- * Consequence: a union (or array) subtree is all-or-nothing — the caller must send the complete
- * block, since a partial patch replaces (and so loses) the omitted siblings.
- *
- * Object keys present only in `base` (e.g. `storage`, `processors`, anything the schema omits) are
- * preserved at every level; `undefined` patch values are skipped. Assumes `patch` is already
- * schema-validated (so every object-valued patch key has a matching schema node). Pure — neither
- * argument is mutated.
- */
-declare const schemaGuidedMerge: <T extends Record<string, unknown>>(schema: z.core.$ZodType, base: T, patch: Record<string, unknown>) => T;
-
-type ServiceUrls = Partial<Record<ServiceId, (url: string) => string | undefined | null>>;
+type GetHistoryQuery = OpenapiQueryType<paths['/api/history']['get']>;
+type GetVotesQuery = OpenapiQueryType<paths['/api/vote']['get']>;
+type GetChatPath = OpenapiPathType<paths['/api/chat/{id}']['get']>;
+type ChatRequest = OpenapiBodyType<paths['/api/chat']['post']>;
+type VoteRequest = OpenapiBodyType<paths['/api/vote']['patch']>;
+type ApprovalBody = OpenapiBodyType<paths['/api/chat/{id}/approval']['post']>;
+type UsageResponse = OpenapiReturnType<paths['/api/usage']['get']>;
 
 /**
- * Service clients reached through the registry — the key is the `clientName`
- * the user accesses them by (e.g. `api.dataScience`), not the `serviceId`.
+ * Bearer (OAuth) project surface. Same handshake + assembly as the legacy build. The
+ * `Authorization: Bearer` header + transparent refresh come from the engine-shared `authMiddleware`
+ * (one instance for management + every project client). This build only adds the project-scoped
+ * `X-KBC-ProjectId` header, composed *outside* the auth middleware so the header is present
+ * before it clones the request for the 401 replay. Bearer has no static token header, so this
+ * combined `attach` rides on every client — including the operational storage and the bootstrap reader.
  */
-type ServiceClientName = 'vault' | 'dataScience' | 'encryption' | 'editor' | 'syncActions' | 'telemetry' | 'queryService' | 'queue' | 'chat' | 'ai' | 'import' | 'kaiAgent' | 'oauth' | 'stream' | 'notifications' | 'scheduler' | 'metastore';
-/** Clients instantiated directly (not stack-discovered), keyed by their property name. */
-type NonServiceClientName = 'storage' | 'management' | 'auth';
-type MiddlewareTarget = ServiceClientName | NonServiceClientName;
-type Middlewares = MiddlewareFn[] | ({
-    all?: MiddlewareFn[];
-} & Partial<Record<MiddlewareTarget, MiddlewareFn[]>>);
-
-type ApiClientOptions = {
-    token: {
-        storageApi: string;
-        managementApi?: string;
-    };
-    middlewares?: Middlewares;
+declare const createProjectClients: ({ baseUrl, projectId, authMiddleware, middlewareFor, clientServiceUrls, }: {
+    baseUrl: string;
+    authMiddleware: MiddlewareFn;
+    projectId: number;
+    middlewareFor: MiddlewareFor;
     clientServiceUrls?: ServiceUrls;
-} & BaseClientOptions;
-declare const isStorageTokenMutatingRequest: (request: Request) => boolean;
-declare const createLiveProject: ({ initialToken, verify, }: {
-    initialToken: StorageToken;
-    verify: () => Promise<StorageToken>;
-}) => {
-    store: Store<{
-        hasFeature: (...feature: string[]) => boolean;
-        hasAdminFeature: (...feature: string[]) => boolean;
-        hasBackend: (backend: Backend) => boolean;
-        sapiToken: StorageToken;
-    }>;
-    getProject: () => {
-        hasFeature: (...feature: string[]) => boolean;
-        hasAdminFeature: (...feature: string[]) => boolean;
-        hasBackend: (backend: Backend) => boolean;
-        sapiToken: StorageToken;
-    };
-    subscribe: (listener: (value: {
-        hasFeature: (...feature: string[]) => boolean;
-        hasAdminFeature: (...feature: string[]) => boolean;
-        hasBackend: (backend: Backend) => boolean;
-        sapiToken: StorageToken;
-    }) => void) => () => void;
-    middleware: MiddlewareFn;
-};
-declare const createClients: ({ baseUrl, token, clientServiceUrls, middlewares, }: ApiClientOptions) => Promise<{
+}) => Promise<{
     sdk: {
         configuration: {
             getConfiguration: <ComponentId extends RegisteredComponentId>(path: ConfigurationPath<ComponentId>) => Promise<{
@@ -4593,7 +4939,142 @@ declare const createClients: ({ baseUrl, token, clientServiceUrls, middlewares,
                         onlyEnabledCustomers: zod.ZodOptional<zod.ZodBoolean>;
                         getAccountChildren: zod.ZodOptional<zod.ZodBoolean>;
                     }, zod_v4_core.$strip>;
-                }, zod_v4_core.$strip>>)[ComponentId]>>;
+                }, zod_v4_core.$strip>> & Record<"keboola.ex-http", zod.ZodObject<{
+                    parameters: zod.ZodObject<{
+                        baseUrl: zod.ZodString;
+                        maxRedirects: zod.ZodOptional<zod.ZodNumber>;
+                    }, zod_v4_core.$loose>;
+                }, zod_v4_core.$loose>> & Record<"keboola.ex-ftp", zod.ZodObject<{
+                    parameters: zod.ZodUnion<readonly [zod.ZodObject<{
+                        host: zod.ZodString;
+                        port: zod.ZodNumber;
+                        connectionType: zod.ZodEnum<{
+                            FTP: "FTP";
+                            FTPS: "FTPS";
+                            SFTP: "SFTP";
+                        }>;
+                        username: zod.ZodString;
+                        ignorePassiveAddress: zod.ZodOptional<zod.ZodBoolean>;
+                        ssh: zod.ZodOptional<zod.ZodObject<{
+                            enabled: zod.ZodBoolean;
+                            sshHost: zod.ZodOptional<zod.ZodString>;
+                            user: zod.ZodOptional<zod.ZodString>;
+                            sshPort: zod.ZodOptional<zod.ZodNumber>;
+                            passivePortRange: zod.ZodOptional<zod.ZodString>;
+                            keys: zod.ZodOptional<zod.ZodObject<{
+                                public: zod.ZodOptional<zod.ZodString>;
+                                '#private': zod.ZodOptional<zod.ZodString>;
+                            }, zod_v4_core.$strip>>;
+                        }, zod_v4_core.$strip>>;
+                        path: zod.ZodOptional<zod.ZodString>;
+                        onlyNewFiles: zod.ZodOptional<zod.ZodBoolean>;
+                        '#password': zod.ZodString;
+                        '#privateKey': zod.ZodOptional<zod.ZodUndefined>;
+                    }, zod_v4_core.$loose>, zod.ZodObject<{
+                        host: zod.ZodString;
+                        port: zod.ZodNumber;
+                        connectionType: zod.ZodEnum<{
+                            FTP: "FTP";
+                            FTPS: "FTPS";
+                            SFTP: "SFTP";
+                        }>;
+                        username: zod.ZodString;
+                        ignorePassiveAddress: zod.ZodOptional<zod.ZodBoolean>;
+                        ssh: zod.ZodOptional<zod.ZodObject<{
+                            enabled: zod.ZodBoolean;
+                            sshHost: zod.ZodOptional<zod.ZodString>;
+                            user: zod.ZodOptional<zod.ZodString>;
+                            sshPort: zod.ZodOptional<zod.ZodNumber>;
+                            passivePortRange: zod.ZodOptional<zod.ZodString>;
+                            keys: zod.ZodOptional<zod.ZodObject<{
+                                public: zod.ZodOptional<zod.ZodString>;
+                                '#private': zod.ZodOptional<zod.ZodString>;
+                            }, zod_v4_core.$strip>>;
+                        }, zod_v4_core.$strip>>;
+                        path: zod.ZodOptional<zod.ZodString>;
+                        onlyNewFiles: zod.ZodOptional<zod.ZodBoolean>;
+                        '#privateKey': zod.ZodString;
+                        '#password': zod.ZodOptional<zod.ZodUndefined>;
+                    }, zod_v4_core.$loose>]>;
+                }, zod_v4_core.$loose>> & Record<"keboola.ex-ftp-csas", zod.ZodObject<{
+                    parameters: zod.ZodUnion<readonly [zod.ZodObject<{
+                        host: zod.ZodString;
+                        port: zod.ZodNumber;
+                        connectionType: zod.ZodEnum<{
+                            FTP: "FTP";
+                            FTPS: "FTPS";
+                            SFTP: "SFTP";
+                        }>;
+                        username: zod.ZodString;
+                        ignorePassiveAddress: zod.ZodOptional<zod.ZodBoolean>;
+                        ssh: zod.ZodOptional<zod.ZodObject<{
+                            enabled: zod.ZodBoolean;
+                            sshHost: zod.ZodOptional<zod.ZodString>;
+                            user: zod.ZodOptional<zod.ZodString>;
+                            sshPort: zod.ZodOptional<zod.ZodNumber>;
+                            passivePortRange: zod.ZodOptional<zod.ZodString>;
+                            keys: zod.ZodOptional<zod.ZodObject<{
+                                public: zod.ZodOptional<zod.ZodString>;
+                                '#private': zod.ZodOptional<zod.ZodString>;
+                            }, zod_v4_core.$strip>>;
+                        }, zod_v4_core.$strip>>;
+                        path: zod.ZodOptional<zod.ZodString>;
+                        onlyNewFiles: zod.ZodOptional<zod.ZodBoolean>;
+                        '#password': zod.ZodString;
+                        '#privateKey': zod.ZodOptional<zod.ZodUndefined>;
+                    }, zod_v4_core.$loose>, zod.ZodObject<{
+                        host: zod.ZodString;
+                        port: zod.ZodNumber;
+                        connectionType: zod.ZodEnum<{
+                            FTP: "FTP";
+                            FTPS: "FTPS";
+                            SFTP: "SFTP";
+                        }>;
+                        username: zod.ZodString;
+                        ignorePassiveAddress: zod.ZodOptional<zod.ZodBoolean>;
+                        ssh: zod.ZodOptional<zod.ZodObject<{
+                            enabled: zod.ZodBoolean;
+                            sshHost: zod.ZodOptional<zod.ZodString>;
+                            user: zod.ZodOptional<zod.ZodString>;
+                            sshPort: zod.ZodOptional<zod.ZodNumber>;
+                            passivePortRange: zod.ZodOptional<zod.ZodString>;
+                            keys: zod.ZodOptional<zod.ZodObject<{
+                                public: zod.ZodOptional<zod.ZodString>;
+                                '#private': zod.ZodOptional<zod.ZodString>;
+                            }, zod_v4_core.$strip>>;
+                        }, zod_v4_core.$strip>>;
+                        path: zod.ZodOptional<zod.ZodString>;
+                        onlyNewFiles: zod.ZodOptional<zod.ZodBoolean>;
+                        '#privateKey': zod.ZodString;
+                        '#password': zod.ZodOptional<zod.ZodUndefined>;
+                    }, zod_v4_core.$loose>]>;
+                }, zod_v4_core.$loose>> & Record<"keboola.ex-aws-s3", zod.ZodObject<{
+                    parameters: zod.ZodUnion<readonly [zod.ZodObject<{
+                        loginType: zod.ZodLiteral<"credentials">;
+                        accessKeyId: zod.ZodString;
+                        '#secretAccessKey': zod.ZodString;
+                        accountId: zod.ZodOptional<zod.ZodUndefined>;
+                        roleName: zod.ZodOptional<zod.ZodUndefined>;
+                    }, zod_v4_core.$loose>, zod.ZodObject<{
+                        loginType: zod.ZodLiteral<"role">;
+                        accountId: zod.ZodString;
+                        roleName: zod.ZodString;
+                        accessKeyId: zod.ZodOptional<zod.ZodUndefined>;
+                        '#secretAccessKey': zod.ZodOptional<zod.ZodUndefined>;
+                    }, zod_v4_core.$loose>]>;
+                }, zod_v4_core.$loose>> & Record<"kds-team.ex-azure-blob-storage-v2", zod.ZodObject<{
+                    parameters: zod.ZodObject<{
+                        account_name: zod.ZodString;
+                        '#account_key': zod.ZodString;
+                        container_name: zod.ZodString;
+                    }, zod_v4_core.$loose>;
+                }, zod_v4_core.$loose>> & Record<"kds-team.ex-azure-data-lake-gen2", zod.ZodObject<{
+                    parameters: zod.ZodObject<{
+                        account_name: zod.ZodString;
+                        '#account_key': zod.ZodString;
+                        file_system: zod.ZodString;
+                    }, zod_v4_core.$loose>;
+                }, zod_v4_core.$loose>>)[ComponentId]>>;
                 runnable: boolean;
                 error: zod.ZodError<unknown> | undefined;
             }>;
@@ -5475,7 +5956,142 @@ declare const createClients: ({ baseUrl, token, clientServiceUrls, middlewares,
                         onlyEnabledCustomers: zod.ZodOptional<zod.ZodBoolean>;
                         getAccountChildren: zod.ZodOptional<zod.ZodBoolean>;
                     }, zod_v4_core.$strip>;
-                }, zod_v4_core.$strip>>)[ComponentId]> extends infer T ? T extends zod.input<(Record<never, never> & Record<"keboola.wr-db-mysql", zod.ZodObject<{
+                }, zod_v4_core.$strip>> & Record<"keboola.ex-http", zod.ZodObject<{
+                    parameters: zod.ZodObject<{
+                        baseUrl: zod.ZodString;
+                        maxRedirects: zod.ZodOptional<zod.ZodNumber>;
+                    }, zod_v4_core.$loose>;
+                }, zod_v4_core.$loose>> & Record<"keboola.ex-ftp", zod.ZodObject<{
+                    parameters: zod.ZodUnion<readonly [zod.ZodObject<{
+                        host: zod.ZodString;
+                        port: zod.ZodNumber;
+                        connectionType: zod.ZodEnum<{
+                            FTP: "FTP";
+                            FTPS: "FTPS";
+                            SFTP: "SFTP";
+                        }>;
+                        username: zod.ZodString;
+                        ignorePassiveAddress: zod.ZodOptional<zod.ZodBoolean>;
+                        ssh: zod.ZodOptional<zod.ZodObject<{
+                            enabled: zod.ZodBoolean;
+                            sshHost: zod.ZodOptional<zod.ZodString>;
+                            user: zod.ZodOptional<zod.ZodString>;
+                            sshPort: zod.ZodOptional<zod.ZodNumber>;
+                            passivePortRange: zod.ZodOptional<zod.ZodString>;
+                            keys: zod.ZodOptional<zod.ZodObject<{
+                                public: zod.ZodOptional<zod.ZodString>;
+                                '#private': zod.ZodOptional<zod.ZodString>;
+                            }, zod_v4_core.$strip>>;
+                        }, zod_v4_core.$strip>>;
+                        path: zod.ZodOptional<zod.ZodString>;
+                        onlyNewFiles: zod.ZodOptional<zod.ZodBoolean>;
+                        '#password': zod.ZodString;
+                        '#privateKey': zod.ZodOptional<zod.ZodUndefined>;
+                    }, zod_v4_core.$loose>, zod.ZodObject<{
+                        host: zod.ZodString;
+                        port: zod.ZodNumber;
+                        connectionType: zod.ZodEnum<{
+                            FTP: "FTP";
+                            FTPS: "FTPS";
+                            SFTP: "SFTP";
+                        }>;
+                        username: zod.ZodString;
+                        ignorePassiveAddress: zod.ZodOptional<zod.ZodBoolean>;
+                        ssh: zod.ZodOptional<zod.ZodObject<{
+                            enabled: zod.ZodBoolean;
+                            sshHost: zod.ZodOptional<zod.ZodString>;
+                            user: zod.ZodOptional<zod.ZodString>;
+                            sshPort: zod.ZodOptional<zod.ZodNumber>;
+                            passivePortRange: zod.ZodOptional<zod.ZodString>;
+                            keys: zod.ZodOptional<zod.ZodObject<{
+                                public: zod.ZodOptional<zod.ZodString>;
+                                '#private': zod.ZodOptional<zod.ZodString>;
+                            }, zod_v4_core.$strip>>;
+                        }, zod_v4_core.$strip>>;
+                        path: zod.ZodOptional<zod.ZodString>;
+                        onlyNewFiles: zod.ZodOptional<zod.ZodBoolean>;
+                        '#privateKey': zod.ZodString;
+                        '#password': zod.ZodOptional<zod.ZodUndefined>;
+                    }, zod_v4_core.$loose>]>;
+                }, zod_v4_core.$loose>> & Record<"keboola.ex-ftp-csas", zod.ZodObject<{
+                    parameters: zod.ZodUnion<readonly [zod.ZodObject<{
+                        host: zod.ZodString;
+                        port: zod.ZodNumber;
+                        connectionType: zod.ZodEnum<{
+                            FTP: "FTP";
+                            FTPS: "FTPS";
+                            SFTP: "SFTP";
+                        }>;
+                        username: zod.ZodString;
+                        ignorePassiveAddress: zod.ZodOptional<zod.ZodBoolean>;
+                        ssh: zod.ZodOptional<zod.ZodObject<{
+                            enabled: zod.ZodBoolean;
+                            sshHost: zod.ZodOptional<zod.ZodString>;
+                            user: zod.ZodOptional<zod.ZodString>;
+                            sshPort: zod.ZodOptional<zod.ZodNumber>;
+                            passivePortRange: zod.ZodOptional<zod.ZodString>;
+                            keys: zod.ZodOptional<zod.ZodObject<{
+                                public: zod.ZodOptional<zod.ZodString>;
+                                '#private': zod.ZodOptional<zod.ZodString>;
+                            }, zod_v4_core.$strip>>;
+                        }, zod_v4_core.$strip>>;
+                        path: zod.ZodOptional<zod.ZodString>;
+                        onlyNewFiles: zod.ZodOptional<zod.ZodBoolean>;
+                        '#password': zod.ZodString;
+                        '#privateKey': zod.ZodOptional<zod.ZodUndefined>;
+                    }, zod_v4_core.$loose>, zod.ZodObject<{
+                        host: zod.ZodString;
+                        port: zod.ZodNumber;
+                        connectionType: zod.ZodEnum<{
+                            FTP: "FTP";
+                            FTPS: "FTPS";
+                            SFTP: "SFTP";
+                        }>;
+                        username: zod.ZodString;
+                        ignorePassiveAddress: zod.ZodOptional<zod.ZodBoolean>;
+                        ssh: zod.ZodOptional<zod.ZodObject<{
+                            enabled: zod.ZodBoolean;
+                            sshHost: zod.ZodOptional<zod.ZodString>;
+                            user: zod.ZodOptional<zod.ZodString>;
+                            sshPort: zod.ZodOptional<zod.ZodNumber>;
+                            passivePortRange: zod.ZodOptional<zod.ZodString>;
+                            keys: zod.ZodOptional<zod.ZodObject<{
+                                public: zod.ZodOptional<zod.ZodString>;
+                                '#private': zod.ZodOptional<zod.ZodString>;
+                            }, zod_v4_core.$strip>>;
+                        }, zod_v4_core.$strip>>;
+                        path: zod.ZodOptional<zod.ZodString>;
+                        onlyNewFiles: zod.ZodOptional<zod.ZodBoolean>;
+                        '#privateKey': zod.ZodString;
+                        '#password': zod.ZodOptional<zod.ZodUndefined>;
+                    }, zod_v4_core.$loose>]>;
+                }, zod_v4_core.$loose>> & Record<"keboola.ex-aws-s3", zod.ZodObject<{
+                    parameters: zod.ZodUnion<readonly [zod.ZodObject<{
+                        loginType: zod.ZodLiteral<"credentials">;
+                        accessKeyId: zod.ZodString;
+                        '#secretAccessKey': zod.ZodString;
+                        accountId: zod.ZodOptional<zod.ZodUndefined>;
+                        roleName: zod.ZodOptional<zod.ZodUndefined>;
+                    }, zod_v4_core.$loose>, zod.ZodObject<{
+                        loginType: zod.ZodLiteral<"role">;
+                        accountId: zod.ZodString;
+                        roleName: zod.ZodString;
+                        accessKeyId: zod.ZodOptional<zod.ZodUndefined>;
+                        '#secretAccessKey': zod.ZodOptional<zod.ZodUndefined>;
+                    }, zod_v4_core.$loose>]>;
+                }, zod_v4_core.$loose>> & Record<"kds-team.ex-azure-blob-storage-v2", zod.ZodObject<{
+                    parameters: zod.ZodObject<{
+                        account_name: zod.ZodString;
+                        '#account_key': zod.ZodString;
+                        container_name: zod.ZodString;
+                    }, zod_v4_core.$loose>;
+                }, zod_v4_core.$loose>> & Record<"kds-team.ex-azure-data-lake-gen2", zod.ZodObject<{
+                    parameters: zod.ZodObject<{
+                        account_name: zod.ZodString;
+                        '#account_key': zod.ZodString;
+                        file_system: zod.ZodString;
+                    }, zod_v4_core.$loose>;
+                }, zod_v4_core.$loose>>)[ComponentId]> extends infer T ? T extends zod.input<(Record<never, never> & Record<"keboola.wr-db-mysql", zod.ZodObject<{
                     parameters: zod.ZodObject<{
                         db: zod.ZodObject<{
                             host: zod.ZodString;
@@ -6351,7 +6967,142 @@ declare const createClients: ({ baseUrl, token, clientServiceUrls, middlewares,
                         onlyEnabledCustomers: zod.ZodOptional<zod.ZodBoolean>;
                         getAccountChildren: zod.ZodOptional<zod.ZodBoolean>;
                     }, zod_v4_core.$strip>;
-                }, zod_v4_core.$strip>>)[ComponentId]> ? T extends object ? { [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends object ? { [K_2 in keyof T_1]?: (T_1[K_2] extends infer T_2 ? T_2 extends T_1[K_2] ? T_2 extends object ? { [K_3 in keyof T_2]?: (T_2[K_3] extends infer T_3 ? T_3 extends T_2[K_3] ? T_3 extends object ? { [K_4 in keyof T_3]?: (T_3[K_4] extends infer T_4 ? T_4 extends T_3[K_4] ? T_4 extends object ? { [K_5 in keyof T_4]?: (T_4[K_5] extends infer T_5 ? T_5 extends T_4[K_5] ? T_5 extends object ? { [K_6 in keyof T_5]?: (T_5[K_6] extends infer T_6 ? T_6 extends T_5[K_6] ? T_6 extends object ? { [K_7 in keyof T_6]?: (T_6[K_7] extends infer T_7 ? T_7 extends T_6[K_7] ? T_7 extends object ? { [K_8 in keyof T_7]?: (T_7[K_8] extends infer T_8 ? T_8 extends T_7[K_8] ? T_8 extends object ? { [K_9 in keyof T_8]?: (T_8[K_9] extends infer T_9 ? T_9 extends T_8[K_9] ? T_9 extends object ? { [K_10 in keyof T_9]?: (T_9[K_10] extends infer T_10 ? T_10 extends T_9[K_10] ? T_10 extends object ? { [K_11 in keyof T_10]?: /*elided*/ any | undefined; } : T_10 : never : never) | undefined; } : T_9 : never : never) | undefined; } : T_8 : never : never) | undefined; } : T_7 : never : never) | undefined; } : T_6 : never : never) | undefined; } : T_5 : never : never) | undefined; } : T_4 : never : never) | undefined; } : T_3 : never : never) | undefined; } : T_2 : never : never) | undefined; } : T_1 : never : never) | undefined; } : T : never : never;
+                }, zod_v4_core.$strip>> & Record<"keboola.ex-http", zod.ZodObject<{
+                    parameters: zod.ZodObject<{
+                        baseUrl: zod.ZodString;
+                        maxRedirects: zod.ZodOptional<zod.ZodNumber>;
+                    }, zod_v4_core.$loose>;
+                }, zod_v4_core.$loose>> & Record<"keboola.ex-ftp", zod.ZodObject<{
+                    parameters: zod.ZodUnion<readonly [zod.ZodObject<{
+                        host: zod.ZodString;
+                        port: zod.ZodNumber;
+                        connectionType: zod.ZodEnum<{
+                            FTP: "FTP";
+                            FTPS: "FTPS";
+                            SFTP: "SFTP";
+                        }>;
+                        username: zod.ZodString;
+                        ignorePassiveAddress: zod.ZodOptional<zod.ZodBoolean>;
+                        ssh: zod.ZodOptional<zod.ZodObject<{
+                            enabled: zod.ZodBoolean;
+                            sshHost: zod.ZodOptional<zod.ZodString>;
+                            user: zod.ZodOptional<zod.ZodString>;
+                            sshPort: zod.ZodOptional<zod.ZodNumber>;
+                            passivePortRange: zod.ZodOptional<zod.ZodString>;
+                            keys: zod.ZodOptional<zod.ZodObject<{
+                                public: zod.ZodOptional<zod.ZodString>;
+                                '#private': zod.ZodOptional<zod.ZodString>;
+                            }, zod_v4_core.$strip>>;
+                        }, zod_v4_core.$strip>>;
+                        path: zod.ZodOptional<zod.ZodString>;
+                        onlyNewFiles: zod.ZodOptional<zod.ZodBoolean>;
+                        '#password': zod.ZodString;
+                        '#privateKey': zod.ZodOptional<zod.ZodUndefined>;
+                    }, zod_v4_core.$loose>, zod.ZodObject<{
+                        host: zod.ZodString;
+                        port: zod.ZodNumber;
+                        connectionType: zod.ZodEnum<{
+                            FTP: "FTP";
+                            FTPS: "FTPS";
+                            SFTP: "SFTP";
+                        }>;
+                        username: zod.ZodString;
+                        ignorePassiveAddress: zod.ZodOptional<zod.ZodBoolean>;
+                        ssh: zod.ZodOptional<zod.ZodObject<{
+                            enabled: zod.ZodBoolean;
+                            sshHost: zod.ZodOptional<zod.ZodString>;
+                            user: zod.ZodOptional<zod.ZodString>;
+                            sshPort: zod.ZodOptional<zod.ZodNumber>;
+                            passivePortRange: zod.ZodOptional<zod.ZodString>;
+                            keys: zod.ZodOptional<zod.ZodObject<{
+                                public: zod.ZodOptional<zod.ZodString>;
+                                '#private': zod.ZodOptional<zod.ZodString>;
+                            }, zod_v4_core.$strip>>;
+                        }, zod_v4_core.$strip>>;
+                        path: zod.ZodOptional<zod.ZodString>;
+                        onlyNewFiles: zod.ZodOptional<zod.ZodBoolean>;
+                        '#privateKey': zod.ZodString;
+                        '#password': zod.ZodOptional<zod.ZodUndefined>;
+                    }, zod_v4_core.$loose>]>;
+                }, zod_v4_core.$loose>> & Record<"keboola.ex-ftp-csas", zod.ZodObject<{
+                    parameters: zod.ZodUnion<readonly [zod.ZodObject<{
+                        host: zod.ZodString;
+                        port: zod.ZodNumber;
+                        connectionType: zod.ZodEnum<{
+                            FTP: "FTP";
+                            FTPS: "FTPS";
+                            SFTP: "SFTP";
+                        }>;
+                        username: zod.ZodString;
+                        ignorePassiveAddress: zod.ZodOptional<zod.ZodBoolean>;
+                        ssh: zod.ZodOptional<zod.ZodObject<{
+                            enabled: zod.ZodBoolean;
+                            sshHost: zod.ZodOptional<zod.ZodString>;
+                            user: zod.ZodOptional<zod.ZodString>;
+                            sshPort: zod.ZodOptional<zod.ZodNumber>;
+                            passivePortRange: zod.ZodOptional<zod.ZodString>;
+                            keys: zod.ZodOptional<zod.ZodObject<{
+                                public: zod.ZodOptional<zod.ZodString>;
+                                '#private': zod.ZodOptional<zod.ZodString>;
+                            }, zod_v4_core.$strip>>;
+                        }, zod_v4_core.$strip>>;
+                        path: zod.ZodOptional<zod.ZodString>;
+                        onlyNewFiles: zod.ZodOptional<zod.ZodBoolean>;
+                        '#password': zod.ZodString;
+                        '#privateKey': zod.ZodOptional<zod.ZodUndefined>;
+                    }, zod_v4_core.$loose>, zod.ZodObject<{
+                        host: zod.ZodString;
+                        port: zod.ZodNumber;
+                        connectionType: zod.ZodEnum<{
+                            FTP: "FTP";
+                            FTPS: "FTPS";
+                            SFTP: "SFTP";
+                        }>;
+                        username: zod.ZodString;
+                        ignorePassiveAddress: zod.ZodOptional<zod.ZodBoolean>;
+                        ssh: zod.ZodOptional<zod.ZodObject<{
+                            enabled: zod.ZodBoolean;
+                            sshHost: zod.ZodOptional<zod.ZodString>;
+                            user: zod.ZodOptional<zod.ZodString>;
+                            sshPort: zod.ZodOptional<zod.ZodNumber>;
+                            passivePortRange: zod.ZodOptional<zod.ZodString>;
+                            keys: zod.ZodOptional<zod.ZodObject<{
+                                public: zod.ZodOptional<zod.ZodString>;
+                                '#private': zod.ZodOptional<zod.ZodString>;
+                            }, zod_v4_core.$strip>>;
+                        }, zod_v4_core.$strip>>;
+                        path: zod.ZodOptional<zod.ZodString>;
+                        onlyNewFiles: zod.ZodOptional<zod.ZodBoolean>;
+                        '#privateKey': zod.ZodString;
+                        '#password': zod.ZodOptional<zod.ZodUndefined>;
+                    }, zod_v4_core.$loose>]>;
+                }, zod_v4_core.$loose>> & Record<"keboola.ex-aws-s3", zod.ZodObject<{
+                    parameters: zod.ZodUnion<readonly [zod.ZodObject<{
+                        loginType: zod.ZodLiteral<"credentials">;
+                        accessKeyId: zod.ZodString;
+                        '#secretAccessKey': zod.ZodString;
+                        accountId: zod.ZodOptional<zod.ZodUndefined>;
+                        roleName: zod.ZodOptional<zod.ZodUndefined>;
+                    }, zod_v4_core.$loose>, zod.ZodObject<{
+                        loginType: zod.ZodLiteral<"role">;
+                        accountId: zod.ZodString;
+                        roleName: zod.ZodString;
+                        accessKeyId: zod.ZodOptional<zod.ZodUndefined>;
+                        '#secretAccessKey': zod.ZodOptional<zod.ZodUndefined>;
+                    }, zod_v4_core.$loose>]>;
+                }, zod_v4_core.$loose>> & Record<"kds-team.ex-azure-blob-storage-v2", zod.ZodObject<{
+                    parameters: zod.ZodObject<{
+                        account_name: zod.ZodString;
+                        '#account_key': zod.ZodString;
+                        container_name: zod.ZodString;
+                    }, zod_v4_core.$loose>;
+                }, zod_v4_core.$loose>> & Record<"kds-team.ex-azure-data-lake-gen2", zod.ZodObject<{
+                    parameters: zod.ZodObject<{
+                        account_name: zod.ZodString;
+                        '#account_key': zod.ZodString;
+                        file_system: zod.ZodString;
+                    }, zod_v4_core.$loose>;
+                }, zod_v4_core.$loose>>)[ComponentId]> ? T extends object ? { [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends object ? { [K_2 in keyof T_1]?: (T_1[K_2] extends infer T_2 ? T_2 extends T_1[K_2] ? T_2 extends object ? { [K_3 in keyof T_2]?: (T_2[K_3] extends infer T_3 ? T_3 extends T_2[K_3] ? T_3 extends object ? { [K_4 in keyof T_3]?: (T_3[K_4] extends infer T_4 ? T_4 extends T_3[K_4] ? T_4 extends object ? { [K_5 in keyof T_4]?: (T_4[K_5] extends infer T_5 ? T_5 extends T_4[K_5] ? T_5 extends object ? { [K_6 in keyof T_5]?: (T_5[K_6] extends infer T_6 ? T_6 extends T_5[K_6] ? T_6 extends object ? { [K_7 in keyof T_6]?: (T_6[K_7] extends infer T_7 ? T_7 extends T_6[K_7] ? T_7 extends object ? { [K_8 in keyof T_7]?: (T_7[K_8] extends infer T_8 ? T_8 extends T_7[K_8] ? T_8 extends object ? { [K_9 in keyof T_8]?: (T_8[K_9] extends infer T_9 ? T_9 extends T_8[K_9] ? T_9 extends object ? { [K_10 in keyof T_9]?: (T_9[K_10] extends infer T_10 ? T_10 extends T_9[K_10] ? T_10 extends object ? { [K_11 in keyof T_10]?: /*elided*/ any | undefined; } : T_10 : never : never) | undefined; } : T_9 : never : never) | undefined; } : T_8 : never : never) | undefined; } : T_7 : never : never) | undefined; } : T_6 : never : never) | undefined; } : T_5 : never : never) | undefined; } : T_4 : never : never) | undefined; } : T_3 : never : never) | undefined; } : T_2 : never : never) | undefined; } : T_1 : never : never) | undefined; } : T : never : never;
             }) => Promise<{
                 data: BaseComponentConfig<zod.input<(Record<never, never> & Record<"keboola.wr-db-mysql", zod.ZodObject<{
                     parameters: zod.ZodObject<{
@@ -7229,7 +7980,142 @@ declare const createClients: ({ baseUrl, token, clientServiceUrls, middlewares,
                         onlyEnabledCustomers: zod.ZodOptional<zod.ZodBoolean>;
                         getAccountChildren: zod.ZodOptional<zod.ZodBoolean>;
                     }, zod_v4_core.$strip>;
-                }, zod_v4_core.$strip>>)[ComponentId]>>;
+                }, zod_v4_core.$strip>> & Record<"keboola.ex-http", zod.ZodObject<{
+                    parameters: zod.ZodObject<{
+                        baseUrl: zod.ZodString;
+                        maxRedirects: zod.ZodOptional<zod.ZodNumber>;
+                    }, zod_v4_core.$loose>;
+                }, zod_v4_core.$loose>> & Record<"keboola.ex-ftp", zod.ZodObject<{
+                    parameters: zod.ZodUnion<readonly [zod.ZodObject<{
+                        host: zod.ZodString;
+                        port: zod.ZodNumber;
+                        connectionType: zod.ZodEnum<{
+                            FTP: "FTP";
+                            FTPS: "FTPS";
+                            SFTP: "SFTP";
+                        }>;
+                        username: zod.ZodString;
+                        ignorePassiveAddress: zod.ZodOptional<zod.ZodBoolean>;
+                        ssh: zod.ZodOptional<zod.ZodObject<{
+                            enabled: zod.ZodBoolean;
+                            sshHost: zod.ZodOptional<zod.ZodString>;
+                            user: zod.ZodOptional<zod.ZodString>;
+                            sshPort: zod.ZodOptional<zod.ZodNumber>;
+                            passivePortRange: zod.ZodOptional<zod.ZodString>;
+                            keys: zod.ZodOptional<zod.ZodObject<{
+                                public: zod.ZodOptional<zod.ZodString>;
+                                '#private': zod.ZodOptional<zod.ZodString>;
+                            }, zod_v4_core.$strip>>;
+                        }, zod_v4_core.$strip>>;
+                        path: zod.ZodOptional<zod.ZodString>;
+                        onlyNewFiles: zod.ZodOptional<zod.ZodBoolean>;
+                        '#password': zod.ZodString;
+                        '#privateKey': zod.ZodOptional<zod.ZodUndefined>;
+                    }, zod_v4_core.$loose>, zod.ZodObject<{
+                        host: zod.ZodString;
+                        port: zod.ZodNumber;
+                        connectionType: zod.ZodEnum<{
+                            FTP: "FTP";
+                            FTPS: "FTPS";
+                            SFTP: "SFTP";
+                        }>;
+                        username: zod.ZodString;
+                        ignorePassiveAddress: zod.ZodOptional<zod.ZodBoolean>;
+                        ssh: zod.ZodOptional<zod.ZodObject<{
+                            enabled: zod.ZodBoolean;
+                            sshHost: zod.ZodOptional<zod.ZodString>;
+                            user: zod.ZodOptional<zod.ZodString>;
+                            sshPort: zod.ZodOptional<zod.ZodNumber>;
+                            passivePortRange: zod.ZodOptional<zod.ZodString>;
+                            keys: zod.ZodOptional<zod.ZodObject<{
+                                public: zod.ZodOptional<zod.ZodString>;
+                                '#private': zod.ZodOptional<zod.ZodString>;
+                            }, zod_v4_core.$strip>>;
+                        }, zod_v4_core.$strip>>;
+                        path: zod.ZodOptional<zod.ZodString>;
+                        onlyNewFiles: zod.ZodOptional<zod.ZodBoolean>;
+                        '#privateKey': zod.ZodString;
+                        '#password': zod.ZodOptional<zod.ZodUndefined>;
+                    }, zod_v4_core.$loose>]>;
+                }, zod_v4_core.$loose>> & Record<"keboola.ex-ftp-csas", zod.ZodObject<{
+                    parameters: zod.ZodUnion<readonly [zod.ZodObject<{
+                        host: zod.ZodString;
+                        port: zod.ZodNumber;
+                        connectionType: zod.ZodEnum<{
+                            FTP: "FTP";
+                            FTPS: "FTPS";
+                            SFTP: "SFTP";
+                        }>;
+                        username: zod.ZodString;
+                        ignorePassiveAddress: zod.ZodOptional<zod.ZodBoolean>;
+                        ssh: zod.ZodOptional<zod.ZodObject<{
+                            enabled: zod.ZodBoolean;
+                            sshHost: zod.ZodOptional<zod.ZodString>;
+                            user: zod.ZodOptional<zod.ZodString>;
+                            sshPort: zod.ZodOptional<zod.ZodNumber>;
+                            passivePortRange: zod.ZodOptional<zod.ZodString>;
+                            keys: zod.ZodOptional<zod.ZodObject<{
+                                public: zod.ZodOptional<zod.ZodString>;
+                                '#private': zod.ZodOptional<zod.ZodString>;
+                            }, zod_v4_core.$strip>>;
+                        }, zod_v4_core.$strip>>;
+                        path: zod.ZodOptional<zod.ZodString>;
+                        onlyNewFiles: zod.ZodOptional<zod.ZodBoolean>;
+                        '#password': zod.ZodString;
+                        '#privateKey': zod.ZodOptional<zod.ZodUndefined>;
+                    }, zod_v4_core.$loose>, zod.ZodObject<{
+                        host: zod.ZodString;
+                        port: zod.ZodNumber;
+                        connectionType: zod.ZodEnum<{
+                            FTP: "FTP";
+                            FTPS: "FTPS";
+                            SFTP: "SFTP";
+                        }>;
+                        username: zod.ZodString;
+                        ignorePassiveAddress: zod.ZodOptional<zod.ZodBoolean>;
+                        ssh: zod.ZodOptional<zod.ZodObject<{
+                            enabled: zod.ZodBoolean;
+                            sshHost: zod.ZodOptional<zod.ZodString>;
+                            user: zod.ZodOptional<zod.ZodString>;
+                            sshPort: zod.ZodOptional<zod.ZodNumber>;
+                            passivePortRange: zod.ZodOptional<zod.ZodString>;
+                            keys: zod.ZodOptional<zod.ZodObject<{
+                                public: zod.ZodOptional<zod.ZodString>;
+                                '#private': zod.ZodOptional<zod.ZodString>;
+                            }, zod_v4_core.$strip>>;
+                        }, zod_v4_core.$strip>>;
+                        path: zod.ZodOptional<zod.ZodString>;
+                        onlyNewFiles: zod.ZodOptional<zod.ZodBoolean>;
+                        '#privateKey': zod.ZodString;
+                        '#password': zod.ZodOptional<zod.ZodUndefined>;
+                    }, zod_v4_core.$loose>]>;
+                }, zod_v4_core.$loose>> & Record<"keboola.ex-aws-s3", zod.ZodObject<{
+                    parameters: zod.ZodUnion<readonly [zod.ZodObject<{
+                        loginType: zod.ZodLiteral<"credentials">;
+                        accessKeyId: zod.ZodString;
+                        '#secretAccessKey': zod.ZodString;
+                        accountId: zod.ZodOptional<zod.ZodUndefined>;
+                        roleName: zod.ZodOptional<zod.ZodUndefined>;
+                    }, zod_v4_core.$loose>, zod.ZodObject<{
+                        loginType: zod.ZodLiteral<"role">;
+                        accountId: zod.ZodString;
+                        roleName: zod.ZodString;
+                        accessKeyId: zod.ZodOptional<zod.ZodUndefined>;
+                        '#secretAccessKey': zod.ZodOptional<zod.ZodUndefined>;
+                    }, zod_v4_core.$loose>]>;
+                }, zod_v4_core.$loose>> & Record<"kds-team.ex-azure-blob-storage-v2", zod.ZodObject<{
+                    parameters: zod.ZodObject<{
+                        account_name: zod.ZodString;
+                        '#account_key': zod.ZodString;
+                        container_name: zod.ZodString;
+                    }, zod_v4_core.$loose>;
+                }, zod_v4_core.$loose>> & Record<"kds-team.ex-azure-data-lake-gen2", zod.ZodObject<{
+                    parameters: zod.ZodObject<{
+                        account_name: zod.ZodString;
+                        '#account_key': zod.ZodString;
+                        file_system: zod.ZodString;
+                    }, zod_v4_core.$loose>;
+                }, zod_v4_core.$loose>>)[ComponentId]>>;
                 runnable: boolean;
                 error: zod.ZodError<unknown> | undefined;
             }>;
@@ -8111,7 +8997,142 @@ declare const createClients: ({ baseUrl, token, clientServiceUrls, middlewares,
                         onlyEnabledCustomers: zod.ZodOptional<zod.ZodBoolean>;
                         getAccountChildren: zod.ZodOptional<zod.ZodBoolean>;
                     }, zod_v4_core.$strip>;
-                }, zod_v4_core.$strip>>)[ComponentId]> extends infer T ? T extends zod.input<(Record<never, never> & Record<"keboola.wr-db-mysql", zod.ZodObject<{
+                }, zod_v4_core.$strip>> & Record<"keboola.ex-http", zod.ZodObject<{
+                    parameters: zod.ZodObject<{
+                        baseUrl: zod.ZodString;
+                        maxRedirects: zod.ZodOptional<zod.ZodNumber>;
+                    }, zod_v4_core.$loose>;
+                }, zod_v4_core.$loose>> & Record<"keboola.ex-ftp", zod.ZodObject<{
+                    parameters: zod.ZodUnion<readonly [zod.ZodObject<{
+                        host: zod.ZodString;
+                        port: zod.ZodNumber;
+                        connectionType: zod.ZodEnum<{
+                            FTP: "FTP";
+                            FTPS: "FTPS";
+                            SFTP: "SFTP";
+                        }>;
+                        username: zod.ZodString;
+                        ignorePassiveAddress: zod.ZodOptional<zod.ZodBoolean>;
+                        ssh: zod.ZodOptional<zod.ZodObject<{
+                            enabled: zod.ZodBoolean;
+                            sshHost: zod.ZodOptional<zod.ZodString>;
+                            user: zod.ZodOptional<zod.ZodString>;
+                            sshPort: zod.ZodOptional<zod.ZodNumber>;
+                            passivePortRange: zod.ZodOptional<zod.ZodString>;
+                            keys: zod.ZodOptional<zod.ZodObject<{
+                                public: zod.ZodOptional<zod.ZodString>;
+                                '#private': zod.ZodOptional<zod.ZodString>;
+                            }, zod_v4_core.$strip>>;
+                        }, zod_v4_core.$strip>>;
+                        path: zod.ZodOptional<zod.ZodString>;
+                        onlyNewFiles: zod.ZodOptional<zod.ZodBoolean>;
+                        '#password': zod.ZodString;
+                        '#privateKey': zod.ZodOptional<zod.ZodUndefined>;
+                    }, zod_v4_core.$loose>, zod.ZodObject<{
+                        host: zod.ZodString;
+                        port: zod.ZodNumber;
+                        connectionType: zod.ZodEnum<{
+                            FTP: "FTP";
+                            FTPS: "FTPS";
+                            SFTP: "SFTP";
+                        }>;
+                        username: zod.ZodString;
+                        ignorePassiveAddress: zod.ZodOptional<zod.ZodBoolean>;
+                        ssh: zod.ZodOptional<zod.ZodObject<{
+                            enabled: zod.ZodBoolean;
+                            sshHost: zod.ZodOptional<zod.ZodString>;
+                            user: zod.ZodOptional<zod.ZodString>;
+                            sshPort: zod.ZodOptional<zod.ZodNumber>;
+                            passivePortRange: zod.ZodOptional<zod.ZodString>;
+                            keys: zod.ZodOptional<zod.ZodObject<{
+                                public: zod.ZodOptional<zod.ZodString>;
+                                '#private': zod.ZodOptional<zod.ZodString>;
+                            }, zod_v4_core.$strip>>;
+                        }, zod_v4_core.$strip>>;
+                        path: zod.ZodOptional<zod.ZodString>;
+                        onlyNewFiles: zod.ZodOptional<zod.ZodBoolean>;
+                        '#privateKey': zod.ZodString;
+                        '#password': zod.ZodOptional<zod.ZodUndefined>;
+                    }, zod_v4_core.$loose>]>;
+                }, zod_v4_core.$loose>> & Record<"keboola.ex-ftp-csas", zod.ZodObject<{
+                    parameters: zod.ZodUnion<readonly [zod.ZodObject<{
+                        host: zod.ZodString;
+                        port: zod.ZodNumber;
+                        connectionType: zod.ZodEnum<{
+                            FTP: "FTP";
+                            FTPS: "FTPS";
+                            SFTP: "SFTP";
+                        }>;
+                        username: zod.ZodString;
+                        ignorePassiveAddress: zod.ZodOptional<zod.ZodBoolean>;
+                        ssh: zod.ZodOptional<zod.ZodObject<{
+                            enabled: zod.ZodBoolean;
+                            sshHost: zod.ZodOptional<zod.ZodString>;
+                            user: zod.ZodOptional<zod.ZodString>;
+                            sshPort: zod.ZodOptional<zod.ZodNumber>;
+                            passivePortRange: zod.ZodOptional<zod.ZodString>;
+                            keys: zod.ZodOptional<zod.ZodObject<{
+                                public: zod.ZodOptional<zod.ZodString>;
+                                '#private': zod.ZodOptional<zod.ZodString>;
+                            }, zod_v4_core.$strip>>;
+                        }, zod_v4_core.$strip>>;
+                        path: zod.ZodOptional<zod.ZodString>;
+                        onlyNewFiles: zod.ZodOptional<zod.ZodBoolean>;
+                        '#password': zod.ZodString;
+                        '#privateKey': zod.ZodOptional<zod.ZodUndefined>;
+                    }, zod_v4_core.$loose>, zod.ZodObject<{
+                        host: zod.ZodString;
+                        port: zod.ZodNumber;
+                        connectionType: zod.ZodEnum<{
+                            FTP: "FTP";
+                            FTPS: "FTPS";
+                            SFTP: "SFTP";
+                        }>;
+                        username: zod.ZodString;
+                        ignorePassiveAddress: zod.ZodOptional<zod.ZodBoolean>;
+                        ssh: zod.ZodOptional<zod.ZodObject<{
+                            enabled: zod.ZodBoolean;
+                            sshHost: zod.ZodOptional<zod.ZodString>;
+                            user: zod.ZodOptional<zod.ZodString>;
+                            sshPort: zod.ZodOptional<zod.ZodNumber>;
+                            passivePortRange: zod.ZodOptional<zod.ZodString>;
+                            keys: zod.ZodOptional<zod.ZodObject<{
+                                public: zod.ZodOptional<zod.ZodString>;
+                                '#private': zod.ZodOptional<zod.ZodString>;
+                            }, zod_v4_core.$strip>>;
+                        }, zod_v4_core.$strip>>;
+                        path: zod.ZodOptional<zod.ZodString>;
+                        onlyNewFiles: zod.ZodOptional<zod.ZodBoolean>;
+                        '#privateKey': zod.ZodString;
+                        '#password': zod.ZodOptional<zod.ZodUndefined>;
+                    }, zod_v4_core.$loose>]>;
+                }, zod_v4_core.$loose>> & Record<"keboola.ex-aws-s3", zod.ZodObject<{
+                    parameters: zod.ZodUnion<readonly [zod.ZodObject<{
+                        loginType: zod.ZodLiteral<"credentials">;
+                        accessKeyId: zod.ZodString;
+                        '#secretAccessKey': zod.ZodString;
+                        accountId: zod.ZodOptional<zod.ZodUndefined>;
+                        roleName: zod.ZodOptional<zod.ZodUndefined>;
+                    }, zod_v4_core.$loose>, zod.ZodObject<{
+                        loginType: zod.ZodLiteral<"role">;
+                        accountId: zod.ZodString;
+                        roleName: zod.ZodString;
+                        accessKeyId: zod.ZodOptional<zod.ZodUndefined>;
+                        '#secretAccessKey': zod.ZodOptional<zod.ZodUndefined>;
+                    }, zod_v4_core.$loose>]>;
+                }, zod_v4_core.$loose>> & Record<"kds-team.ex-azure-blob-storage-v2", zod.ZodObject<{
+                    parameters: zod.ZodObject<{
+                        account_name: zod.ZodString;
+                        '#account_key': zod.ZodString;
+                        container_name: zod.ZodString;
+                    }, zod_v4_core.$loose>;
+                }, zod_v4_core.$loose>> & Record<"kds-team.ex-azure-data-lake-gen2", zod.ZodObject<{
+                    parameters: zod.ZodObject<{
+                        account_name: zod.ZodString;
+                        '#account_key': zod.ZodString;
+                        file_system: zod.ZodString;
+                    }, zod_v4_core.$loose>;
+                }, zod_v4_core.$loose>>)[ComponentId]> extends infer T ? T extends zod.input<(Record<never, never> & Record<"keboola.wr-db-mysql", zod.ZodObject<{
                     parameters: zod.ZodObject<{
                         db: zod.ZodObject<{
                             host: zod.ZodString;
@@ -8987,7 +10008,142 @@ declare const createClients: ({ baseUrl, token, clientServiceUrls, middlewares,
                         onlyEnabledCustomers: zod.ZodOptional<zod.ZodBoolean>;
                         getAccountChildren: zod.ZodOptional<zod.ZodBoolean>;
                     }, zod_v4_core.$strip>;
-                }, zod_v4_core.$strip>>)[ComponentId]> ? T extends object ? { [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends object ? { [K_2 in keyof T_1]?: (T_1[K_2] extends infer T_2 ? T_2 extends T_1[K_2] ? T_2 extends object ? { [K_3 in keyof T_2]?: (T_2[K_3] extends infer T_3 ? T_3 extends T_2[K_3] ? T_3 extends object ? { [K_4 in keyof T_3]?: (T_3[K_4] extends infer T_4 ? T_4 extends T_3[K_4] ? T_4 extends object ? { [K_5 in keyof T_4]?: (T_4[K_5] extends infer T_5 ? T_5 extends T_4[K_5] ? T_5 extends object ? { [K_6 in keyof T_5]?: (T_5[K_6] extends infer T_6 ? T_6 extends T_5[K_6] ? T_6 extends object ? { [K_7 in keyof T_6]?: (T_6[K_7] extends infer T_7 ? T_7 extends T_6[K_7] ? T_7 extends object ? { [K_8 in keyof T_7]?: (T_7[K_8] extends infer T_8 ? T_8 extends T_7[K_8] ? T_8 extends object ? { [K_9 in keyof T_8]?: (T_8[K_9] extends infer T_9 ? T_9 extends T_8[K_9] ? T_9 extends object ? { [K_10 in keyof T_9]?: (T_9[K_10] extends infer T_10 ? T_10 extends T_9[K_10] ? T_10 extends object ? { [K_11 in keyof T_10]?: /*elided*/ any | undefined; } : T_10 : never : never) | undefined; } : T_9 : never : never) | undefined; } : T_8 : never : never) | undefined; } : T_7 : never : never) | undefined; } : T_6 : never : never) | undefined; } : T_5 : never : never) | undefined; } : T_4 : never : never) | undefined; } : T_3 : never : never) | undefined; } : T_2 : never : never) | undefined; } : T_1 : never : never) | undefined; } : T : never : never;
+                }, zod_v4_core.$strip>> & Record<"keboola.ex-http", zod.ZodObject<{
+                    parameters: zod.ZodObject<{
+                        baseUrl: zod.ZodString;
+                        maxRedirects: zod.ZodOptional<zod.ZodNumber>;
+                    }, zod_v4_core.$loose>;
+                }, zod_v4_core.$loose>> & Record<"keboola.ex-ftp", zod.ZodObject<{
+                    parameters: zod.ZodUnion<readonly [zod.ZodObject<{
+                        host: zod.ZodString;
+                        port: zod.ZodNumber;
+                        connectionType: zod.ZodEnum<{
+                            FTP: "FTP";
+                            FTPS: "FTPS";
+                            SFTP: "SFTP";
+                        }>;
+                        username: zod.ZodString;
+                        ignorePassiveAddress: zod.ZodOptional<zod.ZodBoolean>;
+                        ssh: zod.ZodOptional<zod.ZodObject<{
+                            enabled: zod.ZodBoolean;
+                            sshHost: zod.ZodOptional<zod.ZodString>;
+                            user: zod.ZodOptional<zod.ZodString>;
+                            sshPort: zod.ZodOptional<zod.ZodNumber>;
+                            passivePortRange: zod.ZodOptional<zod.ZodString>;
+                            keys: zod.ZodOptional<zod.ZodObject<{
+                                public: zod.ZodOptional<zod.ZodString>;
+                                '#private': zod.ZodOptional<zod.ZodString>;
+                            }, zod_v4_core.$strip>>;
+                        }, zod_v4_core.$strip>>;
+                        path: zod.ZodOptional<zod.ZodString>;
+                        onlyNewFiles: zod.ZodOptional<zod.ZodBoolean>;
+                        '#password': zod.ZodString;
+                        '#privateKey': zod.ZodOptional<zod.ZodUndefined>;
+                    }, zod_v4_core.$loose>, zod.ZodObject<{
+                        host: zod.ZodString;
+                        port: zod.ZodNumber;
+                        connectionType: zod.ZodEnum<{
+                            FTP: "FTP";
+                            FTPS: "FTPS";
+                            SFTP: "SFTP";
+                        }>;
+                        username: zod.ZodString;
+                        ignorePassiveAddress: zod.ZodOptional<zod.ZodBoolean>;
+                        ssh: zod.ZodOptional<zod.ZodObject<{
+                            enabled: zod.ZodBoolean;
+                            sshHost: zod.ZodOptional<zod.ZodString>;
+                            user: zod.ZodOptional<zod.ZodString>;
+                            sshPort: zod.ZodOptional<zod.ZodNumber>;
+                            passivePortRange: zod.ZodOptional<zod.ZodString>;
+                            keys: zod.ZodOptional<zod.ZodObject<{
+                                public: zod.ZodOptional<zod.ZodString>;
+                                '#private': zod.ZodOptional<zod.ZodString>;
+                            }, zod_v4_core.$strip>>;
+                        }, zod_v4_core.$strip>>;
+                        path: zod.ZodOptional<zod.ZodString>;
+                        onlyNewFiles: zod.ZodOptional<zod.ZodBoolean>;
+                        '#privateKey': zod.ZodString;
+                        '#password': zod.ZodOptional<zod.ZodUndefined>;
+                    }, zod_v4_core.$loose>]>;
+                }, zod_v4_core.$loose>> & Record<"keboola.ex-ftp-csas", zod.ZodObject<{
+                    parameters: zod.ZodUnion<readonly [zod.ZodObject<{
+                        host: zod.ZodString;
+                        port: zod.ZodNumber;
+                        connectionType: zod.ZodEnum<{
+                            FTP: "FTP";
+                            FTPS: "FTPS";
+                            SFTP: "SFTP";
+                        }>;
+                        username: zod.ZodString;
+                        ignorePassiveAddress: zod.ZodOptional<zod.ZodBoolean>;
+                        ssh: zod.ZodOptional<zod.ZodObject<{
+                            enabled: zod.ZodBoolean;
+                            sshHost: zod.ZodOptional<zod.ZodString>;
+                            user: zod.ZodOptional<zod.ZodString>;
+                            sshPort: zod.ZodOptional<zod.ZodNumber>;
+                            passivePortRange: zod.ZodOptional<zod.ZodString>;
+                            keys: zod.ZodOptional<zod.ZodObject<{
+                                public: zod.ZodOptional<zod.ZodString>;
+                                '#private': zod.ZodOptional<zod.ZodString>;
+                            }, zod_v4_core.$strip>>;
+                        }, zod_v4_core.$strip>>;
+                        path: zod.ZodOptional<zod.ZodString>;
+                        onlyNewFiles: zod.ZodOptional<zod.ZodBoolean>;
+                        '#password': zod.ZodString;
+                        '#privateKey': zod.ZodOptional<zod.ZodUndefined>;
+                    }, zod_v4_core.$loose>, zod.ZodObject<{
+                        host: zod.ZodString;
+                        port: zod.ZodNumber;
+                        connectionType: zod.ZodEnum<{
+                            FTP: "FTP";
+                            FTPS: "FTPS";
+                            SFTP: "SFTP";
+                        }>;
+                        username: zod.ZodString;
+                        ignorePassiveAddress: zod.ZodOptional<zod.ZodBoolean>;
+                        ssh: zod.ZodOptional<zod.ZodObject<{
+                            enabled: zod.ZodBoolean;
+                            sshHost: zod.ZodOptional<zod.ZodString>;
+                            user: zod.ZodOptional<zod.ZodString>;
+                            sshPort: zod.ZodOptional<zod.ZodNumber>;
+                            passivePortRange: zod.ZodOptional<zod.ZodString>;
+                            keys: zod.ZodOptional<zod.ZodObject<{
+                                public: zod.ZodOptional<zod.ZodString>;
+                                '#private': zod.ZodOptional<zod.ZodString>;
+                            }, zod_v4_core.$strip>>;
+                        }, zod_v4_core.$strip>>;
+                        path: zod.ZodOptional<zod.ZodString>;
+                        onlyNewFiles: zod.ZodOptional<zod.ZodBoolean>;
+                        '#privateKey': zod.ZodString;
+                        '#password': zod.ZodOptional<zod.ZodUndefined>;
+                    }, zod_v4_core.$loose>]>;
+                }, zod_v4_core.$loose>> & Record<"keboola.ex-aws-s3", zod.ZodObject<{
+                    parameters: zod.ZodUnion<readonly [zod.ZodObject<{
+                        loginType: zod.ZodLiteral<"credentials">;
+                        accessKeyId: zod.ZodString;
+                        '#secretAccessKey': zod.ZodString;
+                        accountId: zod.ZodOptional<zod.ZodUndefined>;
+                        roleName: zod.ZodOptional<zod.ZodUndefined>;
+                    }, zod_v4_core.$loose>, zod.ZodObject<{
+                        loginType: zod.ZodLiteral<"role">;
+                        accountId: zod.ZodString;
+                        roleName: zod.ZodString;
+                        accessKeyId: zod.ZodOptional<zod.ZodUndefined>;
+                        '#secretAccessKey': zod.ZodOptional<zod.ZodUndefined>;
+                    }, zod_v4_core.$loose>]>;
+                }, zod_v4_core.$loose>> & Record<"kds-team.ex-azure-blob-storage-v2", zod.ZodObject<{
+                    parameters: zod.ZodObject<{
+                        account_name: zod.ZodString;
+                        '#account_key': zod.ZodString;
+                        container_name: zod.ZodString;
+                    }, zod_v4_core.$loose>;
+                }, zod_v4_core.$loose>> & Record<"kds-team.ex-azure-data-lake-gen2", zod.ZodObject<{
+                    parameters: zod.ZodObject<{
+                        account_name: zod.ZodString;
+                        '#account_key': zod.ZodString;
+                        file_system: zod.ZodString;
+                    }, zod_v4_core.$loose>;
+                }, zod_v4_core.$loose>>)[ComponentId]> ? T extends object ? { [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends object ? { [K_2 in keyof T_1]?: (T_1[K_2] extends infer T_2 ? T_2 extends T_1[K_2] ? T_2 extends object ? { [K_3 in keyof T_2]?: (T_2[K_3] extends infer T_3 ? T_3 extends T_2[K_3] ? T_3 extends object ? { [K_4 in keyof T_3]?: (T_3[K_4] extends infer T_4 ? T_4 extends T_3[K_4] ? T_4 extends object ? { [K_5 in keyof T_4]?: (T_4[K_5] extends infer T_5 ? T_5 extends T_4[K_5] ? T_5 extends object ? { [K_6 in keyof T_5]?: (T_5[K_6] extends infer T_6 ? T_6 extends T_5[K_6] ? T_6 extends object ? { [K_7 in keyof T_6]?: (T_6[K_7] extends infer T_7 ? T_7 extends T_6[K_7] ? T_7 extends object ? { [K_8 in keyof T_7]?: (T_7[K_8] extends infer T_8 ? T_8 extends T_7[K_8] ? T_8 extends object ? { [K_9 in keyof T_8]?: (T_8[K_9] extends infer T_9 ? T_9 extends T_8[K_9] ? T_9 extends object ? { [K_10 in keyof T_9]?: (T_9[K_10] extends infer T_10 ? T_10 extends T_9[K_10] ? T_10 extends object ? { [K_11 in keyof T_10]?: /*elided*/ any | undefined; } : T_10 : never : never) | undefined; } : T_9 : never : never) | undefined; } : T_8 : never : never) | undefined; } : T_7 : never : never) | undefined; } : T_6 : never : never) | undefined; } : T_5 : never : never) | undefined; } : T_4 : never : never) | undefined; } : T_3 : never : never) | undefined; } : T_2 : never : never) | undefined; } : T_1 : never : never) | undefined; } : T : never : never;
             } & {
                 mode?: "replace" | "merge";
             }) => Promise<{
@@ -9867,7 +11023,142 @@ declare const createClients: ({ baseUrl, token, clientServiceUrls, middlewares,
                         onlyEnabledCustomers: zod.ZodOptional<zod.ZodBoolean>;
                         getAccountChildren: zod.ZodOptional<zod.ZodBoolean>;
                     }, zod_v4_core.$strip>;
-                }, zod_v4_core.$strip>>)[ComponentId]>>;
+                }, zod_v4_core.$strip>> & Record<"keboola.ex-http", zod.ZodObject<{
+                    parameters: zod.ZodObject<{
+                        baseUrl: zod.ZodString;
+                        maxRedirects: zod.ZodOptional<zod.ZodNumber>;
+                    }, zod_v4_core.$loose>;
+                }, zod_v4_core.$loose>> & Record<"keboola.ex-ftp", zod.ZodObject<{
+                    parameters: zod.ZodUnion<readonly [zod.ZodObject<{
+                        host: zod.ZodString;
+                        port: zod.ZodNumber;
+                        connectionType: zod.ZodEnum<{
+                            FTP: "FTP";
+                            FTPS: "FTPS";
+                            SFTP: "SFTP";
+                        }>;
+                        username: zod.ZodString;
+                        ignorePassiveAddress: zod.ZodOptional<zod.ZodBoolean>;
+                        ssh: zod.ZodOptional<zod.ZodObject<{
+                            enabled: zod.ZodBoolean;
+                            sshHost: zod.ZodOptional<zod.ZodString>;
+                            user: zod.ZodOptional<zod.ZodString>;
+                            sshPort: zod.ZodOptional<zod.ZodNumber>;
+                            passivePortRange: zod.ZodOptional<zod.ZodString>;
+                            keys: zod.ZodOptional<zod.ZodObject<{
+                                public: zod.ZodOptional<zod.ZodString>;
+                                '#private': zod.ZodOptional<zod.ZodString>;
+                            }, zod_v4_core.$strip>>;
+                        }, zod_v4_core.$strip>>;
+                        path: zod.ZodOptional<zod.ZodString>;
+                        onlyNewFiles: zod.ZodOptional<zod.ZodBoolean>;
+                        '#password': zod.ZodString;
+                        '#privateKey': zod.ZodOptional<zod.ZodUndefined>;
+                    }, zod_v4_core.$loose>, zod.ZodObject<{
+                        host: zod.ZodString;
+                        port: zod.ZodNumber;
+                        connectionType: zod.ZodEnum<{
+                            FTP: "FTP";
+                            FTPS: "FTPS";
+                            SFTP: "SFTP";
+                        }>;
+                        username: zod.ZodString;
+                        ignorePassiveAddress: zod.ZodOptional<zod.ZodBoolean>;
+                        ssh: zod.ZodOptional<zod.ZodObject<{
+                            enabled: zod.ZodBoolean;
+                            sshHost: zod.ZodOptional<zod.ZodString>;
+                            user: zod.ZodOptional<zod.ZodString>;
+                            sshPort: zod.ZodOptional<zod.ZodNumber>;
+                            passivePortRange: zod.ZodOptional<zod.ZodString>;
+                            keys: zod.ZodOptional<zod.ZodObject<{
+                                public: zod.ZodOptional<zod.ZodString>;
+                                '#private': zod.ZodOptional<zod.ZodString>;
+                            }, zod_v4_core.$strip>>;
+                        }, zod_v4_core.$strip>>;
+                        path: zod.ZodOptional<zod.ZodString>;
+                        onlyNewFiles: zod.ZodOptional<zod.ZodBoolean>;
+                        '#privateKey': zod.ZodString;
+                        '#password': zod.ZodOptional<zod.ZodUndefined>;
+                    }, zod_v4_core.$loose>]>;
+                }, zod_v4_core.$loose>> & Record<"keboola.ex-ftp-csas", zod.ZodObject<{
+                    parameters: zod.ZodUnion<readonly [zod.ZodObject<{
+                        host: zod.ZodString;
+                        port: zod.ZodNumber;
+                        connectionType: zod.ZodEnum<{
+                            FTP: "FTP";
+                            FTPS: "FTPS";
+                            SFTP: "SFTP";
+                        }>;
+                        username: zod.ZodString;
+                        ignorePassiveAddress: zod.ZodOptional<zod.ZodBoolean>;
+                        ssh: zod.ZodOptional<zod.ZodObject<{
+                            enabled: zod.ZodBoolean;
+                            sshHost: zod.ZodOptional<zod.ZodString>;
+                            user: zod.ZodOptional<zod.ZodString>;
+                            sshPort: zod.ZodOptional<zod.ZodNumber>;
+                            passivePortRange: zod.ZodOptional<zod.ZodString>;
+                            keys: zod.ZodOptional<zod.ZodObject<{
+                                public: zod.ZodOptional<zod.ZodString>;
+                                '#private': zod.ZodOptional<zod.ZodString>;
+                            }, zod_v4_core.$strip>>;
+                        }, zod_v4_core.$strip>>;
+                        path: zod.ZodOptional<zod.ZodString>;
+                        onlyNewFiles: zod.ZodOptional<zod.ZodBoolean>;
+                        '#password': zod.ZodString;
+                        '#privateKey': zod.ZodOptional<zod.ZodUndefined>;
+                    }, zod_v4_core.$loose>, zod.ZodObject<{
+                        host: zod.ZodString;
+                        port: zod.ZodNumber;
+                        connectionType: zod.ZodEnum<{
+                            FTP: "FTP";
+                            FTPS: "FTPS";
+                            SFTP: "SFTP";
+                        }>;
+                        username: zod.ZodString;
+                        ignorePassiveAddress: zod.ZodOptional<zod.ZodBoolean>;
+                        ssh: zod.ZodOptional<zod.ZodObject<{
+                            enabled: zod.ZodBoolean;
+                            sshHost: zod.ZodOptional<zod.ZodString>;
+                            user: zod.ZodOptional<zod.ZodString>;
+                            sshPort: zod.ZodOptional<zod.ZodNumber>;
+                            passivePortRange: zod.ZodOptional<zod.ZodString>;
+                            keys: zod.ZodOptional<zod.ZodObject<{
+                                public: zod.ZodOptional<zod.ZodString>;
+                                '#private': zod.ZodOptional<zod.ZodString>;
+                            }, zod_v4_core.$strip>>;
+                        }, zod_v4_core.$strip>>;
+                        path: zod.ZodOptional<zod.ZodString>;
+                        onlyNewFiles: zod.ZodOptional<zod.ZodBoolean>;
+                        '#privateKey': zod.ZodString;
+                        '#password': zod.ZodOptional<zod.ZodUndefined>;
+                    }, zod_v4_core.$loose>]>;
+                }, zod_v4_core.$loose>> & Record<"keboola.ex-aws-s3", zod.ZodObject<{
+                    parameters: zod.ZodUnion<readonly [zod.ZodObject<{
+                        loginType: zod.ZodLiteral<"credentials">;
+                        accessKeyId: zod.ZodString;
+                        '#secretAccessKey': zod.ZodString;
+                        accountId: zod.ZodOptional<zod.ZodUndefined>;
+                        roleName: zod.ZodOptional<zod.ZodUndefined>;
+                    }, zod_v4_core.$loose>, zod.ZodObject<{
+                        loginType: zod.ZodLiteral<"role">;
+                        accountId: zod.ZodString;
+                        roleName: zod.ZodString;
+                        accessKeyId: zod.ZodOptional<zod.ZodUndefined>;
+                        '#secretAccessKey': zod.ZodOptional<zod.ZodUndefined>;
+                    }, zod_v4_core.$loose>]>;
+                }, zod_v4_core.$loose>> & Record<"kds-team.ex-azure-blob-storage-v2", zod.ZodObject<{
+                    parameters: zod.ZodObject<{
+                        account_name: zod.ZodString;
+                        '#account_key': zod.ZodString;
+                        container_name: zod.ZodString;
+                    }, zod_v4_core.$loose>;
+                }, zod_v4_core.$loose>> & Record<"kds-team.ex-azure-data-lake-gen2", zod.ZodObject<{
+                    parameters: zod.ZodObject<{
+                        account_name: zod.ZodString;
+                        '#account_key': zod.ZodString;
+                        file_system: zod.ZodString;
+                    }, zod_v4_core.$loose>;
+                }, zod_v4_core.$loose>>)[ComponentId]>>;
                 runnable: boolean;
                 error: zod.ZodError<unknown> | undefined;
             }>;
@@ -9875,13 +11166,34 @@ declare const createClients: ({ baseUrl, token, clientServiceUrls, middlewares,
         tag: {
             getTags: (signal?: AbortSignal) => Promise<TagWithBindings[]>;
             getTagsByObjectId: (objectId: KeboolaObjectId, signal?: AbortSignal) => Promise<TagWithBindings[]>;
-            createTag: (data: TagData, meta?: CreateMetaObjectMetaDataInput) => Promise<MetaObject<TagData, false>>;
-            updateTag: (tagUUID: string, data: TagData, meta?: UpdateMetaObjectMetaDataInput) => Promise<MetaObject<TagData, false>>;
+            createTag: (data: TagData, meta?: CreateMetaObjectMetaDataInput) => Promise<MetaObject<TagData>>;
+            updateTag: (tagUUID: string, data: TagData, meta?: UpdateMetaObjectMetaDataInput) => Promise<MetaObject<TagData>>;
             deleteTag: (tagUUID: string) => Promise<void>;
             assignTags: (tagUUIDs: string[], objectId: KeboolaObjectId, meta?: CreateMetaObjectMetaDataInput) => Promise<void>;
             unassignTags: (tagUUIDs: string[], objectID: KeboolaObjectId) => Promise<void>;
             unassignAllTags: (objectID: KeboolaObjectId, signal?: AbortSignal) => Promise<void>;
-            createAndAssignTag: (data: TagData, objectId: KeboolaObjectId, meta?: CreateMetaObjectMetaDataInput) => Promise<MetaObject<TagData, false>>;
+            createAndAssignTag: (data: TagData, objectId: KeboolaObjectId, meta?: CreateMetaObjectMetaDataInput) => Promise<MetaObject<TagData>>;
+        };
+        semanticLayer: {
+            listModels: (signal?: AbortSignal) => Promise<SemanticObject<SemanticModelData>[]>;
+            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;
+            }[]>;
+            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]>>;
+            createObjects: <T extends SemanticChildObjectType>(objectType: T, items: SemanticChildObjectDataMap[T][], meta?: CreateSemanticObjectMeta) => Promise<SemanticObject<SemanticChildObjectDataMap[T]>[]>;
+            createModelTree: (model: SemanticModelData, children: Partial<{ [T in SemanticChildObjectType]: Omit<SemanticChildObjectDataMap[T], "modelUUID">[]; }>, meta?: CreateSemanticObjectMeta) => Promise<{
+                model: SemanticObject<SemanticModelData>;
+                children: SemanticObject<SemanticDatasetData | SemanticMetricData | SemanticRelationshipData | SemanticGlossaryData | SemanticConstraintData>[];
+            }>;
+            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>;
         };
         storage: {
             createTable: (bucketId: string, body: CreateTableAsyncBody, options?: {
@@ -10843,7 +12155,6 @@ declare const createClients: ({ baseUrl, token, clientServiceUrls, middlewares,
             autoSuspendAfterSeconds?: number;
             autoRestartEnabled?: boolean;
             size?: string | null;
-            provisioningStrategy: "jobQueue" | "operator";
             hasManagedGitRepo?: boolean;
         }[]>;
         getApp: (appId: GetDataAppPath["appId"], signal?: AbortSignal) => Promise<{
@@ -10863,7 +12174,6 @@ declare const createClients: ({ baseUrl, token, clientServiceUrls, middlewares,
             autoSuspendAfterSeconds?: number;
             autoRestartEnabled?: boolean;
             size?: string | null;
-            provisioningStrategy: "jobQueue" | "operator";
             hasManagedGitRepo?: boolean;
         }>;
         createApp: (body: CreateDataAppBody, signal?: AbortSignal) => Promise<{
@@ -10883,7 +12193,6 @@ declare const createClients: ({ baseUrl, token, clientServiceUrls, middlewares,
             autoSuspendAfterSeconds?: number;
             autoRestartEnabled?: boolean;
             size?: string | null;
-            provisioningStrategy: "jobQueue" | "operator";
             hasManagedGitRepo?: boolean;
         }>;
         patchApp: (appId: PatchDataAppPath["appId"], body: PatchDataAppBody, signal?: AbortSignal) => Promise<{
@@ -10903,7 +12212,6 @@ declare const createClients: ({ baseUrl, token, clientServiceUrls, middlewares,
             autoSuspendAfterSeconds?: number;
             autoRestartEnabled?: boolean;
             size?: string | null;
-            provisioningStrategy: "jobQueue" | "operator";
             hasManagedGitRepo?: boolean;
         }>;
         deleteApp: (appId: DeleteDataAppPath["appId"], signal?: AbortSignal) => Promise<ApiResponse<never>>;
@@ -10927,7 +12235,6 @@ declare const createClients: ({ baseUrl, token, clientServiceUrls, middlewares,
             autoSuspendAfterSeconds?: number;
             autoRestartEnabled?: boolean;
             size?: string | null;
-            provisioningStrategy: "jobQueue" | "operator";
             hasManagedGitRepo?: boolean;
         }>;
         getRuntimes: (signal?: AbortSignal) => Promise<{
@@ -11395,42 +12702,242 @@ declare const createClients: ({ baseUrl, token, clientServiceUrls, middlewares,
             previousJobId?: string | null;
             onlyOrchestrationTaskIds?: string[] | null;
         }[]>;
-    };
-    chat: {
-        getHistory: (params?: GetHistoryQuery$1) => Promise<{
-            chats: components$3["schemas"]["Chat"][];
-            hasMore: boolean;
-        }>;
-        getChat: (chatId: GetChatPath$1["id"], signal?: AbortSignal) => Promise<{
-            id: string;
-            title: string;
-            userId: string;
-            createdAt: string;
-            lastMessageAt: string;
-            visibility: "public" | "private";
-            branchId?: number | null;
-            contextWindow?: {
-                usedTokens: number;
-                maxTokens: number;
-                percentage: number;
-            } | null;
-            messages: components$3["schemas"]["Message"][];
-        }>;
-        deleteChat: (chatId: string) => Promise<{
+        searchAllJobs: (query: SearchAllJobsQuery, signal?: AbortSignal) => Promise<{
             id: string;
-            title: string;
-            userId: string;
-            createdAt: string;
-            lastMessageAt: string;
-            visibility: "public" | "private";
-            branchId?: number | null;
-        }>;
-        createChat: (request: ChatRequest$1) => Promise<Response>;
-        getVotes: (chatId: GetVotesQuery$1["chatId"]) => Promise<{
-            chatId: string;
-            messageId: string;
-            isUpvoted: boolean;
-        }[]>;
+            runId: string;
+            branchId?: string;
+            project: {
+                id: string;
+            };
+            token: {
+                id?: string;
+                description?: string;
+            };
+            status: components$2["schemas"]["JobStatus"];
+            desiredStatus?: "processing" | "terminating" | null;
+            component: string;
+            mode: "run" | "debug";
+            tag?: string | null;
+            config?: string | null;
+            configRow?: string | null;
+            configData?: Record<string, never> | null;
+            result?: {
+                images?: {
+                    digests?: string[];
+                    id?: string;
+                }[];
+                configVersion?: number;
+                message?: string;
+            } | null;
+            createdTime: string;
+            startTime?: string | null;
+            endTime?: string | null;
+            delayedStartTime?: string | null;
+            durationSeconds?: number | null;
+            isFinished: boolean;
+            url: string;
+            variableValuesId?: string | null;
+            variableValuesData?: {
+                values?: {
+                    name?: string;
+                    value?: string;
+                }[];
+            } | null;
+            backend?: {
+                type?: string;
+                containerType?: string;
+                context?: string;
+            } | null;
+            metrics?: {
+                storage?: {
+                    inputTablesBytesSum?: number;
+                    outputTablesBytesSum?: number;
+                };
+                backend?: {
+                    type?: string;
+                    containerType?: string;
+                    context?: string;
+                };
+            } | null;
+            type?: components$2["schemas"]["JobType"];
+            orchestrationTaskId?: string | null;
+            previousJobId?: string | null;
+            onlyOrchestrationTaskIds?: string[] | null;
+        }[]>;
+        createJob: (body: CreateJobBody, signal?: AbortSignal) => Promise<{
+            id: string;
+            runId: string;
+            branchId?: string;
+            project: {
+                id: string;
+            };
+            token: {
+                id?: string;
+                description?: string;
+            };
+            status: components$2["schemas"]["JobStatus"];
+            desiredStatus?: "processing" | "terminating" | null;
+            component: string;
+            mode: "run" | "debug";
+            tag?: string | null;
+            config?: string | null;
+            configRow?: string | null;
+            configData?: Record<string, never> | null;
+            result?: {
+                images?: {
+                    digests?: string[];
+                    id?: string;
+                }[];
+                configVersion?: number;
+                message?: string;
+            } | null;
+            createdTime: string;
+            startTime?: string | null;
+            endTime?: string | null;
+            delayedStartTime?: string | null;
+            durationSeconds?: number | null;
+            isFinished: boolean;
+            url: string;
+            variableValuesId?: string | null;
+            variableValuesData?: {
+                values?: {
+                    name?: string;
+                    value?: string;
+                }[];
+            } | null;
+            backend?: {
+                type?: string;
+                containerType?: string;
+                context?: string;
+            } | null;
+            metrics?: {
+                storage?: {
+                    inputTablesBytesSum?: number;
+                    outputTablesBytesSum?: number;
+                };
+                backend?: {
+                    type?: string;
+                    containerType?: string;
+                    context?: string;
+                };
+            } | null;
+            type?: components$2["schemas"]["JobType"];
+            orchestrationTaskId?: string | null;
+            previousJobId?: string | null;
+            onlyOrchestrationTaskIds?: string[] | null;
+        }>;
+        killJob: (jobId: KillJobPath["jobId"], signal?: AbortSignal) => Promise<{
+            id: string;
+            runId: string;
+            branchId?: string;
+            project: {
+                id: string;
+            };
+            token: {
+                id?: string;
+                description?: string;
+            };
+            status: components$2["schemas"]["JobStatus"];
+            desiredStatus?: "processing" | "terminating" | null;
+            component: string;
+            mode: "run" | "debug";
+            tag?: string | null;
+            config?: string | null;
+            configRow?: string | null;
+            configData?: Record<string, never> | null;
+            result?: {
+                images?: {
+                    digests?: string[];
+                    id?: string;
+                }[];
+                configVersion?: number;
+                message?: string;
+            } | null;
+            createdTime: string;
+            startTime?: string | null;
+            endTime?: string | null;
+            delayedStartTime?: string | null;
+            durationSeconds?: number | null;
+            isFinished: boolean;
+            url: string;
+            variableValuesId?: string | null;
+            variableValuesData?: {
+                values?: {
+                    name?: string;
+                    value?: string;
+                }[];
+            } | null;
+            backend?: {
+                type?: string;
+                containerType?: string;
+                context?: string;
+            } | null;
+            metrics?: {
+                storage?: {
+                    inputTablesBytesSum?: number;
+                    outputTablesBytesSum?: number;
+                };
+                backend?: {
+                    type?: string;
+                    containerType?: string;
+                    context?: string;
+                };
+            } | null;
+            type?: components$2["schemas"]["JobType"];
+            orchestrationTaskId?: string | null;
+            previousJobId?: string | null;
+            onlyOrchestrationTaskIds?: string[] | null;
+        }>;
+        searchGroupedJobs: (query: SearchGroupedJobsQuery, signal?: AbortSignal) => Promise<{
+            group?: {
+                [key: string]: string;
+            };
+            jobs?: components$2["schemas"]["Job"][];
+        }[]>;
+        getOrchestrationRerunPlan: (jobId: OrchestrationRerunPlanPath["jobId"], signal?: AbortSignal) => Promise<{
+            jobId?: string;
+            configId?: string | null;
+            matchedTasks?: {
+                taskId?: string;
+                matched?: boolean;
+                jobId?: string | null;
+                componentId?: string | null;
+                configId?: string | null;
+                status?: components$2["schemas"]["JobStatus"] & unknown;
+            }[];
+        }>;
+    };
+    chat: {
+        getHistory: (params?: GetHistoryQuery$1) => Promise<{
+            chats: components$3["schemas"]["Chat"][];
+            hasMore: boolean;
+        }>;
+        getChat: (chatId: GetChatPath$1["id"], signal?: AbortSignal) => Promise<{
+            id: string;
+            title: string;
+            userId: string;
+            createdAt: string;
+            lastMessageAt: string;
+            visibility: "public" | "private";
+            branchId?: number | null;
+            contextWindow?: {
+                usedTokens: number;
+                maxTokens: number;
+                percentage: number;
+            } | null;
+            messages: components$3["schemas"]["Message"][];
+        }>;
+        deleteChat: (chatId: string) => Promise<{
+            id: string;
+            title: string;
+            userId: string;
+            createdAt: string;
+            lastMessageAt: string;
+            visibility: "public" | "private";
+            branchId?: number | null;
+        }>;
+        createChat: (request: ChatRequest$1) => Promise<Response>;
+        getVotes: (chatId: GetVotesQuery$1["chatId"]) => Promise<Vote[]>;
         submitVote: (params: VoteRequest$1) => Promise<void>;
         getUsage: (signal?: AbortSignal) => Promise<UsageResponse$1>;
         getSuggestions: (request: SuggestionsRequestBody, signal?: AbortSignal) => Promise<SuggestionsApiResponse>;
@@ -11483,6 +12990,7 @@ declare const createClients: ({ baseUrl, token, clientServiceUrls, middlewares,
             rootConfigurationExamples: Record<string, never>[] | null;
             rowConfigurationExamples: Record<string, never>[] | null;
             componentFlags: string[] | null;
+            synchronousActions?: string[] | null;
         }>;
     };
     import: {
@@ -11509,6 +13017,11 @@ declare const createClients: ({ baseUrl, token, clientServiceUrls, middlewares,
             lastMessageAt: string;
             visibility: "public" | "private";
             branchId?: number | null;
+            contextWindow?: {
+                usedTokens: number;
+                maxTokens: number;
+                percentage: number;
+            } | null;
             messages: {
                 id: string;
                 role: "user" | "assistant";
@@ -11636,7 +13149,7 @@ declare const createClients: ({ baseUrl, token, clientServiceUrls, middlewares,
             skills: {
                 name: string;
                 description: string | null;
-                source: "first-party" | "vendored" | "project";
+                source: "project" | "first-party" | "vendored";
             }[];
             commands: {
                 name: string;
@@ -11663,9 +13176,9 @@ declare const createClients: ({ baseUrl, token, clientServiceUrls, middlewares,
         chatStreamUrl: string;
     };
     oauth: {
-        getCredentials: (query?: GetCredentialsQuery, signal?: AbortSignal) => Promise<Credential[]>;
-        getCredential: (componentId: string, id: string, signal?: AbortSignal) => Promise<Credential>;
-        createCredential: (componentId: string, body: CreateCredentialBody, signal?: AbortSignal) => Promise<Credential>;
+        getCredentials: (query?: GetCredentialsQuery, signal?: AbortSignal) => Promise<Credential$1[]>;
+        getCredential: (componentId: string, id: string, signal?: AbortSignal) => Promise<Credential$1>;
+        createCredential: (componentId: string, body: CreateCredentialBody, signal?: AbortSignal) => Promise<Credential$1>;
         deleteCredential: (componentId: string, id: string, signal?: AbortSignal) => Promise<void>;
     };
     scheduler: {
@@ -11735,6 +13248,7 @@ declare const createClients: ({ baseUrl, token, clientServiceUrls, middlewares,
         deleteSchedule: (scheduleId: SchedulePath["scheduleId"], signal?: AbortSignal) => Promise<void>;
         refreshScheduleToken: (scheduleId: SchedulePath["scheduleId"], signal?: AbortSignal) => Promise<void>;
         deleteSchedulesForConfiguration: (configurationId: ConfigurationPath$1["configurationId"], signal?: AbortSignal) => Promise<void>;
+        deleteSchedulesForConfigurations: (configurationIds: ConfigurationPath$1["configurationId"][], signal?: AbortSignal) => Promise<void>;
     };
     stream: {
         getSources: (branchId: string, query?: PaginationQuery, signal?: AbortSignal) => Promise<{
@@ -12079,126 +13593,86 @@ declare const createClients: ({ baseUrl, token, clientServiceUrls, middlewares,
     };
     notifications: {
         getSubscriptions: (query?: ListSubscriptionsQuery, signal?: AbortSignal) => Promise<({
-            id?: components$6["schemas"]["NumericString"];
+            id: components$6["schemas"]["NumericString"];
         } & {
             event: components$6["schemas"]["EventName"];
             expiresAt?: string;
-            projectId: string;
             filters?: {
-                field?: string;
-                value?: string | number | boolean;
+                field: string;
+                value: string | number | boolean;
+                operator?: "==" | ">=";
             }[];
             recipient: components$6["schemas"]["RecipientChannel_Email"] | components$6["schemas"]["RecipientChannel_Webhook"];
         })[]>;
-        getSubscription: (subscriptionId: GetSubscriptionPath["subscriptionId"], signal?: AbortSignal) => Promise<{
-            id?: components$6["schemas"]["NumericString"];
+        getSubscription: (subscriptionId: SubscriptionId, signal?: AbortSignal) => Promise<{
+            id: components$6["schemas"]["NumericString"];
         } & {
             event: components$6["schemas"]["EventName"];
             expiresAt?: string;
-            projectId: string;
             filters?: {
-                field?: string;
-                value?: string | number | boolean;
+                field: string;
+                value: string | number | boolean;
+                operator?: "==" | ">=";
             }[];
             recipient: components$6["schemas"]["RecipientChannel_Email"] | components$6["schemas"]["RecipientChannel_Webhook"];
         }>;
         createSubscription: (body: CreateSubscriptionBody, signal?: AbortSignal) => Promise<{
-            id?: components$6["schemas"]["NumericString"];
+            id: components$6["schemas"]["NumericString"];
         } & {
             event: components$6["schemas"]["EventName"];
             expiresAt?: string;
-            projectId: string;
             filters?: {
-                field?: string;
-                value?: string | number | boolean;
+                field: string;
+                value: string | number | boolean;
+                operator?: "==" | ">=";
             }[];
             recipient: components$6["schemas"]["RecipientChannel_Email"] | components$6["schemas"]["RecipientChannel_Webhook"];
         }>;
-        deleteSubscription: (subscriptionId: DeleteSubscriptionPath["subscriptionId"], signal?: AbortSignal) => Promise<void>;
+        createSubscriptions: (bodies: CreateSubscriptionBody[], signal?: AbortSignal) => Promise<({
+            id: components$6["schemas"]["NumericString"];
+        } & {
+            event: components$6["schemas"]["EventName"];
+            expiresAt?: string;
+            filters?: {
+                field: string;
+                value: string | number | boolean;
+                operator?: "==" | ">=";
+            }[];
+            recipient: components$6["schemas"]["RecipientChannel_Email"] | components$6["schemas"]["RecipientChannel_Webhook"];
+        })[]>;
+        deleteSubscription: (subscriptionId: SubscriptionId, signal?: AbortSignal) => Promise<void>;
+        deleteSubscriptions: (subscriptionIds: SubscriptionId[], signal?: AbortSignal) => Promise<void>;
     };
     metastore: {
         healthCheck: (signal?: AbortSignal) => Promise<{
-            service?: string;
-            status?: string;
-            timestamp?: string;
-            version?: string;
+            [key: string]: string;
         }>;
         repository: {
-            getMetaObjects: <TData extends Record<string, unknown>, TDataOptional extends boolean = false>(input: GetMetaObjectsPath, signal?: AbortSignal) => Promise<MetaStoreListResponse<TData, TDataOptional>>;
-            getMetaObjectRevisions: <TData extends Record<string, unknown>, TDataOptional extends boolean = false>(input: GetMetaObjectRevisionsPath, signal?: AbortSignal) => Promise<MetaStoreListResponse<TData, TDataOptional>>;
-            getMetaObject: <TData extends Record<string, unknown>, TDataOptional extends boolean = false>(input: GetMetaObjectPath, signal?: AbortSignal) => Promise<MetaStoreObjectResponse<TData, TDataOptional>>;
-            createMetaObject: <TData extends Record<string, unknown>, TDataOptional extends boolean = false>({ objectType, data, ...body }: CreateMetaObjectInput<TData>) => Promise<MetaStoreObjectResponse<TData, TDataOptional>>;
+            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>>;
+            getMetaObject: <TData extends Record<string, unknown>>(input: GetMetaObjectPath, signal?: AbortSignal) => Promise<MetaStoreObjectResponse<TData>>;
+            createMetaObject: <TData extends Record<string, unknown>>({ objectType, data, ...body }: CreateMetaObjectInput<TData>) => Promise<MetaStoreObjectResponse<TData>>;
             deleteMetaObject: (input: DeleteMetaObjectPath) => Promise<never>;
-            updateMetaObject: <TData extends Record<string, unknown>, TDataOptional extends boolean = false>({ objectType, UUID, data, ...body }: UpdateMetaObjectInput<TData>) => Promise<MetaStoreObjectResponse<TData, TDataOptional>>;
-            replaceMetaObject: <TData extends Record<string, unknown>, TDataOptional extends boolean = false>({ objectType, UUID, data, ...body }: ReplaceMetaObjectInput<TData>) => Promise<MetaStoreObjectResponse<TData, TDataOptional>>;
-            getMetaObjectRevision: <TData extends Record<string, unknown>, TDataOptional extends boolean = false>(input: GetMetaObjectRevisionPath, signal?: AbortSignal) => Promise<MetaStoreObjectResponse<TData, TDataOptional>>;
+            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>>;
+            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<{
-                createdAt?: string;
-                createdBy?: components$7["schemas"]["models.JSONData"];
-                description?: string;
-                id?: string;
-                isDefault?: boolean;
-                objectType?: string;
-                schema?: components$7["schemas"]["models.JSONData"];
-                updatedAt?: string;
-                version?: string;
+                versions?: components$7["schemas"]["models.SchemaInfo"][];
             }>;
             getVersionedSchema: (input: GetVersionedSchemaPath, signal?: AbortSignal) => Promise<{
-                createdAt?: string;
-                createdBy?: components$7["schemas"]["models.JSONData"];
-                description?: string;
-                id?: string;
-                isDefault?: boolean;
-                objectType?: string;
-                schema?: components$7["schemas"]["models.JSONData"];
-                updatedAt?: string;
-                version?: string;
+                [key: string]: unknown;
             }>;
         };
     };
-    context: {
-        stack: {
-            services: Service[];
-            features: string[];
-            components: StackComponent[];
-            hasFeature: (...feature: string[]) => boolean;
-            getServiceUrl: (serviceId: ServiceId) => string | null;
-            hasService: (serviceId: ServiceId) => boolean;
-            getComponent: (componentId: string) => StackComponent | null;
-            hasComponent: (...componentId: string[]) => boolean;
-            api: string;
-            documentation: string;
-            host: string;
-            revision: string;
-            stack: string;
-            urlTemplates: {
-                orchestrationJob: string;
-            };
-            version: string;
-        };
-        defaultBranch: {
-            id: number;
-            name: string;
-            getType: (branchId?: string | number) => "default" | "dev";
-            isDev: (branchId?: string | number) => boolean;
-            isDefault: (branchId?: string | number) => boolean;
-        };
-        readonly project: {
-            hasFeature: (...feature: string[]) => boolean;
-            hasAdminFeature: (...feature: string[]) => boolean;
-            hasBackend: (backend: Backend) => boolean;
-            sapiToken: StorageToken;
-        };
-        readonly st: StorageTable;
-        serviceMeta: {
-            clientName: string;
-            serviceId: ServiceId;
-            isAvailable: boolean;
-        }[];
-    };
+    context: ClientContext;
+    serviceMeta: {
+        clientName: string;
+        serviceId: ServiceId;
+        isAvailable: boolean;
+    }[];
     storage: {
         buckets: {
             getBuckets: (branchId: string, query?: GetBucketsQuery, signal?: AbortSignal) => Promise<Bucket[]>;
@@ -13440,7 +14914,7 @@ declare const createClients: ({ baseUrl, token, clientServiceUrls, middlewares,
                 startTime?: string | null;
                 endTime?: string | null;
                 runId: string;
-                results?: components$8["schemas"]["BucketListingUpdateJobResponse"] | components$8["schemas"]["BucketListingCreateJobResult"] | components$8["schemas"]["BucketListingDeleteResponse"] | components$8["schemas"]["RefreshJobResponse"] | components$8["schemas"]["FileDeleteResponse"] | components$8["schemas"]["TableSnapshotCreateJobResult"] | components$8["schemas"]["TableSwapResult"] | components$8["schemas"]["TableCreateResponse"] | components$8["schemas"]["TableExportJobResponse"];
+                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"];
                 creatorToken: {
                     id?: string;
                     description?: string;
@@ -13489,6 +14963,8 @@ declare const createClients: ({ baseUrl, token, clientServiceUrls, middlewares,
                 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>[];
@@ -13551,9 +15027,14 @@ declare const createClients: ({ baseUrl, token, clientServiceUrls, middlewares,
             })>;
             getConfigurationWorkspaces: ({ componentId, branchId, configId, }: ConfigurationPath) => Promise<Workspace[]>;
         };
+        configurationMetadata: {
+            saveConfigurationMetadata: ({ branchId, componentId, configId, ...body }: SaveConfigurationMetadataInput) => Promise<ConfigurationMetadataItem[]>;
+        };
         configurationVersions: {
-            listConfigurationVersions: ({ branchId, componentId, configId }: ConfigurationVersionPath, signal?: AbortSignal) => Promise<ConfigurationVersion[]>;
+            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>>>;
         };
         tokens: {
             verify: (signal?: AbortSignal) => Promise<StorageToken>;
@@ -13680,770 +15161,18 @@ declare const createClients: ({ baseUrl, token, clientServiceUrls, middlewares,
         };
         getStackInfo: (query?: GetStackInfoQuery, signal?: AbortSignal) => Promise<StackInfo>;
     };
-    management: {
-        currentUser: {
-            getMaintainerInvitations: (signal?: AbortSignal) => Promise<{
-                id: number;
-                created: string;
-                maintainer: {
-                    id?: number;
-                    name?: string;
-                };
-                creator: {
-                    id?: number;
-                    name?: string;
-                    email?: string;
-                };
-            }[]>;
-            getMaintainerInvitation: (id: number, signal?: AbortSignal) => Promise<{
-                id: number;
-                created: string;
-                maintainer: {
-                    id?: number;
-                    name?: string;
-                };
-                creator: {
-                    id?: number;
-                    name?: string;
-                    email?: string;
-                };
-            }>;
-            acceptMaintainerInvitation: (id: number) => Promise<void>;
-            rejectMaintainerInvitation: (id: number) => Promise<void>;
-            getOrganizationInvitations: (signal?: AbortSignal) => Promise<{
-                id: number;
-                created: string;
-                organization: {
-                    id?: number;
-                    name?: string;
-                };
-                creator: {
-                    id?: number;
-                    name?: string;
-                    email?: string;
-                };
-            }[]>;
-            getOrganizationInvitation: (id: number, signal?: AbortSignal) => Promise<{
-                id: number;
-                created: string;
-                organization: {
-                    id?: number;
-                    name?: string;
-                };
-                creator: {
-                    id?: number;
-                    name?: string;
-                    email?: string;
-                };
-            }>;
-            acceptOrganizationInvitation: (id: number) => Promise<void>;
-            rejectOrganizationInvitation: (id: number) => Promise<void>;
-            getProjectInvitations: (signal?: AbortSignal) => Promise<{
-                id: number;
-                created: string;
-                expires?: string | null;
-                reason?: string | null;
-                role?: string | null;
-                project: {
-                    id?: number;
-                    name?: string;
-                };
-                creator: {
-                    id?: number;
-                    name?: string;
-                    email?: string;
-                };
-            }[]>;
-            getProjectInvitation: (id: number, signal?: AbortSignal) => Promise<{
-                id: number;
-                created: string;
-                expires?: string | null;
-                reason?: string | null;
-                role?: string | null;
-                project: {
-                    id?: number;
-                    name?: string;
-                };
-                creator: {
-                    id?: number;
-                    name?: string;
-                    email?: string;
-                };
-            }>;
-            acceptProjectInvitation: (id: number) => Promise<void>;
-            rejectProjectInvitation: (id: number) => Promise<void>;
-            getProjectJoinRequests: (signal?: AbortSignal) => Promise<{
-                id: number;
-                created: string;
-                expires?: string | null;
-                reason?: string | null;
-                project: {
-                    id?: number;
-                    name?: string;
-                };
-            }[]>;
-            deleteProjectJoinRequest: (id: number) => Promise<void>;
-        };
-        deletedProjects: {
-            getDeletedProjects: (query?: DeletedProjectsListQuery, signal?: AbortSignal) => Promise<DeletedProject[]>;
-            getDeletedProject: (projectId: number, signal?: AbortSignal) => Promise<DeletedProject>;
-            restoreDeletedProject: (projectId: number) => Promise<void>;
-            purgeDeletedProject: (projectId: number, ignoreBackendErrors?: boolean) => Promise<DeletedProjectPurgeResult>;
-        };
-        maintainers: {
-            getMaintainers: (signal?: AbortSignal) => Promise<Maintainer[]>;
-            getMaintainer: (maintainerId: number, signal?: AbortSignal) => Promise<MaintainerDetail>;
-            createMaintainer: (body: CreateMaintainerBody) => Promise<{
-                id: number;
-                name: string;
-                created: string;
-                defaultConnectionMysqlId?: number | null;
-                defaultConnectionSnowflakeId?: number | null;
-                defaultConnectionSynapseId?: number | null;
-                defaultConnectionExasolId?: number | null;
-                defaultConnectionBigqueryId?: number | null;
-                defaultConnectionTeradataId?: number | null;
-                defaultFileStorageId?: number | null;
-                zendeskUrl?: string | null;
-                organizations: {
-                    id?: number;
-                    name?: string;
-                }[];
-            }>;
-            updateMaintainer: ({ maintainerId, ...body }: {
-                maintainerId: number;
-            } & UpdateMaintainerBody) => Promise<{
-                id: number;
-                name: string;
-                created: string;
-                defaultConnectionMysqlId?: number | null;
-                defaultConnectionSnowflakeId?: number | null;
-                defaultConnectionSynapseId?: number | null;
-                defaultConnectionExasolId?: number | null;
-                defaultConnectionBigqueryId?: number | null;
-                defaultConnectionTeradataId?: number | null;
-                defaultFileStorageId?: number | null;
-                zendeskUrl?: string | null;
-                organizations: {
-                    id?: number;
-                    name?: string;
-                }[];
-            }>;
-            deleteMaintainer: (maintainerId: number) => Promise<void>;
-            getMaintainerUsers: (maintainerId: number, signal?: AbortSignal) => Promise<MaintainerUser[]>;
-            addMaintainerUser: ({ maintainerId, ...body }: {
-                maintainerId: number;
-            } & AddMaintainerUserBody) => Promise<{
-                id: number;
-                name: string;
-                email: string;
-                mfaEnabled: boolean;
-                features: string[];
-                canAccessLogs: boolean;
-                isSuperAdmin: boolean;
-            }>;
-            removeMaintainerUser: ({ maintainerId, adminId, }: {
-                maintainerId: number;
-                adminId: number;
-            }) => Promise<void>;
-            getMaintainerInvitations: (maintainerId: number, signal?: AbortSignal) => Promise<{
-                id: number;
-                created?: string | null;
-                user: {
-                    id?: number;
-                    name?: string;
-                    email?: string;
-                };
-                creator: {
-                    id?: number;
-                    name?: string;
-                    email?: string;
-                };
-            }[]>;
-            getMaintainerInvitation: ({ maintainerId, invitationId }: {
-                maintainerId: number;
-                invitationId: number;
-            }, signal?: AbortSignal) => Promise<{
-                id: number;
-                created?: string | null;
-                user: {
-                    id?: number;
-                    name?: string;
-                    email?: string;
-                };
-                creator: {
-                    id?: number;
-                    name?: string;
-                    email?: string;
-                };
-            }>;
-            createMaintainerInvitation: ({ maintainerId, ...body }: {
-                maintainerId: number;
-            } & CreateMaintainerInvitationBody) => Promise<{
-                id: number;
-                created?: string | null;
-                user: {
-                    id?: number;
-                    name?: string;
-                    email?: string;
-                };
-                creator: {
-                    id?: number;
-                    name?: string;
-                    email?: string;
-                };
-            }>;
-            deleteMaintainerInvitation: ({ maintainerId, invitationId, }: {
-                maintainerId: number;
-                invitationId: number;
-            }) => Promise<void>;
-            createMaintainerOrganization: ({ maintainerId, ...body }: {
-                maintainerId: number;
-            } & CreateMaintainerOrganizationBody) => Promise<{
-                id: number;
-                name: string;
-                created: string;
-                allowAutoJoin: boolean;
-                crmId?: string | null;
-                activityCenterProjectId?: number | null;
-                mfaRequired: boolean;
-            }>;
-            getMaintainerMetadata: (maintainerId: number, signal?: AbortSignal) => Promise<MetadataItem[]>;
-            setMaintainerMetadata: ({ maintainerId, ...body }: {
-                maintainerId: number;
-            } & SetMaintainerMetadataBody) => Promise<MetadataItem[]>;
-            deleteMaintainerMetadata: ({ maintainerId, metadataId, }: {
-                maintainerId: number;
-                metadataId: number;
-            }) => Promise<void>;
-        };
-        organizations: {
-            getOrganizations: (signal?: AbortSignal) => Promise<{
-                id: number;
-                name: string;
-                created: string;
-                allowAutoJoin: boolean;
-                crmId: string;
-                activityCenterProjectId?: number | null;
-                mfaRequired: boolean;
-                maintainer: {
-                    id?: number;
-                    name?: string;
-                    created?: string;
-                    defaultConnectionMysqlId?: number | null;
-                    defaultConnectionSnowflakeId?: number | null;
-                    defaultConnectionSynapseId?: number | null;
-                    defaultConnectionExasolId?: number | null;
-                    defaultConnectionBigqueryId?: number | null;
-                    defaultConnectionTeradataId?: number | null;
-                    defaultFileStorageId?: number | null;
-                    zendeskUrl?: string | null;
-                };
-            }[]>;
-            getOrganization: (organizationId: number, signal?: AbortSignal) => Promise<OrganizationDetail>;
-            updateOrganization: ({ organizationId, ...body }: {
-                organizationId: number;
-            } & UpdateOrganizationBody) => Promise<{
-                id: number;
-                name: string;
-                created: string;
-                allowAutoJoin: boolean;
-                crmId?: string | null;
-                activityCenterProjectId?: number | null;
-                mfaRequired: boolean;
-            } & {
-                projects: {
-                    id: number;
-                    name: string;
-                    created: string;
-                }[];
-            }>;
-            deleteOrganization: (organizationId: number) => Promise<void>;
-            forceMfa: (organizationId: number) => Promise<{
-                id: number;
-                name: string;
-                created: string;
-                allowAutoJoin: boolean;
-                crmId?: string | null;
-                activityCenterProjectId?: number | null;
-                mfaRequired: boolean;
-            } & {
-                projects: {
-                    id: number;
-                    name: string;
-                    created: string;
-                }[];
-            }>;
-            joinOrganization: (organizationId: number) => Promise<void>;
-            getOrganizationUsers: (organizationId: number, signal?: AbortSignal) => Promise<{
-                id: number;
-                name: string;
-                email: string;
-                mfaEnabled: boolean;
-                features: string[];
-                canAccessLogs: boolean;
-                isSuperAdmin: boolean;
-            }[]>;
-            addOrganizationUser: ({ organizationId, ...body }: {
-                organizationId: number;
-            } & AddOrganizationUserBody) => Promise<{
-                id: number;
-                name: string;
-                email: string;
-                mfaEnabled: boolean;
-                features: string[];
-                canAccessLogs: boolean;
-                isSuperAdmin: boolean;
-            }>;
-            removeOrganizationUser: ({ organizationId, userId, }: {
-                organizationId: number;
-                userId: number;
-            }) => Promise<void>;
-            getOrganizationProjectsUsers: (organizationId: number, signal?: AbortSignal) => Promise<{
-                id: number;
-                name: string;
-                email: string;
-                mfaEnabled: boolean;
-                features: string[];
-                canAccessLogs: boolean;
-                isSuperAdmin: boolean;
-            }[]>;
-            getOrganizationInvitations: (organizationId: number, signal?: AbortSignal) => Promise<{
-                id: number;
-                created?: string | null;
-                user: {
-                    id?: number;
-                    name?: string;
-                    email?: string;
-                };
-                creator: {
-                    id?: number;
-                    name?: string;
-                    email?: string;
-                };
-            }[]>;
-            getOrganizationInvitation: ({ organizationId, invitationId }: {
-                organizationId: number;
-                invitationId: number;
-            }, signal?: AbortSignal) => Promise<{
-                id: number;
-                created?: string | null;
-                user: {
-                    id?: number;
-                    name?: string;
-                    email?: string;
-                };
-                creator: {
-                    id?: number;
-                    name?: string;
-                    email?: string;
-                };
-            }>;
-            createOrganizationInvitation: ({ organizationId, ...body }: {
-                organizationId: number;
-            } & CreateOrganizationInvitationBody) => Promise<{
-                id: number;
-                created?: string | null;
-                user: {
-                    id?: number;
-                    name?: string;
-                    email?: string;
-                };
-                creator: {
-                    id?: number;
-                    name?: string;
-                    email?: string;
-                };
-            }>;
-            deleteOrganizationInvitation: ({ organizationId, invitationId, }: {
-                organizationId: number;
-                invitationId: number;
-            }) => Promise<void>;
-            getOrganizationProjects: (organizationId: number, signal?: AbortSignal) => Promise<Project[]>;
-            createOrganizationProject: ({ organizationId, ...body }: {
-                organizationId: number;
-            } & CreateOrganizationProjectBody) => Promise<{
-                id: number;
-                name: string;
-                type: string;
-                region: string;
-                created?: string | null;
-                expires?: string | null;
-                features: string[];
-                dataSizeBytes: number;
-                rowsCount: number;
-                hasMysql: boolean;
-                hasSynapse: boolean;
-                hasSnowflake: boolean;
-                hasExasol: boolean;
-                hasTeradata: boolean;
-                hasBigquery: boolean;
-                defaultBackend: string;
-                hasTryModeOn: string;
-                limits: {
-                    [key: string]: {
-                        name?: string;
-                        value?: number;
-                    };
-                };
-                metrics: {
-                    [key: string]: {
-                        name?: string;
-                        value?: number;
-                    };
-                };
-                isDisabled: boolean;
-                billedMonthlyPrice?: number | null;
-                dataRetentionTimeInDays: number;
-                isBYODB: boolean;
-                assignedBackends: string[];
-                fileStorageProvider?: string | null;
-                payAsYouGo?: {
-                    purchasedCredits?: number;
-                } | null;
-                disabled?: {
-                    reason?: string;
-                    estimatedEndTime?: string | null;
-                } | null;
-            } & {
-                fileStorage?: Record<string, never>;
-                backends?: Record<string, never>;
-            }>;
-            getOrganizationMetadata: (organizationId: number, signal?: AbortSignal) => Promise<MetadataItem[]>;
-            setOrganizationMetadata: ({ organizationId, ...body }: {
-                organizationId: number;
-            } & SetOrganizationMetadataBody) => Promise<MetadataItem[]>;
-            deleteOrganizationMetadata: ({ organizationId, metadataId, }: {
-                organizationId: number;
-                metadataId: number;
-            }) => Promise<void>;
-        };
-        features: {
-            getAllFeatures: (query: GetAllFeaturesQuery, signal?: AbortSignal) => Promise<Feature[]>;
-            getFeature: (featureId: number, signal?: AbortSignal) => Promise<Feature>;
-            getFeatureProjects: (featureId: number, signal?: AbortSignal) => Promise<FeatureProject[]>;
-            getFeatureAdmins: (featureId: number, signal?: AbortSignal) => Promise<FeatureAdmin[]>;
-        };
-        projects: {
-            getProject: (projectId: GetProjectPath["projectId"], signal?: AbortSignal) => Promise<Project>;
-            addProjectFeature: ({ projectId, feature, }: CreateProjectFeaturePath & CreateProjectFeatureBody) => Promise<Project>;
-            removeProjectFeature: (path: RemoveProjectFeaturePath) => Promise<null>;
-            changeProjectUserRole: ({ projectId, userId, role, }: {
-                projectId: number;
-                userId: number;
-                role: User["role"];
-            }) => Promise<User>;
-            getProjectUsers: (projectId: ListProjectUsersPath["projectId"], signal?: AbortSignal) => Promise<User[]>;
-            getProjectInvitations: (projectId: ListProjectInvitationsPath["projectId"], signal?: AbortSignal) => Promise<{
-                id: number;
-                created?: string | null;
-                expires?: string | null;
-                reason?: string | null;
-                role?: string | null;
-                user: {
-                    id?: number;
-                    name?: string;
-                    email?: string;
-                };
-                creator: {
-                    id?: number;
-                    name?: string;
-                    email?: string;
-                };
-            }[]>;
-            createProjectInvitation: ({ projectId, ...body }: CreateProjectInvitationPath & CreateProjectInvitationBody) => Promise<{
-                id: number;
-                created?: string | null;
-                expires?: string | null;
-                reason?: string | null;
-                role?: string | null;
-                user: {
-                    id?: number;
-                    name?: string;
-                    email?: string;
-                };
-                creator: {
-                    id?: number;
-                    name?: string;
-                    email?: string;
-                };
-            }>;
-            deleteProjectInvitation: ({ projectId, invitationId, }: DeleteProjectInvitationPath) => Promise<null>;
-            addProjectUser: ({ projectId, ...body }: AddProjectUserPath & AddProjectUserBody) => Promise<User>;
-            removeProjectUser: ({ projectId, idOrEmail }: RemoveProjectUserPath) => Promise<null>;
-            getProjectMetadata: (projectId: GetProjectMetadataPath["projectId"], signal?: AbortSignal) => Promise<ProjectMetadataItem[]>;
-            setProjectMetadata: ({ projectId, provider, metadata, }: SetProjectMetadataPath & SetProjectMetadataBody) => Promise<ProjectMetadataItem[]>;
-            getProjectReviewers: (projectId: GetProjectReviewersPath["projectId"], signal?: AbortSignal) => Promise<Reviewer[]>;
-            setProjectReviewers: ({ projectId, adminIds, }: SetProjectReviewersPath & SetProjectReviewersBody) => Promise<void>;
-            updateProject: ({ projectId, ...body }: {
-                projectId: number;
-            } & UpdateProjectBody) => Promise<Project>;
-            deleteProject: (projectId: number) => Promise<null>;
-            moveProject: ({ projectId, organizationId, }: {
-                projectId: number;
-            } & MoveProjectBody) => Promise<Project>;
-            setProjectDisabled: ({ projectId, ...body }: {
-                projectId: number;
-            } & SetProjectDisabledBody) => Promise<Project>;
-        };
-        storageBackends: {
-            getStorageBackend: (id: number, signal?: AbortSignal) => Promise<{
-                id: number;
-                host?: string | null;
-                backend: string;
-                region: string;
-                owner: string;
-                technicalOwner: string;
-                username?: string | null;
-                stats: {
-                    projectsCount?: number;
-                    bucketsCount?: number;
-                    dataSizeGB?: number;
-                    rowsCount?: number;
-                };
-                created: string;
-                creator: {
-                    id?: number | null;
-                    name?: string | null;
-                };
-                warehouse?: string | null;
-                database?: string | null;
-                useSynapseManagedIdentity?: boolean | null;
-                saml2Configuration?: {
-                    idpEntityId?: string;
-                    spEntityId?: string;
-                    spAcsUrl?: string;
-                    publicKey?: string;
-                } | null;
-                useDynamicBackends: boolean;
-                useSso?: boolean | null;
-                isSsoEnabled?: boolean | null;
-                isSsoConfigured?: boolean | null;
-                technicalOwnerContactEmails: string[];
-            }>;
-        };
-        users: {
-            addUserAdminFeature: ({ feature, userIdOrMail }: AddUserFeatureBody & AddUserFeaturePath, signal?: AbortSignal) => Promise<User>;
-            removeUserAdminFeature: ({ userIdOrMail, feature }: RemoveUserFeaturePath, signal?: AbortSignal) => Promise<User>;
-        };
-        verifyToken: (signal?: AbortSignal) => Promise<{
-            id: number;
-            description: string;
-            created: string;
-            lastUsed: string | null;
-            expires: string | null;
-            isSessionToken: boolean;
-            isExpired: boolean;
-            isDisabled: boolean;
-            scopes: string[];
-            type: string;
-            creator: {
-                id: number;
-                name: string;
-            };
-            user?: {
-                id: number;
-                name: string;
-                email: string;
-                mfaEnabled: boolean;
-                features: string[];
-                canAccessLogs: boolean;
-                isSuperAdmin: boolean;
-            } | null;
-        }>;
-    };
-    auth: {
-        login: {
-            withPassword: (input: LoginInput, signal?: AbortSignal) => Promise<{
-                mfaRequired: false;
-                accessToken: string;
-                refreshToken: string;
-                tokenType: string;
-                expiresIn: number;
-                sessionId: string;
-                user: {
-                    id: number;
-                    email: string;
-                    name: string;
-                };
-            } | {
-                mfaRequired: true;
-                mfaType: string;
-                mfaToken: string;
-                expiresIn: number;
-                allowedMethods: string[];
-                webauthn: Record<string, unknown> | null;
-            }>;
-            withOidc: (input: OidcInput, signal?: AbortSignal) => Promise<{
-                mfaRequired: false;
-                accessToken: string;
-                refreshToken: string;
-                tokenType: string;
-                expiresIn: number;
-                sessionId: string;
-                user: {
-                    id: number;
-                    email: string;
-                    name: string;
-                };
-            } | {
-                mfaRequired: true;
-                mfaType: string;
-                mfaToken: string;
-                expiresIn: number;
-                allowedMethods: string[];
-                webauthn: Record<string, unknown> | null;
-            }>;
-        };
-        mfa: {
-            verifyWithCode: (input: MfaCodeInput, signal?: AbortSignal) => Promise<{
-                accessToken: string;
-                refreshToken: string;
-                tokenType: string;
-                expiresIn: number;
-                sessionId: string;
-                user: components$9["schemas"]["UserLoggedInResponse"];
-            }>;
-            verifyWithWebauthn: (input: MfaWebauthnInput, signal?: AbortSignal) => Promise<{
-                accessToken: string;
-                refreshToken: string;
-                tokenType: string;
-                expiresIn: number;
-                sessionId: string;
-                user: components$9["schemas"]["UserLoggedInResponse"];
-            }>;
-            regenerateRecoveryCodes: (signal?: AbortSignal) => Promise<{
-                codes: string[];
-            }>;
-        };
-        saml: {
-            assert: (body: AssertSamlBody, signal?: AbortSignal) => Promise<{
-                accessToken: string;
-                refreshToken: string;
-                tokenType: string;
-                expiresIn: number;
-                sessionId: string;
-                user: components$9["schemas"]["UserLoggedInResponse"];
-            } | {
-                mfaRequired: boolean;
-                mfaType: string;
-                mfaToken: string;
-                expiresIn: number;
-                allowedMethods: string[];
-                webauthn: Record<string, never> | null;
-            }>;
-            initiate: (body?: InitiateSamlBody, signal?: AbortSignal) => Promise<{
-                ssoUrl: string;
-                requestHandle: string;
-                expiresIn: number;
-            }>;
-        };
-        pat: {
-            create: (body: CreatePatBody, signal?: AbortSignal) => Promise<{
-                accessToken: string;
-                tokenType: string;
-                expiresIn: number;
-                pat: components$9["schemas"]["PatItemResponse"];
-            }>;
-            exchange: (body?: ExchangePatBody, signal?: AbortSignal) => Promise<{
-                accessToken: string;
-                tokenType: string;
-                expiresIn: number;
-                scope: Record<string, never>;
-                readOnly: boolean;
-                parentTokenId: string;
-                parentTokenType: "session" | "pat";
-                expiresAt: string;
-                pat: components$9["schemas"]["PatItemResponse"];
-            }>;
-            revoke: (id: RevokePatPath["id"], signal?: AbortSignal) => Promise<void>;
-            getAll: (signal?: AbortSignal) => Promise<{
-                items: components$9["schemas"]["PatItemResponse"][];
-            }>;
-        };
-        device: {
-            create: (body: CreateDeviceAuthorizationBody, signal?: AbortSignal) => Promise<{
-                deviceCode: string;
-                userCode: string;
-                verificationUri: string;
-                verificationUriComplete: string;
-                expiresIn: number;
-                interval: number;
-            }>;
-            approve: (body: ApproveDeviceAuthorizationBody, signal?: AbortSignal) => Promise<{
-                status: "approved" | "denied";
-                idempotent: boolean;
-                decision: components$9["schemas"]["DeviceApprovalDecision"];
-            }>;
-            getToken: (body: GetDeviceAuthorizationTokenBody, signal?: AbortSignal) => Promise<{
-                accessToken: string;
-                refreshToken: string;
-                tokenType: string;
-                expiresIn: number;
-                sessionId: string;
-                user: components$9["schemas"]["UserLoggedInResponse"];
-            }>;
-        };
-        sudo: {
-            verify: (body: SudoBody, signal?: AbortSignal) => Promise<{
-                sudoVerified: boolean;
-                sudoExpiresAt: string;
-                sudoTimeoutSeconds: number;
-            }>;
-            challenge: (signal?: AbortSignal) => Promise<{
-                challengeToken: string;
-                options: Record<string, never>;
-                expiresIn: number;
-            }>;
-        };
-        pkce: {
-            getToken: (body: GetPkceTokenBody, signal?: AbortSignal) => Promise<{
-                accessToken: string;
-                refreshToken: string;
-                tokenType: string;
-                expiresIn: number;
-                sessionId: string;
-                user: components$9["schemas"]["UserLoggedInResponse"];
-            }>;
-        };
-        session: {
-            getAll: (signal?: AbortSignal) => Promise<{
-                sessions?: components$9["schemas"]["SessionItemResponse"][];
-            }>;
-            revoke: (sessionId: RevokeSessionPath["sessionId"], signal?: AbortSignal) => Promise<void>;
-            revokeAll: (signal?: AbortSignal) => Promise<void>;
-        };
-        token: {
-            refresh: (refreshToken: string, signal?: AbortSignal) => Promise<{
-                accessToken: string;
-                refreshToken: string;
-                tokenType: string;
-                expiresIn: number;
-                sessionId: string;
-                user: components$9["schemas"]["UserLoggedInResponse"];
-            }>;
-            introspect: (token?: string, signal?: AbortSignal) => Promise<{
-                sessionId: string;
-                user: components$9["schemas"]["UserLoggedInResponse"];
-                grantType: string;
-                sudoVerified: boolean;
-                createdAt: string;
-                expiresAt: string;
-                lastUsedAt?: string | null;
-                lastUsedIp?: string | null;
-                userAgent?: string | null;
-                projects: components$9["schemas"]["ProjectAccessItem"][];
-            }>;
-            revoke: (body: RevokeTokenBody, signal?: AbortSignal) => Promise<void>;
-        };
-    };
 }>;
-type Clients = Awaited<ReturnType<typeof createClients>>;
-type ClientContext = Clients['context'];
-type ApiClient = {
-    init: (options: ApiClientOptions) => Promise<void>;
-} & Clients;
-declare const createApiClient: () => ApiClient;
+
+type ProjectClients = Awaited<ReturnType<typeof createProjectClients>>;
+type KeboolaApi = ProjectClients & {
+    auth: ReturnType<typeof createAuthClient>;
+    management: ReturnType<typeof createManagementClient>;
+};
+
+/** The bearer (OAuth) session surface, derived from the factory's return. */
+type BearerSession = ReturnType<typeof createKeboola>['session'];
+/** The legacy (SAPI) session surface, derived from the factory's return. */
+type LegacySession = ReturnType<typeof createLegacyKeboola>['session'];
 
 type RequestLog = {
     url: string;
@@ -14493,4 +15222,4 @@ declare const KeboolaHttpHeader: {
     readonly PROJECT_ID: "X-KBC-ProjectId";
 };
 
-export { type ApiClient, type ApiClientOptions, type ClientContext, ConcurrentOptions, HttpContentType, HttpHeader, KeboolaHttpHeader, KeboolaObjectId, type Log, type LogLevel, type Logger, type LoggingOptions, MiddlewareFn, PollException, type ReadableStore, type RequestLog, type ResponseLog, type RetryOptions, type Store, assert, coalesce, createApiClient, createDerivedStore, createLiveProject, createLoggingMiddleware, createRetryMiddleware, createStore, deepMerge, delay, generateUUID, isEmptyDeep, 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, poll, schemaGuidedMerge, series, shallowEqual };