@better-auth/core 1.3.26 → 1.3.28

package/dist/env/index.mjs

@@ -0,0 +1,297 @@
+const _envShim = /* @__PURE__ */ Object.create(null);
+const _getEnv = (useShim) => globalThis.process?.env || //@ts-expect-error
+globalThis.Deno?.env.toObject() || //@ts-expect-error
+globalThis.__env__ || (useShim ? _envShim : globalThis);
+const env = new Proxy(_envShim, {
+  get(_, prop) {
+    const env2 = _getEnv();
+    return env2[prop] ?? _envShim[prop];
+  },
+  has(_, prop) {
+    const env2 = _getEnv();
+    return prop in env2 || prop in _envShim;
+  },
+  set(_, prop, value) {
+    const env2 = _getEnv(true);
+    env2[prop] = value;
+    return true;
+  },
+  deleteProperty(_, prop) {
+    if (!prop) {
+      return false;
+    }
+    const env2 = _getEnv(true);
+    delete env2[prop];
+    return true;
+  },
+  ownKeys() {
+    const env2 = _getEnv(true);
+    return Object.keys(env2);
+  }
+});
+function toBoolean(val) {
+  return val ? val !== "false" : false;
+}
+const nodeENV = typeof process !== "undefined" && process.env && process.env.NODE_ENV || "";
+const isProduction = nodeENV === "production";
+const isDevelopment = nodeENV === "dev" || nodeENV === "development";
+const isTest = () => nodeENV === "test" || toBoolean(env.TEST);
+function getEnvVar(key, fallback) {
+  if (typeof process !== "undefined" && process.env) {
+    return process.env[key] ?? fallback;
+  }
+  if (typeof Deno !== "undefined") {
+    return Deno.env.get(key) ?? fallback;
+  }
+  if (typeof Bun !== "undefined") {
+    return Bun.env[key] ?? fallback;
+  }
+  return fallback;
+}
+function getBooleanEnvVar(key, fallback = true) {
+  const value = getEnvVar(key);
+  if (!value) return fallback;
+  return value !== "0" && value.toLowerCase() !== "false" && value !== "";
+}
+const ENV = Object.freeze({
+  get BETTER_AUTH_SECRET() {
+    return getEnvVar("BETTER_AUTH_SECRET");
+  },
+  get AUTH_SECRET() {
+    return getEnvVar("AUTH_SECRET");
+  },
+  get BETTER_AUTH_TELEMETRY() {
+    return getEnvVar("BETTER_AUTH_TELEMETRY");
+  },
+  get BETTER_AUTH_TELEMETRY_ID() {
+    return getEnvVar("BETTER_AUTH_TELEMETRY_ID");
+  },
+  get NODE_ENV() {
+    return getEnvVar("NODE_ENV", "development");
+  },
+  get PACKAGE_VERSION() {
+    return getEnvVar("PACKAGE_VERSION", "0.0.0");
+  },
+  get BETTER_AUTH_TELEMETRY_ENDPOINT() {
+    return getEnvVar(
+      "BETTER_AUTH_TELEMETRY_ENDPOINT",
+      "https://telemetry.better-auth.com/v1/track"
+    );
+  }
+});
+
+const COLORS_2 = 1;
+const COLORS_16 = 4;
+const COLORS_256 = 8;
+const COLORS_16m = 24;
+const TERM_ENVS = {
+  eterm: COLORS_16,
+  cons25: COLORS_16,
+  console: COLORS_16,
+  cygwin: COLORS_16,
+  dtterm: COLORS_16,
+  gnome: COLORS_16,
+  hurd: COLORS_16,
+  jfbterm: COLORS_16,
+  konsole: COLORS_16,
+  kterm: COLORS_16,
+  mlterm: COLORS_16,
+  mosh: COLORS_16m,
+  putty: COLORS_16,
+  st: COLORS_16,
+  // http://lists.schmorp.de/pipermail/rxvt-unicode/2016q2/002261.html
+  "rxvt-unicode-24bit": COLORS_16m,
+  // https://bugs.launchpad.net/terminator/+bug/1030562
+  terminator: COLORS_16m,
+  "xterm-kitty": COLORS_16m
+};
+const CI_ENVS_MAP = new Map(
+  Object.entries({
+    APPVEYOR: COLORS_256,
+    BUILDKITE: COLORS_256,
+    CIRCLECI: COLORS_16m,
+    DRONE: COLORS_256,
+    GITEA_ACTIONS: COLORS_16m,
+    GITHUB_ACTIONS: COLORS_16m,
+    GITLAB_CI: COLORS_256,
+    TRAVIS: COLORS_256
+  })
+);
+const TERM_ENVS_REG_EXP = [
+  /ansi/,
+  /color/,
+  /linux/,
+  /direct/,
+  /^con[0-9]*x[0-9]/,
+  /^rxvt/,
+  /^screen/,
+  /^xterm/,
+  /^vt100/,
+  /^vt220/
+];
+function getColorDepth() {
+  if (getEnvVar("FORCE_COLOR") !== void 0) {
+    switch (getEnvVar("FORCE_COLOR")) {
+      case "":
+      case "1":
+      case "true":
+        return COLORS_16;
+      case "2":
+        return COLORS_256;
+      case "3":
+        return COLORS_16m;
+      default:
+        return COLORS_2;
+    }
+  }
+  if (getEnvVar("NODE_DISABLE_COLORS") !== void 0 && getEnvVar("NODE_DISABLE_COLORS") !== "" || // See https://no-color.org/
+  getEnvVar("NO_COLOR") !== void 0 && getEnvVar("NO_COLOR") !== "" || // The "dumb" special terminal, as defined by terminfo, doesn't support
+  // ANSI color control codes.
+  // See https://invisible-island.net/ncurses/terminfo.ti.html#toc-_Specials
+  getEnvVar("TERM") === "dumb") {
+    return COLORS_2;
+  }
+  if (getEnvVar("TMUX")) {
+    return COLORS_16m;
+  }
+  if ("TF_BUILD" in env && "AGENT_NAME" in env) {
+    return COLORS_16;
+  }
+  if ("CI" in env) {
+    for (const { 0: envName, 1: colors } of CI_ENVS_MAP) {
+      if (envName in env) {
+        return colors;
+      }
+    }
+    if (getEnvVar("CI_NAME") === "codeship") {
+      return COLORS_256;
+    }
+    return COLORS_2;
+  }
+  if ("TEAMCITY_VERSION" in env) {
+    return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.exec(
+      getEnvVar("TEAMCITY_VERSION")
+    ) !== null ? COLORS_16 : COLORS_2;
+  }
+  switch (getEnvVar("TERM_PROGRAM")) {
+    case "iTerm.app":
+      if (!getEnvVar("TERM_PROGRAM_VERSION") || /^[0-2]\./.exec(getEnvVar("TERM_PROGRAM_VERSION")) !== null) {
+        return COLORS_256;
+      }
+      return COLORS_16m;
+    case "HyperTerm":
+    case "MacTerm":
+      return COLORS_16m;
+    case "Apple_Terminal":
+      return COLORS_256;
+  }
+  if (getEnvVar("COLORTERM") === "truecolor" || getEnvVar("COLORTERM") === "24bit") {
+    return COLORS_16m;
+  }
+  if (getEnvVar("TERM")) {
+    if (/truecolor/.exec(getEnvVar("TERM")) !== null) {
+      return COLORS_16m;
+    }
+    if (/^xterm-256/.exec(getEnvVar("TERM")) !== null) {
+      return COLORS_256;
+    }
+    const termEnv = getEnvVar("TERM").toLowerCase();
+    if (TERM_ENVS[termEnv]) {
+      return TERM_ENVS[termEnv];
+    }
+    if (TERM_ENVS_REG_EXP.some((term) => term.exec(termEnv) !== null)) {
+      return COLORS_16;
+    }
+  }
+  if (getEnvVar("COLORTERM")) {
+    return COLORS_16;
+  }
+  return COLORS_2;
+}
+
+const TTY_COLORS = {
+  reset: "\x1B[0m",
+  bright: "\x1B[1m",
+  dim: "\x1B[2m",
+  undim: "\x1B[22m",
+  underscore: "\x1B[4m",
+  blink: "\x1B[5m",
+  reverse: "\x1B[7m",
+  hidden: "\x1B[8m",
+  fg: {
+    black: "\x1B[30m",
+    red: "\x1B[31m",
+    green: "\x1B[32m",
+    yellow: "\x1B[33m",
+    blue: "\x1B[34m",
+    magenta: "\x1B[35m",
+    cyan: "\x1B[36m",
+    white: "\x1B[37m"
+  },
+  bg: {
+    black: "\x1B[40m",
+    red: "\x1B[41m",
+    green: "\x1B[42m",
+    yellow: "\x1B[43m",
+    blue: "\x1B[44m",
+    magenta: "\x1B[45m",
+    cyan: "\x1B[46m",
+    white: "\x1B[47m"
+  }
+};
+const levels = ["info", "success", "warn", "error", "debug"];
+function shouldPublishLog(currentLogLevel, logLevel) {
+  return levels.indexOf(logLevel) <= levels.indexOf(currentLogLevel);
+}
+const levelColors = {
+  info: TTY_COLORS.fg.blue,
+  success: TTY_COLORS.fg.green,
+  warn: TTY_COLORS.fg.yellow,
+  error: TTY_COLORS.fg.red,
+  debug: TTY_COLORS.fg.magenta
+};
+const formatMessage = (level, message, colorsEnabled) => {
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+  if (colorsEnabled) {
+    return `${TTY_COLORS.dim}${timestamp}${TTY_COLORS.reset} ${levelColors[level]}${level.toUpperCase()}${TTY_COLORS.reset} ${TTY_COLORS.bright}[Better Auth]:${TTY_COLORS.reset} ${message}`;
+  }
+  return `${timestamp} ${level.toUpperCase()} [Better Auth]: ${message}`;
+};
+const createLogger = (options) => {
+  const enabled = options?.disabled !== true;
+  const logLevel = options?.level ?? "error";
+  const isDisableColorsSpecified = options?.disableColors !== void 0;
+  const colorsEnabled = isDisableColorsSpecified ? !options.disableColors : getColorDepth() !== 1;
+  const LogFunc = (level, message, args = []) => {
+    if (!enabled || !shouldPublishLog(logLevel, level)) {
+      return;
+    }
+    const formattedMessage = formatMessage(level, message, colorsEnabled);
+    if (!options || typeof options.log !== "function") {
+      if (level === "error") {
+        console.error(formattedMessage, ...args);
+      } else if (level === "warn") {
+        console.warn(formattedMessage, ...args);
+      } else {
+        console.log(formattedMessage, ...args);
+      }
+      return;
+    }
+    options.log(level === "success" ? "info" : level, message, ...args);
+  };
+  const logger2 = Object.fromEntries(
+    levels.map((level) => [
+      level,
+      (...[message, ...args]) => LogFunc(level, message, args)
+    ])
+  );
+  return {
+    ...logger2,
+    get level() {
+      return logLevel;
+    }
+  };
+};
+const logger = createLogger();
+
+export { ENV, TTY_COLORS, createLogger, env, getBooleanEnvVar, getColorDepth, getEnvVar, isDevelopment, isProduction, isTest, levels, logger, nodeENV, shouldPublishLog };

