doct-ui-auth-kit 1.0.13 → 1.0.14

package/dist/hooks/index.d.ts

@@ -0,0 +1,5 @@
+export { type EmailFormValues, type LoginEntryFormValues, type LoginEntryMode, type PhoneFormValues, type UseLoginEntryFormOptions, type UseLoginEntryFormReturn, useLoginEntryForm, } from './use-login-entry-form';
+export { type MainAuthPageHandlers, type MainLoginAppleProviderConfig, type MainLoginGoogleProviderConfig, type MainLoginPageProvidersConfig, type UseMainAuthPageHandlersOptions, useMainAuthPageHandlers, } from './use-main-auth-page-handlers';
+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 UseRepeatLoginOptions, type UseRepeatLoginReturn, useRepeatLogin, } from './use-repeat-login';
+export { type SignupEmailFormValues, type SignupEntryMode, type SignupFormValues, type SignupPhoneFormValues, type UseSignupFormOptions, type UseSignupFormReturn, useSignupForm, } from './use-signup-form';

package/dist/hooks/use-login-entry-form.d.ts

@@ -0,0 +1,12 @@
+import type { UseLoginEntryFormOptions, UseLoginEntryFormReturn } from '../types';
+export type { EmailFormValues, LoginEntryFormValues, LoginEntryMode, LoginEntrySubmitData, LoginEntrySuccessParams, PhoneFormValues, UseLoginEntryFormOptions, UseLoginEntryFormReturn, } from '../types';
+/**
+ * Form state and validation for the login entry screen (phone or email).
+ *
+ * **Dual submission pattern:**
+ * - `submitApi` (async): hook owns the flow — validate → submitApi(data) → onSuccess(). Future SSO API integration plugs in here.
+ * - `onSubmit` (sync): caller owns the flow — hook validates then hands data back (used by AuthFlow).
+ *
+ * **Validation flow:** RHF form data → Zod schema (loginSchemas[mode]) → setFormErrorsFromZod → field-level errors.
+ */
+export declare function useLoginEntryForm({ mode, onSubmit, submitApi, onSuccess, onError, }: UseLoginEntryFormOptions): UseLoginEntryFormReturn;

package/dist/hooks/use-main-auth-page-handlers.d.ts

@@ -0,0 +1,9 @@
+import type { MainAuthPageHandlers, UseMainAuthPageHandlersOptions } from '../types';
+export type { MainAuthPageHandlers, MainLoginAppleProviderConfig, MainLoginGoogleProviderConfig, MainLoginPageProvidersConfig, UseMainAuthPageHandlersOptions, } from '../types';
+/**
+ * Centralizes Google/Apple OAuth and auth-method CTA handlers for the main login page.
+ * When `providers.google` / `providers.apple` are configured, the SDK runs the OAuth flow internally
+ * and calls `onCredential`; otherwise falls back to consumer-supplied overrides or no-op defaults.
+ * Consumer apps pass callbacks (e.g. `onContinueWithMobile`) to wire navigation.
+ */
+export declare function useMainAuthPageHandlers(options?: Readonly<UseMainAuthPageHandlersOptions>): MainAuthPageHandlers;

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

@@ -1,10 +1,10 @@
-import type { OtpVerificationMode, UseOtpVerificationOptions, UseOtpVerificationReturn } from '@/types';
-export type { OtpFormValues, OtpValidateFn, OtpVerificationMode, UseOtpVerificationOptions, UseOtpVerificationReturn, } from '@/types';
+import type { OtpVerificationMode, UseOtpVerificationOptions, UseOtpVerificationReturn } from '../types';
+export type { OtpFormValues, OtpValidateFn, OtpVerificationMode, UseOtpVerificationOptions, UseOtpVerificationReturn, } from '../types';
 /** Instruction line below recipient (Figma: "Kindly check your Email Inbox."). */
 export declare const DEFAULT_OTP_INSTRUCTIONS: Record<OtpVerificationMode, string>;
 export declare const DEFAULT_OTP_TITLES: Record<OtpVerificationMode, string>;
 /** Re-export for consumers who import from hooks. */
