doct-ui-auth-kit 1.0.0 → 1.0.2

package/dist/auth/index.d.ts

@@ -0,0 +1,23 @@
+import { SSOAuthProvider } from '../core/auth-provider';
+import type { OtpVerificationProps } from '../pages/otp-verification';
+import type { SignupPageProps } from '../pages/signup';
+/** Simple API: full login/signup flow (method select → identifier → OTP → profile). Use inside Auth.Provider. */
+declare function AuthLogin(): React.ReactElement;
+/** Simple API: signup (profile completion) screen with signup layout preset. Layout only; pass props for behavior. */
+declare function AuthSignup(props: SignupPageProps): React.ReactElement;
+/** Simple API: OTP verification screen with verification layout preset. Layout only; pass props for behavior. */
+declare function AuthOtp(props: OtpVerificationProps): React.ReactElement;
+/**
+ * Auth SDK simple + namespace API.
+ * - Auth.Provider: config (methods, MFA, rememberMe, apiAdapter, callbacks).
+ * - Auth.Login: full flow (simple).
+ * - Auth.Signup: signup screen with signup preset (simple).
+ * - Auth.Otp: OTP screen with verification preset (simple).
+ */
+export declare const Auth: {
+    Provider: typeof SSOAuthProvider;
+    Login: typeof AuthLogin;
+    Signup: typeof AuthSignup;
+    Otp: typeof AuthOtp;
+};
+export type { SignupPageProps, OtpVerificationProps };

package/dist/auth-methods/google.d.ts

@@ -1,65 +1,5 @@
-import type { ReactNode } from 'react';
-import React from 'react';
-declare global {
-    interface Window {
-        google?: {
-            accounts: {
-                id: {
-                    initialize: (config: {
-                        client_id: string;
-                        callback: (response: {
-                            credential: string;
-                        }) => void;
-                        auto_select?: boolean;
-                    }) => void;
-                    prompt: (momentListener?: (moment: {
-                        getMomentType: () => string;
-                    }) => void) => void;
-                    renderButton: (element: HTMLElement, options: {
-                        theme?: string;
-                        size?: string;
-                        type?: string;
-                        text?: string;
-                    }) => void;
-                };
-            };
-        };
-    }
-}
-export interface UseGoogleOneTapOptions {
-    /** Google OAuth 2.0 client ID. */
-    clientId: string;
-    /** Callback when user signs in with Google; receives the ID token (credential). */
-    onCredential: (credential: string) => void;
-    /** When true, show One Tap prompt after init. Default true. */
-    enabled?: boolean;
-}
 /**
- * Loads Google Identity Services and optionally shows One Tap prompt.
- * Call onCredential with the ID token to pass to adapter.authenticateWithProvider.
+ * Google Identity Services: custom button + optional One Tap.
+ * Use useGoogleAuth and render your own button that calls loginWithGoogle.
  */
-export declare function useGoogleOneTap({ clientId, onCredential, enabled, }: UseGoogleOneTapOptions): {
-    triggerOneTap: () => void;
-};
-export interface GoogleSignInButtonProps {
-    /** Google OAuth 2.0 client ID. */
-    clientId: string;
-    /** Callback when user signs in; receives the ID token. */
-    onCredential: (credential: string) => void;
-    /** Optional container ref (when using the hook directly). */
-    containerRef?: React.RefObject<HTMLDivElement | null>;
-}
-/**
- * Hook: renders the Google Sign-In button into the given container.
- * Ensure the container is in the DOM (e.g. use a ref on a div).
- */
-export declare function useGoogleSignInButton({ clientId, onCredential, containerRef, }: GoogleSignInButtonProps): void;
-export interface GoogleSignInButtonComponentProps {
-    clientId: string;
-    onCredential: (credential: string) => void;
-    children?: ReactNode;
-}
-/**
- * Component: renders a div that is filled with the Google-branded sign-in button.
- */
-export declare function GoogleSignInButton({ clientId, onCredential, }: GoogleSignInButtonComponentProps): React.ReactElement;
+export { type UseGoogleAuthOptions, type UseGoogleAuthReturn, useGoogleAuth, } from './use-google-auth';

