@authsome/ui-core 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,540 @@
+import { A as AuthErrorType, a as AuthError, V as ValidationError, b as AuthContext, c as AuthProvider, S as SignInRequest, d as SignUpRequest, U as UpdateUserRequest, P as PasswordChangeRequest, e as PasswordResetRequest, f as PasswordResetConfirmRequest, O as OAuthSignInRequest, g as OAuthCallbackRequest, h as OAuthProvider, M as MagicLinkRequest, i as MagicLinkVerifyRequest, j as PhoneAuthRequest, k as PhoneVerifyRequest, T as TwoFactorSetupRequest, l as TwoFactorSetupResponse, m as TwoFactorVerifyRequest, n as TwoFactorMethod, o as PasskeyRegisterRequest, p as PasskeyCredential, q as PasskeyAuthRequest, r as Organization, s as OrganizationMembership, t as User, u as Session } from './provider-DXf_a2WT.js';
+export { y as AuthResponse, v as AuthState, w as OAuthConfig, z as ProviderConfig, x as TwoFactorConfig } from './provider-DXf_a2WT.js';
+import { Storage, Observable, Unsubscribe } from './types/index.js';
+export { Listener, LocalStorageAdapter, MemoryStorageAdapter, SessionStorageAdapter } from './types/index.js';
+export { BaseAuthProvider } from './adapters/index.js';
+
+/**
+ * Error handling utilities
+ */
+
+/**
+ * Create an auth error
+ *
+ * @deprecated Use `new AuthError()` directly instead
+ */
+declare function createAuthError(type: AuthErrorType, message: string, details?: Record<string, unknown>, code?: string | number): AuthError;
+/**
+ * Check if an error is an auth error
+ */
+declare function isAuthError(error: unknown): error is AuthError;
+/**
+ * Convert unknown error to auth error
+ */
+declare function toAuthError(error: unknown): AuthError;
+/**
+ * Check if error is a network error
+ */
+declare function isNetworkError(error: unknown): boolean;
+/**
+ * Check if error indicates authentication is required
+ */
+declare function isUnauthenticatedError(error: unknown): boolean;
+/**
+ * Check if error requires MFA
+ */
+declare function isMFARequiredError(error: unknown): boolean;
+
+/**
+ * Validation utilities
+ */
+
+/**
+ * Validate email address
+ */
+declare function validateEmail(email: string): ValidationError | null;
+/**
+ * Validate password
+ */
+declare function validatePassword(password: string, options?: {
+    minLength?: number;
+    requireUppercase?: boolean;
+    requireLowercase?: boolean;
+    requireNumber?: boolean;
+    requireSpecial?: boolean;
+}): ValidationError | null;
+/**
+ * Validate phone number
+ */
+declare function validatePhone(phone: string): ValidationError | null;
+/**
+ * Validate username
+ */
+declare function validateUsername(username: string): ValidationError | null;
+/**
+ * Validate 2FA code
+ */
+declare function validate2FACode(code: string): ValidationError | null;
+/**
+ * Validate required field
+ */
+declare function validateRequired(value: unknown, fieldName: string): ValidationError | null;
+
+/**
+ * Token management utilities
+ */
+
+/**
+ * Token manager class
+ */
+declare class TokenManager {
+    private storage;
+    constructor(storage?: Storage);
+    /**
+     * Get access token
+     */
+    getToken(): Promise<string | null>;
+    /**
+     * Set access token
+     */
+    setToken(token: string): Promise<void>;
+    /**
+     * Remove access token
+     */
+    removeToken(): Promise<void>;
+    /**
+     * Get refresh token
+     */
+    getRefreshToken(): Promise<string | null>;
+    /**
+     * Set refresh token
+     */
+    setRefreshToken(token: string): Promise<void>;
+    /**
+     * Remove refresh token
+     */
+    removeRefreshToken(): Promise<void>;
+    /**
+     * Clear all tokens
+     */
+    clearTokens(): Promise<void>;
+    /**
+     * Check if token is expired
+     */
+    isTokenExpired(token: string): boolean;
+    /**
+     * Decode JWT token (without verification)
+     */
+    private decodeToken;
+}
+
+/**
+ * Auth client configuration
+ */
+interface AuthClientConfig {
+    provider: AuthProvider;
+    autoRefresh?: boolean;
+    refreshInterval?: number;
+}
+/**
+ * Auth client class
+ */
+declare class AuthClient {
+    private provider;
+    private autoRefresh;
+    private refreshInterval;
+    private refreshTimer?;
+    readonly state: Observable<AuthContext>;
+    constructor(config: AuthClientConfig);
+    /**
+     * Initialize the auth client
+     */
+    initialize(): Promise<void>;
+    /**
+     * Sign in with credentials
+     */
+    signIn(request: SignInRequest): Promise<void>;
+    /**
+     * Sign up with credentials
+     */
+    signUp(request: SignUpRequest): Promise<void>;
+    /**
+     * Sign out
+     */
+    signOut(): Promise<void>;
+    /**
+     * Update user profile
+     */
+    updateUser(request: UpdateUserRequest): Promise<void>;
+    /**
+     * Change password
+     */
+    changePassword(request: PasswordChangeRequest): Promise<void>;
+    /**
+     * Request password reset
+     */
+    requestPasswordReset(request: PasswordResetRequest): Promise<void>;
+    /**
+     * Confirm password reset
+     */
+    confirmPasswordReset(request: PasswordResetConfirmRequest): Promise<void>;
+    /**
+     * Get OAuth sign in URL
+     */
+    getOAuthUrl(request: OAuthSignInRequest): Promise<string>;
+    /**
+     * Handle OAuth callback
+     */
+    handleOAuthCallback(request: OAuthCallbackRequest): Promise<void>;
+    /**
+     * Get available OAuth providers
+     */
+    getOAuthProviders(): Promise<OAuthProvider[]>;
+    /**
+     * Send magic link
+     */
+    sendMagicLink(request: MagicLinkRequest): Promise<void>;
+    /**
+     * Verify magic link
+     */
+    verifyMagicLink(request: MagicLinkVerifyRequest): Promise<void>;
+    /**
+     * Send phone verification code
+     */
+    sendPhoneCode(request: PhoneAuthRequest): Promise<void>;
+    /**
+     * Verify phone code
+     */
+    verifyPhoneCode(request: PhoneVerifyRequest): Promise<void>;
+    /**
+     * Setup 2FA
+     */
+    setupTwoFactor(request: TwoFactorSetupRequest): Promise<TwoFactorSetupResponse>;
+    /**
+     * Verify 2FA code
+     */
+    verifyTwoFactor(request: TwoFactorVerifyRequest): Promise<void>;
+    /**
+     * Disable 2FA
+     */
+    disableTwoFactor(): Promise<void>;
+    /**
+     * Get 2FA status
+     */
+    getTwoFactorStatus(): Promise<TwoFactorMethod[]>;
+    /**
+     * Register passkey
+     */
+    registerPasskey(request: PasskeyRegisterRequest): Promise<PasskeyCredential>;
+    /**
+     * Authenticate with passkey
+     */
+    authenticatePasskey(request: PasskeyAuthRequest): Promise<void>;
+    /**
+     * List passkeys
+     */
+    listPasskeys(): Promise<PasskeyCredential[]>;
+    /**
+     * Delete passkey
+     */
+    deletePasskey(credentialId: string): Promise<void>;
+    /**
+     * Get all organizations the user belongs to
+     * Only available if the provider supports organizations
+     */
+    getOrganizations(): Promise<Organization[]>;
+    /**
+     * Get the currently active organization
+     * Only available if the provider supports organizations
+     */
+    getActiveOrganization(): Promise<Organization | null>;
+    /**
+     * Set the active organization and refresh user state
+     * Only available if the provider supports organizations
+     */
+    setActiveOrganization(organizationId: string): Promise<void>;
+    /**
+     * Get organization memberships with roles and permissions
+     * Only available if the provider supports organizations
+     */
+    getOrganizationMemberships(): Promise<OrganizationMembership[]>;
+    /**
+     * Check if the provider supports organizations
+     */
+    supportsOrganizations(): boolean;
+    /**
+     * Refresh session
+     */
+    refreshSession(): Promise<void>;
+    /**
+     * Get current user
+     */
+    getUser(): User | null;
+    /**
+     * Get current session
+     */
+    getSession(): Session | null;
+    /**
+     * Check if authenticated
+     */
+    isAuthenticated(): boolean;
+    /**
+     * Get current error
+     */
+    getError(): AuthError | null;
+    /**
+     * Clear error
+     */
+    clearError(): void;
+    /**
+     * Subscribe to auth state changes
+     */
+    subscribe(listener: (context: AuthContext) => void): Unsubscribe;
+    /**
+     * Cleanup resources
+     */
+    destroy(): void;
+    private updateState;
+    private setLoading;
+    private handleError;
+    private startAutoRefresh;
+    private stopAutoRefresh;
+    private createUnsupportedError;
+}
+
+/**
+ * Authentication flow types and state machine
+ */
+
+/**
+ * Available authentication flow steps
+ */
+declare enum FlowStep {
+    SIGN_IN = "sign_in",
+    SIGN_UP = "sign_up",
+    EMAIL_PASSWORD_SIGN_IN = "email_password_sign_in",
+    EMAIL_PASSWORD_SIGN_UP = "email_password_sign_up",
+    OAUTH_SELECT = "oauth_select",
+    OAUTH_CALLBACK = "oauth_callback",
+    MAGIC_LINK_REQUEST = "magic_link_request",
+    MAGIC_LINK_VERIFY = "magic_link_verify",
+    MAGIC_LINK_SENT = "magic_link_sent",
+    PHONE_REQUEST = "phone_request",
+    PHONE_VERIFY = "phone_verify",
+    USERNAME_SIGN_IN = "username_sign_in",
+    USERNAME_SIGN_UP = "username_sign_up",
+    PASSKEY_REGISTER = "passkey_register",
+    PASSKEY_AUTHENTICATE = "passkey_authenticate",
+    MFA_REQUIRED = "mfa_required",
+    MFA_SETUP = "mfa_setup",
+    MFA_VERIFY = "mfa_verify",
+    MFA_SELECT_METHOD = "mfa_select_method",
+    EMAIL_VERIFICATION_REQUIRED = "email_verification_required",
+    EMAIL_VERIFICATION_SENT = "email_verification_sent",
+    PHONE_VERIFICATION_REQUIRED = "phone_verification_required",
+    PASSWORD_RESET_REQUEST = "password_reset_request",
+    PASSWORD_RESET_SENT = "password_reset_sent",
+    PASSWORD_RESET_CONFIRM = "password_reset_confirm",
+    PASSWORD_CHANGE = "password_change",
+    PROFILE_UPDATE = "profile_update",
+    PROFILE_COMPLETE = "profile_complete",
+    SUCCESS = "success",
+    ERROR = "error",
+    CANCELLED = "cancelled"
+}
+/**
+ * Flow state data that can be passed between steps
+ */
+interface FlowState {
+    currentStep: FlowStep;
+    previousStep?: FlowStep;
+    user?: User;
+    session?: Session;
+    email?: string;
+    phone?: string;
+    username?: string;
+    mfaRequired?: boolean;
+    mfaMethods?: TwoFactorMethod[];
+    mfaToken?: string;
+    oauthProvider?: OAuthProvider;
+    oauthRedirectUrl?: string;
+    verificationRequired?: boolean;
+    verificationToken?: string;
+    verificationSent?: boolean;
+    error?: AuthError;
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Flow transition result
+ */
+interface FlowTransition {
+    nextStep: FlowStep;
+    state: Partial<FlowState>;
+}
+/**
+ * Flow configuration for a specific authentication journey
+ */
+interface FlowConfig {
+    name: string;
+    description?: string;
+    initialStep: FlowStep;
+    allowedSteps: FlowStep[];
+    transitions: {
+        [key in FlowStep]?: {
+            onSuccess?: FlowStep;
+            onError?: FlowStep;
+            onCancel?: FlowStep;
+            onBack?: FlowStep;
+            conditions?: Array<{
+                when: (state: FlowState) => boolean;
+                then: FlowStep;
+            }>;
+        };
+    };
+    onStepChange?: (step: FlowStep, state: FlowState) => void;
+    onComplete?: (user: User, session: Session) => void;
+    onError?: (error: AuthError, state: FlowState) => void;
+    onCancel?: (state: FlowState) => void;
+}
+/**
+ * Predefined flow configurations
+ */
+declare enum FlowConfigType {
+    SIMPLE_SIGN_IN = "simple_sign_in",
+    SIMPLE_SIGN_UP = "simple_sign_up",
+    SIGN_UP_WITH_EMAIL_VERIFICATION = "sign_up_with_email_verification",
+    SIGN_IN_WITH_MFA = "sign_in_with_mfa",
+    OAUTH_SIGN_IN = "oauth_sign_in",
+    MAGIC_LINK_FLOW = "magic_link_flow",
+    PHONE_AUTH_FLOW = "phone_auth_flow",
+    COMPLETE_SIGN_UP_FLOW = "complete_sign_up_flow",// signup → verify email → complete profile
+    SECURE_SIGN_IN_FLOW = "secure_sign_in_flow",// signin → MFA → success
+    PASSWORD_RESET_FLOW = "password_reset_flow",
+    CUSTOM = "custom"
+}
+/**
+ * Flow action types
+ */
+declare enum FlowAction {
+    START = "start",
+    NEXT = "next",
+    BACK = "back",
+    CANCEL = "cancel",
+    ERROR = "error",
+    RESET = "reset"
+}
+/**
+ * Flow event for state machine
+ */
+interface FlowEvent {
+    action: FlowAction;
+    data?: Partial<FlowState>;
+    error?: AuthError;
+}
+
+/**
+ * Authentication flow state machine engine
+ */
+
+/**
+ * Flow engine that manages authentication flow state transitions
+ */
+declare class FlowEngine {
+    private config;
+    private state;
+    private history;
+    constructor(config: FlowConfig, initialState?: Partial<FlowState>);
+    /**
+     * Get current flow state
+     */
+    getState(): FlowState;
+    /**
+     * Get current step
+     */
+    getCurrentStep(): FlowStep;
+    /**
+     * Check if step is allowed in this flow
+     */
+    isStepAllowed(step: FlowStep): boolean;
+    /**
+     * Transition to next step based on action
+     */
+    transition(event: FlowEvent): Promise<FlowState>;
+    /**
+     * Start or restart the flow
+     */
+    private handleStart;
+    /**
+     * Move to next step
+     */
+    private handleNext;
+    /**
+     * Go back to previous step
+     */
+    private handleBack;
+    /**
+     * Cancel the flow
+     */
+    private handleCancel;
+    /**
+     * Handle error in flow
+     */
+    private handleError;
+    /**
+     * Reset flow to initial state
+     */
+    private handleReset;
+    /**
+     * Move to a specific step
+     */
+    private moveToStep;
+    /**
+     * Get flow history
+     */
+    getHistory(): FlowStep[];
+    /**
+     * Check if can go back
+     */
+    canGoBack(): boolean;
+}
+
+/**
+ * Predefined flow configurations
+ */
+
+/**
+ * Simple sign-in flow (email/password only)
+ */
+declare const simpleSignInFlow: FlowConfig;
+/**
+ * Sign-in with MFA support
+ */
+declare const signInWithMFAFlow: FlowConfig;
+/**
+ * Complete sign-up flow with email verification
+ */
+declare const completeSignUpFlow: FlowConfig;
+/**
+ * Magic link authentication flow
+ */
+declare const magicLinkFlow: FlowConfig;
+/**
+ * Phone authentication flow
+ */
+declare const phoneAuthFlow: FlowConfig;
+/**
+ * OAuth sign-in flow
+ */
+declare const oauthSignInFlow: FlowConfig;
+/**
+ * Password reset flow
+ */
+declare const passwordResetFlow: FlowConfig;
+/**
+ * Get predefined flow configuration by type
+ */
+declare function getFlowConfig(type: FlowConfigType): FlowConfig;
+/**
+ * Export all predefined flows
+ */
+declare const predefinedFlows: {
+    simple_sign_in: FlowConfig;
+    sign_in_with_mfa: FlowConfig;
+    complete_sign_up_flow: FlowConfig;
+    magic_link_flow: FlowConfig;
+    phone_auth_flow: FlowConfig;
+    oauth_sign_in: FlowConfig;
+    password_reset_flow: FlowConfig;
+};
+
+export { AuthClient, type AuthClientConfig, AuthContext, AuthError, AuthErrorType, AuthProvider, FlowAction, type FlowConfig, FlowConfigType, FlowEngine, type FlowEvent, type FlowState, FlowStep, type FlowTransition, MagicLinkRequest, MagicLinkVerifyRequest, OAuthCallbackRequest, OAuthProvider, OAuthSignInRequest, Observable, Organization, OrganizationMembership, PasskeyAuthRequest, PasskeyCredential, PasskeyRegisterRequest, PasswordChangeRequest, PasswordResetConfirmRequest, PasswordResetRequest, PhoneAuthRequest, PhoneVerifyRequest, Session, SignInRequest, SignUpRequest, Storage, TokenManager, TwoFactorMethod, TwoFactorSetupRequest, TwoFactorSetupResponse, TwoFactorVerifyRequest, Unsubscribe, UpdateUserRequest, User, ValidationError, completeSignUpFlow, createAuthError, getFlowConfig, isAuthError, isMFARequiredError, isNetworkError, isUnauthenticatedError, magicLinkFlow, oauthSignInFlow, passwordResetFlow, phoneAuthFlow, predefinedFlows, signInWithMFAFlow, simpleSignInFlow, toAuthError, validate2FACode, validateEmail, validatePassword, validatePhone, validateRequired, validateUsername };