package/dist/error/index.cjs

@@ -0,0 +1,44 @@
+'use strict';
+
+const utils = require('@better-auth/core/utils');
+
+const BASE_ERROR_CODES = utils.defineErrorCodes({
+  USER_NOT_FOUND: "User not found",
+  FAILED_TO_CREATE_USER: "Failed to create user",
+  FAILED_TO_CREATE_SESSION: "Failed to create session",
+  FAILED_TO_UPDATE_USER: "Failed to update user",
+  FAILED_TO_GET_SESSION: "Failed to get session",
+  INVALID_PASSWORD: "Invalid password",
+  INVALID_EMAIL: "Invalid email",
+  INVALID_EMAIL_OR_PASSWORD: "Invalid email or password",
+  SOCIAL_ACCOUNT_ALREADY_LINKED: "Social account already linked",
+  PROVIDER_NOT_FOUND: "Provider not found",
+  INVALID_TOKEN: "Invalid token",
+  ID_TOKEN_NOT_SUPPORTED: "id_token not supported",
+  FAILED_TO_GET_USER_INFO: "Failed to get user info",
+  USER_EMAIL_NOT_FOUND: "User email not found",
+  EMAIL_NOT_VERIFIED: "Email not verified",
+  PASSWORD_TOO_SHORT: "Password too short",
+  PASSWORD_TOO_LONG: "Password too long",
+  USER_ALREADY_EXISTS: "User already exists.",
+  USER_ALREADY_EXISTS_USE_ANOTHER_EMAIL: "User already exists. Use another email.",
+  EMAIL_CAN_NOT_BE_UPDATED: "Email can not be updated",
+  CREDENTIAL_ACCOUNT_NOT_FOUND: "Credential account not found",
+  SESSION_EXPIRED: "Session expired. Re-authenticate to perform this action.",
+  FAILED_TO_UNLINK_LAST_ACCOUNT: "You can't unlink your last account",
+  ACCOUNT_NOT_FOUND: "Account not found",
+  USER_ALREADY_HAS_PASSWORD: "User already has a password. Provide that to delete the account."
+});
+
+class BetterAuthError extends Error {
+  constructor(message, cause) {
+    super(message);
+    this.name = "BetterAuthError";
+    this.message = message;
+    this.cause = cause;
+    this.stack = "";
+  }
+}
+
+exports.BASE_ERROR_CODES = BASE_ERROR_CODES;
+exports.BetterAuthError = BetterAuthError;

