@xylex-group/athena 2.14.0 → 3.0.0

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

@@ -1,26 +1,7 @@
-import { a as AthenaGatewayCallOptions, b as AthenaGatewayConnectionOptions, c as AthenaGatewayConnectionResult, w as AthenaFetchPayload, s as AthenaGatewayResponse, x as AthenaInsertPayload, y as AthenaUpdatePayload, v as AthenaDeletePayload, n as AthenaRpcPayload, j as AthenaRpcCallOptions, C as AthenaQueryPayload, q as AthenaGatewayEndpointPath, r as AthenaGatewayMethod, i as AthenaJsonValue, g as AthenaJsonObject, 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-YQUR7wu0.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-CD6K05JQ.js';
-
-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>>;
-}
+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: {
@@ -194,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.
  *
@@ -205,6 +186,154 @@ 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;
+type Trim<TValue extends string> = TrimLeft<TrimRight<TValue>>;
+/** Known string keys of a row / model type (empty when the shape is untyped). */
+type AthenaColumnKey<Row> = Extract<keyof NonNullable<Row>, string>;
+type KnownSelectColumnKey<Row> = AthenaColumnKey<Row>;
+type HasKnownSelectColumns<Row> = [KnownSelectColumnKey<Row>] extends [never] ? false : string extends KnownSelectColumnKey<Row> ? false : true;
+type HasComplexSelectTokenSyntax<TValue extends string> = TValue extends `${string}(${string}` ? true : TValue extends `${string})${string}` ? true : TValue extends `${string}.${string}` ? true : TValue extends `${string}"${string}` ? true : TValue extends `${string}'${string}` ? true : false;
+type ValidateAliasedBase<Row, TOriginal extends string, TBase extends string> = HasComplexSelectTokenSyntax<Trim<TBase>> extends true ? TOriginal : Trim<TBase> extends KnownSelectColumnKey<Row> ? TOriginal : never;
+type ValidateSelectToken<Row, TToken extends string> = Trim<TToken> extends infer TTrimmed extends string ? TTrimmed extends '' ? never : TTrimmed extends '*' ? TTrimmed : TTrimmed extends `${string}:${infer TBase}` ? ValidateAliasedBase<Row, TTrimmed, TBase> : TTrimmed extends `${infer TBase} as ${string}` ? ValidateAliasedBase<Row, TTrimmed, TBase> : TTrimmed extends `${infer TBase} AS ${string}` ? ValidateAliasedBase<Row, TTrimmed, TBase> : HasComplexSelectTokenSyntax<TTrimmed> extends true ? TTrimmed : TTrimmed extends KnownSelectColumnKey<Row> ? TTrimmed : never : never;
+type ValidateSelectList<Row, TValue extends string> = string extends TValue ? TValue : HasComplexSelectTokenSyntax<TValue> extends true ? TValue : TValue extends `${infer THead},${infer TTail}` ? ValidateSelectToken<Row, THead> extends never ? never : ValidateSelectList<Row, TTail> extends never ? never : TValue : ValidateSelectToken<Row, TValue> extends never ? never : TValue;
+/**
+ * Preferred element type for typed array selects.
+ * Contextual typing validates each array-literal element against known keys
+ * (no `as const` required) and powers IntelliSense on each slot.
+ */
+type AthenaSelectArrayElement<Row> = HasKnownSelectColumns<Row> extends true ? KnownSelectColumnKey<Row> | '*' : string;
+type AthenaSelectInput = string | string[] | readonly string[];
+/**
+ * Compile-time validation for `select` / `single` / `maybeSingle` when
+ * row keys are known.
+ *
+ * - Comma-separated strings: validates each simple token (aliases / relation
+ *   syntax are allowed through).
+ * - Arrays: always `readonly (keyof Row | '*')[]` for element IntelliSense and
+ *   checking without `as const`.
+ */
+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. Known model keys are closed; dynamic
+ * rows retain free-form string support.
+ */
+type AthenaTypecheckedColumnKey<Row> = HasKnownSelectColumns<Row> extends true ? KnownSelectColumnKey<Row> : string;
+
+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<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>;
+    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[]>>;
+}
+
+/** 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>;
@@ -250,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 {
@@ -277,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;
@@ -309,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[]>;
@@ -316,6 +460,33 @@ 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.*`.
@@ -1118,7 +1289,7 @@ interface CreateStorageCatalogRequest {
      */
     region?: string;
     bucket: string;
