@xylex-group/athena 1.7.0 → 2.0.0

package/dist/index.d.cts

@@ -1,8 +1,9 @@
-import { B as BackendConfig, a as BackendType, A as AthenaConditionValue, b as AthenaConditionCastType, c as AthenaConditionArrayValue, d as AthenaConditionOperator, e as AthenaGatewayCallOptions, f as AthenaGatewayErrorDetails, g as AthenaRpcCallOptions } from './types-wPA1Z4vQ.cjs';
-export { h as AthenaGatewayErrorCode, i as AthenaRpcFilter, j as AthenaRpcFilterOperator, k as AthenaRpcOrder, l as AthenaRpcPayload, m as Backend } from './types-wPA1Z4vQ.cjs';
-export { A as AthenaGatewayError, i as isAthenaGatewayError } from './errors-BJGgjHcI.cjs';
-import { S as SchemaDef, A as AnyModelDef, D as DatabaseDef, M as ModelMetadata, a as ModelDef, R as RegistryDef, T as TenantKeyMap, b as TenantContext, c as RowOf, d as ModelAt, e as SchemaIntrospectionProvider, f as AthenaGeneratorConfig, L as LoadGeneratorConfigOptions, g as LoadedGeneratorConfig, N as NormalizedAthenaGeneratorConfig, I as IntrospectionSnapshot, G as GeneratedArtifacts, h as IntrospectionColumn, i as GeneratorProviderConfig, j as GeneratorExperimentalFlags, k as GeneratorSchemaSelection } from './pipeline-BsKuBqmE.cjs';
-export { l as GeneratedArtifact, m as GeneratorArtifactKind, n as GeneratorFeatureFlags, o as GeneratorNamingConfig, p as GeneratorOutputConfig, q as GeneratorOutputTargets, r as InsertOf, s as IntrospectionInspectOptions, t as IntrospectionRelation, u as IntrospectionSchema, v as IntrospectionTable, w as IntrospectionTypeKind, x as ModelRelationKind, y as ModelRelationMetadata, z as NamingStyle, B as RunGeneratorOptions, C as RunGeneratorResult, E as TenantContextValue, U as UpdateOf, F as runSchemaGenerator } from './pipeline-BsKuBqmE.cjs';
+import { B as BackendConfig, a as BackendType, A as AthenaJsonValue, b as AthenaConditionValue, c as AthenaConditionCastType, d as AthenaConditionArrayValue, e as AthenaConditionOperator, f as AthenaGatewayCallOptions, g as AthenaGatewayErrorDetails, h as AthenaJsonObject, i as AthenaRpcCallOptions, S as SchemaDef, j as AnyModelDef, D as DatabaseDef, M as ModelMetadata, k as ModelDef, R as RegistryDef, T as TenantKeyMap, l as TenantContext, m as RowOf, n as ModelAt, I as InsertOf, U as UpdateOf, o as SchemaIntrospectionProvider, p as IntrospectionSnapshot, q as IntrospectionColumn } from './types-BnzoaNRC.cjs';
+export { r as AthenaGatewayErrorCode, s as AthenaJsonArray, t as AthenaJsonPrimitive, u as AthenaRpcFilter, v as AthenaRpcFilterOperator, w as AthenaRpcOrder, x as AthenaRpcPayload, y as Backend, z as IntrospectionInspectOptions, C as IntrospectionRelation, E as IntrospectionSchema, F as IntrospectionTable, G as IntrospectionTypeKind, H as ModelRelationKind, J as ModelRelationMetadata, K as TenantContextValue } from './types-BnzoaNRC.cjs';
+import { A as AthenaAuthBindings, a as AthenaAuthClientConfig, b as AthenaAuthSdkClient } from './model-form-hXkvHS_3.cjs';
+export { c as AthenaAuthAdminUserSessionRevokeBinding, d as AthenaAuthCallOptions, e as AthenaAuthCredentials, f as AthenaAuthEmailChangeResponse, g as AthenaAuthEndpointPath, h as AthenaAuthErrorCode, i as AthenaAuthErrorDetails, j as AthenaAuthGenericInput, k as AthenaAuthGenericQueryInput, l as AthenaAuthLinkedAccount, m as AthenaAuthMethod, n as AthenaAuthOrganization, o as AthenaAuthOrganizationBindings, p as AthenaAuthOrganizationInvitation, q as AthenaAuthOrganizationMember, r as AthenaAuthQueryPrimitive, s as AthenaAuthQueryValue, t as AthenaAuthRequestInput, u as AthenaAuthResetPasswordBinding, v as AthenaAuthResult, w as AthenaAuthRevokeSessionRequest, x as AthenaAuthSession, y as AthenaAuthSessionResponse, z as AthenaAuthSessionRevokeBinding, B as AthenaAuthSignInResponse, C as AthenaAuthSignOutResponse, D as AthenaAuthSocialRedirectResponse, E as AthenaAuthStatusResponse, F as AthenaAuthUser, G as AthenaChangeEmailRequest, H as AthenaChangePasswordRequest, I as AthenaDeleteUserCallbackRequest, J as AthenaDeleteUserRequest, K as AthenaDeleteUserResponse, L as AthenaEmailSignInRequest, M as AthenaEmailSignUpRequest, N as AthenaForgetPasswordRequest, O as AthenaGatewayError, P as AthenaLinkSocialRequest, Q as AthenaOAuthAccountTokenRequest, R as AthenaOAuthTokenBundle, S as AthenaResetPasswordRequest, T as AthenaSendVerificationEmailRequest, U as AthenaSocialSignInRequest, V as AthenaUnlinkAccountRequest, W as AthenaUpdateUserRequest, X as AthenaUsernameSignInRequest, Y as AthenaVerifyEmailRequest, Z as ModelFormAdapter, _ as ModelFormDefaults, $ as ModelFormNullishMode, a0 as ModelFormValues, a1 as ToModelFormDefaultsOptions, a2 as ToModelPayloadOptions, a3 as createModelFormAdapter, a4 as isAthenaGatewayError, a5 as toModelFormDefaults, a6 as toModelPayload } from './model-form-hXkvHS_3.cjs';
+import { A as AthenaGeneratorConfig, L as LoadGeneratorConfigOptions, a as LoadedGeneratorConfig, N as NormalizedAthenaGeneratorConfig, G as GeneratedArtifacts, b as GeneratorProviderConfig, c as GeneratorExperimentalFlags, d as GeneratorSchemaSelection } from './pipeline-C-cN0ACi.cjs';
+export { e as GeneratedArtifact, f as GeneratorArtifactKind, g as GeneratorFeatureFlags, h as GeneratorNamingConfig, i as GeneratorOutputConfig, j as GeneratorOutputTargets, k as NamingStyle, R as RunGeneratorOptions, l as RunGeneratorResult, r as runSchemaGenerator } from './pipeline-C-cN0ACi.cjs';
 
 interface AthenaResult<T> {
     data: T | null;
@@ -13,6 +14,9 @@ interface AthenaResult<T> {
     raw: 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>>;
@@ -26,39 +30,39 @@ interface OrderOptions {
     ascending?: boolean;
 }
 /** Shared filter chain - supports eq, limit, etc. in any order relative to select/update */
-interface FilterChain<Self> {
-    eq(column: string, value: AthenaConditionValue): Self;
-    eqCast(column: string, value: AthenaConditionValue, cast: AthenaConditionCastType): Self;
-    eqUuid(column: string, value: string): Self;
-    match(filters: Record<string, AthenaConditionValue>): Self;
+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: string, options?: OrderOptions): 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;
-    neq(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;
-    contains(column: string, values: AthenaConditionArrayValue): Self;
-    containedBy(column: string, values: AthenaConditionArrayValue): Self;
-    not(columnOrExpression: string, operator?: AthenaConditionOperator, value?: AthenaConditionValue): 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> extends FilterChain<SelectChain<Row>>, PromiseLike<AthenaResult<Row[]>> {
-    single<T = Row>(columns?: string | string[], options?: AthenaGatewayCallOptions): Promise<AthenaResult<T | null>>;
-    maybeSingle<T = Row>(columns?: string | string[], options?: AthenaGatewayCallOptions): Promise<AthenaResult<T | null>>;
+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>>, MutationQuery<Row[]> {
+interface UpdateChain<Row> extends FilterChain<UpdateChain<Row>, Row>, MutationQuery<Row[]> {
 }
 interface RpcFilterChain<Self> {
     eq(column: string, value: AthenaConditionValue): Self;
@@ -84,31 +88,34 @@ interface RpcQueryBuilder<Row> extends RpcFilterChain<RpcQueryBuilder<Row>>, Pro
     offset(count: number): RpcQueryBuilder<Row>;
     range(from: number, to: number): RpcQueryBuilder<Row>;
 }
-interface TableQueryBuilder<Row> extends FilterChain<TableQueryBuilder<Row>> {
-    select<T = Row>(columns?: string | string[], options?: AthenaGatewayCallOptions): SelectChain<T>;
-    insert(values: Row, options?: AthenaGatewayCallOptions): MutationQuery<Row>;
-    insert(values: Row[], options?: AthenaGatewayCallOptions): MutationQuery<Row[]>;
-    upsert(values: Row, options?: AthenaGatewayCallOptions & {
-        updateBody?: Partial<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: Row[], options?: AthenaGatewayCallOptions & {
-        updateBody?: Partial<Row>;
+    upsert(values: Insert[], options?: AthenaGatewayCallOptions & {
+        updateBody?: Update;
         onConflict?: string | string[];
     }): MutationQuery<Row[]>;
-    update(values: Partial<Row>, options?: AthenaGatewayCallOptions): UpdateChain<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>;
+    reset(): TableQueryBuilder<Row, Insert, Update>;
 }
 interface AthenaSdkClient {
-    from<Row = unknown>(table: string): TableQueryBuilder<Row>;
-    rpc<Row = unknown, Args extends Record<string, unknown> = Record<string, unknown>>(fn: string, args?: Args, options?: AthenaRpcCallOptions): RpcQueryBuilder<Row>;
+    from<Row = AthenaRowShape, Insert = Partial<Row>, Update = Partial<Insert>>(table: string): TableQueryBuilder<Row, Insert, Update>;
+    rpc<Row = unknown, Args extends AthenaJsonObject = AthenaJsonObject>(fn: string, args?: Args, options?: AthenaRpcCallOptions): RpcQueryBuilder<Row>;
     query<Row = unknown>(query: string, options?: AthenaGatewayCallOptions): Promise<AthenaResult<Row[]>>;
 }
+interface AthenaSdkClientWithAuth extends AthenaSdkClient {
+    auth: AthenaAuthBindings;
+}
 interface AthenaClientBuilder {
     /** Set the gateway base URL. */
     url(url: string): AthenaClientBuilder;
@@ -123,17 +130,20 @@ interface AthenaClientBuilder {
     /** Enable or disable health tracking metadata. */
     healthTracking(enabled: boolean): AthenaClientBuilder;
     /** Build the immutable Athena SDK client. */
-    build(): AthenaSdkClient;
+    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(): AthenaSdkClient;
+    static fromEnvironment(): AthenaSdkClientWithAuth;
+}
+interface AthenaCreateClientOptions extends Pick<AthenaGatewayCallOptions, 'client' | 'headers' | 'backend'> {
+    auth?: AthenaAuthClientConfig;
 }
 /** Create client (convenience wrapper; use AthenaClient.builder() for full control) */
-declare function createClient(url: string, apiKey: string, options?: Pick<AthenaGatewayCallOptions, 'client' | 'headers' | 'backend'>): AthenaSdkClient;
+declare function createClient(url: string, apiKey: string, options?: AthenaCreateClientOptions): AthenaSdkClientWithAuth;
 
 type AthenaErrorKind = 'unique_violation' | 'not_found' | 'validation' | 'auth' | 'rate_limit' | 'transient' | 'unknown';
 declare const AthenaErrorKind: {
@@ -218,6 +228,12 @@ interface RetryConfig {
 interface RequireAffectedOptions {
     min?: number;
 }
+/**
+ * Parses a string-based boolean flag with a deterministic fallback.
+ *
+ * Accepts common truthy/falsey token variants used by env vars and CLI flags.
+ */
+declare function parseBooleanFlag(rawValue: string | undefined, fallback: boolean): boolean;
 declare class AthenaError extends Error {
     readonly code: AthenaErrorCode;
     readonly kind: AthenaErrorKind;
@@ -352,7 +368,7 @@ 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>>>;
+    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>>>;
 }
 /**
  * Creates a typed client bound to a registry contract and optional tenant header mapping.
@@ -409,255 +425,9 @@ declare function normalizeSchemaSelection(input: GeneratorSchemaSelection | unde
  */
 declare function resolveProviderSchemas(providerConfig: GeneratorProviderConfig): string[];
 
-type AthenaAuthMethod = 'GET' | 'POST';
-type AthenaAuthCredentials = 'omit' | 'same-origin' | 'include';
-type AthenaAuthQueryPrimitive = string | number | boolean;
-type AthenaAuthQueryValue = AthenaAuthQueryPrimitive | AthenaAuthQueryPrimitive[] | null | undefined;
-type AthenaAuthEndpointPath = '/sign-in/social' | '/sign-in/email' | '/sign-in/username' | '/sign-up/email' | '/get-session' | '/sign-out' | '/forget-password' | '/reset-password' | '/verify-email' | '/send-verification-email' | '/change-email' | '/change-password' | '/update-user' | '/delete-user' | '/delete-user/callback' | '/list-sessions' | '/revoke-session' | '/revoke-sessions' | '/revoke-other-sessions' | '/link-social' | '/list-accounts' | '/unlink-account' | '/refresh-token' | '/get-access-token' | '/ok' | '/error' | `/reset-password/${string}`;
-type AthenaAuthErrorCode = 'NETWORK_ERROR' | 'HTTP_ERROR' | 'INVALID_JSON' | 'UNKNOWN_ERROR';
-interface AthenaAuthErrorDetails {
-    code: AthenaAuthErrorCode;
-    message: string;
-    status: number;
-    endpoint?: AthenaAuthEndpointPath;
-    method?: AthenaAuthMethod;
-    requestId?: string;
-    hint?: string;
-    cause?: string;
-}
-interface AthenaAuthResult<T = unknown> {
-    ok: boolean;
-    status: number;
-    data: T | null;
-    error: string | null;
-    errorDetails?: AthenaAuthErrorDetails | null;
-    raw: unknown;
-}
-interface AthenaAuthUser {
-    id: string;
-    email: string;
-    name?: string | null;
-    image?: string | null;
-    emailVerified?: boolean;
-    createdAt?: string;
-    updatedAt?: string;
-    username?: string | null;
-    displayUsername?: string | null;
-    twoFactorEnabled?: boolean;
-    role?: string | null;
-    banned?: boolean;
-    banReason?: string | null;
-    banExpires?: string | null;
-}
-interface AthenaAuthSession {
-    id: string;
-    expiresAt?: string;
-    token?: string;
-    createdAt?: string;
-    updatedAt?: string;
-    ipAddress?: string | null;
-    userAgent?: string | null;
-    userId?: string;
-    impersonatedBy?: string | null;
-    activeOrganizationId?: string | null;
-}
-interface AthenaAuthSessionResponse {
-    session: AthenaAuthSession;
-    user: AthenaAuthUser;
-}
-interface AthenaEmailSignInRequest {
-    email: string;
-    password: string;
-    callbackURL?: string;
-    rememberMe?: boolean;
-}
-interface AthenaUsernameSignInRequest {
-    username: string;
-    password: string;
-    rememberMe?: boolean;
-}
-interface AthenaSocialSignInRequest {
-    provider: string;
-    callbackURL?: string;
-    newUserCallbackURL?: string;
-    errorCallbackURL?: string;
-    disableRedirect?: boolean;
-    idToken?: string;
-    scopes?: string[] | string;
-    requestSignUp?: boolean;
-    loginHint?: string;
-}
-interface AthenaEmailSignUpRequest {
-    name: string;
-    email: string;
-    password: string;
-    callbackURL?: string;
-}
-interface AthenaAuthSignInResponse {
-    redirect: false;
-    token: string;
-    url?: string | null;
-    user: AthenaAuthUser;
-}
-interface AthenaAuthSocialRedirectResponse {
-    url: string;
-    redirect: boolean;
-}
-interface AthenaAuthSignOutResponse {
-    success: boolean;
-}
-interface AthenaAuthStatusResponse {
-    status: boolean;
-}
-interface AthenaAuthRevokeSessionRequest {
-    token: string;
-}
-interface AthenaForgetPasswordRequest {
-    email: string;
-    redirectTo?: string;
-}
-interface AthenaResetPasswordRequest {
-    newPassword: string;
-    token?: string;
-}
-interface AthenaVerifyEmailRequest {
-    token: string;
-    callbackURL?: string;
-}
-interface AthenaSendVerificationEmailRequest {
-    email: string;
-    callbackURL?: string;
-}
-interface AthenaChangeEmailRequest {
-    newEmail: string;
-    callbackURL?: string;
-}
-interface AthenaChangePasswordRequest {
-    newPassword: string;
-    currentPassword: string;
-    revokeOtherSessions?: boolean;
-}
-interface AthenaUpdateUserRequest {
-    name?: string;
-    image?: string;
-}
-interface AthenaDeleteUserRequest {
-    callbackURL?: string;
-    password?: string;
-    token?: string;
-}
-interface AthenaDeleteUserCallbackRequest {
-    token?: string;
-    callbackURL?: string;
-}
-interface AthenaDeleteUserResponse {
-    success: boolean;
-    message?: string;
-}
-interface AthenaAuthEmailChangeResponse {
-    status: boolean;
-    message?: string | null;
-}
-interface AthenaLinkSocialRequest {
-    provider: string;
-    callbackURL?: string;
-    scopes?: string[] | string;
-}
-interface AthenaUnlinkAccountRequest {
-    providerId: string;
-    accountId?: string;
-}
-interface AthenaOAuthAccountTokenRequest {
-    providerId: string;
-    accountId?: string;
-    userId?: string;
-}
-interface AthenaOAuthTokenBundle {
-    tokenType?: string;
-    idToken?: string;
-    accessToken?: string;
-    refreshToken?: string;
-    accessTokenExpiresAt?: string;
-    refreshTokenExpiresAt?: string;
-}
-interface AthenaAuthLinkedAccount {
-    id: string;
-    provider?: string;
-    accountId?: string;
-    scopes?: string[];
-    createdAt?: string;
-    updatedAt?: string;
-}
-interface AthenaAuthRequestInput {
-    endpoint: AthenaAuthEndpointPath;
-    method?: AthenaAuthMethod;
-    body?: unknown;
-    query?: Record<string, AthenaAuthQueryValue>;
-    fetchOptions?: AthenaAuthCallOptions;
-}
-interface AthenaAuthCallOptions {
-    baseUrl?: string;
-    apiKey?: string;
-    bearerToken?: string;
-    headers?: Record<string, string>;
-    credentials?: AthenaAuthCredentials;
-    signal?: AbortSignal;
-}
-interface AthenaAuthFetchCompatibleInput {
-    fetchOptions?: AthenaAuthCallOptions;
-}
-interface AthenaAuthClientConfig extends AthenaAuthCallOptions {
-    fetch?: typeof fetch;
-}
-interface AthenaAuthSdkClient {
-    baseUrl: string;
-    request: <T = unknown>(input: AthenaAuthRequestInput, options?: AthenaAuthCallOptions) => Promise<AthenaAuthResult<T>>;
-    signIn: {
-        email: (input: AthenaEmailSignInRequest & AthenaAuthFetchCompatibleInput, options?: AthenaAuthCallOptions) => Promise<AthenaAuthResult<AthenaAuthSignInResponse>>;
-        username: (input: AthenaUsernameSignInRequest & AthenaAuthFetchCompatibleInput, options?: AthenaAuthCallOptions) => Promise<AthenaAuthResult<AthenaAuthSignInResponse>>;
-        social: (input: AthenaSocialSignInRequest & AthenaAuthFetchCompatibleInput, options?: AthenaAuthCallOptions) => Promise<AthenaAuthResult<AthenaAuthSocialRedirectResponse | AthenaAuthSignInResponse>>;
-    };
-    signUp: {
-        email: (input: AthenaEmailSignUpRequest & AthenaAuthFetchCompatibleInput, options?: AthenaAuthCallOptions) => Promise<AthenaAuthResult<AthenaAuthSignInResponse>>;
-    };
-    signOut: (input?: AthenaAuthFetchCompatibleInput, options?: AthenaAuthCallOptions) => Promise<AthenaAuthResult<AthenaAuthSignOutResponse>>;
-    logout: (input?: AthenaAuthFetchCompatibleInput, options?: AthenaAuthCallOptions) => Promise<AthenaAuthResult<AthenaAuthSignOutResponse>>;
-    getSession: (input?: AthenaAuthFetchCompatibleInput, options?: AthenaAuthCallOptions) => Promise<AthenaAuthResult<AthenaAuthSessionResponse>>;
-    listSessions: (input?: AthenaAuthFetchCompatibleInput, options?: AthenaAuthCallOptions) => Promise<AthenaAuthResult<AthenaAuthSession[]>>;
-    revokeSession: (input: AthenaAuthRevokeSessionRequest & AthenaAuthFetchCompatibleInput, options?: AthenaAuthCallOptions) => Promise<AthenaAuthResult<AthenaAuthStatusResponse>>;
-    clearSession: (input: AthenaAuthRevokeSessionRequest & AthenaAuthFetchCompatibleInput, options?: AthenaAuthCallOptions) => Promise<AthenaAuthResult<AthenaAuthStatusResponse>>;
-    revokeSessions: (input?: AthenaAuthFetchCompatibleInput, options?: AthenaAuthCallOptions) => Promise<AthenaAuthResult<AthenaAuthStatusResponse>>;
-    clearSessions: (input?: AthenaAuthFetchCompatibleInput, options?: AthenaAuthCallOptions) => Promise<AthenaAuthResult<AthenaAuthStatusResponse>>;
-    revokeOtherSessions: (input?: AthenaAuthFetchCompatibleInput, options?: AthenaAuthCallOptions) => Promise<AthenaAuthResult<AthenaAuthStatusResponse>>;
-    clearOtherSessions: (input?: AthenaAuthFetchCompatibleInput, options?: AthenaAuthCallOptions) => Promise<AthenaAuthResult<AthenaAuthStatusResponse>>;
-    forgetPassword: (input: AthenaForgetPasswordRequest & AthenaAuthFetchCompatibleInput, options?: AthenaAuthCallOptions) => Promise<AthenaAuthResult<AthenaAuthStatusResponse>>;
-    resetPassword: (input: AthenaResetPasswordRequest & AthenaAuthFetchCompatibleInput, options?: AthenaAuthCallOptions) => Promise<AthenaAuthResult<AthenaAuthStatusResponse>>;
-    resolveResetPasswordToken: (input: {
-        token: string;
-        callbackURL?: string;
-    } & AthenaAuthFetchCompatibleInput, options?: AthenaAuthCallOptions) => Promise<AthenaAuthResult<{
-        token?: string;
-    }>>;
-    verifyEmail: (input: AthenaVerifyEmailRequest & AthenaAuthFetchCompatibleInput, options?: AthenaAuthCallOptions) => Promise<AthenaAuthResult<{
-        user: AthenaAuthUser;
-        status: boolean;
-    }>>;
-    sendVerificationEmail: (input: AthenaSendVerificationEmailRequest & AthenaAuthFetchCompatibleInput, options?: AthenaAuthCallOptions) => Promise<AthenaAuthResult<AthenaAuthStatusResponse>>;
-    changeEmail: (input: AthenaChangeEmailRequest & AthenaAuthFetchCompatibleInput, options?: AthenaAuthCallOptions) => Promise<AthenaAuthResult<AthenaAuthEmailChangeResponse>>;
-    changePassword: (input: AthenaChangePasswordRequest & AthenaAuthFetchCompatibleInput, options?: AthenaAuthCallOptions) => Promise<AthenaAuthResult<{
-        token?: string | null;
-        user: AthenaAuthUser;
-    }>>;
-    updateUser: (input: AthenaUpdateUserRequest & AthenaAuthFetchCompatibleInput, options?: AthenaAuthCallOptions) => Promise<AthenaAuthResult<AthenaAuthStatusResponse>>;
-    deleteUser: (input?: AthenaDeleteUserRequest & AthenaAuthFetchCompatibleInput, options?: AthenaAuthCallOptions) => Promise<AthenaAuthResult<AthenaDeleteUserResponse>>;
-    deleteUserCallback: (input?: AthenaDeleteUserCallbackRequest & AthenaAuthFetchCompatibleInput, options?: AthenaAuthCallOptions) => Promise<AthenaAuthResult<AthenaDeleteUserResponse>>;
-    linkSocial: (input: AthenaLinkSocialRequest & AthenaAuthFetchCompatibleInput, options?: AthenaAuthCallOptions) => Promise<AthenaAuthResult<AthenaAuthSocialRedirectResponse>>;
-    listAccounts: (input?: AthenaAuthFetchCompatibleInput, options?: AthenaAuthCallOptions) => Promise<AthenaAuthResult<AthenaAuthLinkedAccount[]>>;
-    unlinkAccount: (input: AthenaUnlinkAccountRequest & AthenaAuthFetchCompatibleInput, options?: AthenaAuthCallOptions) => Promise<AthenaAuthResult<AthenaAuthStatusResponse>>;
-    refreshToken: (input: AthenaOAuthAccountTokenRequest & AthenaAuthFetchCompatibleInput, options?: AthenaAuthCallOptions) => Promise<AthenaAuthResult<AthenaOAuthTokenBundle>>;
-    getAccessToken: (input: AthenaOAuthAccountTokenRequest & AthenaAuthFetchCompatibleInput, options?: AthenaAuthCallOptions) => Promise<AthenaAuthResult<AthenaOAuthTokenBundle>>;
-}
-
+/**
+ * @deprecated Prefer `createClient(...).auth` from `@xylex-group/athena`.
+ */
 declare function createAuthClient(config?: AthenaAuthClientConfig): AthenaAuthSdkClient;
 
-export { type AthenaAuthCallOptions, type AthenaAuthClientConfig, type AthenaAuthCredentials, type AthenaAuthEmailChangeResponse, type AthenaAuthEndpointPath, type AthenaAuthErrorCode, type AthenaAuthErrorDetails, type AthenaAuthLinkedAccount, type AthenaAuthMethod, type AthenaAuthQueryPrimitive, type AthenaAuthQueryValue, type AthenaAuthRequestInput, type AthenaAuthResult, type AthenaAuthRevokeSessionRequest, type AthenaAuthSdkClient, type AthenaAuthSession, type AthenaAuthSessionResponse, type AthenaAuthSignInResponse, type AthenaAuthSignOutResponse, type AthenaAuthSocialRedirectResponse, type AthenaAuthStatusResponse, type AthenaAuthUser, type AthenaChangeEmailRequest, type AthenaChangePasswordRequest, AthenaClient, AthenaConditionCastType, type AthenaDeleteUserCallbackRequest, type AthenaDeleteUserRequest, type AthenaDeleteUserResponse, type AthenaEmailSignInRequest, type AthenaEmailSignUpRequest, AthenaError, AthenaErrorCategory, AthenaErrorCode, type AthenaErrorInput, AthenaErrorKind, type AthenaForgetPasswordRequest, AthenaGatewayCallOptions, AthenaGatewayErrorDetails, AthenaGeneratorConfig, type AthenaLinkSocialRequest, type AthenaOAuthAccountTokenRequest, type AthenaOAuthTokenBundle, type AthenaOperationContext, type AthenaResetPasswordRequest, type AthenaResult, AthenaRpcCallOptions, type AthenaSdkClient, type AthenaSendVerificationEmailRequest, type AthenaSocialSignInRequest, type AthenaUnlinkAccountRequest, type AthenaUpdateUserRequest, type AthenaUsernameSignInRequest, type AthenaVerifyEmailRequest, BackendConfig, BackendType, DEFAULT_POSTGRES_SCHEMAS, DatabaseDef, GeneratedArtifacts, GeneratorExperimentalFlags, GeneratorProviderConfig, GeneratorSchemaSelection, type IntCoercionOptions, IntrospectionColumn, IntrospectionSnapshot, LoadGeneratorConfigOptions, LoadedGeneratorConfig, ModelAt, ModelDef, ModelMetadata, type NormalizedAthenaError, NormalizedAthenaGeneratorConfig, type PostgresIntrospectionProviderOptions, RegistryDef, type RequireAffectedOptions, type RetryBackoffStrategy, type RetryConfig, RowOf, type RpcOrderOptions, type RpcQueryBuilder, SchemaDef, SchemaIntrospectionProvider, type TableQueryBuilder, TenantContext, TenantKeyMap, type TypedAthenaClient, type TypedClientOptions, type UnwrapOneOptions, type UnwrapOptions, assertInt, coerceInt, createAuthClient, createClient, createPostgresIntrospectionProvider, createTypedClient, defineDatabase, defineGeneratorConfig, defineModel, defineRegistry, defineSchema, findGeneratorConfigPath, generateArtifactsFromSnapshot, identifier, isOk, loadGeneratorConfig, normalizeAthenaError, normalizeGeneratorConfig, normalizeSchemaSelection, requireAffected, requireSuccess, resolveGeneratorProvider, resolvePostgresColumnType, resolveProviderSchemas, unwrap, unwrapOne, unwrapRows, withRetry };
+export { AthenaAuthBindings, AthenaAuthClientConfig, AthenaAuthSdkClient, AthenaClient, AthenaConditionCastType, type AthenaCreateClientOptions, AthenaError, AthenaErrorCategory, AthenaErrorCode, type AthenaErrorInput, AthenaErrorKind, AthenaGatewayCallOptions, AthenaGatewayErrorDetails, AthenaGeneratorConfig, AthenaJsonObject, AthenaJsonValue, type AthenaOperationContext, type AthenaResult, AthenaRpcCallOptions, type AthenaSdkClient, type AthenaSdkClientWithAuth, BackendConfig, BackendType, DEFAULT_POSTGRES_SCHEMAS, DatabaseDef, GeneratedArtifacts, GeneratorExperimentalFlags, GeneratorProviderConfig, GeneratorSchemaSelection, InsertOf, type IntCoercionOptions, IntrospectionColumn, IntrospectionSnapshot, LoadGeneratorConfigOptions, LoadedGeneratorConfig, ModelAt, ModelDef, ModelMetadata, type NormalizedAthenaError, NormalizedAthenaGeneratorConfig, type PostgresIntrospectionProviderOptions, RegistryDef, type RequireAffectedOptions, type RetryBackoffStrategy, type RetryConfig, RowOf, type RpcOrderOptions, type RpcQueryBuilder, SchemaDef, SchemaIntrospectionProvider, type TableQueryBuilder, TenantContext, TenantKeyMap, type TypedAthenaClient, type TypedClientOptions, type UnwrapOneOptions, type UnwrapOptions, UpdateOf, assertInt, coerceInt, createAuthClient, createClient, createPostgresIntrospectionProvider, createTypedClient, defineDatabase, defineGeneratorConfig, defineModel, defineRegistry, defineSchema, findGeneratorConfigPath, generateArtifactsFromSnapshot, identifier, isOk, loadGeneratorConfig, normalizeAthenaError, normalizeGeneratorConfig, normalizeSchemaSelection, parseBooleanFlag, requireAffected, requireSuccess, resolveGeneratorProvider, resolvePostgresColumnType, resolveProviderSchemas, unwrap, unwrapOne, unwrapRows, withRetry };