@hook-sdk/template 0.9.1 → 0.11.0

package/dist/index.d.ts

@@ -1,92 +1,114 @@
 import * as react_jsx_runtime from 'react/jsx-runtime';
+import * as react from 'react';
 import { ReactNode, ComponentType, Component } from 'react';
-import { z } from 'zod';
 import * as _hook_sdk_sdk from '@hook-sdk/sdk';
-import { CheckoutCycle, CheckoutCardData, CheckoutHolderInfo, PlanState, ReminderSlot } from '@hook-sdk/sdk';
+import { CheckoutMethod as CheckoutMethod$1, CheckoutCycle, CheckoutResult, CheckoutCardData, CheckoutHolderInfo, PlanState, ReminderSlot } from '@hook-sdk/sdk';
 export { PlanInfo, PlanState } from '@hook-sdk/sdk';
+import { z } from 'zod';
 
-declare const AppConfigSchema: z.ZodObject<{
-    $schema: z.ZodOptional<z.ZodString>;
-    slug: z.ZodString;
-    name: z.ZodString;
-    display_name: z.ZodOptional<z.ZodString>;
-    email_alias: z.ZodString;
-    theme: z.ZodObject<{
-        primary_color: z.ZodString;
-        background_color: z.ZodOptional<z.ZodString>;
-        logo_url: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        icon_url: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-    }, z.core.$strict>;
-    features_enabled: z.ZodArray<z.ZodEnum<{
-        db: "db";
-        storage: "storage";
-        upload: "upload";
-        leaderboard: "leaderboard";
-        push: "push";
-        subscription: "subscription";
-        install_prompt: "install_prompt";
-    }>>;
-    persistedKeys: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    dependencies_allowlist: z.ZodArray<z.ZodString>;
-    subscription: z.ZodObject<{
-        price_cents: z.ZodNumber;
-        currency: z.ZodLiteral<"brl">;
-        trial_days: z.ZodNumber;
-        mode: z.ZodDefault<z.ZodEnum<{
-            trial: "trial";
-            pay_first: "pay_first";
-            free: "free";
-        }>>;
-        cpf_required: z.ZodOptional<z.ZodBoolean>;
-        trial_type: z.ZodOptional<z.ZodEnum<{
-            sem_cartao: "sem_cartao";
-            com_cartao: "com_cartao";
-            nenhum: "nenhum";
-        }>>;
-        paywall_config: z.ZodObject<{
-            title: z.ZodString;
-            subtitle: z.ZodOptional<z.ZodString>;
-            benefits: z.ZodArray<z.ZodString>;
-            cta: z.ZodString;
-            priceHint: z.ZodOptional<z.ZodString>;
-            footerNote: z.ZodOptional<z.ZodString>;
-        }, z.core.$strict>;
-    }, z.core.$strict>;
-    auth: z.ZodOptional<z.ZodObject<{
-        has_forgot: z.ZodDefault<z.ZodBoolean>;
-        email_verification_required: z.ZodDefault<z.ZodBoolean>;
-        min_password_length: z.ZodDefault<z.ZodNumber>;
-        pre_auth_routes: z.ZodDefault<z.ZodArray<z.ZodString>>;
-        post_auth_landing: z.ZodDefault<z.ZodString>;
-        signup_anti_enum: z.ZodDefault<z.ZodBoolean>;
-    }, z.core.$strict>>;
-    sdk_version_required: z.ZodString;
-    template_version_required: z.ZodOptional<z.ZodString>;
-    max_bundle_size_kb: z.ZodNumber;
-}, z.core.$strict>;
-type AppConfig = z.infer<typeof AppConfigSchema>;
+type Cycle = 'MONTHLY' | 'YEARLY';
+type CheckoutMethod = 'card' | 'pix-auto' | 'pix-once';
+type AuthFlowConfig = {
+    minPassword: number;
+    requiresEmailVerify: boolean;
+    googleOAuth: boolean;
+    postAuthLanding: string;
+    preAuthRoutes: string[];
+};
+type PaywallConfig = {
+    mode: 'free';
+} | {
+    mode: 'trial' | 'pay_first';
+    trialDays?: number;
+    cycles: Cycle[];
+    prices: {
+        monthlyCents: number;
+        yearlyCents: number;
+    };
+    anchorPrices?: {
+        monthlyCents: number;
+        yearlyCents: number;
+    };
+    checkoutMethods: CheckoutMethod[];
+    requiresCpf: boolean;
+    cancelWindowDays?: number;
+    errorMessages: 'default' | 'custom';
+};
+type PersistedKey = {
+    key: string;
+    default: unknown;
+    guardRegen?: boolean;
+    debounceMs?: number;
+};
+type OnboardingStep = {
+    id: string;
+    screen: string;
+    validates?: string[];
+};
+type OnboardingConfig = {
+    trigger: 'pre_signup' | 'post_signup' | 'pre_signup_custom' | 'optional';
+    steps: OnboardingStep[];
+    persistTo: 'appData';
+    persistKey: string;
+};
+type DeepLinks = {
+    passwordReset?: string;
+    emailVerify?: string;
+};
+type AppConfig = {
+    slug: string;
+    name: string;
+    branding: {
+        primaryColor: string;
+        logoUrl: string;
+    };
+    authFlow: AuthFlowConfig;
+    paywall: PaywallConfig;
+    persistedKeys: PersistedKey[];
+    onboarding?: OnboardingConfig;
+    deepLinks?: DeepLinks;
+    features_enabled?: string[];
+    theme?: Record<string, unknown>;
+};
 
