@xylex-group/athena 2.1.2 → 2.3.0

package/dist/{client-BX0NQqOn.d.ts → react-email-qPA1wjFV.d.ts}

@@ -1,175 +1,6 @@
-import { g as AthenaJsonValue, a as AthenaGatewayCallOptions, e as AthenaJsonObject, h as AthenaRpcCallOptions, m as BackendConfig, n as BackendType, G as AthenaConditionValue, A as AthenaConditionCastType, H as AthenaConditionArrayValue, J as AthenaConditionOperator, c as AthenaGatewayErrorDetails, C as SchemaDef, K as AnyModelDef, D as DatabaseDef, w as ModelMetadata, v as ModelDef, R as RegistryDef, F as TenantKeyMap, T as TenantContext, z as RowOf, M as ModelAt, o as InsertOf, U as UpdateOf, S as SchemaIntrospectionProvider, p as IntrospectionColumn } from './types-BaBzjwXr.js';
-import { a as AthenaAuthBindings, c as AthenaAuthClientConfig, w as AthenaAuthSdkClient } from './model-form-2hqmoOUX.js';
-import { j as GeneratorSchemaSelection, b as GeneratorProviderConfig } from './types-CeBPrnGj.js';
-
-type AthenaRowShape$1 = Record<string, AthenaJsonValue | undefined>;
-type AthenaUpsertOptions<Update> = AthenaGatewayCallOptions & {
-    updateBody?: Update;
-    onConflict?: string | string[];
-};
-interface AthenaDbModule {
-    from<Row = AthenaRowShape$1, Insert = Partial<Row>, Update = Partial<Insert>>(table: string): TableQueryBuilder<Row, Insert, Update>;
-    select<Row = AthenaRowShape$1, SelectedRow = Row>(table: string, columns?: string | string[], options?: AthenaGatewayCallOptions): SelectChain<Row, SelectedRow>;
-    insert<Row = AthenaRowShape$1, Insert = Partial<Row>>(table: string, values: Insert, options?: AthenaGatewayCallOptions): MutationQuery<Row>;
-    insert<Row = AthenaRowShape$1, Insert = Partial<Row>>(table: string, values: Insert[], options?: AthenaGatewayCallOptions): MutationQuery<Row[]>;
-    upsert<Row = AthenaRowShape$1, Insert = Partial<Row>, Update = Partial<Insert>>(table: string, values: Insert, options?: AthenaUpsertOptions<Update>): MutationQuery<Row>;
-    upsert<Row = AthenaRowShape$1, Insert = Partial<Row>, Update = Partial<Insert>>(table: string, values: Insert[], options?: AthenaUpsertOptions<Update>): MutationQuery<Row[]>;
-    update<Row = AthenaRowShape$1, Insert = Partial<Row>, Update = Partial<Insert>>(table: string, values: Update, options?: AthenaGatewayCallOptions): UpdateChain<Row>;
-    delete<Row = AthenaRowShape$1>(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[]>>;
-}
-
-interface AthenaResult<T> {
-    data: T | null;
-    error: string | null;
-    errorDetails?: AthenaGatewayErrorDetails | null;
-    status: number;
-    count?: number | null;
-    raw: unknown;
-}
-interface AthenaClientExperimentalOptions {
-    /**
-     * Pre-compute and attach normalized error metadata to failed AthenaResult values.
-     * Keeps AthenaResult shape intact and enables context-aware normalizeAthenaError(result) usage.
-     */
-    enableErrorNormalization?: boolean;
-}
-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 TableQueryBuilder<Row, Insert = Partial<Row>, Update = Partial<Insert>> extends FilterChain<TableQueryBuilder<Row, Insert, Update>, Row> {
-    select<T = Row>(columns?: string | string[], options?: AthenaGatewayCallOptions): SelectChain<Row, T>;
-    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>;
-}
-interface AthenaSdkClient {
-    from<Row = AthenaRowShape, Insert = Partial<Row>, Update = Partial<Insert>>(table: string): 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[]>>;
-}
-interface AthenaSdkClientWithAuth extends AthenaSdkClient {
-    auth: AthenaAuthBindings;
-}
-interface AthenaClientBuilder {
-    /** Set the gateway base URL. */
-    url(url: string): AthenaClientBuilder;
-    /** Set the API key used for all requests. */
-    key(apiKey: string): AthenaClientBuilder;
-    /** Set the default backend routing strategy. */
-    backend(backend: BackendConfig | BackendType): AthenaClientBuilder;
-    /** Set the default Athena client routing key. */
-    client(clientName: string): AthenaClientBuilder;
-    /** Attach static headers to every request. */
-    headers(headers: Record<string, string>): AthenaClientBuilder;
-    /** Enable or disable health tracking metadata. */
-    healthTracking(enabled: boolean): AthenaClientBuilder;
-    /** Build the immutable Athena SDK client. */
-    build(): 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;
-    /** Build a client from process environment variables. */
-    static fromEnvironment(): AthenaSdkClientWithAuth;
-}
-interface AthenaCreateClientOptions extends Pick<AthenaGatewayCallOptions, 'client' | 'headers' | 'backend'> {
-    auth?: AthenaAuthClientConfig;
-    experimental?: AthenaClientExperimentalOptions;
-}
-/** Create client (convenience wrapper; use AthenaClient.builder() for full control) */
-declare function createClient(url: string, apiKey: string, options?: AthenaCreateClientOptions): AthenaSdkClientWithAuth;
+import { g as AthenaJsonValue, a as AthenaGatewayCallOptions, e as AthenaJsonObject, h as AthenaRpcCallOptions, G as AthenaConditionValue, H as AthenaConditionArrayValue, R as RegistryDef, D as DatabaseDef, C as SchemaDef, J as AnyModelDef, v as ModelDef, y as ModelRelationMetadata, z as RowOf, m as BackendConfig, n as BackendType, c as AthenaGatewayErrorDetails, A as AthenaConditionCastType, K as AthenaConditionOperator, w as ModelMetadata, F as TenantKeyMap, T as TenantContext, M as ModelAt, o as InsertOf, U as UpdateOf, S as SchemaIntrospectionProvider, p as IntrospectionColumn } from './types-A5e97acl.js';
+import { c as AthenaAuthClientConfig, a as AthenaAuthBindings, J as AthenaAuthSdkClient, B as AthenaAuthReactEmailProps, x as AthenaAuthReactEmailComponent, D as AthenaAuthReactEmailRenderInput, h as AthenaAuthEmailTemplateDefinition, f as AthenaAuthEmailTemplateBuilder, E as AthenaAuthReactEmailRenderOptions, C as AthenaAuthReactEmailRenderEvent, y as AthenaAuthReactEmailConfig } from './model-form-BpDXlbxb.js';
+import { j as GeneratorSchemaSelection, b as GeneratorProviderConfig } from './types-BnD22-vb.js';
 
 type AthenaErrorKind = 'unique_violation' | 'not_found' | 'validation' | 'auth' | 'rate_limit' | 'transient' | 'unknown';
 declare const AthenaErrorKind: {
@@ -346,6 +177,332 @@ declare function assertInt(value: unknown, label?: string, options?: IntCoercion
  */
 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): 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[]>>;
+}
+
+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 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 AthenaWhereBooleanOperand<Row = AthenaRowShape$1> = Partial<Record<ResolvedFilterColumnKey$1<Row>, AthenaWherePrimitive | AthenaWhereOperatorInput>>;
+type AthenaWhere<Row = AthenaRowShape$1> = AthenaWhereBooleanOperand<Row> & {
+    or?: Array<AthenaWhereBooleanOperand<Row>>;
+    not?: AthenaWhereBooleanOperand<Row>;
+};
+interface AthenaRelationSelectNode<TSelect extends AthenaSelectShape = AthenaSelectShape> {
+    select: TSelect;
+    as?: string;
+    via?: string;
+}
+type AthenaSelectShape = Record<string, true | AthenaRelationSelectNode<AthenaSelectShape>>;
+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;
+    /**
+     * 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;
+}
+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 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>): 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): 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[]>>;
+}
+interface AthenaSdkClientWithAuth extends AthenaSdkClient {
+    auth: AthenaAuthBindings;
+}
+interface AthenaClientBuilder {
+    /** Set the gateway base URL. */
+    url(url: string): AthenaClientBuilder;
+    /** Set the API key used for all requests. */
+    key(apiKey: string): AthenaClientBuilder;
+    /** Set the default backend routing strategy. */
+    backend(backend: BackendConfig | BackendType): AthenaClientBuilder;
+    /** Set the default Athena client routing key. */
+    client(clientName: string): AthenaClientBuilder;
+    /** Attach static headers to every request. */
+    headers(headers: Record<string, string>): AthenaClientBuilder;
+    /** Configure Athena Auth client behavior for `client.auth.*` methods. */
+    auth(config: AthenaAuthClientConfig): AthenaClientBuilder;
+    /** Configure experimental client options (for example query tracing or findMany AST transport). */
+    experimental(options: AthenaClientExperimentalOptions): AthenaClientBuilder;
+    /** Apply the same options object accepted by `createClient(url, key, options)`. */
+    options(options: AthenaCreateClientOptions): AthenaClientBuilder;
+    /** Enable or disable health tracking metadata. */
+    healthTracking(enabled: boolean): AthenaClientBuilder;
+    /** Build the immutable Athena SDK client. */
+    build(): 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;
+    /** Build a client from process environment variables. */
+    static fromEnvironment(): AthenaSdkClientWithAuth;
+}
+interface AthenaCreateClientOptions extends Pick<AthenaGatewayCallOptions, 'client' | 'headers' | 'backend'> {
+    auth?: AthenaAuthClientConfig;
+    experimental?: AthenaClientExperimentalOptions;
+}
+/** Create client (convenience wrapper; use AthenaClient.builder() for full control) */
+declare function createClient(url: string, apiKey: string, options?: AthenaCreateClientOptions): AthenaSdkClientWithAuth;
+
 /**
  * Immutable identifier object with consistent SQL rendering.
  */
