@xylex-group/athena 2.6.0 → 2.7.0

package/dist/react-email-CDEF0jij.d.ts

@@ -1,1230 +0,0 @@
-import { i as AthenaJsonValue, a as AthenaGatewayCallOptions, g as AthenaJsonObject, j as AthenaRpcCallOptions, b as AthenaGatewayConnectionOptions, c as AthenaGatewayConnectionResult, J as AthenaGatewayEndpointPath, K as AthenaGatewayMethod, L as AthenaConditionValue, N as AthenaConditionArrayValue, R as RegistryDef, D as DatabaseDef, F as SchemaDef, O as AnyModelDef, x as ModelDef, C as ModelRelationMetadata, E as RowOf, o as BackendConfig, p as BackendType, e as AthenaGatewayErrorDetails, A as AthenaConditionCastType, P as AthenaConditionOperator, y as ModelMetadata, H as TenantKeyMap, T as TenantContext, M as ModelAt, q as InsertOf, U as UpdateOf, S as SchemaIntrospectionProvider, r as IntrospectionColumn } from './types-DSX6AT5B.js';
-import { f as AthenaAuthClientConfig, d as AthenaAuthBindings, N as AthenaAuthSdkClient, F as AthenaAuthReactEmailProps, C as AthenaAuthReactEmailComponent, H as AthenaAuthReactEmailRenderInput, k as AthenaAuthEmailTemplateDefinition, i as AthenaAuthEmailTemplateBuilder, I as AthenaAuthReactEmailRenderOptions, G as AthenaAuthReactEmailRenderEvent, D as AthenaAuthReactEmailConfig } from './model-form-Dh6gWjL0.js';
-import { j as GeneratorSchemaSelection, b as GeneratorProviderConfig } from './types-DapchQY5.js';
-import { A as AthenaCookiesOptions, a as AthenaSessionPair, b as AthenaCookieOptions, c as AthenaAuthCookies, g as getCookieCache, d as getSessionCookie, e as AthenaCookieContextRuntime } from './index-CVcQCGyG.js';
-
-type AthenaErrorKind = 'unique_violation' | 'not_found' | 'validation' | 'auth' | 'rate_limit' | 'transient' | 'unknown';
-declare const AthenaErrorKind: {
-    readonly UniqueViolation: "unique_violation";
-    readonly NotFound: "not_found";
-    readonly Validation: "validation";
-    readonly Auth: "auth";
-    readonly RateLimit: "rate_limit";
-    readonly Transient: "transient";
-    readonly Unknown: "unknown";
-};
-type AthenaErrorCode = 'UNIQUE_VIOLATION' | 'NOT_FOUND' | 'VALIDATION_FAILED' | 'AUTH_UNAUTHORIZED' | 'AUTH_FORBIDDEN' | 'RATE_LIMITED' | 'NETWORK_UNAVAILABLE' | 'TRANSIENT_FAILURE' | 'HTTP_FAILURE' | 'UNKNOWN';
-declare const AthenaErrorCode: {
-    readonly UniqueViolation: "UNIQUE_VIOLATION";
-    readonly NotFound: "NOT_FOUND";
-    readonly ValidationFailed: "VALIDATION_FAILED";
-    readonly AuthUnauthorized: "AUTH_UNAUTHORIZED";
-    readonly AuthForbidden: "AUTH_FORBIDDEN";
-    readonly RateLimited: "RATE_LIMITED";
-    readonly NetworkUnavailable: "NETWORK_UNAVAILABLE";
-    readonly TransientFailure: "TRANSIENT_FAILURE";
-    readonly HttpFailure: "HTTP_FAILURE";
-    readonly Unknown: "UNKNOWN";
-};
-type AthenaErrorCategory = 'transport' | 'client' | 'server' | 'database' | 'unknown';
-declare const AthenaErrorCategory: {
-    readonly Transport: "transport";
-    readonly Client: "client";
-    readonly Server: "server";
-    readonly Database: "database";
-    readonly Unknown: "unknown";
-};
-interface AthenaOperationContext {
-    table?: string;
-    operation?: string;
-    identity?: string | Record<string, unknown>;
-}
-interface NormalizedAthenaError {
-    kind: AthenaErrorKind;
-    code: AthenaErrorCode;
-    category: AthenaErrorCategory;
-    retryable: boolean;
-    status?: number;
-    constraint?: string;
-    table?: string;
-    operation?: string;
-    message: string;
-    raw: unknown;
-}
-interface AthenaErrorInput {
-    code: AthenaErrorCode;
-    kind: AthenaErrorKind;
-    category: AthenaErrorCategory;
-    message: string;
-    status?: number;
-    retryable?: boolean;
-    requestId?: string;
-    context?: AthenaOperationContext;
-    raw?: unknown;
-}
-interface UnwrapOptions {
-    allowNull?: boolean;
-    context?: AthenaOperationContext;
-}
-interface UnwrapOneOptions extends UnwrapOptions {
-    requireExactlyOne?: boolean;
-}
-interface IntCoercionOptions {
-    strictBigInt?: boolean;
-    min?: number;
-    max?: number;
-}
-type RetryBackoffStrategy = 'linear' | 'exponential' | ((attempt: number, error: unknown) => number);
-interface RetryConfig {
-    retries: number;
-    baseDelayMs?: number;
-    maxDelayMs?: number;
-    backoff?: RetryBackoffStrategy;
-    jitter?: boolean | number;
-    shouldRetry?: (error: unknown, attempt: number) => boolean | Promise<boolean>;
-}
-interface RequireAffectedOptions {
-    min?: number;
-}
-/**
- * Parses a string-based boolean flag with a deterministic fallback.
- *
- * Accepts common truthy/falsey token variants used by env vars and CLI flags.
- */
-declare function parseBooleanFlag(rawValue: string | undefined, fallback: boolean): boolean;
-declare class AthenaError extends Error {
-    readonly code: AthenaErrorCode;
-    readonly kind: AthenaErrorKind;
-    readonly category: AthenaErrorCategory;
-    readonly status?: number;
-    readonly retryable: boolean;
-    readonly requestId?: string;
-    readonly context?: AthenaOperationContext;
-    readonly raw?: unknown;
-    constructor(input: AthenaErrorInput);
-}
-/**
- * Returns `true` when a result is successful (`2xx` status and no `error`).
- */
-declare function isOk<T>(result: AthenaResult<T>): boolean;
-/**
- * Normalizes any Athena failure shape into a stable, typed error envelope.
- *
- * Accepts `AthenaResult`, `AthenaGatewayError`, native `Error`, or unknown values.
- * Optional `context` can override inferred table/operation metadata for clearer diagnostics.
- */
-declare function normalizeAthenaError(resultOrError: unknown, context?: AthenaOperationContext): NormalizedAthenaError;
-/**
- * Unwraps a successful result into a row array.
- *
- * - Throws on failed results.
- * - Converts `null` data to an empty array.
- * - Wraps scalar data in a single-element array.
- */
-declare function unwrapRows<T>(result: AthenaResult<T[] | T | null>, options?: UnwrapOptions): T[];
-/**
- * Unwraps successful result data from `AthenaResult<T | null>`.
- *
- * By default, `null` data throws. Pass `{ allowNull: true }` to permit nullable payloads.
- */
-declare function unwrap<T>(result: AthenaResult<T | null>, options: UnwrapOptions & {
-    allowNull: true;
-}): T | null;
-declare function unwrap<T>(result: AthenaResult<T | null>, options?: UnwrapOptions): T;
-/**
- * Unwraps the first row from a successful result that may contain arrays/scalars/null.
- *
- * - Throws on failed results.
- * - Throws when no row exists unless `allowNull: true` is provided.
- * - Optionally enforces exact cardinality via `requireExactlyOne`.
- */
-declare function unwrapOne<T>(result: AthenaResult<T[] | T | null>, options: UnwrapOneOptions & {
-    allowNull: true;
-}): T | null;
-declare function unwrapOne<T>(result: AthenaResult<T[] | T | null>, options?: UnwrapOneOptions): T;
-/**
- * Asserts that an Athena result is successful.
- *
- * Returns the original result for fluent composition and throws `AthenaGatewayError` on failure.
- */
-declare function requireSuccess<T>(result: AthenaResult<T>, context?: AthenaOperationContext): AthenaResult<T>;
-/**
- * Enforces mutation postconditions based on `result.count`.
- *
- * - Validates success first.
- * - Requires a non-null count in the response.
- * - Validates `count >= min` (default: `1`).
- *
- * Useful for guaranteeing that critical writes actually affected rows.
- */
-declare function requireAffected<T>(result: AthenaResult<T>, options?: RequireAffectedOptions, context?: AthenaOperationContext): number;
-/**
- * Safely coerces `unknown` values into finite integers.
- *
- * Returns `null` when coercion fails or bounds/strict bigint checks are violated.
- */
-declare function coerceInt(value: unknown, options?: IntCoercionOptions): number | null;
-/**
- * Strict integer assertion wrapper around `coerceInt`.
- *
- * Throws a `TypeError` with the provided label when coercion fails.
- */
-declare function assertInt(value: unknown, label?: string, options?: IntCoercionOptions): number;
-/**
- * Retries an async operation with configurable backoff and retry policy.
- *
- * `retries` represents additional attempts after the first failure.
- * By default, transient and rate-limit errors are retried.
- */
-declare function withRetry<T>(config: RetryConfig, fn: () => Promise<T>): Promise<T>;
-
-type AthenaRowShape$2 = Record<string, AthenaJsonValue | undefined>;
-type AthenaUpsertOptions<Update> = AthenaGatewayCallOptions & {
-    updateBody?: Update;
-    onConflict?: string | string[];
-};
-interface AthenaDbModule {
-    from<Row = AthenaRowShape$2, Insert = Partial<Row>, Update = Partial<Insert>>(table: string, options?: AthenaFromOptions): TableQueryBuilder<Row, Insert, Update>;
-    select<Row = AthenaRowShape$2, SelectedRow = Row>(table: string, columns?: string | string[], options?: AthenaGatewayCallOptions): SelectChain<Row, SelectedRow>;
-    insert<Row = AthenaRowShape$2, Insert = Partial<Row>>(table: string, values: Insert, options?: AthenaGatewayCallOptions): MutationQuery<Row>;
-    insert<Row = AthenaRowShape$2, Insert = Partial<Row>>(table: string, values: Insert[], options?: AthenaGatewayCallOptions): MutationQuery<Row[]>;
-    upsert<Row = AthenaRowShape$2, Insert = Partial<Row>, Update = Partial<Insert>>(table: string, values: Insert, options?: AthenaUpsertOptions<Update>): MutationQuery<Row>;
-    upsert<Row = AthenaRowShape$2, Insert = Partial<Row>, Update = Partial<Insert>>(table: string, values: Insert[], options?: AthenaUpsertOptions<Update>): MutationQuery<Row[]>;
-    update<Row = AthenaRowShape$2, Insert = Partial<Row>, Update = Partial<Insert>>(table: string, values: Update, options?: AthenaGatewayCallOptions): UpdateChain<Row>;
-    delete<Row = AthenaRowShape$2>(table: string, options?: AthenaGatewayCallOptions & {
-        resourceId?: string;
-    }): MutationQuery<Row | null>;
-    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[]>>;
-}
-
-declare function verifyAthenaGatewayUrl(baseUrl: string, options?: AthenaGatewayConnectionOptions): Promise<AthenaGatewayConnectionResult>;
-
-declare const storageSdkManifest: {
-    readonly namespace: "storage";
-    readonly basePath: "/storage";
-    readonly envelopeKinds: {
-        readonly raw: "response body is the payload";
-        readonly athena: "response body is { status, message, data }";
-    };
-    readonly methods: readonly [{
-        readonly name: "listStorageCatalogs";
-        readonly method: "GET";
-        readonly path: "/storage/catalogs";
-        readonly responseEnvelope: "raw";
-        readonly responseType: "{ data: S3CatalogItem[] }";
-    }, {
-        readonly name: "createStorageCatalog";
-        readonly method: "POST";
-        readonly path: "/storage/catalogs";
-        readonly requestType: "CreateStorageCatalogRequest";
-        readonly responseEnvelope: "raw";
-        readonly responseType: "S3CatalogItem";
-    }, {
-        readonly name: "updateStorageCatalog";
-        readonly method: "PATCH";
-        readonly path: "/storage/catalogs/{id}";
-        readonly pathParams: readonly ["id"];
-        readonly requestType: "UpdateStorageCatalogRequest";
-        readonly responseEnvelope: "raw";
-        readonly responseType: "S3CatalogItem";
-    }, {
-        readonly name: "deleteStorageCatalog";
-        readonly method: "DELETE";
-        readonly path: "/storage/catalogs/{id}";
-        readonly pathParams: readonly ["id"];
-        readonly responseEnvelope: "raw";
-        readonly responseType: "{ id: string; deleted: boolean }";
-    }, {
-        readonly name: "listStorageCredentials";
-        readonly method: "GET";
-        readonly path: "/storage/credentials";
-        readonly responseEnvelope: "raw";
-        readonly responseType: "{ data: S3CredentialListItem[] }";
-    }, {
-        readonly name: "createStorageUploadUrl";
-        readonly method: "POST";
-        readonly path: "/storage/files/upload-url";
-        readonly requestType: "CreateStorageUploadUrlRequest";
-        readonly responseEnvelope: "athena";
-        readonly responseType: "StorageUploadUrlResponse";
-    }, {
-        readonly name: "createStorageUploadUrls";
-        readonly method: "POST";
-        readonly path: "/storage/files/upload-urls";
-        readonly requestType: "CreateStorageUploadUrlsRequest";
-        readonly responseEnvelope: "athena";
-        readonly responseType: "StorageBatchUploadUrlResponse";
-    }, {
-        readonly name: "listStorageFiles";
-        readonly method: "POST";
-        readonly path: "/storage/files/list";
-        readonly requestType: "ListStorageFilesRequest";
-        readonly responseEnvelope: "athena";
-        readonly responseType: "StorageListFilesResponse";
-    }, {
-        readonly name: "getStorageFile";
-        readonly method: "GET";
-        readonly path: "/storage/files/{file_id}";
-        readonly pathParams: readonly ["file_id"];
-        readonly responseEnvelope: "athena";
-        readonly responseType: "StorageFileMutationResponse";
-    }, {
-        readonly name: "getStorageFileUrl";
-        readonly method: "GET";
-        readonly path: "/storage/files/{file_id}/url";
-        readonly pathParams: readonly ["file_id"];
-        readonly queryParams: readonly ["purpose"];
-        readonly responseEnvelope: "athena";
-        readonly responseType: "PresignedFileUrlResponse";
-    }, {
-        readonly name: "getStorageFileProxy";
-        readonly method: "GET";
-        readonly path: "/storage/files/{file_id}/proxy";
-        readonly pathParams: readonly ["file_id"];
-        readonly queryParams: readonly ["purpose"];
-        readonly responseEnvelope: "raw";
-        readonly responseType: "Response";
-        readonly binary: true;
-    }, {
-        readonly name: "updateStorageFile";
-        readonly method: "PATCH";
-        readonly path: "/storage/files/{file_id}";
-        readonly pathParams: readonly ["file_id"];
-        readonly requestType: "UpdateStorageFileRequest";
-        readonly responseEnvelope: "athena";
-        readonly responseType: "StorageFileMutationResponse";
-    }, {
-        readonly name: "deleteStorageFile";
-        readonly method: "DELETE";
-        readonly path: "/storage/files/{file_id}";
-        readonly pathParams: readonly ["file_id"];
-        readonly responseEnvelope: "athena";
-        readonly responseType: "StorageFileMutationResponse";
-    }, {
-        readonly name: "setStorageFileVisibility";
-        readonly method: "PATCH";
-        readonly path: "/storage/files/{file_id}/visibility";
-        readonly pathParams: readonly ["file_id"];
-        readonly requestType: "SetStorageFileVisibilityRequest";
-        readonly responseEnvelope: "athena";
-        readonly responseType: "StorageFileMutationResponse";
-    }, {
-        readonly name: "deleteStorageFolder";
-        readonly method: "POST";
-        readonly path: "/storage/folders/delete";
-        readonly requestType: "DeleteStorageFolderRequest";
-        readonly responseEnvelope: "athena";
-        readonly responseType: "StorageFolderMutationResponse";
-    }, {
-        readonly name: "moveStorageFolder";
-        readonly method: "POST";
-        readonly path: "/storage/folders/move";
-        readonly requestType: "MoveStorageFolderRequest";
-        readonly responseEnvelope: "athena";
-        readonly responseType: "StorageFolderMutationResponse";
-    }];
-};
-interface S3CatalogItem {
-    id: string;
-    name: string;
-    description: string;
-    endpoint: string;
-    region: string;
-    bucket?: string | null;
-    provider: string;
-    is_active: boolean;
-    active_credential_id?: string | null;
-    active_access_key?: string | null;
-    created_at: string;
-    updated_at: string;
-}
-interface S3CredentialListItem {
-    id: string;
-    s3_id: string;
-    name: string;
-    description: string;
-    endpoint: string;
-    region: string;
-    bucket?: string | null;
-    provider: string;
-    access_key: string;
-    created_at: string;
-    updated_at: string;
-}
-interface ManagedFileRecord {
-    id: string;
-    name: string;
-    original_name?: string | null;
-    url?: string | null;
-    bucket: string;
-    s3_id?: string | null;
-    prefix_path?: string | null;
-    size_bytes?: number | null;
-    mime_type?: string | null;
-    resource_id?: string | null;
-    organization_id: string;
-    metadata: Record<string, unknown>;
-    created_at: string;
-    updated_at: string;
-    storage_key: string;
-    uploaded_by_user_id?: string | null;
-    extension?: string | null;
-    is_public: boolean;
-    status: string;
-    deleted_at?: string | null;
-}
-interface PresignedFileUrlResponse {
-    file_id: string;
-    bucket: string;
-    storage_key: string;
-    purpose: string;
-    url: string;
-    expires_at: string;
-    expires_at_epoch_seconds: number;
-    expires_in: number;
-    cache_hit: boolean;
-    cache_layer: string;
-}
-interface CreateStorageCatalogRequest {
-    name: string;
-    description?: string;
-    endpoint: string;
-    region: string;
-    bucket?: string;
-    provider?: string;
-    access_key_id: string;
-    secret_key: string;
-    session_token?: string;
-    metadata?: Record<string, unknown>;
-}
-interface UpdateStorageCatalogRequest {
-    name?: string;
-    description?: string;
-    endpoint?: string;
-    region?: string;
-    bucket?: string;
-    provider?: string;
-    access_key_id?: string;
-    secret_key?: string;
-    session_token?: string;
-    is_active?: boolean;
-    metadata?: Record<string, unknown>;
-}
-interface CreateStorageUploadUrlRequest {
-    s3_id: string;
-    bucket?: string;
-    storage_key: string;
-    name?: string;
-    original_name?: string;
-    resource_id?: string;
-    mime_type?: string;
-    content_type?: string;
-    size_bytes?: number;
-    file_id?: string;
-    public?: boolean;
-    metadata?: Record<string, unknown>;
-}
-interface CreateStorageUploadUrlsRequest {
-    files: CreateStorageUploadUrlRequest[];
-}
-interface StorageUploadUrlResponse {
-    file: ManagedFileRecord;
-    upload: PresignedFileUrlResponse;
-}
-interface StorageBatchUploadUrlResponse {
-    files: StorageUploadUrlResponse[];
-}
-interface ListStorageFilesRequest {
-    s3_id: string;
-    prefix: string;
-}
-interface StorageListFilesResponse {
-    files: ManagedFileRecord[];
-    count: number;
-}
-interface UpdateStorageFileRequest {
-    storage_key: string;
-    bucket?: string;
-}
-interface SetStorageFileVisibilityRequest {
-    public: boolean;
-}
-interface DeleteStorageFolderRequest {
-    s3_id: string;
-    prefix: string;
-}
-interface MoveStorageFolderRequest {
-    s3_id: string;
-    from_prefix: string;
-    to_prefix: string;
-}
-interface StorageFileMutationResponse {
-    file: ManagedFileRecord;
-}
-interface StorageFolderMutationResponse {
-    s3_id: string;
-    prefix: string;
-    processed_files: number;
-}
-interface AthenaEnvelope<T> {
-    status: string;
-    message: string;
-    data: T;
-}
-type StorageFileAccessPurpose = 'read' | 'download' | 'stream';
-interface GetStorageFileUrlQuery {
-    purpose?: StorageFileAccessPurpose | (string & {});
-}
-type AthenaStorageErrorHandler = (error: AthenaStorageError) => void | Promise<void>;
-interface AthenaStorageClientConfig {
-    onError?: AthenaStorageErrorHandler;
-}
-interface AthenaStorageCallOptions extends AthenaGatewayCallOptions {
-    signal?: AbortSignal;
-    onError?: AthenaStorageErrorHandler;
-}
-type AthenaStorageBinaryCallOptions = AthenaStorageCallOptions;
-type AthenaStorageErrorCode = 'INVALID_URL' | 'NETWORK_ERROR' | 'HTTP_ERROR' | 'INVALID_JSON' | 'INVALID_ATHENA_ENVELOPE' | 'UNKNOWN_ERROR';
-declare const AthenaStorageErrorCode: {
-    readonly InvalidUrl: "INVALID_URL";
-    readonly NetworkError: "NETWORK_ERROR";
-    readonly HttpError: "HTTP_ERROR";
-    readonly InvalidJson: "INVALID_JSON";
-    readonly InvalidAthenaEnvelope: "INVALID_ATHENA_ENVELOPE";
-    readonly UnknownError: "UNKNOWN_ERROR";
-};
-interface AthenaStorageErrorDetails {
-    code: AthenaStorageErrorCode;
-    athenaCode: AthenaErrorCode;
-    kind: AthenaErrorKind;
-    category: AthenaErrorCategory;
-    retryable: boolean;
-    message: string;
-    status: number;
-    endpoint: AthenaGatewayEndpointPath;
-    method: AthenaGatewayMethod;
-    requestId?: string;
-    hint?: string;
-    cause?: string;
-    raw: unknown;
-}
-interface AthenaStorageErrorInput {
-    code: AthenaStorageErrorCode;
-    message: string;
-    status: number;
-    endpoint: AthenaGatewayEndpointPath;
-    method: AthenaGatewayMethod;
-    raw?: unknown;
-    requestId?: string;
-    hint?: string;
-    cause?: unknown;
-}
-declare class AthenaStorageError extends Error {
-    readonly code: AthenaStorageErrorCode;
-    readonly athenaCode: AthenaErrorCode;
-    readonly kind: AthenaErrorKind;
-    readonly category: AthenaErrorCategory;
-    readonly retryable: boolean;
-    readonly status: number;
-    readonly endpoint: AthenaGatewayEndpointPath;
-    readonly method: AthenaGatewayMethod;
-    readonly requestId?: string;
-    readonly hint?: string;
-    readonly causeDetail?: string;
-    readonly raw: unknown;
-    readonly normalized: NormalizedAthenaError;
-    readonly __athenaNormalizedError: NormalizedAthenaError;
-    constructor(input: AthenaStorageErrorInput);
-    toDetails(): AthenaStorageErrorDetails;
-}
-interface AthenaStorageModule {
-    listStorageCatalogs(options?: AthenaStorageCallOptions): Promise<{
-        data: S3CatalogItem[];
-    }>;
-    createStorageCatalog(input: CreateStorageCatalogRequest, options?: AthenaStorageCallOptions): Promise<S3CatalogItem>;
-    updateStorageCatalog(id: string, input: UpdateStorageCatalogRequest, options?: AthenaStorageCallOptions): Promise<S3CatalogItem>;
-    deleteStorageCatalog(id: string, options?: AthenaStorageCallOptions): Promise<{
-        id: string;
-        deleted: boolean;
-    }>;
-    listStorageCredentials(options?: AthenaStorageCallOptions): Promise<{
-        data: S3CredentialListItem[];
-    }>;
-    createStorageUploadUrl(input: CreateStorageUploadUrlRequest, options?: AthenaStorageCallOptions): Promise<StorageUploadUrlResponse>;
-    createStorageUploadUrls(input: CreateStorageUploadUrlsRequest, options?: AthenaStorageCallOptions): Promise<StorageBatchUploadUrlResponse>;
-    listStorageFiles(input: ListStorageFilesRequest, options?: AthenaStorageCallOptions): Promise<StorageListFilesResponse>;
-    getStorageFile(fileId: string, options?: AthenaStorageCallOptions): Promise<StorageFileMutationResponse>;
-    getStorageFileUrl(fileId: string, query?: GetStorageFileUrlQuery, options?: AthenaStorageCallOptions): Promise<PresignedFileUrlResponse>;
-    getStorageFileProxy(fileId: string, query?: GetStorageFileUrlQuery, options?: AthenaStorageBinaryCallOptions): Promise<Response>;
-    updateStorageFile(fileId: string, input: UpdateStorageFileRequest, options?: AthenaStorageCallOptions): Promise<StorageFileMutationResponse>;
-    deleteStorageFile(fileId: string, options?: AthenaStorageCallOptions): Promise<StorageFileMutationResponse>;
-    setStorageFileVisibility(fileId: string, input: SetStorageFileVisibilityRequest, options?: AthenaStorageCallOptions): Promise<StorageFileMutationResponse>;
-    deleteStorageFolder(input: DeleteStorageFolderRequest, options?: AthenaStorageCallOptions): Promise<StorageFolderMutationResponse>;
-    moveStorageFolder(input: MoveStorageFolderRequest, options?: AthenaStorageCallOptions): Promise<StorageFolderMutationResponse>;
-}
-declare function createAthenaStorageError(input: AthenaStorageErrorInput): AthenaStorageError;
-
-type AthenaRowShape$1 = Record<string, AthenaJsonValue | undefined>;
-type FilterColumnKey$1<Row> = Extract<keyof NonNullable<Row>, string>;
-type ResolvedFilterColumnKey$1<Row> = [FilterColumnKey$1<Row>] extends [never] ? string : FilterColumnKey$1<Row>;
-type AthenaFilterOperator = 'eq' | 'neq' | 'gt' | 'gte' | 'lt' | 'lte' | 'like' | 'ilike' | 'is' | 'in' | 'contains' | 'containedBy';
-type AthenaWherePrimitive = AthenaConditionValue;
-type AthenaWhereOperatorInput = {
-    eq?: AthenaConditionValue;
-    neq?: AthenaConditionValue;
-    gt?: AthenaConditionValue;
-    gte?: AthenaConditionValue;
-    lt?: AthenaConditionValue;
-    lte?: AthenaConditionValue;
-    like?: AthenaConditionValue;
-    ilike?: AthenaConditionValue;
-    is?: AthenaConditionValue;
-    in?: AthenaConditionArrayValue;
-    contains?: AthenaConditionArrayValue;
-    containedBy?: AthenaConditionArrayValue;
-};
-type AthenaWhereColumnInput<Row = AthenaRowShape$1> = Partial<Record<ResolvedFilterColumnKey$1<Row>, AthenaWherePrimitive | AthenaWhereOperatorInput>>;
-type AthenaBooleanSafeOperator = Exclude<AthenaFilterOperator, 'in' | 'contains' | 'containedBy'>;
-type AthenaWhereBooleanSafeOperatorInput = Partial<Record<AthenaBooleanSafeOperator, AthenaConditionValue>>;
-type AthenaWhereBooleanNotOperatorInput = {
-    [K in AthenaBooleanSafeOperator]: {
-        [P in K]: AthenaConditionValue;
-    } & Partial<Record<Exclude<AthenaBooleanSafeOperator, K>, never>>;
-}[AthenaBooleanSafeOperator];
-type AthenaStrictBooleanOperand<Keys extends string, Value> = {
-    [K in Keys]: {
-        [P in K]: 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> & {
-    or?: string extends ResolvedFilterColumnKey$1<Row> ? Array<AthenaWhereColumnInput<Row>> : AthenaNonEmptyArray<AthenaWhereBooleanOperand<Row>>;
-    not?: AthenaWhereNotOperand<Row>;
-};
-interface AthenaRelationSelectNode<TSelect extends AthenaSelectShape = AthenaSelectShape> {
-    select: TSelect;
-    as?: string;
-    via?: string;
-    schema?: string;
-}
-type AthenaSelectShape = Record<string, true | AthenaRelationSelectNode<AthenaSelectShape>>;
-type AthenaAllowedRelationSelectNodeKey = 'select' | 'as' | 'via' | 'schema';
-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;
-} : never : never : never;
-type AthenaValidatedSelectShape<TSelect> = {
-    [K in keyof TSelect]: TSelect[K] extends true ? true : AthenaValidatedRelationSelectNode<TSelect[K]>;
-};
-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> = {
-    column: ResolvedFilterColumnKey$1<Row>;
-    ascending?: boolean;
-} | Partial<Record<ResolvedFilterColumnKey$1<Row>, AthenaOrderByDirectionInput>>;
-interface AthenaFindManyOptions<Row = AthenaRowShape$1, TSelect extends AthenaSelectShape = AthenaSelectShape> {
-    select: TSelect;
-    where?: AthenaWhere<Row>;
-    orderBy?: AthenaOrderBy<Row>;
-    limit?: number;
-}
-type AthenaModelContext<TRegistry extends GenericRegistryDef = GenericRegistryDef, TDatabase extends string = string, TSchema extends string = string, TModel extends AnyModelDef = AnyModelDef> = {
-    registry: TRegistry;
-    database: TDatabase;
-    schema: TSchema;
-    model: TModel;
-};
-type Simplify<T> = {
-    [K in keyof T]: T[K];
-} & {};
-type ContextRegistry<TContext> = TContext extends AthenaModelContext<infer TRegistry, string, string, AnyModelDef> ? TRegistry : never;
-type ContextDatabase<TContext> = TContext extends AthenaModelContext<GenericRegistryDef, infer TDatabase, string, AnyModelDef> ? TDatabase : never;
-type ContextModel<TContext> = TContext extends AthenaModelContext<GenericRegistryDef, string, string, infer TModel> ? TModel : never;
-type ModelMetaOf<TContext> = ContextModel<TContext> extends ModelDef<unknown, unknown, unknown, infer TMeta> ? TMeta : never;
-type ModelRelationsOf<TContext> = NonNullable<ModelMetaOf<TContext>['relations']>;
-type SelectedResultKey<TKey extends string, TValue> = TValue extends {
-    as: infer TAlias extends string;
-} ? TAlias : TKey;
-type ScalarSelectionResult<Row, TSelect extends AthenaSelectShape> = {
-    [TKey in Extract<keyof TSelect, string> as TSelect[TKey] extends true ? TKey : never]-?: TKey extends keyof NonNullable<Row> ? NonNullable<Row>[TKey] : unknown;
-};
-type RelationByKey<TContext, TKey extends string> = TKey extends keyof ModelRelationsOf<TContext> ? ModelRelationsOf<TContext>[TKey] : never;
-type RelationByVia<TContext, TVia extends string> = {
-    [TKey in keyof ModelRelationsOf<TContext>]: ModelRelationsOf<TContext>[TKey] extends infer TRelation ? TRelation extends ModelRelationMetadata ? TVia extends TRelation['sourceColumns'][number] ? TRelation : never : never : never;
-}[keyof ModelRelationsOf<TContext>];
-type ResolvedRelation<TContext, TKey extends string, TValue> = RelationByKey<TContext, TKey> extends never ? TValue extends {
-    via: infer TVia extends string;
-} ? RelationByVia<TContext, TVia> : never : RelationByKey<TContext, TKey>;
-type TargetDatabaseName<TContext, TRelation extends ModelRelationMetadata> = TRelation['targetDatabase'] extends string ? TRelation['targetDatabase'] : ContextDatabase<TContext>;
-type ResolveTargetModel<TContext, TRelation extends ModelRelationMetadata> = ContextRegistry<TContext> extends infer TRegistry ? TRegistry extends GenericRegistryDef ? TargetDatabaseName<TContext, TRelation> extends keyof TRegistry & string ? TRelation['targetSchema'] extends keyof TRegistry[TargetDatabaseName<TContext, TRelation>]['schemas'] & string ? TRelation['targetModel'] extends keyof TRegistry[TargetDatabaseName<TContext, TRelation>]['schemas'][TRelation['targetSchema']]['models'] & string ? TRegistry[TargetDatabaseName<TContext, TRelation>]['schemas'][TRelation['targetSchema']]['models'][TRelation['targetModel']] : never : never : never : never : never;
-type RelationResultValue<TRelation extends ModelRelationMetadata, TValue, TContext> = TValue extends AthenaRelationSelectNode<infer TChildSelect> ? ResolveTargetModel<TContext, TRelation> extends infer TTargetModel ? TTargetModel extends AnyModelDef ? TRelation['kind'] extends 'one-to-many' | 'many-to-many' ? Array<AthenaFindManyResult<RowOf<TTargetModel>, TChildSelect, AthenaModelContext<ContextRegistry<TContext>, TargetDatabaseName<TContext, TRelation>, TRelation['targetSchema'], TTargetModel>>> : AthenaFindManyResult<RowOf<TTargetModel>, TChildSelect, AthenaModelContext<ContextRegistry<TContext>, TargetDatabaseName<TContext, TRelation>, TRelation['targetSchema'], TTargetModel>> | null : unknown : unknown : never;
-type RelationSelectionResult<TContext, TSelect extends AthenaSelectShape> = {
-    [TKey in Extract<keyof TSelect, string> as TSelect[TKey] extends AthenaRelationSelectNode<AthenaSelectShape> ? SelectedResultKey<TKey, TSelect[TKey]> : never]-?: ResolvedRelation<TContext, TKey, TSelect[TKey]> extends infer TRelation ? TRelation extends ModelRelationMetadata ? RelationResultValue<TRelation, TSelect[TKey], TContext> : unknown : unknown;
-};
-type AthenaFindManyResult<Row, TSelect extends AthenaSelectShape, TContext = unknown> = Simplify<ScalarSelectionResult<Row, TSelect> & RelationSelectionResult<TContext, TSelect>>;
-
-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;
-}
-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;
-    /**
-     * Send the original `findMany(...)` AST body for clean object-select reads.
-     * This requires gateway support and falls back to legacy compiled transport
-     * when a chain carries filter/pagination state that the AST payload cannot
-     * represent losslessly yet.
-     */
-    findManyAst?: boolean;
-    /**
-     * Expose the experimental `client.storage.*` bindings for Athena storage APIs.
-     */
-    athenaStorageBackend?: boolean;
-    /**
-     * Optional storage SDK runtime hooks. Only used when `athenaStorageBackend` is enabled.
-     */
-    storage?: AthenaStorageClientConfig;
-}
-interface AthenaQueryTraceOptions {
-    /**
-     * Custom sink for trace events. Defaults to console.info.
-     */
-    logger?: (event: AthenaQueryTraceEvent) => void;
-}
-interface AthenaQueryTraceCallsite {
-    filePath: string;
-    fileName: string;
-    line: number;
-    column: number;
-    frame?: string;
-    functionName?: string;
-}
-interface AthenaQueryTraceEvent {
-    timestamp: string;
-    durationMs: number;
-    operation: 'select' | 'insert' | 'upsert' | 'update' | 'delete' | 'rpc' | 'query';
-    endpoint: '/gateway/fetch' | '/gateway/insert' | '/gateway/update' | '/gateway/delete' | '/gateway/rpc' | '/gateway/query' | `/rpc/${string}`;
-    table?: string;
-    functionName?: string;
-    sql: string;
-    payload: unknown;
-    options?: AthenaGatewayCallOptions | AthenaRpcCallOptions;
-    callsite: AthenaQueryTraceCallsite | null;
-    outcome?: {
-        status: number;
-        error: AthenaResultError | null;
-        errorDetails?: AthenaGatewayErrorDetails | null;
-        count?: number | null;
-        data: unknown;
-        raw: unknown;
-    };
-    thrownError?: unknown;
-}
-type MutationSingleResult<Result> = Result extends Array<infer Item> ? Item | null : Result | null;
-type AthenaRowShape = Record<string, AthenaJsonValue | undefined>;
-type FilterColumnKey<Row> = Extract<keyof NonNullable<Row>, string>;
-type ResolvedFilterColumnKey<Row> = [FilterColumnKey<Row>] extends [never] ? string : FilterColumnKey<Row>;
-interface MutationQuery<Result> extends PromiseLike<AthenaResult<Result>> {
-    select(columns?: string | string[], options?: AthenaGatewayCallOptions): Promise<AthenaResult<Result>>;
-    returning(columns?: string | string[], options?: AthenaGatewayCallOptions): Promise<AthenaResult<Result>>;
-    single(columns?: string | string[], options?: AthenaGatewayCallOptions): Promise<AthenaResult<MutationSingleResult<Result>>>;
-    maybeSingle(columns?: string | string[], 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>>;
-}
-interface OrderOptions {
-    ascending?: boolean;
-}
-/** Shared filter chain - supports eq, limit, etc. in any order relative to select/update */
-interface FilterChain<Self, Row> {
-    eq(column: ResolvedFilterColumnKey<Row>, value: AthenaConditionValue): Self;
-    eqCast(column: ResolvedFilterColumnKey<Row>, value: AthenaConditionValue, cast: AthenaConditionCastType): Self;
-    eqUuid(column: ResolvedFilterColumnKey<Row>, value: string): Self;
-    match(filters: Partial<Record<ResolvedFilterColumnKey<Row>, AthenaConditionValue>>): Self;
-    range(from: number, to: number): Self;
-    limit(count: number): Self;
-    offset(count: number): Self;
-    currentPage(value: number): Self;
-    pageSize(value: number): Self;
-    totalPages(value: number): Self;
-    order(column: ResolvedFilterColumnKey<Row>, options?: OrderOptions): Self;
-    gt(column: ResolvedFilterColumnKey<Row>, value: AthenaConditionValue): Self;
-    gte(column: ResolvedFilterColumnKey<Row>, value: AthenaConditionValue): Self;
-    lt(column: ResolvedFilterColumnKey<Row>, value: AthenaConditionValue): Self;
-    lte(column: ResolvedFilterColumnKey<Row>, value: AthenaConditionValue): Self;
-    neq(column: ResolvedFilterColumnKey<Row>, value: AthenaConditionValue): Self;
-    like(column: ResolvedFilterColumnKey<Row>, value: AthenaConditionValue): Self;
-    ilike(column: ResolvedFilterColumnKey<Row>, value: AthenaConditionValue): Self;
-    is(column: ResolvedFilterColumnKey<Row>, value: AthenaConditionValue): Self;
-    in(column: ResolvedFilterColumnKey<Row>, values: AthenaConditionArrayValue): Self;
-    contains(column: ResolvedFilterColumnKey<Row>, values: AthenaConditionArrayValue): Self;
-    containedBy(column: ResolvedFilterColumnKey<Row>, values: AthenaConditionArrayValue): Self;
-    not(columnOrExpression: ResolvedFilterColumnKey<Row> | string, operator?: AthenaConditionOperator, value?: AthenaConditionValue): Self;
-    or(expression: string): Self;
-}
-/** Chain returned by select() - supports filters and single/maybeSingle before execution */
-interface SelectChain<Row, SelectedRow = Row> extends FilterChain<SelectChain<Row, SelectedRow>, Row>, PromiseLike<AthenaResult<SelectedRow[]>> {
-    single<T = SelectedRow>(columns?: string | string[], options?: AthenaGatewayCallOptions): Promise<AthenaResult<T | null>>;
-    maybeSingle<T = SelectedRow>(columns?: string | string[], options?: AthenaGatewayCallOptions): Promise<AthenaResult<T | null>>;
-}
-/** Chain returned by update() - supports filters before execution, plus select/returning */
-interface UpdateChain<Row> extends FilterChain<UpdateChain<Row>, Row>, MutationQuery<Row[]> {
-}
-interface RpcFilterChain<Self> {
-    eq(column: string, value: AthenaConditionValue): Self;
-    neq(column: string, value: AthenaConditionValue): Self;
-    gt(column: string, value: AthenaConditionValue): Self;
-    gte(column: string, value: AthenaConditionValue): Self;
-    lt(column: string, value: AthenaConditionValue): Self;
-    lte(column: string, value: AthenaConditionValue): Self;
-    like(column: string, value: AthenaConditionValue): Self;
-    ilike(column: string, value: AthenaConditionValue): Self;
-    is(column: string, value: AthenaConditionValue): Self;
-    in(column: string, values: AthenaConditionArrayValue): Self;
-}
-interface RpcOrderOptions {
-    ascending?: boolean;
-}
-interface RpcQueryBuilder<Row> extends RpcFilterChain<RpcQueryBuilder<Row>>, PromiseLike<AthenaResult<Row[]>> {
-    select(columns?: string | string[], options?: AthenaRpcCallOptions): Promise<AthenaResult<Row[]>>;
-    single<T = Row>(columns?: string | string[], options?: AthenaRpcCallOptions): Promise<AthenaResult<T | null>>;
-    maybeSingle<T = Row>(columns?: string | string[], options?: AthenaRpcCallOptions): Promise<AthenaResult<T | null>>;
-    order(column: string, 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> extends FilterChain<TableQueryBuilder<Row, Insert, Update, TContext>, Row> {
-    select<T = Row>(columns?: string | string[], options?: AthenaGatewayCallOptions): SelectChain<Row, T>;
-    findMany<const TSelect extends AthenaSelectShape>(options: AthenaFindManyOptions<Row, TSelect> & {
-        select: AthenaValidatedSelectShape<TSelect>;
-    }): Promise<AthenaResult<Array<AthenaFindManyResult<Row, TSelect, TContext>>>>;
-    insert(values: Insert, options?: AthenaGatewayCallOptions): MutationQuery<Row>;
-    insert(values: Insert[], options?: AthenaGatewayCallOptions): MutationQuery<Row[]>;
-    upsert(values: Insert, options?: AthenaGatewayCallOptions & {
-        updateBody?: Update;
-        onConflict?: string | string[];
-    }): MutationQuery<Row>;
-    upsert(values: Insert[], options?: AthenaGatewayCallOptions & {
-        updateBody?: Update;
-        onConflict?: string | string[];
-    }): MutationQuery<Row[]>;
-    update(values: Update, options?: AthenaGatewayCallOptions): UpdateChain<Row>;
-    delete(options?: AthenaGatewayCallOptions & {
-        resourceId?: string;
-    }): MutationQuery<Row | null>;
-    single<T = Row>(columns?: string | string[], options?: AthenaGatewayCallOptions): Promise<AthenaResult<T | null>>;
-    maybeSingle<T = Row>(columns?: string | string[], options?: AthenaGatewayCallOptions): Promise<AthenaResult<T | null>>;
-    reset(): TableQueryBuilder<Row, Insert, Update, TContext>;
-}
-interface AthenaSdkClient {
-    from<Row = AthenaRowShape, Insert = Partial<Row>, Update = Partial<Insert>>(table: string, options?: AthenaFromOptions): TableQueryBuilder<Row, Insert, Update>;
-    db: AthenaDbModule;
-    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[]>>;
-    verifyConnection(options?: AthenaGatewayConnectionOptions): Promise<AthenaGatewayConnectionResult>;
-}
-interface AthenaSdkClientWithAuth extends AthenaSdkClient {
-    auth: AthenaAuthBindings;
-}
-interface AthenaSdkClientWithStorage extends AthenaSdkClientWithAuth {
-    storage: AthenaStorageModule;
-}
-interface AthenaCreateClientOptions extends Pick<AthenaGatewayCallOptions, 'client' | 'headers' | 'backend'> {
-    auth?: AthenaAuthClientConfig;
-    experimental?: AthenaClientExperimentalOptions;
-}
-interface AthenaCreateClientOptionsWithStorage extends AthenaCreateClientOptions {
-    experimental: AthenaClientExperimentalOptions & {
-        athenaStorageBackend: true;
-    };
-}
-interface AthenaClientBuilder<StorageEnabled extends boolean = false> {
-    /** Set the gateway base URL. */
-    url(url: string): AthenaClientBuilder<StorageEnabled>;
-    /** Set the API key used for all requests. */
-    key(apiKey: string): AthenaClientBuilder<StorageEnabled>;
-    /** Set the default backend routing strategy. */
-    backend(backend: BackendConfig | BackendType): AthenaClientBuilder<StorageEnabled>;
-    /** Set the default Athena client routing key. */
-    client(clientName: string): AthenaClientBuilder<StorageEnabled>;
-    /** Attach static headers to every request. */
-    headers(headers: Record<string, string>): AthenaClientBuilder<StorageEnabled>;
-    /** Configure Athena Auth client behavior for `client.auth.*` methods. */
-    auth(config: AthenaAuthClientConfig): AthenaClientBuilder<StorageEnabled>;
-    /** Configure experimental client options and narrow the built client when storage is enabled. */
-    experimental(options: AthenaClientExperimentalOptions & {
-        athenaStorageBackend: true;
-    }): AthenaClientBuilder<true>;
-    experimental(options: AthenaClientExperimentalOptions): AthenaClientBuilder<StorageEnabled>;
-    /** Apply createClient options and narrow the built client when storage is enabled. */
-    options(options: AthenaCreateClientOptionsWithStorage): AthenaClientBuilder<true>;
-    options(options: AthenaCreateClientOptions): AthenaClientBuilder<StorageEnabled>;
-    /** Build the immutable Athena SDK client. */
-    build(): StorageEnabled extends true ? AthenaSdkClientWithStorage : AthenaSdkClientWithAuth;
-}
-/** 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>;
-    /** Build a client from process environment variables. */
-    static fromEnvironment(): AthenaSdkClientWithAuth;
-}
-/** Create client (convenience wrapper; use AthenaClient.builder() for full control) */
-declare function createClient(url: string, apiKey: string, options: AthenaCreateClientOptionsWithStorage): AthenaSdkClientWithStorage;
-declare function createClient(url: string, apiKey: string, options?: AthenaCreateClientOptions): AthenaSdkClientWithAuth;
-
-interface NormalizeAthenaGatewayBaseUrlOptions {
-    defaultBaseUrl?: string;
-    label?: string;
-}
-declare function normalizeAthenaGatewayBaseUrl(input: string | null | undefined, options?: NormalizeAthenaGatewayBaseUrlOptions): string;
-
-/**
- * Immutable identifier object with consistent SQL rendering.
- */
-interface SqlIdentifier {
-    readonly segments: string[];
-    toSql(): string;
-    toString(): string;
-}
-/**
- * Creates a quoted identifier object from segment or dotted inputs.
- */
-declare function identifier(...segments: string[]): SqlIdentifier;
-
-/**
- * Declares a model contract with explicit metadata and typed row/insert/update shapes.
- */
-declare function defineModel<Row, Insert = Partial<Row>, Update = Partial<Insert>, Meta extends ModelMetadata<Row> = ModelMetadata<Row>>(input: {
-    meta: Meta;
-}): ModelDef<Row, Insert, Update, Meta>;
-/**
- * Declares a schema-level model map.
- */
-declare function defineSchema<Models extends Record<string, AnyModelDef>>(models: Models): SchemaDef<Models>;
-/**
- * Declares a database-level schema map.
- */
-declare function defineDatabase<Schemas extends Record<string, SchemaDef<Record<string, AnyModelDef>>>>(schemas: Schemas): DatabaseDef<Schemas>;
-/**
- * Declares a top-level multi-database registry.
- */
-declare function defineRegistry<Databases extends Record<string, DatabaseDef<Record<string, SchemaDef<Record<string, AnyModelDef>>>>>>(databases: Databases): RegistryDef<Databases>;
-
-type RegistryConstraint = RegistryDef<Record<string, DatabaseDef<Record<string, SchemaDef<Record<string, AnyModelDef>>>>>>;
-/**
- * Options for creating typed Athena clients.
- */
-interface TypedClientOptions<TMap extends TenantKeyMap = TenantKeyMap> extends Pick<AthenaGatewayCallOptions, 'backend' | 'client' | 'headers'> {
-    tenantKeyMap?: TMap;
-    tenantContext?: TenantContext<TMap>;
-}
-/**
- * Typed Athena client with registry-driven model resolution and tenant-context propagation.
- */
-interface TypedAthenaClient<TRegistry extends RegistryConstraint, TTenantMap extends TenantKeyMap = Record<never, string>> extends AthenaSdkClient {
-    readonly registry: TRegistry;
-    readonly tenantKeyMap: Readonly<TTenantMap>;
-    readonly tenantContext: TenantContext<TTenantMap>;
-    withTenantContext(context: TenantContext<TTenantMap>): TypedAthenaClient<TRegistry, TTenantMap>;
-    fromModel<TDatabase extends keyof TRegistry & string, TSchema extends keyof TRegistry[TDatabase]['schemas'] & string, TModel extends keyof TRegistry[TDatabase]['schemas'][TSchema]['models'] & string>(database: TDatabase, schema: TSchema, model: TModel): TableQueryBuilder<RowOf<ModelAt<TRegistry, TDatabase, TSchema, TModel>>, InsertOf<ModelAt<TRegistry, TDatabase, TSchema, TModel>>, UpdateOf<ModelAt<TRegistry, TDatabase, TSchema, TModel>>, {
-        registry: TRegistry;
-        database: TDatabase;
-        schema: TSchema;
-        model: ModelAt<TRegistry, TDatabase, TSchema, TModel>;
-    }>;
-}
-/**
- * Creates a typed client bound to a registry contract and optional tenant header mapping.
- */
-declare function createTypedClient<TRegistry extends RegistryConstraint, TTenantMap extends TenantKeyMap = Record<never, string>>(registry: TRegistry, url: string, apiKey: string, options?: TypedClientOptions<TTenantMap>): TypedAthenaClient<TRegistry, TTenantMap>;
-
-/**
- * Constructor options for the PostgreSQL introspection provider.
- */
-interface PostgresIntrospectionProviderOptions {
-    connectionString: string;
-    database?: string;
-    schemas?: readonly string[];
-}
-/**
- * Creates a PostgreSQL-backed schema introspection provider.
- */
-declare function createPostgresIntrospectionProvider(options: PostgresIntrospectionProviderOptions): SchemaIntrospectionProvider;
-
-interface GeneratorEnvBaseOptions<T> {
-    default?: T;
-    optional?: boolean;
-}
-type GeneratorEnvStringOptions = GeneratorEnvBaseOptions<string>;
-type GeneratorEnvBooleanOptions = GeneratorEnvBaseOptions<boolean>;
-interface GeneratorEnvListOptions extends GeneratorEnvBaseOptions<readonly string[]> {
-    separator?: string;
-}
-type GeneratorEnvJsonOptions<T> = GeneratorEnvBaseOptions<T>;
-type GeneratorEnvOneOfOptions<T extends string> = GeneratorEnvBaseOptions<T>;
-type GeneratorEnvHelper = {
-    (key: string, options?: GeneratorEnvStringOptions): string;
-    (key: string, options: GeneratorEnvStringOptions & {
-        optional: true;
-    }): string | undefined;
-    boolean(key: string, options?: GeneratorEnvBooleanOptions): boolean;
-    boolean(key: string, options: GeneratorEnvBooleanOptions & {
-        optional: true;
-    }): boolean | undefined;
-    list(key: string, options?: GeneratorEnvListOptions): string[];
-    list(key: string, options: GeneratorEnvListOptions & {
-        optional: true;
-    }): string[] | undefined;
-    json<T>(key: string, options?: GeneratorEnvJsonOptions<T>): T;
-    json<T>(key: string, options: GeneratorEnvJsonOptions<T> & {
-        optional: true;
-    }): T | undefined;
-    oneOf<const T extends string>(key: string, allowedValues: readonly T[], options?: GeneratorEnvOneOfOptions<T>): T;
-    oneOf<const T extends string>(key: string, allowedValues: readonly T[], options: GeneratorEnvOneOfOptions<T> & {
-        optional: true;
-    }): T | undefined;
-};
-/**
- * Typed env reader for generator configs. This keeps `athena.config.*` files
- * declarative while preserving exact field types for booleans, lists, unions,
- * and JSON-backed objects.
- */
-declare const generatorEnv: GeneratorEnvHelper;
-
-declare function resolvePostgresColumnType(column: IntrospectionColumn): string;
-
-declare const DEFAULT_POSTGRES_SCHEMAS: readonly ["public"];
-/**
- * Normalizes schema selection from config or env-backed strings into a stable,
- * deduplicated list. Empty selections fall back to PostgreSQL's public schema.
- */
-declare function normalizeSchemaSelection(input: GeneratorSchemaSelection | undefined): string[];
-/**
- * Resolves the effective schema list for provider-backed generator runs.
- */
-declare function resolveProviderSchemas(providerConfig: GeneratorProviderConfig): string[];
-
-/**
- * @deprecated Prefer `createClient(...).auth` from `@xylex-group/athena`.
- */
-declare function createAuthClient(config?: AthenaAuthClientConfig): AthenaAuthSdkClient;
-
-type AthenaMaybePromise<T> = T | Promise<T>;
-type AthenaAuthServerCookieOptions = Pick<AthenaCookiesOptions, 'session' | 'advanced'>;
-declare const ATHENA_AUTH_BASE_ERROR_CODES: {
-    readonly HANDLER_NOT_CONFIGURED: "HANDLER_NOT_CONFIGURED";
-    readonly INVALID_BASE_URL: "INVALID_BASE_URL";
-    readonly UNTRUSTED_HOST: "UNTRUSTED_HOST";
-};
-interface AthenaAuthSocialProviderConfig {
-    clientId: string;
-    clientSecret: string;
-    scope?: string[];
-    [key: string]: unknown;
-}
-interface AthenaAuthPluginContext {
-    path?: string;
-    headers?: Headers;
-    context: {
-        returned?: unknown;
-        responseHeaders?: Headers;
-        setSession?: AthenaSessionPair | null;
-        clearSession?: boolean;
-        dontRememberMe?: boolean;
-        cookieOverrides?: Partial<AthenaCookieOptions>;
-        [key: string]: unknown;
-    };
-}
-interface AthenaAuthPluginHandlerContext extends AthenaAuthPluginContext {
-    auth: AthenaAuthServer;
-}
-interface AthenaAuthPlugin {
-    id: string;
-    version: string;
-    $ERROR_CODES?: Record<string, string>;
-    hooks?: {
-        after?: Array<{
-            matcher: (ctx: AthenaAuthPluginContext) => boolean;
-            handler: (ctx: AthenaAuthPluginHandlerContext) => Promise<void> | void;
-        }>;
-    };
-}
-interface AthenaAuthCookieRuntimeInput {
-    headers?: Headers;
-    responseHeaders?: Headers;
-    cookies?: AthenaAuthCookies;
-    getCookie?: (name: string) => string | null | undefined;
-    setCookie?: (name: string, value: string, attributes: AthenaCookieOptions) => void;
-    logger?: AthenaCookieContextRuntime['logger'];
-    setSignedCookie?: AthenaCookieContextRuntime['setSignedCookie'];
-    getSignedCookie?: AthenaCookieContextRuntime['getSignedCookie'];
-    setNewSession?: AthenaCookieContextRuntime['context']['setNewSession'];
-}
-interface AthenaAuthServerRuntimeOptions {
-    baseURL?: string;
-    basePath: string;
-    secret: string;
-    cookies: AthenaAuthServerCookieOptions;
-}
-type AthenaAuthDatabaseFactory<TDatabase = unknown> = (options: AthenaAuthServerRuntimeOptions) => TDatabase;
-type AthenaAuthBaseURLConfig = AthenaCookiesOptions['baseURL'];
-type AthenaAuthTrustedOrigins = string[] | ((request?: Request) => AthenaMaybePromise<string[]>);
-type AthenaAuthTrustedProviders = string[] | ((request?: Request) => AthenaMaybePromise<string[]>);
-interface AthenaAuthHandlerResult {
-    response?: Response;
-    returned?: unknown;
-    setSession?: AthenaSessionPair | null;
-    clearSession?: boolean;
-    dontRememberMe?: boolean;
-    cookieOverrides?: Partial<AthenaCookieOptions>;
-}
-interface AthenaAuthServerConfig<TDatabase = unknown> extends AthenaAuthServerCookieOptions {
-    baseURL?: AthenaAuthBaseURLConfig;
-    basePath?: string;
-    secret: string;
-    database: TDatabase | AthenaAuthDatabaseFactory<TDatabase>;
-    socialProviders?: Record<string, AthenaAuthSocialProviderConfig>;
-    trustedOrigins?: AthenaAuthTrustedOrigins;
-    trustedProviders?: AthenaAuthTrustedProviders;
-    api?: Record<string, unknown>;
-    errorCodes?: Record<string, string>;
-    handler?: (ctx: AthenaAuthRequestContext) => AthenaMaybePromise<Response | AthenaAuthHandlerResult>;
-    plugins?: AthenaAuthPlugin[];
-}
-type ResolveAthenaAuthDatabase<TConfig extends AthenaAuthServerConfig> = TConfig['database'] extends (...args: never[]) => infer TResult ? TResult : TConfig['database'];
-interface AthenaAuthRequestContext<TConfig extends AthenaAuthServerConfig = AthenaAuthServerConfig> {
-    auth: AthenaAuthServer<TConfig>;
-    request: Request;
-    url: URL;
-    path: string;
-    basePath: string;
-    baseURL: string;
-    origin: string;
-    headers: Headers;
-    cookies: AthenaAuthCookies;
-    trustedOrigins: string[];
-    trustedProviders: string[];
-    options: TConfig;
-    runtime: AthenaAuthServerRuntimeOptions;
-    database: ResolveAthenaAuthDatabase<TConfig>;
-    socialProviders: NonNullable<TConfig['socialProviders']>;
-}
-interface AthenaAuthContext<TConfig extends AthenaAuthServerConfig = AthenaAuthServerConfig> {
-    auth: AthenaAuthServer<TConfig>;
-    options: TConfig;
-    runtime: AthenaAuthServerRuntimeOptions;
-    basePath: string;
-    baseURL?: string;
-    origin?: string;
-    database: ResolveAthenaAuthDatabase<TConfig>;
-    socialProviders: NonNullable<TConfig['socialProviders']>;
-    plugins: AthenaAuthPlugin[];
-    cookies: AthenaAuthCookies;
-    trustedOrigins: string[];
-    trustedProviders: string[];
-}
-interface AthenaAuthServerApi<TConfig extends AthenaAuthServerConfig = AthenaAuthServerConfig> {
-    applyResponseCookies: AthenaAuthServer<TConfig>['applyResponseCookies'];
-    clearSession: AthenaAuthServer<TConfig>['clearSession'];
-    createCookieContext: AthenaAuthServer<TConfig>['createCookieContext'];
-    getCookieCache: typeof getCookieCache;
-    getSessionCookie: typeof getSessionCookie;
-    resolveRequestContext: AthenaAuthServer<TConfig>['resolveRequestContext'];
-    runAfterHooks: AthenaAuthServer<TConfig>['runAfterHooks'];
-    setSession: AthenaAuthServer<TConfig>['setSession'];
-}
-interface AthenaAuthServer<TConfig extends AthenaAuthServerConfig = AthenaAuthServerConfig> {
-    config: TConfig;
-    options: TConfig;
-    runtime: AthenaAuthServerRuntimeOptions;
-    database: ResolveAthenaAuthDatabase<TConfig>;
-    socialProviders: NonNullable<TConfig['socialProviders']>;
-    plugins: AthenaAuthPlugin[];
-    cookies: AthenaAuthCookies;
-    api: AthenaAuthServerApi<TConfig> & Record<string, unknown>;
-    $context: Promise<AthenaAuthContext<TConfig>>;
-    $ERROR_CODES: Record<string, string>;
-    createCookieContext: (input?: AthenaAuthCookieRuntimeInput) => AthenaCookieContextRuntime;
-    setSession: (input: AthenaAuthCookieRuntimeInput | undefined, session: AthenaSessionPair, dontRememberMe?: boolean, overrides?: Partial<AthenaCookieOptions>) => Promise<void>;
-    clearSession: (input?: AthenaAuthCookieRuntimeInput, skipDontRememberMe?: boolean) => void;
-    applyResponseCookies: (ctx: AthenaAuthPluginContext) => Promise<Headers>;
-    runAfterHooks: (ctx: AthenaAuthPluginContext) => Promise<AthenaAuthPluginContext>;
-    resolveRequestContext: (request: Request) => Promise<AthenaAuthRequestContext<TConfig>>;
-    handler: (request: Request) => Promise<Response>;
-}
-declare function defineAthenaAuthConfig<TConfig extends AthenaAuthServerConfig>(config: TConfig): TConfig;
-declare function athenaAuth<TConfig extends AthenaAuthServerConfig>(config: TConfig): AthenaAuthServer<TConfig>;
-
-interface AthenaAuthRenderedReactEmail {
-    html: string;
-    text?: string;
-}
-interface AthenaAuthReactEmailRuntimeOptions {
-    route?: string;
-    defaults?: AthenaAuthReactEmailRenderOptions;
-    observe?: (event: AthenaAuthReactEmailRenderEvent) => void;
-}
-declare function createAuthReactEmailInput<TProps extends AthenaAuthReactEmailProps = AthenaAuthReactEmailProps>(component: AthenaAuthReactEmailComponent<TProps>, props: TProps, overrides?: Omit<AthenaAuthReactEmailRenderInput, 'component' | 'props' | 'element'>): AthenaAuthReactEmailRenderInput;
-declare function defineAuthEmailTemplate<TProps extends AthenaAuthReactEmailProps = AthenaAuthReactEmailProps>(definition: AthenaAuthEmailTemplateDefinition<TProps>): AthenaAuthEmailTemplateBuilder<TProps>;
-declare function renderAthenaReactEmail(input: AthenaAuthReactEmailRenderInput, options?: AthenaAuthReactEmailRuntimeOptions | AthenaAuthReactEmailConfig): Promise<AthenaAuthRenderedReactEmail>;
-
-export { type AthenaWhere as $, ATHENA_AUTH_BASE_ERROR_CODES as A, type AthenaErrorInput as B, AthenaErrorKind as C, type AthenaFindManyOptions as D, type AthenaFindManyResult as E, type AthenaFromOptions as F, type AthenaOperationContext as G, type AthenaOrderBy as H, type AthenaQueryTraceCallsite as I, type AthenaQueryTraceEvent as J, type AthenaQueryTraceOptions as K, type AthenaRelationSelectNode as L, type AthenaResult as M, type AthenaResultError as N, type AthenaSdkClient as O, type AthenaSdkClientWithAuth as P, type AthenaSdkClientWithStorage as Q, type AthenaSelectShape as R, type AthenaStorageBinaryCallOptions as S, type AthenaStorageCallOptions as T, type AthenaStorageClientConfig as U, AthenaStorageError as V, AthenaStorageErrorCode as W, type AthenaStorageErrorDetails as X, type AthenaStorageErrorHandler as Y, type AthenaStorageErrorInput as Z, type AthenaStorageModule as _, type AthenaAuthBaseURLConfig as a, renderAthenaReactEmail as a$, type AthenaWhereBooleanOperand as a0, type AthenaWhereOperatorInput as a1, type CreateStorageCatalogRequest as a2, type CreateStorageUploadUrlRequest as a3, type CreateStorageUploadUrlsRequest as a4, DEFAULT_POSTGRES_SCHEMAS as a5, type DeleteStorageFolderRequest as a6, type GeneratorEnvBooleanOptions as a7, type GeneratorEnvJsonOptions as a8, type GeneratorEnvListOptions as a9, type TypedClientOptions as aA, type UnwrapOneOptions as aB, type UnwrapOptions as aC, type UpdateStorageCatalogRequest as aD, type UpdateStorageFileRequest as aE, assertInt as aF, athenaAuth as aG, coerceInt as aH, createAthenaStorageError as aI, createAuthClient as aJ, createAuthReactEmailInput as aK, createClient as aL, createPostgresIntrospectionProvider as aM, createTypedClient as aN, defineAthenaAuthConfig as aO, defineAuthEmailTemplate as aP, defineDatabase as aQ, defineModel as aR, defineRegistry as aS, defineSchema as aT, generatorEnv as aU, identifier as aV, isOk as aW, normalizeAthenaError as aX, normalizeAthenaGatewayBaseUrl as aY, normalizeSchemaSelection as aZ, parseBooleanFlag as a_, type GeneratorEnvOneOfOptions as aa, type GeneratorEnvStringOptions as ab, type GetStorageFileUrlQuery as ac, type IntCoercionOptions as ad, type ListStorageFilesRequest as ae, type ManagedFileRecord as af, type MoveStorageFolderRequest as ag, type NormalizedAthenaError as ah, type PostgresIntrospectionProviderOptions as ai, type PresignedFileUrlResponse as aj, type RequireAffectedOptions as ak, type RetryBackoffStrategy as al, type RetryConfig as am, type RpcOrderOptions as an, type RpcQueryBuilder as ao, type S3CatalogItem as ap, type S3CredentialListItem as aq, type SetStorageFileVisibilityRequest as ar, type StorageBatchUploadUrlResponse as as, type StorageFileAccessPurpose as at, type StorageFileMutationResponse as au, type StorageFolderMutationResponse as av, type StorageListFilesResponse as aw, type StorageUploadUrlResponse as ax, type TableQueryBuilder as ay, type TypedAthenaClient as az, type AthenaAuthContext as b, requireAffected as b0, requireSuccess as b1, resolvePostgresColumnType as b2, resolveProviderSchemas as b3, storageSdkManifest as b4, unwrap as b5, unwrapOne as b6, unwrapRows as b7, verifyAthenaGatewayUrl as b8, withRetry as b9, type AthenaAuthCookieRuntimeInput as c, type AthenaAuthDatabaseFactory as d, type AthenaAuthHandlerResult as e, type AthenaAuthPlugin as f, type AthenaAuthPluginContext as g, type AthenaAuthPluginHandlerContext as h, type AthenaAuthRequestContext as i, type AthenaAuthServer as j, type AthenaAuthServerApi as k, type AthenaAuthServerConfig as l, type AthenaAuthServerRuntimeOptions as m, type AthenaAuthSocialProviderConfig as n, type AthenaAuthTrustedOrigins as o, type AthenaAuthTrustedProviders as p, AthenaClient as q, type AthenaClientBuilder as r, type AthenaClientExperimentalOptions as s, type AthenaCreateClientOptions as t, type AthenaCreateClientOptionsWithStorage as u, type AthenaDbModule as v, type AthenaEnvelope as w, AthenaError as x, AthenaErrorCategory as y, AthenaErrorCode as z };