@xylex-group/athena 2.14.0 → 3.0.2

package/dist/{client-wU2J9yqb.d.cts → v3-client-CWfZHcKL.d.cts}

@@ -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.cjs';
-import { F as AthenaAuthClientConfig, D as AthenaAuthBindings } from './types-eAKAh71s.cjs';
-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-6H575ITc.cjs';
-
-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.cjs';
+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.cjs';
+import { A as AthenaModelTarget, n as RowOf, a as InsertOf, U as UpdateOf, u as AthenaClientTableName, t as AthenaClientModelForTableName, R as RegistryDef, D as DatabaseDef, o as SchemaDef, s as AnyModelDef, j as ModelDef, m as ModelRelationMetadata, r as AthenaClientModelsInput } from './types-CgCv5o6R.cjs';
+import { a as AthenaBillingClientConfig, c as AthenaBillingModule } from './module-C_ab-MM1.cjs';
 
 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$1<Row> = AthenaColumnKey<Row>;
+type HasKnownSelectColumns<Row> = [KnownSelectColumnKey$1<Row>] extends [never] ? false : string extends KnownSelectColumnKey$1<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$1<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$1<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$1<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$1<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,9 +2369,10 @@ 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 KnownSelectColumnKey<Row> = AthenaColumnKey<Row>;
 type AthenaFilterOperator = 'eq' | 'neq' | 'gt' | 'gte' | 'lt' | 'lte' | 'like' | 'ilike' | 'is' | 'in' | 'contains' | 'containedBy';
 type AthenaWherePrimitive = AthenaConditionValue;
 type AthenaWhereOperatorInput = {
@@ -2255,7 +2389,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 +2403,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>;
 };
@@ -2283,26 +2417,46 @@ interface AthenaRelationSelectNode<TSelect extends AthenaSelectShape = AthenaSel
 }
 type AthenaSelectShape = Record<string, true | AthenaRelationSelectNode<AthenaSelectShape>>;
 type AthenaAllowedRelationSelectNodeKey = 'select' | 'as' | 'via' | 'schema';
+/**
+ * Structural validation only (relation node shape). Nested relation target rows
+ * are not model-checked here unless a richer context path is wired later.
+ */
+type AthenaStructuralValidatedSelectShape<TSelect> = {
+    [K in keyof TSelect]: TSelect[K] extends true ? true : AthenaValidatedRelationSelectNode<TSelect[K]>;
+};
 type AthenaValidatedRelationSelectNode<TNode> = TNode extends {
     select: infer TChild;
 } ? Exclude<keyof TNode, AthenaAllowedRelationSelectNodeKey> extends never ? TNode extends {
     schema: string;
     via: string;
 } ? never : TChild extends Record<string, unknown> ? {
-    [K in keyof TNode]: K extends 'select' ? AthenaValidatedSelectShape<TChild> : K extends AthenaAllowedRelationSelectNodeKey ? TNode[K] : never;
+    [K in keyof TNode]: K extends 'select' ? AthenaStructuralValidatedSelectShape<TChild> : K extends AthenaAllowedRelationSelectNodeKey ? TNode[K] : never;
 } : never : never : never;
