doct-ui-auth-kit 1.0.2 → 1.0.4

package/dist/types/auth-api-adapter.d.ts

@@ -0,0 +1,43 @@
+/**
+ * API adapter types for the SSO auth SDK.
+ * Consumers implement AuthApiAdapter to connect the SDK to their central auth service.
+ */
+import type { AuthenticateWithProviderParams, CompleteProfileParams, SendOtpResponse, SSOSession, VerifyOtpResponse } from './auth-types';
+/** Parameters for sending OTP to phone or email. */
+export interface SendOtpParams {
+    type: 'phone' | 'email';
+    value: string;
+}
+/** Parameters for verifying OTP. */
+export interface VerifyOtpParams {
+    type: 'phone' | 'email';
+    value: string;
+    otp: string;
+}
+/**
+ * Adapter implemented by the consumer to talk to the central auth service.
+ * All methods return promises; the SDK handles loading/error state.
+ */
+export interface AuthApiAdapter {
+    /** Send OTP to the given phone or email. */
+    sendOtp(params: SendOtpParams): Promise<SendOtpResponse>;
+    /**
+     * Verify OTP. Returns session if existing user, or isNewUser flag for profile completion.
+     * May return conflict error when identifier is linked to another account.
+     */
+    verifyOtp(params: VerifyOtpParams): Promise<VerifyOtpResponse>;
+    /** Complete profile for new users; returns SSO session. */
+    completeProfile(params: CompleteProfileParams): Promise<SSOSession>;
+    /** Authenticate with a third-party provider (Google/Apple) credential. */
+    authenticateWithProvider(params: AuthenticateWithProviderParams): Promise<VerifyOtpResponse>;
+    /** Validate an existing SSO session token; called on SDK mount. Returns null if invalid/expired. */
+    validateSession(token: string): Promise<SSOSession | null>;
+    /**
+     * Optional: validate session using server-read cookie (no token from client).
+     * Required when using serverCookieTokenStorage. Client sends credentials;
+     * server reads cookie from the request and returns session or null.
+     */
+    validateSessionFromCookie?(): Promise<SSOSession | null>;
+    /** Optional: refresh an expired SSO session using refresh token. */
+    refreshSession?(refreshToken: string): Promise<SSOSession | null>;
+}

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

@@ -0,0 +1,37 @@
+import type { ReactNode } from 'react';
+import type { AuthApiAdapter } from './auth-api-adapter';
+import type { AuthError, SSOSession } from './auth-types';
+import type { TokenStorageStrategy } from './sso-session';
+/** Consumer-provided config for SSOAuthProvider. */
+export interface SSOAuthConfig {
+    /** Consumer-provided adapter to their central auth service. */
+    apiAdapter: AuthApiAdapter;
+    /** Auth method configs (Google client ID, Apple client ID, etc.). */
+    providers?: {
+        google?: {
+            clientId: string;
+            enableOneTap?: boolean;
+        };
+        apple?: {
+            clientId: string;
+            redirectUri: string;
+        };
+    };
+    /** Called when SSO session is established (any method). */
+    onAuthSuccess: (session: SSOSession) => void;
+    /** Called on auth errors. */
+    onAuthError?: (error: AuthError) => void;
+    /** Optional: called when user signs out. */
+    onSignOut?: () => void;
+    /** SSO token persistence strategy. Defaults to localStorage. */
+    tokenStorage?: TokenStorageStrategy;
+    /** Branding customization (logo, slider images). */
+    branding?: {
+        logo?: ReactNode;
+        sliderImages?: string[];
+    };
+}
+export interface SSOAuthProviderProps {
+    config: SSOAuthConfig;
+    children: ReactNode;
+}

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

