@getpara/core-sdk 2.12.0 → 2.13.0

package/dist/types/ParaCore.d.ts

@@ -1,7 +1,12 @@
-import { AuthMethod, AuthExtras, CurrentWalletIds, EmailTheme, PartnerEntity, TWalletType, PregenIds, BiometricLocationHint, Auth, SupportedWalletTypes, AuthIdentifier, AuthType, ExternalWalletInfo, ServerAuthStateLogin, ServerAuthStateSignup, PrimaryAuthInfo, SessionInfo, PrimaryAuth, PrimaryAuthType, AccountMetadata, LinkedAccounts, VerifyLinkParams, VerifyExternalWalletParams, SupportedAccountLinks, OnRampPurchase, BalancesConfig, Theme, ServerAuthStateDone } from '@getpara/user-management-client';
+import { AuthMethod, AuthExtras, CurrentWalletIds, EmailTheme, PartnerEntity, TWalletType, PregenIds, BiometricLocationHint, Auth, SupportedWalletTypes, AuthIdentifier, AuthType, ExternalWalletInfo, PrimaryAuthInfo, SessionInfo, PrimaryAuth, PrimaryAuthType, AccountMetadata, LinkedAccounts, VerifyLinkParams, VerifyExternalWalletParams as VerifyExternalWalletParamsServer, SupportedAccountLinks, OnRampPurchase, BalancesConfig, Theme, IssueJwtParams } from '@getpara/user-management-client';
 import type { pki as pkiType } from 'node-forge';
-import { Ctx, Environment, WalletFilters, Wallet, PortalUrlOptions, ConstructorOpts, CoreAuthInfo, PortalUrlType, CoreMethodParams, CoreMethodResponse, NewCredentialUrlParams, LoginUrlParams, CoreInterface, ExternalWalletConnectionType, AccountLinkInProgress, InternalMethodParams, InternalMethodResponse, AvailableWallet } from './types/index.js';
+import { Ctx, Environment, Wallet, ConstructorOpts, CoreAuthInfo, CoreMethodParams, CoreMethodResponse, CoreInterface, AccountLinkInProgress, InternalMethodParams, InternalMethodResponse, OAuthResponse, AvailableWallet } from './types/index.js';
 import { PlatformUtils } from './PlatformUtils.js';
