@tulip-systems/core 0.2.0

package/dist/modules/config/router/init.server.d.ts

@@ -0,0 +1,2125 @@
+import { Permission } from "../../auth/lib/permissions.js";
+import { TDatabaseSchema } from "../db/types.js";
+import { PathConfig } from "../paths/types.js";
+import { ProtectedRPCContext, RPCContext } from "./context.server.js";
+import "server-cli-only";
+import * as _orpc_server27 from "@orpc/server";
+import * as zod239 from "zod";
+import * as better_auth258 from "better-auth";
+import * as better_auth_plugins51 from "better-auth/plugins";
+import * as drizzle_orm_postgres_js1 from "drizzle-orm/postgres-js";
+import * as _aws_sdk_client_s30 from "@aws-sdk/client-s3";
+import * as resend0 from "resend";
+import * as next_dist_server_web_spec_extension_adapters_headers0 from "next/dist/server/web/spec-extension/adapters/headers";
+import * as _orpc_contract2 from "@orpc/contract";
+
+//#region src/modules/config/router/init.server.d.ts
+/**
+ * Initialize TRPC
+ */
+declare function initRPC<TSchema extends TDatabaseSchema>(): {
+  publicProcedure: _orpc_server27.Builder<RPCContext<TSchema> & Record<never, never>, RPCContext<TSchema>, _orpc_contract2.Schema<unknown, unknown>, _orpc_contract2.Schema<unknown, unknown>, Record<never, never>, Record<never, never>>;
+  protectedProcedure: _orpc_server27.BuilderWithMiddlewares<_orpc_server27.MergedInitialContext<RPCContext<TSchema> & Record<never, never>, RPCContext<TSchema> & Record<never, never>, RPCContext<TSchema>>, _orpc_server27.MergedCurrentContext<RPCContext<TSchema>, ProtectedRPCContext<TSchema>>, _orpc_contract2.Schema<unknown, unknown>, _orpc_contract2.Schema<unknown, unknown>, Record<never, never>, Record<never, never>>;
+  authMiddleware: _orpc_server27.DecoratedMiddleware<RPCContext<TSchema> & Record<never, never>, ProtectedRPCContext<TSchema>, unknown, any, any, Record<never, never>>;
+  permissionMiddleware: (permission: Permission) => _orpc_server27.DecoratedMiddleware<{
+    session: {
+      session: {
+        id: string;
+        createdAt: Date;
+        updatedAt: Date;
+        userId: string;
+        expiresAt: Date;
+        token: string;
+        ipAddress?: string | null | undefined | undefined;
+        userAgent?: string | null | undefined | undefined;
+        impersonatedBy?: string | null | undefined;
+      };
+      user: {
+        id: string;
+        createdAt: Date;
+        updatedAt: Date;
+        email: string;
+        emailVerified: boolean;
+        name: string;
+        image?: string | null | undefined | undefined;
+        firstName: string;
+        lastName: string;
+        banned: boolean | null | undefined;
+        role?: string | null | undefined;
+        banReason?: string | null | undefined;
+        banExpires?: Date | null | undefined;
+      };
+    } | null;
+    headers: next_dist_server_web_spec_extension_adapters_headers0.ReadonlyHeaders;
+    general: {
+      name: string;
+      shortName: string;
+    };
+    paths: PathConfig<TSchema>;
+    schema: TSchema;
+    db: drizzle_orm_postgres_js1.PostgresJsDatabase<TSchema>;
+    auth: better_auth258.Auth<{
+      database: (options: better_auth258.BetterAuthOptions) => better_auth258.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_auth258.HookEndpointContext): true;
+            handler: (inputContext: better_auth258.MiddlewareInputContext<better_auth258.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_auth258.GenericEndpointContext | undefined): Promise<void>;
+                };
+              };
+            };
+          };
+        };
+        hooks: {
+          after: {
+            matcher(context: better_auth258.HookEndpointContext): boolean;
+            handler: (inputContext: better_auth258.MiddlewareInputContext<better_auth258.MiddlewareOptions>) => Promise<better_auth_plugins51.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_auth258.Middleware[];
+              path?: string;
+            } & {
+              asResponse?: AsResponse | undefined;
+              returnHeaders?: ReturnHeaders | undefined;
+            }): Promise<[AsResponse] extends [true] ? Response : [ReturnHeaders] extends [true] ? {
+              headers: Headers;
+              response: {
+                user: better_auth_plugins51.UserWithRole;
+              };
+            } : {
+              user: better_auth_plugins51.UserWithRole;
+            }>;
+            options: {
+              method: "POST";
+              body: zod239.ZodObject<{
+                userId: zod239.ZodCoercedString<unknown>;
+                role: zod239.ZodUnion<readonly [zod239.ZodString, zod239.ZodArray<zod239.ZodString>]>;
+              }, better_auth258.$strip>;
+              requireHeaders: true;
+              use: ((inputContext: better_auth258.MiddlewareInputContext<better_auth258.MiddlewareOptions>) => Promise<{
+                session: {
+                  user: better_auth_plugins51.UserWithRole;
+                  session: better_auth258.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 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_auth258.Middleware[];
+              path?: string;
+            } & {
+              asResponse?: AsResponse | undefined;
+              returnHeaders?: ReturnHeaders | undefined;
+            }): Promise<[AsResponse] extends [true] ? Response : [ReturnHeaders] 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: zod239.ZodObject<{
+                id: zod239.ZodString;
+              }, better_auth258.$strip>;
+              use: ((inputContext: better_auth258.MiddlewareInputContext<better_auth258.MiddlewareOptions>) => Promise<{
+                session: {
+                  user: better_auth_plugins51.UserWithRole;
+                  session: better_auth258.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 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_auth258.Middleware[];
+              path?: string;
+            } & {
+              asResponse?: AsResponse | undefined;
+              returnHeaders?: ReturnHeaders | undefined;
+            }): Promise<[AsResponse] extends [true] ? Response : [ReturnHeaders] extends [true] ? {
+              headers: Headers;
+              response: {
+                user: better_auth_plugins51.UserWithRole;
+              };
+            } : {
+              user: better_auth_plugins51.UserWithRole;
+            }>;
+            options: {
+              method: "POST";
+              body: zod239.ZodObject<{
+                email: zod239.ZodString;
+                password: zod239.ZodString;
+                name: zod239.ZodString;
+                role: zod239.ZodOptional<zod239.ZodUnion<readonly [zod239.ZodString, zod239.ZodArray<zod239.ZodString>]>>;
+                data: zod239.ZodOptional<zod239.ZodRecord<zod239.ZodString, zod239.ZodAny>>;
+              }, better_auth258.$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 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_auth258.Middleware[];
+              path?: string;
+            } & {
+              asResponse?: AsResponse | undefined;
+              returnHeaders?: ReturnHeaders | undefined;
+            }): Promise<[AsResponse] extends [true] ? Response : [ReturnHeaders] extends [true] ? {
+              headers: Headers;
+              response: better_auth_plugins51.UserWithRole;
+            } : better_auth_plugins51.UserWithRole>;
+            options: {
+              method: "POST";
+              body: zod239.ZodObject<{
+                userId: zod239.ZodCoercedString<unknown>;
+                data: zod239.ZodRecord<zod239.ZodAny, zod239.ZodAny>;
+              }, better_auth258.$strip>;
+              use: ((inputContext: better_auth258.MiddlewareInputContext<better_auth258.MiddlewareOptions>) => Promise<{
+                session: {
+                  user: better_auth_plugins51.UserWithRole;
+                  session: better_auth258.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 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_auth258.Middleware[];
+              path?: string;
+            } & {
+              asResponse?: AsResponse | undefined;
+              returnHeaders?: ReturnHeaders | undefined;
+            }): Promise<[AsResponse] extends [true] ? Response : [ReturnHeaders] extends [true] ? {
+              headers: Headers;
+              response: {
+                users: better_auth_plugins51.UserWithRole[];
+                total: number;
+                limit: number | undefined;
+                offset: number | undefined;
+              } | {
+                users: never[];
+                total: number;
+              };
+            } : {
+              users: better_auth_plugins51.UserWithRole[];
+              total: number;
+              limit: number | undefined;
+              offset: number | undefined;
+            } | {
+              users: never[];
+              total: number;
+            }>;
+            options: {
+              method: "GET";
+              use: ((inputContext: better_auth258.MiddlewareInputContext<better_auth258.MiddlewareOptions>) => Promise<{
+                session: {
+                  user: better_auth_plugins51.UserWithRole;
+                  session: better_auth258.Session;
+                };
+              }>)[];
+              query: zod239.ZodObject<{
+                searchValue: zod239.ZodOptional<zod239.ZodString>;
+                searchField: zod239.ZodOptional<zod239.ZodEnum<{
+                  name: "name";
+                  email: "email";
+                }>>;
+                searchOperator: zod239.ZodOptional<zod239.ZodEnum<{
+                  contains: "contains";
+                  starts_with: "starts_with";
+                  ends_with: "ends_with";
+                }>>;
+                limit: zod239.ZodOptional<zod239.ZodUnion<[zod239.ZodString, zod239.ZodNumber]>>;
+                offset: zod239.ZodOptional<zod239.ZodUnion<[zod239.ZodString, zod239.ZodNumber]>>;
+                sortBy: zod239.ZodOptional<zod239.ZodString>;
+                sortDirection: zod239.ZodOptional<zod239.ZodEnum<{
+                  asc: "asc";
+                  desc: "desc";
+                }>>;
+                filterField: zod239.ZodOptional<zod239.ZodString>;
+                filterValue: zod239.ZodOptional<zod239.ZodUnion<[zod239.ZodUnion<[zod239.ZodString, zod239.ZodNumber]>, zod239.ZodBoolean]>>;
+                filterOperator: zod239.ZodOptional<zod239.ZodEnum<{
+                  eq: "eq";
+                  ne: "ne";
+                  lt: "lt";
+                  lte: "lte";
+                  gt: "gt";
+                  gte: "gte";
+                  contains: "contains";
+                }>>;
+              }, better_auth258.$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 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_auth258.Middleware[];
+              path?: string;
+            } & {
+              asResponse?: AsResponse | undefined;
+              returnHeaders?: ReturnHeaders | undefined;
+            }): Promise<[AsResponse] extends [true] ? Response : [ReturnHeaders] extends [true] ? {
+              headers: Headers;
+              response: {
+                sessions: better_auth_plugins51.SessionWithImpersonatedBy[];
+              };
+            } : {
+              sessions: better_auth_plugins51.SessionWithImpersonatedBy[];
+            }>;
+            options: {
+              method: "POST";
+              use: ((inputContext: better_auth258.MiddlewareInputContext<better_auth258.MiddlewareOptions>) => Promise<{
+                session: {
+                  user: better_auth_plugins51.UserWithRole;
+                  session: better_auth258.Session;
+                };
+              }>)[];
+              body: zod239.ZodObject<{
+                userId: zod239.ZodCoercedString<unknown>;
+              }, better_auth258.$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 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_auth258.Middleware[];
+              path?: string;
+            } & {
+              asResponse?: AsResponse | undefined;
+              returnHeaders?: ReturnHeaders | undefined;
+            }): Promise<[AsResponse] extends [true] ? Response : [ReturnHeaders] extends [true] ? {
+              headers: Headers;
+              response: {
+                user: any;
+              };
+            } : {
+              user: any;
+            }>;
+            options: {
+              method: "POST";
+              body: zod239.ZodObject<{
+                userId: zod239.ZodCoercedString<unknown>;
+              }, better_auth258.$strip>;
+              use: ((inputContext: better_auth258.MiddlewareInputContext<better_auth258.MiddlewareOptions>) => Promise<{
+                session: {
+                  user: better_auth_plugins51.UserWithRole;
+                  session: better_auth258.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 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_auth258.Middleware[];
+              path?: string;
+            } & {
+              asResponse?: AsResponse | undefined;
+              returnHeaders?: ReturnHeaders | undefined;
+            }): Promise<[AsResponse] extends [true] ? Response : [ReturnHeaders] extends [true] ? {
+              headers: Headers;
+              response: {
+                user: any;
+              };
+            } : {
+              user: any;
+            }>;
+            options: {
+              method: "POST";
+              body: zod239.ZodObject<{
+                userId: zod239.ZodCoercedString<unknown>;
+                banReason: zod239.ZodOptional<zod239.ZodString>;
+                banExpiresIn: zod239.ZodOptional<zod239.ZodNumber>;
+              }, better_auth258.$strip>;
+              use: ((inputContext: better_auth258.MiddlewareInputContext<better_auth258.MiddlewareOptions>) => Promise<{
+                session: {
+                  user: better_auth_plugins51.UserWithRole;
+                  session: better_auth258.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 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_auth258.Middleware[];
+              path?: string;
+            } & {
+              asResponse?: AsResponse | undefined;
+              returnHeaders?: ReturnHeaders | undefined;
+            }): Promise<[AsResponse] extends [true] ? Response : [ReturnHeaders] 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: zod239.ZodObject<{
+                userId: zod239.ZodCoercedString<unknown>;
+              }, better_auth258.$strip>;
+              use: ((inputContext: better_auth258.MiddlewareInputContext<better_auth258.MiddlewareOptions>) => Promise<{
+                session: {
+                  user: better_auth_plugins51.UserWithRole;
+                  session: better_auth258.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 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_auth258.Middleware[];
+              path?: string;
+            } & {
+              asResponse?: AsResponse | undefined;
+              returnHeaders?: ReturnHeaders | undefined;
+            }): Promise<[AsResponse] extends [true] ? Response : [ReturnHeaders] extends [true] ? {
+              headers: Headers;
+              response: {
+                session: better_auth258.Session & Record<string, any>;
+                user: packages_core_dist_db.User & Record<string, any>;
+              };
+            } : {
+              session: better_auth258.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 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_auth258.Middleware[];
+              path?: string;
+            } & {
+              asResponse?: AsResponse | undefined;
+              returnHeaders?: ReturnHeaders | undefined;
+            }): Promise<[AsResponse] extends [true] ? Response : [ReturnHeaders] extends [true] ? {
+              headers: Headers;
+              response: {
+                success: boolean;
+              };
+            } : {
+              success: boolean;
+            }>;
+            options: {
+              method: "POST";
+              body: zod239.ZodObject<{
+                sessionToken: zod239.ZodString;
+              }, better_auth258.$strip>;
+              use: ((inputContext: better_auth258.MiddlewareInputContext<better_auth258.MiddlewareOptions>) => Promise<{
+                session: {
+                  user: better_auth_plugins51.UserWithRole;
+                  session: better_auth258.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 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_auth258.Middleware[];
+              path?: string;
+            } & {
+              asResponse?: AsResponse | undefined;
+              returnHeaders?: ReturnHeaders | undefined;
+            }): Promise<[AsResponse] extends [true] ? Response : [ReturnHeaders] extends [true] ? {
+              headers: Headers;
+              response: {
+                success: boolean;
+              };
+            } : {
+              success: boolean;
+            }>;
+            options: {
+              method: "POST";
+              body: zod239.ZodObject<{
+                userId: zod239.ZodCoercedString<unknown>;
+              }, better_auth258.$strip>;
+              use: ((inputContext: better_auth258.MiddlewareInputContext<better_auth258.MiddlewareOptions>) => Promise<{
+                session: {
+                  user: better_auth_plugins51.UserWithRole;
+                  session: better_auth258.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 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_auth258.Middleware[];
+              path?: string;
+            } & {
+              asResponse?: AsResponse | undefined;
+              returnHeaders?: ReturnHeaders | undefined;
+            }): Promise<[AsResponse] extends [true] ? Response : [ReturnHeaders] extends [true] ? {
+              headers: Headers;
+              response: {
+                success: boolean;
+              };
+            } : {
+              success: boolean;
+            }>;
+            options: {
+              method: "POST";
+              body: zod239.ZodObject<{
+                userId: zod239.ZodCoercedString<unknown>;
+              }, better_auth258.$strip>;
+              use: ((inputContext: better_auth258.MiddlewareInputContext<better_auth258.MiddlewareOptions>) => Promise<{
+                session: {
+                  user: better_auth_plugins51.UserWithRole;
+                  session: better_auth258.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 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_auth258.Middleware[];
+              path?: string;
+            } & {
+              asResponse?: AsResponse | undefined;
+              returnHeaders?: ReturnHeaders | undefined;
+            }): Promise<[AsResponse] extends [true] ? Response : [ReturnHeaders] extends [true] ? {
+              headers: Headers;
+              response: {
+                status: boolean;
+              };
+            } : {
+              status: boolean;
+            }>;
+            options: {
+              method: "POST";
+              body: zod239.ZodObject<{
+                newPassword: zod239.ZodString;
+                userId: zod239.ZodCoercedString<unknown>;
+              }, better_auth258.$strip>;
+              use: ((inputContext: better_auth258.MiddlewareInputContext<better_auth258.MiddlewareOptions>) => Promise<{
+                session: {
+                  user: better_auth_plugins51.UserWithRole;
+                  session: better_auth258.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 extends boolean = false>(inputCtx_0: {
+              body: ({
+                permission: {
+                  readonly [x: string]: better_auth258.LiteralString[] | undefined;
+                };
+                permissions?: never;
+              } | {
+                permissions: {
+                  readonly [x: string]: better_auth258.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_auth258.Middleware[];
+              path?: string;
+            } & {
+              asResponse?: AsResponse | undefined;
+              returnHeaders?: ReturnHeaders | undefined;
+            }): Promise<[AsResponse] extends [true] ? Response : [ReturnHeaders] extends [true] ? {
+              headers: Headers;
+              response: {
+                error: null;
+                success: boolean;
+              };
+            } : {
+              error: null;
+              success: boolean;
+            }>;
+            options: {
+              method: "POST";
+              body: zod239.ZodIntersection<zod239.ZodObject<{
+                userId: zod239.ZodOptional<zod239.ZodCoercedString<unknown>>;
+                role: zod239.ZodOptional<zod239.ZodString>;
+              }, better_auth258.$strip>, zod239.ZodUnion<readonly [zod239.ZodObject<{
+                permission: zod239.ZodRecord<zod239.ZodString, zod239.ZodArray<zod239.ZodString>>;
+                permissions: zod239.ZodUndefined;
+              }, better_auth258.$strip>, zod239.ZodObject<{
+                permission: zod239.ZodUndefined;
+                permissions: zod239.ZodRecord<zod239.ZodString, zod239.ZodArray<zod239.ZodString>>;
+              }, better_auth258.$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_auth258.LiteralString[] | undefined;
+                    };
+                    permissions?: never;
+                  } | {
+                    permissions: {
+                      readonly [x: string]: better_auth258.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_auth258.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 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_auth258.Middleware[];
+              path?: string;
+            } & {
+              asResponse?: AsResponse | undefined;
+              returnHeaders?: ReturnHeaders | undefined;
+            }): Promise<[AsResponse] extends [true] ? Response : [ReturnHeaders] extends [true] ? {
+              headers: Headers;
+              response: string;
+            } : string>;
+            options: {
+              method: "POST";
+              body: zod239.ZodObject<{
+                email: zod239.ZodString;
+                type: zod239.ZodEnum<{
+                  "sign-in": "sign-in";
+                  "forget-password": "forget-password";
+                  "email-verification": "email-verification";
+                }>;
+              }, better_auth258.$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 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_auth258.Middleware[];
+              path?: string;
+            } & {
+              asResponse?: AsResponse | undefined;
+              returnHeaders?: ReturnHeaders | undefined;
+            }): Promise<[AsResponse] extends [true] ? Response : [ReturnHeaders] extends [true] ? {
+              headers: Headers;
+              response: {
+                otp: null;
+              } | {
+                otp: string;
+              };
+            } : {
+              otp: null;
+            } | {
+              otp: string;
+            }>;
+            options: {
+              method: "GET";
+              query: zod239.ZodObject<{
+                email: zod239.ZodString;
+                type: zod239.ZodEnum<{
+                  "sign-in": "sign-in";
+                  "forget-password": "forget-password";
+                  "email-verification": "email-verification";
+                }>;
+              }, better_auth258.$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 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_auth258.Middleware[];
+              path?: string;
+            } & {
+              asResponse?: AsResponse | undefined;
+              returnHeaders?: ReturnHeaders | undefined;
+            }): Promise<[AsResponse] extends [true] ? Response : [ReturnHeaders] extends [true] ? {
+              headers: Headers;
+              response: {
+                success: boolean;
+              };
+            } : {
+              success: boolean;
+            }>;
+            options: {
+              method: "POST";
+              body: zod239.ZodObject<{
+                email: zod239.ZodString;
+                type: zod239.ZodEnum<{
+                  "sign-in": "sign-in";
+                  "forget-password": "forget-password";
+                  "email-verification": "email-verification";
+                }>;
+                otp: zod239.ZodString;
+              }, better_auth258.$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 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_auth258.Middleware[];
+              path?: string;
+            } & {
+              asResponse?: AsResponse | undefined;
+              returnHeaders?: ReturnHeaders | undefined;
+            }): Promise<[AsResponse] extends [true] ? Response : [ReturnHeaders] 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: zod239.ZodObject<{
+                email: zod239.ZodString;
+                otp: zod239.ZodString;
+              }, better_auth258.$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 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_auth258.Middleware[];
+              path?: string;
+            } & {
+              asResponse?: AsResponse | undefined;
+              returnHeaders?: ReturnHeaders | undefined;
+            }): Promise<[AsResponse] extends [true] ? Response : [ReturnHeaders] 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: zod239.ZodObject<{
+                email: zod239.ZodString;
+                otp: zod239.ZodString;
+              }, better_auth258.$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 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_auth258.Middleware[];
+              path?: string;
+            } & {
+              asResponse?: AsResponse | undefined;
+              returnHeaders?: ReturnHeaders | undefined;
+            }): Promise<[AsResponse] extends [true] ? Response : [ReturnHeaders] extends [true] ? {
+              headers: Headers;
+              response: {
+                success: boolean;
+              };
+            } : {
+              success: boolean;
+            }>;
+            options: {
+              method: "POST";
+              body: zod239.ZodObject<{
+                email: zod239.ZodString;
+              }, better_auth258.$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 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_auth258.Middleware[];
+              path?: string;
+            } & {
+              asResponse?: AsResponse | undefined;
+              returnHeaders?: ReturnHeaders | undefined;
+            }): Promise<[AsResponse] extends [true] ? Response : [ReturnHeaders] extends [true] ? {
+              headers: Headers;
+              response: {
+                success: boolean;
+              };
+            } : {
+              success: boolean;
+            }>;
+            options: {
+              method: "POST";
+              body: zod239.ZodObject<{
+                email: zod239.ZodString;
+                otp: zod239.ZodString;
+                password: zod239.ZodString;
+              }, better_auth258.$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 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_auth258.Middleware[];
+              path?: string;
+            } & {
+              asResponse?: AsResponse | undefined;
+              returnHeaders?: ReturnHeaders | undefined;
+            }): Promise<[AsResponse] extends [true] ? Response : [ReturnHeaders] extends [true] ? {
+              headers: Headers;
+              response: {
+                success: boolean;
+              };
+            } : {
+              success: boolean;
+            }>;
+            options: {
+              method: "POST";
+              body: zod239.ZodObject<{
+                email: zod239.ZodString;
+                type: zod239.ZodEnum<{
+                  "sign-in": "sign-in";
+                  "forget-password": "forget-password";
+                  "email-verification": "email-verification";
+                }>;
+              }, better_auth258.$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_auth258.HookEndpointContext): boolean;
+            handler: (inputContext: better_auth258.MiddlewareInputContext<better_auth258.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: resend0.Resend;
+    blob: _aws_sdk_client_s30.S3Client;
+  } & {
+    session: {
+      session: {
+        id: string;
+        createdAt: Date;
+        updatedAt: Date;
+        userId: string;
+        expiresAt: Date;
+        token: string;
+        ipAddress?: string | null | undefined | undefined;
+        userAgent?: string | null | undefined | undefined;
+        impersonatedBy?: string | null | undefined;
+      };
+      user: {
+        id: string;
+        createdAt: Date;
+        updatedAt: Date;
+        email: string;
+        emailVerified: boolean;
+        name: string;
+        image?: string | null | undefined | undefined;
+        firstName: string;
+        lastName: string;
+        banned: boolean | null | undefined;
+        role?: string | null | undefined;
+        banReason?: string | null | undefined;
+        banExpires?: Date | null | undefined;
+      };
+    };
+  } & Record<never, never>, ProtectedRPCContext<TSchema>, unknown, any, any, Record<never, never>>;
+};
+//#endregion
+export { initRPC };
+//# sourceMappingURL=init.server.d.ts.map