package/dist/auth-methods/index.d.ts

@@ -1,2 +1 @@
-export { type UseAppleSignInOptions, useAppleSignIn } from './apple';
-export { GoogleSignInButton, type GoogleSignInButtonComponentProps, type GoogleSignInButtonProps, type UseGoogleOneTapOptions, useGoogleOneTap, useGoogleSignInButton, } from './google';
+export { type UseGoogleAuthOptions, type UseGoogleAuthReturn, useGoogleAuth, } from './google';

package/dist/auth-methods/use-google-auth.d.ts

@@ -0,0 +1,69 @@
+/** GSI callback payload when user signs in. */
+interface CredentialResponse {
+    credential: string;
+}
+/** OAuth2 Code Client callback payload (popup mode). */
+interface CodeResponse {
+    code: string;
+}
+declare global {
+    interface Window {
+        google?: {
+            accounts: {
+                id: {
+                    initialize: (config: {
+                        client_id: string;
+                        callback: (response: CredentialResponse) => void;
+                        auto_select?: boolean;
+                        /**
+                         * When false, avoids using FedCM for One Tap prompts (helps when FedCM is
+                         * disabled via browser/site settings).
+                         */
+                        use_fedcm_for_prompt?: boolean;
+                    }) => void;
+                    prompt: (momentListener?: (moment: {
+                        getMomentType: () => string;
+                    }) => void) => void;
+                };
+                oauth2: {
+                    initCodeClient: (config: {
+                        client_id: string;
+                        scope: string;
+                        ux_mode: 'popup';
+                        callback: (response: CodeResponse) => void;
+                        error_callback?: (error: {
+                            type: string;
+                            message?: string;
+                        }) => void;
+                    }) => {
+                        requestCode: () => void;
+                    };
+                };
+            };
+        };
+    }
+}
+export interface UseGoogleAuthOptions {
+    /** Google OAuth 2.0 client ID. Hook is a no-op when empty. */
+    clientId: string;
+    /**
+     * Called with a Google credential suitable for backend verification.
+     *
+     * - **One Tap** returns an **ID token**.
+     * - **Button click** uses OAuth popup and returns an **authorization code**.
+     *
+     * Your backend should verify/exchange this value for a session.
+     */
+    onCredential: (credential: string) => void;
+    /** When true, shows One Tap prompt automatically after init. Default false. */
+    enableOneTap?: boolean;
+}
+export interface UseGoogleAuthReturn {
+    /**
+     * Opens the Google sign-in popup (OAuth code flow).
+     * Intended for use with a custom "Continue with Google" button.
+     */
+    loginWithGoogle: () => Promise<void>;
+}
+export declare function useGoogleAuth({ clientId, onCredential, enableOneTap, }: UseGoogleAuthOptions): UseGoogleAuthReturn;
+export {};

package/dist/components/layout/auth-layout-preset.d.ts

@@ -0,0 +1,25 @@
+import type { ReactNode } from 'react';
+import type { LayoutPresetName } from '../../types/layout-presets';
+export interface AuthLayoutPresetProps {
+    /**
+     * Preset name. Controls structure only (layoutType, variant, maxWidth, contentWidth, align).
+     * Use "" for no preset (children rendered as-is; use AuthLayout.Root for full composition).
+     */
+    preset: LayoutPresetName;
+    /** Main content (e.g. form). Rendered in layout body. */
+    children: ReactNode;
+    /** Optional slot overrides. When not provided, slot is empty. */
+    logo?: ReactNode;
+    title?: ReactNode;
+    description?: ReactNode;
+    footer?: ReactNode;
+    header?: ReactNode;
+    backButton?: ReactNode;
+    /** Extra class for root. */
+    className?: string;
+}
+/**
+ * Layout shell driven by a preset. Structure only — no auth logic.
+ * Use for advanced usage when you need a consistent layout without wiring AuthFlow.
+ */
+export declare function AuthLayoutPreset({ preset, children, logo, title, description, footer, header, backButton, className, }: AuthLayoutPresetProps): React.ReactElement;