-export { getResendCooldownSeconds, OTP_LENGTH, RESEND_COOLDOWN_EMAIL_SECONDS, RESEND_COOLDOWN_PHONE_SECONDS, } from '@/validations';
+export { getResendCooldownSeconds, OTP_LENGTH, RESEND_COOLDOWN_EMAIL_SECONDS, RESEND_COOLDOWN_PHONE_SECONDS, } from '../validations';
 /**
  * Form state, resend countdown, and validation for OTP verification.
  *

package/dist/hooks/use-repeat-login.d.ts

@@ -0,0 +1,9 @@
+import type { UseRepeatLoginOptions, UseRepeatLoginReturn } from '../types';
+export type { UseRepeatLoginOptions, UseRepeatLoginReturn } from '../types';
+/**
+ * Business logic for repeat login (device-based returning-user detection).
+ *
+ * **Dual submission:** `continueApi` (async, hook owns flow) vs `onContinueWithLastMethod` (sync, caller owns flow).
+ * Last-used method is read from localStorage by the provider and passed down as a prop.
+ */
+export declare function useRepeatLogin(options?: UseRepeatLoginOptions): UseRepeatLoginReturn;

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

@@ -0,0 +1,12 @@
+import type { UseSignupFormOptions, UseSignupFormReturn } from '../types';
+export type { SignupEmailFormValues, SignupEntryMode, SignupForeignFormValues, SignupFormValues, SignupPhoneFormValues, SignupSubmitData, UseSignupFormOptions, UseSignupFormReturn, } from '../types';
+/**
+ * Form state and validation for the signup screen (full name + phone or email, or foreign: all three).
+ *
+ * **Dual submission pattern:**
+ * - `submitApi` (async): hook owns the flow — validate → submitApi(data) → onSuccess(). Future SSO profile completion plugs in here.
+ * - `onSubmit` (sync): caller owns the flow — hook validates then hands data back (used by AuthFlow).
+ *
+ * **Validation flow:** RHF form data → Zod schema (signupSchemas[mode]) → setFormErrorsFromZod → field-level errors.
+ */
+export declare function useSignupForm({ mode, defaultPhone, onSubmit, submitApi, onSuccess, onError, }: UseSignupFormOptions): UseSignupFormReturn;

package/dist/index.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Auth SDK UI Kit – library entry point.
+ * Consumers can import components, layouts (composition + preset), hooks, core (SSO provider, flow, session), and auth methods.
+ *
+ * Import the kit styles once globally in your app (e.g. in main.tsx):
+ * `import 'doct-ui-auth-kit/style.css';`
+ *
+ * @example
+ * ```ts
+ * import {
+ *   SSOAuthProvider,
+ *   AuthFlow,
+ *   useAuthFlow,
+ *   useAuthSession,
+ *   MainLayout,
+ *   AuthLayout,
+ *   ImageSlider,
+ *   AuthLayoutWrapper,
+ *   LoginEntry,
+ *   OtpVerification,
+ *   useGoogleAuth,
+ * } from 'doct-ui-auth-kit';
+ * ```
+ */
+import './index.css';
+export { createHttpAuthAdapter } from './adapters';
+export { Auth } from './auth';
+export type { UseAppleSignInOptions, UseGoogleAuthOptions, UseGoogleAuthReturn, } from './auth-methods';
+export { useAppleSignIn, useGoogleAuth } from './auth-methods';
+export type { BackButtonProps } from './components/common';
+export { BackButton, DefaultFooter, EnterpriseHeader, } from './components/common';
+export type { AuthLayoutPresetProps, AuthLayoutType, AuthLayoutWrapperProps, } from './components/layout';
+export { AuthLayout, AuthLayoutPreset, AuthLayoutWrapper, ImageSlider, MainLayout, } from './components/layout';
+export * from './core';
+export * from './hooks';
+export type { LoginEntryPageProps, LoginEntryProps, MainLoginPageProps, MainLoginPageProvidersConfig, OtpVerificationPageProps, OtpVerificationProps, RepeatLoginPageProps, RepeatLoginProps, SignupPageFullProps, SignupPageProps, } from './pages/index';
+export { LoginEntry, LoginEntryPage, MainLogin, MainLoginPage, OtpVerification, OtpVerificationPage, RepeatLogin, RepeatLoginPage, Signup, SignupPage, } from './pages/index';
+export * from './types';

