azirid-react 0.6.0

package/dist/index.d.cts

@@ -0,0 +1,1570 @@
+import * as react from 'react';
+import { ReactNode, CSSProperties, FormEvent } from 'react';
+import * as _tanstack_react_query from '@tanstack/react-query';
+import { UseMutationResult, UseQueryResult } from '@tanstack/react-query';
+import { z } from 'zod';
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { ClassValue } from 'clsx';
+
+interface AuthUser {
+    id: string;
+    email: string;
+    firstName?: string;
+    lastName?: string;
+    emailVerified: boolean;
+    mfaEnabled?: boolean;
+    appId?: string;
+    tenantId?: string;
+    workspaceId?: string;
+    environment?: 'development' | 'production';
+    mustChangePassword?: boolean;
+    publicMetadata?: Record<string, unknown> | null;
+    unsafeMetadata?: Record<string, unknown> | null;
+    [key: string]: unknown;
+}
+interface AuthSuccessResponse {
+    accessToken: string;
+    user: AuthUser;
+}
+interface AuthState {
+    user: AuthUser | null;
+    accessToken: string | null;
+    isAuthenticated: boolean;
+    isLoading: boolean;
+    error: string | null;
+}
+interface SignupData {
+    email: string;
+    password: string;
+    acceptedTosVersion?: string;
+    acceptedPrivacyVersion?: string;
+    unsafeMetadata?: Record<string, unknown>;
+    referralCode?: string;
+}
+interface SocialLoginData {
+    provider: 'google' | 'github';
+    providerAccountId: string;
+    email: string;
+    emailVerified?: boolean;
+    firstName?: string;
+    lastName?: string;
+    createUserIfNotExists?: boolean;
+    turnstileToken?: string;
+    acceptedTosVersion?: string;
+    acceptedPrivacyVersion?: string;
+}
+interface ChangePasswordData {
+    currentPassword: string;
+    newPassword: string;
+}
+interface AppBranding {
+    displayName?: string | null;
+    logoUrl?: string | null;
+    faviconUrl?: string | null;
+    primaryColor?: string | null;
+    accentColor?: string | null;
+    removeBranding?: boolean;
+}
+type SupportedLocale = 'es' | 'en';
+interface AccessMessages {
+    login: {
+        title: string;
+        description: string;
+        submit: string;
+        emailLabel: string;
+        emailPlaceholder: string;
+        passwordLabel: string;
+        passwordPlaceholder: string;
+    };
+    signup: {
+        title: string;
+        description: string;
+        submit: string;
+        emailLabel: string;
+        emailPlaceholder: string;
+        passwordLabel: string;
+        passwordPlaceholder: string;
+        confirmPasswordLabel: string;
+        confirmPasswordPlaceholder: string;
+    };
+    forgotPassword: {
+        title: string;
+        description: string;
+        submit: string;
+        emailLabel: string;
+        emailPlaceholder: string;
+        successMessage: string;
+    };
+    resetPassword: {
+        title: string;
+        description: string;
+        submit: string;
+        newPasswordLabel: string;
+        newPasswordPlaceholder: string;
+        confirmPasswordLabel: string;
+        confirmPasswordPlaceholder: string;
+    };
+    social: {
+        google: string;
+        apple: string;
+        separator: string;
+        comingSoon: string;
+    };
+    passwordToggle: {
+        show: string;
+        hide: string;
+    };
+    securedBy: string;
+    billing: {
+        pay: string;
+        selectPaymentMethod: string;
+        creditCard: string;
+        paypal: string;
+        payphone: string;
+        bankTransfer: string;
+        cancel: string;
+        processing: string;
+    };
+    validation: {
+        emailRequired: string;
+        emailInvalid: string;
+        passwordRequired: string;
+        passwordMinLength: string;
+        confirmPasswordRequired: string;
+        passwordsMismatch: string;
+        tokenRequired: string;
+        newPasswordRequired: string;
+        currentPasswordRequired: string;
+        mfaCodeRequired: string;
+        mfaCodeLength: string;
+        providerRequired: string;
+        providerIdRequired: string;
+        urlInvalid: string;
+    };
+}
+type BootstrapResponse = {
+    authenticated: true;
+    accessToken: string;
+    user: AuthUser;
+    branding?: AppBranding;
+} | {
+    authenticated: false;
+    branding?: AppBranding;
+};
+interface PasskeyItem {
+    id: string;
+    deviceName?: string;
+    credentialId: string;
+    createdAt: string;
+    lastUsedAt?: string;
+}
+interface PasskeyRegisterStartData {
+    deviceName?: string;
+}
+interface PasskeyRegisterStartResponse {
+    challengeId: string;
+    options: unknown;
+}
+interface PasskeyRegisterVerifyData {
+    challengeId: string;
+    credential: unknown;
+}
+interface PasskeyLoginStartData {
+    tenantId?: string;
+}
+interface PasskeyLoginStartResponse {
+    challengeId: string;
+    options: unknown;
+}
+interface PasskeyLoginVerifyData {
+    challengeId: string;
+    credential: unknown;
+    tenantId?: string;
+}
+interface PasskeyLoginData {
+    credentialId: string;
+    tenantId?: string;
+}
+interface RegisterPasskeyData {
+    credentialId: string;
+    publicKey: string;
+    deviceName?: string;
+}
+interface AziridProviderProps {
+    children: ReactNode;
+    /**
+     * Azirid API URL for **direct mode** (requests go straight to the API).
+     *
+     * - **Omitted** → proxy mode (recommended for Next.js). Requests go to
+     *   your app's `/api/auth/*` route handler which proxies them securely.
+     *   Cookies are first-party. No CORS needed.
+     *
+     * - **Set** → direct mode. Requests go directly to this URL.
+     *   Requires CORS configured on the API.
+     *
+     * @example Direct mode (React SPA / Vite)
+     * ```tsx
+     * <AziridProvider apiUrl="https://api.azirid.com" publishableKey="pk_live_...">
+     * ```
+     *
+     * @example Proxy mode (Next.js — recommended)
+     * ```tsx
+     * <AziridProvider publishableKey="pk_live_...">
+     * ```
+     */
+    apiUrl?: string;
+    /** Extra headers to send with every request */
+    fetchOptions?: Record<string, string>;
+    /** Callback after successful login */
+    onLoginSuccess?: (response: AuthSuccessResponse) => void;
+    /** Callback after successful signup */
+    onSignupSuccess?: (response: AuthSuccessResponse) => void;
+    /** Callback after logout */
+    onLogoutSuccess?: () => void;
+    /** Callback on any auth error */
+    onError?: (error: string) => void;
+    /** Callback when session expires and refresh fails */
+    onSessionExpired?: () => void;
+    /** Auto-bootstrap session on mount (default: true) */
+    autoBootstrap?: boolean;
+    /** Interval in ms for proactive token refresh (default: 50000 = 50 seconds). Set to 0 to disable. */
+    refreshInterval?: number;
+    /**
+     * URL of a local API route to sync the session cookie (for server actions).
+     * - In dev mode (pk_dev_*): auto-activates with "/api/auth/session"
+     * - In prod mode (pk_live_*): disabled by default
+     * - Pass a string to force a custom URL, or false to force disable
+     */
+    sessionSyncUrl?: string | false;
+    /** Publishable key for the app (e.g. pk_development_a1b2c3...) */
+    publishableKey?: string;
+    /** Tenant ID for multi-tenant apps */
+    tenantId?: string;
+    /** Locale for built-in form strings (default: "es") */
+    locale?: SupportedLocale;
+    /** Override specific message strings */
+    messages?: Partial<AccessMessages>;
+}
+interface AziridContextValue extends AuthState {
+    /** Shortcut: calls loginMutation.mutate(data) */
+    login: (data: {
+        email: string;
+        password: string;
+    }) => void;
+    /** Shortcut: calls signupMutation.mutate(data) */
+    signup: (data: SignupData) => void;
+    /** Shortcut: calls logoutMutation.mutate() */
+    logout: () => void;
+    clearError: () => void;
+    /** Refresh the access token manually */
+    refresh: () => Promise<void>;
+    /** Update local user state after profile changes */
+    setUser: (user: AuthUser | null) => void;
+    /** TanStack mutation states */
+    isLoginPending: boolean;
+    isSignupPending: boolean;
+    isBootstrapping: boolean;
+    /** Full login mutation — same instance used by LoginForm and useLogin() */
+    loginMutation: UseMutationResult<AuthSuccessResponse, Error, {
+        email: string;
+        password: string;
+    }>;
+    /** Full signup mutation — same instance used by SignupForm and useSignup() */
+    signupMutation: UseMutationResult<AuthSuccessResponse, Error, SignupData>;
+    /** Full logout mutation — same instance used by useLogout() */
+    logoutMutation: UseMutationResult<unknown, Error, void>;
+}
+interface LoginFormProps {
+    /** Override the default onSubmit (uses context login by default) */
+    onSubmit?: (data: {
+        email: string;
+        password: string;
+    }) => void | Promise<void>;
+    /** Custom Zod schema for validation (overrides default loginSchema) */
+    schema?: z.ZodType;
+    /** Show a loading spinner / disable the form */
+    isLoading?: boolean;
+    /** Error message to display */
+    error?: string | null;
+    /** Custom class name for the root element */
+    className?: string;
+    /** Inline styles for the root element */
+    style?: CSSProperties;
+    /** Title displayed above the form */
+    title?: string;
+    /** Subtitle / description below the title */
+    description?: string;
+    /** Logo or branding element rendered above the card */
+    logo?: ReactNode;
+    /** Text for the submit button */
+    submitText?: string;
+    /** Render a footer below the form */
+    footer?: ReactNode;
+    /** Render a "forgot password?" link next to the password label */
+    forgotPassword?: ReactNode;
+    /** Hide the password visibility toggle */
+    hidePasswordToggle?: boolean;
+    /** Show SSO buttons (Google, Apple) above the form (default: true) */
+    showSocialButtons?: boolean;
+    /** Labels for i18n */
+    labels?: {
+        email?: string;
+        password?: string;
+        emailPlaceholder?: string;
+        passwordPlaceholder?: string;
+    };
+    /** Pre-fill the form fields */
+    defaultValues?: {
+        email?: string;
+        password?: string;
+    };
+}
+interface SignupFormProps {
+    /** Override the default onSubmit (uses context signup by default) */
+    onSubmit?: (data: SignupData) => void | Promise<void>;
+    /** Custom Zod schema for validation (overrides default signupSchema) */
+    schema?: z.ZodType;
+    /** Show a loading spinner / disable the form */
+    isLoading?: boolean;
+    /** Error message to display */
+    error?: string | null;
+    /** Custom class name for the root element */
+    className?: string;
+    /** Inline styles for the root element */
+    style?: CSSProperties;
+    /** Title displayed above the form */
+    title?: string;
+    /** Subtitle / description below the title */
+    description?: string;
+    /** Logo or branding element rendered above the card */
+    logo?: ReactNode;
+    /** Text for the submit button */
+    submitText?: string;
+    /** Render a footer below the form */
+    footer?: ReactNode;
+    /** Hide the password visibility toggle */
+    hidePasswordToggle?: boolean;
+    /** Show SSO buttons (Google, Apple) above the form (default: true) */
+    showSocialButtons?: boolean;
+    /** Labels for i18n */
+    labels?: {
+        email?: string;
+        password?: string;
+        confirmPassword?: string;
+        emailPlaceholder?: string;
+        passwordPlaceholder?: string;
+        confirmPasswordPlaceholder?: string;
+    };
+}
+interface FieldError {
+    field: string;
+    message: string;
+}
+interface UseFormReturn<T> {
+    values: T;
+    errors: FieldError[];
+    isSubmitting: boolean;
+    handleChange: (field: keyof T) => (e: React.ChangeEvent<HTMLInputElement>) => void;
+    handleSubmit: (e: FormEvent) => void;
+    setFieldValue: (field: keyof T, value: string) => void;
+    reset: () => void;
+}
+interface ReferralInfo {
+    referralCode: string;
+    referralUrl: string;
+    totalReferred: number;
+    completedReferrals: number;
+    pendingReferrals: number;
+}
+interface ReferralStatsData {
+    totalReferred: number;
+    completedReferrals: number;
+    pendingReferrals: number;
+    totalRewards: number;
+    referrals: ReferralItem[];
+}
+interface ReferralItem {
+    id: string;
+    referredEmail: string;
+    status: 'PENDING' | 'COMPLETED' | 'EXPIRED';
+    rewardStatus: 'PENDING' | 'GRANTED' | 'EXPIRED' | 'FAILED';
+    rewardAmount?: number;
+    createdAt: string;
+    completedAt?: string;
+}
+type PaymentProviderType = 'STRIPE' | 'PAYPAL' | 'PAYPHONE' | 'NUVEI' | 'MANUAL_TRANSFER';
+interface AvailableProvider {
+    provider: PaymentProviderType;
+    checkout: boolean;
+    subscriptions: boolean;
+}
+interface PaymentIntent {
+    id: string;
+    amount: number;
+    currency: string;
+    description?: string;
+    status: 'PENDING' | 'PROCESSING' | 'COMPLETED' | 'EXPIRED' | 'CANCELED';
+    expiresAt?: string;
+    metadata?: Record<string, unknown>;
+}
+interface BillingPlan {
+    id: string;
+    name: string;
+    slug: string;
+    description?: string;
+    amount: number;
+    currency: string;
+    interval: 'MONTHLY' | 'YEARLY' | 'ONE_TIME';
+    features?: string[];
+    metadata?: Record<string, unknown>;
+    sortOrder: number;
+}
+interface UserSubscription {
+    id: string;
+    planId: string;
+    plan: BillingPlan;
+    status: 'ACTIVE' | 'TRIALING' | 'PAST_DUE' | 'CANCELED' | 'UNPAID' | 'INCOMPLETE';
+    currentPeriodStart?: string;
+    currentPeriodEnd?: string;
+    cancelAtPeriodEnd: boolean;
+    canceledAt?: string;
+    trialEnd?: string;
+}
+interface PayphoneWidgetConfig {
+    token: string;
+    storeId: string;
+    clientTransactionId: string;
+    amount: number;
+    amountWithoutTax: number;
+    currency: string;
+    reference: string;
+}
+interface CheckoutResponse {
+    /** Redirect URL (card providers like Stripe/PayPal) */
+    url?: string;
+    sessionId?: string;
+    /** Set when the response identifies the provider */
+    provider?: PaymentProviderType;
+    /** Plan details (for MANUAL_TRANSFER and PAYPHONE) */
+    plan?: {
+        id: string;
+        name: string;
+        slug: string;
+        amount: number;
+        currency: string;
+        interval: string;
+    };
+    /** Intent details (for MANUAL_TRANSFER and PAYPHONE) */
+    intent?: {
+        id: string;
+        amount: number;
+        currency: string;
+        description?: string | null;
+    };
+    /** Payphone widget configuration (only for PAYPHONE) */
+    widgetConfig?: PayphoneWidgetConfig;
+    /** Bank account details (only for MANUAL_TRANSFER) */
+    bankDetails?: Record<string, unknown> | null;
+    /** Instructions for the user (only for MANUAL_TRANSFER) */
+    transferInstructions?: string | null;
+}
+interface BillingInvoice {
+    id: string;
+    amount: number;
+    currency: string;
+    status: 'PENDING' | 'PAID' | 'FAILED' | 'REFUNDED';
+    paidAt?: string;
+    invoiceUrl?: string;
+    createdAt: string;
+}
+interface SubmitTransferProofData {
+    planId: string;
+    fileUrl: string;
+    fileName?: string;
+    fileType?: string;
+    amount: number;
+    currency?: string;
+    notes?: string;
+}
+interface TransferProof {
+    id: string;
+    planId: string;
+    plan?: BillingPlan;
+    fileUrl: string;
+    fileName?: string;
+    fileType?: string;
+    amount: number;
+    currency: string;
+    status: 'PENDING_REVIEW' | 'APPROVED' | 'REJECTED';
+    reviewedAt?: string;
+    rejectionReason?: string;
+    notes?: string;
+    createdAt: string;
+}
+
+declare const LoginForm: react.ForwardRefExoticComponent<LoginFormProps & react.RefAttributes<HTMLFormElement>>;
+
+declare const SignupForm: react.ForwardRefExoticComponent<SignupFormProps & react.RefAttributes<HTMLFormElement>>;
+
+interface ReferralCardProps {
+    className?: string;
+    style?: CSSProperties;
+    title?: string;
+    description?: string;
+}
+declare function ReferralCard({ className, style, title, description, }: ReferralCardProps): react_jsx_runtime.JSX.Element;
+declare namespace ReferralCard {
+    var displayName: string;
+}
+
+interface ReferralStatsProps {
+    className?: string;
+    style?: CSSProperties;
+}
+declare function ReferralStats({ className, style }: ReferralStatsProps): react_jsx_runtime.JSX.Element;
+declare namespace ReferralStats {
+    var displayName: string;
+}
+
+interface PricingTableProps {
+    className?: string;
+    style?: CSSProperties;
+    successUrl: string;
+    cancelUrl: string;
+    columns?: number;
+    onPlanSelect?: (plan: BillingPlan) => void;
+}
+declare function PricingTable({ className, style, successUrl, cancelUrl, columns, onPlanSelect, }: PricingTableProps): react_jsx_runtime.JSX.Element;
+declare namespace PricingTable {
+    var displayName: string;
+}
+
+interface CheckoutButtonProps {
+    planId: string;
+    successUrl: string;
+    cancelUrl: string;
+    className?: string;
+    style?: CSSProperties;
+    children?: ReactNode;
+}
+declare function CheckoutButton({ planId, successUrl, cancelUrl, className, style, children, }: CheckoutButtonProps): react_jsx_runtime.JSX.Element;
+declare namespace CheckoutButton {
+    var displayName: string;
+}
+
+interface PayButtonProps {
+    planId?: string;
+    intentId?: string;
+    successUrl: string;
+    cancelUrl: string;
+    className?: string;
+    style?: CSSProperties;
+    children?: ReactNode;
+    disabled?: boolean;
+    onSuccess?: (data: CheckoutResponse) => void;
+    onError?: (error: Error) => void;
+    onProviderSelect?: (provider: PaymentProviderType) => void;
+}
+declare function PayButton({ planId, intentId, successUrl, cancelUrl, className, style, children, disabled, onSuccess, onError, onProviderSelect, }: PayButtonProps): react_jsx_runtime.JSX.Element;
+
+interface PayphoneCallbackProps {
+    onSuccess?: (data: {
+        status: string;
+        intentId: string;
+    }) => void;
+    onError?: (error: Error) => void;
+    className?: string;
+    style?: CSSProperties;
+}
+declare function PayphoneCallback({ onSuccess, onError, className, style, }: PayphoneCallbackProps): react_jsx_runtime.JSX.Element;
+
+interface SubscriptionBadgeProps {
+    className?: string;
+    style?: CSSProperties;
+}
+declare function SubscriptionBadge({ className, style }: SubscriptionBadgeProps): react_jsx_runtime.JSX.Element;
+declare namespace SubscriptionBadge {
+    var displayName: string;
+}
+
+interface InvoiceListProps {
+    className?: string;
+    style?: CSSProperties;
+}
+declare function InvoiceList({ className, style }: InvoiceListProps): react_jsx_runtime.JSX.Element;
+declare namespace InvoiceList {
+    var displayName: string;
+}
+
+/** Error thrown by the API client — carries the HTTP status code. */
+interface ApiError extends Error {
+    status: number;
+}
+/** Check if an error is an API auth error (401/403). */
+declare function isAuthError(err: unknown): boolean;
+declare const SUFFIXES: {
+    readonly login: "login";
+    readonly signup: "signup";
+    readonly logout: "logout";
+    readonly me: "me";
+    readonly refresh: "refresh";
+    readonly bootstrap: "session/bootstrap";
+    readonly magicLinkRequest: "magic-link/request";
+    readonly magicLinkVerify: "magic-link/verify";
+    readonly socialLogin: "social/login";
+    readonly changePassword: "password/change";
+    readonly passkeyLogin: "passkeys/login";
+    readonly passkeyLoginStart: "passkeys/login/start";
+    readonly passkeyLoginVerify: "passkeys/login/verify";
+    readonly passkeyRegisterStart: "passkeys/register/start";
+    readonly passkeyRegisterVerify: "passkeys/register/verify";
+    readonly passkeys: "passkeys";
+    readonly providers: "billing/providers";
+    readonly plans: "billing/plans";
+    readonly subscription: "billing/subscription";
+    readonly checkout: "billing/checkout";
+    readonly billingPortal: "billing/portal";
+    readonly invoices: "billing/invoices";
+    readonly submitTransferProof: "billing/transfer-proof";
+    readonly transferProofs: "billing/transfer-proofs";
+    readonly payphoneConfirm: "billing/payphone/confirm";
+    readonly referralMe: "referrals/me";
+    readonly referralStats: "referrals/stats";
+};
+/** Base paths for each mode */
+declare const BASE_PATHS: {
+    /** Proxy mode (Next.js): requests go to the same origin via route handler */
+    readonly proxy: "/api/auth";
+    /** Direct mode: requests go straight to the Azirid API */
+    readonly direct: "/v1/users/auth";
+};
+/** Build full path map from a basePath */
+declare function buildPaths(basePath: string): AuthPaths;
+/** Default paths (direct mode — backward compatible) */
+declare const PATHS: AuthPaths;
+type AuthPaths = {
+    [K in keyof typeof SUFFIXES]: string;
+};
+interface AccessClientConfig {
+    /** Base URL of the Azirid API (empty string for proxy mode) */
+    baseUrl: string;
+    /**
+     * Base path for auth endpoints.
+     * - Proxy mode: '/api/auth' (matches Next.js route handler)
+     * - Direct mode: '/v1/users/auth' (matches API routes)
+     * @default '/v1/users/auth'
+     */
+    basePath?: string;
+    /** Extra headers (e.g. Authorization) */
+    headers?: Record<string, string>;
+}
+interface AccessClient {
+    /** HTTP methods */
+    post: <T = unknown>(path: string, body?: unknown) => Promise<T>;
+    get: <T = unknown>(path: string) => Promise<T>;
+    patch: <T = unknown>(path: string, body?: unknown) => Promise<T>;
+    del: <T = unknown>(path: string) => Promise<T>;
+    /** Resolved paths */
+    paths: AuthPaths;
+    /** Base URL */
+    baseUrl: string;
+    /** App context */
+    appContext?: {
+        publishableKey: string;
+        tenantId?: string;
+    };
+    /** Manually set the access token (used by refresh/bootstrap) */
+    setAccessToken: (token: string | null) => void;
+    /** Get the current access token */
+    getAccessToken: () => string | null;
+    /** Store refresh token received from the API body (cross-origin support) */
+    setRefreshToken: (token: string | null) => void;
+    /** Get the current in-memory refresh token */
+    getRefreshToken: () => string | null;
+    /** Store CSRF token received from the API body (cross-origin support) */
+    setCsrfToken: (token: string | null) => void;
+    /** Get the current CSRF token (from memory or cookie) */
+    getCsrfToken: () => string | null;
+    /** Deduplicated refresh — safe to call from multiple places concurrently */
+    refreshSession: () => Promise<void>;
+}
+declare function createAccessClient(config: AccessClientConfig, appContext?: AccessClient['appContext']): AccessClient;
+
+/** Access the raw API client for custom calls */
+declare function useAccessClient(): AccessClient;
+/**
+ * Get the current app branding from bootstrap.
+ * Returns null when no branding is configured.
+ */
+declare function useBranding(): AppBranding | null;
+/**
+ * Get resolved i18n messages for the current locale.
+ * Falls back to Spanish (es) if no provider is found.
+ */
+declare function useMessages(): AccessMessages;
+declare function AziridProvider(props: AziridProviderProps): react_jsx_runtime.JSX.Element;
+declare function useAzirid(): AziridContextValue;
+
+declare const es: AccessMessages;
+
+declare const en: AccessMessages;
+
+/**
+ * Resolve the messages dictionary for a given locale.
+ * Optional overrides are shallow-merged per section.
+ */
+declare function resolveMessages(locale?: SupportedLocale, overrides?: Partial<AccessMessages>): AccessMessages;
+
+interface LoginData {
+    email: string;
+    password: string;
+}
+interface UseLoginOptions {
+    /** Callback after successful login */
+    onSuccess?: (response: AuthSuccessResponse) => void;
+    /** Callback on login error */
+    onError?: (error: Error) => void;
+}
+type UseLoginReturn = UseMutationResult<AuthSuccessResponse, Error, LoginData> & {
+    /** Convenience: call mutate() with consumer callbacks */
+    login: (data: LoginData) => void;
+};
+/**
+ * Hook for login. Uses the **same mutation** as `<LoginForm>` and
+ * `useAzirid().login()`, so the provider state (user, tokens, callbacks)
+ * is always in sync.
+ *
+ * @example
+ * ```tsx
+ * const { login, isPending, error } = useLogin({
+ *   onSuccess: (res) => router.push("/dashboard"),
+ *   onError: (err) => toast.error(err.message),
+ * });
+ *
+ * login({ email: "user@test.com", password: "secret" });
+ * ```
+ */
+declare function useLogin(options?: UseLoginOptions): UseLoginReturn;
+
+interface UseSignupOptions {
+    /** Callback after successful signup */
+    onSuccess?: (response: AuthSuccessResponse) => void;
+    /** Callback on signup error */
+    onError?: (error: Error) => void;
+}
+type UseSignupReturn = UseMutationResult<AuthSuccessResponse, Error, SignupData> & {
+    /** Convenience: call mutate() with consumer callbacks */
+    signup: (data: SignupData) => void;
+};
+/**
+ * Hook for signup. Uses the **same mutation** as `<SignupForm>` and
+ * `useAzirid().signup()`, so the provider state (user, tokens, callbacks)
+ * is always in sync.
+ *
+ * @example
+ * ```tsx
+ * const { signup, isPending, error } = useSignup({
+ *   onSuccess: (res) => router.push("/welcome"),
+ * });
+ *
+ * signup({ email: "new@user.com", password: "SecurePass10" });
+ * ```
+ */
+declare function useSignup(options?: UseSignupOptions): UseSignupReturn;
+
+interface UseLogoutOptions {
+    /** Callback after successful logout */
+    onSuccess?: () => void;
+    /** Callback on logout error */
+    onError?: (error: Error) => void;
+}
+type UseLogoutReturn = UseMutationResult<unknown, Error, void> & {
+    /** Convenience: call mutate() with consumer callbacks */
+    logout: () => void;
+};
+/**
+ * Hook for logout. Uses the **same mutation** as `useAzirid().logout()`,
+ * so the provider state is always in sync.
+ *
+ * @example
+ * ```tsx
+ * const { logout, isPending } = useLogout({
+ *   onSuccess: () => router.push("/login"),
+ * });
+ *
+ * <button onClick={logout}>Cerrar sesión</button>
+ * ```
+ */
+declare function useLogout(options?: UseLogoutOptions): UseLogoutReturn;
+
+interface UseSessionOptions {
+    /** Enable/disable auto-fetching (default: true) */
+    enabled?: boolean;
+    /** Refetch interval in ms (default: disabled) */
+    refetchInterval?: number;
+    /** Refetch when window gets focus (default: false) */
+    refetchOnWindowFocus?: boolean;
+}
+type UseSessionReturn = UseQueryResult<AuthUser, Error> & {
+    /** Shorthand: is the user authenticated? */
+    isAuthenticated: boolean;
+};
+/**
+ * Standalone hook to fetch the current session (GET /me).
+ * Requires `<AziridProvider>`.
+ *
+ * Useful for:
+ * - Checking if the user is still logged in on mount
+ * - Getting fresh user data from the server
+ * - Bootstrapping auth state on page load
+ *
+ * @example
+ * ```tsx
+ * const session = useSession();
+ *
+ * if (session.isLoading) return <Spinner />;
+ * if (!session.isAuthenticated) return <Redirect to="/login" />;
+ *
+ * return <p>Hola, {session.data?.firstName}</p>;
+ * ```
+ */
+declare function useSession(options?: UseSessionOptions): UseSessionReturn;
+
+interface MagicLinkRequestData {
+    email: string;
+}
+interface MagicLinkVerifyData {
+    token: string;
+}
+interface UseMagicLinkOptions {
+    /** Callback after magic link email sent */
+    onRequestSuccess?: () => void;
+    /** Callback after magic link verified (user logged in) */
+    onVerifySuccess?: (response: AuthSuccessResponse) => void;
+    /** Callback on error */
+    onError?: (error: Error) => void;
+}
+interface UseMagicLinkReturn {
+    /** Request a magic link email */
+    request: UseMutationResult<unknown, Error, MagicLinkRequestData>;
+    /** Verify the magic link token */
+    verify: UseMutationResult<AuthSuccessResponse, Error, MagicLinkVerifyData>;
+}
+/**
+ * Standalone hook for magic link auth flow. Requires `<AziridProvider>`.
+ *
+ * @example
+ * ```tsx
+ * const magicLink = useMagicLink({
+ *   onRequestSuccess: () => toast.success("Revisa tu correo"),
+ *   onVerifySuccess: (res) => router.push("/dashboard"),
+ * });
+ *
+ * // Step 1: request magic link
+ * magicLink.request.mutate({ email: "user@test.com" });
+ *
+ * // Step 2: verify token (from URL params)
+ * magicLink.verify.mutate({ token: searchParams.get("token")! });
+ * ```
+ */
+declare function useMagicLink(options?: UseMagicLinkOptions): UseMagicLinkReturn;
+
+interface UseSocialLoginOptions {
+    /** Callback after successful social login */
+    onSuccess?: (response: AuthSuccessResponse) => void;
+    /** Callback on error */
+    onError?: (error: Error) => void;
+}
+type UseSocialLoginReturn = UseMutationResult<AuthSuccessResponse, Error, SocialLoginData>;
+/**
+ * Standalone hook for social login (Google, GitHub). Requires `<AziridProvider>`.
+ *
+ * @example
+ * ```tsx
+ * const socialLogin = useSocialLogin({
+ *   onSuccess: (res) => router.push("/dashboard"),
+ * });
+ *
+ * socialLogin.mutate({
+ *   provider: "google",
+ *   providerAccountId: googleUser.id,
+ *   email: googleUser.email,
+ * });
+ * ```
+ */
+declare function useSocialLogin(options?: UseSocialLoginOptions): UseSocialLoginReturn;
+
+interface UseChangePasswordOptions {
+    /** Callback after password changed */
+    onSuccess?: (response: {
+        updated: boolean;
+    }) => void;
+    /** Callback on error */
+    onError?: (error: Error) => void;
+}
+type UseChangePasswordReturn = UseMutationResult<{
+    updated: boolean;
+}, Error, ChangePasswordData>;
+/**
+ * Standalone hook for changing password. Requires `<AziridProvider>`.
+ *
+ * @example
+ * ```tsx
+ * const changePassword = useChangePassword({
+ *   onSuccess: () => toast.success("Contraseña actualizada"),
+ * });
+ *
+ * changePassword.mutate({
+ *   currentPassword: "OldPass123!",
+ *   newPassword: "NewSecure10!",
+ * });
+ * ```
+ */
+declare function useChangePassword(options?: UseChangePasswordOptions): UseChangePasswordReturn;
+
+interface UseRefreshOptions {
+    /** Callback after tokens refreshed */
+    onSuccess?: (response: AuthSuccessResponse) => void;
+    /** Callback on error (e.g. session expired) */
+    onError?: (error: Error) => void;
+}
+type UseRefreshReturn = UseMutationResult<AuthSuccessResponse, Error, void>;
+/**
+ * Standalone hook for manually refreshing the access token.
+ * Requires `<AziridProvider>`. Uses the refresh token cookie.
+ *
+ * Note: The AccessClient automatically handles 401 responses with token refresh.
+ * This hook is for cases where you want to proactively refresh.
+ *
+ * @example
+ * ```tsx
+ * const refresh = useRefresh({
+ *   onSuccess: (res) => console.log("Token renovado"),
+ *   onError: () => router.push("/login"),
+ * });
+ *
+ * refresh.mutate();
+ * ```
+ */
+declare function useRefresh(options?: UseRefreshOptions): UseRefreshReturn;
+
+interface UseBootstrapOptions {
+    /** Enable auto-fetching on mount (default: true) */
+    enabled?: boolean;
+    /** Callback after bootstrap succeeds with an authenticated session */
+    onAuthenticated?: (response: Extract<BootstrapResponse, {
+        authenticated: true;
+    }>) => void;
+    /** Callback when no valid session exists */
+    onUnauthenticated?: () => void;
+}
+type UseBootstrapReturn = UseQueryResult<BootstrapResponse, Error> & {
+    /** Whether the bootstrap resolved to an authenticated session */
+    isAuthenticated: boolean;
+};
+/**
+ * Standalone hook for silent session bootstrap using refresh token cookie.
+ * Requires `<AziridProvider>`. Posts to the bootstrap endpoint on mount.
+ *
+ * @example
+ * ```tsx
+ * const bootstrap = useBootstrap({
+ *   onAuthenticated: (res) => console.log("Sesión restaurada:", res.user.email),
+ *   onUnauthenticated: () => router.push("/login"),
+ * });
+ *
+ * if (bootstrap.isLoading) return <Spinner />;
+ * if (!bootstrap.isAuthenticated) return <LoginPage />;
+ * ```
+ */
+declare function useBootstrap(options?: UseBootstrapOptions): UseBootstrapReturn;
+
+interface UsePasskeysOptions {
+    /** Enable auto-fetching of passkey list (default: false) */
+    listEnabled?: boolean;
+    /** Callback after passkey registered */
+    onRegisterSuccess?: () => void;
+    /** Callback after passkey revoked */
+    onRevokeSuccess?: (data: {
+        revoked: boolean;
+        passkeyId: string;
+    }) => void;
+    /** Callback after passkey login */
+    onLoginSuccess?: (response: AuthSuccessResponse) => void;
+    /** Callback on error */
+    onError?: (error: Error) => void;
+}
+interface UsePasskeysReturn {
+    /** List registered passkeys (authenticated) */
+    list: UseQueryResult<PasskeyItem[], Error>;
+    /** Start passkey registration challenge (authenticated) */
+    registerStart: UseMutationResult<PasskeyRegisterStartResponse, Error, PasskeyRegisterStartData>;
+    /** Verify passkey registration (authenticated) */
+    registerVerify: UseMutationResult<{
+        message: string;
+    }, Error, PasskeyRegisterVerifyData>;
+    /** Register a passkey directly (authenticated) */
+    register: UseMutationResult<{
+        message: string;
+    }, Error, RegisterPasskeyData>;
+    /** Revoke a passkey (authenticated) */
+    revoke: UseMutationResult<{
+        revoked: boolean;
+        passkeyId: string;
+    }, Error, string>;
+    /** Simple passkey login by credentialId (public) */
+    login: UseMutationResult<AuthSuccessResponse, Error, PasskeyLoginData>;
+    /** Start passkey login challenge (public) */
+    loginStart: UseMutationResult<PasskeyLoginStartResponse, Error, PasskeyLoginStartData | void>;
+    /** Verify passkey login (public) */
+    loginVerify: UseMutationResult<AuthSuccessResponse, Error, PasskeyLoginVerifyData>;
+}
+/**
+ * Standalone hook for passkey (WebAuthn) management. Requires `<AziridProvider>`.
+ *
+ * @example
+ * ```tsx
+ * const passkeys = usePasskeys({
+ *   listEnabled: true,
+ *   onLoginSuccess: (res) => router.push("/dashboard"),
+ *   onRegisterSuccess: () => toast.success("Passkey registrada"),
+ * });
+ *
+ * // List passkeys
+ * const { data: passkeyList } = passkeys.list;
+ *
+ * // Start registration flow
+ * const challenge = await passkeys.registerStart.mutateAsync({ deviceName: "Mi Mac" });
+ * // ... get credential from navigator.credentials.create() ...
+ * await passkeys.registerVerify.mutateAsync({ challengeId: challenge.challengeId, credential });
+ *
+ * // Login with passkey
+ * const loginChallenge = await passkeys.loginStart.mutateAsync();
+ * // ... get assertion from navigator.credentials.get() ...
+ * await passkeys.loginVerify.mutateAsync({ challengeId: loginChallenge.challengeId, credential: assertion });
+ * ```
+ */
+declare function usePasskeys(options?: UsePasskeysOptions): UsePasskeysReturn;
+
+declare function useReferral(): {
+    copyToClipboard: () => Promise<boolean>;
+    data: ReferralInfo;
+    error: Error;
+    isError: true;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: false;
+    isRefetchError: true;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "error";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<ReferralInfo, Error>>;
+    fetchStatus: _tanstack_react_query.FetchStatus;
+    promise: Promise<ReferralInfo>;
+} | {
+    copyToClipboard: () => Promise<boolean>;
+    data: ReferralInfo;
+    error: null;
+    isError: false;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: true;
+    isPlaceholderData: false;
+    status: "success";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<ReferralInfo, Error>>;
+    fetchStatus: _tanstack_react_query.FetchStatus;
+    promise: Promise<ReferralInfo>;
+} | {
+    copyToClipboard: () => Promise<boolean>;
+    data: undefined;
+    error: Error;
+    isError: true;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: true;
+    isRefetchError: false;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "error";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<ReferralInfo, Error>>;
+    fetchStatus: _tanstack_react_query.FetchStatus;
+    promise: Promise<ReferralInfo>;
+} | {
+    copyToClipboard: () => Promise<boolean>;
+    data: undefined;
+    error: null;
+    isError: false;
+    isPending: true;
+    isLoading: true;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "pending";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<ReferralInfo, Error>>;
+    fetchStatus: _tanstack_react_query.FetchStatus;
+    promise: Promise<ReferralInfo>;
+} | {
+    copyToClipboard: () => Promise<boolean>;
+    data: undefined;
+    error: null;
+    isError: false;
+    isPending: true;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "pending";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isLoading: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<ReferralInfo, Error>>;
+    fetchStatus: _tanstack_react_query.FetchStatus;
+    promise: Promise<ReferralInfo>;
+} | {
+    copyToClipboard: () => Promise<boolean>;
+    data: ReferralInfo;
+    isError: false;
+    error: null;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: true;
+    isPlaceholderData: true;
+    status: "success";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<ReferralInfo, Error>>;
+    fetchStatus: _tanstack_react_query.FetchStatus;
+    promise: Promise<ReferralInfo>;
+};
+
+declare function useReferralStats(): _tanstack_react_query.UseQueryResult<ReferralStatsData, Error>;
+
+declare function usePlans(): _tanstack_react_query.UseQueryResult<BillingPlan[], Error>;
+
+declare function useSubscription(): _tanstack_react_query.UseQueryResult<UserSubscription, Error>;
+
+interface CheckoutParams {
+    planId?: string;
+    intentId?: string;
+    successUrl: string;
+    cancelUrl: string;
+    provider?: PaymentProviderType;
+}
+interface UseCheckoutOptions {
+    onSuccess?: (data: CheckoutResponse) => void;
+    onError?: (error: Error) => void;
+    redirectOnSuccess?: boolean;
+}
+declare function useCheckout(options?: UseCheckoutOptions): {
+    checkout: (params: CheckoutParams) => void;
+    data: undefined;
+    variables: undefined;
+    error: null;
+    isError: false;
+    isIdle: true;
+    isPending: false;
+    isSuccess: false;
+    status: "idle";
+    mutate: _tanstack_react_query.UseMutateFunction<CheckoutResponse, Error, CheckoutParams, unknown>;
+    reset: () => void;
+    context: unknown;
+    failureCount: number;
+    failureReason: Error | null;
+    isPaused: boolean;
+    submittedAt: number;
+    mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<CheckoutResponse, Error, CheckoutParams, unknown>;
+} | {
+    checkout: (params: CheckoutParams) => void;
+    data: undefined;
+    variables: CheckoutParams;
+    error: null;
+    isError: false;
+    isIdle: false;
+    isPending: true;
+    isSuccess: false;
+    status: "pending";
+    mutate: _tanstack_react_query.UseMutateFunction<CheckoutResponse, Error, CheckoutParams, unknown>;
+    reset: () => void;
+    context: unknown;
+    failureCount: number;
+    failureReason: Error | null;
+    isPaused: boolean;
+    submittedAt: number;
+    mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<CheckoutResponse, Error, CheckoutParams, unknown>;
+} | {
+    checkout: (params: CheckoutParams) => void;
+    data: undefined;
+    error: Error;
+    variables: CheckoutParams;
+    isError: true;
+    isIdle: false;
+    isPending: false;
+    isSuccess: false;
+    status: "error";
+    mutate: _tanstack_react_query.UseMutateFunction<CheckoutResponse, Error, CheckoutParams, unknown>;
+    reset: () => void;
+    context: unknown;
+    failureCount: number;
+    failureReason: Error | null;
+    isPaused: boolean;
+    submittedAt: number;
+    mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<CheckoutResponse, Error, CheckoutParams, unknown>;
+} | {
+    checkout: (params: CheckoutParams) => void;
+    data: CheckoutResponse;
+    error: null;
+    variables: CheckoutParams;
+    isError: false;
+    isIdle: false;
+    isPending: false;
+    isSuccess: true;
+    status: "success";
+    mutate: _tanstack_react_query.UseMutateFunction<CheckoutResponse, Error, CheckoutParams, unknown>;
+    reset: () => void;
+    context: unknown;
+    failureCount: number;
+    failureReason: Error | null;
+    isPaused: boolean;
+    submittedAt: number;
+    mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<CheckoutResponse, Error, CheckoutParams, unknown>;
+};
+
+declare function useInvoices(): _tanstack_react_query.UseQueryResult<BillingInvoice[], Error>;
+
+interface UseTransferProofOptions {
+    onSuccess?: (data: TransferProof) => void;
+    onError?: (error: Error) => void;
+}
+declare function useSubmitTransferProof(options?: UseTransferProofOptions): {
+    submit: (data: SubmitTransferProofData) => void;
+    data: undefined;
+    variables: undefined;
+    error: null;
+    isError: false;
+    isIdle: true;
+    isPending: false;
+    isSuccess: false;
+    status: "idle";
+    mutate: _tanstack_react_query.UseMutateFunction<TransferProof, Error, SubmitTransferProofData, unknown>;
+    reset: () => void;
+    context: unknown;
+    failureCount: number;
+    failureReason: Error | null;
+    isPaused: boolean;
+    submittedAt: number;
+    mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<TransferProof, Error, SubmitTransferProofData, unknown>;
+} | {
+    submit: (data: SubmitTransferProofData) => void;
+    data: undefined;
+    variables: SubmitTransferProofData;
+    error: null;
+    isError: false;
+    isIdle: false;
+    isPending: true;
+    isSuccess: false;
+    status: "pending";
+    mutate: _tanstack_react_query.UseMutateFunction<TransferProof, Error, SubmitTransferProofData, unknown>;
+    reset: () => void;
+    context: unknown;
+    failureCount: number;
+    failureReason: Error | null;
+    isPaused: boolean;
+    submittedAt: number;
+    mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<TransferProof, Error, SubmitTransferProofData, unknown>;
+} | {
+    submit: (data: SubmitTransferProofData) => void;
+    data: undefined;
+    error: Error;
+    variables: SubmitTransferProofData;
+    isError: true;
+    isIdle: false;
+    isPending: false;
+    isSuccess: false;
+    status: "error";
+    mutate: _tanstack_react_query.UseMutateFunction<TransferProof, Error, SubmitTransferProofData, unknown>;
+    reset: () => void;
+    context: unknown;
+    failureCount: number;
+    failureReason: Error | null;
+    isPaused: boolean;
+    submittedAt: number;
+    mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<TransferProof, Error, SubmitTransferProofData, unknown>;
+} | {
+    submit: (data: SubmitTransferProofData) => void;
+    data: TransferProof;
+    error: null;
+    variables: SubmitTransferProofData;
+    isError: false;
+    isIdle: false;
+    isPending: false;
+    isSuccess: true;
+    status: "success";
+    mutate: _tanstack_react_query.UseMutateFunction<TransferProof, Error, SubmitTransferProofData, unknown>;
+    reset: () => void;
+    context: unknown;
+    failureCount: number;
+    failureReason: Error | null;
+    isPaused: boolean;
+    submittedAt: number;
+    mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<TransferProof, Error, SubmitTransferProofData, unknown>;
+};
+declare function useTransferProofs(): _tanstack_react_query.UseQueryResult<TransferProof[], Error>;
+
+declare function usePaymentProviders(): _tanstack_react_query.UseQueryResult<AvailableProvider[], Error>;
+
+interface PayphoneConfirmParams {
+    id: number;
+    clientTransactionId: string;
+}
+interface PayphoneConfirmResult {
+    status: 'confirmed' | 'cancelled' | 'already_confirmed';
+    intentId: string;
+}
+interface UsePayphoneConfirmOptions {
+    onSuccess?: (data: PayphoneConfirmResult) => void;
+    onError?: (error: Error) => void;
+}
+declare function usePayphoneConfirm(options?: UsePayphoneConfirmOptions): _tanstack_react_query.UseMutationResult<PayphoneConfirmResult, Error, PayphoneConfirmParams, unknown>;
+
+declare function useFormState<T extends Record<string, unknown>>(initialValues: T, schema: z.ZodType<unknown, z.ZodTypeDef, unknown>, onSubmit: (values: T) => void | Promise<void>): UseFormReturn<T>;
+
+declare function usePasswordToggle(): {
+    visible: boolean;
+    toggle: () => void;
+    type: "password" | "text";
+};
+
+declare function createLoginSchema(v: AccessMessages['validation']): z.ZodObject<{
+    email: z.ZodString;
+    password: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    email: string;
+    password: string;
+}, {
+    email: string;
+    password: string;
+}>;
+declare function createSignupSchema(v: AccessMessages['validation']): z.ZodObject<{
+    email: z.ZodString;
+    password: z.ZodString;
+    acceptedTosVersion: z.ZodOptional<z.ZodString>;
+    acceptedPrivacyVersion: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    email: string;
+    password: string;
+    acceptedTosVersion?: string | undefined;
+    acceptedPrivacyVersion?: string | undefined;
+}, {
+    email: string;
+    password: string;
+    acceptedTosVersion?: string | undefined;
+    acceptedPrivacyVersion?: string | undefined;
+}>;
+declare const loginSchema: z.ZodObject<{
+    email: z.ZodString;
+    password: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    email: string;
+    password: string;
+}, {
+    email: string;
+    password: string;
+}>;
+type LoginInput = z.infer<typeof loginSchema>;
+declare const signupSchema: z.ZodObject<{
+    email: z.ZodString;
+    password: z.ZodString;
+    acceptedTosVersion: z.ZodOptional<z.ZodString>;
+    acceptedPrivacyVersion: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    email: string;
+    password: string;
+    acceptedTosVersion?: string | undefined;
+    acceptedPrivacyVersion?: string | undefined;
+}, {
+    email: string;
+    password: string;
+    acceptedTosVersion?: string | undefined;
+    acceptedPrivacyVersion?: string | undefined;
+}>;
+type SignupInput = z.infer<typeof signupSchema>;
+declare const changePasswordSchema: z.ZodObject<{
+    currentPassword: z.ZodString;
+    newPassword: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    currentPassword: string;
+    newPassword: string;
+}, {
+    currentPassword: string;
+    newPassword: string;
+}>;
+type ChangePasswordInput = z.infer<typeof changePasswordSchema>;
+declare const magicLinkRequestSchema: z.ZodObject<{
+    email: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    email: string;
+}, {
+    email: string;
+}>;
+type MagicLinkRequestInput = z.infer<typeof magicLinkRequestSchema>;
+declare const magicLinkVerifySchema: z.ZodObject<{
+    token: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    token: string;
+}, {
+    token: string;
+}>;
+type MagicLinkVerifyInput = z.infer<typeof magicLinkVerifySchema>;
+declare const socialLoginSchema: z.ZodObject<{
+    provider: z.ZodEnum<["google", "github"]>;
+    providerAccountId: z.ZodString;
+    email: z.ZodString;
+    emailVerified: z.ZodOptional<z.ZodBoolean>;
+    firstName: z.ZodOptional<z.ZodString>;
+    lastName: z.ZodOptional<z.ZodString>;
+    createUserIfNotExists: z.ZodOptional<z.ZodBoolean>;
+    turnstileToken: z.ZodOptional<z.ZodString>;
+    acceptedTosVersion: z.ZodOptional<z.ZodString>;
+    acceptedPrivacyVersion: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    email: string;
+    provider: "google" | "github";
+    providerAccountId: string;
+    firstName?: string | undefined;
+    lastName?: string | undefined;
+    emailVerified?: boolean | undefined;
+    acceptedTosVersion?: string | undefined;
+    acceptedPrivacyVersion?: string | undefined;
+    createUserIfNotExists?: boolean | undefined;
+    turnstileToken?: string | undefined;
+}, {
+    email: string;
+    provider: "google" | "github";
+    providerAccountId: string;
+    firstName?: string | undefined;
+    lastName?: string | undefined;
+    emailVerified?: boolean | undefined;
+    acceptedTosVersion?: string | undefined;
+    acceptedPrivacyVersion?: string | undefined;
+    createUserIfNotExists?: boolean | undefined;
+    turnstileToken?: string | undefined;
+}>;
+type SocialLoginInput = z.infer<typeof socialLoginSchema>;
+declare const passkeyRegisterStartSchema: z.ZodObject<{
+    deviceName: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    deviceName?: string | undefined;
+}, {
+    deviceName?: string | undefined;
+}>;
+type PasskeyRegisterStartInput = z.infer<typeof passkeyRegisterStartSchema>;
+
+declare function cn(...inputs: ClassValue[]): string;
+
+/** Remove injected styles from the DOM (useful when embedding in host apps). */
+declare function removeStyles(): void;
+
+declare global {
+    interface Window {
+        PPaymentButtonBox: new (config: Record<string, unknown>) => {
+            render: (containerId: string) => void;
+        };
+    }
+}
+interface PayphoneModalProps {
+    config: PayphoneWidgetConfig;
+    successUrl: string;
+    onClose: () => void;
+}
+
+interface SessionSyncOptions {
+    /** Cookie name (default: "__session") */
+    cookieName?: string;
+    /** Set Secure flag on cookie (default: false) */
+    secure?: boolean;
+    /** Cookie max age in seconds (default: 3600 = 1h) */
+    maxAge?: number;
+}
+
+declare const SDK_VERSION: string;
+
+export { type AccessClient, type AccessClientConfig, type AccessMessages, type ApiError, type AppBranding, type AuthPaths, type AuthState, type AuthSuccessResponse, type AuthUser, type AvailableProvider, type AziridContextValue, AziridProvider, type AziridProviderProps, BASE_PATHS, type BillingInvoice, type BillingPlan, type BootstrapResponse, type ChangePasswordData, type ChangePasswordInput, CheckoutButton, type CheckoutButtonProps, type CheckoutParams, type CheckoutResponse, type FieldError, InvoiceList, type InvoiceListProps, type LoginData, LoginForm, type LoginFormProps, type LoginInput, type MagicLinkRequestData, type MagicLinkRequestInput, type MagicLinkVerifyData, type MagicLinkVerifyInput, PATHS, type PasskeyItem, type PasskeyLoginData, type PasskeyLoginStartData, type PasskeyLoginStartResponse, type PasskeyLoginVerifyData, type PasskeyRegisterStartData, type PasskeyRegisterStartInput, type PasskeyRegisterStartResponse, type PasskeyRegisterVerifyData, PayButton, type PayButtonProps, type PaymentIntent, type PaymentProviderType, PayphoneCallback, type PayphoneCallbackProps, type PayphoneConfirmParams, type PayphoneConfirmResult, type PayphoneModalProps, type PayphoneWidgetConfig, PricingTable, type PricingTableProps, ReferralCard, type ReferralCardProps, type ReferralInfo, type ReferralItem, ReferralStats, type ReferralStatsData, type ReferralStatsProps, type RegisterPasskeyData, SDK_VERSION, type SessionSyncOptions, type SignupData, SignupForm, type SignupFormProps, type SignupInput, type SocialLoginData, type SocialLoginInput, type SubmitTransferProofData, SubscriptionBadge, type SubscriptionBadgeProps, type SupportedLocale, type TransferProof, type UseBootstrapOptions, type UseBootstrapReturn, type UseChangePasswordOptions, type UseChangePasswordReturn, type UseCheckoutOptions, type UseFormReturn, type UseLoginOptions, type UseLoginReturn, type UseLogoutOptions, type UseLogoutReturn, type UseMagicLinkOptions, type UseMagicLinkReturn, type UsePasskeysOptions, type UsePasskeysReturn, type UsePayphoneConfirmOptions, type UseRefreshOptions, type UseRefreshReturn, type UseSessionOptions, type UseSessionReturn, type UseSignupOptions, type UseSignupReturn, type UseSocialLoginOptions, type UseSocialLoginReturn, type UserSubscription, buildPaths, changePasswordSchema, cn, createAccessClient, createLoginSchema, createSignupSchema, en, es, isAuthError, loginSchema, magicLinkRequestSchema, magicLinkVerifySchema, passkeyRegisterStartSchema, removeStyles, resolveMessages, signupSchema, socialLoginSchema, useAccessClient, useAzirid, useBootstrap, useBranding, useChangePassword, useCheckout, useFormState, useInvoices, useLogin, useLogout, useMagicLink, useMessages, usePasskeys, usePasswordToggle, usePaymentProviders, usePayphoneConfirm, usePlans, useReferral, useReferralStats, useRefresh, useSession, useSignup, useSocialLogin, useSubmitTransferProof, useSubscription, useTransferProofs };