package/dist/components/layout/auth-layout-public.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Public AuthLayout API: compound components + preset-based layout.
+ * Merged here to avoid circular dependencies (preset uses wrapper, wrapper uses compound).
+ */
+import { AuthLayoutPreset } from './auth-layout-preset';
+/** Compound layout + preset-based layout. Use .Root/.Header/... for composition, .Preset for preset. */
+export declare const AuthLayout: {
+    Preset: typeof AuthLayoutPreset;
+    Root: ({ children, variant, maxWidth, className, contentClassName, }: Readonly<import(".").AuthLayoutRootProps>) => import("react/jsx-runtime").JSX.Element;
+    Header: ({ children, className, }: Readonly<import(".").AuthLayoutHeaderProps>) => import("react/jsx-runtime").JSX.Element;
+    Main: ({ children, sm, className, }: Readonly<import(".").AuthLayoutMainProps>) => import("react/jsx-runtime").JSX.Element;
+    Logo: ({ children, align, className, }: Readonly<import(".").AuthLayoutLogoProps>) => import("react/jsx-runtime").JSX.Element;
+    Title: ({ children, align, className, }: Readonly<import(".").AuthLayoutTitleProps>) => import("react/jsx-runtime").JSX.Element;
+    Description: ({ children, align, className, }: Readonly<import(".").AuthLayoutDescriptionProps>) => import("react/jsx-runtime").JSX.Element;
+    Body: ({ children, className, }: Readonly<import(".").AuthLayoutBodyProps>) => import("react/jsx-runtime").JSX.Element;
+    Footer: ({ children, className, }: Readonly<import(".").AuthLayoutFooterProps>) => import("react/jsx-runtime").JSX.Element;
+};

package/dist/components/layout/auth-layout-wrapper.d.ts

@@ -0,0 +1,23 @@
+import { type ReactNode } from 'react';
+import type { AuthLayoutAlign, AuthLayoutMaxWidth, AuthLayoutVariant } from '../../types/auth-layout-types';
+export type AuthLayoutType = 'withSlider' | 'standalone';
+export interface AuthLayoutWrapperProps {
+    children: ReactNode;
+    layoutType?: AuthLayoutType;
+    logo?: ReactNode;
+    title?: ReactNode;
+    description?: ReactNode;
+    footer?: ReactNode;
+    header?: ReactNode;
+    onBack?: (() => void) | null;
+    backButton?: ReactNode;
+    sliderImages?: string[];
+    sliderAutoPlayInterval?: number;
+    sliderTitles?: (ReactNode | string)[];
+    variant?: AuthLayoutVariant;
+    maxWidth?: AuthLayoutMaxWidth;
+    contentWidth?: 'sm' | 'default';
+    align?: AuthLayoutAlign;
+    className?: string;
+}
+export declare function AuthLayoutWrapper({ children, layoutType, logo, title, description, footer, header, onBack, backButton, sliderImages, sliderAutoPlayInterval, sliderTitles, variant, maxWidth, contentWidth, align, className, }: AuthLayoutWrapperProps): React.ReactElement;

package/dist/components/layout/index.d.ts

@@ -1,6 +1,8 @@
 export type { AuthLayoutAlign, AuthLayoutBodyProps, AuthLayoutDescriptionProps, AuthLayoutFooterProps, AuthLayoutHeaderProps, AuthLayoutLogoProps, AuthLayoutMainProps, AuthLayoutMaxWidth, AuthLayoutRootProps, AuthLayoutTitleProps, AuthLayoutVariant, } from '../../types/auth-layout-types';
-export { AuthLayout } from './auth-layout';
+export { AuthLayoutPreset, type AuthLayoutPresetProps, } from './auth-layout-preset';
+export { AuthLayout } from './auth-layout-public';
+export { type AuthLayoutType, AuthLayoutWrapper, type AuthLayoutWrapperProps, } from './auth-layout-wrapper';
 export type { ImageSliderProps } from './image-slider';
 export { ImageSlider } from './image-slider';