-    /** Storage provider: `s3`, `r2`, or `cloudflare_r2` (and free-form S3-compatible labels). */
+    /** 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.
@@ -1385,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;
@@ -1435,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;
@@ -1454,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[];
@@ -1466,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;
@@ -1479,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;
@@ -1523,7 +1723,7 @@ interface AthenaStorageClientConfig extends AthenaStorageFileConfig {
     onError?: AthenaStorageErrorHandler;
 }
 /**
- * Experimental credentials for signing the upload PUT in the client.
+ * 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.
  */
@@ -1801,73 +2001,6 @@ interface AthenaStorageModule extends AthenaStorageBaseModule {
 declare function createAthenaStorageError(input: AthenaStorageErrorInput): AthenaStorageError;
 declare function createStorageModule(gateway: AthenaGatewayClient, runtimeOptions?: AthenaStorageClientConfig): AthenaStorageModule;
 
-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;
-type Trim<TValue extends string> = TrimLeft<TrimRight<TValue>>;
-/** Known string keys of a row / model type (empty when the shape is untyped). */
-type AthenaColumnKey<Row> = Extract<keyof NonNullable<Row>, string>;
-type KnownSelectColumnKey<Row> = AthenaColumnKey<Row>;
-type HasKnownSelectColumns<Row> = [KnownSelectColumnKey<Row>] extends [never] ? false : string extends KnownSelectColumnKey<Row> ? false : true;
-type HasComplexSelectTokenSyntax<TValue extends string> = TValue extends `${string}(${string}` ? true : TValue extends `${string})${string}` ? true : TValue extends `${string}.${string}` ? true : TValue extends `${string}"${string}` ? true : TValue extends `${string}'${string}` ? true : false;
-type ValidateAliasedBase<Row, TOriginal extends string, TBase extends string> = HasComplexSelectTokenSyntax<Trim<TBase>> extends true ? TOriginal : Trim<TBase> extends KnownSelectColumnKey<Row> ? TOriginal : never;
-type ValidateSelectToken<Row, TToken extends string> = Trim<TToken> extends infer TTrimmed extends string ? TTrimmed extends '' ? never : TTrimmed extends '*' ? TTrimmed : TTrimmed extends `${string}:${infer TBase}` ? ValidateAliasedBase<Row, TTrimmed, TBase> : TTrimmed extends `${infer TBase} as ${string}` ? ValidateAliasedBase<Row, TTrimmed, TBase> : TTrimmed extends `${infer TBase} AS ${string}` ? ValidateAliasedBase<Row, TTrimmed, TBase> : HasComplexSelectTokenSyntax<TTrimmed> extends true ? TTrimmed : TTrimmed extends KnownSelectColumnKey<Row> ? TTrimmed : never : never;
-type ValidateSelectList<Row, TValue extends string> = string extends TValue ? TValue : HasComplexSelectTokenSyntax<TValue> extends true ? TValue : TValue extends `${infer THead},${infer TTail}` ? ValidateSelectToken<Row, THead> extends never ? never : ValidateSelectList<Row, TTail> extends never ? never : TValue : ValidateSelectToken<Row, TValue> extends never ? never : TValue;
-/**
- * Preferred element type for typed array selects.
- * Contextual typing validates each array-literal element against known keys
- * (no `as const` required) and powers IntelliSense on each slot.
- */
-type AthenaSelectArrayElement<Row> = HasKnownSelectColumns<Row> extends true ? KnownSelectColumnKey<Row> | '*' : string;
-type AthenaSelectInput = string | string[] | readonly string[];
-/**
- * Compile-time validation for `select` / `single` / `maybeSingle` when
- * `experimental.typecheckColumns` is enabled and row keys are known.
- *
- * - Comma-separated strings: validates each simple token (aliases / relation
- *   syntax are allowed through).
- * - Arrays: always `readonly (keyof Row | '*')[]` for element IntelliSense and
- *   checking without `as const`.
- */
-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.
- */
-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 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 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 & {
-        resourceId?: string;
-    }): MutationQuery<Row | null, Row, TStrict>;
-    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[]>>;
-}
-
 type AthenaChatRoomKind = 'dm' | 'group' | 'channel';
 type AthenaChatMemberRole = 'owner' | 'admin' | 'member';
 interface AthenaChatAttachmentInput {
@@ -2165,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 {
@@ -2236,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';
@@ -2255,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 = {
@@ -2269,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>;
 };
@@ -2298,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>;
@@ -2457,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'];
     };
@@ -2508,122 +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;
-    /**
-     * Sign high-level `storage.file.upload(...)` PUTs in the client and send
-     * file bytes directly to the configured S3-compatible storage endpoint.
-     * Athena still creates managed-file metadata, preserving the upload result contract.
-     */
-    directStorageUpload?: AthenaStorageDirectUploadConfig;
-    /**
-     * Optional storage SDK runtime hooks. Only used when `athenaStorageBackend` is enabled.
-     */
-    storage?: AthenaStorageClientConfig;
-}
 interface AthenaQueryTraceOptions {
     /**
      * Custom sink for trace events. Defaults to console.info.
@@ -2662,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>>;
@@ -2725,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 AthenaStorageBackupNamespace 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 RetryBackoffStrategy as b$, type AthenaStorageBaseModule as b0, type AthenaStorageBinaryCallOptions as b1, type AthenaStorageBucketCorsNamespace as b2, type AthenaStorageBucketNamespace as b3, type AthenaStorageCallOptions as b4, type AthenaStorageCatalogNamespace as b5, type AthenaStorageClientConfig as b6, type AthenaStorageCredentialsNamespace as b7, type AthenaStorageDirectUploadConfig as b8, type AthenaStorageEnv as b9, type AthenaStorageTemplateValue as bA, type AthenaStorageTemplateVars as bB, type AthenaStorageUploadConstraints as bC, type AthenaStorageUploadProgress as bD, type AthenaStorageUploadProgressHandler as bE, type AthenaStorageUploadSource as bF, type AthenaStorageUploadedFile as bG, type AthenaTableBuilderStateAst as bH, type AthenaUpdateDebugAst as bI, type AthenaUpsertDebugAst as bJ, type BackupRecoveryStrategy as bK, type ConfirmStorageUploadRequest as bL, type CopyStorageFileRequest as bM, type CreateStorageCatalogRequest as bN, type CreateStorageUploadUrlRequest as bO, type CreateStorageUploadUrlsRequest as bP, type DeleteManyStorageFilesRequest as bQ, type DeleteStorageFolderRequest as bR, type GetStorageFileUrlQuery as bS, type IntCoercionOptions as bT, type ListStorageFilesRequest as bU, type ListStorageFoldersRequest as bV, type ManagedFileRecord as bW, type MoveStorageFolderRequest as bX, type NormalizedAthenaError as bY, type PresignedFileUrlResponse as bZ, type RequireAffectedOptions as b_, AthenaStorageError as ba, AthenaStorageErrorCode as bb, type AthenaStorageErrorDetails as bc, type AthenaStorageErrorHandler as bd, type AthenaStorageErrorInput as be, type AthenaStorageFileConfig as bf, type AthenaStorageFileDeleteInput as bg, type AthenaStorageFileDownloadInput as bh, type AthenaStorageFileListInput as bi, type AthenaStorageFileModule as bj, type AthenaStorageFileNamespace as bk, type AthenaStorageFileUploadInput as bl, type AthenaStorageFileUploadManyRequest as bm, type AthenaStorageFileUploadRequest as bn, type AthenaStorageFileUploadResult as bo, type AthenaStorageFolderNamespace as bp, type AthenaStorageManagedUpload as bq, type AthenaStorageModule as br, type AthenaStorageMultipartNamespace as bs, type AthenaStorageObjectFolderNamespace as bt, type AthenaStorageObjectNamespace as bu, type AthenaStoragePathContext as bv, type AthenaStoragePermissionNamespace as bw, type AthenaStoragePrefixPath as bx, type AthenaStoragePutBody as by, type AthenaStoragePutOptions as bz, type AthenaChatAttachmentView as c, type StorageSetBucketPolicyRequest as c$, type RetryConfig as c0, type RpcOrderOptions as c1, type RpcQueryBuilder as c2, type S3CatalogItem as c3, type S3CredentialListItem as c4, type SearchStorageFilesRequest as c5, type SetManyStorageFileVisibilityRequest as c6, type SetStorageFileVisibilityRequest as c7, type StorageAuditEventRecord as c8, type StorageAuditListResponse as c9, type StorageMultipartAbortRequest as cA, type StorageMultipartCompletePartInput as cB, type StorageMultipartCompleteRequest as cC, type StorageMultipartCreateRequest as cD, type StorageMultipartListPartsRequest as cE, type StorageMultipartSignPartRequest as cF, type StorageObjectBaseRequest as cG, type StorageObjectCopyRequest as cH, type StorageObjectFolderCreateRequest as cI, type StorageObjectFolderDeleteRequest as cJ, type StorageObjectFolderRenameRequest as cK, type StorageObjectPublicUrlRequest as cL, type StorageObjectRequest as cM, type StorageObjectValidateRequest as cN, type StorageObjectVersionListRequest as cO, type StorageObjectVersionMutationRequest as cP, type StoragePermissionCheckRequest as cQ, type StoragePermissionCheckResponse as cR, type StoragePermissionGrantRequest as cS, type StoragePermissionListRequest as cT, type StoragePermissionListResponse as cU, type StoragePermissionRevokeRequest as cV, type StoragePresignUploadRequest as cW, type StoragePublicAccessBlockRequest as cX, type StorageServerSideEncryptionOptions as cY, type StorageSetBucketCorsRequest as cZ, type StorageSetBucketLifecycleRequest as c_, type StorageAuditQueryRequest as ca, type StorageBackupCreateRequest as cb, type StorageBackupJob as cc, type StorageBackupListPage as cd, type StorageBackupListQuery as ce, type StorageBackupQueuedJob as cf, type StorageBackupRecord as cg, type StorageBackupRestoreRequest as ch, type StorageBackupSchedule as ci, type StorageBackupScheduleCreateRequest as cj, type StorageBatchUploadUrlResponse as ck, type StorageBatchUploadUrlResponseWithPut as cl, type StorageBucketCorsRequest as cm, type StorageBucketCorsRuleInput as cn, type StorageBucketLifecycleRequest as co, type StorageBucketLifecycleRuleInput as cp, type StorageBucketPolicyRequest as cq, type StorageFileAccessPurpose as cr, type StorageFileMutationManyResponse as cs, type StorageFileMutationResponse as ct, type StorageFilePermissionRecord as cu, type StorageFileRetentionRequest as cv, type StorageFileVersionPathRequest as cw, type StorageFolderMutationResponse as cx, type StorageListFilesResponse as cy, type StorageListObjectsRequest as cz, type AthenaChatCallOptions as d, type StorageSetPublicAccessBlockRequest as d0, type StorageSignedPostPolicyRequest as d1, type StorageUpdateObjectRequest as d2, type StorageUploadUrlResponse as d3, type StorageUploadUrlResponseWithPut as d4, type TableQueryBuilder as d5, type TreeStorageFoldersRequest as d6, type UnwrapOneOptions as d7, type UnwrapOptions as d8, type UpdateManyStorageFilesRequest as d9, type AthenaQueryTraceOptions as dA, type AthenaRelationSelectNode as dB, type AthenaResultError as dC, type AthenaSelectShape as dD, type AthenaWhere as dE, type AthenaWhereBooleanOperand as dF, type AthenaWhereOperatorInput as dG, type UpdateStorageCatalogRequest as da, type UpdateStorageFileRequest as db, assertInt as dc, coerceInt as dd, createAthenaStorageError as de, createClient as df, createStorageModule as dg, getAthenaDebugAst as dh, isOk as di, normalizeAthenaError as dj, parseBooleanFlag as dk, requireAffected as dl, requireSuccess as dm, storageSdkManifest as dn, unwrap as dp, unwrapOne as dq, unwrapRows as dr, verifyAthenaGatewayUrl as ds, withRetry as dt, type AthenaClientBuilder as du, type AthenaFindManyOptions as dv, type AthenaFindManyResult as dw, type AthenaOrderBy as dx, type AthenaQueryTraceCallsite as dy, type AthenaQueryTraceEvent as dz, 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 };