package/dist/error/index.d.cts

@@ -0,0 +1,33 @@
+declare const BASE_ERROR_CODES: {
+    readonly USER_NOT_FOUND: "User not found";
+    readonly FAILED_TO_CREATE_USER: "Failed to create user";
+    readonly FAILED_TO_CREATE_SESSION: "Failed to create session";
+    readonly FAILED_TO_UPDATE_USER: "Failed to update user";
+    readonly FAILED_TO_GET_SESSION: "Failed to get session";
+    readonly INVALID_PASSWORD: "Invalid password";
+    readonly INVALID_EMAIL: "Invalid email";
+    readonly INVALID_EMAIL_OR_PASSWORD: "Invalid email or password";
+    readonly SOCIAL_ACCOUNT_ALREADY_LINKED: "Social account already linked";
+    readonly PROVIDER_NOT_FOUND: "Provider not found";
+    readonly INVALID_TOKEN: "Invalid token";
+    readonly ID_TOKEN_NOT_SUPPORTED: "id_token not supported";
+    readonly FAILED_TO_GET_USER_INFO: "Failed to get user info";
+    readonly USER_EMAIL_NOT_FOUND: "User email not found";
+    readonly EMAIL_NOT_VERIFIED: "Email not verified";
+    readonly PASSWORD_TOO_SHORT: "Password too short";
+    readonly PASSWORD_TOO_LONG: "Password too long";
+    readonly USER_ALREADY_EXISTS: "User already exists.";
+    readonly USER_ALREADY_EXISTS_USE_ANOTHER_EMAIL: "User already exists. Use another email.";
+    readonly EMAIL_CAN_NOT_BE_UPDATED: "Email can not be updated";
+    readonly CREDENTIAL_ACCOUNT_NOT_FOUND: "Credential account not found";
+    readonly SESSION_EXPIRED: "Session expired. Re-authenticate to perform this action.";
+    readonly FAILED_TO_UNLINK_LAST_ACCOUNT: "You can't unlink your last account";
+    readonly ACCOUNT_NOT_FOUND: "Account not found";
+    readonly USER_ALREADY_HAS_PASSWORD: "User already has a password. Provide that to delete the account.";
+};
+
+declare class BetterAuthError extends Error {
+    constructor(message: string, cause?: string);
+}
+
+export { BASE_ERROR_CODES, BetterAuthError };