-type AuthScreen = 'login' | 'signup' | 'forgot' | 'reset';
 interface AuthScreenProps {
-    onNavigate: (to: AuthScreen) => void;
+    /**
+     * Optional callback for in-screen navigation between the auth screens
+     * (e.g. Login → Signup). Pre-Router screens used this; Router-based
+     * screens should use `useNavigate()` from react-router-dom directly and
+     * may ignore this prop.
+     */
+    onNavigate?: (target: 'login' | 'signup' | 'forgot' | 'reset') => void;
 }
-declare function DefaultLoginScreen({ onNavigate }: AuthScreenProps): react_jsx_runtime.JSX.Element;
 
-interface AppRootProps {
-    config: AppConfig;
+declare function PaymentReturnHandler({ children }: {
     children: ReactNode;
-    Login?: ComponentType<AuthScreenProps>;
-    Signup?: ComponentType<AuthScreenProps>;
-    Forgot?: ComponentType<AuthScreenProps>;
-    /**
-     * Tela de reset de senha (form com nova senha via link do email).
-     * Renderizada pelo AuthGate quando URL tem `?token=` + user não logado.
-     * Default: DefaultResetScreen.
-     */
-    Reset?: ComponentType<AuthScreenProps>;
+}): react_jsx_runtime.JSX.Element;
+
+type AppRootSlots = {
+    Login: ComponentType<AuthScreenProps>;
+    Signup: ComponentType<AuthScreenProps>;
+    Forgot: ComponentType<AuthScreenProps>;
+    Reset: ComponentType<AuthScreenProps>;
+    /** Required when config.authFlow.requiresEmailVerify === true. */
+    EmailVerify?: ComponentType<AuthScreenProps>;
+    /** Required when config.paywall.mode !== "free". */
     Paywall?: ComponentType;
-}
-declare function AppRoot({ config, children, Login, Signup, Forgot, Reset, Paywall, }: AppRootProps): react_jsx_runtime.JSX.Element;
+    /** Map of step id → component. Used when config.onboarding && trigger !== "pre_signup_custom". */
+    Onboarding?: Record<string, ComponentType>;
+    /** Required when config.onboarding?.trigger === "pre_signup_custom". */
+    PreAuthFlow?: ComponentType;
+};
+type AppRootProps = AppRootSlots & {
+    config: AppConfig;
+    children?: ReactNode;
+    /** Test-only: skip BrowserRouter (which fights jsdom's document.location). */
+    testRouter?: 'memory';
+    /** Test-only: initial entries for MemoryRouter. */
+    testInitialEntries?: string[];
+};
+
+declare function AppRoot(props: AppRootProps): react_jsx_runtime.JSX.Element;
 
 interface PushPromptTexts {
     cta: string;
@@ -119,22 +141,6 @@ interface InstallSplashProps {
 }
 declare function InstallSplash({ children, title, subtitle }: InstallSplashProps): react_jsx_runtime.JSX.Element;
 
-declare function DefaultSignupScreen({ onNavigate }: AuthScreenProps): react_jsx_runtime.JSX.Element;
-
-declare function DefaultForgotScreen({ onNavigate }: AuthScreenProps): react_jsx_runtime.JSX.Element;
-
-/**
- * Tela default de reset de senha. Renderizada pelo AuthGate quando
- * `?token=` está presente na URL (link vindo do email de password_reset).
- *
- * AuthScreenProps.onNavigate é usado pra voltar pro login após reset
- * bem-sucedido (usuário precisa re-autenticar — backend revoga todos
- * os refresh tokens na chamada de `auth.reset`).
- */
-declare function DefaultResetScreen({ onNavigate }: AuthScreenProps): react_jsx_runtime.JSX.Element;
-
-declare function DefaultPaywall(): react_jsx_runtime.JSX.Element;
-
 declare function LoadingState({ message }: {
     message?: string;
 }): react_jsx_runtime.JSX.Element;
@@ -155,10 +161,24 @@ interface State {
 declare class ErrorBoundary extends Component<Props, State> {
     state: State;
     static getDerivedStateFromError(error: Error): State;
-    componentDidCatch(error: Error): void;
+    componentDidCatch(error: Error, info: {
+        componentStack: string;
+    }): void;
     render(): string | number | boolean | Iterable<ReactNode> | react_jsx_runtime.JSX.Element;
 }
 
+/**
+ * Reads `?token=` from the URL on mount + on location change. When present and
+ * the current pathname is `/`, redirects to the configured deep-link path
+ * (passwordReset or emailVerify) substituting `:token` for the actual value.
+ *
+ * Mounts once inside `<AppRoot>` (post-Router); a no-op when `deepLinks` is
+ * undefined or no `token` is in the URL.
+ */
+declare function DeepLinkHandler({ deepLinks }: {
+    deepLinks?: DeepLinks;
+}): null;
+
 type AuthFormErrorCode = 'invalid_credentials' | 'rate_limited' | 'email_unverified' | 'account_locked' | 'network' | 'server';
 interface AuthFormError {
     code: AuthFormErrorCode;
@@ -267,64 +287,98 @@ interface UseResetFormResult {
 declare function useResetForm(): UseResetFormResult;
 
 type SubscriptionStatus = 'active' | 'trialing' | 'expired' | 'canceled' | 'past_due' | 'pending' | 'none';
-type PaymentMethod = 'card' | 'pix-auto' | 'pix-once';
+type PaymentMethod = CheckoutMethod$1;
+interface PaywallError {
+    code: string;
+    message: string;
+    userMessage: string;
+}
+/**
+ * Local pixPending shape — re-exposes SDK's reactive `subscription.pixPending`
+ * with two extra UI-facing fields:
+ * - `expiresAt`: null (kept for compat; SDK does not surface expiry on auto/once)
+ * - `paid`: derived from `subscription.current.status` — flips true when the
+ *   underlying subscription transitions to ACTIVE/TRIAL after the user pays
+ *   the QR code. SDK clears the underlying pixPending shortly after; this
+ *   wrapper preserves the "paid" frame for ~1 render so the paywall can show
+ *   confirmation copy before unmounting the modal.
+ */
 interface PixPending {
     method: 'pix-auto' | 'pix-once';
     qrCodePayload: string | null;
     qrCodeBase64: string | null;
     expiresAt: string | null;
-    /**
-     * Flipa `true` quando o polling detecta subscription ACTIVE/TRIAL (webhook
-     * PAYMENT_RECEIVED ou AUTHORIZATION_ACTIVATED chegou). UI deve renderizar
-     * confirmação visual nesse momento; após 2-3s chama `dismissPix` pra
-     * limpar o modal e deixar SubscriptionGate liberar o app.
-     */
     paid: boolean;
 }
+interface CardFormState {
+    number: string;
+    cvv: string;
+    expiry: string;
+    holder: string;
+}
+interface CardFormStateWithSetter extends CardFormState {
+    set: (patch: Partial<CardFormState>) => void;
+}
+interface CpfState {
+    required: boolean;
+    value: string;
+    set: (v: string) => void;
+    valid: boolean;
+}
 interface PaywallCheckoutArgs {
     cpf: string;
     cycle: CheckoutCycle;
-    method: 'card' | 'pix-auto';
-    /** Required when method === 'card'. */
+    method: 'card' | 'pix-auto' | 'pix-once';
     card?: CheckoutCardData;
-    /** Required when method === 'card'. */
     holderInfo?: CheckoutHolderInfo;
-    /** Optional; backend falls back to X-Forwarded-For when absent. */
     remoteIp?: string;
 }
+interface PaywallPlanDerived {
+    monthlyCents: number;
+    yearlyCents: number | null;
+    anchorMonthlyCents?: number;
+    anchorYearlyCents?: number;
+    monthlyEquivalent: number;
+    discountPercent: number;
+}
 /**
- * Hook headless pro Paywall. Expõe status da subscription + ação
- * `checkout({cpf, cycle, method, card?, holderInfo?, remoteIp?})`.
- *
- * App Store substrate (2026-04-24, SDK 0.14.0+):
- *
- * - **method='card'** → backend tokeniza via Asaas `/v3/creditCard/tokenize`
- *   e cria subscription com `nextDueDate = today + trialDays`. Sem cobrança
- *   no day 0; trial corre enquanto Asaas já segura o instrumento. Caller
- *   obrigatório passar `card` + `holderInfo`. Nada é persistido/loggado no
- *   SDK — PAN/CVV transitam só no request HTTPS direto ao backend. Após
- *   success chama `subscription.refresh()` pra SubscriptionGate liberar
- *   o app automaticamente (status passa pra `trialing`).
+ * Headless paywall state — owns:
+ * - reactive subscription status (proxied from SDK)
+ * - cycle / selectedMethod / cpf / card form state
+ * - methods list (config.paywall.checkoutMethods filtered by SDK methodAvailability)
+ * - submit() — high-level no-args entrypoint that uses internal state
+ * - error mapping via asaasErrorMessage when paywall.errorMessages === 'default'
  *
- * - **method='pix-auto'** → Pix Automático BACEN Jornada 3. User escaneia
- *   QR 1x, autoriza débito recorrente no app do banco. Retorna QR via
- *   `pixPending` (polling existing detecta ativação e flipa `paid=true`).
- *
- * Subscription real é atualizada via webhook (`PAYMENT_RECEIVED` ou
- * `PIX_AUTOMATIC_RECURRING_AUTHORIZATION_ACTIVATED`).
+ * Backward-compat aliases preserved for SDK 0.13/template 0.9 consumers:
+ * - `availableMethods` mirrors `methods`
+ * - `opening` mirrors `submitting`
+ * - `checkout(args)` takes legacy args + validates card/holderInfo presence
+ * - `dismissPix` no-op (SDK polling auto-clears pixPending on settle)
+ * - `monthlyEquivalent(cycle)` helper
  */
 declare function usePaywallState(): {
     status: SubscriptionStatus;
     daysLeftInTrial: number | null;
     initialLoadComplete: boolean;
+    plan: PaywallPlanDerived | null;
+    cycle: CheckoutCycle;
+    setCycle: react.Dispatch<react.SetStateAction<CheckoutCycle>>;
+    methods: readonly CheckoutMethod$1[];
+    selectedMethod: CheckoutMethod$1;
+    setSelectedMethod: react.Dispatch<react.SetStateAction<CheckoutMethod$1>>;
+    cpfState: CpfState;
+    cardState: CardFormStateWithSetter;
+    submit: () => Promise<CheckoutResult | undefined>;
     checkout: (args: PaywallCheckoutArgs) => Promise<void>;
     cancel: () => Promise<void>;
-    opening: boolean;
-    error: Error | null;
     pixPending: PixPending | null;
+    error: PaywallError | null;
+    submitting: boolean;
+    opening: boolean;
+    availableMethods: readonly CheckoutMethod$1[];
+    monthlyEquivalent: (c: CheckoutCycle) => number;
     dismissPix: () => void;
-    availableMethods: readonly ("card" | "pix-auto")[];
-    monthlyEquivalent: (cycle: CheckoutCycle) => number;
+    refreshPlan: () => void;
 };
 
 /**
@@ -623,4 +677,149 @@ declare function shouldBlockInstall(state: InstallState, now?: number): boolean;
  */
 declare function shouldShowPermanentOption(state: InstallState): boolean;
 
-export { type AndroidBrowser, AppRoot, type AppRootProps, type AuthFormError, type AuthFormErrorCode, type AuthScreen, type AuthScreenProps, DefaultForgotScreen, DefaultLoginScreen, DefaultPaywall, DefaultResetScreen, DefaultSignupScreen, EmptyState, ErrorBoundary, type IOSBrowser, type InAppApp, type InstallActions, InstallGate, InstallSplash, type InstallState, type InstallVariant, LoadingState, type PaymentMethod, type PixPending, type Platform, PushPrompt, type PushPromptProps, type PushPromptTexts, type PushUiState, type SubscriptionStatus, type ToastItem, type UseLoginFormResult, type UseResetFormResult, computeAnchorCents, dailyFromYearly, detectAndroidBrowser, detectIOSBrowser, detectInAppApp, detectPlatform, detectStandalone, discountPercent, formatBRL, monthlyFromYearly, shouldBlockInstall, shouldShowPermanentOption, useAuth, useAuthPrimitives, useForgotForm, useInstallPrompt, useLoginForm, usePaywallState, usePlan, usePush, useReminders, useResetForm, useSignupForm, useSubscription, useToast };
+declare function asaasErrorMessage(code: string): string;
+
+type RouteBoundaryProps = {
+    children: ReactNode;
+};
+declare function RouteBoundary({ children }: RouteBoundaryProps): react_jsx_runtime.JSX.Element;
+
+type PreAuthShellProps = {
+    basename?: string;
+    /** Test-only escape hatch — use MemoryRouter so jsdom doesn't fight document.location. */
+    testRouter?: 'memory';
+    /** Optional initial entries for MemoryRouter; ignored otherwise. */
+    testInitialEntries?: string[];
+    children: ReactNode;
+};
+declare function PreAuthShell({ basename, testRouter, testInitialEntries, children, }: PreAuthShellProps): react_jsx_runtime.JSX.Element;
+
+type PersistenceRegistryProps = {
+    config: PersistedKey[];
+    children: ReactNode;
+};
+/**
+ * Fire-and-forget prefetch of every key declared in `app.config.json.persistedKeys`
+ * via `appData.bulkRead`. Does NOT gate render — children mount immediately;
+ * `usePersistedState` consumers hit cache as soon as the prefetch resolves.
+ *
+ * Use when the consuming app tolerates a brief flash of `defaultValue` before
+ * hydrated state lands. For strict "no flash" semantics use `<PersistedKeysPrefetch>`
+ * (gating variant in `internal/`).
+ */
+declare function PersistenceRegistry({ config, children }: PersistenceRegistryProps): react_jsx_runtime.JSX.Element;
+
+type OnboardingStepDef = {
+    id: string;
+    screen: string;
+    validates?: string[];
+};
+type OnboardingFlowProps = {
+    steps: OnboardingStepDef[];
+    screens: Record<string, ComponentType>;
+    onComplete: (value: Record<string, unknown>) => void;
+    persistKey: string;
+};
+declare function OnboardingFlow({ steps, screens, onComplete, persistKey, }: OnboardingFlowProps): react_jsx_runtime.JSX.Element | null;
+
+type OnboardingStepCtx = {
+    stepIndex: number;
+    totalSteps: number;
+    next: () => void;
+    prev: () => void;
+    value: Record<string, unknown>;
+    setValue: (patch: Record<string, unknown>) => void;
+    valid: boolean;
+};
+declare function useOnboardingStep(): OnboardingStepCtx;
+
+/**
+ * Returns `true` when `app.config.json.features_enabled` includes `name`.
+ * Use to gate optional UI surfaces (e.g. share button, premium-only screens)
+ * without scattering the feature list across the codebase.
+ */
+declare function useFeature(name: string): boolean;
+
+declare function AppConfigProvider({ config, children, }: {
+    config: AppConfig;
+    children: ReactNode;
+}): react_jsx_runtime.JSX.Element;
+declare function useAppConfig(): AppConfig;
+
+declare const AppConfigSchema: z.ZodObject<{
+    slug: z.ZodString;
+    name: z.ZodString;
+    branding: z.ZodObject<{
+        primaryColor: z.ZodString;
+        logoUrl: z.ZodString;
+    }, z.core.$strip>;
+    authFlow: z.ZodObject<{
+        minPassword: z.ZodNumber;
+        requiresEmailVerify: z.ZodBoolean;
+        googleOAuth: z.ZodBoolean;
+        postAuthLanding: z.ZodString;
+        preAuthRoutes: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>;
+    paywall: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        mode: z.ZodEnum<{
+            trial: "trial";
+            pay_first: "pay_first";
+        }>;
+        trialDays: z.ZodOptional<z.ZodNumber>;
+        cycles: z.ZodArray<z.ZodEnum<{
+            MONTHLY: "MONTHLY";
+            YEARLY: "YEARLY";
+        }>>;
+        prices: z.ZodObject<{
+            monthlyCents: z.ZodNumber;
+            yearlyCents: z.ZodNumber;
+        }, z.core.$strip>;
+        anchorPrices: z.ZodOptional<z.ZodObject<{
+            monthlyCents: z.ZodNumber;
+            yearlyCents: z.ZodNumber;
+        }, z.core.$strip>>;
+        checkoutMethods: z.ZodArray<z.ZodEnum<{
+            card: "card";
+            "pix-auto": "pix-auto";
+            "pix-once": "pix-once";
+        }>>;
+        requiresCpf: z.ZodBoolean;
+        cancelWindowDays: z.ZodOptional<z.ZodNumber>;
+        errorMessages: z.ZodEnum<{
+            default: "default";
+            custom: "custom";
+        }>;
+    }, z.core.$strip>, z.ZodObject<{
+        mode: z.ZodLiteral<"free">;
+    }, z.core.$strip>], "mode">;
+    persistedKeys: z.ZodArray<z.ZodObject<{
+        key: z.ZodString;
+        default: z.ZodUnknown;
+        guardRegen: z.ZodOptional<z.ZodBoolean>;
+        debounceMs: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    onboarding: z.ZodOptional<z.ZodObject<{
+        trigger: z.ZodEnum<{
+            pre_signup: "pre_signup";
+            post_signup: "post_signup";
+            pre_signup_custom: "pre_signup_custom";
+            optional: "optional";
+        }>;
+        steps: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            screen: z.ZodString;
+            validates: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>>;
+        persistTo: z.ZodLiteral<"appData">;
+        persistKey: z.ZodString;
+    }, z.core.$strip>>;
+    deepLinks: z.ZodOptional<z.ZodObject<{
+        passwordReset: z.ZodOptional<z.ZodString>;
+        emailVerify: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    features_enabled: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    theme: z.ZodOptional<z.ZodObject<{}, z.core.$loose>>;
+}, z.core.$strict>;
+declare function parseAppConfig(input: unknown): AppConfig;
+
+export { type AndroidBrowser, type AppConfig, AppConfigProvider, AppConfigSchema, AppRoot, type AppRootProps, type AppRootSlots, type AuthFlowConfig, type AuthFormError, type AuthFormErrorCode, type AuthScreenProps, type CheckoutMethod, type Cycle, DeepLinkHandler, type DeepLinks, EmptyState, ErrorBoundary, type IOSBrowser, type InAppApp, type InstallActions, InstallGate, InstallSplash, type InstallState, type InstallVariant, LoadingState, type OnboardingConfig, OnboardingFlow, type OnboardingFlowProps, type OnboardingStep, type OnboardingStepCtx, type OnboardingStepDef, type PaymentMethod, PaymentReturnHandler, type PaywallConfig, type PersistedKey, PersistenceRegistry, type PersistenceRegistryProps, type PixPending, type Platform, PreAuthShell, type PreAuthShellProps, PushPrompt, type PushPromptProps, type PushPromptTexts, type PushUiState, RouteBoundary, type RouteBoundaryProps, type SubscriptionStatus, type ToastItem, type UseLoginFormResult, type UseResetFormResult, asaasErrorMessage, computeAnchorCents, dailyFromYearly, detectAndroidBrowser, detectIOSBrowser, detectInAppApp, detectPlatform, detectStandalone, discountPercent, formatBRL, monthlyFromYearly, parseAppConfig, shouldBlockInstall, shouldShowPermanentOption, useAppConfig, useAuth, useAuthPrimitives, useFeature, useForgotForm, useInstallPrompt, useLoginForm, useOnboardingStep, usePaywallState, usePlan, usePush, useReminders, useResetForm, useSignupForm, useSubscription, useToast };