@getpara/core-sdk 0.1.0 → 0.2.0

package/dist/types/ParaCore.d.ts

@@ -1,7 +1,7 @@
 import Client, { AuthMethod, AuthType, BackupKitEmailProps, CurrentWalletIds, EmailTheme, PartnerEntity, WalletEntity, WalletType, WalletScheme, WalletParams, OAuthMethod, OnRampPurchaseCreateParams, OnRampPurchase, TPregenIdentifierType, PregenIds, BiometricLocationHint, TelegramAuthResponse, VerifyTelegramRes, Auth } from '@getpara/user-management-client';
 import type { pki as pkiType } from 'node-forge';
 import { Ctx, Environment, WalletFilters, WalletTypeProp } from './definitions.js';
-import { Theme, FullSignatureRes, EmbeddedWalletType, ExternalWalletType, ExternalWalletInfo } from './types/index.js';
+import { Theme, FullSignatureRes, EmbeddedWalletType, ExternalWalletType, ExternalWalletInfo, GetWebAuthUrlForLoginParams, AccountSetupResp, LoginResp } from './types/index.js';
 import { PlatformUtils } from './PlatformUtils.js';
 import { CountryCallingCode } from 'libphonenumber-js';
 export declare function entityToWallet(w: WalletEntity): Omit<Wallet, 'signer'>;
