@uninspired/auth-client 1.0.21 → 2.1.0

package/dist/index.d.ts

@@ -1,25 +1,42 @@
+import * as _$_better_auth_passkey_client0 from "@better-auth/passkey/client";
+import * as _$better_auth_client0 from "better-auth/client";
+import * as _$better_auth_react0 from "better-auth/react";
+import * as _$zod from "zod";
 import { z } from "zod";
 import * as _$react from "react";
 import { PropsWithChildren } from "react";
+import { PostHog } from "posthog-js";
+import { PostHogProvider, useFeatureFlagEnabled, useFeatureFlagVariantKey, usePostHog } from "posthog-js/react/dist/esm/slim/index.js";
 import { QueryClient } from "@tanstack/react-query";
-import * as _$react_jsx_runtime0 from "react/jsx-runtime";
+import * as _$better_auth0 from "better-auth";
 import { Session as Session$1, User } from "better-auth";
+import * as _$better_auth_plugins0 from "better-auth/plugins";
+import * as _$zod_v4_core0 from "zod/v4/core";
+import * as _$_better_auth_passkey0 from "@better-auth/passkey";
 
 //#region ../types/src/analytics.d.ts
 declare const ANALYTICS_PRODUCTS: readonly ["mixd", "momentum", "unpinned", "accounts"];
 type AnalyticsProduct = (typeof ANALYTICS_PRODUCTS)[number];
-declare const ANALYTICS_EVENTS: {
-  readonly USER_SIGNED_UP: "user signed up";
-  readonly USER_LOGGED_IN: "user logged in";
-  readonly TRIAL_STARTED: "trial started";
-  readonly CHECKOUT_STARTED: "checkout started";
-  readonly CHECKOUT_COMPLETED: "checkout completed";
-  readonly FEATURE_USED: "feature used";
-};
-type AnalyticsEvent = (typeof ANALYTICS_EVENTS)[keyof typeof ANALYTICS_EVENTS];
 type AuthMethod = "magic_link" | "email_otp" | "passkey";
 declare function isAnalyticsProduct(value: string): value is AnalyticsProduct;
 //#endregion
