doct-ui-auth-kit 1.0.6 → 1.0.8

package/dist/types/{auth-api-adapter.d.ts → auth/auth-api-adapter.d.ts}

@@ -1,8 +1,4 @@
-/**
- * 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';
+import { AuthenticateWithProviderParams, CompleteProfileParams, SendOtpResponse, SSOSession, VerifyOtpResponse } from './auth-types';
 /** Parameters for sending OTP to phone or email. */
 export interface SendOtpParams {
     type: 'phone' | 'email';

package/dist/types/{auth-provider.d.ts → auth/auth-provider.d.ts}

@@ -1,7 +1,7 @@
-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';
+import { ReactNode } from 'react';
+import { AuthApiAdapter } from './auth-api-adapter';
+import { AuthError, SSOSession } from './auth-types';
+import { TokenStorageStrategy } from './sso-session';
 /** Consumer-provided config for SSOAuthProvider. */
 export interface SSOAuthConfig {
     /** Consumer-provided adapter to their central auth service. */
@@ -31,7 +31,10 @@ export interface SSOAuthConfig {
         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/device-detection.d.ts

@@ -0,0 +1,10 @@
+import { 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;
+}

package/dist/types/{flow.d.ts → auth/flow.d.ts}

@@ -1,7 +1,4 @@
-/**
- * Auth flow state machine types: state, actions, and context.
- */
-import type { AuthStep, SSOSession, UserType } from './auth-types';
+import { AuthStep, SSOSession, UserType } from './auth-types';
 /** Identifier type for OTP / profile steps. */
 export type IdentifierType = 'phone' | 'email';
 /** Full state for the auth flow. */

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

@@ -0,0 +1,9 @@
+/**
+ * Auth domain types: session, adapter, provider, flow state, errors, device detection.
+ */
+export * from './auth-types';
+export * from './auth-api-adapter';
+export * from './auth-provider';
+export * from './sso-session';
+export * from './device-detection';
+export * from './flow';

package/dist/types/{auth-layout-types.d.ts → components/auth-layout-types.d.ts}

@@ -1,4 +1,4 @@
-import type { ReactNode } from 'react';
+import { ReactNode } from 'react';
 /**
  * Layout configuration types
  */

package/dist/types/components/forms.d.ts

@@ -0,0 +1,68 @@
+import { KeyboardEvent } from 'react';
+import { Control, FieldValues } from 'react-hook-form';
+/** Base props shared by RHF form field components. */
+export interface BaseFormFieldProps {
+    /** Field name used by react-hook-form for registration and validation. */
+    name: string;
+    /** Visible label rendered above or beside the input. */
+    label?: string;
+    /** Placeholder text shown when the input is empty. */
+    placeholder?: string;
+    /** Whether the field is required for form submission. */
+    required?: boolean;
+    /** Whether the field is disabled (non-interactive). */
+    disabled?: boolean;
+    /** Additional CSS class name(s) applied to the field wrapper. */
+    className?: string;
+    /** Validation error message to display below the input. */
+    error?: string;
+    /** Supplementary helper text shown below the input when there is no error. */
+    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 {
+    /** HTML input type. Allowed: `'text'`, `'email'`, `'password'`, `'number'`, `'tel'`, `'url'`, `'search'`. */
+    type?: 'text' | 'email' | 'password' | 'number' | 'tel' | 'url' | 'search';
+    /** HTML `autocomplete` attribute value (e.g. `'email'`, `'tel'`). */
+    autoComplete?: string;
+    /** Maximum character length enforced on the input. */
+    maxLength?: number;
+    /** Minimum character length enforced on the input. */
+    minLength?: number;
+    /** Regex pattern string for native HTML validation. */
+    pattern?: string;
+    /** react-hook-form `Control` instance. When omitted, the field uses the nearest `FormProvider`. */
+    control?: Control<FieldValues>;
+    /** Called when a key is pressed while the input is focused. */
+    onKeyDown?: (event: KeyboardEvent<HTMLInputElement>) => void;
+    /** When true, restricts input to numeric characters only. */
+    numericOnly?: boolean;
+}
+/** Props for RHF wrapper around DoctPhoneInput (docthub-core-components). */
+export interface RHFDoctPhoneInputFieldProps extends BaseFormFieldProps {
+    /** ISO 3166-1 alpha-2 country code pre-selected in the phone input (e.g. `'IN'`, `'US'`). */
+    defaultCountry?: string;
+    /** Display variant: `'default'` shows full country selector, `'flag'` shows flag icon only. */
+    variant?: 'default' | 'flag';
+    /** react-hook-form `Control` instance. When omitted, the field uses the nearest `FormProvider`. */
+    control?: Control<FieldValues>;
+}
+/** Props for the OTP input field component. */
+export interface RHFOtpInputFieldProps extends BaseFormFieldProps {
+    /** Number of OTP digit boxes to render. @default 6 */
+    length?: number;
+    /** Input type for each OTP box: `'text'`, `'number'`, or `'password'` (masked). */
+    type?: 'text' | 'number' | 'password';
+    /** Focus the first OTP box on mount. */
+    autoFocus?: boolean;
+    /** Automatically trigger submission when all boxes are filled. */
+    autoSubmit?: boolean;
+    /** Called with the complete OTP string once all boxes are filled. */
+    onComplete?: (otp: string) => void;
+    /** CSS class name(s) applied to each individual OTP input box. */
+    inputClassName?: string;
+    /** react-hook-form `Control` instance. When omitted, the field uses the nearest `FormProvider`. */
+    control?: Control<FieldValues>;
+}

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

@@ -0,0 +1,7 @@
+/**
+ * Component prop types: form fields, layouts, auth-layout compound, presets.
+ */
+export * from './forms';
+export * from './layout';
+export * from './auth-layout-types';
+export * from './layout-presets';

package/dist/types/{layout-presets.d.ts → components/layout-presets.d.ts}

@@ -1,9 +1,4 @@
-/**
- * Layout preset types for the Auth SDK.
- * Presets control structure only: width, alignment, slider vs standalone.
- * They do NOT control auth methods, MFA, or flow behavior.
- */
-import type { AuthLayoutAlign, AuthLayoutMaxWidth, AuthLayoutVariant } from './auth-layout-types';
+import { AuthLayoutAlign, AuthLayoutMaxWidth, AuthLayoutVariant } from './auth-layout-types';
 /** Layout type: two-panel with slider vs single centered column. */
 export type LayoutType = 'withSlider' | 'standalone';
 /**

package/dist/types/{layout.d.ts → components/layout.d.ts}

@@ -1,4 +1,4 @@
-import type { ReactNode } from 'react';
+import { ReactNode } from 'react';
 /** Props for the ImageSlider component. */
 export interface ImageSliderProps {
     /** Array of image URLs to display */

package/dist/types/index.d.ts

@@ -1,20 +1,7 @@
 /**
- * Central export file for all types and interfaces.
- * Import types from here: import type { RHFInputFieldProps } from '@/types';
+ * Central export for all types and interfaces.
+ * Organized by domain: auth (SSO), components (props), pages (page-specific).
  */
-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 './auth';
+export * from './components';
 export * from './pages';
-export * from './repeat-login';
-export * from './signup-form';
-export * from './sso-session';

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

@@ -0,0 +1,9 @@
+/**
+ * Page-specific types: props, form values, hook options/return types.
+ */
+export * from './pages';
+export * from './login-form';
+export * from './signup-form';
+export * from './otp-verification';
+export * from './main-login';
+export * from './repeat-login';

package/dist/types/{login-form.d.ts → pages/login-form.d.ts}

@@ -1,10 +1,13 @@
-import type { UseFormReturn } from 'react-hook-form';
-import type { z } from 'zod';
-import type { loginEmailFormSchema, loginPhoneFormSchema } from '@/validations';
+import { UseFormReturn } from 'react-hook-form';
+import { z } from 'zod';
+import { loginEmailFormSchema, loginPhoneFormSchema } from '../../validations';
 /** Login mode: phone number or email */
 export type LoginEntryMode = 'phone' | 'email';
+/** Form values for phone-based login, inferred from the Zod schema. */
 export type PhoneFormValues = z.infer<typeof loginPhoneFormSchema>;
+/** Form values for email-based login, inferred from the Zod schema. */
 export type EmailFormValues = z.infer<typeof loginEmailFormSchema>;
+/** Discriminated union of phone or email login form values. */
 export type LoginEntryFormValues = PhoneFormValues | EmailFormValues;
 /** Payload when login entry form is valid (phone or email). */
 export type LoginEntrySubmitData = {
@@ -32,15 +35,19 @@ export interface UseLoginEntryFormOptions {
      * When provided, hook runs business logic: validate → call submitApi(data) → onSuccess(params).
      * Use from consumer (e.g. Next.js): submitApi = sendOtp, onSuccess = (params) => router.push(`/otp?mode=${params.mode}&recipient=${encodeURIComponent(params.recipient)}`).
      */
-    submitApi?: (data: LoginEntrySubmitData) => Promise<void>;
+    submitApi?: ((data: LoginEntrySubmitData) => Promise<void>) | undefined;
     /** Called after submitApi resolves successfully; receives mode and recipient for OTP redirect/display. */
-    onSuccess?: (params: LoginEntrySuccessParams) => void;
+    onSuccess?: ((params: LoginEntrySuccessParams) => void) | undefined;
     /** Called when submitApi rejects or throws. */
-    onError?: (error: unknown) => void;
+    onError?: ((error: unknown) => void) | undefined;
 }
+/** Return value of the `useLoginEntryForm` hook, providing form state and mode info. */
 export interface UseLoginEntryFormReturn {
+    /** react-hook-form methods bound to the current login mode's schema. */
     methods: UseFormReturn<LoginEntryFormValues>;
+    /** Submit handler to pass to the form's `onSubmit`. Validates and dispatches the login data. */
     handleSubmit: (data: LoginEntryFormValues) => void;
+    /** True when the current mode is `'phone'`; use for conditional field rendering. */
     isPhone: boolean;
     /** True when current form values pass validation (for disabling Continue until valid – edge cases 3, 4). */
     isFormValid: (data: LoginEntryFormValues) => boolean;

package/dist/types/{main-login.d.ts → pages/main-login.d.ts}

@@ -1,26 +1,37 @@
 /** Handlers exposed by the main auth page (method select). */
 export interface MainAuthPageHandlers {
+    /** Called when the user selects "Continue with Mobile". */
     onContinueWithMobile: () => void;
+    /** Called when the user selects "Continue with Email". */
     onContinueWithEmail: () => void;
+    /** Called when the user selects "Continue with Google". */
     onContinueWithGoogle: () => void;
+    /** Called when the user selects "Continue with Apple". */
     onContinueWithApple: () => void;
 }
 /** Config for lib-handled Google sign-in. When set, the lib runs the OAuth flow and calls onCredential. */
 export interface MainLoginGoogleProviderConfig {
+    /** Google OAuth 2.0 client ID. */
     clientId: string;
     /** Called with ID token (One Tap) or auth code (button popup). Send to your backend to verify. */
     onCredential: (credential: string) => void;
+    /** Enable Google One Tap prompt for automatic sign-in. */
     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 {
+    /** Apple Services ID (client ID) configured in the Apple Developer portal. */
     clientId: string;
+    /** OAuth redirect URI registered with Apple for the sign-in flow. */
     redirectUri: string;
+    /** Called with the Apple identity token after a successful sign-in. Send to your backend to verify. */
     onCredential: (credential: string) => void;
 }
 /** Optional provider config so the lib handles Google/Apple API calls. */
 export interface MainLoginPageProvidersConfig {
+    /** Google sign-in configuration. When set, the lib handles the Google OAuth flow. */
     google?: MainLoginGoogleProviderConfig;
+    /** Apple sign-in configuration. When set, the lib handles the Apple OAuth flow. */
     apple?: MainLoginAppleProviderConfig;
 }
 /** Options for useMainAuthPageHandlers: optional callback overrides + optional provider config for lib-handled OAuth. */

package/dist/types/{otp-verification.d.ts → pages/otp-verification.d.ts}

@@ -1,29 +1,39 @@
-import type { UseFormReturn } from 'react-hook-form';
-import type { z } from 'zod';
-import type { OtpVerificationMode, otpFormSchema } from '@/validations';
+import { UseFormReturn } from 'react-hook-form';
+import { z } from 'zod';
+import { OtpVerificationMode, otpFormSchema } from '../../validations';
 export type { OtpVerificationMode };
+/** Form values for the OTP verification form, inferred from the Zod schema. */
 export type OtpFormValues = z.infer<typeof otpFormSchema>;
+/** Options for the `useOtpVerification` hook controlling mode, submission, and callbacks. */
 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;
+    /** Called when the user requests a new OTP code (resend). Ignored when submitApi is provided. */
     onResendCode?: (() => void) | undefined;
     /** When provided, hook runs: validate → submitApi(otp) → onSuccess(). Consumer passes redirect in onSuccess. */
-    submitApi?: (otp: string) => Promise<void>;
+    submitApi?: ((otp: string) => Promise<void>) | undefined;
     /** Called after submitApi resolves (e.g. router.push('/dashboard')). */
-    onSuccess?: () => void;
+    onSuccess?: (() => void) | undefined;
     /** Called when submitApi rejects or throws. */
-    onError?: (error: unknown) => void;
+    onError?: ((error: unknown) => void) | undefined;
 }
+/** Return value of the `useOtpVerification` hook, providing form state and resend controls. */
 export interface UseOtpVerificationReturn {
+    /** react-hook-form methods bound to the OTP form. */
     methods: UseFormReturn<OtpFormValues>;
+    /** Submit handler to pass to the form's `onSubmit`. Validates and dispatches the OTP. */
     handleSubmit: (data: OtpFormValues) => void;
     /** True when current form values pass validation (for disabling Submit until valid – edge case 6). */
     isFormValid: (data: OtpFormValues) => boolean;
+    /** Triggers a resend of the OTP code and resets the cooldown timer. */
     handleResend: () => void;
+    /** Seconds remaining before the user can request another OTP code. */
     resendSecondsLeft: number;
+    /** True when the resend cooldown has elapsed and the user may request a new code. */
     canResend: boolean;
+    /** Human-readable countdown string (e.g. `"00:45"`) for display next to the resend button. */
     timerText: string;
     /** True while submitApi is in flight. */
     isSubmitting: boolean;

package/dist/types/{pages.d.ts → pages/pages.d.ts}

@@ -1,11 +1,8 @@
-/**
- * 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';
+import { UserType } from '../auth/auth-types';
+import { IdentifierType } from '../auth/flow';
+import { LoginEntryMode } from './login-form';
+import { UseMainAuthPageHandlersOptions } from './main-login';
+import { OtpVerificationMode } from './otp-verification';
 /** Props for MainLoginPage and MainLogin components. */
 export type MainLoginPageProps = UseMainAuthPageHandlersOptions;
 /** Props for LoginEntry (inner form without layout). */
@@ -22,25 +19,25 @@ export interface LoginEntryProps {
      * Sync callback with valid data. Use when parent owns API (e.g. AuthFlow).
      * Ignored when submitApi is provided.
      */
-    onSubmit?: (data: {
+    onSubmit?: ((data: {
         phone?: string;
         email?: string;
-    }) => void;
+    }) => void) | undefined;
     /**
      * 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: {
+    submitApi?: ((data: {
         phone?: string;
         email?: string;
-    }) => Promise<void>;
+    }) => Promise<void>) | undefined;
     /** Called after submitApi succeeds; receives { mode, recipient } for OTP redirect/recipientDisplay. */
-    onSuccess?: (params: {
+    onSuccess?: ((params: {
         mode: LoginEntryMode;
         recipient: string;
-    }) => void;
+    }) => void) | undefined;
     /** Called when submitApi fails. */
-    onError?: (error: unknown) => void;
+    onError?: ((error: unknown) => void) | undefined;
 }
 /** Props for the full LoginEntryPage (adds optional layout overrides for story/viewport). */
 export interface LoginEntryPageProps extends LoginEntryProps {
@@ -58,23 +55,23 @@ export interface SignupPageProps {
     /** Indian only: which field to collect (phone or email). */
     signupCollectField: IdentifierType;
     /** Foreign only: phone when user entered phone before signup details. */
-    pendingPhone?: string;
+    pendingPhone?: string | undefined;
     /** Sync callback with valid data. Use when parent owns API (e.g. AuthFlow). Ignored when submitApi is provided. */
-    onSubmit?: (data: {
+    onSubmit?: ((data: {
         fullName: string;
         phone?: string;
         email?: string;
-    }) => void;
+    }) => void) | undefined;
     /** Async API (e.g. complete profile). When provided, hook runs: validate → submitApi(data) → onSuccess(). */
-    submitApi?: (data: {
+    submitApi?: ((data: {
         fullName: string;
         phone?: string;
         email?: string;
-    }) => Promise<void>;
+    }) => Promise<void>) | undefined;
     /** Called after submitApi succeeds (e.g. router.push('/otp') or next step). */
-    onSuccess?: () => void;
+    onSuccess?: (() => void) | undefined;
     /** Called when submitApi fails. */
-    onError?: (error: unknown) => void;
+    onError?: ((error: unknown) => void) | undefined;
 }
 /** Props for the full SignupPage (adds optional layout overrides). */
 export interface SignupPageFullProps extends SignupPageProps {
@@ -86,23 +83,23 @@ 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;
+    title?: string | undefined;
     /** 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;
+    isForeignUser?: boolean | undefined;
     /** Handler when back is clicked */
-    onBack?: () => void;
+    onBack?: (() => void) | undefined;
     /** Sync callback with OTP. Use when parent owns API (e.g. AuthFlow). Ignored when submitApi is provided. */
-    onSubmit?: (otp: string) => void;
+    onSubmit?: ((otp: string) => void) | undefined;
     /** Handler when user requests resend code */
-    onResendCode?: () => void;
+    onResendCode?: (() => void) | undefined;
     /** Async API (e.g. verify OTP). When provided, hook runs: validate → submitApi(otp) → onSuccess(). */
-    submitApi?: (otp: string) => Promise<void>;
+    submitApi?: ((otp: string) => Promise<void>) | undefined;
     /** Called after submitApi succeeds (e.g. router.push('/dashboard')). */
-    onSuccess?: () => void;
+    onSuccess?: (() => void) | undefined;
     /** Called when submitApi fails. */
-    onError?: (error: unknown) => void;
+    onError?: ((error: unknown) => void) | undefined;
 }
 /** Props for the full OtpVerificationPage (adds optional layout overrides). */
 export interface OtpVerificationPageProps extends OtpVerificationProps {
@@ -119,15 +116,15 @@ export interface RepeatLoginProps {
      */
     lastUsedMethod?: string;
     /** Sync handler for primary action. Use when caller owns API (e.g. AuthFlow). Ignored when continueApi is provided. */
-    onContinueWithLastMethod?: () => void;
+    onContinueWithLastMethod?: (() => void) | undefined;
     /** Handler for the secondary action (choose another method). */
-    onUseAnotherMethod?: () => void;
+    onUseAnotherMethod?: (() => void) | undefined;
     /** Async API for continue (e.g. validate session). When provided, hook runs: continueApi() → onSuccess(). */
-    continueApi?: () => Promise<void>;
+    continueApi?: (() => Promise<void>) | undefined;
     /** Called after continueApi succeeds (e.g. router.push('/dashboard')). */
-    onSuccess?: () => void;
+    onSuccess?: (() => void) | undefined;
     /** Called when continueApi fails. */
-    onError?: (error: unknown) => void;
+    onError?: ((error: unknown) => void) | undefined;
 }
 /** Props for the full RepeatLoginPage (adds optional layout overrides). */
 export interface RepeatLoginPageProps extends RepeatLoginProps {

package/dist/types/{repeat-login.d.ts → pages/repeat-login.d.ts}

@@ -6,18 +6,19 @@ export interface UseRepeatLoginOptions {
      * Last used authentication method shown in the primary button label.
      * @default "Mobile"
      */
-    lastUsedMethod?: string;
+    lastUsedMethod?: string | undefined;
     /** Sync handler for primary action. Use when caller owns API (e.g. AuthFlow). Ignored when continueApi is provided. */
-    onContinueWithLastMethod?: () => void;
+    onContinueWithLastMethod?: (() => void) | undefined;
     /** Handler for the secondary action (choose another method). */
-    onUseAnotherMethod?: () => void;
+    onUseAnotherMethod?: (() => void) | undefined;
     /** Async API for continue (e.g. validate session). When provided, hook runs: continueApi() → onSuccess(). */
-    continueApi?: () => Promise<void>;
+    continueApi?: (() => Promise<void>) | undefined;
     /** Called after continueApi succeeds (e.g. router.push('/dashboard')). */
-    onSuccess?: () => void;
+    onSuccess?: (() => void) | undefined;
     /** Called when continueApi fails. */
-    onError?: (error: unknown) => void;
+    onError?: ((error: unknown) => void) | undefined;
 }
+/** Return value of the `useRepeatLogin` hook, providing continue handler and display state. */
 export interface UseRepeatLoginReturn {
     /** Call this when the user clicks "Continue with {lastUsedMethod}". */
     handleContinue: () => void;

package/dist/types/{signup-form.d.ts → pages/signup-form.d.ts}

@@ -1,11 +1,15 @@
-import type { UseFormReturn } from 'react-hook-form';
-import type { z } from 'zod';
-import type { signupEmailFormSchema, signupForeignFormSchema, signupPhoneFormSchema } from '@/validations';
+import { UseFormReturn } from 'react-hook-form';
+import { z } from 'zod';
+import { signupEmailFormSchema, signupForeignFormSchema, signupPhoneFormSchema } from '../../validations';
 /** Signup mode: phone, email as second field, or foreign (full name + email + phone). */
 export type SignupEntryMode = 'phone' | 'email' | 'foreign';
+/** Form values for phone-based signup, inferred from the Zod schema. */
 export type SignupPhoneFormValues = z.infer<typeof signupPhoneFormSchema>;
+/** Form values for email-based signup, inferred from the Zod schema. */
 export type SignupEmailFormValues = z.infer<typeof signupEmailFormSchema>;
+/** Form values for foreign signup (full name + email + phone), inferred from the Zod schema. */
 export type SignupForeignFormValues = z.infer<typeof signupForeignFormSchema>;
+/** Discriminated union of all signup form value shapes. */
 export type SignupFormValues = SignupPhoneFormValues | SignupEmailFormValues | SignupForeignFormValues;
 /** Payload when signup form is valid. */
 export type SignupSubmitData = {
@@ -17,18 +21,21 @@ export interface UseSignupFormOptions {
     /** Mode: phone, email as second field, or foreign (name + email + phone) */
     mode: SignupEntryMode;
     /** For foreign mode: pre-fill phone when user already entered it. */
-    defaultPhone?: string;
+    defaultPhone?: string | undefined;
     /** Sync callback with valid data. Use when parent owns API (e.g. AuthFlow). Ignored when submitApi is provided. */
     onSubmit?: ((data: SignupSubmitData) => void) | undefined;
     /** When provided, hook runs: validate → submitApi(data) → onSuccess(). Consumer passes redirect in onSuccess. */
-    submitApi?: (data: SignupSubmitData) => Promise<void>;
+    submitApi?: ((data: SignupSubmitData) => Promise<void>) | undefined;
     /** Called after submitApi succeeds (e.g. router.push('/otp') or next step). */
-    onSuccess?: () => void;
+    onSuccess?: (() => void) | undefined;
     /** Called when submitApi rejects or throws. */
-    onError?: (error: unknown) => void;
+    onError?: ((error: unknown) => void) | undefined;
 }
+/** Return value of the `useSignupForm` hook, providing form state and mode flags. */
 export interface UseSignupFormReturn {
+    /** react-hook-form methods bound to the current signup mode's schema. */
     methods: UseFormReturn<SignupFormValues>;
+    /** Submit handler to pass to the form's `onSubmit`. Validates and dispatches signup data. */
     handleSubmit: (data: SignupFormValues) => void;
     /** True when mode is 'phone', false when mode is 'email'. For 'foreign' same as (mode === 'phone') for layout. */
     isPhone: boolean;

package/dist/utils/set-form-errors-from-zod.d.ts

@@ -1,4 +1,4 @@
-import type { ZodError } from 'zod';
+import { ZodError } from 'zod';
 /**
  * Applies Zod validation errors to a React Hook Form setError function.
  * Used by form submit handlers to display field-level errors from schema validation.

package/dist/validations/schemas.d.ts

@@ -1,7 +1,3 @@
-/**
- * Centralized Zod schemas for auth forms (signup, login, OTP).
- * Single source of truth for validation rules per PRODUCT_PROTOCOLS.
- */
 import { z } from 'zod';
 /** Capitalize first letter of each word (PRODUCT_PROTOCOLS #25 – Naming conventions). */
 export declare function capitalizeWords(value: string): string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "doct-ui-auth-kit",
-  "version": "1.0.6",
+  "version": "1.0.8",
   "description": "Composable React auth SDK – layouts, login/signup/OTP pages, SSO provider, and auth flow hooks for Docthub",
   "type": "module",
   "main": "./dist/index.js",
@@ -23,7 +23,7 @@
   },
   "scripts": {
     "dev": "vite",
-    "build": "tsc -b && vite build && tsc -p tsconfig.build.json",
+    "build": "tsc -b && vite build",
     "prepublishOnly": "npm run build",
     "lint": "biome lint .",
     "preview": "vite preview",

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

@@ -1,42 +0,0 @@
-import type { LoginEntryPageProps, LoginEntryProps } from '@/types';
-export type { LoginEntryMode, LoginEntryPageProps, LoginEntryProps, } 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;
-/**
- * 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;