@getpara/core-sdk 2.0.0-dev.0 → 2.0.0-dev.2

package/dist/types/ParaCore.d.ts

@@ -1,11 +1,14 @@
-import { AuthMethod, BackupKitEmailProps, CurrentWalletIds, EmailTheme, WalletEntity, WalletType, WalletParams, OAuthMethod, OnRampPurchaseCreateParams, OnRampPurchase, TPregenIdentifierType, PregenIds, BiometricLocationHint, TelegramAuthResponse, VerifyTelegramRes, Auth, SupportedWalletTypes, AuthIdentifier, ExternalWalletLoginRes, SessionInfo, PrimaryAuth, PrimaryAuthType } from '@getpara/user-management-client';
+import { AuthMethod, AuthExtras, CurrentWalletIds, EmailTheme, TWalletType, PregenIds, BiometricLocationHint, Auth, SupportedWalletTypes, AuthIdentifier, AuthType, ExternalWalletInfo, PrimaryAuthInfo, SessionInfo, PrimaryAuth, PrimaryAuthType, AccountMetadata, LinkedAccounts, VerifyLinkParams, VerifyExternalWalletParams, SupportedAccountLinks } from '@getpara/user-management-client';
 import type { pki as pkiType } from 'node-forge';
-import { Ctx, Environment, Theme, FullSignatureRes, ExternalWalletInfo, GetWebAuthUrlForLoginParams, AccountSetupResponse, LoginResponse, WalletFilters, WalletTypeProp, Wallet, PortalUrlOptions, ConstructorOpts, RecoveryStatus, CoreAuthInfo, AuthExtras, VerifyExternalWallet, ExternalWalletConnectionType } from './types/index.js';
+import { Ctx, Environment, Theme, WalletFilters, Wallet, PortalUrlOptions, ConstructorOpts, CoreAuthInfo, PortalUrlType, CoreMethodParams, CoreMethodResponse, NewCredentialUrlParams, LoginUrlParams, CoreInterface, ExternalWalletConnectionType, AccountLinkInProgress, InternalMethodParams, InternalMethodResponse } from './types/index.js';
 import { PlatformUtils } from './PlatformUtils.js';