@@ -394,7 +551,12 @@ interface TypedAthenaClient<TRegistry extends RegistryConstraint, TTenantMap ext
     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>>>;
+    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.
@@ -432,4 +594,17 @@ declare function resolveProviderSchemas(providerConfig: GeneratorProviderConfig)
  */
 declare function createAuthClient(config?: AthenaAuthClientConfig): AthenaAuthSdkClient;
 
-export { AthenaClient as A, defineModel as B, defineRegistry as C, DEFAULT_POSTGRES_SCHEMAS as D, defineSchema as E, identifier as F, isOk as G, normalizeAthenaError as H, type IntCoercionOptions as I, normalizeSchemaSelection as J, parseBooleanFlag as K, requireAffected as L, requireSuccess as M, type NormalizedAthenaError as N, resolvePostgresColumnType as O, type PostgresIntrospectionProviderOptions as P, resolveProviderSchemas as Q, type RequireAffectedOptions as R, unwrap as S, type TableQueryBuilder as T, type UnwrapOneOptions as U, unwrapOne as V, unwrapRows as W, withRetry as X, type AthenaClientExperimentalOptions as a, type AthenaCreateClientOptions as b, type AthenaDbModule as c, AthenaError as d, AthenaErrorCategory as e, AthenaErrorCode as f, type AthenaErrorInput as g, AthenaErrorKind as h, type AthenaOperationContext as i, type AthenaResult as j, type AthenaSdkClient as k, type AthenaSdkClientWithAuth as l, type RetryBackoffStrategy as m, type RetryConfig as n, type RpcOrderOptions as o, type RpcQueryBuilder as p, type TypedAthenaClient as q, type TypedClientOptions as r, type UnwrapOptions as s, assertInt as t, coerceInt as u, createAuthClient as v, createClient as w, createPostgresIntrospectionProvider as x, createTypedClient as y, defineDatabase as z };
+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 { normalizeAthenaError as $, AthenaClient as A, type RpcOrderOptions as B, type RpcQueryBuilder as C, DEFAULT_POSTGRES_SCHEMAS as D, type TypedAthenaClient as E, type TypedClientOptions as F, type UnwrapOptions as G, assertInt as H, type IntCoercionOptions as I, coerceInt as J, createAuthClient as K, createAuthReactEmailInput as L, createClient as M, type NormalizedAthenaError as N, createPostgresIntrospectionProvider as O, type PostgresIntrospectionProviderOptions as P, createTypedClient as Q, type RequireAffectedOptions as R, defineAuthEmailTemplate as S, type TableQueryBuilder as T, type UnwrapOneOptions as U, defineDatabase as V, defineModel as W, defineRegistry as X, defineSchema as Y, identifier as Z, isOk as _, type AthenaClientExperimentalOptions as a, normalizeSchemaSelection as a0, parseBooleanFlag as a1, renderAthenaReactEmail as a2, requireAffected as a3, requireSuccess as a4, resolvePostgresColumnType as a5, resolveProviderSchemas as a6, unwrap as a7, unwrapOne as a8, unwrapRows as a9, withRetry as aa, type AthenaCreateClientOptions as b, type AthenaDbModule as c, AthenaError as d, AthenaErrorCategory as e, AthenaErrorCode as f, type AthenaErrorInput as g, AthenaErrorKind as h, type AthenaFindManyOptions as i, type AthenaFindManyResult as j, type AthenaOperationContext as k, type AthenaOrderBy as l, type AthenaQueryTraceCallsite as m, type AthenaQueryTraceEvent as n, type AthenaQueryTraceOptions as o, type AthenaRelationSelectNode as p, type AthenaResult as q, type AthenaResultError as r, type AthenaSdkClient as s, type AthenaSdkClientWithAuth as t, type AthenaSelectShape as u, type AthenaWhere as v, type AthenaWhereBooleanOperand as w, type AthenaWhereOperatorInput as x, type RetryBackoffStrategy as y, type RetryConfig as z };

