@tspvivek/baasix-sdk 0.1.0-alpha.1

package/dist/modules/auth.d.ts

@@ -0,0 +1,384 @@
+import { H as HttpClient, A as AuthMode, a as AuthStateEvent, U as User, R as RegisterData, b as AuthResponse, L as LoginCredentials, c as AuthTokens, M as MagicLinkOptions, P as PasswordResetOptions, T as Tenant, d as AuthState } from '../client-CzF9B60b.js';
+import { S as StorageAdapter } from '../types-BdjsGANq.js';
+
+type OAuthProvider = "google" | "facebook" | "apple" | "github";
+interface OAuthOptions {
+    provider: OAuthProvider;
+    redirectUrl: string;
+    scopes?: string[];
+    state?: string;
+}
+interface InviteOptions {
+    email: string;
+    roleId: string;
+    tenantId?: string;
+    redirectUrl: string;
+}
+interface VerifyInviteResult {
+    valid: boolean;
+    email?: string;
+    tenantId?: string;
+    roleId?: string;
+}
+interface AuthModuleConfig {
+    client: HttpClient;
+    storage: StorageAdapter;
+    authMode: AuthMode;
+    onAuthStateChange?: (event: AuthStateEvent, user: User | null) => void;
+}
+/**
+ * Authentication module for handling user authentication, sessions, and token management.
+ *
+ * @example
+ * ```typescript
+ * // Login
+ * const { user, token } = await baasix.auth.login({
+ *   email: 'user@example.com',
+ *   password: 'password123'
+ * });
+ *
+ * // Get current user
+ * const user = await baasix.auth.getUser();
+ *
+ * // Logout
+ * await baasix.auth.logout();
+ * ```
+ */
+declare class AuthModule {
+    private client;
+    private storage;
+    private authMode;
+    private onAuthStateChange?;
+    private currentUser;
+    constructor(config: AuthModuleConfig);
+    /**
+     * Emit an authentication state change event
+     */
+    private emitAuthStateChange;
+    /**
+     * Store authentication tokens
+     */
+    private storeTokens;
+    /**
+     * Clear stored authentication data
+     */
+    private clearAuth;
+    /**
+     * Register a new user
+     *
+     * @example
+     * ```typescript
+     * const { user, token } = await baasix.auth.register({
+     *   email: 'newuser@example.com',
+     *   password: 'securepassword',
+     *   firstName: 'John',
+     *   lastName: 'Doe'
+     * });
+     * ```
+     */
+    register(data: RegisterData): Promise<AuthResponse>;
+    /**
+     * Login with email and password
+     *
+     * @example
+     * ```typescript
+     * const { user, token } = await baasix.auth.login({
+     *   email: 'user@example.com',
+     *   password: 'password123'
+     * });
+     *
+     * // Login with tenant (multi-tenant mode)
+     * const result = await baasix.auth.login({
+     *   email: 'user@example.com',
+     *   password: 'password123',
+     *   tenantId: 'tenant-uuid'
+     * });
+     * ```
+     */
+    login(credentials: LoginCredentials): Promise<AuthResponse>;
+    /**
+     * Logout the current user
+     *
+     * @example
+     * ```typescript
+     * await baasix.auth.logout();
+     * ```
+     */
+    logout(): Promise<void>;
+    /**
+     * Get the current authenticated user from the server
+     *
+     * @example
+     * ```typescript
+     * const user = await baasix.auth.getUser();
+     * console.log(user?.email);
+     * ```
+     */
+    getUser(): Promise<User | null>;
+    /**
+     * Get the cached current user (does not make an API call)
+     *
+     * @example
+     * ```typescript
+     * const user = await baasix.auth.getCachedUser();
+     * ```
+     */
+    getCachedUser(): Promise<User | null>;
+    /**
+     * Check if user is authenticated (has valid token)
+     *
+     * @example
+     * ```typescript
+     * if (await baasix.auth.isAuthenticated()) {
+     *   // User is logged in
+     * }
+     * ```
+     */
+    isAuthenticated(): Promise<boolean>;
+    /**
+     * Get the current access token
+     *
+     * @example
+     * ```typescript
+     * const token = await baasix.auth.getToken();
+     * ```
+     */
+    getToken(): Promise<string | null>;
+    /**
+     * Set a static token (useful for server-side or service accounts)
+     *
+     * @example
+     * ```typescript
+     * baasix.auth.setToken('your-api-token');
+     * ```
+     */
+    setToken(token: string): Promise<void>;
+    /**
+     * Refresh the current token
+     *
+     * @example
+     * ```typescript
+     * const tokens = await baasix.auth.refreshToken();
+     * ```
+     */
+    refreshToken(): Promise<AuthTokens>;
+    /**
+     * Request a magic link for passwordless login
+     *
+     * @example
+     * ```typescript
+     * await baasix.auth.sendMagicLink({
+     *   email: 'user@example.com',
+     *   redirectUrl: 'https://myapp.com/auth/callback'
+     * });
+     * ```
+     */
+    sendMagicLink(options: MagicLinkOptions): Promise<void>;
+    /**
+     * Verify magic link/code and complete login
+     *
+     * @example
+     * ```typescript
+     * const { user, token } = await baasix.auth.verifyMagicLink('verification-token');
+     * ```
+     */
+    verifyMagicLink(token: string): Promise<AuthResponse>;
+    /**
+     * Request a password reset
+     *
+     * @example
+     * ```typescript
+     * await baasix.auth.forgotPassword({
+     *   email: 'user@example.com',
+     *   redirectUrl: 'https://myapp.com/reset-password'
+     * });
+     * ```
+     */
+    forgotPassword(options: PasswordResetOptions): Promise<void>;
+    /**
+     * Reset password using a reset token
+     *
+     * @example
+     * ```typescript
+     * await baasix.auth.resetPassword('reset-token', 'newpassword123');
+     * ```
+     */
+    resetPassword(token: string, newPassword: string): Promise<void>;
+    /**
+     * Change the current user's password
+     *
+     * @example
+     * ```typescript
+     * await baasix.auth.changePassword('currentPassword', 'newPassword');
+     * ```
+     */
+    changePassword(currentPassword: string, newPassword: string): Promise<void>;
+    /**
+     * Update the current user's profile
+     *
+     * @example
+     * ```typescript
+     * const updatedUser = await baasix.auth.updateProfile({
+     *   firstName: 'Jane',
+     *   lastName: 'Doe'
+     * });
+     * ```
+     */
+    updateProfile(data: Partial<User>): Promise<User>;
+    /**
+     * Get available tenants for the current user (multi-tenant mode)
+     *
+     * @example
+     * ```typescript
+     * const tenants = await baasix.auth.getTenants();
+     * ```
+     */
+    getTenants(): Promise<Tenant[]>;
+    /**
+     * Switch to a different tenant (multi-tenant mode)
+     *
+     * @example
+     * ```typescript
+     * const { user, token } = await baasix.auth.switchTenant('tenant-uuid');
+     * ```
+     */
+    switchTenant(tenantId: string): Promise<AuthResponse>;
+    /**
+     * Get the current authentication state
+     *
+     * @example
+     * ```typescript
+     * const state = await baasix.auth.getState();
+     * console.log(state.isAuthenticated, state.user);
+     * ```
+     */
+    getState(): Promise<AuthState>;
+    /**
+     * Initialize authentication state from storage
+     * Call this on app startup to restore previous session
+     *
+     * @example
+     * ```typescript
+     * await baasix.auth.initialize();
+     * ```
+     */
+    initialize(): Promise<AuthState>;
+    /**
+     * Get the OAuth authorization URL for a provider
+     * Redirect the user to this URL to start the OAuth flow
+     *
+     * @example
+     * ```typescript
+     * const url = baasix.auth.getOAuthUrl({
+     *   provider: 'google',
+     *   redirectUrl: 'https://myapp.com/auth/callback'
+     * });
+     * window.location.href = url;
+     * ```
+     */
+    getOAuthUrl(options: OAuthOptions): string;
+    /**
+     * Handle OAuth callback and complete login
+     * Call this from your callback page with the token from URL
+     *
+     * @example
+     * ```typescript
+     * // In your callback page
+     * const params = new URLSearchParams(window.location.search);
+     * const token = params.get('token');
+     *
+     * if (token) {
+     *   await baasix.auth.handleOAuthCallback(token);
+     * }
+     * ```
+     */
+    handleOAuthCallback(token: string): Promise<AuthResponse>;
+    /**
+     * Request email verification
+     * Sends a verification email to the current user
+     *
+     * @example
+     * ```typescript
+     * await baasix.auth.requestEmailVerification('https://myapp.com/verify-email');
+     * ```
+     */
+    requestEmailVerification(redirectUrl: string): Promise<void>;
+    /**
+     * Verify email with token
+     *
+     * @example
+     * ```typescript
+     * const params = new URLSearchParams(window.location.search);
+     * const token = params.get('token');
+     *
+     * await baasix.auth.verifyEmail(token);
+     * ```
+     */
+    verifyEmail(token: string): Promise<void>;
+    /**
+     * Check if current session/token is valid
+     *
+     * @example
+     * ```typescript
+     * const isValid = await baasix.auth.checkSession();
+     * ```
+     */
+    checkSession(): Promise<boolean>;
+    /**
+     * Send an invitation to a user (multi-tenant mode)
+     *
+     * @example
+     * ```typescript
+     * await baasix.auth.sendInvite({
+     *   email: 'newuser@example.com',
+     *   roleId: 'role-uuid',
+     *   tenantId: 'tenant-uuid',
+     *   redirectUrl: 'https://myapp.com/accept-invite'
+     * });
+     * ```
+     */
+    sendInvite(options: InviteOptions): Promise<void>;
+    /**
+     * Verify an invitation token
+     *
+     * @example
+     * ```typescript
+     * const params = new URLSearchParams(window.location.search);
+     * const token = params.get('token');
+     *
+     * const result = await baasix.auth.verifyInvite(token);
+     * if (result.valid) {
+     *   // Show registration form with pre-filled email
+     * }
+     * ```
+     */
+    verifyInvite(token: string, redirectUrl?: string): Promise<VerifyInviteResult>;
+    /**
+     * Accept an invitation (for existing users)
+     *
+     * @example
+     * ```typescript
+     * await baasix.auth.acceptInvite(token);
+     * ```
+     */
+    acceptInvite(token: string): Promise<AuthResponse>;
+    /**
+     * Register with an invitation token
+     *
+     * @example
+     * ```typescript
+     * const { user, token } = await baasix.auth.registerWithInvite({
+     *   email: 'user@example.com',
+     *   password: 'password',
+     *   firstName: 'John',
+     *   lastName: 'Doe',
+     *   inviteToken: 'invite-token'
+     * });
+     * ```
+     */
+    registerWithInvite(data: RegisterData & {
+        inviteToken: string;
+    }): Promise<AuthResponse>;
+}
+
+export { AuthModule, type AuthModuleConfig, AuthResponse, AuthState, AuthStateEvent, AuthTokens, type InviteOptions, LoginCredentials, MagicLinkOptions, type OAuthOptions, type OAuthProvider, PasswordResetOptions, RegisterData, Tenant, User, type VerifyInviteResult };