-export declare abstract class ParaCore {
+export declare abstract class ParaCore implements CoreInterface {
     #private;
     static version?: string;
     ctx: Ctx;
+    protected isNativePasskey: boolean;
+    protected isPartnerOptional?: boolean;
+    isReady: boolean;
     get authInfo(): CoreAuthInfo | undefined;
     get email(): AuthIdentifier<'email'> | undefined;
     get phone(): AuthIdentifier<'phone'> | undefined;
@@ -14,6 +17,7 @@ export declare abstract class ParaCore {
     get externalWalletWithParaAuth(): Wallet | undefined;
     get externalWalletConnectionType(): ExternalWalletConnectionType;
     userId?: string;
+    accountLinkInProgress: AccountLinkInProgress | undefined;
     private sessionCookie?;
     private isAwaitingAccountCreation;
     private isAwaitingLogin;
@@ -24,12 +28,13 @@ export declare abstract class ParaCore {
     get isFarcaster(): boolean;
     get isTelegram(): boolean;
     get isExternalWalletAuth(): boolean;
+    get isExternalWalletWithVerification(): boolean;
     get partnerId(): 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 currentWalletIdsArray(): [string, WalletType][];
+    get currentWalletIdsArray(): [string, TWalletType][];
     get currentWalletIdsUnique(): string[];
     /**
      * Wallets associated with the `ParaCore` instance. Retrieve a particular wallet using `para.wallets[walletId]`.
@@ -113,10 +118,17 @@ export declare abstract class ParaCore {
      * @deprecated configure theming through the developer portal
      */
     portalTheme?: Theme;
+    /**
+     * Whether or not to treat external wallets as connections only, skipping all Para functionality.
+     */
+    externalWalletConnectionOnly?: boolean;
     private disableProviderModal?;
+    private fetchPregenWalletsOverride?;
+    get isNoWalletConfig(): boolean;
     get supportedWalletTypes(): SupportedWalletTypes;
     get cosmosPrefix(): string | undefined;
-    get isWalletTypeEnabled(): Partial<Record<WalletType, boolean>>;
+    get supportedAccountLinks(): SupportedAccountLinks;
+    get isWalletTypeEnabled(): Partial<Record<TWalletType, boolean>>;
     private platformUtils;
     private localStorageGetItem;
     private localStorageSetItem;
@@ -130,7 +142,7 @@ export declare abstract class ParaCore {
      * Remove all local storage and prefixed session storage.
      * @param {'local' | 'session' | 'secure' | 'all'} type - Type of storage to clear. Defaults to 'all'.
      */
-    clearStorage: (type?: 'local' | 'session' | 'secure' | 'all') => Promise<void>;
+    clearStorage: (type?: CoreMethodParams<"clearStorage">) => CoreMethodResponse<"clearStorage">;
     private convertBigInt;
     private convertEncryptionKeyPair;
     private isPortal;
@@ -146,12 +158,14 @@ export declare abstract class ParaCore {
      * @param {string} walletId the ID of the wallet address to display.
      * @param {object} options additional options for formatting the address.
      * @param {boolean} options.truncate whether to truncate the address.
-     * @param {WalletType} options.addressType the type of address to display.
+     * @param {TWalletType} options.addressType the type of address to display.
      * @returns the formatted address
      */
     getDisplayAddress(walletId: string, options?: {
         truncate?: boolean;
-        addressType?: WalletTypeProp | undefined;
+        addressType?: TWalletType | undefined;
+        cosmosPrefix?: string;
+        targetLength?: number;
     } | undefined): string;
     /**
      * Returns a unique hash for a wallet suitable for use as an identicon seed.
@@ -159,11 +173,12 @@ export declare abstract class ParaCore {
      * @param {boolean} options.addressType used to format the hash for another wallet type.
      * @returns the identicon hash string
      */
-    getIdenticonHash(walletId: string, overrideType?: WalletType): string | undefined;
+    getIdenticonHash(walletId: string, overrideType?: TWalletType): string | undefined;
     getWallets(): Record<string, Wallet>;
     getAddress(walletId?: string): string | undefined;
     protected abstract getPlatformUtils(): PlatformUtils;
-    private constructPortalUrl;
+    abstract isPasskeySupported(): Promise<boolean>;
+    protected constructPortalUrl(type: PortalUrlType, opts?: PortalUrlOptions): Promise<string>;
     /**
      * Constructs a new `ParaCore` instance.
      * @param env - `Environment` to use.
@@ -172,6 +187,8 @@ export declare abstract class ParaCore {
      * @returns - A new ParaCore instance.
      */
     constructor(env: Environment, apiKey: string, opts?: ConstructorOpts);
+    private trackError;
+    private wrapMethodsWithErrorTracking;
     private initializeFromStorage;
     private updateAuthInfoFromStorage;
     private updateUserIdFromStorage;
@@ -189,10 +206,13 @@ export declare abstract class ParaCore {
      * Init only needs to be called for storage that is async.
      */
     init(): Promise<void>;
+    protected abstract ready(): Promise<void>;
     protected setAuth(auth: PrimaryAuth, { extras, userId }?: {
         extras?: AuthExtras;
         userId?: string;
     }): Promise<typeof this.authInfo>;
+    protected assertUserId(): string;
+    protected assertIsAuthSet(allowed?: AuthType[]): PrimaryAuthInfo;
     /**
      * Sets the email associated with the `ParaCore` instance.
      * @param email - Email to set.
@@ -219,7 +239,7 @@ export declare abstract class ParaCore {
      * @param externalAddress - External wallet address to set.
      * @param externalType - Type of external wallet to set.
      */
-    setExternalWallet({ address, type, provider, addressBech32, withFullParaAuth }: ExternalWalletInfo): Promise<void>;
+    setExternalWallet(externalWallet: ExternalWalletInfo[] | ExternalWalletInfo): Promise<void>;
     /**
      * Sets the user id associated with the `ParaCore` instance.
      * @param userId - User id to set.
@@ -246,6 +266,7 @@ export declare abstract class ParaCore {
      * @returns - userId associated with the `ParaCore` instance.
      */
     getUserId(): string | undefined;
+    getAuthInfo(): CoreAuthInfo | undefined;
     /**
      * Gets the email associated with the `ParaCore` instance.
      * @returns - email associated with the `ParaCore` instance.
@@ -266,6 +287,13 @@ export declare abstract class ParaCore {
         sessionLookupId?: string;
         newDeviceSessionLookupId?: string;
     }): 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.
+     * @deprecated use `para.getLinkedAccounts({ withMetadata: true })` instead.
+     * @returns {Promise<AccountMetadata>} the user's account metadata.
+     */
+    getAccountMetadata(): Promise<AccountMetadata>;
     /**
      * Validates that a wallet ID is present on the instance, usable, and matches the desired filters.
      * If no ID is passed, this will instead return the first valid, usable wallet ID that matches the filters.
@@ -282,14 +310,14 @@ export declare abstract class ParaCore {
      * @returns {string} the wallet ID originally passed, or the one found.
      */
     findWalletByAddress(address: string, filter?: WalletFilters | undefined): any;
-    findWallet(idOrAddress?: string, overrideType?: WalletTypeProp, filter?: WalletFilters): Omit<Wallet, 'signer'> | undefined;
-    get availableWallets(): Pick<Wallet, 'id' | 'type' | 'name' | 'address' | 'isExternal'>[];
+    findWallet(idOrAddress?: string, overrideType?: TWalletType, filter?: WalletFilters): Omit<Wallet, 'signer'> | undefined;
+    get availableWallets(): Pick<Wallet, 'id' | 'type' | 'name' | 'address' | 'isExternal' | 'externalProviderId' | 'isExternalConnectionOnly'>[];
     /**
      * 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: WalletTypeProp): Wallet[];
+    getWalletsByType(type: CoreMethodParams<'getWalletsByType'>): CoreMethodResponse<'getWalletsByType'>;
     private assertIsValidWalletId;
     private assertIsValidWalletType;
     private getMissingTypes;
@@ -301,28 +329,6 @@ export declare abstract class ParaCore {
      * @returns - portal URL
      */
     protected getPortalURL(): Promise<string>;
-    private getWebAuthURLForCreate;
-    private getPasswordURLForCreate;
-    private getShortUrl;
-    shortenLoginLink(link: string): Promise<string>;
-    /**
-     * Generates a URL for registering a new WebAuth passkey.
-     * @param {GetWebAuthUrlForLoginParams} opts the options object
-     * @returns - the URL for creating a new passkey
-     */
-    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 for registering a new WebAuth passkey for a phone number.
-     * @param {Omit<GetWebAuthUrlForLoginParams, 'authType'>} opts the options object
-     * @returns - web auth url
-     */
-    getWebAuthURLForLoginForPhone(opts: Omit<GetWebAuthUrlForLoginParams, 'authType'>): Promise<string>;
     /**
      * Gets the private key for the given wallet.
      * @param {string } [walletId] id of the wallet to get the private key for. Will default to the first wallet if not provided.
@@ -333,73 +339,27 @@ export declare abstract class ParaCore {
      * Fetches the wallets associated with the user.
      * @returns {WalletEntity[]} wallets that were fetched.
      */
-    fetchWallets(): Promise<WalletEntity[]>;
+    fetchWallets(): CoreMethodResponse<'fetchWallets'>;
     private populateWalletAddresses;
     private populatePregenWalletAddresses;
-    /**
-     * 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 }: {
-        email: string;
-    }): Promise<boolean>;
-    /**
-     * 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(auth: Auth<'phone'>): Promise<boolean>;
-    /**
-     * Creates a new user.
-     * @param {Object} opts the options object
-     * @param {string} opts.email the email to use.
-     */
-    createUser({ email }: Auth<'email'>): Promise<void>;
-    /**
-     * Creates a new user with a phone number.
-     * @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(auth: Auth<'phone'>): Promise<void>;
     /**
      * Logs in or creates a new user using an external wallet address.
      * @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 {TWalletType} 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<ExternalWalletLoginRes>;
-    /**
-     * Passes the email code obtained from the user for verification.
-     * @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 }: {
-        verificationCode: string;
-    }): Promise<string>;
-    verifyExternalWallet({ address, signedMessage, cosmosPublicKeyHex, cosmosSigner, }: VerifyExternalWallet): Promise<string>;
-    /**
-     * Passes the phone code obtained from the user for verification.
-     * @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 }: {
-        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.
-     * @param authResponse - the response JSON object received from the Telegram widget.
-     * @returns `{ isValid: boolean; telegramUserId?: string; userId?: string; isNewUser?: boolean; supportedAuthMethods?: AuthMethod[]; biometricHints?: BiometricLocationHint[] }`
-     */
-    verifyTelegram(authObject: TelegramAuthResponse): Promise<VerifyTelegramRes>;
+    loginExternalWallet({ externalWallet, ...urlOptions }: CoreMethodParams<'loginExternalWallet'>): CoreMethodResponse<'loginExternalWallet'>;
+    verifyExternalWallet({ externalWallet, signedMessage, cosmosPublicKeyHex, cosmosSigner, ...urlOptions }: CoreMethodParams<'verifyExternalWallet'>): CoreMethodResponse<'verifyExternalWallet'>;
+    protected verifyExternalWalletLink(opts: InternalMethodParams<'verifyExternalWalletLink'>): InternalMethodResponse<'verifyExternalWalletLink'>;
+    protected verifyTelegramProcess(opts: CoreMethodParams<'verifyTelegram'> & {
+        isLinkAccount: false;
+    }): CoreMethodResponse<'verifyTelegram'>;
+    protected verifyTelegramProcess(opts: InternalMethodParams<'verifyTelegramLink'> & {
+        isLinkAccount: true;
+    }): InternalMethodResponse<'verifyTelegramLink'>;
+    verifyTelegram(opts: CoreMethodParams<'verifyTelegram'>): CoreMethodResponse<'verifyTelegram'>;
+    protected verifyTelegramLink(opts: InternalMethodParams<'verifyTelegramLink'>): InternalMethodResponse<'verifyTelegramLink'>;
     /**
      * Performs 2FA verification.
      * @param {Object} opts the options object
@@ -407,181 +367,70 @@ export declare abstract class ParaCore {
      * @param {string} opts.verificationCode the verification code to received via 2FA.
      * @returns {Object} `{ address, initiatedAt, status, userId, walletId }`
      */
-    verify2FA({ email, verificationCode }: {
-        email: string;
-        verificationCode: string;
-    }): Promise<{
-        initiatedAt?: Date;
-        status?: RecoveryStatus;
-        userId: string;
-        wallets: Pick<Wallet, 'address' | 'id'>[];
-    }>;
-    /**
-     * Performs 2FA verification.
-     * @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, verificationCode, }: Auth<'phone'> & {
-        verificationCode: string;
-    }): Promise<{
-        initiatedAt?: Date;
-        status?: RecoveryStatus;
-        userId: string;
-        wallets: Pick<Wallet, 'address' | 'id'>[];
-    }>;
+    verify2fa({ auth, verificationCode }: CoreMethodParams<'verify2fa'>): CoreMethodResponse<'verify2fa'>;
     /**
      * Sets up two-factor authentication for the current user.
      * @returns {string} uri - uri to use for setting up 2FA
      * */
-    setup2FA(): Promise<{
-        uri?: string;
-    }>;
+    setup2fa(): CoreMethodResponse<'setup2fa'>;
     /**
      * Enables 2FA.
      * @param {Object} opts the options object
      * @param {string} opts.verificationCode - the verification code received via 2FA.
      */
-    enable2FA({ verificationCode }: {
-        verificationCode: string;
-    }): Promise<void>;
-    /**
-     * Determines if 2FA has been set up.
-     * @returns {Object} `{ isSetup: boolean }` - true if 2FA is setup, false otherwise
-     */
-    check2FAStatus(): Promise<{
-        isSetup: boolean;
-    }>;
+    enable2fa({ verificationCode }: CoreMethodParams<'enable2fa'>): CoreMethodResponse<'enable2fa'>;
     /**
      * 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>;
+    resendVerificationCode({ type: reason, }: CoreMethodParams<'resendVerificationCode'>): CoreMethodResponse<'resendVerificationCode'>;
     /**
      * Checks if the current session is active.
      * @returns `true` if active, `false` otherwise
      */
-    isSessionActive(): Promise<boolean>;
+    isSessionActive(): CoreMethodResponse<'isSessionActive'>;
     /**
      * Checks if a session is active and a wallet exists.
      * @returns `true` if active, `false` otherwise
      **/
-    isFullyLoggedIn(): Promise<boolean>;
+    isFullyLoggedIn(): CoreMethodResponse<'isFullyLoggedIn'>;
+    get isGuestMode(): boolean;
     protected supportedAuthMethods(auth: Auth<PrimaryAuthType | 'userId'>): Promise<Set<AuthMethod>>;
     /**
      * Get hints associated with the users stored biometrics.
+     * @deprecated
      * @returns Array containing useragents and AAGuids for stored biometrics
      */
     protected getUserBiometricLocationHints(): Promise<BiometricLocationHint[]>;
-    /**
-     * Initiates a login.
-     * @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 }: PrimaryAuth & {
-        useShortUrl?: boolean;
-    }): Promise<string>;
-    /**
-     * Initiates a login.
-     * @param email - the email to login with
-     * @returns - a set of supported auth methods for the user
-     **/
-    initiateUserLoginV2(auth: PrimaryAuth): Promise<Set<AuthMethod>>;
-    /**
-     * Initiates a login.
-     * @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;
-    }): Promise<string>;
     /**
      * Waits for the session to be active.
      **/
-    waitForAccountCreation({ popupWindow }?: {
-        popupWindow?: Window | null;
-    }): Promise<boolean>;
-    waitForPasskeyAndCreateWallet({ popupWindow, }?: {
-        popupWindow?: Window;
-    }): Promise<AccountSetupResponse>;
-    /**
-     * Initiates a Farcaster login attempt and return the URI for the user to connect.
+    waitForSignup({ isCanceled, onCancel, onPoll, }: CoreMethodParams<'waitForSignup'>): CoreMethodResponse<'waitForSignup'>;
+    waitForWalletCreation({ isCanceled, onCancel, }?: CoreMethodParams<'waitForWalletCreation'>): CoreMethodResponse<'waitForWalletCreation'>;
+    /**
+     * 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.
      * @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.
-     * @return {Object} `{userExists: boolean; username: string; pfpUrl?: string | null }` - the user's information and whether the user already exists.
-     */
-    waitForFarcasterStatus(): Promise<{
-        userId: string;
-        userExists: boolean;
-        username: string;
-        pfpUrl?: string | null;
-    }>;
-    /**
-     * Generates a URL for the user to log in with OAuth using a desire method.
-     *
-     * @param {Object} opts the options object
-     * @param {OAuthMethod} opts.method the third-party service to use for OAuth.
-     * @param {string} [opts.deeplinkUrl] the deeplink 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({ method, deeplinkUrl }: {
-        method: OAuthMethod;
-        deeplinkUrl?: string;
-    }): 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} `{ email?: string; isError?: boolean; userExists: boolean; }` the result data
-     */
-    waitForOAuth({ popupWindow }?: {
-        popupWindow?: Window | null;
-    }): Promise<{
-        email?: string;
-        isError?: boolean;
-        userExists: boolean;
-    }>;
+    getFarcasterConnectUri({ appScheme }?: {
+        appScheme?: string;
+    }): CoreMethodResponse<'getFarcasterConnectUri'>;
+    protected verifyFarcasterProcess(opts: CoreMethodParams<'verifyFarcaster'> & {
+        isLinkAccount: false;
+    }): CoreMethodResponse<'verifyFarcaster'>;
+    protected verifyFarcasterProcess(opts: InternalMethodParams<'verifyFarcasterLink'> & {
+        isLinkAccount: true;
+    }): InternalMethodResponse<'verifyFarcasterLink'>;
+    verifyFarcaster(opts: CoreMethodParams<'verifyFarcaster'>): CoreMethodResponse<'verifyFarcaster'>;
+    protected verifyFarcasterLink(opts: InternalMethodParams<'verifyFarcasterLink'>): InternalMethodResponse<'verifyFarcasterLink'>;
+    getOAuthUrl(opts: CoreMethodParams<'getOAuthUrl'>): CoreMethodResponse<'getOAuthUrl'>;
+    protected verifyOAuthProcess(_: InternalMethodParams<'verifyOAuthLink'> & {
+        isLinkAccount: true;
+    }): InternalMethodResponse<'verifyOAuthLink'>;
+    protected verifyOAuthProcess(_: CoreMethodParams<'verifyOAuth'> & {
+        isLinkAccount: false;
+    }): CoreMethodResponse<'verifyOAuth'>;
+    verifyOAuth(opts: CoreMethodParams<'verifyOAuth'>): CoreMethodResponse<'verifyOAuth'>;
+    protected verifyOAuthLink(opts: InternalMethodParams<'verifyOAuthLink'>): InternalMethodResponse<'verifyOAuthLink'>;
     /**
      * Waits for the session to be active and sets up the user.
      *
@@ -590,10 +439,7 @@ export declare abstract class ParaCore {
      * @param {boolean} [opts.skipSessionRefresh] whether to skip refreshing the session.
      * @returns {Object} `{ isComplete: boolean; isError: boolean; needsWallet: boolean; partnerId: string; }` the result data
      **/
-    waitForLoginAndSetup({ popupWindow, skipSessionRefresh, }?: {
-        popupWindow?: Window | null;
-        skipSessionRefresh?: boolean;
-    }): Promise<LoginResponse>;
+    waitForLogin({ isCanceled, onCancel, onPoll, skipSessionRefresh, }?: CoreMethodParams<'waitForLogin'>): CoreMethodResponse<'waitForLogin'>;
     /**
      * Updates the session with the user management server, possibly
      * opening a popup to refresh the session.
@@ -602,9 +448,7 @@ export declare abstract class ParaCore {
      * @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 }?: {
-        shouldOpenPopup?: boolean;
-    }): Promise<string>;
+    refreshSession({ shouldOpenPopup, }?: CoreMethodParams<'refreshSession'>): CoreMethodResponse<'refreshSession'>;
     /**
      * Call this method after login to ensure that the user ID is set
      * internally.
@@ -625,7 +469,7 @@ export declare abstract class ParaCore {
      * @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, }?: {
+    protected setupAfterLogin({ temporaryShares, skipSessionRefresh, }?: {
         temporaryShares?: any[];
         skipSessionRefresh?: boolean;
     }): Promise<void>;
@@ -638,12 +482,7 @@ export declare abstract class ParaCore {
      * @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;
-        userShare?: string;
-        skipBiometricShareCreation?: boolean;
-        forceRefresh?: boolean;
-    }): Promise<string>;
+    distributeNewWalletShare({ walletId, userShare, skipBiometricShareCreation, forceRefresh, }: CoreMethodParams<'distributeNewWalletShare'>): CoreMethodResponse<'distributeNewWalletShare'>;
     private waitForWalletAddress;
     /**
      * Waits for a pregen wallet address to be created.
@@ -662,14 +501,7 @@ export declare abstract class ParaCore {
      *
      * @deprecated alias for `createWalletPerType`
      **/
-    createWalletPerMissingType: ({ skipDistribute, types, }?: {
-        skipDistribute?: boolean;
-        types?: WalletType[];
-    }) => Promise<{
-        wallets: Wallet[];
-        walletIds: CurrentWalletIds;
-        recoverySecret?: string;
-    }>;
+    createWalletPerMissingType: ({ skipDistribute, types, }?: CoreMethodParams<"createWalletPerType">) => CoreMethodResponse<"createWalletPerType">;
     /**
      * 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`
@@ -678,17 +510,10 @@ export declare abstract class ParaCore {
      *
      * @param {Object} [opts] the options object.
      * @param {boolean} [opts.skipDistribute] if `true`, the wallets' recovery share will not be distributed.
-     * @param {WalletType[]} [opts.types] the types of wallets to create.
+     * @param {TWalletType[]} [opts.types] the types of wallets to create.
      * @returns {Object} the wallets created, their ids, and the recovery secret.
      **/
-    createWalletPerType({ skipDistribute, types, }?: {
-        skipDistribute?: boolean;
-        types?: WalletType[];
-    }): Promise<{
-        wallets: Wallet[];
-        walletIds: CurrentWalletIds;
-        recoverySecret?: string;
-    }>;
+    createWalletPerType({ skipDistribute, types, }?: CoreMethodParams<'createWalletPerType'>): CoreMethodResponse<'createWalletPerType'>;
     /**
      * Refresh the current user share for a wallet.
      *
@@ -701,44 +526,16 @@ export declare abstract class ParaCore {
      * @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, }: {
-        walletId: string;
-        share: string;
-        oldPartnerId?: string;
-        newPartnerId?: string;
-        keyShareProtocolId?: string;
-        redistributeBackupEncryptedShares?: boolean;
-        emailProps?: BackupKitEmailProps;
-    }): Promise<{
-        signer: string;
-        recoverySecret?: string;
-        protocolId: string;
-    }>;
+    refreshShare({ walletId, share, oldPartnerId, newPartnerId, keyShareProtocolId, redistributeBackupEncryptedShares, }: CoreMethodParams<'refreshShare'>): CoreMethodResponse<'refreshShare'>;
     /**
      * Creates a new wallet.
      * @param {Object} opts the options object.
-     * @param {WalletType} opts.type the type of wallet to create.
+     * @param {TWalletType} 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;
-        skipDistribute?: boolean;
-    }): Promise<[Wallet, string | null]>;
-    /**
-     * 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 {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.
-     **/
-    createPregenWallet(opts: {
-        type: WalletType;
-        pregenIdentifier: string;
-        pregenIdentifierType: TPregenIdentifierType;
-    }): Promise<Wallet>;
+    createWallet({ type: _type, skipDistribute, }?: CoreMethodParams<'createWallet'>): CoreMethodResponse<'createWallet'>;
+    createPregenWallet(opts: CoreMethodParams<'createPregenWallet'>): CoreMethodResponse<'createPregenWallet'>;
     /**
      * 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
@@ -746,26 +543,18 @@ export declare abstract class ParaCore {
      * @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.
+     * @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, pregenIdentifier, pregenIdentifierType, }: {
-        pregenIdentifier: string;
-        pregenIdentifierType: TPregenIdentifierType;
-        types?: WalletType[];
-    }): Promise<Wallet[]>;
+    createPregenWalletPerType({ types, pregenId, }: CoreMethodParams<'createPregenWalletPerType'>): CoreMethodResponse<'createPregenWalletPerType'>;
     /**
      * Claims a pregenerated wallet.
-     *
      * @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, pregenIdentifierType, }?: {
-        pregenIdentifier?: string;
-        pregenIdentifierType?: TPregenIdentifierType;
-    }): Promise<string | undefined>;
+    claimPregenWallets({ pregenId, }?: CoreMethodParams<'claimPregenWallets'>): CoreMethodResponse<'claimPregenWallets'>;
     /**
      * Updates the identifier for a pregen wallet.
      * @param {Object} opts the options object.
@@ -773,11 +562,7 @@ export declare abstract class ParaCore {
      * @param {string} opts.newPregenIdentifier the new identtifier
      * @param {TPregenIdentifierType} opts.newPregenIdentifierType: the new identifier type
      **/
-    updatePregenWalletIdentifier({ walletId, newPregenIdentifier, newPregenIdentifierType, }: {
-        walletId: string;
-        newPregenIdentifier: string;
-        newPregenIdentifierType: TPregenIdentifierType;
-    }): Promise<void>;
+    updatePregenWalletIdentifier({ walletId, newPregenId, }: CoreMethodParams<'updatePregenWalletIdentifier'>): CoreMethodResponse<'updatePregenWalletIdentifier'>;
     /**
      * Checks if a pregen Wallet exists for the given identifier with the current partner.
      * @param {Object} opts the options object.
@@ -785,10 +570,7 @@ export declare abstract class ParaCore {
      * @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>;
+    hasPregenWallet({ pregenId }: CoreMethodParams<'hasPregenWallet'>): CoreMethodResponse<'hasPregenWallet'>;
     /**
      * Get pregen wallets for the given identifier.
      * @param {Object} opts the options object.
@@ -796,23 +578,22 @@ export declare abstract class ParaCore {
      * @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;
-        pregenIdentifierType?: TPregenIdentifierType;
-    }): Promise<WalletEntity[]>;
+    getPregenWallets({ pregenId }?: CoreMethodParams<'getPregenWallets'>): CoreMethodResponse<'getPregenWallets'>;
+    createGuestWallets(): CoreMethodResponse<'createGuestWallets'>;
     private encodeWalletBase64;
     /**
      * Encodes the current wallets encoded in Base 64.
      * @returns {string} the encoded wallet string
      **/
-    getUserShare(): string | null;
+    getUserShare(): CoreMethodResponse<'getUserShare'>;
     /**
      * Sets the current wallets from a Base 64 string.
      * @param {string} base64Wallet the encoded wallet string
      **/
-    setUserShare(base64Wallets: string | null): Promise<void>;
+    setUserShare(base64Wallets: CoreMethodParams<'setUserShare'>): CoreMethodResponse<'setUserShare'>;
     private getTransactionReviewUrl;
     private getOnRampTransactionUrl;
+    getWalletBalance: ({ walletId, rpcUrl, }: CoreMethodParams<"getWalletBalance">) => CoreMethodResponse<"getWalletBalance">;
     /**
      * Signs a message using one of the current wallets.
      *
@@ -824,12 +605,7 @@ export declare abstract class ParaCore {
      * @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;
-        messageBase64: string;
-        timeoutMs?: number;
-        cosmosSignDocBase64?: string;
-    }): Promise<FullSignatureRes>;
+    signMessage({ walletId, messageBase64, timeoutMs, cosmosSignDocBase64, isCanceled, onCancel, onPoll, }: CoreMethodParams<'signMessage'>): CoreMethodResponse<'signMessage'>;
     private signMessageInner;
     /**
      * Signs a transaction.
@@ -839,24 +615,7 @@ export declare abstract class ParaCore {
      * @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;
-        rlpEncodedTxBase64: string;
-        chainId: string;
-        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
-     * @param chainId - chain id of the chain the transaction is being sent on.
-     **/
-    sendTransaction({ walletId, rlpEncodedTxBase64, chainId, }: {
-        walletId: string;
-        rlpEncodedTxBase64: string;
-        chainId: string;
-    }): Promise<FullSignatureRes>;
+    signTransaction({ walletId, rlpEncodedTxBase64, chainId, timeoutMs, isCanceled, onCancel, onPoll, }: CoreMethodParams<'signTransaction'>): CoreMethodResponse<'signTransaction'>;
     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.
@@ -866,37 +625,28 @@ export declare abstract class ParaCore {
      * @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;
-        shouldOpenPopup?: boolean;
-    }): Promise<{
-        onRampPurchase: OnRampPurchase;
-        portalUrl: string;
-    }>;
+    initiateOnRampTransaction(options: CoreMethodParams<'initiateOnRampTransaction'>): CoreMethodResponse<'initiateOnRampTransaction'>;
     /**
      * Returns `true` if session was successfully kept alive, `false` otherwise.
      **/
     keepSessionAlive(): Promise<boolean>;
     /**
      * Serialize the current session for import by another Para instance.
+     * @param {boolean} excludeSigners - whether or not to exclude the signer from the exported wallets.
      * @returns {string} the serialized session
      */
-    exportSession(): string;
+    exportSession({ excludeSigners }?: CoreMethodParams<'exportSession'>): CoreMethodResponse<'exportSession'>;
     /**
      * 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;
-    protected exitFarcaster(): void;
-    protected exitOAuth(): void;
-    protected exitLoops(): void;
+    importSession(serializedInstanceBase64: CoreMethodParams<'importSession'>): CoreMethodResponse<'importSession'>;
     /**
      * Retrieves a token to verify the current session.
      * @returns {Promise<string>} the ID
      **/
-    getVerificationToken(): Promise<string>;
+    getVerificationToken(): CoreMethodResponse<'getVerificationToken'>;
+    issueJwt({ keyIndex }?: CoreMethodParams<'issueJwt'>): CoreMethodResponse<'issueJwt'>;
     /**
      * Logs the user out.
      * @param {Object} opts the options object.
@@ -905,11 +655,34 @@ export declare abstract class ParaCore {
     logout({ clearPregenWallets }?: {
         clearPregenWallets?: boolean;
     }): Promise<void>;
-    protected getSupportedCreateAuthMethods(): Promise<Set<AuthMethod>>;
+    protected get toStringAdditions(): Record<string, unknown>;
     /**
      * Converts to a string, removing sensitive data when logging this class.
      *
      * Doesn't work for all types of logging.
      **/
     toString(): string;
+    protected devLog(...s: string[]): void;
+    protected getNewCredentialAndUrl({ authMethod, isForNewDevice, portalTheme, shorten, }?: NewCredentialUrlParams): Promise<{
+        credentialId: string;
+        url?: string;
+    }>;
+    /**
+     * Returns a Para Portal URL for logging in with a WebAuth passkey or a password.
+     * @param {Object} opts the options object
+     * @param {String} opts.auth - the user auth to sign up or log in with, in the form ` { email: string } | { phone: `+${number}` } `
+     * @param {boolean} opts.useShortUrls - whether to shorten the generated portal URLs
+     * @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>;
+    signUpOrLogIn({ auth, ...urlOptions }: CoreMethodParams<'signUpOrLogIn'>): CoreMethodResponse<'signUpOrLogIn'>;
+    verifyNewAccount({ verificationCode, ...urlOptions }: CoreMethodParams<'verifyNewAccount'>): CoreMethodResponse<'verifyNewAccount'>;
+    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>;
+    protected verifyEmailOrPhoneLink({ verificationCode, }: InternalMethodParams<'verifyEmailOrPhoneLink'>): InternalMethodResponse<'verifyEmailOrPhoneLink'>;
 }