@xylex-group/athena 2.6.0 → 2.8.0

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

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

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

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

package/dist/react-email-DZhDDlEl.d.cts

@@ -0,0 +1,417 @@
+import { b as AthenaGatewayConnectionOptions, c as AthenaGatewayConnectionResult, J as SchemaDef, N as AnyModelDef, D as DatabaseDef, E as ModelMetadata, C as ModelDef, R as RegistryDef, y as ModelColumnKind, L as TenantKeyMap, T as TenantContext, H as RowOf, M as ModelAt, r as InsertOf, U as UpdateOf, a as AthenaGatewayCallOptions, S as SchemaIntrospectionProvider, s as IntrospectionColumn } from './types-vikz9YIO.cjs';
+import { bB as ModelFormNullishMode, bC as ModelFormValues, aK as AthenaSdkClient, bU as TableQueryBuilder, $ as AthenaClientExperimentalOptions, f as AthenaAuthClientConfig, N as AthenaAuthSdkClient, F as AthenaAuthReactEmailProps, C as AthenaAuthReactEmailComponent, H as AthenaAuthReactEmailRenderInput, k as AthenaAuthEmailTemplateDefinition, i as AthenaAuthEmailTemplateBuilder, I as AthenaAuthReactEmailRenderOptions, G as AthenaAuthReactEmailRenderEvent, D as AthenaAuthReactEmailConfig } from './model-form-DMed05gE.cjs';
+import { ZodType } from 'zod';
+import { l as GeneratorSchemaSelection, b as GeneratorProviderConfig } from './types-CAtTGGoz.cjs';
+import { A as AthenaCookiesOptions, a as AthenaSessionPair, b as AthenaCookieOptions, c as AthenaAuthCookies, g as getCookieCache, d as getSessionCookie, e as AthenaCookieContextRuntime } from './index-CVcQCGyG.cjs';
+
+declare function verifyAthenaGatewayUrl(baseUrl: string, options?: AthenaGatewayConnectionOptions): Promise<AthenaGatewayConnectionResult>;
+
+interface NormalizeAthenaGatewayBaseUrlOptions {
+    defaultBaseUrl?: string;
+    label?: string;
+}
+declare function normalizeAthenaGatewayBaseUrl(input: string | null | undefined, options?: NormalizeAthenaGatewayBaseUrlOptions): string;
+
+/**
+ * Immutable identifier object with consistent SQL rendering.
+ */
+interface SqlIdentifier {
+    readonly segments: string[];
+    toSql(): string;
+    toString(): string;
+}
+/**
+ * Creates a quoted identifier object from segment or dotted inputs.
+ */
+declare function identifier(...segments: string[]): SqlIdentifier;
+
+/**
+ * Declares a model contract with explicit metadata and typed row/insert/update shapes.
+ */
+declare function defineModel<Row, Insert = Partial<Row>, Update = Partial<Insert>, Meta extends ModelMetadata<Row> = ModelMetadata<Row>>(input: {
+    meta: Meta;
+}): ModelDef<Row, Insert, Update, Meta>;
+/**
+ * Declares a schema-level model map.
+ */
+declare function defineSchema<Models extends Record<string, AnyModelDef>>(models: Models): SchemaDef<Models>;
+/**
+ * Declares a database-level schema map.
+ */
+declare function defineDatabase<Schemas extends Record<string, SchemaDef<Record<string, AnyModelDef>>>>(schemas: Schemas): DatabaseDef<Schemas>;
+/**
+ * Declares a top-level multi-database registry.
+ */
+declare function defineRegistry<Databases extends Record<string, DatabaseDef<Record<string, SchemaDef<Record<string, AnyModelDef>>>>>>(databases: Databases): RegistryDef<Databases>;
+
+declare const COLUMN_CONFIG: unique symbol;
+interface ColumnRuntimeConfig<TValue, TNullable extends boolean = false, THasDefault extends boolean = false, TGenerated extends boolean = false, TColumnName extends string | undefined = undefined, TKind extends ModelColumnKind = ModelColumnKind> {
+    readonly kind: TKind;
+    readonly columnName?: TColumnName;
+    readonly nullable: TNullable;
+    readonly hasDefault: THasDefault;
+    readonly isGenerated: TGenerated;
+    readonly enumValues?: readonly string[];
+    readonly jsonSchema?: ZodType<TValue>;
+    readonly __value?: TValue;
+}
+interface AthenaColumnBuilder<TValue, TNullable extends boolean = false, THasDefault extends boolean = false, TGenerated extends boolean = false, TColumnName extends string | undefined = undefined, TKind extends ModelColumnKind = ModelColumnKind> {
+    readonly [COLUMN_CONFIG]: ColumnRuntimeConfig<TValue, TNullable, THasDefault, TGenerated, TColumnName, TKind>;
+    optional(): AthenaColumnBuilder<TValue, true, THasDefault, TGenerated, TColumnName, TKind>;
+    from<TNextColumnName extends string>(columnName: TNextColumnName): AthenaColumnBuilder<TValue, TNullable, THasDefault, TGenerated, TNextColumnName, TKind>;
+    defaulted(): AthenaColumnBuilder<TValue, TNullable, true, TGenerated, TColumnName, TKind>;
+    generated(): AthenaColumnBuilder<TValue, TNullable, THasDefault, true, TColumnName, TKind>;
+}
+type AnyColumnBuilder = AthenaColumnBuilder<unknown, boolean, boolean, boolean, string | undefined, ModelColumnKind>;
+declare function string(): AthenaColumnBuilder<string, false, false, false, undefined, 'string'>;
+declare function number(): AthenaColumnBuilder<number, false, false, false, undefined, 'number'>;
+declare function boolean(): AthenaColumnBuilder<boolean, false, false, false, undefined, 'boolean'>;
+declare function json<TValue = unknown>(schema?: ZodType<TValue>): AthenaColumnBuilder<TValue, false, false, false, undefined, 'json'>;
+declare function enumeration<const TValues extends readonly [string, ...string[]]>(values: TValues): AthenaColumnBuilder<TValues[number], false, false, false, undefined, 'enumeration'>;
+
+interface AthenaTableSchemaBundle<Row, Insert, Update> {
+    readonly row: ZodType<Row>;
+    readonly insert: ZodType<Insert>;
+    readonly update: ZodType<Update>;
+    readonly form: ZodType<Insert>;
+}
+
+type Simplify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+type ExtractColumnConfig<TColumn extends AnyColumnBuilder> = TColumn[typeof COLUMN_CONFIG];
+type ColumnValue<TColumn extends AnyColumnBuilder> = ExtractColumnConfig<TColumn> extends {
+    __value?: infer TValue;
+} ? TValue : never;
+type ColumnNullable<TColumn extends AnyColumnBuilder> = ExtractColumnConfig<TColumn> extends {
+    nullable: infer TNullable extends boolean;
+} ? TNullable : never;
+type ColumnHasDefault<TColumn extends AnyColumnBuilder> = ExtractColumnConfig<TColumn> extends {
+    hasDefault: infer THasDefault extends boolean;
+} ? THasDefault : never;
+type ColumnGenerated<TColumn extends AnyColumnBuilder> = ExtractColumnConfig<TColumn> extends {
+    isGenerated: infer TGenerated extends boolean;
+} ? TGenerated : never;
+type RowFieldType<TColumn extends AnyColumnBuilder> = ColumnNullable<TColumn> extends true ? ColumnValue<TColumn> | null : ColumnValue<TColumn>;
+type WritableColumnKeys<TColumns extends Record<string, AnyColumnBuilder>> = Extract<{
+    [K in keyof TColumns]-?: ColumnGenerated<TColumns[K]> extends true ? never : K;
+}[keyof TColumns], string>;
+type InsertRequiredKeys<TColumns extends Record<string, AnyColumnBuilder>> = Extract<{
+    [K in keyof TColumns]-?: ColumnGenerated<TColumns[K]> extends true ? never : ColumnHasDefault<TColumns[K]> extends true ? never : ColumnNullable<TColumns[K]> extends true ? never : K;
+}[keyof TColumns], string>;
+type InsertOptionalKeys<TColumns extends Record<string, AnyColumnBuilder>> = Exclude<WritableColumnKeys<TColumns>, InsertRequiredKeys<TColumns>>;
+type ExtractMappedSchemaName<TMappedName extends string | undefined> = TMappedName extends `${infer TSchema}.${string}` ? TSchema : undefined;
+type ExtractMappedTableName<TMappedName extends string | undefined> = TMappedName extends `${string}.${infer TTable}` ? TTable : TMappedName extends string ? TMappedName : undefined;
+type ResolvedSchemaName<TSchemaName extends string | undefined, TMappedName extends string | undefined> = TSchemaName extends string ? TSchemaName : ExtractMappedSchemaName<TMappedName>;
+type ResolvedTableName<TName extends string, TMappedName extends string | undefined> = ExtractMappedTableName<TMappedName> extends string ? ExtractMappedTableName<TMappedName> : TName;
+type QualifiedTableName<TName extends string, TMappedName extends string | undefined, TSchemaName extends string | undefined> = ResolvedSchemaName<TSchemaName, TMappedName> extends infer TResolvedSchema extends string | undefined ? TResolvedSchema extends string ? `${TResolvedSchema}.${ResolvedTableName<TName, TMappedName>}` : ResolvedTableName<TName, TMappedName> : never;
+type RowFromColumns<TColumns extends Record<string, AnyColumnBuilder>> = Simplify<{
+    [K in keyof TColumns]: RowFieldType<TColumns[K]>;
+}>;
+type InsertFromColumns<TColumns extends Record<string, AnyColumnBuilder>> = Simplify<{
+    [K in InsertRequiredKeys<TColumns>]: ColumnValue<TColumns[K]>;
+} & {
+    [K in InsertOptionalKeys<TColumns>]?: RowFieldType<TColumns[K]>;
+}>;
+type UpdateFromColumns<TColumns extends Record<string, AnyColumnBuilder>> = Simplify<{
+    [K in WritableColumnKeys<TColumns>]?: RowFieldType<TColumns[K]>;
+}>;
+type FormValuesFromColumns<TColumns extends Record<string, AnyColumnBuilder>, TMode extends ModelFormNullishMode = 'empty-string'> = ModelFormValues<AthenaTableDef<TColumns>, TMode>;
+interface AthenaTableDef<TColumns extends Record<string, AnyColumnBuilder>, TName extends string = string, TMappedName extends string | undefined = undefined, TSchemaName extends string | undefined = undefined> extends ModelDef<RowFromColumns<TColumns>, InsertFromColumns<TColumns>, UpdateFromColumns<TColumns>, ModelMetadata<RowFromColumns<TColumns>>> {
+    readonly kind: 'table';
+    readonly name: TName;
+    readonly mappedName: TMappedName;
+    readonly schemaName: ResolvedSchemaName<TSchemaName, TMappedName>;
+    readonly tableName: ResolvedTableName<TName, TMappedName>;
+    readonly qualifiedName: QualifiedTableName<TName, TMappedName, TSchemaName>;
+    readonly columns: Readonly<TColumns>;
+    readonly schemas: AthenaTableSchemaBundle<RowFromColumns<TColumns>, InsertFromColumns<TColumns>, UpdateFromColumns<TColumns>>;
+}
+interface AthenaTableBuilder<TName extends string, TMappedName extends string | undefined = undefined, TSchemaName extends string | undefined = undefined> {
+    readonly name: TName;
+    readonly mappedName: TMappedName;
+    readonly schemaName: TSchemaName;
+    from<TNextMappedName extends string>(tableName: TNextMappedName): AthenaTableBuilder<TName, TNextMappedName, TSchemaName>;
+    schema<TNextSchemaName extends string>(schemaName: TNextSchemaName): AthenaTableBuilder<TName, TMappedName, TNextSchemaName>;
+    columns<TColumns extends Record<string, AnyColumnBuilder>>(columns: TColumns): AthenaTableColumnsBuilder<TName, TMappedName, TSchemaName, TColumns>;
+}
+interface AthenaTableColumnsBuilder<TName extends string, TMappedName extends string | undefined, TSchemaName extends string | undefined, TColumns extends Record<string, AnyColumnBuilder>> {
+    readonly name: TName;
+    readonly mappedName: TMappedName;
+    readonly schemaName: TSchemaName;
+    readonly columns: Readonly<TColumns>;
+    from<TNextMappedName extends string>(tableName: TNextMappedName): AthenaTableColumnsBuilder<TName, TNextMappedName, TSchemaName, TColumns>;
+    schema<TNextSchemaName extends string>(schemaName: TNextSchemaName): AthenaTableColumnsBuilder<TName, TMappedName, TNextSchemaName, TColumns>;
+    primaryKey<TPrimaryKey extends readonly [
+        Extract<keyof TColumns, string>,
+        ...Array<Extract<keyof TColumns, string>>
+    ]>(...keys: TPrimaryKey): AthenaTableDef<TColumns, TName, TMappedName, TSchemaName>;
+}
+declare function table<TName extends string>(name: TName): AthenaTableBuilder<TName, undefined>;
+
+type RegistryConstraint = RegistryDef<Record<string, DatabaseDef<Record<string, SchemaDef<Record<string, AnyModelDef>>>>>>;
+/**
+ * Options for creating typed Athena clients.
+ */
+interface TypedClientOptions<TMap extends TenantKeyMap = TenantKeyMap> extends Pick<AthenaGatewayCallOptions, 'backend' | 'client' | 'headers'> {
+    tenantKeyMap?: TMap;
+    tenantContext?: TenantContext<TMap>;
+    experimental?: AthenaClientExperimentalOptions;
+}
+interface TypedClientOptionsWithTypecheckedColumns<TMap extends TenantKeyMap = TenantKeyMap> extends TypedClientOptions<TMap> {
+    experimental: AthenaClientExperimentalOptions & {
+        typecheckColumns: true;
+    };
+}
+/**
+ * Typed Athena client with registry-driven model resolution and tenant-context propagation.
+ */
+interface TypedAthenaClient<TRegistry extends RegistryConstraint, TTenantMap extends TenantKeyMap = Record<never, string>, TStrict extends boolean = false> extends AthenaSdkClient<TStrict> {
+    readonly registry: TRegistry;
+    readonly tenantKeyMap: Readonly<TTenantMap>;
+    readonly tenantContext: TenantContext<TTenantMap>;
+    withTenantContext(context: TenantContext<TTenantMap>): TypedAthenaClient<TRegistry, TTenantMap, TStrict>;
+    fromModel<TDatabase extends keyof TRegistry & string, TSchema extends keyof TRegistry[TDatabase]['schemas'] & string, TModel extends keyof TRegistry[TDatabase]['schemas'][TSchema]['models'] & string>(database: TDatabase, schema: TSchema, model: TModel): TableQueryBuilder<RowOf<ModelAt<TRegistry, TDatabase, TSchema, TModel>>, InsertOf<ModelAt<TRegistry, TDatabase, TSchema, TModel>>, UpdateOf<ModelAt<TRegistry, TDatabase, TSchema, TModel>>, {
+        registry: TRegistry;
+        database: TDatabase;
+        schema: TSchema;
+        model: ModelAt<TRegistry, TDatabase, TSchema, TModel>;
+    }, TStrict>;
+}
+/**
+ * Creates a typed client bound to a registry contract and optional tenant header mapping.
+ */
+declare function createTypedClient<TRegistry extends RegistryConstraint, TTenantMap extends TenantKeyMap = Record<never, string>>(registry: TRegistry, url: string, apiKey: string, options: TypedClientOptionsWithTypecheckedColumns<TTenantMap>): TypedAthenaClient<TRegistry, TTenantMap, true>;
+declare function createTypedClient<TRegistry extends RegistryConstraint, TTenantMap extends TenantKeyMap = Record<never, string>>(registry: TRegistry, url: string, apiKey: string, options?: TypedClientOptions<TTenantMap>): TypedAthenaClient<TRegistry, TTenantMap, false>;
+
+/**
+ * Constructor options for the PostgreSQL introspection provider.
+ */
+interface PostgresIntrospectionProviderOptions {
+    connectionString: string;
+    database?: string;
+    schemas?: readonly string[];
+}
+/**
+ * Creates a PostgreSQL-backed schema introspection provider.
+ */
+declare function createPostgresIntrospectionProvider(options: PostgresIntrospectionProviderOptions): SchemaIntrospectionProvider;
+
+interface GeneratorEnvBaseOptions<T> {
+    default?: T;
+    optional?: boolean;
+}
+type GeneratorEnvStringOptions = GeneratorEnvBaseOptions<string>;
+type GeneratorEnvBooleanOptions = GeneratorEnvBaseOptions<boolean>;
+interface GeneratorEnvListOptions extends GeneratorEnvBaseOptions<readonly string[]> {
+    separator?: string;
+}
+type GeneratorEnvJsonOptions<T> = GeneratorEnvBaseOptions<T>;
+type GeneratorEnvOneOfOptions<T extends string> = GeneratorEnvBaseOptions<T>;
+type GeneratorEnvHelper = {
+    (key: string, options?: GeneratorEnvStringOptions): string;
+    (key: string, options: GeneratorEnvStringOptions & {
+        optional: true;
+    }): string | undefined;
+    boolean(key: string, options?: GeneratorEnvBooleanOptions): boolean;
+    boolean(key: string, options: GeneratorEnvBooleanOptions & {
+        optional: true;
+    }): boolean | undefined;
+    list(key: string, options?: GeneratorEnvListOptions): string[];
+    list(key: string, options: GeneratorEnvListOptions & {
+        optional: true;
+    }): string[] | undefined;
+    json<T>(key: string, options?: GeneratorEnvJsonOptions<T>): T;
+    json<T>(key: string, options: GeneratorEnvJsonOptions<T> & {
+        optional: true;
+    }): T | undefined;
+    oneOf<const T extends string>(key: string, allowedValues: readonly T[], options?: GeneratorEnvOneOfOptions<T>): T;
+    oneOf<const T extends string>(key: string, allowedValues: readonly T[], options: GeneratorEnvOneOfOptions<T> & {
+        optional: true;
+    }): T | undefined;
+};
+/**
+ * Typed env reader for generator configs. This keeps `athena.config.*` files
+ * declarative while preserving exact field types for booleans, lists, unions,
+ * and JSON-backed objects.
+ */
+declare const generatorEnv: GeneratorEnvHelper;
+
+declare function resolvePostgresColumnType(column: IntrospectionColumn): string;
+
+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[];
+
+/**
+ * @deprecated Prefer `createClient(...).auth` from `@xylex-group/athena`.
+ */
+declare function createAuthClient(config?: AthenaAuthClientConfig): AthenaAuthSdkClient;
+
+type AthenaMaybePromise<T> = T | Promise<T>;
+type AthenaAuthServerCookieOptions = Pick<AthenaCookiesOptions, 'session' | 'advanced'>;
+declare const ATHENA_AUTH_BASE_ERROR_CODES: {
+    readonly HANDLER_NOT_CONFIGURED: "HANDLER_NOT_CONFIGURED";
+    readonly INVALID_BASE_URL: "INVALID_BASE_URL";
+    readonly UNTRUSTED_HOST: "UNTRUSTED_HOST";
+};
+interface AthenaAuthSocialProviderConfig {
+    clientId: string;
+    clientSecret: string;
+    scope?: string[];
+    [key: string]: unknown;
+}
+interface AthenaAuthPluginContext {
+    path?: string;
+    headers?: Headers;
+    context: {
+        returned?: unknown;
+        responseHeaders?: Headers;
+        setSession?: AthenaSessionPair | null;
+        clearSession?: boolean;
+        dontRememberMe?: boolean;
+        cookieOverrides?: Partial<AthenaCookieOptions>;
+        [key: string]: unknown;
+    };
+}
+interface AthenaAuthPluginHandlerContext extends AthenaAuthPluginContext {
+    auth: AthenaAuthServer;
+}
+interface AthenaAuthPlugin {
+    id: string;
+    version: string;
+    $ERROR_CODES?: Record<string, string>;
+    hooks?: {
+        after?: Array<{
+            matcher: (ctx: AthenaAuthPluginContext) => boolean;
+            handler: (ctx: AthenaAuthPluginHandlerContext) => Promise<void> | void;
+        }>;
+    };
+}
+interface AthenaAuthCookieRuntimeInput {
+    headers?: Headers;
+    responseHeaders?: Headers;
+    cookies?: AthenaAuthCookies;
+    getCookie?: (name: string) => string | null | undefined;
+    setCookie?: (name: string, value: string, attributes: AthenaCookieOptions) => void;
+    logger?: AthenaCookieContextRuntime['logger'];
+    setSignedCookie?: AthenaCookieContextRuntime['setSignedCookie'];
+    getSignedCookie?: AthenaCookieContextRuntime['getSignedCookie'];
+    setNewSession?: AthenaCookieContextRuntime['context']['setNewSession'];
+}
+interface AthenaAuthServerRuntimeOptions {
+    baseURL?: string;
+    basePath: string;
+    secret: string;
+    cookies: AthenaAuthServerCookieOptions;
+}
+type AthenaAuthDatabaseFactory<TDatabase = unknown> = (options: AthenaAuthServerRuntimeOptions) => TDatabase;
+type AthenaAuthBaseURLConfig = AthenaCookiesOptions['baseURL'];
+type AthenaAuthTrustedOrigins = string[] | ((request?: Request) => AthenaMaybePromise<string[]>);
+type AthenaAuthTrustedProviders = string[] | ((request?: Request) => AthenaMaybePromise<string[]>);
+interface AthenaAuthHandlerResult {
+    response?: Response;
+    returned?: unknown;
+    setSession?: AthenaSessionPair | null;
+    clearSession?: boolean;
+    dontRememberMe?: boolean;
+    cookieOverrides?: Partial<AthenaCookieOptions>;
+}
+interface AthenaAuthServerConfig<TDatabase = unknown> extends AthenaAuthServerCookieOptions {
+    baseURL?: AthenaAuthBaseURLConfig;
+    basePath?: string;
+    secret: string;
+    database: TDatabase | AthenaAuthDatabaseFactory<TDatabase>;
+    socialProviders?: Record<string, AthenaAuthSocialProviderConfig>;
+    trustedOrigins?: AthenaAuthTrustedOrigins;
+    trustedProviders?: AthenaAuthTrustedProviders;
+    api?: Record<string, unknown>;
+    errorCodes?: Record<string, string>;
+    handler?: (ctx: AthenaAuthRequestContext) => AthenaMaybePromise<Response | AthenaAuthHandlerResult>;
+    plugins?: AthenaAuthPlugin[];
+}
+type ResolveAthenaAuthDatabase<TConfig extends AthenaAuthServerConfig> = TConfig['database'] extends (...args: never[]) => infer TResult ? TResult : TConfig['database'];
+interface AthenaAuthRequestContext<TConfig extends AthenaAuthServerConfig = AthenaAuthServerConfig> {
+    auth: AthenaAuthServer<TConfig>;
+    request: Request;
+    url: URL;
+    path: string;
+    basePath: string;
+    baseURL: string;
+    origin: string;
+    headers: Headers;
+    cookies: AthenaAuthCookies;
+    trustedOrigins: string[];
+    trustedProviders: string[];
+    options: TConfig;
+    runtime: AthenaAuthServerRuntimeOptions;
+    database: ResolveAthenaAuthDatabase<TConfig>;
+    socialProviders: NonNullable<TConfig['socialProviders']>;
+}
+interface AthenaAuthContext<TConfig extends AthenaAuthServerConfig = AthenaAuthServerConfig> {
+    auth: AthenaAuthServer<TConfig>;
+    options: TConfig;
+    runtime: AthenaAuthServerRuntimeOptions;
+    basePath: string;
+    baseURL?: string;
+    origin?: string;
+    database: ResolveAthenaAuthDatabase<TConfig>;
+    socialProviders: NonNullable<TConfig['socialProviders']>;
+    plugins: AthenaAuthPlugin[];
+    cookies: AthenaAuthCookies;
+    trustedOrigins: string[];
+    trustedProviders: string[];
+}
+interface AthenaAuthServerApi<TConfig extends AthenaAuthServerConfig = AthenaAuthServerConfig> {
+    applyResponseCookies: AthenaAuthServer<TConfig>['applyResponseCookies'];
+    clearSession: AthenaAuthServer<TConfig>['clearSession'];
+    createCookieContext: AthenaAuthServer<TConfig>['createCookieContext'];
+    getCookieCache: typeof getCookieCache;
+    getSessionCookie: typeof getSessionCookie;
+    resolveRequestContext: AthenaAuthServer<TConfig>['resolveRequestContext'];
+    runAfterHooks: AthenaAuthServer<TConfig>['runAfterHooks'];
+    setSession: AthenaAuthServer<TConfig>['setSession'];
+}
+interface AthenaAuthServer<TConfig extends AthenaAuthServerConfig = AthenaAuthServerConfig> {
+    config: TConfig;
+    options: TConfig;
+    runtime: AthenaAuthServerRuntimeOptions;
+    database: ResolveAthenaAuthDatabase<TConfig>;
+    socialProviders: NonNullable<TConfig['socialProviders']>;
+    plugins: AthenaAuthPlugin[];
+    cookies: AthenaAuthCookies;
+    api: AthenaAuthServerApi<TConfig> & Record<string, unknown>;
+    $context: Promise<AthenaAuthContext<TConfig>>;
+    $ERROR_CODES: Record<string, string>;
+    createCookieContext: (input?: AthenaAuthCookieRuntimeInput) => AthenaCookieContextRuntime;
+    setSession: (input: AthenaAuthCookieRuntimeInput | undefined, session: AthenaSessionPair, dontRememberMe?: boolean, overrides?: Partial<AthenaCookieOptions>) => Promise<void>;
+    clearSession: (input?: AthenaAuthCookieRuntimeInput, skipDontRememberMe?: boolean) => void;
+    applyResponseCookies: (ctx: AthenaAuthPluginContext) => Promise<Headers>;
+    runAfterHooks: (ctx: AthenaAuthPluginContext) => Promise<AthenaAuthPluginContext>;
+    resolveRequestContext: (request: Request) => Promise<AthenaAuthRequestContext<TConfig>>;
+    handler: (request: Request) => Promise<Response>;
+}
+declare function defineAthenaAuthConfig<TConfig extends AthenaAuthServerConfig>(config: TConfig): TConfig;
+declare function athenaAuth<TConfig extends AthenaAuthServerConfig>(config: TConfig): AthenaAuthServer<TConfig>;
+
+interface AthenaAuthRenderedReactEmail {
+    html: string;
+    text?: string;
+}
+interface AthenaAuthReactEmailRuntimeOptions {
+    route?: string;
+    defaults?: AthenaAuthReactEmailRenderOptions;
+    observe?: (event: AthenaAuthReactEmailRenderEvent) => void;
+}
+declare function createAuthReactEmailInput<TProps extends AthenaAuthReactEmailProps = AthenaAuthReactEmailProps>(component: AthenaAuthReactEmailComponent<TProps>, props: TProps, overrides?: Omit<AthenaAuthReactEmailRenderInput, 'component' | 'props' | 'element'>): AthenaAuthReactEmailRenderInput;
+declare function defineAuthEmailTemplate<TProps extends AthenaAuthReactEmailProps = AthenaAuthReactEmailProps>(definition: AthenaAuthEmailTemplateDefinition<TProps>): AthenaAuthEmailTemplateBuilder<TProps>;
+declare function renderAthenaReactEmail(input: AthenaAuthReactEmailRenderInput, options?: AthenaAuthReactEmailRuntimeOptions | AthenaAuthReactEmailConfig): Promise<AthenaAuthRenderedReactEmail>;
+
+export { normalizeSchemaSelection as $, ATHENA_AUTH_BASE_ERROR_CODES as A, athenaAuth as B, type ColumnRuntimeConfig as C, DEFAULT_POSTGRES_SCHEMAS as D, boolean as E, type FormValuesFromColumns as F, type GeneratorEnvBooleanOptions as G, createAuthClient as H, type InsertFromColumns as I, createAuthReactEmailInput as J, createPostgresIntrospectionProvider as K, createTypedClient as L, defineAthenaAuthConfig as M, defineAuthEmailTemplate as N, defineDatabase as O, type PostgresIntrospectionProviderOptions as P, defineModel as Q, type RowFromColumns as R, defineRegistry as S, type TypedAthenaClient as T, type UpdateFromColumns as U, defineSchema as V, enumeration as W, generatorEnv as X, identifier as Y, json as Z, normalizeAthenaGatewayBaseUrl as _, type AnyColumnBuilder as a, number as a0, renderAthenaReactEmail as a1, resolvePostgresColumnType as a2, resolveProviderSchemas as a3, string as a4, table as a5, verifyAthenaGatewayUrl as a6, type AthenaAuthBaseURLConfig as b, type AthenaAuthContext as c, type AthenaAuthCookieRuntimeInput as d, type AthenaAuthDatabaseFactory as e, type AthenaAuthHandlerResult as f, type AthenaAuthPlugin as g, type AthenaAuthPluginContext as h, type AthenaAuthPluginHandlerContext as i, type AthenaAuthRequestContext as j, type AthenaAuthServer as k, type AthenaAuthServerApi as l, type AthenaAuthServerConfig as m, type AthenaAuthServerRuntimeOptions as n, type AthenaAuthSocialProviderConfig as o, type AthenaAuthTrustedOrigins as p, type AthenaAuthTrustedProviders as q, type AthenaColumnBuilder as r, type AthenaTableDef as s, type AthenaTableSchemaBundle as t, type GeneratorEnvJsonOptions as u, type GeneratorEnvListOptions as v, type GeneratorEnvOneOfOptions as w, type GeneratorEnvStringOptions as x, type TypedClientOptions as y, type TypedClientOptionsWithTypecheckedColumns as z };