package/dist/error/index.d.mts

@@ -0,0 +1,33 @@
+declare const BASE_ERROR_CODES: {
+    readonly USER_NOT_FOUND: "User not found";
+    readonly FAILED_TO_CREATE_USER: "Failed to create user";
+    readonly FAILED_TO_CREATE_SESSION: "Failed to create session";
+    readonly FAILED_TO_UPDATE_USER: "Failed to update user";
+    readonly FAILED_TO_GET_SESSION: "Failed to get session";
+    readonly INVALID_PASSWORD: "Invalid password";
+    readonly INVALID_EMAIL: "Invalid email";
+    readonly INVALID_EMAIL_OR_PASSWORD: "Invalid email or password";
+    readonly SOCIAL_ACCOUNT_ALREADY_LINKED: "Social account already linked";
+    readonly PROVIDER_NOT_FOUND: "Provider not found";
+    readonly INVALID_TOKEN: "Invalid token";
+    readonly ID_TOKEN_NOT_SUPPORTED: "id_token not supported";
+    readonly FAILED_TO_GET_USER_INFO: "Failed to get user info";
+    readonly USER_EMAIL_NOT_FOUND: "User email not found";
+    readonly EMAIL_NOT_VERIFIED: "Email not verified";
+    readonly PASSWORD_TOO_SHORT: "Password too short";
+    readonly PASSWORD_TOO_LONG: "Password too long";
+    readonly USER_ALREADY_EXISTS: "User already exists.";
+    readonly USER_ALREADY_EXISTS_USE_ANOTHER_EMAIL: "User already exists. Use another email.";
+    readonly EMAIL_CAN_NOT_BE_UPDATED: "Email can not be updated";
+    readonly CREDENTIAL_ACCOUNT_NOT_FOUND: "Credential account not found";
+    readonly SESSION_EXPIRED: "Session expired. Re-authenticate to perform this action.";
+    readonly FAILED_TO_UNLINK_LAST_ACCOUNT: "You can't unlink your last account";
+    readonly ACCOUNT_NOT_FOUND: "Account not found";
+    readonly USER_ALREADY_HAS_PASSWORD: "User already has a password. Provide that to delete the account.";
+};
+
+declare class BetterAuthError extends Error {
+    constructor(message: string, cause?: string);
+}
+
+export { BASE_ERROR_CODES, BetterAuthError };

