@monkeyplus/payscope 1.0.0

package/dist/server/router.d.mts

@@ -0,0 +1,1218 @@
+import { Database, Store } from "../_chunks/db.mjs";
+import { Payment } from "../_chunks/index.mjs";
+import { MiddlewareInputContext, MiddlewareOptions, StrictEndpoint } from "../_chunks/libs/better-call.mjs";
+import { H3, H3Event } from "h3";
+interface OptionsAccount$2 {
+  path: (...params: string[]) => string;
+  storeId: number;
+}
+declare function useUser(event: H3Event): {
+  id: string;
+  email: string;
+};
+declare function registerAccount(app: H3, db: Database, {
+  path,
+  storeId
+}: OptionsAccount$2): void;
+declare const _auth: import("better-auth").Auth<{
+  plugins: [{
+    id: "admin";
+    version: string;
+    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: import("better-auth").GenericEndpointContext | null): Promise<void>;
+            };
+          };
+        };
+      };
+    };
+    hooks: {
+      after: {
+        matcher(context: import("better-auth").HookEndpointContext): boolean;
+        handler: (inputContext: MiddlewareInputContext<MiddlewareOptions>) => Promise<import("better-auth/plugins").SessionWithImpersonatedBy[] | undefined>;
+      }[];
+    };
+    endpoints: {
+      setRole: StrictEndpoint<"/admin/set-role", {
+        method: "POST";
+        body: import("zod").ZodObject<{
+          userId: import("zod").ZodCoercedString<unknown>;
+          role: import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodArray<import("zod").ZodString>]>;
+        }, import("zod/v4/core").$strip>;
+        requireHeaders: true;
+        use: ((inputContext: MiddlewareInputContext<MiddlewareOptions>) => Promise<{
+          session: {
+            user: import("better-auth/plugins").UserWithRole;
+            session: {
+              id: string;
+              createdAt: Date;
+              updatedAt: Date;
+              userId: string;
+              expiresAt: Date;
+              token: string;
+              ipAddress?: string | null | undefined;
+              userAgent?: string | null | undefined;
+            };
+          };
+        }>)[];
+        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: "admin" | "user" | ("admin" | "user")[];
+            };
+          };
+        };
+      }, {
+        user: import("better-auth/plugins").UserWithRole;
+      }>;
+      getUser: StrictEndpoint<"/admin/get-user", {
+        method: "GET";
+        query: import("zod").ZodObject<{
+          id: import("zod").ZodString;
+        }, import("zod/v4/core").$strip>;
+        use: ((inputContext: MiddlewareInputContext<MiddlewareOptions>) => Promise<{
+          session: {
+            user: import("better-auth/plugins").UserWithRole;
+            session: {
+              id: string;
+              createdAt: Date;
+              updatedAt: Date;
+              userId: string;
+              expiresAt: Date;
+              token: string;
+              ipAddress?: string | null | undefined;
+              userAgent?: string | null | undefined;
+            };
+          };
+        }>)[];
+        metadata: {
+          openapi: {
+            operationId: string;
+            summary: string;
+            description: string;
+            responses: {
+              200: {
+                description: string;
+                content: {
+                  "application/json": {
+                    schema: {
+                      type: "object";
+                      properties: {
+                        user: {
+                          $ref: string;
+                        };
+                      };
+                    };
+                  };
+                };
+              };
+            };
+          };
+        };
+      }, import("better-auth/plugins").UserWithRole>;
+      createUser: StrictEndpoint<"/admin/create-user", {
+        method: "POST";
+        body: import("zod").ZodObject<{
+          email: import("zod").ZodString;
+          password: import("zod").ZodOptional<import("zod").ZodString>;
+          name: import("zod").ZodString;
+          role: import("zod").ZodOptional<import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodArray<import("zod").ZodString>]>>;
+          data: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodAny>>;
+        }, import("zod/v4/core").$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 | undefined;
+              name: string;
+              role?: "admin" | "user" | ("admin" | "user")[];
+              data?: Record<string, any> | undefined;
+            };
+          };
+        };
+      }, {
+        user: import("better-auth/plugins").UserWithRole;
+      }>;
+      adminUpdateUser: StrictEndpoint<"/admin/update-user", {
+        method: "POST";
+        body: import("zod").ZodObject<{
+          userId: import("zod").ZodCoercedString<unknown>;
+          data: import("zod").ZodRecord<import("zod").ZodAny, import("zod").ZodAny>;
+        }, import("zod/v4/core").$strip>;
+        use: ((inputContext: MiddlewareInputContext<MiddlewareOptions>) => Promise<{
+          session: {
+            user: import("better-auth/plugins").UserWithRole;
+            session: {
+              id: string;
+              createdAt: Date;
+              updatedAt: Date;
+              userId: string;
+              expiresAt: Date;
+              token: string;
+              ipAddress?: string | null | undefined;
+              userAgent?: string | null | undefined;
+            };
+          };
+        }>)[];
+        metadata: {
+          openapi: {
+            operationId: string;
+            summary: string;
+            description: string;
+            responses: {
+              200: {
+                description: string;
+                content: {
+                  "application/json": {
+                    schema: {
+                      type: "object";
+                      properties: {
+                        user: {
+                          $ref: string;
+                        };
+                      };
+                    };
+                  };
+                };
+              };
+            };
+          };
+        };
+      }, import("better-auth/plugins").UserWithRole>;
+      listUsers: StrictEndpoint<"/admin/list-users", {
+        method: "GET";
+        use: ((inputContext: MiddlewareInputContext<MiddlewareOptions>) => Promise<{
+          session: {
+            user: import("better-auth/plugins").UserWithRole;
+            session: {
+              id: string;
+              createdAt: Date;
+              updatedAt: Date;
+              userId: string;
+              expiresAt: Date;
+              token: string;
+              ipAddress?: string | null | undefined;
+              userAgent?: string | null | undefined;
+            };
+          };
+        }>)[];
+        query: import("zod").ZodObject<{
+          searchValue: import("zod").ZodOptional<import("zod").ZodString>;
+          searchField: import("zod").ZodOptional<import("zod").ZodEnum<{
+            email: "email";
+            name: "name";
+          }>>;
+          searchOperator: import("zod").ZodOptional<import("zod").ZodEnum<{
+            contains: "contains";
+            starts_with: "starts_with";
+            ends_with: "ends_with";
+          }>>;
+          limit: import("zod").ZodOptional<import("zod").ZodUnion<[import("zod").ZodString, import("zod").ZodNumber]>>;
+          offset: import("zod").ZodOptional<import("zod").ZodUnion<[import("zod").ZodString, import("zod").ZodNumber]>>;
+          sortBy: import("zod").ZodOptional<import("zod").ZodString>;
+          sortDirection: import("zod").ZodOptional<import("zod").ZodEnum<{
+            asc: "asc";
+            desc: "desc";
+          }>>;
+          filterField: import("zod").ZodOptional<import("zod").ZodString>;
+          filterValue: import("zod").ZodOptional<import("zod").ZodUnion<[import("zod").ZodUnion<[import("zod").ZodUnion<[import("zod").ZodUnion<[import("zod").ZodString, import("zod").ZodNumber]>, import("zod").ZodBoolean]>, import("zod").ZodArray<import("zod").ZodString>]>, import("zod").ZodArray<import("zod").ZodNumber>]>>;
+          filterOperator: import("zod").ZodOptional<import("zod").ZodEnum<{
+            eq: "eq";
+            ne: "ne";
+            gt: "gt";
+            gte: "gte";
+            lt: "lt";
+            lte: "lte";
+            in: "in";
+            not_in: "not_in";
+            contains: "contains";
+            starts_with: "starts_with";
+            ends_with: "ends_with";
+          }>>;
+        }, import("zod/v4/core").$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[];
+                    };
+                  };
+                };
+              };
+            };
+          };
+        };
+      }, {
+        users: import("better-auth/plugins").UserWithRole[];
+        total: number;
+      }>;
+      listUserSessions: StrictEndpoint<"/admin/list-user-sessions", {
+        method: "POST";
+        use: ((inputContext: MiddlewareInputContext<MiddlewareOptions>) => Promise<{
+          session: {
+            user: import("better-auth/plugins").UserWithRole;
+            session: {
+              id: string;
+              createdAt: Date;
+              updatedAt: Date;
+              userId: string;
+              expiresAt: Date;
+              token: string;
+              ipAddress?: string | null | undefined;
+              userAgent?: string | null | undefined;
+            };
+          };
+        }>)[];
+        body: import("zod").ZodObject<{
+          userId: import("zod").ZodCoercedString<unknown>;
+        }, import("zod/v4/core").$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;
+                          };
+                        };
+                      };
+                    };
+                  };
+                };
+              };
+            };
+          };
+        };
+      }, {
+        sessions: import("better-auth/plugins").SessionWithImpersonatedBy[];
+      }>;
+      unbanUser: StrictEndpoint<"/admin/unban-user", {
+        method: "POST";
+        body: import("zod").ZodObject<{
+          userId: import("zod").ZodCoercedString<unknown>;
+        }, import("zod/v4/core").$strip>;
+        use: ((inputContext: MiddlewareInputContext<MiddlewareOptions>) => Promise<{
+          session: {
+            user: import("better-auth/plugins").UserWithRole;
+            session: {
+              id: string;
+              createdAt: Date;
+              updatedAt: Date;
+              userId: string;
+              expiresAt: Date;
+              token: string;
+              ipAddress?: string | null | undefined;
+              userAgent?: string | null | undefined;
+            };
+          };
+        }>)[];
+        metadata: {
+          openapi: {
+            operationId: string;
+            summary: string;
+            description: string;
+            responses: {
+              200: {
+                description: string;
+                content: {
+                  "application/json": {
+                    schema: {
+                      type: "object";
+                      properties: {
+                        user: {
+                          $ref: string;
+                        };
+                      };
+                    };
+                  };
+                };
+              };
+            };
+          };
+        };
+      }, {
+        user: import("better-auth/plugins").UserWithRole;
+      }>;
+      banUser: StrictEndpoint<"/admin/ban-user", {
+        method: "POST";
+        body: import("zod").ZodObject<{
+          userId: import("zod").ZodCoercedString<unknown>;
+          banReason: import("zod").ZodOptional<import("zod").ZodString>;
+          banExpiresIn: import("zod").ZodOptional<import("zod").ZodNumber>;
+        }, import("zod/v4/core").$strip>;
+        use: ((inputContext: MiddlewareInputContext<MiddlewareOptions>) => Promise<{
+          session: {
+            user: import("better-auth/plugins").UserWithRole;
+            session: {
+              id: string;
+              createdAt: Date;
+              updatedAt: Date;
+              userId: string;
+              expiresAt: Date;
+              token: string;
+              ipAddress?: string | null | undefined;
+              userAgent?: string | null | undefined;
+            };
+          };
+        }>)[];
+        metadata: {
+          openapi: {
+            operationId: string;
+            summary: string;
+            description: string;
+            responses: {
+              200: {
+                description: string;
+                content: {
+                  "application/json": {
+                    schema: {
+                      type: "object";
+                      properties: {
+                        user: {
+                          $ref: string;
+                        };
+                      };
+                    };
+                  };
+                };
+              };
+            };
+          };
+        };
+      }, {
+        user: import("better-auth/plugins").UserWithRole;
+      }>;
+      impersonateUser: StrictEndpoint<"/admin/impersonate-user", {
+        method: "POST";
+        body: import("zod").ZodObject<{
+          userId: import("zod").ZodCoercedString<unknown>;
+        }, import("zod/v4/core").$strip>;
+        use: ((inputContext: MiddlewareInputContext<MiddlewareOptions>) => Promise<{
+          session: {
+            user: import("better-auth/plugins").UserWithRole;
+            session: {
+              id: string;
+              createdAt: Date;
+              updatedAt: Date;
+              userId: string;
+              expiresAt: Date;
+              token: string;
+              ipAddress?: string | null | undefined;
+              userAgent?: string | null | undefined;
+            };
+          };
+        }>)[];
+        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;
+                        };
+                      };
+                    };
+                  };
+                };
+              };
+            };
+          };
+        };
+      }, {
+        session: {
+          id: string;
+          createdAt: Date;
+          updatedAt: Date;
+          userId: string;
+          expiresAt: Date;
+          token: string;
+          ipAddress?: string | null | undefined;
+          userAgent?: string | null | undefined;
+        };
+        user: import("better-auth/plugins").UserWithRole;
+      }>;
+      stopImpersonating: StrictEndpoint<"/admin/stop-impersonating", {
+        method: "POST";
+        requireHeaders: true;
+      }, {
+        session: {
+          id: string;
+          createdAt: Date;
+          updatedAt: Date;
+          userId: string;
+          expiresAt: Date;
+          token: string;
+          ipAddress?: string | null | undefined;
+          userAgent?: string | null | undefined;
+        } & Record<string, any>;
+        user: {
+          id: string;
+          createdAt: Date;
+          updatedAt: Date;
+          email: string;
+          emailVerified: boolean;
+          name: string;
+          image?: string | null | undefined;
+        } & Record<string, any>;
+      }>;
+      revokeUserSession: StrictEndpoint<"/admin/revoke-user-session", {
+        method: "POST";
+        body: import("zod").ZodObject<{
+          sessionToken: import("zod").ZodString;
+        }, import("zod/v4/core").$strip>;
+        use: ((inputContext: MiddlewareInputContext<MiddlewareOptions>) => Promise<{
+          session: {
+            user: import("better-auth/plugins").UserWithRole;
+            session: {
+              id: string;
+              createdAt: Date;
+              updatedAt: Date;
+              userId: string;
+              expiresAt: Date;
+              token: string;
+              ipAddress?: string | null | undefined;
+              userAgent?: string | null | undefined;
+            };
+          };
+        }>)[];
+        metadata: {
+          openapi: {
+            operationId: string;
+            summary: string;
+            description: string;
+            responses: {
+              200: {
+                description: string;
+                content: {
+                  "application/json": {
+                    schema: {
+                      type: "object";
+                      properties: {
+                        success: {
+                          type: string;
+                        };
+                      };
+                    };
+                  };
+                };
+              };
+            };
+          };
+        };
+      }, {
+        success: boolean;
+      }>;
+      revokeUserSessions: StrictEndpoint<"/admin/revoke-user-sessions", {
+        method: "POST";
+        body: import("zod").ZodObject<{
+          userId: import("zod").ZodCoercedString<unknown>;
+        }, import("zod/v4/core").$strip>;
+        use: ((inputContext: MiddlewareInputContext<MiddlewareOptions>) => Promise<{
+          session: {
+            user: import("better-auth/plugins").UserWithRole;
+            session: {
+              id: string;
+              createdAt: Date;
+              updatedAt: Date;
+              userId: string;
+              expiresAt: Date;
+              token: string;
+              ipAddress?: string | null | undefined;
+              userAgent?: string | null | undefined;
+            };
+          };
+        }>)[];
+        metadata: {
+          openapi: {
+            operationId: string;
+            summary: string;
+            description: string;
+            responses: {
+              200: {
+                description: string;
+                content: {
+                  "application/json": {
+                    schema: {
+                      type: "object";
+                      properties: {
+                        success: {
+                          type: string;
+                        };
+                      };
+                    };
+                  };
+                };
+              };
+            };
+          };
+        };
+      }, {
+        success: boolean;
+      }>;
+      removeUser: StrictEndpoint<"/admin/remove-user", {
+        method: "POST";
+        body: import("zod").ZodObject<{
+          userId: import("zod").ZodCoercedString<unknown>;
+        }, import("zod/v4/core").$strip>;
+        use: ((inputContext: MiddlewareInputContext<MiddlewareOptions>) => Promise<{
+          session: {
+            user: import("better-auth/plugins").UserWithRole;
+            session: {
+              id: string;
+              createdAt: Date;
+              updatedAt: Date;
+              userId: string;
+              expiresAt: Date;
+              token: string;
+              ipAddress?: string | null | undefined;
+              userAgent?: string | null | undefined;
+            };
+          };
+        }>)[];
+        metadata: {
+          openapi: {
+            operationId: string;
+            summary: string;
+            description: string;
+            responses: {
+              200: {
+                description: string;
+                content: {
+                  "application/json": {
+                    schema: {
+                      type: "object";
+                      properties: {
+                        success: {
+                          type: string;
+                        };
+                      };
+                    };
+                  };
+                };
+              };
+            };
+          };
+        };
+      }, {
+        success: boolean;
+      }>;
+      setUserPassword: StrictEndpoint<"/admin/set-user-password", {
+        method: "POST";
+        body: import("zod").ZodObject<{
+          newPassword: import("zod").ZodString;
+          userId: import("zod").ZodCoercedString<unknown>;
+        }, import("zod/v4/core").$strip>;
+        use: ((inputContext: MiddlewareInputContext<MiddlewareOptions>) => Promise<{
+          session: {
+            user: import("better-auth/plugins").UserWithRole;
+            session: {
+              id: string;
+              createdAt: Date;
+              updatedAt: Date;
+              userId: string;
+              expiresAt: Date;
+              token: string;
+              ipAddress?: string | null | undefined;
+              userAgent?: string | null | undefined;
+            };
+          };
+        }>)[];
+        metadata: {
+          openapi: {
+            operationId: string;
+            summary: string;
+            description: string;
+            responses: {
+              200: {
+                description: string;
+                content: {
+                  "application/json": {
+                    schema: {
+                      type: "object";
+                      properties: {
+                        status: {
+                          type: string;
+                        };
+                      };
+                    };
+                  };
+                };
+              };
+            };
+          };
+        };
+      }, {
+        status: boolean;
+      }>;
+      userHasPermission: StrictEndpoint<"/admin/has-permission", {
+        method: "POST";
+        body: import("zod").ZodIntersection<import("zod").ZodObject<{
+          userId: import("zod").ZodOptional<import("zod").ZodCoercedString<unknown>>;
+          role: import("zod").ZodOptional<import("zod").ZodString>;
+        }, import("zod/v4/core").$strip>, import("zod").ZodXor<readonly [import("zod").ZodObject<{
+          permission: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodArray<import("zod").ZodString>>;
+        }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+          permissions: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodArray<import("zod").ZodString>>;
+        }, import("zod/v4/core").$strip>]>>;
+        metadata: {
+          openapi: {
+            description: string;
+            requestBody: {
+              content: {
+                "application/json": {
+                  schema: {
+                    type: "object";
+                    properties: {
+                      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: {
+              permissions: {
+                readonly [x: string]: import("better-auth").LiteralString[];
+              };
+            } & {
+              userId?: string | undefined;
+              role?: "admin" | "user";
+            };
+          };
+        };
+      }, {
+        error: null;
+        success: boolean;
+      }>;
+    };
+    $ERROR_CODES: {
+      USER_ALREADY_EXISTS_USE_ANOTHER_EMAIL: import("better-auth").RawError<"USER_ALREADY_EXISTS_USE_ANOTHER_EMAIL">;
+      FAILED_TO_CREATE_USER: import("better-auth").RawError<"FAILED_TO_CREATE_USER">;
+      USER_ALREADY_EXISTS: import("better-auth").RawError<"USER_ALREADY_EXISTS">;
+      YOU_CANNOT_BAN_YOURSELF: import("better-auth").RawError<"YOU_CANNOT_BAN_YOURSELF">;
+      YOU_ARE_NOT_ALLOWED_TO_CHANGE_USERS_ROLE: import("better-auth").RawError<"YOU_ARE_NOT_ALLOWED_TO_CHANGE_USERS_ROLE">;
+      YOU_ARE_NOT_ALLOWED_TO_CREATE_USERS: import("better-auth").RawError<"YOU_ARE_NOT_ALLOWED_TO_CREATE_USERS">;
+      YOU_ARE_NOT_ALLOWED_TO_LIST_USERS: import("better-auth").RawError<"YOU_ARE_NOT_ALLOWED_TO_LIST_USERS">;
+      YOU_ARE_NOT_ALLOWED_TO_LIST_USERS_SESSIONS: import("better-auth").RawError<"YOU_ARE_NOT_ALLOWED_TO_LIST_USERS_SESSIONS">;
+      YOU_ARE_NOT_ALLOWED_TO_BAN_USERS: import("better-auth").RawError<"YOU_ARE_NOT_ALLOWED_TO_BAN_USERS">;
+      YOU_ARE_NOT_ALLOWED_TO_IMPERSONATE_USERS: import("better-auth").RawError<"YOU_ARE_NOT_ALLOWED_TO_IMPERSONATE_USERS">;
+      YOU_ARE_NOT_ALLOWED_TO_REVOKE_USERS_SESSIONS: import("better-auth").RawError<"YOU_ARE_NOT_ALLOWED_TO_REVOKE_USERS_SESSIONS">;
+      YOU_ARE_NOT_ALLOWED_TO_DELETE_USERS: import("better-auth").RawError<"YOU_ARE_NOT_ALLOWED_TO_DELETE_USERS">;
+      YOU_ARE_NOT_ALLOWED_TO_SET_USERS_PASSWORD: import("better-auth").RawError<"YOU_ARE_NOT_ALLOWED_TO_SET_USERS_PASSWORD">;
+      BANNED_USER: import("better-auth").RawError<"BANNED_USER">;
+      YOU_ARE_NOT_ALLOWED_TO_GET_USER: import("better-auth").RawError<"YOU_ARE_NOT_ALLOWED_TO_GET_USER">;
+      NO_DATA_TO_UPDATE: import("better-auth").RawError<"NO_DATA_TO_UPDATE">;
+      YOU_ARE_NOT_ALLOWED_TO_UPDATE_USERS: import("better-auth").RawError<"YOU_ARE_NOT_ALLOWED_TO_UPDATE_USERS">;
+      YOU_CANNOT_REMOVE_YOURSELF: import("better-auth").RawError<"YOU_CANNOT_REMOVE_YOURSELF">;
+      YOU_ARE_NOT_ALLOWED_TO_SET_NON_EXISTENT_VALUE: import("better-auth").RawError<"YOU_ARE_NOT_ALLOWED_TO_SET_NON_EXISTENT_VALUE">;
+      YOU_CANNOT_IMPERSONATE_ADMINS: import("better-auth").RawError<"YOU_CANNOT_IMPERSONATE_ADMINS">;
+      INVALID_ROLE_TYPE: import("better-auth").RawError<"INVALID_ROLE_TYPE">;
+      YOU_ARE_NOT_ALLOWED_TO_SET_USERS_EMAIL: import("better-auth").RawError<"YOU_ARE_NOT_ALLOWED_TO_SET_USERS_EMAIL">;
+      PASSWORD_CANNOT_BE_UPDATED_VIA_UPDATE_USER: import("better-auth").RawError<"PASSWORD_CANNOT_BE_UPDATED_VIA_UPDATE_USER">;
+    };
+    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;
+            input: false;
+          };
+        };
+      };
+    };
+    options: NoInfer<import("better-auth/plugins").AdminOptions>;
+  }, {
+    id: "username";
+    version: string;
+    init(ctx: import("better-auth").AuthContext): {
+      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>, context: import("better-auth").GenericEndpointContext | null): Promise<{
+                data: {
+                  username: string;
+                  displayUsername: string;
+                  id: string;
+                  createdAt: Date;
+                  updatedAt: Date;
+                  email: string;
+                  emailVerified: boolean;
+                  name: string;
+                  image?: string | null | undefined;
+                };
+              } | {
+                data: {
+                  displayUsername?: string | undefined;
+                  id: string;
+                  createdAt: Date;
+                  updatedAt: Date;
+                  email: string;
+                  emailVerified: boolean;
+                  name: string;
+                  image?: string | null | undefined;
+                };
+              }>;
+            };
+            update: {
+              before(user: Partial<{
+                id: string;
+                createdAt: Date;
+                updatedAt: Date;
+                email: string;
+                emailVerified: boolean;
+                name: string;
+                image?: string | null | undefined;
+              }> & Record<string, unknown>, context: import("better-auth").GenericEndpointContext | null): Promise<{
+                data: {
+                  displayUsername?: string | undefined;
+                  username: string;
+                  id?: string | undefined;
+                  createdAt?: Date | undefined;
+                  updatedAt?: Date | undefined;
+                  email?: string | undefined;
+                  emailVerified?: boolean | undefined;
+                  name?: string | undefined;
+                  image?: string | null | undefined;
+                };
+              } | {
+                data: {
+                  displayUsername?: string | undefined;
+                  id?: string | undefined;
+                  createdAt?: Date | undefined;
+                  updatedAt?: Date | undefined;
+                  email?: string | undefined;
+                  emailVerified?: boolean | undefined;
+                  name?: string | undefined;
+                  image?: string | null | undefined;
+                };
+              }>;
+            };
+          };
+        };
+      };
+    };
+    endpoints: {
+      signInUsername: StrictEndpoint<"/sign-in/username", {
+        method: "POST";
+        body: import("zod").ZodObject<{
+          username: import("zod").ZodString;
+          password: import("zod").ZodString;
+          rememberMe: import("zod").ZodOptional<import("zod").ZodBoolean>;
+          callbackURL: import("zod").ZodOptional<import("zod").ZodString>;
+        }, import("zod/v4/core").$strip>;
+        metadata: {
+          openapi: {
+            summary: string;
+            description: string;
+            responses: {
+              200: {
+                description: string;
+                content: {
+                  "application/json": {
+                    schema: {
+                      type: "object";
+                      properties: {
+                        redirect: {
+                          type: string;
+                          description: string;
+                        };
+                        token: {
+                          type: string;
+                          description: string;
+                        };
+                        url: {
+                          type: string;
+                          nullable: boolean;
+                          description: string;
+                        };
+                        user: {
+                          $ref: string;
+                        };
+                      };
+                      required: string[];
+                    };
+                  };
+                };
+              };
+              422: {
+                description: string;
+                content: {
+                  "application/json": {
+                    schema: {
+                      type: "object";
+                      properties: {
+                        message: {
+                          type: string;
+                        };
+                      };
+                    };
+                  };
+                };
+              };
+            };
+          };
+        };
+      }, {
+        redirect: boolean;
+        token: string;
+        url: string | undefined;
+        user: {
+          id: string;
+          createdAt: Date;
+          updatedAt: Date;
+          email: string;
+          emailVerified: boolean;
+          name: string;
+          image?: string | null | undefined;
+        } & {
+          username: string;
+          displayUsername: string;
+        };
+      }>;
+      isUsernameAvailable: StrictEndpoint<"/is-username-available", {
+        method: "POST";
+        body: import("zod").ZodObject<{
+          username: import("zod").ZodString;
+        }, import("zod/v4/core").$strip>;
+      }, {
+        available: boolean;
+      }>;
+    };
+    schema: {
+      user: {
+        fields: {
+          username: {
+            type: "string";
+            required: false;
+            sortable: true;
+            unique: true;
+            returned: true;
+            transform: {
+              input(value: import("better-auth").DBPrimitive): string | number | boolean | Date | Record<string, unknown> | unknown[] | null | undefined;
+            };
+          };
+          displayUsername: {
+            type: "string";
+            required: false;
+            transform: {
+              input(value: import("better-auth").DBPrimitive): string | number | boolean | Date | Record<string, unknown> | unknown[] | null | undefined;
+            };
+          };
+        };
+      };
+    };
+    hooks: {
+      before: {
+        matcher(context: import("better-auth").HookEndpointContext): boolean;
+        handler: (inputContext: MiddlewareInputContext<MiddlewareOptions>) => Promise<void>;
+      }[];
+    };
+    options: import("better-auth/plugins").UsernameOptions | undefined;
+    $ERROR_CODES: {
+      EMAIL_NOT_VERIFIED: import("better-auth").RawError<"EMAIL_NOT_VERIFIED">;
+      UNEXPECTED_ERROR: import("better-auth").RawError<"UNEXPECTED_ERROR">;
+      INVALID_USERNAME_OR_PASSWORD: import("better-auth").RawError<"INVALID_USERNAME_OR_PASSWORD">;
+      USERNAME_IS_ALREADY_TAKEN: import("better-auth").RawError<"USERNAME_IS_ALREADY_TAKEN">;
+      USERNAME_TOO_SHORT: import("better-auth").RawError<"USERNAME_TOO_SHORT">;
+      USERNAME_TOO_LONG: import("better-auth").RawError<"USERNAME_TOO_LONG">;
+      INVALID_USERNAME: import("better-auth").RawError<"INVALID_USERNAME">;
+      INVALID_DISPLAY_USERNAME: import("better-auth").RawError<"INVALID_DISPLAY_USERNAME">;
+    };
+  }];
+  user: {
+    additionalFields: {
+      surname: {
+        type: "string";
+        required: false;
+      };
+      identification: {
+        type: "string";
+        required: false;
+      };
+      phone: {
+        type: "string";
+        required: false;
+      };
+      birthday: {
+        type: "date";
+        required: false;
+      };
+    };
+  };
+}>;
+type Auth = typeof _auth;
+declare function registerAuthMiddleware(app: H3, options: {
+  auth: any;
+  guard?: {
+    path?: string;
+    excludePaths?: string[];
+  };
+}): void;
+declare function registerAuth(app: H3, auth: Auth): void;
+interface OptionsCache {
+  path: (...params: string[]) => string;
+  storeId: number;
+}
+declare function getTax(store: Store): any;
+declare function useProducts(db: Database): {
+  getProducts: (storeId: any) => Promise<any[]>;
+  getStore: (storeId: any) => Promise<any>;
+};
+declare function registerCache(app: H3, db: Database, {
+  path,
+  storeId
+}: OptionsCache): void;
+interface PVariant {}
+interface Product {
+  id: any;
+  title: any;
+  taxes: any[];
+  extras: any;
+  discount: number;
+  originalPrice: number;
+  variants: {
+    id: any;
+    originalPrice: number;
+  }[];
+}
+interface LineItemsCart {
+  id: string;
+  quantity: number;
+  title: string;
+  variant: PVariant;
+  taxes?: any[];
+}
+type GetProducts = () => Promise<Product[]>;
+interface OptionsCart {
+  getProducts: GetProducts;
+  path: (...params: string[]) => string;
+}
+declare function registerCart(app: H3, {
+  getProducts,
+  path
+}: OptionsCart): void;
+interface OptionsAccount$1 {
+  path: (...params: string[]) => string;
+  storeId: number;
+}
+declare function getCheckoutId(event: H3Event): any;
+declare function registerCheckout(app: H3, db: Database, {
+  path,
+  storeId
+}: OptionsAccount$1): void;
+interface PayPresset {
+  prepare?: {
+    preHandle?: (event: H3Event, payment: Payment) => Promise<void>;
+    postHandle?: (event: H3Event, result: any) => Promise<void>;
+  };
+  postPrepare?: {
+    preHandle?: (event: H3Event, payment: Payment) => Promise<void>;
+    postHandle?: (event: H3Event, result: any) => Promise<void>;
+  };
+}
+interface OptionsAccount {
+  path: (...params: string[]) => string;
+  storeId: number;
+  providers: any;
+  preset: 'ecommerce' | PayPresset;
+  providerOptions: Record<string, any>;
+  redirect: string;
+}
+declare const safeParams: (v: string) => string;
+declare function registerPayment(app: H3, db: Database, {
+  path,
+  storeId,
+  providers,
+  preset,
+  providerOptions,
+  redirect: globalRedirect
+}: OptionsAccount): void;
+export { LineItemsCart, getCheckoutId, getTax, registerAccount, registerAuth, registerAuthMiddleware, registerCache, registerCart, registerCheckout, registerPayment, safeParams, useProducts, useUser };