+//#region ../types/src/consent.d.ts
+/**
+ * Cookie-consent state shared by the API worker and `@uninspired/auth-client`.
+ *
+ * The consent cookie is the single source of truth for whether a user has
+ * answered the banner. Its absence means "pending" (no decision yet), which is
+ * treated exactly like the PII-free tracking baseline everywhere.
+ */
+interface TrackingConsent {
+  /** PostHog: full mode (cookies + identify) vs the cookieless baseline. */
+  analytics: boolean;
+  /** Meta Pixel (the only marketing-category tracker). */
+  marketing: boolean;
+}
+/** `null` = no decision recorded yet → the banner should be shown. */
+type ConsentState = TrackingConsent | null;
+//#endregion
 //#region ../types/src/purchases.d.ts
 declare const userPurchasesSchema: z.ZodObject<{
   stripe: z.ZodArray<z.ZodObject<{
@@ -89,35 +106,6 @@ interface Session {
   };
 }
 //#endregion
-//#region ../types/src/meta.d.ts
-declare const metaTrackEventSchema: z.ZodObject<{
-  event_name: z.ZodEnum<{
-    ViewContent: "ViewContent";
-    InitiateCheckout: "InitiateCheckout";
-  }>;
-  content_ids: z.ZodOptional<z.ZodArray<z.ZodString>>;
-  content_type: z.ZodOptional<z.ZodString>;
-  event_source_url: z.ZodOptional<z.ZodString>;
-  value: z.ZodOptional<z.ZodNumber>;
-  currency: z.ZodOptional<z.ZodString>;
-  event_id: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
-type MetaTrackEventInput = z.infer<typeof metaTrackEventSchema>;
-type MetaAttributionCookies = {
-  fbc?: string;
-  fbp?: string;
-};
-declare function parseMetaAttributionFromCookieHeader(cookieHeader: string | undefined): MetaAttributionCookies;
-declare function buildFbcFromFbclid(fbclid: string, seenAtMs?: number): string;
-//#endregion
-//#region src/metaAttribution.d.ts
-declare function getMetaCookieDomain(frontendUrl: string): string | undefined;
-declare function readMetaAttributionCookies(): MetaAttributionCookies;
-declare function captureMetaClickId(options: {
-  frontendUrl: string;
-  stripFbclidFromUrl?: boolean;
-}): MetaAttributionCookies;
-//#endregion
 //#region src/AuthClient.d.ts
 declare class AuthClient {
   #private;
@@ -126,13 +114,6 @@ declare class AuthClient {
   signInAnonymously: () => Promise<Session | null>;
   signOut: (onSuccess?: () => void) => Promise<void>;
   getPurchases: () => Promise<UserPurchases | null>;
-  trackMetaEvent: (payload: MetaTrackEventInput) => Promise<void>;
-  trackViewContent: (options: {
-    contentIds: string[];
-    contentType?: string;
-    eventSourceUrl?: string;
-  }) => Promise<void>;
-  getMetaAttribution: () => MetaAttributionCookies;
   getLoginUrl: (options?: {
     redirectUrl?: string;
     appName?: string;
@@ -146,7 +127,1590 @@ declare class AuthClient {
   }) => string;
 }
 //#endregion
+//#region src/betterAuthClient.d.ts
+declare function createBetterAuthClient(baseURL: string): _$better_auth_react0.ReactAuthClient<{
+  baseURL: string;
+  plugins: ({
+    id: "anonymous";
+    version: string;
+    $InferServerPlugin: ReturnType<(options?: _$better_auth_plugins0.AnonymousOptions | undefined) => {
+      id: "anonymous";
+      version: string;
+      endpoints: {
+        signInAnonymous: _$better_auth0.StrictEndpoint<"/sign-in/anonymous", {
+          method: "POST";
+          metadata: {
+            openapi: {
+              description: string;
+              responses: {
+                200: {
+                  description: string;
+                  content: {
+                    "application/json": {
+                      schema: {
+                        type: "object";
+                        properties: {
+                          user: {
+                            $ref: string;
+                          };
+                          session: {
+                            $ref: string;
+                          };
+                        };
+                      };
+                    };
+                  };
+                };
+              };
+            };
+          };
+        }, {
+          token: string;
+          user: Record<string, any> & {
+            id: string;
+            createdAt: Date;
+            updatedAt: Date;
+            email: string;
+            emailVerified: boolean;
+            name: string;
+            image?: string | null | undefined;
+          };
+        }>;
+        deleteAnonymousUser: _$better_auth0.StrictEndpoint<"/delete-anonymous-user", {
+          method: "POST";
+          use: _$better_auth0.Middleware<_$better_auth0.MiddlewareOptions, (inputContext: _$better_auth0.MiddlewareInputContext<_$better_auth0.MiddlewareOptions>) => Promise<{
+            session: {
+              session: Record<string, any> & {
+                id: string;
+                createdAt: Date;
+                updatedAt: Date;
+                userId: string;
+                expiresAt: Date;
+                token: string;
+                ipAddress?: string | null | undefined;
+                userAgent?: string | null | undefined;
+              };
+              user: Record<string, any> & {
+                id: string;
+                createdAt: Date;
+                updatedAt: Date;
+                email: string;
+                emailVerified: boolean;
+                name: string;
+                image?: string | null | undefined;
+              };
+            };
+          }>>[];
+          metadata: {
+            openapi: {
+              description: string;
+              responses: {
+                200: {
+                  description: string;
+                  content: {
+                    "application/json": {
+                      schema: {
+                        type: "object";
+                        properties: {
+                          success: {
+                            type: string;
+                          };
+                        };
+                      };
+                    };
+                  };
+                };
+                "400": {
+                  description: string;
+                  content: {
+                    "application/json": {
+                      schema: {
+                        type: "object";
+                        properties: {
+                          message: {
+                            type: string;
+                          };
+                        };
+                      };
+                      required: string[];
+                    };
+                  };
+                };
+                "500": {
+                  description: string;
+                  content: {
+                    "application/json": {
+                      schema: {
+                        type: "object";
+                        properties: {
+                          message: {
+                            type: string;
+                          };
+                        };
+                        required: string[];
+                      };
+                    };
+                  };
+                };
+              };
+            };
+          };
+        }, {
+          success: boolean;
+        }>;
+      };
+      hooks: {
+        before: {
+          matcher(ctx: _$better_auth0.HookEndpointContext): boolean;
+          handler: _$better_auth0.Middleware<_$better_auth0.MiddlewareOptions, (inputContext: _$better_auth0.MiddlewareInputContext<_$better_auth0.MiddlewareOptions>) => Promise<void>>;
+        }[];
+        after: {
+          matcher(ctx: _$better_auth0.HookEndpointContext): boolean;
+          handler: _$better_auth0.Middleware<_$better_auth0.MiddlewareOptions, (inputContext: _$better_auth0.MiddlewareInputContext<_$better_auth0.MiddlewareOptions>) => Promise<void>>;
+        }[];
+      };
+      options: _$better_auth_plugins0.AnonymousOptions | undefined;
+      schema: {
+        user: {
+          fields: {
+            isAnonymous: {
+              type: "boolean";
+              required: false;
+              input: false;
+              defaultValue: false;
+            };
+          };
+        };
+      };
+      $ERROR_CODES: {
+        FAILED_TO_CREATE_USER: _$better_auth0.RawError<"FAILED_TO_CREATE_USER">;
+        INVALID_EMAIL_FORMAT: _$better_auth0.RawError<"INVALID_EMAIL_FORMAT">;
+        COULD_NOT_CREATE_SESSION: _$better_auth0.RawError<"COULD_NOT_CREATE_SESSION">;
+        ANONYMOUS_USERS_CANNOT_SIGN_IN_AGAIN_ANONYMOUSLY: _$better_auth0.RawError<"ANONYMOUS_USERS_CANNOT_SIGN_IN_AGAIN_ANONYMOUSLY">;
+        FAILED_TO_DELETE_ANONYMOUS_USER: _$better_auth0.RawError<"FAILED_TO_DELETE_ANONYMOUS_USER">;
+        FAILED_TO_DELETE_ANONYMOUS_USER_SESSIONS: _$better_auth0.RawError<"FAILED_TO_DELETE_ANONYMOUS_USER_SESSIONS">;
+        USER_IS_NOT_ANONYMOUS: _$better_auth0.RawError<"USER_IS_NOT_ANONYMOUS">;
+        DELETE_ANONYMOUS_USER_DISABLED: _$better_auth0.RawError<"DELETE_ANONYMOUS_USER_DISABLED">;
+      };
+    }>;
+    pathMethods: {
+      "/sign-in/anonymous": "POST";
+      "/delete-anonymous-user": "POST";
+    };
+    atomListeners: {
+      matcher: (path: string) => path is "/sign-in/anonymous";
+      signal: "$sessionSignal";
+    }[];
+    $ERROR_CODES: {
+      FAILED_TO_CREATE_USER: _$better_auth0.RawError<"FAILED_TO_CREATE_USER">;
+      INVALID_EMAIL_FORMAT: _$better_auth0.RawError<"INVALID_EMAIL_FORMAT">;
+      COULD_NOT_CREATE_SESSION: _$better_auth0.RawError<"COULD_NOT_CREATE_SESSION">;
+      ANONYMOUS_USERS_CANNOT_SIGN_IN_AGAIN_ANONYMOUSLY: _$better_auth0.RawError<"ANONYMOUS_USERS_CANNOT_SIGN_IN_AGAIN_ANONYMOUSLY">;
+      FAILED_TO_DELETE_ANONYMOUS_USER: _$better_auth0.RawError<"FAILED_TO_DELETE_ANONYMOUS_USER">;
+      FAILED_TO_DELETE_ANONYMOUS_USER_SESSIONS: _$better_auth0.RawError<"FAILED_TO_DELETE_ANONYMOUS_USER_SESSIONS">;
+      USER_IS_NOT_ANONYMOUS: _$better_auth0.RawError<"USER_IS_NOT_ANONYMOUS">;
+      DELETE_ANONYMOUS_USER_DISABLED: _$better_auth0.RawError<"DELETE_ANONYMOUS_USER_DISABLED">;
+    };
+  } | {
+    id: "magic-link";
+    version: string;
+    $InferServerPlugin: ReturnType<(options: _$better_auth_plugins0.MagicLinkOptions) => {
+      id: "magic-link";
+      version: string;
+      endpoints: {
+        signInMagicLink: _$better_auth0.StrictEndpoint<"/sign-in/magic-link", {
+          method: "POST";
+          requireHeaders: true;
+          use: _$better_auth0.Middleware<_$better_auth0.MiddlewareOptions, (inputContext: _$better_auth0.MiddlewareInputContext<_$better_auth0.MiddlewareOptions>) => Promise<void>>[];
+          body: _$zod.ZodObject<{
+            email: _$zod.ZodEmail;
+            name: _$zod.ZodOptional<_$zod.ZodString>;
+            callbackURL: _$zod.ZodOptional<_$zod.ZodString>;
+            newUserCallbackURL: _$zod.ZodOptional<_$zod.ZodString>;
+            errorCallbackURL: _$zod.ZodOptional<_$zod.ZodString>;
+            metadata: _$zod.ZodOptional<_$zod.ZodRecord<_$zod.ZodString, _$zod.ZodAny>>;
+          }, _$zod_v4_core0.$strip>;
+          metadata: {
+            openapi: {
+              operationId: string;
+              description: string;
+              responses: {
+                200: {
+                  description: string;
+                  content: {
+                    "application/json": {
+                      schema: {
+                        type: "object";
+                        properties: {
+                          status: {
+                            type: string;
+                          };
+                        };
+                      };
+                    };
+                  };
+                };
+              };
+            };
+          };
+        }, {
+          status: boolean;
+        }>;
+        magicLinkVerify: _$better_auth0.StrictEndpoint<"/magic-link/verify", {
+          method: "GET";
+          query: _$zod.ZodObject<{
+            token: _$zod.ZodString;
+            callbackURL: _$zod.ZodOptional<_$zod.ZodString>;
+            errorCallbackURL: _$zod.ZodOptional<_$zod.ZodString>;
+            newUserCallbackURL: _$zod.ZodOptional<_$zod.ZodString>;
+          }, _$zod_v4_core0.$strip>;
+          use: _$better_auth0.Middleware<_$better_auth0.MiddlewareOptions, (inputContext: _$better_auth0.MiddlewareInputContext<_$better_auth0.MiddlewareOptions>) => Promise<void>>[];
+          requireHeaders: true;
+          metadata: {
+            openapi: {
+              operationId: string;
+              description: string;
+              responses: {
+                200: {
+                  description: string;
+                  content: {
+                    "application/json": {
+                      schema: {
+                        type: "object";
+                        properties: {
+                          session: {
+                            $ref: string;
+                          };
+                          user: {
+                            $ref: string;
+                          };
+                        };
+                      };
+                    };
+                  };
+                };
+              };
+            };
+          };
+        }, {
+          token: string;
+          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;
+          };
+        }>;
+      };
+      rateLimit: {
+        pathMatcher(path: string): boolean;
+        window: number;
+        max: number;
+      }[];
+      options: _$better_auth_plugins0.MagicLinkOptions;
+    }>;
+  } | {
+    id: "email-otp";
+    version: string;
+    $InferServerPlugin: ReturnType<(options: _$better_auth_plugins0.EmailOTPOptions) => {
+      id: "email-otp";
+      version: string;
+      init(ctx: _$better_auth0.AuthContext): {
+        options: {
+          emailVerification: {
+            sendVerificationEmail(data: {
+              user: _$better_auth0.User;
+              url: string;
+              token: string;
+            }, request: Request | undefined): Promise<void>;
+          };
+        };
+      } | undefined;
+      endpoints: {
+        sendVerificationOTP: _$better_auth0.StrictEndpoint<"/email-otp/send-verification-otp", {
+          method: "POST";
+          use: _$better_auth0.Middleware<_$better_auth0.MiddlewareOptions, (inputContext: _$better_auth0.MiddlewareInputContext<_$better_auth0.MiddlewareOptions>) => Promise<void>>[];
+          body: _$zod.ZodObject<{
+            email: _$zod.ZodString;
+            type: _$zod.ZodEnum<{
+              "sign-in": "sign-in";
+              "change-email": "change-email";
+              "email-verification": "email-verification";
+              "forget-password": "forget-password";
+            }>;
+          }, _$zod_v4_core0.$strip>;
+          metadata: {
+            openapi: {
+              operationId: string;
+              description: string;
+              responses: {
+                200: {
+                  description: string;
+                  content: {
+                    "application/json": {
+                      schema: {
+                        type: "object";
+                        properties: {
+                          success: {
+                            type: string;
+                          };
+                        };
+                      };
+                    };
+                  };
+                };
+              };
+            };
+          };
+        }, {
+          success: boolean;
+        }>;
+        createVerificationOTP: _$better_auth0.StrictEndpoint<string, {
+          method: "POST";
+          body: _$zod.ZodObject<{
+            email: _$zod.ZodString;
+            type: _$zod.ZodEnum<{
+              "sign-in": "sign-in";
+              "change-email": "change-email";
+              "email-verification": "email-verification";
+              "forget-password": "forget-password";
+            }>;
+          }, _$zod_v4_core0.$strip>;
+          metadata: {
+            openapi: {
+              operationId: string;
+              description: string;
+              responses: {
+                200: {
+                  description: string;
+                  content: {
+                    "application/json": {
+                      schema: {
+                        type: "string";
+                      };
+                    };
+                  };
+                };
+              };
+            };
+          };
+        }, string>;
+        getVerificationOTP: _$better_auth0.StrictEndpoint<string, {
+          method: "GET";
+          query: _$zod.ZodObject<{
+            email: _$zod.ZodString;
+            type: _$zod.ZodEnum<{
+              "sign-in": "sign-in";
+              "change-email": "change-email";
+              "email-verification": "email-verification";
+              "forget-password": "forget-password";
+            }>;
+          }, _$zod_v4_core0.$strip>;
+          metadata: {
+            openapi: {
+              operationId: string;
+              description: string;
+              responses: {
+                "200": {
+                  description: string;
+                  content: {
+                    "application/json": {
+                      schema: {
+                        type: "object";
+                        properties: {
+                          otp: {
+                            type: string;
+                            nullable: boolean;
+                            description: string;
+                          };
+                        };
+                        required: string[];
+                      };
+                    };
+                  };
+                };
+              };
+            };
+          };
+        }, {
+          otp: null;
+        } | {
+          otp: string;
+        }>;
+        checkVerificationOTP: _$better_auth0.StrictEndpoint<"/email-otp/check-verification-otp", {
+          method: "POST";
+          body: _$zod.ZodObject<{
+            email: _$zod.ZodString;
+            type: _$zod.ZodEnum<{
+              "sign-in": "sign-in";
+              "change-email": "change-email";
+              "email-verification": "email-verification";
+              "forget-password": "forget-password";
+            }>;
+            otp: _$zod.ZodString;
+          }, _$zod_v4_core0.$strip>;
+          metadata: {
+            openapi: {
+              operationId: string;
+              description: string;
+              responses: {
+                200: {
+                  description: string;
+                  content: {
+                    "application/json": {
+                      schema: {
+                        type: "object";
+                        properties: {
+                          success: {
+                            type: string;
+                          };
+                        };
+                      };
+                    };
+                  };
+                };
+              };
+            };
+          };
+        }, {
+          success: boolean;
+        }>;
+        verifyEmailOTP: _$better_auth0.StrictEndpoint<"/email-otp/verify-email", {
+          method: "POST";
+          body: _$zod.ZodObject<{
+            email: _$zod.ZodString;
+            otp: _$zod.ZodString;
+          }, _$zod_v4_core0.$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[];
+                      };
+                    };
+                  };
+                };
+              };
+            };
+          };
+        }, {
+          status: boolean;
+          token: string;
+          user: {
+            id: string;
+            createdAt: Date;
+            updatedAt: Date;
+            email: string;
+            emailVerified: boolean;
+            name: string;
+            image?: string | null | undefined;
+          } & Record<string, any>;
+        } | {
+          status: boolean;
+          token: null;
+          user: {
+            id: string;
+            createdAt: Date;
+            updatedAt: Date;
+            email: string;
+            emailVerified: boolean;
+            name: string;
+            image?: string | null | undefined;
+          } & Record<string, any>;
+        }>;
+        signInEmailOTP: _$better_auth0.StrictEndpoint<"/sign-in/email-otp", {
+          method: "POST";
+          body: _$zod.ZodIntersection<_$zod.ZodObject<{
+            email: _$zod.ZodString;
+            otp: _$zod.ZodString;
+            name: _$zod.ZodOptional<_$zod.ZodString>;
+            image: _$zod.ZodOptional<_$zod.ZodString>;
+          }, _$zod_v4_core0.$strip>, _$zod.ZodRecord<_$zod.ZodString, _$zod.ZodAny>>;
+          metadata: {
+            openapi: {
+              operationId: string;
+              description: string;
+              responses: {
+                200: {
+                  description: string;
+                  content: {
+                    "application/json": {
+                      schema: {
+                        type: "object";
+                        properties: {
+                          token: {
+                            type: string;
+                            description: string;
+                          };
+                          user: {
+                            $ref: string;
+                          };
+                        };
+                        required: string[];
+                      };
+                    };
+                  };
+                };
+              };
+            };
+          };
+        }, {
+          token: string;
+          user: {
+            id: string;
+            createdAt: Date;
+            updatedAt: Date;
+            email: string;
+            emailVerified: boolean;
+            name: string;
+            image?: string | null | undefined;
+          };
+        }>;
+        requestPasswordResetEmailOTP: _$better_auth0.StrictEndpoint<"/email-otp/request-password-reset", {
+          method: "POST";
+          body: _$zod.ZodObject<{
+            email: _$zod.ZodString;
+          }, _$zod_v4_core0.$strip>;
+          metadata: {
+            openapi: {
+              operationId: string;
+              description: string;
+              responses: {
+                200: {
+                  description: string;
+                  content: {
+                    "application/json": {
+                      schema: {
+                        type: "object";
+                        properties: {
+                          success: {
+                            type: string;
+                            description: string;
+                          };
+                        };
+                      };
+                    };
+                  };
+                };
+              };
+            };
+          };
+        }, {
+          success: boolean;
+        }>;
+        forgetPasswordEmailOTP: _$better_auth0.StrictEndpoint<"/forget-password/email-otp", {
+          method: "POST";
+          body: _$zod.ZodObject<{
+            email: _$zod.ZodString;
+          }, _$zod_v4_core0.$strip>;
+          metadata: {
+            openapi: {
+              operationId: string;
+              description: string;
+              responses: {
+                200: {
+                  description: string;
+                  content: {
+                    "application/json": {
+                      schema: {
+                        type: "object";
+                        properties: {
+                          success: {
+                            type: string;
+                            description: string;
+                          };
+                        };
+                      };
+                    };
+                  };
+                };
+              };
+            };
+          };
+        }, {
+          success: boolean;
+        }>;
+        resetPasswordEmailOTP: _$better_auth0.StrictEndpoint<"/email-otp/reset-password", {
+          method: "POST";
+          body: _$zod.ZodObject<{
+            email: _$zod.ZodString;
+            otp: _$zod.ZodString;
+            password: _$zod.ZodString;
+          }, _$zod_v4_core0.$strip>;
+          metadata: {
+            openapi: {
+              operationId: string;
+              description: string;
+              responses: {
+                200: {
+                  description: string;
+                  content: {
+                    "application/json": {
+                      schema: {
+                        type: "object";
+                        properties: {
+                          success: {
+                            type: string;
+                          };
+                        };
+                      };
+                    };
+                  };
+                };
+              };
+            };
+          };
+        }, {
+          success: boolean;
+        }>;
+        requestEmailChangeEmailOTP: _$better_auth0.StrictEndpoint<"/email-otp/request-email-change", {
+          method: "POST";
+          body: _$zod.ZodObject<{
+            newEmail: _$zod.ZodString;
+            otp: _$zod.ZodOptional<_$zod.ZodString>;
+          }, _$zod_v4_core0.$strip>;
+          use: _$better_auth0.Middleware<_$better_auth0.MiddlewareOptions, (inputContext: _$better_auth0.MiddlewareInputContext<_$better_auth0.MiddlewareOptions>) => Promise<{
+            session: {
+              session: Record<string, any> & {
+                id: string;
+                createdAt: Date;
+                updatedAt: Date;
+                userId: string;
+                expiresAt: Date;
+                token: string;
+                ipAddress?: string | null | undefined;
+                userAgent?: string | null | undefined;
+              };
+              user: Record<string, any> & {
+                id: string;
+                createdAt: Date;
+                updatedAt: Date;
+                email: string;
+                emailVerified: boolean;
+                name: string;
+                image?: string | null | undefined;
+              };
+            };
+          }>>[];
+          metadata: {
+            openapi: {
+              operationId: string;
+              description: string;
+              responses: {
+                200: {
+                  description: string;
+                  content: {
+                    "application/json": {
+                      schema: {
+                        type: "object";
+                        properties: {
+                          success: {
+                            type: string;
+                          };
+                        };
+                      };
+                    };
+                  };
+                };
+              };
+            };
+          };
+        }, {
+          success: boolean;
+        }>;
+        changeEmailEmailOTP: _$better_auth0.StrictEndpoint<"/email-otp/change-email", {
+          method: "POST";
+          body: _$zod.ZodObject<{
+            newEmail: _$zod.ZodString;
+            otp: _$zod.ZodString;
+          }, _$zod_v4_core0.$strip>;
+          use: _$better_auth0.Middleware<_$better_auth0.MiddlewareOptions, (inputContext: _$better_auth0.MiddlewareInputContext<_$better_auth0.MiddlewareOptions>) => Promise<{
+            session: {
+              session: Record<string, any> & {
+                id: string;
+                createdAt: Date;
+                updatedAt: Date;
+                userId: string;
+                expiresAt: Date;
+                token: string;
+                ipAddress?: string | null | undefined;
+                userAgent?: string | null | undefined;
+              };
+              user: Record<string, any> & {
+                id: string;
+                createdAt: Date;
+                updatedAt: Date;
+                email: string;
+                emailVerified: boolean;
+                name: string;
+                image?: string | null | undefined;
+              };
+            };
+          }>>[];
+          metadata: {
+            openapi: {
+              operationId: string;
+              description: string;
+              responses: {
+                200: {
+                  description: string;
+                  content: {
+                    "application/json": {
+                      schema: {
+                        type: "object";
+                        properties: {
+                          success: {
+                            type: string;
+                          };
+                        };
+                      };
+                    };
+                  };
+                };
+              };
+            };
+          };
+        }, {
+          success: boolean;
+        }>;
+      };
+      hooks: {
+        after: {
+          matcher(context: _$better_auth0.HookEndpointContext): boolean;
+          handler: _$better_auth0.Middleware<_$better_auth0.MiddlewareOptions, (inputContext: _$better_auth0.MiddlewareInputContext<_$better_auth0.MiddlewareOptions>) => Promise<void>>;
+        }[];
+      };
+      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;
+      } | {
+        pathMatcher(path: string): path is "/email-otp/request-password-reset";
+        window: number;
+        max: number;
+      } | {
+        pathMatcher(path: string): path is "/email-otp/reset-password";
+        window: number;
+        max: number;
+      } | {
+        pathMatcher(path: string): path is "/forget-password/email-otp";
+        window: number;
+        max: number;
+      } | {
+        pathMatcher(path: string): path is "/email-otp/request-email-change";
+        window: number;
+        max: number;
+      } | {
+        pathMatcher(path: string): path is "/email-otp/change-email";
+        window: number;
+        max: number;
+      })[];
+      options: _$better_auth_plugins0.EmailOTPOptions;
+      $ERROR_CODES: {
+        OTP_EXPIRED: _$better_auth0.RawError<"OTP_EXPIRED">;
+        INVALID_OTP: _$better_auth0.RawError<"INVALID_OTP">;
+        TOO_MANY_ATTEMPTS: _$better_auth0.RawError<"TOO_MANY_ATTEMPTS">;
+      };
+    }>;
+    atomListeners: {
+      matcher: (path: string) => path is "/email-otp/verify-email" | "/sign-in/email-otp" | "/email-otp/request-email-change";
+      signal: "$sessionSignal";
+    }[];
+    $ERROR_CODES: {
+      OTP_EXPIRED: _$better_auth0.RawError<"OTP_EXPIRED">;
+      INVALID_OTP: _$better_auth0.RawError<"INVALID_OTP">;
+      TOO_MANY_ATTEMPTS: _$better_auth0.RawError<"TOO_MANY_ATTEMPTS">;
+    };
+  } | {
+    id: "passkey";
+    version: string;
+    $InferServerPlugin: ReturnType<(options?: _$_better_auth_passkey0.PasskeyOptions | undefined) => {
+      id: "passkey";
+      version: string;
+      endpoints: {
+        generatePasskeyRegistrationOptions: _$better_auth0.StrictEndpoint<"/passkey/generate-register-options", {
+          method: "GET";
+          use: _$better_auth0.Middleware<_$better_auth0.MiddlewareOptions, (inputContext: _$better_auth0.MiddlewareInputContext<_$better_auth0.MiddlewareOptions>) => Promise<{
+            session: {
+              session: Record<string, any> & {
+                id: string;
+                createdAt: Date;
+                updatedAt: Date;
+                userId: string;
+                expiresAt: Date;
+                token: string;
+                ipAddress?: string | null | undefined;
+                userAgent?: string | null | undefined;
+              };
+              user: Record<string, any> & {
+                id: string;
+                createdAt: Date;
+                updatedAt: Date;
+                email: string;
+                emailVerified: boolean;
+                name: string;
+                image?: string | null | undefined;
+              };
+            };
+          }>>[];
+          query: _$zod.ZodOptional<_$zod.ZodObject<{
+            authenticatorAttachment: _$zod.ZodOptional<_$zod.ZodEnum<{
+              platform: "platform";
+              "cross-platform": "cross-platform";
+            }>>;
+            name: _$zod.ZodOptional<_$zod.ZodString>;
+            context: _$zod.ZodOptional<_$zod.ZodString>;
+          }, _$zod_v4_core0.$strip>>;
+          metadata: {
+            openapi: {
+              operationId: string;
+              description: string;
+              parameters: _$better_auth0.OpenAPIParameter[];
+              responses: {
+                200: {
+                  description: string;
+                  content: {
+                    "application/json": {
+                      schema: {
+                        type: "object";
+                        properties: {
+                          challenge: {
+                            type: string;
+                          };
+                          rp: {
+                            type: string;
+                            properties: {
+                              name: {
+                                type: string;
+                              };
+                              id: {
+                                type: string;
+                              };
+                            };
+                          };
+                          user: {
+                            type: string;
+                            properties: {
+                              id: {
+                                type: string;
+                              };
+                              name: {
+                                type: string;
+                              };
+                              displayName: {
+                                type: string;
+                              };
+                            };
+                          };
+                          pubKeyCredParams: {
+                            type: string;
+                            items: {
+                              type: string;
+                              properties: {
+                                type: {
+                                  type: string;
+                                };
+                                alg: {
+                                  type: string;
+                                };
+                              };
+                            };
+                          };
+                          timeout: {
+                            type: string;
+                          };
+                          excludeCredentials: {
+                            type: string;
+                            items: {
+                              type: string;
+                              properties: {
+                                id: {
+                                  type: string;
+                                };
+                                type: {
+                                  type: string;
+                                };
+                                transports: {
+                                  type: string;
+                                  items: {
+                                    type: string;
+                                  };
+                                };
+                              };
+                            };
+                          };
+                          authenticatorSelection: {
+                            type: string;
+                            properties: {
+                              authenticatorAttachment: {
+                                type: string;
+                              };
+                              requireResidentKey: {
+                                type: string;
+                              };
+                              userVerification: {
+                                type: string;
+                              };
+                            };
+                          };
+                          attestation: {
+                            type: string;
+                          };
+                          extensions: {
+                            type: string;
+                          };
+                        };
+                      };
+                    };
+                  };
+                };
+              };
+            };
+          };
+        }, _$_better_auth_passkey_client0.PublicKeyCredentialCreationOptionsJSON>;
+        generatePasskeyAuthenticationOptions: _$better_auth0.StrictEndpoint<"/passkey/generate-authenticate-options", {
+          method: "GET";
+          metadata: {
+            openapi: {
+              operationId: string;
+              description: string;
+              responses: {
+                200: {
+                  description: string;
+                  content: {
+                    "application/json": {
+                      schema: {
+                        type: "object";
+                        properties: {
+                          challenge: {
+                            type: string;
+                          };
+                          rp: {
+                            type: string;
+                            properties: {
+                              name: {
+                                type: string;
+                              };
+                              id: {
+                                type: string;
+                              };
+                            };
+                          };
+                          user: {
+                            type: string;
+                            properties: {
+                              id: {
+                                type: string;
+                              };
+                              name: {
+                                type: string;
+                              };
+                              displayName: {
+                                type: string;
+                              };
+                            };
+                          };
+                          timeout: {
+                            type: string;
+                          };
+                          allowCredentials: {
+                            type: string;
+                            items: {
+                              type: string;
+                              properties: {
+                                id: {
+                                  type: string;
+                                };
+                                type: {
+                                  type: string;
+                                };
+                                transports: {
+                                  type: string;
+                                  items: {
+                                    type: string;
+                                  };
+                                };
+                              };
+                            };
+                          };
+                          userVerification: {
+                            type: string;
+                          };
+                          authenticatorSelection: {
+                            type: string;
+                            properties: {
+                              authenticatorAttachment: {
+                                type: string;
+                              };
+                              requireResidentKey: {
+                                type: string;
+                              };
+                              userVerification: {
+                                type: string;
+                              };
+                            };
+                          };
+                          extensions: {
+                            type: string;
+                          };
+                        };
+                      };
+                    };
+                  };
+                };
+              };
+            };
+          };
+        }, _$_better_auth_passkey_client0.PublicKeyCredentialRequestOptionsJSON>;
+        verifyPasskeyRegistration: _$better_auth0.StrictEndpoint<"/passkey/verify-registration", {
+          method: "POST";
+          body: _$zod.ZodObject<{
+            response: _$zod.ZodAny;
+            name: _$zod.ZodOptional<_$zod.ZodString>;
+            createSession: _$zod.ZodOptional<_$zod.ZodBoolean>;
+          }, _$zod_v4_core0.$strip>;
+          use: _$better_auth0.Middleware<_$better_auth0.MiddlewareOptions, (inputContext: _$better_auth0.MiddlewareInputContext<_$better_auth0.MiddlewareOptions>) => Promise<{
+            session: {
+              session: Record<string, any> & {
+                id: string;
+                createdAt: Date;
+                updatedAt: Date;
+                userId: string;
+                expiresAt: Date;
+                token: string;
+                ipAddress?: string | null | undefined;
+                userAgent?: string | null | undefined;
+              };
+              user: Record<string, any> & {
+                id: string;
+                createdAt: Date;
+                updatedAt: Date;
+                email: string;
+                emailVerified: boolean;
+                name: string;
+                image?: string | null | undefined;
+              };
+            };
+          }>>[];
+          metadata: {
+            openapi: {
+              operationId: string;
+              description: string;
+              responses: {
+                200: {
+                  description: string;
+                  content: {
+                    "application/json": {
+                      schema: {
+                        readonly type: "object";
+                        readonly allOf: readonly [{
+                          readonly $ref: "#/components/schemas/Passkey";
+                        }, {
+                          readonly type: "object";
+                          readonly properties: {
+                            readonly session: {
+                              readonly $ref: "#/components/schemas/Session";
+                            };
+                            readonly user: {
+                              readonly $ref: "#/components/schemas/User";
+                            };
+                          };
+                        }];
+                      };
+                    };
+                  };
+                };
+                400: {
+                  description: string;
+                };
+              };
+            };
+          };
+        }, _$_better_auth_passkey0.Passkey>;
+        verifyPasskeyAuthentication: _$better_auth0.StrictEndpoint<"/passkey/verify-authentication", {
+          method: "POST";
+          body: _$zod.ZodObject<{
+            response: _$zod.ZodRecord<_$zod.ZodAny, _$zod.ZodAny>;
+          }, _$zod_v4_core0.$strip>;
+          metadata: {
+            openapi: {
+              operationId: string;
+              description: string;
+              responses: {
+                200: {
+                  description: string;
+                  content: {
+                    "application/json": {
+                      schema: {
+                        type: "object";
+                        properties: {
+                          session: {
+                            $ref: string;
+                          };
+                          user: {
+                            $ref: string;
+                          };
+                        };
+                      };
+                    };
+                  };
+                };
+              };
+            };
+            $Infer: {
+              body: {
+                response: _$_better_auth_passkey_client0.AuthenticationResponseJSON;
+              };
+            };
+          };
+        }, {
+          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;
+          };
+        }>;
+        listPasskeys: _$better_auth0.StrictEndpoint<"/passkey/list-user-passkeys", {
+          method: "GET";
+          use: _$better_auth0.Middleware<_$better_auth0.MiddlewareOptions, (inputContext: _$better_auth0.MiddlewareInputContext<_$better_auth0.MiddlewareOptions>) => Promise<{
+            session: {
+              session: Record<string, any> & {
+                id: string;
+                createdAt: Date;
+                updatedAt: Date;
+                userId: string;
+                expiresAt: Date;
+                token: string;
+                ipAddress?: string | null | undefined;
+                userAgent?: string | null | undefined;
+              };
+              user: Record<string, any> & {
+                id: string;
+                createdAt: Date;
+                updatedAt: Date;
+                email: string;
+                emailVerified: boolean;
+                name: string;
+                image?: string | null | undefined;
+              };
+            };
+          }>>[];
+          metadata: {
+            openapi: {
+              description: string;
+              responses: {
+                "200": {
+                  description: string;
+                  content: {
+                    "application/json": {
+                      schema: {
+                        type: "array";
+                        items: {
+                          $ref: string;
+                          required: string[];
+                        };
+                        description: string;
+                      };
+                    };
+                  };
+                };
+              };
+            };
+          };
+        }, _$_better_auth_passkey0.Passkey[]>;
+        deletePasskey: _$better_auth0.StrictEndpoint<"/passkey/delete-passkey", {
+          method: "POST";
+          body: _$zod.ZodObject<{
+            id: _$zod.ZodString;
+          }, _$zod_v4_core0.$strip>;
+          use: (_$better_auth0.Middleware<_$better_auth0.MiddlewareOptions, (inputContext: _$better_auth0.MiddlewareInputContext<_$better_auth0.MiddlewareOptions>) => Promise<{
+            session: {
+              session: Record<string, any> & {
+                id: string;
+                createdAt: Date;
+                updatedAt: Date;
+                userId: string;
+                expiresAt: Date;
+                token: string;
+                ipAddress?: string | null | undefined;
+                userAgent?: string | null | undefined;
+              };
+              user: Record<string, any> & {
+                id: string;
+                createdAt: Date;
+                updatedAt: Date;
+                email: string;
+                emailVerified: boolean;
+                name: string;
+                image?: string | null | undefined;
+              };
+            };
+          }>> | _$better_auth0.Middleware<_$better_auth0.MiddlewareOptions, (inputContext: _$better_auth0.MiddlewareInputContext<_$better_auth0.MiddlewareOptions>) => Promise<{
+            verifiedResource: {};
+          }>>)[];
+          metadata: {
+            openapi: {
+              description: string;
+              responses: {
+                "200": {
+                  description: string;
+                  content: {
+                    "application/json": {
+                      schema: {
+                        type: "object";
+                        properties: {
+                          status: {
+                            type: string;
+                            description: string;
+                          };
+                        };
+                        required: string[];
+                      };
+                    };
+                  };
+                };
+              };
+            };
+          };
+        }, {
+          status: boolean;
+        }>;
+        updatePasskey: _$better_auth0.StrictEndpoint<"/passkey/update-passkey", {
+          method: "POST";
+          body: _$zod.ZodObject<{
+            id: _$zod.ZodString;
+            name: _$zod.ZodString;
+          }, _$zod_v4_core0.$strip>;
+          use: (_$better_auth0.Middleware<_$better_auth0.MiddlewareOptions, (inputContext: _$better_auth0.MiddlewareInputContext<_$better_auth0.MiddlewareOptions>) => Promise<{
+            session: {
+              session: Record<string, any> & {
+                id: string;
+                createdAt: Date;
+                updatedAt: Date;
+                userId: string;
+                expiresAt: Date;
+                token: string;
+                ipAddress?: string | null | undefined;
+                userAgent?: string | null | undefined;
+              };
+              user: Record<string, any> & {
+                id: string;
+                createdAt: Date;
+                updatedAt: Date;
+                email: string;
+                emailVerified: boolean;
+                name: string;
+                image?: string | null | undefined;
+              };
+            };
+          }>> | _$better_auth0.Middleware<_$better_auth0.MiddlewareOptions, (inputContext: _$better_auth0.MiddlewareInputContext<_$better_auth0.MiddlewareOptions>) => Promise<{
+            verifiedResource: {};
+          }>>)[];
+          metadata: {
+            openapi: {
+              description: string;
+              responses: {
+                "200": {
+                  description: string;
+                  content: {
+                    "application/json": {
+                      schema: {
+                        type: "object";
+                        properties: {
+                          passkey: {
+                            $ref: string;
+                          };
+                        };
+                        required: string[];
+                      };
+                    };
+                  };
+                };
+              };
+            };
+          };
+        }, {
+          passkey: _$_better_auth_passkey0.Passkey;
+        }>;
+      };
+      schema: {
+        passkey: {
+          fields: {
+            name: {
+              type: "string";
+              required: false;
+            };
+            publicKey: {
+              type: "string";
+              required: true;
+            };
+            userId: {
+              type: "string";
+              references: {
+                model: string;
+                field: string;
+              };
+              required: true;
+              index: true;
+            };
+            credentialID: {
+              type: "string";
+              required: true;
+              index: true;
+            };
+            counter: {
+              type: "number";
+              required: true;
+            };
+            deviceType: {
+              type: "string";
+              required: true;
+            };
+            backedUp: {
+              type: "boolean";
+              required: true;
+            };
+            transports: {
+              type: "string";
+              required: false;
+            };
+            createdAt: {
+              type: "date";
+              required: false;
+            };
+            aaguid: {
+              type: "string";
+              required: false;
+            };
+          };
+        };
+      };
+      $ERROR_CODES: {
+        CHALLENGE_NOT_FOUND: _$better_auth0.RawError<"CHALLENGE_NOT_FOUND">;
+        YOU_ARE_NOT_ALLOWED_TO_REGISTER_THIS_PASSKEY: _$better_auth0.RawError<"YOU_ARE_NOT_ALLOWED_TO_REGISTER_THIS_PASSKEY">;
+        FAILED_TO_VERIFY_REGISTRATION: _$better_auth0.RawError<"FAILED_TO_VERIFY_REGISTRATION">;
+        PASSKEY_NOT_FOUND: _$better_auth0.RawError<"PASSKEY_NOT_FOUND">;
+        AUTHENTICATION_FAILED: _$better_auth0.RawError<"AUTHENTICATION_FAILED">;
+        UNABLE_TO_CREATE_SESSION: _$better_auth0.RawError<"UNABLE_TO_CREATE_SESSION">;
+        USER_NOT_FOUND: _$better_auth0.RawError<"USER_NOT_FOUND">;
+        FAILED_TO_UPDATE_PASSKEY: _$better_auth0.RawError<"FAILED_TO_UPDATE_PASSKEY">;
+        PREVIOUSLY_REGISTERED: _$better_auth0.RawError<"PREVIOUSLY_REGISTERED">;
+        REGISTRATION_CANCELLED: _$better_auth0.RawError<"REGISTRATION_CANCELLED">;
+        AUTH_CANCELLED: _$better_auth0.RawError<"AUTH_CANCELLED">;
+        UNKNOWN_ERROR: _$better_auth0.RawError<"UNKNOWN_ERROR">;
+        SESSION_REQUIRED: _$better_auth0.RawError<"SESSION_REQUIRED">;
+        RESOLVE_USER_REQUIRED: _$better_auth0.RawError<"RESOLVE_USER_REQUIRED">;
+        RESOLVED_USER_INVALID: _$better_auth0.RawError<"RESOLVED_USER_INVALID">;
+      };
+      options: _$_better_auth_passkey0.PasskeyOptions | undefined;
+    }>;
+    getActions: ($fetch: _$better_auth_client0.BetterFetch, $store: _$better_auth0.ClientStore) => {
+      signIn: {
+        passkey: (opts?: {
+          autoFill?: boolean;
+          extensions?: _$_better_auth_passkey_client0.AuthenticationExtensionsClientInputs;
+          returnWebAuthnResponse?: boolean;
+          fetchOptions?: _$better_auth0.ClientFetchOption;
+        } | undefined, options?: _$better_auth0.ClientFetchOption | undefined) => Promise<{
+          data: null;
+          error: {
+            message?: string | undefined;
+            status: number;
+            statusText: string;
+          };
+        } | {
+          data: {
+            session: _$better_auth0.Session;
+            user: _$better_auth0.User;
+          };
+          error: null;
+        } | {
+          data: null;
+          error: {
+            code: string;
+            message: string;
+            status: number;
+            statusText: string;
+          };
+        } | {
+          webauthn: {
+            response: _$_better_auth_passkey_client0.AuthenticationResponseJSON;
+            clientExtensionResults: _$_better_auth_passkey_client0.AuthenticationExtensionsClientOutputs;
+          };
+          data: null;
+          error: {
+            message?: string | undefined;
+            status: number;
+            statusText: string;
+          };
+        } | {
+          webauthn: {
+            response: _$_better_auth_passkey_client0.AuthenticationResponseJSON;
+            clientExtensionResults: _$_better_auth_passkey_client0.AuthenticationExtensionsClientOutputs;
+          };
+          data: {
+            session: _$better_auth0.Session;
+            user: _$better_auth0.User;
+          };
+          error: null;
+        }>;
+      };
+      passkey: {
+        addPasskey: (opts?: {
+          fetchOptions?: _$better_auth0.ClientFetchOption;
+          name?: string;
+          authenticatorAttachment?: "platform" | "cross-platform";
+          context?: string | null;
+          createSession?: boolean;
+          extensions?: _$_better_auth_passkey_client0.AuthenticationExtensionsClientInputs;
+          useAutoRegister?: boolean;
+          returnWebAuthnResponse?: boolean;
+        } | undefined, fetchOpts?: _$better_auth0.ClientFetchOption | undefined) => Promise<{
+          data: null;
+          error: {
+            message?: string | undefined;
+            status: number;
+            statusText: string;
+          };
+        } | {
+          data: _$_better_auth_passkey0.Passkey & {
+            session?: _$better_auth0.Session;
+            user?: _$better_auth0.User;
+          };
+          error: null;
+        } | {
+          webauthn: {
+            response: _$_better_auth_passkey_client0.RegistrationResponseJSON;
+            clientExtensionResults: _$_better_auth_passkey_client0.AuthenticationExtensionsClientOutputs;
+          };
+          data: _$_better_auth_passkey0.Passkey & {
+            session?: _$better_auth0.Session;
+            user?: _$better_auth0.User;
+          };
+          error: null;
+        } | {
+          data: null;
+          error: {
+            code: string;
+            message: string;
+            status: number;
+            statusText: string;
+          };
+        }>;
+      };
+      $Infer: {
+        Passkey: _$_better_auth_passkey0.Passkey;
+      };
+    };
+    getAtoms($fetch: _$better_auth_client0.BetterFetch): {
+      listPasskeys: _$better_auth_client0.AuthQueryAtom<_$_better_auth_passkey0.Passkey[]>;
+      $listPasskeys: _$better_auth_client0.PreinitializedWritableAtom<any> & object;
+    };
+    pathMethods: {
+      "/passkey/register": "POST";
+      "/passkey/authenticate": "POST";
+    };
+    atomListeners: ({
+      matcher(path: string): path is "/passkey/delete-passkey" | "/passkey/update-passkey" | "/passkey/verify-registration" | "/sign-out";
+      signal: "$listPasskeys";
+    } | {
+      matcher: (path: string) => path is "/passkey/verify-authentication";
+      signal: "$sessionSignal";
+    })[];
+    $ERROR_CODES: {
+      CHALLENGE_NOT_FOUND: _$better_auth0.RawError<"CHALLENGE_NOT_FOUND">;
+      YOU_ARE_NOT_ALLOWED_TO_REGISTER_THIS_PASSKEY: _$better_auth0.RawError<"YOU_ARE_NOT_ALLOWED_TO_REGISTER_THIS_PASSKEY">;
+      FAILED_TO_VERIFY_REGISTRATION: _$better_auth0.RawError<"FAILED_TO_VERIFY_REGISTRATION">;
+      PASSKEY_NOT_FOUND: _$better_auth0.RawError<"PASSKEY_NOT_FOUND">;
+      AUTHENTICATION_FAILED: _$better_auth0.RawError<"AUTHENTICATION_FAILED">;
+      UNABLE_TO_CREATE_SESSION: _$better_auth0.RawError<"UNABLE_TO_CREATE_SESSION">;
+      USER_NOT_FOUND: _$better_auth0.RawError<"USER_NOT_FOUND">;
+      FAILED_TO_UPDATE_PASSKEY: _$better_auth0.RawError<"FAILED_TO_UPDATE_PASSKEY">;
+      PREVIOUSLY_REGISTERED: _$better_auth0.RawError<"PREVIOUSLY_REGISTERED">;
+      REGISTRATION_CANCELLED: _$better_auth0.RawError<"REGISTRATION_CANCELLED">;
+      AUTH_CANCELLED: _$better_auth0.RawError<"AUTH_CANCELLED">;
+      UNKNOWN_ERROR: _$better_auth0.RawError<"UNKNOWN_ERROR">;
+      SESSION_REQUIRED: _$better_auth0.RawError<"SESSION_REQUIRED">;
+      RESOLVE_USER_REQUIRED: _$better_auth0.RawError<"RESOLVE_USER_REQUIRED">;
+      RESOLVED_USER_INVALID: _$better_auth0.RawError<"RESOLVED_USER_INVALID">;
+    };
+  })[];
+}>;
+type BetterAuthClient = ReturnType<typeof createBetterAuthClient>;
+//#endregion
 //#region src/analytics.d.ts
