@neondatabase/auth 0.1.0-beta.1

package/dist/adapter-core-C12KoaiU.d.mts

@@ -0,0 +1,2247 @@
+import { createAuthClient } from "better-auth/react";
+import * as better_auth_client11 from "better-auth/client";
+import { AuthClient, BetterAuthClientOptions } from "better-auth/client";
+import * as better_auth_client_plugins7 from "better-auth/client/plugins";
+import * as jose0 from "jose";
+import * as better_auth220 from "better-auth";
+import * as _better_fetch_fetch138 from "@better-fetch/fetch";
+import * as nanostores1 from "nanostores";
+import * as better_call0 from "better-call";
+import * as zod0 from "zod";
+
+//#region src/core/adapter-core.d.ts
+interface NeonAuthAdapterCoreAuthOptions extends Omit<BetterAuthClientOptions, 'plugins'> {}
+declare const supportedBetterAuthClientPlugins: ({
+  id: "better-auth-client";
+  $InferServerPlugin: ReturnType<(options?: better_auth_client_plugins7.JwtOptions | undefined) => {
+    id: "jwt";
+    options: better_auth_client_plugins7.JwtOptions | undefined;
+    endpoints: {
+      getJwks: better_call0.StrictEndpoint<string, {
+        method: "GET";
+        metadata: {
+          openapi: {
+            operationId: string;
+            description: string;
+            responses: {
+              "200": {
+                description: string;
+                content: {
+                  "application/json": {
+                    schema: {
+                      type: "object";
+                      properties: {
+                        keys: {
+                          type: string;
+                          description: string;
+                          items: {
+                            type: string;
+                            properties: {
+                              kid: {
+                                type: string;
+                                description: string;
+                              };
+                              kty: {
+                                type: string;
+                                description: string;
+                              };
+                              alg: {
+                                type: string;
+                                description: string;
+                              };
+                              use: {
+                                type: string;
+                                description: string;
+                                enum: string[];
+                                nullable: boolean;
+                              };
+                              n: {
+                                type: string;
+                                description: string;
+                                nullable: boolean;
+                              };
+                              e: {
+                                type: string;
+                                description: string;
+                                nullable: boolean;
+                              };
+                              crv: {
+                                type: string;
+                                description: string;
+                                nullable: boolean;
+                              };
+                              x: {
+                                type: string;
+                                description: string;
+                                nullable: boolean;
+                              };
+                              y: {
+                                type: string;
+                                description: string;
+                                nullable: boolean;
+                              };
+                            };
+                            required: string[];
+                          };
+                        };
+                      };
+                      required: string[];
+                    };
+                  };
+                };
+              };
+            };
+          };
+        };
+      } & {
+        use: any[];
+      }, jose0.JSONWebKeySet>;
+      getToken: better_call0.StrictEndpoint<"/token", {
+        method: "GET";
+        requireHeaders: true;
+        use: ((inputContext: better_call0.MiddlewareInputContext<better_call0.MiddlewareOptions>) => 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: {
+          openapi: {
+            operationId: string;
+            description: string;
+            responses: {
+              200: {
+                description: string;
+                content: {
+                  "application/json": {
+                    schema: {
+                      type: "object";
+                      properties: {
+                        token: {
+                          type: string;
+                        };
+                      };
+                    };
+                  };
+                };
+              };
+            };
+          };
+        };
+      } & {
+        use: any[];
+      }, {
+        token: string;
+      }>;
+      signJWT: better_call0.StrictEndpoint<"/sign-jwt", {
+        method: "POST";
+        metadata: {
+          SERVER_ONLY: true;
+          $Infer: {
+            body: {
+              payload: jose0.JWTPayload;
+              overrideOptions?: better_auth_client_plugins7.JwtOptions | undefined;
+            };
+          };
+        };
+        body: zod0.ZodObject<{
+          payload: zod0.ZodRecord<zod0.ZodString, zod0.ZodAny>;
+          overrideOptions: zod0.ZodOptional<zod0.ZodRecord<zod0.ZodString, zod0.ZodAny>>;
+        }, better_auth220.$strip>;
+      } & {
+        use: any[];
+      }, {
+        token: string;
+      }>;
+      verifyJWT: better_call0.StrictEndpoint<"/verify-jwt", {
+        method: "POST";
+        metadata: {
+          SERVER_ONLY: true;
+          $Infer: {
+            body: {
+              token: string;
+              issuer?: string;
+            };
+            response: {
+              payload: {
+                sub: string;
+                aud: string;
+                [key: string]: any;
+              } | null;
+            };
+          };
+        };
+        body: zod0.ZodObject<{
+          token: zod0.ZodString;
+          issuer: zod0.ZodOptional<zod0.ZodString>;
+        }, better_auth220.$strip>;
+      } & {
+        use: any[];
+      }, {
+        payload: (jose0.JWTPayload & Required<Pick<jose0.JWTPayload, "sub" | "aud">>) | null;
+      }>;
+    };
+    hooks: {
+      after: {
+        matcher(context: better_auth220.HookEndpointContext): boolean;
+        handler: (inputContext: better_call0.MiddlewareInputContext<better_call0.MiddlewareOptions>) => Promise<void>;
+      }[];
+    };
+    schema: {
+      jwks: {
+        fields: {
+          publicKey: {
+            type: "string";
+            required: true;
+          };
+          privateKey: {
+            type: "string";
+            required: true;
+          };
+          createdAt: {
+            type: "date";
+            required: true;
+          };
+          expiresAt: {
+            type: "date";
+            required: false;
+          };
+        };
+      };
+    };
+  }>;
+  pathMethods: {
+    [x: string]: "GET";
+  };
+  getActions: ($fetch: _better_fetch_fetch138.BetterFetch) => {
+    jwks: (fetchOptions?: any) => Promise<{
+      data: null;
+      error: {
+        message?: string | undefined;
+        status: number;
+        statusText: string;
+      };
+    } | {
+      data: jose0.JSONWebKeySet;
+      error: null;
+    }>;
+  };
+} | {
+  id: "admin-client";
+  $InferServerPlugin: {
+    id: "admin";
+    init(): {
+      options: {
+        databaseHooks: {
+          user: {
+            create: {
+              before(user: {
+                id: string;
+                createdAt: Date;
+                updatedAt: Date;
+                email: string;
+                emailVerified: boolean;
+                name: string;
+                image?: string | null | undefined;
+              } & Record<string, unknown>): Promise<{
+                data: {
+                  id: string;
+                  createdAt: Date;
+                  updatedAt: Date;
+                  email: string;
+                  emailVerified: boolean;
+                  name: string;
+                  image?: string | null | undefined;
+                  role: string;
+                };
+              }>;
+            };
+          };
+          session: {
+            create: {
+              before(session: {
+                id: string;
+                createdAt: Date;
+                updatedAt: Date;
+                userId: string;
+                expiresAt: Date;
+                token: string;
+                ipAddress?: string | null | undefined;
+                userAgent?: string | null | undefined;
+              } & Record<string, unknown>, ctx: better_auth220.GenericEndpointContext | undefined): Promise<void>;
+            };
+          };
+        };
+      };
+    };
+    hooks: {
+      after: {
+        matcher(context: better_auth220.HookEndpointContext): boolean;
+        handler: (inputContext: better_call0.MiddlewareInputContext<better_call0.MiddlewareOptions>) => Promise<better_auth_client_plugins7.SessionWithImpersonatedBy[] | undefined>;
+      }[];
+    };
+    endpoints: {
+      setRole: better_call0.StrictEndpoint<"/admin/set-role", {
+        method: "POST";
+        body: zod0.ZodObject<{
+          userId: zod0.ZodCoercedString<unknown>;
+          role: zod0.ZodUnion<readonly [zod0.ZodString, zod0.ZodArray<zod0.ZodString>]>;
+        }, better_auth220.$strip>;
+        requireHeaders: true;
+        use: ((inputContext: better_call0.MiddlewareInputContext<better_call0.MiddlewareOptions>) => Promise<{
+          session: {
+            user: better_auth_client_plugins7.UserWithRole;
+            session: better_auth220.Session;
+          };
+        }>)[];
+        metadata: {
+          openapi: {
+            operationId: string;
+            summary: string;
+            description: string;
+            responses: {
+              200: {
+                description: string;
+                content: {
+                  "application/json": {
+                    schema: {
+                      type: "object";
+                      properties: {
+                        user: {
+                          $ref: string;
+                        };
+                      };
+                    };
+                  };
+                };
+              };
+            };
+          };
+          $Infer: {
+            body: {
+              userId: string;
+              role: "user" | "admin" | ("user" | "admin")[];
+            };
+          };
+        };
+      } & {
+        use: any[];
+      }, {
+        user: better_auth_client_plugins7.UserWithRole;
+      }>;
+      getUser: better_call0.StrictEndpoint<"/admin/get-user", {
+        method: "GET";
+        query: zod0.ZodObject<{
+          id: zod0.ZodString;
+        }, better_auth220.$strip>;
+        use: ((inputContext: better_call0.MiddlewareInputContext<better_call0.MiddlewareOptions>) => Promise<{
+          session: {
+            user: better_auth_client_plugins7.UserWithRole;
+            session: better_auth220.Session;
+          };
+        }>)[];
+        metadata: {
+          openapi: {
+            operationId: string;
+            summary: string;
+            description: string;
+            responses: {
+              200: {
+                description: string;
+                content: {
+                  "application/json": {
+                    schema: {
+                      type: "object";
+                      properties: {
+                        user: {
+                          $ref: string;
+                        };
+                      };
+                    };
+                  };
+                };
+              };
+            };
+          };
+        };
+      } & {
+        use: any[];
+      }, {
+        id: string;
+        createdAt: Date;
+        updatedAt: Date;
+        email: string;
+        emailVerified: boolean;
+        name: string;
+        image?: string | null | undefined;
+      }>;
+      createUser: better_call0.StrictEndpoint<"/admin/create-user", {
+        method: "POST";
+        body: zod0.ZodObject<{
+          email: zod0.ZodString;
+          password: zod0.ZodString;
+          name: zod0.ZodString;
+          role: zod0.ZodOptional<zod0.ZodUnion<readonly [zod0.ZodString, zod0.ZodArray<zod0.ZodString>]>>;
+          data: zod0.ZodOptional<zod0.ZodRecord<zod0.ZodString, zod0.ZodAny>>;
+        }, better_auth220.$strip>;
+        metadata: {
+          openapi: {
+            operationId: string;
+            summary: string;
+            description: string;
+            responses: {
+              200: {
+                description: string;
+                content: {
+                  "application/json": {
+                    schema: {
+                      type: "object";
+                      properties: {
+                        user: {
+                          $ref: string;
+                        };
+                      };
+                    };
+                  };
+                };
+              };
+            };
+          };
+          $Infer: {
+            body: {
+              email: string;
+              password: string;
+              name: string;
+              role?: "user" | "admin" | ("user" | "admin")[] | undefined;
+              data?: Record<string, any> | undefined;
+            };
+          };
+        };
+      } & {
+        use: any[];
+      }, {
+        user: better_auth_client_plugins7.UserWithRole;
+      }>;
+      adminUpdateUser: better_call0.StrictEndpoint<"/admin/update-user", {
+        method: "POST";
+        body: zod0.ZodObject<{
+          userId: zod0.ZodCoercedString<unknown>;
+          data: zod0.ZodRecord<zod0.ZodAny, zod0.ZodAny>;
+        }, better_auth220.$strip>;
+        use: ((inputContext: better_call0.MiddlewareInputContext<better_call0.MiddlewareOptions>) => Promise<{
+          session: {
+            user: better_auth_client_plugins7.UserWithRole;
+            session: better_auth220.Session;
+          };
+        }>)[];
+        metadata: {
+          openapi: {
+            operationId: string;
+            summary: string;
+            description: string;
+            responses: {
+              200: {
+                description: string;
+                content: {
+                  "application/json": {
+                    schema: {
+                      type: "object";
+                      properties: {
+                        user: {
+                          $ref: string;
+                        };
+                      };
+                    };
+                  };
+                };
+              };
+            };
+          };
+        };
+      } & {
+        use: any[];
+      }, better_auth_client_plugins7.UserWithRole>;
+      listUsers: better_call0.StrictEndpoint<"/admin/list-users", {
+        method: "GET";
+        use: ((inputContext: better_call0.MiddlewareInputContext<better_call0.MiddlewareOptions>) => Promise<{
+          session: {
+            user: better_auth_client_plugins7.UserWithRole;
+            session: better_auth220.Session;
+          };
+        }>)[];
+        query: zod0.ZodObject<{
+          searchValue: zod0.ZodOptional<zod0.ZodString>;
+          searchField: zod0.ZodOptional<zod0.ZodEnum<{
+            name: "name";
+            email: "email";
+          }>>;
+          searchOperator: zod0.ZodOptional<zod0.ZodEnum<{
+            contains: "contains";
+            starts_with: "starts_with";
+            ends_with: "ends_with";
+          }>>;
+          limit: zod0.ZodOptional<zod0.ZodUnion<[zod0.ZodString, zod0.ZodNumber]>>;
+          offset: zod0.ZodOptional<zod0.ZodUnion<[zod0.ZodString, zod0.ZodNumber]>>;
+          sortBy: zod0.ZodOptional<zod0.ZodString>;
+          sortDirection: zod0.ZodOptional<zod0.ZodEnum<{
+            asc: "asc";
+            desc: "desc";
+          }>>;
+          filterField: zod0.ZodOptional<zod0.ZodString>;
+          filterValue: zod0.ZodOptional<zod0.ZodUnion<[zod0.ZodUnion<[zod0.ZodString, zod0.ZodNumber]>, zod0.ZodBoolean]>>;
+          filterOperator: zod0.ZodOptional<zod0.ZodEnum<{
+            eq: "eq";
+            ne: "ne";
+            lt: "lt";
+            lte: "lte";
+            gt: "gt";
+            gte: "gte";
+            contains: "contains";
+          }>>;
+        }, better_auth220.$strip>;
+        metadata: {
+          openapi: {
+            operationId: string;
+            summary: string;
+            description: string;
+            responses: {
+              200: {
+                description: string;
+                content: {
+                  "application/json": {
+                    schema: {
+                      type: "object";
+                      properties: {
+                        users: {
+                          type: string;
+                          items: {
+                            $ref: string;
+                          };
+                        };
+                        total: {
+                          type: string;
+                        };
+                        limit: {
+                          type: string;
+                        };
+                        offset: {
+                          type: string;
+                        };
+                      };
+                      required: string[];
+                    };
+                  };
+                };
+              };
+            };
+          };
+        };
+      } & {
+        use: any[];
+      }, {
+        users: better_auth_client_plugins7.UserWithRole[];
+        total: number;
+        limit: number | undefined;
+        offset: number | undefined;
+      } | {
+        users: never[];
+        total: number;
+      }>;
+      listUserSessions: better_call0.StrictEndpoint<"/admin/list-user-sessions", {
+        method: "POST";
+        use: ((inputContext: better_call0.MiddlewareInputContext<better_call0.MiddlewareOptions>) => Promise<{
+          session: {
+            user: better_auth_client_plugins7.UserWithRole;
+            session: better_auth220.Session;
+          };
+        }>)[];
+        body: zod0.ZodObject<{
+          userId: zod0.ZodCoercedString<unknown>;
+        }, better_auth220.$strip>;
+        metadata: {
+          openapi: {
+            operationId: string;
+            summary: string;
+            description: string;
+            responses: {
+              200: {
+                description: string;
+                content: {
+                  "application/json": {
+                    schema: {
+                      type: "object";
+                      properties: {
+                        sessions: {
+                          type: string;
+                          items: {
+                            $ref: string;
+                          };
+                        };
+                      };
+                    };
+                  };
+                };
+              };
+            };
+          };
+        };
+      } & {
+        use: any[];
+      }, {
+        sessions: better_auth_client_plugins7.SessionWithImpersonatedBy[];
+      }>;
+      unbanUser: better_call0.StrictEndpoint<"/admin/unban-user", {
+        method: "POST";
+        body: zod0.ZodObject<{
+          userId: zod0.ZodCoercedString<unknown>;
+        }, better_auth220.$strip>;
+        use: ((inputContext: better_call0.MiddlewareInputContext<better_call0.MiddlewareOptions>) => Promise<{
+          session: {
+            user: better_auth_client_plugins7.UserWithRole;
+            session: better_auth220.Session;
+          };
+        }>)[];
+        metadata: {
+          openapi: {
+            operationId: string;
+            summary: string;
+            description: string;
+            responses: {
+              200: {
+                description: string;
+                content: {
+                  "application/json": {
+                    schema: {
+                      type: "object";
+                      properties: {
+                        user: {
+                          $ref: string;
+                        };
+                      };
+                    };
+                  };
+                };
+              };
+            };
+          };
+        };
+      } & {
+        use: any[];
+      }, {
+        user: {
+          id: string;
+          createdAt: Date;
+          updatedAt: Date;
+          email: string;
+          emailVerified: boolean;
+          name: string;
+          image?: string | null | undefined;
+        } & Record<string, any>;
+      }>;
+      banUser: better_call0.StrictEndpoint<"/admin/ban-user", {
+        method: "POST";
+        body: zod0.ZodObject<{
+          userId: zod0.ZodCoercedString<unknown>;
+          banReason: zod0.ZodOptional<zod0.ZodString>;
+          banExpiresIn: zod0.ZodOptional<zod0.ZodNumber>;
+        }, better_auth220.$strip>;
+        use: ((inputContext: better_call0.MiddlewareInputContext<better_call0.MiddlewareOptions>) => Promise<{
+          session: {
+            user: better_auth_client_plugins7.UserWithRole;
+            session: better_auth220.Session;
+          };
+        }>)[];
+        metadata: {
+          openapi: {
+            operationId: string;
+            summary: string;
+            description: string;
+            responses: {
+              200: {
+                description: string;
+                content: {
+                  "application/json": {
+                    schema: {
+                      type: "object";
+                      properties: {
+                        user: {
+                          $ref: string;
+                        };
+                      };
+                    };
+                  };
+                };
+              };
+            };
+          };
+        };
+      } & {
+        use: any[];
+      }, {
+        user: {
+          id: string;
+          createdAt: Date;
+          updatedAt: Date;
+          email: string;
+          emailVerified: boolean;
+          name: string;
+          image?: string | null | undefined;
+        } & Record<string, any>;
+      }>;
+      impersonateUser: better_call0.StrictEndpoint<"/admin/impersonate-user", {
+        method: "POST";
+        body: zod0.ZodObject<{
+          userId: zod0.ZodCoercedString<unknown>;
+        }, better_auth220.$strip>;
+        use: ((inputContext: better_call0.MiddlewareInputContext<better_call0.MiddlewareOptions>) => Promise<{
+          session: {
+            user: better_auth_client_plugins7.UserWithRole;
+            session: better_auth220.Session;
+          };
+        }>)[];
+        metadata: {
+          openapi: {
+            operationId: string;
+            summary: string;
+            description: string;
+            responses: {
+              200: {
+                description: string;
+                content: {
+                  "application/json": {
+                    schema: {
+                      type: "object";
+                      properties: {
+                        session: {
+                          $ref: string;
+                        };
+                        user: {
+                          $ref: string;
+                        };
+                      };
+                    };
+                  };
+                };
+              };
+            };
+          };
+        };
+      } & {
+        use: any[];
+      }, {
+        session: {
+          id: string;
+          createdAt: Date;
+          updatedAt: Date;
+          userId: string;
+          expiresAt: Date;
+          token: string;
+          ipAddress?: string | null | undefined;
+          userAgent?: string | null | undefined;
+        };
+        user: {
+          id: string;
+          createdAt: Date;
+          updatedAt: Date;
+          email: string;
+          emailVerified: boolean;
+          name: string;
+          image?: string | null | undefined;
+        };
+      }>;
+      stopImpersonating: better_call0.StrictEndpoint<"/admin/stop-impersonating", {
+        method: "POST";
+        requireHeaders: true;
+      } & {
+        use: any[];
+      }, {
+        session: better_auth220.Session & Record<string, any>;
+        user: better_auth220.User & Record<string, any>;
+      }>;
+      revokeUserSession: better_call0.StrictEndpoint<"/admin/revoke-user-session", {
+        method: "POST";
+        body: zod0.ZodObject<{
+          sessionToken: zod0.ZodString;
+        }, better_auth220.$strip>;
+        use: ((inputContext: better_call0.MiddlewareInputContext<better_call0.MiddlewareOptions>) => Promise<{
+          session: {
+            user: better_auth_client_plugins7.UserWithRole;
+            session: better_auth220.Session;
+          };
+        }>)[];
+        metadata: {
+          openapi: {
+            operationId: string;
+            summary: string;
+            description: string;
+            responses: {
+              200: {
+                description: string;
+                content: {
+                  "application/json": {
+                    schema: {
+                      type: "object";
+                      properties: {
+                        success: {
+                          type: string;
+                        };
+                      };
+                    };
+                  };
+                };
+              };
+            };
+          };
+        };
+      } & {
+        use: any[];
+      }, {
+        success: boolean;
+      }>;
+      revokeUserSessions: better_call0.StrictEndpoint<"/admin/revoke-user-sessions", {
+        method: "POST";
+        body: zod0.ZodObject<{
+          userId: zod0.ZodCoercedString<unknown>;
+        }, better_auth220.$strip>;
+        use: ((inputContext: better_call0.MiddlewareInputContext<better_call0.MiddlewareOptions>) => Promise<{
+          session: {
+            user: better_auth_client_plugins7.UserWithRole;
+            session: better_auth220.Session;
+          };
+        }>)[];
+        metadata: {
+          openapi: {
+            operationId: string;
+            summary: string;
+            description: string;
+            responses: {
+              200: {
+                description: string;
+                content: {
+                  "application/json": {
+                    schema: {
+                      type: "object";
+                      properties: {
+                        success: {
+                          type: string;
+                        };
+                      };
+                    };
+                  };
+                };
+              };
+            };
+          };
+        };
+      } & {
+        use: any[];
+      }, {
+        success: boolean;
+      }>;
+      removeUser: better_call0.StrictEndpoint<"/admin/remove-user", {
+        method: "POST";
+        body: zod0.ZodObject<{
+          userId: zod0.ZodCoercedString<unknown>;
+        }, better_auth220.$strip>;
+        use: ((inputContext: better_call0.MiddlewareInputContext<better_call0.MiddlewareOptions>) => Promise<{
+          session: {
+            user: better_auth_client_plugins7.UserWithRole;
+            session: better_auth220.Session;
+          };
+        }>)[];
+        metadata: {
+          openapi: {
+            operationId: string;
+            summary: string;
+            description: string;
+            responses: {
+              200: {
+                description: string;
+                content: {
+                  "application/json": {
+                    schema: {
+                      type: "object";
+                      properties: {
+                        success: {
+                          type: string;
+                        };
+                      };
+                    };
+                  };
+                };
+              };
+            };
+          };
+        };
+      } & {
+        use: any[];
+      }, {
+        success: boolean;
+      }>;
+      setUserPassword: better_call0.StrictEndpoint<"/admin/set-user-password", {
+        method: "POST";
+        body: zod0.ZodObject<{
+          newPassword: zod0.ZodString;
+          userId: zod0.ZodCoercedString<unknown>;
+        }, better_auth220.$strip>;
+        use: ((inputContext: better_call0.MiddlewareInputContext<better_call0.MiddlewareOptions>) => Promise<{
+          session: {
+            user: better_auth_client_plugins7.UserWithRole;
+            session: better_auth220.Session;
+          };
+        }>)[];
+        metadata: {
+          openapi: {
+            operationId: string;
+            summary: string;
+            description: string;
+            responses: {
+              200: {
+                description: string;
+                content: {
+                  "application/json": {
+                    schema: {
+                      type: "object";
+                      properties: {
+                        status: {
+                          type: string;
+                        };
+                      };
+                    };
+                  };
+                };
+              };
+            };
+          };
+        };
+      } & {
+        use: any[];
+      }, {
+        status: boolean;
+      }>;
+      userHasPermission: better_call0.StrictEndpoint<"/admin/has-permission", {
+        method: "POST";
+        body: zod0.ZodIntersection<zod0.ZodObject<{
+          userId: zod0.ZodOptional<zod0.ZodCoercedString<unknown>>;
+          role: zod0.ZodOptional<zod0.ZodString>;
+        }, better_auth220.$strip>, zod0.ZodUnion<readonly [zod0.ZodObject<{
+          permission: zod0.ZodRecord<zod0.ZodString, zod0.ZodArray<zod0.ZodString>>;
+          permissions: zod0.ZodUndefined;
+        }, better_auth220.$strip>, zod0.ZodObject<{
+          permission: zod0.ZodUndefined;
+          permissions: zod0.ZodRecord<zod0.ZodString, zod0.ZodArray<zod0.ZodString>>;
+        }, better_auth220.$strip>]>>;
+        metadata: {
+          openapi: {
+            description: string;
+            requestBody: {
+              content: {
+                "application/json": {
+                  schema: {
+                    type: "object";
+                    properties: {
+                      permission: {
+                        type: string;
+                        description: string;
+                        deprecated: boolean;
+                      };
+                      permissions: {
+                        type: string;
+                        description: string;
+                      };
+                    };
+                    required: string[];
+                  };
+                };
+              };
+            };
+            responses: {
+              "200": {
+                description: string;
+                content: {
+                  "application/json": {
+                    schema: {
+                      type: "object";
+                      properties: {
+                        error: {
+                          type: string;
+                        };
+                        success: {
+                          type: string;
+                        };
+                      };
+                      required: string[];
+                    };
+                  };
+                };
+              };
+            };
+          };
+          $Infer: {
+            body: ({
+              permission: {
+                readonly user?: ("create" | "list" | "set-role" | "ban" | "impersonate" | "delete" | "set-password" | "get" | "update")[] | undefined;
+                readonly session?: ("list" | "delete" | "revoke")[] | undefined;
+              };
+              permissions?: never | undefined;
+            } | {
+              permissions: {
+                readonly user?: ("create" | "list" | "set-role" | "ban" | "impersonate" | "delete" | "set-password" | "get" | "update")[] | undefined;
+                readonly session?: ("list" | "delete" | "revoke")[] | undefined;
+              };
+              permission?: never | undefined;
+            }) & {
+              userId?: string | undefined;
+              role?: "user" | "admin" | undefined;
+            };
+          };
+        };
+      } & {
+        use: any[];
+      }, {
+        error: null;
+        success: boolean;
+      }>;
+    };
+    $ERROR_CODES: {
+      readonly FAILED_TO_CREATE_USER: "Failed to create user";
+      readonly USER_ALREADY_EXISTS: "User already exists.";
+      readonly USER_ALREADY_EXISTS_USE_ANOTHER_EMAIL: "User already exists. Use another email.";
+      readonly YOU_CANNOT_BAN_YOURSELF: "You cannot ban yourself";
+      readonly YOU_ARE_NOT_ALLOWED_TO_CHANGE_USERS_ROLE: "You are not allowed to change users role";
+      readonly YOU_ARE_NOT_ALLOWED_TO_CREATE_USERS: "You are not allowed to create users";
+      readonly YOU_ARE_NOT_ALLOWED_TO_LIST_USERS: "You are not allowed to list users";
+      readonly YOU_ARE_NOT_ALLOWED_TO_LIST_USERS_SESSIONS: "You are not allowed to list users sessions";
+      readonly YOU_ARE_NOT_ALLOWED_TO_BAN_USERS: "You are not allowed to ban users";
+      readonly YOU_ARE_NOT_ALLOWED_TO_IMPERSONATE_USERS: "You are not allowed to impersonate users";
+      readonly YOU_ARE_NOT_ALLOWED_TO_REVOKE_USERS_SESSIONS: "You are not allowed to revoke users sessions";
+      readonly YOU_ARE_NOT_ALLOWED_TO_DELETE_USERS: "You are not allowed to delete users";
+      readonly YOU_ARE_NOT_ALLOWED_TO_SET_USERS_PASSWORD: "You are not allowed to set users password";
+      readonly BANNED_USER: "You have been banned from this application";
+      readonly YOU_ARE_NOT_ALLOWED_TO_GET_USER: "You are not allowed to get user";
+      readonly NO_DATA_TO_UPDATE: "No data to update";
+      readonly YOU_ARE_NOT_ALLOWED_TO_UPDATE_USERS: "You are not allowed to update users";
+      readonly YOU_CANNOT_REMOVE_YOURSELF: "You cannot remove yourself";
+      readonly YOU_ARE_NOT_ALLOWED_TO_SET_NON_EXISTENT_VALUE: "You are not allowed to set a non-existent role value";
+    };
+    schema: {
+      user: {
+        fields: {
+          role: {
+            type: "string";
+            required: false;
+            input: false;
+          };
+          banned: {
+            type: "boolean";
+            defaultValue: false;
+            required: false;
+            input: false;
+          };
+          banReason: {
+            type: "string";
+            required: false;
+            input: false;
+          };
+          banExpires: {
+            type: "date";
+            required: false;
+            input: false;
+          };
+        };
+      };
+      session: {
+        fields: {
+          impersonatedBy: {
+            type: "string";
+            required: false;
+          };
+        };
+      };
+    };
+    options: any;
+  };
+  getActions: () => {
+    admin: {
+      checkRolePermission: <R extends "user" | "admin">(data: ({
+        permission: {
+          readonly user?: ("create" | "list" | "set-role" | "ban" | "impersonate" | "delete" | "set-password" | "get" | "update")[] | undefined;
+          readonly session?: ("list" | "delete" | "revoke")[] | undefined;
+        };
+        permissions?: never | undefined;
+      } | {
+        permissions: {
+          readonly user?: ("create" | "list" | "set-role" | "ban" | "impersonate" | "delete" | "set-password" | "get" | "update")[] | undefined;
+          readonly session?: ("list" | "delete" | "revoke")[] | undefined;
+        };
+        permission?: never | undefined;
+      }) & {
+        role: R;
+      }) => boolean;
+    };
+  };
+  pathMethods: {
+    "/admin/list-users": "GET";
+    "/admin/stop-impersonating": "POST";
+  };
+} | {
+  id: "organization";
+  $InferServerPlugin: better_auth_client11.OrganizationPlugin<{
+    ac: better_auth_client11.AccessControl<{
+      readonly organization: readonly ["update", "delete"];
+      readonly member: readonly ["create", "update", "delete"];
+      readonly invitation: readonly ["create", "cancel"];
+      readonly team: readonly ["create", "update", "delete"];
+      readonly ac: readonly ["create", "read", "update", "delete"];
+    }>;
+    roles: {
+      admin: better_auth_client11.Role;
+      member: better_auth_client11.Role;
+      owner: better_auth_client11.Role;
+    };
+    teams: {
+      enabled: false;
+    };
+    schema: {
+      organization?: {
+        additionalFields?: {
+          [key: string]: better_auth220.DBFieldAttribute;
+        };
+      };
+      member?: {
+        additionalFields?: {
+          [key: string]: better_auth220.DBFieldAttribute;
+        };
+      };
+      invitation?: {
+        additionalFields?: {
+          [key: string]: better_auth220.DBFieldAttribute;
+        };
+      };
+      team?: {
+        additionalFields?: {
+          [key: string]: better_auth220.DBFieldAttribute;
+        };
+      };
+      organizationRole?: {
+        additionalFields?: {
+          [key: string]: better_auth220.DBFieldAttribute;
+        };
+      };
+    } | undefined;
+    dynamicAccessControl: {
+      enabled: false;
+    };
+  }>;
+  getActions: ($fetch: _better_fetch_fetch138.BetterFetch, _$store: better_auth220.ClientStore, co: BetterAuthClientOptions | undefined) => {
+    $Infer: {
+      ActiveOrganization: {
+        members: {
+          id: string;
+          organizationId: string;
+          role: "admin" | "member" | "owner";
+          createdAt: Date;
+          userId: string;
+          user: {
+            id: string;
+            email: string;
+            name: string;
+            image?: string | undefined;
+          };
+        }[];
+        invitations: {
+          id: string;
+          organizationId: string;
+          email: string;
+          role: "admin" | "member" | "owner";
+          status: better_auth_client11.InvitationStatus;
+          inviterId: string;
+          expiresAt: Date;
+          createdAt: Date;
+        }[];
+      } & {
+        id: string;
+        name: string;
+        slug: string;
+        createdAt: Date;
+        logo?: string | null | undefined | undefined;
+        metadata?: any;
+      };
+      Organization: {
+        id: string;
+        name: string;
+        slug: string;
+        createdAt: Date;
+        logo?: string | null | undefined;
+        metadata?: any;
+      };
+      Invitation: {
+        id: string;
+        organizationId: string;
+        email: string;
+        role: "admin" | "member" | "owner";
+        status: better_auth_client11.InvitationStatus;
+        inviterId: string;
+        expiresAt: Date;
+        createdAt: Date;
+      };
+      Member: {
+        id: string;
+        organizationId: string;
+        role: "admin" | "member" | "owner";
+        createdAt: Date;
+        userId: string;
+        user: {
+          id: string;
+          email: string;
+          name: string;
+          image?: string | undefined;
+        };
+      };
+      Team: {
+        id: string;
+        name: string;
+        organizationId: string;
+        createdAt: Date;
+        updatedAt?: Date | undefined;
+      };
+    };
+    organization: {
+      checkRolePermission: <R extends "admin" | "member" | "owner">(data: ({
+        permission: {
+          readonly organization?: ("delete" | "update")[] | undefined;
+          readonly member?: ("create" | "delete" | "update")[] | undefined;
+          readonly invitation?: ("create" | "cancel")[] | undefined;
+          readonly team?: ("create" | "delete" | "update")[] | undefined;
+          readonly ac?: ("create" | "delete" | "update" | "read")[] | undefined;
+        };
+        permissions?: never | undefined;
+      } | {
+        permissions: {
+          readonly organization?: ("delete" | "update")[] | undefined;
+          readonly member?: ("create" | "delete" | "update")[] | undefined;
+          readonly invitation?: ("create" | "cancel")[] | undefined;
+          readonly team?: ("create" | "delete" | "update")[] | undefined;
+          readonly ac?: ("create" | "delete" | "update" | "read")[] | undefined;
+        };
+        permission?: never | undefined;
+      }) & {
+        role: R;
+      }) => boolean;
+    };
+  };
+  getAtoms: ($fetch: _better_fetch_fetch138.BetterFetch) => {
+    $listOrg: nanostores1.PreinitializedWritableAtom<boolean> & object;
+    $activeOrgSignal: nanostores1.PreinitializedWritableAtom<boolean> & object;
+    $activeMemberSignal: nanostores1.PreinitializedWritableAtom<boolean> & object;
+    $activeMemberRoleSignal: nanostores1.PreinitializedWritableAtom<boolean> & object;
+    activeOrganization: nanostores1.PreinitializedWritableAtom<{
+      data: better_auth220.Prettify<{
+        id: string;
+        name: string;
+        slug: string;
+        createdAt: Date;
+        logo?: string | null | undefined | undefined;
+        metadata?: any;
+      } & {
+        members: {
+          id: string;
+          organizationId: string;
+          role: "admin" | "member" | "owner";
+          createdAt: Date;
+          userId: string;
+          user: {
+            id: string;
+            email: string;
+            name: string;
+            image?: string | undefined;
+          };
+        }[];
+        invitations: {
+          id: string;
+          organizationId: string;
+          email: string;
+          role: "admin" | "member" | "owner";
+          status: better_auth_client11.InvitationStatus;
+          inviterId: string;
+          expiresAt: Date;
+          createdAt: Date;
+        }[];
+      }> | null;
+      error: null | _better_fetch_fetch138.BetterFetchError;
+      isPending: boolean;
+      isRefetching: boolean;
+      refetch: (queryParams?: {
+        query?: better_auth220.SessionQueryParams;
+      } | undefined) => Promise<void>;
+    }> & object;
+    listOrganizations: nanostores1.PreinitializedWritableAtom<{
+      data: {
+        id: string;
+        name: string;
+        slug: string;
+        createdAt: Date;
+        logo?: string | null | undefined | undefined;
+        metadata?: any;
+      }[] | null;
+      error: null | _better_fetch_fetch138.BetterFetchError;
+      isPending: boolean;
+      isRefetching: boolean;
+      refetch: (queryParams?: {
+        query?: better_auth220.SessionQueryParams;
+      } | undefined) => Promise<void>;
+    }> & object;
+    activeMember: nanostores1.PreinitializedWritableAtom<{
+      data: {
+        id: string;
+        organizationId: string;
+        userId: string;
+        role: string;
+        createdAt: Date;
+      } | null;
+      error: null | _better_fetch_fetch138.BetterFetchError;
+      isPending: boolean;
+      isRefetching: boolean;
+      refetch: (queryParams?: {
+        query?: better_auth220.SessionQueryParams;
+      } | undefined) => Promise<void>;
+    }> & object;
+    activeMemberRole: nanostores1.PreinitializedWritableAtom<{
+      data: {
+        role: string;
+      } | null;
+      error: null | _better_fetch_fetch138.BetterFetchError;
+      isPending: boolean;
+      isRefetching: boolean;
+      refetch: (queryParams?: {
+        query?: better_auth220.SessionQueryParams;
+      } | undefined) => Promise<void>;
+    }> & object;
+  };
+  pathMethods: {
+    "/organization/get-full-organization": "GET";
+    "/organization/list-user-teams": "GET";
+  };
+  atomListeners: ({
+    matcher(path: string): path is "/organization/create" | "/organization/update" | "/organization/delete";
+    signal: "$listOrg";
+  } | {
+    matcher(path: string): boolean;
+    signal: "$activeOrgSignal";
+  } | {
+    matcher(path: string): boolean;
+    signal: "$sessionSignal";
+  } | {
+    matcher(path: string): boolean;
+    signal: "$activeMemberSignal";
+  } | {
+    matcher(path: string): boolean;
+    signal: "$activeMemberRoleSignal";
+  })[];
+} | {
+  id: "email-otp";
+  $InferServerPlugin: {
+    id: "email-otp";
+    init(ctx: better_auth220.AuthContext): {
+      options: {
+        emailVerification: {
+          sendVerificationEmail(data: {
+            user: better_auth220.User;
+            url: string;
+            token: string;
+          }, request: Request | undefined): Promise<void>;
+        };
+      };
+    } | undefined;
+    endpoints: {
+      sendVerificationOTP: better_call0.StrictEndpoint<"/email-otp/send-verification-otp", {
+        method: "POST";
+        body: zod0.ZodObject<{
+          email: zod0.ZodString;
+          type: zod0.ZodEnum<{
+            "sign-in": "sign-in";
+            "email-verification": "email-verification";
+            "forget-password": "forget-password";
+          }>;
+        }, better_auth220.$strip>;
+        metadata: {
+          openapi: {
+            operationId: string;
+            description: string;
+            responses: {
+              200: {
+                description: string;
+                content: {
+                  "application/json": {
+                    schema: {
+                      type: "object";
+                      properties: {
+                        success: {
+                          type: string;
+                        };
+                      };
+                    };
+                  };
+                };
+              };
+            };
+          };
+        };
+      } & {
+        use: any[];
+      }, {
+        success: boolean;
+      }>;
+      createVerificationOTP: better_call0.StrictEndpoint<"/email-otp/create-verification-otp", {
+        method: "POST";
+        body: zod0.ZodObject<{
+          email: zod0.ZodString;
+          type: zod0.ZodEnum<{
+            "sign-in": "sign-in";
+            "email-verification": "email-verification";
+            "forget-password": "forget-password";
+          }>;
+        }, better_auth220.$strip>;
+        metadata: {
+          SERVER_ONLY: true;
+          openapi: {
+            operationId: string;
+            description: string;
+            responses: {
+              200: {
+                description: string;
+                content: {
+                  "application/json": {
+                    schema: {
+                      type: "string";
+                    };
+                  };
+                };
+              };
+            };
+          };
+        };
+      } & {
+        use: any[];
+      }, string>;
+      getVerificationOTP: better_call0.StrictEndpoint<"/email-otp/get-verification-otp", {
+        method: "GET";
+        query: zod0.ZodObject<{
+          email: zod0.ZodString;
+          type: zod0.ZodEnum<{
+            "sign-in": "sign-in";
+            "email-verification": "email-verification";
+            "forget-password": "forget-password";
+          }>;
+        }, better_auth220.$strip>;
+        metadata: {
+          SERVER_ONLY: true;
+          openapi: {
+            operationId: string;
+            description: string;
+            responses: {
+              "200": {
+                description: string;
+                content: {
+                  "application/json": {
+                    schema: {
+                      type: "object";
+                      properties: {
+                        otp: {
+                          type: string;
+                          nullable: boolean;
+                          description: string;
+                        };
+                      };
+                      required: string[];
+                    };
+                  };
+                };
+              };
+            };
+          };
+        };
+      } & {
+        use: any[];
+      }, {
+        otp: null;
+      } | {
+        otp: string;
+      }>;
+      checkVerificationOTP: better_call0.StrictEndpoint<"/email-otp/check-verification-otp", {
+        method: "POST";
+        body: zod0.ZodObject<{
+          email: zod0.ZodString;
+          type: zod0.ZodEnum<{
+            "sign-in": "sign-in";
+            "email-verification": "email-verification";
+            "forget-password": "forget-password";
+          }>;
+          otp: zod0.ZodString;
+        }, better_auth220.$strip>;
+        metadata: {
+          openapi: {
+            operationId: string;
+            description: string;
+            responses: {
+              200: {
+                description: string;
+                content: {
+                  "application/json": {
+                    schema: {
+                      type: "object";
+                      properties: {
+                        success: {
+                          type: string;
+                        };
+                      };
+                    };
+                  };
+                };
+              };
+            };
+          };
+        };
+      } & {
+        use: any[];
+      }, {
+        success: boolean;
+      }>;
+      verifyEmailOTP: better_call0.StrictEndpoint<"/email-otp/verify-email", {
+        method: "POST";
+        body: zod0.ZodObject<{
+          email: zod0.ZodString;
+          otp: zod0.ZodString;
+        }, better_auth220.$strip>;
+        metadata: {
+          openapi: {
+            description: string;
+            responses: {
+              200: {
+                description: string;
+                content: {
+                  "application/json": {
+                    schema: {
+                      type: "object";
+                      properties: {
+                        status: {
+                          type: string;
+                          description: string;
+                          enum: boolean[];
+                        };
+                        token: {
+                          type: string;
+                          nullable: boolean;
+                          description: string;
+                        };
+                        user: {
+                          $ref: string;
+                        };
+                      };
+                      required: string[];
+                    };
+                  };
+                };
+              };
+            };
+          };
+        };
+      } & {
+        use: any[];
+      }, {
+        status: boolean;
+        token: string;
+        user: {
+          id: string;
+          email: string;
+          emailVerified: boolean;
+          name: string;
+          image: string | null | undefined;
+          createdAt: Date;
+          updatedAt: Date;
+        };
+      } | {
+        status: boolean;
+        token: null;
+        user: {
+          id: string;
+          email: string;
+          emailVerified: boolean;
+          name: string;
+          image: string | null | undefined;
+          createdAt: Date;
+          updatedAt: Date;
+        };
+      }>;
+      signInEmailOTP: better_call0.StrictEndpoint<"/sign-in/email-otp", {
+        method: "POST";
+        body: zod0.ZodObject<{
+          email: zod0.ZodString;
+          otp: zod0.ZodString;
+        }, better_auth220.$strip>;
+        metadata: {
+          openapi: {
+            operationId: string;
+            description: string;
+            responses: {
+              200: {
+                description: string;
+                content: {
+                  "application/json": {
+                    schema: {
+                      type: "object";
+                      properties: {
+                        token: {
+                          type: string;
+                          description: string;
+                        };
+                        user: {
+                          $ref: string;
+                        };
+                      };
+                      required: string[];
+                    };
+                  };
+                };
+              };
+            };
+          };
+        };
+      } & {
+        use: any[];
+      }, {
+        token: string;
+        user: {
+          id: string;
+          email: string;
+          emailVerified: boolean;
+          name: string;
+          image: string | null | undefined;
+          createdAt: Date;
+          updatedAt: Date;
+        };
+      }>;
+      forgetPasswordEmailOTP: better_call0.StrictEndpoint<"/forget-password/email-otp", {
+        method: "POST";
+        body: zod0.ZodObject<{
+          email: zod0.ZodString;
+        }, better_auth220.$strip>;
+        metadata: {
+          openapi: {
+            operationId: string;
+            description: string;
+            responses: {
+              200: {
+                description: string;
+                content: {
+                  "application/json": {
+                    schema: {
+                      type: "object";
+                      properties: {
+                        success: {
+                          type: string;
+                          description: string;
+                        };
+                      };
+                    };
+                  };
+                };
+              };
+            };
+          };
+        };
+      } & {
+        use: any[];
+      }, {
+        success: boolean;
+      }>;
+      resetPasswordEmailOTP: better_call0.StrictEndpoint<"/email-otp/reset-password", {
+        method: "POST";
+        body: zod0.ZodObject<{
+          email: zod0.ZodString;
+          otp: zod0.ZodString;
+          password: zod0.ZodString;
+        }, better_auth220.$strip>;
+        metadata: {
+          openapi: {
+            operationId: string;
+            description: string;
+            responses: {
+              200: {
+                description: string;
+                contnt: {
+                  "application/json": {
+                    schema: {
+                      type: string;
+                      properties: {
+                        success: {
+                          type: string;
+                        };
+                      };
+                    };
+                  };
+                };
+              };
+            };
+          };
+        };
+      } & {
+        use: any[];
+      }, {
+        success: boolean;
+      }>;
+    };
+    hooks: {
+      after: {
+        matcher(context: better_auth220.HookEndpointContext): boolean;
+        handler: (inputContext: better_call0.MiddlewareInputContext<better_call0.MiddlewareOptions>) => Promise<void>;
+      }[];
+    };
+    $ERROR_CODES: {
+      readonly OTP_EXPIRED: "OTP expired";
+      readonly INVALID_OTP: "Invalid OTP";
+      readonly TOO_MANY_ATTEMPTS: "Too many attempts";
+    };
+    rateLimit: ({
+      pathMatcher(path: string): path is "/email-otp/send-verification-otp";
+      window: number;
+      max: number;
+    } | {
+      pathMatcher(path: string): path is "/email-otp/check-verification-otp";
+      window: number;
+      max: number;
+    } | {
+      pathMatcher(path: string): path is "/email-otp/verify-email";
+      window: number;
+      max: number;
+    } | {
+      pathMatcher(path: string): path is "/sign-in/email-otp";
+      window: number;
+      max: number;
+    })[];
+  };
+  atomListeners: {
+    matcher: (path: string) => path is "/email-otp/verify-email" | "/sign-in/email-otp";
+    signal: "$sessionSignal";
+  }[];
+} | {
+  id: "anonymous";
+  $InferServerPlugin: ReturnType<(options?: better_auth_client_plugins7.AnonymousOptions | undefined) => {
+    id: "anonymous";
+    endpoints: {
+      signInAnonymous: better_call0.StrictEndpoint<"/sign-in/anonymous", {
+        method: "POST";
+        metadata: {
+          openapi: {
+            description: string;
+            responses: {
+              200: {
+                description: string;
+                content: {
+                  "application/json": {
+                    schema: {
+                      type: "object";
+                      properties: {
+                        user: {
+                          $ref: string;
+                        };
+                        session: {
+                          $ref: string;
+                        };
+                      };
+                    };
+                  };
+                };
+              };
+            };
+          };
+        };
+      } & {
+        use: any[];
+      }, {
+        token: string;
+        user: {
+          id: string;
+          email: string;
+          emailVerified: boolean;
+          name: string;
+          createdAt: Date;
+          updatedAt: Date;
+        };
+      } | null>;
+    };
+    hooks: {
+      after: {
+        matcher(ctx: better_auth220.HookEndpointContext): boolean;
+        handler: (inputContext: better_call0.MiddlewareInputContext<better_call0.MiddlewareOptions>) => Promise<void>;
+      }[];
+    };
+    schema: {
+      user: {
+        fields: {
+          isAnonymous: {
+            type: "boolean";
+            required: false;
+            input: false;
+            defaultValue: false;
+          };
+        };
+      };
+    };
+    $ERROR_CODES: {
+      readonly INVALID_EMAIL_FORMAT: "Email was not generated in a valid format";
+      readonly FAILED_TO_CREATE_USER: "Failed to create user";
+      readonly COULD_NOT_CREATE_SESSION: "Could not create session";
+      readonly ANONYMOUS_USERS_CANNOT_SIGN_IN_AGAIN_ANONYMOUSLY: "Anonymous users cannot sign in again anonymously";
+    };
+  }>;
+  pathMethods: {
+    "/sign-in/anonymous": "POST";
+  };
+  atomListeners: {
+    matcher: (path: string) => path is "/sign-in/anonymous";
+    signal: "$sessionSignal";
+  }[];
+} | {
+  id: "phoneNumber";
+  $InferServerPlugin: ReturnType<(options?: better_auth_client_plugins7.PhoneNumberOptions | undefined) => {
+    id: "phone-number";
+    hooks: {
+      before: {
+        matcher: (ctx: better_auth220.HookEndpointContext) => boolean;
+        handler: (inputContext: better_call0.MiddlewareInputContext<better_call0.MiddlewareOptions>) => Promise<never>;
+      }[];
+    };
+    endpoints: {
+      signInPhoneNumber: better_call0.StrictEndpoint<"/sign-in/phone-number", {
+        method: "POST";
+        body: zod0.ZodObject<{
+          phoneNumber: zod0.ZodString;
+          password: zod0.ZodString;
+          rememberMe: zod0.ZodOptional<zod0.ZodBoolean>;
+        }, better_auth220.$strip>;
+        metadata: {
+          openapi: {
+            summary: string;
+            description: string;
+            responses: {
+              200: {
+                description: string;
+                content: {
+                  "application/json": {
+                    schema: {
+                      type: "object";
+                      properties: {
+                        user: {
+                          $ref: string;
+                        };
+                        session: {
+                          $ref: string;
+                        };
+                      };
+                    };
+                  };
+                };
+              };
+              400: {
+                description: string;
+              };
+            };
+          };
+        };
+      } & {
+        use: any[];
+      }, {
+        token: string;
+        user: better_auth_client_plugins7.UserWithPhoneNumber;
+      }>;
+      sendPhoneNumberOTP: better_call0.StrictEndpoint<"/phone-number/send-otp", {
+        method: "POST";
+        body: zod0.ZodObject<{
+          phoneNumber: zod0.ZodString;
+        }, better_auth220.$strip>;
+        metadata: {
+          openapi: {
+            summary: string;
+            description: string;
+            responses: {
+              200: {
+                description: string;
+                content: {
+                  "application/json": {
+                    schema: {
+                      type: "object";
+                      properties: {
+                        message: {
+                          type: string;
+                        };
+                      };
+                    };
+                  };
+                };
+              };
+            };
+          };
+        };
+      } & {
+        use: any[];
+      }, {
+        message: string;
+      }>;
+      verifyPhoneNumber: better_call0.StrictEndpoint<"/phone-number/verify", {
+        method: "POST";
+        body: zod0.ZodObject<{
+          phoneNumber: zod0.ZodString;
+          code: zod0.ZodString;
+          disableSession: zod0.ZodOptional<zod0.ZodBoolean>;
+          updatePhoneNumber: zod0.ZodOptional<zod0.ZodBoolean>;
+        }, better_auth220.$strip>;
+        metadata: {
+          openapi: {
+            summary: string;
+            description: string;
+            responses: {
+              "200": {
+                description: string;
+                content: {
+                  "application/json": {
+                    schema: {
+                      type: "object";
+                      properties: {
+                        status: {
+                          type: string;
+                          description: string;
+                          enum: boolean[];
+                        };
+                        token: {
+                          type: string;
+                          nullable: boolean;
+                          description: string;
+                        };
+                        user: {
+                          type: string;
+                          nullable: boolean;
+                          properties: {
+                            id: {
+                              type: string;
+                              description: string;
+                            };
+                            email: {
+                              type: string;
+                              format: string;
+                              nullable: boolean;
+                              description: string;
+                            };
+                            emailVerified: {
+                              type: string;
+                              nullable: boolean;
+                              description: string;
+                            };
+                            name: {
+                              type: string;
+                              nullable: boolean;
+                              description: string;
+                            };
+                            image: {
+                              type: string;
+                              format: string;
+                              nullable: boolean;
+                              description: string;
+                            };
+                            phoneNumber: {
+                              type: string;
+                              description: string;
+                            };
+                            phoneNumberVerified: {
+                              type: string;
+                              description: string;
+                            };
+                            createdAt: {
+                              type: string;
+                              format: string;
+                              description: string;
+                            };
+                            updatedAt: {
+                              type: string;
+                              format: string;
+                              description: string;
+                            };
+                          };
+                          required: string[];
+                          description: string;
+                        };
+                      };
+                      required: string[];
+                    };
+                  };
+                };
+              };
+              400: {
+                description: string;
+              };
+            };
+          };
+        };
+      } & {
+        use: any[];
+      }, {
+        status: boolean;
+        token: string;
+        user: better_auth_client_plugins7.UserWithPhoneNumber;
+      } | {
+        status: boolean;
+        token: null;
+        user: better_auth_client_plugins7.UserWithPhoneNumber;
+      }>;
+      requestPasswordResetPhoneNumber: better_call0.StrictEndpoint<"/phone-number/request-password-reset", {
+        method: "POST";
+        body: zod0.ZodObject<{
+          phoneNumber: zod0.ZodString;
+        }, better_auth220.$strip>;
+        metadata: {
+          openapi: {
+            description: string;
+            responses: {
+              "200": {
+                description: string;
+                content: {
+                  "application/json": {
+                    schema: {
+                      type: "object";
+                      properties: {
+                        status: {
+                          type: string;
+                          description: string;
+                          enum: boolean[];
+                        };
+                      };
+                      required: string[];
+                    };
+                  };
+                };
+              };
+            };
+          };
+        };
+      } & {
+        use: any[];
+      }, {
+        status: boolean;
+      }>;
+      resetPasswordPhoneNumber: better_call0.StrictEndpoint<"/phone-number/reset-password", {
+        method: "POST";
+        body: zod0.ZodObject<{
+          otp: zod0.ZodString;
+          phoneNumber: zod0.ZodString;
+          newPassword: zod0.ZodString;
+        }, better_auth220.$strip>;
+        metadata: {
+          openapi: {
+            description: string;
+            responses: {
+              "200": {
+                description: string;
+                content: {
+                  "application/json": {
+                    schema: {
+                      type: "object";
+                      properties: {
+                        status: {
+                          type: string;
+                          description: string;
+                          enum: boolean[];
+                        };
+                      };
+                      required: string[];
+                    };
+                  };
+                };
+              };
+            };
+          };
+        };
+      } & {
+        use: any[];
+      }, {
+        status: boolean;
+      }>;
+    };
+    schema: {
+      user: {
+        fields: {
+          phoneNumber: {
+            type: "string";
+            required: false;
+            unique: true;
+            sortable: true;
+            returned: true;
+          };
+          phoneNumberVerified: {
+            type: "boolean";
+            required: false;
+            returned: true;
+            input: false;
+          };
+        };
+      };
+    };
+    rateLimit: {
+      pathMatcher(path: string): boolean;
+      window: number;
+      max: number;
+    }[];
+    $ERROR_CODES: {
+      readonly INVALID_PHONE_NUMBER: "Invalid phone number";
+      readonly PHONE_NUMBER_EXIST: "Phone number already exists";
+      readonly PHONE_NUMBER_NOT_EXIST: "phone number isn't registered";
+      readonly INVALID_PHONE_NUMBER_OR_PASSWORD: "Invalid phone number or password";
+      readonly UNEXPECTED_ERROR: "Unexpected error";
+      readonly OTP_NOT_FOUND: "OTP not found";
+      readonly OTP_EXPIRED: "OTP expired";
+      readonly INVALID_OTP: "Invalid OTP";
+      readonly PHONE_NUMBER_NOT_VERIFIED: "Phone number not verified";
+      readonly PHONE_NUMBER_CANNOT_BE_UPDATED: "Phone number cannot be updated";
+      readonly SEND_OTP_NOT_IMPLEMENTED: "sendOTP not implemented";
+      readonly TOO_MANY_ATTEMPTS: "Too many attempts";
+    };
+  }>;
+  atomListeners: {
+    matcher(path: string): path is "/phone-number/verify" | "/sign-in/phone-number" | "/phone-number/update";
+    signal: "$sessionSignal";
+  }[];
+} | {
+  id: "magic-link";
+  $InferServerPlugin: {
+    id: "magic-link";
+    endpoints: {
+      signInMagicLink: better_call0.StrictEndpoint<"/sign-in/magic-link", {
+        method: "POST";
+        requireHeaders: true;
+        body: zod0.ZodObject<{
+          email: zod0.ZodEmail;
+          name: zod0.ZodOptional<zod0.ZodString>;
+          callbackURL: zod0.ZodOptional<zod0.ZodString>;
+          newUserCallbackURL: zod0.ZodOptional<zod0.ZodString>;
+          errorCallbackURL: zod0.ZodOptional<zod0.ZodString>;
+        }, better_auth220.$strip>;
+        metadata: {
+          openapi: {
+            operationId: string;
+            description: string;
+            responses: {
+              200: {
+                description: string;
+                content: {
+                  "application/json": {
+                    schema: {
+                      type: "object";
+                      properties: {
+                        status: {
+                          type: string;
+                        };
+                      };
+                    };
+                  };
+                };
+              };
+            };
+          };
+        };
+      } & {
+        use: any[];
+      }, {
+        status: boolean;
+      }>;
+      magicLinkVerify: better_call0.StrictEndpoint<"/magic-link/verify", {
+        method: "GET";
+        query: zod0.ZodObject<{
+          token: zod0.ZodString;
+          callbackURL: zod0.ZodOptional<zod0.ZodString>;
+          errorCallbackURL: zod0.ZodOptional<zod0.ZodString>;
+          newUserCallbackURL: zod0.ZodOptional<zod0.ZodString>;
+        }, better_auth220.$strip>;
+        use: ((inputContext: better_call0.MiddlewareInputContext<better_call0.MiddlewareOptions>) => Promise<void>)[];
+        requireHeaders: true;
+        metadata: {
+          openapi: {
+            operationId: string;
+            description: string;
+            responses: {
+              200: {
+                description: string;
+                content: {
+                  "application/json": {
+                    schema: {
+                      type: "object";
+                      properties: {
+                        session: {
+                          $ref: string;
+                        };
+                        user: {
+                          $ref: string;
+                        };
+                      };
+                    };
+                  };
+                };
+              };
+            };
+          };
+        };
+      } & {
+        use: any[];
+      }, {
+        token: string;
+        user: {
+          id: string;
+          email: string;
+          emailVerified: boolean;
+          name: string;
+          image: string | null | undefined;
+          createdAt: Date;
+          updatedAt: Date;
+        };
+      }>;
+    };
+    rateLimit: {
+      pathMatcher(path: string): boolean;
+      window: number;
+      max: number;
+    }[];
+  };
+})[];
+type SupportedBetterAuthClientPlugins = typeof supportedBetterAuthClientPlugins;
+declare abstract class NeonAuthAdapterCore {
+  protected betterAuthOptions: BetterAuthClientOptions & {
+    plugins: SupportedBetterAuthClientPlugins;
+    fetchOptions: {
+      throw: false;
+    };
+  };
+  /**
+   * Better Auth adapter implementing the NeonAuthClient interface.
+   * See CLAUDE.md for architecture details and API mappings.
+   */
+  constructor(betterAuthClientOptions: NeonAuthAdapterCoreAuthOptions);
+  abstract getBetterAuthInstance?(): AuthClient<BetterAuthClientOptions> | ReturnType<typeof createAuthClient>;
+  abstract getJWTToken(): Promise<string | null>;
+}
+//#endregion
+export { NeonAuthAdapterCoreAuthOptions as n, SupportedBetterAuthClientPlugins as r, NeonAuthAdapterCore as t };