package/dist/pages/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Page components barrel: *Page = full page with layout, bare name = form-only for composition.
+ */
+export { LoginEntry, type LoginEntryMode, LoginEntryPage, type LoginEntryPageProps, type LoginEntryProps, } from './login-entry';
+export { MainLogin, type MainLoginAppleProviderConfig, type MainLoginGoogleProviderConfig, MainLoginPage, type MainLoginPageProps, type MainLoginPageProvidersConfig, } from './main-login';
+export { OtpVerification, type OtpVerificationMode, OtpVerificationPage, type OtpVerificationPageProps, type OtpVerificationProps, } from './otp-verification';
+export { RepeatLogin, RepeatLoginPage, type RepeatLoginPageProps, type RepeatLoginProps, } from './repeat-login';
+export { Signup, SignupPage, type SignupPageFullProps, type SignupPageProps, } from './signup';

package/dist/pages/login-entry/index.d.ts

@@ -0,0 +1,3 @@
+export type { LoginEntryMode, LoginEntryPageProps, LoginEntryProps, } from '../../types';
+export { LoginEntry } from './login-entry';
+export { LoginEntryPage } from './login-entry-page';

package/dist/pages/login-entry/login-entry-page.d.ts

@@ -0,0 +1,21 @@
+import type { LoginEntryPageProps } from '../../types';
+/**
+ * Full LoginEntry page with AuthLayoutWrapper, back button, and slider/standalone layout.
+ * Use when rendering the login entry screen as a standalone page.
+ *
+ * @example Next.js: API call in hook, redirect with mode + recipient for OTP page
+ * ```tsx
+ * <LoginEntryPage
+ *   mode="phone"
+ *   onBack={() => router.back()}
+ *   submitApi={(data) => api.sendOtp(data)}
+ *   onSuccess={(params) => router.push(`/otp?mode=${params.mode}&recipient=${encodeURIComponent(params.recipient)}`)}
+ * />
+ * ```
+ *
+ * @example Sync callback (caller owns API)
+ * ```tsx
+ * <LoginEntryPage mode="phone" onSubmit={(data) => sendOtp(data)} />
+ * ```
+ */
+export declare function LoginEntryPage(props: Readonly<LoginEntryPageProps>): import("react/jsx-runtime").JSX.Element;

package/dist/pages/login-entry/login-entry.d.ts

@@ -0,0 +1,21 @@
+import type { LoginEntryProps } from '../../types';
+/**
+ * Login entry form body without layout wrapper.
+ * Single form for phone or email based on mode. Use inside your own layout or AuthFlow.
+ * Validation per PRODUCT_PROTOCOLS and edge cases 3–5, 18; cursor focus on first field (#26).
+ *
+ * @example With AuthFlow (sync onSubmit)
+ * ```tsx
+ * <LoginEntry mode="phone" onSubmit={(data) => actions.submitIdentifier(data)} />
+ * ```
+ *
+ * @example Standalone Next.js (API + redirect in hook)
+ * ```tsx
+ * <LoginEntry
+ *   mode="phone"
+ *   submitApi={(data) => api.sendOtp(data)}
+ *   onSuccess={() => router.push('/otp')}
+ * />
+ * ```
+ */
+export declare function LoginEntry(props: Readonly<LoginEntryProps>): import("react/jsx-runtime").JSX.Element;

package/dist/pages/main-login/index.d.ts

@@ -0,0 +1,3 @@
+export type { MainLoginAppleProviderConfig, MainLoginGoogleProviderConfig, MainLoginPageProps, MainLoginPageProvidersConfig, } from '../../types';
+export { MainLogin } from './main-login';
+export { MainLoginPage } from './main-login-page';

package/dist/pages/main-login/main-login-page.d.ts

@@ -0,0 +1,16 @@
+import type { MainLoginPageProps } from '../../types';
+/**
+ * Full MainLogin page with AuthLayoutWrapper, header, footer, and slider layout.
+ * Includes default branding and layout configuration.
+ *
+ * @example
+ * ```tsx
+ * <MainLoginPage
+ *   onContinueWithMobile={() => navigate('/auth/phone')}
+ *   onContinueWithEmail={() => navigate('/auth/email')}
+ *   onContinueWithGoogle={() => navigate('/auth/google')}
+ *   onContinueWithApple={() => navigate('/auth/apple')}
+ * />
+ * ```
+ */
+export declare const MainLoginPage: (props: Readonly<MainLoginPageProps>) => import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,25 @@
+import type { MainAuthPageHandlers, MainLoginPageProps } from '../../types';
+interface MainLoginPageBodyProps {
+    handlers: MainAuthPageHandlers;
+}
+/**
+ * Renders the main login form body with four authentication options.
+ * Each button triggers its corresponding handler from the handlers prop.
+ */
+export declare const MainLoginPageBody: ({ handlers, }: Readonly<MainLoginPageBodyProps>) => import("react/jsx-runtime").JSX.Element;
+/**
+ * Login body component without layout wrapper.
+ * Displays four authentication method buttons (Mobile, Email, Google, Apple).
+ *
+ * Use this when you need custom layout or when integrating with AuthFlow.
+ *
+ * @example
+ * ```tsx
+ * <MainLogin
+ *   onContinueWithMobile={() => navigate('/auth/phone')}
+ *   onContinueWithEmail={() => navigate('/auth/email')}
+ * />
+ * ```
+ */
+export declare function MainLogin(props: Readonly<MainLoginPageProps>): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/pages/otp-verification/index.d.ts