-export type { MainLayoutProps, MarketingPanelProps } from './main-layout';
-export { MainLayout, MarketingPanel } from './main-layout';
+export type { MainLayoutProps } from './main-layout';
+export { MainLayout } from './main-layout';

package/dist/constants/demo-slider.d.ts

@@ -12,5 +12,3 @@
 export declare const DEMO_SLIDER_IMAGES: string[];
 /** Default auto-play interval (ms) for the demo slider. */
 export declare const DEMO_SLIDER_AUTO_PLAY_INTERVAL = 5000;
-/** Per-slide CTA titles for the demo slider (Figma: "Get Healthcare Career App Now!"). */
-export declare const DEMO_SLIDER_TITLES: string[];

package/dist/constants/index.d.ts

@@ -1 +1,2 @@
-export { DEMO_SLIDER_AUTO_PLAY_INTERVAL, DEMO_SLIDER_IMAGES, DEMO_SLIDER_TITLES, } from './demo-slider';
+export { DEMO_SLIDER_AUTO_PLAY_INTERVAL, DEMO_SLIDER_IMAGES, } from './demo-slider';
+export { getLayoutPresetConfig } from './layout-presets';

package/dist/constants/layout-presets.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Layout preset configurations. Structure only — no auth behavior.
+ * Used by AuthLayout when preset="login" | "signup" | "verification".
+ */
+import type { LayoutPresetConfig, LayoutPresetName } from '../types/layout-presets';
+/**
+ * Returns layout structure config for a preset name.
+ * Empty string returns undefined (caller uses full composition / no preset).
+ */
+export declare function getLayoutPresetConfig(preset: LayoutPresetName): LayoutPresetConfig | undefined;

package/dist/core/auth-context.d.ts

@@ -20,18 +20,14 @@ export interface AuthFlowActions {
         phone?: string;
         email?: string;
     }) => void;