package/dist/react.cjs

@@ -93,23 +93,39 @@ function normalizeHeaderValue(value) {
 function isRecord(value) {
   return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
+function nonEmptyString(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value.trim() : void 0;
+}
+function resolveStructuredErrorPayload(payload) {
+  if (!isRecord(payload)) return null;
+  return isRecord(payload.error) ? payload.error : payload;
+}
 function resolveRequestId(headers) {
   return headers.get("x-request-id") ?? headers.get("x-correlation-id") ?? headers.get("x-athena-request-id") ?? void 0;
 }
 function resolveErrorMessage(payload, fallback) {
-  if (isRecord(payload)) {
-    const messageCandidates = [payload.error, payload.message, payload.details];
+  const structuredPayload = resolveStructuredErrorPayload(payload);
+  if (structuredPayload) {
+    const messageCandidates = [structuredPayload.message, structuredPayload.error, structuredPayload.details];
     for (const candidate of messageCandidates) {
-      if (typeof candidate === "string" && candidate.trim().length > 0) {
-        return candidate.trim();
-      }
+      const resolved = nonEmptyString(candidate);
+      if (resolved) return resolved;
     }
   }
-  if (typeof payload === "string" && payload.trim().length > 0) {
-    return payload.trim();
-  }
+  const rawMessage = nonEmptyString(payload);
+  if (rawMessage) return rawMessage;
   return fallback;
 }
+function resolveErrorHint(payload) {
+  const structuredPayload = resolveStructuredErrorPayload(payload);
+  return structuredPayload ? nonEmptyString(structuredPayload.hint) : void 0;
+}
+function resolveStatusText(response, payload) {
+  const rawStatusText = nonEmptyString(response.statusText);
+  if (rawStatusText) return rawStatusText;
+  const payloadRecord = isRecord(payload) ? payload : null;
+  return payloadRecord ? nonEmptyString(payloadRecord.statusText) ?? null : null;
+}
 function detailsFromError(error) {
   return error.toDetails();
 }
@@ -280,6 +296,7 @@ async function callAthena(config, endpoint, method, payload, options) {
       return {
         ok: false,
         status: response.status,
+        statusText: resolveStatusText(response, parsedBody.parsed),
         data: null,
         error: invalidJsonError.message,
         errorDetails: detailsFromError(invalidJsonError),
@@ -298,11 +315,13 @@ async function callAthena(config, endpoint, method, payload, options) {
         status: response.status,
         endpoint,
         method,
-        requestId
+        requestId,
+        hint: resolveErrorHint(parsed)
       });
       return {
         ok: false,
         status: response.status,
+        statusText: resolveStatusText(response, parsed),
         data: null,
         error: httpError.message,
         errorDetails: detailsFromError(httpError),
@@ -314,6 +333,7 @@ async function callAthena(config, endpoint, method, payload, options) {
     return {
       ok: true,
       status: response.status,
+      statusText: resolveStatusText(response, parsed),
       data: payloadData ?? null,
       count: payloadCount,
       error: void 0,
@@ -333,6 +353,7 @@ async function callAthena(config, endpoint, method, payload, options) {
     return {
       ok: false,
       status: 0,
+      statusText: null,
       data: null,
       error: networkError.message,
       errorDetails: detailsFromError(networkError),