package/dist/error/index.d.ts

@@ -0,0 +1,33 @@
+declare const BASE_ERROR_CODES: {
+    readonly USER_NOT_FOUND: "User not found";
+    readonly FAILED_TO_CREATE_USER: "Failed to create user";
+    readonly FAILED_TO_CREATE_SESSION: "Failed to create session";
+    readonly FAILED_TO_UPDATE_USER: "Failed to update user";
+    readonly FAILED_TO_GET_SESSION: "Failed to get session";
+    readonly INVALID_PASSWORD: "Invalid password";
+    readonly INVALID_EMAIL: "Invalid email";
+    readonly INVALID_EMAIL_OR_PASSWORD: "Invalid email or password";
+    readonly SOCIAL_ACCOUNT_ALREADY_LINKED: "Social account already linked";
+    readonly PROVIDER_NOT_FOUND: "Provider not found";
+    readonly INVALID_TOKEN: "Invalid token";
+    readonly ID_TOKEN_NOT_SUPPORTED: "id_token not supported";
+    readonly FAILED_TO_GET_USER_INFO: "Failed to get user info";
+    readonly USER_EMAIL_NOT_FOUND: "User email not found";
+    readonly EMAIL_NOT_VERIFIED: "Email not verified";
+    readonly PASSWORD_TOO_SHORT: "Password too short";
+    readonly PASSWORD_TOO_LONG: "Password too long";
+    readonly USER_ALREADY_EXISTS: "User already exists.";
+    readonly USER_ALREADY_EXISTS_USE_ANOTHER_EMAIL: "User already exists. Use another email.";
+    readonly EMAIL_CAN_NOT_BE_UPDATED: "Email can not be updated";
+    readonly CREDENTIAL_ACCOUNT_NOT_FOUND: "Credential account not found";
+    readonly SESSION_EXPIRED: "Session expired. Re-authenticate to perform this action.";
+    readonly FAILED_TO_UNLINK_LAST_ACCOUNT: "You can't unlink your last account";
+    readonly ACCOUNT_NOT_FOUND: "Account not found";
+    readonly USER_ALREADY_HAS_PASSWORD: "User already has a password. Provide that to delete the account.";
+};
+
+declare class BetterAuthError extends Error {
+    constructor(message: string, cause?: string);
+}
+
+export { BASE_ERROR_CODES, BetterAuthError };

