faire-auth 1.0.4 → 1.1.0

package/dist/shared.d.cts

@@ -0,0 +1,1581 @@
+import { DBAdapter, DBAdapter as DBAdapter$1, DBAdapterInstance, DBAdapterInstance as DBAdapterInstance$1, DBAdapterSchemaCreation, DBAdapterSchemaCreation as DBAdapterSchemaCreation$1, DBTransactionAdapter, DBTransactionAdapter as DBTransactionAdapter$1, Where, Where as Where$1 } from "@faire-auth/core/db/adapter";
+import { ENV, ENV as ENV$1, InternalLogger, LogHandlerParams, LogLevel, Logger, createLogger, logger } from "@faire-auth/core/env";
+import { AnyHono, AuthContext as AuthContext$1, AuthRouteConfig, BasePath as BasePath$1, BuildSchema, ConvertPathType, CustomIO, DTOTransformer, DefaultHook, DocPathFromOptions, ExK, Exec, ExecOpts, Expand, FaireAuthOptions as FaireAuthOptions$1, FaireAuthPlugin as FaireAuthPlugin$1, FaireAuthRateLimitOptions as FaireAuthRateLimitOptions$1, FieldAttribute, Fn, FromFn, InferFieldsFromOptions as InferFieldsFromOptions$1, InferFieldsFromPlugins as InferFieldsFromPlugins$1, InferFieldsInputClient as InferFieldsInputClient$1, InferFieldsOutput as InferFieldsOutput$1, InferInput, InternalAdapter, JSONRenderRespond, LiteralString, LiteralStringUnion, MinRouteConfig, OmitId, Prettify, ProcessRouteConfig, RouteConfigToEnv, RouteConfigToMiddleware, RouteConfigToRequest, RouteHandler, RouteHook, StripEmptyObjects, UnionToIntersection, execHelper } from "@faire-auth/core/types";
+import { Context, Env, ExecutionContext, Hono, HonoRequest, MiddlewareHandler, Schema, TypedResponse } from "hono";
+import { APIError, BASE_ERROR_CODES, FaireAuthError, MissingDependencyError } from "@faire-auth/core/error";
+import { OpenAPIHono, OpenAPIHono as OpenAPIHono$1 } from "@faire-auth/core/factory";
+import { BetterFetch, BetterFetchError, BetterFetchOption, BetterFetchPlugin, CreateFetchOption, Methods, Schema as Schema$1, SchemaConfig, StandardSchemaV1 } from "@better-fetch/fetch";
+import { ExtractSchema } from "hono/types";
+import { Atom, WritableAtom } from "nanostores";
+import { Account, AccountInput, DBFieldAttribute, DBFieldAttributeConfig, DBFieldType, FaireAuthDBSchema, FaireAuthPluginDBSchema as FaireAuthPluginDBSchema$1, Session as Session$1, SessionInput, StrictSession, StrictUser, User, UserInput, VerificationInput } from "@faire-auth/core/db";
+import { ClientRequest, ClientResponse } from "hono/client";
+import { ClientErrorStatusCode, ServerErrorStatusCode, SuccessStatusCode } from "hono/utils/http-status";
+import { HasRequiredKeys } from "hono/utils/types";
+import { Definitions, Routes, SCHEMAS } from "@faire-auth/core/static";
+import * as z from "zod";
+import { z as z$1 } from "zod";
+import { HonoRequest as HonoRequest$1 } from "hono/request";
+import { generateId, generateRandomString } from "@faire-auth/core/crypto";
+declare const getCurrentAdapter: (adapter?: DBTransactionAdapter$1) => DBTransactionAdapter$1;
+/**
+ * Adapter Interface
+ *
+ * @deprecated Use `DBAdapter` from `@faire-auth/core/db/adapter` instead.
+ */
+type Adapter = DBAdapter$1;
+/**
+ * @deprecated Use `DBTransactionAdapter` from `@faire-auth/core/db/adapter` instead.
+ */
+type TransactionAdapter = DBTransactionAdapter$1;
+/**
+ * @deprecated Use `DBAdapterSchemaCreation` from `@faire-auth/core/db/adapter` instead.
+ */
+type AdapterSchemaCreation = DBAdapterSchemaCreation$1;
+/**
+ * @deprecated Use `DBAdapterInstance` from `@faire-auth/core/db/adapter` instead.
+ */
+type AdapterInstance = DBAdapterInstance$1;
+type AuthContext<Options extends FaireAuthOptions = FaireAuthOptions> = AuthContext$1<ContextVars, Options>;
+declare const init: <O extends FaireAuthOptions>(options: O) => readonly [AuthContext$1<ContextVars, Options>, FaireAuthOptions];
+type AuthArgs<C extends MinRouteConfig> = [C, RouteHandler<C, Env extends RouteConfigToEnv<C> ? ContextVars : RouteConfigToEnv<C> & ContextVars>, FromFn<RouteHook<C>> | undefined];
+/**
+ * Represents the properties of an auth endpoint.
+ * @template C - The route config type.
+ * @template O - The options type.
+ */
+interface AuthProperties<C extends MinRouteConfig> extends ReturnType<typeof execHelper<C, ContextVars<any>>> {
+  toArgs: (builtSchemas: Record<Definitions, z$1.ZodType>, context: AuthContext, api: Record<string, (...args: any[]) => any>, hook?: FromFn<RouteHook<any>>) => AuthArgs<C>;
+}
+/**
+ * Represents an auth endpoint function.
+ * @template C - The route config type.
+ */
+interface AuthEndpoint<C extends MinRouteConfig> {
+  <O extends FaireAuthOptions = {}>(options: O): AuthProperties<ProcessRouteConfig<C, O>>;
+}
+/**
+ * Factory function for creating auth endpoints.
+ *
+ * @todo Maybe some day the compiler will be strong enough we won't
+ * need this explicit type annotation
+ */
+interface AuthFactory {
+  <C extends AuthRouteConfig, H extends (options: FaireAuthOptions) => RouteHandler<C, RouteConfigToEnv<C>, InferInput<C>, ConvertPathType<C["path"]>, true>>(config: C, handler: H, hook?: FromFn<RouteHook<C>>): AuthEndpoint<C>;
+}
+/**
+ * Creates an auth endpoint.
+ * @template C - The route config type.
+ * @param config - The route configuration.
+ * @param handler - The route handler function.
+ * @param hook - Optional route hook.
+ * @returns The auth endpoint function.
+ */
+declare const createEndpoint: <C extends AuthRouteConfig>(config: C, handler: (options: FaireAuthOptions) => RouteHandler<C, Env extends RouteConfigToEnv<C> ? ContextVars : RouteConfigToEnv<C> & ContextVars, InferInput<C>, ConvertPathType<C["path"]>, true>, hook?: FromFn<RouteHook<C>>) => AuthEndpoint<C>;
+declare const createFieldAttribute: <T extends DBFieldType, C extends DBFieldAttributeConfig>(type: T, config?: C) => DBFieldAttribute<T>;
+type InferValueType<T extends DBFieldType> = T extends "string" ? string : T extends "number" ? number : T extends "boolean" ? boolean : T extends "date" ? Date : T extends `${infer T}[]` ? T extends "string" ? string[] : number[] : T extends Array<any> ? T[number] : never;
+type InferFieldsOutput<Field> = Field extends Record<infer Key, DBFieldAttribute> ? { [key in Key as Field[key]["required"] extends false ? Field[key]["defaultValue"] extends boolean | string | number | Date ? key : never : key]: InferFieldOutput<Field[key]>; } & { [key in Key as Field[key]["returned"] extends false ? never : key]?: InferFieldOutput<Field[key]> | null; } : {};
+type InferFieldsInput<Field> = Field extends Record<infer Key, DBFieldAttribute> ? { [key in Key as Field[key]["required"] extends false ? never : Field[key]["defaultValue"] extends string | number | boolean | Date ? never : Field[key]["input"] extends false ? never : key]: InferFieldInput<Field[key]>; } & { [key in Key as Field[key]["input"] extends false ? never : key]?: InferFieldInput<Field[key]> | undefined | null; } : {};
+/**
+ * For client will add "?" on optional fields
+ */
+type InferFieldsInputClient<Field> = Field extends Record<infer Key, DBFieldAttribute> ? { [key in Key as Field[key]["required"] extends false ? never : Field[key]["defaultValue"] extends string | number | boolean | Date ? never : Field[key]["input"] extends false ? never : key]: InferFieldInput<Field[key]>; } & { [key in Key as Field[key]["input"] extends false ? never : Field[key]["required"] extends false ? key : Field[key]["defaultValue"] extends string | number | boolean | Date ? key : never]?: InferFieldInput<Field[key]> | undefined | null; } : {};
+type InferFieldOutput<T extends DBFieldAttribute> = T["returned"] extends false ? never : T["required"] extends false ? InferValueType<T["type"]> | undefined | null : InferValueType<T["type"]>;
+/**
+ * Converts a Record<string, DBFieldAttribute> to an object type
+ * with keys and value types inferred from DBFieldAttribute["type"].
+ */
+type FieldAttributeToObject<Fields extends Record<string, DBFieldAttribute>> = AddOptionalFields<{ [K in keyof Fields]: InferValueType<Fields[K]["type"]>; }, Fields>;
+type AddOptionalFields<T extends Record<string, any>, Fields extends Record<keyof T, DBFieldAttribute>> = { [K in keyof T as Fields[K] extends {
+  required: true;
+} ? K : never]: T[K]; } & { [K in keyof T as Fields[K] extends {
+  required: true;
+} ? never : K]?: T[K]; };
+/**
+ * Infer the additional fields from the plugin options.
+ * For example, you can infer the additional fields of the org plugin's organization schema like this:
+ * ```ts
+ * type AdditionalFields = InferAdditionalFieldsFromPluginOptions<"organization", OrganizationOptions>
+ * ```
+ */
+type InferAdditionalFieldsFromPluginOptions<SchemaName extends string, Options extends {
+  schema?: { [key in SchemaName]?: {
+    additionalFields?: Record<string, DBFieldAttribute>;
+  }; };
+}, isClientSide extends boolean = true> = Options["schema"] extends { [key in SchemaName]?: {
+  additionalFields: infer Field extends Record<string, DBFieldAttribute>;
+}; } ? isClientSide extends true ? FieldAttributeToObject<RemoveFieldsWithInputFalse<Field>> : FieldAttributeToObject<Field> : {};
+type RemoveFieldsWithInputFalse<T extends Record<string, DBFieldAttribute>> = { [K in keyof T as T[K]["input"] extends false ? never : K]: T[K]; };
+type InferFieldInput<T extends DBFieldAttribute> = InferValueType<T["type"]>;
+type PluginFieldAttribute = Omit<DBFieldAttribute, "transform" | "defaultValue" | "hashValue">;
+type InferFieldsFromPlugins<Options extends FaireAuthOptions$1, Key extends string, Format extends "output" | "input" = "output"> = Options["plugins"] extends [] ? {} : Options["plugins"] extends Array<infer T> ? T extends {
+  schema: { [key in Key]: {
+    fields: infer Field;
+  }; };
+} ? Format extends "output" ? InferFieldsOutput<Field> : InferFieldsInput<Field> : {} : {};
+type InferFieldsFromOptions<Options extends FaireAuthOptions$1, Key extends "session" | "user", Format extends "output" | "input" = "output"> = Options[Key] extends {
+  additionalFields: infer Field;
+} ? Format extends "output" ? InferFieldsOutput<Field> : InferFieldsInput<Field> : {};
+type KyselyDatabaseType = "postgres" | "mysql" | "sqlite" | "mssql";
+declare function matchType(columnDataType: string, fieldType: DBFieldType, dbType: KyselyDatabaseType): any;
+declare function getMigrations(config: FaireAuthOptions): Promise<{
+  toBeCreated: {
+    table: string;
+    fields: Record<string, DBFieldAttribute>;
+    order: number;
+  }[];
+  toBeAdded: {
+    table: string;
+    fields: Record<string, DBFieldAttribute>;
+    order: number;
+  }[];
+  runMigrations: () => Promise<void>;
+  compileMigrations: () => Promise<string>;
+}>;
+declare function getSchema(config: FaireAuthOptions): Record<string, {
+  fields: Record<string, DBFieldAttribute>;
+  order: number;
+}>;
+declare const getAuthTables: (options: FaireAuthOptions) => FaireAuthDBSchema;
+declare const createInternalAdapter: (adapter: DBAdapter$1<FaireAuthOptions>, options: Pick<FaireAuthOptions, "advanced" | "user" | "session" | "verification" | "plugins">, context: Pick<AuthContext, "logger" | "generateId" | "secondaryStorage" | "sessionConfig">, hooks?: Exclude<FaireAuthOptions["databaseHooks"], undefined>[]) => InternalAdapter;
+declare function parseUserOutput(options: Pick<FaireAuthOptions, "user" | "plugins">, user: User): User;
+declare function parseAccountOutput(options: Pick<FaireAuthOptions, "plugins">, account: Account): Account;
+declare function parseSessionOutput(options: Pick<FaireAuthOptions, "session" | "plugins">, session: Session$1): Session$1;
+declare function parseInputData<T extends Record<string, any>>(data: T, schema: {
+  fields: Record<string, DBFieldAttribute>;
+  action?: ("create" | "update") | undefined;
+}): Partial<T> | Response;
+declare function parseUserInput(options: Pick<FaireAuthOptions, "user" | "plugins">, user: Record<string, any> | undefined, action: "create" | "update"): Partial<Record<string, any>> | Response;
+declare function parseAdditionalUserInput(options: Pick<FaireAuthOptions, "user" | "plugins">, user?: Record<string, any>): Partial<Record<string, any>> | Response;
+declare function parseAccountInput(options: Pick<FaireAuthOptions, "plugins">, account: Partial<Account>): any;
+declare function parseSessionInput(options: Pick<FaireAuthOptions, "session" | "plugins">, session: Partial<Session$1>): any;
+declare function mergeSchema<S extends FaireAuthPluginDBSchema$1>(schema: S, newSchema?: { [K in keyof S]?: {
+  modelName?: string | undefined;
+  fields?: {
+    [P: string]: string;
+  } | undefined;
+}; }): S;
+declare function toZodSchema<Fields extends Record<string, DBFieldAttribute | never>, IsClientSide extends boolean>({ fields, isClientSide }: {
+  fields: Fields;
+  /**
+   * If true, then any fields that have `input: false` will be removed from the schema to prevent user input.
+   */
+  isClientSide: IsClientSide;
+}): z.ZodObject<RemoveNeverProps<{ [key in keyof Fields]: FieldAttributeToSchema<Fields[key], IsClientSide>; }>, z.core.$strip>;
+type FieldAttributeToSchema<Field extends DBFieldAttribute | Record<string, never>, isClientSide extends boolean = false> = Field extends {
+  type: any;
+} ? GetInput<isClientSide, Field, GetRequired<Field, GetType<Field>>> : Record<string, never>;
+type GetType<F extends DBFieldAttribute> = F extends {
+  type: "string";
+} ? z.ZodString : F extends {
+  type: "number";
+} ? z.ZodNumber : F extends {
+  type: "boolean";
+} ? z.ZodBoolean : F extends {
+  type: "date";
+} ? z.ZodDate : z.ZodAny;
+type GetRequired<F extends DBFieldAttribute, Schema extends z.core.SomeType> = F extends {
+  required: true;
+} ? Schema : z.ZodOptional<Schema>;
+type GetInput<isClientSide extends boolean, Field extends DBFieldAttribute, Schema extends z.core.SomeType> = Field extends {
+  input: false;
+} ? isClientSide extends true ? never : Schema : Schema;
+type RemoveNeverProps<T> = { [K in keyof T as [T[K]] extends [never] ? never : K]: T[K]; };
+declare function getAdapter(options: FaireAuthOptions): DBAdapter$1<FaireAuthOptions>;
+declare function convertToDB<T extends Record<string, any>>(fields: Record<string, DBFieldAttribute>, values: T): T;
+declare function convertFromDB<T extends Record<string, any>>(fields: Record<string, DBFieldAttribute>, values: T | null): T | null;
+type BaseModels = keyof NonNullable<FaireAuthOptions["databaseHooks"]>;
+type ModelShape = { [K in BaseModels]: K extends "user" ? UserInput : K extends "session" ? SessionInput : K extends "account" ? AccountInput : K extends "verification" ? VerificationInput : unknown; };
+type ModelFn<M extends BaseModels, Op extends "create" | "update" | "delete"> = Exclude<Exclude<Exclude<Exclude<FaireAuthOptions["databaseHooks"], undefined>[M], undefined>[Op], undefined>["before"], undefined> extends ((...args: [infer Model extends Partial<ModelShape[M]>, ...any[]]) => Promise<infer Return>) ? {
+  arg: Model;
+  ret: Return extends any ? Return extends {
+    data: infer D;
+  } ? D : never : never;
+} : never;
+declare const getWithHooks: (adapter: DBAdapter$1<FaireAuthOptions>, hooks?: Exclude<FaireAuthOptions["databaseHooks"], undefined>[]) => {
+  createWithHooks<M extends BaseModels>(data: OmitId<ModelFn<M, "create">["arg"]>, model: M, customCreateFn?: {
+    fn: (data: OmitId<ModelFn<M, "create">["arg"]>) => Promise<ModelFn<M, "create">["ret"] | void>;
+    executeMainFn?: boolean;
+  } | undefined): Promise<ModelFn<M, "create">["ret"] | null>;
+  updateWithHooks<M extends BaseModels>(data: ModelFn<M, "update">["arg"], where: Where$1[], model: M, customUpdateFn?: {
+    fn: (data: ModelFn<M, "update">["arg"]) => Promise<ModelFn<M, "update">["ret"] | void>;
+    executeMainFn?: boolean;
+  } | undefined): Promise<ModelFn<M, "update">["ret"] | null>;
+  updateManyWithHooks<M extends BaseModels>(data: ModelFn<M, "update">["arg"], where: Where$1[], model: M, customUpdateFn?: {
+    fn: (data: ModelFn<M, "update">["arg"]) => Promise<ModelFn<M, "update">["ret"] | void>;
+    executeMainFn?: boolean;
+  } | undefined): Promise<number | ModelFn<M, "update">["ret"] | null>;
+  deleteWithHooks<M extends BaseModels>(where: Where$1[], model: M, customDeleteFn?: {
+    fn: (where: Where$1[]) => Promise<void>;
+    executeMainFn?: boolean;
+  } | undefined): Promise<void | null>;
+  deleteManyWithHooks<M extends BaseModels>(where: Where$1[], model: M, customDeleteFn?: {
+    fn: (where: Where$1[]) => Promise<void>;
+    executeMainFn?: boolean;
+  } | undefined): Promise<number | void | null>;
+};
+import * as import__faire_auth_core_db from "@faire-auth/core/db";
+type AuthPluginSchema = { [table in string]: {
+  fields: { [field in string]: FieldAttribute; };
+  disableMigration?: boolean;
+  modelName?: string | undefined;
+}; };
+interface FaireAuthPlugin extends FaireAuthPlugin$1<ContextVars<any>> {
+  /**
+   * Custom routes provided by the plugin.
+   */
+  routes?: Record<string, AuthEndpoint<any>>;
+  /**
+   * Post-validation route hooks used in base or plugin routes.
+   */
+  routeHooks?: Prettify<Hooks>;
+  /**
+   * Plugin middleware used in base or plugin routes.
+   */
+  middleware?: Prettify<Middleware>;
+}
+type InferOptionSchema<S extends index_d_exports.FaireAuthPluginDBSchema> = S extends Record<string, {
+  fields: infer Fields;
+}> ? { [K in keyof S]?: {
+  modelName?: string | undefined;
+  fields?: { [P in keyof Fields]?: string; } | undefined;
+}; } : never;
+type InferPluginErrorCodes<O extends FaireAuthOptions> = O["plugins"] extends (infer P)[] ? UnionToIntersection<P extends FaireAuthPlugin ? P["$ERROR_CODES"] extends Record<string, any> ? P["$ERROR_CODES"] : {} : {}> : {};
+type InferPluginHooks<T extends readonly FaireAuthPlugin[]> = UnionToIntersection<T extends (infer P)[] ? P extends {
+  routes: infer R;
+} ? { [K in keyof R]?: R[K] extends AuthEndpoint<infer C> ? RouteHook<C> : never; } : {} : {}>;
+type InferPluginMiddleware<T extends readonly FaireAuthPlugin[]> = UnionToIntersection<T extends (infer P)[] ? P extends {
+  routes: infer R;
+} ? { [K in keyof R]?: R[K] extends AuthEndpoint<infer C> ? never extends RouteConfigToMiddleware<C> ? MiddlewareHandler<ContextVars> : RouteConfigToMiddleware<C> : never; } : {} : {}>;
+type InferPluginDTO<T extends readonly FaireAuthPlugin[]> = UnionToIntersection<T extends (infer P)[] ? P extends {
+  schemas: infer R;
+} ? { [K in keyof R]?: DTOTransformer<z$1.output<R[K]>>; } : {} : {}>;
+type InferPluginRateLimit<T extends readonly FaireAuthPlugin[]> = {
+  customRules?: UnionToIntersection<T extends (infer P)[] ? P extends {
+    routes: infer R;
+  } ? R extends Record<string, infer E> ? E extends AuthEndpoint<infer C> ? { [K in C as K["path"]]?: {
+    window: number;
+    max: number;
+  } | false | ((request: HonoRequest<K["path"], CustomIO<K, "out">>) => {
+    window: number;
+    max: number;
+  } | false | Promise<{
+    window: number;
+    max: number;
+  } | false>); } : {} : {} : {} : {}>;
+};
+type Hooks = { [K in LiteralStringUnion<Routes>]?: FromFn<K extends Routes ? RouteHook<Config<K>> : DefaultHook> extends ((...args: infer A) => infer R) ? (...args: A) => R | void : never; };
+type DTO = { [K in LiteralStringUnion<Definitions>]?: K extends Definitions ? (typeof SCHEMAS)[K] extends {
+  default: infer D;
+} ? DTOTransformer<z$1.output<D & z$1.ZodType>> extends ((...args: infer A) => infer R) ? (...args: A) => R : never : never : (schema: any) => any | Promise<any>; };
+type Middleware = { [K in LiteralStringUnion<Routes>]?: K extends Routes ? RouteConfigToMiddleware<Config<K>> extends never ? MiddlewareHandler : RouteConfigToMiddleware<Config<K>> : MiddlewareHandler; };
+type CustomRules = { [K in LiteralStringUnion<Config<Routes>> as K extends AuthRouteConfig ? K["path"] : string]?: {
+  /**
+   * The window to use for the custom rule.
+   */
+  window: number;
+  /**
+   * The maximum number of requests allowed within the window.
+   */
+  max: number;
+} | false | ((request: K extends AuthRouteConfig ? RouteConfigToRequest<K> : HonoRequest) => {
+  window: number;
+  max: number;
+} | false | Promise<{
+  window: number;
+  max: number;
+} | false>); };
+interface FaireAuthRateLimitOptions extends FaireAuthRateLimitOptions$1 {
+  /**
+   * Custom rate limit rules to apply to
+   * specific paths.
+   */
+  customRules?: CustomRules | undefined;
+}
+interface FaireAuthOptions extends FaireAuthOptions$1<ContextVars> {
+  /**
+   * Post-validation route hooks for base or plugin routes.
+   *
+   * Route hooks run after request validation but before the handler runs.
+   * They allow you to modify the request data, handle errors, or perform
+   * additional logic based on the validation result.
+   *
+   * @example
+   * ```ts
+   * routeHooks: {
+   *   // Transform successful sign-up requests to add custom data
+   *   signUpEmail: (result, ctx) => {
+   *     if (result.success && result.target === 'json') {
+   *       result.data.customField = 'custom value';
+   *     }
+   *   },
+   *   // Handle validation errors with custom responses
+   *   signInEmail: (result, ctx) => {
+   *     if (!result.success) {
+   *       return ctx.json({
+   *         error: 'Custom error message',
+   *         details: result.error.errors
+   *       }, 400);
+   *     }
+   *   }
+   * }
+   * ```
+   *
+   * The hook receives:
+   * - `result`: Either `{ success: true, target: string, data: any }` for successful validation
+   *   or `{ success: false, error: ZodError }` for validation failures
+   * - `ctx`: The request context with methods like `ctx.json()` to return responses
+   *
+   * Hooks can return a response or undefined to continue with the original.
+   */
+  routeHooks?: Hooks;
+  /**
+   * Custom middleware for base or plugin routes.
+   *
+   * Middleware functions run before route handlers and can perform
+   * authentication, authorization, request modification, or early response.
+   * They execute in the order they are defined and can pass control
+   * to the next middleware or route handler.
+   *
+   * @example
+   * ```ts
+   * middleware: {
+   *   // Add custom authentication to specific routes
+   *   signUpEmail: createMiddleware<{ isAdmin: boolean }>()(async (ctx, next) => {
+   *     const user = ctx.get('user');
+   *     if (!user?.isAdmin) {
+   *       return ctx.json({ error: 'Admin access required' }, 403);
+   *     }
+   *     ctx.set("isAdmin", true)
+   *     return await next();
+   *   }),
+   *
+   *   // Add request logging
+   *   getSession: createMiddleware()(async (ctx, next) => {
+   *     const logger = ctx.get("context").logger
+   *     logger.info(`${ctx.req.method} ${ctx.req.path}`);
+   *     const start = Date.now();
+   *     await next();
+   *     logger.info(`Response time: ${Date.now() - start}ms`);
+   *   })
+   * }
+   * ```
+   *
+   * Common middleware patterns:
+   * - Authentication: Check user sessions, API keys, or tokens
+   * - Authorization: Verify user permissions or roles
+   * - Request processing: Parse, validate, or transform request data
+   * - Response modification: Add headers, CORS, or caching
+   * - Error handling: Catch and format errors consistently
+   *
+   * The middleware receives the request context and `next()` function.
+   * Call `await next()` to continue to the next middleware or route handler.
+   * Return a Response to stop processing and send an immediate response.
+   */
+  middleware?: Middleware;
+  /**
+   * Data Transfer Object (DTO) transformers that automatically transform
+   * response objects across all routes.
+   *
+   * DTO transformers can be synchronous or asynchronous and are perfect for:
+   * - Sanitizing data according to your operational security policy
+   *   (removing passwords, internal IDs)
+   * - Adding computed properties or metadata
+   * - Formatting data for client consumption
+   * - Implementing data access patterns
+   *
+   * @example
+   * ```ts
+   * dto: {
+   *   // Transform user objects to remove sensitive data
+   *   user: (user) => ({
+   *     ...user,
+   *     id: undefined,
+   *     email: user.email.toLowerCase(),
+   *     displayName: user.name || 'Anonymous',
+   *     isActive: true,
+   *     memberSince: user.createdAt.toISOString().split('T')[0]
+   *   }),
+   *
+   *   // Add metadata to session responses
+   *   session: (session) => ({
+   *     ...session,
+   *     expiresIn: Math.floor((session.expiresAt - Date.now()) / 1000),
+   *     isFresh: session.createdAt > new Date(Date.now() - 60000)
+   *   }),
+   *
+   *   // Async transformation for complex operations
+   *   account: async (account) => {
+   *     const providerInfo = await getProviderDetails(account.providerId);
+   *     return {
+   *       ...account,
+   *       providerName: providerInfo.name,
+   *       providerIcon: providerInfo.icon,
+   *       lastUsedFormatted: formatLastUsed(account.updatedAt)
+   *     };
+   *   }
+   * }
+   * ```
+   *
+   * Key features:
+   * - **Automatic nesting**: Works with nested response structures
+   * - **Type safety**: Preserves TypeScript types through transformations
+   * - **Performance**: Only transforms data that actually gets sent to clients
+   *   and the API
+   * - **Consistency**: Ensures all responses follow the same data format
+   *
+   * Common use cases:
+   * - Remove internal properties (passwords, tokens, metadata)
+   * - Format dates, numbers, and other display values
+   * - Add computed properties or relationships
+   * - Implement field-level access control
+   * - Standardize API response formats
+   */
+  dto?: DTO;
+  /**
+   * List of Faire Auth plugins
+   */
+  plugins?: FaireAuthPlugin[] | undefined;
+}
+type ClientRequestOptions<T = unknown> = {
+  fetch?: typeof fetch | HonoRequest$1;
+  webSocket?: (...args: ConstructorParameters<typeof WebSocket>) => WebSocket;
+  /**
+   * Standard `RequestInit`, caution that this take highest priority
+   * and could be used to overwrite things that Hono sets for you, like `body | method | headers`.
+   *
+   * If you want to add some headers, use in `headers` instead of `init`
+   */
+  init?: RequestInit;
+} & (keyof T extends never ? {
+  headers?: HeadersInit | (() => HeadersInit | Promise<HeadersInit>);
+} : {
+  headers: T | (() => T | Promise<T>);
+});
+type FetchOptions<Head = unknown, Body = any, Query extends Record<string, any> = any, Params extends Record<string, any> | Array<string> | undefined = any, Res = any, ExtraOptions extends Record<string, any> = {}> = {
+  fetchOptions?: ExK<BetterFetchOption<Body, Query, Params, Res, ExtraOptions>, "throw">;
+} & ClientRequestOptions<Head>;
+type FetchEsque = (input: string | URL | globalThis.Request, init?: RequestInit) => Promise<Response> | Response;
+interface AtomListener {
+  matcher: (path: string) => boolean;
+  signal: LiteralStringUnion<"$sessionSignal">;
+}
+interface Store {
+  notify: (signal: string) => void;
+  listen: (signal: string, listener: () => void) => void;
+  atoms: Record<string, WritableAtom<any>>;
+}
+interface FaireAuthClientPlugin {
+  id: LiteralString;
+  /**
+   * only used for type inference. don't pass the
+   * actual plugin
+   */
+  $InferServerPlugin?: FaireAuthPlugin;
+  /**
+   * Custom actions
+   */
+  getActions?: ($fetch: BetterFetch, $store: Store,
+  /**
+   * faire-auth client options
+   */
+  options: ClientOptions | undefined) => Record<string, any>;
+  /**
+   * State atoms that'll be resolved by each framework
+   * auth store.
+   */
+  getAtoms?: ($fetch: BetterFetch) => Record<string, Atom<any>>;
+  /**
+   * specify path methods for server plugin inferred
+   * endpoints to force a specific method.
+   */
+  pathMethods?: Record<string, "POST" | "GET">;
+  /**
+   * Better fetch plugins
+   */
+  fetchPlugins?: BetterFetchPlugin[];
+  /**
+   * a list of recaller based on a matcher function.
+   * The signal name needs to match a signal in this
+   * plugin or any plugin the user might have added.
+   */
+  atomListeners?: AtomListener[];
+}
+interface RevalidateOptions {
+  /**
+   * A time interval (in seconds) after which the session will be re-fetched.
+   * If set to `0` (default), the session is not polled.
+   *
+   * This helps prevent session expiry during idle periods by periodically
+   * refreshing the session.
+   *
+   * @default 0
+   */
+  refetchInterval?: number | undefined;
+  /**
+   * Automatically refetch the session when the user switches back to the window/tab.
+   * This option activates this behavior if set to `true` (default).
+   *
+   * Prevents expired sessions when users switch tabs and come back later.
+   *
+   * @default true
+   */
+  refetchOnWindowFocus?: boolean | undefined;
+  /**
+   * Set to `false` to stop polling when the device has no internet access
+   * (determined by `navigator.onLine`).
+   *
+   * @default false
+   * @see https://developer.mozilla.org/en-US/docs/Web/API/NavigatorOnLine/onLine
+   */
+  refetchWhenOffline?: boolean | undefined;
+}
+interface ClientOptions<S extends Schema$1 = Schema$1> {
+  fetchOptions?: Omit<CreateFetchOption, "schema" | "customFetchImpl"> & {
+    schema?: S;
+    customFetchImpl?: FetchEsque;
+  };
+  plugins?: FaireAuthClientPlugin[];
+  baseURL?: string;
+  basePath?: string;
+  disableDefaultFetchPlugins?: boolean;
+  $InferAuth?: FaireAuthOptions;
+  sessionOptions?: RevalidateOptions | undefined;
+}
+type InferActions<O extends ClientOptions> = O["plugins"] extends Array<infer Plugin> ? UnionToIntersection<Plugin extends FaireAuthClientPlugin ? Plugin["getActions"] extends ((...args: any) => infer Actions) ? Actions : {} : {}> : {};
+type InferErrorCodes<O extends ClientOptions> = O["plugins"] extends (infer Plugin)[] ? UnionToIntersection<Plugin extends FaireAuthClientPlugin ? Plugin["$InferServerPlugin"] extends FaireAuthPlugin ? Plugin["$InferServerPlugin"]["$ERROR_CODES"] : {} : {}> : {};
+/**
+ * signals are just used to recall a computed value.
+ * as a convention they start with "$"
+ */
+type IsSignal<T> = T extends `$${infer _}` ? true : false;
+type InferPluginsFromClient<O extends ClientOptions> = O["plugins"] extends FaireAuthClientPlugin[] ? O["plugins"][number]["$InferServerPlugin"][] : undefined;
+type InferSessionFromClient<O extends ClientOptions> = StripEmptyObjects<StrictSession & UnionToIntersection<InferAdditionalFromClient<O, "session">>>;
+type InferUserFromClient<O extends ClientOptions> = StripEmptyObjects<StrictUser & UnionToIntersection<InferAdditionalFromClient<O, "user">>>;
+type InferAdditionalFromClient<Options extends ClientOptions, Key extends string, Format extends "input" | "output" = "output"> = Options["plugins"] extends Array<infer T> ? T extends FaireAuthClientPlugin ? T["$InferServerPlugin"] extends {
+  schema: { [key in Key]: {
+    fields: infer Field;
+  }; };
+} ? Format extends "input" ? InferFieldsInputClient$1<Field> : InferFieldsOutput$1<Field> : {} : {} : {};
+type SessionQueryParams = {
+  disableCookieCache?: boolean;
+  disableRefresh?: boolean;
+};
+type InferAdditionalAsClient<Options extends FaireAuthOptions, Key extends string, Format extends "input" | "output" = "output"> = Options["plugins"] extends (infer T)[] ? T extends FaireAuthPlugin ? T extends {
+  schema: Record<Key, {
+    fields: infer Field;
+  }>;
+} ? Format extends "input" ? InferFieldsInputClient$1<Field> : InferFieldsOutput$1<Field> : {} : {} : {};
+type TransformToSchema<T> = { [K in keyof T]: T[K] extends Record<string, any> ? { [M in keyof T[K] as M extends `$${infer Method extends Methods}` ? `@${Method}/${K & string}` : never]: T[K][M] extends {
+  input: {
+    json?: infer Json;
+    cbor?: infer Cbor;
+    query?: infer Query;
+    param?: infer Param;
+  };
+  output: infer Output;
+  outputFormat?: string;
+  status?: number;
+} ? Prettify<{
+  method?: M extends `$${infer Method extends Methods}` ? Method : never;
+} & (Json extends Record<string, any> ? {
+  input: StandardSchemaV1<Json>;
+} : {}) & (Cbor extends Record<string, any> ? {
+  input: StandardSchemaV1<Cbor>;
+} : {}) & (Output extends Record<string, any> ? {
+  output: StandardSchemaV1<Output>;
+} : {}) & (Query extends Record<string, any> ? {
+  query: StandardSchemaV1<Query>;
+} : {}) & (Param extends Record<string, any> ? {
+  params: StandardSchemaV1<Param>;
+} : {})> : never; } : never; }[keyof T] extends (infer U) ? U extends Record<string, any> ? U : never : never;
+type FlattenRoutes<T> = T extends Record<string, any> ? (T extends any ? T : never) : never;
+type CreateSchemaType<T> = {
+  schema: FlattenRoutes<TransformToSchema<T>>;
+  config: SchemaConfig;
+};
+type S$1<T> = {
+  data: T;
+  error: null;
+};
+type E<Err, Stat extends ClientErrorStatusCode | ServerErrorStatusCode> = {
+  data: null;
+  error: Prettify<(Err extends Record<string, any> ? Err : {
+    message?: string;
+  }) & {
+    status: Stat;
+    statusText: string;
+  }>;
+};
+type BuildTuple<N extends number, Acc extends unknown[] = []> = Acc["length"] extends N ? Acc : BuildTuple<N, [...Acc, unknown]>;
+type Inc<A extends number> = [unknown, ...BuildTuple<A>]["length"] & number;
+type CamelCase<S extends string> = S extends `${infer P1}-${infer P2}${infer P3}` ? `${Lowercase<P1>}${Uppercase<P2>}${CamelCase<P3>}` : Lowercase<S>;
+type ExcludeServerPaths<T, P extends string> = T extends Record<string, infer EP> ? EP extends any ? EP extends {
+  SERVER_ONLY: true;
+} ? never : EP extends {
+  isAction: false;
+} ? never : P : never : never;
+type Segments<P extends string, O extends string[] = [], Depth extends number = 0> = P extends "" ? O : Depth extends 3 ? O : P extends `${infer First}/${infer Second}` ? Segments<Second, [...O, First], Inc<Depth>> : [...O, P];
+type BuildChain<Segs extends string[], BasePath extends string, Sch extends Schema, Original extends string, Throw extends boolean, Idx extends number = 0> = Idx extends Segs["length"] ? ClientRequest<string, Original, Sch[Original]> extends (infer I) ? { [K in keyof I]: I[K] extends ((...args: [infer In extends object, infer _Opt, ...infer Rest]) => Promise<infer Res>) ? <O extends FetchOptions<In extends {
+  header: infer H;
+} ? H : unknown, In extends {
+  json: infer J;
+} ? J : any, // | In["cbor"]
+  In extends {
+    query: infer Q;
+  } ? Q : any, In extends {
+    param: infer P;
+  } ? P : any, Res extends any ? Res extends ClientResponse<infer CRes, infer Stat, infer _F> ? Stat extends SuccessStatusCode ? CRes : never : never : never>>(...args: HasRequiredKeys<In> extends true ? [args: In, options?: O, ...Rest] : [options?: O, ...Rest]) => Promise<Res extends any ? Res extends ClientResponse<infer CRes, infer Stat, infer _F> ? Stat extends SuccessStatusCode ? Throw extends true ? CRes : S$1<CRes> : Stat extends ClientErrorStatusCode | ServerErrorStatusCode ? Throw extends true ? never : E<CRes, Stat> : never : Res : never> : I[K]; } : never : { [K in Segs[Idx] as ExcludeServerPaths<Sch[Original], CamelCase<K>>]: BuildChain<Segs, BasePath, Sch, Original, Throw, Inc<Idx>>; };
+type Relative<Path extends string, BasePath extends string> = BasePath extends "" ? Path : Path extends `${BasePath}/${infer Rest}` ? Rest : Path extends BasePath ? "" : Path;
+type PathToChain<Path extends string, BasePath extends string, E extends Schema, Original extends string = Path, Throw extends boolean = false> = BuildChain<Segments<Relative<Path, BasePath>>, BasePath, E, Original, Throw>;
+type Client<S, BasePath extends string, COpts extends ClientOptions> = UnionToIntersection<S extends Record<infer K, any> ? K extends string ? PathToChain<K, BasePath, S, K, COpts["fetchOptions"] extends {
+  throw: true;
+} ? true : false> : never : never>;
+type InferResolvedHooks<O extends ClientOptions> = O["plugins"] extends (infer Plugin)[] ? Plugin extends FaireAuthClientPlugin ? Plugin["getAtoms"] extends ((fetch: any) => infer Atoms) ? Atoms extends Record<string, any> ? { [key in keyof Atoms as IsSignal<key> extends true ? never : key extends string ? `use${Capitalize<key>}` : never]: Atoms[key]; } : {} : {} : {} : {};
+declare const createAuthClient: <App extends AnyHono = DefaultApp>() => <Option extends ClientOptions>(options: Option) => UnionToIntersection<InferResolvedHooks<Option>> & (App extends Hono<any, infer S extends import("hono").Schema, infer P extends string> ? UnionToIntersection<S_1 extends Record<infer K extends string | number | symbol, any> ? K extends string ? 0 extends (infer T) ? T extends 0 ? T extends ((BasePath extends "" ? K : K extends (infer T_1) ? T_1 extends K ? T_1 extends `${BasePath}/${infer Rest}` ? Rest : T_1 extends BasePath ? "" : T_1 : never : never) extends (infer T_2) ? T_2 extends (BasePath extends "" ? K : K extends (infer T_1) ? T_1 extends K ? T_1 extends `${BasePath}/${infer Rest}` ? Rest : T_1 extends BasePath ? "" : T_1 : never : never) ? T_2 extends "" ? [] : T_2 extends `${infer First}/${infer Second}` ? Second extends "" ? [First] : Second extends `${infer First}/${infer Second}` ? Second extends "" ? [First, First] : Second extends `${infer First}/${infer Second}` ? Second extends "" ? [First, First, First] : [First, First, First] : [First, First, Second] : [First, Second] : [T_2] : never : never)["length"] ? import("hono/client").ClientRequest<string, K, S_1[K]> extends (infer I) ? { [K_1 in keyof I]: I[K_1] extends ((args_0: infer In extends object, args_1: infer _Opt, ...args: infer Rest_1) => Promise<infer Res>) ? <O extends FetchOptions<In extends {
+  header: infer H;
+} ? H : unknown, In extends {
+  json: infer J;
+} ? J : any, In extends {
+  query: infer Q;
+} ? Q : any, In extends {
+  param: infer P_1;
+} ? P_1 : any, Res extends any ? Res extends import("hono/client").ClientResponse<infer CRes, infer Stat, infer _F> ? Stat extends import("hono/utils/http-status").SuccessStatusCode ? CRes : never : never : never>>(...args: import("hono/utils/types").HasRequiredKeys<In> extends true ? [args: In, options?: O, ...Rest_1] : [options?: O, ...Rest_1]) => Promise<Res extends any ? Res extends import("hono/client").ClientResponse<infer CRes, infer Stat extends number, infer _F extends string> ? Stat extends import("hono/utils/http-status").SuccessStatusCode ? (COpts["fetchOptions"] extends {
+  throw: true;
+} ? true : false) extends (infer T_3) ? T_3 extends (COpts["fetchOptions"] extends {
+  throw: true;
+} ? true : false) ? T_3 extends true ? CRes : {
+  data: CRes;
+  error: null;
+} : never : never : Stat extends import("hono/utils/http-status").ClientErrorStatusCode | import("hono/utils/http-status").ServerErrorStatusCode ? (COpts["fetchOptions"] extends {
+  throw: true;
+} ? true : false) extends (infer T_4) ? T_4 extends (COpts["fetchOptions"] extends {
+  throw: true;
+} ? true : false) ? T_4 extends true ? never : {
+  data: null;
+  error: Prettify<(Err extends Record<string, any> ? Err : {
+    message?: string;
+  }) & {
+    status: Stat_1;
+    statusText: string;
+  }>;
+} : never : never : never : Res : never> : I[K_1]; } : never : { [K_1 in ((BasePath extends "" ? K : K extends (infer T_1) ? T_1 extends K ? T_1 extends `${BasePath}/${infer Rest}` ? Rest : T_1 extends BasePath ? "" : T_1 : never : never) extends (infer T_2) ? T_2 extends (BasePath extends "" ? K : K extends (infer T_1) ? T_1 extends K ? T_1 extends `${BasePath}/${infer Rest}` ? Rest : T_1 extends BasePath ? "" : T_1 : never : never) ? T_2 extends "" ? [] : T_2 extends `${infer First}/${infer Second}` ? Second extends "" ? [First] : Second extends `${infer First}/${infer Second}` ? Second extends "" ? [First, First] : Second extends `${infer First}/${infer Second}` ? Second extends "" ? [First, First, First] : [First, First, First] : [First, First, Second] : [First, Second] : [T_2] : never : never)[T] as S_1[K] extends (infer T_3) ? T_3 extends S_1[K] ? T_3 extends Record<string, infer EP> ? EP extends any ? EP extends {
+  SERVER_ONLY: true;
+} ? never : EP extends {
+  isAction: false;
+} ? never : CamelCase<K_1> : never : never : never : never]: Inc<T> extends (infer T_4) ? T_4 extends Inc<T> ? T_4 extends ((BasePath extends "" ? K : K extends (infer T_1) ? T_1 extends K ? T_1 extends `${BasePath}/${infer Rest}` ? Rest : T_1 extends BasePath ? "" : T_1 : never : never) extends (infer T_2) ? T_2 extends (BasePath extends "" ? K : K extends (infer T_1) ? T_1 extends K ? T_1 extends `${BasePath}/${infer Rest}` ? Rest : T_1 extends BasePath ? "" : T_1 : never : never) ? T_2 extends "" ? [] : T_2 extends `${infer First}/${infer Second}` ? Second extends "" ? [First] : Second extends `${infer First}/${infer Second}` ? Second extends "" ? [First, First] : Second extends `${infer First}/${infer Second}` ? Second extends "" ? [First, First, First] : [First, First, First] : [First, First, Second] : [First, Second] : [T_2] : never : never)["length"] ? import("hono/client").ClientRequest<string, K, S_1[K]> extends (infer I) ? { [K_1 in keyof I]: I[K_1] extends ((args_0: infer In extends object, args_1: infer _Opt, ...args: infer Rest_1) => Promise<infer Res>) ? <O extends FetchOptions<In extends {
+  header: infer H;
+} ? H : unknown, In extends {
+  json: infer J;
+} ? J : any, In extends {
+  query: infer Q;
+} ? Q : any, In extends {
+  param: infer P_1;
+} ? P_1 : any, Res extends any ? Res extends import("hono/client").ClientResponse<infer CRes, infer Stat, infer _F> ? Stat extends import("hono/utils/http-status").SuccessStatusCode ? CRes : never : never : never>>(...args: import("hono/utils/types").HasRequiredKeys<In> extends true ? [args: In, options?: O, ...Rest_1] : [options?: O, ...Rest_1]) => Promise<Res extends any ? Res extends import("hono/client").ClientResponse<infer CRes, infer Stat extends number, infer _F extends string> ? Stat extends import("hono/utils/http-status").SuccessStatusCode ? (COpts["fetchOptions"] extends {
+  throw: true;
+} ? true : false) extends (infer T_3) ? T_3 extends (COpts["fetchOptions"] extends {
+  throw: true;
+} ? true : false) ? T_3 extends true ? CRes : {
+  data: CRes;
+  error: null;
+} : never : never : Stat extends import("hono/utils/http-status").ClientErrorStatusCode | import("hono/utils/http-status").ServerErrorStatusCode ? (COpts["fetchOptions"] extends {
+  throw: true;
+} ? true : false) extends (infer T_4) ? T_4 extends (COpts["fetchOptions"] extends {
+  throw: true;
+} ? true : false) ? T_4 extends true ? never : {
+  data: null;
+  error: Prettify<(Err extends Record<string, any> ? Err : {
+    message?: string;
+  }) & {
+    status: Stat_1;
+    statusText: string;
+  }>;
+} : never : never : never : Res : never> : I[K_1]; } : never : { [K_2 in ((BasePath extends "" ? K : K extends (infer T_1) ? T_1 extends K ? T_1 extends `${BasePath}/${infer Rest}` ? Rest : T_1 extends BasePath ? "" : T_1 : never : never) extends (infer T_2) ? T_2 extends (BasePath extends "" ? K : K extends (infer T_1) ? T_1 extends K ? T_1 extends `${BasePath}/${infer Rest}` ? Rest : T_1 extends BasePath ? "" : T_1 : never : never) ? T_2 extends "" ? [] : T_2 extends `${infer First}/${infer Second}` ? Second extends "" ? [First] : Second extends `${infer First}/${infer Second}` ? Second extends "" ? [First, First] : Second extends `${infer First}/${infer Second}` ? Second extends "" ? [First, First, First] : [First, First, First] : [First, First, Second] : [First, Second] : [T_2] : never : never)[T_4] as S_1[K] extends (infer T_5) ? T_5 extends S_1[K] ? T_5 extends Record<string, infer EP> ? EP extends any ? EP extends {
+  SERVER_ONLY: true;
+} ? never : EP extends {
+  isAction: false;
+} ? never : CamelCase<K_2> : never : never : never : never]: Inc<T_4> extends (infer T_6) ? T_6 extends Inc<T_4> ? T_6 extends ((BasePath extends "" ? K : K extends (infer T_1) ? T_1 extends K ? T_1 extends `${BasePath}/${infer Rest}` ? Rest : T_1 extends BasePath ? "" : T_1 : never : never) extends (infer T_2) ? T_2 extends (BasePath extends "" ? K : K extends (infer T_1) ? T_1 extends K ? T_1 extends `${BasePath}/${infer Rest}` ? Rest : T_1 extends BasePath ? "" : T_1 : never : never) ? T_2 extends "" ? [] : T_2 extends `${infer First}/${infer Second}` ? Second extends "" ? [First] : Second extends `${infer First}/${infer Second}` ? Second extends "" ? [First, First] : Second extends `${infer First}/${infer Second}` ? Second extends "" ? [First, First, First] : [First, First, First] : [First, First, Second] : [First, Second] : [T_2] : never : never)["length"] ? import("hono/client").ClientRequest<string, K, S_1[K]> extends (infer I) ? { [K_1 in keyof I]: I[K_1] extends ((args_0: infer In extends object, args_1: infer _Opt, ...args: infer Rest_1) => Promise<infer Res>) ? <O extends FetchOptions<In extends {
+  header: infer H;
+} ? H : unknown, In extends {
+  json: infer J;
+} ? J : any, In extends {
+  query: infer Q;
+} ? Q : any, In extends {
+  param: infer P_1;
+} ? P_1 : any, Res extends any ? Res extends import("hono/client").ClientResponse<infer CRes, infer Stat, infer _F> ? Stat extends import("hono/utils/http-status").SuccessStatusCode ? CRes : never : never : never>>(...args: import("hono/utils/types").HasRequiredKeys<In> extends true ? [args: In, options?: O, ...Rest_1] : [options?: O, ...Rest_1]) => Promise<Res extends any ? Res extends import("hono/client").ClientResponse<infer CRes, infer Stat extends number, infer _F extends string> ? Stat extends import("hono/utils/http-status").SuccessStatusCode ? (COpts["fetchOptions"] extends {
+  throw: true;
+} ? true : false) extends (infer T_3) ? T_3 extends (COpts["fetchOptions"] extends {
+  throw: true;
+} ? true : false) ? T_3 extends true ? CRes : {
+  data: CRes;
+  error: null;
+} : never : never : Stat extends import("hono/utils/http-status").ClientErrorStatusCode | import("hono/utils/http-status").ServerErrorStatusCode ? (COpts["fetchOptions"] extends {
+  throw: true;
+} ? true : false) extends (infer T_4) ? T_4 extends (COpts["fetchOptions"] extends {
+  throw: true;
+} ? true : false) ? T_4 extends true ? never : {
+  data: null;
+  error: Prettify<(Err extends Record<string, any> ? Err : {
+    message?: string;
+  }) & {
+    status: Stat_1;
+    statusText: string;
+  }>;
+} : never : never : never : Res : never> : I[K_1]; } : never : { [K_3 in ((BasePath extends "" ? K : K extends (infer T_1) ? T_1 extends K ? T_1 extends `${BasePath}/${infer Rest}` ? Rest : T_1 extends BasePath ? "" : T_1 : never : never) extends (infer T_2) ? T_2 extends (BasePath extends "" ? K : K extends (infer T_1) ? T_1 extends K ? T_1 extends `${BasePath}/${infer Rest}` ? Rest : T_1 extends BasePath ? "" : T_1 : never : never) ? T_2 extends "" ? [] : T_2 extends `${infer First}/${infer Second}` ? Second extends "" ? [First] : Second extends `${infer First}/${infer Second}` ? Second extends "" ? [First, First] : Second extends `${infer First}/${infer Second}` ? Second extends "" ? [First, First, First] : [First, First, First] : [First, First, Second] : [First, Second] : [T_2] : never : never)[T_6] as S_1[K] extends (infer T_7) ? T_7 extends S_1[K] ? T_7 extends Record<string, infer EP> ? EP extends any ? EP extends {
+  SERVER_ONLY: true;
+} ? never : EP extends {
+  isAction: false;
+} ? never : CamelCase<K_3> : never : never : never : never]: Inc<T_6> extends (infer T_8) ? T_8 extends Inc<T_6> ? T_8 extends ((BasePath extends "" ? K : K extends (infer T_1) ? T_1 extends K ? T_1 extends `${BasePath}/${infer Rest}` ? Rest : T_1 extends BasePath ? "" : T_1 : never : never) extends (infer T_2) ? T_2 extends (BasePath extends "" ? K : K extends (infer T_1) ? T_1 extends K ? T_1 extends `${BasePath}/${infer Rest}` ? Rest : T_1 extends BasePath ? "" : T_1 : never : never) ? T_2 extends "" ? [] : T_2 extends `${infer First}/${infer Second}` ? Second extends "" ? [First] : Second extends `${infer First}/${infer Second}` ? Second extends "" ? [First, First] : Second extends `${infer First}/${infer Second}` ? Second extends "" ? [First, First, First] : [First, First, First] : [First, First, Second] : [First, Second] : [T_2] : never : never)["length"] ? import("hono/client").ClientRequest<string, K, S_1[K]> extends (infer I) ? { [K_1 in keyof I]: I[K_1] extends ((args_0: infer In extends object, args_1: infer _Opt, ...args: infer Rest_1) => Promise<infer Res>) ? <O extends FetchOptions<In extends {
+  header: infer H;
+} ? H : unknown, In extends {
+  json: infer J;
+} ? J : any, In extends {
+  query: infer Q;
+} ? Q : any, In extends {
+  param: infer P_1;
+} ? P_1 : any, Res extends any ? Res extends import("hono/client").ClientResponse<infer CRes, infer Stat, infer _F> ? Stat extends import("hono/utils/http-status").SuccessStatusCode ? CRes : never : never : never>>(...args: import("hono/utils/types").HasRequiredKeys<In> extends true ? [args: In, options?: O, ...Rest_1] : [options?: O, ...Rest_1]) => Promise<Res extends any ? Res extends import("hono/client").ClientResponse<infer CRes, infer Stat extends number, infer _F extends string> ? Stat extends import("hono/utils/http-status").SuccessStatusCode ? (COpts["fetchOptions"] extends {
+  throw: true;
+} ? true : false) extends (infer T_3) ? T_3 extends (COpts["fetchOptions"] extends {
+  throw: true;
+} ? true : false) ? T_3 extends true ? CRes : {
+  data: CRes;
+  error: null;
+} : never : never : Stat extends import("hono/utils/http-status").ClientErrorStatusCode | import("hono/utils/http-status").ServerErrorStatusCode ? (COpts["fetchOptions"] extends {
+  throw: true;
+} ? true : false) extends (infer T_4) ? T_4 extends (COpts["fetchOptions"] extends {
+  throw: true;
+} ? true : false) ? T_4 extends true ? never : {
+  data: null;
+  error: Prettify<(Err extends Record<string, any> ? Err : {
+    message?: string;
+  }) & {
+    status: Stat_1;
+    statusText: string;
+  }>;
+} : never : never : never : Res : never> : I[K_1]; } : never : { [K_4 in ((BasePath extends "" ? K : K extends (infer T_1) ? T_1 extends K ? T_1 extends `${BasePath}/${infer Rest}` ? Rest : T_1 extends BasePath ? "" : T_1 : never : never) extends (infer T_2) ? T_2 extends (BasePath extends "" ? K : K extends (infer T_1) ? T_1 extends K ? T_1 extends `${BasePath}/${infer Rest}` ? Rest : T_1 extends BasePath ? "" : T_1 : never : never) ? T_2 extends "" ? [] : T_2 extends `${infer First}/${infer Second}` ? Second extends "" ? [First] : Second extends `${infer First}/${infer Second}` ? Second extends "" ? [First, First] : Second extends `${infer First}/${infer Second}` ? Second extends "" ? [First, First, First] : [First, First, First] : [First, First, Second] : [First, Second] : [T_2] : never : never)[T_8] as S_1[K] extends (infer T_9) ? T_9 extends S_1[K] ? T_9 extends Record<string, infer EP> ? EP extends any ? EP extends {
+  SERVER_ONLY: true;
+} ? never : EP extends {
+  isAction: false;
+} ? never : CamelCase<K_4> : never : never : never : never]: Inc<T_8> extends (infer T_10) ? T_10 extends Inc<T_8> ? T_10 extends ((BasePath extends "" ? K : K extends (infer T_1) ? T_1 extends K ? T_1 extends `${BasePath}/${infer Rest}` ? Rest : T_1 extends BasePath ? "" : T_1 : never : never) extends (infer T_2) ? T_2 extends (BasePath extends "" ? K : K extends (infer T_1) ? T_1 extends K ? T_1 extends `${BasePath}/${infer Rest}` ? Rest : T_1 extends BasePath ? "" : T_1 : never : never) ? T_2 extends "" ? [] : T_2 extends `${infer First}/${infer Second}` ? Second extends "" ? [First] : Second extends `${infer First}/${infer Second}` ? Second extends "" ? [First, First] : Second extends `${infer First}/${infer Second}` ? Second extends "" ? [First, First, First] : [First, First, First] : [First, First, Second] : [First, Second] : [T_2] : never : never)["length"] ? import("hono/client").ClientRequest<string, K, S_1[K]> extends (infer I) ? { [K_1 in keyof I]: I[K_1] extends ((args_0: infer In extends object, args_1: infer _Opt, ...args: infer Rest_1) => Promise<infer Res>) ? <O extends FetchOptions<In extends {
+  header: infer H;
+} ? H : unknown, In extends {
+  json: infer J;
+} ? J : any, In extends {
+  query: infer Q;
+} ? Q : any, In extends {
+  param: infer P_1;
+} ? P_1 : any, Res extends any ? Res extends import("hono/client").ClientResponse<infer CRes, infer Stat, infer _F> ? Stat extends import("hono/utils/http-status").SuccessStatusCode ? CRes : never : never : never>>(...args: import("hono/utils/types").HasRequiredKeys<In> extends true ? [args: In, options?: O, ...Rest_1] : [options?: O, ...Rest_1]) => Promise<Res extends any ? Res extends import("hono/client").ClientResponse<infer CRes, infer Stat extends number, infer _F extends string> ? Stat extends import("hono/utils/http-status").SuccessStatusCode ? (COpts["fetchOptions"] extends {
+  throw: true;
+} ? true : false) extends (infer T_3) ? T_3 extends (COpts["fetchOptions"] extends {
+  throw: true;
+} ? true : false) ? T_3 extends true ? CRes : {
+  data: CRes;
+  error: null;
+} : never : never : Stat extends import("hono/utils/http-status").ClientErrorStatusCode | import("hono/utils/http-status").ServerErrorStatusCode ? (COpts["fetchOptions"] extends {
+  throw: true;
+} ? true : false) extends (infer T_4) ? T_4 extends (COpts["fetchOptions"] extends {
+  throw: true;
+} ? true : false) ? T_4 extends true ? never : {
+  data: null;
+  error: Prettify<(Err extends Record<string, any> ? Err : {
+    message?: string;
+  }) & {
+    status: Stat_1;
+    statusText: string;
+  }>;
+} : never : never : never : Res : never> : I[K_1]; } : never : { [K_5 in ((BasePath extends "" ? K : K extends (infer T_1) ? T_1 extends K ? T_1 extends `${BasePath}/${infer Rest}` ? Rest : T_1 extends BasePath ? "" : T_1 : never : never) extends (infer T_2) ? T_2 extends (BasePath extends "" ? K : K extends (infer T_1) ? T_1 extends K ? T_1 extends `${BasePath}/${infer Rest}` ? Rest : T_1 extends BasePath ? "" : T_1 : never : never) ? T_2 extends "" ? [] : T_2 extends `${infer First}/${infer Second}` ? Second extends "" ? [First] : Second extends `${infer First}/${infer Second}` ? Second extends "" ? [First, First] : Second extends `${infer First}/${infer Second}` ? Second extends "" ? [First, First, First] : [First, First, First] : [First, First, Second] : [First, Second] : [T_2] : never : never)[T_10] as S_1[K] extends (infer T_11) ? T_11 extends S_1[K] ? T_11 extends Record<string, infer EP> ? EP extends any ? EP extends {
+  SERVER_ONLY: true;
+} ? never : EP extends {
+  isAction: false;
+} ? never : CamelCase<K_5> : never : never : never : never]: Inc<T_10> extends (infer T_12) ? T_12 extends Inc<T_10> ? T_12 extends ((BasePath extends "" ? K : K extends (infer T_1) ? T_1 extends K ? T_1 extends `${BasePath}/${infer Rest}` ? Rest : T_1 extends BasePath ? "" : T_1 : never : never) extends (infer T_2) ? T_2 extends (BasePath extends "" ? K : K extends (infer T_1) ? T_1 extends K ? T_1 extends `${BasePath}/${infer Rest}` ? Rest : T_1 extends BasePath ? "" : T_1 : never : never) ? T_2 extends "" ? [] : T_2 extends `${infer First}/${infer Second}` ? Second extends "" ? [First] : Second extends `${infer First}/${infer Second}` ? Second extends "" ? [First, First] : Second extends `${infer First}/${infer Second}` ? Second extends "" ? [First, First, First] : [First, First, First] : [First, First, Second] : [First, Second] : [T_2] : never : never)["length"] ? import("hono/client").ClientRequest<string, K, S_1[K]> extends (infer I) ? { [K_1 in keyof I]: I[K_1] extends ((args_0: infer In extends object, args_1: infer _Opt, ...args: infer Rest_1) => Promise<infer Res>) ? <O extends FetchOptions<In extends {
+  header: infer H;
+} ? H : unknown, In extends {
+  json: infer J;
+} ? J : any, In extends {
+  query: infer Q;
+} ? Q : any, In extends {
+  param: infer P_1;
+} ? P_1 : any, Res extends any ? Res extends import("hono/client").ClientResponse<infer CRes, infer Stat, infer _F> ? Stat extends import("hono/utils/http-status").SuccessStatusCode ? CRes : never : never : never>>(...args: import("hono/utils/types").HasRequiredKeys<In> extends true ? [args: In, options?: O, ...Rest_1] : [options?: O, ...Rest_1]) => Promise<Res extends any ? Res extends import("hono/client").ClientResponse<infer CRes, infer Stat extends number, infer _F extends string> ? Stat extends import("hono/utils/http-status").SuccessStatusCode ? (COpts["fetchOptions"] extends {
+  throw: true;
+} ? true : false) extends (infer T_3) ? T_3 extends (COpts["fetchOptions"] extends {
+  throw: true;
+} ? true : false) ? T_3 extends true ? CRes : {
+  data: CRes;
+  error: null;
+} : never : never : Stat extends import("hono/utils/http-status").ClientErrorStatusCode | import("hono/utils/http-status").ServerErrorStatusCode ? (COpts["fetchOptions"] extends {
+  throw: true;
+} ? true : false) extends (infer T_4) ? T_4 extends (COpts["fetchOptions"] extends {
+  throw: true;
+} ? true : false) ? T_4 extends true ? never : {
+  data: null;
+  error: Prettify<(Err extends Record<string, any> ? Err : {
+    message?: string;
+  }) & {
+    status: Stat_1;
+    statusText: string;
+  }>;
+} : never : never : never : Res : never> : I[K_1]; } : never : { [K_6 in ((BasePath extends "" ? K : K extends (infer T_1) ? T_1 extends K ? T_1 extends `${BasePath}/${infer Rest}` ? Rest : T_1 extends BasePath ? "" : T_1 : never : never) extends (infer T_2) ? T_2 extends (BasePath extends "" ? K : K extends (infer T_1) ? T_1 extends K ? T_1 extends `${BasePath}/${infer Rest}` ? Rest : T_1 extends BasePath ? "" : T_1 : never : never) ? T_2 extends "" ? [] : T_2 extends `${infer First}/${infer Second}` ? Second extends "" ? [First] : Second extends `${infer First}/${infer Second}` ? Second extends "" ? [First, First] : Second extends `${infer First}/${infer Second}` ? Second extends "" ? [First, First, First] : [First, First, First] : [First, First, Second] : [First, Second] : [T_2] : never : never)[T_12] as S_1[K] extends (infer T_13) ? T_13 extends S_1[K] ? T_13 extends Record<string, infer EP> ? EP extends any ? EP extends {
+  SERVER_ONLY: true;
+} ? never : EP extends {
+  isAction: false;
+} ? never : CamelCase<K_6> : never : never : never : never]: Inc<T_12> extends (infer T_14) ? T_14 extends Inc<T_12> ? T_14 extends ((BasePath extends "" ? K : K extends (infer T_1) ? T_1 extends K ? T_1 extends `${BasePath}/${infer Rest}` ? Rest : T_1 extends BasePath ? "" : T_1 : never : never) extends (infer T_2) ? T_2 extends (BasePath extends "" ? K : K extends (infer T_1) ? T_1 extends K ? T_1 extends `${BasePath}/${infer Rest}` ? Rest : T_1 extends BasePath ? "" : T_1 : never : never) ? T_2 extends "" ? [] : T_2 extends `${infer First}/${infer Second}` ? Second extends "" ? [First] : Second extends `${infer First}/${infer Second}` ? Second extends "" ? [First, First] : Second extends `${infer First}/${infer Second}` ? Second extends "" ? [First, First, First] : [First, First, First] : [First, First, Second] : [First, Second] : [T_2] : never : never)["length"] ? import("hono/client").ClientRequest<string, K, S_1[K]> extends (infer I) ? { [K_1 in keyof I]: I[K_1] extends ((args_0: infer In extends object, args_1: infer _Opt, ...args: infer Rest_1) => Promise<infer Res>) ? <O extends FetchOptions<In extends {
+  header: infer H;
+} ? H : unknown, In extends {
+  json: infer J;
+} ? J : any, In extends {
+  query: infer Q;
+} ? Q : any, In extends {
+  param: infer P_1;
+} ? P_1 : any, Res extends any ? Res extends import("hono/client").ClientResponse<infer CRes, infer Stat, infer _F> ? Stat extends import("hono/utils/http-status").SuccessStatusCode ? CRes : never : never : never>>(...args: import("hono/utils/types").HasRequiredKeys<In> extends true ? [args: In, options?: O, ...Rest_1] : [options?: O, ...Rest_1]) => Promise<Res extends any ? Res extends import("hono/client").ClientResponse<infer CRes, infer Stat extends number, infer _F extends string> ? Stat extends import("hono/utils/http-status").SuccessStatusCode ? (COpts["fetchOptions"] extends {
+  throw: true;
+} ? true : false) extends (infer T_3) ? T_3 extends (COpts["fetchOptions"] extends {
+  throw: true;
+} ? true : false) ? T_3 extends true ? CRes : {
+  data: CRes;
+  error: null;
+} : never : never : Stat extends import("hono/utils/http-status").ClientErrorStatusCode | import("hono/utils/http-status").ServerErrorStatusCode ? (COpts["fetchOptions"] extends {
+  throw: true;
+} ? true : false) extends (infer T_4) ? T_4 extends (COpts["fetchOptions"] extends {
+  throw: true;
+} ? true : false) ? T_4 extends true ? never : {
+  data: null;
+  error: Prettify<(Err extends Record<string, any> ? Err : {
+    message?: string;
+  }) & {
+    status: Stat_1;
+    statusText: string;
+  }>;
+} : never : never : never : Res : never> : I[K_1]; } : never : { [K_7 in ((BasePath extends "" ? K : K extends (infer T_1) ? T_1 extends K ? T_1 extends `${BasePath}/${infer Rest}` ? Rest : T_1 extends BasePath ? "" : T_1 : never : never) extends (infer T_2) ? T_2 extends (BasePath extends "" ? K : K extends (infer T_1) ? T_1 extends K ? T_1 extends `${BasePath}/${infer Rest}` ? Rest : T_1 extends BasePath ? "" : T_1 : never : never) ? T_2 extends "" ? [] : T_2 extends `${infer First}/${infer Second}` ? Second extends "" ? [First] : Second extends `${infer First}/${infer Second}` ? Second extends "" ? [First, First] : Second extends `${infer First}/${infer Second}` ? Second extends "" ? [First, First, First] : [First, First, First] : [First, First, Second] : [First, Second] : [T_2] : never : never)[T_14] as S_1[K] extends (infer T_15) ? T_15 extends S_1[K] ? T_15 extends Record<string, infer EP> ? EP extends any ? EP extends {
+  SERVER_ONLY: true;
+} ? never : EP extends {
+  isAction: false;
+} ? never : CamelCase<K_7> : never : never : never : never]: Inc<T_14> extends (infer T_16) ? T_16 extends Inc<T_14> ? T_16 extends ((BasePath extends "" ? K : K extends (infer T_1) ? T_1 extends K ? T_1 extends `${BasePath}/${infer Rest}` ? Rest : T_1 extends BasePath ? "" : T_1 : never : never) extends (infer T_2) ? T_2 extends (BasePath extends "" ? K : K extends (infer T_1) ? T_1 extends K ? T_1 extends `${BasePath}/${infer Rest}` ? Rest : T_1 extends BasePath ? "" : T_1 : never : never) ? T_2 extends "" ? [] : T_2 extends `${infer First}/${infer Second}` ? Second extends "" ? [First] : Second extends `${infer First}/${infer Second}` ? Second extends "" ? [First, First] : Second extends `${infer First}/${infer Second}` ? Second extends "" ? [First, First, First] : [First, First, First] : [First, First, Second] : [First, Second] : [T_2] : never : never)["length"] ? import("hono/client").ClientRequest<string, K, S_1[K]> extends (infer I) ? { [K_1 in keyof I]: I[K_1] extends ((args_0: infer In extends object, args_1: infer _Opt, ...args: infer Rest_1) => Promise<infer Res>) ? <O extends FetchOptions<In extends {
+  header: infer H;
+} ? H : unknown, In extends {
+  json: infer J;
+} ? J : any, In extends {
+  query: infer Q;
+} ? Q : any, In extends {
+  param: infer P_1;
+} ? P_1 : any, Res extends any ? Res extends import("hono/client").ClientResponse<infer CRes, infer Stat, infer _F> ? Stat extends import("hono/utils/http-status").SuccessStatusCode ? CRes : never : never : never>>(...args: import("hono/utils/types").HasRequiredKeys<In> extends true ? [args: In, options?: O, ...Rest_1] : [options?: O, ...Rest_1]) => Promise<Res extends any ? Res extends import("hono/client").ClientResponse<infer CRes, infer Stat extends number, infer _F extends string> ? Stat extends import("hono/utils/http-status").SuccessStatusCode ? (COpts["fetchOptions"] extends {
+  throw: true;
+} ? true : false) extends (infer T_3) ? T_3 extends (COpts["fetchOptions"] extends {
+  throw: true;
+} ? true : false) ? T_3 extends true ? CRes : {
+  data: CRes;
+  error: null;
+} : never : never : Stat extends import("hono/utils/http-status").ClientErrorStatusCode | import("hono/utils/http-status").ServerErrorStatusCode ? (COpts["fetchOptions"] extends {
+  throw: true;
+} ? true : false) extends (infer T_4) ? T_4 extends (COpts["fetchOptions"] extends {
+  throw: true;
+} ? true : false) ? T_4 extends true ? never : {
+  data: null;
+  error: Prettify<(Err extends Record<string, any> ? Err : {
+    message?: string;
+  }) & {
+    status: Stat_1;
+    statusText: string;
+  }>;
+} : never : never : never : Res : never> : I[K_1]; } : never : { [K_8 in ((BasePath extends "" ? K : K extends (infer T_1) ? T_1 extends K ? T_1 extends `${BasePath}/${infer Rest}` ? Rest : T_1 extends BasePath ? "" : T_1 : never : never) extends (infer T_2) ? T_2 extends (BasePath extends "" ? K : K extends (infer T_1) ? T_1 extends K ? T_1 extends `${BasePath}/${infer Rest}` ? Rest : T_1 extends BasePath ? "" : T_1 : never : never) ? T_2 extends "" ? [] : T_2 extends `${infer First}/${infer Second}` ? Second extends "" ? [First] : Second extends `${infer First}/${infer Second}` ? Second extends "" ? [First, First] : Second extends `${infer First}/${infer Second}` ? Second extends "" ? [First, First, First] : [First, First, First] : [First, First, Second] : [First, Second] : [T_2] : never : never)[T_16] as S_1[K] extends (infer T_17) ? T_17 extends S_1[K] ? T_17 extends Record<string, infer EP> ? EP extends any ? EP extends {
+  SERVER_ONLY: true;
+} ? never : EP extends {
+  isAction: false;
+} ? never : CamelCase<K_8> : never : never : never : never]: Inc<T_16> extends (infer T_18) ? T_18 extends Inc<T_16> ? T_18 extends ((BasePath extends "" ? K : K extends (infer T_1) ? T_1 extends K ? T_1 extends `${BasePath}/${infer Rest}` ? Rest : T_1 extends BasePath ? "" : T_1 : never : never) extends (infer T_2) ? T_2 extends (BasePath extends "" ? K : K extends (infer T_1) ? T_1 extends K ? T_1 extends `${BasePath}/${infer Rest}` ? Rest : T_1 extends BasePath ? "" : T_1 : never : never) ? T_2 extends "" ? [] : T_2 extends `${infer First}/${infer Second}` ? Second extends "" ? [First] : Second extends `${infer First}/${infer Second}` ? Second extends "" ? [First, First] : Second extends `${infer First}/${infer Second}` ? Second extends "" ? [First, First, First] : [First, First, First] : [First, First, Second] : [First, Second] : [T_2] : never : never)["length"] ? import("hono/client").ClientRequest<string, K, S_1[K]> extends (infer I) ? { [K_1 in keyof I]: I[K_1] extends ((args_0: infer In extends object, args_1: infer _Opt, ...args: infer Rest_1) => Promise<infer Res>) ? <O extends FetchOptions<In extends {
+  header: infer H;
+} ? H : unknown, In extends {
+  json: infer J;
+} ? J : any, In extends {
+  query: infer Q;
+} ? Q : any, In extends {
+  param: infer P_1;
+} ? P_1 : any, Res extends any ? Res extends import("hono/client").ClientResponse<infer CRes, infer Stat, infer _F> ? Stat extends import("hono/utils/http-status").SuccessStatusCode ? CRes : never : never : never>>(...args: import("hono/utils/types").HasRequiredKeys<In> extends true ? [args: In, options?: O, ...Rest_1] : [options?: O, ...Rest_1]) => Promise<Res extends any ? Res extends import("hono/client").ClientResponse<infer CRes, infer Stat extends number, infer _F extends string> ? Stat extends import("hono/utils/http-status").SuccessStatusCode ? (COpts["fetchOptions"] extends {
+  throw: true;
+} ? true : false) extends (infer T_3) ? T_3 extends (COpts["fetchOptions"] extends {
+  throw: true;
+} ? true : false) ? T_3 extends true ? CRes : {
+  data: CRes;
+  error: null;
+} : never : never : Stat extends import("hono/utils/http-status").ClientErrorStatusCode | import("hono/utils/http-status").ServerErrorStatusCode ? (COpts["fetchOptions"] extends {
+  throw: true;
+} ? true : false) extends (infer T_4) ? T_4 extends (COpts["fetchOptions"] extends {
+  throw: true;
+} ? true : false) ? T_4 extends true ? never : {
+  data: null;
+  error: Prettify<(Err extends Record<string, any> ? Err : {
+    message?: string;
+  }) & {
+    status: Stat_1;
+    statusText: string;
+  }>;
+} : never : never : never : Res : never> : I[K_1]; } : never : { [K_9 in ((BasePath extends "" ? K : K extends (infer T_1) ? T_1 extends K ? T_1 extends `${BasePath}/${infer Rest}` ? Rest : T_1 extends BasePath ? "" : T_1 : never : never) extends (infer T_2) ? T_2 extends (BasePath extends "" ? K : K extends (infer T_1) ? T_1 extends K ? T_1 extends `${BasePath}/${infer Rest}` ? Rest : T_1 extends BasePath ? "" : T_1 : never : never) ? T_2 extends "" ? [] : T_2 extends `${infer First}/${infer Second}` ? Second extends "" ? [First] : Second extends `${infer First}/${infer Second}` ? Second extends "" ? [First, First] : Second extends `${infer First}/${infer Second}` ? Second extends "" ? [First, First, First] : [First, First, First] : [First, First, Second] : [First, Second] : [T_2] : never : never)[T_18] as S_1[K] extends (infer T_19) ? T_19 extends S_1[K] ? T_19 extends Record<string, infer EP> ? EP extends any ? EP extends {
+  SERVER_ONLY: true;
+} ? never : EP extends {
+  isAction: false;
+} ? never : CamelCase<K_9> : never : never : never : never]: Inc<T_18> extends (infer T_20) ? T_20 extends Inc<T_18> ? T_20 extends ((BasePath extends "" ? K : K extends (infer T_1) ? T_1 extends K ? T_1 extends `${BasePath}/${infer Rest}` ? Rest : T_1 extends BasePath ? "" : T_1 : never : never) extends (infer T_2) ? T_2 extends (BasePath extends "" ? K : K extends (infer T_1) ? T_1 extends K ? T_1 extends `${BasePath}/${infer Rest}` ? Rest : T_1 extends BasePath ? "" : T_1 : never : never) ? T_2 extends "" ? [] : T_2 extends `${infer First}/${infer Second}` ? Second extends "" ? [First] : Second extends `${infer First}/${infer Second}` ? Second extends "" ? [First, First] : Second extends `${infer First}/${infer Second}` ? Second extends "" ? [First, First, First] : [First, First, First] : [First, First, Second] : [First, Second] : [T_2] : never : never)["length"] ? import("hono/client").ClientRequest<string, K, S_1[K]> extends (infer I) ? { [K_1 in keyof I]: I[K_1] extends ((args_0: infer In extends object, args_1: infer _Opt, ...args: infer Rest_1) => Promise<infer Res>) ? <O extends FetchOptions<In extends {
+  header: infer H;
+} ? H : unknown, In extends {
+  json: infer J;
+} ? J : any, In extends {
+  query: infer Q;
+} ? Q : any, In extends {
+  param: infer P_1;
+} ? P_1 : any, Res extends any ? Res extends import("hono/client").ClientResponse<infer CRes, infer Stat, infer _F> ? Stat extends import("hono/utils/http-status").SuccessStatusCode ? CRes : never : never : never>>(...args: import("hono/utils/types").HasRequiredKeys<In> extends true ? [args: In, options?: O, ...Rest_1] : [options?: O, ...Rest_1]) => Promise<Res extends any ? Res extends import("hono/client").ClientResponse<infer CRes, infer Stat extends number, infer _F extends string> ? Stat extends import("hono/utils/http-status").SuccessStatusCode ? (COpts["fetchOptions"] extends {
+  throw: true;
+} ? true : false) extends (infer T_3) ? T_3 extends (COpts["fetchOptions"] extends {
+  throw: true;
+} ? true : false) ? T_3 extends true ? CRes : {
+  data: CRes;
+  error: null;
+} : never : never : Stat extends import("hono/utils/http-status").ClientErrorStatusCode | import("hono/utils/http-status").ServerErrorStatusCode ? (COpts["fetchOptions"] extends {
+  throw: true;
+} ? true : false) extends (infer T_4) ? T_4 extends (COpts["fetchOptions"] extends {
+  throw: true;
+} ? true : false) ? T_4 extends true ? never : {
+  data: null;
+  error: Prettify<(Err extends Record<string, any> ? Err : {
+    message?: string;
+  }) & {
+    status: Stat_1;
+    statusText: string;
+  }>;
+} : never : never : never : Res : never> : I[K_1]; } : never : { [K_10 in ((BasePath extends "" ? K : K extends (infer T_1) ? T_1 extends K ? T_1 extends `${BasePath}/${infer Rest}` ? Rest : T_1 extends BasePath ? "" : T_1 : never : never) extends (infer T_2) ? T_2 extends (BasePath extends "" ? K : K extends (infer T_1) ? T_1 extends K ? T_1 extends `${BasePath}/${infer Rest}` ? Rest : T_1 extends BasePath ? "" : T_1 : never : never) ? T_2 extends "" ? [] : T_2 extends `${infer First}/${infer Second}` ? Second extends "" ? [First] : Second extends `${infer First}/${infer Second}` ? Second extends "" ? [First, First] : Second extends `${infer First}/${infer Second}` ? Second extends "" ? [First, First, First] : [First, First, First] : [First, First, Second] : [First, Second] : [T_2] : never : never)[T_20] as S_1[K] extends (infer T_21) ? T_21 extends S_1[K] ? T_21 extends Record<string, infer EP> ? EP extends any ? EP extends {
+  SERVER_ONLY: true;
+} ? never : EP extends {
+  isAction: false;
+} ? never : CamelCase<K_10> : never : never : never : never]: Inc<T_20> extends (infer T_22) ? T_22 extends Inc<T_20> ? T_22 extends ((BasePath extends "" ? K : K extends (infer T_1) ? T_1 extends K ? T_1 extends `${BasePath}/${infer Rest}` ? Rest : T_1 extends BasePath ? "" : T_1 : never : never) extends (infer T_2) ? T_2 extends (BasePath extends "" ? K : K extends (infer T_1) ? T_1 extends K ? T_1 extends `${BasePath}/${infer Rest}` ? Rest : T_1 extends BasePath ? "" : T_1 : never : never) ? T_2 extends "" ? [] : T_2 extends `${infer First}/${infer Second}` ? Second extends "" ? [First] : Second extends `${infer First}/${infer Second}` ? Second extends "" ? [First, First] : Second extends `${infer First}/${infer Second}` ? Second extends "" ? [First, First, First] : [First, First, First] : [First, First, Second] : [First, Second] : [T_2] : never : never)["length"] ? import("hono/client").ClientRequest<string, K, S_1[K]> extends (infer I) ? { [K_1 in keyof I]: I[K_1] extends ((args_0: infer In extends object, args_1: infer _Opt, ...args: infer Rest_1) => Promise<infer Res>) ? <O extends FetchOptions<In extends {
+  header: infer H;
+} ? H : unknown, In extends {
+  json: infer J;
+} ? J : any, In extends {
+  query: infer Q;
+} ? Q : any, In extends {
+  param: infer P_1;
+} ? P_1 : any, Res extends any ? Res extends import("hono/client").ClientResponse<infer CRes, infer Stat, infer _F> ? Stat extends import("hono/utils/http-status").SuccessStatusCode ? CRes : never : never : never>>(...args: import("hono/utils/types").HasRequiredKeys<In> extends true ? [args: In, options?: O, ...Rest_1] : [options?: O, ...Rest_1]) => Promise<Res extends any ? Res extends import("hono/client").ClientResponse<infer CRes, infer Stat extends number, infer _F extends string> ? Stat extends import("hono/utils/http-status").SuccessStatusCode ? (COpts["fetchOptions"] extends {
+  throw: true;
+} ? true : false) extends (infer T_3) ? T_3 extends (COpts["fetchOptions"] extends {
+  throw: true;
+} ? true : false) ? T_3 extends true ? CRes : {
+  data: CRes;
+  error: null;
+} : never : never : Stat extends import("hono/utils/http-status").ClientErrorStatusCode | import("hono/utils/http-status").ServerErrorStatusCode ? (COpts["fetchOptions"] extends {
+  throw: true;
+} ? true : false) extends (infer T_4) ? T_4 extends (COpts["fetchOptions"] extends {
+  throw: true;
+} ? true : false) ? T_4 extends true ? never : {
+  data: null;
+  error: Prettify<(Err extends Record<string, any> ? Err : {
+    message?: string;
+  }) & {
+    status: Stat_1;
+    statusText: string;
+  }>;
+} : never : never : never : Res : never> : I[K_1]; } : never : { [K_11 in ((BasePath extends "" ? K : K extends (infer T_1) ? T_1 extends K ? T_1 extends `${BasePath}/${infer Rest}` ? Rest : T_1 extends BasePath ? "" : T_1 : never : never) extends (infer T_2) ? T_2 extends (BasePath extends "" ? K : K extends (infer T_1) ? T_1 extends K ? T_1 extends `${BasePath}/${infer Rest}` ? Rest : T_1 extends BasePath ? "" : T_1 : never : never) ? T_2 extends "" ? [] : T_2 extends `${infer First}/${infer Second}` ? Second extends "" ? [First] : Second extends `${infer First}/${infer Second}` ? Second extends "" ? [First, First] : Second extends `${infer First}/${infer Second}` ? Second extends "" ? [First, First, First] : [First, First, First] : [First, First, Second] : [First, Second] : [T_2] : never : never)[T_22] as S_1[K] extends (infer T_23) ? T_23 extends S_1[K] ? T_23 extends Record<string, infer EP> ? EP extends any ? EP extends {
+  SERVER_ONLY: true;
+} ? never : EP extends {
+  isAction: false;
+} ? never : CamelCase<K_11> : never : never : never : never]: /*elided*/ any; } : never : never; } : never : never; } : never : never; } : never : never; } : never : never; } : never : never; } : never : never; } : never : never; } : never : never; } : never : never; } : never : never : never : never> : never) & InferActions<Option> & {
+  useSession: Atom<{
+    data: (App extends Hono<any, infer S_2 extends import("hono").Schema, infer P_1 extends string> ? (S_2[`${P_1}/get-session`]["$get"]["output"] & {
+      success: true;
+    })["data"] : never) | null;
+    error: BetterFetchError | null;
+    isPending: boolean;
+  }>;
+  $fetch: import("@better-fetch/fetch").BetterFetch<{
+    cache?: RequestCache;
+    integrity?: string;
+    keepalive?: boolean;
+    mode?: RequestMode;
+    priority?: RequestPriority;
+    redirect?: RequestRedirect;
+    referrer?: string;
+    referrerPolicy?: ReferrerPolicy;
+    signal?: AbortSignal | null;
+    window?: null;
+    catchAllError?: boolean;
+    defaultOutput?: import("@better-fetch/fetch").StandardSchemaV1;
+    defaultError?: import("@better-fetch/fetch").StandardSchemaV1;
+    onRetry?: (response: import("@better-fetch/fetch").ResponseContext) => Promise<void> | void;
+    hookOptions?: {
+      cloneResponse?: boolean;
+    };
+    timeout?: number;
+    throw?: boolean;
+    auth?: {
+      type: "Basic";
+      username: string | (() => string | undefined) | undefined;
+      password: string | (() => string | undefined) | undefined;
+    } | {
+      type: "Bearer";
+      token: string | Promise<string | undefined> | (() => string | Promise<string | undefined> | undefined) | undefined;
+    } | {
+      type: "Custom";
+      prefix: string | (() => string | undefined) | undefined;
+      value: string | (() => string | undefined) | undefined;
+    };
+    headers?: {
+      [x: string]: string | undefined;
+      accept?: "application/json" | "application/octet-stream" | "text/plain" | (string & {});
+      "content-type"?: "application/json" | "application/octet-stream" | "application/x-www-form-urlencoded" | "multipart/form-data" | "text/plain" | (string & {});
+      authorization?: `Basic ${string}` | `Bearer ${string}` | (string & {});
+    } | {};
+    body?: any;
+    query?: any;
+    params?: any;
+    duplex?: "full" | "half";
+    retry?: import("@better-fetch/fetch").RetryOptions;
+    retryAttempt?: number;
+    output?: import("@better-fetch/fetch").StandardSchemaV1 | typeof Blob | typeof File;
+    errorSchema?: import("@better-fetch/fetch").StandardSchemaV1;
+    disableValidation?: boolean;
+    schema?: import("@better-fetch/fetch").Schema;
+    baseURL: string;
+    credentials?: RequestCredentials;
+    method: string;
+    jsonParser: (text: string) => Promise<any> | any;
+    customFetchImpl: any;
+    plugins: (import("@better-fetch/fetch").BetterFetchPlugin | {
+      id: string;
+      name: string;
+      hooks: {};
+    })[];
+  }, unknown, unknown, import("@better-fetch/fetch").Schema>;
+  $store: {
+    notify: (signal?: BASE_ERROR_CODES<"$sessionSignal">) => void;
+    listen: (signal: BASE_ERROR_CODES<"$sessionSignal">, listener: (value: boolean, oldValue?: boolean | undefined) => void) => void;
+    atoms: {
+      session: import("nanostores").PreinitializedWritableAtom<{
+        data: {
+          user: BASE_ERROR_CODES;
+          session: BASE_ERROR_CODES;
+        } | null;
+        error: BetterFetchError | null;
+        isPending: boolean;
+        isRefetching: boolean;
+        refetch: () => void;
+      }> & object;
+      $sessionSignal: import("nanostores").PreinitializedWritableAtom<boolean> & object;
+    } & Record<string, import("nanostores").WritableAtom<any>>;
+  };
+  $Infer: {
+    Session: NonNullable<App extends Hono<any, infer S_2 extends import("hono").Schema, infer P_1 extends string> ? (S_2[`${P_1}/get-session`]["$get"]["output"] & {
+      success: true;
+    })["data"] : never>;
+  };
+  $ERROR_CODES: Prettify<InferErrorCodes<Option> & typeof BASE_ERROR_CODES>;
+};
+declare const signInSocialRoute: any;
+declare const signInEmailRoute: any;
+declare const getOAuthCallbackRoute: any;
+declare const postOAuthCallbackRoute: any;
+declare const getSessionRoute: any;
+declare const getSessionFromCtx: <U extends User = StrictUser, S extends Session$1 = StrictSession, V extends object = object>(ctx: Context<ContextVars<V & {
+  session?: {
+    session: S;
+    user: U;
+  };
+}>>, config?: {
+  disableCookieCache?: boolean;
+  disableRefresh?: boolean;
+}) => Promise<{
+  session: S;
+  user: U;
+} | (Response & TypedResponse<{
+  success: false;
+  code?: string | undefined;
+  message?: string | undefined;
+}, 401>)>;
+/**
+ * The middleware forces the endpoint to require a valid session.
+ */
+declare const sessionMiddleware: <V extends object>() => (ctx: Context<ContextVars<V & {
+  session: {
+    session: Session$1;
+    user: User;
+  };
+}>, string, {}>, next: import("hono").Next) => Promise<void | (Response & TypedResponse<{
+  success: false;
+  code?: string | undefined;
+  message?: string | undefined;
+}, 401>)>;
+/**
+ * This middleware forces the endpoint to require a valid session and ignores cookie cache.
+ * This should be used for sensitive operations like password changes, account deletion, etc.
+ * to ensure that revoked sessions cannot be used even if they're still cached in cookies.
+ */
+declare const sensitiveSessionMiddleware: (ctx: Context<ContextVars<{
+  session: {
+    session: Session$1;
+    user: User;
+  };
+}>, string, {}>, next: import("hono").Next) => Promise<void | (Response & TypedResponse<{
+  success: false;
+  code?: string | undefined;
+  message?: string | undefined;
+}, 401>)>;
+/**
+ * This middleware allows you to call the endpoint on the client if session is valid.
+ * However, if called on the server, no session is required.
+ */
+declare const requestOnlySessionMiddleware: (ctx: Context<ContextVars<{
+  session?: {
+    session: Session$1;
+    user: User;
+  };
+}>, string, {}>, next: import("hono").Next) => Promise<void | (Response & TypedResponse<{
+  success: false;
+  code?: string | undefined;
+  message?: string | undefined;
+}, 401>)>;
+/**
+ * This middleware forces the endpoint to require a valid session,
+ * as well as making sure the session is fresh before proceeding.
+ *
+ * Session freshness check will be skipped if the session config's freshAge
+ * is set to 0
+ */
+declare const freshSessionMiddleware: (ctx: Context<ContextVars<{
+  session: {
+    session: Session$1;
+    user: User;
+  };
+}>, string, {}>, next: import("hono").Next) => Promise<void | Response>;
+declare const listSessionsRoute: any;
+declare const revokeSessionRoute: any;
+declare const revokeSessionsRoute: any;
+declare const revokeOtherSessionsRoute: any;
+declare const signOutRoute: any;
+declare const requestPasswordResetRoute: any;
+declare const requestPasswordResetCallbackRoute: any;
+declare const resetPasswordRoute: any;
+declare const sendVerificationEmailRoute: any;
+declare const verifyEmailRoute: any;
+declare const updateUserRoute: any;
+declare const changePasswordRoute: any;
+declare const setPasswordRoute: any;
+declare const deleteUserRoute: any;
+declare const deleteUserCallbackRoute: any;
+declare const changeEmailRoute: any;
+declare const errorRoute: any;
+declare const okRoute: any;
+declare const signUpEmailRoute: any;
+declare const listAccountsRoute: any;
+declare const linkAccountRoute: any;
+declare const unlinkAccountRoute: any;
+declare const getAccessTokenRoute: any;
+declare const refreshAccessTokenRoute: any;
+declare const getAccountInfoRoute: any;
+type APIFromRoutes<C extends AuthRouteConfig> = { [K in C as K["operationId"]]: FromFn<Execute<K>> extends ((...args: infer A) => infer R) ? (...args: A) => R : never; };
+type AllPluginConfigs<O> = O extends {
+  plugins: readonly (infer P)[];
+} ? P extends {
+  routes: infer R;
+} ? R extends Record<string, infer T> ? T extends AuthEndpoint<infer C> ? C : never : never : never : never;
+type Configs = typeof changeEmailRoute | typeof changePasswordRoute | typeof deleteUserCallbackRoute | typeof deleteUserRoute | typeof errorRoute | typeof getAccessTokenRoute | typeof getAccountInfoRoute | typeof getOAuthCallbackRoute | typeof getSessionRoute | typeof linkAccountRoute | typeof listAccountsRoute | typeof listSessionsRoute | typeof okRoute | typeof postOAuthCallbackRoute | typeof refreshAccessTokenRoute | typeof requestPasswordResetCallbackRoute | typeof requestPasswordResetRoute | typeof resetPasswordRoute | typeof revokeOtherSessionsRoute | typeof revokeSessionRoute | typeof revokeSessionsRoute | typeof sendVerificationEmailRoute | typeof setPasswordRoute | typeof signInEmailRoute | typeof signInSocialRoute | typeof signOutRoute | typeof signUpEmailRoute | typeof unlinkAccountRoute | typeof updateUserRoute | typeof verifyEmailRoute;
+type Config<R extends string> = {
+  operationId: R;
+} & Configs;
+type BuildConfigs<O extends FaireAuthOptions> = AllPluginConfigs<O> | Configs extends (infer X) ? ProcessRouteConfig<X, O> : never;
+type InferSchema<O extends FaireAuthOptions> = UnionToIntersection<BuildSchema<BuildConfigs<O>, BasePath$1<O>>> & DocPathFromOptions<O>;
+type InferApp<O extends FaireAuthOptions> = OpenAPIHono$1<ContextVars, InferSchema<O>, BasePath$1<O>>;
+type InferAPI<A extends AnyHono, HideCallbacks extends boolean = true> = ExtractSchema<A> extends Record<string, infer R> ? { [Method in keyof R as R[Method] extends {
+  operationId: infer K;
+} ? K extends string ? true extends HideCallbacks ? R[Method] extends {
+  isAction: false;
+} ? never : K : K : never : never]: R[Method] extends {
+  _api: infer Api;
+} ? Api : never; } extends (infer S) ? UnionToIntersection<S> : never : never;
+type Session<C, Opts extends ClientOptions> = C extends {
+  getSession: {
+    $get: infer GetSession;
+  };
+} ? GetSession extends ((...args: any) => any) ? Awaited<ReturnType<GetSession>> extends (infer R) ? Opts["fetchOptions"] extends {
+  throw: true;
+} ? R : R extends {
+  status: 200;
+  json: infer Json;
+} ? Json extends ((...args: any) => any) ? Awaited<ReturnType<Json>> : never : never : never : never : never;
+/**
+ * InferClient turns a Hono-based FaireAuth client into the exact shape
+ * that the runtime client returns, including every route, action, hook
+ * and the strongly-typed `useSession` atom.
+ */
+type InferClient<A extends AnyHono, Opts extends ClientOptions> = A extends Hono<any, infer S, infer B> ? Client<S, B, Opts> extends (infer ClientAPI) ? UnionToIntersection<InferResolvedHooks<Opts>> & ClientAPI & InferActions<Opts> & {
+  useSession: Atom<{
+    data: Session<ClientAPI, Opts> | null;
+    error: BetterFetchError | null;
+    isPending: boolean;
+  }>;
+  $fetch: BetterFetch;
+  $store: {
+    notify: (signal?: LiteralStringUnion<"$sessionSignal"> | undefined) => void;
+    listen: (signal: LiteralStringUnion<"$sessionSignal">, listener: (value: boolean, oldValue?: boolean | undefined) => void) => void;
+    atoms: Record<string, WritableAtom<any>>;
+  };
+  $Infer: {
+    Session: Session<ClientAPI, Opts>;
+  };
+  $ERROR_CODES: Prettify<InferErrorCodes<Opts> & typeof BASE_ERROR_CODES>;
+} : never : never;
+type DefaultAPI = APIFromRoutes<Configs>;
+type DefaultApp = OpenAPIHono$1<ContextVars, UnionToIntersection<BuildSchema<Configs, "/api/auth">>, "/api/auth">;
+declare module "hono" {
+  interface ContextRenderer extends JSONRenderRespond {}
+  interface ContextVariableMap {
+    /** Gets set early before hitting route handler */
+    path: LiteralStringUnion<Configs["path"]>;
+    /** Gets set at route handler for intraroute consistency */
+    config?: AuthRouteConfig;
+    /** Gets set by initContext middleware */
+    context: AuthContext;
+    /** Gets set in endpoint Route Apps */
+    isServer?: true;
+    /** Gets set by initContext middleware */
+    api: DefaultAPI;
+  }
+}
+type ContextVars<E extends object = object> = {
+  Bindings: typeof ENV$1;
+  Variables: E;
+};
+type Execute<C extends MinRouteConfig> = Exec<C, ContextVars<any>>;
+type ToExecFull<T extends Execute<any>> = T extends Fn<infer Par extends any[], infer Ret> ? {
+  <AsResponse extends boolean = false, ReturnHeaders extends boolean = false>(...args: Par extends [infer Input, infer Ctx] ? Ctx extends Context<any> ? [Input, (Ctx | ExecOpts<AsResponse, ReturnHeaders>)?] : Par : Par extends [infer Ctx] ? [(Ctx | ExecOpts<AsResponse, ReturnHeaders>)?] : Par): Ret extends Promise<infer R> ? Promise<AsResponse extends true ? Response : ReturnHeaders extends true ? {
+    headers: Headers;
+    response: R;
+  } : R> : never;
+} : never;
+type Models = "user" | "account" | "session" | "verification" | "rate-limit" | "organization" | "member" | "invitation" | "jwks" | "passkey" | "two-factor";
+type AdditionalUserFieldsInput<Options extends FaireAuthOptions> = InferFieldsFromOptions$1<Options, "user", "input"> & InferFieldsFromPlugins$1<Options, "user", "input">;
+type AdditionalUserFieldsOutput<Options extends FaireAuthOptions> = InferFieldsFromOptions$1<Options, "user"> & InferFieldsFromPlugins$1<Options, "user">;
+type AdditionalSessionFieldsInput<Options extends FaireAuthOptions> = InferFieldsFromOptions$1<Options, "session", "input"> & InferFieldsFromPlugins$1<Options, "session", "input">;
+type AdditionalSessionFieldsOutput<Options extends FaireAuthOptions> = InferFieldsFromOptions$1<Options, "session"> & InferFieldsFromPlugins$1<Options, "session">;
+type InferUser<O extends Auth | FaireAuthOptions> = Record<never, never> & UnionToIntersection<StripEmptyObjects<(O extends FaireAuthOptions ? AdditionalUserFieldsOutput<O> : O extends Auth ? AdditionalUserFieldsOutput<O["options"]> : {}) & StrictUser>>;
+type InferSession<O extends Auth | FaireAuthOptions> = Record<never, never> & UnionToIntersection<StripEmptyObjects<(O extends FaireAuthOptions ? AdditionalSessionFieldsOutput<O> : O extends Auth ? AdditionalSessionFieldsOutput<O["options"]> : {}) & StrictSession>>;
+type InferPluginTypes<O extends FaireAuthOptions> = O["plugins"] extends (infer P)[] ? UnionToIntersection<P extends FaireAuthPlugin ? P["$Infer"] extends Record<string, any> ? P["$Infer"] : {} : {}> : {};
+interface RateLimit {
+  /**
+   * The key to use for rate limiting
+   */
+  key: string;
+  /**
+   * The number of requests made
+   */
+  count: number;
+  /**
+   * The last request time in milliseconds
+   */
+  lastRequest: number;
+}
+declare const router: <O extends FaireAuthOptions>(context: AuthContext, options: O) => {
+  api: {
+    [x: number]: any;
+  };
+  app: any;
+};
+type WithJsDoc<T, D> = Expand<D & T>;
+declare function defineOptions<const T extends FaireAuthPlugin[], U extends {
+  routeHooks?: InferPluginHooks<T>;
+  middleware?: InferPluginMiddleware<T>;
+  dto?: InferPluginDTO<T>;
+  rateLimit?: InferPluginRateLimit<T>;
+} & ExK<FaireAuthOptions, "plugins">>(config: {
+  plugins: T;
+} & U): {
+  plugins: T;
+} & U;
+declare function defineOptions<U extends ExK<FaireAuthOptions, "plugins">>(config: U): U;
+declare const faireAuth: <Options extends FaireAuthOptions>(options: Options & Record<never, never>) => {
+  handler: (request: Request, Env?: any, executionCtx?: ExecutionContext) => any;
+  app: any;
+  api: {
+    [x: number]: any;
+  };
+  options: {
+    [x: string]: unknown;
+    secret: string;
+    baseURL: string;
+    basePath: string;
+  } & Options;
+  $context: BaseAuthContext<ContextVars, Options_1>;
+  $Infer: {
+    Session: {
+      session: Prettify<InferSession<Options>>;
+      user: Prettify<InferUser<Options>>;
+    };
+    App: <O extends FaireAuthOptions>(_o: O) => InferApp<O>;
+    Api: <A extends AnyHono>(_a: A) => InferAPI<A>;
+  } & InferPluginTypes<Options>;
+  $ERROR_CODES: InferPluginErrorCodes<Options> & typeof BASE_ERROR_CODES;
+};
+interface Auth<Options extends FaireAuthOptions = FaireAuthOptions> {
+  handler: (request: Request, Env?: any, executionCtx?: ExecutionContext) => Promise<Response> | Response;
+  app: ReturnType<typeof router>["app"];
+  api: ReturnType<typeof router>["api"];
+  options: {
+    [x: string]: unknown;
+    secret: string;
+    baseURL: string;
+    basePath: string;
+  } & Options;
+  $context: AuthContext<Options>;
+  $Infer: {
+    Session: unknown;
+    App: unknown;
+    Api: unknown;
+  };
+  $ERROR_CODES: typeof BASE_ERROR_CODES;
+}
+declare const generateState: <V extends object>(ctx: Context<ContextVars<V>, string, {
+  out: {
+    json: {
+      callbackURL?: string | undefined;
+      errorCallbackURL?: string | undefined;
+      newUserCallbackURL?: string | undefined;
+      requestSignUp?: boolean | undefined;
+    };
+  };
+}>, link?: {
+  email: string;
+  userId: string;
+}, options?: Pick<FaireAuthOptions, "baseURL">) => Promise<{
+  state: any;
+  codeVerifier: any;
+}>;
+declare const parsingSchema: z.ZodObject<{
+  callbackURL: z.ZodString;
+  codeVerifier: z.ZodString;
+  errorURL: z.ZodOptional<z.ZodString>;
+  newUserURL: z.ZodOptional<z.ZodString>;
+  expiresAt: z.ZodNumber;
+  link: z.ZodOptional<z.ZodObject<{
+    email: any;
+    userId: z.ZodCoercedString<unknown>;
+  }, z.core.$strip>>;
+  requestSignUp: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+declare const parseState: <V extends object>(ctx: Context<ContextVars<V>, string, {
+  out: {
+    query: {
+      state?: string | undefined;
+    };
+    json: {
+      state?: string | undefined;
+    };
+  };
+}>, options: Pick<FaireAuthOptions, "onAPIError">) => Promise<{
+  type: "success";
+  data: z.output<typeof parsingSchema>;
+} | {
+  type: "redirect";
+  response: Response & TypedResponse<undefined, 302, "redirect">;
+}>;
+type HeaderSource = HeadersInit | Record<string, string | undefined>;
+declare const mergeHeaders: (...sources: (HeaderSource | (() => HeaderSource | Promise<HeaderSource>) | undefined)[]) => Headers | (() => Promise<Headers>);
+interface TelemetryEvent {
+  type: string;
+  anonymousId?: string | undefined;
+  payload: Record<string, any>;
+}
+interface TelemetryContext {
+  customTrack?: (event: TelemetryEvent) => Promise<void>;
+  database?: string;
+  adapter?: string;
+  skipTestCheck?: boolean;
+}
+declare function createTelemetry(options: FaireAuthOptions, context?: TelemetryContext): {
+  initPromise: Promise<void>;
+  publish(event: TelemetryEvent): Promise<void>;
+};
+declare function getTelemetryAuthConfig(options: FaireAuthOptions, context?: TelemetryContext): {
+  database: string | undefined;
+  adapter: string | undefined;
+  emailVerification: {
+    sendVerificationEmail: boolean;
+    sendOnSignUp: boolean;
+    sendOnSignIn: boolean;
+    autoSignInAfterVerification: boolean;
+    expiresIn: any;
+    onEmailVerification: boolean;
+    afterEmailVerification: boolean;
+  };
+  emailAndPassword: {
+    enabled: boolean;
+    disableSignUp: boolean;
+    requireEmailVerification: boolean;
+    maxPasswordLength: any;
+    minPasswordLength: any;
+    sendResetPassword: boolean;
+    resetPasswordTokenExpiresIn: any;
+    onPasswordReset: boolean;
+    password: {
+      hash: boolean;
+      verify: boolean;
+    };
+    autoSignIn: boolean;
+    revokeSessionsOnPasswordReset: boolean;
+  };
+  socialProviders: ({
+    id?: never;
+    mapProfileToUser?: never;
+    disableDefaultScope?: never;
+    disableIdTokenSignIn?: never;
+    disableImplicitSignUp?: never;
+    disableSignUp?: never;
+    getUserInfo?: never;
+    overrideUserInfoOnSignIn?: never;
+    prompt?: never;
+    verifyIdToken?: never;
+    scope?: never;
+    refreshAccessToken?: never;
+  } | {
+    id: string;
+    mapProfileToUser: boolean;
+    disableDefaultScope: boolean;
+    disableIdTokenSignIn: boolean;
+    disableImplicitSignUp: any;
+    disableSignUp: any;
+    getUserInfo: boolean;
+    overrideUserInfoOnSignIn: boolean;
+    prompt: any;
+    verifyIdToken: boolean;
+    scope: any;
+    refreshAccessToken: boolean;
+  })[];
+  plugins: any[] | undefined;
+  user: {
+    modelName: any;
+    fields: any;
+    additionalFields: any;
+    changeEmail: {
+      enabled: any;
+      sendChangeEmailVerification: boolean;
+    };
+  };
+  verification: {
+    modelName: any;
+    disableCleanup: any;
+    fields: any;
+  };
+  session: {
+    modelName: any;
+    additionalFields: any;
+    cookieCache: {
+      enabled: any;
+      maxAge: any;
+    };
+    disableSessionRefresh: any;
+    expiresIn: any;
+    fields: any;
+    freshAge: any;
+    preserveSessionInDatabase: any;
+    storeSessionInDatabase: any;
+    updateAge: any;
+  };
+  account: {
+    modelName: any;
+    fields: any;
+    encryptOAuthTokens: any;
+    updateAccountOnSignIn: any;
+    accountLinking: {
+      enabled: any;
+      trustedProviders: any;
+      updateUserInfoOnLink: any;
+      allowUnlinkingAll: any;
+    };
+  };
+  hooks: {
+    after: boolean;
+    before: boolean;
+  };
+  secondaryStorage: boolean;
+  advanced: {
+    cookiePrefix: boolean;
+    cookies: boolean;
+    crossSubDomainCookies: {
+      domain: boolean;
+      enabled: any;
+      additionalCookies: any;
+    };
+    database: {
+      useNumberId: boolean;
+      generateId: any;
+      defaultFindManyLimit: any;
+    };
+    useSecureCookies: any;
+    ipAddress: {
+      disableIpTracking: any;
+      ipAddressHeaders: any;
+    };
+    disableCSRFCheck: any;
+    cookieAttributes: {
+      expires: any;
+      secure: any;
+      sameSite: any;
+      domain: boolean;
+      path: any;
+      httpOnly: any;
+    };
+  };
+  trustedOrigins: any;
+  rateLimit: {
+    storage: any;
+    modelName: any;
+    window: any;
+    customStorage: boolean;
+    enabled: any;
+    max: any;
+  };
+  onAPIError: {
+    errorURL: any;
+    onError: boolean;
+    throw: any;
+  };
+  logger: {
+    disabled: any;
+    level: any;
+    log: boolean;
+  };
+  databaseHooks: {
+    user: {
+      create: {
+        after: boolean;
+        before: boolean;
+      };
+      update: {
+        after: boolean;
+        before: boolean;
+      };
+    };
+    session: {
+      create: {
+        after: boolean;
+        before: boolean;
+      };
+      update: {
+        after: boolean;
+        before: boolean;
+      };
+    };
+    account: {
+      create: {
+        after: boolean;
+        before: boolean;
+      };
+      update: {
+        after: boolean;
+        before: boolean;
+      };
+    };
+    verification: {
+      create: {
+        after: boolean;
+        before: boolean;
+      };
+      update: {
+        after: boolean;
+        before: boolean;
+      };
+    };
+  };
+};
+export { FaireAuthClientPlugin as $, InferFieldsInputClient as $t, InferSession as A, getAdapter as At, InferClient as B, parseUserInput as Bt, faireAuth as C, InferPluginErrorCodes as Ct, AdditionalUserFieldsInput as D, getWithHooks as Dt, AdditionalSessionFieldsOutput as E, InferPluginRateLimit as Et, Execute as F, parseAccountOutput as Ft, sessionMiddleware as G, getMigrations as Gt, getSessionFromCtx as H, createInternalAdapter as Ht, ToExecFull as I, parseAdditionalUserInput as It, AtomListener as J, FieldAttributeToObject as Jt, InferResolvedHooks as K, matchType as Kt, DefaultApp as L, parseInputData as Lt, Models as M, toZodSchema as Mt, RateLimit as N, mergeSchema as Nt, AdditionalUserFieldsOutput as O, convertFromDB as Ot, ContextVars as P, parseAccountInput as Pt, CreateSchemaType as Q, InferFieldsInput as Qt, InferAPI as R, parseSessionInput as Rt, defineOptions as S, InferPluginDTO as St, AdditionalSessionFieldsInput as T, InferPluginMiddleware as Tt, requestOnlySessionMiddleware as U, getAuthTables as Ut, freshSessionMiddleware as V, parseUserOutput as Vt, sensitiveSessionMiddleware as W, getSchema as Wt, Client as X, InferFieldsFromOptions as Xt, CamelCase as Y, InferAdditionalFieldsFromPluginOptions as Yt, ClientOptions as Z, InferFieldsFromPlugins as Zt, mergeHeaders as _, TransactionAdapter as _n, Hooks as _t, getTelemetryAuthConfig as a, AuthFactory as an, InferPluginsFromClient as at, Auth as b, FaireAuthPlugin as bt, ENV as c, AuthContext as cn, IsSignal as ct, LogLevel as d, AdapterInstance as dn, Store as dt, InferFieldsOutput as en, Inc as et, Logger as f, AdapterSchemaCreation as fn, FetchOptions as ft, logger as g, DBTransactionAdapter as gn, FaireAuthRateLimitOptions as gt, generateRandomString as h, DBAdapterSchemaCreation as hn, FaireAuthOptions as ht, OpenAPIHono as i, AuthEndpoint as in, InferErrorCodes as it, InferUser as j, FieldAttributeToSchema as jt, InferPluginTypes as k, convertToDB as kt, InternalLogger as l, init as ln, RevalidateOptions as lt, generateId as m, DBAdapterInstance as mn, DTO as mt, FaireAuthError as n, PluginFieldAttribute as nn, InferAdditionalAsClient as nt, createTelemetry as o, AuthProperties as on, InferSessionFromClient as ot, createLogger as p, DBAdapter as pn, CustomRules as pt, createAuthClient as q, KyselyDatabaseType as qt, MissingDependencyError as r, createFieldAttribute as rn, InferAdditionalFromClient as rt, TelemetryEvent as s, createEndpoint as sn, InferUserFromClient as st, APIError as t, InferValueType as tn, InferActions as tt, LogHandlerParams as u, Adapter as un, SessionQueryParams as ut, generateState as v, Where as vn, Middleware as vt, router as w, InferPluginHooks as wt, WithJsDoc as x, InferOptionSchema as xt, parseState as y, getCurrentAdapter as yn, AuthPluginSchema as yt, InferApp as z, parseSessionOutput as zt };