+import { AuthServiceInterface, ExternalWalletServiceInterface, PollingServiceInterface, PortalUrlServiceInterface, PregenWalletServiceInterface, SessionManagementServiceInterface, StateMachineInterface, WalletServiceInterface } from './types/serviceInterfaces.js';
+import type { WaitForLoginParams, WaitForLoginResponse, WaitForSignupParams, WaitForWalletCreationParams, VerifyFarcasterParams, VerifyFarcasterResponse, VerifyNewAccountParams, VerifyTelegramParams, AddCredentialParams, GetNewCredentialAndUrlParams, GetNewCredentialAndUrlResponse, LoginExternalWalletParams, ResendVerificationCodeParams, SignUpOrLogInParams, VerifyOAuthProcessParams, VerifyOAuthProcessResponse, GetLoginUrlParams, GetOAuthUrlParams, PortalUrlOptions, PortalUrlType, ClaimPregenWalletsParams, CreatePregenWalletParams, CreatePregenWalletPerTypeParams, GetPregenWalletsParams, HasPregenWalletParams, UpdatePregenWalletIdentifierParams, CreateWalletParams, CreateWalletPerTypeParams, DistributeNewWalletShareParams, FindWalletByAddressParams, FindWalletIdParams, FindWalletParams, GetDisplayAddressParams, GetIdenticonHashParams, GetWalletBalanceParams, GetWalletsByTypeParams, RefreshShareParams, SetCurrentWalletIdsParams, SetWalletsParams, RefreshSessionParams, VerifyExternalWalletParams, InitExternalWalletProviderParams, ConnectExternalWalletParams, ExternalSignMessageParams, AuthenticateWithEmailOrPhoneParams, AuthenticateWithOAuthParams } from './services/types';
+import { CorePhase, StateSnapshot } from './state/types/core.js';
+import { AuthPhase } from './state/types/auth.js';
+import { WalletPhase } from './state/types/wallet.js';
 export declare abstract class ParaCore implements CoreInterface {
     #private;
     popupWindow: Window | null;
@@ -11,25 +16,94 @@ export declare abstract class ParaCore implements CoreInterface {
     protected isNativePasskey: boolean;
     protected isPartnerOptional?: boolean;
     protected setModalError(_error?: string): void;
-    isReady: boolean;
+    isSetup: boolean;
+    /**
+     * The current readiness state.
+     */
+    get isReady(): boolean;
+    /**
+     * The current phase of the core flow.
+     */
+    get corePhase(): CorePhase;
+    /**
+     * The current phase of the authentication flow.
+     */
+    get authPhase(): AuthPhase;
+    /**
+     * The current phase of the wallet flow.
+     */
+    get walletPhase(): WalletPhase;
+    /**
+     * Any error that has occurred in the core flow.
+     */
+    get error(): Error | null;
+    /**
+     * Get the current state of the core, auth, and wallet phases.
+     * @returns An object containing the current core, auth, and wallet state phases, along with any error.
+     */
+    getCurrentState(): StateSnapshot;
+    /**
+     * Subscribe to changes in the core, auth, and wallet state phases.
+     *
+     * This method immediately calls the callback with the current state, then continues
+     * to call it whenever any phase changes. This ensures you never miss the initial state
+     * and can react to all subsequent changes.
+     *
+     * @param callback A function that will be called with the current state phases whenever they change.
+     * The callback receives an object containing `corePhase`, `authPhase`, `walletPhase`, and `error`.
+     *
+     * @returns A function that can be called to unsubscribe from the state changes.
+     * Always call this function when your component unmounts or when you no longer need updates
+     * to prevent memory leaks.
+     *
+     * @example
+     * ```typescript
+     * // React example
+     * useEffect(() => {
+     *   const unsubscribe = paraClient.onStatePhaseChange((snapshot) => {
+     *     console.log('Core phase:', snapshot.corePhase);
+     *     console.log('Auth phase:', snapshot.authPhase);
+     *     console.log('Wallet phase:', snapshot.walletPhase);
+     *
+     *     if (snapshot.error) {
+     *       console.error('Para error:', snapshot.error.message);
+     *     }
+     *   });
+     *
+     *   return unsubscribe; // Cleanup on unmount
+     * }, [paraClient]);
+     *
+     * // Vue example
+     * onMounted(() => {
+     *   const unsubscribe = paraClient.onStatePhaseChange((state) => {
+     *     phases.value = state;
+     *   });
+     *
+     *   onUnmounted(unsubscribe);
+     * });
+     * ```
+     */
+    onStatePhaseChange(callback: (_: StateSnapshot) => void): () => void;
+    /**
+     * Subscribe to changes in the readiness state of the ParaCore instance.
+     * @param callback A function that will be called with the new readiness state.
+     * @returns A function that can be called to unsubscribe from the readiness state changes.
+     */
+    onReadyStateChange(callback: (isReady: boolean) => void): () => void;
     get authInfo(): CoreAuthInfo | undefined;
     get email(): AuthIdentifier<'email'> | undefined;
     get phone(): AuthIdentifier<'phone'> | undefined;
     get farcasterUsername(): AuthIdentifier<'farcaster'> | undefined;
     get telegramUserId(): AuthIdentifier<'telegram'> | undefined;
     get externalWalletWithParaAuth(): Wallet | undefined;
-    get externalWalletConnectionType(): ExternalWalletConnectionType;
+    get externalWalletConnectionType(): import("./services/types").ExternalWalletConnectionType;
     protected partner?: PartnerEntity;
-    userId?: string;
+    get userId(): string | undefined;
     accountLinkInProgress: AccountLinkInProgress | undefined;
-    private sessionCookie?;
-    isEnclaveUser: boolean;
+    get isEnclaveUser(): boolean;
+    set isEnclaveUser(value: boolean);
     private enclaveJwt?;
     private enclaveRefreshJwt?;
-    private isAwaitingAccountCreation;
-    private isAwaitingLogin;
-    private isAwaitingFarcaster;
-    private isAwaitingOAuth;
     private isWorkerInitialized;
     get isEmail(): boolean;
     get isPhone(): boolean;
@@ -40,20 +114,17 @@ export declare abstract class ParaCore implements CoreInterface {
     get partnerId(): string | undefined;
     protected get partnerName(): string | undefined;
     protected get partnerLogo(): string | undefined;
-    /**
-     * The IDs of the currently active wallets, for each supported wallet type. Any signer integrations will default to the first viable wallet ID in this dictionary.
-     */
-    currentWalletIds: CurrentWalletIds;
+    get currentWalletIds(): CurrentWalletIds;
     get currentWalletIdsArray(): [string, TWalletType][];
     get currentWalletIdsUnique(): string[];
     /**
      * Wallets associated with the `ParaCore` instance. Retrieve a particular wallet using `para.wallets[walletId]`.
      */
-    wallets: Record<string, Wallet>;
+    get wallets(): Record<string, Wallet>;
     /**
      * Wallets associated with the `ParaCore` instance.
      */
-    externalWallets: Record<string, Wallet>;
+    get externalWallets(): Record<string, Wallet>;
     /**
      * A map of pre-generated wallet identifiers that can be claimed in the current instance.
      */
@@ -167,12 +238,6 @@ export declare abstract class ParaCore implements CoreInterface {
     protected isPortal(envOverride?: Environment): boolean;
     private isParaConnect;
     private requireApiKey;
-    private isWalletSupported;
-    private isWalletOwned;
-    private isPregenWalletUnclaimed;
-    private isPregenWalletClaimable;
-    private isWalletUsable;
-    private truncateAddress;
     /**
      * Returns the formatted address for the desired wallet ID, depending on your app settings.
      * @param {string} walletId the ID of the wallet address to display.
@@ -181,19 +246,14 @@ export declare abstract class ParaCore implements CoreInterface {
      * @param {TWalletType} options.addressType the type of address to display.
      * @returns the formatted address
      */
-    getDisplayAddress(walletId: string, options?: {
-        truncate?: boolean;
-        addressType?: TWalletType | undefined;
-        cosmosPrefix?: string;
-        targetLength?: number;
-    } | undefined): string;
+    getDisplayAddress(...params: GetDisplayAddressParams): string;
     /**
      * Returns a unique hash for a wallet suitable for use as an identicon seed.
      * @param {string} walletId the ID of the wallet.
      * @param {boolean} options.addressType used to format the hash for another wallet type.
      * @returns the identicon hash string
      */
-    getIdenticonHash(walletId: string, overrideType?: TWalletType): string | undefined;
+    getIdenticonHash(...params: GetIdenticonHashParams): string;
     getWallets(): Record<string, Wallet>;
     getAddress(walletId?: string): string | undefined;
     protected abstract getPlatformUtils(): PlatformUtils;
@@ -209,6 +269,15 @@ export declare abstract class ParaCore implements CoreInterface {
      */
     constructor(env: Environment | undefined, apiKey: string, opts?: ConstructorOpts);
     constructor(apiKey: string, opts?: ConstructorOpts);
+    initExternalWalletProvider: (params: InitExternalWalletProviderParams) => Promise<void>;
+    getAuthServiceInterface(): AuthServiceInterface;
+    getWalletServiceInterface(): WalletServiceInterface;
+    getPregenWalletServiceInterface(): PregenWalletServiceInterface;
+    getPortalUrlServiceInterface(): PortalUrlServiceInterface;
+    getSessionManagementServiceInterface(): SessionManagementServiceInterface;
+    getStateMachineInterface(): StateMachineInterface;
+    getExternalWalletServiceInterface(): ExternalWalletServiceInterface;
+    getPollingServiceInterface(): PollingServiceInterface;
     private trackError;
     private wrapMethodsWithErrorTracking;
     private initializeFromStorage;
@@ -236,7 +305,7 @@ export declare abstract class ParaCore implements CoreInterface {
      *
      * This method will be called automatically if you use the React `ParaProvider` or when you call any methods that request an updated session.
      */
-    abstract ready(): Promise<void>;
+    abstract setup(): Promise<void>;
     protected setAuth(auth: PrimaryAuth, { extras, userId }?: {
         extras?: AuthExtras;
         userId?: string;
@@ -246,11 +315,6 @@ export declare abstract class ParaCore implements CoreInterface {
      * @internal
      */
     protected displayModalError(error?: string): void;
-    /**
-     * Handle specific touchSession errors with user-friendly messages
-     * @private
-     */
-    private handleTouchSessionError;
     protected assertUserId({ allowGuestMode }?: {
         allowGuestMode?: boolean;
     }): string;
@@ -292,7 +356,7 @@ export declare abstract class ParaCore implements CoreInterface {
      * Sets the wallets associated with the `ParaCore` instance.
      * @param wallets - Wallets to set.
      */
-    setWallets(wallets: Record<string, Wallet>): Promise<void>;
+    setWallets(wallets: SetWalletsParams): Promise<void>;
     /**
      * Sets the external wallets associated with the `ParaCore` instance.
      * @param externalWallets - External wallets to set, or a function that modifies the current wallets.
@@ -325,11 +389,7 @@ export declare abstract class ParaCore implements CoreInterface {
      * @returns - farcaster username associated with the `ParaCore` instance.
      */
     getFarcasterUsername(): string | undefined;
-    setCurrentWalletIds(currentWalletIds: CurrentWalletIds, { needsWallet, sessionLookupId, newDeviceSessionLookupId, }?: {
-        needsWallet?: boolean;
-        sessionLookupId?: string;
-        newDeviceSessionLookupId?: string;
-    }): Promise<void>;
+    setCurrentWalletIds: (...params: SetCurrentWalletIdsParams) => Promise<void>;
     /**
      * Fetches the most recent OAuth account metadata for the signed-in user.
      * If applicable, this will include the user's most recent metadata from their Google, Apple, Facebook, X, Discord, Farcaster, or Telegram account, the last time they signed in to your app.
@@ -344,7 +404,7 @@ export declare abstract class ParaCore implements CoreInterface {
      * @param {WalletFilters} [filter={}] a `WalletFilters` object specifying allowed types, schemes, and whether to forbid unclaimed pregen wallets.
      * @returns {string} the wallet ID originally passed, or the one found.
      */
-    findWalletId(walletId?: string, filter?: WalletFilters): string;
+    findWalletId: (...params: FindWalletIdParams) => string;
     /**
      * Retrieves a wallet with the given address, if present.
      * If no ID is passed, this will instead return the first valid, usable wallet ID that matches the filters.
@@ -352,20 +412,16 @@ export declare abstract class ParaCore implements CoreInterface {
      * @param {WalletFilters} [filter={}] a `WalletFilters` object specifying allowed types, schemes, and whether to forbid unclaimed pregen wallets.
      * @returns {string} the wallet ID originally passed, or the one found.
      */
-    findWalletByAddress(address: string, filter?: WalletFilters | undefined): any;
-    findWallet(idOrAddress?: string, overrideType?: TWalletType, filter?: WalletFilters): Omit<Wallet, 'signer'> | undefined;
+    findWalletByAddress(...params: FindWalletByAddressParams): Wallet;
+    findWallet(...params: FindWalletParams): import("./types/wallet.js").WalletNoSigner;
     get availableWallets(): AvailableWallet[];
     /**
      * Retrieves all usable wallets with the provided type (`'EVM' | 'COSMOS' | 'SOLANA'`)
      * @param {string} type the wallet type to filter by.
      * @returns {Wallet[]} an array of matching wallets.
      */
-    getWalletsByType(type: CoreMethodParams<'getWalletsByType'>): CoreMethodResponse<'getWalletsByType'>;
-    private assertIsValidWalletId;
-    private assertIsValidWalletType;
-    private getMissingTypes;
-    private getTypesToCreate;
-    private getPartnerURL;
+    getWalletsByType(type: GetWalletsByTypeParams): Wallet[];
+    getPartner(partnerId: string): Promise<PartnerEntity>;
     /**
      * URL of the portal, which can be associated with a partner id
      * @param partnerId: string - id of the partner to get the portal URL for
@@ -382,9 +438,8 @@ export declare abstract class ParaCore implements CoreInterface {
      * Fetches the wallets associated with the user.
      * @returns {WalletEntity[]} wallets that were fetched.
      */
-    fetchWallets(): CoreMethodResponse<'fetchWallets'>;
+    fetchWallets(): Promise<import("@getpara/user-management-client").IWalletEntity[]>;
     protected populateWalletAddresses(): Promise<void>;
-    private populatePregenWalletAddresses;
     /**
      * Logs in or creates a new user using an external wallet address.
      * @param {Object} opts the options object
@@ -392,21 +447,24 @@ export declare abstract class ParaCore implements CoreInterface {
      * @param {TWalletType} opts.type type of external wallet to use for identification.
      * @param {string} opts.provider the name of the provider for the external wallet.
      */
-    loginExternalWallet({ externalWallet, chainId, uri, ...urlOptions }: CoreMethodParams<'loginExternalWallet'>): CoreMethodResponse<'loginExternalWallet'>;
-    verifyExternalWallet(params: {
-        serverAuthState: ServerAuthStateSignup | ServerAuthStateLogin | ServerAuthStateDone;
-    } & Omit<CoreMethodParams<'verifyExternalWallet'>, keyof VerifyExternalWalletParams>): CoreMethodResponse<'verifyExternalWallet'>;
-    verifyExternalWallet(params: VerifyExternalWalletParams & {
-        serverAuthState?: undefined;
-    } & Omit<CoreMethodParams<'verifyExternalWallet'>, 'serverAuthState'>): CoreMethodResponse<'verifyExternalWallet'>;
+    loginExternalWallet(params: LoginExternalWalletParams): Promise<import("./services/types").LoginExternalWalletResponse>;
+    /**
+     * Connects to an external wallet & logs in to Para (if applicable).
+     * @param {Object} params the params object
+     * @param {Function} params.connect the function called to connect to the external wallet.
+     */
+    connectExternalWallet(params: ConnectExternalWalletParams): Promise<import("./services/types").ConnectExternalWalletResponse>;
+    verifyExternalWallet(params: VerifyExternalWalletParams): Promise<import("./services/types").VerifyExternalWalletResponse>;
+    retryVerifyExternalWallet(): Promise<import("./services/types").VerifyExternalWalletResponse>;
+    signExternalWalletVerification(params: ExternalSignMessageParams): Promise<import("./services/types").BaseVerifyExternalWalletParams>;
     protected verifyExternalWalletLink(opts: InternalMethodParams<'verifyExternalWalletLink'>): InternalMethodResponse<'verifyExternalWalletLink'>;
-    protected verifyTelegramProcess(opts: CoreMethodParams<'verifyTelegram'> & {
+    protected verifyTelegramProcess(opts: VerifyTelegramParams & {
         isLinkAccount: false;
-    }): CoreMethodResponse<'verifyTelegram'>;
+    }): Promise<OAuthResponse>;
     protected verifyTelegramProcess(opts: InternalMethodParams<'verifyTelegramLink'> & {
         isLinkAccount: true;
     }): InternalMethodResponse<'verifyTelegramLink'>;
-    verifyTelegram(opts: CoreMethodParams<'verifyTelegram'>): CoreMethodResponse<'verifyTelegram'>;
+    verifyTelegram(params: VerifyTelegramParams): Promise<import("./types/authState.js").AuthStateSignupOrLoginOrDone>;
     protected verifyTelegramLink(opts: InternalMethodParams<'verifyTelegramLink'>): InternalMethodResponse<'verifyTelegramLink'>;
     /**
      * Performs 2FA verification.
@@ -430,17 +488,17 @@ export declare abstract class ParaCore implements CoreInterface {
     /**
      * Resend a verification email for the current user.
      */
-    resendVerificationCode({ type: reason, }: CoreMethodParams<'resendVerificationCode'>): CoreMethodResponse<'resendVerificationCode'>;
+    resendVerificationCode({ type: reason }: ResendVerificationCodeParams): Promise<void>;
     /**
      * Checks if the current session is active.
      * @returns `true` if active, `false` otherwise
      */
-    isSessionActive(): CoreMethodResponse<'isSessionActive'>;
+    isSessionActive(): Promise<boolean>;
     /**
      * Checks if a session is active and a wallet exists.
      * @returns `true` if active, `false` otherwise
      **/
-    isFullyLoggedIn(): CoreMethodResponse<'isFullyLoggedIn'>;
+    isFullyLoggedIn(): Promise<boolean>;
     get isGuestMode(): boolean;
     /**
      * Get the auth methods available to an existing user
@@ -460,8 +518,8 @@ export declare abstract class ParaCore implements CoreInterface {
     /**
      * Waits for the session to be active.
      **/
-    waitForSignup({ isCanceled, onCancel, onPoll, }: CoreMethodParams<'waitForSignup'>): CoreMethodResponse<'waitForSignup'>;
-    waitForWalletCreation({ isCanceled, onCancel, }?: CoreMethodParams<'waitForWalletCreation'>): CoreMethodResponse<'waitForWalletCreation'>;
+    waitForSignup(params: WaitForSignupParams): Promise<true>;
+    waitForWalletCreation(params: WaitForWalletCreationParams): Promise<import("./services/types").WaitForWalletCreationResponse>;
     /**
      * Initiates a Farcaster login attempt and returns the URL for the user to connect.
      * You can create a QR code with this URI that works with Farcaster's mobile app.
@@ -469,23 +527,31 @@ export declare abstract class ParaCore implements CoreInterface {
      */
     getFarcasterConnectUri({ appScheme }?: {
         appScheme?: string;
-    }): CoreMethodResponse<'getFarcasterConnectUri'>;
-    protected verifyFarcasterProcess(opts: CoreMethodParams<'verifyFarcaster'> & {
+    }): Promise<string>;
+    protected verifyFarcasterProcess(_: VerifyFarcasterParams & {
         isLinkAccount: false;
-    }): CoreMethodResponse<'verifyFarcaster'>;
+    }): Promise<VerifyFarcasterResponse>;
     protected verifyFarcasterProcess(opts: InternalMethodParams<'verifyFarcasterLink'> & {
         isLinkAccount: true;
     }): InternalMethodResponse<'verifyFarcasterLink'>;
-    verifyFarcaster(opts: CoreMethodParams<'verifyFarcaster'>): CoreMethodResponse<'verifyFarcaster'>;
+    verifyFarcaster(params: VerifyFarcasterParams): Promise<import("./types/authState.js").AuthStateSignupOrLoginOrDone>;
     protected verifyFarcasterLink(opts: InternalMethodParams<'verifyFarcasterLink'>): InternalMethodResponse<'verifyFarcasterLink'>;
-    getOAuthUrl(opts: CoreMethodParams<'getOAuthUrl'>): CoreMethodResponse<'getOAuthUrl'>;
+    /**
+     * Generates a URL for the user to log in with OAuth using a desire method.
+     *
+     * @param {Object} opts the options object
+     * @param {TOAuthMethod} opts.method the third-party service to use for OAuth.
+     * @param {string} [opts.appScheme] the app scheme to redirect to after the OAuth flow. This is for mobile only.
+     * @returns {string} the URL for the user to log in with OAuth.
+     */
+    getOAuthUrl(params: GetOAuthUrlParams): Promise<string>;
     protected verifyOAuthProcess(_: InternalMethodParams<'verifyOAuthLink'> & {
         isLinkAccount: true;
     }): InternalMethodResponse<'verifyOAuthLink'>;
-    protected verifyOAuthProcess(_: CoreMethodParams<'verifyOAuth'> & {
+    protected verifyOAuthProcess(_: VerifyOAuthProcessParams & {
         isLinkAccount: false;
-    }): CoreMethodResponse<'verifyOAuth'>;
-    verifyOAuth(opts: CoreMethodParams<'verifyOAuth'>): CoreMethodResponse<'verifyOAuth'>;
+    }): Promise<VerifyOAuthProcessResponse>;
+    verifyOAuth(params: VerifyOAuthProcessParams): Promise<VerifyOAuthProcessResponse>;
     protected verifyOAuthLink(opts: InternalMethodParams<'verifyOAuthLink'>): InternalMethodResponse<'verifyOAuthLink'>;
     /**
      * Waits for the session to be active and sets up the user.
@@ -495,8 +561,8 @@ export declare abstract class ParaCore implements CoreInterface {
      * @param {boolean} [opts.skipSessionRefresh] whether to skip refreshing the session.
      * @returns {Object} `{ isComplete: boolean; isError: boolean; needsWallet: boolean; partnerId: string; }` the result data
      **/
-    waitForLogin(args: CoreMethodParams<'waitForLogin'>): CoreMethodResponse<'waitForLogin'>;
-    protected waitForWalletSwitching(args: CoreMethodParams<'waitForLogin'>): CoreMethodResponse<'waitForLogin'>;
+    waitForLogin(params: WaitForLoginParams): Promise<WaitForLoginResponse>;
+    protected waitForWalletSwitching(args: WaitForLoginParams): Promise<WaitForLoginResponse>;
     /**
      * Gets the switch wallets URL for wallet selection.
      * The authMethod is automatically included in the URL if available.
@@ -512,20 +578,21 @@ export declare abstract class ParaCore implements CoreInterface {
      * @param {boolean} [shouldOpenPopup] - if `true`, the running device will open a popup to reauthenticate the user.
      * @returns a URL for the user to reauthenticate.
      **/
-    refreshSession({ shouldOpenPopup, }?: CoreMethodParams<'refreshSession'>): CoreMethodResponse<'refreshSession'>;
+    refreshSession(params?: RefreshSessionParams): Promise<string>;
     /**
      * Call this method after login to ensure that the user ID is set
      * internally.
      **/
-    protected userSetupAfterLogin(): Promise<SessionInfo>;
+    protected userSetupAfterLogin(existingSession?: SessionInfo): Promise<SessionInfo>;
     /**
      * Get transmission shares associated with session.
      * @param {Object} opts the options object.
      * @param {boolean} opts.isForNewDevice - true if this device is registering.
      * @returns - transmission keyshares.
      **/
-    protected getTransmissionKeyShares({ isForNewDevice }?: {
+    protected getTransmissionKeyShares({ isForNewDevice, sessionLookupId: existingSessionLookupId, }?: {
         isForNewDevice?: boolean;
+        sessionLookupId?: string;
     }): Promise<any>;
     /**
      * Call this method after login to perform setup.
@@ -546,17 +613,7 @@ export declare abstract class ParaCore implements CoreInterface {
      * @param {boolean} opts.forceRefreshRecovery whether or not to force recovery secret regeneration. Used when regenerating recovery shares.
      * @returns {string} the recovery share.
      **/
-    distributeNewWalletShare({ walletId, userShare, skipBiometricShareCreation, forceRefresh, }: CoreMethodParams<'distributeNewWalletShare'>): CoreMethodResponse<'distributeNewWalletShare'>;
-    private waitForWalletAddress;
-    /**
-     * Waits for a pregen wallet address to be created.
-     *
-     * @param pregenIdentifier - the identifier of the user the pregen wallet is associated with.
-     * @param walletId - the wallet id
-     * @param pregenIdentifierType - the identifier type of the user the pregen wallet is associated with.
-     * @returns - recovery share.
-     **/
-    private waitForPregenWalletAddress;
+    distributeNewWalletShare(params: DistributeNewWalletShareParams): Promise<string>;
     /**
      * Creates several new wallets with the desired types. If no types are provided, this method
      * will create one for each of the non-optional types specified in the instance's `supportedWalletTypes`
@@ -565,7 +622,7 @@ export declare abstract class ParaCore implements CoreInterface {
      *
      * @deprecated alias for `createWalletPerType`
      **/
-    createWalletPerMissingType: ({ skipDistribute, types, }?: CoreMethodParams<"createWalletPerType">) => CoreMethodResponse<"createWalletPerType">;
+    createWalletPerMissingType: (params?: CreateWalletPerTypeParams) => Promise<import("./services/types").CreateWalletPerTypeResponse>;
     /**
      * Creates several new wallets with the desired types. If no types are provided, this method
      * will create one for each of the non-optional types specified in the instance's `supportedWalletTypes`
@@ -577,7 +634,7 @@ export declare abstract class ParaCore implements CoreInterface {
      * @param {TWalletType[]} [opts.types] the types of wallets to create.
      * @returns {Object} the wallets created, their ids, and the recovery secret.
      **/
-    createWalletPerType({ skipDistribute, types, }?: CoreMethodParams<'createWalletPerType'>): CoreMethodResponse<'createWalletPerType'>;
+    createWalletPerType(params?: CreateWalletPerTypeParams): Promise<import("./services/types").CreateWalletPerTypeResponse>;
     /**
      * Refresh the current user share for a wallet.
      *
@@ -590,7 +647,7 @@ export declare abstract class ParaCore implements CoreInterface {
      * @param {boolean} [opts.redistributeBackupEncryptedShares] whether or not to redistribute backup encrypted shares.
      * @returns {Object} the new user share and recovery secret.
      **/
-    refreshShare({ walletId, share, oldPartnerId, newPartnerId, keyShareProtocolId, redistributeBackupEncryptedShares, }: CoreMethodParams<'refreshShare'>): CoreMethodResponse<'refreshShare'>;
+    refreshShare(params: RefreshShareParams): Promise<import("./services/types").RefreshShareResponse>;
     /**
      * Creates a new wallet.
      * @param {Object} opts the options object.
@@ -598,8 +655,17 @@ export declare abstract class ParaCore implements CoreInterface {
      * @param {boolean} opts.skipDistribute - if true, recovery share will not be distributed.
      * @returns {[Wallet, string | null]} `[wallet, recoveryShare]` - the wallet object and the new recovery share.
      **/
-    createWallet({ type: _type, skipDistribute, }?: CoreMethodParams<'createWallet'>): CoreMethodResponse<'createWallet'>;
-    createPregenWallet(opts: CoreMethodParams<'createPregenWallet'>): CoreMethodResponse<'createPregenWallet'>;
+    createWallet(params?: CreateWalletParams): Promise<import("./services/types").CreateWalletResponse>;
+    /**
+     * Creates a new pregenerated wallet.
+     *
+     * @param {Object} opts the options object.
+     * @param {string} opts.pregenIdentifier the identifier associated with the new wallet.
+     * @param {TPregenIdentifierType} [opts.pregenIdentifierType] the identifier type. Defaults to `EMAIL`.
+     * @param {TWalletType} [opts.type] the type of wallet to create. Defaults to the first non-optional type in the instance's `supportedWalletTypes` array.
+     * @returns {Wallet} the created wallet.
+     **/
+    createPregenWallet(params: CreatePregenWalletParams): Promise<Wallet>;
     /**
      * Creates new pregenerated wallets for each desired type.
      * If no types are provided, this method will create one for each of the non-optional types
@@ -610,7 +676,7 @@ export declare abstract class ParaCore implements CoreInterface {
      * @param {TWalletType[]} [opts.types] the wallet types to create. Defaults to any types the instance supports that are not already present.
      * @returns {Wallet[]} an array containing the created wallets.
      **/
-    createPregenWalletPerType({ types, pregenId, }: CoreMethodParams<'createPregenWalletPerType'>): CoreMethodResponse<'createPregenWalletPerType'>;
+    createPregenWalletPerType(params: CreatePregenWalletPerTypeParams): Promise<import("./services/types").CreatePregenWalletPerTypeResponse>;
     /**
      * Claims a pregenerated wallet.
      * @param {Object} opts the options object.
@@ -618,7 +684,7 @@ export declare abstract class ParaCore implements CoreInterface {
      * @param {TPregenIdentifierType} opts.pregenIdentifierType type of the identifier of the user claiming the wallet
      * @returns {[Wallet, string | null]} `[wallet, recoveryShare]` - the wallet object and the new recovery share.
      **/
-    claimPregenWallets({ pregenId, }?: CoreMethodParams<'claimPregenWallets'>): CoreMethodResponse<'claimPregenWallets'>;
+    claimPregenWallets(params?: ClaimPregenWalletsParams): Promise<string>;
     /**
      * Updates the identifier for a pregen wallet.
      * @param {Object} opts the options object.
@@ -626,7 +692,7 @@ export declare abstract class ParaCore implements CoreInterface {
      * @param {string} opts.newPregenIdentifier the new identtifier
      * @param {TPregenIdentifierType} opts.newPregenIdentifierType: the new identifier type
      **/
-    updatePregenWalletIdentifier({ walletId, newPregenId, }: CoreMethodParams<'updatePregenWalletIdentifier'>): CoreMethodResponse<'updatePregenWalletIdentifier'>;
+    updatePregenWalletIdentifier(params: UpdatePregenWalletIdentifierParams): Promise<void>;
     /**
      * Checks if a pregen Wallet exists for the given identifier with the current partner.
      * @param {Object} opts the options object.
@@ -634,7 +700,7 @@ export declare abstract class ParaCore implements CoreInterface {
      * @param {TPregenIdentifierType} opts.pregenIdentifierType type of the string of the identifier of the user claiming the wallet
      * @returns {boolean} whether the pregen wallet exists
      **/
-    hasPregenWallet({ pregenId }: CoreMethodParams<'hasPregenWallet'>): CoreMethodResponse<'hasPregenWallet'>;
+    hasPregenWallet(params: HasPregenWalletParams): Promise<boolean>;
     /**
      * Get pregen wallets for the given identifier.
      * @param {Object} opts the options object.
@@ -642,22 +708,21 @@ export declare abstract class ParaCore implements CoreInterface {
      * @param {TPregenIdentifierType} opts.pregenIdentifierType - type of the identifier of the user claiming the wallet
      * @returns {Promise<WalletEntity[]>} the array of found wallets
      **/
-    getPregenWallets({ pregenId }?: CoreMethodParams<'getPregenWallets'>): CoreMethodResponse<'getPregenWallets'>;
-    createGuestWallets(): CoreMethodResponse<'createGuestWallets'>;
-    private encodeWalletBase64;
+    getPregenWallets(params?: GetPregenWalletsParams): Promise<import("./services/types").GetPregenWalletsResponse>;
+    createGuestWallets(): Promise<import("./services/types").CreateGuestWalletsResponse>;
     /**
      * Encodes the current wallets encoded in Base 64.
      * @returns {string} the encoded wallet string
      **/
-    getUserShare(): CoreMethodResponse<'getUserShare'>;
+    getUserShare(): string;
     /**
      * Sets the current wallets from a Base 64 string.
      * @param {string} base64Wallet the encoded wallet string
      **/
-    setUserShare(base64Wallets: CoreMethodParams<'setUserShare'>): CoreMethodResponse<'setUserShare'>;
+    setUserShare(base64Wallets: string): Promise<void>;
     private getTransactionReviewUrl;
     private getOnRampTransactionUrl;
-    getWalletBalance: ({ walletId, rpcUrl, }: CoreMethodParams<"getWalletBalance">) => CoreMethodResponse<"getWalletBalance">;
+    getWalletBalance(params: GetWalletBalanceParams): Promise<string>;
     /**
      * Signs a message using one of the current wallets.
      *
@@ -709,8 +774,8 @@ export declare abstract class ParaCore implements CoreInterface {
      * Retrieves a token to verify the current session.
      * @returns {Promise<string>} the ID
      **/
-    getVerificationToken(): CoreMethodResponse<'getVerificationToken'>;
-    issueJwt({ keyIndex }?: CoreMethodParams<'issueJwt'>): CoreMethodResponse<'issueJwt'>;
+    getVerificationToken(): Promise<string>;
+    issueJwt(params?: IssueJwtParams): Promise<import("./services/types").IssueJwtResponse>;
     /**
      * Logs the user out.
      * @param {Object} opts the options object.
@@ -719,6 +784,13 @@ export declare abstract class ParaCore implements CoreInterface {
     logout({ clearPregenWallets }?: {
         clearPregenWallets?: boolean;
     }): Promise<void>;
+    /**
+     * Cancels any in-progress authentication flow, returning the auth state machine
+     * to its initial unauthenticated state. Does not affect existing sessions or stored data.
+     *
+     * Resolves once the auth state machine has settled back to `unauthenticated`.
+     */
+    cancelAuthFlow(): Promise<void>;
     protected get toStringAdditions(): Record<string, unknown>;
     /**
      * Converts to a string, removing sensitive data when logging this class.
@@ -727,11 +799,8 @@ export declare abstract class ParaCore implements CoreInterface {
      **/
     toString(): string;
     protected devLog(...s: any[]): void;
-    protected getNewCredentialAndUrl({ authMethod: optsAuthMethod, isForNewDevice, portalTheme, shorten, }?: NewCredentialUrlParams): Promise<{
-        credentialId: string;
-        url?: string;
-    }>;
-    addCredential({ authMethod }: Pick<NewCredentialUrlParams, 'authMethod'>): Promise<string>;
+    protected getNewCredentialAndUrl(params?: GetNewCredentialAndUrlParams): Promise<GetNewCredentialAndUrlResponse>;
+    addCredential: (params: AddCredentialParams) => Promise<string>;
     /**
      * Returns a Para Portal URL for logging in with a WebAuth passkey, password, PIN or OTP.
      * @param {Object} opts the options object
@@ -740,16 +809,18 @@ export declare abstract class ParaCore implements CoreInterface {
      * @param {Theme} opts.portalTheme the Para Portal theme to apply to the password creation URL, if other than the default theme
      * @returns {SignUpOrLogInResponse} an object in the form of either: `{ stage: 'verify' }` or `{ stage: 'login'; passkeyUrl?: string; passwordUrl?: string; biometricHints?: BiometricLocationHint[] }`
      */
-    protected getLoginUrl({ authMethod, shorten, portalTheme, sessionId, }: LoginUrlParams): Promise<string>;
-    protected prepareLogin(): InternalMethodResponse<'prepareLogin'>;
-    signUpOrLogIn({ auth, ...urlOptions }: CoreMethodParams<'signUpOrLogIn'>): CoreMethodResponse<'signUpOrLogIn'>;
-    verifyNewAccount({ verificationCode, ...urlOptions }: CoreMethodParams<'verifyNewAccount'>): CoreMethodResponse<'verifyNewAccount'>;
+    protected getLoginUrl(params: GetLoginUrlParams): Promise<string>;
+    protected prepareLogin(): Promise<string>;
+    signUpOrLogIn(params: SignUpOrLogInParams): Promise<import("./services/types").SignUpOrLogInResponse>;
+    authenticateWithEmailOrPhone(params: AuthenticateWithEmailOrPhoneParams): Promise<import("./services/types").AuthenticateResponse>;
+    authenticateWithOAuth(params: AuthenticateWithOAuthParams): Promise<import("./services/types").AuthenticateResponse>;
+    verifyNewAccount(params: VerifyNewAccountParams): Promise<import("./types/authState.js").AuthStateSignup>;
     getLinkedAccounts({ withMetadata, }?: CoreMethodParams<'getLinkedAccounts'>): CoreMethodResponse<'getLinkedAccounts'>;
     protected linkAccount(opts: InternalMethodParams<'linkAccount'>): InternalMethodResponse<'linkAccount'>;
     protected unlinkAccount({ linkedAccountId, }: InternalMethodParams<'unlinkAccount'>): InternalMethodResponse<'unlinkAccount'>;
     protected verifyLink({ accountLinkInProgress, ...opts }?: {
         accountLinkInProgress?: AccountLinkInProgress;
-    } & Partial<Pick<VerifyLinkParams, 'verificationCode' | 'telegramAuthResponse'> & VerifyExternalWalletParams>): Promise<LinkedAccounts>;
+    } & Partial<Pick<VerifyLinkParams, 'verificationCode' | 'telegramAuthResponse'> & VerifyExternalWalletParamsServer>): Promise<LinkedAccounts>;
     protected verifyEmailOrPhoneLink({ verificationCode, }: InternalMethodParams<'verifyEmailOrPhoneLink'>): InternalMethodResponse<'verifyEmailOrPhoneLink'>;
     protected getProfileBalance({ config, refetch }?: {
         config?: BalancesConfig;