@@ -0,0 +1,70 @@
+/**
+ * SSO auth domain types: session, flow steps, adapter contracts, and error codes.
+ * Used by the flow engine, provider, and adapter implementations.
+ */
+/** Auth methods available in the SSO system. */
+export type AuthMethod = 'phone' | 'email' | 'google' | 'apple';
+/** User payload in the SSO session. */
+export interface SSOUser {
+    id: string;
+    name: string;
+    email?: string;
+    phone?: string;
+    avatar?: string;
+    isNewUser: boolean;
+}
+/** The SSO session — same structure regardless of auth method used. */
+export interface SSOSession {
+    accessToken: string;
+    refreshToken?: string;
+    expiresAt: number;
+    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' | '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. */
+export interface AuthError {
+    code: AuthErrorCode;
+    message?: string;
+    /** Masked linked identifier when conflict (e.g. "+91 98XXXX0X0X"). */
+    linkedIdentifier?: string;
+}
+/** Response from sendOtp. */
+export interface SendOtpResponse {
+    success: boolean;
+    /** Masked value for display (e.g. "+91 9825910X0X" or "j***@gmail.com"). */
+    maskedValue?: string;
+    error?: AuthError;
+}
+/** Result of verifyOtp or authenticateWithProvider: existing user gets session, new user gets profile step. */
+export interface VerifyOtpResponse {
+    /** Present when user exists and is authenticated. */
+    session?: SSOSession;
+    /** True when user is new and must complete profile. */
+    isNewUser: boolean;
+    /** When isNewUser and conflict (e.g. email already linked), masked linked identifier. */
+    conflict?: AuthError;
+}
+/** Input for completeProfile (new users). */
+export interface CompleteProfileParams {
+    fullName: string;
+    email?: string;
+    phone?: string;
+}
+/** Input for authenticateWithProvider (Google/Apple credential). */
+export interface AuthenticateWithProviderParams {
+    provider: 'google' | 'apple';
+    /** Id token or equivalent from the provider. */
+    credential: string;
+}
+/** Repeat-login device history (method + masked identifier). */
+export interface RepeatLoginInfo {
+    method: AuthMethod;
+    maskedIdentifier: string;
+    timestamp: number;
+}

package/dist/types/device-detection.d.ts

@@ -0,0 +1,7 @@
+import type { AuthMethod } from './auth-types';
+/** Stored repeat-login info (method + masked identifier). */
+export interface StoredRepeatLogin {
+    method: AuthMethod;
+    maskedIdentifier: string;
+    timestamp: number;
+}

package/dist/types/flow.d.ts

@@ -0,0 +1,125 @@
+/**
+ * Auth flow state machine types: state, actions, and context.
+ */
+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. */
+export interface AuthFlowState {
+    step: AuthStep;
+    /** Previous step for goBack. */
+    lastStep: AuthStep;
+    /** 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 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;
+    /** 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;
+}
+/** Pure reducer actions. */
+export type AuthFlowAction = {
+    type: 'SET_SESSION';
+    session: SSOSession;
+} | {
+    type: 'SET_STEP_REPEAT_LOGIN';
+    lastMethod: string;
+    maskedIdentifier: string;
+} | {
+    type: 'SET_STEP_METHOD_SELECT';
+} | {
+    type: 'SET_STEP_PHONE_ENTRY';
+} | {
+    type: 'SET_STEP_EMAIL_ENTRY';
+} | {
+    type: 'SET_STEP_OTP_VERIFICATION';
+    userType: UserType;
+    identifierType: IdentifierType;
+    value: string;
+    maskedValue: string;
+    /** Foreign flow: for completeProfile after OTP. */
+    pendingFullName?: string;
+    pendingEmail?: string;
+    pendingPhone?: string;
+} | {
+    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_AUTHENTICATED';
+    session: SSOSession;
+} | {
+    type: 'GO_BACK';
+} | {
+    type: 'RESET';
+} | {
+    type: 'SIGN_OUT';
+};
+/** Provider config slice exposed to flow for Google/Apple wiring. */
+export interface AuthFlowProviderConfig {
+    google?: {
+        clientId: string;
+        enableOneTap?: boolean;
+    };
+    apple?: {
+        clientId: string;
+        redirectUri: string;
+    };
+}
+/** Async actions that perform I/O and dispatch to the flow reducer. */
+export interface AuthFlowActions {
+    selectMethod: (method: 'phone' | 'email' | 'google' | 'apple') => void;
+    /** From REPEAT_LOGIN: continue with last used method. */
+    continueWithLastMethod: () => void;
+    submitIdentifier: (data: {
+        phone?: string;
+        email?: string;
+    }) => void;
+    /** 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;
+    }) => void;
+    goBack: () => void;
+    reset: () => void;
+    signOut: () => void;
+}
+/** Auth flow context value provided by SSOAuthProvider. */
+export interface AuthFlowContextValue {
+    state: AuthFlowState;
+    actions: AuthFlowActions;
+    /** Session when step is AUTHENTICATED. */
+    session: SSOSession | null;
+    /** True while step is CHECKING_SESSION. */
+    isLoading: boolean;
+    /** Provider config for Google/Apple (One Tap, Sign-In button). */
+    providerConfig: AuthFlowProviderConfig | undefined;
+}

package/dist/types/forms.d.ts

@@ -10,6 +10,8 @@ export interface BaseFormFieldProps {
     className?: string;
     error?: string;
     helperText?: string;
+    /** Focus this field when form/screen opens (PRODUCT_PROTOCOLS #26). */
+    autoFocus?: boolean;
 }
 /** Props for the text/email/number input field component. */
 export interface RHFInputFieldProps extends BaseFormFieldProps {

package/dist/types/index.d.ts

@@ -2,6 +2,19 @@
  * Central export file for all types and interfaces.
  * Import types from here: import type { RHFInputFieldProps } from '@/types';
  */
+export * from './auth-api-adapter';
 export * from './auth-layout-types';
+export * from './auth-provider';
+export * from './auth-types';
+export * from './device-detection';
+export * from './flow';
 export * from './forms';
+export * from './layout';
 export * from './layout-presets';
+export * from './login-form';
+export * from './main-login';
+export * from './otp-verification';
+export * from './pages';
+export * from './repeat-login';
+export * from './signup-form';
+export * from './sso-session';

package/dist/types/layout.d.ts

@@ -0,0 +1,57 @@
+import type { ReactNode } from 'react';
+/** Props for the ImageSlider component. */
+export interface ImageSliderProps {
+    /** Array of image URLs to display */
+    images: string[];
+    /** Auto-play interval in milliseconds (0 to disable) */
+    autoPlayInterval?: number;
+    /** Additional className for the root container */
+    className?: string;
+    /** Whether to hide the built-in slider indicators */
+    hideIndicators?: boolean;
+    /** Optional callback fired whenever the active slide changes */
+    onSlideChange?: (index: number) => void;
+    /** Controlled active index (makes component controlled) */
+    activeIndex?: number;
+    /** Callback for manual slide navigation in controlled mode */
+    onNavigate?: (index: number) => void;
+}
+/**
+ * Props for the MainLayout component.
+ * Two-panel auth page: left panel (marketing/slider), right panel (auth content).
+ */
+export interface MainLayoutProps {
+    /** Array of image URLs for the slider */
+    sliderImages?: string[];
+    /** Auto-play interval for slider in milliseconds (0 to disable) */
+    sliderAutoPlayInterval?: number;
+    /** Call-to-action text displayed above the image card. Set to null to hide */
+    ctaText?: ReactNode | null;
+    /** Per-slide title/CTA (overrides ctaText when provided; uses active slide index) */
+    sliderTitles?: (ReactNode | string)[] | undefined;
+    /** Additional className for the root container */
+    className?: string;
+    /** Additional className for the marketing panel (left side) */
+    marketingClassName?: string;
+    /** Additional className for the content panel (right side) */
+    contentClassName?: string;
+    /** Main authentication content (typically AuthLayout.Root with slots) */
+    children: ReactNode;
+}
+/** Props for the MarketingPanel component (left side). */
+export interface MarketingPanelProps {
+    /** Array of image URLs for the slider */
+    sliderImages: string[];
+    /** Auto-play interval for slider in milliseconds */
+    sliderAutoPlayInterval: number;
+    /** Active slide index (controlled) */
+    activeSlideIndex: number;
+    /** Callback when slide changes */
+    onSlideChange: (index: number) => void;
+    /** Call-to-action text */
+    ctaText?: ReactNode | null;
+    /** Per-slide title/CTA (overrides ctaText when provided) */
+    sliderTitles?: (ReactNode | string)[] | undefined;
+    /** Additional className */
+    className?: string;
+}

package/dist/types/login-form.d.ts

@@ -0,0 +1,39 @@
+import type { UseFormReturn } from 'react-hook-form';
+import type { z } from 'zod';
+import type { loginEmailFormSchema, loginPhoneFormSchema } from '@/validations';
+/** Login mode: phone number or email */
+export type LoginEntryMode = 'phone' | 'email';
+export type PhoneFormValues = z.infer<typeof loginPhoneFormSchema>;
+export type EmailFormValues = z.infer<typeof loginEmailFormSchema>;
+export type LoginEntryFormValues = PhoneFormValues | EmailFormValues;
+/** Payload when login entry form is valid (phone or email). */
+export type LoginEntrySubmitData = {
+    phone?: string;
+    email?: string;
+};
+export interface UseLoginEntryFormOptions {
+    mode: LoginEntryMode;
+    /**
+     * Sync callback with valid form data. Used when parent owns API (e.g. AuthFlow passes actions.submitIdentifier).
+     * Ignored when submitApi is provided.
+     */
+    onSubmit?: ((data: LoginEntrySubmitData) => void) | undefined;
+    /**
+     * When provided, hook runs business logic: validate → call submitApi(data) → onSuccess().
+     * Use from consumer (e.g. Next.js): submitApi = sendOtp, onSuccess = () => router.push('/otp').
+     */
+    submitApi?: (data: LoginEntrySubmitData) => Promise<void>;
+    /** Called after submitApi resolves successfully (e.g. redirect to OTP page). */
+    onSuccess?: () => void;
+    /** Called when submitApi rejects or throws. */
+    onError?: (error: unknown) => void;
+}
+export interface UseLoginEntryFormReturn {
+    methods: UseFormReturn<LoginEntryFormValues>;
+    handleSubmit: (data: LoginEntryFormValues) => void;
+    isPhone: boolean;
+    /** True when current form values pass validation (for disabling Continue until valid – edge cases 3, 4). */
+    isFormValid: (data: LoginEntryFormValues) => boolean;
+    /** True while submitApi is in flight. Use to disable Continue button and show loading. */
+    isSubmitting: boolean;
+}

package/dist/types/main-login.d.ts

@@ -0,0 +1,29 @@
+/** Handlers exposed by the main auth page (method select). */
+export interface MainAuthPageHandlers {
+    onContinueWithMobile: () => void;
+    onContinueWithEmail: () => void;
+    onContinueWithGoogle: () => void;
+    onContinueWithApple: () => void;
+}
+/** Config for lib-handled Google sign-in. When set, the lib runs the OAuth flow and calls onCredential. */
+export interface MainLoginGoogleProviderConfig {
+    clientId: string;
+    /** Called with ID token (One Tap) or auth code (button popup). Send to your backend to verify. */
+    onCredential: (credential: string) => void;
+    enableOneTap?: boolean;
+}
+/** Config for lib-handled Apple sign-in (stub). When set, the lib will run the flow and call onCredential when implemented. */
+export interface MainLoginAppleProviderConfig {
+    clientId: string;
+    redirectUri: string;
+    onCredential: (credential: string) => void;
+}
+/** Optional provider config so the lib handles Google/Apple API calls. */
+export interface MainLoginPageProvidersConfig {
+    google?: MainLoginGoogleProviderConfig;
+    apple?: MainLoginAppleProviderConfig;
+}
+/** Options for useMainAuthPageHandlers: optional callback overrides + optional provider config for lib-handled OAuth. */
+export type UseMainAuthPageHandlersOptions = Partial<MainAuthPageHandlers> & {
+    providers?: MainLoginPageProvidersConfig;
+};

package/dist/types/otp-verification.d.ts

@@ -0,0 +1,28 @@
+import type { UseFormReturn } from 'react-hook-form';
+import type { z } from 'zod';
+import type { OtpVerificationMode, otpFormSchema } from '@/validations';
+export type { OtpVerificationMode };
+export type OtpFormValues = z.infer<typeof otpFormSchema>;
+export interface UseOtpVerificationOptions {
+    /** OTP mode: phone (60s cooldown) or email (2 min cooldown). */
+    mode: OtpVerificationMode;
+    /** Sync callback with OTP string. Use when parent owns API (e.g. AuthFlow). Ignored when submitApi is provided. */
+    onSubmit?: ((otp: string) => void) | undefined;
+    onResendCode?: (() => void) | undefined;
+    /** When provided, hook runs: validate → submitApi(otp) → onSuccess(). Consumer passes redirect in onSuccess. */
+    submitApi?: (otp: string) => Promise<void>;
+    /** Called after submitApi resolves (e.g. router.push('/dashboard')). */
+    onSuccess?: () => void;
+    /** Called when submitApi rejects or throws. */
+    onError?: (error: unknown) => void;
+}
+export interface UseOtpVerificationReturn {
+    methods: UseFormReturn<OtpFormValues>;
+    handleSubmit: (data: OtpFormValues) => void;
+    handleResend: () => void;
+    resendSecondsLeft: number;
+    canResend: boolean;
+    timerText: string;
+    /** True while submitApi is in flight. */
+    isSubmitting: boolean;
+}

package/dist/types/pages.d.ts

@@ -0,0 +1,133 @@
+/**
+ * Props and public types for auth page components.
+ */
+import type { UserType } from './auth-types';
+import type { IdentifierType } from './flow';
+import type { LoginEntryMode } from './login-form';
+import type { UseMainAuthPageHandlersOptions } from './main-login';
+import type { OtpVerificationMode } from './otp-verification';
+/** Props for MainLoginPage and MainLogin components. */
+export type MainLoginPageProps = UseMainAuthPageHandlersOptions;
+/** Props for LoginEntry (inner form without layout). */
+export interface LoginEntryProps {
+    /** Mode: phone number or email input */
+    mode: LoginEntryMode;
+    /** Override title (consumers render via AuthLayout.Title) */
+    title?: string;
+    /** Override subtitle (consumers render via AuthLayout.Description) */
+    subtitle?: string;
+    /** Handler when back button is clicked (consumers render back button in AuthLayout.Logo) */
+    onBack?: () => void;
+    /**
+     * Sync callback with valid data. Use when parent owns API (e.g. AuthFlow).
+     * Ignored when submitApi is provided.
+     */
+    onSubmit?: (data: {
+        phone?: string;
+        email?: string;
+    }) => void;
+    /**
+     * Async API call (e.g. send OTP). When provided, hook runs: validate → submitApi(data) → onSuccess().
+     * Consumer (e.g. Next.js) can pass redirect in onSuccess.
+     */
+    submitApi?: (data: {
+        phone?: string;
+        email?: string;
+    }) => Promise<void>;
+    /** Called after submitApi succeeds (e.g. router.push('/otp')). */
+    onSuccess?: () => void;
+    /** Called when submitApi fails. */
+    onError?: (error: unknown) => void;
+}
+/** Props for the full LoginEntryPage (adds optional layout overrides for story/viewport). */
+export interface LoginEntryPageProps extends LoginEntryProps {
+    /** Layout type. Default: 'withSlider' for desktop, use 'standalone' for mobile. */
+    layoutType?: 'withSlider' | 'standalone';
+    /** Layout variant. Default derived from layoutType if not set. */
+    variant?: 'desktop' | 'mobile';
+}
+/** Props for Signup (inner form without layout). */
+export interface SignupPageProps {
+    /** Indian: which field to collect. Foreign: use 'foreign' mode (name + email + phone). */
+    userType: UserType;
+    /** How user started (phone or email). */
+    loginMethod: IdentifierType;
+    /** Indian only: which field to collect (phone or email). */
+    signupCollectField: IdentifierType;
+    /** Foreign only: phone when user entered phone before signup details. */
+    pendingPhone?: string;
+    /** Sync callback with valid data. Use when parent owns API (e.g. AuthFlow). Ignored when submitApi is provided. */
+    onSubmit?: (data: {
+        fullName: string;
+        phone?: string;
+        email?: string;
+    }) => void;
+    /** Async API (e.g. complete profile). When provided, hook runs: validate → submitApi(data) → onSuccess(). */
+    submitApi?: (data: {
+        fullName: string;
+        phone?: string;
+        email?: string;
+    }) => Promise<void>;
+    /** Called after submitApi succeeds (e.g. router.push('/otp') or next step). */
+    onSuccess?: () => void;
+    /** Called when submitApi fails. */
+    onError?: (error: unknown) => void;
+}
+/** Props for the full SignupPage (adds optional layout overrides). */
+export interface SignupPageFullProps extends SignupPageProps {
+    layoutType?: 'withSlider' | 'standalone';
+    variant?: 'desktop' | 'mobile';
+}
+/** Props for OtpVerification (inner form without layout). */
+export interface OtpVerificationProps {
+    /** Mode: mobile (phone) or email OTP */
+    mode: OtpVerificationMode;
+    /** Title override. Default: "6 digit OTP has been sent to your Mobile" | "..." Email */
+    title?: string;
+    /** Masked phone (e.g. "+91 9825910X0X") or email (e.g. "j***@gmail.com") */
+    recipientDisplay: string;
+    /** When true, show instruction line ("Kindly check your Email Inbox."). Used for foreign user flow. */
+    isForeignUser?: boolean;
+    /** Handler when back is clicked */
+    onBack?: () => void;
+    /** Sync callback with OTP. Use when parent owns API (e.g. AuthFlow). Ignored when submitApi is provided. */
+    onSubmit?: (otp: string) => void;
+    /** Handler when user requests resend code */
+    onResendCode?: () => void;
+    /** Async API (e.g. verify OTP). When provided, hook runs: validate → submitApi(otp) → onSuccess(). */
+    submitApi?: (otp: string) => Promise<void>;
+    /** Called after submitApi succeeds (e.g. router.push('/dashboard')). */
+    onSuccess?: () => void;
+    /** Called when submitApi fails. */
+    onError?: (error: unknown) => void;
+}
+/** Props for the full OtpVerificationPage (adds optional layout overrides). */
+export interface OtpVerificationPageProps extends OtpVerificationProps {
+    layoutType?: 'withSlider' | 'standalone';
+    variant?: 'desktop' | 'mobile';
+}
+/** Props for RepeatLogin (inner component without layout). */
+export interface RepeatLoginProps {
+    /**
+     * Last used authentication method shown in the primary button label.
+     * Example: "Mobile", "Email".
+     *
+     * @default "Mobile"
+     */
+    lastUsedMethod?: string;
+    /** Sync handler for primary action. Use when caller owns API (e.g. AuthFlow). Ignored when continueApi is provided. */
+    onContinueWithLastMethod?: () => void;
+    /** Handler for the secondary action (choose another method). */
+    onUseAnotherMethod?: () => void;
+    /** Async API for continue (e.g. validate session). When provided, hook runs: continueApi() → onSuccess(). */
+    continueApi?: () => Promise<void>;
+    /** Called after continueApi succeeds (e.g. router.push('/dashboard')). */
+    onSuccess?: () => void;
+    /** Called when continueApi fails. */
+    onError?: (error: unknown) => void;
+}
+/** Props for the full RepeatLoginPage (adds optional layout overrides). */
+export interface RepeatLoginPageProps extends RepeatLoginProps {
+    layoutType?: 'withSlider' | 'standalone';
+    variant?: 'desktop' | 'mobile';
+}

package/dist/types/repeat-login.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Hook options and return type for repeat login (continue with last method).
+ */
+export interface UseRepeatLoginOptions {
+    /**
+     * Last used authentication method shown in the primary button label.
+     * @default "Mobile"
+     */
+    lastUsedMethod?: string;
+    /** Sync handler for primary action. Use when caller owns API (e.g. AuthFlow). Ignored when continueApi is provided. */
+    onContinueWithLastMethod?: () => void;
+    /** Handler for the secondary action (choose another method). */
+    onUseAnotherMethod?: () => void;
+    /** Async API for continue (e.g. validate session). When provided, hook runs: continueApi() → onSuccess(). */
+    continueApi?: () => Promise<void>;
+    /** Called after continueApi succeeds (e.g. router.push('/dashboard')). */
+    onSuccess?: () => void;
+    /** Called when continueApi fails. */
+    onError?: (error: unknown) => void;
+}
+export interface UseRepeatLoginReturn {
+    /** Call this when the user clicks "Continue with {lastUsedMethod}". */
+    handleContinue: () => void;
+    /** True while continueApi is in flight. */
+    isSubmitting: boolean;
+    /** Resolved lastUsedMethod for display (default "Mobile"). */
+    lastUsedMethod: string;
+}