@@ -0,0 +1,3 @@
+export type { OtpVerificationMode, OtpVerificationPageProps, OtpVerificationProps, } from '../../types';
+export { OtpVerification } from './otp-verification';
+export { OtpVerificationPage } from './otp-verification-page';

package/dist/pages/otp-verification/otp-verification-page.d.ts

@@ -0,0 +1,23 @@
+import type { OtpVerificationPageProps } from '../../types';
+/**
+ * Full OTP verification page with AuthLayoutWrapper and back button.
+ * Use when rendering the OTP screen as a standalone page.
+ *
+ * @example Next.js: API in hook, redirect from consumer
+ * ```tsx
+ * <OtpVerificationPage
+ *   mode="phone"
+ *   recipientDisplay="+91 9825910X0X"
+ *   onBack={() => router.back()}
+ *   submitApi={(otp) => api.verifyOtp(otp)}
+ *   onSuccess={() => router.push('/dashboard')}
+ *   onResendCode={() => api.resendOtp()}
+ * />
+ * ```
+ *
+ * @example Sync callback (AuthFlow)
+ * ```tsx
+ * <OtpVerificationPage onSubmit={(otp) => actions.verifyOtp(otp)} ... />
+ * ```
+ */
+export declare function OtpVerificationPage(props: Readonly<OtpVerificationPageProps>): import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,22 @@
+import type { OtpVerificationProps } from '../../types';
+/**
+ * OTP verification form body without layout wrapper.
+ * 6-digit OTP input, resend countdown, and submit. Use inside your own layout or AuthFlow.
+ * Validation per edge cases 6, 7 (invalid/expired OTP); cursor focus on first OTP box (#26).
+ *
+ * @example With submitApi + onSuccess (consumer redirect)
+ * ```tsx
+ * <OtpVerification
+ *   mode="phone"
+ *   recipientDisplay="+91 9825910X0X"
+ *   submitApi={(otp) => api.verifyOtp(otp)}
+ *   onSuccess={() => router.push('/dashboard')}
+ * />
+ * ```
+ *
+ * @example Sync onSubmit (AuthFlow)
+ * ```tsx
+ * <OtpVerification onSubmit={(otp) => actions.verifyOtp(otp)} ... />
+ * ```
+ */
+export declare function OtpVerification(props: Readonly<OtpVerificationProps>): import("react/jsx-runtime").JSX.Element;

package/dist/pages/repeat-login/index.d.ts

@@ -0,0 +1,3 @@
+export type { RepeatLoginPageProps, RepeatLoginProps } from '../../types';
+export { RepeatLogin } from './repeat-login';
+export { RepeatLoginPage } from './repeat-login-page';

package/dist/pages/repeat-login/repeat-login-page.d.ts

