@xylex-group/athena 1.6.2 → 1.9.0

package/dist/index.d.cts

@@ -1,8 +1,8 @@
-import { A as AthenaGatewayCallOptions, a as AthenaConditionValue, b as AthenaConditionCastType, c as AthenaConditionArrayValue, d as AthenaConditionOperator, e as AthenaGatewayErrorDetails, f as AthenaRpcCallOptions, B as BackendConfig, g as BackendType } from './types-v6UyGg-x.cjs';
-export { m as AthenaGatewayErrorCode, i as AthenaRpcFilter, j as AthenaRpcFilterOperator, k as AthenaRpcOrder, l as AthenaRpcPayload, h as Backend } from './types-v6UyGg-x.cjs';
-export { A as AthenaGatewayError, i as isAthenaGatewayError } from './errors-BYRK5phv.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 } from './pipeline-CA2aexDl.cjs';
-export { u as GeneratedArtifact, v as GeneratorArtifactKind, w as GeneratorFeatureFlags, x as GeneratorNamingConfig, y as GeneratorOutputConfig, z as GeneratorOutputTargets, k as InsertOf, l as IntrospectionInspectOptions, m as IntrospectionRelation, n as IntrospectionSchema, o as IntrospectionTable, p as IntrospectionTypeKind, q as ModelRelationKind, s as ModelRelationMetadata, B as NamingStyle, C as RunGeneratorOptions, E as RunGeneratorResult, t as TenantContextValue, U as UpdateOf, r as runSchemaGenerator } from './pipeline-CA2aexDl.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';
+export { A as AthenaGatewayError, M as ModelFormAdapter, a as ModelFormDefaults, b as ModelFormNullishMode, c as ModelFormValues, T as ToModelFormDefaultsOptions, d as ToModelPayloadOptions, e as createModelFormAdapter, i as isAthenaGatewayError, t as toModelFormDefaults, f as toModelPayload } from './model-form-DkS48fsh.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 +13,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 +29,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,29 +87,29 @@ 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 AthenaClientBuilder {
@@ -352,7 +355,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.
@@ -365,6 +368,7 @@ declare function createTypedClient<TRegistry extends RegistryConstraint, TTenant
 interface PostgresIntrospectionProviderOptions {
     connectionString: string;
     database?: string;
+    schemas?: readonly string[];
 }
 /**
  * Creates a PostgreSQL-backed schema introspection provider.
@@ -397,4 +401,266 @@ declare function resolvePostgresColumnType(column: IntrospectionColumn): string;
  */
 declare function resolveGeneratorProvider(providerConfig: GeneratorProviderConfig, experimentalFlags: GeneratorExperimentalFlags): SchemaIntrospectionProvider;
 
-export { AthenaClient, AthenaConditionCastType, AthenaError, AthenaErrorCategory, AthenaErrorCode, type AthenaErrorInput, AthenaErrorKind, AthenaGatewayCallOptions, AthenaGatewayErrorDetails, AthenaGeneratorConfig, type AthenaOperationContext, type AthenaResult, AthenaRpcCallOptions, type AthenaSdkClient, BackendConfig, BackendType, DatabaseDef, GeneratedArtifacts, GeneratorExperimentalFlags, GeneratorProviderConfig, 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, createClient, createPostgresIntrospectionProvider, createTypedClient, defineDatabase, defineGeneratorConfig, defineModel, defineRegistry, defineSchema, findGeneratorConfigPath, generateArtifactsFromSnapshot, identifier, isOk, loadGeneratorConfig, normalizeAthenaError, normalizeGeneratorConfig, requireAffected, requireSuccess, resolveGeneratorProvider, resolvePostgresColumnType, unwrap, unwrapOne, unwrapRows, withRetry };
+declare const DEFAULT_POSTGRES_SCHEMAS: readonly ["public"];
+/**
+ * Normalizes schema selection from config or env-backed strings into a stable,
+ * deduplicated list. Empty selections fall back to PostgreSQL's public schema.
+ */
+declare function normalizeSchemaSelection(input: GeneratorSchemaSelection | undefined): string[];
+/**
+ * Resolves the effective schema list for provider-backed generator runs.
+ */
+declare function resolveProviderSchemas(providerConfig: GeneratorProviderConfig): string[];
+
+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>>;
+}
+
+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, AthenaJsonObject, AthenaJsonValue, 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, 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, requireAffected, requireSuccess, resolveGeneratorProvider, resolvePostgresColumnType, resolveProviderSchemas, unwrap, unwrapOne, unwrapRows, withRetry };