@@ -169,12 +169,12 @@ export declare abstract class ParaCore {
     #private;
     static version?: string;
     ctx: Ctx;
-    protected email?: string;
-    protected phone?: string;
-    protected countryCode?: CountryCallingCode;
-    private farcasterUsername?;
+    email?: string;
+    phone?: string;
+    countryCode?: CountryCallingCode;
+    farcasterUsername?: string;
     telegramUserId?: string;
-    private userId?;
+    userId?: string;
     private sessionCookie?;
     private isAwaitingAccountCreation;
     private isAwaitingLogin;
@@ -469,72 +469,75 @@ export declare abstract class ParaCore {
     private getShortUrl;
     shortenLoginLink(link: string): Promise<string>;
     /**
-     * Generates a URL that can be used to perform web auth
-     * for creating a new credential.
-     * @param sessionId - id of the session to use for web auth
-     * @param loginEncryptionPublicKey - public key to use for encrypting the login encryption key
-     * @param partnerId - id of the partner to get the portal URL for
-     * @param newDeviceSessionId - id of the session to use for web auth for a new device
-     * @param newDeviceEncryptionKey - public key to use for encrypting the login encryption key for a new device
-     * @returns - web auth url
+     * Generates a URL for registering a new WebAuth passkey.
+     * @param {GetWebAuthUrlForLoginParams} opts the options object
+     * @returns - the URL for creating a new passkey
      */
-    getWebAuthURLForLogin(options: Pick<PortalUrlOptions, 'authType' | 'partnerId' | 'newDeviceSessionId' | 'newDeviceEncryptionKey' | 'displayName' | 'pfpUrl'> & {
-        sessionId: string;
-        loginEncryptionPublicKey: string;
-    }): Promise<string>;
-    getPasswordURLForLogin(options: Pick<PortalUrlOptions, 'authType' | 'partnerId' | 'newDeviceSessionId' | 'newDeviceEncryptionKey' | 'displayName' | 'pfpUrl'> & {
-        sessionId: string;
-        loginEncryptionPublicKey: string;
-    }): Promise<string>;
+    getWebAuthURLForLogin(opts: GetWebAuthUrlForLoginParams): Promise<string>;
+    /**
+     * Generates a URL for registering a new user password.
+     * @param {GetWebAuthUrlForLoginParams} opts the options object
+     * @returns - the URL for creating a new password
+     */
+    getPasswordURLForLogin(opts: GetWebAuthUrlForLoginParams): Promise<string>;
     /**
-     * Generates a URL that can be used to perform web auth for phone number
-     * for creating a new credential.
-     * @param sessionId - id of the session to use for web auth
-     * @param loginEncryptionPublicKey - public key to use for encrypting the login encryption key
-     * @param partnerId - id of the partner to get the portal URL for
-     * @param newDeviceSessionId - id of the session to use for web auth for a new device
-     * @param newDeviceEncryptionKey - public key to use for encrypting the login encryption key for a new device
+     * Generates a URL for registering a new WebAuth passkey for a phone number.
+     * @param {Omit<GetWebAuthUrlForLoginParams, 'authType'>} opts the options object
      * @returns - web auth url
      */
-    getWebAuthURLForLoginForPhone(options: Pick<PortalUrlOptions, 'partnerId' | 'newDeviceSessionId' | 'newDeviceEncryptionKey'> & {
-        sessionId: string;
-        loginEncryptionPublicKey: string;
-    }): Promise<string>;
+    getWebAuthURLForLoginForPhone(opts: Omit<GetWebAuthUrlForLoginParams, 'authType'>): Promise<string>;
     /**
      * Gets the private key for the given wallet.
-     * @param walletId - (optional) id of the wallet to get the private key for. Will default to the first wallet if not provided.
-     * @returns - private key string.
+     * @param {string } [walletId] id of the wallet to get the private key for. Will default to the first wallet if not provided.
+     * @returns - the private key string.
      */
     protected getPrivateKey(walletId?: string): Promise<string>;
     /**
      * Fetches the wallets associated with the user.
-     * @returns - wallets that were fetched.
+     * @returns {WalletEntity[]} wallets that were fetched.
      */
     fetchWallets(): Promise<WalletEntity[]>;
     private populateWalletAddresses;
     private populatePregenWalletAddresses;
     /**
-     * Checks if a user exists.
-     * @returns - true if user exists, false otherwise.
+     * Checks if a user exists for an email address.
+     * @param {Object} opts the options object
+     * @param {string} opts.email the email to check.
+     * @returns true if user exists, false otherwise.
      */
-    checkIfUserExists(email: string): Promise<boolean>;
+    checkIfUserExists({ email }: {
+        email: string;
+    }): Promise<boolean>;
     /**
-     * Checks if a user exists by their phone number.
-     * @returns - true if user exists, false otherwise.
+     * Checks if a user exists for a phone number.
+     * @param {Object} opts the options object
+     * @param {string} opts.phone - phone number to check.
+     * @param {string} opts.countryCode - the country code.
+     * @returns true if user exists, false otherwise.
+     */
+    checkIfUserExistsByPhone({ phone, countryCode }: {
+        phone: string;
+        countryCode: string;
+    }): Promise<boolean>;
+    /**
+     * Creates a new user.
+     * @param {Object} opts the options object
+     * @param {string} opts.email the email to use.
      */
-    checkIfUserExistsByPhone(phone: string, countryCode: CountryCallingCode): Promise<boolean>;
     createUser({ email }: Auth<'email'>): Promise<void>;
     /**
      * Creates a new user with a phone number.
-     * @param phone - phone number to use for creating the user.
-     * @param countryCode - country code to use for creating the user.
+     * @param {Object} opts the options object
+     * @param {string} opts.phone - the phone number to use for creating the user.
+     * @param {string} opts.countryCode - the country code to use for creating the user.
      */
     createUserByPhone({ phone, countryCode }: Auth<'phone'>): Promise<void>;
     /**
      * Logs in or creates a new user using an external wallet address.
-     * @param externalAddress - external wallet address to use for identification.
-     * @param type - type of external wallet to use for identification.
-     * @param externalWalletProvider - name of provider for the external wallet.
+     * @param {Object} opts the options object
+     * @param {string} opts.address the external wallet address to use for identification.
+     * @param {WalletType} opts.type type of external wallet to use for identification.
+     * @param {string} opts.provider the name of the provider for the external wallet.
      */
     externalWalletLogin(wallet: ExternalWalletInfo): Promise<void>;
     /**
@@ -543,16 +546,22 @@ export declare abstract class ParaCore {
     protected isUsingExternalWallet(): boolean;
     /**
      * Passes the email code obtained from the user for verification.
-     * @param verificationCode
-     * @returns - web auth url for creating a new credential
+     * @param {Object} opts the options object
+     * @param {string} verificationCode the six-digit code to check
+     * @returns {string} the web auth url for creating a new credential
      */
-    verifyEmail(verificationCode: string): Promise<string>;
+    verifyEmail({ verificationCode }: {
+        verificationCode: string;
+    }): Promise<string>;
     /**
      * Passes the phone code obtained from the user for verification.
-     * @param verificationCode
-     * @returns - web auth url for creating a new credential
+     * @param {Object} opts the options object
+     * @param {string} verificationCode the six-digit code to check
+     * @returns {string} the web auth url for creating a new credential
      */
-    verifyPhone(verificationCode: string): Promise<string>;
+    verifyPhone({ verificationCode }: {
+        verificationCode: string;
+    }): Promise<string>;
     /**
      * Validates the response received from an attempted Telegram login for authenticity, then
      * creates or retrieves the corresponding Para user and prepares the Para instance to sign in with that user.
@@ -562,11 +571,15 @@ export declare abstract class ParaCore {
     verifyTelegram(authObject: TelegramAuthResponse): Promise<VerifyTelegramRes>;
     /**
      * Performs 2FA verification.
-     * @param email - email to use for performing a 2FA verification.
-     * @param verificationCode - verification code to received via 2FA.
-     * @returns { address, initiatedAt, status, userId, walletId }
+     * @param {Object} opts the options object
+     * @param {string} opts.email the email to use for performing a 2FA verification.
+     * @param {string} opts.verificationCode the verification code to received via 2FA.
+     * @returns {Object} `{ address, initiatedAt, status, userId, walletId }`
      */
-    verify2FA(email: string, verificationCode: string): Promise<{
+    verify2FA({ email, verificationCode }: {
+        email: string;
+        verificationCode: string;
+    }): Promise<{
         initiatedAt?: Date;
         status?: RecoveryStatus;
         userId: string;
@@ -574,45 +587,84 @@ export declare abstract class ParaCore {
     }>;
     /**
      * Performs 2FA verification.
-     * @param phone - phone to use for performing a 2FA verification.
-     * @param verificationCode - verification code to received via 2FA.
-     * @returns { address, initiatedAt, status, userId, walletId }
-     */
-    verify2FAForPhone(phone: string, countryCode: CountryCallingCode, verificationCode: string): Promise<{
+     * @param {Object} opts the options object
+     * @param {string} opts.phone the phone number
+     * @param {string} opts.countryCode - the country code
+     * @param {string} opts.verificationCode - verification code to received via 2FA.
+     * @returns {Object} `{ address, initiatedAt, status, userId, walletId }`
+     */
+    verify2FAForPhone({ phone, countryCode, verificationCode, }: {
+        phone: string;
+        countryCode: string;
+        verificationCode: string;
+    }): Promise<{
         initiatedAt?: Date;
         status?: RecoveryStatus;
         userId: string;
         wallets: Pick<Wallet, 'address' | 'id'>[];
     }>;
     /**
-     * Sets up 2FA.
-     * @returns uri - uri to use for setting up 2FA
+     * Sets up two-factor authentication for the current user.
+     * @returns {string} uri - uri to use for setting up 2FA
      * */
     setup2FA(): Promise<{
         uri?: string;
     }>;
     /**
      * Enables 2FA.
-     * @param verificationCode - verification code received via 2FA.
+     * @param {Object} opts the options object
+     * @param {string} opts.verificationCode - the verification code received via 2FA.
      */
-    enable2FA(verificationCode: string): Promise<void>;
+    enable2FA({ verificationCode }: {
+        verificationCode: string;
+    }): Promise<void>;
     /**
      * Determines if 2FA has been set up.
-     * @returns { isSetup } - true if 2FA is setup, false otherwise
+     * @returns {Object} `{ isSetup: boolean }` - true if 2FA is setup, false otherwise
      */
     check2FAStatus(): Promise<{
         isSetup: boolean;
     }>;
+    /**
+     * Resend a verification email for the current user.
+     */
     resendVerificationCode(): Promise<void>;
+    /**
+     * Resend a verification SMS for the current user.
+     */
     resendVerificationCodeByPhone(): Promise<void>;
+    /**
+     * Returns a URL for setting up a new WebAuth passkey.
+     * @param {Object} opts the options object
+     * @param {string} opts.authType - the auth type to use
+     * @param {boolean} opts.isForNewDevice whether the passkey is for a new device of an existing user
+     * @returns {string} the URL
+     */
     getSetUpBiometricsURL({ authType, isForNewDevice, }?: Pick<PortalUrlOptions, 'authType' | 'isForNewDevice'>): Promise<string>;
+    /**
+     * Returns a URL for setting up a new WebAuth passkey for a phone number.
+     * @param {Object} opts the options object
+     * @param {boolean} opts.isForNewDevice whether the passkey is for a new device of an existing user
+     * @returns {string} the URL
+     */
     getSetUpBiometricsURLForPhone({ isForNewDevice, }?: Pick<PortalUrlOptions, 'isForNewDevice'>): Promise<string>;
+    /**
+     * Returns a URL for setting up a new password.
+     * @param {Object} opts the options object
+     * @param {string} opts.authType - the auth type to use
+     * @param {boolean} opts.isForNewDevice whether the passkey is for a new device of an existing user
+     * @param {Theme} [opts.theme] the portal theme to use in place of the partner's default
+     * @returns {string} the URL
+     */
     getSetupPasswordURL({ authType, isForNewDevice, theme, }?: Pick<PortalUrlOptions, 'authType' | 'isForNewDevice' | 'theme'>): Promise<string>;
+    /**
+     * Checks if the current session is active.
+     * @returns `true` if active, `false` otherwise
+     */
     isSessionActive(): Promise<boolean>;
     /**
      * Checks if a session is active and a wallet exists.
-     *
-     * @returns true if session is active and a wallet exists.
+     * @returns `true` if active, `false` otherwise
      **/
     isFullyLoggedIn(): Promise<boolean>;
     protected supportedAuthMethods(auth: Auth): Promise<Set<AuthMethod>>;
@@ -624,9 +676,10 @@ export declare abstract class ParaCore {
     private setAuth;
     /**
      * Initiates a login.
-     * @param email - the email to login with
-     * @param useShortURL - whether to shorten the link
-     * @returns - web auth url for logging in
+     * @param {Object} opts the options object
+     * @param {String} opts.email - the email to login with
+     * @param {boolean} opts.useShortURL - whether to shorten the link
+     * @returns - the WebAuth URL for logging in
      **/
     initiateUserLogin({ useShortUrl, ...auth }: Auth & {
         useShortUrl?: boolean;
@@ -639,10 +692,11 @@ export declare abstract class ParaCore {
     initiateUserLoginV2(auth: Auth): Promise<Set<AuthMethod>>;
     /**
      * Initiates a login.
-     * @param phone - the phone number to login with
-     * @param countryCode
-     * @param useShortURL - whether to shorten the link
-     * @returns - web auth url for logging in
+     * @param opts the options object
+     * @param opts.phone the phone number
+     * @param opts.countryCode the country code
+     * @param opts.useShortURL - whether to shorten the link
+     * @returns - the WebAuth URL for logging in
      **/
     initiateUserLoginForPhone({ useShortUrl, ...auth }: Auth<'phone'> & {
         useShortUrl?: boolean;
@@ -651,23 +705,17 @@ export declare abstract class ParaCore {
      * Waits for the session to be active.
      **/
     waitForAccountCreation(): Promise<boolean>;
-    waitForPasskeyAndCreateWallet(): Promise<{
-        walletIds: CurrentWalletIds;
-        recoverySecret?: string;
-    }>;
+    waitForPasskeyAndCreateWallet(): Promise<AccountSetupResp>;
     /**
      * Initiates a Farcaster login attempt and return the URI for the user to connect.
      * You can create a QR code with this URI that works with Farcaster's mobile app.
-     *
-     * @return {string}
+     * @return {string} the Farcaster connect URI
      */
     getFarcasterConnectURL(): Promise<string>;
     /**
      * Awaits the response from a user's attempt to log in with Farcaster.
      * If successful, this returns the user's Farcaster username and profile picture and indicates whether the user already exists.
-     *
-     * @param {Object} opts the options object.
-     * @return {Object} the user's information and whether the user already exists.
+     * @return {Object} `{userExists: boolean; username: string; pfpUrl?: string | null }` - the user's information and whether the user already exists.
      */
     waitForFarcasterStatus(): Promise<{
         userExists: boolean;
@@ -677,17 +725,20 @@ export declare abstract class ParaCore {
     /**
      * Generates a URL for the user to log in with OAuth using a desire method.
      *
-     * @param {OAuthMethod} oAuthMethod the third-party service to use for OAuth.
+     * @param {Object} opts the options object
+     * @param {OAuthMethod} opts.method the third-party service to use for OAuth.
      * @returns {string} the URL for the user to log in with OAuth.
      */
-    getOAuthURL(oAuthMethod: OAuthMethod): Promise<string>;
+    getOAuthURL({ method }: {
+        method: OAuthMethod;
+    }): Promise<string>;
     /**
      * Awaits the response from a user's attempt to log in with OAuth.
      * If successful, this returns the user's email address and indicates whether the user already exists.
      *
      * @param {Object} opts the options object.
      * @param {Window} [opts.popupWindow] the popup window being used for login.
-     * @return {Object} the user's email address and whether the user already exists.
+     * @return {Object} `{ email?: string; isError?: boolean; userExists: boolean; }` the result data
      */
     waitForOAuth({ popupWindow }?: {
         popupWindow?: Window;
@@ -702,24 +753,19 @@ export declare abstract class ParaCore {
      * @param {Object} opts the options object
      * @param {Window} [opts.popupWindow] the popup window being used for login.
      * @param {boolean} [opts.skipSessionRefresh] whether to skip refreshing the session.
-     * @returns { needsWallet } - whether a wallet needs to be created
+     * @returns {Object} `{ isComplete: boolean; isError: boolean; needsWallet: boolean; partnerId: string; }` the result data
      **/
     waitForLoginAndSetup({ popupWindow, skipSessionRefresh, }?: {
         popupWindow?: Window;
         skipSessionRefresh?: boolean;
-    }): Promise<{
-        isComplete: boolean;
-        isError?: boolean;
-        needsWallet?: boolean;
-        partnerId?: string;
-    }>;
+    }): Promise<LoginResp>;
     /**
      * Updates the session with the user management server, possibly
      * opening a popup to refresh the session.
      *
      * @param {Object} opts the options object.
      * @param {boolean} [shouldOpenPopup] - if `true`, the running device will open a popup to reauthenticate the user.
-     * @returns - a URL for the user to reauthenticate.
+     * @returns a URL for the user to reauthenticate.
      **/
     refreshSession({ shouldOpenPopup }?: {
         shouldOpenPopup?: boolean;
@@ -737,8 +783,8 @@ export declare abstract class ParaCore {
     }>;
     /**
      * Get transmission shares associated with session.
-     *
-     * @param isForNewDevice - true if this device is registering.
+     * @param {Object} opts the options object.
+     * @param {boolean} opts.isForNewDevice - true if this device is registering.
      * @returns - transmission keyshares.
      **/
     protected getTransmissionKeyShares({ isForNewDevice }?: {
@@ -746,8 +792,9 @@ export declare abstract class ParaCore {
     }): Promise<any>;
     /**
      * Call this method after login to perform setup.
-     *
-     * @param temporaryShares - optional temporary shares to use for decryption.
+     * @param {Object} opts the options object.
+     * @param {any[]} opts.temporaryShares optional temporary shares to use for decryption.
+     * @param {boolean} [opts.skipSessionRefresh] - whether or not to skip refreshing the session.
      **/
     setupAfterLogin({ temporaryShares, skipSessionRefresh, }?: {
         temporaryShares?: any[];
@@ -755,12 +802,12 @@ export declare abstract class ParaCore {
     }): Promise<void>;
     /**
      * Distributes a new wallet recovery share.
-     *
-     * @param walletId - the wallet to distribute the recovery share for.
-     * @param userShare - optional user share generate the recovery share from. Defaults to the signer from the passed in walletId
-     * @param skipBiometricShareCreation - whether or not to skip biometric share creation. Used when regenerating recovery shares.
-     * @param forceRefreshRecovery - whether or not to force recovery secret regeneration. Used when regenerating recovery shares.
-     * @returns - recovery share.
+     * @param {Object} opts the options object.
+     * @param {string} opts.walletId the wallet to distribute the recovery share for.
+     * @param {string} opts.userShare optional user share generate the recovery share from. Defaults to the signer from the passed in walletId
+     * @param {boolean} opts.skipBiometricShareCreation whether or not to skip biometric share creation. Used when regenerating recovery shares.
+     * @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, }: {
         walletId: string;
@@ -840,10 +887,10 @@ export declare abstract class ParaCore {
     }>;
     /**
      * Creates a new wallet.
-     *
-     * @param skipDistribute - if true, recovery share will not be distributed.
-     * @param [customFunction] - {deprecated} method called when createWallet is done.
-     * @returns [wallet, recoveryShare]
+     * @param {Object} opts the options object.
+     * @param {WalletType} opts.type the type of wallet to create.
+     * @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, }?: {
         type?: WalletType;
@@ -858,7 +905,7 @@ export declare abstract class ParaCore {
      * @param {WalletType} [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.
      **/
-    createWalletPreGen(opts: {
+    createPregenWallet(opts: {
         type: WalletType;
         pregenIdentifier: string;
         pregenIdentifierType: TPregenIdentifierType;
@@ -867,11 +914,11 @@ export declare abstract class ParaCore {
      * 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
      * specified in the instance's `supportedWalletTypes` array that are not already present.
-     *
-     * @param {string} pregenIdentifier the identifier to associate each wallet with.
-     * @param {TPregenIdentifierType} pregenIdentifierType - either `'EMAIL'` or `'PHONE'`.
-     * @param {WalletType[]} [types] the wallet types to create. Defaults to any types the instance supports that are not already present.
-     * @returns an array containing the created wallets.
+     * @param {Object} opts the options object.
+     * @param {string} opts.pregenIdentifier the identifier to associate each wallet with.
+     * @param {TPregenIdentifierType} opts.pregenIdentifierType - either `'EMAIL'` or `'PHONE'`.
+     * @param {WalletType[]} [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, pregenIdentifier, pregenIdentifierType, }: {
         pregenIdentifier: string;
@@ -881,17 +928,21 @@ export declare abstract class ParaCore {
     /**
      * Claims a pregenerated wallet.
      *
-     * @param pregenIdentifier string the identifier of the user claiming the wallet
-     * @param pregenIdentifierType type of the identifier of the user claiming the wallet
-     * @returns [wallet, recoveryShare]
+     * @param {Object} opts the options object.
+     * @param {string} opts.pregenIdentifier string the identifier of the user claiming the wallet
+     * @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(pregenIdentifier?: string, pregenIdentifierType?: TPregenIdentifierType): Promise<string | undefined>;
+    claimPregenWallets({ pregenIdentifier, pregenIdentifierType, }?: {
+        pregenIdentifier?: string;
+        pregenIdentifierType?: TPregenIdentifierType;
+    }): Promise<string | undefined>;
     /**
-     * Updates a pregenerated wallet identifier.
-     *
-     * @param newIdentifier - string
-     * @param walletId - string
-     * @returns Promise<void>
+     * Updates the identifier for a pregen wallet.
+     * @param {Object} opts the options object.
+     * @param {string} opts.walletId the pregen wallet ID
+     * @param {string} opts.newPregenIdentifier the new identtifier
+     * @param {TPregenIdentifierType} opts.newPregenIdentifierType: the new identifier type
      **/
     updatePregenWalletIdentifier({ walletId, newPregenIdentifier, newPregenIdentifierType, }: {
         walletId: string;
@@ -899,22 +950,22 @@ export declare abstract class ParaCore {
         newPregenIdentifierType: TPregenIdentifierType;
     }): Promise<void>;
     /**
-     * Checks if Pregen Wallet exists for the identifier and partnerId
-     *
-     * @param pregenIdentifier string the identifier of the user claiming the wallet
-     * @param pregenIdentifierType type of the string of the identifier of the user claiming the wallet
-     * @returns Promise<boolean>
+     * Checks if a pregen Wallet exists for the given identifier with the current partner.
+     * @param {Object} opts the options object.
+     * @param {string} opts.pregenIdentifier string the identifier of the user claiming the wallet
+     * @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({ pregenIdentifier, pregenIdentifierType, }: {
         pregenIdentifier: string;
         pregenIdentifierType: TPregenIdentifierType;
     }): Promise<boolean>;
     /**
-     * Get pregen wallets for the identifier
-     *
-     * @param {string} pregenIdentifier - the identifier of the user claiming the wallet
-     * @param {TPregenIdentifierType} pregenIdentifierType - type of the identifier of the user claiming the wallet
-     * @returns {Promise<WalletEntity[]>} Promise of pregen wallets
+     * Get pregen wallets for the given identifier.
+     * @param {Object} opts the options object.
+     * @param {string} opts.pregenIdentifier - the identifier of the user claiming the wallet
+     * @param {TPregenIdentifierType} opts.pregenIdentifierType - type of the identifier of the user claiming the wallet
+     * @returns {Promise<WalletEntity[]>} the array of found wallets
      **/
     getPregenWallets({ pregenIdentifier, pregenIdentifierType, }?: {
         pregenIdentifier?: string;
@@ -922,28 +973,27 @@ export declare abstract class ParaCore {
     }): Promise<WalletEntity[]>;
     private encodeWalletBase64;
     /**
-     * Returns a base64 encoded wallet
-     *
-     * @returns string base64 encoded wallet
+     * Encodes the current wallets encoded in Base 64.
+     * @returns {string} the encoded wallet string
      **/
     getUserShare(): string | null;
     /**
-     * Sets a wallet from a base 64 encoded wallet
-     *
-     * @param base64Wallet
-     * @returns Promise<void>
+     * Sets the current wallets from a Base 64 string.
+     * @param {string} base64Wallet the encoded wallet string
      **/
     setUserShare(base64Wallets: string | null): Promise<void>;
     private getTransactionReviewUrl;
     private getOnRampTransactionUrl;
     /**
-     * Signs a message.
+     * Signs a message using one of the current wallets.
      *
      * If you want to sign the keccak256 hash of a message, hash the
      * message first and then pass in the base64 encoded hash.
-     * @param walletId - id of the wallet to sign with.
-     * @param messageBase64 - base64 encoding of exact message that should be signed
-     * @param timeout - optional timeout in milliseconds. If not present, defaults to 30 seconds.
+     * @param {Object} opts the options object.
+     * @param {string} opts.walletId the id of the wallet to sign with.
+     * @param {string} opts.messageBase64 the base64 encoding of exact message that should be signed
+     * @param {number} [opts.timeout] optional timeout in milliseconds. If not present, defaults to 30 seconds.
+     * @param {string} [opts.cosmosSignDocBase64] the Cosmos `SignDoc` in base64, if applicable
      **/
     signMessage({ walletId, messageBase64, timeoutMs, cosmosSignDocBase64, }: {
         walletId: string;
@@ -954,9 +1004,11 @@ export declare abstract class ParaCore {
     private signMessageInner;
     /**
      * Signs a transaction.
-     * @param walletId - id of the wallet to sign the transaction from.
-     * @param rlpEncodedTxBase64 - rlp encoded tx as base64 string
-     * @param chainId - chain id of the chain the transaction is being sent on.
+     * @param {Object} opts the options object.
+     * @param {string} opts.walletId the id of the wallet to sign with.
+     * @param {string} opts.rlpEncodedTxBase64 the transaction to sign, in RLP base64 encoding
+     * @param {string} [opts.chainId] the EVM chain id of the chain the transaction is being sent on, if applicable
+     * @param {number} [opts.timeoutMs] the amount of time to wait for the user to sign the transaction, in milliseconds
      **/
     signTransaction({ walletId, rlpEncodedTxBase64, chainId, timeoutMs, }: {
         walletId: string;
@@ -965,6 +1017,7 @@ export declare abstract class ParaCore {
         timeoutMs?: number;
     }): Promise<FullSignatureRes>;
     /**
+     * @deprecated
      * Sends a transaction.
      * @param walletId - id of the wallet to send the transaction from.
      * @param rlpEncodedTxBase64 - rlp encoded tx as base64 string
@@ -978,11 +1031,11 @@ export declare abstract class ParaCore {
     protected isProviderModalDisabled(): boolean;
     /**
      * Starts a on-ramp or off-ramp transaction and returns the Para Portal link for the user to finalize and complete it.
-     * @param {Object} options - the options for the transaction.
-     * @param {OnRampPurchaseCreateParams} options.params - the transaction settings.
-     * @param {boolean} options.shouldOpenPopup - if `true`, a popup window with the link will be opened.
-     * @param {string} options.walletId - the wallet ID to use for the transaction, where funds will be sent or withdrawn.
-     * @param {string} options.externalWalletAddress - the external wallet address to send funds to or withdraw funds from, if using an external wallet.
+     * @param {Object} opts the options object
+     * @param {OnRampPurchaseCreateParams} opts.params the transaction settings.
+     * @param {boolean} opts.shouldOpenPopup if `true`, a popup window with the link will be opened.
+     * @param {string} opts.walletId the wallet ID to use for the transaction, where funds will be sent or withdrawn.
+     * @param {string} opts.externalWalletAddress the external wallet address to send funds to or withdraw funds from, if using an external wallet.
      **/
     initiateOnRampTransaction(options: WalletParams & {
         params: OnRampPurchaseCreateParams;
@@ -992,10 +1045,18 @@ export declare abstract class ParaCore {
         portalUrl: string;
     }>;
     /**
-     * Returns true if session was successfully kept alive, false otherwise.
+     * Returns `true` if session was successfully kept alive, `false` otherwise.
      **/
     keepSessionAlive(): Promise<boolean>;
+    /**
+     * Serialize the current session for import by another Para instance.
+     * @returns {string} the serialized session
+     */
     exportSession(): string;
+    /**
+     * Imports a session serialized by another Para instance.
+     * @param {string} serializedInstanceBase64 the serialized session
+     */
     importSession(serializedInstanceBase64: string): Promise<void>;
     protected exitAccountCreation(): void;
     protected exitLogin(): void;
@@ -1004,8 +1065,8 @@ export declare abstract class ParaCore {
     protected exitLoops(): void;
     /**
      * Logs the user out.
-     *
-     * @param preservePregenWallets - preserves the stored pregen wallets in memory after the logout.
+     * @param {Object} opts the options object.
+     * @param {boolean} opts.clearPregenWallets if `true`, will remove all pregen wallets from storage
      **/
     logout({ clearPregenWallets }?: {
         clearPregenWallets?: boolean;