@tulip-systems/core 0.2.0

package/dist/modules/config/lib/resolve.server.d.ts

@@ -0,0 +1,2065 @@
+import { TDatabaseSchema } from "../db/types.js";
+import { PathConfig } from "../paths/types.js";
+import { TulipConfig } from "./config.server.js";
+import "server-cli-only";
+import * as zod0 from "zod";
+import * as better_auth52 from "better-auth";
+import * as better_auth_plugins5 from "better-auth/plugins";
+import * as drizzle_orm_postgres_js0 from "drizzle-orm/postgres-js";
+import { S3Client } from "@aws-sdk/client-s3";
+import { Resend } from "resend";
+
+//#region src/modules/config/lib/resolve.server.d.ts
+/**
+ * Get the Tulip provider
+ */
+type GetTulipParams<TSchema extends TDatabaseSchema> = {
+  config: TulipConfig<TSchema>;
+};
+type GetTulipReturn<TSchema extends TDatabaseSchema> = Awaited<ReturnType<typeof getTulip<TSchema>>>;
+/**
+ * Get the Tulip provider
+ */
+declare const getTulip: <TSchema extends TDatabaseSchema>(params: GetTulipParams<TSchema>) => Promise<{
+  general: {
+    name: string;
+    shortName: string;
+  };
+  paths: PathConfig<TSchema>;
+  schema: TSchema;
+  db: drizzle_orm_postgres_js0.PostgresJsDatabase<TSchema>;
+  auth: better_auth52.Auth<{
+    database: (options: better_auth52.BetterAuthOptions) => better_auth52.Adapter;
+    emailAndPassword: {
+      enabled: true;
+    };
+    user: {
+      changeEmail: {
+        enabled: true;
+      };
+      additionalFields: {
+        firstName: {
+          type: "string";
+          required: true;
+          input: true;
+        };
+        lastName: {
+          type: "string";
+          required: true;
+          input: true;
+        };
+      };
+    };
+    plugins: [{
+      id: "next-cookies";
+      hooks: {
+        after: {
+          matcher(ctx: better_auth52.HookEndpointContext): true;
+          handler: (inputContext: better_auth52.MiddlewareInputContext<better_auth52.MiddlewareOptions>) => Promise<void>;
+        }[];
+      };
+    }, {
+      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_auth52.GenericEndpointContext | undefined): Promise<void>;
+              };
+            };
+          };
+        };
+      };
+      hooks: {
+        after: {
+          matcher(context: better_auth52.HookEndpointContext): boolean;
+          handler: (inputContext: better_auth52.MiddlewareInputContext<better_auth52.MiddlewareOptions>) => Promise<better_auth_plugins5.SessionWithImpersonatedBy[] | undefined>;
+        }[];
+      };
+      endpoints: {
+        setRole: {
+          <AsResponse extends boolean = false, ReturnHeaders extends boolean = false>(inputCtx_0: {
+            body: {
+              userId: string;
+              role: string | string[];
+            };
+          } & {
+            method?: "POST" | undefined;
+          } & {
+            query?: Record<string, any> | undefined;
+          } & {
+            params?: Record<string, any>;
+          } & {
+            request?: Request;
+          } & {
+            headers: HeadersInit;
+          } & {
+            asResponse?: boolean;
+            returnHeaders?: boolean;
+            use?: better_auth52.Middleware[];
+            path?: string;
+          } & {
+            asResponse?: AsResponse | undefined;
+            returnHeaders?: ReturnHeaders | undefined;
+          }): Promise<[AsResponse] extends [true] ? Response : [ReturnHeaders] extends [true] ? {
+            headers: Headers;
+            response: {
+              user: better_auth_plugins5.UserWithRole;
+            };
+          } : {
+            user: better_auth_plugins5.UserWithRole;
+          }>;
+          options: {
+            method: "POST";
+            body: zod0.ZodObject<{
+              userId: zod0.ZodCoercedString<unknown>;
+              role: zod0.ZodUnion<readonly [zod0.ZodString, zod0.ZodArray<zod0.ZodString>]>;
+            }, better_auth52.$strip>;
+            requireHeaders: true;
+            use: ((inputContext: better_auth52.MiddlewareInputContext<better_auth52.MiddlewareOptions>) => Promise<{
+              session: {
+                user: better_auth_plugins5.UserWithRole;
+                session: better_auth52.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: string | string[];
+                };
+              };
+            };
+          } & {
+            use: any[];
+          };
+          path: "/admin/set-role";
+        };
+        getUser: {
+          <AsResponse extends boolean = false, ReturnHeaders_1 extends boolean = false>(inputCtx_0: {
+            body?: undefined;
+          } & {
+            method?: "GET" | undefined;
+          } & {
+            query: {
+              id: string;
+            };
+          } & {
+            params?: Record<string, any>;
+          } & {
+            request?: Request;
+          } & {
+            headers?: HeadersInit;
+          } & {
+            asResponse?: boolean;
+            returnHeaders?: boolean;
+            use?: better_auth52.Middleware[];
+            path?: string;
+          } & {
+            asResponse?: AsResponse | undefined;
+            returnHeaders?: ReturnHeaders_1 | undefined;
+          }): Promise<[AsResponse] extends [true] ? Response : [ReturnHeaders_1] extends [true] ? {
+            headers: Headers;
+            response: {
+              id: string;
+              createdAt: Date;
+              updatedAt: Date;
+              email: string;
+              emailVerified: boolean;
+              name: string;
+              image?: string | null | undefined;
+            };
+          } : {
+            id: string;
+            createdAt: Date;
+            updatedAt: Date;
+            email: string;
+            emailVerified: boolean;
+            name: string;
+            image?: string | null | undefined;
+          }>;
+          options: {
+            method: "GET";
+            query: zod0.ZodObject<{
+              id: zod0.ZodString;
+            }, better_auth52.$strip>;
+            use: ((inputContext: better_auth52.MiddlewareInputContext<better_auth52.MiddlewareOptions>) => Promise<{
+              session: {
+                user: better_auth_plugins5.UserWithRole;
+                session: better_auth52.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[];
+          };
+          path: "/admin/get-user";
+        };
+        createUser: {
+          <AsResponse extends boolean = false, ReturnHeaders_2 extends boolean = false>(inputCtx_0: {
+            body: {
+              email: string;
+              password: string;
+              name: string;
+              role?: string | string[] | undefined;
+              data?: Record<string, any>;
+            };
+          } & {
+            method?: "POST" | undefined;
+          } & {
+            query?: Record<string, any> | undefined;
+          } & {
+            params?: Record<string, any>;
+          } & {
+            request?: Request;
+          } & {
+            headers?: HeadersInit;
+          } & {
+            asResponse?: boolean;
+            returnHeaders?: boolean;
+            use?: better_auth52.Middleware[];
+            path?: string;
+          } & {
+            asResponse?: AsResponse | undefined;
+            returnHeaders?: ReturnHeaders_2 | undefined;
+          }): Promise<[AsResponse] extends [true] ? Response : [ReturnHeaders_2] extends [true] ? {
+            headers: Headers;
+            response: {
+              user: better_auth_plugins5.UserWithRole;
+            };
+          } : {
+            user: better_auth_plugins5.UserWithRole;
+          }>;
+          options: {
+            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_auth52.$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?: string | string[] | undefined;
+                  data?: Record<string, any>;
+                };
+              };
+            };
+          } & {
+            use: any[];
+          };
+          path: "/admin/create-user";
+        };
+        adminUpdateUser: {
+          <AsResponse extends boolean = false, ReturnHeaders_3 extends boolean = false>(inputCtx_0: {
+            body: {
+              userId: unknown;
+              data: Record<any, any>;
+            };
+          } & {
+            method?: "POST" | undefined;
+          } & {
+            query?: Record<string, any> | undefined;
+          } & {
+            params?: Record<string, any>;
+          } & {
+            request?: Request;
+          } & {
+            headers?: HeadersInit;
+          } & {
+            asResponse?: boolean;
+            returnHeaders?: boolean;
+            use?: better_auth52.Middleware[];
+            path?: string;
+          } & {
+            asResponse?: AsResponse | undefined;
+            returnHeaders?: ReturnHeaders_3 | undefined;
+          }): Promise<[AsResponse] extends [true] ? Response : [ReturnHeaders_3] extends [true] ? {
+            headers: Headers;
+            response: better_auth_plugins5.UserWithRole;
+          } : better_auth_plugins5.UserWithRole>;
+          options: {
+            method: "POST";
+            body: zod0.ZodObject<{
+              userId: zod0.ZodCoercedString<unknown>;
+              data: zod0.ZodRecord<zod0.ZodAny, zod0.ZodAny>;
+            }, better_auth52.$strip>;
+            use: ((inputContext: better_auth52.MiddlewareInputContext<better_auth52.MiddlewareOptions>) => Promise<{
+              session: {
+                user: better_auth_plugins5.UserWithRole;
+                session: better_auth52.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[];
+          };
+          path: "/admin/update-user";
+        };
+        listUsers: {
+          <AsResponse extends boolean = false, ReturnHeaders_4 extends boolean = false>(inputCtx_0: {
+            body?: undefined;
+          } & {
+            method?: "GET" | undefined;
+          } & {
+            query: {
+              searchValue?: string | undefined;
+              searchField?: "name" | "email" | undefined;
+              searchOperator?: "contains" | "starts_with" | "ends_with" | undefined;
+              limit?: string | number | undefined;
+              offset?: string | number | undefined;
+              sortBy?: string | undefined;
+              sortDirection?: "asc" | "desc" | undefined;
+              filterField?: string | undefined;
+              filterValue?: string | number | boolean | undefined;
+              filterOperator?: "eq" | "ne" | "lt" | "lte" | "gt" | "gte" | "contains" | undefined;
+            };
+          } & {
+            params?: Record<string, any>;
+          } & {
+            request?: Request;
+          } & {
+            headers?: HeadersInit;
+          } & {
+            asResponse?: boolean;
+            returnHeaders?: boolean;
+            use?: better_auth52.Middleware[];
+            path?: string;
+          } & {
+            asResponse?: AsResponse | undefined;
+            returnHeaders?: ReturnHeaders_4 | undefined;
+          }): Promise<[AsResponse] extends [true] ? Response : [ReturnHeaders_4] extends [true] ? {
+            headers: Headers;
+            response: {
+              users: better_auth_plugins5.UserWithRole[];
+              total: number;
+              limit: number | undefined;
+              offset: number | undefined;
+            } | {
+              users: never[];
+              total: number;
+            };
+          } : {
+            users: better_auth_plugins5.UserWithRole[];
+            total: number;
+            limit: number | undefined;
+            offset: number | undefined;
+          } | {
+            users: never[];
+            total: number;
+          }>;
+          options: {
+            method: "GET";
+            use: ((inputContext: better_auth52.MiddlewareInputContext<better_auth52.MiddlewareOptions>) => Promise<{
+              session: {
+                user: better_auth_plugins5.UserWithRole;
+                session: better_auth52.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_auth52.$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[];
+          };
+          path: "/admin/list-users";
+        };
+        listUserSessions: {
+          <AsResponse extends boolean = false, ReturnHeaders_5 extends boolean = false>(inputCtx_0: {
+            body: {
+              userId: unknown;
+            };
+          } & {
+            method?: "POST" | undefined;
+          } & {
+            query?: Record<string, any> | undefined;
+          } & {
+            params?: Record<string, any>;
+          } & {
+            request?: Request;
+          } & {
+            headers?: HeadersInit;
+          } & {
+            asResponse?: boolean;
+            returnHeaders?: boolean;
+            use?: better_auth52.Middleware[];
+            path?: string;
+          } & {
+            asResponse?: AsResponse | undefined;
+            returnHeaders?: ReturnHeaders_5 | undefined;
+          }): Promise<[AsResponse] extends [true] ? Response : [ReturnHeaders_5] extends [true] ? {
+            headers: Headers;
+            response: {
+              sessions: better_auth_plugins5.SessionWithImpersonatedBy[];
+            };
+          } : {
+            sessions: better_auth_plugins5.SessionWithImpersonatedBy[];
+          }>;
+          options: {
+            method: "POST";
+            use: ((inputContext: better_auth52.MiddlewareInputContext<better_auth52.MiddlewareOptions>) => Promise<{
+              session: {
+                user: better_auth_plugins5.UserWithRole;
+                session: better_auth52.Session;
+              };
+            }>)[];
+            body: zod0.ZodObject<{
+              userId: zod0.ZodCoercedString<unknown>;
+            }, better_auth52.$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[];
+          };
+          path: "/admin/list-user-sessions";
+        };
+        unbanUser: {
+          <AsResponse extends boolean = false, ReturnHeaders_6 extends boolean = false>(inputCtx_0: {
+            body: {
+              userId: unknown;
+            };
+          } & {
+            method?: "POST" | undefined;
+          } & {
+            query?: Record<string, any> | undefined;
+          } & {
+            params?: Record<string, any>;
+          } & {
+            request?: Request;
+          } & {
+            headers?: HeadersInit;
+          } & {
+            asResponse?: boolean;
+            returnHeaders?: boolean;
+            use?: better_auth52.Middleware[];
+            path?: string;
+          } & {
+            asResponse?: AsResponse | undefined;
+            returnHeaders?: ReturnHeaders_6 | undefined;
+          }): Promise<[AsResponse] extends [true] ? Response : [ReturnHeaders_6] extends [true] ? {
+            headers: Headers;
+            response: {
+              user: any;
+            };
+          } : {
+            user: any;
+          }>;
+          options: {
+            method: "POST";
+            body: zod0.ZodObject<{
+              userId: zod0.ZodCoercedString<unknown>;
+            }, better_auth52.$strip>;
+            use: ((inputContext: better_auth52.MiddlewareInputContext<better_auth52.MiddlewareOptions>) => Promise<{
+              session: {
+                user: better_auth_plugins5.UserWithRole;
+                session: better_auth52.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[];
+          };
+          path: "/admin/unban-user";
+        };
+        banUser: {
+          <AsResponse extends boolean = false, ReturnHeaders_7 extends boolean = false>(inputCtx_0: {
+            body: {
+              userId: unknown;
+              banReason?: string | undefined;
+              banExpiresIn?: number | undefined;
+            };
+          } & {
+            method?: "POST" | undefined;
+          } & {
+            query?: Record<string, any> | undefined;
+          } & {
+            params?: Record<string, any>;
+          } & {
+            request?: Request;
+          } & {
+            headers?: HeadersInit;
+          } & {
+            asResponse?: boolean;
+            returnHeaders?: boolean;
+            use?: better_auth52.Middleware[];
+            path?: string;
+          } & {
+            asResponse?: AsResponse | undefined;
+            returnHeaders?: ReturnHeaders_7 | undefined;
+          }): Promise<[AsResponse] extends [true] ? Response : [ReturnHeaders_7] extends [true] ? {
+            headers: Headers;
+            response: {
+              user: any;
+            };
+          } : {
+            user: any;
+          }>;
+          options: {
+            method: "POST";
+            body: zod0.ZodObject<{
+              userId: zod0.ZodCoercedString<unknown>;
+              banReason: zod0.ZodOptional<zod0.ZodString>;
+              banExpiresIn: zod0.ZodOptional<zod0.ZodNumber>;
+            }, better_auth52.$strip>;
+            use: ((inputContext: better_auth52.MiddlewareInputContext<better_auth52.MiddlewareOptions>) => Promise<{
+              session: {
+                user: better_auth_plugins5.UserWithRole;
+                session: better_auth52.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[];
+          };
+          path: "/admin/ban-user";
+        };
+        impersonateUser: {
+          <AsResponse extends boolean = false, ReturnHeaders_8 extends boolean = false>(inputCtx_0: {
+            body: {
+              userId: unknown;
+            };
+          } & {
+            method?: "POST" | undefined;
+          } & {
+            query?: Record<string, any> | undefined;
+          } & {
+            params?: Record<string, any>;
+          } & {
+            request?: Request;
+          } & {
+            headers?: HeadersInit;
+          } & {
+            asResponse?: boolean;
+            returnHeaders?: boolean;
+            use?: better_auth52.Middleware[];
+            path?: string;
+          } & {
+            asResponse?: AsResponse | undefined;
+            returnHeaders?: ReturnHeaders_8 | undefined;
+          }): Promise<[AsResponse] extends [true] ? Response : [ReturnHeaders_8] extends [true] ? {
+            headers: Headers;
+            response: {
+              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;
+              };
+            };
+          } : {
+            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;
+            };
+          }>;
+          options: {
+            method: "POST";
+            body: zod0.ZodObject<{
+              userId: zod0.ZodCoercedString<unknown>;
+            }, better_auth52.$strip>;
+            use: ((inputContext: better_auth52.MiddlewareInputContext<better_auth52.MiddlewareOptions>) => Promise<{
+              session: {
+                user: better_auth_plugins5.UserWithRole;
+                session: better_auth52.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[];
+          };
+          path: "/admin/impersonate-user";
+        };
+        stopImpersonating: {
+          <AsResponse extends boolean = false, ReturnHeaders_9 extends boolean = false>(inputCtx_0: {
+            body?: undefined;
+          } & {
+            method?: "POST" | undefined;
+          } & {
+            query?: Record<string, any> | undefined;
+          } & {
+            params?: Record<string, any>;
+          } & {
+            request?: Request;
+          } & {
+            headers: HeadersInit;
+          } & {
+            asResponse?: boolean;
+            returnHeaders?: boolean;
+            use?: better_auth52.Middleware[];
+            path?: string;
+          } & {
+            asResponse?: AsResponse | undefined;
+            returnHeaders?: ReturnHeaders_9 | undefined;
+          }): Promise<[AsResponse] extends [true] ? Response : [ReturnHeaders_9] extends [true] ? {
+            headers: Headers;
+            response: {
+              session: better_auth52.Session & Record<string, any>;
+              user: packages_core_dist_db.User & Record<string, any>;
+            };
+          } : {
+            session: better_auth52.Session & Record<string, any>;
+            user: packages_core_dist_db.User & Record<string, any>;
+          }>;
+          options: {
+            method: "POST";
+            requireHeaders: true;
+          } & {
+            use: any[];
+          };
+          path: "/admin/stop-impersonating";
+        };
+        revokeUserSession: {
+          <AsResponse extends boolean = false, ReturnHeaders_10 extends boolean = false>(inputCtx_0: {
+            body: {
+              sessionToken: string;
+            };
+          } & {
+            method?: "POST" | undefined;
+          } & {
+            query?: Record<string, any> | undefined;
+          } & {
+            params?: Record<string, any>;
+          } & {
+            request?: Request;
+          } & {
+            headers?: HeadersInit;
+          } & {
+            asResponse?: boolean;
+            returnHeaders?: boolean;
+            use?: better_auth52.Middleware[];
+            path?: string;
+          } & {
+            asResponse?: AsResponse | undefined;
+            returnHeaders?: ReturnHeaders_10 | undefined;
+          }): Promise<[AsResponse] extends [true] ? Response : [ReturnHeaders_10] extends [true] ? {
+            headers: Headers;
+            response: {
+              success: boolean;
+            };
+          } : {
+            success: boolean;
+          }>;
+          options: {
+            method: "POST";
+            body: zod0.ZodObject<{
+              sessionToken: zod0.ZodString;
+            }, better_auth52.$strip>;
+            use: ((inputContext: better_auth52.MiddlewareInputContext<better_auth52.MiddlewareOptions>) => Promise<{
+              session: {
+                user: better_auth_plugins5.UserWithRole;
+                session: better_auth52.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[];
+          };
+          path: "/admin/revoke-user-session";
+        };
+        revokeUserSessions: {
+          <AsResponse extends boolean = false, ReturnHeaders_11 extends boolean = false>(inputCtx_0: {
+            body: {
+              userId: unknown;
+            };
+          } & {
+            method?: "POST" | undefined;
+          } & {
+            query?: Record<string, any> | undefined;
+          } & {
+            params?: Record<string, any>;
+          } & {
+            request?: Request;
+          } & {
+            headers?: HeadersInit;
+          } & {
+            asResponse?: boolean;
+            returnHeaders?: boolean;
+            use?: better_auth52.Middleware[];
+            path?: string;
+          } & {
+            asResponse?: AsResponse | undefined;
+            returnHeaders?: ReturnHeaders_11 | undefined;
+          }): Promise<[AsResponse] extends [true] ? Response : [ReturnHeaders_11] extends [true] ? {
+            headers: Headers;
+            response: {
+              success: boolean;
+            };
+          } : {
+            success: boolean;
+          }>;
+          options: {
+            method: "POST";
+            body: zod0.ZodObject<{
+              userId: zod0.ZodCoercedString<unknown>;
+            }, better_auth52.$strip>;
+            use: ((inputContext: better_auth52.MiddlewareInputContext<better_auth52.MiddlewareOptions>) => Promise<{
+              session: {
+                user: better_auth_plugins5.UserWithRole;
+                session: better_auth52.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[];
+          };
+          path: "/admin/revoke-user-sessions";
+        };
+        removeUser: {
+          <AsResponse extends boolean = false, ReturnHeaders_12 extends boolean = false>(inputCtx_0: {
+            body: {
+              userId: unknown;
+            };
+          } & {
+            method?: "POST" | undefined;
+          } & {
+            query?: Record<string, any> | undefined;
+          } & {
+            params?: Record<string, any>;
+          } & {
+            request?: Request;
+          } & {
+            headers?: HeadersInit;
+          } & {
+            asResponse?: boolean;
+            returnHeaders?: boolean;
+            use?: better_auth52.Middleware[];
+            path?: string;
+          } & {
+            asResponse?: AsResponse | undefined;
+            returnHeaders?: ReturnHeaders_12 | undefined;
+          }): Promise<[AsResponse] extends [true] ? Response : [ReturnHeaders_12] extends [true] ? {
+            headers: Headers;
+            response: {
+              success: boolean;
+            };
+          } : {
+            success: boolean;
+          }>;
+          options: {
+            method: "POST";
+            body: zod0.ZodObject<{
+              userId: zod0.ZodCoercedString<unknown>;
+            }, better_auth52.$strip>;
+            use: ((inputContext: better_auth52.MiddlewareInputContext<better_auth52.MiddlewareOptions>) => Promise<{
+              session: {
+                user: better_auth_plugins5.UserWithRole;
+                session: better_auth52.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[];
+          };
+          path: "/admin/remove-user";
+        };
+        setUserPassword: {
+          <AsResponse extends boolean = false, ReturnHeaders_13 extends boolean = false>(inputCtx_0: {
+            body: {
+              newPassword: string;
+              userId: unknown;
+            };
+          } & {
+            method?: "POST" | undefined;
+          } & {
+            query?: Record<string, any> | undefined;
+          } & {
+            params?: Record<string, any>;
+          } & {
+            request?: Request;
+          } & {
+            headers?: HeadersInit;
+          } & {
+            asResponse?: boolean;
+            returnHeaders?: boolean;
+            use?: better_auth52.Middleware[];
+            path?: string;
+          } & {
+            asResponse?: AsResponse | undefined;
+            returnHeaders?: ReturnHeaders_13 | undefined;
+          }): Promise<[AsResponse] extends [true] ? Response : [ReturnHeaders_13] extends [true] ? {
+            headers: Headers;
+            response: {
+              status: boolean;
+            };
+          } : {
+            status: boolean;
+          }>;
+          options: {
+            method: "POST";
+            body: zod0.ZodObject<{
+              newPassword: zod0.ZodString;
+              userId: zod0.ZodCoercedString<unknown>;
+            }, better_auth52.$strip>;
+            use: ((inputContext: better_auth52.MiddlewareInputContext<better_auth52.MiddlewareOptions>) => Promise<{
+              session: {
+                user: better_auth_plugins5.UserWithRole;
+                session: better_auth52.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[];
+          };
+          path: "/admin/set-user-password";
+        };
+        userHasPermission: {
+          <AsResponse extends boolean = false, ReturnHeaders_14 extends boolean = false>(inputCtx_0: {
+            body: ({
+              permission: {
+                readonly [x: string]: better_auth52.LiteralString[] | undefined;
+              };
+              permissions?: never;
+            } | {
+              permissions: {
+                readonly [x: string]: better_auth52.LiteralString[] | undefined;
+              };
+              permission?: never;
+            }) & {
+              userId?: string;
+              role?: string | undefined;
+            };
+          } & {
+            method?: "POST" | undefined;
+          } & {
+            query?: Record<string, any> | undefined;
+          } & {
+            params?: Record<string, any>;
+          } & {
+            request?: Request;
+          } & {
+            headers?: HeadersInit;
+          } & {
+            asResponse?: boolean;
+            returnHeaders?: boolean;
+            use?: better_auth52.Middleware[];
+            path?: string;
+          } & {
+            asResponse?: AsResponse | undefined;
+            returnHeaders?: ReturnHeaders_14 | undefined;
+          }): Promise<[AsResponse] extends [true] ? Response : [ReturnHeaders_14] extends [true] ? {
+            headers: Headers;
+            response: {
+              error: null;
+              success: boolean;
+            };
+          } : {
+            error: null;
+            success: boolean;
+          }>;
+          options: {
+            method: "POST";
+            body: zod0.ZodIntersection<zod0.ZodObject<{
+              userId: zod0.ZodOptional<zod0.ZodCoercedString<unknown>>;
+              role: zod0.ZodOptional<zod0.ZodString>;
+            }, better_auth52.$strip>, zod0.ZodUnion<readonly [zod0.ZodObject<{
+              permission: zod0.ZodRecord<zod0.ZodString, zod0.ZodArray<zod0.ZodString>>;
+              permissions: zod0.ZodUndefined;
+            }, better_auth52.$strip>, zod0.ZodObject<{
+              permission: zod0.ZodUndefined;
+              permissions: zod0.ZodRecord<zod0.ZodString, zod0.ZodArray<zod0.ZodString>>;
+            }, better_auth52.$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 [x: string]: better_auth52.LiteralString[] | undefined;
+                  };
+                  permissions?: never;
+                } | {
+                  permissions: {
+                    readonly [x: string]: better_auth52.LiteralString[] | undefined;
+                  };
+                  permission?: never;
+                }) & {
+                  userId?: string;
+                  role?: string | undefined;
+                };
+              };
+            };
+          } & {
+            use: any[];
+          };
+          path: "/admin/has-permission";
+        };
+      };
+      $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";
+      };
+      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;
+    }, {
+      id: "email-otp";
+      init(ctx: better_auth52.AuthContext): {
+        options: {
+          emailVerification: {
+            sendVerificationEmail(data: {
+              user: packages_core_dist_db.User;
+              url: string;
+              token: string;
+            }, request: Request | undefined): Promise<void>;
+          };
+        };
+      } | undefined;
+      endpoints: {
+        createVerificationOTP: {
+          <AsResponse extends boolean = false, ReturnHeaders_15 extends boolean = false>(inputCtx_0: {
+            body: {
+              email: string;
+              type: "sign-in" | "forget-password" | "email-verification";
+            };
+          } & {
+            method?: "POST" | undefined;
+          } & {
+            query?: Record<string, any> | undefined;
+          } & {
+            params?: Record<string, any>;
+          } & {
+            request?: Request;
+          } & {
+            headers?: HeadersInit;
+          } & {
+            asResponse?: boolean;
+            returnHeaders?: boolean;
+            use?: better_auth52.Middleware[];
+            path?: string;
+          } & {
+            asResponse?: AsResponse | undefined;
+            returnHeaders?: ReturnHeaders_15 | undefined;
+          }): Promise<[AsResponse] extends [true] ? Response : [ReturnHeaders_15] extends [true] ? {
+            headers: Headers;
+            response: string;
+          } : string>;
+          options: {
+            method: "POST";
+            body: zod0.ZodObject<{
+              email: zod0.ZodString;
+              type: zod0.ZodEnum<{
+                "sign-in": "sign-in";
+                "forget-password": "forget-password";
+                "email-verification": "email-verification";
+              }>;
+            }, better_auth52.$strip>;
+            metadata: {
+              SERVER_ONLY: true;
+              openapi: {
+                description: string;
+                responses: {
+                  200: {
+                    description: string;
+                    content: {
+                      "application/json": {
+                        schema: {
+                          type: "string";
+                        };
+                      };
+                    };
+                  };
+                };
+              };
+            };
+          } & {
+            use: any[];
+          };
+          path: "/email-otp/create-verification-otp";
+        };
+        getVerificationOTP: {
+          <AsResponse extends boolean = false, ReturnHeaders_16 extends boolean = false>(inputCtx_0: {
+            body?: undefined;
+          } & {
+            method?: "GET" | undefined;
+          } & {
+            query: {
+              email: string;
+              type: "sign-in" | "forget-password" | "email-verification";
+            };
+          } & {
+            params?: Record<string, any>;
+          } & {
+            request?: Request;
+          } & {
+            headers?: HeadersInit;
+          } & {
+            asResponse?: boolean;
+            returnHeaders?: boolean;
+            use?: better_auth52.Middleware[];
+            path?: string;
+          } & {
+            asResponse?: AsResponse | undefined;
+            returnHeaders?: ReturnHeaders_16 | undefined;
+          }): Promise<[AsResponse] extends [true] ? Response : [ReturnHeaders_16] extends [true] ? {
+            headers: Headers;
+            response: {
+              otp: null;
+            } | {
+              otp: string;
+            };
+          } : {
+            otp: null;
+          } | {
+            otp: string;
+          }>;
+          options: {
+            method: "GET";
+            query: zod0.ZodObject<{
+              email: zod0.ZodString;
+              type: zod0.ZodEnum<{
+                "sign-in": "sign-in";
+                "forget-password": "forget-password";
+                "email-verification": "email-verification";
+              }>;
+            }, better_auth52.$strip>;
+            metadata: {
+              SERVER_ONLY: true;
+              openapi: {
+                description: string;
+                responses: {
+                  "200": {
+                    description: string;
+                    content: {
+                      "application/json": {
+                        schema: {
+                          type: "object";
+                          properties: {
+                            otp: {
+                              type: string;
+                              nullable: boolean;
+                              description: string;
+                            };
+                          };
+                          required: string[];
+                        };
+                      };
+                    };
+                  };
+                };
+              };
+            };
+          } & {
+            use: any[];
+          };
+          path: "/email-otp/get-verification-otp";
+        };
+        checkVerificationOTP: {
+          <AsResponse extends boolean = false, ReturnHeaders_17 extends boolean = false>(inputCtx_0: {
+            body: {
+              email: string;
+              type: "sign-in" | "forget-password" | "email-verification";
+              otp: string;
+            };
+          } & {
+            method?: "POST" | undefined;
+          } & {
+            query?: Record<string, any> | undefined;
+          } & {
+            params?: Record<string, any>;
+          } & {
+            request?: Request;
+          } & {
+            headers?: HeadersInit;
+          } & {
+            asResponse?: boolean;
+            returnHeaders?: boolean;
+            use?: better_auth52.Middleware[];
+            path?: string;
+          } & {
+            asResponse?: AsResponse | undefined;
+            returnHeaders?: ReturnHeaders_17 | undefined;
+          }): Promise<[AsResponse] extends [true] ? Response : [ReturnHeaders_17] extends [true] ? {
+            headers: Headers;
+            response: {
+              success: boolean;
+            };
+          } : {
+            success: boolean;
+          }>;
+          options: {
+            method: "POST";
+            body: zod0.ZodObject<{
+              email: zod0.ZodString;
+              type: zod0.ZodEnum<{
+                "sign-in": "sign-in";
+                "forget-password": "forget-password";
+                "email-verification": "email-verification";
+              }>;
+              otp: zod0.ZodString;
+            }, better_auth52.$strip>;
+            metadata: {
+              openapi: {
+                description: string;
+                responses: {
+                  200: {
+                    description: string;
+                    content: {
+                      "application/json": {
+                        schema: {
+                          type: "object";
+                          properties: {
+                            success: {
+                              type: string;
+                            };
+                          };
+                        };
+                      };
+                    };
+                  };
+                };
+              };
+            };
+          } & {
+            use: any[];
+          };
+          path: "/email-otp/check-verification-otp";
+        };
+        verifyEmailOTP: {
+          <AsResponse extends boolean = false, ReturnHeaders_18 extends boolean = false>(inputCtx_0: {
+            body: {
+              email: string;
+              otp: string;
+            };
+          } & {
+            method?: "POST" | undefined;
+          } & {
+            query?: Record<string, any> | undefined;
+          } & {
+            params?: Record<string, any>;
+          } & {
+            request?: Request;
+          } & {
+            headers?: HeadersInit;
+          } & {
+            asResponse?: boolean;
+            returnHeaders?: boolean;
+            use?: better_auth52.Middleware[];
+            path?: string;
+          } & {
+            asResponse?: AsResponse | undefined;
+            returnHeaders?: ReturnHeaders_18 | undefined;
+          }): Promise<[AsResponse] extends [true] ? Response : [ReturnHeaders_18] extends [true] ? {
+            headers: Headers;
+            response: {
+              status: boolean;
+              token: string;
+              user: {
+                id: any;
+                email: any;
+                emailVerified: any;
+                name: any;
+                image: any;
+                createdAt: any;
+                updatedAt: any;
+              };
+            } | {
+              status: boolean;
+              token: null;
+              user: {
+                id: any;
+                email: any;
+                emailVerified: any;
+                name: any;
+                image: any;
+                createdAt: any;
+                updatedAt: any;
+              };
+            };
+          } : {
+            status: boolean;
+            token: string;
+            user: {
+              id: any;
+              email: any;
+              emailVerified: any;
+              name: any;
+              image: any;
+              createdAt: any;
+              updatedAt: any;
+            };
+          } | {
+            status: boolean;
+            token: null;
+            user: {
+              id: any;
+              email: any;
+              emailVerified: any;
+              name: any;
+              image: any;
+              createdAt: any;
+              updatedAt: any;
+            };
+          }>;
+          options: {
+            method: "POST";
+            body: zod0.ZodObject<{
+              email: zod0.ZodString;
+              otp: zod0.ZodString;
+            }, better_auth52.$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[];
+          };
+          path: "/email-otp/verify-email";
+        };
+        signInEmailOTP: {
+          <AsResponse extends boolean = false, ReturnHeaders_19 extends boolean = false>(inputCtx_0: {
+            body: {
+              email: string;
+              otp: string;
+            };
+          } & {
+            method?: "POST" | undefined;
+          } & {
+            query?: Record<string, any> | undefined;
+          } & {
+            params?: Record<string, any>;
+          } & {
+            request?: Request;
+          } & {
+            headers?: HeadersInit;
+          } & {
+            asResponse?: boolean;
+            returnHeaders?: boolean;
+            use?: better_auth52.Middleware[];
+            path?: string;
+          } & {
+            asResponse?: AsResponse | undefined;
+            returnHeaders?: ReturnHeaders_19 | undefined;
+          }): Promise<[AsResponse] extends [true] ? Response : [ReturnHeaders_19] extends [true] ? {
+            headers: Headers;
+            response: {
+              token: string;
+              user: {
+                id: string;
+                email: string;
+                emailVerified: boolean;
+                name: string;
+                image: string | null | undefined;
+                createdAt: Date;
+                updatedAt: Date;
+              };
+            };
+          } : {
+            token: string;
+            user: {
+              id: string;
+              email: string;
+              emailVerified: boolean;
+              name: string;
+              image: string | null | undefined;
+              createdAt: Date;
+              updatedAt: Date;
+            };
+          }>;
+          options: {
+            method: "POST";
+            body: zod0.ZodObject<{
+              email: zod0.ZodString;
+              otp: zod0.ZodString;
+            }, better_auth52.$strip>;
+            metadata: {
+              openapi: {
+                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[];
+          };
+          path: "/sign-in/email-otp";
+        };
+        forgetPasswordEmailOTP: {
+          <AsResponse extends boolean = false, ReturnHeaders_20 extends boolean = false>(inputCtx_0: {
+            body: {
+              email: string;
+            };
+          } & {
+            method?: "POST" | undefined;
+          } & {
+            query?: Record<string, any> | undefined;
+          } & {
+            params?: Record<string, any>;
+          } & {
+            request?: Request;
+          } & {
+            headers?: HeadersInit;
+          } & {
+            asResponse?: boolean;
+            returnHeaders?: boolean;
+            use?: better_auth52.Middleware[];
+            path?: string;
+          } & {
+            asResponse?: AsResponse | undefined;
+            returnHeaders?: ReturnHeaders_20 | undefined;
+          }): Promise<[AsResponse] extends [true] ? Response : [ReturnHeaders_20] extends [true] ? {
+            headers: Headers;
+            response: {
+              success: boolean;
+            };
+          } : {
+            success: boolean;
+          }>;
+          options: {
+            method: "POST";
+            body: zod0.ZodObject<{
+              email: zod0.ZodString;
+            }, better_auth52.$strip>;
+            metadata: {
+              openapi: {
+                description: string;
+                responses: {
+                  200: {
+                    description: string;
+                    content: {
+                      "application/json": {
+                        schema: {
+                          type: "object";
+                          properties: {
+                            success: {
+                              type: string;
+                              description: string;
+                            };
+                          };
+                        };
+                      };
+                    };
+                  };
+                };
+              };
+            };
+          } & {
+            use: any[];
+          };
+          path: "/forget-password/email-otp";
+        };
+        resetPasswordEmailOTP: {
+          <AsResponse extends boolean = false, ReturnHeaders_21 extends boolean = false>(inputCtx_0: {
+            body: {
+              email: string;
+              otp: string;
+              password: string;
+            };
+          } & {
+            method?: "POST" | undefined;
+          } & {
+            query?: Record<string, any> | undefined;
+          } & {
+            params?: Record<string, any>;
+          } & {
+            request?: Request;
+          } & {
+            headers?: HeadersInit;
+          } & {
+            asResponse?: boolean;
+            returnHeaders?: boolean;
+            use?: better_auth52.Middleware[];
+            path?: string;
+          } & {
+            asResponse?: AsResponse | undefined;
+            returnHeaders?: ReturnHeaders_21 | undefined;
+          }): Promise<[AsResponse] extends [true] ? Response : [ReturnHeaders_21] extends [true] ? {
+            headers: Headers;
+            response: {
+              success: boolean;
+            };
+          } : {
+            success: boolean;
+          }>;
+          options: {
+            method: "POST";
+            body: zod0.ZodObject<{
+              email: zod0.ZodString;
+              otp: zod0.ZodString;
+              password: zod0.ZodString;
+            }, better_auth52.$strip>;
+            metadata: {
+              openapi: {
+                description: string;
+                responses: {
+                  200: {
+                    description: string;
+                    contnt: {
+                      "application/json": {
+                        schema: {
+                          type: string;
+                          properties: {
+                            success: {
+                              type: string;
+                            };
+                          };
+                        };
+                      };
+                    };
+                  };
+                };
+              };
+            };
+          } & {
+            use: any[];
+          };
+          path: "/email-otp/reset-password";
+        };
+        sendVerificationOTP: {
+          <AsResponse extends boolean = false, ReturnHeaders_22 extends boolean = false>(inputCtx_0: {
+            body: {
+              email: string;
+              type: "sign-in" | "forget-password" | "email-verification";
+            };
+          } & {
+            method?: "POST" | undefined;
+          } & {
+            query?: Record<string, any> | undefined;
+          } & {
+            params?: Record<string, any>;
+          } & {
+            request?: Request;
+          } & {
+            headers?: HeadersInit;
+          } & {
+            asResponse?: boolean;
+            returnHeaders?: boolean;
+            use?: better_auth52.Middleware[];
+            path?: string;
+          } & {
+            asResponse?: AsResponse | undefined;
+            returnHeaders?: ReturnHeaders_22 | undefined;
+          }): Promise<[AsResponse] extends [true] ? Response : [ReturnHeaders_22] extends [true] ? {
+            headers: Headers;
+            response: {
+              success: boolean;
+            };
+          } : {
+            success: boolean;
+          }>;
+          options: {
+            method: "POST";
+            body: zod0.ZodObject<{
+              email: zod0.ZodString;
+              type: zod0.ZodEnum<{
+                "sign-in": "sign-in";
+                "forget-password": "forget-password";
+                "email-verification": "email-verification";
+              }>;
+            }, better_auth52.$strip>;
+            metadata: {
+              openapi: {
+                description: string;
+                responses: {
+                  200: {
+                    description: string;
+                    content: {
+                      "application/json": {
+                        schema: {
+                          type: "object";
+                          properties: {
+                            success: {
+                              type: string;
+                            };
+                          };
+                        };
+                      };
+                    };
+                  };
+                };
+              };
+            };
+          } & {
+            use: any[];
+          };
+          path: "/email-otp/send-verification-otp";
+        };
+      };
+      hooks: {
+        after: {
+          matcher(context: better_auth52.HookEndpointContext): boolean;
+          handler: (inputContext: better_auth52.MiddlewareInputContext<better_auth52.MiddlewareOptions>) => Promise<void>;
+        }[];
+      };
+      $ERROR_CODES: {
+        readonly OTP_EXPIRED: "otp expired";
+        readonly INVALID_OTP: "Invalid OTP";
+        readonly INVALID_EMAIL: "Invalid email";
+        readonly USER_NOT_FOUND: "User not found";
+        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;
+      })[];
+    }];
+  }>;
+  resend: Resend;
+  blob: S3Client;
+}>;
+//#endregion
+export { GetTulipParams, GetTulipReturn, getTulip };
+//# sourceMappingURL=resolve.server.d.ts.map