@xylex-group/athena 1.6.1 → 1.7.0

package/dist/index.d.cts

@@ -1,5 +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 './errors-C4GJaFI_.cjs';
-export { i as AthenaGatewayError, o as AthenaGatewayErrorCode, k as AthenaRpcFilter, l as AthenaRpcFilterOperator, m as AthenaRpcOrder, n as AthenaRpcPayload, h as Backend, j as isAthenaGatewayError } from './errors-C4GJaFI_.cjs';
+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';
 
 interface AthenaResult<T> {
     data: T | null;
@@ -314,185 +317,6 @@ interface SqlIdentifier {
  */
 declare function identifier(...segments: string[]): SqlIdentifier;
 
-type ModelKey = string;
-type ColumnKey = string;
-/**
- * Runtime values that can safely be serialized into tenant-scoped headers.
- */
-type TenantContextValue = string | number | boolean | null | undefined;
-/**
- * Compile-time map of tenant context keys to outbound header names.
- */
-type TenantKeyMap = Record<string, string>;
-/**
- * Partial tenant context keyed by `TenantKeyMap`.
- */
-type TenantContext<TMap extends TenantKeyMap> = Partial<Record<keyof TMap, TenantContextValue>>;
-/**
- * Supported relationship cardinalities for model metadata and introspection snapshots.
- */
-type ModelRelationKind = 'one-to-one' | 'one-to-many' | 'many-to-one' | 'many-to-many';
-/**
- * Base metadata shape shared by typed model definitions and introspection snapshots.
- * This type is intentionally row-agnostic so it can be used for generic registries.
- */
-interface ModelMetadataBase {
-    database?: string;
-    schema?: string;
-    model?: string;
-    tableName?: string;
-    primaryKey: string[];
-    nullable?: Partial<Record<string, boolean>>;
-    relations?: Record<string, ModelRelationMetadata>;
-}
-/**
- * Strongly-typed model metadata linked to a row shape.
- */
-type ModelMetadata<Row> = Omit<ModelMetadataBase, 'primaryKey' | 'nullable'> & {
-    primaryKey: Array<Extract<keyof Row, string>>;
-    nullable?: Partial<Record<Extract<keyof Row, string>, boolean>>;
-};
-/**
- * Relation metadata for model contracts and introspection snapshots.
- */
-interface ModelRelationMetadata {
-    kind: ModelRelationKind;
-    sourceColumns: ColumnKey[];
-    targetSchema: string;
-    targetModel: ModelKey;
-    targetColumns: ColumnKey[];
-    targetDatabase?: string;
-    through?: {
-        schema: string;
-        model: string;
-        sourceColumns: ColumnKey[];
-        targetColumns: ColumnKey[];
-    };
-}
-/**
- * Core model definition contract used by typed registries.
- */
-interface ModelDef<Row, Insert = Partial<Row>, Update = Partial<Insert>, Meta extends ModelMetadataBase = ModelMetadata<Row>> {
-    readonly meta: Meta;
-    readonly __types?: {
-        row: Row;
-        insert: Insert;
-        update: Update;
-    };
-}
-/**
- * Row-agnostic model definition used as a generic constraint.
- */
-type AnyModelDef = ModelDef<unknown, unknown, unknown, ModelMetadataBase>;
-/**
- * Schema-level model registry.
- */
-interface SchemaDef<Models extends Record<ModelKey, AnyModelDef>> {
-    readonly models: Models;
-}
-/**
- * Database-level schema registry.
- */
-interface DatabaseDef<Schemas extends Record<string, SchemaDef<Record<ModelKey, AnyModelDef>>>> {
-    readonly schemas: Schemas;
-}
-/**
- * Top-level registry keyed by logical database names.
- */
-type RegistryDef<Databases extends Record<string, DatabaseDef<Record<string, SchemaDef<Record<ModelKey, AnyModelDef>>>>>> = Databases;
-/**
- * Extracts row type from a model definition.
- */
-type RowOf<TModel extends AnyModelDef> = TModel extends ModelDef<infer TRow, unknown, unknown, ModelMetadataBase> ? TRow : never;
-/**
- * Extracts insert type from a model definition.
- */
-type InsertOf<TModel extends AnyModelDef> = TModel extends ModelDef<unknown, infer TInsert, unknown, ModelMetadataBase> ? TInsert : never;
-/**
- * Extracts update type from a model definition.
- */
-type UpdateOf<TModel extends AnyModelDef> = TModel extends ModelDef<unknown, unknown, infer TUpdate, ModelMetadataBase> ? TUpdate : never;
-/**
- * Resolves a model definition from a registry path.
- */
-type ModelAt<TRegistry extends RegistryDef<Record<string, DatabaseDef<Record<string, SchemaDef<Record<ModelKey, AnyModelDef>>>>>>, TDatabase extends keyof TRegistry & string, TSchema extends keyof TRegistry[TDatabase]['schemas'] & string, TModel extends keyof TRegistry[TDatabase]['schemas'][TSchema]['models'] & string> = TRegistry[TDatabase]['schemas'][TSchema]['models'][TModel];
-/**
- * Introspection-level column type families.
- */
-type IntrospectionTypeKind = 'scalar' | 'enum' | 'domain' | 'range' | 'multirange' | 'composite';
-/**
- * Introspected column metadata.
- */
-interface IntrospectionColumn {
-    name: string;
-    dataType: string;
-    udtName: string;
-    typeKind: IntrospectionTypeKind;
-    isNullable: boolean;
-    isPrimaryKey: boolean;
-    hasDefault: boolean;
-    isGenerated: boolean;
-    arrayDimensions: number;
-    enumValues?: string[];
-}
-/**
- * Introspected relationship metadata.
- */
-interface IntrospectionRelation {
-    name: string;
-    kind: ModelRelationKind;
-    sourceColumns: string[];
-    targetSchema: string;
-    targetModel: string;
-    targetColumns: string[];
-    targetDatabase?: string;
-    through?: {
-        schema: string;
-        model: string;
-        sourceColumns: string[];
-        targetColumns: string[];
-    };
-}
-/**
- * Introspected table metadata.
- */
-interface IntrospectionTable {
-    schema: string;
-    name: string;
-    columns: Record<string, IntrospectionColumn>;
-    primaryKey: string[];
-    relations: Record<string, IntrospectionRelation>;
-}
-/**
- * Introspected schema metadata.
- */
-interface IntrospectionSchema {
-    name: string;
-    tables: Record<string, IntrospectionTable>;
-}
-/**
- * Normalized output of a schema introspection pass.
- */
-interface IntrospectionSnapshot {
-    backend: BackendType;
-    database: string;
-    generatedAt: string;
-    schemas: Record<string, IntrospectionSchema>;
-}
-/**
- * Options accepted by introspection providers.
- */
-interface IntrospectionInspectOptions {
-    schemas?: string[];
-}
-/**
- * Provider contract implemented by backend-specific introspection adapters.
- */
-interface SchemaIntrospectionProvider {
-    readonly backend: BackendType;
-    inspect(options?: IntrospectionInspectOptions): Promise<IntrospectionSnapshot>;
-}
-
 /**
  * Declares a model contract with explicit metadata and typed row/insert/update shapes.
  */
@@ -541,163 +365,13 @@ declare function createTypedClient<TRegistry extends RegistryConstraint, TTenant
 interface PostgresIntrospectionProviderOptions {
     connectionString: string;
     database?: string;
+    schemas?: readonly string[];
 }
 /**
  * Creates a PostgreSQL-backed schema introspection provider.
  */
 declare function createPostgresIntrospectionProvider(options: PostgresIntrospectionProviderOptions): SchemaIntrospectionProvider;
 
-/**
- * Supported case transformations for generated symbols and path token variants.
- */
-type NamingStyle = 'preserve' | 'camel' | 'pascal' | 'snake' | 'kebab';
-/**
- * Naming configuration for generated TypeScript identifiers.
- */
-interface GeneratorNamingConfig {
-    modelType: NamingStyle;
-    modelConst: NamingStyle;
-    schemaConst: NamingStyle;
-    databaseConst: NamingStyle;
-    registryConst: NamingStyle;
-}
-/**
- * Stable feature flags for generator output behavior.
- */
-interface GeneratorFeatureFlags {
-    emitRelations: boolean;
-    emitRegistry: boolean;
-}
-/**
- * Experimental toggles for optional/forward-compatible generator behavior.
- */
-interface GeneratorExperimentalFlags {
-    /**
-     * Legacy compatibility toggle from the initial scaffold.
-     * Gateway introspection is now implemented; this flag is retained for additive config compatibility.
-     */
-    postgresGatewayIntrospection: boolean;
-    /**
-     * Enables contract placeholders for future Scylla provider work.
-     */
-    scyllaProviderContracts: boolean;
-}
-/**
- * Path templates for each generated artifact category.
- */
-interface GeneratorOutputTargets {
-    model: string;
-    schema: string;
-    database: string;
-    registry: string;
-}
-/**
- * Output configuration including dynamic placeholder aliases.
- */
-interface GeneratorOutputConfig {
-    targets: GeneratorOutputTargets;
-    placeholderMap: Record<string, string>;
-}
-/**
- * Direct PostgreSQL introspection mode (implemented).
- */
-interface PostgresDirectProviderConfig {
-    kind: 'postgres';
-    mode: 'direct';
-    connectionString: string;
-    database?: string;
-    schemas?: string[];
-}
-/**
- * Athena gateway-backed PostgreSQL introspection mode using `/gateway/query`.
- */
-interface PostgresGatewayProviderConfig {
-    kind: 'postgres';
-    mode: 'gateway';
-    gatewayUrl: string;
-    apiKey: string;
-    database: string;
-    schemas?: string[];
-    backend?: BackendType;
-}
-/**
- * Scylla introspection provider contract placeholder (phase-two scaffold).
- */
-interface ScyllaDirectProviderConfig {
-    kind: 'scylla';
-    mode: 'direct';
-    contactPoints: string[];
-    keyspace: string;
-    datacenter?: string;
-}
-type GeneratorProviderConfig = PostgresDirectProviderConfig | PostgresGatewayProviderConfig | ScyllaDirectProviderConfig;
-/**
- * Root config contract loaded from `athena.config.ts`.
- */
-interface AthenaGeneratorConfig {
-    provider: GeneratorProviderConfig;
-    output: GeneratorOutputConfig;
-    naming?: Partial<GeneratorNamingConfig>;
-    features?: Partial<GeneratorFeatureFlags>;
-    experimental?: Partial<GeneratorExperimentalFlags>;
-}
-/**
- * Normalized generator config with defaults applied.
- */
-interface NormalizedAthenaGeneratorConfig {
-    provider: GeneratorProviderConfig;
-    output: GeneratorOutputConfig;
-    naming: GeneratorNamingConfig;
-    features: GeneratorFeatureFlags;
-    experimental: GeneratorExperimentalFlags;
-}
-/**
- * Config loader options for CLI/programmatic usage.
- */
-interface LoadGeneratorConfigOptions {
-    cwd?: string;
-    configPath?: string;
-}
-/**
- * Fully loaded config result including resolved file path.
- */
-interface LoadedGeneratorConfig {
-    configPath: string;
-    config: NormalizedAthenaGeneratorConfig;
-}
-type GeneratorArtifactKind = 'model' | 'schema' | 'database' | 'registry';
-/**
- * One generated output file.
- */
-interface GeneratedArtifact {
-    kind: GeneratorArtifactKind;
-    path: string;
-    content: string;
-}
-/**
- * In-memory generator output payload.
- */
-interface GeneratedArtifacts {
-    snapshot: IntrospectionSnapshot;
-    files: GeneratedArtifact[];
-}
-/**
- * Runtime options for executing the generator pipeline.
- */
-interface RunGeneratorOptions {
-    cwd?: string;
-    configPath?: string;
-    dryRun?: boolean;
-    provider?: SchemaIntrospectionProvider;
-}
-/**
- * Generator execution result including files written to disk.
- */
-interface RunGeneratorResult extends GeneratedArtifacts {
-    configPath: string;
-    writtenFiles: string[];
-}
-
 declare function normalizeGeneratorConfig(input: AthenaGeneratorConfig): NormalizedAthenaGeneratorConfig;
 /**
  * Typed identity helper for authoring generator configs.
@@ -724,9 +398,266 @@ declare function resolvePostgresColumnType(column: IntrospectionColumn): string;
  */
 declare function resolveGeneratorProvider(providerConfig: GeneratorProviderConfig, experimentalFlags: GeneratorExperimentalFlags): SchemaIntrospectionProvider;
 
+declare const DEFAULT_POSTGRES_SCHEMAS: readonly ["public"];
 /**
- * End-to-end generator execution: load config, introspect, render, and optionally write files.
+ * 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 runSchemaGenerator(options?: RunGeneratorOptions): Promise<RunGeneratorResult>;
+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 { AthenaClient, AthenaConditionCastType, AthenaError, AthenaErrorCategory, AthenaErrorCode, type AthenaErrorInput, AthenaErrorKind, AthenaGatewayCallOptions, AthenaGatewayErrorDetails, type AthenaGeneratorConfig, type AthenaOperationContext, type AthenaResult, AthenaRpcCallOptions, type AthenaSdkClient, BackendConfig, BackendType, type DatabaseDef, type GeneratedArtifact, type GeneratedArtifacts, type GeneratorArtifactKind, type GeneratorExperimentalFlags, type GeneratorFeatureFlags, type GeneratorNamingConfig, type GeneratorOutputConfig, type GeneratorOutputTargets, type GeneratorProviderConfig, type InsertOf, type IntCoercionOptions, type IntrospectionColumn, type IntrospectionInspectOptions, type IntrospectionRelation, type IntrospectionSchema, type IntrospectionSnapshot, type IntrospectionTable, type IntrospectionTypeKind, type LoadGeneratorConfigOptions, type LoadedGeneratorConfig, type ModelAt, type ModelDef, type ModelMetadata, type ModelRelationKind, type ModelRelationMetadata, type NamingStyle, type NormalizedAthenaError, type NormalizedAthenaGeneratorConfig, type PostgresIntrospectionProviderOptions, type RegistryDef, type RequireAffectedOptions, type RetryBackoffStrategy, type RetryConfig, type RowOf, type RpcOrderOptions, type RpcQueryBuilder, type RunGeneratorOptions, type RunGeneratorResult, type SchemaDef, type SchemaIntrospectionProvider, type TableQueryBuilder, type TenantContext, type TenantContextValue, type TenantKeyMap, type TypedAthenaClient, type TypedClientOptions, type UnwrapOneOptions, type UnwrapOptions, type UpdateOf, assertInt, coerceInt, createClient, createPostgresIntrospectionProvider, createTypedClient, defineDatabase, defineGeneratorConfig, defineModel, defineRegistry, defineSchema, findGeneratorConfigPath, generateArtifactsFromSnapshot, identifier, isOk, loadGeneratorConfig, normalizeAthenaError, normalizeGeneratorConfig, requireAffected, requireSuccess, resolveGeneratorProvider, resolvePostgresColumnType, runSchemaGenerator, unwrap, unwrapOne, unwrapRows, withRetry };
+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 };