@nauth-toolkit/client 0.1.45 → 0.1.48

package/dist/angular/index.d.mts

@@ -1303,11 +1303,11 @@ declare class NAuthClient {
 }
 
 /**
- * Angular wrapper around NAuthClient that exposes Observables for auth state.
+ * Angular wrapper around NAuthClient that provides promise-based auth methods and reactive state.
  *
  * This service provides:
  * - Reactive state (currentUser$, isAuthenticated$, challenge$)
- * - All core auth methods as Observables (login, signup, logout, refresh)
+ * - All core auth methods as Promises (login, signup, logout, refresh)
  * - Profile management (getProfile, updateProfile, changePassword)
  * - Challenge flow methods (respondToChallenge, resendCode)
  * - MFA management (getMfaStatus, setupMfaDevice, etc.)
@@ -1323,15 +1323,15 @@ declare class NAuthClient {
  * this.auth.currentUser$.subscribe(user => ...);
  * this.auth.isAuthenticated$.subscribe(isAuth => ...);
  *
- * // Auth operations
- * this.auth.login(email, password).subscribe(response => ...);
+ * // Auth operations with async/await
+ * const response = await this.auth.login(email, password);
  *
  * // Profile management
- * this.auth.changePassword(oldPassword, newPassword).subscribe(() => ...);
- * this.auth.updateProfile({ firstName: 'John' }).subscribe(user => ...);
+ * await this.auth.changePassword(oldPassword, newPassword);
+ * const user = await this.auth.updateProfile({ firstName: 'John' });
  *
  * // MFA operations
- * this.auth.getMfaStatus().subscribe(status => ...);
+ * const status = await this.auth.getMfaStatus();
  * ```
  */
 declare class AuthService {
@@ -1390,16 +1390,49 @@ declare class AuthService {
     getCurrentChallenge(): AuthResponse | null;
     /**
      * Login with identifier and password.
+     *
+     * @param identifier - User email or username
+     * @param password - User password
+     * @returns Promise with auth response or challenge
+     *
+     * @example
+     * ```typescript
+     * const response = await this.auth.login('user@example.com', 'password');
+     * if (response.challengeName) {
+     *   // Handle challenge
+     * } else {
+     *   // Login successful
+     * }
+     * ```
      */
-    login(identifier: string, password: string): Observable<AuthResponse>;
+    login(identifier: string, password: string): Promise<AuthResponse>;
     /**
      * Signup with credentials.
+     *
+     * @param payload - Signup request payload
+     * @returns Promise with auth response or challenge
+     *
+     * @example
+     * ```typescript
+     * const response = await this.auth.signup({
+     *   email: 'new@example.com',
+     *   password: 'SecurePass123!',
+     *   firstName: 'John',
+     * });
+     * ```
      */
-    signup(payload: Parameters<NAuthClient['signup']>[0]): Observable<AuthResponse>;
+    signup(payload: Parameters<NAuthClient['signup']>[0]): Promise<AuthResponse>;
     /**
      * Logout current session.
+     *
+     * @param forgetDevice - If true, removes device trust
+     *
+     * @example
+     * ```typescript
+     * await this.auth.logout();
+     * ```
      */
-    logout(forgetDevice?: boolean): Observable<void>;
+    logout(forgetDevice?: boolean): Promise<void>;
     /**
      * Logout all sessions.
      *
@@ -1407,108 +1440,132 @@ declare class AuthService {
      * Optionally revokes all trusted devices if forgetDevices is true.
      *
      * @param forgetDevices - If true, also revokes all trusted devices (default: false)
-     * @returns Observable with number of sessions revoked
+     * @returns Promise with number of sessions revoked
+     *
+     * @example
+     * ```typescript
+     * const result = await this.auth.logoutAll();
+     * console.log(`Revoked ${result.revokedCount} sessions`);
+     * ```
      */
-    logoutAll(forgetDevices?: boolean): Observable<{
+    logoutAll(forgetDevices?: boolean): Promise<{
         revokedCount: number;
     }>;
     /**
      * Refresh tokens.
-     */
-    refresh(): Observable<TokenResponse>;
-    /**
-     * Refresh tokens (promise-based).
-     *
-     * Returns a promise instead of an Observable, matching the core NAuthClient API.
-     * Useful for async/await patterns in guards and interceptors.
      *
-     * @returns Promise of TokenResponse
+     * @returns Promise with new tokens
      *
      * @example
      * ```typescript
-     * const tokens = await auth.refreshTokensPromise();
+     * const tokens = await this.auth.refresh();
      * ```
      */
-    refreshTokensPromise(): Promise<TokenResponse>;
+    refresh(): Promise<TokenResponse>;
     /**
      * Request a password reset code (forgot password).
+     *
+     * @param identifier - User email, username, or phone
+     * @returns Promise with password reset response
+     *
+     * @example
+     * ```typescript
+     * await this.auth.forgotPassword('user@example.com');
+     * ```
      */
-    forgotPassword(identifier: string): Observable<ForgotPasswordResponse>;
+    forgotPassword(identifier: string): Promise<ForgotPasswordResponse>;
     /**
      * Confirm a password reset code and set a new password.
+     *
+     * @param identifier - User email, username, or phone
+     * @param code - One-time reset code
+     * @param newPassword - New password
+     * @returns Promise with confirmation response
+     *
+     * @example
+     * ```typescript
+     * await this.auth.confirmForgotPassword('user@example.com', '123456', 'NewPass123!');
+     * ```
      */
-    confirmForgotPassword(identifier: string, code: string, newPassword: string): Observable<ConfirmForgotPasswordResponse>;
+    confirmForgotPassword(identifier: string, code: string, newPassword: string): Promise<ConfirmForgotPasswordResponse>;
     /**
      * Change user password (requires current password).
      *
      * @param oldPassword - Current password
      * @param newPassword - New password (must meet requirements)
-     * @returns Observable that completes when password is changed
+     * @returns Promise that resolves when password is changed
      *
      * @example
      * ```typescript
-     * this.auth.changePassword('oldPassword123', 'newSecurePassword456!').subscribe({
-     *   next: () => console.log('Password changed successfully'),
-     *   error: (err) => console.error('Failed to change password:', err)
-     * });
+     * await this.auth.changePassword('oldPassword123', 'newSecurePassword456!');
      * ```
      */
-    changePassword(oldPassword: string, newPassword: string): Observable<void>;
+    changePassword(oldPassword: string, newPassword: string): Promise<void>;
     /**
      * Request password change (must change on next login).
      *
-     * @returns Observable that completes when request is sent
-     */
-    requestPasswordChange(): Observable<void>;
-    /**
-     * Get current user profile.
-     *
-     * @returns Observable of current user profile
+     * @returns Promise that resolves when request is sent
      *
      * @example
      * ```typescript
-     * this.auth.getProfile().subscribe(user => {
-     *   console.log('User profile:', user);
-     * });
+     * await this.auth.requestPasswordChange();
      * ```
      */
-    getProfile(): Observable<AuthUser>;
+    requestPasswordChange(): Promise<void>;
     /**
-     * Get current user profile (promise-based).
-     *
-     * Returns a promise instead of an Observable, matching the core NAuthClient API.
-     * Useful for async/await patterns in guards and interceptors.
+     * Get current user profile.
      *
      * @returns Promise of current user profile
      *
      * @example
      * ```typescript
-     * const user = await auth.getProfilePromise();
+     * const user = await this.auth.getProfile();
+     * console.log('User profile:', user);
      * ```
      */
-    getProfilePromise(): Promise<AuthUser>;
+    getProfile(): Promise<AuthUser>;
     /**
      * Update user profile.
      *
      * @param updates - Profile fields to update
-     * @returns Observable of updated user profile
+     * @returns Promise of updated user profile
      *
      * @example
      * ```typescript
-     * this.auth.updateProfile({ firstName: 'John', lastName: 'Doe' }).subscribe(user => {
-     *   console.log('Profile updated:', user);
-     * });
+     * const user = await this.auth.updateProfile({ firstName: 'John', lastName: 'Doe' });
+     * console.log('Profile updated:', user);
      * ```
      */
-    updateProfile(updates: UpdateProfileRequest): Observable<AuthUser>;
+    updateProfile(updates: UpdateProfileRequest): Promise<AuthUser>;
     /**
      * Respond to a challenge (VERIFY_EMAIL, VERIFY_PHONE, MFA_REQUIRED, etc.).
+     *
+     * @param response - Challenge response data
+     * @returns Promise with auth response or next challenge
+     *
+     * @example
+     * ```typescript
+     * const result = await this.auth.respondToChallenge({
+     *   session: challengeSession,
+     *   type: 'VERIFY_EMAIL',
+     *   code: '123456',
+     * });
+     * ```
      */
-    respondToChallenge(response: ChallengeResponse): Observable<AuthResponse>;
+    respondToChallenge(response: ChallengeResponse): Promise<AuthResponse>;
     /**
      * Resend challenge code.
+     *
+     * @param session - Challenge session token
+     * @returns Promise with destination information
+     *
+     * @example
+     * ```typescript
+     * const result = await this.auth.resendCode(session);
+     * console.log('Code sent to:', result.destination);
+     * ```
      */
-    resendCode(session: string): Observable<{
+    resendCode(session: string): Promise<{
         destination: string;
     }>;
     /**
@@ -1522,24 +1579,51 @@ declare class AuthService {
      *
      * @param session - Challenge session token
      * @param method - MFA method to set up
-     * @returns Observable of setup data response
+     * @returns Promise of setup data response
+     *
+     * @example
+     * ```typescript
+     * const setupData = await this.auth.getSetupData(session, 'totp');
+     * console.log('QR Code:', setupData.setupData.qrCode);
+     * ```
      */
-    getSetupData(session: string, method: string): Observable<GetSetupDataResponse>;
+    getSetupData(session: string, method: string): Promise<GetSetupDataResponse>;
     /**
      * Get MFA challenge data (for MFA_REQUIRED challenge - e.g., passkey options).
      *
      * @param session - Challenge session token
      * @param method - Challenge method
-     * @returns Observable of challenge data response
+     * @returns Promise of challenge data response
+     *
+     * @example
+     * ```typescript
+     * const challengeData = await this.auth.getChallengeData(session, 'passkey');
+     * ```
      */
-    getChallengeData(session: string, method: string): Observable<GetChallengeDataResponse>;
+    getChallengeData(session: string, method: string): Promise<GetChallengeDataResponse>;
     /**
      * Clear stored challenge (when navigating away from challenge flow).
+     *
+     * @returns Promise that resolves when challenge is cleared
+     *
+     * @example
+     * ```typescript
+     * await this.auth.clearChallenge();
+     * ```
      */
-    clearChallenge(): Observable<void>;
+    clearChallenge(): Promise<void>;
     /**
      * Initiate social OAuth login flow.
      * Redirects the browser to backend `/auth/social/:provider/redirect`.
+     *
+     * @param provider - Social provider ('google', 'apple', 'facebook')
+     * @param options - Optional redirect options
+     * @returns Promise that resolves when redirect starts
+     *
+     * @example
+     * ```typescript
+     * await this.auth.loginWithSocial('google', { returnTo: '/auth/callback' });
+     * ```
      */
     loginWithSocial(provider: SocialProvider, options?: SocialLoginOptions): Promise<void>;
     /**
@@ -1549,153 +1633,226 @@ declare class AuthService {
      * with `exchangeToken` instead of setting cookies.
      *
      * @param exchangeToken - One-time exchange token from the callback URL
-     * @returns Observable of AuthResponse
-     */
-    exchangeSocialRedirect(exchangeToken: string): Observable<AuthResponse>;
-    /**
-     * Exchange an exchangeToken (from redirect callback URL) into an AuthResponse (promise-based).
-     *
-     * Returns a promise instead of an Observable, matching the core NAuthClient API.
-     * Useful for async/await patterns in guards and interceptors.
-     *
-     * @param exchangeToken - One-time exchange token from the callback URL
      * @returns Promise of AuthResponse
      *
      * @example
      * ```typescript
-     * const response = await auth.exchangeSocialRedirectPromise(exchangeToken);
+     * const response = await this.auth.exchangeSocialRedirect(exchangeToken);
      * ```
      */
-    exchangeSocialRedirectPromise(exchangeToken: string): Promise<AuthResponse>;
+    exchangeSocialRedirect(exchangeToken: string): Promise<AuthResponse>;
     /**
      * Verify native social token (mobile).
      *
      * @param request - Social verification request with provider and token
-     * @returns Observable of AuthResponse
+     * @returns Promise of AuthResponse
+     *
+     * @example
+     * ```typescript
+     * const result = await this.auth.verifyNativeSocial({
+     *   provider: 'google',
+     *   idToken: nativeIdToken,
+     * });
+     * ```
      */
-    verifyNativeSocial(request: SocialVerifyRequest): Observable<AuthResponse>;
+    verifyNativeSocial(request: SocialVerifyRequest): Promise<AuthResponse>;
     /**
      * Get linked social accounts.
      *
-     * @returns Observable of linked accounts response
+     * @returns Promise of linked accounts response
+     *
+     * @example
+     * ```typescript
+     * const accounts = await this.auth.getLinkedAccounts();
+     * console.log('Linked providers:', accounts.providers);
+     * ```
      */
-    getLinkedAccounts(): Observable<LinkedAccountsResponse>;
+    getLinkedAccounts(): Promise<LinkedAccountsResponse>;
     /**
      * Link social account.
      *
      * @param provider - Social provider to link
      * @param code - OAuth authorization code
      * @param state - OAuth state parameter
-     * @returns Observable with success message
+     * @returns Promise with success message
+     *
+     * @example
+     * ```typescript
+     * await this.auth.linkSocialAccount('google', code, state);
+     * ```
      */
-    linkSocialAccount(provider: string, code: string, state: string): Observable<{
+    linkSocialAccount(provider: string, code: string, state: string): Promise<{
         message: string;
     }>;
     /**
      * Unlink social account.
      *
      * @param provider - Social provider to unlink
-     * @returns Observable with success message
+     * @returns Promise with success message
+     *
+     * @example
+     * ```typescript
+     * await this.auth.unlinkSocialAccount('google');
+     * ```
      */
-    unlinkSocialAccount(provider: string): Observable<{
+    unlinkSocialAccount(provider: string): Promise<{
         message: string;
     }>;
     /**
      * Get MFA status for the current user.
      *
-     * @returns Observable of MFA status
+     * @returns Promise of MFA status
+     *
+     * @example
+     * ```typescript
+     * const status = await this.auth.getMfaStatus();
+     * console.log('MFA enabled:', status.enabled);
+     * ```
      */
-    getMfaStatus(): Observable<MFAStatus>;
+    getMfaStatus(): Promise<MFAStatus>;
     /**
      * Get MFA devices for the current user.
      *
-     * @returns Observable of MFA devices array
+     * @returns Promise of MFA devices array
+     *
+     * @example
+     * ```typescript
+     * const devices = await this.auth.getMfaDevices();
+     * ```
      */
-    getMfaDevices(): Observable<MFADevice[]>;
+    getMfaDevices(): Promise<MFADevice[]>;
     /**
      * Setup MFA device (authenticated user).
      *
      * @param method - MFA method to set up
-     * @returns Observable of setup data
+     * @returns Promise of setup data
+     *
+     * @example
+     * ```typescript
+     * const setupData = await this.auth.setupMfaDevice('totp');
+     * ```
      */
-    setupMfaDevice(method: string): Observable<unknown>;
+    setupMfaDevice(method: string): Promise<unknown>;
     /**
      * Verify MFA setup (authenticated user).
      *
      * @param method - MFA method
      * @param setupData - Setup data from setupMfaDevice
      * @param deviceName - Optional device name
-     * @returns Observable with device ID
+     * @returns Promise with device ID
+     *
+     * @example
+     * ```typescript
+     * const result = await this.auth.verifyMfaSetup('totp', { code: '123456' }, 'My Phone');
+     * ```
      */
-    verifyMfaSetup(method: string, setupData: Record<string, unknown>, deviceName?: string): Observable<{
+    verifyMfaSetup(method: string, setupData: Record<string, unknown>, deviceName?: string): Promise<{
         deviceId: number;
     }>;
     /**
      * Remove MFA device.
      *
      * @param method - MFA method to remove
-     * @returns Observable with success message
+     * @returns Promise with success message
+     *
+     * @example
+     * ```typescript
+     * await this.auth.removeMfaDevice('sms');
+     * ```
      */
-    removeMfaDevice(method: string): Observable<{
+    removeMfaDevice(method: string): Promise<{
         message: string;
     }>;
     /**
      * Set preferred MFA method.
      *
      * @param method - Device method to set as preferred ('totp', 'sms', 'email', or 'passkey')
-     * @returns Observable with success message
+     * @returns Promise with success message
+     *
+     * @example
+     * ```typescript
+     * await this.auth.setPreferredMfaMethod('totp');
+     * ```
      */
-    setPreferredMfaMethod(method: 'totp' | 'sms' | 'email' | 'passkey'): Observable<{
+    setPreferredMfaMethod(method: 'totp' | 'sms' | 'email' | 'passkey'): Promise<{
         message: string;
     }>;
     /**
      * Generate backup codes.
      *
-     * @returns Observable of backup codes array
+     * @returns Promise of backup codes array
+     *
+     * @example
+     * ```typescript
+     * const codes = await this.auth.generateBackupCodes();
+     * console.log('Backup codes:', codes);
+     * ```
      */
-    generateBackupCodes(): Observable<string[]>;
+    generateBackupCodes(): Promise<string[]>;
     /**
      * Set MFA exemption (admin/test scenarios).
      *
      * @param exempt - Whether to exempt user from MFA
      * @param reason - Optional reason for exemption
-     * @returns Observable that completes when exemption is set
+     * @returns Promise that resolves when exemption is set
+     *
+     * @example
+     * ```typescript
+     * await this.auth.setMfaExemption(true, 'Test account');
+     * ```
      */
-    setMfaExemption(exempt: boolean, reason?: string): Observable<void>;
+    setMfaExemption(exempt: boolean, reason?: string): Promise<void>;
     /**
      * Trust current device.
      *
-     * @returns Observable with device token
+     * @returns Promise with device token
+     *
+     * @example
+     * ```typescript
+     * const result = await this.auth.trustDevice();
+     * console.log('Device trusted:', result.deviceToken);
+     * ```
      */
-    trustDevice(): Observable<{
+    trustDevice(): Promise<{
         deviceToken: string;
     }>;
     /**
      * Check if the current device is trusted.
      *
-     * @returns Observable with trusted status
+     * @returns Promise with trusted status
+     *
+     * @example
+     * ```typescript
+     * const result = await this.auth.isTrustedDevice();
+     * if (result.trusted) {
+     *   console.log('This device is trusted');
+     * }
+     * ```
      */
-    isTrustedDevice(): Observable<{
+    isTrustedDevice(): Promise<{
         trusted: boolean;
     }>;
     /**
      * Get paginated audit history for the current user.
      *
      * @param params - Query parameters for filtering and pagination
-     * @returns Observable of audit history response
+     * @returns Promise of audit history response
      *
      * @example
      * ```typescript
-     * this.auth.getAuditHistory({ page: 1, limit: 20, eventType: 'LOGIN_SUCCESS' }).subscribe(history => {
-     *   console.log('Audit history:', history);
+     * const history = await this.auth.getAuditHistory({
+     *   page: 1,
+     *   limit: 20,
+     *   eventType: 'LOGIN_SUCCESS'
      * });
+     * console.log('Audit history:', history);
      * ```
      */
-    getAuditHistory(params?: Record<string, string | number | boolean>): Observable<AuditHistoryResponse>;
+    getAuditHistory(params?: Record<string, string | number | boolean>): Promise<AuditHistoryResponse>;
     /**
      * Expose underlying NAuthClient for advanced scenarios.
      *
-     * @deprecated All core functionality is now exposed directly on AuthService as Observables.
+     * @deprecated All core functionality is now exposed directly on AuthService as Promises.
      * Use the direct methods on AuthService instead (e.g., `auth.changePassword()` instead of `auth.getClient().changePassword()`).
      * This method is kept for backward compatibility only and may be removed in a future version.
      *
@@ -1706,8 +1863,8 @@ declare class AuthService {
      * // Deprecated - use direct methods instead
      * const status = await this.auth.getClient().getMfaStatus();
      *
-     * // Preferred - use Observable-based methods
-     * this.auth.getMfaStatus().subscribe(status => ...);
+     * // Preferred - use direct methods
+     * const status = await this.auth.getMfaStatus();
      * ```
      */
     getClient(): NAuthClient;