@xylex-group/athena 2.7.0 → 2.8.0

package/dist/{model-form-ehfqLuG7.d.cts → model-form-DXPlOnlI.d.ts}

@@ -1,4 +1,4 @@
-import { i as AthenaJsonValue, a as AthenaGatewayCallOptions, g as AthenaJsonObject, j as AthenaRpcCallOptions, W as AthenaGatewayEndpointPath, X as AthenaGatewayMethod, Y as AthenaConditionValue, Z as AthenaConditionArrayValue, R as RegistryDef, D as DatabaseDef, F as SchemaDef, J as AnyModelDef, x as ModelDef, C as ModelRelationMetadata, E as RowOf, o as BackendConfig, p as BackendType, e as AthenaGatewayErrorDetails, A as AthenaConditionCastType, _ as AthenaConditionOperator, b as AthenaGatewayConnectionOptions, c as AthenaGatewayConnectionResult, d as AthenaGatewayErrorCode, P as AthenaGatewayResponse, q as InsertOf, U as UpdateOf } from './types-BsyRW49r.cjs';
+import { j as AthenaModelTarget, H as RowOf, r as InsertOf, U as UpdateOf, i as AthenaJsonValue, a as AthenaGatewayCallOptions, g as AthenaJsonObject, k as AthenaRpcCallOptions, Z as AthenaGatewayEndpointPath, _ as AthenaGatewayMethod, $ as AthenaConditionValue, a0 as AthenaConditionArrayValue, R as RegistryDef, D as DatabaseDef, J as SchemaDef, N as AnyModelDef, C as ModelDef, G as ModelRelationMetadata, a1 as AthenaGatewayCondition, a2 as AthenaSortBy, V as AthenaFetchPayload, X as AthenaInsertPayload, Y as AthenaUpdatePayload, Q as AthenaDeletePayload, l as AthenaRpcFilter, o as AthenaRpcPayload, p as BackendConfig, q as BackendType, e as AthenaGatewayErrorDetails, A as AthenaConditionCastType, a3 as AthenaConditionOperator, b as AthenaGatewayConnectionOptions, c as AthenaGatewayConnectionResult, d as AthenaGatewayErrorCode, W as AthenaGatewayResponse } from './types-vikz9YIO.js';
 
 type AthenaAuthMethod = 'GET' | 'POST';
 type AthenaAuthCredentials = 'omit' | 'same-origin' | 'include';
@@ -1396,6 +1396,10 @@ declare class AthenaError extends Error {
  */
 declare function isOk<T>(result: AthenaResult<T>): boolean;
 /**
+ * @deprecated Prefer `result.error` on failed `AthenaResult` values and the
+ * structured fields already attached to thrown SDK errors. This helper is
+ * retained for compatibility with mixed unknown inputs.
+ *
  * Normalizes any Athena failure shape into a stable, typed error envelope.
  *
  * Accepts `AthenaResult`, `AthenaGatewayError`, native `Error`, or unknown values.
@@ -1466,23 +1470,43 @@ declare function assertInt(value: unknown, label?: string, options?: IntCoercion
  */
 declare function withRetry<T>(config: RetryConfig, fn: () => Promise<T>): Promise<T>;
 
+type Whitespace = ' ' | '\n' | '\r' | '\t';
+type TrimLeft<TValue extends string> = TValue extends `${Whitespace}${infer TRest}` ? TrimLeft<TRest> : TValue;
+type TrimRight<TValue extends string> = TValue extends `${infer TRest}${Whitespace}` ? TrimRight<TRest> : TValue;
+type Trim<TValue extends string> = TrimLeft<TrimRight<TValue>>;
+type KnownSelectColumnKey<Row> = Extract<keyof NonNullable<Row>, string>;
+type HasKnownSelectColumns<Row> = [KnownSelectColumnKey<Row>] extends [never] ? false : string extends KnownSelectColumnKey<Row> ? false : true;
+type HasComplexSelectTokenSyntax<TValue extends string> = TValue extends `${string}(${string}` ? true : TValue extends `${string})${string}` ? true : TValue extends `${string}.${string}` ? true : TValue extends `${string}"${string}` ? true : TValue extends `${string}'${string}` ? true : false;
+type ValidateAliasedBase<Row, TOriginal extends string, TBase extends string> = HasComplexSelectTokenSyntax<Trim<TBase>> extends true ? TOriginal : Trim<TBase> extends KnownSelectColumnKey<Row> ? TOriginal : never;
+type ValidateSelectToken<Row, TToken extends string> = Trim<TToken> extends infer TTrimmed extends string ? TTrimmed extends '' ? never : TTrimmed extends '*' ? TTrimmed : TTrimmed extends `${string}:${infer TBase}` ? ValidateAliasedBase<Row, TTrimmed, TBase> : TTrimmed extends `${infer TBase} as ${string}` ? ValidateAliasedBase<Row, TTrimmed, TBase> : TTrimmed extends `${infer TBase} AS ${string}` ? ValidateAliasedBase<Row, TTrimmed, TBase> : HasComplexSelectTokenSyntax<TTrimmed> extends true ? TTrimmed : TTrimmed extends KnownSelectColumnKey<Row> ? TTrimmed : never : never;
+type ValidateSelectList<Row, TValue extends string> = string extends TValue ? TValue : HasComplexSelectTokenSyntax<TValue> extends true ? TValue : TValue extends `${infer THead},${infer TTail}` ? ValidateSelectToken<Row, THead> extends never ? never : ValidateSelectList<Row, TTail> extends never ? never : TValue : ValidateSelectToken<Row, TValue> extends never ? never : TValue;
+type ValidateSelectArray<Row, TValue extends readonly string[]> = string extends TValue[number] ? TValue : TValue extends readonly [
+    infer THead extends string,
+    ...infer TTail extends readonly string[]
+] ? ValidateSelectToken<Row, THead> extends never ? never : ValidateSelectArray<Row, TTail> extends never ? never : TValue : TValue;
+type AthenaSelectInput = string | string[] | readonly string[];
+type AthenaValidatedSelectInput<Row, TValue extends AthenaSelectInput> = HasKnownSelectColumns<Row> extends true ? TValue extends string ? ValidateSelectList<Row, TValue> : TValue extends readonly string[] ? ValidateSelectArray<Row, TValue> : never : TValue;
+type AthenaTypecheckedColumnKey<Row, TEnabled extends boolean> = TEnabled extends true ? HasKnownSelectColumns<Row> extends true ? KnownSelectColumnKey<Row> : string : string;
+
 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>;
+interface AthenaDbModule<TStrict extends boolean = false> {
+    from<TModel extends AthenaModelTarget>(model: TModel): TableQueryBuilder<RowOf<TModel>, InsertOf<TModel>, UpdateOf<TModel>, unknown, TStrict>;
+    from<Row = AthenaRowShape$2, Insert = Partial<Row>, Update = Partial<Insert>>(table: string, options?: AthenaFromOptions): TableQueryBuilder<Row, Insert, Update, unknown, TStrict>;
+    select<Row = AthenaRowShape$2>(table: string, options?: AthenaGatewayCallOptions): SelectChain<Row, Row, TStrict>;
+    select(table: string, columns: AthenaSelectInput, options?: AthenaGatewayCallOptions): SelectChain<AthenaRowShape$2, AthenaRowShape$2, TStrict>;
+    insert<Row = AthenaRowShape$2, Insert = Partial<Row>>(table: string, values: Insert, options?: AthenaGatewayCallOptions): MutationQuery<Row, Row, TStrict>;
+    insert<Row = AthenaRowShape$2, Insert = Partial<Row>>(table: string, values: Insert[], options?: AthenaGatewayCallOptions): MutationQuery<Row[], Row, TStrict>;
+    upsert<Row = AthenaRowShape$2, Insert = Partial<Row>, Update = Partial<Insert>>(table: string, values: Insert, options?: AthenaUpsertOptions<Update>): MutationQuery<Row, Row, TStrict>;
+    upsert<Row = AthenaRowShape$2, Insert = Partial<Row>, Update = Partial<Insert>>(table: string, values: Insert[], options?: AthenaUpsertOptions<Update>): MutationQuery<Row[], Row, TStrict>;
+    update<Row = AthenaRowShape$2, Insert = Partial<Row>, Update = Partial<Insert>>(table: string, values: Update, options?: AthenaGatewayCallOptions): UpdateChain<Row, TStrict>;
     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>;
+    }): MutationQuery<Row | null, Row, TStrict>;
+    rpc<Row = unknown, Args extends AthenaJsonObject = AthenaJsonObject>(fn: string, args?: Args, options?: AthenaRpcCallOptions): RpcQueryBuilder<Row, TStrict>;
     query<Row = unknown>(query: string, options?: AthenaGatewayCallOptions): Promise<AthenaResult<Row[]>>;
 }
 