-    /** Foreign (non-IN) phone flow: collect fullName + email, send OTP to email. */
-    submitForeignEmail: (data: {
-        fullName: string;
-        email: string;
-    }) => void;
-    verifyOtp: (otp: string) => void;
-    resendOtp: () => void;
-    completeProfile: (data: {
+    /** SIGNUP_DETAILS step: submit name + phone/email, then OTP (foreign) or complete (Indian). */
+    submitSignupDetails: (data: {
         fullName: string;
         phone?: string;
         email?: string;
     }) => void;
+    verifyOtp: (otp: string) => void;
+    resendOtp: () => void;
     providerCallback: (params: {
         provider: 'google' | 'apple';
         credential: string;

package/dist/core/auth-flow.d.ts

@@ -1,5 +1,5 @@
 /**
- * Full auth flow orchestrator. Renders the correct page per flow state.
- * Use inside SSOAuthProvider + AuthLayout.Main.
+ * Full auth flow orchestrator. Renders the correct page per flow state with appropriate layout.
+ * Use inside SSOAuthProvider.
  */
 export declare function AuthFlow(): import("react/jsx-runtime").JSX.Element | null;

package/dist/core/auth-types.d.ts

@@ -21,8 +21,10 @@ export interface SSOSession {
     user: SSOUser;
     authMethod: AuthMethod;
 }
+/** User type for layout and OTP routing: Indian (+91) vs Foreign (non +91). */
+export type UserType = 'INDIAN' | 'FOREIGN';
 /** Flow states for the state machine. */
-export type AuthStep = 'CHECKING_SESSION' | 'REPEAT_LOGIN' | 'METHOD_SELECT' | 'PHONE_ENTRY' | 'EMAIL_ENTRY' | 'FOREIGN_EMAIL_COLLECT' | 'OTP_VERIFICATION' | 'PROFILE_COMPLETION' | 'PROVIDER_PENDING' | 'CONFLICT' | 'AUTHENTICATED';
+export type AuthStep = 'CHECKING_SESSION' | 'REPEAT_LOGIN' | 'METHOD_SELECT' | 'PHONE_ENTRY' | 'EMAIL_ENTRY' | 'OTP_VERIFICATION' | 'SIGNUP_DETAILS' | 'PROVIDER_PENDING' | 'AUTHENTICATED';
 /** Error codes from the central auth service. */
 export type AuthErrorCode = 'IDENTIFIER_CONFLICT' | 'OTP_EXPIRED' | 'OTP_INVALID' | 'OTP_RATE_LIMIT' | 'SESSION_EXPIRED' | 'PROVIDER_AUTH_FAILED' | 'NETWORK_ERROR' | 'UNKNOWN';
 /** Auth error with code and optional message / linked identifier. */

package/dist/core/sso-session.d.ts

@@ -2,7 +2,6 @@
  * SSO session management: token persistence strategies and useAuthSession hook.
  * Token storage is consumer-configurable for cross-app SSO (e.g. shared cookie domain).
  */
-import type { AuthMethod, SSOSession } from './auth-types';
 /** How/where the SSO token is stored for cross-app access. */
 export interface TokenStorageStrategy {
     get(): string | null;
@@ -14,21 +13,6 @@ export interface TokenStorageStrategy {
  * Suitable for dev or when all Docthub apps share the same origin.
  */
 export declare function localStorageTokenStorage(): TokenStorageStrategy;
-/**
- * Token storage using a cookie on the given domain (e.g. '.docthub.com').
- * Allows subdomains to share the SSO session. Not httpOnly (set from client).
- */
-export declare function cookieTokenStorage(domain: string): TokenStorageStrategy;
-/**
- * Return type of useAuthSession. Session and loading come from AuthFlowContext.
- */
-export interface UseAuthSessionReturn {
-    session: SSOSession | null;
-    isAuthenticated: boolean;
-    isLoading: boolean;
-    signOut: () => void;
-    authMethod: AuthMethod | null;
-}
 /**
  * useAuthSession hook is implemented in auth-context (uses AuthFlowContext).
  * Re-exported from core index for consumer convenience.

package/dist/core/use-auth-flow.d.ts

@@ -2,7 +2,7 @@
  * Auth flow state machine: reducer and state type.
  * Side effects (API calls, token persistence) are performed by the provider; this module is pure.
  */
-import type { AuthError, AuthStep, SSOSession } from './auth-types';
+import type { AuthStep, SSOSession, UserType } from './auth-types';
 /** Identifier type for OTP / profile steps. */
 export type IdentifierType = 'phone' | 'email';
 /** Full state for the auth flow. */
@@ -10,23 +10,23 @@ export interface AuthFlowState {
     step: AuthStep;
     /** Previous step for goBack. */
     lastStep: AuthStep;
-    /** Current identifier value (phone or email) when in OTP or profile. */
+    /** Indian (+91) vs Foreign (non +91); drives layout and OTP routing. */
+    userType: UserType;
+    /** Current identifier value (phone or email) when in OTP or signup. */
     identifierValue: string;
     /** Type of identifier (phone vs email). */
     identifierType: IdentifierType;
     /** Masked value for display (e.g. "+91 9825910X0X"). */
     maskedRecipient: string;
-    /** For PROFILE_COMPLETION: which field to collect (phone or email). */
-    signupMode: IdentifierType;
+    /** For SIGNUP_DETAILS (Indian): which field to collect (phone or email). */
+    signupCollectField: IdentifierType;
     /** For REPEAT_LOGIN: last used method label. */
     lastMethod: string;
     /** Set when step is AUTHENTICATED. */
     session: SSOSession | null;
-    /** Set when step is CONFLICT. */
-    conflictError: AuthError | null;
-    /** For FOREIGN_EMAIL_COLLECT: the non-IN phone we already have. */
-    foreignPhoneValue: string;
-    /** When set, foreign flow: use in completeProfile after OTP for new user. */
+    /** Foreign flow: phone value when user entered phone before signup details. */
+    pendingPhone: string;
+    /** Foreign flow: signup form data for completeProfile after OTP verify. */
     pendingFullName: string;
     pendingEmail: string;
 }
@@ -46,26 +46,29 @@ export type AuthFlowAction = {
     type: 'SET_STEP_PHONE_ENTRY';
 } | {
     type: 'SET_STEP_EMAIL_ENTRY';
-} | {
-    type: 'SET_STEP_FOREIGN_EMAIL_COLLECT';
-    phoneValue: string;
-    maskedPhone?: string;
 } | {
     type: 'SET_STEP_OTP_VERIFICATION';
+    userType: UserType;
     identifierType: IdentifierType;
     value: string;
     maskedValue: string;
-    /** Optional: from foreign flow for completeProfile after OTP. */
+    /** Foreign flow: for completeProfile after OTP. */
     pendingFullName?: string;
     pendingEmail?: string;
+    pendingPhone?: string;
 } | {
-    type: 'SET_STEP_PROFILE_COMPLETION';
-    signupMode: IdentifierType;
+    type: 'SET_STEP_SIGNUP_DETAILS';
+    userType: UserType;
+    /** Indian: which field to collect (phone or email). Foreign: ignored. */
+    signupCollectField: IdentifierType;
+    /** Foreign only: phone value when user entered phone before signup. */
+    pendingPhone?: string;
+    /** When coming from identifier entry (foreign): preserve for later OTP. */
+    identifierType?: IdentifierType;
+    identifierValue?: string;
+    maskedRecipient?: string;
 } | {
     type: 'SET_STEP_PROVIDER_PENDING';
-} | {
-    type: 'SET_STEP_CONFLICT';
-    error: AuthError;
 } | {
     type: 'SET_STEP_AUTHENTICATED';
     session: SSOSession;

package/dist/hooks/index.d.ts

@@ -1,3 +1,3 @@
 export { type EmailFormValues, type LoginEntryFormValues, type LoginEntryMode, type PhoneFormValues, type UseLoginEntryFormOptions, type UseLoginEntryFormReturn, useLoginEntryForm, } from './use-login-entry-form';
-export { DEFAULT_OTP_TITLES, OTP_LENGTH, type OtpFormValues, type OtpVerificationMode, RESEND_COOLDOWN_SECONDS, type UseOtpVerificationOptions, type UseOtpVerificationReturn, useOtpVerification, } from './use-otp-verification';
+export { DEFAULT_OTP_TITLES, OTP_LENGTH, type OtpFormValues, type OtpVerificationMode, RESEND_COOLDOWN_EMAIL_SECONDS, RESEND_COOLDOWN_PHONE_SECONDS, type UseOtpVerificationOptions, type UseOtpVerificationReturn, useOtpVerification, } from './use-otp-verification';
 export { type SignupEmailFormValues, type SignupEntryMode, type SignupFormValues, type SignupPhoneFormValues, type UseSignupFormOptions, type UseSignupFormReturn, useSignupForm, } from './use-signup-form';

package/dist/hooks/use-otp-verification.d.ts

@@ -3,13 +3,20 @@ import { z } from 'zod';
 /** OTP verification mode: mobile (phone) or email */
 export type OtpVerificationMode = 'phone' | 'email';
 export declare const OTP_LENGTH = 6;
-export declare const RESEND_COOLDOWN_SECONDS = 120;
+/** Resend cooldown: 60s for phone OTP, 2 min for email OTP (per design). */
+export declare const RESEND_COOLDOWN_PHONE_SECONDS = 60;
+export declare const RESEND_COOLDOWN_EMAIL_SECONDS = 120;
+export declare function getResendCooldownSeconds(mode: OtpVerificationMode): number;
 declare const otpFormSchema: z.ZodObject<{
     otp: z.ZodArray<z.ZodString>;
 }, z.core.$strip>;
 export type OtpFormValues = z.infer<typeof otpFormSchema>;
 export declare const DEFAULT_OTP_TITLES: Record<OtpVerificationMode, string>;
+/** Instruction line below recipient (Figma: "Kindly check your Email Inbox."). */
+export declare const DEFAULT_OTP_INSTRUCTIONS: Record<OtpVerificationMode, string>;
 export interface UseOtpVerificationOptions {
+    /** OTP mode: phone (60s cooldown) or email (2 min cooldown). */
+    mode: OtpVerificationMode;
     onSubmit?: ((otp: string) => void) | undefined;
     onResendCode?: (() => void) | undefined;
 }
@@ -25,5 +32,5 @@ export interface UseOtpVerificationReturn {
  * Form state, resend countdown, and validation for OTP verification.
  * Use with OtpVerification component or build a custom OTP UI.
  */
-export declare function useOtpVerification({ onSubmit, onResendCode, }?: UseOtpVerificationOptions): UseOtpVerificationReturn;
+export declare function useOtpVerification({ mode, onSubmit, onResendCode, }: UseOtpVerificationOptions): UseOtpVerificationReturn;
 export {};

package/dist/hooks/use-signup-form.d.ts

@@ -1,7 +1,7 @@
 import type { UseFormReturn } from 'react-hook-form';
 import { z } from 'zod';
-/** Signup mode: phone number or email as the second field (after full name) */
-export type SignupEntryMode = 'phone' | 'email';
+/** Signup mode: phone, email as second field, or foreign (full name + email + phone) */
+export type SignupEntryMode = 'phone' | 'email' | 'foreign';
 declare const signupPhoneFormSchema: z.ZodObject<{
     fullName: z.ZodString;
     phone: z.ZodString;
@@ -10,13 +10,21 @@ declare const signupEmailFormSchema: z.ZodObject<{
     fullName: z.ZodString;
     email: z.ZodString;
 }, z.core.$strip>;
+declare const signupForeignFormSchema: z.ZodObject<{
+    fullName: z.ZodString;
+    email: z.ZodString;
+    phone: z.ZodString;
+}, z.core.$strip>;
 export type SignupPhoneFormValues = z.infer<typeof signupPhoneFormSchema>;
 export type SignupEmailFormValues = z.infer<typeof signupEmailFormSchema>;
-export type SignupFormValues = SignupPhoneFormValues | SignupEmailFormValues;
+export type SignupForeignFormValues = z.infer<typeof signupForeignFormSchema>;
+export type SignupFormValues = SignupPhoneFormValues | SignupEmailFormValues | SignupForeignFormValues;
 export interface UseSignupFormOptions {
-    /** Mode: phone number or email as second field */
+    /** Mode: phone, email as second field, or foreign (name + email + phone) */
     mode: SignupEntryMode;
-    /** Called with valid form data on submit. Omit or pass undefined when not needed. */
+    /** For foreign mode: pre-fill phone when user already entered it. */
+    defaultPhone?: string;
+    /** Called with valid form data on submit. */
     onSubmit?: ((data: {
         fullName: string;
         phone?: string;
@@ -26,12 +34,14 @@ export interface UseSignupFormOptions {
 export interface UseSignupFormReturn {
     methods: UseFormReturn<SignupFormValues>;
     handleSubmit: (data: SignupFormValues) => void;
-    /** True when mode is 'phone', false when mode is 'email'. Use to switch between phone/email input. */
+    /** True when mode is 'phone', false when mode is 'email'. For 'foreign' same as (mode === 'phone') for layout. */
     isPhone: boolean;
+    /** True when mode is 'foreign' (full name + email + phone). */
+    isForeign: boolean;
 }
 /**
- * Form state and validation for the signup screen (full name + phone or email).
+ * Form state and validation for the signup screen (full name + phone or email, or foreign: all three).
  * Use with SignupPage component or build a custom signup form.
  */
-export declare function useSignupForm({ mode, onSubmit, }: UseSignupFormOptions): UseSignupFormReturn;
+export declare function useSignupForm({ mode, defaultPhone, onSubmit, }: UseSignupFormOptions): UseSignupFormReturn;
 export {};

package/dist/index.d.ts

@@ -13,11 +13,12 @@
  *   AuthLayout,
  *   LoginEntry,
  *   OtpVerification,
- *   useGoogleOneTap,
+ *   useGoogleAuth,
  * } from 'doct-ui-auth-kit';
  * ```
  */
 export * from './adapters';
+export { Auth } from './auth';
 export * from './auth-methods';
 export * from './components/layout';
 export * from './core';