@authsome/ui-core 0.1.8 → 1.0.0

package/dist/index.mjs

@@ -1,1734 +0,0 @@
-// src/types/auth.ts
-var AuthState = /* @__PURE__ */ ((AuthState2) => {
-  AuthState2["AUTHENTICATED"] = "authenticated";
-  AuthState2["UNAUTHENTICATED"] = "unauthenticated";
-  AuthState2["LOADING"] = "loading";
-  AuthState2["ERROR"] = "error";
-  return AuthState2;
-})(AuthState || {});
-var AuthErrorType = /* @__PURE__ */ ((AuthErrorType2) => {
-  AuthErrorType2["INVALID_CREDENTIALS"] = "invalid_credentials";
-  AuthErrorType2["USER_NOT_FOUND"] = "user_not_found";
-  AuthErrorType2["USER_ALREADY_EXISTS"] = "user_already_exists";
-  AuthErrorType2["INVALID_TOKEN"] = "invalid_token";
-  AuthErrorType2["TOKEN_EXPIRED"] = "token_expired";
-  AuthErrorType2["NETWORK_ERROR"] = "network_error";
-  AuthErrorType2["VALIDATION_ERROR"] = "validation_error";
-  AuthErrorType2["MFA_REQUIRED"] = "mfa_required";
-  AuthErrorType2["EMAIL_NOT_VERIFIED"] = "email_not_verified";
-  AuthErrorType2["PHONE_NOT_VERIFIED"] = "phone_not_verified";
-  AuthErrorType2["RATE_LIMIT_EXCEEDED"] = "rate_limit_exceeded";
-  AuthErrorType2["UNKNOWN_ERROR"] = "unknown_error";
-  return AuthErrorType2;
-})(AuthErrorType || {});
-var AuthError = class _AuthError extends Error {
-  constructor(message, type = "unknown_error" /* UNKNOWN_ERROR */, options) {
-    super(message);
-    this.name = "AuthError";
-    this.type = type;
-    this.details = options?.details;
-    this.code = options?.code;
-    this.originalError = options?.originalError;
-    if (Error.captureStackTrace) {
-      Error.captureStackTrace(this, _AuthError);
-    }
-  }
-};
-var OAuthProvider = /* @__PURE__ */ ((OAuthProvider2) => {
-  OAuthProvider2["GOOGLE"] = "google";
-  OAuthProvider2["GITHUB"] = "github";
-  OAuthProvider2["FACEBOOK"] = "facebook";
-  OAuthProvider2["TWITTER"] = "twitter";
-  OAuthProvider2["MICROSOFT"] = "microsoft";
-  OAuthProvider2["APPLE"] = "apple";
-  OAuthProvider2["LINKEDIN"] = "linkedin";
-  OAuthProvider2["DISCORD"] = "discord";
-  return OAuthProvider2;
-})(OAuthProvider || {});
-var TwoFactorMethod = /* @__PURE__ */ ((TwoFactorMethod2) => {
-  TwoFactorMethod2["TOTP"] = "totp";
-  TwoFactorMethod2["SMS"] = "sms";
-  TwoFactorMethod2["EMAIL"] = "email";
-  TwoFactorMethod2["BACKUP_CODE"] = "backup_code";
-  return TwoFactorMethod2;
-})(TwoFactorMethod || {});
-
-// src/types/storage.ts
-var LocalStorageAdapter = class {
-  getItem(key) {
-    if (typeof window === "undefined") return null;
-    return window.localStorage.getItem(key);
-  }
-  setItem(key, value) {
-    if (typeof window === "undefined") return;
-    window.localStorage.setItem(key, value);
-  }
-  removeItem(key) {
-    if (typeof window === "undefined") return;
-    window.localStorage.removeItem(key);
-  }
-  clear() {
-    if (typeof window === "undefined") return;
-    window.localStorage.clear();
-  }
-};
-var SessionStorageAdapter = class {
-  getItem(key) {
-    if (typeof window === "undefined") return null;
-    return window.sessionStorage.getItem(key);
-  }
-  setItem(key, value) {
-    if (typeof window === "undefined") return;
-    window.sessionStorage.setItem(key, value);
-  }
-  removeItem(key) {
-    if (typeof window === "undefined") return;
-    window.sessionStorage.removeItem(key);
-  }
-  clear() {
-    if (typeof window === "undefined") return;
-    window.sessionStorage.clear();
-  }
-};
-var MemoryStorageAdapter = class {
-  constructor() {
-    this.store = /* @__PURE__ */ new Map();
-  }
-  getItem(key) {
-    return this.store.get(key) ?? null;
-  }
-  setItem(key, value) {
-    this.store.set(key, value);
-  }
-  removeItem(key) {
-    this.store.delete(key);
-  }
-  clear() {
-    this.store.clear();
-  }
-};
-
-// src/types/observable.ts
-var Observable = class {
-  constructor(initialValue) {
-    this.listeners = /* @__PURE__ */ new Set();
-    this.value = initialValue;
-  }
-  /**
-   * Get current value
-   */
-  getValue() {
-    return this.value;
-  }
-  /**
-   * Set new value and notify listeners
-   */
-  setValue(newValue) {
-    if (this.value !== newValue) {
-      this.value = newValue;
-      this.notify();
-    }
-  }
-  /**
-   * Update value with a function
-   */
-  update(updater) {
-    this.setValue(updater(this.value));
-  }
-  /**
-   * Subscribe to value changes
-   */
-  subscribe(listener) {
-    this.listeners.add(listener);
-    listener(this.value);
-    return () => {
-      this.listeners.delete(listener);
-    };
-  }
-  /**
-   * Notify all listeners
-   */
-  notify() {
-    this.listeners.forEach((listener) => listener(this.value));
-  }
-  /**
-   * Clear all listeners
-   */
-  clearListeners() {
-    this.listeners.clear();
-  }
-  /**
-   * Get number of listeners
-   */
-  getListenerCount() {
-    return this.listeners.size;
-  }
-};
-
-// src/utils/errors.ts
-function createAuthError(type, message, details, code) {
-  return new AuthError(message, type, { details, code });
-}
-function isAuthError(error) {
-  return error instanceof AuthError;
-}
-function toAuthError(error) {
-  if (isAuthError(error)) {
-    return error;
-  }
-  if (error instanceof Error) {
-    return new AuthError(error.message, "unknown_error" /* UNKNOWN_ERROR */, {
-      details: {
-        originalError: error.name,
-        stack: error.stack
-      }
-    });
-  }
-  if (typeof error === "string") {
-    return new AuthError(error, "unknown_error" /* UNKNOWN_ERROR */);
-  }
-  return new AuthError(
-    "An unknown error occurred",
-    "unknown_error" /* UNKNOWN_ERROR */,
-    { details: { error } }
-  );
-}
-function isNetworkError(error) {
-  if (error instanceof Error) {
-    return error.name === "NetworkError" || error.message.includes("network") || error.message.includes("fetch");
-  }
-  return false;
-}
-function isUnauthenticatedError(error) {
-  if (isAuthError(error)) {
-    return error.type === "invalid_token" /* INVALID_TOKEN */ || error.type === "token_expired" /* TOKEN_EXPIRED */;
-  }
-  return false;
-}
-function isMFARequiredError(error) {
-  if (isAuthError(error)) {
-    return error.type === "mfa_required" /* MFA_REQUIRED */;
-  }
-  return false;
-}
-
-// src/locale/en.ts
-var enLocale = {
-  common: {
-    loading: "Loading...",
-    submit: "Submit",
-    cancel: "Cancel",
-    continue: "Continue",
-    back: "Back",
-    or: "or",
-    optional: "optional"
-  },
-  auth: {
-    signIn: "Sign In",
-    signUp: "Sign Up",
-    signOut: "Sign Out",
-    email: "Email",
-    password: "Password",
-    confirmPassword: "Confirm Password",
-    username: "Username",
-    phone: "Phone",
-    rememberMe: "Remember me",
-    forgotPassword: "Forgot password?",
-    continueWith: "Continue with {provider}",
-    orContinueWith: "Or continue with"
-  },
-  oauth: {
-    google: "Google",
-    github: "GitHub",
-    microsoft: "Microsoft",
-    facebook: "Facebook",
-    apple: "Apple",
-    discord: "Discord",
-    twitter: "Twitter",
-    linkedin: "LinkedIn",
-    chooseProvider: "Choose Your Provider",
-    signInPreferred: "Sign in with your preferred account"
-  },
-  magicLink: {
-    sendLink: "Send magic link",
-    checkEmail: "Check your email",
-    linkSent: "Magic link sent! Check your email to continue.",
-    enterEmail: "Enter your email to receive a magic link"
-  },
-  phone: {
-    enterPhone: "Enter your phone number",
-    sendCode: "Send code",
-    enterCode: "Enter verification code",
-    verifyPhone: "Verify phone number",
-    codeLabel: "Verification code"
-  },
-  mfa: {
-    required: "Two-factor authentication required",
-    selectMethod: "Select verification method",
-    verify: "Verify",
-    enterCode: "Enter verification code",
-    sms: "SMS",
-    authenticator: "Authenticator app",
-    email: "Email"
-  },
-  passkey: {
-    signInWith: "Sign in with passkey",
-    register: "Register passkey",
-    usePasskey: "Use passkey"
-  },
-  signUp: {
-    title: "Create Account",
-    subtitle: "Get started with your account",
-    haveAccount: "Already have an account?",
-    signInLink: "Sign in",
-    agreeToTerms: "I agree to the {terms}",
-    terms: "terms and conditions"
-  },
-  signIn: {
-    title: "Sign In",
-    subtitle: "Enter your email to continue",
-    noAccount: "Don't have an account?",
-    signUpLink: "Sign up",
-    enterEmail: "Enter your email to continue"
-  },
-  validation: {
-    emailRequired: "Email is required",
-    emailInvalid: "Invalid email address",
-    passwordRequired: "Password is required",
-    passwordTooShort: "Password must be at least {min} characters",
-    passwordRequireUppercase: "Password must contain an uppercase letter",
-    passwordRequireLowercase: "Password must contain a lowercase letter",
-    passwordRequireNumber: "Password must contain a number",
-    passwordRequireSpecial: "Password must contain a special character",
-    passwordMismatch: "Passwords do not match",
-    usernameRequired: "Username is required",
-    usernameInvalid: "Username must be 3-30 characters and contain only letters, numbers, underscores, and hyphens",
-    phoneRequired: "Phone number is required",
-    phoneInvalid: "Invalid phone number",
-    codeRequired: "Verification code is required",
-    codeInvalid: "Invalid verification code",
-    fieldRequired: "{field} is required",
-    termsRequired: "You must agree to the terms and conditions"
-  },
-  errors: {
-    invalidCredentials: "Invalid email or password",
-    userNotFound: "User not found",
-    userExists: "User already exists",
-    invalidToken: "Invalid or expired token",
-    tokenExpired: "Token has expired",
-    networkError: "Network error. Please try again.",
-    mfaRequired: "Two-factor authentication required",
-    emailNotVerified: "Email not verified",
-    phoneNotVerified: "Phone number not verified",
-    rateLimitExceeded: "Too many attempts. Please try again later.",
-    unknownError: "An unknown error occurred",
-    generic: "Something went wrong. Please try again."
-  },
-  success: {
-    signedIn: "Successfully signed in",
-    signedUp: "Account created successfully",
-    signedOut: "Successfully signed out",
-    linkSent: "Link sent successfully",
-    codeSent: "Verification code sent",
-    verified: "Successfully verified",
-    welcome: "Welcome, {name}!"
-  },
-  placeholders: {
-    email: "john@example.com",
-    password: "Enter your password",
-    confirmPassword: "Confirm your password",
-    username: "johndoe",
-    phone: "+1234567890",
-    code: "123456",
-    fullName: "John Doe"
-  }
-};
-
-// src/locale/utils.ts
-var defaultLocale = enLocale;
-function deepMerge(target, source) {
-  const result = { ...target };
-  for (const key in source) {
-    if (source[key] !== void 0) {
-      if (typeof source[key] === "object" && source[key] !== null && !Array.isArray(source[key]) && typeof result[key] === "object" && result[key] !== null) {
-        result[key] = deepMerge(result[key], source[key]);
-      } else {
-        result[key] = source[key];
-      }
-    }
-  }
-  return result;
-}
-function createLocale(overrides) {
-  if (!overrides) {
-    return defaultLocale;
-  }
-  return deepMerge(defaultLocale, overrides);
-}
-function interpolate(template, values) {
-  return template.replace(/\{(\w+)\}/g, (match, key) => {
-    return values[key] !== void 0 ? String(values[key]) : match;
-  });
-}
-
-// src/utils/validation.ts
-var EMAIL_REGEX = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
-var PHONE_REGEX = /^\+?[1-9]\d{1,14}$/;
-var USERNAME_REGEX = /^[a-zA-Z0-9_-]{3,30}$/;
-function validateEmail(email, locale) {
-  const messages = locale?.validation || defaultLocale.validation;
-  if (!email) {
-    return { field: "email", message: messages.emailRequired };
-  }
-  if (!EMAIL_REGEX.test(email)) {
-    return { field: "email", message: messages.emailInvalid };
-  }
-  return null;
-}
-function validatePassword(password, options = {}) {
-  const {
-    minLength = 8,
-    requireUppercase = true,
-    requireLowercase = true,
-    requireNumber = true,
-    requireSpecial = false,
-    locale
-  } = options;
-  const messages = locale?.validation || defaultLocale.validation;
-  if (!password) {
-    return { field: "password", message: messages.passwordRequired };
-  }
-  if (password.length < minLength) {
-    return {
-      field: "password",
-      message: interpolate(messages.passwordTooShort, { min: minLength.toString() })
-    };
-  }
-  if (requireUppercase && !/[A-Z]/.test(password)) {
-    return {
-      field: "password",
-      message: messages.passwordRequireUppercase
-    };
-  }
-  if (requireLowercase && !/[a-z]/.test(password)) {
-    return {
-      field: "password",
-      message: messages.passwordRequireLowercase
-    };
-  }
-  if (requireNumber && !/\d/.test(password)) {
-    return { field: "password", message: messages.passwordRequireNumber };
-  }
-  if (requireSpecial && !/[!@#$%^&*(),.?":{}|<>]/.test(password)) {
-    return {
-      field: "password",
-      message: messages.passwordRequireSpecial
-    };
-  }
-  return null;
-}
-function validatePhone(phone, locale) {
-  const messages = locale?.validation || defaultLocale.validation;
-  if (!phone) {
-    return { field: "phone", message: messages.phoneRequired };
-  }
-  if (!PHONE_REGEX.test(phone)) {
-    return {
-      field: "phone",
-      message: messages.phoneInvalid
-    };
-  }
-  return null;
-}
-function validateUsername(username, locale) {
-  const messages = locale?.validation || defaultLocale.validation;
-  if (!username) {
-    return { field: "username", message: messages.usernameRequired };
-  }
-  if (!USERNAME_REGEX.test(username)) {
-    return {
-      field: "username",
-      message: messages.usernameInvalid
-    };
-  }
-  return null;
-}
-function validate2FACode(code, locale) {
-  const messages = locale?.validation || defaultLocale.validation;
-  if (!code) {
-    return { field: "code", message: messages.codeRequired };
-  }
-  if (!/^\d{6}$/.test(code)) {
-    return { field: "code", message: messages.codeInvalid };
-  }
-  return null;
-}
-function validateRequired(value, fieldName, locale) {
-  const messages = locale?.validation || defaultLocale.validation;
-  if (!value || typeof value === "string" && !value.trim()) {
-    return {
-      field: fieldName,
-      message: interpolate(messages.fieldRequired, { field: fieldName })
-    };
-  }
-  return null;
-}
-
-// src/utils/tokens.ts
-var TOKEN_KEY = "authsome_token";
-var REFRESH_TOKEN_KEY = "authsome_refresh_token";
-var TokenManager = class {
-  constructor(storage = new LocalStorageAdapter()) {
-    this.storage = storage;
-  }
-  /**
-   * Get access token
-   */
-  async getToken() {
-    return await Promise.resolve(this.storage.getItem(TOKEN_KEY));
-  }
-  /**
-   * Set access token
-   */
-  async setToken(token) {
-    await Promise.resolve(this.storage.setItem(TOKEN_KEY, token));
-  }
-  /**
-   * Remove access token
-   */
-  async removeToken() {
-    await Promise.resolve(this.storage.removeItem(TOKEN_KEY));
-  }
-  /**
-   * Get refresh token
-   */
-  async getRefreshToken() {
-    return await Promise.resolve(this.storage.getItem(REFRESH_TOKEN_KEY));
-  }
-  /**
-   * Set refresh token
-   */
-  async setRefreshToken(token) {
-    await Promise.resolve(this.storage.setItem(REFRESH_TOKEN_KEY, token));
-  }
-  /**
-   * Remove refresh token
-   */
-  async removeRefreshToken() {
-    await Promise.resolve(this.storage.removeItem(REFRESH_TOKEN_KEY));
-  }
-  /**
-   * Clear all tokens
-   */
-  async clearTokens() {
-    await this.removeToken();
-    await this.removeRefreshToken();
-  }
-  /**
-   * Check if token is expired
-   */
-  isTokenExpired(token) {
-    try {
-      const payload = this.decodeToken(token);
-      if (!payload.exp) return false;
-      const expiresAt = payload.exp * 1e3;
-      const now = Date.now();
-      return expiresAt - now < 6e4;
-    } catch {
-      return true;
-    }
-  }
-  /**
-   * Decode JWT token (without verification)
-   */
-  decodeToken(token) {
-    const parts = token.split(".");
-    if (parts.length !== 3) {
-      throw new Error("Invalid token format");
-    }
-    const payload = parts[1];
-    const decoded = atob(payload);
-    return JSON.parse(decoded);
-  }
-};
-
-// src/utils/cookies.ts
-function parseCookie(setCookieHeader) {
-  if (!setCookieHeader) return null;
-  const parts = setCookieHeader.split(";").map((p) => p.trim());
-  if (parts.length === 0) return null;
-  const [nameValue] = parts;
-  const [name, value] = nameValue.split("=");
-  if (!name || value === void 0) return null;
-  const cookieData = { name, value };
-  const options = {};
-  for (let i = 1; i < parts.length; i++) {
-    const part = parts[i];
-    const lowerPart = part.toLowerCase();
-    if (lowerPart === "httponly") {
-      options.httpOnly = true;
-    } else if (lowerPart === "secure") {
-      options.secure = true;
-    } else if (lowerPart.startsWith("path=")) {
-      options.path = part.substring(5);
-    } else if (lowerPart.startsWith("domain=")) {
-      options.domain = part.substring(7);
-    } else if (lowerPart.startsWith("max-age=")) {
-      const maxAge = parseInt(part.substring(8), 10);
-      if (!isNaN(maxAge)) {
-        options.maxAge = maxAge;
-      }
-    } else if (lowerPart.startsWith("expires=")) {
-      const expiresStr = part.substring(8);
-      const expiresDate = new Date(expiresStr);
-      if (!isNaN(expiresDate.getTime())) {
-        options.expires = expiresDate;
-      }
-    } else if (lowerPart.startsWith("samesite=")) {
-      const sameSiteValue = lowerPart.substring(9);
-      if (sameSiteValue === "strict" || sameSiteValue === "lax" || sameSiteValue === "none") {
-        options.sameSite = sameSiteValue;
-      }
-    }
-  }
-  if (Object.keys(options).length > 0) {
-    cookieData.options = options;
-  }
-  return cookieData;
-}
-function extractCookiesFromHeaders(setCookieHeaders) {
-  const headers = Array.isArray(setCookieHeaders) ? setCookieHeaders : [setCookieHeaders];
-  const cookies = [];
-  for (const header of headers) {
-    const cookie = parseCookie(header);
-    if (cookie) {
-      cookies.push(cookie);
-    }
-  }
-  return cookies;
-}
-function serializeCookie(cookie) {
-  const parts = [`${cookie.name}=${cookie.value}`];
-  if (cookie.options) {
-    const opts = cookie.options;
-    if (opts.path) {
-      parts.push(`Path=${opts.path}`);
-    }
-    if (opts.domain) {
-      parts.push(`Domain=${opts.domain}`);
-    }
-    if (opts.expires) {
-      parts.push(`Expires=${opts.expires.toUTCString()}`);
-    }
-    if (opts.maxAge !== void 0) {
-      parts.push(`Max-Age=${opts.maxAge}`);
-    }
-    if (opts.httpOnly) {
-      parts.push("HttpOnly");
-    }
-    if (opts.secure) {
-      parts.push("Secure");
-    }
-    if (opts.sameSite) {
-      const sameSite = opts.sameSite.charAt(0).toUpperCase() + opts.sameSite.slice(1);
-      parts.push(`SameSite=${sameSite}`);
-    }
-  }
-  return parts.join("; ");
-}
-function parseCookieOptions(cookieHeader) {
-  const cookies = {};
-  if (!cookieHeader) return cookies;
-  const pairs = cookieHeader.split(";").map((p) => p.trim());
-  for (const pair of pairs) {
-    const [name, value] = pair.split("=");
-    if (name && value !== void 0) {
-      cookies[name.trim()] = value.trim();
-    }
-  }
-  return cookies;
-}
-function serializeCookies(cookies) {
-  return Object.entries(cookies).map(([key, value]) => `${key}=${value}`).join("; ");
-}
-
-// src/adapters/base-provider.ts
-var BaseAuthProvider = class {
-  constructor() {
-    this.config = {};
-    this.initialized = false;
-  }
-  /**
-   * Initialize the provider
-   */
-  async initialize(config) {
-    this.config = config;
-    this.initialized = true;
-  }
-  /**
-   * Ensure provider is initialized
-   */
-  ensureInitialized() {
-    if (!this.initialized) {
-      throw new Error(`Provider ${this.name} is not initialized`);
-    }
-  }
-  /**
-   * Make HTTP request
-   */
-  async request(url, options = {}) {
-    const response = await fetch(url, {
-      ...options,
-      headers: {
-        "Content-Type": "application/json",
-        ...options.headers
-      }
-    });
-    if (!response.ok) {
-      const error = await response.json().catch(() => ({
-        message: response.statusText
-      }));
-      throw error;
-    }
-    return response.json();
-  }
-  /**
-   * Normalize error to AuthError
-   */
-  normalizeError(error) {
-    return toAuthError(error);
-  }
-};
-
-// src/client.ts
-var AuthClient = class {
-  // Expose adapter for accessing provider-specific methods
-  get adapter() {
-    return this.provider;
-  }
-  constructor(config) {
-    this.provider = config.provider;
-    this.autoRefresh = config.autoRefresh ?? true;
-    this.refreshInterval = config.refreshInterval ?? 5 * 60 * 1e3;
-    this.state = new Observable({
-      state: "loading" /* LOADING */,
-      user: null,
-      session: null,
-      error: null,
-      isAuthenticated: false,
-      isLoading: true
-    });
-  }
-  /**
-   * Initialize the auth client
-   */
-  async initialize() {
-    try {
-      const user = await this.provider.getCurrentUser();
-      const session = await this.provider.getCurrentSession();
-      if (user && session) {
-        this.updateState({
-          state: "authenticated" /* AUTHENTICATED */,
-          user,
-          session,
-          error: null,
-          isAuthenticated: true,
-          isLoading: false
-        });
-        if (this.autoRefresh) {
-          this.startAutoRefresh();
-        }
-      } else {
-        this.updateState({
-          state: "unauthenticated" /* UNAUTHENTICATED */,
-          user: null,
-          session: null,
-          error: null,
-          isAuthenticated: false,
-          isLoading: false
-        });
-      }
-    } catch (error) {
-      this.handleError(error);
-    }
-  }
-  /**
-   * Sign in with credentials
-   */
-  async signIn(request) {
-    try {
-      this.setLoading();
-      const response = await this.provider.signIn(request);
-      if (response.requiresTwoFactor) {
-        this.updateState({
-          state: "unauthenticated" /* UNAUTHENTICATED */,
-          user: response.user,
-          session: null,
-          error: null,
-          isAuthenticated: false,
-          isLoading: false
-        });
-        return;
-      }
-      this.updateState({
-        state: "authenticated" /* AUTHENTICATED */,
-        user: response.user,
-        session: response.session,
-        error: null,
-        isAuthenticated: true,
-        isLoading: false
-      });
-      if (this.autoRefresh) {
-        this.startAutoRefresh();
-      }
-    } catch (error) {
-      this.handleError(error);
-    }
-  }
-  /**
-   * Sign up with credentials
-   */
-  async signUp(request) {
-    try {
-      this.setLoading();
-      const response = await this.provider.signUp(request);
-      this.updateState({
-        state: "authenticated" /* AUTHENTICATED */,
-        user: response.user,
-        session: response.session,
-        error: null,
-        isAuthenticated: true,
-        isLoading: false
-      });
-      if (this.autoRefresh) {
-        this.startAutoRefresh();
-      }
-    } catch (error) {
-      this.handleError(error);
-    }
-  }
-  /**
-   * Sign out
-   */
-  async signOut() {
-    try {
-      this.stopAutoRefresh();
-      await this.provider.signOut();
-      this.updateState({
-        state: "unauthenticated" /* UNAUTHENTICATED */,
-        user: null,
-        session: null,
-        error: null,
-        isAuthenticated: false,
-        isLoading: false
-      });
-    } catch (error) {
-      this.handleError(error);
-    }
-  }
-  /**
-   * Update user profile
-   */
-  async updateUser(request) {
-    try {
-      const user = await this.provider.updateUser(request);
-      const currentState = this.state.getValue();
-      this.updateState({
-        ...currentState,
-        user
-      });
-    } catch (error) {
-      this.handleError(error);
-    }
-  }
-  /**
-   * Change password
-   */
-  async changePassword(request) {
-    try {
-      await this.provider.changePassword(request);
-    } catch (error) {
-      throw this.provider.normalizeError(error);
-    }
-  }
-  /**
-   * Request password reset
-   */
-  async requestPasswordReset(request) {
-    try {
-      await this.provider.requestPasswordReset(request);
-    } catch (error) {
-      throw this.provider.normalizeError(error);
-    }
-  }
-  /**
-   * Confirm password reset
-   */
-  async confirmPasswordReset(request) {
-    try {
-      await this.provider.confirmPasswordReset(request);
-    } catch (error) {
-      throw this.provider.normalizeError(error);
-    }
-  }
-  /**
-   * Get OAuth sign in URL
-   */
-  async getOAuthUrl(request) {
-    return this.provider.oauthSignIn(request);
-  }
-  /**
-   * Handle OAuth callback
-   */
-  async handleOAuthCallback(request) {
-    try {
-      this.setLoading();
-      const response = await this.provider.oauthCallback(request);
-      this.updateState({
-        state: "authenticated" /* AUTHENTICATED */,
-        user: response.user,
-        session: response.session,
-        error: null,
-        isAuthenticated: true,
-        isLoading: false
-      });
-      if (this.autoRefresh) {
-        this.startAutoRefresh();
-      }
-    } catch (error) {
-      this.handleError(error);
-    }
-  }
-  /**
-   * Get available OAuth providers
-   */
-  async getOAuthProviders() {
-    return this.provider.getOAuthProviders();
-  }
-  /**
-   * Send magic link
-   */
-  async sendMagicLink(request) {
-    try {
-      await this.provider.sendMagicLink(request);
-    } catch (error) {
-      throw this.provider.normalizeError(error);
-    }
-  }
-  /**
-   * Verify magic link
-   */
-  async verifyMagicLink(request) {
-    try {
-      this.setLoading();
-      const response = await this.provider.verifyMagicLink(request);
-      this.updateState({
-        state: "authenticated" /* AUTHENTICATED */,
-        user: response.user,
-        session: response.session,
-        error: null,
-        isAuthenticated: true,
-        isLoading: false
-      });
-      if (this.autoRefresh) {
-        this.startAutoRefresh();
-      }
-    } catch (error) {
-      this.handleError(error);
-    }
-  }
-  /**
-   * Send phone verification code
-   */
-  async sendPhoneCode(request) {
-    try {
-      await this.provider.sendPhoneCode(request);
-    } catch (error) {
-      throw this.provider.normalizeError(error);
-    }
-  }
-  /**
-   * Verify phone code
-   */
-  async verifyPhoneCode(request) {
-    try {
-      this.setLoading();
-      const response = await this.provider.verifyPhoneCode(request);
-      this.updateState({
-        state: "authenticated" /* AUTHENTICATED */,
-        user: response.user,
-        session: response.session,
-        error: null,
-        isAuthenticated: true,
-        isLoading: false
-      });
-      if (this.autoRefresh) {
-        this.startAutoRefresh();
-      }
-    } catch (error) {
-      this.handleError(error);
-    }
-  }
-  /**
-   * Setup 2FA
-   */
-  async setupTwoFactor(request) {
-    return this.provider.setupTwoFactor(request);
-  }
-  /**
-   * Verify 2FA code
-   */
-  async verifyTwoFactor(request) {
-    try {
-      this.setLoading();
-      const response = await this.provider.verifyTwoFactor(request);
-      this.updateState({
-        state: "authenticated" /* AUTHENTICATED */,
-        user: response.user,
-        session: response.session,
-        error: null,
-        isAuthenticated: true,
-        isLoading: false
-      });
-      if (this.autoRefresh) {
-        this.startAutoRefresh();
-      }
-    } catch (error) {
-      this.handleError(error);
-    }
-  }
-  /**
-   * Disable 2FA
-   */
-  async disableTwoFactor() {
-    return this.provider.disableTwoFactor();
-  }
-  /**
-   * Get 2FA status
-   */
-  async getTwoFactorStatus() {
-    return this.provider.getTwoFactorStatus();
-  }
-  /**
-   * Register passkey
-   */
-  async registerPasskey(request) {
-    return this.provider.registerPasskey(request);
-  }
-  /**
-   * Authenticate with passkey
-   */
-  async authenticatePasskey(request) {
-    try {
-      this.setLoading();
-      const response = await this.provider.authenticatePasskey(request);
-      this.updateState({
-        state: "authenticated" /* AUTHENTICATED */,
-        user: response.user,
-        session: response.session,
-        error: null,
-        isAuthenticated: true,
-        isLoading: false
-      });
-      if (this.autoRefresh) {
-        this.startAutoRefresh();
-      }
-    } catch (error) {
-      this.handleError(error);
-    }
-  }
-  /**
-   * List passkeys
-   */
-  async listPasskeys() {
-    return this.provider.listPasskeys();
-  }
-  /**
-   * Delete passkey
-   */
-  async deletePasskey(credentialId) {
-    return this.provider.deletePasskey(credentialId);
-  }
-  /**
-   * Get all organizations the user belongs to
-   * Only available if the provider supports organizations
-   */
-  async getOrganizations() {
-    if (!this.provider.getOrganizations) {
-      throw this.createUnsupportedError("Organization support");
-    }
-    return this.provider.getOrganizations();
-  }
-  /**
-   * Get the currently active organization
-   * Only available if the provider supports organizations
-   */
-  async getActiveOrganization() {
-    if (!this.provider.getActiveOrganization) {
-      throw this.createUnsupportedError("Organization support");
-    }
-    return this.provider.getActiveOrganization();
-  }
-  /**
-   * Set the active organization and refresh user state
-   * Only available if the provider supports organizations
-   */
-  async setActiveOrganization(organizationId) {
-    if (!this.provider.setActiveOrganization) {
-      throw this.createUnsupportedError("Organization support");
-    }
-    await this.provider.setActiveOrganization(organizationId);
-    await this.refreshSession();
-  }
-  /**
-   * Get organization memberships with roles and permissions
-   * Only available if the provider supports organizations
-   */
-  async getOrganizationMemberships() {
-    if (!this.provider.getOrganizationMemberships) {
-      throw this.createUnsupportedError("Organization memberships");
-    }
-    return this.provider.getOrganizationMemberships();
-  }
-  /**
-   * Check if the provider supports organizations
-   */
-  supportsOrganizations() {
-    return !!(this.provider.getOrganizations && this.provider.getActiveOrganization && this.provider.setActiveOrganization);
-  }
-  /**
-   * Refresh session
-   */
-  async refreshSession() {
-    try {
-      const session = await this.provider.refreshSession();
-      const currentState = this.state.getValue();
-      this.updateState({
-        ...currentState,
-        session
-      });
-    } catch (error) {
-      console.warn("[AuthClient] Session refresh failed:", error);
-    }
-  }
-  /**
-   * Get current user
-   */
-  getUser() {
-    return this.state.getValue().user;
-  }
-  /**
-   * Get current session
-   */
-  getSession() {
-    return this.state.getValue().session;
-  }
-  /**
-   * Check if authenticated
-   */
-  isAuthenticated() {
-    return this.state.getValue().isAuthenticated;
-  }
-  /**
-   * Get current error
-   */
-  getError() {
-    return this.state.getValue().error;
-  }
-  /**
-   * Clear error
-   */
-  clearError() {
-    const currentState = this.state.getValue();
-    this.updateState({
-      ...currentState,
-      error: null
-    });
-  }
-  /**
-   * Subscribe to auth state changes
-   */
-  subscribe(listener) {
-    return this.state.subscribe(listener);
-  }
-  /**
-   * Cleanup resources
-   */
-  destroy() {
-    this.stopAutoRefresh();
-    this.state.clearListeners();
-  }
-  // Private methods
-  updateState(newState) {
-    this.state.setValue(newState);
-  }
-  setLoading() {
-    const currentState = this.state.getValue();
-    this.updateState({
-      ...currentState,
-      state: "loading" /* LOADING */,
-      isLoading: true,
-      error: null
-    });
-  }
-  handleError(error) {
-    const authError = this.provider.normalizeError(error);
-    const currentState = this.state.getValue();
-    this.updateState({
-      ...currentState,
-      state: "error" /* ERROR */,
-      error: authError,
-      isLoading: false
-    });
-    throw authError;
-  }
-  startAutoRefresh() {
-    this.stopAutoRefresh();
-    this.refreshTimer = setInterval(() => {
-      this.refreshSession();
-    }, this.refreshInterval);
-  }
-  stopAutoRefresh() {
-    if (this.refreshTimer) {
-      clearInterval(this.refreshTimer);
-      this.refreshTimer = void 0;
-    }
-  }
-  createUnsupportedError(feature) {
-    return {
-      name: "AuthError",
-      message: `${feature} is not available with this auth provider`,
-      type: "unknown_error" /* UNKNOWN_ERROR */
-    };
-  }
-};
-
-// src/flows/types.ts
-var FlowStep = /* @__PURE__ */ ((FlowStep2) => {
-  FlowStep2["SIGN_IN"] = "sign_in";
-  FlowStep2["SIGN_UP"] = "sign_up";
-  FlowStep2["EMAIL_PASSWORD_SIGN_IN"] = "email_password_sign_in";
-  FlowStep2["EMAIL_PASSWORD_SIGN_UP"] = "email_password_sign_up";
-  FlowStep2["OAUTH_SELECT"] = "oauth_select";
-  FlowStep2["OAUTH_CALLBACK"] = "oauth_callback";
-  FlowStep2["MAGIC_LINK_REQUEST"] = "magic_link_request";
-  FlowStep2["MAGIC_LINK_VERIFY"] = "magic_link_verify";
-  FlowStep2["MAGIC_LINK_SENT"] = "magic_link_sent";
-  FlowStep2["PHONE_REQUEST"] = "phone_request";
-  FlowStep2["PHONE_VERIFY"] = "phone_verify";
-  FlowStep2["USERNAME_SIGN_IN"] = "username_sign_in";
-  FlowStep2["USERNAME_SIGN_UP"] = "username_sign_up";
-  FlowStep2["PASSKEY_REGISTER"] = "passkey_register";
-  FlowStep2["PASSKEY_AUTHENTICATE"] = "passkey_authenticate";
-  FlowStep2["MFA_REQUIRED"] = "mfa_required";
-  FlowStep2["MFA_SETUP"] = "mfa_setup";
-  FlowStep2["MFA_VERIFY"] = "mfa_verify";
-  FlowStep2["MFA_SELECT_METHOD"] = "mfa_select_method";
-  FlowStep2["EMAIL_VERIFICATION_REQUIRED"] = "email_verification_required";
-  FlowStep2["EMAIL_VERIFICATION_SENT"] = "email_verification_sent";
-  FlowStep2["PHONE_VERIFICATION_REQUIRED"] = "phone_verification_required";
-  FlowStep2["PASSWORD_RESET_REQUEST"] = "password_reset_request";
-  FlowStep2["PASSWORD_RESET_SENT"] = "password_reset_sent";
-  FlowStep2["PASSWORD_RESET_CONFIRM"] = "password_reset_confirm";
-  FlowStep2["PASSWORD_CHANGE"] = "password_change";
-  FlowStep2["PROFILE_UPDATE"] = "profile_update";
-  FlowStep2["PROFILE_COMPLETE"] = "profile_complete";
-  FlowStep2["SUCCESS"] = "success";
-  FlowStep2["ERROR"] = "error";
-  FlowStep2["CANCELLED"] = "cancelled";
-  return FlowStep2;
-})(FlowStep || {});
-var FlowConfigType = /* @__PURE__ */ ((FlowConfigType2) => {
-  FlowConfigType2["SIMPLE_SIGN_IN"] = "simple_sign_in";
-  FlowConfigType2["SIMPLE_SIGN_UP"] = "simple_sign_up";
-  FlowConfigType2["SIGN_UP_WITH_EMAIL_VERIFICATION"] = "sign_up_with_email_verification";
-  FlowConfigType2["SIGN_IN_WITH_MFA"] = "sign_in_with_mfa";
-  FlowConfigType2["OAUTH_SIGN_IN"] = "oauth_sign_in";
-  FlowConfigType2["MAGIC_LINK_FLOW"] = "magic_link_flow";
-  FlowConfigType2["PHONE_AUTH_FLOW"] = "phone_auth_flow";
-  FlowConfigType2["COMPLETE_SIGN_UP_FLOW"] = "complete_sign_up_flow";
-  FlowConfigType2["SECURE_SIGN_IN_FLOW"] = "secure_sign_in_flow";
-  FlowConfigType2["PASSWORD_RESET_FLOW"] = "password_reset_flow";
-  FlowConfigType2["EMAIL_VERIFICATION_FLOW"] = "email_verification_flow";
-  FlowConfigType2["CUSTOM"] = "custom";
-  return FlowConfigType2;
-})(FlowConfigType || {});
-var FlowAction = /* @__PURE__ */ ((FlowAction2) => {
-  FlowAction2["START"] = "start";
-  FlowAction2["NEXT"] = "next";
-  FlowAction2["BACK"] = "back";
-  FlowAction2["CANCEL"] = "cancel";
-  FlowAction2["ERROR"] = "error";
-  FlowAction2["RESET"] = "reset";
-  return FlowAction2;
-})(FlowAction || {});
-
-// src/flows/engine.ts
-var FlowEngine = class {
-  constructor(config, initialState) {
-    this.history = [];
-    this.config = config;
-    this.state = {
-      currentStep: config.initialStep,
-      ...initialState
-    };
-    this.history.push(this.state.currentStep);
-  }
-  /**
-   * Get current flow state
-   */
-  getState() {
-    return { ...this.state };
-  }
-  /**
-   * Get current step
-   */
-  getCurrentStep() {
-    return this.state.currentStep;
-  }
-  /**
-   * Check if step is allowed in this flow
-   */
-  isStepAllowed(step) {
-    return this.config.allowedSteps.includes(step);
-  }
-  /**
-   * Transition to next step based on action
-   */
-  async transition(event) {
-    const { action, data, error } = event;
-    switch (action) {
-      case "start":
-        return this.handleStart(data);
-      case "next":
-        return this.handleNext(data);
-      case "back":
-        return this.handleBack();
-      case "cancel":
-        return this.handleCancel();
-      case "error":
-        return this.handleError(error);
-      case "reset":
-        return this.handleReset();
-      default:
-        throw new AuthError(
-          `Unknown flow action: ${action}`,
-          "validation_error" /* VALIDATION_ERROR */
-        );
-    }
-  }
-  /**
-   * Start or restart the flow
-   */
-  handleStart(data) {
-    this.state = {
-      currentStep: this.config.initialStep,
-      ...data
-    };
-    this.history = [this.state.currentStep];
-    if (this.config.onStepChange) {
-      this.config.onStepChange(this.state.currentStep, this.state);
-    }
-    return this.getState();
-  }
-  /**
-   * Move to next step
-   */
-  handleNext(data) {
-    this.state = {
-      ...this.state,
-      ...data,
-      previousStep: this.state.currentStep
-    };
-    const transitionConfig = this.config.transitions[this.state.currentStep];
-    if (!transitionConfig) {
-      throw new AuthError(
-        `No transition configured for step: ${this.state.currentStep}`,
-        "validation_error" /* VALIDATION_ERROR */
-      );
-    }
-    if (transitionConfig.conditions) {
-      for (const condition of transitionConfig.conditions) {
-        if (condition.when(this.state)) {
-          return this.moveToStep(condition.then);
-        }
-      }
-    }
-    if (transitionConfig.onSuccess) {
-      return this.moveToStep(transitionConfig.onSuccess);
-    }
-    throw new AuthError(
-      `No valid transition found for step: ${this.state.currentStep}`,
-      "validation_error" /* VALIDATION_ERROR */
-    );
-  }
-  /**
-   * Go back to previous step
-   */
-  handleBack() {
-    if (this.history.length < 2) {
-      throw new AuthError(
-        "Cannot go back - already at first step",
-        "validation_error" /* VALIDATION_ERROR */
-      );
-    }
-    this.history.pop();
-    const previousStep = this.history[this.history.length - 1];
-    const transitionConfig = this.config.transitions[this.state.currentStep];
-    const targetStep = transitionConfig?.onBack || previousStep;
-    return this.moveToStep(targetStep, false);
-  }
-  /**
-   * Cancel the flow
-   */
-  handleCancel() {
-    const transitionConfig = this.config.transitions[this.state.currentStep];
-    const targetStep = transitionConfig?.onCancel;
-    if (this.config.onCancel) {
-      this.config.onCancel(this.state);
-    }
-    if (targetStep) {
-      return this.moveToStep(targetStep);
-    }
-    this.state.currentStep = "cancelled";
-    return this.getState();
-  }
-  /**
-   * Handle error in flow
-   */
-  handleError(error) {
-    this.state.error = error;
-    const transitionConfig = this.config.transitions[this.state.currentStep];
-    const targetStep = transitionConfig?.onError;
-    if (this.config.onError) {
-      this.config.onError(error, this.state);
-    }
-    if (targetStep) {
-      return this.moveToStep(targetStep);
-    }
-    return this.getState();
-  }
-  /**
-   * Reset flow to initial state
-   */
-  handleReset() {
-    return this.handleStart();
-  }
-  /**
-   * Move to a specific step
-   */
-  moveToStep(step, addToHistory = true) {
-    if (!this.isStepAllowed(step)) {
-      throw new AuthError(
-        `Step ${step} is not allowed in this flow`,
-        "validation_error" /* VALIDATION_ERROR */
-      );
-    }
-    this.state.currentStep = step;
-    if (addToHistory) {
-      this.history.push(step);
-    }
-    if (this.config.onStepChange) {
-      this.config.onStepChange(step, this.state);
-    }
-    if (step === "success" && this.state.user && this.state.session) {
-      if (this.config.onComplete) {
-        this.config.onComplete(this.state.user, this.state.session);
-      }
-    }
-    return this.getState();
-  }
-  /**
-   * Get flow history
-   */
-  getHistory() {
-    return [...this.history];
-  }
-  /**
-   * Check if can go back
-   */
-  canGoBack() {
-    return this.history.length > 1;
-  }
-};
-
-// src/flows/configs.ts
-var simpleSignInFlow = {
-  name: "Simple Sign In",
-  description: "Basic email/password sign-in",
-  initialStep: "email_password_sign_in" /* EMAIL_PASSWORD_SIGN_IN */,
-  allowedSteps: [
-    "email_password_sign_in" /* EMAIL_PASSWORD_SIGN_IN */,
-    "email_verification_required" /* EMAIL_VERIFICATION_REQUIRED */,
-    "email_verification_sent" /* EMAIL_VERIFICATION_SENT */,
-    "password_reset_request" /* PASSWORD_RESET_REQUEST */,
-    "password_reset_sent" /* PASSWORD_RESET_SENT */,
-    "success" /* SUCCESS */,
-    "error" /* ERROR */
-  ],
-  transitions: {
-    ["email_password_sign_in" /* EMAIL_PASSWORD_SIGN_IN */]: {
-      onSuccess: "success" /* SUCCESS */,
-      onError: "email_password_sign_in" /* EMAIL_PASSWORD_SIGN_IN */
-    },
-    ["email_verification_required" /* EMAIL_VERIFICATION_REQUIRED */]: {
-      onSuccess: "email_verification_sent" /* EMAIL_VERIFICATION_SENT */,
-      onError: "email_verification_required" /* EMAIL_VERIFICATION_REQUIRED */
-    },
-    ["email_verification_sent" /* EMAIL_VERIFICATION_SENT */]: {
-      onSuccess: "email_password_sign_in" /* EMAIL_PASSWORD_SIGN_IN */,
-      onError: "email_verification_required" /* EMAIL_VERIFICATION_REQUIRED */
-    },
-    ["password_reset_request" /* PASSWORD_RESET_REQUEST */]: {
-      onSuccess: "password_reset_sent" /* PASSWORD_RESET_SENT */,
-      onBack: "email_password_sign_in" /* EMAIL_PASSWORD_SIGN_IN */
-    },
-    ["password_reset_sent" /* PASSWORD_RESET_SENT */]: {
-      onSuccess: "email_password_sign_in" /* EMAIL_PASSWORD_SIGN_IN */
-    }
-  }
-};
-var signInWithMFAFlow = {
-  name: "Sign In with MFA",
-  description: "Sign-in that handles MFA if enabled",
-  initialStep: "email_password_sign_in" /* EMAIL_PASSWORD_SIGN_IN */,
-  allowedSteps: [
-    "email_password_sign_in" /* EMAIL_PASSWORD_SIGN_IN */,
-    "email_verification_required" /* EMAIL_VERIFICATION_REQUIRED */,
-    "email_verification_sent" /* EMAIL_VERIFICATION_SENT */,
-    "mfa_required" /* MFA_REQUIRED */,
-    "mfa_select_method" /* MFA_SELECT_METHOD */,
-    "mfa_verify" /* MFA_VERIFY */,
-    "password_reset_request" /* PASSWORD_RESET_REQUEST */,
-    "password_reset_sent" /* PASSWORD_RESET_SENT */,
-    "success" /* SUCCESS */,
-    "error" /* ERROR */
-  ],
-  transitions: {
-    ["email_password_sign_in" /* EMAIL_PASSWORD_SIGN_IN */]: {
-      onSuccess: "success" /* SUCCESS */,
-      onError: "email_password_sign_in" /* EMAIL_PASSWORD_SIGN_IN */,
-      conditions: [
-        {
-          when: (state) => state.mfaRequired === true,
-          then: "mfa_required" /* MFA_REQUIRED */
-        }
-      ]
-    },
-    ["email_verification_required" /* EMAIL_VERIFICATION_REQUIRED */]: {
-      onSuccess: "email_verification_sent" /* EMAIL_VERIFICATION_SENT */,
-      onError: "email_verification_required" /* EMAIL_VERIFICATION_REQUIRED */
-    },
-    ["email_verification_sent" /* EMAIL_VERIFICATION_SENT */]: {
-      onSuccess: "email_password_sign_in" /* EMAIL_PASSWORD_SIGN_IN */,
-      onError: "email_verification_required" /* EMAIL_VERIFICATION_REQUIRED */
-    },
-    ["mfa_required" /* MFA_REQUIRED */]: {
-      onSuccess: "mfa_verify" /* MFA_VERIFY */,
-      conditions: [
-        {
-          when: (state) => (state.mfaMethods?.length || 0) > 1,
-          then: "mfa_select_method" /* MFA_SELECT_METHOD */
-        }
-      ]
-    },
-    ["mfa_select_method" /* MFA_SELECT_METHOD */]: {
-      onSuccess: "mfa_verify" /* MFA_VERIFY */,
-      onBack: "email_password_sign_in" /* EMAIL_PASSWORD_SIGN_IN */
-    },
-    ["mfa_verify" /* MFA_VERIFY */]: {
-      onSuccess: "success" /* SUCCESS */,
-      onError: "mfa_verify" /* MFA_VERIFY */,
-      onBack: "mfa_select_method" /* MFA_SELECT_METHOD */
-    },
-    ["password_reset_request" /* PASSWORD_RESET_REQUEST */]: {
-      onSuccess: "password_reset_sent" /* PASSWORD_RESET_SENT */,
-      onBack: "email_password_sign_in" /* EMAIL_PASSWORD_SIGN_IN */
-    }
-  }
-};
-var completeSignUpFlow = {
-  name: "Complete Sign Up",
-  description: "Sign-up with email verification and profile completion",
-  initialStep: "email_password_sign_up" /* EMAIL_PASSWORD_SIGN_UP */,
-  allowedSteps: [
-    "email_password_sign_up" /* EMAIL_PASSWORD_SIGN_UP */,
-    "email_verification_required" /* EMAIL_VERIFICATION_REQUIRED */,
-    "email_verification_sent" /* EMAIL_VERIFICATION_SENT */,
-    "profile_complete" /* PROFILE_COMPLETE */,
-    "success" /* SUCCESS */,
-    "error" /* ERROR */
-  ],
-  transitions: {
-    ["email_password_sign_up" /* EMAIL_PASSWORD_SIGN_UP */]: {
-      onSuccess: "email_verification_required" /* EMAIL_VERIFICATION_REQUIRED */,
-      onError: "email_password_sign_up" /* EMAIL_PASSWORD_SIGN_UP */,
-      conditions: [
-        {
-          when: (state) => state.verificationRequired === false,
-          then: "profile_complete" /* PROFILE_COMPLETE */
-        }
-      ]
-    },
-    ["email_verification_required" /* EMAIL_VERIFICATION_REQUIRED */]: {
-      onSuccess: "email_verification_sent" /* EMAIL_VERIFICATION_SENT */
-    },
-    ["email_verification_sent" /* EMAIL_VERIFICATION_SENT */]: {
-      onSuccess: "profile_complete" /* PROFILE_COMPLETE */
-    },
-    ["profile_complete" /* PROFILE_COMPLETE */]: {
-      onSuccess: "success" /* SUCCESS */,
-      onError: "profile_complete" /* PROFILE_COMPLETE */
-    }
-  }
-};
-var magicLinkFlow = {
-  name: "Magic Link",
-  description: "Passwordless authentication via email",
-  initialStep: "magic_link_request" /* MAGIC_LINK_REQUEST */,
-  allowedSteps: [
-    "magic_link_request" /* MAGIC_LINK_REQUEST */,
-    "magic_link_sent" /* MAGIC_LINK_SENT */,
-    "magic_link_verify" /* MAGIC_LINK_VERIFY */,
-    "success" /* SUCCESS */,
-    "error" /* ERROR */
-  ],
-  transitions: {
-    ["magic_link_request" /* MAGIC_LINK_REQUEST */]: {
-      onSuccess: "magic_link_sent" /* MAGIC_LINK_SENT */,
-      onError: "magic_link_request" /* MAGIC_LINK_REQUEST */
-    },
-    ["magic_link_sent" /* MAGIC_LINK_SENT */]: {
-      onSuccess: "magic_link_verify" /* MAGIC_LINK_VERIFY */
-    },
-    ["magic_link_verify" /* MAGIC_LINK_VERIFY */]: {
-      onSuccess: "success" /* SUCCESS */,
-      onError: "magic_link_request" /* MAGIC_LINK_REQUEST */
-    }
-  }
-};
-var phoneAuthFlow = {
-  name: "Phone Authentication",
-  description: "SMS-based authentication",
-  initialStep: "phone_request" /* PHONE_REQUEST */,
-  allowedSteps: [
-    "phone_request" /* PHONE_REQUEST */,
-    "phone_verify" /* PHONE_VERIFY */,
-    "success" /* SUCCESS */,
-    "error" /* ERROR */
-  ],
-  transitions: {
-    ["phone_request" /* PHONE_REQUEST */]: {
-      onSuccess: "phone_verify" /* PHONE_VERIFY */,
-      onError: "phone_request" /* PHONE_REQUEST */
-    },
-    ["phone_verify" /* PHONE_VERIFY */]: {
-      onSuccess: "success" /* SUCCESS */,
-      onError: "phone_verify" /* PHONE_VERIFY */,
-      onBack: "phone_request" /* PHONE_REQUEST */
-    }
-  }
-};
-var oauthSignInFlow = {
-  name: "OAuth Sign In",
-  description: "Third-party OAuth authentication",
-  initialStep: "oauth_select" /* OAUTH_SELECT */,
-  allowedSteps: [
-    "oauth_select" /* OAUTH_SELECT */,
-    "oauth_callback" /* OAUTH_CALLBACK */,
-    "success" /* SUCCESS */,
-    "error" /* ERROR */
-  ],
-  transitions: {
-    ["oauth_select" /* OAUTH_SELECT */]: {
-      onSuccess: "oauth_callback" /* OAUTH_CALLBACK */,
-      onError: "oauth_select" /* OAUTH_SELECT */
-    },
-    ["oauth_callback" /* OAUTH_CALLBACK */]: {
-      onSuccess: "success" /* SUCCESS */,
-      onError: "oauth_select" /* OAUTH_SELECT */
-    }
-  }
-};
-var passwordResetFlow = {
-  name: "Password Reset",
-  description: "Reset forgotten password",
-  initialStep: "password_reset_request" /* PASSWORD_RESET_REQUEST */,
-  allowedSteps: [
-    "password_reset_request" /* PASSWORD_RESET_REQUEST */,
-    "password_reset_sent" /* PASSWORD_RESET_SENT */,
-    "password_reset_confirm" /* PASSWORD_RESET_CONFIRM */,
-    "success" /* SUCCESS */,
-    "error" /* ERROR */
-  ],
-  transitions: {
-    ["password_reset_request" /* PASSWORD_RESET_REQUEST */]: {
-      onSuccess: "password_reset_sent" /* PASSWORD_RESET_SENT */,
-      onError: "password_reset_request" /* PASSWORD_RESET_REQUEST */
-    },
-    ["password_reset_sent" /* PASSWORD_RESET_SENT */]: {
-      onSuccess: "password_reset_confirm" /* PASSWORD_RESET_CONFIRM */
-    },
-    ["password_reset_confirm" /* PASSWORD_RESET_CONFIRM */]: {
-      onSuccess: "success" /* SUCCESS */,
-      onError: "password_reset_confirm" /* PASSWORD_RESET_CONFIRM */
-    }
-  }
-};
-var emailVerificationFlow = {
-  name: "Email Verification",
-  description: "Verify email address with code or link",
-  initialStep: "email_verification_required" /* EMAIL_VERIFICATION_REQUIRED */,
-  allowedSteps: [
-    "email_verification_required" /* EMAIL_VERIFICATION_REQUIRED */,
-    "email_verification_sent" /* EMAIL_VERIFICATION_SENT */,
-    "success" /* SUCCESS */,
-    "error" /* ERROR */
-  ],
-  transitions: {
-    ["email_verification_required" /* EMAIL_VERIFICATION_REQUIRED */]: {
-      onSuccess: "email_verification_sent" /* EMAIL_VERIFICATION_SENT */,
-      onError: "email_verification_required" /* EMAIL_VERIFICATION_REQUIRED */
-    },
-    ["email_verification_sent" /* EMAIL_VERIFICATION_SENT */]: {
-      onSuccess: "success" /* SUCCESS */,
-      onError: "email_verification_required" /* EMAIL_VERIFICATION_REQUIRED */
-    }
-  }
-};
-function getFlowConfig(type) {
-  switch (type) {
-    case "simple_sign_in" /* SIMPLE_SIGN_IN */:
-      return simpleSignInFlow;
-    case "sign_in_with_mfa" /* SIGN_IN_WITH_MFA */:
-      return signInWithMFAFlow;
-    case "complete_sign_up_flow" /* COMPLETE_SIGN_UP_FLOW */:
-      return completeSignUpFlow;
-    case "magic_link_flow" /* MAGIC_LINK_FLOW */:
-      return magicLinkFlow;
-    case "phone_auth_flow" /* PHONE_AUTH_FLOW */:
-      return phoneAuthFlow;
-    case "oauth_sign_in" /* OAUTH_SIGN_IN */:
-      return oauthSignInFlow;
-    case "password_reset_flow" /* PASSWORD_RESET_FLOW */:
-      return passwordResetFlow;
-    case "email_verification_flow" /* EMAIL_VERIFICATION_FLOW */:
-      return emailVerificationFlow;
-    default:
-      throw new Error(`Unknown flow type: ${type}`);
-  }
-}
-var predefinedFlows = {
-  ["simple_sign_in" /* SIMPLE_SIGN_IN */]: simpleSignInFlow,
-  ["sign_in_with_mfa" /* SIGN_IN_WITH_MFA */]: signInWithMFAFlow,
-  ["complete_sign_up_flow" /* COMPLETE_SIGN_UP_FLOW */]: completeSignUpFlow,
-  ["magic_link_flow" /* MAGIC_LINK_FLOW */]: magicLinkFlow,
-  ["phone_auth_flow" /* PHONE_AUTH_FLOW */]: phoneAuthFlow,
-  ["oauth_sign_in" /* OAUTH_SIGN_IN */]: oauthSignInFlow,
-  ["password_reset_flow" /* PASSWORD_RESET_FLOW */]: passwordResetFlow,
-  ["email_verification_flow" /* EMAIL_VERIFICATION_FLOW */]: emailVerificationFlow
-};
-
-export { AuthClient, AuthError, AuthErrorType, AuthState, BaseAuthProvider, FlowAction, FlowConfigType, FlowEngine, FlowStep, LocalStorageAdapter, MemoryStorageAdapter, OAuthProvider, Observable, SessionStorageAdapter, TokenManager, TwoFactorMethod, completeSignUpFlow, createAuthError, createLocale, defaultLocale, emailVerificationFlow, extractCookiesFromHeaders, getFlowConfig, interpolate, isAuthError, isMFARequiredError, isNetworkError, isUnauthenticatedError, magicLinkFlow, oauthSignInFlow, parseCookie, parseCookieOptions, passwordResetFlow, phoneAuthFlow, predefinedFlows, serializeCookie, serializeCookies, signInWithMFAFlow, simpleSignInFlow, toAuthError, validate2FACode, validateEmail, validatePassword, validatePhone, validateRequired, validateUsername };
-//# sourceMappingURL=index.mjs.map
-//# sourceMappingURL=index.mjs.map