@keboola/api-client 25.0.0 → 29.0.0

package/dist/types-CC0wymfG.d.ts

@@ -0,0 +1,2088 @@
+import { a as OpenapiParametersType, c as OpenapiReturnType, n as ArrayElement, o as OpenapiPathType, r as OpenapiBodyType, s as OpenapiQueryType } from "./index-8pN6Emos.js";
+import { g as paths, h as components } from "./types-CRYtdj5w.js";
+//#region src/clients/storage/bucketExternal/types.d.ts
+type RegisterBucketSchemaBody = OpenapiBodyType<paths['/v2/storage/buckets/register']['post']>;
+type RegisterBucketSchemaQuery = OpenapiQueryType<paths['/v2/storage/buckets/register']['post']>;
+/**
+ * Body for `POST /v2/storage/buckets/register`. The generated schema stubs the request body, so it
+ * is hand-authored from the Storage API contract.
+ */
+type RegisterBucketBody = {
+  name: string;
+  /** Snowflake: `['database', 'schema']`; BigQuery: `['projectId', 'location', 'exchanger', 'listing']`. */
+  path: string[];
+  stage?: BucketStage;
+  description?: string;
+  backend?: 'snowflake' | 'bigquery';
+  displayName?: string;
+  isSnowflakeSharedDatabase?: boolean;
+};
+/** Markdown guide returned by `GET /v2/storage/buckets/register-guide`. */
+type BucketRegistrationGuide = OpenapiReturnType<paths['/v2/storage/buckets/register-guide']['get']>;
+type BucketRegistrationGuideSchemaQuery = OpenapiQueryType<paths['/v2/storage/buckets/register-guide']['get']>;
+/**
+ * Query for `GET /v2/storage/buckets/register-guide`.
+ *
+ * The spec names the repeatable segment `path[]`, brackets and all, which would put a bracketed key
+ * in every call site. Only that one field is remapped: `queryArrayFormat: 'brackets'` builds the
+ * same wire format from a clean `path`, which is how `files` and `jobs` spell their repeatable
+ * fields — and how `RegisterBucketBody` right below already spells this one.
+ */
+type BucketRegistrationGuideQuery = Omit<BucketRegistrationGuideSchemaQuery, 'path[]'> & {
+  path: string[];
+};
+/** Optional query for `PUT /v2/storage/buckets/{bucketId}/refresh`. */
+type RefreshExternalBucketQuery = {
+  force?: boolean;
+  lastChangeDate?: string;
+};
+type RefreshExternalBucketInput = {
+  bucketId: string;
+} & RefreshExternalBucketQuery;
+type CreateScheduledRefreshPath = {
+  branchId: string;
+  bucketId: string;
+};
+type CreateScheduledRefreshBody = {
+  cronExpression: string;
+};
+type CreateScheduledRefreshInput = CreateScheduledRefreshPath & CreateScheduledRefreshBody;
+type ScheduledTask = {
+  uuid: string;
+  job: string;
+  relatedEntity: string;
+  relatedId: string;
+  cronExpression: string;
+  createdAt: string;
+};
+//#endregion
+//#region src/clients/storage/buckets/types.d.ts
+type GetBucketsSchemaQuery = OpenapiQueryType<paths['/v2/storage/branch/{branchId}/buckets']['get']>;
+type CreateBucketSchemaBody = OpenapiBodyType<paths['/v2/storage/buckets']['post']>;
+type UpdateBucketOwnerSchemaBody = OpenapiBodyType<paths['/v2/storage/buckets/{bucketId}/owner']['post']>;
+type BucketStage = 'in' | 'out';
+type BucketBackend = 'snowflake' | 'redshift' | 'bigquery' | 'teradata';
+type Bucket = {
+  attributes?: {
+    name: string;
+    value: string;
+    protected: boolean;
+  }[];
+  backend: BucketBackend;
+  backendPath: string[];
+  bucketSharingAllowed?: boolean;
+  color: string | null;
+  created: string;
+  databaseName: string | null;
+  dataSizeBytes: number;
+  description: string;
+  displayName: string;
+  hasExternalSchema: boolean;
+  id: string;
+  idBranch: number;
+  isMaintenance: boolean;
+  isReadOnly: boolean;
+  isSnowflakeSharedDatabase: boolean;
+  lastChangeDate: string | null;
+  metadata?: {
+    id: string;
+    key: string;
+    value: string;
+    provider: string;
+    timestamp: string;
+  }[];
+  name: string;
+  owner: {
+    id: number;
+    name: string;
+    email: string;
+  } | null;
+  path: string;
+  rowsCount: number;
+  sharedBy?: {
+    id: number | null;
+    name: string | null;
+    date: string | null;
+  };
+  sharing: string | null;
+  sharingParameters?: {
+    projects?: {
+      id: number;
+      name: string;
+    }[];
+    users?: {
+      id: number;
+      name: string;
+      email: string;
+    }[];
+  };
+  sourceBucket?: BucketShared;
+  stage: BucketStage;
+  tables: string;
+  updated: string | null;
+  uri: string;
+};
+type BucketShared = {
+  backend: BucketBackend;
+  color: string | null;
+  created: string;
+  databaseName: string | null;
+  dataSizeBytes: number;
+  description: string;
+  displayName: string;
+  hasExternalSchema: boolean;
+  id: string;
+  lastChangeDate: string | null;
+  name: string;
+  owner: {
+    id: number;
+    name: string;
+    email: string;
+  } | null;
+  path: string;
+  project: {
+    id: number;
+    name: string;
+  };
+  rowsCount: number;
+  sharedBy?: {
+    id: number | null;
+    name: string | null;
+    date: string | null;
+  };
+  sharing: string | null;
+  sharingParameters?: {
+    projects?: {
+      id: number;
+      name: string;
+    }[];
+    users?: {
+      id: number;
+      name: string;
+      email: string;
+    }[];
+  };
+  stage: BucketStage;
+  tables: {
+    id: string;
+    name: string;
+    displayName: string;
+    path: string;
+  }[];
+};
+type BucketDetail = Bucket & {
+  linkedBy?: {
+    id: string;
+    created: string;
+    project: {
+      id: number;
+      name: string;
+    };
+  }[];
+  scheduledTasks?: ScheduledTask[];
+  tables: unknown[];
+};
+type GetBucketsInput = {
+  branchId: string;
+} & GetBucketsQuery;
+type GetBucketsQuery = {
+  include?: ('attributes' | 'metadata' | 'linkedBuckets')[];
+};
+type GetBucketQuery = {
+  include?: ('columns' | 'metadata' | 'columnMetadata' | 'sourceMetadata')[];
+};
+type GetBucketInput = {
+  branchId: string;
+  bucketId: string;
+} & GetBucketQuery;
+type GetBucketOwnerInput = {
+  branchId: string;
+  bucketId: string;
+};
+type CreateBucketBody = {
+  name: string;
+  stage: BucketStage;
+  displayName?: string;
+  description?: string;
+  backend?: BucketBackend;
+};
+type UpdateBucketBody = {
+  displayName?: string;
+  description?: string;
+  color?: string;
+};
+type UpdateBucketInput = {
+  bucketId: string;
+} & UpdateBucketBody;
+/** `force` deletes every table in the bucket before removing it. */
+type DeleteBucketAsyncInput = {
+  bucketId: string;
+  force?: boolean;
+};
+/**
+ * Body for `POST /v2/storage/buckets/{bucketId}/owner`. The generated schema stubs the request
+ * body, so it is hand-authored: pass the new owner either by `email` or by `id`.
+ */
+type UpdateBucketOwnerBody = {
+  email: string;
+} | {
+  id: number;
+};
+type UpdateBucketOwnerInput = {
+  bucketId: string;
+} & UpdateBucketOwnerBody;
+/** Owner detail returned by `GET /v2/storage/branch/{branchId}/buckets/{bucketId}/owner`. */
+type BucketOwner = OpenapiReturnType<paths['/v2/storage/branch/{branchId}/buckets/{bucketId}/owner']['get']>;
+/** Body for `POST /v2/storage/branch/{branchId}/buckets/{bucketId}/metadata`. */
+type SaveBucketMetadataBody = OpenapiBodyType<paths['/v2/storage/branch/{branchId}/buckets/{bucketId}/metadata']['post']>;
+/** Metadata items returned by `POST /v2/storage/branch/{branchId}/buckets/{bucketId}/metadata`. */
+type BucketMetadata = OpenapiReturnType<paths['/v2/storage/branch/{branchId}/buckets/{bucketId}/metadata']['post']>;
+type SaveBucketMetadataInput = {
+  branchId: string;
+  bucketId: string;
+} & SaveBucketMetadataBody;
+type DeleteBucketMetadataInput = {
+  branchId: string;
+  bucketId: string;
+  metadataId: MetadataId;
+};
+//#endregion
+//#region src/clients/storage/bucketSharing/types.d.ts
+type LinkBucketSchemaBody = OpenapiBodyType<paths['/v2/storage/buckets']['post']>;
+/**
+ * The `LinkBucketRequest` arm of the create-or-link union `POST /v2/storage/buckets` accepts, picked
+ * by the discriminating field rather than hand-authored so the stage enum stays spec-derived.
+ */
+type LinkBucketBody = Extract<LinkBucketSchemaBody, {
+  sourceBucketId: string;
+}>;
+type ShareBucketToOrganizationSchemaQuery = OpenapiQueryType<paths['/v2/storage/branch/{branchId}/buckets/{bucketId}/share-organization']['post']>;
+type ShareBucketToOrganizationInput = OpenapiPathType<paths['/v2/storage/branch/{branchId}/buckets/{bucketId}/share-organization']['post']>;
+type ShareBucketToOrganizationProjectSchemaQuery = OpenapiQueryType<paths['/v2/storage/branch/{branchId}/buckets/{bucketId}/share-organization-project']['post']>;
+type ShareBucketToOrganizationProjectInput = OpenapiPathType<paths['/v2/storage/branch/{branchId}/buckets/{bucketId}/share-organization-project']['post']>;
+type ShareBucketToProjectsSchemaBody = OpenapiBodyType<paths['/v2/storage/branch/{branchId}/buckets/{bucketId}/share-to-projects']['post']>;
+type ShareBucketToProjectsSchemaQuery = OpenapiQueryType<paths['/v2/storage/branch/{branchId}/buckets/{bucketId}/share-to-projects']['post']>;
+type ShareBucketToProjectsPath = OpenapiPathType<paths['/v2/storage/branch/{branchId}/buckets/{bucketId}/share-to-projects']['post']>;
+/** Body for `POST /v2/storage/branch/{branchId}/buckets/{bucketId}/share-to-projects`. */
+type ShareBucketToProjectsBody = {
+  targetProjectIds: number[];
+};
+type ShareBucketToProjectsInput = ShareBucketToProjectsPath & ShareBucketToProjectsBody;
+type ShareBucketToUsersSchemaBody = OpenapiBodyType<paths['/v2/storage/branch/{branchId}/buckets/{bucketId}/share-to-users']['post']>;
+type ShareBucketToUsersSchemaQuery = OpenapiQueryType<paths['/v2/storage/branch/{branchId}/buckets/{bucketId}/share-to-users']['post']>;
+type ShareBucketToUsersPath = OpenapiPathType<paths['/v2/storage/branch/{branchId}/buckets/{bucketId}/share-to-users']['post']>;
+/**
+ * Body for `POST /v2/storage/branch/{branchId}/buckets/{bucketId}/share-to-users` — admin ids, which
+ * the endpoint also accepts as e-mails.
+ */
+type ShareBucketToUsersBody = {
+  targetUsers: (number | string)[];
+};
+type ShareBucketToUsersInput = ShareBucketToUsersPath & ShareBucketToUsersBody;
+type UnshareBucketSchemaQuery = OpenapiQueryType<paths['/v2/storage/branch/{branchId}/buckets/{bucketId}/share']['delete']>;
+type UnshareBucketInput = OpenapiPathType<paths['/v2/storage/branch/{branchId}/buckets/{bucketId}/share']['delete']>;
+type ForceUnlinkBucketSchemaQuery = OpenapiQueryType<paths['/v2/storage/branch/{branchId}/buckets/{bucketId}/links/{linkedProjectId}']['delete']>;
+type ForceUnlinkBucketSchemaPath = OpenapiPathType<paths['/v2/storage/branch/{branchId}/buckets/{bucketId}/links/{linkedProjectId}']['delete']>;
+type ForceUnlinkBucketInput = Omit<ForceUnlinkBucketSchemaPath, 'linkedProjectId'> & {
+  linkedProjectId: string;
+};
+type SharedBucketsQuery = NonNullable<OpenapiQueryType<paths['/v2/storage/shared-buckets']['get']>>;
+/** Buckets shared with the current project, returned by `GET /v2/storage/shared-buckets`. */
+type SharedBuckets = OpenapiReturnType<paths['/v2/storage/shared-buckets']['get']>;
+//#endregion
+//#region src/clients/storage/bucketListings/types.d.ts
+type CreateBucketListingPath = OpenapiPathType<paths['/v2/storage/buckets/{bucketId}/listing']['post']>;
+type CreateBucketListingSchemaBody = OpenapiBodyType<paths['/v2/storage/buckets/{bucketId}/listing']['post']>;
+type UpdateBucketListingPath = OpenapiPathType<paths['/v2/storage/buckets/{bucketId}/listing']['patch']>;
+type UpdateBucketListingSchemaBody = OpenapiBodyType<paths['/v2/storage/buckets/{bucketId}/listing']['patch']>;
+type BucketListingDetail = OpenapiReturnType<paths['/v2/storage/buckets/{bucketId}/listing']['get']>;
+type ProjectBucketListing = ArrayElement<OpenapiReturnType<paths['/v2/storage/listings']['get']>>;
+/**
+ * A listing subscriber, decoded from the `user:`/`group:`-prefixed IAM principal the API carries in
+ * `bigquery.subscribers`. Convert with `toBackendSubscribers` / `fromBackendSubscribers`.
+ */
+type Subscriber = {
+  type: 'user' | 'group';
+  email: string;
+};
+type CreateBucketListingBody = {
+  name: string;
+  description: string | null;
+  listingId: string;
+  subscribers: Subscriber[];
+};
+type CreateBucketListingInput = CreateBucketListingPath & CreateBucketListingBody;
+type UpdateBucketListingBody = {
+  name?: string;
+  description?: string | null;
+  subscribers?: Subscriber[];
+};
+type UpdateBucketListingInput = UpdateBucketListingPath & UpdateBucketListingBody;
+//#endregion
+//#region src/clients/storage/tables/types.d.ts
+type GetTablesPath = OpenapiPathType<paths['/v2/storage/branch/{branchId}/tables']['get']>;
+type GetTablesSchemaQuery = OpenapiQueryType<paths['/v2/storage/branch/{branchId}/tables']['get']>;
+type GetTablePath = OpenapiPathType<paths['/v2/storage/branch/{branchId}/tables/{id}']['get']>;
+type DeleteTablePath = OpenapiPathType<paths['/v2/storage/branch/{branchId}/tables/{id}']['delete']>;
+type DeleteTableSchemaQuery = NonNullable<OpenapiQueryType<paths['/v2/storage/branch/{branchId}/tables/{id}']['delete']>>;
+type PullTableAsyncPath = OpenapiPathType<paths['/v2/storage/branch/{branchId}/tables/{id}/pull']['post']>;
+type GetDataPreviewPath = OpenapiPathType<paths['/v2/storage/branch/{branchId}/tables/{tableId}/data-preview']['get']>;
+type GetDataPreviewSchemaQuery = OpenapiQueryType<paths['/v2/storage/branch/{branchId}/tables/{tableId}/data-preview']['get']>;
+type DeleteTableRowsPath = OpenapiPathType<paths['/v2/storage/branch/{branchId}/tables/{id}/rows']['delete']>;
+type DeleteTableRowsSchemaQuery = OpenapiQueryType<paths['/v2/storage/branch/{branchId}/tables/{id}/rows']['delete']>;
+type CreateTableAsyncPath = OpenapiPathType<paths['/v2/storage/branch/{branchId}/buckets/{id}/tables-async']['post']>;
+type CreateTableAsyncSchemaBody = OpenapiBodyType<paths['/v2/storage/branch/{branchId}/buckets/{id}/tables-async']['post']>;
+type CreateTableDefinitionPath = OpenapiPathType<paths['/v2/storage/branch/{branchId}/buckets/{bucketId}/tables-definition']['post']>;
+type CreateTableDefinitionSchemaBody = OpenapiBodyType<paths['/v2/storage/branch/{branchId}/buckets/{bucketId}/tables-definition']['post']>;
+type ImportAsyncPath = OpenapiPathType<paths['/v2/storage/branch/{branchId}/tables/{id}/import-async']['post']>;
+type TableImportAsyncSchemaBody = OpenapiBodyType<paths['/v2/storage/branch/{branchId}/tables/{id}/import-async']['post']>;
+type ExportAsyncPath = OpenapiPathType<paths['/v2/storage/tables/{tableId}/export-async']['post']>;
+type TableExportAsyncSchemaBody = OpenapiBodyType<paths['/v2/storage/tables/{tableId}/export-async']['post']>;
+type SetAliasTableFilterPath = OpenapiPathType<paths['/v2/storage/tables/{tableId}/alias-filter']['post']>;
+type SetAliasTableFilterSchemaBody = OpenapiBodyType<paths['/v2/storage/tables/{tableId}/alias-filter']['post']>;
+type UpdateTableDefinitionPath = OpenapiPathType<paths['/v2/storage/branch/{branchId}/tables/{tableId}/definition']['put']>;
+type UpdateTableDefinitionSchemaBody = OpenapiBodyType<paths['/v2/storage/branch/{branchId}/tables/{tableId}/definition']['put']>;
+type SaveTableMetadataPath = OpenapiPathType<paths['/v2/storage/branch/{branchId}/tables/{id}/metadata']['post']>;
+type SaveTableMetadataSchemaBody = OpenapiBodyType<paths['/v2/storage/branch/{branchId}/tables/{id}/metadata']['post']>;
+type TableMetadataResponse = OpenapiReturnType<paths['/v2/storage/branch/{branchId}/tables/{id}/metadata']['post']>;
+type DeleteTableMetadataPath = OpenapiPathType<paths['/v2/storage/branch/{branchId}/tables/{id}/metadata/{metadataId}']['delete']>;
+/**
+ * Marks the sibling source keys absent. Both `tables-async` and `import-async` resolve which variant
+ * you meant from which source key is populated, and reject more than one outright ("Only one source
+ * can be provided") — see connection's `CreateTableAsyncGuessRequest` / `ImportDataAsyncGuessRequest`.
+ * The document cannot express that: each variant is a standalone schema that simply omits the
+ * others' keys, and a union of those permits them all together.
+ */
+type NoOtherSource<Others extends PropertyKey> = Partial<Record<Others, never>>;
+/**
+ * Body for `POST /v2/storage/branch/{branchId}/tables/{id}/import-async`.
+ *
+ * The document marks every field of both variants required. The backend's request objects mark all
+ * but the source id `Assert\Optional`, each with a default applied on mapping — so kbc-ui imports a
+ * file with `dataFileId` plus a delimiter/enclosure/incremental triple and nothing else. The
+ * workspace variant additionally enforces, in a callback rather than the schema, that one of
+ * `dataObject` / `dataTableName` is set, hence its two arms.
+ */
+type ImportFromFileBody = Extract<TableImportAsyncSchemaBody, {
+  dataFileId: number;
+}>;
+type ImportFromWorkspaceBody = Extract<TableImportAsyncSchemaBody, {
+  dataWorkspaceId: number;
+}>;
+type ImportSource<T, Required extends keyof T> = Partial<T> & Pick<T, Required>;
+type TableImportAsyncBody = (ImportSource<ImportFromFileBody, 'dataFileId'> & NoOtherSource<'dataWorkspaceId'>) | (ImportSource<ImportFromWorkspaceBody, 'dataWorkspaceId' | 'dataObject'> & NoOtherSource<'dataFileId'>) | (ImportSource<ImportFromWorkspaceBody, 'dataWorkspaceId' | 'dataTableName'> & NoOtherSource<'dataFileId'>);
+type FilterOperator = 'eq' | 'ne' | 'gt' | 'lt' | 'ge' | 'le';
+type DataType = 'INTEGER' | 'DOUBLE' | 'BIGINT' | 'REAL' | 'DECIMAL';
+type WhereFilters = {
+  column: string;
+  operator: FilterOperator;
+  values: string[];
+  dataType?: DataType;
+};
+type DeleteTableRows = {
+  changedSince?: string;
+  changedUntil?: string;
+  whereFilters?: WhereFilters[];
+  allowTruncate?: boolean;
+};
+type OrderBy = {
+  column: string;
+  order: 'ASC' | 'DESC';
+  dataType?: DataType;
+};
+type GetDataPreviewQuery = {
+  format?: 'json' | 'rfc';
+  limit?: number;
+  changedSince?: string;
+  changedUntil?: string;
+  fulltextSearch?: string;
+  whereFilters?: WhereFilters[];
+  orderBy?: OrderBy[];
+};
+type GetTablesQuery = {
+  include?: ('attributes' | 'buckets' | 'columns' | 'metadata' | 'columnMetadata' | 'bucketsWithoutSourceTables' | 'sourceMetadata' | 'sourceColumnMetadata')[];
+};
+type PreviewData = {
+  columns: string[];
+  rows: {
+    columnName: string;
+    value: string;
+    isTruncated: boolean;
+  }[][];
+};
+/** @deprecated misspelling kept for backwards compatibility — use `PreviewData`. */
+type PrevieData = PreviewData;
+type TableDefinition = {
+  columns: {
+    name: string;
+    definition: {
+      type: string;
+    };
+  }[];
+  primaryKeysNames: string[];
+};
+type Metadata = {
+  id: string;
+  key: string;
+  provider: string;
+  timestamp: string;
+  value: string;
+};
+type ColumnMetadata = Record<string, Metadata[]>;
+type BaseSourceTable = {
+  id: string;
+  project: {
+    id: number;
+    name: string;
+  };
+  columnMetadata: Record<string, Metadata[]>;
+  uri: string;
+};
+type SourceTable = BaseSourceTable & {
+  definition?: TableDefinition;
+};
+type TypedSourceTable = BaseSourceTable & {
+  definition: TableDefinition;
+};
+type TableDetail = {
+  id: string;
+  name: string;
+  displayName: string;
+  primaryKey: string[];
+  metadata: Metadata[];
+  columns: string[];
+  columnMetadata: ColumnMetadata;
+  bucket: Bucket;
+  attributes: unknown[];
+} & ({
+  isTyped: false;
+  isAlias: false;
+} | {
+  isTyped: true;
+  definition: TableDefinition;
+  isAlias: false;
+} | {
+  isTyped: false;
+  isAlias: true;
+  sourceTable: SourceTable;
+  bucket: Bucket & {
+    sourceBucket: Bucket;
+  };
+} | {
+  isTyped: true;
+  definition: TableDefinition;
+  isAlias: true;
+  sourceTable: TypedSourceTable;
+  bucket: Bucket & {
+    sourceBucket: Bucket;
+  };
+});
+type Table = {
+  id: string;
+  indexKey: unknown[];
+  indexType: unknown;
+  uri: string;
+  transactional?: boolean;
+  timestampType: string;
+  tableType: string;
+  syntheticPrimaryKeyEnabled: boolean;
+  rowsCount: number;
+  primaryKey: string[];
+  path: string;
+  name: string;
+  lastImportDate: string;
+  lastChangeDate: string;
+  isTyped: boolean;
+  isAliasable: boolean;
+  isAlias: boolean;
+  displayName: string;
+  dataSizeBytes: number;
+  created: string;
+  metadata?: Metadata[];
+  columns?: string[];
+  columnMetadata?: ColumnMetadata;
+  bucket?: Bucket;
+  distributionKey: unknown[];
+  distributionType: unknown;
+};
+type TableExportAsyncBody = {
+  limit?: number;
+  columns?: string[];
+  whereColumn?: string;
+  whereOperator?: FilterOperator;
+  whereValues?: string[];
+  changedSince?: string;
+  changedUntil?: string;
+};
+/**
+ * Body for creating a table from an uploaded file.
+ *
+ * Hand-authored to match the Storage backend's runtime contract, which differs
+ * from the stack's published OpenAPI doc (`doc.json`, the source for the
+ * generated schema): the doc models `primaryKey`/`distributionKey` as
+ * `string[]` and marks several fields required, but the backend rejects an
+ * array `primaryKey` ("primaryKey must be string. Use comma as separator for
+ * composite primary key.") and treats every field except `dataFileId` and
+ * `name` as optional. kbc-ui sends `primaryKey` comma-joined, or omits it.
+ * See UT-4310.
+ */
+type CreateTableAsyncFromFileBody = {
+  dataFileId: number;
+  name: string;
+  delimiter?: string | null;
+  enclosure?: string | null;
+  escapedBy?: string | null;
+  /** Comma-separated primary-key columns; omit when there is no primary key. */
+  primaryKey?: string;
+  /** Comma-separated distribution-key columns (Synapse); omit when none. */
+  distributionKey?: string;
+  /** Column names (file workspace only). */
+  columns?: string[] | null;
+  timestampType?: string | null;
+};
+/**
+ * The document gets the same three fields wrong on every create-table variant, which is why
+ * `CreateTableAsyncFromFileBody` above is hand-authored rather than derived. In connection's
+ * `Storage/Tables/Create/Request`, all three variants compose `ParamPrimaryKey` and
+ * `ParamDistribution`, which make `primaryKey` and `distributionKey` `Assert\Optional` *and*
+ * `Assert\Type('string')` — a comma-separated list, not the `string[]` the document declares (an
+ * array is rejected: "primaryKey must be string. Use comma as separator for composite primary
+ * key."). `timestampType` is `Assert\Optional` too. See UT-4310.
+ *
+ * Distributive so the union in `CreateTableAsyncBody` keeps its arms.
+ */
+type WithCorrectedTableShape<T> = T extends unknown ? Omit<T, 'primaryKey' | 'distributionKey' | 'timestampType'> & {
+  /** Comma-separated primary-key columns; omit when there is no primary key. */
+  primaryKey?: string;
+  /** Comma-separated distribution-key columns (Synapse); omit when none. */
+  distributionKey?: string;
+  timestampType?: string | null;
+} : never;
+/** Body for creating a table from an existing snapshot. */
+type CreateTableAsyncFromSnapshotBody = WithCorrectedTableShape<components['schemas']['CreateTableAsyncFromSnapshotRequest']>;
+/** Body for creating a table from another table as it was at a point in time. */
+type CreateTableAsyncFromTimeTravelBody = WithCorrectedTableShape<components['schemas']['CreateTableAsyncFromTimeTravelRequest']>;
+/**
+ * Both keys are already optional on this variant (unlike the import one, where they are required and
+ * `ImportSource` is enough), so the arm has to make its own required rather than un-optional the
+ * other — and non-null, since the backend rejects a blank value.
+ */
+type RequireSource<T, K extends keyof T> = T & { [P in K]-?: NonNullable<T[P]>; };
+type CreateFromWorkspace = WithCorrectedTableShape<components['schemas']['CreateTableAsyncFromWorkspaceRequest']>;
+/**
+ * Body for creating a table from a workspace. Like the workspace import, one of `dataObject` /
+ * `dataTableName` is required — enforced in an `Assert\Callback`, which the document cannot express
+ * — hence the two arms. `dataTableName` is the deprecated spelling.
+ */
+type CreateTableAsyncFromWorkspaceBody = RequireSource<CreateFromWorkspace, 'dataObject'> | RequireSource<CreateFromWorkspace, 'dataTableName'>;
+/**
+ * The file variant is hand-authored above to match the backend; the rest are derived per variant so
+ * each can carry the corrections the document needs. A new variant in the schema is a type error
+ * here rather than a silently unsupported body.
+ */
+type CreateTableAsyncBody = (CreateTableAsyncFromFileBody & NoOtherSource<'snapshotId' | 'sourceTableId' | 'dataWorkspaceId'>) | (CreateTableAsyncFromSnapshotBody & NoOtherSource<'dataFileId' | 'sourceTableId' | 'dataWorkspaceId'>) | (CreateTableAsyncFromTimeTravelBody & NoOtherSource<'dataFileId' | 'snapshotId' | 'dataWorkspaceId'>) | (CreateTableAsyncFromWorkspaceBody & NoOtherSource<'dataFileId' | 'snapshotId' | 'sourceTableId'>);
+/**
+ * Body for `POST /v2/storage/buckets/{bucketId}/tables-definition` — creates a typed
+ * table from an explicit column definition (no data). Returns a `tableDefinitionCreate` storage job.
+ */
+type CreateTableDefinitionBody = {
+  name: string;
+  primaryKeysNames?: string[];
+  columns: {
+    name: string;
+    definition: {
+      type: string;
+      nullable?: boolean;
+      length?: string;
+    };
+  }[];
+};
+type TableDefinitionPatchFields = {
+  displayName: string;
+  description: string | null;
+  /**
+   * `false` marks the description user-authored, which stops Output Mapping from
+   * overwriting it on the next component run. Tables default to `true`
+   * (system-managed).
+   */
+  isDescriptionSystemManaged: boolean;
+  columns: {
+    name: string;
+    length?: string;
+    nullable?: boolean;
+    default?: string | null;
+    description?: string | null;
+  }[];
+};
+/**
+ * Body for `PUT /v2/storage/branch/{branchId}/tables/{tableId}/definition`.
+ *
+ * Every field is a patch — omitted keys are left untouched — and the server
+ * rejects a body carrying none of them, so the type requires at least one:
+ * it distributes into one variant per field, each pinning that field required
+ * and leaving the rest optional. `columns` is positive-only: columns absent from
+ * it keep their current definition. Server-side validation caps `description`
+ * and each `columns[].description` at 65,535 chars; the value is stored in full
+ * and truncated only where the backend is narrower (BigQuery 1,024 / Snowflake
+ * 16,384).
+ */
+type UpdateTableDefinitionBody = { [K in keyof TableDefinitionPatchFields]: Required<Pick<TableDefinitionPatchFields, K>> & Partial<Omit<TableDefinitionPatchFields, K>>; }[keyof TableDefinitionPatchFields];
+/** Body for `PUT /v2/storage/tables/{id}` — synchronous table update (display name). */
+type UpdateTableBody = {
+  displayName?: string;
+};
+/** Body for `POST /v2/storage/buckets/{bucketId}/table-aliases`. */
+type CreateAliasTableBody = {
+  sourceTable: string;
+  name: string;
+  /** Keep the alias' columns in step with the source table's. Defaults to true. */
+  aliasColumnsAutosync?: boolean;
+  aliasColumns?: string[];
+  aliasFilter?: {
+    column: string;
+    operator?: 'eq' | 'ne';
+    values: string[];
+  };
+};
+/** Body for `POST /v2/storage/tables/{id}/alias-filter` (synchronous). */
+type SetAliasTableFilterBody = {
+  column: string;
+  values: string[];
+  operator?: 'eq' | 'ne';
+};
+type SaveMetadataBody = {
+  provider: string;
+  metadata: {
+    key: string;
+    value: string;
+  }[];
+};
+type GetTablesInput = GetTablesPath & GetTablesQuery;
+type GetTableInput = GetTablePath;
+/**
+ * Input for `POST /v2/storage/branch/{branchId}/tables/{id}/pull`. The branch is the *target* — the
+ * table is pulled from the default branch into it — so pass the dev branch you are pulling into; a
+ * pull into the default branch is a no-op.
+ */
+type PullTableAsyncInput = PullTableAsyncPath;
+type GetDataPreviewInput = GetDataPreviewPath & GetDataPreviewQuery;
+type DeleteTableInput = DeleteTablePath & Pick<DeleteTableSchemaQuery, 'force'>;
+/** Not an endpoint — `deleteTables` fans out over `deleteTable`, so the ids are a client-side list. */
+type DeleteTablesInput = Omit<DeleteTableInput, 'id'> & {
+  ids: string[];
+};
+type DeleteTableRowsInput = DeleteTableRowsPath & DeleteTableRows;
+type CreateTableAsyncInput = CreateTableAsyncPath & CreateTableAsyncBody;
+type CreateTableDefinitionInput = CreateTableDefinitionPath & CreateTableDefinitionBody;
+/**
+ * `POST /v2/storage/buckets/{bucketId}/table-aliases` is absent from the Storage document, so this
+ * is one of the two inputs here with a hand-written path parameter.
+ */
+type CreateAliasTableInput = {
+  bucketId: string;
+} & CreateAliasTableBody;
+type SetAliasTableFilterInput = SetAliasTableFilterPath & SetAliasTableFilterBody;
+/**
+ * `PUT /v2/storage/tables/{id}` is absent from the Storage document — it declares `put?: never` on
+ * both the branched and unbranched table paths — so, like `CreateAliasTableInput`, this one cannot
+ * derive its path parameter.
+ */
+type UpdateTableInput = {
+  tableId: string;
+} & UpdateTableBody;
+type ExportAsyncInput = ExportAsyncPath & TableExportAsyncBody;
+type ImportAsyncInput = ImportAsyncPath & TableImportAsyncBody;
+type UpdateTableDefinitionInput = UpdateTableDefinitionPath & UpdateTableDefinitionBody;
+type SaveTableMetadataInput = SaveTableMetadataPath & SaveMetadataBody;
+type DeleteTableMetadataInput = Omit<DeleteTableMetadataPath, 'metadataId'> & {
+  metadataId: MetadataId;
+};
+//#endregion
+//#region src/clients/storage/columns/types.d.ts
+type AddTableColumnSchemaBody = OpenapiBodyType<paths['/v2/storage/branch/{branchId}/tables/{id}/columns']['post']>;
+type CreateTablePrimaryKeySchemaBody = OpenapiBodyType<paths['/v2/storage/branch/{branchId}/tables/{tableId}/primary-key']['post']>;
+type AddTableColumnPath = OpenapiPathType<paths['/v2/storage/branch/{branchId}/tables/{id}/columns']['post']>;
+type DeleteTableColumnPath = OpenapiPathType<paths['/v2/storage/branch/{branchId}/tables/{tableId}/columns/{columnName}']['delete']>;
+type DeleteTableColumnQuery = NonNullable<OpenapiQueryType<paths['/v2/storage/branch/{branchId}/tables/{tableId}/columns/{columnName}']['delete']>>;
+type CreateTablePrimaryKeyPath = OpenapiPathType<paths['/v2/storage/branch/{branchId}/tables/{tableId}/primary-key']['post']>;
+/** Body for `POST /v2/storage/tables/{id}/columns`. */
+type AddTableColumnBody = {
+  name: string;
+  /** Column settings for typed tables. */
+  definition?: {
+    type: string;
+    length?: string;
+    nullable?: boolean;
+    default?: string;
+  };
+  /** Base datatype for non-typed tables (e.g. `STRING`, `INTEGER`, `BOOLEAN`). */
+  basetype?: string;
+};
+/** Body for `POST /v2/storage/tables/{id}/primary-key`. */
+type CreateTablePrimaryKeyBody = {
+  columns: string[];
+  /** Skip the duplicate-values check (Snowflake only). */
+  skipDuplicatesCheck?: boolean;
+};
+type AddTableColumnInput = AddTableColumnPath & AddTableColumnBody;
+type DeleteTableColumnInput = DeleteTableColumnPath & DeleteTableColumnQuery;
+type CreateTablePrimaryKeyInput = CreateTablePrimaryKeyPath & CreateTablePrimaryKeyBody;
+type RemoveTablePrimaryKeyInput = OpenapiPathType<paths['/v2/storage/branch/{branchId}/tables/{tableId}/primary-key']['delete']>;
+type SaveColumnMetadataInput = {
+  branchId: string;
+  columnId: string;
+} & SaveMetadataBody;
+type DeleteColumnMetadataInput = {
+  branchId: string;
+  columnId: string;
+  metadataId: MetadataId;
+};
+//#endregion
+//#region src/clients/storage/events/types.d.ts
+type EventType = 'info' | 'warn' | 'error' | 'success';
+type GetEventsPath = OpenapiPathType<paths['/v2/storage/branch/{branchId}/events']['get']>;
+type GetEventsQuery = NonNullable<OpenapiQueryType<paths['/v2/storage/branch/{branchId}/events']['get']>>;
+type GetEventsInput = GetEventsPath & GetEventsQuery;
+type GetEventPath = OpenapiPathType<paths['/v2/storage/branch/{branchId}/events/{eventId}']['get']>;
+/**
+ * `branchId` is optional here alone, where the spec requires it.
+ *
+ * - A writer records against the branch it is running in, and the callers outside kbc-ui have no
+ *   branch to resolve, so the client falls back to the default one.
+ * - Both reads take it, since which branch's feed you want is never implicit.
+ */
+type CreateEventPath = Omit<OpenapiPathType<paths['/v2/storage/branch/{branchId}/events']['post']>, 'branchId'> & Partial<Pick<OpenapiPathType<paths['/v2/storage/branch/{branchId}/events']['post']>, 'branchId'>>;
+type CreateEventSchemaBody = OpenapiBodyType<paths['/v2/storage/branch/{branchId}/events']['post']>;
+/**
+ * Derived from the create body, overriding the three fields the spec models badly.
+ *
+ * - `params` and `results` are JSON-encoded `string | null` there; both go as objects instead.
+ * - `params` also keeps the string form, which `sapi-events/actions` pre-serializes.
+ * - `type` is a free-form `string | null`; only the four `EventType` values do anything.
+ */
+type CreateEventBody = Omit<CreateEventSchemaBody, 'type' | 'params' | 'results'> & {
+  type?: EventType;
+  params?: Record<string, unknown> | string;
+  results?: Record<string, unknown>;
+};
+type CreateEventInput = CreateEventPath & CreateEventBody;
+type GetTableEventsPath = OpenapiPathType<paths['/v2/storage/branch/{branchId}/tables/{tableId}/events']['get']>;
+type GetTableEventsQuery = NonNullable<OpenapiQueryType<paths['/v2/storage/branch/{branchId}/tables/{tableId}/events']['get']>>;
+type GetTableEventsInput = GetTableEventsPath & GetTableEventsQuery;
+type GetBucketEventsPath = OpenapiPathType<paths['/v2/storage/branch/{branchId}/buckets/{bucketId}/events']['get']>;
+type GetBucketEventsQuery = NonNullable<OpenapiQueryType<paths['/v2/storage/branch/{branchId}/buckets/{bucketId}/events']['get']>>;
+type GetBucketEventsInput = GetBucketEventsPath & GetBucketEventsQuery;
+/**
+ * One event as a feed returns it, from the table feed's payload — the bucket feed declares an
+ * identical shape, and the project feed and the detail endpoint declare none at all.
+ */
+type StorageEventRaw = OpenapiReturnType<paths['/v2/storage/branch/{branchId}/tables/{tableId}/events']['get']>[number];
+/**
+ * Fields the table feed declares required that this type does not, because it also describes the
+ * project feed and the detail endpoint — and neither of those declares a payload to check them
+ * against. Optional is the safe reading until a live one is probed.
+ */
+type UnverifiedEventFields = 'description' | 'objectId' | 'objectName' | 'objectType' | 'idBranch' | 'uri' | 'token' | 'context' | 'attachments';
+/**
+ * Derived from `StorageEventRaw`, overriding only what the spec cannot express.
+ *
+ * - `params`, `results` and `performance` are `Record<string, never>` there, which types every
+ *   property access as an error.
+ * - `type` is a free-form `string`; the four `EventType` values are what the backend emits.
+ */
+type StorageEvent = Omit<StorageEventRaw, 'type' | 'params' | 'results' | 'performance' | UnverifiedEventFields> & Partial<Pick<StorageEventRaw, UnverifiedEventFields>> & {
+  type: EventType;
+  params?: Record<string, unknown>;
+  results?: {
+    rowsCount?: number;
+    sizeBytes?: number;
+  };
+  performance?: {
+    importDuration?: number;
+  };
+};
+/**
+ * What a create answers with — not a feed item.
+ *
+ * - Keyed by `id`, which the detail endpoint cannot resolve: that one keys on `uuid`.
+ * - `createdTime`, where a feed item carries `created`.
+ */
+type CreatedEvent = {
+  id: string | number;
+  component: string;
+  message: string;
+  type: EventType;
+  runId?: string;
+  configurationId?: string;
+  results?: Record<string, unknown>;
+  params?: Record<string, unknown>;
+  duration?: number;
+  createdTime: string;
+};
+//#endregion
+//#region src/clients/storage/files/types.d.ts
+/**
+ * One id type across the namespace, as `File['id']` returns it.
+ *
+ * - Spec types the same path segment a `string` on the detail, tag-create and tag-delete operations
+ *   and a `number` on the delete and the content read.
+ * - The paths below normalise it to this; the client stringifies for the `string` operations.
+ */
+type FileId = number;
+type GetFilePath = Omit<OpenapiPathType<paths['/v2/storage/files/{fileId}']['get']>, 'fileId'> & {
+  fileId: FileId;
+};
+type DeleteFilePath = OpenapiPathType<paths['/v2/storage/files/{fileId}']['delete']>;
+type GetFileContentPath = OpenapiPathType<paths['/v2/storage/files/{fileId}/content']['get']>;
+type AddFileTagPath = Omit<OpenapiPathType<paths['/v2/storage/files/{fileId}/tags']['post']>, 'fileId'> & {
+  fileId: FileId;
+};
+type AddFileTagBody = OpenapiBodyType<paths['/v2/storage/files/{fileId}/tags']['post']>;
+type AddFileTagInput = AddFileTagPath & AddFileTagBody;
+type DeleteFileTagPath = Omit<OpenapiPathType<paths['/v2/storage/files/{fileId}/tags/{tagName}']['delete']>, 'fileId'> & {
+  fileId: FileId;
+};
+/**
+ * Spec models the list as a GET carrying a `ListFilesRequest` **body** and no query parameters.
+ *
+ * - The API reads the same fields from the query string, which is what `GetFilesQuery` describes.
+ * - So the whole parameters object is asserted in, not just the query.
+ */
+type GetFilesSchemaParams = OpenapiParametersType<paths['/v2/storage/files']['get']>;
+/**
+ * The list filters, from the shape the spec mis-models as a request body.
+ *
+ * - Spec marks `tags`, `limit`, `offset` and `showExpired` required, each with a default the API
+ *   applies, so every filter is optional here.
+ */
+type GetFilesQuery = Partial<OpenapiBodyType<paths['/v2/storage/files']['get']>>;
+type CreatorToken$1 = {
+  id: number;
+  description: string;
+};
+type File = {
+  created: string;
+  creatorToken: CreatorToken$1;
+  id: number;
+  isExpired: boolean;
+  isEncrypted: boolean;
+  isPublic: boolean;
+  isSliced: boolean;
+  maxAgeDays: number | null;
+  name: string;
+  provider: string;
+  region: string;
+  runId: string;
+  runIds: string[];
+  sizeBytes: number;
+  tags: string[];
+  url: string;
+};
+type PrepareFileSchemaBody = OpenapiBodyType<paths['/v2/storage/files/prepare']['post']>;
+/**
+ * The prepare body, with every flag optional because the API defaults each one.
+ *
+ * - `PrepareFileSchemaBody` is a union of one arm per provider; the S3 arm is the widest and the only
+ *   one declaring `isPublic`, `notify`, `isEncrypted` and `federationToken`, so it is picked by a
+ *   field the other two lack.
+ * - `name` stays required: the API has nothing to default it to.
+ */
+type PrepareFileBody = Partial<Extract<PrepareFileSchemaBody, {
+  isPublic: boolean;
+}>> & {
+  name: string;
+};
+type AwsUploadParams = {
+  key: string;
+  bucket: string;
+  acl: string;
+  credentials: {
+    AccessKeyId: string;
+    SecretAccessKey: string;
+    SessionToken: string;
+    Expiration: string;
+  };
+};
+type AzureUploadParams = {
+  container: string;
+  blobName: string;
+  accountName: string;
+  sasConnectionString: string;
+};
+type GcsUploadParams = {
+  key: string;
+  bucket: string;
+  credentials: {
+    access_token: string;
+    expires_in: number;
+    token_type: string;
+  };
+};
+type PreparedFile = {
+  id: number;
+  name: string;
+  url: string;
+  provider: 'aws' | 'azure' | 'gcp';
+  region?: string;
+  isSliced: boolean;
+  isEncrypted: boolean;
+  uploadParams?: AwsUploadParams;
+  absUploadParams?: AzureUploadParams;
+  gcsUploadParams?: GcsUploadParams;
+};
+//#endregion
+//#region src/clients/storage/branches/types.d.ts
+type BranchMetadataRaw = OpenapiReturnType<paths['/v2/storage/branch/{branchId}/metadata']['get']>[number];
+type CreateDevBranchSchemaBody = OpenapiBodyType<paths['/v2/storage/dev-branches']['post']>;
+type UpdateDevBranchSchemaBody = OpenapiBodyType<paths['/v2/storage/dev-branches/{id}']['put']>;
+type SaveDevBranchMetadataPath = OpenapiPathType<paths['/v2/storage/branch/{branchId}/metadata']['post']>;
+type DeleteDevBranchMetadataSchemaPath = OpenapiPathType<paths['/v2/storage/branch/{branchId}/metadata/{metadataId}']['delete']>;
+type BranchMetadataEntry = {
+  key: string;
+  value: string;
+};
+type DevBranch = {
+  id: number;
+  name: string;
+  description: string;
+  isDefault: boolean;
+  created: string;
+  creatorToken: {
+    id: number;
+    name: string;
+  } | [];
+};
+type CreateDevBranchBody = {
+  name: string;
+  description?: string;
+};
+type DevBranchPath = {
+  id: number;
+};
+type UpdateDevBranchInput = DevBranchPath & CreateDevBranchBody;
+type SaveDevBranchMetadataInput = SaveDevBranchMetadataPath & {
+  metadata: BranchMetadataEntry[];
+};
+type DeleteDevBranchMetadataPath = Omit<DeleteDevBranchMetadataSchemaPath, 'metadataId'> & {
+  metadataId: MetadataId;
+};
+//#endregion
+//#region src/clients/storage/workspaces/types.d.ts
+/**
+ * One id type across the namespace, as the list and detail payloads return it.
+ *
+ * - Spec types the same path segment a `string` on the delete, password, SSO and public-key
+ *   operations and a `number` on the list, detail, objects and batch-delete ones.
+ * - The paths below normalise it to this; the client stringifies for the `string` operations.
+ */
+type WorkspaceId = number;
+type GetWorkspacesPath = OpenapiPathType<paths['/v2/storage/branch/{branchId}/workspaces']['get']>;
+type GetWorkspacePath = OpenapiPathType<paths['/v2/storage/branch/{branchId}/workspaces/{workspaceId}']['get']>;
+type DeleteWorkspacePath = Omit<OpenapiPathType<paths['/v2/storage/branch/{branchId}/workspaces/{workspaceId}']['delete']>, 'workspaceId'> & {
+  workspaceId: WorkspaceId;
+};
+/** Client-side fan-out over `deleteWorkspace`, not an endpoint of its own. */
+type DeleteWorkspacesInput = Omit<DeleteWorkspacePath, 'workspaceId'> & {
+  workspaceIds: WorkspaceId[];
+};
+type ResetWorkspacePasswordPath = Omit<OpenapiPathType<paths['/v2/storage/branch/{branchId}/workspaces/{workspaceId}/password']['post']>, 'workspaceId'> & {
+  workspaceId: WorkspaceId;
+};
+type GetWorkspaceSaml2LoginPath = OpenapiPathType<paths['/v2/storage/branch/{branchId}/workspaces/{workspaceId}/saml2-login']['get']>;
+type SetWorkspacePublicKeyPath = Omit<OpenapiPathType<paths['/v2/storage/branch/{branchId}/workspaces/{workspaceId}/public-key']['post']>, 'workspaceId'> & {
+  workspaceId: WorkspaceId;
+};
+type SetWorkspacePublicKeyBody = OpenapiBodyType<paths['/v2/storage/branch/{branchId}/workspaces/{workspaceId}/public-key']['post']>;
+type SetWorkspacePublicInput = SetWorkspacePublicKeyPath & SetWorkspacePublicKeyBody;
+type GetWorkspaceObjectsPath = OpenapiPathType<paths['/v2/storage/branch/{branchId}/workspaces/{workspaceId}/objects']['get']>;
+type WorkspaceObject = OpenapiReturnType<paths['/v2/storage/branch/{branchId}/workspaces/{workspaceId}/objects']['get']>[number];
+type DeleteWorkspaceObjectPath = OpenapiPathType<paths['/v2/storage/branch/{branchId}/workspaces/{workspaceId}/objects/batch-delete']['post']>;
+type DeleteWorkspaceObjectBody = OpenapiBodyType<paths['/v2/storage/branch/{branchId}/workspaces/{workspaceId}/objects/batch-delete']['post']>;
+type DeleteWorkspaceObjectInput = DeleteWorkspaceObjectPath & DeleteWorkspaceObjectBody;
+type UnloadWorkspacePath = OpenapiPathType<paths['/v2/storage/branch/{branchId}/workspaces/{workspaceId}/unload']['post']>;
+type UnloadWorkspaceQuery = Omit<OpenapiQueryType<paths['/v2/storage/branch/{branchId}/workspaces/{workspaceId}/unload']['post']>, 'only-direct-grants'>;
+type UnloadWorkspaceInput = UnloadWorkspacePath & UnloadWorkspaceQuery;
+type WorkspaceInputMappingLoadPreviewPath = OpenapiPathType<paths['/v2/storage/branch/{branchId}/input-mapping-load/preview']['post']>;
+type WorkspaceInputMappingLoadPreviewQuery = NonNullable<OpenapiQueryType<paths['/v2/storage/branch/{branchId}/input-mapping-load/preview']['post']>>;
+/** Component-style input-mapping config sent to the workspace-less preview endpoint. */
+type WorkspaceInputMappingLoadPreviewBody = OpenapiBodyType<paths['/v2/storage/branch/{branchId}/input-mapping-load/preview']['post']>;
+/** Resolved load type plus the possible load types per input table. */
+type WorkspaceInputMappingLoadPreviewResponse = OpenapiReturnType<paths['/v2/storage/branch/{branchId}/input-mapping-load/preview']['post']>;
+type WorkspaceInputMappingLoadPreviewInput = WorkspaceInputMappingLoadPreviewPath & WorkspaceInputMappingLoadPreviewQuery & {
+  body: WorkspaceInputMappingLoadPreviewBody;
+};
+type WorkspaceLoginType = 'default' | 'snowflake-legacy-service' | 'snowflake-person-sso' | 'snowflake-person-keypair' | 'snowflake-service-keypair';
+/**
+ * Hand-authored, because `WorkspaceDetailResponse.connection` describes a narrower payload than the
+ * one callers get.
+ *
+ * - Spec's union carries neither `password` nor `account` nor `port`, which a workspace created
+ *   through `configurationWorkspaces.createConfigurationWorkspace` returns and consumers read.
+ * - `configurations/types` reuses this shape for a component's `db` parameters.
+ */
+type WorkspaceConnection = {
+  account: string;
+  backend?: 'snowflake' | 'bigquery';
+  port?: string;
+  host: string;
+  region: string;
+  database: string;
+  schema: string;
+  warehouse: string;
+  user: string;
+  /**
+   * Available only upon creation with `storage.configurationWorkspaces.createConfigurationWorkspace`.
+   */
+  password?: string;
+  loginType: WorkspaceLoginType;
+  /** Only for file workspaces */
+  container: string;
+  /** indicates whenever is login into workspace possible via Snowflake SSO */
+  ssoLoginAvailable: boolean;
+};
+/** The workspace payload as the spec declares it — `Workspace` is the corrected shape. */
+type WorkspaceRaw = OpenapiReturnType<paths['/v2/storage/branch/{branchId}/workspaces/{workspaceId}']['get']>;
+/**
+ * Derived from `WorkspaceRaw`, overriding only the fields the spec models badly. Everything not
+ * listed in the `Omit` tracks the schema, so a field the backend adds arrives with `pnpm gen:types`.
+ * Each override below names the spec bug it works around — if one is ever fixed upstream, delete the
+ * override.
+ */
+type Workspace = Omit<WorkspaceRaw, 'name' | 'component' | 'configurationId' | 'backendSize' | 'connection' | 'creatorToken' | 'platformUsageType'> & {
+  /** working schema name */
+  name: string;
+  /** name of the registered component that created the workspace */
+  component: string | null;
+  /** id of a configuration used to create workspace */
+  configurationId: string | null;
+  /** string for backends supporting dynamic backend size (currently only Snowflake), null for other backends */
+  backendSize: string | null;
+  connection: WorkspaceConnection;
+  creatorToken: {
+    id: number;
+    description: string;
+  };
+  /** type of usage in Keboola Connection (user, system, reader) */
+  platformUsageType: 'user' | 'system' | 'reader';
+};
+type WorkspaceSaml2Login = {
+  acsUrl: string;
+  samlResponse: string;
+  relayState: string;
+  expiresAt: string;
+};
+type ResetWorkspacePassword = {
+  password: string;
+};
+//#endregion
+//#region src/clients/storage/configurationRows/types.d.ts
+type CreateConfigurationRowPath = OpenapiPathType<paths['/v2/storage/branch/{branchId}/components/{componentId}/configs/{configurationId}/rows']['post']>;
+type CreateConfigurationRowSchemaBody = OpenapiBodyType<paths['/v2/storage/branch/{branchId}/components/{componentId}/configs/{configurationId}/rows']['post']>;
+type GetConfigurationRowPath = OpenapiPathType<paths['/v2/storage/branch/{branchId}/components/{componentId}/configs/{configurationId}/rows/{rowId}']['get']>;
+type UpdateConfigurationRowPath = OpenapiPathType<paths['/v2/storage/branch/{branchId}/components/{componentId}/configs/{configurationId}/rows/{rowId}']['put']>;
+type UpdateConfigurationRowSchemaBody = OpenapiBodyType<paths['/v2/storage/branch/{branchId}/components/{componentId}/configs/{configurationId}/rows/{rowId}']['put']>;
+type DeleteConfigurationRowPath = OpenapiPathType<paths['/v2/storage/branch/{branchId}/components/{componentId}/configs/{configurationId}/rows/{rowId}']['delete']>;
+type DeleteConfigurationRowSchemaBody = OpenapiBodyType<paths['/v2/storage/branch/{branchId}/components/{componentId}/configs/{configurationId}/rows/{rowId}']['delete']>;
+type UpdateConfigurationRowStatePath = OpenapiPathType<paths['/v2/storage/branch/{branchId}/components/{componentId}/configs/{configurationId}/rows/{rowId}/state']['put']>;
+type UpdateConfigurationRowStateSchemaBody = OpenapiBodyType<paths['/v2/storage/branch/{branchId}/components/{componentId}/configs/{configurationId}/rows/{rowId}/state']['put']>;
+type RowPayload = {
+  isDisabled?: boolean | number;
+  configuration?: string | Record<string, unknown>;
+  state?: string | Record<string, unknown>;
+};
+type CreateConfigurationRowBody = RowPayload & {
+  rowId?: string;
+  name?: string;
+  description?: string;
+  changeDescription?: string;
+};
+type UpdateConfigurationRowBody = RowPayload & {
+  name?: string;
+  description?: string;
+  changeDescription?: string;
+};
+type UpdateConfigurationRowStateBody = Pick<RowPayload, 'state'>;
+type DeleteConfigurationRowBody = {
+  changeDescription?: string;
+};
+type CreateConfigurationRowInput = CreateConfigurationRowPath & CreateConfigurationRowBody;
+type CreateConfigurationRowsInput = CreateConfigurationRowPath & {
+  data: CreateConfigurationRowBody[];
+};
+type GetConfigurationRowInput = GetConfigurationRowPath;
+type UpdateConfigurationRowInput = UpdateConfigurationRowPath & UpdateConfigurationRowBody;
+type UpdateConfigurationRowStateInput = UpdateConfigurationRowStatePath & UpdateConfigurationRowStateBody;
+type DeleteConfigurationRowInput = DeleteConfigurationRowPath & DeleteConfigurationRowBody;
+type DeleteConfigurationRowsInput = Omit<DeleteConfigurationRowInput, 'rowId' | 'changeDescription'> & {
+  rowIds: string[];
+  changeDescription?: string | ((rowId: string) => string);
+};
+type Row = {
+  id: string;
+  name: string;
+  description: string;
+  isDisabled: boolean;
+  created: string;
+  creatorToken: CreatorToken;
+  changeDescription: string;
+  versionIdentifier: string;
+  state: Record<string, unknown>;
+  configuration: Record<string, unknown>;
+};
+type WrDbRow = Omit<Row, 'configuration'> & {
+  configuration: {
+    parameters?: {
+      dbName?: string;
+      incremental?: boolean;
+      items?: {
+        name: string;
+        dbName: string;
+        default: string;
+        nullable: boolean;
+        size: string;
+        type: number;
+      }[];
+      primaryKey?: string[];
+      tableId?: string;
+    };
+    storage?: {
+      input?: {
+        tables?: {
+          columns: string[];
+          destination: string;
+          overwrite: boolean;
+          source: string;
+        }[];
+      };
+    };
+  };
+};
+//#endregion
+//#region src/clients/storage/configurations/types.d.ts
+type CreateConfigurationSchemaBody = OpenapiBodyType<paths['/v2/storage/branch/{branchId}/components/{componentId}/configs']['post']>;
+type UpdateConfigurationSchemaBody = OpenapiBodyType<paths['/v2/storage/branch/{branchId}/components/{componentId}/configs/{configurationId}']['put']>;
+type UpdateConfigurationStateSchemaBody = OpenapiBodyType<paths['/v2/storage/branch/{branchId}/components/{componentId}/configs/{configurationId}/state']['put']>;
+type RebaseConfigurationSchemaBody = OpenapiBodyType<paths['/v2/storage/branch/{branchId}/components/{componentId}/configs/{configurationId}/rebase']['post']>;
+type SearchComponentConfigurationsSchemaQuery = OpenapiQueryType<paths['/v2/storage/branch/{branchId}/search/component-configurations']['get']>;
+type BranchId$2 = number | string | 'default';
+type GetSearchComponentConfigurationsPath = {
+  branchId?: BranchId$2;
+};
+type GetConfigurationsPath<ComponentId extends string = string> = {
+  branchId?: BranchId$2;
+  componentId: ComponentId;
+};
+type ConfigurationPath<ComponentId extends string = string> = {
+  configId: string;
+} & GetConfigurationsPath<ComponentId>;
+type CreatorToken = {
+  id: number;
+  description: string;
+};
+type CreateConfigurationBody<ConfigData extends Record<string, unknown> = Record<string, unknown>> = {
+  name: string;
+  description?: string;
+  changeDescription?: string;
+  isDisabled?: boolean;
+  /**
+   * Id to create the configuration under. Omit to have Storage generate one — which is what
+   * most callers want; pass it only to mirror an id that already exists somewhere else (the
+   * same configuration in another branch, a fixed id for a first-run flow).
+   */
+  configurationId?: string;
+  /**
+   * Omit it to have Storage create the configuration empty, which is what a "new configuration"
+   * flow with nothing filled in yet does.
+   */
+  configuration?: ConfigData;
+};
+type CreateConfigurationInput<ComponentId extends string = string, ConfigData extends Record<string, unknown> = Record<string, unknown>> = GetConfigurationsPath<ComponentId> & CreateConfigurationBody<ConfigData>;
+type UpdateConfigurationSchemaQuery = OpenapiQueryType<paths['/v2/storage/branch/{branchId}/components/{componentId}/configs/{configurationId}']['put']>;
+type UpdateConfigurationBody<ConfigData extends Record<string, unknown> = Record<string, unknown>> = {
+  name?: string;
+  description?: string;
+  changeDescription?: string;
+  isDisabled?: boolean;
+  configuration?: ConfigData;
+  state?: Record<string, unknown>;
+  rowsSortOrder?: string[];
+};
+type UpdateConfigurationInput<ComponentId extends string = string, ConfigData extends Record<string, unknown> = Record<string, unknown>> = ConfigurationPath<ComponentId> & UpdateConfigurationBody<ConfigData> & UpdateConfigurationSchemaQuery;
+type UpdateConfigurationResult<T extends ConfigType = 'unknown'> = {
+  /** The updated configuration. This part of the write is complete. */
+  configuration: ComponentConfig<T>;
+  /**
+   * The output-mapping sync job `workspaceId` enqueued, to poll via `jobs.getJob`.
+   *
+   * - `null` whenever no `workspaceId` was sent.
+   * - `null` for components outside Storage's sync allow-list, which ignore `workspaceId`.
+   */
+  syncJobId: number | null;
+};
+type DeleteConfigurationInput = Required<ConfigurationPath> & {
+  /**
+   * Configuration `version` the delete was decided on, sent as the `If-Match` precondition:
+   * Storage answers 412 when the configuration has moved on since it was read.
+   */
+  expectedVersion?: number;
+};
+type PurgeConfigurationInput = ConfigurationPath & {
+  /** Configuration `version` to purge, from the trash listing. Storage answers 428 without it. */
+  expectedVersion: number;
+};
+/** One `concurrent` fan-out over the whole trash, whatever component each configuration belongs to. */
+type PurgeConfigurationsInput = Pick<ConfigurationPath, 'branchId'> & {
+  configs: {
+    componentId: string;
+    configId: string;
+    expectedVersion: number;
+  }[];
+};
+type UpdateConfigurationStateBody = {
+  state?: string | Record<string, unknown>;
+};
+type UpdateConfigurationStateInput<ComponentId extends string = string> = ConfigurationPath<ComponentId> & UpdateConfigurationStateBody;
+type ConfigurationCurrentVersion = {
+  created: string;
+  creatorToken: CreatorToken;
+  changeDescription: string;
+  versionIdentifier: string;
+};
+type BaseComponentConfig<ConfigData extends Record<string, unknown> = Record<string, unknown>> = {
+  id: string;
+  name: string;
+  description: string;
+  created: string;
+  creatorToken: CreatorToken;
+  changeDescription: string;
+  isDisabled: boolean;
+  isDeleted: boolean;
+  version: number;
+  currentVersion: ConfigurationCurrentVersion;
+  rowsSortOrder: string[];
+  isSample?: boolean;
+  configuration?: ConfigData;
+  state: Record<string, unknown>;
+  rows: Row[];
+};
+type DataAppConfigConfiguration = {
+  authorization?: {
+    app_proxy: {
+      auth_providers: {
+        id: string;
+        type: string;
+      }[];
+      auth_rules: {
+        type: string;
+        value: string;
+        auth_required: boolean;
+        auth: string[];
+      }[];
+    };
+  };
+  parameters?: {
+    id: string;
+    autoSuspendAfterSeconds: number;
+    size: string;
+    script?: string[];
+    packages?: string[];
+    dataApp?: {
+      slug?: string;
+      secrets?: Record<string, string>;
+      streamlit?: {
+        'config.toml': string;
+      };
+      streamlitAuthEnabled?: boolean;
+      freezeDependencies?: boolean;
+    };
+  };
+};
+type DataAppConfigState = {
+  component?: unknown[];
+  storage?: {
+    input: {
+      tables: unknown[];
+      files: unknown[];
+    };
+  };
+  data_app?: {
+    'requirements.txt': string;
+  };
+};
+type DataAppConfig = Omit<BaseComponentConfig, 'configuration' | 'state'> & {
+  configuration: DataAppConfigConfiguration;
+  state: DataAppConfigState;
+};
+type WrDbConfig = BaseComponentConfig & {
+  configuration: {
+    parameters: {
+      db?: Omit<Partial<WorkspaceConnection>, 'backend'> & {
+        driver: string;
+        workspaceId?: number;
+      };
+    };
+  };
+  rows: WrDbRow[];
+};
+type DevBranchId = number | `${number}`;
+type ConfigurationDiffPath = {
+  branchId: DevBranchId;
+  componentId: string;
+  configId: string;
+};
+type ConfigurationDiffSideContent = {
+  name: string;
+  description: string;
+  changeDescription: string;
+  isDisabled: boolean;
+  configuration: Record<string, unknown>;
+};
+type ConfigurationDiffRow = {
+  id: string;
+  name: string;
+  description: string;
+  isDisabled: boolean;
+  configuration: Record<string, unknown>;
+};
+type ConfigurationDiffContent = ConfigurationDiffSideContent & {
+  rows: ConfigurationDiffRow[];
+};
+type ConfigurationDiffSide = {
+  version: number;
+  isDeleted: boolean;
+  diff: ConfigurationDiffContent;
+};
+type ConfigurationDiff = {
+  base: ConfigurationDiffSide | null;
+  ours: ConfigurationDiffSide | null;
+  theirs: ConfigurationDiffSide | null;
+};
+type RebaseConfigurationPath = ConfigurationDiffPath;
+type RebaseConfigurationRow = {
+  /** Omit to have the backend create a row with a generated id. */
+  id?: string;
+  name: string;
+  description: string;
+  isDisabled: boolean;
+  configuration: Record<string, unknown>;
+};
+type RebaseConfigurationDiff = {
+  /** Resolved configuration name (head). Required — a configuration always has a name. */
+  name: string;
+  /** Resolved configuration description (head, the 3-way diff result). */
+  description?: string;
+  /** Resolved configuration body (head, the 3-way diff result). */
+  configuration?: Record<string, unknown>;
+  /** Change description for the resolved head version. Defaults to a backend rebase message. */
+  changeDescription?: string;
+  /** Resolved disabled flag (head, the 3-way diff result). Defaults to false. */
+  isDisabled?: boolean;
+  /**
+   * Complete resolved row set (the diff's `diff.rows` sent back). Required for a
+   * keep rebase; `[]` deletes all rows. Array order = row sort order. Row `id`
+   * drives reconciliation: id in base → update, id absent from base or missing
+   * → create, base row whose id is absent from the request → delete.
+   */
+  rows: RebaseConfigurationRow[];
+};
+type RebaseConfigurationBody = {
+  /** Default-branch version to rebase the dev branch onto. */
+  version: number;
+  /**
+   * Resolved configuration content (the 3-way diff result) wrapped in the same
+   * envelope the /diff endpoint returns its sides in. The API also accepts an
+   * empty `diff` (`{}` or an empty string) to resolve the conflict by deleting
+   * the configuration — expressed through `rebaseConfigurationToDeleted`, never
+   * by widening this type (a keep rebase must not silently become a delete).
+   */
+  diff: RebaseConfigurationDiff;
+};
+type RebaseConfigurationInput = RebaseConfigurationPath & RebaseConfigurationBody;
+type RebaseConfigurationToDeletedInput = RebaseConfigurationPath & Pick<RebaseConfigurationBody, 'version'>;
+type ConfigType = 'data-app' | 'wr-db' | 'unknown';
+type ComponentConfig<T extends ConfigType = 'unknown'> = T extends 'data-app' ? DataAppConfig : T extends 'wr-db' ? WrDbConfig : BaseComponentConfig;
+type SearchComponentConfigurationsQuery = {
+  /**
+   * The API's field name, per the spec and what kbc-ui's legacy client sends in production. This
+   * used to be `componentId`, which Storage rejects with "This field was not expected" — the live
+   * nightly caught it, so the previous divergence from the spec was a bug, not a deliberate choice.
+   */
+  idComponent?: string | null;
+  configurationId?: string | null;
+  /** Comma-joined by the client, which is how the spec types it (`include?: string`). */
+  include?: 'filteredMetadata'[];
+  metadataKeys?: string[];
+};
+type SearchComponentConfigurationsInput = GetSearchComponentConfigurationsPath & SearchComponentConfigurationsQuery;
+type SearchComponentConfiguration = {
+  configurationId: string;
+  idComponent: string;
+  metadata?: {
+    id: string;
+    key: string;
+    timestamp: string;
+    value: string;
+  }[];
+};
+//#endregion
+//#region src/clients/storage/components/types.d.ts
+type GetComponentSchemaPath = OpenapiPathType<paths['/v2/storage/branch/{branchId}/components/{componentId}']['get']>;
+type GetComponentsSchemaPath = OpenapiPathType<paths['/v2/storage/branch/{branchId}/components']['get']>;
+type GetComponentsSchemaQuery = OpenapiQueryType<paths['/v2/storage/branch/{branchId}/components']['get']>;
+type BranchId$1 = number | string | 'default';
+type GetComponentsPath = {
+  branchId?: BranchId$1;
+};
+type GetComponentPath = Omit<GetComponentSchemaPath, 'branchId'> & {
+  branchId?: BranchId$1;
+};
+type GetComponentsQuery = Pick<GetComponentsSchemaQuery, 'componentType'> & {
+  include?: ('configuration' | 'rows' | 'state')[];
+  isDeleted?: boolean;
+};
+type GetComponentsInput = GetComponentsPath & GetComponentsQuery;
+type ComponentDefinition = {
+  type: string;
+  uri: string;
+  tag?: string;
+  digest?: string;
+};
+type ComponentVendor = {
+  contact?: string[];
+  licenseUrl?: string;
+};
+type ComponentLogging = {
+  verbosity?: Record<string, string>;
+  gelf_server_type?: string;
+  type?: string;
+};
+type ComponentStagingStorage = {
+  input: string;
+  output: string;
+};
+type ComponentData = {
+  configuration_format?: string;
+  default_bucket?: boolean;
+  default_bucket_stage?: string;
+  definition?: ComponentDefinition;
+  forward_token?: boolean;
+  forward_token_details?: boolean;
+  logging?: ComponentLogging;
+  network?: string;
+  staging_storage?: ComponentStagingStorage;
+  vendor?: ComponentVendor;
+};
+type ComponentDataTypesConfiguration = {
+  dataTypesSupport: 'none' | 'hints' | 'authoritative';
+};
+type ComponentProcessorConfiguration = {
+  allowedProcessorPosition: 'before' | 'after' | 'any';
+};
+type Component = StackComponent & {
+  longDescription?: string;
+  version: number;
+  complexity?: string | null;
+  hasUI: boolean;
+  hasRun: boolean;
+  ico32?: string;
+  data: ComponentData;
+  configurationSchema?: Record<string, unknown>;
+  configurationRowSchema?: Record<string, unknown>;
+  emptyConfiguration?: Record<string, unknown>;
+  emptyConfigurationRow?: Record<string, unknown>;
+  createConfigurationRowSchema?: Record<string, unknown>;
+  uiOptions?: Record<string, unknown>;
+  configurationDescription?: string;
+  expiredOn?: string | null;
+  dataTypesConfiguration?: ComponentDataTypesConfiguration;
+  processorConfiguration?: ComponentProcessorConfiguration;
+  uri: string;
+  documentationUrl?: string;
+  configurations?: ComponentConfig[];
+};
+//#endregion
+//#region src/clients/storage/configurationWorkspaces/types.d.ts
+type GetConfigurationWorkspacesPath = OpenapiPathType<paths['/v2/storage/branch/{branchId}/components/{componentId}/configs/{configurationId}/workspaces']['get']>;
+type CreateConfigurationWorkspacePath = OpenapiPathType<paths['/v2/storage/branch/{branchId}/components/{componentId}/configs/{configurationId}/workspaces']['post']>;
+type CreateConfigurationWorkspaceSchemaBody = OpenapiBodyType<paths['/v2/storage/branch/{branchId}/components/{componentId}/configs/{configurationId}/workspaces']['post']>;
+type BackendType = Exclude<NonNullable<CreateConfigurationWorkspaceSchemaBody['backend']>, 'abs'>;
+type LoginType = NonNullable<CreateConfigurationWorkspaceSchemaBody['loginType']>;
+type ConfigurationUseCaseType = NonNullable<CreateConfigurationWorkspaceSchemaBody['useCase']>;
+type CreateConfigurationWorkspaceBody = Omit<CreateConfigurationWorkspaceSchemaBody, 'backend' | 'readOnlyStorageAccess' | 'useCase'> & {
+  backend: BackendType;
+  readOnlyStorageAccess: boolean;
+  useCase: ConfigurationUseCaseType;
+};
+type CreateConfigurationWorkspaceInput = CreateConfigurationWorkspacePath & CreateConfigurationWorkspaceBody;
+//#endregion
+//#region src/clients/storage/configurationMetadata/types.d.ts
+type GetConfigurationMetadataPath = OpenapiPathType<paths['/v2/storage/branch/{branchId}/components/{componentId}/configs/{configurationId}/metadata']['get']>;
+type SaveConfigurationMetadataPath = OpenapiPathType<paths['/v2/storage/branch/{branchId}/components/{componentId}/configs/{configurationId}/metadata']['post']>;
+type SaveConfigurationMetadataSchemaBody = OpenapiBodyType<paths['/v2/storage/branch/{branchId}/components/{componentId}/configs/{configurationId}/metadata']['post']>;
+type DeleteConfigurationMetadataPath = OpenapiPathType<paths['/v2/storage/branch/{branchId}/components/{componentId}/configs/{configurationId}/metadata/{metadataId}']['delete']>;
+type ConfigurationMetadataItem = {
+  id: string;
+  key: string;
+  value: string;
+  timestamp: string;
+};
+type SaveConfigurationMetadataBody = {
+  metadata: {
+    key: string;
+    value: string;
+  }[];
+};
+type SaveConfigurationMetadataInput = SaveConfigurationMetadataPath & SaveConfigurationMetadataBody;
+type DeleteConfigurationMetadataInput = DeleteConfigurationMetadataPath;
+type GetConfigurationMetadataInput = GetConfigurationMetadataPath;
+//#endregion
+//#region src/clients/storage/configurationVersions/types.d.ts
+type ConfigurationVersionsSchemaPath = OpenapiPathType<paths['/v2/storage/branch/{branchId}/components/{componentId}/configs/{configurationId}/versions']['get']>;
+type ConfigurationVersionSchemaPath = OpenapiPathType<paths['/v2/storage/branch/{branchId}/components/{componentId}/configs/{configurationId}/versions/{versionId}']['get']>;
+type CopyConfigurationFromVersionSchemaBody = OpenapiBodyType<paths['/v2/storage/branch/{branchId}/components/{componentId}/configs/{configurationId}/versions/{versionId}/create']['post']>;
+type RollbackConfigurationToVersionSchemaBody = OpenapiBodyType<paths['/v2/storage/branch/{branchId}/components/{componentId}/configs/{configurationId}/versions/{versionId}/rollback']['post']>;
+type ConfigurationRowVersionsSchemaPath = OpenapiPathType<paths['/v2/storage/branch/{branchId}/components/{componentId}/configs/{configurationId}/rows/{rowId}/versions']['get']>;
+type ConfigurationRowVersionSchemaPath = OpenapiPathType<paths['/v2/storage/branch/{branchId}/components/{componentId}/configs/{configurationId}/rows/{rowId}/versions/{versionId}']['get']>;
+type CopyConfigurationRowFromVersionSchemaBody = OpenapiBodyType<paths['/v2/storage/branch/{branchId}/components/{componentId}/configs/{configurationId}/rows/{rowId}/versions/{versionId}/create']['post']>;
+type RollbackConfigurationRowToVersionSchemaBody = OpenapiBodyType<paths['/v2/storage/branch/{branchId}/components/{componentId}/configs/{configurationId}/rows/{rowId}/versions/{versionId}/rollback']['post']>;
+type BranchId = number | string | 'default';
+type VersionId = number | string;
+type ConfigurationVersionPath = Omit<ConfigurationVersionsSchemaPath, 'branchId'> & {
+  branchId: BranchId;
+};
+type ConfigurationVersionDetailPath = Omit<ConfigurationVersionSchemaPath, 'branchId' | 'versionId'> & {
+  branchId: BranchId;
+  versionId: VersionId;
+};
+/** Roll a configuration back to one of its versions. Takes no request body. */
+type RollbackConfigurationToVersionInput = Omit<ConfigurationVersionSchemaPath, 'branchId' | 'versionId'> & {
+  branchId?: BranchId;
+  versionId: VersionId;
+};
+type CopyConfigurationFromVersionPath = RollbackConfigurationToVersionInput;
+type CopyConfigurationFromVersionBody = {
+  name: string;
+  description?: string;
+};
+type CopyConfigurationFromVersionInput = CopyConfigurationFromVersionPath & CopyConfigurationFromVersionBody;
+type ConfigurationVersion = {
+  version: number;
+  created: string;
+  creatorToken: CreatorToken;
+  changeDescription: string;
+  name: string;
+  description: string;
+  versionIdentifier: string;
+};
+/**
+ * What the rollback endpoint answers with — only the new version number, and as a **string**, unlike
+ * the `number` the same field carries on `ConfigurationVersion`. The inconsistency is the API's; it is
+ * mirrored here rather than hidden, and the nightly smoke pins the string-ness.
+ */
+type RollbackConfigurationToVersionResult = {
+  version: string;
+};
+/** What the copy endpoint answers with — only the new configuration's id. */
+type CopyConfigurationFromVersionResult = {
+  id: string;
+};
+type ConfigurationVersionDetail = ConfigurationVersion & {
+  configuration: Record<string, unknown>;
+  state: Record<string, unknown>;
+  rowsSortOrder: string[];
+  rows: {
+    id: string;
+    version: number;
+    name: string;
+    description: string;
+    isDisabled: boolean;
+    configuration: Record<string, unknown>;
+    state: Record<string, unknown>;
+  }[];
+};
+type ConfigurationRowVersionPath = Omit<ConfigurationRowVersionsSchemaPath, 'branchId'> & {
+  branchId: BranchId;
+};
+type ConfigurationRowVersionDetailPath = Omit<ConfigurationRowVersionSchemaPath, 'branchId' | 'versionId'> & {
+  branchId: BranchId;
+  versionId: VersionId;
+};
+/** Roll a configuration row back to one of its versions. Takes no request body. */
+type RollbackConfigurationRowToVersionInput = Omit<ConfigurationRowVersionSchemaPath, 'branchId' | 'versionId'> & {
+  branchId?: BranchId;
+  versionId: VersionId;
+};
+type CopyConfigurationRowFromVersionInput = Omit<ConfigurationRowVersionSchemaPath, 'branchId' | 'versionId'> & {
+  branchId?: BranchId;
+  versionId: VersionId;
+};
+type ConfigurationRowVersion = {
+  version: number;
+  created: string;
+  creatorToken: CreatorToken;
+  changeDescription: string;
+  name: string;
+  description: string;
+  isDisabled: boolean;
+  versionIdentifier: string;
+};
+type ConfigurationRowVersionDetail = ConfigurationRowVersion & {
+  id: string;
+  configuration: Record<string, unknown>;
+  state: Record<string, unknown>;
+};
+//#endregion
+//#region src/clients/storage/mergeRequests/types.d.ts
+/**
+ * Both bodies are the spec's, with everything the API can default made optional.
+ *
+ * - The spec declares each field required and nullable; the API defaults an absent one.
+ * - Sending an explicit `null` is not the same request as omitting the key.
+ */
+type CreateMergeRequestSchemaBody = OpenapiBodyType<paths['/v2/storage/merge-request']['post']>;
+type CreateMergeRequestBody = Pick<CreateMergeRequestSchemaBody, 'branchFromId' | 'branchIntoId' | 'title'> & Partial<Omit<CreateMergeRequestSchemaBody, 'branchFromId' | 'branchIntoId' | 'title'>>;
+type UpdateMergeRequestSchemaBody = OpenapiBodyType<paths['/v2/storage/merge-request/{id}']['put']>;
+type UpdateMergeRequestBody = Partial<UpdateMergeRequestSchemaBody>;
+type UpdateMergeRequestInput = {
+  id: number;
+} & UpdateMergeRequestBody;
+type MergeRequest = OpenapiReturnType<paths['/v2/storage/merge-request']['get']>[number];
+type MergeRequestChangeLogEntry = {
+  isDeleted: boolean;
+  componentId: string;
+  configurationId: string;
+  lastVersionIdentifier?: string;
+};
+type MergeRequestChangeLog = {
+  configurations: MergeRequestChangeLogEntry[];
+};
+type MergeRequestDetail = Omit<components['schemas']['MergeRequestWithChangeLogResponse'], 'changeLog'> & {
+  changeLog?: MergeRequestChangeLog;
+};
+type MergeRequestReviewer = MergeRequest['reviewers'][number];
+type MergeRequestReviewerStatus = NonNullable<MergeRequestReviewer['status']>;
+type MergeRequestActivityLogEntry = NonNullable<components['schemas']['MergeRequestDetailResponse']['activityLog']>[number];
+type MergeRequestActivityEventType = MergeRequestActivityLogEntry['eventType'];
+type MergeRequestDetailWithActivityLog = MergeRequestDetail & {
+  activityLog?: MergeRequestActivityLogEntry[];
+};
+type MergeRequestConflict = OpenapiReturnType<paths['/v2/storage/merge-request/{id}/conflicts']['get']>[number];
+//#endregion
+//#region src/clients/storage/jobs/types.d.ts
+/**
+ * The statuses a storage job reports.
+ *
+ * - Terminal: `success` and `error`. There is no third outcome.
+ * - `StorageJobStatus` in `connection` backs these with an integer 1–4 and its `fromString` throws
+ *   on anything else, so `created`, `terminating`, `terminated`, `cancelled` and `warning` are
+ *   unrepresentable on a storage job — they are the queue's.
+ */
+type StorageJobStatus = 'waiting' | 'processing' | 'error' | 'success';
+type JobOperation = 'bucketDelete' | 'bucketListingCreate' | 'bucketListingUpdate' | 'bucketListingDelete' | 'bucketShareToOrganization' | 'bucketShareToOrganizationProject' | 'bucketShareToProjects' | 'bucketShareToAdmins' | 'bucketRemoveShare' | 'bucketForceUnlink' | 'bucketLink' | 'bucketRegister' | 'bucketRefresh' | 'devBranchCreate' | 'devBranchDelete' | 'workspaceDrop' | 'workspaceCreate' | 'workspaceOutputMappingSync' | 'tableDefinitionCreate' | 'tableDefinitionUpdate' | 'tableCreate' | 'tableExport' | 'tableImport' | 'tableRowsDelete' | 'tableSnapshotCreate' | 'aliasCreate' | 'devBranchTablePull' | 'tableColumnAdd' | 'tableColumnDelete' | 'tablePrimaryKeyAdd' | 'tablePrimaryKeyDelete' | 'workspaceBatchDeleteObjects';
+type JobResult<SuccessData = unknown, ErrorData = null> = {
+  status: 'success';
+  results: SuccessData;
+} | {
+  status: 'error';
+  results: ErrorData;
+  error: {
+    code: string;
+    message: string;
+    exceptionId?: string;
+  };
+} | {
+  status: Exclude<StorageJobStatus, 'success' | 'error'>;
+  results: null;
+};
+type JobBase<OperationName extends JobOperation | string = string, OperationValues extends Record<string, unknown> = Record<string, unknown>> = {
+  id: number;
+  tableId: string | null;
+  runId: string;
+  url: string;
+  createdTime: string;
+  creatorToken: {
+    id: string;
+    description: string;
+  };
+  endTime: string | null;
+  startTime: string | null;
+  operationName: OperationName;
+  operationParams: {
+    queue: string;
+  } & OperationValues;
+  metrics: {
+    inCompressed: boolean;
+    inBytes: number;
+    inBytesUncompressed: number;
+    outCompressed: boolean;
+    outBytes: number;
+    outBytesUncompressed: number;
+  };
+};
+type StorageJob<OperationName extends JobOperation | string = string, SuccessData = unknown, OperationValues extends Record<string, unknown> = Record<string, unknown>, ErrorData = null> = JobBase<OperationName, OperationValues> & JobResult<SuccessData, ErrorData>;
+type CreateDevBranchJob = StorageJob<'devBranchCreate', DevBranch, {
+  values: {
+    name: string;
+    description: string;
+  };
+}>;
+type DeleteDevBranchJob = StorageJob<'devBranchDelete', null, {
+  values: {
+    id: number;
+  };
+}>;
+type WorkspaceOutputMappingSyncJob = StorageJob<'workspaceOutputMappingSync', unknown, {
+  workspaceId: number;
+  targetConfigurationVersion: number;
+}>;
+type CreateWorkspaceJob = StorageJob<'workspaceCreate', Workspace, {
+  backend: string;
+  backendConfiguration: [];
+  backendSize: null;
+  branchId: number;
+  componentId: string;
+  configurationId: string;
+  loginType: number;
+  networkPolicy: string;
+  publicKey: string;
+  readOnlyStorageAccess: boolean;
+  useCase: ConfigurationUseCaseType;
+}>;
+type WorkspaceDropJob = StorageJob<'workspaceDrop', null, {
+  workspaceId: string;
+  backendConfiguration: [];
+}>;
+type TableDefinitionCreateJob = StorageJob<'tableDefinitionCreate', Table, {
+  timestampType: string;
+  primaryKeysNames: string[];
+  name: string;
+  backendConfiguration: unknown[];
+  columns: unknown[];
+}>;
+type TableDefinitionUpdateJob = StorageJob<'tableDefinitionUpdate', Table, {
+  tableId: string;
+  displayName: string;
+  description?: string | null;
+  columns: unknown[];
+}>;
+type TableCreateJob = StorageJob<'tableCreate', Table, {
+  id: string;
+}>;
+type TableExportJob = StorageJob<'tableExport', {
+  file: {
+    id: number;
+  };
+}, {
+  id: string;
+}>;
+type TableImportJob = StorageJob<'tableImport', Table, {
+  id: string;
+}>;
+type DeleteTableRowsJob = StorageJob<'tableRowsDelete', {
+  deletedRows: number;
+}, {
+  id: string;
+}>;
+type CreateSnapshotJob = StorageJob<'tableSnapshotCreate', null, {
+  id: string;
+}>;
+type PullTableJob = StorageJob<'devBranchTablePull', null, {
+  id: string;
+}>;
+type AddTableColumnJob = StorageJob<'tableColumnAdd', null, {
+  id: string;
+}>;
+type DeleteTableColumnJob = StorageJob<'tableColumnDelete', null, {
+  id: string;
+}>;
+type CreateTablePrimaryKeyJob = StorageJob<'tablePrimaryKeyAdd', null, {
+  id: string;
+}>;
+type RemoveTablePrimaryKeyJob = StorageJob<'tablePrimaryKeyDelete', null, {
+  id: string;
+}>;
+type CreateAliasJob = StorageJob<'aliasCreate', null, {
+  name: string;
+  sourceTable: string;
+}>;
+type DeleteBucketJob = StorageJob<'bucketDelete', null, {
+  id: string;
+}>;
+type BucketListingCreateJob = StorageJob<'bucketListingCreate', null, {
+  bucketId: string;
+}>;
+type BucketListingUpdateJob = StorageJob<'bucketListingUpdate', null, {
+  bucketId: string;
+}>;
+type BucketListingDeleteJob = StorageJob<'bucketListingDelete', null, {
+  bucketId: string;
+}>;
+type ShareBucketToOrganizationJob = StorageJob<'bucketShareToOrganization', null>;
+type ShareBucketToOrganizationProjectJob = StorageJob<'bucketShareToOrganizationProject', null>;
+type ShareBucketToProjectsJob = StorageJob<'bucketShareToProjects', null>;
+type ShareBucketToAdminsJob = StorageJob<'bucketShareToAdmins', null>;
+type RemoveBucketShareJob = StorageJob<'bucketRemoveShare', null>;
+type ForceUnlinkBucketJob = StorageJob<'bucketForceUnlink', null>;
+type LinkBucketJob = StorageJob<'bucketLink', BucketDetail>;
+type ExternalBucketWarning = {
+  message: string;
+};
+type RegisterBucketJob = StorageJob<'bucketRegister', {
+  id: string;
+  warnings?: ExternalBucketWarning[];
+}>;
+type RefreshBucketJob = StorageJob<'bucketRefresh', {
+  warnings?: ExternalBucketWarning[];
+}>;
+type WorkspaceBatchDeleteObjectResult = {
+  deleted: {
+    objectName: string;
+  }[];
+  failed: {
+    objectName: string;
+    error: string;
+  }[];
+};
+type DeleteWorkspaceObjectsJob = StorageJob<'workspaceBatchDeleteObjects', WorkspaceBatchDeleteObjectResult, {
+  workspaceId: string;
+  objects: string[];
+}, WorkspaceBatchDeleteObjectResult>;
+type GetJobPath = Omit<OpenapiPathType<paths['/v2/storage/jobs/{jobId}']['get']>, 'jobId'> & {
+  jobId: number;
+};
+type JobUnion = CreateDevBranchJob | DeleteDevBranchJob | DeleteBucketJob | BucketListingCreateJob | BucketListingUpdateJob | BucketListingDeleteJob | ShareBucketToOrganizationJob | ShareBucketToOrganizationProjectJob | ShareBucketToProjectsJob | ShareBucketToAdminsJob | RemoveBucketShareJob | ForceUnlinkBucketJob | LinkBucketJob | RegisterBucketJob | RefreshBucketJob | WorkspaceDropJob | CreateWorkspaceJob | TableDefinitionCreateJob | TableDefinitionUpdateJob | TableCreateJob | TableExportJob | TableImportJob | DeleteTableRowsJob | CreateSnapshotJob | PullTableJob | AddTableColumnJob | DeleteTableColumnJob | CreateTablePrimaryKeyJob | RemoveTablePrimaryKeyJob | CreateAliasJob | DeleteWorkspaceObjectsJob;
+type GetJobsSchemaQuery = OpenapiQueryType<paths['/v2/storage/jobs']['get']>;
+/**
+ * The list filters, deriving every one the spec names as a caller passes it.
+ *
+ * - Only the two repeatable filters are re-declared: the spec names them `storage_job_status[]` and
+ *   `excluded_storage_job_status[]`, where the brackets are the serializer's job (`queryArrayFormat`)
+ *   rather than the caller's.
+ * - Both narrow to `StorageJobStatus[]`, where the spec widens to `string[]`.
+ * - `StorageJobsListStatusFilter` in connection matches these against a column holding 1-4, so a
+ *   status from another service would filter on a value that cannot be stored.
+ */
+type GetJobsQuery = Omit<NonNullable<GetJobsSchemaQuery>, 'storage_job_status[]' | 'excluded_storage_job_status[]'> & {
+  storage_job_status?: StorageJobStatus[];
+  excluded_storage_job_status?: StorageJobStatus[];
+};
+type JobByOperation = {
+  bucketDelete: DeleteBucketJob;
+  bucketListingCreate: BucketListingCreateJob;
+  bucketListingUpdate: BucketListingUpdateJob;
+  bucketListingDelete: BucketListingDeleteJob;
+  bucketShareToOrganization: ShareBucketToOrganizationJob;
+  bucketShareToOrganizationProject: ShareBucketToOrganizationProjectJob;
+  bucketShareToProjects: ShareBucketToProjectsJob;
+  bucketShareToAdmins: ShareBucketToAdminsJob;
+  bucketRemoveShare: RemoveBucketShareJob;
+  bucketForceUnlink: ForceUnlinkBucketJob;
+  bucketLink: LinkBucketJob;
+  bucketRegister: RegisterBucketJob;
+  bucketRefresh: RefreshBucketJob;
+  devBranchCreate: CreateDevBranchJob;
+  devBranchDelete: DeleteDevBranchJob;
+  workspaceDrop: WorkspaceDropJob;
+  workspaceCreate: CreateWorkspaceJob;
+  workspaceOutputMappingSync: WorkspaceOutputMappingSyncJob;
+  tableDefinitionCreate: TableDefinitionCreateJob;
+  tableDefinitionUpdate: TableDefinitionUpdateJob;
+  tableCreate: TableCreateJob;
+  tableExport: TableExportJob;
+  tableImport: TableImportJob;
+  tableRowsDelete: DeleteTableRowsJob;
+  tableSnapshotCreate: CreateSnapshotJob;
+  devBranchTablePull: PullTableJob;
+  tableColumnAdd: AddTableColumnJob;
+  tableColumnDelete: DeleteTableColumnJob;
+  tablePrimaryKeyAdd: CreateTablePrimaryKeyJob;
+  tablePrimaryKeyDelete: RemoveTablePrimaryKeyJob;
+  aliasCreate: CreateAliasJob;
+  workspaceBatchDeleteObjects: DeleteWorkspaceObjectsJob;
+};
+type Job<T extends JobOperation | string = string> = T extends keyof JobByOperation ? JobByOperation[T] : JobUnion;
+//#endregion
+//#region src/clients/storage/triggers/types.d.ts
+type Trigger = OpenapiReturnType<paths['/v2/storage/triggers']['get']>[number];
+type GetTriggersQuery = OpenapiQueryType<paths['/v2/storage/triggers']['get']>;
+type CreateTriggerBody = OpenapiBodyType<paths['/v2/storage/triggers']['post']>;
+type UpdateTriggerRequest = OpenapiBodyType<paths['/v2/storage/triggers/{triggerId}']['put']>;
+type UpdateTriggerBody = Partial<UpdateTriggerRequest>;
+type UpdateTriggerInput = {
+  triggerId: Trigger['id'];
+} & UpdateTriggerBody;
+//#endregion
+//#region src/clients/storage/search/types.d.ts
+type GlobalSearchSchemaQuery = OpenapiQueryType<paths['/v2/storage/global-search']['get']>;
+type SearchTablesSchemaQuery = NonNullable<OpenapiQueryType<paths['/v2/storage/search/tables']['get']>>;
+/**
+ * Object types the `types` filter accepts, spec-derived so the allow-list can't drift. Narrower than
+ * `GlobalSearchItemType`: the spec has no `component` filter, though a hit can carry that type.
+ */
+type GlobalSearchFilterType = NonNullable<GlobalSearchSchemaQuery['types[]']>[number];
+/** Result categories returned by global search. */
+type GlobalSearchItemType = 'flow' | 'bucket' | 'table' | 'transformation' | 'component' | 'configuration' | 'configuration-row' | 'workspace' | 'shared-code';
+/** A single global-search hit. */
+type GlobalSearchItem = {
+  id: string;
+  type: GlobalSearchItemType;
+  componentId: string;
+  name: string;
+  organizationId: number;
+  projectId: number;
+  created: string;
+  /** Present only for `table` hits matched via column names — contains just the matched columns. */
+  matchedColumns?: string[];
+  fullPath: {
+    branch: {
+      id: number;
+      name: string;
+      isDefault: boolean;
+      isNative: boolean;
+    };
+    project: {
+      id: string;
+      name: string;
+    };
+    component?: {
+      id: string;
+      name: string;
+    };
+    configuration?: {
+      id: string;
+      name: string;
+    };
+    bucket?: {
+      id: string;
+      name: string;
+    };
+  };
+};
+/**
+ * Query for `GET /v2/storage/global-search`. Derived from the spec, minus its `[]` suffixes: the
+ * document names every repeatable filter the way PHP receives it (`types[]`), which is
+ * wire-serialization detail rather than something a caller should have to type — `globalSearch` casts
+ * back. `branchTypes` also stays `string[]` where the spec says `('production' | 'development')[]`,
+ * because callers build it from a set of filter strings.
+ */
+type GlobalSearchQuery = Omit<GlobalSearchSchemaQuery, 'types[]' | 'projectIds[]' | 'branchTypes[]' | 'branchIds[]'> & {
+  types?: GlobalSearchFilterType[];
+  projectIds?: number[];
+  branchTypes?: string[];
+  branchIds?: number[];
+};
+type GlobalSearchResponse = {
+  all: number;
+  items: GlobalSearchItem[];
+  byType: {
+    total: number;
+  } & Partial<Record<GlobalSearchItemType, number>>;
+  byProject: Record<number, string>;
+};
+/**
+ * Query for `GET /v2/storage/search/tables`. Two tightenings on top of the spec: at least one of the
+ * three metadata filters is required (the endpoint answers 400 without one), and `include` narrows
+ * from `string | string[]` to the one documented value, sent comma-joined like every other table read.
+ */
+type SearchTablesQuery = Omit<SearchTablesSchemaQuery, 'include' | 'metadataKey' | 'metadataValue' | 'metadataProvider'> & {
+  include?: 'buckets'[];
+} & ({
+  metadataKey: string;
+} | {
+  metadataValue: string;
+} | {
+  metadataProvider: string;
+});
+//#endregion
+//#region src/clients/storage/snapshots/types.d.ts
+type CreateSnapshotBody = OpenapiBodyType<paths['/v2/storage/branch/{branchId}/tables/{id}/snapshots']['post']>;
+type GetSnapshotsQuery = NonNullable<OpenapiQueryType<paths['/v2/storage/branch/{branchId}/tables/{id}/snapshots']['get']>>;
+/**
+ * A table snapshot. The schema types the list items as a bare `Record<string, never>` because the
+ * backend OpenAPI declares them as plain objects — this is the real shape.
+ */
+type Snapshot = {
+  id: string;
+  description: string;
+  created: string;
+  creatorToken: {
+    id: number;
+    description: string;
+  };
+};
+type CreateSnapshotInput = {
+  branchId: string;
+  tableId: string;
+} & CreateSnapshotBody;
+type GetTableSnapshotsInput = {
+  branchId: string;
+  tableId: string;
+} & GetSnapshotsQuery;
+//#endregion
+//#region src/clients/storage/stats/types.d.ts
+/** A table entry in run stats. Consumers currently only count entries; `id` identifies the table. */
+type RunIdTableStat = {
+  id: string;
+};
+/**
+ * Response of `GET /v2/storage/stats?runId=…` — import/export table stats for a job run.
+ * The generated schema stubs this operation, so the shape is hand-authored from the consumed paths.
+ */
+type RunIdStats = {
+  tables: {
+    import: {
+      tables: RunIdTableStat[];
+    };
+    export: {
+      tables: RunIdTableStat[];
+    };
+  };
+};
+//#endregion
+//#region src/clients/storage/types.d.ts
+/**
+ * Spec declares the index `query?: never` and its 200 contentless, so both ends are asserted in.
+ *
+ * - `exclude=componentDetails` is accepted; it trims the component registry out of the payload.
+ * - The whole parameters object is asserted, not just the query, since `never` admits no key.
+ */
+type GetStackInfoSchemaParams = OpenapiParametersType<paths['/v2/storage']['get']>;
+type GetStackInfoQuery = {
+  exclude: 'componentDetails';
+};
+type MetadataId = string | number;
+type ServiceId = 'vault' | 'data-science' | 'encryption' | 'telemetry' | 'ai' | 'editor' | 'import' | 'oauth' | 'query' | 'queue' | 'kai-assistant' | 'kai-agent' | 'sync-actions' | 'stream' | 'notification' | 'scheduler' | 'metastore';
+type Service = {
+  id: ServiceId;
+  url: string;
+};
+type ComponentType = 'extractor' | 'writer' | 'application' | 'transformation' | 'code-pattern' | 'other' | '';
+type StackComponent = {
+  id: string;
+  name: string;
+  type: ComponentType;
+  description: string;
+  features: unknown[];
+  categories: string[];
+  flags: string[];
+  ico64: string;
+  ico128: string;
+};
+type StackInfo = {
+  api: string;
+  documentation: string;
+  services: Service[];
+  components: StackComponent[];
+  features: string[];
+  host: string;
+  revision: string;
+  stack: string;
+  urlTemplates: {
+    orchestrationJob: string;
+  };
+  version: string;
+};
+type PartialKey<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
+//#endregion
+export { ConfigurationRowVersion as $, CreateBucketListingPath as $a, DeleteTableMetadataInput as $i, UpdateConfigurationRowInput as $n, UpdateBucketOwnerSchemaBody as $o, GetFileContentPath as $r, GetComponentsSchemaPath as $t, UpdateTriggerRequest as A, SaveTableMetadataPath as Aa, CreateTablePrimaryKeyPath as Ai, SearchComponentConfigurationsSchemaQuery as An, Bucket as Ao, WorkspaceInputMappingLoadPreviewResponse as Ar, SaveConfigurationMetadataPath as At, MergeRequest as B, TableImportAsyncBody as Ba, CreateTableAsyncBody as Bi, CreateConfigurationRowInput as Bn, DeleteBucketMetadataInput as Bo, DeleteDevBranchMetadataSchemaPath as Br, Component as Bt, SearchTablesQuery as C, Metadata as Ca, StorageEventRaw as Ci, RebaseConfigurationPath as Cn, ShareBucketToUsersPath as Co, UnloadWorkspaceQuery as Cr, ConfigurationMetadataItem as Ct, Trigger as D, PullTableAsyncPath as Da, AddTableColumnSchemaBody as Di, SearchComponentConfiguration as Dn, SharedBucketsQuery as Do, WorkspaceInputMappingLoadPreviewInput as Dr, GetConfigurationMetadataPath as Dt, GetTriggersQuery as E, PullTableAsyncInput as Ea, AddTableColumnPath as Ei, RebaseConfigurationToDeletedInput as En, SharedBuckets as Eo, WorkspaceInputMappingLoadPreviewBody as Er, GetConfigurationMetadataInput as Et, JobOperation as F, SetAliasTableFilterSchemaBody as Fa, DeleteTableColumnQuery as Fi, UpdateConfigurationSchemaQuery as Fn, BucketShared as Fo, BranchMetadataEntry as Fr, CreateConfigurationWorkspaceInput as Ft, MergeRequestConflict as G, UpdateTableDefinitionInput as Ga, CreateTableAsyncInput as Gi, DeleteConfigurationRowInput as Gn, GetBucketsQuery as Go, UpdateDevBranchInput as Gr, ComponentProcessorConfiguration as Gt, MergeRequestActivityLogEntry as H, TableMetadataResponse as Ha, CreateTableAsyncFromSnapshotBody as Hi, CreateConfigurationRowSchemaBody as Hn, GetBucketOwnerInput as Ho, DevBranchPath as Hr, ComponentDataTypesConfiguration as Ht, JobUnion as I, Table as Ia, RemoveTablePrimaryKeyInput as Ii, UpdateConfigurationStateBody as In, BucketStage as Io, BranchMetadataRaw as Ir, CreateConfigurationWorkspacePath as It, MergeRequestReviewer as J, UpdateTableInput as Ja, CreateTableDefinitionBody as Ji, DeleteConfigurationRowsInput as Jn, SaveBucketMetadataInput as Jo, AddFileTagInput as Jr, GetComponentPath as Jt, MergeRequestDetail as K, UpdateTableDefinitionPath as Ka, CreateTableAsyncPath as Ki, DeleteConfigurationRowPath as Kn, GetBucketsSchemaQuery as Ko, UpdateDevBranchSchemaBody as Kr, ComponentStagingStorage as Kt, StorageJobStatus as L, TableDetail as La, SaveColumnMetadataInput as Li, UpdateConfigurationStateInput as Ln, CreateBucketBody as Lo, CreateDevBranchBody as Lr, CreateConfigurationWorkspaceSchemaBody as Lt, GetJobsQuery as M, SetAliasTableFilterBody as Ma, DeleteColumnMetadataInput as Mi, UpdateConfigurationInput as Mn, BucketDetail as Mo, WorkspaceObject as Mr, BackendType as Mt, GetJobsSchemaQuery as N, SetAliasTableFilterInput as Na, DeleteTableColumnInput as Ni, UpdateConfigurationResult as Nn, BucketMetadata as No, WorkspaceRaw as Nr, ConfigurationUseCaseType as Nt, UpdateTriggerBody as O, SaveMetadataBody as Oa, CreateTablePrimaryKeyBody as Oi, SearchComponentConfigurationsInput as On, UnshareBucketInput as Oo, WorkspaceInputMappingLoadPreviewPath as Or, SaveConfigurationMetadataBody as Ot, Job as P, SetAliasTableFilterPath as Pa, DeleteTableColumnPath as Pi, UpdateConfigurationSchemaBody as Pn, BucketOwner as Po, WorkspaceSaml2Login as Pr, CreateConfigurationWorkspaceBody as Pt, UpdateMergeRequestSchemaBody as Q, CreateBucketListingInput as Qa, DeleteTableInput as Qi, UpdateConfigurationRowBody as Qn, UpdateBucketOwnerInput as Qo, File as Qr, GetComponentsQuery as Qt, CreateMergeRequestBody as R, TableExportAsyncBody as Ra, CreateAliasTableBody as Ri, UpdateConfigurationStateSchemaBody as Rn, CreateBucketSchemaBody as Ro, CreateDevBranchSchemaBody as Rr, GetConfigurationWorkspacesPath as Rt, GlobalSearchSchemaQuery as S, ImportAsyncPath as Sa, StorageEvent as Si, RebaseConfigurationInput as Sn, ShareBucketToUsersInput as So, UnloadWorkspacePath as Sr, RollbackConfigurationToVersionSchemaBody as St, CreateTriggerBody as T, PreviewData as Ta, AddTableColumnInput as Ti, RebaseConfigurationSchemaBody as Tn, ShareBucketToUsersSchemaQuery as To, WorkspaceConnection as Tr, DeleteConfigurationMetadataPath as Tt, MergeRequestChangeLog as U, UpdateTableBody as Ua, CreateTableAsyncFromTimeTravelBody as Ui, CreateConfigurationRowsInput as Un, GetBucketQuery as Uo, SaveDevBranchMetadataInput as Ur, ComponentDefinition as Ut, MergeRequestActivityEventType as V, TableImportAsyncSchemaBody as Va, CreateTableAsyncFromFileBody as Vi, CreateConfigurationRowPath as Vn, GetBucketInput as Vo, DevBranch as Vr, ComponentData as Vt, MergeRequestChangeLogEntry as W, UpdateTableDefinitionBody as Wa, CreateTableAsyncFromWorkspaceBody as Wi, DeleteConfigurationRowBody as Wn, GetBucketsInput as Wo, SaveDevBranchMetadataPath as Wr, ComponentLogging as Wt, UpdateMergeRequestBody as X, BucketListingDetail as Xa, CreateTableDefinitionPath as Xi, GetConfigurationRowPath as Xn, UpdateBucketInput as Xo, DeleteFilePath as Xr, GetComponentsInput as Xt, MergeRequestReviewerStatus as Y, WhereFilters as Ya, CreateTableDefinitionInput as Yi, GetConfigurationRowInput as Yn, UpdateBucketBody as Yo, AddFileTagPath as Yr, GetComponentSchemaPath as Yt, UpdateMergeRequestInput as Z, CreateBucketListingBody as Za, CreateTableDefinitionSchemaBody as Zi, Row as Zn, UpdateBucketOwnerBody as Zo, DeleteFileTagPath as Zr, GetComponentsPath as Zt, GlobalSearchFilterType as _, GetTablesInput as _a, GetEventsPath as _i, GetSearchComponentConfigurationsPath as _n, ShareBucketToProjectsInput as _o, ResetWorkspacePasswordPath as _r, CopyConfigurationRowFromVersionSchemaBody as _t, PartialKey as a, DeleteTableRowsSchemaQuery as aa, PreparedFile as ai, ConfigurationDiffContent as an, UpdateBucketListingPath as ao, UpdateConfigurationRowStateSchemaBody as ar, CreateScheduledRefreshPath as as, ConfigurationVersion as at, GlobalSearchQuery as b, GetTablesSchemaQuery as ba, GetTableEventsPath as bi, RebaseConfigurationBody as bn, ShareBucketToProjectsSchemaQuery as bo, SetWorkspacePublicKeyPath as br, RollbackConfigurationToVersionInput as bt, StackComponent as c, ExportAsyncInput as ca, CreateEventPath as ci, ConfigurationDiffSide as cn, ForceUnlinkBucketSchemaPath as co, DeleteWorkspaceObjectInput as cr, RegisterBucketBody as cs, ConfigurationVersionPath as ct, RunIdTableStat as d, GetDataPreviewInput as da, EventType as di, CreateConfigurationBody as dn, LinkBucketSchemaBody as do, DeleteWorkspacesInput as dr, ScheduledTask as ds, CopyConfigurationFromVersionBody as dt, DeleteTableMetadataPath as ea, GetFilePath as ei, GetComponentsSchemaQuery as en, CreateBucketListingSchemaBody as eo, UpdateConfigurationRowPath as er, BucketRegistrationGuide as es, ConfigurationRowVersionDetail as et, CreateSnapshotBody as f, GetDataPreviewPath as fa, GetBucketEventsInput as fi, CreateConfigurationInput as fn, ShareBucketToOrganizationInput as fo, GetWorkspaceObjectsPath as fr, CopyConfigurationFromVersionInput as ft, Snapshot as g, GetTablePath as ga, GetEventsInput as gi, GetConfigurationsPath as gn, ShareBucketToProjectsBody as go, ResetWorkspacePassword as gr, CopyConfigurationRowFromVersionInput as gt, GetTableSnapshotsInput as h, GetTableInput as ha, GetEventPath as hi, DeleteConfigurationInput as hn, ShareBucketToOrganizationSchemaQuery as ho, GetWorkspacesPath as hr, CopyConfigurationFromVersionSchemaBody as ht, MetadataId as i, DeleteTableRowsPath as ia, PrepareFileSchemaBody as ii, ConfigurationDiff as in, UpdateBucketListingInput as io, UpdateConfigurationRowStatePath as ir, CreateScheduledRefreshInput as is, ConfigurationRowVersionsSchemaPath as it, GetJobPath as j, SaveTableMetadataSchemaBody as ja, CreateTablePrimaryKeySchemaBody as ji, UpdateConfigurationBody as jn, BucketBackend as jo, WorkspaceLoginType as jr, SaveConfigurationMetadataSchemaBody as jt, UpdateTriggerInput as k, SaveTableMetadataInput as ka, CreateTablePrimaryKeyInput as ki, SearchComponentConfigurationsQuery as kn, UnshareBucketSchemaQuery as ko, WorkspaceInputMappingLoadPreviewQuery as kr, SaveConfigurationMetadataInput as kt, StackInfo as l, ExportAsyncPath as la, CreateEventSchemaBody as li, ConfigurationDiffSideContent as ln, ForceUnlinkBucketSchemaQuery as lo, DeleteWorkspaceObjectPath as lr, RegisterBucketSchemaBody as ls, ConfigurationVersionSchemaPath as lt, GetSnapshotsQuery as m, GetDataPreviewSchemaQuery as ma, GetBucketEventsQuery as mi, CreatorToken as mn, ShareBucketToOrganizationProjectSchemaQuery as mo, GetWorkspaceSaml2LoginPath as mr, CopyConfigurationFromVersionResult as mt, GetStackInfoQuery as n, DeleteTableRows as na, GetFilesSchemaParams as ni, ComponentConfig as nn, Subscriber as no, UpdateConfigurationRowStateBody as nr, BucketRegistrationGuideSchemaQuery as ns, ConfigurationRowVersionPath as nt, Service as o, DeleteTableSchemaQuery as oa, CreateEventBody as oi, ConfigurationDiffPath as on, UpdateBucketListingSchemaBody as oo, WrDbRow as or, RefreshExternalBucketInput as os, ConfigurationVersionDetail as ot, CreateSnapshotInput as p, GetDataPreviewQuery as pa, GetBucketEventsPath as pi, CreateConfigurationSchemaBody as pn, ShareBucketToOrganizationProjectInput as po, GetWorkspacePath as pr, CopyConfigurationFromVersionPath as pt, MergeRequestDetailWithActivityLog as q, UpdateTableDefinitionSchemaBody as qa, CreateTableAsyncSchemaBody as qi, DeleteConfigurationRowSchemaBody as qn, SaveBucketMetadataBody as qo, AddFileTagBody as qr, ComponentVendor as qt, GetStackInfoSchemaParams as r, DeleteTableRowsInput as ra, PrepareFileBody as ri, ConfigType as rn, UpdateBucketListingBody as ro, UpdateConfigurationRowStateInput as rr, CreateScheduledRefreshBody as rs, ConfigurationRowVersionSchemaPath as rt, ServiceId as s, DeleteTablesInput as sa, CreateEventInput as si, ConfigurationDiffRow as sn, ForceUnlinkBucketInput as so, DeleteWorkspaceObjectBody as sr, RefreshExternalBucketQuery as ss, ConfigurationVersionDetailPath as st, ComponentType as t, DeleteTablePath as ta, GetFilesQuery as ti, BaseComponentConfig as tn, ProjectBucketListing as to, UpdateConfigurationRowSchemaBody as tr, BucketRegistrationGuideQuery as ts, ConfigurationRowVersionDetailPath as tt, RunIdStats as u, FilterOperator as ua, CreatedEvent as ui, ConfigurationPath as un, LinkBucketBody as uo, DeleteWorkspacePath as ur, RegisterBucketSchemaQuery as us, ConfigurationVersionsSchemaPath as ut, GlobalSearchItem as v, GetTablesPath as va, GetEventsQuery as vi, PurgeConfigurationInput as vn, ShareBucketToProjectsPath as vo, SetWorkspacePublicInput as vr, RollbackConfigurationRowToVersionInput as vt, SearchTablesSchemaQuery as w, PrevieData as wa, AddTableColumnBody as wi, RebaseConfigurationRow as wn, ShareBucketToUsersSchemaBody as wo, Workspace as wr, DeleteConfigurationMetadataInput as wt, GlobalSearchResponse as x, ImportAsyncInput as xa, GetTableEventsQuery as xi, RebaseConfigurationDiff as xn, ShareBucketToUsersBody as xo, UnloadWorkspaceInput as xr, RollbackConfigurationToVersionResult as xt, GlobalSearchItemType as y, GetTablesQuery as ya, GetTableEventsInput as yi, PurgeConfigurationsInput as yn, ShareBucketToProjectsSchemaBody as yo, SetWorkspacePublicKeyBody as yr, RollbackConfigurationRowToVersionSchemaBody as yt, CreateMergeRequestSchemaBody as z, TableExportAsyncSchemaBody as za, CreateAliasTableInput as zi, CreateConfigurationRowBody as zn, DeleteBucketAsyncInput as zo, DeleteDevBranchMetadataPath as zr, LoginType as zt };
+//# sourceMappingURL=types-CC0wymfG.d.ts.map