@xylex-group/athena 2.13.0 → 3.0.0

package/dist/{client-DVOKSYDI.d.ts → v3-client-CuCNy-JJ.d.ts}

@@ -1,6 +1,7 @@
-import { i as AthenaJsonValue, a as AthenaGatewayCallOptions, g as AthenaJsonObject, j as AthenaRpcCallOptions, b as AthenaGatewayConnectionOptions, c as AthenaGatewayConnectionResult, w as AthenaFetchPayload, s as AthenaGatewayResponse, x as AthenaInsertPayload, y as AthenaUpdatePayload, v as AthenaDeletePayload, n as AthenaRpcPayload, C as AthenaQueryPayload, q as AthenaGatewayEndpointPath, r as AthenaGatewayMethod, D as AthenaGatewayBaseOptions, E as AthenaConditionValue, F as AthenaConditionArrayValue, G as AthenaGatewayCondition, H as AthenaSortBy, k as AthenaRpcFilter, o as BackendConfig, p as BackendType, e as AthenaGatewayErrorDetails, A as AthenaConditionCastType, I as AthenaConditionOperator } from './types-CH78O90i.js';
-import { F as AthenaAuthClientConfig, D as AthenaAuthBindings } from './types-eAKAh71s.js';
-import { A as AthenaModelTarget, n as RowOf, a as InsertOf, U as UpdateOf, u as AthenaClientTableName, s as AthenaClientModelForTableName, R as RegistryDef, D as DatabaseDef, o as SchemaDef, r as AnyModelDef, j as ModelDef, m as ModelRelationMetadata, t as AthenaClientModelsInput } from './types-BRP7sfSF.js';
+import { F as AthenaAuthClientConfig, D as AthenaAuthBindings } from './types-AOY-GLu8.js';
+import { e as AthenaGatewayErrorDetails, a as AthenaGatewayCallOptions, b as AthenaGatewayConnectionOptions, c as AthenaGatewayConnectionResult, x as AthenaFetchPayload, s as AthenaGatewayResponse, y as AthenaInsertPayload, z as AthenaUpdatePayload, w as AthenaDeletePayload, n as AthenaRpcPayload, j as AthenaRpcCallOptions, C as AthenaQueryPayload, i as AthenaJsonValue, g as AthenaJsonObject, q as AthenaGatewayEndpointPath, r as AthenaGatewayMethod, D as AthenaGatewayBaseOptions, E as AthenaConditionValue, F as AthenaConditionArrayValue, G as AthenaGatewayCondition, H as AthenaSortBy, k as AthenaRpcFilter, A as AthenaConditionCastType, I as AthenaConditionOperator, o as BackendConfig, p as BackendType } from './types-Bltx6iL6.js';
+import { A as AthenaModelTarget, n as RowOf, a as InsertOf, U as UpdateOf, u as AthenaClientTableName, s as AthenaClientModelForTableName, R as RegistryDef, D as DatabaseDef, o as SchemaDef, r as AnyModelDef, j as ModelDef, m as ModelRelationMetadata, t as AthenaClientModelsInput } from './types-jClgDy1J.js';
+import { a as AthenaBillingClientConfig, c as AthenaBillingModule } from './module-8dSMcy0K.js';
 
 type AthenaErrorKind = 'unique_violation' | 'not_found' | 'validation' | 'auth' | 'rate_limit' | 'transient' | 'unknown';
 declare const AthenaErrorKind: {
@@ -174,7 +175,7 @@ declare function coerceInt(value: unknown, options?: IntCoercionOptions): number
  */
 declare function assertInt(value: unknown, label?: string, options?: IntCoercionOptions): number;
 /**
- * @deprecated Prefer `experimental.retryReads` for standard SDK-managed read
+ * @deprecated Prefer `retryReads` for standard SDK-managed read
  * retries, or a call-site retry policy when you need custom write/replay
  * behavior. This helper is retained for compatibility.
  *
@@ -185,6 +186,89 @@ declare function assertInt(value: unknown, label?: string, options?: IntCoercion
  */
 declare function withRetry<T>(config: RetryConfig, fn: () => Promise<T>): Promise<T>;
 
+interface AthenaResult<T> {
+    data: T | null;
+    error: AthenaResultError | null;
+    statusText?: string | null;
+    /**
+     * @deprecated Prefer `error?.gatewayCode`, `error?.hint`, and related fields on `error`.
+     */
+    errorDetails?: AthenaGatewayErrorDetails | null;
+    status: number;
+    count?: number | null;
+    raw: unknown;
+}
+interface AthenaResultError {
+    message: string;
+    code: string | null;
+    athenaCode: NormalizedAthenaError['code'];
+    gatewayCode?: AthenaGatewayErrorDetails['code'] | null;
+    kind: NormalizedAthenaError['kind'];
+    category: NormalizedAthenaError['category'];
+    retryable: boolean;
+    details: unknown | null;
+    hint: string | null;
+    status: number;
+    statusText: string | null;
+    constraint?: string;
+    table?: string;
+    operation?: string;
+    endpoint?: AthenaGatewayErrorDetails['endpoint'];
+    method?: AthenaGatewayErrorDetails['method'];
+    requestId?: string;
+    cause?: string;
+    raw: unknown;
+}
+
+type AthenaRequestService = 'db' | 'auth' | 'chat' | 'storage';
+type AthenaRequestMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE' | 'HEAD' | 'OPTIONS';
+interface AthenaRequestQueryValueMap {
+    [key: string]: string | number | boolean | null | undefined | Array<string | number | boolean | null | undefined>;
+}
+interface AthenaRequestOptions {
+    service?: AthenaRequestService;
+    url?: string;
+    path?: string;
+    method?: AthenaRequestMethod;
+    headers?: Record<string, string>;
+    /** Per-request override for the canonical `X-Athena-Key` header. */
+    apiKey?: string | null;
+    query?: AthenaRequestQueryValueMap;
+    body?: RequestInit['body'] | Record<string, unknown> | unknown[] | null;
+    signal?: AbortSignal;
+    credentials?: RequestInit['credentials'];
+    responseType?: 'json' | 'text' | 'response';
+}
+interface AthenaRequestResponse<T = unknown> {
+    ok: boolean;
+    status: number;
+    statusText: string;
+    headers: Headers;
+    data: T | string | null;
+    raw: Response;
+}
+
+interface AthenaFindManyAstPayload$1 {
+    table_name: string;
+    select: Record<string, unknown>;
+    where?: Record<string, unknown>;
+    orderBy?: Record<string, unknown>;
+    limit?: number;
+}
+declare function verifyAthenaGatewayUrl(baseUrl: string, options?: AthenaGatewayConnectionOptions): Promise<AthenaGatewayConnectionResult>;
+interface AthenaGatewayClient {
+    baseUrl: string;
+    buildHeaders(options?: AthenaGatewayCallOptions): Record<string, string>;
+    resolveCallOptions(options?: AthenaGatewayCallOptions): Promise<AthenaGatewayCallOptions | undefined>;
+    verifyConnection(options?: AthenaGatewayConnectionOptions): Promise<AthenaGatewayConnectionResult>;
+    fetchGateway<T>(payload: AthenaFetchPayload | AthenaFindManyAstPayload$1, options?: AthenaGatewayCallOptions): Promise<AthenaGatewayResponse<T>>;
+    insertGateway<T>(payload: AthenaInsertPayload, options?: AthenaGatewayCallOptions): Promise<AthenaGatewayResponse<T>>;
+    updateGateway<T>(payload: AthenaUpdatePayload, options?: AthenaGatewayCallOptions): Promise<AthenaGatewayResponse<T>>;
+    deleteGateway<T>(payload: AthenaDeletePayload, options?: AthenaGatewayCallOptions): Promise<AthenaGatewayResponse<T>>;
+    rpcGateway<T>(payload: AthenaRpcPayload, options?: AthenaRpcCallOptions): Promise<AthenaGatewayResponse<T>>;
+    queryGateway<T>(payload: AthenaQueryPayload, options?: AthenaGatewayCallOptions): Promise<AthenaGatewayResponse<T>>;
+}
+
 type Whitespace = ' ' | '\n' | '\r' | '\t';
 type TrimLeft<TValue extends string> = TValue extends `${Whitespace}${infer TRest}` ? TrimLeft<TRest> : TValue;
 type TrimRight<TValue extends string> = TValue extends `${infer TRest}${Whitespace}` ? TrimRight<TRest> : TValue;
@@ -206,7 +290,7 @@ type AthenaSelectArrayElement<Row> = HasKnownSelectColumns<Row> extends true ? K
 type AthenaSelectInput = string | string[] | readonly string[];
 /**
  * Compile-time validation for `select` / `single` / `maybeSingle` when
- * `experimental.typecheckColumns` is enabled and row keys are known.
+ * row keys are known.
  *
  * - Comma-separated strings: validates each simple token (aliases / relation
  *   syntax are allowed through).
@@ -215,63 +299,41 @@ type AthenaSelectInput = string | string[] | readonly string[];
  */
 type AthenaValidatedSelectInput<Row, TValue extends AthenaSelectInput> = HasKnownSelectColumns<Row> extends true ? TValue extends readonly string[] ? readonly AthenaSelectArrayElement<Row>[] : TValue extends string ? ValidateSelectList<Row, TValue> : never : TValue;
 /**
- * Filter / order / RPC column parameter when `typecheckColumns` is enabled.
- * When disabled, still surfaces known keys for IntelliSense via
- * `Keys | (string & {})` so free-form strings remain assignable.
+ * Filter / order / RPC column parameter. Known model keys are closed; dynamic
+ * rows retain free-form string support.
  */
-type AthenaTypecheckedColumnKey<Row, TEnabled extends boolean> = TEnabled extends true ? HasKnownSelectColumns<Row> extends true ? KnownSelectColumnKey<Row> : string : HasKnownSelectColumns<Row> extends true ? KnownSelectColumnKey<Row> | (string & {}) : string;
+type AthenaTypecheckedColumnKey<Row> = HasKnownSelectColumns<Row> extends true ? KnownSelectColumnKey<Row> : string;
 
-type AthenaRowShape$2 = Record<string, AthenaJsonValue | undefined>;
-/**
- * Free-form `from<Row>(table)` table argument.
- * With client `models`, this is the known table-name union (IntelliSense).
- * Without models, plain `string`.
- */
-type UntypedTableName$1<TModels> = [TModels] extends [never] ? string : [AthenaClientTableName<TModels>] extends [never] ? string : AthenaClientTableName<TModels>;
-type ResolvedClientTableModel$1<TModels, TTableName extends string> = Extract<AthenaClientModelForTableName<TModels, TTableName>, AthenaModelTarget>;
-type ClientTableQueryBuilder$1<TModels, TTableName extends string, TStrict extends boolean> = TableQueryBuilder<RowOf<ResolvedClientTableModel$1<TModels, TTableName>>, InsertOf<ResolvedClientTableModel$1<TModels, TTableName>>, UpdateOf<ResolvedClientTableModel$1<TModels, TTableName>>, unknown, TStrict>;
+type AthenaRowShape$1 = Record<string, AthenaJsonValue | undefined>;
+type UntypedTableName<TModels> = [TModels] extends [never] ? string : [AthenaClientTableName<TModels>] extends [never] ? string : AthenaClientTableName<TModels>;
+type ResolvedClientTableModel<TModels, TTableName extends string> = Extract<AthenaClientModelForTableName<TModels, TTableName>, AthenaModelTarget>;
+type ClientTableQueryBuilder<TModels, TTableName extends string> = TableQueryBuilder<RowOf<ResolvedClientTableModel<TModels, TTableName>>, InsertOf<ResolvedClientTableModel<TModels, TTableName>>, UpdateOf<ResolvedClientTableModel<TModels, TTableName>>>;
 type AthenaUpsertOptions<Update> = AthenaGatewayCallOptions & {
     updateBody?: Update;
     onConflict?: string | string[];
 };
-interface AthenaDbModule<TStrict extends boolean = false, TModels = never> {
-    from<TModel extends AthenaModelTarget>(model: TModel): TableQueryBuilder<RowOf<TModel>, InsertOf<TModel>, UpdateOf<TModel>, unknown, TStrict>;
-    from<TTableName extends AthenaClientTableName<TModels>>(table: TTableName, options?: AthenaFromOptions): ClientTableQueryBuilder$1<TModels, TTableName, TStrict>;
-    from<Row = AthenaRowShape$2, Insert = Partial<Row>, Update = Partial<Insert>>(table: UntypedTableName$1<TModels>, options?: AthenaFromOptions): TableQueryBuilder<Row, Insert, Update, unknown, TStrict>;
-    select<Row = AthenaRowShape$2>(table: UntypedTableName$1<TModels>, options?: AthenaGatewayCallOptions): SelectChain<Row, Row, TStrict>;
-    select(table: UntypedTableName$1<TModels>, columns: AthenaSelectInput, options?: AthenaGatewayCallOptions): SelectChain<AthenaRowShape$2, AthenaRowShape$2, TStrict>;
-    insert<Row = AthenaRowShape$2, Insert = Partial<Row>>(table: UntypedTableName$1<TModels>, values: Insert, options?: AthenaGatewayCallOptions): MutationQuery<Row, Row, TStrict>;
-    insert<Row = AthenaRowShape$2, Insert = Partial<Row>>(table: UntypedTableName$1<TModels>, values: Insert[], options?: AthenaGatewayCallOptions): MutationQuery<Row[], Row, TStrict>;
-    upsert<Row = AthenaRowShape$2, Insert = Partial<Row>, Update = Partial<Insert>>(table: UntypedTableName$1<TModels>, values: Insert, options?: AthenaUpsertOptions<Update>): MutationQuery<Row, Row, TStrict>;
-    upsert<Row = AthenaRowShape$2, Insert = Partial<Row>, Update = Partial<Insert>>(table: UntypedTableName$1<TModels>, values: Insert[], options?: AthenaUpsertOptions<Update>): MutationQuery<Row[], Row, TStrict>;
-    update<Row = AthenaRowShape$2, Insert = Partial<Row>, Update = Partial<Insert>>(table: UntypedTableName$1<TModels>, values: Update, options?: AthenaGatewayCallOptions): UpdateChain<Row, TStrict>;
-    delete<Row = AthenaRowShape$2>(table: UntypedTableName$1<TModels>, options?: AthenaGatewayCallOptions & {
+interface AthenaDbModule<TModels = never> {
+    from<TModel extends AthenaModelTarget>(model: TModel): TableQueryBuilder<RowOf<TModel>, InsertOf<TModel>, UpdateOf<TModel>>;
+    from<TTableName extends AthenaClientTableName<TModels>>(table: TTableName, options?: AthenaFromOptions): ClientTableQueryBuilder<TModels, TTableName>;
+    from<Row = AthenaRowShape$1, Insert = Partial<Row>, Update = Partial<Insert>>(table: UntypedTableName<TModels>, options?: AthenaFromOptions): TableQueryBuilder<Row, Insert, Update>;
+    select<Row = AthenaRowShape$1>(table: UntypedTableName<TModels>, options?: AthenaGatewayCallOptions): SelectChain<Row, Row>;
+    select(table: UntypedTableName<TModels>, columns: AthenaSelectInput, options?: AthenaGatewayCallOptions): SelectChain<AthenaRowShape$1, AthenaRowShape$1>;
+    insert<Row = AthenaRowShape$1, Insert = Partial<Row>>(table: UntypedTableName<TModels>, values: Insert, options?: AthenaGatewayCallOptions): MutationQuery<Row, Row>;
+    insert<Row = AthenaRowShape$1, Insert = Partial<Row>>(table: UntypedTableName<TModels>, values: Insert[], options?: AthenaGatewayCallOptions): MutationQuery<Row[], Row>;
+    upsert<Row = AthenaRowShape$1, Insert = Partial<Row>, Update = Partial<Insert>>(table: UntypedTableName<TModels>, values: Insert, options?: AthenaUpsertOptions<Update>): MutationQuery<Row, Row>;
+    upsert<Row = AthenaRowShape$1, Insert = Partial<Row>, Update = Partial<Insert>>(table: UntypedTableName<TModels>, values: Insert[], options?: AthenaUpsertOptions<Update>): MutationQuery<Row[], Row>;
+    update<Row = AthenaRowShape$1, Insert = Partial<Row>, Update = Partial<Insert>>(table: UntypedTableName<TModels>, values: Update, options?: AthenaGatewayCallOptions): UpdateChain<Row>;
+    delete<Row = AthenaRowShape$1>(table: UntypedTableName<TModels>, options?: AthenaGatewayCallOptions & {
         resourceId?: string;
-    }): MutationQuery<Row | null, Row, TStrict>;
-    rpc<Row = unknown, Args extends AthenaJsonObject = AthenaJsonObject>(fn: string, args?: Args, options?: AthenaRpcCallOptions): RpcQueryBuilder<Row, TStrict>;
+    }): MutationQuery<Row | null, Row>;
+    rpc<Row = unknown, Args extends AthenaJsonObject = AthenaJsonObject>(fn: string, args?: Args, options?: AthenaRpcCallOptions): RpcQueryBuilder<Row>;
     query<Row = unknown>(query: string, options?: AthenaGatewayCallOptions): Promise<AthenaResult<Row[]>>;
 }
 
-interface AthenaFindManyAstPayload$1 {
-    table_name: string;
-    select: Record<string, unknown>;
-    where?: Record<string, unknown>;
-    orderBy?: Record<string, unknown>;
-    limit?: number;
-}
-declare function verifyAthenaGatewayUrl(baseUrl: string, options?: AthenaGatewayConnectionOptions): Promise<AthenaGatewayConnectionResult>;
-interface AthenaGatewayClient {
-    baseUrl: string;
-    buildHeaders(options?: AthenaGatewayCallOptions): Record<string, string>;
-    verifyConnection(options?: AthenaGatewayConnectionOptions): Promise<AthenaGatewayConnectionResult>;
-    fetchGateway<T>(payload: AthenaFetchPayload | AthenaFindManyAstPayload$1, options?: AthenaGatewayCallOptions): Promise<AthenaGatewayResponse<T>>;
-    insertGateway<T>(payload: AthenaInsertPayload, options?: AthenaGatewayCallOptions): Promise<AthenaGatewayResponse<T>>;
-    updateGateway<T>(payload: AthenaUpdatePayload, options?: AthenaGatewayCallOptions): Promise<AthenaGatewayResponse<T>>;
-    deleteGateway<T>(payload: AthenaDeletePayload, options?: AthenaGatewayCallOptions): Promise<AthenaGatewayResponse<T>>;
-    rpcGateway<T>(payload: AthenaRpcPayload, options?: AthenaRpcCallOptions): Promise<AthenaGatewayResponse<T>>;
-    queryGateway<T>(payload: AthenaQueryPayload, options?: AthenaGatewayCallOptions): Promise<AthenaGatewayResponse<T>>;
-}
-
+/** Files at or above this size use multipart unless `forceSinglePut` is set. */
+declare const DEFAULT_MULTIPART_THRESHOLD_BYTES: number;
+/** Chunk size for multipart uploads (S3 requires >= 5 MiB except the last part). */
+declare const DEFAULT_MULTIPART_PART_SIZE_BYTES: number;
 type AthenaStorageTemplateValue = string | number | boolean | null | undefined;
 type AthenaStorageTemplateVars = Record<string, AthenaStorageTemplateValue>;
 type AthenaStorageEnv = Record<string, string | undefined>;
@@ -296,6 +358,7 @@ interface AthenaStorageFileConfig {
     prefixPath?: AthenaStoragePrefixPath;
     vars?: AthenaStorageTemplateVars;
     env?: AthenaStorageEnv;
+    directUpload?: AthenaStorageDirectUploadConfig;
 }
 type AthenaStorageUploadSource = Blob | ArrayBuffer | Uint8Array;
 interface AthenaStorageUploadConstraints {
@@ -316,6 +379,12 @@ interface AthenaStorageUploadProgress {
     aggregateLoaded: number;
     aggregateTotal: number;
     aggregatePercent: number;
+    /** Present when the active file is uploading via multipart. */
+    multipart?: {
+        uploadId: string;
+        partNumber: number;
+        partCount: number;
+    };
 }
 type AthenaStorageUploadProgressHandler = (progress: AthenaStorageUploadProgress) => void;
 interface AthenaStorageFileUploadInput extends AthenaStorageUploadConstraints, StorageServerSideEncryptionOptions {
@@ -343,6 +412,14 @@ interface AthenaStorageFileUploadInput extends AthenaStorageUploadConstraints, S
     env?: AthenaStorageEnv;
     uploadHeaders?: AthenaStorageUploadHeaders;
     onProgress?: AthenaStorageUploadProgressHandler;
+    /** Override auto-multipart threshold (default 32 MiB). */
+    multipartThresholdBytes?: number;
+    /** Override multipart chunk size (default 8 MiB, minimum 5 MiB). */
+    multipartPartSizeBytes?: number;
+    /** Always use a single PUT even when the file exceeds the multipart threshold. */
+    forceSinglePut?: boolean;
+    /** Always use multipart even when the file is below the threshold. */
+    forceMultipart?: boolean;
 }
 interface AthenaStorageUploadedFile {
     file: ManagedFileRecord;
@@ -375,6 +452,7 @@ interface AthenaStorageFileDownloadInput extends GetStorageFileUrlQuery {
 type AthenaStorageFileDeleteInput = string | readonly string[];
 interface AthenaStorageFileModule {
     upload(input: AthenaStorageFileUploadInput, options?: AthenaStorageCallOptions): Promise<AthenaStorageFileUploadResult>;
+    uploadMultipart(input: AthenaStorageFileUploadInput, options?: AthenaStorageCallOptions): Promise<AthenaStorageFileUploadResult>;
     download(fileId: string, query?: GetStorageFileUrlQuery, options?: AthenaStorageBinaryCallOptions): Promise<Response>;
     download(fileIds: readonly string[], query?: GetStorageFileUrlQuery, options?: AthenaStorageBinaryCallOptions): Promise<Response[]>;
     download(input: AthenaStorageFileDownloadInput, options?: AthenaStorageBinaryCallOptions): Promise<Response | Response[]>;
@@ -382,6 +460,146 @@ interface AthenaStorageFileModule {
     delete(fileId: string, options?: AthenaStorageCallOptions): Promise<StorageFileMutationResponse>;
     delete(fileIds: readonly string[], options?: AthenaStorageCallOptions): Promise<StorageFileMutationResponse[]>;
 }
+interface AthenaStorageFileBaseModule {
+    createStorageUploadUrl(input: CreateStorageUploadUrlRequest, options?: AthenaStorageCallOptions): Promise<StorageUploadUrlResponse>;
+    createStorageUploadUrls(input: {
+        files: CreateStorageUploadUrlRequest[];
+    }, options?: AthenaStorageCallOptions): Promise<StorageBatchUploadUrlResponse>;
+    listStorageFiles(input: ListStorageFilesRequest, options?: AthenaStorageCallOptions): Promise<StorageListFilesResponse>;
+    getStorageFileProxy(fileId: string, query?: GetStorageFileUrlQuery, options?: AthenaStorageBinaryCallOptions): Promise<Response>;
+    deleteStorageFile(fileId: string, options?: AthenaStorageCallOptions): Promise<StorageFileMutationResponse>;
+}
+interface AthenaStorageMultipartClient {
+    create(input: StorageMultipartCreateRequest, options?: AthenaStorageCallOptions): Promise<Record<string, unknown>>;
+    signPart(input: StorageMultipartSignPartRequest, options?: AthenaStorageCallOptions): Promise<Record<string, unknown>>;
+    complete(input: StorageMultipartCompleteRequest, options?: AthenaStorageCallOptions): Promise<StorageFileMutationResponse>;
+    abort(input: StorageMultipartAbortRequest, options?: AthenaStorageCallOptions): Promise<Record<string, unknown>>;
+}
+declare function createStorageFileModule(base: AthenaStorageFileBaseModule, config?: AthenaStorageFileConfig, multipart?: AthenaStorageMultipartClient): AthenaStorageFileModule;
+declare function resolveStoragePath(path: string, input: {
+    prefixPath?: AthenaStoragePrefixPath;
+    vars?: AthenaStorageTemplateVars;
+    env?: AthenaStorageEnv;
+    organization_id?: string;
+    organizationId?: string;
+    user_id?: string;
+    userId?: string;
+    resource_id?: string;
+    resourceId?: string;
+}, options: AthenaStorageCallOptions | undefined, config?: AthenaStorageFileConfig): string;
+
+/**
+ * Admin backup surface exposed under `client.storage.backup.*`.
+ *
+ * Routes live at `/admin/backups*` (admin / elevated key). Archives land in the
+ * server-configured S3 or R2 profile (`ATHENA_BACKUP_S3_*` including provider + account_id).
+ */
+
+type BackupRecoveryStrategy = 'none' | 'repair_missing_role_oids';
+interface StorageBackupRecord {
+    job_id: number;
+    s3_bucket: string;
+    s3_key: string;
+    /** Alias of s3_key for convenience */
+    key: string;
+    client_name: string;
+    label?: string | null;
+    size_bytes: number;
+    execution_daemon_id?: string | null;
+    completed_at: string;
+}
+interface StorageBackupListPage {
+    backups: StorageBackupRecord[];
+    next_cursor: string | null;
+}
+interface StorageBackupListQuery {
+    client_name?: string;
+    cursor?: string | null;
+    limit?: number;
+}
+interface StorageBackupCreateRequest {
+    client_name: string;
+    label?: string;
+    pg_uri?: string;
+    recovery_strategy?: BackupRecoveryStrategy;
+}
+interface StorageBackupQueuedJob {
+    job_id: number;
+    client_name: string;
+    status: string;
+    key?: string;
+}
+interface StorageBackupRestoreRequest {
+    client_name: string;
+    pg_uri?: string;
+}
+interface StorageBackupJob {
+    id: number;
+    job_type: string;
+    client_name?: string | null;
+    status: string;
+    progress_pct?: number | null;
+    progress_stage?: string | null;
+    s3_bucket?: string | null;
+    s3_key?: string | null;
+    label?: string | null;
+    error_message?: string | null;
+    created_at?: string;
+    updated_at?: string;
+    completed_at?: string | null;
+    [key: string]: unknown;
+}
+interface StorageBackupSchedule {
+    id: number;
+    client_name: string;
+    frequency?: string;
+    enabled?: boolean;
+    label?: string | null;
+    [key: string]: unknown;
+}
+interface StorageBackupScheduleCreateRequest {
+    client_name: string;
+    frequency: string;
+    time_of_day?: string;
+    day_of_week?: number;
+    day_of_month?: number;
+    label?: string;
+    execution_daemon_id?: string;
+    enabled?: boolean;
+    [key: string]: unknown;
+}
+interface AthenaStorageBackupNamespace {
+    /** `GET /admin/backups` */
+    list(query?: StorageBackupListQuery, options?: AthenaStorageCallOptions): Promise<StorageBackupListPage>;
+    /** `POST /admin/backups` — queue a backup job */
+    create(input: StorageBackupCreateRequest, options?: AthenaStorageCallOptions): Promise<StorageBackupQueuedJob>;
+    /** `POST /admin/backups/{key}/restore` */
+    restore(key: string, input: StorageBackupRestoreRequest, options?: AthenaStorageCallOptions): Promise<StorageBackupQueuedJob>;
+    /** `DELETE /admin/backups/{key}` */
+    delete(key: string, options?: AthenaStorageCallOptions): Promise<void>;
+    /** Build a browser download URL for `GET /admin/backups/{key}/download` */
+    downloadUrl(key: string, options?: {
+        apiKey?: string;
+    }): string;
+    jobs: {
+        list(query?: {
+            limit?: number;
+            status?: string;
+            client_name?: string;
+        }, options?: AthenaStorageCallOptions): Promise<StorageBackupJob[]>;
+        get(jobId: number | string, options?: AthenaStorageCallOptions): Promise<StorageBackupJob>;
+        cancel(jobId: number | string, options?: AthenaStorageCallOptions): Promise<Record<string, unknown>>;
+        delete(jobId: number | string, options?: AthenaStorageCallOptions): Promise<void>;
+        /** Presigned/console open link for the job archive object (S3 or R2) */
+        openObjectUrl(jobId: number | string, options?: AthenaStorageCallOptions): Promise<string>;
+    };
+    schedules: {
+        list(options?: AthenaStorageCallOptions): Promise<StorageBackupSchedule[]>;
+        create(input: StorageBackupScheduleCreateRequest, options?: AthenaStorageCallOptions): Promise<StorageBackupSchedule>;
+        update(id: number | string, input: Partial<StorageBackupScheduleCreateRequest>, options?: AthenaStorageCallOptions): Promise<StorageBackupSchedule>;
+        delete(id: number | string, options?: AthenaStorageCallOptions): Promise<void>;
+    };
+}
 
 declare const storageSdkManifest: {
     readonly namespace: "storage";
@@ -424,6 +642,47 @@ declare const storageSdkManifest: {
         readonly path: "/storage/credentials";
         readonly responseEnvelope: "raw";
         readonly responseType: "{ data: S3CredentialListItem[] }";
+    }, {
+        readonly name: "backup.list";
+        readonly method: "GET";
+        readonly path: "/admin/backups";
+        readonly responseEnvelope: "athena";
+        readonly responseType: "StorageBackupListPage";
+        readonly note: "Admin backup archives on server S3/R2 profile";
+    }, {
+        readonly name: "backup.create";
+        readonly method: "POST";
+        readonly path: "/admin/backups";
+        readonly requestType: "StorageBackupCreateRequest";
+        readonly responseEnvelope: "athena";
+        readonly responseType: "StorageBackupQueuedJob";
+    }, {
+        readonly name: "backup.restore";
+        readonly method: "POST";
+        readonly path: "/admin/backups/{key}/restore";
+        readonly pathParams: readonly ["key"];
+        readonly requestType: "StorageBackupRestoreRequest";
+        readonly responseEnvelope: "athena";
+        readonly responseType: "StorageBackupQueuedJob";
+    }, {
+        readonly name: "backup.delete";
+        readonly method: "DELETE";
+        readonly path: "/admin/backups/{key}";
+        readonly pathParams: readonly ["key"];
+        readonly responseEnvelope: "athena";
+        readonly responseType: "void";
+    }, {
+        readonly name: "backup.jobs.list";
+        readonly method: "GET";
+        readonly path: "/admin/backups/jobs";
+        readonly responseEnvelope: "athena";
+        readonly responseType: "StorageBackupJob[]";
+    }, {
+        readonly name: "backup.schedules.list";
+        readonly method: "GET";
+        readonly path: "/admin/backups/schedules";
+        readonly responseEnvelope: "athena";
+        readonly responseType: "StorageBackupSchedule[]";
     }, {
         readonly name: "createStorageUploadUrl";
         readonly method: "POST";
@@ -1019,10 +1278,24 @@ interface StorageServerSideEncryptionOptions {
 }
 interface CreateStorageCatalogRequest {
     name: string;
-    endpoint: string;
-    region: string;
+    /**
+     * S3-compatible API endpoint.
+     * Optional when `provider` is R2 and `account_id` (or `metadata.account_id`) is set;
+     * the Athena server derives `https://{account_id}.r2.cloudflarestorage.com`.
+     */
+    endpoint?: string;
+    /**
+     * Region. Optional for R2 (server defaults to `auto` after normalize).
+     */
+    region?: string;
     bucket: string;
+    /** Storage provider: `s3` or `r2`; aliases include `aws`, `aws_s3`, `cloudflare_r2`, and `cloudflare-r2`. */
     provider?: string;
+    /**
+     * Cloudflare account ID for R2 catalogs when endpoint is omitted.
+     * Also accepted under `metadata.account_id`.
+     */
+    account_id?: string;
     force_path_style?: boolean;
     default_prefix?: string;
     public_base_url?: string;
@@ -1037,6 +1310,8 @@ interface UpdateStorageCatalogRequest {
     region?: string;
     bucket?: string;
     provider?: string;
+    /** Cloudflare account ID for R2 (merged into metadata / endpoint derivation). */
+    account_id?: string;
     force_path_style?: boolean;
     default_prefix?: string | null;
     public_base_url?: string | null;
@@ -1281,49 +1556,78 @@ interface StorageMultipartListPartsRequest {
     file_id: string;
     upload_id: string;
 }
-interface StorageObjectFolderCreateRequest {
+interface DeprecatedInlineStorageConnectionFields {
+    provider?: string;
+    /**
+     * @deprecated Prefer `s3_id` / `s3Id` and a managed storage catalog.
+     */
+    endpoint?: string;
+    /**
+     * @deprecated Prefer `s3_id` / `s3Id` and a managed storage catalog.
+     */
+    region?: string;
+    /**
+     * @deprecated Prefer `s3_id` / `s3Id` and a managed storage catalog.
+     */
+    access_key_id?: string;
+    /**
+     * @deprecated Prefer `s3_id` / `s3Id` and a managed storage catalog.
+     */
+    secret_key?: string;
+    /**
+     * @deprecated Prefer `s3_id` / `s3Id` and a managed storage catalog.
+     */
+    session_token?: string;
+}
+type StorageConnectionSelector = ({
+    s3_id: string;
+    s3Id?: string;
+} & DeprecatedInlineStorageConnectionFields) | ({
+    s3_id?: string;
+    s3Id: string;
+} & DeprecatedInlineStorageConnectionFields) | ({
+    s3_id?: string;
+    s3Id?: string;
     endpoint: string;
     region: string;
     access_key_id: string;
     secret_key: string;
+} & DeprecatedInlineStorageConnectionFields);
+type StorageObjectFolderCreateRequest = StorageConnectionSelector & {
     bucket: string;
     prefix: string;
-}
+};
 type StorageObjectFolderDeleteRequest = StorageObjectFolderCreateRequest;
 interface StorageObjectFolderRenameRequest extends Omit<StorageObjectFolderCreateRequest, 'prefix'> {
     from_prefix: string;
     to_prefix: string;
 }
-interface StorageObjectBaseRequest {
-    endpoint: string;
-    region: string;
-    access_key_id: string;
-    secret_key: string;
+type StorageObjectBaseRequest = StorageConnectionSelector & {
     bucket: string;
-}
-interface StorageObjectRequest extends StorageObjectBaseRequest {
+};
+type StorageObjectRequest = StorageObjectBaseRequest & {
     key: string;
-}
-interface StorageObjectValidateRequest extends StorageObjectRequest {
+};
+type StorageObjectValidateRequest = StorageObjectRequest & {
     checksum_sha256?: string;
     etag?: string;
-}
-interface StorageObjectCopyRequest extends StorageObjectBaseRequest, StorageServerSideEncryptionOptions {
+};
+type StorageObjectCopyRequest = StorageObjectBaseRequest & StorageServerSideEncryptionOptions & {
     source_key: string;
     destination_key: string;
     destination_bucket?: string;
-}
-interface StorageObjectPublicUrlRequest extends StorageObjectRequest {
+};
+type StorageObjectPublicUrlRequest = StorageObjectRequest & {
     public_base_url?: string;
     force_path_style?: boolean;
-}
-interface StorageListObjectsRequest extends StorageObjectBaseRequest {
+};
+type StorageListObjectsRequest = StorageObjectBaseRequest & {
     prefix?: string;
     delimiter?: string;
     continuation_token?: string;
     max_keys?: number;
-}
-interface StorageUpdateObjectRequest extends StorageObjectRequest {
+};
+type StorageUpdateObjectRequest = StorageObjectRequest & {
     acl?: string;
     content_type?: string;
     cache_control?: string;
@@ -1331,18 +1635,18 @@ interface StorageUpdateObjectRequest extends StorageObjectRequest {
     content_encoding?: string;
     content_language?: string;
     metadata?: Record<string, string>;
-}
-interface StorageObjectVersionListRequest extends StorageObjectBaseRequest {
+};
+type StorageObjectVersionListRequest = StorageObjectBaseRequest & {
     key?: string;
     max_keys?: number;
     key_marker?: string;
     version_id_marker?: string;
     delimiter?: string;
-}
-interface StorageObjectVersionMutationRequest extends StorageObjectRequest {
+};
+type StorageObjectVersionMutationRequest = StorageObjectRequest & {
     version_id: string;
-}
-interface StorageSignedPostPolicyRequest extends StorageObjectRequest, StorageServerSideEncryptionOptions {
+};
+type StorageSignedPostPolicyRequest = StorageObjectRequest & StorageServerSideEncryptionOptions & {
     content_type?: string;
     min_size?: number;
     max_size?: number;
@@ -1350,10 +1654,10 @@ interface StorageSignedPostPolicyRequest extends StorageObjectRequest, StorageSe
     public_base_url?: string;
     force_path_style?: boolean;
     success_action_status?: string;
-}
-interface StoragePresignUploadRequest extends StorageObjectRequest, StorageServerSideEncryptionOptions {
+};
+type StoragePresignUploadRequest = StorageObjectRequest & StorageServerSideEncryptionOptions & {
     content_type?: string;
-}
+};
 type StorageBucketCorsRequest = StorageObjectBaseRequest;
 interface StorageBucketCorsRuleInput {
     allowed_origins: string[];
@@ -1362,9 +1666,9 @@ interface StorageBucketCorsRuleInput {
     expose_headers?: string[];
     max_age_seconds?: number;
 }
-interface StorageSetBucketCorsRequest extends StorageBucketCorsRequest {
+type StorageSetBucketCorsRequest = StorageBucketCorsRequest & {
     rules: StorageBucketCorsRuleInput[];
-}
+};
 type StorageBucketLifecycleRequest = StorageObjectBaseRequest;
 interface StorageBucketLifecycleRuleInput {
     id?: string;
@@ -1375,20 +1679,20 @@ interface StorageBucketLifecycleRuleInput {
     noncurrent_version_expiration_days?: number;
     abort_incomplete_multipart_upload_days?: number;
 }
-interface StorageSetBucketLifecycleRequest extends StorageBucketLifecycleRequest {
+type StorageSetBucketLifecycleRequest = StorageBucketLifecycleRequest & {
     rules: StorageBucketLifecycleRuleInput[];
-}
+};
 type StorageBucketPolicyRequest = StorageObjectBaseRequest;
-interface StorageSetBucketPolicyRequest extends StorageBucketPolicyRequest {
+type StorageSetBucketPolicyRequest = StorageBucketPolicyRequest & {
     policy: Record<string, unknown> | string;
-}
+};
 type StoragePublicAccessBlockRequest = StorageObjectBaseRequest;
-interface StorageSetPublicAccessBlockRequest extends StoragePublicAccessBlockRequest {
+type StorageSetPublicAccessBlockRequest = StoragePublicAccessBlockRequest & {
     block_public_acls?: boolean;
     ignore_public_acls?: boolean;
     block_public_policy?: boolean;
     restrict_public_buckets?: boolean;
-}
+};
 interface StorageFileVersionPathRequest {
     file_id: string;
     version_id: string;
@@ -1418,6 +1722,21 @@ type AthenaStorageErrorHandler = (error: AthenaStorageError) => void | Promise<v
 interface AthenaStorageClientConfig extends AthenaStorageFileConfig {
     onError?: AthenaStorageErrorHandler;
 }
+/**
+ * Credentials for signing the direct upload PUT in the client.
+ * The Athena API still creates managed-file metadata so the public upload
+ * result remains unchanged; file bytes go directly to this S3-compatible endpoint.
+ */
+interface AthenaStorageDirectUploadConfig {
+    endpoint: string;
+    bucket?: string;
+    region?: string;
+    accessKeyId: string;
+    secretAccessKey: string;
+    sessionToken?: string;
+    /** R2 uses path-style addressing by default. */
+    forcePathStyle?: boolean;
+}
 interface AthenaStorageCallOptions extends AthenaGatewayCallOptions {
     signal?: AbortSignal;
     onError?: AthenaStorageErrorHandler;
@@ -1672,6 +1991,11 @@ interface AthenaStorageModule extends AthenaStorageBaseModule {
     bucket: AthenaStorageBucketNamespace;
     multipart: AthenaStorageMultipartNamespace;
     audit: AthenaStorageAuditNamespace;
+    /**
+     * Database backup / restore admin API (`/admin/backups*`).
+     * Archives are stored in the server S3 or R2 profile (`ATHENA_BACKUP_S3_*`).
+     */
+    backup: AthenaStorageBackupNamespace;
     delete: AthenaStorageFileModule['delete'];
 }
 declare function createAthenaStorageError(input: AthenaStorageErrorInput): AthenaStorageError;
@@ -1974,7 +2298,7 @@ interface AthenaChatWsErrorEvent {
     code?: string | null;
 }
 type AthenaChatWsServerEvent = AthenaChatWsHelloOkEvent | AthenaChatWsSubscribedEvent | AthenaChatWsRoomCreatedEvent | AthenaChatWsRoomUpdatedEvent | AthenaChatWsRoomArchivedEvent | AthenaChatWsMessageCreatedEvent | AthenaChatWsMessageUpdatedEvent | AthenaChatWsMessageDeletedEvent | AthenaChatWsReadUpdatedEvent | AthenaChatWsMembersUpdatedEvent | AthenaChatWsTypingUpdatedEvent | AthenaChatWsPresenceUpdatedEvent | AthenaChatWsSyncRequiredEvent | AthenaChatWsReactionUpdatedEvent | AthenaChatWsPongEvent | AthenaChatWsErrorEvent;
-type AthenaChatCallOptions = Pick<AthenaGatewayBaseOptions, 'headers' | 'client' | 'apiKey' | 'athenaKey' | 'bearerToken' | 'cookie' | 'sessionToken' | 'forceNoCache'> & {
+type AthenaChatCallOptions = Pick<AthenaGatewayBaseOptions, 'headers' | 'client' | 'apiKey' | 'bearerToken' | 'cookie' | 'sessionToken' | 'forceNoCache'> & {
     signal?: AbortSignal;
 };
 interface AthenaChatWebSocketLike {
@@ -2045,7 +2369,7 @@ interface AthenaChatModule {
     realtime: AthenaChatRealtimeModule;
 }
 
-type AthenaRowShape$1 = Record<string, AthenaJsonValue | undefined>;
+type AthenaRowShape = Record<string, AthenaJsonValue | undefined>;
 type FilterColumnKey$1<Row> = Extract<keyof NonNullable<Row>, string>;
 type ResolvedFilterColumnKey$1<Row> = [FilterColumnKey$1<Row>] extends [never] ? string : FilterColumnKey$1<Row>;
 type AthenaFilterOperator = 'eq' | 'neq' | 'gt' | 'gte' | 'lt' | 'lte' | 'like' | 'ilike' | 'is' | 'in' | 'contains' | 'containedBy';
@@ -2064,7 +2388,7 @@ type AthenaWhereOperatorInput = {
     contains?: AthenaConditionArrayValue;
     containedBy?: AthenaConditionArrayValue;
 };
-type AthenaWhereColumnInput<Row = AthenaRowShape$1> = Partial<Record<ResolvedFilterColumnKey$1<Row>, AthenaWherePrimitive | AthenaWhereOperatorInput>>;
+type AthenaWhereColumnInput<Row = AthenaRowShape> = Partial<Record<ResolvedFilterColumnKey$1<Row>, AthenaWherePrimitive | AthenaWhereOperatorInput>>;
 type AthenaBooleanSafeOperator = Exclude<AthenaFilterOperator, 'in' | 'contains' | 'containedBy'>;
 type AthenaWhereBooleanSafeOperatorInput = Partial<Record<AthenaBooleanSafeOperator, AthenaConditionValue>>;
 type AthenaWhereBooleanNotOperatorInput = {
@@ -2078,9 +2402,9 @@ type AthenaStrictBooleanOperand<Keys extends string, Value> = {
     } & Partial<Record<Exclude<Keys, K>, never>>;
 }[Keys];
 type AthenaNonEmptyArray<T> = [T, ...T[]];
-type AthenaWhereBooleanOperand<Row = AthenaRowShape$1> = string extends ResolvedFilterColumnKey$1<Row> ? AthenaWhereColumnInput<Row> : AthenaStrictBooleanOperand<ResolvedFilterColumnKey$1<Row>, AthenaWherePrimitive | AthenaWhereBooleanSafeOperatorInput>;
-type AthenaWhereNotOperand<Row = AthenaRowShape$1> = string extends ResolvedFilterColumnKey$1<Row> ? AthenaWhereColumnInput<Row> : AthenaStrictBooleanOperand<ResolvedFilterColumnKey$1<Row>, AthenaWherePrimitive | AthenaWhereBooleanNotOperatorInput>;
-type AthenaWhere<Row = AthenaRowShape$1> = AthenaWhereColumnInput<Row> & {
+type AthenaWhereBooleanOperand<Row = AthenaRowShape> = string extends ResolvedFilterColumnKey$1<Row> ? AthenaWhereColumnInput<Row> : AthenaStrictBooleanOperand<ResolvedFilterColumnKey$1<Row>, AthenaWherePrimitive | AthenaWhereBooleanSafeOperatorInput>;
+type AthenaWhereNotOperand<Row = AthenaRowShape> = string extends ResolvedFilterColumnKey$1<Row> ? AthenaWhereColumnInput<Row> : AthenaStrictBooleanOperand<ResolvedFilterColumnKey$1<Row>, AthenaWherePrimitive | AthenaWhereBooleanNotOperatorInput>;
+type AthenaWhere<Row = AthenaRowShape> = AthenaWhereColumnInput<Row> & {
     or?: string extends ResolvedFilterColumnKey$1<Row> ? Array<AthenaWhereColumnInput<Row>> : AthenaNonEmptyArray<AthenaWhereBooleanOperand<Row>>;
     not?: AthenaWhereNotOperand<Row>;
 };
@@ -2107,11 +2431,11 @@ type GenericRegistryDef = RegistryDef<Record<string, DatabaseDef<Record<string,
 type AthenaOrderByDirectionInput = 'asc' | 'desc' | 'ascending' | 'descending' | boolean | {
     ascending?: boolean;
 };
-type AthenaOrderBy<Row = AthenaRowShape$1> = {
+type AthenaOrderBy<Row = AthenaRowShape> = {
     column: ResolvedFilterColumnKey$1<Row>;
     ascending?: boolean;
 } | Partial<Record<ResolvedFilterColumnKey$1<Row>, AthenaOrderByDirectionInput>>;
-interface AthenaFindManyOptions<Row = AthenaRowShape$1, TSelect extends AthenaSelectShape = AthenaSelectShape> {
+interface AthenaFindManyOptions<Row = AthenaRowShape, TSelect extends AthenaSelectShape = AthenaSelectShape> {
     select: TSelect;
     where?: AthenaWhere<Row>;
     orderBy?: AthenaOrderBy<Row>;
@@ -2266,7 +2590,7 @@ interface AthenaUpsertDebugAst extends AthenaDebugAstBase<'upsert'> {
 interface AthenaUpdateDebugAst extends AthenaDebugAstBase<'update'> {
     tableName: string;
     input: {
-        values: AthenaUpdatePayload['set'];
+        values: AthenaUpdatePayload['update_body'];
         state: AthenaTableBuilderStateAst;
         returning?: AthenaUpdatePayload['columns'];
     };
@@ -2317,116 +2641,6 @@ interface AthenaRawQueryDebugAst extends AthenaDebugAstBase<'query'> {
 type AthenaQueryDebugAst = AthenaSelectDebugAst | AthenaFindManyDebugAst | AthenaInsertDebugAst | AthenaUpsertDebugAst | AthenaUpdateDebugAst | AthenaDeleteDebugAst | AthenaRpcDebugAst | AthenaRawQueryDebugAst;
 declare function getAthenaDebugAst(value: unknown): AthenaQueryDebugAst | null;
 
-interface AthenaResult<T> {
-    data: T | null;
-    error: AthenaResultError | null;
-    statusText?: string | null;
-    /**
-     * @deprecated Prefer `error?.gatewayCode`, `error?.hint`, and related fields on `error`.
-     */
-    errorDetails?: AthenaGatewayErrorDetails | null;
-    status: number;
-    count?: number | null;
-    raw: unknown;
-}
-interface AthenaResultError {
-    message: string;
-    code: string | null;
-    athenaCode: NormalizedAthenaError['code'];
-    gatewayCode?: AthenaGatewayErrorDetails['code'] | null;
-    kind: NormalizedAthenaError['kind'];
-    category: NormalizedAthenaError['category'];
-    retryable: boolean;
-    details: unknown | null;
-    hint: string | null;
-    status: number;
-    statusText: string | null;
-    constraint?: string;
-    table?: string;
-    operation?: string;
-    endpoint?: AthenaGatewayErrorDetails['endpoint'];
-    method?: AthenaGatewayErrorDetails['method'];
-    requestId?: string;
-    cause?: string;
-    raw: unknown;
-}
-type AthenaRequestService = 'db' | 'auth' | 'chat' | 'storage';
-type AthenaRequestMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE' | 'HEAD' | 'OPTIONS';
-interface AthenaRequestQueryValueMap {
-    [key: string]: string | number | boolean | null | undefined | Array<string | number | boolean | null | undefined>;
-}
-interface AthenaRequestOptions {
-    service?: AthenaRequestService;
-    url?: string;
-    path?: string;
-    method?: AthenaRequestMethod;
-    headers?: Record<string, string>;
-    /** Per-request override for the canonical `X-Athena-Key` header. */
-    apiKey?: string | null;
-    /** Per-request override for `X-Athena-Key` only. */
-    athenaKey?: string | null;
-    query?: AthenaRequestQueryValueMap;
-    body?: RequestInit['body'] | Record<string, unknown> | unknown[] | null;
-    signal?: AbortSignal;
-    credentials?: RequestInit['credentials'];
-    responseType?: 'json' | 'text' | 'response';
-}
-interface AthenaRequestResponse<T = unknown> {
-    ok: boolean;
-    status: number;
-    statusText: string;
-    headers: Headers;
-    data: T | string | null;
-    raw: Response;
-}
-interface AthenaClientExperimentalOptions {
-    /**
-     * @deprecated Failed `AthenaResult` values now include normalized structured `error`
-     * envelopes by default. This flag is retained as a no-op compatibility switch.
-     */
-    enableErrorNormalization?: boolean;
-    /**
-     * Retry retryable read failures (`select`, `findMany`, `query`) with a fixed internal policy.
-     *
-     * Applies two additional attempts with exponential backoff and jitter.
-     */
-    retryReads?: boolean;
-    /**
-     * Emit execution diagnostics for every query/mutation/RPC invocation.
-     * Includes payload, synthesized SQL, full outcome, and best-effort callsite metadata.
-     */
-    traceQueries?: boolean | AthenaQueryTraceOptions;
-    /**
-     * Build and attach a normalized operation AST for runtime debugging.
-     *
-     * When enabled, successful Athena results expose a non-enumerable debug AST
-     * that can be read with `getAthenaDebugAst(...)`. If tracing is also enabled,
-     * the same AST is included on emitted trace events.
-     */
-    debugAst?: boolean;
-    /**
-     * Compile-time opt-in for validating simple `select(...)`, `order(...)`, and
-     * RPC filter column names against known row keys.
-     *
-     * This flag is type-only. It does not change runtime request behavior.
-     */
-    typecheckColumns?: boolean;
-    /**
-     * Send the original `findMany(...)` AST body for clean object-select reads.
-     * This requires gateway support and falls back to legacy compiled transport
-     * when a chain carries filter/pagination state that the AST payload cannot
-     * represent losslessly yet.
-     */
-    findManyAst?: boolean;
-    /**
-     * Expose the experimental `client.storage.*` bindings for Athena storage APIs.
-     */
-    athenaStorageBackend?: boolean;
-    /**
-     * Optional storage SDK runtime hooks. Only used when `athenaStorageBackend` is enabled.
-     */
-    storage?: AthenaStorageClientConfig;
-}
 interface AthenaQueryTraceOptions {
     /**
      * Custom sink for trace events. Defaults to console.info.
@@ -2465,34 +2679,21 @@ interface AthenaQueryTraceEvent {
 }
 type MutationSingleResult<Result> = Result extends Array<infer Item> ? Item | null : Result | null;
 type MutationResultRow<Result> = Result extends Array<infer Item> ? Item : Result;
-type AthenaRowShape = Record<string, AthenaJsonValue | undefined>;
 type FilterColumnKey<Row> = Extract<keyof NonNullable<Row>, string>;
 /** Known keys when the row shape is concrete; `string` when untyped / index signature. */
 type ResolvedFilterColumnKey<Row> = [FilterColumnKey<Row>] extends [never] ? string : string extends FilterColumnKey<Row> ? string : FilterColumnKey<Row>;
-/**
- * Table-name argument for free-form `from<Row>(table)`.
- * - No client `models` → `string` (nothing to complete).
- * - With `models` → known bare/qualified names (IntelliSense + reject unknowns).
- *   Prefer `.from("users")` without a row generic so the row type is inferred from the model.
- */
-type UntypedTableName<TModels> = [TModels] extends [never] ? string : [AthenaClientTableName<TModels>] extends [never] ? string : AthenaClientTableName<TModels>;
-type ResolvedClientTableModel<TModels, TTableName extends string> = Extract<AthenaClientModelForTableName<TModels, TTableName>, AthenaModelTarget>;
-type ClientTableQueryBuilder<TModels, TTableName extends string, TStrict extends boolean> = TableQueryBuilder<RowOf<ResolvedClientTableModel<TModels, TTableName>>, InsertOf<ResolvedClientTableModel<TModels, TTableName>>, UpdateOf<ResolvedClientTableModel<TModels, TTableName>>, unknown, TStrict>;
 /**
  * Select/returning/single column input.
  *
- * - Typed row + `typecheckColumns`: validates string lists; arrays use key union
- *   (IntelliSense + reject unknown elements without `as const`).
- * - Typed row without strict: free-form strings still allowed; key unions are
- *   included so IDEs can suggest column names on `select` / `single` / etc.
+ * - Typed row: validates string lists; arrays use the model-key union.
  * - Untyped row: plain `TValue` (`string | string[]`).
  */
-type SelectColumnsFor<Row, TStrict extends boolean, TValue extends AthenaSelectInput> = TStrict extends true ? AthenaValidatedSelectInput<Row, TValue> : [FilterColumnKey<Row>] extends [never] ? TValue : string extends FilterColumnKey<Row> ? TValue : TValue | FilterColumnKey<Row> | '*' | readonly (FilterColumnKey<Row> | '*')[];
-interface MutationQuery<Result, Row = MutationResultRow<Result>, TStrict extends boolean = false> extends PromiseLike<AthenaResult<Result>> {
-    select<const TColumns extends AthenaSelectInput = string>(columns?: SelectColumnsFor<Row, TStrict, TColumns>, options?: AthenaGatewayCallOptions): Promise<AthenaResult<Result>>;
-    returning<const TColumns extends AthenaSelectInput = string>(columns?: SelectColumnsFor<Row, TStrict, TColumns>, options?: AthenaGatewayCallOptions): Promise<AthenaResult<Result>>;
-    single<const TColumns extends AthenaSelectInput = string>(columns?: SelectColumnsFor<Row, TStrict, TColumns>, options?: AthenaGatewayCallOptions): Promise<AthenaResult<MutationSingleResult<Result>>>;
-    maybeSingle<const TColumns extends AthenaSelectInput = string>(columns?: SelectColumnsFor<Row, TStrict, TColumns>, options?: AthenaGatewayCallOptions): Promise<AthenaResult<MutationSingleResult<Result>>>;
+type SelectColumnsFor<Row, TValue extends AthenaSelectInput> = AthenaValidatedSelectInput<Row, TValue>;
+interface MutationQuery<Result, Row = MutationResultRow<Result>> extends PromiseLike<AthenaResult<Result>> {
+    select<const TColumns extends AthenaSelectInput = string>(columns?: SelectColumnsFor<Row, TColumns>, options?: AthenaGatewayCallOptions): Promise<AthenaResult<Result>>;
+    returning<const TColumns extends AthenaSelectInput = string>(columns?: SelectColumnsFor<Row, TColumns>, options?: AthenaGatewayCallOptions): Promise<AthenaResult<Result>>;
+    single<const TColumns extends AthenaSelectInput = string>(columns?: SelectColumnsFor<Row, TColumns>, options?: AthenaGatewayCallOptions): Promise<AthenaResult<MutationSingleResult<Result>>>;
+    maybeSingle<const TColumns extends AthenaSelectInput = string>(columns?: SelectColumnsFor<Row, TColumns>, options?: AthenaGatewayCallOptions): Promise<AthenaResult<MutationSingleResult<Result>>>;
     then<TResult1 = AthenaResult<Result>, TResult2 = never>(onfulfilled?: ((value: AthenaResult<Result>) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: unknown) => TResult2 | PromiseLike<TResult2>) | undefined | null): Promise<TResult1 | TResult2>;
     catch<TResult = never>(onrejected?: ((reason: unknown) => TResult | PromiseLike<TResult>) | undefined | null): Promise<AthenaResult<Result> | TResult>;
     finally(onfinally?: (() => void) | undefined | null): Promise<AthenaResult<Result>>;
@@ -2528,277 +2729,138 @@ interface FilterChain<Self, Row> {
     or(expression: string): Self;
 }
 /** Chain returned by select() - supports filters and single/maybeSingle before execution */
-interface SelectChain<Row, SelectedRow = Row, TStrict extends boolean = false> extends FilterChain<SelectChain<Row, SelectedRow, TStrict>, Row>, PromiseLike<AthenaResult<SelectedRow[]>> {
-    single<T = SelectedRow, const TColumns extends AthenaSelectInput = string>(columns?: SelectColumnsFor<Row, TStrict, TColumns>, options?: AthenaGatewayCallOptions): Promise<AthenaResult<T | null>>;
-    maybeSingle<T = SelectedRow, const TColumns extends AthenaSelectInput = string>(columns?: SelectColumnsFor<Row, TStrict, TColumns>, options?: AthenaGatewayCallOptions): Promise<AthenaResult<T | null>>;
+interface SelectChain<Row, SelectedRow = Row> extends FilterChain<SelectChain<Row, SelectedRow>, Row>, PromiseLike<AthenaResult<SelectedRow[]>> {
+    single<T = SelectedRow, const TColumns extends AthenaSelectInput = string>(columns?: SelectColumnsFor<Row, TColumns>, options?: AthenaGatewayCallOptions): Promise<AthenaResult<T | null>>;
+    maybeSingle<T = SelectedRow, const TColumns extends AthenaSelectInput = string>(columns?: SelectColumnsFor<Row, TColumns>, options?: AthenaGatewayCallOptions): Promise<AthenaResult<T | null>>;
 }
 /** Chain returned by update() - supports filters before execution, plus select/returning */
-interface UpdateChain<Row, TStrict extends boolean = false> extends FilterChain<UpdateChain<Row, TStrict>, Row>, MutationQuery<Row[], Row, TStrict> {
-}
-interface RpcFilterChain<Self, Row, TStrict extends boolean = false> {
-    eq(column: AthenaTypecheckedColumnKey<Row, TStrict>, value: AthenaConditionValue): Self;
-    neq(column: AthenaTypecheckedColumnKey<Row, TStrict>, value: AthenaConditionValue): Self;
-    gt(column: AthenaTypecheckedColumnKey<Row, TStrict>, value: AthenaConditionValue): Self;
-    gte(column: AthenaTypecheckedColumnKey<Row, TStrict>, value: AthenaConditionValue): Self;
-    lt(column: AthenaTypecheckedColumnKey<Row, TStrict>, value: AthenaConditionValue): Self;
-    lte(column: AthenaTypecheckedColumnKey<Row, TStrict>, value: AthenaConditionValue): Self;
-    like(column: AthenaTypecheckedColumnKey<Row, TStrict>, value: AthenaConditionValue): Self;
-    ilike(column: AthenaTypecheckedColumnKey<Row, TStrict>, value: AthenaConditionValue): Self;
-    is(column: AthenaTypecheckedColumnKey<Row, TStrict>, value: AthenaConditionValue): Self;
-    in(column: AthenaTypecheckedColumnKey<Row, TStrict>, values: AthenaConditionArrayValue): Self;
+interface UpdateChain<Row> extends FilterChain<UpdateChain<Row>, Row>, MutationQuery<Row[], Row> {
+}
+interface RpcFilterChain<Self, Row> {
+    eq(column: AthenaTypecheckedColumnKey<Row>, value: AthenaConditionValue): Self;
+    neq(column: AthenaTypecheckedColumnKey<Row>, value: AthenaConditionValue): Self;
+    gt(column: AthenaTypecheckedColumnKey<Row>, value: AthenaConditionValue): Self;
+    gte(column: AthenaTypecheckedColumnKey<Row>, value: AthenaConditionValue): Self;
+    lt(column: AthenaTypecheckedColumnKey<Row>, value: AthenaConditionValue): Self;
+    lte(column: AthenaTypecheckedColumnKey<Row>, value: AthenaConditionValue): Self;
+    like(column: AthenaTypecheckedColumnKey<Row>, value: AthenaConditionValue): Self;
+    ilike(column: AthenaTypecheckedColumnKey<Row>, value: AthenaConditionValue): Self;
+    is(column: AthenaTypecheckedColumnKey<Row>, value: AthenaConditionValue): Self;
+    in(column: AthenaTypecheckedColumnKey<Row>, values: AthenaConditionArrayValue): Self;
 }
 interface RpcOrderOptions {
     ascending?: boolean;
 }
-interface RpcQueryBuilder<Row, TStrict extends boolean = false> extends RpcFilterChain<RpcQueryBuilder<Row, TStrict>, Row, TStrict>, PromiseLike<AthenaResult<Row[]>> {
-    select<const TColumns extends AthenaSelectInput = string>(columns?: SelectColumnsFor<Row, TStrict, TColumns>, options?: AthenaRpcCallOptions): Promise<AthenaResult<Row[]>>;
-    single<T = Row, const TColumns extends AthenaSelectInput = string>(columns?: SelectColumnsFor<Row, TStrict, TColumns>, options?: AthenaRpcCallOptions): Promise<AthenaResult<T | null>>;
-    maybeSingle<T = Row, const TColumns extends AthenaSelectInput = string>(columns?: SelectColumnsFor<Row, TStrict, TColumns>, options?: AthenaRpcCallOptions): Promise<AthenaResult<T | null>>;
-    order(column: AthenaTypecheckedColumnKey<Row, TStrict>, options?: RpcOrderOptions): RpcQueryBuilder<Row, TStrict>;
-    limit(count: number): RpcQueryBuilder<Row, TStrict>;
-    offset(count: number): RpcQueryBuilder<Row, TStrict>;
-    range(from: number, to: number): RpcQueryBuilder<Row, TStrict>;
+interface RpcQueryBuilder<Row> extends RpcFilterChain<RpcQueryBuilder<Row>, Row>, PromiseLike<AthenaResult<Row[]>> {
+    select<const TColumns extends AthenaSelectInput = string>(columns?: SelectColumnsFor<Row, TColumns>, options?: AthenaRpcCallOptions): Promise<AthenaResult<Row[]>>;
+    single<T = Row, const TColumns extends AthenaSelectInput = string>(columns?: SelectColumnsFor<Row, TColumns>, options?: AthenaRpcCallOptions): Promise<AthenaResult<T | null>>;
+    maybeSingle<T = Row, const TColumns extends AthenaSelectInput = string>(columns?: SelectColumnsFor<Row, TColumns>, options?: AthenaRpcCallOptions): Promise<AthenaResult<T | null>>;
+    order(column: AthenaTypecheckedColumnKey<Row>, options?: RpcOrderOptions): RpcQueryBuilder<Row>;
+    limit(count: number): RpcQueryBuilder<Row>;
+    offset(count: number): RpcQueryBuilder<Row>;
+    range(from: number, to: number): RpcQueryBuilder<Row>;
 }
 interface AthenaFromOptions {
     schema?: string;
 }
-interface TableQueryBuilder<Row, Insert = Partial<Row>, Update = Partial<Insert>, TContext = unknown, TStrict extends boolean = false> extends FilterChain<TableQueryBuilder<Row, Insert, Update, TContext, TStrict>, Row> {
-    select<T = Row, const TColumns extends AthenaSelectInput = string>(columns?: SelectColumnsFor<Row, TStrict, TColumns>, options?: AthenaGatewayCallOptions): SelectChain<Row, T, TStrict>;
+interface TableQueryBuilder<Row, Insert = Partial<Row>, Update = Partial<Insert>, TContext = unknown> extends FilterChain<TableQueryBuilder<Row, Insert, Update, TContext>, Row> {
+    select<T = Row, const TColumns extends AthenaSelectInput = string>(columns?: SelectColumnsFor<Row, TColumns>, options?: AthenaGatewayCallOptions): SelectChain<Row, T>;
     findMany<const TSelect extends AthenaSelectShape>(options: AthenaFindManyOptions<Row, TSelect> & {
         select: AthenaValidatedSelectShape<TSelect>;
     }): Promise<AthenaResult<Array<AthenaFindManyResult<Row, TSelect, TContext>>>>;
-    insert(values: Insert, options?: AthenaGatewayCallOptions): MutationQuery<Row, Row, TStrict>;
-    insert(values: Insert[], options?: AthenaGatewayCallOptions): MutationQuery<Row[], Row, TStrict>;
+    insert(values: Insert, options?: AthenaGatewayCallOptions): MutationQuery<Row, Row>;
+    insert(values: Insert[], options?: AthenaGatewayCallOptions): MutationQuery<Row[], Row>;
     upsert(values: Insert, options?: AthenaGatewayCallOptions & {
         updateBody?: Update;
         onConflict?: ResolvedFilterColumnKey<Row> | Array<ResolvedFilterColumnKey<Row>> | (string & {}) | Array<string & {}>;
-    }): MutationQuery<Row, Row, TStrict>;
+    }): MutationQuery<Row, Row>;
     upsert(values: Insert[], options?: AthenaGatewayCallOptions & {
         updateBody?: Update;
         onConflict?: ResolvedFilterColumnKey<Row> | Array<ResolvedFilterColumnKey<Row>> | (string & {}) | Array<string & {}>;
-    }): MutationQuery<Row[], Row, TStrict>;
-    update(values: Update, options?: AthenaGatewayCallOptions): UpdateChain<Row, TStrict>;
+    }): MutationQuery<Row[], Row>;
+    update(values: Update, options?: AthenaGatewayCallOptions): UpdateChain<Row>;
     delete(options?: AthenaGatewayCallOptions & {
         resourceId?: string;
-    }): MutationQuery<Row | null, Row, TStrict>;
-    single<T = Row, const TColumns extends AthenaSelectInput = string>(columns?: SelectColumnsFor<Row, TStrict, TColumns>, options?: AthenaGatewayCallOptions): Promise<AthenaResult<T | null>>;
-    maybeSingle<T = Row, const TColumns extends AthenaSelectInput = string>(columns?: SelectColumnsFor<Row, TStrict, TColumns>, options?: AthenaGatewayCallOptions): Promise<AthenaResult<T | null>>;
-    reset(): TableQueryBuilder<Row, Insert, Update, TContext, TStrict>;
-}
-interface AthenaSdkClient<TStrict extends boolean = false, TModels = never> {
-    from<TModel extends AthenaModelTarget>(model: TModel): TableQueryBuilder<RowOf<TModel>, InsertOf<TModel>, UpdateOf<TModel>, unknown, TStrict>;
-    from<TTableName extends AthenaClientTableName<TModels>>(table: TTableName, options?: AthenaFromOptions): ClientTableQueryBuilder<TModels, TTableName, TStrict>;
-    from<Row = AthenaRowShape, Insert = Partial<Row>, Update = Partial<Insert>>(table: UntypedTableName<TModels>, options?: AthenaFromOptions): TableQueryBuilder<Row, Insert, Update, unknown, TStrict>;
-    db: AthenaDbModule<TStrict, TModels>;
-    rpc<Row = unknown, Args extends AthenaJsonObject = AthenaJsonObject>(fn: string, args?: Args, options?: AthenaRpcCallOptions): RpcQueryBuilder<Row, TStrict>;
-    query<Row = unknown>(query: string, options?: AthenaGatewayCallOptions): Promise<AthenaResult<Row[]>>;
-    request<T = unknown>(options: AthenaRequestOptions): Promise<AthenaRequestResponse<T>>;
-    verifyConnection(options?: AthenaGatewayConnectionOptions): Promise<AthenaGatewayConnectionResult>;
-    withContext(context?: AthenaClientContextOptions): AthenaSdkClient<TStrict, TModels>;
-    withSession(session?: AthenaClientSessionLike | null, options?: AthenaClientSessionOptions): AthenaSdkClient<TStrict, TModels>;
-}
-interface AthenaSdkClientWithAuth<TStrict extends boolean = false, TModels = never> extends AthenaSdkClient<TStrict, TModels> {
-    auth: AthenaAuthBindings;
-    chat: AthenaChatModule;
-    withContext(context?: AthenaClientContextOptions): AthenaSdkClientWithAuth<TStrict, TModels>;
-    withSession(session?: AthenaClientSessionLike | null, options?: AthenaClientSessionOptions): AthenaSdkClientWithAuth<TStrict, TModels>;
-    withOptions(options?: AthenaClientOverrideOptions): AthenaSdkClientWithAuth<TStrict, TModels>;
-}
-interface AthenaSdkClientWithStorage<TStrict extends boolean = false, TModels = never> extends AthenaSdkClientWithAuth<TStrict, TModels> {
-    storage: AthenaStorageModule;
-    withContext(context?: AthenaClientContextOptions): AthenaSdkClientWithStorage<TStrict, TModels>;
-    withSession(session?: AthenaClientSessionLike | null, options?: AthenaClientSessionOptions): AthenaSdkClientWithStorage<TStrict, TModels>;
-    withOptions(options?: AthenaClientOverrideOptions): AthenaSdkClientWithStorage<TStrict, TModels>;
-}
-interface AthenaHeaderBag {
-    get(name: string): string | null;
-}
-interface AthenaClientSessionLike {
-    user?: {
-        id?: string | null | undefined;
-    } | null | undefined;
-    session?: {
-        token?: string | null | undefined;
-        activeOrganizationId?: string | null | undefined;
-    } | null | undefined;
-}
-interface AthenaCreateClientServiceUrlConfig {
-    url?: string | null | undefined;
-}
-interface AthenaCreateClientChatOptions extends AthenaCreateClientServiceUrlConfig {
-    wsUrl?: string | null | undefined;
-    webSocketFactory?: AthenaChatWebSocketFactory | null | undefined;
-}
-interface AthenaCreateClientAuthOptions extends Omit<AthenaAuthClientConfig, 'baseUrl' | 'apiKey' | 'bearerToken' | 'cookie' | 'sessionToken'> {
-    url?: string | null | undefined;
-    baseUrl?: string | null | undefined;
-    apiKey?: string | null | undefined;
-    bearerToken?: string | null | undefined;
-    cookie?: string | null | undefined;
-    sessionToken?: string | null | undefined;
-}
-interface AthenaCreateClientOptions {
-    client?: string | null | undefined;
-    userId?: string | null | undefined;
-    organizationId?: string | null | undefined;
-    forceNoCache?: boolean;
-    headers?: Record<string, string>;
-    /** Direct PostgreSQL URI forwarded as `x-pg-uri` on gateway requests. */
-    pgUri?: string | null | undefined;
-    /** JDBC/PostgreSQL URI mirrored to `x-athena-jdbc-url` and `x-jdbc-url`. */
-    jdbcUrl?: string | null | undefined;
-    /** Client-wide override for the canonical `X-Athena-Key` header. */
-    athenaKey?: string | null | undefined;
-    backend?: BackendConfig | BackendType;
-    db?: AthenaCreateClientServiceUrlConfig;
-    gateway?: AthenaCreateClientServiceUrlConfig;
-    auth?: AthenaCreateClientAuthOptions;
-    chat?: AthenaCreateClientChatOptions;
-    storage?: AthenaCreateClientServiceUrlConfig;
-    dbUrl?: string | null | undefined;
-    gatewayUrl?: string | null | undefined;
-    authUrl?: string | null | undefined;
-    chatUrl?: string | null | undefined;
-    chatWsUrl?: string | null | undefined;
-    storageUrl?: string | null | undefined;
-    models?: AthenaClientModelsInput;
-    experimental?: AthenaClientExperimentalOptions;
-}
-interface AthenaCreateClientOptionsWithStorage extends AthenaCreateClientOptions {
-    experimental: AthenaClientExperimentalOptions & {
-        athenaStorageBackend: true;
-    };
-}
-interface AthenaCreateClientOptionsWithTypecheckedColumns extends AthenaCreateClientOptions {
-    experimental: AthenaClientExperimentalOptions & {
-        typecheckColumns: true;
-    };
+    }): MutationQuery<Row | null, Row>;
+    single<T = Row, const TColumns extends AthenaSelectInput = string>(columns?: SelectColumnsFor<Row, TColumns>, options?: AthenaGatewayCallOptions): Promise<AthenaResult<T | null>>;
+    maybeSingle<T = Row, const TColumns extends AthenaSelectInput = string>(columns?: SelectColumnsFor<Row, TColumns>, options?: AthenaGatewayCallOptions): Promise<AthenaResult<T | null>>;
+    reset(): TableQueryBuilder<Row, Insert, Update, TContext>;
 }
-interface AthenaCreateClientOptionsWithStorageAndTypecheckedColumns extends AthenaCreateClientOptions {
-    experimental: AthenaClientExperimentalOptions & {
-        athenaStorageBackend: true;
-        typecheckColumns: true;
-    };
+
+type MaybePromise<T> = T | Promise<T>;
+type ResolvedModels<TModels> = TModels extends AthenaClientModelsInput ? TModels : never;
+type AthenaService = 'db' | 'auth' | 'chat' | 'storage' | 'billing';
+declare class AthenaConfigurationError extends Error {
+    readonly code: "ATHENA_SERVICE_NOT_CONFIGURED";
+    readonly service: AthenaService;
+    constructor(service: AthenaService, message?: string);
+}
+interface AthenaRequestContext {
+    userId?: string | null;
+    organizationId?: string | null;
+    headers?: Record<string, string>;
+    cookie?: string | null;
+    bearerToken?: string | null;
+    sessionToken?: string | null;
+    forceNoCache?: boolean;
 }
-interface AthenaCreateClientConfig extends AthenaCreateClientOptions {
-    url?: string | null | undefined;
-    key: string | null | undefined;
+type AthenaRequestContextProvider = () => MaybePromise<AthenaRequestContext | undefined>;
+interface AthenaDbConfig {
+    url?: string | null;
+    pgUri?: string | null;
+    jdbcUrl?: string | null;
 }
-interface AthenaCreateClientConfigWithStorage extends AthenaCreateClientOptionsWithStorage {
-    url?: string | null | undefined;
-    key: string | null | undefined;
+interface AthenaAuthConfig extends Omit<AthenaAuthClientConfig, 'baseUrl' | 'apiKey' | 'bearerToken' | 'cookie' | 'sessionToken'> {
+    url?: string | null;
 }
-interface AthenaCreateClientConfigWithTypecheckedColumns extends AthenaCreateClientOptionsWithTypecheckedColumns {
-    url?: string | null | undefined;
-    key: string | null | undefined;
+interface AthenaChatConfig {
+    url?: string | null;
+    wsUrl?: string | null;
+    webSocketFactory?: AthenaChatWebSocketFactory | null;
 }
-interface AthenaCreateClientConfigWithStorageAndTypecheckedColumns extends AthenaCreateClientOptionsWithStorageAndTypecheckedColumns {
-    url?: string | null | undefined;
-    key: string | null | undefined;
+interface AthenaStorageConfig extends Omit<AthenaStorageClientConfig, 'baseUrl' | 'directUpload'> {
+    url?: string | null;
+    directUpload?: AthenaStorageDirectUploadConfig;
 }
-interface AthenaClientOverrideOptions extends Omit<AthenaCreateClientOptions, 'experimental' | 'models'> {
-    url?: string | null | undefined;
-    key?: string | null | undefined;
+interface AthenaBillingConfig extends Omit<AthenaBillingClientConfig, 'baseUrl' | 'apiKey' | 'client' | 'fetchImpl'> {
+    /** Optional override; defaults to the unified/root or db Athena URL. */
+    url?: string | null;
 }
-interface AthenaClientContextOptions {
-    userId?: string | null | undefined;
-    organizationId?: string | null | undefined;
-    forceNoCache?: boolean;
+interface AthenaClientConfig<TModels extends AthenaClientModelsInput | undefined = undefined> {
+    url?: string | null;
+    key?: string | null;
+    client?: string | null;
+    backend?: BackendConfig | BackendType;
     headers?: Record<string, string>;
-    auth?: Omit<AthenaCreateClientAuthOptions, 'url' | 'baseUrl' | 'apiKey'>;
-}
-interface AthenaClientSessionOptions extends AthenaClientContextOptions {
-    requestHeaders?: AthenaHeaderBag | Record<string, string | null | undefined>;
-}
-interface AthenaClientFromEnvironmentOptions extends AthenaCreateClientOptions {
+    models?: TModels;
     env?: Record<string, string | undefined>;
-    url?: string | null | undefined;
-    key?: string | null | undefined;
-}
-interface AthenaClientFromEnvironmentOptionsWithStorage extends AthenaClientFromEnvironmentOptions {
-    experimental: AthenaClientExperimentalOptions & {
-        athenaStorageBackend: true;
-    };
-}
-interface AthenaClientFromEnvironmentOptionsWithTypecheckedColumns extends AthenaClientFromEnvironmentOptions {
-    experimental: AthenaClientExperimentalOptions & {
-        typecheckColumns: true;
-    };
+    context?: AthenaRequestContext | AthenaRequestContextProvider;
+    db?: AthenaDbConfig;
+    auth?: AthenaAuthConfig;
+    chat?: AthenaChatConfig;
+    storage?: AthenaStorageConfig;
+    billing?: AthenaBillingConfig;
+    retryReads?: boolean;
+    traceQueries?: boolean | AthenaQueryTraceOptions;
+    debugAst?: boolean;
+    findManyAst?: boolean;
 }
-interface AthenaClientFromEnvironmentOptionsWithStorageAndTypecheckedColumns extends AthenaClientFromEnvironmentOptions {
-    experimental: AthenaClientExperimentalOptions & {
-        athenaStorageBackend: true;
-        typecheckColumns: true;
-    };
+type V3TableBuilder<Row, Insert = Partial<Row>, Update = Partial<Insert>, Result = unknown> = TableQueryBuilder<Row, Insert, Update, Result>;
+interface AthenaClient<TModels extends AthenaClientModelsInput | undefined = AthenaClientModelsInput | undefined> {
+    readonly db: AthenaDbModule<ResolvedModels<TModels>>;
+    readonly auth: AthenaAuthBindings;
+    readonly chat: AthenaChatModule;
+    readonly storage: AthenaStorageModule;
+    readonly billing: AthenaBillingModule;
+    from<TModel extends AthenaModelTarget>(model: TModel): V3TableBuilder<RowOf<TModel>, InsertOf<TModel>, UpdateOf<TModel>>;
+    from<TTableName extends AthenaClientTableName<ResolvedModels<TModels>>>(table: TTableName, options?: AthenaFromOptions): V3TableBuilder<RowOf<AthenaClientModelForTableName<ResolvedModels<TModels>, TTableName>>, InsertOf<AthenaClientModelForTableName<ResolvedModels<TModels>, TTableName>>, UpdateOf<AthenaClientModelForTableName<ResolvedModels<TModels>, TTableName>>>;
+    from<Row = Record<string, unknown>, Insert = Partial<Row>, Update = Partial<Insert>>(table: string, options?: AthenaFromOptions): V3TableBuilder<Row, Insert, Update>;
+    rpc<Row = unknown, Args extends AthenaJsonObject = AthenaJsonObject>(fn: string, args?: Args, options?: AthenaRpcCallOptions): RpcQueryBuilder<Row>;
+    query<Row = unknown>(query: string, options?: AthenaGatewayCallOptions): Promise<AthenaResult<Row[]>>;
+    request<T = unknown>(options: AthenaRequestOptions): Promise<AthenaRequestResponse<T>>;
+    verifyConnection(options?: AthenaGatewayConnectionOptions): Promise<AthenaGatewayConnectionResult>;
+    withContext(context: AthenaRequestContext): AthenaClient<TModels>;
 }
-interface AthenaClientBuilder<StorageEnabled extends boolean = false, TStrict extends boolean = false> {
-    /** Set the public Athena base URL. */
-    url(url: string | null | undefined): AthenaClientBuilder<StorageEnabled, TStrict>;
-    /** Set the API key used for all requests. */
-    key(apiKey: string | null | undefined): AthenaClientBuilder<StorageEnabled, TStrict>;
-    /** Set the default backend routing strategy. */
-    backend(backend: BackendConfig | BackendType): AthenaClientBuilder<StorageEnabled, TStrict>;
-    /** Set the default Athena client routing key. */
-    client(clientName: string | null | undefined): AthenaClientBuilder<StorageEnabled, TStrict>;
-    /** Attach static headers to every request. */
-    headers(headers: Record<string, string>): AthenaClientBuilder<StorageEnabled, TStrict>;
-    /** Forward a direct PostgreSQL URI as `x-pg-uri` on gateway requests. */
-    pgUri(pgUri: string | null | undefined): AthenaClientBuilder<StorageEnabled, TStrict>;
-    /** Forward a JDBC/PostgreSQL URI to compatibility JDBC headers. */
-    jdbcUrl(jdbcUrl: string | null | undefined): AthenaClientBuilder<StorageEnabled, TStrict>;
-    /** Override the canonical `X-Athena-Key` header for this client. */
-    athenaKey(athenaKey: string | null | undefined): AthenaClientBuilder<StorageEnabled, TStrict>;
-    /** Configure Athena Auth client behavior for `client.auth.*` methods. */
-    auth(config: AthenaCreateClientAuthOptions): AthenaClientBuilder<StorageEnabled, TStrict>;
-    /** Configure experimental client options and narrow the built client when storage or strict column checks are enabled. */
-    experimental(options: AthenaClientExperimentalOptions & {
-        athenaStorageBackend: true;
-        typecheckColumns: true;
-    }): AthenaClientBuilder<true, true>;
-    experimental(options: AthenaClientExperimentalOptions & {
-        athenaStorageBackend: true;
-    }): AthenaClientBuilder<true, TStrict>;
-    experimental(options: AthenaClientExperimentalOptions & {
-        typecheckColumns: true;
-    }): AthenaClientBuilder<StorageEnabled, true>;
-    experimental(options: AthenaClientExperimentalOptions): AthenaClientBuilder<StorageEnabled, TStrict>;
-    /** Apply createClient options and narrow the built client when storage is enabled. */
-    options(options: AthenaCreateClientOptionsWithStorageAndTypecheckedColumns): AthenaClientBuilder<true, true>;
-    options(options: AthenaCreateClientOptionsWithStorage): AthenaClientBuilder<true, TStrict>;
-    options(options: AthenaCreateClientOptionsWithTypecheckedColumns): AthenaClientBuilder<StorageEnabled, true>;
-    options(options: AthenaCreateClientOptions): AthenaClientBuilder<StorageEnabled, TStrict>;
-    /** Build the immutable Athena SDK client. */
-    build(): StorageEnabled extends true ? AthenaSdkClientWithStorage<TStrict> : AthenaSdkClientWithAuth<TStrict>;
-}
-/** Canonical Athena client factory with builder-based configuration. */
-declare class AthenaClient {
-    /** Create a fluent builder for a strongly-typed Athena SDK client. */
-    static builder(): AthenaClientBuilder<false, false>;
-    /** Build a client from process environment variables. */
-    static fromEnvironment(options: AthenaClientFromEnvironmentOptionsWithStorageAndTypecheckedColumns): AthenaSdkClientWithStorage<true>;
-    static fromEnvironment(options: AthenaClientFromEnvironmentOptionsWithStorage): AthenaSdkClientWithStorage<false>;
-    static fromEnvironment(options: AthenaClientFromEnvironmentOptionsWithTypecheckedColumns): AthenaSdkClientWithAuth<true>;
-    static fromEnvironment(options?: AthenaClientFromEnvironmentOptions): AthenaSdkClientWithAuth<false>;
-}
-type ExtractClientModels<TInput> = TInput extends {
-    models: infer TModels extends AthenaClientModelsInput;
-} ? TModels : never;
-type AthenaCreateClientReturn<TInput> = TInput extends {
-    experimental: AthenaClientExperimentalOptions & {
-        athenaStorageBackend: true;
-        typecheckColumns: true;
-    };
-} ? AthenaSdkClientWithStorage<true, ExtractClientModels<TInput>> : TInput extends {
-    experimental: AthenaClientExperimentalOptions & {
-        athenaStorageBackend: true;
-    };
-} ? AthenaSdkClientWithStorage<false, ExtractClientModels<TInput>> : TInput extends {
-    experimental: AthenaClientExperimentalOptions & {
-        typecheckColumns: true;
-    };
-} ? AthenaSdkClientWithAuth<true, ExtractClientModels<TInput>> : AthenaSdkClientWithAuth<false, ExtractClientModels<TInput>>;
-/** Create client (convenience wrapper; use AthenaClient.builder() for full control) */
-declare function createClient<TConfig extends AthenaCreateClientConfig>(config: TConfig): AthenaCreateClientReturn<TConfig>;
-declare function createClient<TOptions extends AthenaCreateClientOptions | undefined>(url: string | null | undefined, apiKey: string | null | undefined, options?: TOptions): TOptions extends AthenaCreateClientOptions ? AthenaCreateClientReturn<TOptions> : AthenaSdkClientWithAuth<false>;
+declare function createClient<const TModels extends AthenaClientModelsInput | undefined = undefined>(config: AthenaClientConfig<TModels>): AthenaClient<TModels>;
 
-export { type AthenaChatWsReadUpdatedEvent as $, type AthenaChatAddMembersRequest as A, type AthenaChatRoom as B, type AthenaChatRoomCreatedResponse as C, type AthenaChatRoomKind as D, type AthenaChatRoomPage as E, type AthenaChatSearchHit as F, type AthenaChatSearchMessagesRequest as G, type AthenaChatSearchPage as H, type AthenaChatSendMessageRequest as I, type AthenaChatUpdateRoomRequest as J, type AthenaChatWebSocketFactory as K, type AthenaChatWebSocketLike as L, type AthenaChatWsAuthHelloCommand as M, type AthenaChatWsClientCommand as N, type AthenaChatWsErrorEvent as O, type AthenaChatWsHelloOkEvent as P, type AthenaChatWsMembersUpdatedEvent as Q, type AthenaChatWsMessageCreatedEvent as R, type AthenaChatWsMessageDeletedEvent as S, type AthenaChatWsMessageEventBase as T, type AthenaChatWsMessageUpdatedEvent as U, type AthenaChatWsPingCommand as V, type AthenaChatWsPongEvent as W, type AthenaChatWsPresenceHeartbeatCommand as X, type AthenaChatWsPresenceUpdatedEvent as Y, type AthenaChatWsReactionUpdatedEvent as Z, type AthenaChatWsReadUpToCommand as _, type AthenaChatAddReactionRequest as a, type AthenaStorageBaseModule as a$, type AthenaChatWsResumeCommand as a0, type AthenaChatWsRoomArchivedEvent as a1, type AthenaChatWsRoomCreatedEvent as a2, type AthenaChatWsRoomEventBase as a3, type AthenaChatWsRoomUpdatedEvent as a4, type AthenaChatWsServerEvent as a5, type AthenaChatWsSubscribeCommand as a6, type AthenaChatWsSubscribedEvent as a7, type AthenaChatWsSyncRequiredEvent as a8, type AthenaChatWsTypingStartCommand as a9, type AthenaEnvelope as aA, AthenaError as aB, AthenaErrorCategory as aC, AthenaErrorCode as aD, type AthenaErrorInput as aE, AthenaErrorKind as aF, type AthenaFindManyDebugAst as aG, type AthenaFromOptions as aH, type AthenaHeaderBag as aI, type AthenaInsertDebugAst as aJ, type AthenaOperationContext as aK, type AthenaQueryDebugAst as aL, type AthenaRawQueryDebugAst as aM, type AthenaRequestMethod as aN, type AthenaRequestOptions as aO, type AthenaRequestQueryValueMap as aP, type AthenaRequestResponse as aQ, type AthenaRequestService as aR, type AthenaResult as aS, type AthenaRpcBuilderStateAst as aT, type AthenaRpcDebugAst as aU, type AthenaSdkClient as aV, type AthenaSdkClientWithAuth as aW, type AthenaSdkClientWithStorage as aX, type AthenaSelectDebugAst as aY, type AthenaSelectDebugTransport as aZ, type AthenaStorageAuditNamespace as a_, type AthenaChatWsTypingStopCommand as aa, type AthenaChatWsTypingUpdatedEvent as ab, type AthenaChatWsUnsubscribeCommand as ac, AthenaClient as ad, type AthenaClientContextOptions as ae, type AthenaClientExperimentalOptions as af, type AthenaClientFromEnvironmentOptions as ag, type AthenaClientFromEnvironmentOptionsWithStorage as ah, type AthenaClientFromEnvironmentOptionsWithStorageAndTypecheckedColumns as ai, type AthenaClientFromEnvironmentOptionsWithTypecheckedColumns as aj, type AthenaClientOverrideOptions as ak, type AthenaClientSessionLike as al, type AthenaClientSessionOptions as am, type AthenaCreateClientAuthOptions as an, type AthenaCreateClientChatOptions as ao, type AthenaCreateClientConfig as ap, type AthenaCreateClientConfigWithStorage as aq, type AthenaCreateClientConfigWithStorageAndTypecheckedColumns as ar, type AthenaCreateClientConfigWithTypecheckedColumns as as, type AthenaCreateClientOptions as at, type AthenaCreateClientOptionsWithStorage as au, type AthenaCreateClientOptionsWithStorageAndTypecheckedColumns as av, type AthenaCreateClientOptionsWithTypecheckedColumns as aw, type AthenaCreateClientServiceUrlConfig as ax, type AthenaDbModule as ay, type AthenaDeleteDebugAst as az, type AthenaChatAttachmentInput as b, type RpcQueryBuilder as b$, type AthenaStorageBinaryCallOptions as b0, type AthenaStorageBucketCorsNamespace as b1, type AthenaStorageBucketNamespace as b2, type AthenaStorageCallOptions as b3, type AthenaStorageCatalogNamespace as b4, type AthenaStorageClientConfig as b5, type AthenaStorageCredentialsNamespace as b6, type AthenaStorageEnv as b7, AthenaStorageError as b8, AthenaStorageErrorCode as b9, type AthenaStorageUploadConstraints as bA, type AthenaStorageUploadProgress as bB, type AthenaStorageUploadProgressHandler as bC, type AthenaStorageUploadSource as bD, type AthenaStorageUploadedFile as bE, type AthenaTableBuilderStateAst as bF, type AthenaUpdateDebugAst as bG, type AthenaUpsertDebugAst as bH, type ConfirmStorageUploadRequest as bI, type CopyStorageFileRequest as bJ, type CreateStorageCatalogRequest as bK, type CreateStorageUploadUrlRequest as bL, type CreateStorageUploadUrlsRequest as bM, type DeleteManyStorageFilesRequest as bN, type DeleteStorageFolderRequest as bO, type GetStorageFileUrlQuery as bP, type IntCoercionOptions as bQ, type ListStorageFilesRequest as bR, type ListStorageFoldersRequest as bS, type ManagedFileRecord as bT, type MoveStorageFolderRequest as bU, type NormalizedAthenaError as bV, type PresignedFileUrlResponse as bW, type RequireAffectedOptions as bX, type RetryBackoffStrategy as bY, type RetryConfig as bZ, type RpcOrderOptions as b_, type AthenaStorageErrorDetails as ba, type AthenaStorageErrorHandler as bb, type AthenaStorageErrorInput as bc, type AthenaStorageFileConfig as bd, type AthenaStorageFileDeleteInput as be, type AthenaStorageFileDownloadInput as bf, type AthenaStorageFileListInput as bg, type AthenaStorageFileModule as bh, type AthenaStorageFileNamespace as bi, type AthenaStorageFileUploadInput as bj, type AthenaStorageFileUploadManyRequest as bk, type AthenaStorageFileUploadRequest as bl, type AthenaStorageFileUploadResult as bm, type AthenaStorageFolderNamespace as bn, type AthenaStorageManagedUpload as bo, type AthenaStorageModule as bp, type AthenaStorageMultipartNamespace as bq, type AthenaStorageObjectFolderNamespace as br, type AthenaStorageObjectNamespace as bs, type AthenaStoragePathContext as bt, type AthenaStoragePermissionNamespace as bu, type AthenaStoragePrefixPath as bv, type AthenaStoragePutBody as bw, type AthenaStoragePutOptions as bx, type AthenaStorageTemplateValue as by, type AthenaStorageTemplateVars as bz, type AthenaChatAttachmentView as c, type UpdateStorageFileRequest as c$, type S3CatalogItem as c0, type S3CredentialListItem as c1, type SearchStorageFilesRequest as c2, type SetManyStorageFileVisibilityRequest as c3, type SetStorageFileVisibilityRequest as c4, type StorageAuditEventRecord as c5, type StorageAuditListResponse as c6, type StorageAuditQueryRequest as c7, type StorageBatchUploadUrlResponse as c8, type StorageBatchUploadUrlResponseWithPut as c9, type StorageObjectRequest as cA, type StorageObjectValidateRequest as cB, type StorageObjectVersionListRequest as cC, type StorageObjectVersionMutationRequest as cD, type StoragePermissionCheckRequest as cE, type StoragePermissionCheckResponse as cF, type StoragePermissionGrantRequest as cG, type StoragePermissionListRequest as cH, type StoragePermissionListResponse as cI, type StoragePermissionRevokeRequest as cJ, type StoragePresignUploadRequest as cK, type StoragePublicAccessBlockRequest as cL, type StorageServerSideEncryptionOptions as cM, type StorageSetBucketCorsRequest as cN, type StorageSetBucketLifecycleRequest as cO, type StorageSetBucketPolicyRequest as cP, type StorageSetPublicAccessBlockRequest as cQ, type StorageSignedPostPolicyRequest as cR, type StorageUpdateObjectRequest as cS, type StorageUploadUrlResponse as cT, type StorageUploadUrlResponseWithPut as cU, type TableQueryBuilder as cV, type TreeStorageFoldersRequest as cW, type UnwrapOneOptions as cX, type UnwrapOptions as cY, type UpdateManyStorageFilesRequest as cZ, type UpdateStorageCatalogRequest as c_, type StorageBucketCorsRequest as ca, type StorageBucketCorsRuleInput as cb, type StorageBucketLifecycleRequest as cc, type StorageBucketLifecycleRuleInput as cd, type StorageBucketPolicyRequest as ce, type StorageFileAccessPurpose as cf, type StorageFileMutationManyResponse as cg, type StorageFileMutationResponse as ch, type StorageFilePermissionRecord as ci, type StorageFileRetentionRequest as cj, type StorageFileVersionPathRequest as ck, type StorageFolderMutationResponse as cl, type StorageListFilesResponse as cm, type StorageListObjectsRequest as cn, type StorageMultipartAbortRequest as co, type StorageMultipartCompletePartInput as cp, type StorageMultipartCompleteRequest as cq, type StorageMultipartCreateRequest as cr, type StorageMultipartListPartsRequest as cs, type StorageMultipartSignPartRequest as ct, type StorageObjectBaseRequest as cu, type StorageObjectCopyRequest as cv, type StorageObjectFolderCreateRequest as cw, type StorageObjectFolderDeleteRequest as cx, type StorageObjectFolderRenameRequest as cy, type StorageObjectPublicUrlRequest as cz, type AthenaChatCallOptions as d, assertInt as d0, coerceInt as d1, createAthenaStorageError as d2, createClient as d3, createStorageModule as d4, getAthenaDebugAst as d5, isOk as d6, normalizeAthenaError as d7, parseBooleanFlag as d8, requireAffected as d9, requireSuccess as da, storageSdkManifest as db, unwrap as dc, unwrapOne as dd, unwrapRows as de, verifyAthenaGatewayUrl as df, withRetry as dg, type AthenaClientBuilder as dh, type AthenaFindManyOptions as di, type AthenaFindManyResult as dj, type AthenaOrderBy as dk, type AthenaQueryTraceCallsite as dl, type AthenaQueryTraceEvent as dm, type AthenaQueryTraceOptions as dn, type AthenaRelationSelectNode as dp, type AthenaResultError as dq, type AthenaSelectShape as dr, type AthenaWhere as ds, type AthenaWhereBooleanOperand as dt, type AthenaWhereOperatorInput as du, type AthenaChatConnectOptions as e, type AthenaChatCreateRoomRequest as f, type AthenaChatDeleteResult as g, type AthenaChatEditMessageRequest as h, type AthenaChatListMessagesQuery as i, type AthenaChatListRoomsQuery as j, type AthenaChatMarkReadUpToRequest as k, type AthenaChatMember as l, type AthenaChatMemberRole as m, type AthenaChatMessage as n, type AthenaChatMessageCreatedResponse as o, type AthenaChatMessagePage as p, type AthenaChatModule as q, type AthenaChatPresenceUser as r, type AthenaChatReactionCount as s, type AthenaChatReactionSummary as t, type AthenaChatReadCursor as u, type AthenaChatRealtimeConnection as v, type AthenaChatRealtimeInfoResponse as w, type AthenaChatRealtimeModule as x, type AthenaChatRemoveResult as y, type AthenaChatResumeRoomCursor as z };
+export { type AthenaChatWsPresenceUpdatedEvent as $, type AthenaAuthConfig as A, type AthenaChatRealtimeModule as B, type AthenaChatRemoveResult as C, type AthenaChatResumeRoomCursor as D, type AthenaChatRoom as E, type AthenaChatRoomCreatedResponse as F, type AthenaChatRoomKind as G, type AthenaChatRoomPage as H, type AthenaChatSearchHit as I, type AthenaChatSearchMessagesRequest as J, type AthenaChatSearchPage as K, type AthenaChatSendMessageRequest as L, type AthenaChatUpdateRoomRequest as M, type AthenaChatWebSocketFactory as N, type AthenaChatWebSocketLike as O, type AthenaChatWsAuthHelloCommand as P, type AthenaChatWsClientCommand as Q, type AthenaChatWsErrorEvent as R, type AthenaChatWsHelloOkEvent as S, type AthenaChatWsMembersUpdatedEvent as T, type AthenaChatWsMessageCreatedEvent as U, type AthenaChatWsMessageDeletedEvent as V, type AthenaChatWsMessageEventBase as W, type AthenaChatWsMessageUpdatedEvent as X, type AthenaChatWsPingCommand as Y, type AthenaChatWsPongEvent as Z, type AthenaChatWsPresenceHeartbeatCommand as _, type AthenaBillingConfig as a, type AthenaStorageErrorHandler as a$, type AthenaChatWsReactionUpdatedEvent as a0, type AthenaChatWsReadUpToCommand as a1, type AthenaChatWsReadUpdatedEvent as a2, type AthenaChatWsResumeCommand as a3, type AthenaChatWsRoomArchivedEvent as a4, type AthenaChatWsRoomCreatedEvent as a5, type AthenaChatWsRoomEventBase as a6, type AthenaChatWsRoomUpdatedEvent as a7, type AthenaChatWsServerEvent as a8, type AthenaChatWsSubscribeCommand as a9, type AthenaRequestMethod as aA, type AthenaRequestOptions as aB, type AthenaRequestQueryValueMap as aC, type AthenaRequestResponse as aD, type AthenaRequestService as aE, type AthenaResult as aF, type AthenaRpcBuilderStateAst as aG, type AthenaRpcDebugAst as aH, type AthenaSelectDebugAst as aI, type AthenaSelectDebugTransport as aJ, type AthenaService as aK, type AthenaStorageAuditNamespace as aL, type AthenaStorageBackupNamespace as aM, type AthenaStorageBaseModule as aN, type AthenaStorageBinaryCallOptions as aO, type AthenaStorageBucketCorsNamespace as aP, type AthenaStorageBucketNamespace as aQ, type AthenaStorageCallOptions as aR, type AthenaStorageCatalogNamespace as aS, type AthenaStorageClientConfig as aT, type AthenaStorageConfig as aU, type AthenaStorageCredentialsNamespace as aV, type AthenaStorageDirectUploadConfig as aW, type AthenaStorageEnv as aX, AthenaStorageError as aY, AthenaStorageErrorCode as aZ, type AthenaStorageErrorDetails as a_, type AthenaChatWsSubscribedEvent as aa, type AthenaChatWsSyncRequiredEvent as ab, type AthenaChatWsTypingStartCommand as ac, type AthenaChatWsTypingStopCommand as ad, type AthenaChatWsTypingUpdatedEvent as ae, type AthenaChatWsUnsubscribeCommand as af, type AthenaClient as ag, type AthenaClientConfig as ah, AthenaConfigurationError as ai, type AthenaDbConfig as aj, type AthenaDbModule as ak, type AthenaDeleteDebugAst as al, type AthenaEnvelope as am, AthenaError as an, AthenaErrorCategory as ao, AthenaErrorCode as ap, type AthenaErrorInput as aq, AthenaErrorKind as ar, type AthenaFindManyDebugAst as as, type AthenaFromOptions as at, type AthenaInsertDebugAst as au, type AthenaOperationContext as av, type AthenaQueryDebugAst as aw, type AthenaRawQueryDebugAst as ax, type AthenaRequestContext as ay, type AthenaRequestContextProvider as az, type AthenaChatAddMembersRequest as b, type StorageBackupJob as b$, type AthenaStorageErrorInput as b0, type AthenaStorageFileConfig as b1, type AthenaStorageFileDeleteInput as b2, type AthenaStorageFileDownloadInput as b3, type AthenaStorageFileListInput as b4, type AthenaStorageFileModule as b5, type AthenaStorageFileNamespace as b6, type AthenaStorageFileUploadInput as b7, type AthenaStorageFileUploadManyRequest as b8, type AthenaStorageFileUploadRequest as b9, type CreateStorageUploadUrlRequest as bA, type CreateStorageUploadUrlsRequest as bB, type DeleteManyStorageFilesRequest as bC, type DeleteStorageFolderRequest as bD, type DeprecatedInlineStorageConnectionFields as bE, type GetStorageFileUrlQuery as bF, type IntCoercionOptions as bG, type ListStorageFilesRequest as bH, type ListStorageFoldersRequest as bI, type ManagedFileRecord as bJ, type MoveStorageFolderRequest as bK, type NormalizedAthenaError as bL, type PresignedFileUrlResponse as bM, type RequireAffectedOptions as bN, type RetryBackoffStrategy as bO, type RetryConfig as bP, type RpcOrderOptions as bQ, type RpcQueryBuilder as bR, type S3CatalogItem as bS, type S3CredentialListItem as bT, type SearchStorageFilesRequest as bU, type SetManyStorageFileVisibilityRequest as bV, type SetStorageFileVisibilityRequest as bW, type StorageAuditEventRecord as bX, type StorageAuditListResponse as bY, type StorageAuditQueryRequest as bZ, type StorageBackupCreateRequest as b_, type AthenaStorageFileUploadResult as ba, type AthenaStorageFolderNamespace as bb, type AthenaStorageManagedUpload as bc, type AthenaStorageModule as bd, type AthenaStorageMultipartNamespace as be, type AthenaStorageObjectFolderNamespace as bf, type AthenaStorageObjectNamespace as bg, type AthenaStoragePathContext as bh, type AthenaStoragePermissionNamespace as bi, type AthenaStoragePrefixPath as bj, type AthenaStoragePutBody as bk, type AthenaStoragePutOptions as bl, type AthenaStorageTemplateValue as bm, type AthenaStorageTemplateVars as bn, type AthenaStorageUploadConstraints as bo, type AthenaStorageUploadProgress as bp, type AthenaStorageUploadProgressHandler as bq, type AthenaStorageUploadSource as br, type AthenaStorageUploadedFile as bs, type AthenaTableBuilderStateAst as bt, type AthenaUpdateDebugAst as bu, type AthenaUpsertDebugAst as bv, type BackupRecoveryStrategy as bw, type ConfirmStorageUploadRequest as bx, type CopyStorageFileRequest as by, type CreateStorageCatalogRequest as bz, type AthenaChatAddReactionRequest as c, type UpdateStorageFileRequest as c$, type StorageBackupListPage as c0, type StorageBackupListQuery as c1, type StorageBackupQueuedJob as c2, type StorageBackupRecord as c3, type StorageBackupRestoreRequest as c4, type StorageBackupSchedule as c5, type StorageBackupScheduleCreateRequest as c6, type StorageBatchUploadUrlResponse as c7, type StorageBatchUploadUrlResponseWithPut as c8, type StorageBucketCorsRequest as c9, type StorageObjectRequest as cA, type StorageObjectValidateRequest as cB, type StorageObjectVersionListRequest as cC, type StorageObjectVersionMutationRequest as cD, type StoragePermissionCheckRequest as cE, type StoragePermissionCheckResponse as cF, type StoragePermissionGrantRequest as cG, type StoragePermissionListRequest as cH, type StoragePermissionListResponse as cI, type StoragePermissionRevokeRequest as cJ, type StoragePresignUploadRequest as cK, type StoragePublicAccessBlockRequest as cL, type StorageServerSideEncryptionOptions as cM, type StorageSetBucketCorsRequest as cN, type StorageSetBucketLifecycleRequest as cO, type StorageSetBucketPolicyRequest as cP, type StorageSetPublicAccessBlockRequest as cQ, type StorageSignedPostPolicyRequest as cR, type StorageUpdateObjectRequest as cS, type StorageUploadUrlResponse as cT, type StorageUploadUrlResponseWithPut as cU, type TableQueryBuilder as cV, type TreeStorageFoldersRequest as cW, type UnwrapOneOptions as cX, type UnwrapOptions as cY, type UpdateManyStorageFilesRequest as cZ, type UpdateStorageCatalogRequest as c_, type StorageBucketCorsRuleInput as ca, type StorageBucketLifecycleRequest as cb, type StorageBucketLifecycleRuleInput as cc, type StorageBucketPolicyRequest as cd, type StorageConnectionSelector as ce, type StorageFileAccessPurpose as cf, type StorageFileMutationManyResponse as cg, type StorageFileMutationResponse as ch, type StorageFilePermissionRecord as ci, type StorageFileRetentionRequest as cj, type StorageFileVersionPathRequest as ck, type StorageFolderMutationResponse as cl, type StorageListFilesResponse as cm, type StorageListObjectsRequest as cn, type StorageMultipartAbortRequest as co, type StorageMultipartCompletePartInput as cp, type StorageMultipartCompleteRequest as cq, type StorageMultipartCreateRequest as cr, type StorageMultipartListPartsRequest as cs, type StorageMultipartSignPartRequest as ct, type StorageObjectBaseRequest as cu, type StorageObjectCopyRequest as cv, type StorageObjectFolderCreateRequest as cw, type StorageObjectFolderDeleteRequest as cx, type StorageObjectFolderRenameRequest as cy, type StorageObjectPublicUrlRequest as cz, type AthenaChatAttachmentInput as d, assertInt as d0, coerceInt as d1, createAthenaStorageError as d2, createClient as d3, createStorageModule as d4, getAthenaDebugAst as d5, isOk as d6, normalizeAthenaError as d7, parseBooleanFlag as d8, requireAffected as d9, requireSuccess as da, storageSdkManifest as db, unwrap as dc, unwrapOne as dd, unwrapRows as de, verifyAthenaGatewayUrl as df, withRetry as dg, type AthenaFindManyOptions as dh, type AthenaFindManyResult as di, type AthenaOrderBy as dj, type AthenaQueryTraceCallsite as dk, type AthenaQueryTraceEvent as dl, type AthenaQueryTraceOptions as dm, type AthenaRelationSelectNode as dn, type AthenaResultError as dp, type AthenaSelectShape as dq, type AthenaWhere as dr, type AthenaWhereBooleanOperand as ds, type AthenaWhereOperatorInput as dt, DEFAULT_MULTIPART_PART_SIZE_BYTES as du, DEFAULT_MULTIPART_THRESHOLD_BYTES as dv, createStorageFileModule as dw, resolveStoragePath as dx, type AthenaChatAttachmentView as e, type AthenaChatCallOptions as f, type AthenaChatConfig as g, type AthenaChatConnectOptions as h, type AthenaChatCreateRoomRequest as i, type AthenaChatDeleteResult as j, type AthenaChatEditMessageRequest as k, type AthenaChatListMessagesQuery as l, type AthenaChatListRoomsQuery as m, type AthenaChatMarkReadUpToRequest as n, type AthenaChatMember as o, type AthenaChatMemberRole as p, type AthenaChatMessage as q, type AthenaChatMessageCreatedResponse as r, type AthenaChatMessagePage as s, type AthenaChatModule as t, type AthenaChatPresenceUser as u, type AthenaChatReactionCount as v, type AthenaChatReactionSummary as w, type AthenaChatReadCursor as x, type AthenaChatRealtimeConnection as y, type AthenaChatRealtimeInfoResponse as z };