@@ -2011,8 +2035,7 @@ interface StorageObjectFolderCreateRequest {
     bucket: string;
     prefix: string;
 }
-interface StorageObjectFolderDeleteRequest extends StorageObjectFolderCreateRequest {
-}
+type StorageObjectFolderDeleteRequest = StorageObjectFolderCreateRequest;
 interface StorageObjectFolderRenameRequest extends Omit<StorageObjectFolderCreateRequest, 'prefix'> {
     from_prefix: string;
     to_prefix: string;
@@ -2054,8 +2077,7 @@ interface StorageUpdateObjectRequest extends StorageObjectRequest {
 interface StoragePresignUploadRequest extends StorageObjectRequest {
     content_type?: string;
 }
-interface StorageBucketCorsRequest extends StorageObjectBaseRequest {
-}
+type StorageBucketCorsRequest = StorageObjectBaseRequest;
 interface StorageBucketCorsRuleInput {
     allowed_origins: string[];
     allowed_methods: string[];
@@ -2421,6 +2443,171 @@ type RelationSelectionResult<TContext, TSelect extends AthenaSelectShape> = {
 };
 type AthenaFindManyResult<Row, TSelect extends AthenaSelectShape, TContext = unknown> = Simplify<ScalarSelectionResult<Row, TSelect> & RelationSelectionResult<TContext, TSelect>>;
 
+type AthenaFindManyAstPayload<Row, TSelect extends AthenaSelectShape> = {
+    table_name: string;
+    select: TSelect;
+    where?: AthenaWhere<Row>;
+    orderBy?: AthenaOrderBy<Row>;
+    limit?: number;
+};
+
+interface AthenaTableBuilderStateAst {
+    conditions: AthenaGatewayCondition[];
+    limit?: number;
+    offset?: number;
+    order?: AthenaSortBy;
+    currentPage?: number;
+    pageSize?: number;
+    totalPages?: number;
+}
+interface AthenaRpcBuilderStateAst {
+    filters: AthenaRpcFilter[];
+    limit?: number;
+    offset?: number;
+    order?: {
+        column: string;
+        ascending?: boolean;
+    };
+}
+interface AthenaDebugAstBase<TKind extends string> {
+    version: 1;
+    kind: TKind;
+}
+type AthenaSelectDebugTransport = {
+    mode: 'compiled-fetch' | 'structured-fetch';
+    endpoint: '/gateway/fetch';
+    payload: AthenaFetchPayload;
+} | {
+    mode: 'typed-query';
+    endpoint: '/gateway/query';
+    payload: {
+        query: string;
+    };
+};
+interface AthenaSelectDebugAst extends AthenaDebugAstBase<'select'> {
+    tableName: string;
+    input: {
+        columns: string | string[];
+        state: AthenaTableBuilderStateAst;
+    };
+    transport: AthenaSelectDebugTransport;
+}
+type AthenaFindManyDebugTransport<Row = Record<string, unknown>, TSelect extends AthenaSelectShape = AthenaSelectShape> = {
+    mode: 'direct-ast-fetch';
+    endpoint: '/gateway/fetch';
+    payload: AthenaFindManyAstPayload<Row, TSelect>;
+} | {
+    mode: 'compiled-fetch' | 'structured-fetch';
+    endpoint: '/gateway/fetch';
+    payload: AthenaFetchPayload;
+} | {
+    mode: 'compiled-query';
+    endpoint: '/gateway/query';
+    payload: {
+        query: string;
+    };
+};
+interface AthenaFindManyDebugAst<Row = Record<string, unknown>, TSelect extends AthenaSelectShape = AthenaSelectShape> extends AthenaDebugAstBase<'findMany'> {
+    tableName: string;
+    input: {
+        select: AthenaValidatedSelectShape<TSelect>;
+        where?: AthenaWhere<Row>;
+        orderBy?: AthenaOrderBy<Row>;
+        limit?: number;
+    };
+    compiled: {
+        columns: string;
+        baseState: AthenaTableBuilderStateAst;
+        executionState: AthenaTableBuilderStateAst;
+    };
+    transport: AthenaFindManyDebugTransport<Row, TSelect>;
+}
+interface AthenaInsertDebugAst extends AthenaDebugAstBase<'insert'> {
+    tableName: string;
+    input: {
+        values: AthenaInsertPayload['insert_body'];
+        returning?: AthenaInsertPayload['columns'];
+        count?: AthenaInsertPayload['count'];
+        head?: boolean;
+        defaultToNull?: boolean;
+    };
+    transport: {
+        mode: 'insert';
+        endpoint: '/gateway/insert';
+        payload: AthenaInsertPayload;
+    };
+}
+interface AthenaUpsertDebugAst extends AthenaDebugAstBase<'upsert'> {
+    tableName: string;
+    input: {
+        values: AthenaInsertPayload['insert_body'];
+        updateBody?: AthenaInsertPayload['update_body'];
+        onConflict?: AthenaInsertPayload['on_conflict'];
+        returning?: AthenaInsertPayload['columns'];
+        count?: AthenaInsertPayload['count'];
+        head?: boolean;
+        defaultToNull?: boolean;
+    };
+    transport: {
+        mode: 'upsert';
+        endpoint: '/gateway/insert';
+        payload: AthenaInsertPayload;
+    };
+}
+interface AthenaUpdateDebugAst extends AthenaDebugAstBase<'update'> {
+    tableName: string;
+    input: {
+        values: AthenaUpdatePayload['set'];
+        state: AthenaTableBuilderStateAst;
+        returning?: AthenaUpdatePayload['columns'];
+    };
+    transport: {
+        mode: 'update';
+        endpoint: '/gateway/update';
+        payload: AthenaUpdatePayload;
+    };
+}
+interface AthenaDeleteDebugAst extends AthenaDebugAstBase<'delete'> {
+    tableName: string;
+    input: {
+        resourceId?: AthenaDeletePayload['resource_id'];
+        state: AthenaTableBuilderStateAst;
+        returning?: AthenaDeletePayload['columns'];
+    };
+    transport: {
+        mode: 'delete';
+        endpoint: '/gateway/delete';
+        payload: AthenaDeletePayload;
+    };
+}
+interface AthenaRpcDebugAst extends AthenaDebugAstBase<'rpc'> {
+    functionName: string;
+    input: {
+        args?: AthenaJsonObject;
+        select?: string | string[];
+        state: AthenaRpcBuilderStateAst;
+    };
+    transport: {
+        mode: 'rpc-post' | 'rpc-get';
+        endpoint: '/gateway/rpc' | `/rpc/${string}`;
+        payload: AthenaRpcPayload;
+    };
+}
+interface AthenaRawQueryDebugAst extends AthenaDebugAstBase<'query'> {
+    input: {
+        query: string;
+    };
+    transport: {
+        mode: 'raw-query';
+        endpoint: '/gateway/query';
+        payload: {
+            query: string;
+        };
+    };
+}
+type AthenaQueryDebugAst = AthenaSelectDebugAst | AthenaFindManyDebugAst | AthenaInsertDebugAst | AthenaUpsertDebugAst | AthenaUpdateDebugAst | AthenaDeleteDebugAst | AthenaRpcDebugAst | AthenaRawQueryDebugAst;
+declare function getAthenaDebugAst(value: unknown): AthenaQueryDebugAst | null;
+
 interface AthenaResult<T> {
     data: T | null;
     error: AthenaResultError | null;
@@ -2471,6 +2658,21 @@ interface AthenaClientExperimentalOptions {
      * Includes payload, synthesized SQL, full outcome, and best-effort callsite metadata.
      */
     traceQueries?: boolean | AthenaQueryTraceOptions;
+    /**
+     * Build and attach a normalized operation AST for runtime debugging.
+     *
+     * When enabled, successful Athena results expose a non-enumerable debug AST
+     * that can be read with `getAthenaDebugAst(...)`. If tracing is also enabled,
+     * the same AST is included on emitted trace events.
+     */
+    debugAst?: boolean;
+    /**
+     * Compile-time opt-in for validating simple `select(...)`, `order(...)`, and
+     * RPC filter column names against known row keys.
+     *
+     * This flag is type-only. It does not change runtime request behavior.
+     */
+    typecheckColumns?: boolean;
     /**
      * Send the original `findMany(...)` AST body for clean object-select reads.
      * This requires gateway support and falls back to legacy compiled transport
@@ -2510,6 +2712,7 @@ interface AthenaQueryTraceEvent {
     functionName?: string;
     sql: string;
     payload: unknown;
+    ast?: AthenaQueryDebugAst;
     options?: AthenaGatewayCallOptions | AthenaRpcCallOptions;
     callsite: AthenaQueryTraceCallsite | null;
     outcome?: {
@@ -2523,14 +2726,16 @@ interface AthenaQueryTraceEvent {
     thrownError?: unknown;
 }
 type MutationSingleResult<Result> = Result extends Array<infer Item> ? Item | null : Result | null;
+type MutationResultRow<Result> = Result extends Array<infer Item> ? Item : Result;
 type AthenaRowShape = Record<string, AthenaJsonValue | undefined>;
 type FilterColumnKey<Row> = Extract<keyof NonNullable<Row>, string>;
 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>>>;
+type SelectColumnsFor<Row, TStrict extends boolean, TValue extends AthenaSelectInput> = TStrict extends true ? AthenaValidatedSelectInput<Row, TValue> : TValue;
+interface MutationQuery<Result, Row = MutationResultRow<Result>, TStrict extends boolean = false> extends PromiseLike<AthenaResult<Result>> {
+    select<const TColumns extends AthenaSelectInput = string>(columns?: SelectColumnsFor<Row, TStrict, TColumns>, options?: AthenaGatewayCallOptions): Promise<AthenaResult<Result>>;
+    returning<const TColumns extends AthenaSelectInput = string>(columns?: SelectColumnsFor<Row, TStrict, TColumns>, options?: AthenaGatewayCallOptions): Promise<AthenaResult<Result>>;
+    single<const TColumns extends AthenaSelectInput = string>(columns?: SelectColumnsFor<Row, TStrict, TColumns>, options?: AthenaGatewayCallOptions): Promise<AthenaResult<MutationSingleResult<Result>>>;
+    maybeSingle<const TColumns extends AthenaSelectInput = string>(columns?: SelectColumnsFor<Row, TStrict, TColumns>, options?: AthenaGatewayCallOptions): Promise<AthenaResult<MutationSingleResult<Result>>>;
     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>>;
@@ -2566,78 +2771,92 @@ interface FilterChain<Self, Row> {
     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>>;
+interface SelectChain<Row, SelectedRow = Row, TStrict extends boolean = false> extends FilterChain<SelectChain<Row, SelectedRow, TStrict>, Row>, PromiseLike<AthenaResult<SelectedRow[]>> {
+    single<T = SelectedRow, const TColumns extends AthenaSelectInput = string>(columns?: SelectColumnsFor<Row, TStrict, TColumns>, options?: AthenaGatewayCallOptions): Promise<AthenaResult<T | null>>;
+    maybeSingle<T = SelectedRow, const TColumns extends AthenaSelectInput = string>(columns?: SelectColumnsFor<Row, TStrict, TColumns>, options?: AthenaGatewayCallOptions): Promise<AthenaResult<T | null>>;
 }
 /** 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 UpdateChain<Row, TStrict extends boolean = false> extends FilterChain<UpdateChain<Row, TStrict>, Row>, MutationQuery<Row[], Row, TStrict> {
+}
+interface RpcFilterChain<Self, Row, TStrict extends boolean = false> {
+    eq(column: AthenaTypecheckedColumnKey<Row, TStrict>, value: AthenaConditionValue): Self;
+    neq(column: AthenaTypecheckedColumnKey<Row, TStrict>, value: AthenaConditionValue): Self;
+    gt(column: AthenaTypecheckedColumnKey<Row, TStrict>, value: AthenaConditionValue): Self;
+    gte(column: AthenaTypecheckedColumnKey<Row, TStrict>, value: AthenaConditionValue): Self;
+    lt(column: AthenaTypecheckedColumnKey<Row, TStrict>, value: AthenaConditionValue): Self;
+    lte(column: AthenaTypecheckedColumnKey<Row, TStrict>, value: AthenaConditionValue): Self;
+    like(column: AthenaTypecheckedColumnKey<Row, TStrict>, value: AthenaConditionValue): Self;
+    ilike(column: AthenaTypecheckedColumnKey<Row, TStrict>, value: AthenaConditionValue): Self;
+    is(column: AthenaTypecheckedColumnKey<Row, TStrict>, value: AthenaConditionValue): Self;
+    in(column: AthenaTypecheckedColumnKey<Row, TStrict>, values: AthenaConditionArrayValue): Self;
 }
 interface 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 RpcQueryBuilder<Row, TStrict extends boolean = false> extends RpcFilterChain<RpcQueryBuilder<Row, TStrict>, Row, TStrict>, PromiseLike<AthenaResult<Row[]>> {
+    select<const TColumns extends AthenaSelectInput = string>(columns?: SelectColumnsFor<Row, TStrict, TColumns>, options?: AthenaRpcCallOptions): Promise<AthenaResult<Row[]>>;
+    single<T = Row, const TColumns extends AthenaSelectInput = string>(columns?: SelectColumnsFor<Row, TStrict, TColumns>, options?: AthenaRpcCallOptions): Promise<AthenaResult<T | null>>;
+    maybeSingle<T = Row, const TColumns extends AthenaSelectInput = string>(columns?: SelectColumnsFor<Row, TStrict, TColumns>, options?: AthenaRpcCallOptions): Promise<AthenaResult<T | null>>;
+    order(column: AthenaTypecheckedColumnKey<Row, TStrict>, options?: RpcOrderOptions): RpcQueryBuilder<Row, TStrict>;
+    limit(count: number): RpcQueryBuilder<Row, TStrict>;
+    offset(count: number): RpcQueryBuilder<Row, TStrict>;
+    range(from: number, to: number): RpcQueryBuilder<Row, TStrict>;
 }
 interface 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>;
+interface TableQueryBuilder<Row, Insert = Partial<Row>, Update = Partial<Insert>, TContext = unknown, TStrict extends boolean = false> extends FilterChain<TableQueryBuilder<Row, Insert, Update, TContext, TStrict>, Row> {
+    select<T = Row, const TColumns extends AthenaSelectInput = string>(columns?: SelectColumnsFor<Row, TStrict, TColumns>, options?: AthenaGatewayCallOptions): SelectChain<Row, T, TStrict>;
     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[]>;
+    insert(values: Insert, options?: AthenaGatewayCallOptions): MutationQuery<Row, Row, TStrict>;
+    insert(values: Insert[], options?: AthenaGatewayCallOptions): MutationQuery<Row[], Row, TStrict>;
     upsert(values: Insert, options?: AthenaGatewayCallOptions & {
         updateBody?: Update;
         onConflict?: string | string[];
-    }): MutationQuery<Row>;
+    }): MutationQuery<Row, Row, TStrict>;
     upsert(values: Insert[], options?: AthenaGatewayCallOptions & {
         updateBody?: Update;
         onConflict?: string | string[];
-    }): MutationQuery<Row[]>;
-    update(values: Update, options?: AthenaGatewayCallOptions): UpdateChain<Row>;
+    }): MutationQuery<Row[], Row, TStrict>;
+    update(values: Update, options?: AthenaGatewayCallOptions): UpdateChain<Row, TStrict>;
     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>;
+    }): MutationQuery<Row | null, Row, TStrict>;
+    single<T = Row, const TColumns extends AthenaSelectInput = string>(columns?: SelectColumnsFor<Row, TStrict, TColumns>, options?: AthenaGatewayCallOptions): Promise<AthenaResult<T | null>>;
+    maybeSingle<T = Row, const TColumns extends AthenaSelectInput = string>(columns?: SelectColumnsFor<Row, TStrict, TColumns>, options?: AthenaGatewayCallOptions): Promise<AthenaResult<T | null>>;
+    reset(): TableQueryBuilder<Row, Insert, Update, TContext, TStrict>;
+}
+interface AthenaSdkClient<TStrict extends boolean = false> {
+    from<TModel extends AthenaModelTarget>(model: TModel): TableQueryBuilder<RowOf<TModel>, InsertOf<TModel>, UpdateOf<TModel>, unknown, TStrict>;
+    from<Row = AthenaRowShape, Insert = Partial<Row>, Update = Partial<Insert>>(table: string, options?: AthenaFromOptions): TableQueryBuilder<Row, Insert, Update, unknown, TStrict>;
+    db: AthenaDbModule<TStrict>;
+    rpc<Row = unknown, Args extends AthenaJsonObject = AthenaJsonObject>(fn: string, args?: Args, options?: AthenaRpcCallOptions): RpcQueryBuilder<Row, TStrict>;
     query<Row = unknown>(query: string, options?: AthenaGatewayCallOptions): Promise<AthenaResult<Row[]>>;
     verifyConnection(options?: AthenaGatewayConnectionOptions): Promise<AthenaGatewayConnectionResult>;
 }
-interface AthenaSdkClientWithAuth extends AthenaSdkClient {
+interface AthenaSdkClientWithAuth<TStrict extends boolean = false> extends AthenaSdkClient<TStrict> {
     auth: AthenaAuthBindings;
 }
-interface AthenaSdkClientWithStorage extends AthenaSdkClientWithAuth {
+interface AthenaSdkClientWithStorage<TStrict extends boolean = false> extends AthenaSdkClientWithAuth<TStrict> {
     storage: AthenaStorageModule;
 }
+interface AthenaCreateClientServiceUrlConfig {
+    url?: string | null;
+}
+interface AthenaCreateClientAuthOptions extends AthenaAuthClientConfig {
+    url?: string | null;
+}
 interface AthenaCreateClientOptions extends Pick<AthenaGatewayCallOptions, 'client' | 'headers' | 'backend'> {
-    auth?: AthenaAuthClientConfig;
+    db?: AthenaCreateClientServiceUrlConfig;
+    gateway?: AthenaCreateClientServiceUrlConfig;
+    auth?: AthenaCreateClientAuthOptions;
+    storage?: AthenaCreateClientServiceUrlConfig;
+    dbUrl?: string | null;
+    gatewayUrl?: string | null;
+    authUrl?: string | null;
+    storageUrl?: string | null;
     experimental?: AthenaClientExperimentalOptions;
 }
 interface AthenaCreateClientOptionsWithStorage extends AthenaCreateClientOptions {
@@ -2645,40 +2864,82 @@ interface AthenaCreateClientOptionsWithStorage extends AthenaCreateClientOptions
         athenaStorageBackend: true;
     };
 }
-interface AthenaClientBuilder<StorageEnabled extends boolean = false> {
-    /** Set the gateway base URL. */
-    url(url: string): AthenaClientBuilder<StorageEnabled>;
+interface AthenaCreateClientOptionsWithTypecheckedColumns extends AthenaCreateClientOptions {
+    experimental: AthenaClientExperimentalOptions & {
+        typecheckColumns: true;
+    };
+}
+interface AthenaCreateClientOptionsWithStorageAndTypecheckedColumns extends AthenaCreateClientOptions {
+    experimental: AthenaClientExperimentalOptions & {
+        athenaStorageBackend: true;
+        typecheckColumns: true;
+    };
+}
+interface AthenaCreateClientConfig extends AthenaCreateClientOptions {
+    url?: string | null;
+    key: string;
+}
+interface AthenaCreateClientConfigWithStorage extends AthenaCreateClientOptionsWithStorage {
+    url?: string | null;
+    key: string;
+}
+interface AthenaCreateClientConfigWithTypecheckedColumns extends AthenaCreateClientOptionsWithTypecheckedColumns {
+    url?: string | null;
+    key: string;
+}
+interface AthenaCreateClientConfigWithStorageAndTypecheckedColumns extends AthenaCreateClientOptionsWithStorageAndTypecheckedColumns {
+    url?: string | null;
+    key: string;
+}
+interface AthenaClientBuilder<StorageEnabled extends boolean = false, TStrict extends boolean = false> {
+    /** Set the public Athena base URL. */
+    url(url: string): AthenaClientBuilder<StorageEnabled, TStrict>;
     /** Set the API key used for all requests. */
-    key(apiKey: string): AthenaClientBuilder<StorageEnabled>;
+    key(apiKey: string): AthenaClientBuilder<StorageEnabled, TStrict>;
     /** Set the default backend routing strategy. */
-    backend(backend: BackendConfig | BackendType): AthenaClientBuilder<StorageEnabled>;
+    backend(backend: BackendConfig | BackendType): AthenaClientBuilder<StorageEnabled, TStrict>;
     /** Set the default Athena client routing key. */
-    client(clientName: string): AthenaClientBuilder<StorageEnabled>;
+    client(clientName: string): AthenaClientBuilder<StorageEnabled, TStrict>;
     /** Attach static headers to every request. */
-    headers(headers: Record<string, string>): AthenaClientBuilder<StorageEnabled>;
+    headers(headers: Record<string, string>): AthenaClientBuilder<StorageEnabled, TStrict>;
     /** 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. */
+    auth(config: AthenaCreateClientAuthOptions): AthenaClientBuilder<StorageEnabled, TStrict>;
+    /** Configure experimental client options and narrow the built client when storage or strict column checks are enabled. */
     experimental(options: AthenaClientExperimentalOptions & {
         athenaStorageBackend: true;
-    }): AthenaClientBuilder<true>;
-    experimental(options: AthenaClientExperimentalOptions): AthenaClientBuilder<StorageEnabled>;
+        typecheckColumns: true;
+    }): AthenaClientBuilder<true, true>;
+    experimental(options: AthenaClientExperimentalOptions & {
+        athenaStorageBackend: true;
+    }): AthenaClientBuilder<true, TStrict>;
+    experimental(options: AthenaClientExperimentalOptions & {
+        typecheckColumns: true;
+    }): AthenaClientBuilder<StorageEnabled, true>;
+    experimental(options: AthenaClientExperimentalOptions): AthenaClientBuilder<StorageEnabled, TStrict>;
     /** Apply createClient options and narrow the built client when storage is enabled. */
-    options(options: AthenaCreateClientOptionsWithStorage): AthenaClientBuilder<true>;
-    options(options: AthenaCreateClientOptions): AthenaClientBuilder<StorageEnabled>;
+    options(options: AthenaCreateClientOptionsWithStorageAndTypecheckedColumns): AthenaClientBuilder<true, true>;
+    options(options: AthenaCreateClientOptionsWithStorage): AthenaClientBuilder<true, TStrict>;
+    options(options: AthenaCreateClientOptionsWithTypecheckedColumns): AthenaClientBuilder<StorageEnabled, true>;
+    options(options: AthenaCreateClientOptions): AthenaClientBuilder<StorageEnabled, TStrict>;
     /** Build the immutable Athena SDK client. */
-    build(): StorageEnabled extends true ? AthenaSdkClientWithStorage : AthenaSdkClientWithAuth;
+    build(): StorageEnabled extends true ? AthenaSdkClientWithStorage<TStrict> : AthenaSdkClientWithAuth<TStrict>;
 }
 /** Canonical Athena client factory with builder-based configuration. */
 declare class AthenaClient {
     /** Create a fluent builder for a strongly-typed Athena SDK client. */
-    static builder(): AthenaClientBuilder<false>;
+    static builder(): AthenaClientBuilder<false, false>;
     /** Build a client from process environment variables. */
-    static fromEnvironment(): AthenaSdkClientWithAuth;
+    static fromEnvironment(): AthenaSdkClientWithAuth<false>;
 }
 /** 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;
+declare function createClient(config: AthenaCreateClientConfigWithStorageAndTypecheckedColumns): AthenaSdkClientWithStorage<true>;
+declare function createClient(config: AthenaCreateClientConfigWithStorage): AthenaSdkClientWithStorage<false>;
+declare function createClient(config: AthenaCreateClientConfigWithTypecheckedColumns): AthenaSdkClientWithAuth<true>;
+declare function createClient(config: AthenaCreateClientConfig): AthenaSdkClientWithAuth<false>;
+declare function createClient(url: string, apiKey: string, options: AthenaCreateClientOptionsWithStorageAndTypecheckedColumns): AthenaSdkClientWithStorage<true>;
+declare function createClient(url: string, apiKey: string, options: AthenaCreateClientOptionsWithStorage): AthenaSdkClientWithStorage<false>;
+declare function createClient(url: string, apiKey: string, options: AthenaCreateClientOptionsWithTypecheckedColumns): AthenaSdkClientWithAuth<true>;
+declare function createClient(url: string, apiKey: string, options?: AthenaCreateClientOptions): AthenaSdkClientWithAuth<false>;
 
 interface AthenaGatewayErrorInput {
     code: AthenaGatewayErrorCode;
@@ -2722,6 +2983,10 @@ type MapNullableToFormValue<TField, TMode extends ModelFormNullishMode> = null e
 type ModelFormValues<TModel extends AnyModelDef, TMode extends ModelFormNullishMode = 'empty-string'> = {
     [K in keyof InsertOf<TModel>]: MapNullableToFormValue<InsertOf<TModel>[K], TMode>;
 };
+/**
+ * Alias for deriving form value types from any model contract.
+ */
+type FormValuesOf<TModel extends AnyModelDef, TMode extends ModelFormNullishMode = 'empty-string'> = ModelFormValues<TModel, TMode>;
 /**
  * Default value shape for form initialization.
  */
@@ -2769,4 +3034,4 @@ interface ModelFormAdapter<TModel extends AnyModelDef> {
  */
 declare function createModelFormAdapter<TModel extends AnyModelDef>(model: TModel): ModelFormAdapter<TModel>;
 
-export { type AthenaClientExperimentalOptions as $, type AthenaAdminListUsersFilterOperator as A, type AthenaAuthQueryValue as B, type AthenaAuthReactEmailComponent as C, type AthenaAuthReactEmailConfig as D, type AthenaAuthReactEmailEventPhase as E, type AthenaAuthReactEmailProps as F, type AthenaAuthReactEmailRenderEvent as G, type AthenaAuthReactEmailRenderInput as H, type AthenaAuthReactEmailRenderOptions as I, type AthenaAuthRequestInput as J, type AthenaAuthResetPasswordBinding as K, type AthenaAuthResult as L, type AthenaAuthRevokeSessionRequest as M, type AthenaAuthSdkClient as N, type AthenaAuthSearchOperator as O, type AthenaAuthSession as P, type AthenaAuthSessionResponse as Q, type AthenaAuthSessionRevokeBinding as R, type AthenaAuthSignInResponse as S, type AthenaAuthSignOutResponse as T, type AthenaAuthSocialRedirectResponse as U, type AthenaAuthStatusResponse as V, type AthenaAuthUser as W, type AthenaChangeEmailRequest as X, type AthenaChangePasswordRequest as Y, AthenaClient as Z, type AthenaClientBuilder as _, type AthenaAdminListUsersQuery as a, type AthenaUnlinkAccountRequest as a$, type AthenaCreateClientOptions as a0, type AthenaCreateClientOptionsWithStorage as a1, type AthenaDbModule as a2, type AthenaDeleteUserCallbackRequest as a3, type AthenaDeleteUserRequest as a4, type AthenaDeleteUserResponse as a5, type AthenaEmailSignInRequest as a6, type AthenaEmailSignUpRequest as a7, type AthenaEnvelope as a8, AthenaError as a9, type AthenaSocialSignInRequest as aA, type AthenaStorageBinaryCallOptions as aB, type AthenaStorageCallOptions as aC, type AthenaStorageClientConfig as aD, type AthenaStorageEnv as aE, AthenaStorageError as aF, AthenaStorageErrorCode as aG, type AthenaStorageErrorDetails as aH, type AthenaStorageErrorHandler as aI, type AthenaStorageErrorInput as aJ, type AthenaStorageFileConfig as aK, type AthenaStorageFileDeleteInput as aL, type AthenaStorageFileDownloadInput as aM, type AthenaStorageFileListInput as aN, type AthenaStorageFileModule as aO, type AthenaStorageFileUploadInput as aP, type AthenaStorageFileUploadResult as aQ, type AthenaStorageModule as aR, type AthenaStoragePathContext as aS, type AthenaStoragePrefixPath as aT, type AthenaStorageTemplateValue as aU, type AthenaStorageTemplateVars as aV, type AthenaStorageUploadConstraints as aW, type AthenaStorageUploadProgress as aX, type AthenaStorageUploadProgressHandler as aY, type AthenaStorageUploadSource as aZ, type AthenaStorageUploadedFile as a_, AthenaErrorCategory as aa, AthenaErrorCode as ab, type AthenaErrorInput as ac, AthenaErrorKind as ad, type AthenaFindManyOptions as ae, type AthenaFindManyResult as af, type AthenaForgetPasswordRequest as ag, type AthenaFromOptions as ah, AthenaGatewayError as ai, type AthenaLinkSocialRequest as aj, type AthenaOAuthAccountTokenRequest as ak, type AthenaOAuthTokenBundle as al, type AthenaOperationContext as am, type AthenaOrderBy as an, type AthenaQueryTraceCallsite as ao, type AthenaQueryTraceEvent as ap, type AthenaQueryTraceOptions as aq, type AthenaRelationSelectNode as ar, type AthenaResetPasswordRequest as as, type AthenaResult as at, type AthenaResultError as au, type AthenaSdkClient as av, type AthenaSdkClientWithAuth as aw, type AthenaSdkClientWithStorage as ax, type AthenaSelectShape as ay, type AthenaSendVerificationEmailRequest as az, type AthenaAdminListUsersSearchOperator as b, type AthenaUpdateUserRequest as b0, type AthenaUsernameSignInRequest as b1, type AthenaVerifyEmailRequest as b2, type AthenaWhere as b3, type AthenaWhereBooleanOperand as b4, type AthenaWhereOperatorInput as b5, type CreateStorageCatalogRequest as b6, type CreateStorageUploadUrlRequest as b7, type CreateStorageUploadUrlsRequest as b8, type DeleteStorageFolderRequest as b9, type ToModelFormDefaultsOptions as bA, type ToModelPayloadOptions as bB, type UnwrapOneOptions as bC, type UnwrapOptions as bD, type UpdateStorageCatalogRequest as bE, type UpdateStorageFileRequest as bF, assertInt as bG, coerceInt as bH, createAthenaStorageError as bI, createClient as bJ, createModelFormAdapter as bK, isAthenaGatewayError as bL, isOk as bM, normalizeAthenaError as bN, parseBooleanFlag as bO, requireAffected as bP, requireSuccess as bQ, storageSdkManifest as bR, toModelFormDefaults as bS, toModelPayload as bT, unwrap as bU, unwrapOne as bV, unwrapRows as bW, withRetry as bX, type AthenaAuthFetchCompatibleInput as bY, type GetStorageFileUrlQuery as ba, type IntCoercionOptions as bb, type ListStorageFilesRequest as bc, type ManagedFileRecord as bd, type ModelFormAdapter as be, type ModelFormDefaults as bf, type ModelFormNullishMode as bg, type ModelFormValues as bh, type MoveStorageFolderRequest as bi, type NormalizedAthenaError as bj, type PresignedFileUrlResponse as bk, type RequireAffectedOptions as bl, type RetryBackoffStrategy as bm, type RetryConfig as bn, type RpcOrderOptions as bo, type RpcQueryBuilder as bp, type S3CatalogItem as bq, type S3CredentialListItem as br, type SetStorageFileVisibilityRequest as bs, type StorageBatchUploadUrlResponse as bt, type StorageFileAccessPurpose as bu, type StorageFileMutationResponse as bv, type StorageFolderMutationResponse as bw, type StorageListFilesResponse as bx, type StorageUploadUrlResponse as by, type TableQueryBuilder as bz, type AthenaAuthAdminUserSessionRevokeBinding as c, type AthenaAuthBindings as d, type AthenaAuthCallOptions as e, type AthenaAuthClientConfig as f, type AthenaAuthCredentials as g, type AthenaAuthEmailChangeResponse as h, type AthenaAuthEmailTemplateBuilder as i, type AthenaAuthEmailTemplateCreateFromDefinitionInput as j, type AthenaAuthEmailTemplateDefinition as k, type AthenaAuthEmailTemplateReactOverrides as l, type AthenaAuthEmailTemplateUpdateFromDefinitionInput as m, type AthenaAuthEndpointPath as n, type AthenaAuthErrorCode as o, type AthenaAuthErrorDetails as p, type AthenaAuthFilterOperator as q, type AthenaAuthGenericInput as r, type AthenaAuthGenericQueryInput as s, type AthenaAuthLinkedAccount as t, type AthenaAuthMethod as u, type AthenaAuthOrganization as v, type AthenaAuthOrganizationBindings as w, type AthenaAuthOrganizationInvitation as x, type AthenaAuthOrganizationMember as y, type AthenaAuthQueryPrimitive as z };
+export { type AthenaClientExperimentalOptions as $, type AthenaAdminListUsersFilterOperator as A, type AthenaAuthQueryValue as B, type AthenaAuthReactEmailComponent as C, type AthenaAuthReactEmailConfig as D, type AthenaAuthReactEmailEventPhase as E, type AthenaAuthReactEmailProps as F, type AthenaAuthReactEmailRenderEvent as G, type AthenaAuthReactEmailRenderInput as H, type AthenaAuthReactEmailRenderOptions as I, type AthenaAuthRequestInput as J, type AthenaAuthResetPasswordBinding as K, type AthenaAuthResult as L, type AthenaAuthRevokeSessionRequest as M, type AthenaAuthSdkClient as N, type AthenaAuthSearchOperator as O, type AthenaAuthSession as P, type AthenaAuthSessionResponse as Q, type AthenaAuthSessionRevokeBinding as R, type AthenaAuthSignInResponse as S, type AthenaAuthSignOutResponse as T, type AthenaAuthSocialRedirectResponse as U, type AthenaAuthStatusResponse as V, type AthenaAuthUser as W, type AthenaChangeEmailRequest as X, type AthenaChangePasswordRequest as Y, AthenaClient as Z, type AthenaClientBuilder as _, type AthenaAdminListUsersQuery as a, type AthenaStorageFileConfig as a$, type AthenaCreateClientAuthOptions as a0, type AthenaCreateClientConfig as a1, type AthenaCreateClientConfigWithStorage as a2, type AthenaCreateClientConfigWithStorageAndTypecheckedColumns as a3, type AthenaCreateClientConfigWithTypecheckedColumns as a4, type AthenaCreateClientOptions as a5, type AthenaCreateClientOptionsWithStorage as a6, type AthenaCreateClientOptionsWithStorageAndTypecheckedColumns as a7, type AthenaCreateClientOptionsWithTypecheckedColumns as a8, type AthenaCreateClientServiceUrlConfig as a9, type AthenaQueryTraceCallsite as aA, type AthenaQueryTraceEvent as aB, type AthenaQueryTraceOptions as aC, type AthenaRawQueryDebugAst as aD, type AthenaRelationSelectNode as aE, type AthenaResetPasswordRequest as aF, type AthenaResult as aG, type AthenaResultError as aH, type AthenaRpcBuilderStateAst as aI, type AthenaRpcDebugAst as aJ, type AthenaSdkClient as aK, type AthenaSdkClientWithAuth as aL, type AthenaSdkClientWithStorage as aM, type AthenaSelectDebugAst as aN, type AthenaSelectDebugTransport as aO, type AthenaSelectShape as aP, type AthenaSendVerificationEmailRequest as aQ, type AthenaSocialSignInRequest as aR, type AthenaStorageBinaryCallOptions as aS, type AthenaStorageCallOptions as aT, type AthenaStorageClientConfig as aU, type AthenaStorageEnv as aV, AthenaStorageError as aW, AthenaStorageErrorCode as aX, type AthenaStorageErrorDetails as aY, type AthenaStorageErrorHandler as aZ, type AthenaStorageErrorInput as a_, type AthenaDbModule as aa, type AthenaDeleteDebugAst as ab, type AthenaDeleteUserCallbackRequest as ac, type AthenaDeleteUserRequest as ad, type AthenaDeleteUserResponse as ae, type AthenaEmailSignInRequest as af, type AthenaEmailSignUpRequest as ag, type AthenaEnvelope as ah, AthenaError as ai, AthenaErrorCategory as aj, AthenaErrorCode as ak, type AthenaErrorInput as al, AthenaErrorKind as am, type AthenaFindManyDebugAst as an, type AthenaFindManyOptions as ao, type AthenaFindManyResult as ap, type AthenaForgetPasswordRequest as aq, type AthenaFromOptions as ar, AthenaGatewayError as as, type AthenaInsertDebugAst as at, type AthenaLinkSocialRequest as au, type AthenaOAuthAccountTokenRequest as av, type AthenaOAuthTokenBundle as aw, type AthenaOperationContext as ax, type AthenaOrderBy as ay, type AthenaQueryDebugAst as az, type AthenaAdminListUsersSearchOperator as b, assertInt as b$, type AthenaStorageFileDeleteInput as b0, type AthenaStorageFileDownloadInput as b1, type AthenaStorageFileListInput as b2, type AthenaStorageFileModule as b3, type AthenaStorageFileUploadInput as b4, type AthenaStorageFileUploadResult as b5, type AthenaStorageModule as b6, type AthenaStoragePathContext as b7, type AthenaStoragePrefixPath as b8, type AthenaStorageTemplateValue as b9, type ModelFormDefaults as bA, type ModelFormNullishMode as bB, type ModelFormValues as bC, type MoveStorageFolderRequest as bD, type NormalizedAthenaError as bE, type PresignedFileUrlResponse as bF, type RequireAffectedOptions as bG, type RetryBackoffStrategy as bH, type RetryConfig as bI, type RpcOrderOptions as bJ, type RpcQueryBuilder as bK, type S3CatalogItem as bL, type S3CredentialListItem as bM, type SetStorageFileVisibilityRequest as bN, type StorageBatchUploadUrlResponse as bO, type StorageFileAccessPurpose as bP, type StorageFileMutationResponse as bQ, type StorageFolderMutationResponse as bR, type StorageListFilesResponse as bS, type StorageUploadUrlResponse as bT, type TableQueryBuilder as bU, type ToModelFormDefaultsOptions as bV, type ToModelPayloadOptions as bW, type UnwrapOneOptions as bX, type UnwrapOptions as bY, type UpdateStorageCatalogRequest as bZ, type UpdateStorageFileRequest as b_, type AthenaStorageTemplateVars as ba, type AthenaStorageUploadConstraints as bb, type AthenaStorageUploadProgress as bc, type AthenaStorageUploadProgressHandler as bd, type AthenaStorageUploadSource as be, type AthenaStorageUploadedFile as bf, type AthenaTableBuilderStateAst as bg, type AthenaUnlinkAccountRequest as bh, type AthenaUpdateDebugAst as bi, type AthenaUpdateUserRequest as bj, type AthenaUpsertDebugAst as bk, type AthenaUsernameSignInRequest as bl, type AthenaVerifyEmailRequest as bm, type AthenaWhere as bn, type AthenaWhereBooleanOperand as bo, type AthenaWhereOperatorInput as bp, type CreateStorageCatalogRequest as bq, type CreateStorageUploadUrlRequest as br, type CreateStorageUploadUrlsRequest as bs, type DeleteStorageFolderRequest as bt, type FormValuesOf as bu, type GetStorageFileUrlQuery as bv, type IntCoercionOptions as bw, type ListStorageFilesRequest as bx, type ManagedFileRecord as by, type ModelFormAdapter as bz, type AthenaAuthAdminUserSessionRevokeBinding as c, coerceInt as c0, createAthenaStorageError as c1, createClient as c2, createModelFormAdapter as c3, getAthenaDebugAst as c4, isAthenaGatewayError as c5, isOk as c6, normalizeAthenaError as c7, parseBooleanFlag as c8, requireAffected as c9, requireSuccess as ca, storageSdkManifest as cb, toModelFormDefaults as cc, toModelPayload as cd, unwrap as ce, unwrapOne as cf, unwrapRows as cg, withRetry as ch, type AthenaAuthFetchCompatibleInput as ci, type AthenaAuthBindings as d, type AthenaAuthCallOptions as e, type AthenaAuthClientConfig as f, type AthenaAuthCredentials as g, type AthenaAuthEmailChangeResponse as h, type AthenaAuthEmailTemplateBuilder as i, type AthenaAuthEmailTemplateCreateFromDefinitionInput as j, type AthenaAuthEmailTemplateDefinition as k, type AthenaAuthEmailTemplateReactOverrides as l, type AthenaAuthEmailTemplateUpdateFromDefinitionInput as m, type AthenaAuthEndpointPath as n, type AthenaAuthErrorCode as o, type AthenaAuthErrorDetails as p, type AthenaAuthFilterOperator as q, type AthenaAuthGenericInput as r, type AthenaAuthGenericQueryInput as s, type AthenaAuthLinkedAccount as t, type AthenaAuthMethod as u, type AthenaAuthOrganization as v, type AthenaAuthOrganizationBindings as w, type AthenaAuthOrganizationInvitation as x, type AthenaAuthOrganizationMember as y, type AthenaAuthQueryPrimitive as z };

package/dist/{pipeline-BUsR9XlO.d.ts → pipeline-CkMnhwPI.d.ts}

@@ -1,4 +1,4 @@
-import { R as RunGeneratorOptions, l as RunGeneratorResult } from './types-t_TVqnmp.js';
+import { R as RunGeneratorOptions, o as RunGeneratorResult } from './types-BzY6fETM.js';
 
 /**
  * End-to-end generator execution: load config, introspect, render, and optionally write files.

package/dist/{pipeline-BfCWSRYl.d.cts → pipeline-D4sJRKqN.d.cts}

@@ -1,4 +1,4 @@
-import { R as RunGeneratorOptions, l as RunGeneratorResult } from './types-BSIsyss1.cjs';
+import { R as RunGeneratorOptions, o as RunGeneratorResult } from './types-CAtTGGoz.cjs';
 
 /**
  * End-to-end generator execution: load config, introspect, render, and optionally write files.