-type AthenaValidatedSelectShape<TSelect> = {
-    [K in keyof TSelect]: TSelect[K] extends true ? true : AthenaValidatedRelationSelectNode<TSelect[K]>;
-};
+/**
+ * Compile-time validation for `findMany({ select })`.
+ *
+ * - When `Row` has known model keys: scalar `true` entries must use those keys.
+ * - Relation nodes (`{ select: ... }`) keep structural validation and may use
+ *   non-row keys (relation names are not row columns).
+ * - When `Row` is untyped: free-form keys (same as pre-model behavior).
+ */
+type AthenaValidatedSelectShape<Row, TSelect> = HasKnownSelectColumns<Row> extends true ? {
+    [K in keyof TSelect]: TSelect[K] extends true ? K extends KnownSelectColumnKey<Row> ? true : never : AthenaValidatedRelationSelectNode<TSelect[K]>;
+} : AthenaStructuralValidatedSelectShape<TSelect>;
 type GenericRegistryDef = RegistryDef<Record<string, DatabaseDef<Record<string, SchemaDef<Record<string, AnyModelDef>>>>>>;
 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> {
+    /**
+     * Object select tree. Callers should pass through `findMany(...)`, which
+     * intersects this with `AthenaValidatedSelectShape<Row, TSelect>` so model
+     * column keys are checked after `TSelect` is inferred from the literal.
+     */
     select: TSelect;
     where?: AthenaWhere<Row>;
     orderBy?: AthenaOrderBy<Row>;
@@ -2410,7 +2564,7 @@ type AthenaFindManyDebugTransport<Row = Record<string, unknown>, TSelect extends
 interface AthenaFindManyDebugAst<Row = Record<string, unknown>, TSelect extends AthenaSelectShape = AthenaSelectShape> extends AthenaDebugAstBase<'findMany'> {
     tableName: string;
     input: {
-        select: AthenaValidatedSelectShape<TSelect>;
+        select: TSelect;
         where?: AthenaWhere<Row>;
         orderBy?: AthenaOrderBy<Row>;
         limit?: number;
@@ -2457,7 +2611,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 +2662,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 +2700,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 +2750,133 @@ 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>;
+        select: AthenaValidatedSelectShape<Row, 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;
-    };
+    }): 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 AthenaCreateClientOptionsWithTypecheckedColumns extends AthenaCreateClientOptions {
-    experimental: AthenaClientExperimentalOptions & {
-        typecheckColumns: true;
-    };
-}
-interface AthenaCreateClientOptionsWithStorageAndTypecheckedColumns extends AthenaCreateClientOptions {
-    experimental: AthenaClientExperimentalOptions & {
-        athenaStorageBackend: true;
-        typecheckColumns: true;
-    };
+
+type MaybePromise<T> = T | Promise<T>;
+type ResolvedModels<TModels> = TModels extends AthenaClientModelsInput ? TModels : never;
+
+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 AthenaStorageFileConfig 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 AthenaRequestOptions as aA, type AthenaRequestQueryValueMap as aB, type AthenaRequestResponse as aC, type AthenaRequestService as aD, type AthenaResult as aE, type AthenaRpcBuilderStateAst as aF, type AthenaRpcDebugAst as aG, type AthenaSelectDebugAst as aH, type AthenaSelectDebugTransport as aI, type AthenaStorageAuditNamespace as aJ, type AthenaStorageBackupNamespace as aK, type AthenaStorageBaseModule as aL, type AthenaStorageBinaryCallOptions as aM, type AthenaStorageBucketCorsNamespace as aN, type AthenaStorageBucketNamespace as aO, type AthenaStorageCallOptions as aP, type AthenaStorageCatalogNamespace as aQ, type AthenaStorageClientConfig as aR, type AthenaStorageConfig as aS, type AthenaStorageCredentialsNamespace as aT, type AthenaStorageDirectUploadConfig as aU, type AthenaStorageEnv as aV, AthenaStorageError as aW, AthenaStorageErrorCode as aX, type AthenaStorageErrorDetails as aY, type AthenaStorageErrorHandler as aZ, type AthenaStorageErrorInput 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, type AthenaDbConfig as ai, type AthenaDbModule as aj, type AthenaDeleteDebugAst as ak, type AthenaEnvelope as al, AthenaError as am, AthenaErrorCategory as an, AthenaErrorCode as ao, type AthenaErrorInput as ap, AthenaErrorKind as aq, type AthenaFindManyDebugAst as ar, type AthenaFromOptions as as, type AthenaInsertDebugAst as at, type AthenaOperationContext as au, type AthenaQueryDebugAst as av, type AthenaRawQueryDebugAst as aw, type AthenaRequestContext as ax, type AthenaRequestContextProvider as ay, type AthenaRequestMethod as az, type AthenaChatAddMembersRequest as b, type StorageBackupListQuery as b$, type AthenaStorageFileDeleteInput as b0, type AthenaStorageFileDownloadInput as b1, type AthenaStorageFileListInput as b2, type AthenaStorageFileModule as b3, type AthenaStorageFileNamespace as b4, type AthenaStorageFileUploadInput as b5, type AthenaStorageFileUploadManyRequest as b6, type AthenaStorageFileUploadRequest as b7, type AthenaStorageFileUploadResult as b8, type AthenaStorageFolderNamespace as b9, type DeleteManyStorageFilesRequest as bA, type DeleteStorageFolderRequest as bB, type DeprecatedInlineStorageConnectionFields as bC, type GetStorageFileUrlQuery as bD, type IntCoercionOptions as bE, type ListStorageFilesRequest as bF, type ListStorageFoldersRequest as bG, type ManagedFileRecord as bH, type MoveStorageFolderRequest as bI, type NormalizedAthenaError as bJ, type PresignedFileUrlResponse as bK, type RequireAffectedOptions as bL, type RetryBackoffStrategy as bM, type RetryConfig as bN, type RpcOrderOptions as bO, type RpcQueryBuilder as bP, type S3CatalogItem as bQ, type S3CredentialListItem as bR, type SearchStorageFilesRequest as bS, type SetManyStorageFileVisibilityRequest as bT, type SetStorageFileVisibilityRequest as bU, type StorageAuditEventRecord as bV, type StorageAuditListResponse as bW, type StorageAuditQueryRequest as bX, type StorageBackupCreateRequest as bY, type StorageBackupJob as bZ, type StorageBackupListPage as b_, type AthenaStorageManagedUpload as ba, type AthenaStorageModule as bb, type AthenaStorageMultipartNamespace as bc, type AthenaStorageObjectFolderNamespace as bd, type AthenaStorageObjectNamespace as be, type AthenaStoragePathContext as bf, type AthenaStoragePermissionNamespace as bg, type AthenaStoragePrefixPath as bh, type AthenaStoragePutBody as bi, type AthenaStoragePutOptions as bj, type AthenaStorageTemplateValue as bk, type AthenaStorageTemplateVars as bl, type AthenaStorageUploadConstraints as bm, type AthenaStorageUploadProgress as bn, type AthenaStorageUploadProgressHandler as bo, type AthenaStorageUploadSource as bp, type AthenaStorageUploadedFile as bq, type AthenaTableBuilderStateAst as br, type AthenaUpdateDebugAst as bs, type AthenaUpsertDebugAst as bt, type BackupRecoveryStrategy as bu, type ConfirmStorageUploadRequest as bv, type CopyStorageFileRequest as bw, type CreateStorageCatalogRequest as bx, type CreateStorageUploadUrlRequest as by, type CreateStorageUploadUrlsRequest as bz, type AthenaChatAddReactionRequest as c, coerceInt as c$, type StorageBackupQueuedJob as c0, type StorageBackupRecord as c1, type StorageBackupRestoreRequest as c2, type StorageBackupSchedule as c3, type StorageBackupScheduleCreateRequest as c4, type StorageBatchUploadUrlResponse as c5, type StorageBatchUploadUrlResponseWithPut as c6, type StorageBucketCorsRequest as c7, type StorageBucketCorsRuleInput as c8, type StorageBucketLifecycleRequest as c9, type StorageObjectVersionListRequest as cA, type StorageObjectVersionMutationRequest as cB, type StoragePermissionCheckRequest as cC, type StoragePermissionCheckResponse as cD, type StoragePermissionGrantRequest as cE, type StoragePermissionListRequest as cF, type StoragePermissionListResponse as cG, type StoragePermissionRevokeRequest as cH, type StoragePresignUploadRequest as cI, type StoragePublicAccessBlockRequest as cJ, type StorageServerSideEncryptionOptions as cK, type StorageSetBucketCorsRequest as cL, type StorageSetBucketLifecycleRequest as cM, type StorageSetBucketPolicyRequest as cN, type StorageSetPublicAccessBlockRequest as cO, type StorageSignedPostPolicyRequest as cP, type StorageUpdateObjectRequest as cQ, type StorageUploadUrlResponse as cR, type StorageUploadUrlResponseWithPut as cS, type TableQueryBuilder as cT, type TreeStorageFoldersRequest as cU, type UnwrapOneOptions as cV, type UnwrapOptions as cW, type UpdateManyStorageFilesRequest as cX, type UpdateStorageCatalogRequest as cY, type UpdateStorageFileRequest as cZ, assertInt as c_, type StorageBucketLifecycleRuleInput as ca, type StorageBucketPolicyRequest as cb, type StorageConnectionSelector as cc, type StorageFileAccessPurpose as cd, type StorageFileMutationManyResponse as ce, type StorageFileMutationResponse as cf, type StorageFilePermissionRecord as cg, type StorageFileRetentionRequest as ch, type StorageFileVersionPathRequest as ci, type StorageFolderMutationResponse as cj, type StorageListFilesResponse as ck, type StorageListObjectsRequest as cl, type StorageMultipartAbortRequest as cm, type StorageMultipartCompletePartInput as cn, type StorageMultipartCompleteRequest as co, type StorageMultipartCreateRequest as cp, type StorageMultipartListPartsRequest as cq, type StorageMultipartSignPartRequest as cr, type StorageObjectBaseRequest as cs, type StorageObjectCopyRequest as ct, type StorageObjectFolderCreateRequest as cu, type StorageObjectFolderDeleteRequest as cv, type StorageObjectFolderRenameRequest as cw, type StorageObjectPublicUrlRequest as cx, type StorageObjectRequest as cy, type StorageObjectValidateRequest as cz, type AthenaChatAttachmentInput as d, createAthenaStorageError as d0, createClient as d1, createStorageModule as d2, getAthenaDebugAst as d3, isOk as d4, normalizeAthenaError as d5, parseBooleanFlag as d6, requireAffected as d7, requireSuccess as d8, storageSdkManifest as d9, unwrap as da, unwrapOne as db, unwrapRows as dc, verifyAthenaGatewayUrl as dd, withRetry as de, type AthenaFindManyOptions as df, type AthenaFindManyResult as dg, type AthenaOrderBy as dh, type AthenaQueryTraceCallsite as di, type AthenaQueryTraceEvent as dj, type AthenaQueryTraceOptions as dk, type AthenaRelationSelectNode as dl, type AthenaResultError as dm, type AthenaSelectShape as dn, type AthenaValidatedSelectShape as dp, type AthenaWhere as dq, type AthenaWhereBooleanOperand as dr, type AthenaWhereOperatorInput as ds, DEFAULT_MULTIPART_PART_SIZE_BYTES as dt, DEFAULT_MULTIPART_THRESHOLD_BYTES as du, createStorageFileModule as dv, resolveStoragePath as dw, 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 };