package/dist/error/index.mjs

@@ -0,0 +1,41 @@
+import { defineErrorCodes } from '@better-auth/core/utils';
+
+const BASE_ERROR_CODES = defineErrorCodes({
+  USER_NOT_FOUND: "User not found",
+  FAILED_TO_CREATE_USER: "Failed to create user",
+  FAILED_TO_CREATE_SESSION: "Failed to create session",
+  FAILED_TO_UPDATE_USER: "Failed to update user",
+  FAILED_TO_GET_SESSION: "Failed to get session",
+  INVALID_PASSWORD: "Invalid password",
+  INVALID_EMAIL: "Invalid email",
+  INVALID_EMAIL_OR_PASSWORD: "Invalid email or password",
+  SOCIAL_ACCOUNT_ALREADY_LINKED: "Social account already linked",
+  PROVIDER_NOT_FOUND: "Provider not found",
+  INVALID_TOKEN: "Invalid token",
+  ID_TOKEN_NOT_SUPPORTED: "id_token not supported",
+  FAILED_TO_GET_USER_INFO: "Failed to get user info",
+  USER_EMAIL_NOT_FOUND: "User email not found",
+  EMAIL_NOT_VERIFIED: "Email not verified",
+  PASSWORD_TOO_SHORT: "Password too short",
+  PASSWORD_TOO_LONG: "Password too long",
+  USER_ALREADY_EXISTS: "User already exists.",
+  USER_ALREADY_EXISTS_USE_ANOTHER_EMAIL: "User already exists. Use another email.",
+  EMAIL_CAN_NOT_BE_UPDATED: "Email can not be updated",
+  CREDENTIAL_ACCOUNT_NOT_FOUND: "Credential account not found",
+  SESSION_EXPIRED: "Session expired. Re-authenticate to perform this action.",
+  FAILED_TO_UNLINK_LAST_ACCOUNT: "You can't unlink your last account",
+  ACCOUNT_NOT_FOUND: "Account not found",
+  USER_ALREADY_HAS_PASSWORD: "User already has a password. Provide that to delete the account."
+});
+
+class BetterAuthError extends Error {
+  constructor(message, cause) {
+    super(message);
+    this.name = "BetterAuthError";
+    this.message = message;
+    this.cause = cause;
+    this.stack = "";
+  }
+}
+
+export { BASE_ERROR_CODES, BetterAuthError };

package/dist/index.d.cts

@@ -1,2 +1,180 @@
+import { L as LiteralString } from './shared/core.CajxAutx.cjs';
+export { a as LiteralUnion } from './shared/core.CajxAutx.cjs';
+import { A as AuthContext, B as BetterAuthOptions, a as AuthMiddleware } from './shared/core.gYIBmdi1.cjs';
+export { b as BetterAuthAdvancedOptions, d as BetterAuthCookies, c as BetterAuthRateLimitOptions, G as GenerateIdFn, e as GenericEndpointContext, I as InternalAdapter } from './shared/core.gYIBmdi1.cjs';
+import { Migration } from 'kysely';
+import { Endpoint, Middleware, EndpointContext, InputContext } from 'better-call';
+import { B as BetterAuthPluginDBSchema } from './shared/core.HqYn20Fi.cjs';
+import { BetterFetch, BetterFetchOption, BetterFetchPlugin } from '@better-fetch/fetch';
+import { WritableAtom, Atom } from 'nanostores';
+import 'zod';
+import 'better-sqlite3';
+import './shared/core.Dl-70uns.cjs';
+import 'bun:sqlite';
+import 'node:sqlite';
+import './social-providers/index.cjs';
+import '@better-auth/core/oauth2';
+import './shared/core.DyEdx0m7.cjs';
+import './shared/core.BwoNUcJQ.cjs';
+import '@better-auth/core';
 
