@forge-connect/react 0.1.0 → 1.0.1

package/dist/index.d.ts

@@ -2,25 +2,70 @@ import * as react_jsx_runtime from 'react/jsx-runtime';
 import * as react from 'react';
 import { ReactNode } from 'react';
 
-type OAuthProvider = 'google' | 'discord' | 'twitter' | 'apple';
+type OAuthProvider = 'google' | 'discord' | 'twitter' | 'apple' | 'telegram';
 type Chain = 'solana' | 'ethereum';
+/** A login method entry for the method selector. OAuth providers are individual entries. */
+type LoginMethod = 'email' | 'otp' | 'wallet' | 'passkey' | OAuthProvider;
+/** Wallet display preferences for the wallet connect step. */
+interface WalletConfig {
+    /** Wallet adapter names shown first (e.g. ['Phantom', 'Solflare']). */
+    preferredWallets?: string[];
+    /** If true, only show wallets listed in preferredWallets. Default: false. */
+    onlyPreferred?: boolean;
+}
 interface ForgeConnectConfig {
     /** Base URL of the ForgeConnect API */
     apiUrl: string;
-    /** OAuth providers to enable */
+    /**
+     * Ordered array of login methods. Controls what shows in the method
+     * selector and in what order. Each OAuth provider is a separate entry.
+     *
+     * @example ['google', 'discord', 'email', 'wallet']
+     *
+     * When set, this is the single source of truth. Legacy fields
+     * (oauthProviders, walletLogin, passwordlessLogin) are ignored.
+     */
+    loginMethods?: LoginMethod[];
+    /**
+     * Skip the method selector and go directly to this login step.
+     * Must be present in loginMethods (or enabled via legacy fields).
+     *
+     * @example 'wallet'  // opens directly to wallet connect
+     */
+    defaultLoginMethod?: LoginMethod;
+    /** Wallet display preferences */
+    walletConfig?: WalletConfig;
+    /**
+     * WebAuthn Relying Party ID for passkeys. Must match the frontend domain
+     * (e.g. 'forgeconnect.dev'). Defaults to the server's WEBAUTHN_RP_ID env var.
+     */
+    webauthnRpId?: string;
+    /**
+     * WebAuthn origin for passkeys. Must match the frontend URL with protocol
+     * (e.g. 'https://forgeconnect.dev'). Defaults to the server's WEBAUTHN_ORIGIN env var.
+     */
+    webauthnOrigin?: string;
+    /** @deprecated Use loginMethods instead. */
     oauthProviders?: OAuthProvider[];
-    /** Enable wallet login */
+    /** @deprecated Use loginMethods instead. */
     walletLogin?: boolean;
-    /** Enable passwordless (OTP) login */
+    /** @deprecated Use loginMethods instead. */
     passwordlessLogin?: boolean;
     /** Appearance customization */
     appearance?: AppearanceConfig;
 }
 interface AppearanceConfig {
-    theme?: 'light' | 'dark';
+    theme?: 'light' | 'dark' | 'glass';
     accentColor?: string;
+    /** URL or imported image source for the modal logo. */
     logo?: string;
+    /** ReactNode logo — pass a React component (SVG, etc.) instead of a URL. */
+    logoNode?: unknown;
     title?: string;
+    /** URL to your Terms of Service page. Shown at the bottom of the modal. */
+    termsUrl?: string;
+    /** URL to your Privacy Policy page. Shown at the bottom of the modal. */
+    privacyUrl?: string;
 }
 interface User {
     id: string;
@@ -31,11 +76,12 @@ interface User {
     createdAt: string;
     updatedAt: string;
 }
-type AuthProvider = 'email' | 'google' | 'twitter' | 'discord' | 'apple' | 'solana_wallet' | 'ethereum_wallet';
+type AuthProvider = 'email' | 'google' | 'twitter' | 'discord' | 'apple' | 'telegram' | 'solana_wallet' | 'ethereum_wallet';
 interface AuthMethod {
     id: string;
     provider: AuthProvider;
     providerId: string;
+    providerUsername: string | null;
     isVerified: boolean;
     verifiedAt: string | null;
     createdAt: string;
@@ -64,36 +110,109 @@ interface AuthState {
     user: User | null;
     accessToken: string | null;
 }
-type ModalStep = 'method-select' | 'email-login' | 'email-register' | 'email-otp' | 'wallet-connect' | 'oauth';
+type ModalStep = 'method-select' | 'email-login' | 'email-register' | 'email-otp' | 'wallet-connect' | 'oauth' | 'forgot-password' | 'verify-2fa' | 'success' | 'error';
 interface ModalState {
     isOpen: boolean;
     step: ModalStep;
 }
-
-interface ForgeConnectProviderProps {
-    config: ForgeConnectConfig;
-    children: ReactNode;
-    /** Called when user successfully authenticates */
-    onLogin?: (user: User) => void;
-    /** Called when user logs out */
-    onLogout?: () => void;
-}
-declare function ForgeConnectProvider({ config, children, onLogin, onLogout }: ForgeConnectProviderProps): react_jsx_runtime.JSX.Element;
-
-interface LoginButtonProps {
-    className?: string;
-    label?: string;
+type AccountModalTab = 'profile' | 'auth-methods' | 'wallets' | 'sessions';
+interface AccountModalState {
+    isOpen: boolean;
 }
-declare function LoginButton({ className, label }: LoginButtonProps): react_jsx_runtime.JSX.Element;
-
-declare function LoginModal(): react_jsx_runtime.JSX.Element;
-
-interface ModalOverlayProps {
+interface LinkModalState {
     isOpen: boolean;
-    onClose: () => void;
-    children: ReactNode;
+    /** 'auth' shows only social/email methods, 'wallet' jumps straight to wallet connect. Default: 'auth'. */
+    mode?: 'auth' | 'wallet';
+}
+interface TotpSetup {
+    secret: string;
+    qrCodeDataUrl: string;
+    recoveryCodes: string[];
+}
+interface Passkey {
+    id: string;
+    credentialId: string;
+    name: string | null;
+    deviceType: string | null;
+    backedUp: boolean;
+    createdAt: string;
+    lastUsedAt: string | null;
+}
+interface TwoFactorStatus {
+    enabled: boolean;
+    hasPasskeys: boolean;
+}
+interface LoginResponse {
+    accessToken: string;
+    requires2FA?: boolean;
+    challengeToken?: string;
+    user?: {
+        id: string;
+        displayName?: string | null;
+        email?: string;
+    };
+}
+interface Role {
+    id: string;
+    name: string;
+    description: string | null;
+    permissions: string[];
+    isSystem: boolean;
+    tenantId: string | null;
+    createdBy: string | null;
+    createdAt: string;
+    userCount?: number;
+}
+interface UserRoleAssignment {
+    roleId: string;
+    roleName: string;
+    permissions: string[];
+    isSystem: boolean;
+    tenantId: string | null;
+}
+type PermissionDomains = Record<string, string[]>;
+/** A user assigned to a role, including their auth methods. */
+interface RoleUser {
+    id: string;
+    displayName: string | null;
+    primaryEmail: string | null;
+    avatarUrl: string | null;
+    status: string;
+    createdAt: string;
+    authMethods: {
+        provider: string;
+        providerId: string;
+        providerUsername: string | null;
+        isVerified: boolean | null;
+    }[];
+    grantedAt: string | null;
+}
+type UserStatus = 'active' | 'suspended' | 'deleted';
+interface PaginatedResponse<T> {
+    data: T[];
+    page: number;
+    limit: number;
+    total: number;
+}
+interface AdminUser extends User {
+    authMethods: AuthMethod[];
+    wallets: Wallet[];
+}
+interface TokenVerificationResult {
+    active: boolean;
+    user_id?: string;
+    tenant_id?: string;
+    scopes?: string[];
+    role?: string;
+    permissions?: string[];
+    roles?: {
+        name: string;
+        permissions: string[];
+    }[];
+}
+interface WalletUserResult {
+    user_id: string;
 }
-declare function ModalOverlay({ isOpen, onClose, children }: ModalOverlayProps): react.ReactPortal | null;
 
 declare class ForgeConnectApiError extends Error {
     readonly status: number;
@@ -105,8 +224,10 @@ declare function createApiClient(apiUrl: string): {
         success: true;
     }>;
     login(email: string, password: string): Promise<{
-        accessToken: string;
-        user: {
+        accessToken?: string;
+        requires2FA?: boolean;
+        challengeToken?: string;
+        user?: {
             id: string;
             displayName: string | null;
             email: string;
@@ -116,18 +237,40 @@ declare function createApiClient(apiUrl: string): {
         success: true;
     }>;
     verifyOtp(email: string, code: string): Promise<{
-        accessToken: string;
-        user: {
+        accessToken?: string;
+        requires2FA?: boolean;
+        challengeToken?: string;
+        user?: {
             id: string;
             email: string;
         };
     }>;
     walletChallenge(walletAddress: string, chain?: string): Promise<{
         challengeId: string;
-        nonce: string;
+        message: string;
     }>;
     walletVerify(challengeId: string, signature: string, walletAddress: string): Promise<{
-        accessToken: string;
+        accessToken?: string;
+        requires2FA?: boolean;
+        challengeToken?: string;
+    }>;
+    walletChallengeTx(walletAddress: string, chain?: string): Promise<{
+        challengeId: string;
+        transaction: string;
+    }>;
+    walletVerifyTx(challengeId: string, signedTransaction: string, walletAddress: string): Promise<{
+        accessToken?: string;
+        requires2FA?: boolean;
+        challengeToken?: string;
+    }>;
+    exchangeOAuthCode(code: string): Promise<{
+        accessToken?: string;
+        requires2FA?: boolean;
+        challengeToken?: string;
+        userId?: string;
+    }>;
+    createLinkIntent(token: string): Promise<{
+        intentToken: string;
     }>;
     refresh(): Promise<{
         accessToken: string;
@@ -159,10 +302,14 @@ declare function createApiClient(apiUrl: string): {
         createdAt: string;
         updatedAt: string;
     }>;
+    setPassword(token: string, newPassword: string, currentPassword?: string): Promise<{
+        success: true;
+    }>;
     getAuthMethods(token: string): Promise<{
         id: string;
         provider: string;
         providerId: string;
+        providerUsername: string | null;
         isVerified: boolean;
         verifiedAt: string | null;
         createdAt: string;
@@ -177,6 +324,12 @@ declare function createApiClient(apiUrl: string): {
     }): Promise<{
         success: true;
     }>;
+    linkOtpSend(token: string, email: string): Promise<{
+        success: true;
+    }>;
+    linkOtpVerify(token: string, email: string, code: string): Promise<{
+        success: true;
+    }>;
     unlinkAuthMethod(token: string, id: string): Promise<{
         success: true;
     }>;
@@ -214,6 +367,107 @@ declare function createApiClient(apiUrl: string): {
     revokeSession(token: string, id: string): Promise<{
         success: true;
     }>;
+    verifyEmailToken(token: string): Promise<{
+        accessToken?: string;
+        requires2FA?: boolean;
+        challengeToken?: string;
+    }>;
+    forgotPassword(email: string): Promise<{
+        success: true;
+    }>;
+    resetPassword(token: string, password: string): Promise<{
+        success: true;
+    }>;
+    get2FAStatus(token: string): Promise<{
+        enabled: boolean;
+    }>;
+    setup2FA(token: string): Promise<TotpSetup>;
+    enable2FA(token: string, code: string): Promise<{
+        success: true;
+    }>;
+    disable2FA(token: string, code: string): Promise<{
+        success: true;
+    }>;
+    verify2FA(challengeToken: string, code: string): Promise<{
+        accessToken: string;
+    }>;
+    verifyRecoveryCode(challengeToken: string, code: string): Promise<{
+        accessToken: string;
+    }>;
+    regenerateRecoveryCodes(token: string, code: string): Promise<{
+        recoveryCodes: string[];
+    }>;
+    getPasskeys(token: string): Promise<Passkey[]>;
+    getPasskeyRegisterOptions(token: string, rpId?: string, origin?: string): Promise<{
+        options: any;
+        challengeKey: string;
+    }>;
+    verifyPasskeyRegistration(token: string, challengeKey: string, response: any, name?: string, rpId?: string, origin?: string): Promise<Passkey>;
+    getPasskeyLoginOptions(rpId?: string): Promise<{
+        options: any;
+        challengeKey: string;
+    }>;
+    verifyPasskeyLogin(challengeKey: string, response: any, rpId?: string, origin?: string): Promise<{
+        accessToken: string;
+    }>;
+    renamePasskey(token: string, id: string, name: string): Promise<Passkey>;
+    deletePasskey(token: string, id: string): Promise<{
+        success: true;
+    }>;
+    requestAccountDeletion(token: string): Promise<{
+        requiresVerification: boolean;
+    }>;
+    confirmAccountDeletion(token: string, code?: string): Promise<{
+        success: true;
+    }>;
+    adminListUsers(token: string, params?: {
+        page?: number;
+        limit?: number;
+        search?: string;
+    }): Promise<PaginatedResponse<User>>;
+    adminGetUser(token: string, id: string): Promise<AdminUser>;
+    adminUpdateUserStatus(token: string, id: string, status: UserStatus): Promise<{
+        success: true;
+    }>;
+    adminGetUserSessions(token: string, id: string): Promise<Session[]>;
+    adminRevokeUserSessions(token: string, id: string): Promise<{
+        success: true;
+    }>;
+    adminListRoles(token: string, tenantId?: string): Promise<{
+        data: Role[];
+    }>;
+    adminGetRole(token: string, id: string): Promise<Role>;
+    adminGetRoleUsers(token: string, id: string): Promise<{
+        data: RoleUser[];
+    }>;
+    adminCreateRole(token: string, data: {
+        name: string;
+        description?: string;
+        permissions: string[];
+        tenantId?: string;
+    }): Promise<Role>;
+    adminUpdateRole(token: string, id: string, data: {
+        name?: string;
+        description?: string;
+        permissions?: string[];
+    }): Promise<Role>;
+    adminDeleteRole(token: string, id: string): Promise<{
+        success: true;
+    }>;
+    adminGetPermissions(token: string): Promise<{
+        domains: PermissionDomains;
+    }>;
+    adminGetUserRoles(token: string, userId: string, tenantId?: string): Promise<{
+        data: UserRoleAssignment[];
+    }>;
+    adminAssignRole(token: string, userId: string, roleId: string, tenantId?: string): Promise<{
+        success: true;
+    }>;
+    adminRevokeRole(token: string, userId: string, roleId: string, tenantId?: string): Promise<{
+        success: true;
+    }>;
+    serviceVerifyToken(serviceKey: string, accessToken: string, tenantId?: string): Promise<TokenVerificationResult>;
+    serviceUserByWallet(serviceKey: string, walletAddress: string, chain?: string): Promise<WalletUserResult>;
 };
 type ApiClient = ReturnType<typeof createApiClient>;
 
@@ -226,17 +480,116 @@ interface ForgeConnectContextValue {
     register: (email: string, password: string, displayName?: string) => Promise<void>;
     sendOtp: (email: string) => Promise<void>;
     verifyOtp: (email: string, code: string) => Promise<void>;
-    loginWithWallet: (walletAddress: string, signMessage: (message: Uint8Array) => Promise<Uint8Array>, chain?: string) => Promise<void>;
+    loginWithWallet: (walletAddress: string, signMessage: ((message: Uint8Array) => Promise<Uint8Array>) | undefined, chain?: string, signTransaction?: (txBase64: string) => Promise<string>) => Promise<void>;
     loginWithOAuth: (provider: string) => void;
+    loginWithPasskey: () => Promise<void>;
     logout: () => Promise<void>;
     logoutAll: () => Promise<void>;
+    forgotPassword: (email: string) => Promise<void>;
+    resetPassword: (token: string, password: string) => Promise<void>;
+    verifyEmailToken: (token: string) => Promise<void>;
+    challengeToken: string | null;
+    verify2FA: (code: string) => Promise<void>;
+    verifyRecoveryCode: (code: string) => Promise<void>;
     openModal: () => void;
     closeModal: () => void;
     setModalStep: (step: ModalState['step']) => void;
+    accountModal: AccountModalState;
+    openAccountModal: () => void;
+    closeAccountModal: () => void;
+    linkModal: LinkModalState;
+    openLinkModal: (mode?: 'auth' | 'wallet') => void;
+    closeLinkModal: () => void;
     getAccessToken: () => string | null;
+    walletAdapter: WalletAdapterContext | null;
+}
+interface WalletAdapterContext {
+    publicKey: {
+        toBase58(): string;
+    } | null;
+    signMessage: ((message: Uint8Array) => Promise<Uint8Array>) | undefined;
+    signTransaction: ((transaction: any) => Promise<any>) | undefined;
+    wallets: Array<{
+        adapter: {
+            name: string;
+            icon: string;
+            connected: boolean;
+        };
+        readyState: string;
+    }>;
+    select: (name: string) => void;
+    connect: () => Promise<void>;
 }
 declare const ForgeConnectContext: react.Context<ForgeConnectContextValue | null>;
 
+interface ForgeConnectProviderProps {
+    config: ForgeConnectConfig;
+    children: ReactNode;
+    /** Called when user successfully authenticates */
+    onLogin?: (user: User) => void;
+    /** Called when user logs out */
+    onLogout?: () => void;
+    /** Pass `useWallet()` from @solana/wallet-adapter-react to enable wallet login */
+    walletAdapter?: WalletAdapterContext | null;
+}
+declare function ForgeConnectProvider({ config, children, onLogin, onLogout, walletAdapter }: ForgeConnectProviderProps): react_jsx_runtime.JSX.Element;
+
+interface LoginButtonProps {
+    className?: string;
+    label?: string;
+}
+declare function LoginButton({ className, label }: LoginButtonProps): react_jsx_runtime.JSX.Element;
+
+declare function LoginModal(): react_jsx_runtime.JSX.Element;
+
+declare function AccountModal(): react_jsx_runtime.JSX.Element | null;
+
+declare function LinkAuthModal(): react_jsx_runtime.JSX.Element | null;
+
+interface AccountButtonProps {
+    className?: string;
+    loginLabel?: string;
+    compact?: boolean;
+}
+declare function AccountButton({ className, loginLabel, compact }: AccountButtonProps): react_jsx_runtime.JSX.Element;
+
+interface TwoFactorModalProps {
+    isOpen: boolean;
+    onClose: () => void;
+    initialEnabled: boolean;
+    onStatusChange: (enabled: boolean) => void;
+}
+declare function TwoFactorModal({ isOpen, onClose, initialEnabled, onStatusChange }: TwoFactorModalProps): react_jsx_runtime.JSX.Element | null;
+
+interface PasskeysModalProps {
+    isOpen: boolean;
+    onClose: () => void;
+    onCountChange: (count: number) => void;
+}
+declare function PasskeysModal({ isOpen, onClose, onCountChange }: PasskeysModalProps): react_jsx_runtime.JSX.Element | null;
+
+interface DeleteAccountModalProps {
+    isOpen: boolean;
+    onClose: () => void;
+    onDeleted: () => void;
+}
+declare function DeleteAccountModal({ isOpen, onClose, onDeleted }: DeleteAccountModalProps): react_jsx_runtime.JSX.Element | null;
+
+interface ModalOverlayProps {
+    isOpen: boolean;
+    onClose: () => void;
+    children: ReactNode;
+}
+declare function ModalOverlay({ isOpen, onClose, children }: ModalOverlayProps): react.ReactPortal | null;
+
+interface ErrorViewProps {
+    title?: string;
+    message?: string;
+    onRetry?: () => void;
+    onClose?: () => void;
+}
+declare function ErrorView({ title, message, onRetry, onClose, }: ErrorViewProps): react_jsx_runtime.JSX.Element;
+
 declare function useForgeConnect(): ForgeConnectContextValue;
 
 declare function useUser(): {
@@ -259,6 +612,7 @@ declare function useUser(): {
         id: string;
         provider: string;
         providerId: string;
+        providerUsername: string | null;
         isVerified: boolean;
         verifiedAt: string | null;
         createdAt: string;
@@ -271,7 +625,10 @@ declare function useUser(): {
         signature?: string;
         walletAddress?: string;
     }) => Promise<void>;
+    linkOtpSend: (email: string) => Promise<void>;
+    linkOtpVerify: (email: string, code: string) => Promise<void>;
     unlinkAuthMethod: (id: string) => Promise<void>;
+    linkOAuth: (provider: string) => Promise<void>;
 };
 
 declare function useWallets(): {
@@ -291,6 +648,7 @@ declare function useWallets(): {
         label?: string;
         isPrimary?: boolean;
     }) => Promise<void>;
+    linkWallet: (walletAddress: string, signMessage: (message: Uint8Array) => Promise<Uint8Array>, chain?: string) => Promise<void>;
 };
 
 declare function useSessions(): {
@@ -307,4 +665,68 @@ declare function useSessions(): {
     revokeSession: (id: string) => Promise<void>;
 };
 
-export { type ApiClient, type AppearanceConfig, type AuthMethod, type AuthProvider, type AuthState, type AuthStatus, type Chain, ForgeConnectApiError, type ForgeConnectConfig, ForgeConnectContext, type ForgeConnectContextValue, ForgeConnectProvider, LoginButton, LoginModal, ModalOverlay, type ModalState, type ModalStep, type OAuthProvider, type Session, type User, type Wallet, createApiClient, useForgeConnect, useSessions, useUser, useWallets };
+declare function useAdmin(): {
+    users: PaginatedResponse<User> | null;
+    selectedUser: AdminUser | null;
+    userSessions: Session[] | null;
+    loading: boolean;
+    listUsers: (params?: {
+        page?: number;
+        limit?: number;
+        search?: string;
+    }) => Promise<PaginatedResponse<User>>;
+    getUser: (id: string) => Promise<AdminUser>;
+    updateUserStatus: (id: string, status: UserStatus) => Promise<void>;
+    getUserSessions: (id: string) => Promise<Session[]>;
+    revokeUserSessions: (id: string) => Promise<void>;
+};
+
+declare function useRoles(): {
+    roles: Role[] | null;
+    selectedRole: Role | null;
+    roleUsers: RoleUser[] | null;
+    userRoleAssignments: UserRoleAssignment[] | null;
+    permissionDomains: PermissionDomains | null;
+    loading: boolean;
+    listRoles: (tenantId?: string) => Promise<Role[]>;
+    getRole: (id: string) => Promise<Role>;
+    getRoleUsers: (id: string) => Promise<RoleUser[]>;
+    createRole: (data: {
+        name: string;
+        description?: string;
+        permissions: string[];
+        tenantId?: string;
+    }) => Promise<Role>;
+    updateRole: (id: string, data: {
+        name?: string;
+        description?: string;
+        permissions?: string[];
+    }) => Promise<Role>;
+    deleteRole: (id: string) => Promise<void>;
+    getPermissions: () => Promise<PermissionDomains>;
+    getUserRoles: (userId: string, tenantId?: string) => Promise<UserRoleAssignment[]>;
+    assignRole: (userId: string, roleId: string, tenantId?: string) => Promise<void>;
+    revokeRole: (userId: string, roleId: string, tenantId?: string) => Promise<void>;
+};
+
+/**
+ * Client-side permission checking utilities.
+ * These mirror the server-side logic for UI gating.
+ */
+/** Check if a single required permission is satisfied by any of the granted permissions. */
+declare function hasPermission(required: string, granted: string[]): boolean;
+/** Check that ALL required permissions are satisfied. */
+declare function hasAllPermissions(required: string[], granted: string[]): boolean;
+/** Check that at least ONE of the required permissions is satisfied. */
+declare function hasAnyPermission(required: string[], granted: string[]): boolean;
+
+/** Check if a login method is an OAuth provider. */
+declare function isOAuthMethod(method: LoginMethod): method is OAuthProvider;
+/**
+ * Resolve the effective ordered login methods from config.
+ * If `loginMethods` is set, uses that directly.
+ * Otherwise, falls back to legacy fields for backward compat.
+ */
+declare function resolveLoginMethods(config: ForgeConnectConfig): LoginMethod[];
+
+export { AccountButton, AccountModal, type AccountModalState, type AccountModalTab, type AdminUser, type ApiClient, type AppearanceConfig, type AuthMethod, type AuthProvider, type AuthState, type AuthStatus, type Chain, DeleteAccountModal, ErrorView, type ErrorViewProps, ForgeConnectApiError, type ForgeConnectConfig, ForgeConnectContext, type ForgeConnectContextValue, ForgeConnectProvider, LinkAuthModal, type LinkModalState, LoginButton, type LoginMethod, LoginModal, type LoginResponse, ModalOverlay, type ModalState, type ModalStep, type OAuthProvider, type PaginatedResponse, type Passkey, PasskeysModal, type PermissionDomains, type Role, type RoleUser, type Session, type TokenVerificationResult, type TotpSetup, TwoFactorModal, type TwoFactorStatus, type User, type UserRoleAssignment, type UserStatus, type Wallet, type WalletAdapterContext, type WalletConfig, type WalletUserResult, createApiClient, hasAllPermissions, hasAnyPermission, hasPermission, isOAuthMethod, resolveLoginMethods, useAdmin, useForgeConnect, useRoles, useSessions, useUser, useWallets };