+/**
+ * Re-exported as a local binding: re-exporting the const directly from the
+ * bundled `@us-auth/types` package trips the declaration bundler.
+ */
+declare const ANALYTICS_EVENTS: {
+  readonly USER_SIGNED_UP: "user signed up";
+  readonly USER_LOGGED_IN: "user logged in";
+  readonly TRIAL_STARTED: "trial started";
+  readonly CHECKOUT_STARTED: "checkout started";
+  readonly CHECKOUT_COMPLETED: "checkout completed";
+  readonly FEATURE_USED: "feature used";
+};
 interface PostHogAnalyticsClient {
   capture: (event: string, properties?: Record<string, unknown>) => void;
   register?: (properties: Record<string, unknown>) => void;
@@ -161,6 +1725,178 @@ declare function captureCheckoutStarted(ph: PostHogAnalyticsClient | null | unde
   product?: AnalyticsProduct;
 }): void;
 //#endregion
+//#region src/consent/store.d.ts
+type Listener = () => void;
+/**
+ * The imperative consent API. This is the single source of truth for the
+ * banner and works without React.
+ */
+declare function getConsent(): ConsentState;
+declare function isConsentPending(): boolean;
+declare function subscribeConsent(listener: Listener): () => void;
+/** Overrides the cookie domain; `undefined` derives it, `""` forces host-only. */
+declare function configureConsentDomain(domain: string | undefined): void;
+/** Parent domain for consent and legacy-tracking cookie expiry. */
+declare function resolveConsentCookieDomain(): string | undefined;
+/** Writes the decision and notifies subscribers. The only consent writer. */
+declare function setConsent(consent: TrackingConsent): void;
+/** Re-reads the cookie and notifies only when the decision changed. */
+declare function refreshConsent(): void;
+//#endregion
+//#region src/consent/useTrackingConsent.d.ts
+interface TrackingConsentApi {
+  consent: ConsentState;
+  pending: boolean;
+  setConsent: (consent: {
+    analytics: boolean;
+    marketing: boolean;
+  }) => void;
+}
+/**
+ * Banner-facing hook. Works without `TrackingProvider` because it reads the
+ * consent store directly.
+ */
+declare function useTrackingConsent(): TrackingConsentApi;
+//#endregion
+//#region src/tracking/consentAction.d.ts
+/**
+ * Pure mapping from consent state to the PostHog consent action.
+ * Kept separate from the PostHog import so it is trivially testable.
+ */
+declare function posthogConsentAction(consent: ConsentState): "opt_in" | "opt_out";
+//#endregion
+//#region src/tracking/posthog.d.ts
+interface PostHogConfigInput {
+  apiKey: string;
+  apiHost: string;
+  uiHost?: string;
+}
+declare function getOrInitPostHog(config: PostHogConfigInput): PostHog | null;
+/** Returns the PostHog singleton initialized by `TrackingProvider`, if any. */
+declare function getPostHog(): PostHog | null;
+/**
+ * Mirrors the `uninspired_consent` decision into PostHog's own consent state.
+ *
+ * - granted  → `opt_in_capturing()` upgrades to cookies + identify live
+ * - pending  → `opt_out_capturing()` keeps capturing cookielessly
+ * - denied   → same as pending (cookieless capture continues)
+ */
+declare function syncPostHogConsent(ph: PostHog | null, consent: ConsentState): void;
+//#endregion
+//#region src/tracking/TrackingClient.d.ts
+interface TrackingClientOptions {
+  product: AnalyticsProduct;
+  /** `null` disables PostHog entirely (product apps without analytics config). */
+  posthog: PostHogConfigInput | null;
+  metaPixelId?: string;
+  /** `undefined` derives the domain, `""` forces a host-only cookie. */
+  consentCookieDomain?: string;
+}
+interface ViewContentOptions {
+  contentId: string;
+  value?: number;
+  currency?: string;
+}
+interface InitiateCheckoutOptions {
+  contentIds?: string[];
+  value?: number;
+  currency?: string;
+}
+interface PurchaseOptions {
+  value?: number;
+  currency?: string;
+  contentIds?: string[];
+  /** Paddle transaction id — lets Meta dedupe repeated browser events. */
+  eventId?: string;
+}
+/**
+ * Owns PostHog initialization and the Meta Pixel lifecycle for an app.
+ *
+ * PostHog capture always works (cookieless while pending/denied, full when
+ * granted); `identify` and every Meta call are consent-gated.
+ */
+declare class TrackingClient {
+  #private;
+  readonly ph: PostHog | null;
+  readonly product: AnalyticsProduct;
+  constructor(options: TrackingClientOptions);
+  start(): void;
+  stop(): void;
+  getConsent(): ConsentState;
+  setConsent(consent: TrackingConsent): void;
+  capture(event: string, properties?: Record<string, unknown>): void;
+  captureException(error: unknown, properties?: Record<string, unknown>): void;
+  identify(userId: string): void;
+  reset(): void;
+  getFeatureFlag(key: string): boolean | string | undefined;
+  registerProduct(product: AnalyticsProduct): void;
+  captureFeatureUsed(featureName: string, extra?: Record<string, unknown>): void;
+  captureCheckoutStarted(options: {
+    plan: string;
+    product?: AnalyticsProduct;
+  }): void;
+  trackPageView(): void;
+  trackViewContent({
+    contentId,
+    value,
+    currency
+  }: ViewContentOptions): void;
+  trackInitiateCheckout({
+    contentIds,
+    value,
+    currency
+  }?: InitiateCheckoutOptions): void;
+  trackPurchase({
+    value,
+    currency,
+    contentIds,
+    eventId
+  }?: PurchaseOptions): void;
+}
+//#endregion
+//#region src/tracking/TrackingProvider.d.ts
+interface TrackingProviderProps extends TrackingClientOptions, PropsWithChildren {}
+/**
+ * Mount once per app, above `AuthProvider`. Owns PostHog init and the Meta
+ * Pixel lifecycle, both driven by the shared consent cookie.
+ */
+declare const TrackingProvider: ({
+  children,
+  ...options
+}: TrackingProviderProps) => _$react.JSX.Element;
+//#endregion
+//#region src/tracking/useTracking.d.ts
+/**
+ * Returns the app's `TrackingClient`, or `null` when no `TrackingProvider`
+ * wraps the tree (in which case all analytics no-op).
+ */
+declare function useTracking(): TrackingClient | null;
+//#endregion
+//#region src/tracking/metaPixel.d.ts
+/** Injects the Meta Pixel base code and fires an initial PageView. Idempotent. */
+declare function loadMetaPixel(pixelId: string): void;
+declare function isMetaPixelLoaded(): boolean;
+/**
+ * Tells an already-loaded pixel to stop sending when marketing consent is
+ * withdrawn. Does not unload the script or clear cookies.
+ */
+declare function revokeMetaPixelConsent(): void;
+/** Fires a standard pixel event; `eventId` lets Meta dedupe on reloads. */
+declare function trackMetaPixel(event: string, params?: Record<string, unknown>, eventId?: string): void;
+//#endregion
+//#region src/tracking/redaction.d.ts
+type RedactableEvent = {
+  properties?: Record<string, unknown>;
+};
+/**
+ * Strips URL query strings and short-link passphrases from every event before
+ * it leaves the browser. Together with `mask_all_text` this keeps autocapture
+ * and pageviews PII-free without disabling them.
+ *
+ * Applies in every consent mode: it is PII hygiene, not a consent mitigation.
+ */
+declare function redactBeforeSend<T extends RedactableEvent | null>(event: T): T;
+//#endregion
 //#region src/react/AuthContext.d.ts
 type AuthContextType = {
   session: Session | null;
@@ -172,9 +1908,6 @@ type AuthContextType = {
   signOut: AuthClient["signOut"];
   getLoginUrl: AuthClient["getLoginUrl"];
   getCheckoutUrl: AuthClient["getCheckoutUrl"];
-  trackMetaEvent: AuthClient["trackMetaEvent"];
-  trackViewContent: AuthClient["trackViewContent"];
-  getMetaAttribution: AuthClient["getMetaAttribution"];
   captureFeatureUsed: (featureName: string, extra?: Record<string, unknown>) => void;
   captureCheckoutStarted: (options: {
     plan: string;
@@ -206,7 +1939,7 @@ declare const AuthProvider: ({
   initialPurchases,
   authClient: providedAuthClient,
   queryClient: providedQueryClient
-}: AuthProviderProps) => _$react_jsx_runtime0.JSX.Element;
+}: AuthProviderProps) => _$react.JSX.Element;
 //#endregion
 //#region src/react/useAuth.d.ts
 declare function useAuth(): {
@@ -219,9 +1952,6 @@ declare function useAuth(): {
   signOut: AuthClient["signOut"];
   getLoginUrl: AuthClient["getLoginUrl"];
   getCheckoutUrl: AuthClient["getCheckoutUrl"];
-  trackMetaEvent: AuthClient["trackMetaEvent"];
-  trackViewContent: AuthClient["trackViewContent"];
-  getMetaAttribution: AuthClient["getMetaAttribution"];
   captureFeatureUsed: (featureName: string, extra?: Record<string, unknown>) => void;
   captureCheckoutStarted: (options: {
     plan: string;
@@ -233,5 +1963,65 @@ declare function useAuth(): {
   isLoggedIn: boolean;
 };
 //#endregion
-export { ANALYTICS_EVENTS, ANALYTICS_PRODUCTS, type AnalyticsEvent, type AnalyticsProduct, AuthClient, AuthContext, AuthContextType, type AuthMethod, AuthProvider, AuthProviderProps, type MetaAttributionCookies, PostHogAnalyticsClient, type Session, type UserPurchases, buildFbcFromFbclid, captureCheckoutStarted, captureFeatureUsed, captureMetaClickId, getMetaCookieDomain, isAnalyticsProduct, parseMetaAttributionFromCookieHeader, readMetaAttributionCookies, registerProduct, useAuth };
+//#region src/react/useEmailOtpLoginFlow.d.ts
+type EmailOtpAuthClient = {
+  emailOtp: {
+    sendVerificationOtp: (input: {
+      email: string;
+      type: "sign-in";
+    }) => Promise<{
+      error?: unknown;
+    }>;
+  };
+  signIn: {
+    emailOtp: (input: {
+      email: string;
+      otp: string;
+    }) => Promise<{
+      error?: unknown;
+    }>;
+  };
+};
+type EmailOtpLoginFlowOptions = {
+  authClient: EmailOtpAuthClient;
+  onVerified: () => void | Promise<void>;
+  onSendSuccess?: () => void;
+  onSendError?: (error: unknown) => void;
+  onVerifyError?: (error: unknown) => void;
+  resendCooldownSeconds?: number;
+};
+declare function useEmailOtpLoginFlow({
+  authClient,
+  onVerified,
+  onSendSuccess,
+  onSendError,
+  onVerifyError,
+  resendCooldownSeconds
+}: EmailOtpLoginFlowOptions): {
+  step: "email" | "otp";
+  email: string;
+  setEmail: _$react.Dispatch<_$react.SetStateAction<string>>;
+  otp: string;
+  setOtp: _$react.Dispatch<_$react.SetStateAction<string>>;
+  emailValid: boolean;
+  otpValid: boolean;
+  submitting: boolean;
+  verifying: boolean;
+  resending: boolean;
+  remainingSeconds: number;
+  isCoolingDown: boolean;
+  submitEmail: () => Promise<void>;
+  resendOtp: () => Promise<void>;
+  verifyOtp: () => Promise<void>;
+  backToEmail: () => void;
+  setNow: _$react.Dispatch<_$react.SetStateAction<number>>;
+  availableAt: number;
+};
+//#endregion
+//#region src/react/resendCooldown.d.ts
+declare const RESEND_COOLDOWN_SECONDS = 30;
+declare function remainingCooldownSeconds(availableAt: number, now: number): number;
+declare function resendButtonLabel(label: string, remainingSeconds: number): string;
+//#endregion
+export { ANALYTICS_EVENTS, type AnalyticsProduct, AuthClient, AuthContext, AuthContextType, type AuthMethod, AuthProvider, AuthProviderProps, type BetterAuthClient, EmailOtpAuthClient, EmailOtpLoginFlowOptions, type InitiateCheckoutOptions, PostHogAnalyticsClient, type PostHogConfigInput, PostHogProvider, type PurchaseOptions, RESEND_COOLDOWN_SECONDS, type Session, TrackingClient, type TrackingClientOptions, type TrackingConsentApi, TrackingProvider, type TrackingProviderProps, type UserPurchases, type ViewContentOptions, captureCheckoutStarted, captureFeatureUsed, configureConsentDomain, createBetterAuthClient, getConsent, getOrInitPostHog, getPostHog, isAnalyticsProduct, isConsentPending, isMetaPixelLoaded, loadMetaPixel, posthogConsentAction, redactBeforeSend, refreshConsent, registerProduct, remainingCooldownSeconds, resendButtonLabel, resolveConsentCookieDomain, revokeMetaPixelConsent, setConsent, subscribeConsent, syncPostHogConsent, trackMetaPixel, useAuth, useEmailOtpLoginFlow, useFeatureFlagEnabled, useFeatureFlagVariantKey, usePostHog, useTracking, useTrackingConsent };
 //# sourceMappingURL=index.d.ts.map