-export { };
+type Awaitable<T> = T | Promise<T>;
+type DeepPartial<T> = T extends Function ? T : T extends object ? {
+    [K in keyof T]?: DeepPartial<T[K]>;
+} : T;
+type HookEndpointContext = EndpointContext<string, any> & Omit<InputContext<string, any>, "method"> & {
+    context: AuthContext & {
+        returned?: unknown;
+        responseHeaders?: Headers;
+    };
+    headers?: Headers;
+};
+type BetterAuthPlugin = {
+    id: LiteralString;
+    /**
+     * The init function is called when the plugin is initialized.
+     * You can return a new context or modify the existing context.
+     */
+    init?: (ctx: AuthContext) => Awaitable<{
+        context?: DeepPartial<Omit<AuthContext, "options">>;
+        options?: Partial<BetterAuthOptions>;
+    }> | void | Promise<void>;
+    endpoints?: {
+        [key: string]: Endpoint;
+    };
+    middlewares?: {
+        path: string;
+        middleware: Middleware;
+    }[];
+    onRequest?: (request: Request, ctx: AuthContext) => Promise<{
+        response: Response;
+    } | {
+        request: Request;
+    } | void>;
+    onResponse?: (response: Response, ctx: AuthContext) => Promise<{
+        response: Response;
+    } | void>;
+    hooks?: {
+        before?: {
+            matcher: (context: HookEndpointContext) => boolean;
+            handler: AuthMiddleware;
+        }[];
+        after?: {
+            matcher: (context: HookEndpointContext) => boolean;
+            handler: AuthMiddleware;
+        }[];
+    };
+    /**
+     * Schema the plugin needs
+     *
+     * This will also be used to migrate the database. If the fields are dynamic from the plugins
+     * configuration each time the configuration is changed a new migration will be created.
+     *
+     * NOTE: If you want to create migrations manually using
+     * migrations option or any other way you
+     * can disable migration per table basis.
+     *
+     * @example
+     * ```ts
+     * schema: {
+     * 	user: {
+     * 		fields: {
+     * 			email: {
+     * 				 type: "string",
+     * 			},
+     * 			emailVerified: {
+     * 				type: "boolean",
+     * 				defaultValue: false,
+     * 			},
+     * 		},
+     * 	}
+     * } as AuthPluginSchema
+     * ```
+     */
+    schema?: BetterAuthPluginDBSchema;
+    /**
+     * The migrations of the plugin. If you define schema that will automatically create
+     * migrations for you.
+     *
+     * ⚠️ Only uses this if you dont't want to use the schema option and you disabled migrations for
+     * the tables.
+     */
+    migrations?: Record<string, Migration>;
+    /**
+     * The options of the plugin
+     */
+    options?: Record<string, any> | undefined;
+    /**
+     * types to be inferred
+     */
+    $Infer?: Record<string, any>;
+    /**
+     * The rate limit rules to apply to specific paths.
+     */
+    rateLimit?: {
+        window: number;
+        max: number;
+        pathMatcher: (path: string) => boolean;
+    }[];
+    /**
+     * The error codes returned by the plugin
+     */
+    $ERROR_CODES?: Record<string, string>;
+};
+
+interface ClientStore {
+    notify: (signal: string) => void;
+    listen: (signal: string, listener: () => void) => void;
+    atoms: Record<string, WritableAtom<any>>;
+}
+type ClientAtomListener = {
+    matcher: (path: string) => boolean;
+    signal: "$sessionSignal" | Omit<string, "$sessionSignal">;
+};
+interface BetterAuthClientOptions {
+    fetchOptions?: BetterFetchOption;
+    plugins?: BetterAuthClientPlugin[];
+    baseURL?: string;
+    basePath?: string;
+    disableDefaultFetchPlugins?: boolean;
+    $InferAuth?: BetterAuthOptions;
+}
+interface BetterAuthClientPlugin {
+    id: LiteralString;
+    /**
+     * only used for type inference. don't pass the
+     * actual plugin
+     */
+    $InferServerPlugin?: BetterAuthPlugin;
+    /**
+     * Custom actions
+     */
+    getActions?: ($fetch: BetterFetch, $store: ClientStore, 
+    /**
+     * better-auth client options
+     */
+    options: BetterAuthClientOptions | 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?: ClientAtomListener[];
+}
+
+export { AuthContext, BetterAuthOptions, LiteralString };
+export type { BetterAuthClientOptions, BetterAuthClientPlugin, BetterAuthPlugin, ClientAtomListener, ClientStore };