@better-auth/api-key 1.5.6 → 1.6.0-beta.0

package/dist/index-QFsA1o28.d.mts

@@ -0,0 +1,1966 @@
+import { n as ApiKeyConfigurationOptions, r as ApiKeyOptions, t as ApiKey } from "./types-CCe5L05Y.mjs";
+import * as better_auth0 from "better-auth";
+import { HookEndpointContext } from "@better-auth/core";
+
+//#region ../../node_modules/.pnpm/better-call@2.0.3_zod@4.3.6/node_modules/better-call/dist/cookies.d.mts
+//#region src/cookies.d.ts
+type CookiePrefixOptions = "host" | "secure";
+type CookieOptions = {
+  /**
+   * Domain of the cookie
+   *
+   * The Domain attribute specifies which server can receive a cookie. If specified, cookies are
+   * available on the specified server and its subdomains. If the it is not
+   * specified, the cookies are available on the server that sets it but not on
+   * its subdomains.
+   *
+   * @example
+   * `domain: "example.com"`
+   */
+  domain?: string;
+  /**
+   * A lifetime of a cookie. Permanent cookies are deleted after the date specified in the
+   * Expires attribute:
+   *
+   * Expires has been available for longer than Max-Age, however Max-Age is less error-prone, and
+   * takes precedence when both are set. The rationale behind this is that when you set an
+   * Expires date and time, they're relative to the client the cookie is being set on. If the
+   * server is set to a different time, this could cause errors
+   */
+  expires?: Date;
+  /**
+   * Forbids JavaScript from accessing the cookie, for example, through the Document.cookie
+   * property. Note that a cookie that has been created with HttpOnly will still be sent with
+   * JavaScript-initiated requests, for example, when calling XMLHttpRequest.send() or fetch().
+   * This mitigates attacks against cross-site scripting
+   */
+  httpOnly?: boolean;
+  /**
+   * Indicates the number of seconds until the cookie expires. A zero or negative number will
+   * expire the cookie immediately. If both Expires and Max-Age are set, Max-Age has precedence.
+   *
+   * @example 604800 - 7 days
+   */
+  maxAge?: number;
+  /**
+   * Indicates the path that must exist in the requested URL for the browser to send the Cookie
+   * header.
+   *
+   * @example
+   * "/docs"
+   * // -> the request paths /docs, /docs/, /docs/Web/, and /docs/Web/HTTP will all match. the request paths /, /fr/docs will not match.
+   */
+  path?: string;
+  /**
+   * Indicates that the cookie is sent to the server only when a request is made with the https:
+   * scheme (except on localhost), and therefore, is more resistant to man-in-the-middle attacks.
+   */
+  secure?: boolean;
+  /**
+   * Controls whether or not a cookie is sent with cross-site requests, providing some protection
+   * against cross-site request forgery attacks (CSRF).
+   *
+   * Strict -  Means that the browser sends the cookie only for same-site requests, that is,
+   * requests originating from the same site that set the cookie. If a request originates from a
+   * different domain or scheme (even with the same domain), no cookies with the SameSite=Strict
+   * attribute are sent.
+   *
+   * Lax - Means that the cookie is not sent on cross-site requests, such as on requests to load
+   * images or frames, but is sent when a user is navigating to the origin site from an external
+   * site (for example, when following a link). This is the default behavior if the SameSite
+   * attribute is not specified.
+   *
+   * None - Means that the browser sends the cookie with both cross-site and same-site requests.
+   * The Secure attribute must also be set when setting this value.
+   */
+  sameSite?: "Strict" | "Lax" | "None" | "strict" | "lax" | "none";
+  /**
+   * Indicates that the cookie should be stored using partitioned storage. Note that if this is
+   * set, the Secure directive must also be set.
+   *
+   * @see https://developer.mozilla.org/en-US/docs/Web/Privacy/Privacy_sandbox/Partitioned_cookies
+   */
+  partitioned?: boolean;
+  /**
+   * Cooke Prefix
+   *
+   * - secure: `__Secure-` -> `__Secure-cookie-name`
+   * - host: `__Host-` -> `__Host-cookie-name`
+   *
+   * `secure` must be set to true to use prefixes
+   */
+  prefix?: CookiePrefixOptions;
+};
+//#endregion
+//#region ../../node_modules/.pnpm/better-call@2.0.3_zod@4.3.6/node_modules/better-call/dist/standard-schema.d.mts
+//#region src/standard-schema.d.ts
+/** The Standard Schema interface. */
+interface StandardSchemaV1<Input = unknown, Output = Input> {
+  /** The Standard Schema properties. */
+  readonly "~standard": StandardSchemaV1.Props<Input, Output>;
+}
+declare namespace StandardSchemaV1 {
+  /** The Standard Schema properties interface. */
+  interface Props<Input = unknown, Output = Input> {
+    /** The version number of the standard. */
+    readonly version: 1;
+    /** The vendor name of the schema library. */
+    readonly vendor: string;
+    /** Validates unknown input values. */
+    readonly validate: (value: unknown) => Result<Output> | Promise<Result<Output>>;
+    /** Inferred types associated with the schema. */
+    readonly types?: Types<Input, Output> | undefined;
+  }
+  /** The result interface of the validate function. */
+  type Result<Output> = SuccessResult<Output> | FailureResult;
+  /** The result interface if validation succeeds. */
+  interface SuccessResult<Output> {
+    /** The typed output value. */
+    readonly value: Output;
+    /** The non-existent issues. */
+    readonly issues?: undefined;
+  }
+  /** The result interface if validation fails. */
+  interface FailureResult {
+    /** The issues of failed validation. */
+    readonly issues: ReadonlyArray<Issue>;
+  }
+  /** The issue interface of the failure output. */
+  interface Issue {
+    /** The error message of the issue. */
+    readonly message: string;
+    /** The path of the issue, if any. */
+    readonly path?: ReadonlyArray<PropertyKey | PathSegment> | undefined;
+  }
+  /** The path segment interface of the issue. */
+  interface PathSegment {
+    /** The key representing a path segment. */
+    readonly key: PropertyKey;
+  }
+  /** The Standard Schema types interface. */
+  interface Types<Input = unknown, Output = Input> {
+    /** The input type of the schema. */
+    readonly input: Input;
+    /** The output type of the schema. */
+    readonly output: Output;
+  }
+  /** Infers the input type of a Standard Schema. */
+  type InferInput<Schema extends StandardSchemaV1> = NonNullable<Schema["~standard"]["types"]>["input"];
+  /** Infers the output type of a Standard Schema. */
+  type InferOutput<Schema extends StandardSchemaV1> = NonNullable<Schema["~standard"]["types"]>["output"];
+} //#endregion
+//#endregion
+//#region ../../node_modules/.pnpm/better-call@2.0.3_zod@4.3.6/node_modules/better-call/dist/error.d.mts
+declare const statusCodes: {
+  OK: number;
+  CREATED: number;
+  ACCEPTED: number;
+  NO_CONTENT: number;
+  MULTIPLE_CHOICES: number;
+  MOVED_PERMANENTLY: number;
+  FOUND: number;
+  SEE_OTHER: number;
+  NOT_MODIFIED: number;
+  TEMPORARY_REDIRECT: number;
+  BAD_REQUEST: number;
+  UNAUTHORIZED: number;
+  PAYMENT_REQUIRED: number;
+  FORBIDDEN: number;
+  NOT_FOUND: number;
+  METHOD_NOT_ALLOWED: number;
+  NOT_ACCEPTABLE: number;
+  PROXY_AUTHENTICATION_REQUIRED: number;
+  REQUEST_TIMEOUT: number;
+  CONFLICT: number;
+  GONE: number;
+  LENGTH_REQUIRED: number;
+  PRECONDITION_FAILED: number;
+  PAYLOAD_TOO_LARGE: number;
+  URI_TOO_LONG: number;
+  UNSUPPORTED_MEDIA_TYPE: number;
+  RANGE_NOT_SATISFIABLE: number;
+  EXPECTATION_FAILED: number;
+  "I'M_A_TEAPOT": number;
+  MISDIRECTED_REQUEST: number;
+  UNPROCESSABLE_ENTITY: number;
+  LOCKED: number;
+  FAILED_DEPENDENCY: number;
+  TOO_EARLY: number;
+  UPGRADE_REQUIRED: number;
+  PRECONDITION_REQUIRED: number;
+  TOO_MANY_REQUESTS: number;
+  REQUEST_HEADER_FIELDS_TOO_LARGE: number;
+  UNAVAILABLE_FOR_LEGAL_REASONS: number;
+  INTERNAL_SERVER_ERROR: number;
+  NOT_IMPLEMENTED: number;
+  BAD_GATEWAY: number;
+  SERVICE_UNAVAILABLE: number;
+  GATEWAY_TIMEOUT: number;
+  HTTP_VERSION_NOT_SUPPORTED: number;
+  VARIANT_ALSO_NEGOTIATES: number;
+  INSUFFICIENT_STORAGE: number;
+  LOOP_DETECTED: number;
+  NOT_EXTENDED: number;
+  NETWORK_AUTHENTICATION_REQUIRED: number;
+};
+type Status = 100 | 101 | 102 | 103 | 200 | 201 | 202 | 203 | 204 | 205 | 206 | 207 | 208 | 226 | 300 | 301 | 302 | 303 | 304 | 305 | 306 | 307 | 308 | 400 | 401 | 402 | 403 | 404 | 405 | 406 | 407 | 408 | 409 | 410 | 411 | 412 | 413 | 414 | 415 | 416 | 417 | 418 | 421 | 422 | 423 | 424 | 425 | 426 | 428 | 429 | 431 | 451 | 500 | 501 | 502 | 503 | 504 | 505 | 506 | 507 | 508 | 510 | 511;
+declare class InternalAPIError extends Error {
+  status: keyof typeof statusCodes | Status;
+  body: ({
+    message?: string;
+    code?: string;
+    cause?: unknown;
+  } & Record<string, any>) | undefined;
+  headers: HeadersInit;
+  statusCode: number;
+  constructor(status?: keyof typeof statusCodes | Status, body?: ({
+    message?: string;
+    code?: string;
+    cause?: unknown;
+  } & Record<string, any>) | undefined, headers?: HeadersInit, statusCode?: number);
+}
+type APIError = InstanceType<typeof InternalAPIError>;
+declare const APIError: new (status?: Status | "OK" | "CREATED" | "ACCEPTED" | "NO_CONTENT" | "MULTIPLE_CHOICES" | "MOVED_PERMANENTLY" | "FOUND" | "SEE_OTHER" | "NOT_MODIFIED" | "TEMPORARY_REDIRECT" | "BAD_REQUEST" | "UNAUTHORIZED" | "PAYMENT_REQUIRED" | "FORBIDDEN" | "NOT_FOUND" | "METHOD_NOT_ALLOWED" | "NOT_ACCEPTABLE" | "PROXY_AUTHENTICATION_REQUIRED" | "REQUEST_TIMEOUT" | "CONFLICT" | "GONE" | "LENGTH_REQUIRED" | "PRECONDITION_FAILED" | "PAYLOAD_TOO_LARGE" | "URI_TOO_LONG" | "UNSUPPORTED_MEDIA_TYPE" | "RANGE_NOT_SATISFIABLE" | "EXPECTATION_FAILED" | "I'M_A_TEAPOT" | "MISDIRECTED_REQUEST" | "UNPROCESSABLE_ENTITY" | "LOCKED" | "FAILED_DEPENDENCY" | "TOO_EARLY" | "UPGRADE_REQUIRED" | "PRECONDITION_REQUIRED" | "TOO_MANY_REQUESTS" | "REQUEST_HEADER_FIELDS_TOO_LARGE" | "UNAVAILABLE_FOR_LEGAL_REASONS" | "INTERNAL_SERVER_ERROR" | "NOT_IMPLEMENTED" | "BAD_GATEWAY" | "SERVICE_UNAVAILABLE" | "GATEWAY_TIMEOUT" | "HTTP_VERSION_NOT_SUPPORTED" | "VARIANT_ALSO_NEGOTIATES" | "INSUFFICIENT_STORAGE" | "LOOP_DETECTED" | "NOT_EXTENDED" | "NETWORK_AUTHENTICATION_REQUIRED" | undefined, body?: ({
+  message?: string;
+  code?: string;
+  cause?: unknown;
+} & Record<string, any>) | undefined, headers?: HeadersInit | undefined, statusCode?: number | undefined) => InternalAPIError & {
+  errorStack: string | undefined;
+}; //#endregion
+//#endregion
+//#region ../../node_modules/.pnpm/better-call@2.0.3_zod@4.3.6/node_modules/better-call/dist/helper.d.mts
+type Prettify<T> = 0 extends 1 & T ? any : { [K in keyof T]: T[K] } & {};
+type IsEmptyObject<T> = keyof T extends never ? true : false;
+type InferParamPath<Path> = Path extends `${infer _Start}:${infer Param}/${infer Rest}` ? { [K in Param | keyof InferParamPath<Rest>]: string } : Path extends `${infer _Start}:${infer Param}` ? { [K in Param]: string } : Path extends `${infer _Start}/${infer Rest}` ? InferParamPath<Rest> : {};
+type InferParamWildCard<Path> = Path extends `${infer _Start}/*:${infer Param}/${infer Rest}` | `${infer _Start}/**:${infer Param}/${infer Rest}` ? { [K in Param | keyof InferParamPath<Rest>]: string } : Path extends `${infer _Start}/*` ? { [K in "_"]: string } : Path extends `${infer _Start}/${infer Rest}` ? InferParamWildCard<Rest> : {}; //#endregion
+//#endregion
+//#region ../../node_modules/.pnpm/better-call@2.0.3_zod@4.3.6/node_modules/better-call/dist/middleware.d.mts
+//#region src/middleware.d.ts
+type MiddlewareContext<Context = {}> = {
+  /**
+   * Method
+   *
+   * The request method
+   */
+  method: string;
+  /**
+   * Path
+   *
+   * The path of the endpoint
+   */
+  path: string;
+  /**
+   * Body
+   *
+   * The body object will be the parsed JSON from the request and validated
+   * against the body schema if it exists
+   */
+  body: any;
+  /**
+   * Query
+   *
+   * The query object will be the parsed query string from the request
+   * and validated against the query schema if it exists
+   */
+  query: Record<string, any> | undefined;
+  /**
+   * Params
+   *
+   * If the path is `/user/:id` and the request is `/user/1` then the
+   * params will be `{ id: "1" }` and if the path includes a wildcard like
+   * `/user/*` then the params will be `{ _: "1" }` where `_` is the wildcard
+   * key. If the wildcard is named like `/user/**:name` then the params will
+   * be `{ name: string }`
+   */
+  params: Record<string, any> | undefined;
+  /**
+   * Request object
+   *
+   * If `requireRequest` is set to true in the endpoint options this will be
+   * required
+   */
+  request: Request | undefined;
+  /**
+   * Headers
+   *
+   * If `requireHeaders` is set to true in the endpoint options this will be
+   * required
+   */
+  headers: Headers | undefined;
+  /**
+   * Set header
+   *
+   * If it's called outside of a request it will just be ignored.
+   */
+  setHeader: (key: string, value: string) => void;
+  /**
+   * Set the response status code
+   */
+  setStatus: (status: Status) => void;
+  /**
+   * Get header
+   *
+   * If it's called outside of a request it will just return null
+   *
+   * @param key - The key of the header
+   */
+  getHeader: (key: string) => string | null;
+  /**
+   * Get a cookie value from the request
+   *
+   * @param key - The key of the cookie
+   * @param prefix - The prefix of the cookie between `__Secure-` and `__Host-`
+   * @returns The value of the cookie
+   */
+  getCookie: (key: string, prefix?: CookiePrefixOptions) => string | null;
+  /**
+   * Get a signed cookie value from the request
+   *
+   * @param key - The key of the cookie
+   * @param secret - The secret of the signed cookie
+   * @param prefix - The prefix of the cookie between `__Secure-` and `__Host-`
+   * @returns The value of the cookie or null if the cookie is not found or false if the signature is invalid
+   */
+  getSignedCookie: (key: string, secret: string, prefix?: CookiePrefixOptions) => Promise<string | null | false>;
+  /**
+   * Set a cookie value in the response
+   *
+   * @param key - The key of the cookie
+   * @param value - The value to set
+   * @param options - The options of the cookie
+   * @returns The cookie string
+   */
+  setCookie: (key: string, value: string, options?: CookieOptions) => string;
+  /**
+   * Set signed cookie
+   *
+   * @param key - The key of the cookie
+   * @param value - The value to set
+   * @param secret - The secret to sign the cookie with
+   * @param options - The options of the cookie
+   * @returns The cookie string
+   */
+  setSignedCookie: (key: string, value: string, secret: string, options?: CookieOptions) => Promise<string>;
+  /**
+   * JSON
+   *
+   * A helper function to create a JSON response with the correct headers
+   * and status code. If `asResponse` is set to true in the context then
+   * it will return a Response object instead of the JSON object.
+   *
+   * @param json - The JSON object to return
+   * @param routerResponse - The response object to return if `asResponse` is
+   * true in the context this will take precedence
+   */
+  json: <R extends Record<string, any> | null>(json: R, routerResponse?: {
+    status?: number;
+    headers?: Record<string, string>;
+    response?: Response;
+    body?: Record<string, any>;
+  } | Response) => R;
+  /**
+   * Middleware context
+   */
+  context: Prettify<Context>;
+  /**
+   * Redirect to a new URL
+   */
+  redirect: (url: string) => APIError;
+  /**
+   * Return error
+   */
+  error: (status: keyof typeof statusCodes | Status, body?: {
+    message?: string;
+    code?: string;
+  } & Record<string, any>, headers?: HeadersInit) => APIError;
+  asResponse?: boolean;
+  returnHeaders?: boolean;
+  returnStatus?: boolean;
+  responseHeaders: Headers;
+};
+type DefaultHandler = (inputCtx: MiddlewareContext<any>) => Promise<any>;
+type Middleware<Handler extends (inputCtx: MiddlewareContext<any>) => Promise<any> = DefaultHandler> = Handler & {
+  options: Record<string, any>;
+};
+//#endregion
+//#region ../../node_modules/.pnpm/better-call@2.0.3_zod@4.3.6/node_modules/better-call/dist/types.d.mts
+//#region src/types.d.ts
+type HTTPMethod = "GET" | "POST" | "PUT" | "DELETE" | "PATCH" | "HEAD";
+/**
+ * Resolves a method type parameter to its effective runtime type.
+ */
+/**
+ * Infer param input (required vs optional based on whether path has params).
+ */
+type InferParamInput<Path extends string> = [Path] extends [never] ? {
+  params?: Record<string, any>;
+} : IsEmptyObject<InferParamPath<Path> & InferParamWildCard<Path>> extends true ? {
+  params?: Record<string, any>;
+} : {
+  params: Prettify<InferParamPath<Path> & InferParamWildCard<Path>>;
+};
+/**
+ * Infer body input from an already-resolved body type.
+ * Body is the plain resolved type (not a schema).
+ */
+type InferBodyInput<Body> = undefined extends Body ? {
+  body?: Body;
+} : {
+  body: Body;
+};
+/**
+ * Infer query input from an already-resolved query type.
+ * Query is the plain resolved type (not a schema).
+ */
+type InferQueryInput<Query> = undefined extends Query ? {
+  query?: Query;
+} : {
+  query: Query;
+};
+/**
+ * Infer method input: required for wildcard, optional for arrays and single methods.
+ */
+type InferMethodInput<M> = 0 extends 1 & M ? {
+  method?: HTTPMethod | undefined;
+} : M extends "*" ? {
+  method: HTTPMethod;
+} : M extends Array<any> ? {
+  method?: M[number] | undefined;
+} : {
+  method?: M | undefined;
+};
+/**
+ * Infer request input.
+ */
+type InferRequestInput<ReqRequest extends boolean> = 0 extends 1 & ReqRequest ? {
+  request?: Request;
+} : ReqRequest extends true ? {
+  request: Request;
+} : {
+  request?: Request;
+};
+/**
+ * Infer headers input.
+ */
+type InferHeadersInput<ReqHeaders extends boolean> = 0 extends 1 & ReqHeaders ? {
+  headers?: HeadersInit;
+} : ReqHeaders extends true ? {
+  headers: HeadersInit;
+} : {
+  headers?: HeadersInit;
+};
+/**
+ * Infer the use (middleware) context union.
+ * Guards against `any` and `[]` to avoid poisoning the Context type.
+ */
+/**
+ * The full InputContext type for the Endpoint call signature.
+ * Body and Query are already-resolved plain types.
+ */
+type InputContext<Path extends string, M, Body, Query, ReqHeaders extends boolean, ReqRequest extends boolean> = InferBodyInput<Body> & InferMethodInput<M> & InferQueryInput<Query> & InferParamInput<Path> & InferRequestInput<ReqRequest> & InferHeadersInput<ReqHeaders> & {
+  asResponse?: boolean;
+  returnHeaders?: boolean;
+  returnStatus?: boolean;
+  use?: Middleware[];
+  path?: string;
+  context?: Record<string, any>;
+}; //#endregion
+//#endregion
+//#region ../../node_modules/.pnpm/better-call@2.0.3_zod@4.3.6/node_modules/better-call/dist/endpoint.d.mts
+//#region src/endpoint.d.ts
+interface EndpointMetadata {
+  /**
+   * Open API definition
+   */
+  openapi?: {
+    summary?: string;
+    description?: string;
+    tags?: string[];
+    operationId?: string;
+    parameters?: OpenAPIParameter[];
+    requestBody?: {
+      content: {
+        "application/json": {
+          schema: {
+            type?: OpenAPISchemaType;
+            properties?: Record<string, any>;
+            required?: string[];
+            $ref?: string;
+          };
+        };
+      };
+    };
+    responses?: {
+      [status: string]: {
+        description: string;
+        content?: {
+          "application/json"?: {
+            schema: {
+              type?: OpenAPISchemaType;
+              properties?: Record<string, any>;
+              required?: string[];
+              $ref?: string;
+            };
+          };
+          "text/plain"?: {
+            schema?: {
+              type?: OpenAPISchemaType;
+              properties?: Record<string, any>;
+              required?: string[];
+              $ref?: string;
+            };
+          };
+          "text/html"?: {
+            schema?: {
+              type?: OpenAPISchemaType;
+              properties?: Record<string, any>;
+              required?: string[];
+              $ref?: string;
+            };
+          };
+        };
+      };
+    };
+  };
+  /**
+   * Infer body and query type from ts interface
+   *
+   * useful for generic and dynamic types
+   *
+   * @example
+   * ```ts
+   * const endpoint = createEndpoint("/path", {
+   * 		method: "POST",
+   * 		body: z.record(z.string()),
+   * 		$Infer: {
+   * 			body: {} as {
+   * 				type: InferTypeFromOptions<Option> // custom type inference
+   * 			}
+   * 		}
+   * 	}, async(ctx)=>{
+   * 		const body = ctx.body
+   * 	})
+   * ```
+   */
+  $Infer?: {
+    /**
+     * Body
+     */
+    body?: any;
+    /**
+     * Query
+     */
+    query?: Record<string, any>;
+    /**
+     * Error
+     */
+    error?: any;
+  };
+  /**
+   * If enabled, endpoint won't be exposed over a router
+   * @deprecated Use path-less endpoints instead
+   */
+  SERVER_ONLY?: boolean;
+  /**
+   * If enabled, endpoint won't be exposed as an action to the client
+   * @deprecated Use path-less endpoints instead
+   */
+  isAction?: boolean;
+  /**
+   * Defines the places where the endpoint will be available
+   *
+   * Possible options:
+   * - `rpc` - the endpoint is exposed to the router, can be invoked directly and is available to the client
+   * - `server` - the endpoint is exposed to the router, can be invoked directly, but is not available to the client
+   * - `http` - the endpoint is only exposed to the router
+   * @default "rpc"
+   */
+  scope?: "rpc" | "server" | "http";
+  /**
+   * List of allowed media types (MIME types) for the endpoint
+   *
+   * if provided, only the media types in the list will be allowed to be passed in the body
+   *
+   * @example
+   * ```ts
+   * const endpoint = createEndpoint("/path", {
+   * 		method: "POST",
+   * 		allowedMediaTypes: ["application/json", "application/x-www-form-urlencoded"],
+   * 	}, async(ctx)=>{
+   * 		const body = ctx.body
+   * 	})
+   * ```
+   */
+  allowedMediaTypes?: string[];
+  /**
+   * Extra metadata
+   */
+  [key: string]: any;
+}
+interface EndpointRuntimeOptions {
+  method: string | string[];
+  body?: StandardSchemaV1;
+  /**
+   * Query Schema
+   */
+  query?: StandardSchemaV1;
+  /**
+   * Error Schema
+   */
+  error?: StandardSchemaV1;
+  /**
+   * If true headers will be required to be passed in the context
+   */
+  requireHeaders?: boolean;
+  /**
+   * If true request object will be required
+   */
+  requireRequest?: boolean;
+  /**
+   * Clone the request object from the router
+   */
+  cloneRequest?: boolean;
+  /**
+   * If true the body will be undefined
+   */
+  disableBody?: boolean;
+  /**
+   * Endpoint metadata
+   */
+  metadata?: EndpointMetadata;
+  /**
+   * List of middlewares to use
+   */
+  use?: Middleware[];
+  /**
+   * A callback to run before any API error is thrown or returned
+   *
+   * @param e - The API error
+   */
+  onAPIError?: (e: APIError) => void | Promise<void>;
+  /**
+   * A callback to run before a validation error is thrown.
+   * You can customize the validation error message by throwing your own APIError.
+   */
+  onValidationError?: (info: {
+    message: string;
+    issues: readonly StandardSchemaV1.Issue[];
+  }) => void | Promise<void>;
+}
+type Endpoint<Path extends string = string, Method = any, Body = any, Query = any, Use extends Middleware[] = any, R = any, Meta extends EndpointMetadata | undefined = EndpointMetadata | undefined, Error = any> = {
+  (context: InputContext<Path, Method, Body, Query, false, false> & {
+    asResponse: true;
+  }): Promise<Response>;
+  (context: InputContext<Path, Method, Body, Query, false, false> & {
+    returnHeaders: true;
+    returnStatus: true;
+  }): Promise<{
+    headers: Headers;
+    status: number;
+    response: Awaited<R>;
+  }>;
+  (context: InputContext<Path, Method, Body, Query, false, false> & {
+    returnHeaders: true;
+  }): Promise<{
+    headers: Headers;
+    response: Awaited<R>;
+  }>;
+  (context: InputContext<Path, Method, Body, Query, false, false> & {
+    returnStatus: true;
+  }): Promise<{
+    status: number;
+    response: Awaited<R>;
+  }>;
+  (context?: InputContext<Path, Method, Body, Query, false, false>): Promise<Awaited<R>>;
+  readonly options: Omit<EndpointRuntimeOptions, "method" | "metadata"> & {
+    readonly method: Method;
+    readonly metadata?: Meta;
+  };
+  readonly path: Path;
+};
+//#endregion
+//#region ../../node_modules/.pnpm/better-call@2.0.3_zod@4.3.6/node_modules/better-call/dist/openapi.d.mts
+//#region src/openapi.d.ts
+type OpenAPISchemaType = "string" | "number" | "integer" | "boolean" | "array" | "object";
+interface OpenAPIParameter {
+  in: "query" | "path" | "header" | "cookie";
+  name?: string;
+  description?: string;
+  required?: boolean;
+  schema?: {
+    type: OpenAPISchemaType;
+    format?: string | undefined;
+    items?: {
+      type: OpenAPISchemaType;
+    };
+    enum?: string[];
+    minLength?: number;
+    description?: string | undefined;
+    default?: string | undefined;
+    example?: string | undefined;
+  };
+}
+//#endregion
+//#region src/error-codes.d.ts
+declare const API_KEY_ERROR_CODES: {
+  INVALID_METADATA_TYPE: better_auth0.RawError<"INVALID_METADATA_TYPE">;
+  REFILL_AMOUNT_AND_INTERVAL_REQUIRED: better_auth0.RawError<"REFILL_AMOUNT_AND_INTERVAL_REQUIRED">;
+  REFILL_INTERVAL_AND_AMOUNT_REQUIRED: better_auth0.RawError<"REFILL_INTERVAL_AND_AMOUNT_REQUIRED">;
+  USER_BANNED: better_auth0.RawError<"USER_BANNED">;
+  UNAUTHORIZED_SESSION: better_auth0.RawError<"UNAUTHORIZED_SESSION">;
+  KEY_NOT_FOUND: better_auth0.RawError<"KEY_NOT_FOUND">;
+  KEY_DISABLED: better_auth0.RawError<"KEY_DISABLED">;
+  KEY_EXPIRED: better_auth0.RawError<"KEY_EXPIRED">;
+  USAGE_EXCEEDED: better_auth0.RawError<"USAGE_EXCEEDED">;
+  KEY_NOT_RECOVERABLE: better_auth0.RawError<"KEY_NOT_RECOVERABLE">;
+  EXPIRES_IN_IS_TOO_SMALL: better_auth0.RawError<"EXPIRES_IN_IS_TOO_SMALL">;
+  EXPIRES_IN_IS_TOO_LARGE: better_auth0.RawError<"EXPIRES_IN_IS_TOO_LARGE">;
+  INVALID_REMAINING: better_auth0.RawError<"INVALID_REMAINING">;
+  INVALID_PREFIX_LENGTH: better_auth0.RawError<"INVALID_PREFIX_LENGTH">;
+  INVALID_NAME_LENGTH: better_auth0.RawError<"INVALID_NAME_LENGTH">;
+  METADATA_DISABLED: better_auth0.RawError<"METADATA_DISABLED">;
+  RATE_LIMIT_EXCEEDED: better_auth0.RawError<"RATE_LIMIT_EXCEEDED">;
+  NO_VALUES_TO_UPDATE: better_auth0.RawError<"NO_VALUES_TO_UPDATE">;
+  KEY_DISABLED_EXPIRATION: better_auth0.RawError<"KEY_DISABLED_EXPIRATION">;
+  INVALID_API_KEY: better_auth0.RawError<"INVALID_API_KEY">;
+  INVALID_USER_ID_FROM_API_KEY: better_auth0.RawError<"INVALID_USER_ID_FROM_API_KEY">;
+  INVALID_REFERENCE_ID_FROM_API_KEY: better_auth0.RawError<"INVALID_REFERENCE_ID_FROM_API_KEY">;
+  INVALID_API_KEY_GETTER_RETURN_TYPE: better_auth0.RawError<"INVALID_API_KEY_GETTER_RETURN_TYPE">;
+  SERVER_ONLY_PROPERTY: better_auth0.RawError<"SERVER_ONLY_PROPERTY">;
+  FAILED_TO_UPDATE_API_KEY: better_auth0.RawError<"FAILED_TO_UPDATE_API_KEY">;
+  NAME_REQUIRED: better_auth0.RawError<"NAME_REQUIRED">;
+  ORGANIZATION_ID_REQUIRED: better_auth0.RawError<"ORGANIZATION_ID_REQUIRED">;
+  USER_NOT_MEMBER_OF_ORGANIZATION: better_auth0.RawError<"USER_NOT_MEMBER_OF_ORGANIZATION">;
+  INSUFFICIENT_API_KEY_PERMISSIONS: better_auth0.RawError<"INSUFFICIENT_API_KEY_PERMISSIONS">;
+  NO_DEFAULT_API_KEY_CONFIGURATION_FOUND: better_auth0.RawError<"NO_DEFAULT_API_KEY_CONFIGURATION_FOUND">;
+  ORGANIZATION_PLUGIN_REQUIRED: better_auth0.RawError<"ORGANIZATION_PLUGIN_REQUIRED">;
+};
+//#endregion
+//#region src/index.d.ts
+declare module "@better-auth/core" {
+  interface BetterAuthPluginRegistry<AuthOptions, Options> {
+    "api-key": {
+      creator: typeof apiKey;
+    };
+  }
+}
+declare const defaultKeyHasher: (key: string) => Promise<string>;
+declare const API_KEY_TABLE_NAME = "apikey";
+declare function apiKey(_configurations?: (ApiKeyConfigurationOptions & ApiKeyOptions) | ApiKeyConfigurationOptions[] | undefined, _options?: ApiKeyOptions | undefined): {
+  id: "api-key";
+  version: string;
+  $ERROR_CODES: {
+    INVALID_METADATA_TYPE: better_auth0.RawError<"INVALID_METADATA_TYPE">;
+    REFILL_AMOUNT_AND_INTERVAL_REQUIRED: better_auth0.RawError<"REFILL_AMOUNT_AND_INTERVAL_REQUIRED">;
+    REFILL_INTERVAL_AND_AMOUNT_REQUIRED: better_auth0.RawError<"REFILL_INTERVAL_AND_AMOUNT_REQUIRED">;
+    USER_BANNED: better_auth0.RawError<"USER_BANNED">;
+    UNAUTHORIZED_SESSION: better_auth0.RawError<"UNAUTHORIZED_SESSION">;
+    KEY_NOT_FOUND: better_auth0.RawError<"KEY_NOT_FOUND">;
+    KEY_DISABLED: better_auth0.RawError<"KEY_DISABLED">;
+    KEY_EXPIRED: better_auth0.RawError<"KEY_EXPIRED">;
+    USAGE_EXCEEDED: better_auth0.RawError<"USAGE_EXCEEDED">;
+    KEY_NOT_RECOVERABLE: better_auth0.RawError<"KEY_NOT_RECOVERABLE">;
+    EXPIRES_IN_IS_TOO_SMALL: better_auth0.RawError<"EXPIRES_IN_IS_TOO_SMALL">;
+    EXPIRES_IN_IS_TOO_LARGE: better_auth0.RawError<"EXPIRES_IN_IS_TOO_LARGE">;
+    INVALID_REMAINING: better_auth0.RawError<"INVALID_REMAINING">;
+    INVALID_PREFIX_LENGTH: better_auth0.RawError<"INVALID_PREFIX_LENGTH">;
+    INVALID_NAME_LENGTH: better_auth0.RawError<"INVALID_NAME_LENGTH">;
+    METADATA_DISABLED: better_auth0.RawError<"METADATA_DISABLED">;
+    RATE_LIMIT_EXCEEDED: better_auth0.RawError<"RATE_LIMIT_EXCEEDED">;
+    NO_VALUES_TO_UPDATE: better_auth0.RawError<"NO_VALUES_TO_UPDATE">;
+    KEY_DISABLED_EXPIRATION: better_auth0.RawError<"KEY_DISABLED_EXPIRATION">;
+    INVALID_API_KEY: better_auth0.RawError<"INVALID_API_KEY">;
+    INVALID_USER_ID_FROM_API_KEY: better_auth0.RawError<"INVALID_USER_ID_FROM_API_KEY">;
+    INVALID_REFERENCE_ID_FROM_API_KEY: better_auth0.RawError<"INVALID_REFERENCE_ID_FROM_API_KEY">;
+    INVALID_API_KEY_GETTER_RETURN_TYPE: better_auth0.RawError<"INVALID_API_KEY_GETTER_RETURN_TYPE">;
+    SERVER_ONLY_PROPERTY: better_auth0.RawError<"SERVER_ONLY_PROPERTY">;
+    FAILED_TO_UPDATE_API_KEY: better_auth0.RawError<"FAILED_TO_UPDATE_API_KEY">;
+    NAME_REQUIRED: better_auth0.RawError<"NAME_REQUIRED">;
+    ORGANIZATION_ID_REQUIRED: better_auth0.RawError<"ORGANIZATION_ID_REQUIRED">;
+    USER_NOT_MEMBER_OF_ORGANIZATION: better_auth0.RawError<"USER_NOT_MEMBER_OF_ORGANIZATION">;
+    INSUFFICIENT_API_KEY_PERMISSIONS: better_auth0.RawError<"INSUFFICIENT_API_KEY_PERMISSIONS">;
+    NO_DEFAULT_API_KEY_CONFIGURATION_FOUND: better_auth0.RawError<"NO_DEFAULT_API_KEY_CONFIGURATION_FOUND">;
+    ORGANIZATION_PLUGIN_REQUIRED: better_auth0.RawError<"ORGANIZATION_PLUGIN_REQUIRED">;
+  };
+  hooks: {
+    before: {
+      matcher: (ctx: HookEndpointContext) => boolean;
+      handler: Middleware<(inputContext: Record<string, any>) => Promise<{
+        user: {
+          id: string;
+          createdAt: Date;
+          updatedAt: Date;
+          email: string;
+          emailVerified: boolean;
+          name: string;
+          image?: string | null | undefined;
+        };
+        session: {
+          id: string;
+          token: string;
+          userId: string;
+          userAgent: string | null;
+          ipAddress: string | null;
+          createdAt: Date;
+          updatedAt: Date;
+          expiresAt: Date;
+        };
+      } | {
+        context: MiddlewareContext<{
+          returned?: unknown | undefined;
+          responseHeaders?: Headers | undefined;
+        } & better_auth0.PluginContext<better_auth0.BetterAuthOptions> & better_auth0.InfoContext & {
+          options: better_auth0.BetterAuthOptions;
+          trustedOrigins: string[];
+          trustedProviders: string[];
+          isTrustedOrigin: (url: string, settings?: {
+            allowRelativePaths: boolean;
+          }) => boolean;
+          oauthConfig: {
+            skipStateCookieCheck?: boolean | undefined;
+            storeStateStrategy: "database" | "cookie";
+          };
+          newSession: {
+            session: {
+              id: string;
+              createdAt: Date;
+              updatedAt: Date;
+              userId: string;
+              expiresAt: Date;
+              token: string;
+              ipAddress?: string | null | undefined;
+              userAgent?: string | null | undefined;
+            } & Record<string, any>;
+            user: {
+              id: string;
+              createdAt: Date;
+              updatedAt: Date;
+              email: string;
+              emailVerified: boolean;
+              name: string;
+              image?: string | null | undefined;
+            } & Record<string, any>;
+          } | null;
+          session: {
+            session: {
+              id: string;
+              createdAt: Date;
+              updatedAt: Date;
+              userId: string;
+              expiresAt: Date;
+              token: string;
+              ipAddress?: string | null | undefined;
+              userAgent?: string | null | undefined;
+            } & Record<string, any>;
+            user: {
+              id: string;
+              createdAt: Date;
+              updatedAt: Date;
+              email: string;
+              emailVerified: boolean;
+              name: string;
+              image?: string | null | undefined;
+            } & Record<string, any>;
+          } | null;
+          setNewSession: (session: {
+            session: {
+              id: string;
+              createdAt: Date;
+              updatedAt: Date;
+              userId: string;
+              expiresAt: Date;
+              token: string;
+              ipAddress?: string | null | undefined;
+              userAgent?: string | null | undefined;
+            } & Record<string, any>;
+            user: {
+              id: string;
+              createdAt: Date;
+              updatedAt: Date;
+              email: string;
+              emailVerified: boolean;
+              name: string;
+              image?: string | null | undefined;
+            } & Record<string, any>;
+          } | null) => void;
+          socialProviders: better_auth0.OAuthProvider[];
+          authCookies: better_auth0.BetterAuthCookies;
+          logger: ReturnType<typeof better_auth0.createLogger>;
+          rateLimit: {
+            enabled: boolean;
+            window: number;
+            max: number;
+            storage: "memory" | "database" | "secondary-storage";
+          } & Omit<better_auth0.BetterAuthRateLimitOptions, "enabled" | "window" | "max" | "storage">;
+          adapter: better_auth0.DBAdapter<better_auth0.BetterAuthOptions>;
+          internalAdapter: better_auth0.InternalAdapter<better_auth0.BetterAuthOptions>;
+          createAuthCookie: (cookieName: string, overrideAttributes?: Partial<CookieOptions> | undefined) => better_auth0.BetterAuthCookie;
+          secret: string;
+          secretConfig: string | better_auth0.SecretConfig;
+          sessionConfig: {
+            updateAge: number;
+            expiresIn: number;
+            freshAge: number;
+            cookieRefreshCache: false | {
+              enabled: true;
+              updateAge: number;
+            };
+          };
+          generateId: (options: {
+            model: better_auth0.ModelNames;
+            size?: number | undefined;
+          }) => string | false;
+          secondaryStorage: better_auth0.SecondaryStorage | undefined;
+          password: {
+            hash: (password: string) => Promise<string>;
+            verify: (data: {
+              password: string;
+              hash: string;
+            }) => Promise<boolean>;
+            config: {
+              minPasswordLength: number;
+              maxPasswordLength: number;
+            };
+            checkPassword: (userId: string, ctx: better_auth0.GenericEndpointContext<better_auth0.BetterAuthOptions>) => Promise<boolean>;
+          };
+          tables: better_auth0.BetterAuthDBSchema;
+          runMigrations: () => Promise<void>;
+          publishTelemetry: (event: {
+            type: string;
+            anonymousId?: string | undefined;
+            payload: Record<string, any>;
+          }) => Promise<void>;
+          skipOriginCheck: boolean | string[];
+          skipCSRFCheck: boolean;
+          runInBackground: (promise: Promise<unknown>) => void;
+          runInBackgroundOrAwait: (promise: Promise<unknown> | void) => better_auth0.Awaitable<unknown>;
+        }>;
+      }>>;
+    }[];
+  };
+  endpoints: {
+    /**
+     * ### Endpoint
+     *
+     * POST `/api-key/create`
+     *
+     * ### API Methods
+     *
+     * **server:**
+     * `auth.api.createApiKey`
+     *
+     * **client:**
+     * `authClient.apiKey.create`
+     *
+     * @see [Read our docs to learn more.](https://better-auth.com/docs/plugins/api-key#api-method-api-key-create)
+     */
+    createApiKey: Endpoint<"/api-key/create", "POST", {
+      configId?: string | undefined;
+      name?: string | undefined;
+      expiresIn?: number | null | undefined;
+      prefix?: string | undefined;
+      remaining?: number | null | undefined;
+      metadata?: any;
+      refillAmount?: number | undefined;
+      refillInterval?: number | undefined;
+      rateLimitTimeWindow?: number | undefined;
+      rateLimitMax?: number | undefined;
+      rateLimitEnabled?: boolean | undefined;
+      permissions?: Record<string, string[]> | undefined;
+      userId?: unknown;
+      organizationId?: unknown;
+    }, Record<string, any> | undefined, [], {
+      key: string;
+      metadata: any;
+      permissions: any;
+      id: string;
+      configId: string;
+      name: string | null;
+      start: string | null;
+      prefix: string | null;
+      referenceId: string;
+      refillInterval: number | null;
+      refillAmount: number | null;
+      lastRefillAt: Date | null;
+      enabled: boolean;
+      rateLimitEnabled: boolean;
+      rateLimitTimeWindow: number | null;
+      rateLimitMax: number | null;
+      requestCount: number;
+      remaining: number | null;
+      lastRequest: Date | null;
+      expiresAt: Date | null;
+      createdAt: Date;
+      updatedAt: Date;
+    }, {
+      openapi: {
+        description: string;
+        responses: {
+          "200": {
+            description: string;
+            content: {
+              "application/json": {
+                schema: {
+                  type: "object";
+                  properties: {
+                    id: {
+                      type: string;
+                      description: string;
+                    };
+                    createdAt: {
+                      type: string;
+                      format: string;
+                      description: string;
+                    };
+                    updatedAt: {
+                      type: string;
+                      format: string;
+                      description: string;
+                    };
+                    name: {
+                      type: string;
+                      nullable: boolean;
+                      description: string;
+                    };
+                    prefix: {
+                      type: string;
+                      nullable: boolean;
+                      description: string;
+                    };
+                    start: {
+                      type: string;
+                      nullable: boolean;
+                      description: string;
+                    };
+                    key: {
+                      type: string;
+                      description: string;
+                    };
+                    enabled: {
+                      type: string;
+                      description: string;
+                    };
+                    expiresAt: {
+                      type: string;
+                      format: string;
+                      nullable: boolean;
+                      description: string;
+                    };
+                    referenceId: {
+                      type: string;
+                      description: string;
+                    };
+                    lastRefillAt: {
+                      type: string;
+                      format: string;
+                      nullable: boolean;
+                      description: string;
+                    };
+                    lastRequest: {
+                      type: string;
+                      format: string;
+                      nullable: boolean;
+                      description: string;
+                    };
+                    metadata: {
+                      type: string;
+                      nullable: boolean;
+                      additionalProperties: boolean;
+                      description: string;
+                    };
+                    rateLimitMax: {
+                      type: string;
+                      nullable: boolean;
+                      description: string;
+                    };
+                    rateLimitTimeWindow: {
+                      type: string;
+                      nullable: boolean;
+                      description: string;
+                    };
+                    remaining: {
+                      type: string;
+                      nullable: boolean;
+                      description: string;
+                    };
+                    refillAmount: {
+                      type: string;
+                      nullable: boolean;
+                      description: string;
+                    };
+                    refillInterval: {
+                      type: string;
+                      nullable: boolean;
+                      description: string;
+                    };
+                    rateLimitEnabled: {
+                      type: string;
+                      description: string;
+                    };
+                    requestCount: {
+                      type: string;
+                      description: string;
+                    };
+                    permissions: {
+                      type: string;
+                      nullable: boolean;
+                      additionalProperties: {
+                        type: string;
+                        items: {
+                          type: string;
+                        };
+                      };
+                      description: string;
+                    };
+                  };
+                  required: string[];
+                };
+              };
+            };
+          };
+        };
+      };
+    }, undefined>;
+    /**
+     * ### Endpoint
+     *
+     * POST `/api-key/verify`
+     *
+     * ### API Methods
+     *
+     * **server:**
+     * `auth.api.verifyApiKey`
+     *
+     * @see [Read our docs to learn more.](https://better-auth.com/docs/plugins/api-key#api-method-api-key-verify)
+     */
+    verifyApiKey: Endpoint<string, "POST", {
+      key: string;
+      configId?: string | undefined;
+      permissions?: Record<string, string[]> | undefined;
+    }, Record<string, any> | undefined, [], {
+      valid: boolean;
+      error: {
+        message: better_auth0.RawError<"INVALID_API_KEY">;
+        code: "KEY_NOT_FOUND";
+      };
+      key: null;
+    } | {
+      valid: boolean;
+      error: {
+        message: string | undefined;
+        code: string;
+        cause?: unknown;
+      };
+      key: null;
+    } | {
+      valid: boolean;
+      error: {
+        message: better_auth0.RawError<"INVALID_API_KEY">;
+        code: "INVALID_API_KEY";
+      };
+      key: null;
+    } | {
+      valid: boolean;
+      error: null;
+      key: Omit<ApiKey, "key"> | null;
+    }, undefined, undefined>;
+    /**
+     * ### Endpoint
+     *
+     * GET `/api-key/get`
+     *
+     * ### API Methods
+     *
+     * **server:**
+     * `auth.api.getApiKey`
+     *
+     * **client:**
+     * `authClient.apiKey.get`
+     *
+     * @see [Read our docs to learn more.](https://better-auth.com/docs/plugins/api-key#api-method-api-key-get)
+     */
+    getApiKey: Endpoint<"/api-key/get", "GET", undefined, {
+      id: string;
+      configId?: string | undefined;
+    }, [Middleware<(inputContext: Record<string, any>) => Promise<{
+      session: {
+        session: Record<string, any> & {
+          id: string;
+          createdAt: Date;
+          updatedAt: Date;
+          userId: string;
+          expiresAt: Date;
+          token: string;
+          ipAddress?: string | null | undefined;
+          userAgent?: string | null | undefined;
+        };
+        user: Record<string, any> & {
+          id: string;
+          createdAt: Date;
+          updatedAt: Date;
+          email: string;
+          emailVerified: boolean;
+          name: string;
+          image?: string | null | undefined;
+        };
+      };
+    }>>], {
+      metadata: Record<string, any> | null;
+      permissions: {
+        [key: string]: string[];
+      } | null;
+      id: string;
+      configId: string;
+      name: string | null;
+      start: string | null;
+      prefix: string | null;
+      referenceId: string;
+      refillInterval: number | null;
+      refillAmount: number | null;
+      lastRefillAt: Date | null;
+      enabled: boolean;
+      rateLimitEnabled: boolean;
+      rateLimitTimeWindow: number | null;
+      rateLimitMax: number | null;
+      requestCount: number;
+      remaining: number | null;
+      lastRequest: Date | null;
+      expiresAt: Date | null;
+      createdAt: Date;
+      updatedAt: Date;
+    }, {
+      openapi: {
+        description: string;
+        responses: {
+          "200": {
+            description: string;
+            content: {
+              "application/json": {
+                schema: {
+                  type: "object";
+                  properties: {
+                    id: {
+                      type: string;
+                      description: string;
+                    };
+                    name: {
+                      type: string;
+                      nullable: boolean;
+                      description: string;
+                    };
+                    start: {
+                      type: string;
+                      nullable: boolean;
+                      description: string;
+                    };
+                    prefix: {
+                      type: string;
+                      nullable: boolean;
+                      description: string;
+                    };
+                    userId: {
+                      type: string;
+                      description: string;
+                    };
+                    refillInterval: {
+                      type: string;
+                      nullable: boolean;
+                      description: string;
+                    };
+                    refillAmount: {
+                      type: string;
+                      nullable: boolean;
+                      description: string;
+                    };
+                    lastRefillAt: {
+                      type: string;
+                      format: string;
+                      nullable: boolean;
+                      description: string;
+                    };
+                    enabled: {
+                      type: string;
+                      description: string;
+                      default: boolean;
+                    };
+                    rateLimitEnabled: {
+                      type: string;
+                      description: string;
+                    };
+                    rateLimitTimeWindow: {
+                      type: string;
+                      nullable: boolean;
+                      description: string;
+                    };
+                    rateLimitMax: {
+                      type: string;
+                      nullable: boolean;
+                      description: string;
+                    };
+                    requestCount: {
+                      type: string;
+                      description: string;
+                    };
+                    remaining: {
+                      type: string;
+                      nullable: boolean;
+                      description: string;
+                    };
+                    lastRequest: {
+                      type: string;
+                      format: string;
+                      nullable: boolean;
+                      description: string;
+                    };
+                    expiresAt: {
+                      type: string;
+                      format: string;
+                      nullable: boolean;
+                      description: string;
+                    };
+                    createdAt: {
+                      type: string;
+                      format: string;
+                      description: string;
+                    };
+                    updatedAt: {
+                      type: string;
+                      format: string;
+                      description: string;
+                    };
+                    metadata: {
+                      type: string;
+                      nullable: boolean;
+                      additionalProperties: boolean;
+                      description: string;
+                    };
+                    permissions: {
+                      type: string;
+                      nullable: boolean;
+                      description: string;
+                    };
+                  };
+                  required: string[];
+                };
+              };
+            };
+          };
+        };
+      };
+    }, undefined>;
+    /**
+     * ### Endpoint
+     *
+     * POST `/api-key/update`
+     *
+     * ### API Methods
+     *
+     * **server:**
+     * `auth.api.updateApiKey`
+     *
+     * **client:**
+     * `authClient.apiKey.update`
+     *
+     * @see [Read our docs to learn more.](https://better-auth.com/docs/plugins/api-key#api-method-api-key-update)
+     */
+    updateApiKey: Endpoint<"/api-key/update", "POST", {
+      keyId: string;
+      configId?: string | undefined;
+      userId?: unknown;
+      name?: string | undefined;
+      enabled?: boolean | undefined;
+      remaining?: number | undefined;
+      refillAmount?: number | undefined;
+      refillInterval?: number | undefined;
+      metadata?: any;
+      expiresIn?: number | null | undefined;
+      rateLimitEnabled?: boolean | undefined;
+      rateLimitTimeWindow?: number | undefined;
+      rateLimitMax?: number | undefined;
+      permissions?: Record<string, string[]> | null | undefined;
+    }, Record<string, any> | undefined, [], {
+      metadata: Record<string, any> | null;
+      permissions: {
+        [key: string]: string[];
+      } | null;
+      id: string;
+      configId: string;
+      name: string | null;
+      start: string | null;
+      prefix: string | null;
+      referenceId: string;
+      refillInterval: number | null;
+      refillAmount: number | null;
+      lastRefillAt: Date | null;
+      enabled: boolean;
+      rateLimitEnabled: boolean;
+      rateLimitTimeWindow: number | null;
+      rateLimitMax: number | null;
+      requestCount: number;
+      remaining: number | null;
+      lastRequest: Date | null;
+      expiresAt: Date | null;
+      createdAt: Date;
+      updatedAt: Date;
+    }, {
+      openapi: {
+        description: string;
+        responses: {
+          "200": {
+            description: string;
+            content: {
+              "application/json": {
+                schema: {
+                  type: "object";
+                  properties: {
+                    id: {
+                      type: string;
+                      description: string;
+                    };
+                    name: {
+                      type: string;
+                      nullable: boolean;
+                      description: string;
+                    };
+                    start: {
+                      type: string;
+                      nullable: boolean;
+                      description: string;
+                    };
+                    prefix: {
+                      type: string;
+                      nullable: boolean;
+                      description: string;
+                    };
+                    userId: {
+                      type: string;
+                      description: string;
+                    };
+                    refillInterval: {
+                      type: string;
+                      nullable: boolean;
+                      description: string;
+                    };
+                    refillAmount: {
+                      type: string;
+                      nullable: boolean;
+                      description: string;
+                    };
+                    lastRefillAt: {
+                      type: string;
+                      format: string;
+                      nullable: boolean;
+                      description: string;
+                    };
+                    enabled: {
+                      type: string;
+                      description: string;
+                      default: boolean;
+                    };
+                    rateLimitEnabled: {
+                      type: string;
+                      description: string;
+                    };
+                    rateLimitTimeWindow: {
+                      type: string;
+                      nullable: boolean;
+                      description: string;
+                    };
+                    rateLimitMax: {
+                      type: string;
+                      nullable: boolean;
+                      description: string;
+                    };
+                    requestCount: {
+                      type: string;
+                      description: string;
+                    };
+                    remaining: {
+                      type: string;
+                      nullable: boolean;
+                      description: string;
+                    };
+                    lastRequest: {
+                      type: string;
+                      format: string;
+                      nullable: boolean;
+                      description: string;
+                    };
+                    expiresAt: {
+                      type: string;
+                      format: string;
+                      nullable: boolean;
+                      description: string;
+                    };
+                    createdAt: {
+                      type: string;
+                      format: string;
+                      description: string;
+                    };
+                    updatedAt: {
+                      type: string;
+                      format: string;
+                      description: string;
+                    };
+                    metadata: {
+                      type: string;
+                      nullable: boolean;
+                      additionalProperties: boolean;
+                      description: string;
+                    };
+                    permissions: {
+                      type: string;
+                      nullable: boolean;
+                      description: string;
+                    };
+                  };
+                  required: string[];
+                };
+              };
+            };
+          };
+        };
+      };
+    }, undefined>;
+    /**
+     * ### Endpoint
+     *
+     * POST `/api-key/delete`
+     *
+     * ### API Methods
+     *
+     * **server:**
+     * `auth.api.deleteApiKey`
+     *
+     * **client:**
+     * `authClient.apiKey.delete`
+     *
+     * @see [Read our docs to learn more.](https://better-auth.com/docs/plugins/api-key#api-method-api-key-delete)
+     */
+    deleteApiKey: Endpoint<"/api-key/delete", "POST", {
+      keyId: string;
+      configId?: string | undefined;
+    }, Record<string, any> | undefined, [Middleware<(inputContext: Record<string, any>) => Promise<{
+      session: {
+        session: Record<string, any> & {
+          id: string;
+          createdAt: Date;
+          updatedAt: Date;
+          userId: string;
+          expiresAt: Date;
+          token: string;
+          ipAddress?: string | null | undefined;
+          userAgent?: string | null | undefined;
+        };
+        user: Record<string, any> & {
+          id: string;
+          createdAt: Date;
+          updatedAt: Date;
+          email: string;
+          emailVerified: boolean;
+          name: string;
+          image?: string | null | undefined;
+        };
+      };
+    }>>], {
+      success: boolean;
+    }, {
+      openapi: {
+        description: string;
+        requestBody: {
+          content: {
+            "application/json": {
+              schema: {
+                type: "object";
+                properties: {
+                  keyId: {
+                    type: string;
+                    description: string;
+                  };
+                };
+                required: string[];
+              };
+            };
+          };
+        };
+        responses: {
+          "200": {
+            description: string;
+            content: {
+              "application/json": {
+                schema: {
+                  type: "object";
+                  properties: {
+                    success: {
+                      type: string;
+                      description: string;
+                    };
+                  };
+                  required: string[];
+                };
+              };
+            };
+          };
+        };
+      };
+    }, undefined>;
+    /**
+     * ### Endpoint
+     *
+     * GET `/api-key/list`
+     *
+     * ### API Methods
+     *
+     * **server:**
+     * `auth.api.listApiKeys`
+     *
+     * **client:**
+     * `authClient.apiKey.list`
+     *
+     * @see [Read our docs to learn more.](https://better-auth.com/docs/plugins/api-key#api-method-api-key-list)
+     */
+    listApiKeys: Endpoint<"/api-key/list", "GET", undefined, {
+      configId?: string | undefined;
+      organizationId?: string | undefined;
+      limit?: unknown;
+      offset?: unknown;
+      sortBy?: string | undefined;
+      sortDirection?: "asc" | "desc" | undefined;
+    } | undefined, [Middleware<(inputContext: Record<string, any>) => Promise<{
+      session: {
+        session: Record<string, any> & {
+          id: string;
+          createdAt: Date;
+          updatedAt: Date;
+          userId: string;
+          expiresAt: Date;
+          token: string;
+          ipAddress?: string | null | undefined;
+          userAgent?: string | null | undefined;
+        };
+        user: Record<string, any> & {
+          id: string;
+          createdAt: Date;
+          updatedAt: Date;
+          email: string;
+          emailVerified: boolean;
+          name: string;
+          image?: string | null | undefined;
+        };
+      };
+    }>>], {
+      apiKeys: {
+        metadata: Record<string, any> | null;
+        permissions: {
+          [key: string]: string[];
+        } | null;
+        id: string;
+        configId: string;
+        name: string | null;
+        start: string | null;
+        prefix: string | null;
+        referenceId: string;
+        refillInterval: number | null;
+        refillAmount: number | null;
+        lastRefillAt: Date | null;
+        enabled: boolean;
+        rateLimitEnabled: boolean;
+        rateLimitTimeWindow: number | null;
+        rateLimitMax: number | null;
+        requestCount: number;
+        remaining: number | null;
+        lastRequest: Date | null;
+        expiresAt: Date | null;
+        createdAt: Date;
+        updatedAt: Date;
+      }[];
+      total: number;
+      limit: number | undefined;
+      offset: number | undefined;
+    }, {
+      openapi: {
+        description: string;
+        responses: {
+          "200": {
+            description: string;
+            content: {
+              "application/json": {
+                schema: {
+                  type: "object";
+                  properties: {
+                    apiKeys: {
+                      type: string;
+                      items: {
+                        type: string;
+                        properties: {
+                          id: {
+                            type: string;
+                            description: string;
+                          };
+                          name: {
+                            type: string;
+                            nullable: boolean;
+                            description: string;
+                          };
+                          start: {
+                            type: string;
+                            nullable: boolean;
+                            description: string;
+                          };
+                          prefix: {
+                            type: string;
+                            nullable: boolean;
+                            description: string;
+                          };
+                          userId: {
+                            type: string;
+                            description: string;
+                          };
+                          refillInterval: {
+                            type: string;
+                            nullable: boolean;
+                            description: string;
+                          };
+                          refillAmount: {
+                            type: string;
+                            nullable: boolean;
+                            description: string;
+                          };
+                          lastRefillAt: {
+                            type: string;
+                            format: string;
+                            nullable: boolean;
+                            description: string;
+                          };
+                          enabled: {
+                            type: string;
+                            description: string;
+                            default: boolean;
+                          };
+                          rateLimitEnabled: {
+                            type: string;
+                            description: string;
+                          };
+                          rateLimitTimeWindow: {
+                            type: string;
+                            nullable: boolean;
+                            description: string;
+                          };
+                          rateLimitMax: {
+                            type: string;
+                            nullable: boolean;
+                            description: string;
+                          };
+                          requestCount: {
+                            type: string;
+                            description: string;
+                          };
+                          remaining: {
+                            type: string;
+                            nullable: boolean;
+                            description: string;
+                          };
+                          lastRequest: {
+                            type: string;
+                            format: string;
+                            nullable: boolean;
+                            description: string;
+                          };
+                          expiresAt: {
+                            type: string;
+                            format: string;
+                            nullable: boolean;
+                            description: string;
+                          };
+                          createdAt: {
+                            type: string;
+                            format: string;
+                            description: string;
+                          };
+                          updatedAt: {
+                            type: string;
+                            format: string;
+                            description: string;
+                          };
+                          metadata: {
+                            type: string;
+                            nullable: boolean;
+                            additionalProperties: boolean;
+                            description: string;
+                          };
+                          permissions: {
+                            type: string;
+                            nullable: boolean;
+                            description: string;
+                          };
+                        };
+                        required: string[];
+                      };
+                    };
+                    total: {
+                      type: string;
+                      description: string;
+                    };
+                    limit: {
+                      type: string;
+                      nullable: boolean;
+                      description: string;
+                    };
+                    offset: {
+                      type: string;
+                      nullable: boolean;
+                      description: string;
+                    };
+                  };
+                  required: string[];
+                };
+              };
+            };
+          };
+        };
+      };
+    }, undefined>;
+    /**
+     * ### Endpoint
+     *
+     * POST `/api-key/delete-all-expired-api-keys`
+     *
+     * ### API Methods
+     *
+     * **server:**
+     * `auth.api.deleteAllExpiredApiKeys`
+     *
+     * @see [Read our docs to learn more.](https://better-auth.com/docs/plugins/api-key#api-method-api-key-delete-all-expired-api-keys)
+     */
+    deleteAllExpiredApiKeys: Endpoint<string, "POST", undefined, Record<string, any> | undefined, [], {
+      success: boolean;
+      error: unknown;
+    }, undefined, undefined>;
+  };
+  schema: {
+    apikey: {
+      fields: {
+        configId: {
+          type: "string";
+          required: true;
+          defaultValue: string;
+          input: false;
+          index: true;
+        };
+        name: {
+          type: "string";
+          required: false;
+          input: false;
+        };
+        start: {
+          type: "string";
+          required: false;
+          input: false;
+        };
+        referenceId: {
+          type: "string";
+          required: true;
+          input: false;
+          index: true;
+        };
+        prefix: {
+          type: "string";
+          required: false;
+          input: false;
+        };
+        key: {
+          type: "string";
+          required: true;
+          input: false;
+          index: true;
+        };
+        refillInterval: {
+          type: "number";
+          required: false;
+          input: false;
+        };
+        refillAmount: {
+          type: "number";
+          required: false;
+          input: false;
+        };
+        lastRefillAt: {
+          type: "date";
+          required: false;
+          input: false;
+        };
+        enabled: {
+          type: "boolean";
+          required: false;
+          input: false;
+          defaultValue: true;
+        };
+        rateLimitEnabled: {
+          type: "boolean";
+          required: false;
+          input: false;
+          defaultValue: true;
+        };
+        rateLimitTimeWindow: {
+          type: "number";
+          required: false;
+          input: false;
+          defaultValue: number;
+        };
+        rateLimitMax: {
+          type: "number";
+          required: false;
+          input: false;
+          defaultValue: number;
+        };
+        requestCount: {
+          type: "number";
+          required: false;
+          input: false;
+          defaultValue: number;
+        };
+        remaining: {
+          type: "number";
+          required: false;
+          input: false;
+        };
+        lastRequest: {
+          type: "date";
+          required: false;
+          input: false;
+        };
+        expiresAt: {
+          type: "date";
+          required: false;
+          input: false;
+        };
+        createdAt: {
+          type: "date";
+          required: true;
+          input: false;
+        };
+        updatedAt: {
+          type: "date";
+          required: true;
+          input: false;
+        };
+        permissions: {
+          type: "string";
+          required: false;
+          input: false;
+        };
+        metadata: {
+          type: "string";
+          required: false;
+          input: true;
+          transform: {
+            input(value: better_auth0.DBPrimitive): string;
+            output(value: better_auth0.DBPrimitive): any;
+          };
+        };
+      };
+    };
+  };
+};
+//#endregion
+export { API_KEY_ERROR_CODES as i, apiKey as n, defaultKeyHasher as r, API_KEY_TABLE_NAME as t };