@@ -0,0 +1,24 @@
+import type { RepeatLoginPageProps } from '../../types';
+/**
+ * Full Repeat Login page with AuthLayoutWrapper, logo, title, description, and footer.
+ * Use when rendering the repeat login screen as a standalone page.
+ *
+ * @example Next.js: API in lib, redirect from consumer
+ * ```tsx
+ * <RepeatLoginPage
+ *   lastUsedMethod="Mobile"
+ *   continueApi={() => api.validateSession()}
+ *   onSuccess={() => router.push('/dashboard')}
+ *   onUseAnotherMethod={() => resetFlow()}
+ * />
+ * ```
+ *
+ * @example Sync (AuthFlow)
+ * ```tsx
+ * <RepeatLoginPage
+ *   onContinueWithLastMethod={() => actions.continueWithLastMethod()}
+ *   onUseAnotherMethod={() => actions.reset()}
+ * />
+ * ```
+ */
+export declare function RepeatLoginPage(props: Readonly<RepeatLoginPageProps>): import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,25 @@
+import type { RepeatLoginProps } from '../../types';
+/**
+ * Repeat login body without layout wrapper.
+ * Primary CTA (continue with last method) and secondary "Use another method" button.
+ * When continueApi is provided, primary runs: continueApi() → onSuccess() (e.g. redirect).
+ *
+ * @example With continueApi + onSuccess (consumer redirect)
+ * ```tsx
+ * <RepeatLogin
+ *   lastUsedMethod="Mobile"
+ *   continueApi={() => api.validateSession()}
+ *   onSuccess={() => router.push('/dashboard')}
+ *   onUseAnotherMethod={() => resetFlow()}
+ * />
+ * ```
+ *
+ * @example Sync (AuthFlow)
+ * ```tsx
+ * <RepeatLogin
+ *   onContinueWithLastMethod={() => actions.continueWithLastMethod()}
+ *   onUseAnotherMethod={() => actions.reset()}
+ * />
+ * ```
+ */
+export declare function RepeatLogin(props: Readonly<RepeatLoginProps>): import("react/jsx-runtime").JSX.Element;

package/dist/pages/signup/index.d.ts

@@ -0,0 +1,3 @@
+export type { SignupEntryMode, SignupPageFullProps, SignupPageProps, } from '../../types';
+export { Signup } from './signup';
+export { SignupPage } from './signup-page';

package/dist/pages/signup/signup-page.d.ts

@@ -0,0 +1,6 @@
+import type { SignupPageFullProps } from '../../types';
+/**
+ * Full signup page: AuthLayoutWrapper + logo + title + description + {@link Signup} form.
+ * Use when rendering signup as a standalone route. For embedding in a custom layout, use {@link Signup} directly.
+ */
+export declare function SignupPage(props: Readonly<SignupPageFullProps>): import("react/jsx-runtime").JSX.Element;

package/dist/pages/signup/signup.d.ts

@@ -0,0 +1,7 @@
+import type { SignupPageProps } from '../../types';
+/**
+ * Form-only signup component (no layout wrapper). Use inside a custom layout or AuthFlow.
+ * Supports `submitApi` (async, hook-driven — future SSO profile completion plugs in here)
+ * and `onSubmit` (sync, caller-driven via AuthFlow actions).
+ */
+export declare function Signup(props: Readonly<SignupPageProps>): import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,57 @@
+/**
+ * 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, UserType, 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;
+}
+/** Optional lookup to branch flows before sending OTP (e.g. foreign existing user). */
+export interface CheckIdentifierParams {
+    type: 'phone' | 'email';
+    value: string;
+}
+/** Optional lookup response used by the provider to choose the next step. */
+export interface CheckIdentifierResponse {
+    exists: boolean;
+    userType?: UserType;
+}
+/**
+ * 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>;
+    /** Optional: check identifier existence before OTP routing decisions. */
+    checkIdentifier?(params: CheckIdentifierParams): Promise<CheckIdentifierResponse>;
+    /** Optional: clear server-side cookie/session on sign out. */
+    logout?(): Promise<void>;
+}

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

@@ -0,0 +1,40 @@
+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[];
+    };
+}
+/** Props for the SSOAuthProvider context wrapper that supplies auth state to the component tree. */
+export interface SSOAuthProviderProps {
+    /** Auth configuration including API adapter, provider settings, and callbacks. */
+    config: SSOAuthConfig;
+    /** Child components that will have access to the SSO auth context. */
+    children: ReactNode;
+}

package/dist/types/auth/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/auth/device-detection.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Types for device-based repeat-login detection and persistence.
+ */
+import type { AuthMethod } from './auth-types';
+/** Stored repeat-login info (method + masked identifier). */
+export interface StoredRepeatLogin {
+    /** The authentication method used in the previous login (e.g. `'phone'`, `'email'`, `'google'`). */
+    method: AuthMethod;
+    /** Partially masked identifier shown to the user (e.g. `"****1234"` or `"j***@example.com"`). */
+    maskedIdentifier: string;
+    /** Unix epoch (ms) when this login record was stored. Used for expiry checks. */
+    timestamp: number;
+}