@getpara/core-sdk 1.11.0 → 2.0.0-alpha.10

package/dist/types/ParaCore.d.ts

@@ -1,17 +1,19 @@
-import Client, { AuthMethod, BackupKitEmailProps, CurrentWalletIds, EmailTheme, WalletEntity, WalletType, WalletParams, OAuthMethod, OnRampPurchaseCreateParams, OnRampPurchase, TPregenIdentifierType, PregenIds, BiometricLocationHint, TelegramAuthResponse, VerifyTelegramRes, Auth, ExternalWalletLoginRes, AccountMetadata } from '@getpara/user-management-client';
+import { AuthMethod, AuthExtras, CurrentWalletIds, EmailTheme, TWalletType, PregenIds, BiometricLocationHint, Auth, SupportedWalletTypes, AuthIdentifier, AuthType, ExternalWalletInfo, PrimaryAuthInfo, SessionInfo, PrimaryAuth, PrimaryAuthType, AccountMetadata } 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, SupportedWalletTypes, PortalUrlOptions, ConstructorOpts, RecoveryStatus, GetWalletBalanceParams, CreateGuestWalletsParams } from './types/index.js';
+import { Ctx, Environment, Theme, WalletFilters, Wallet, PortalUrlOptions, ConstructorOpts, CoreAuthInfo, PortalUrlType, CoreMethodParams, CoreMethodResponse, NewCredentialUrlParams, LoginUrlParams, CoreInterface, ExternalWalletConnectionType } from './types/index.js';
 import { PlatformUtils } from './PlatformUtils.js';
-import { CountryCallingCode } from 'libphonenumber-js';
-export declare abstract class ParaCore {
+export declare abstract class ParaCore implements CoreInterface {
     #private;
     static version?: string;
     ctx: Ctx;
-    email?: string;
-    phone?: string;
-    countryCode?: CountryCallingCode;
-    farcasterUsername?: string;
-    telegramUserId?: string;
+    protected isNativePasskey: boolean;
+    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;
     userId?: string;
     private sessionCookie?;
     private isAwaitingAccountCreation;
@@ -22,13 +24,13 @@ export declare abstract class ParaCore {
     get isPhone(): boolean;
     get isFarcaster(): boolean;
     get isTelegram(): boolean;
-    get externalWalletWithParaAuth(): Wallet | undefined;
     get isExternalWalletAuth(): 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]`.
@@ -112,13 +114,19 @@ 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?;
     get isNoWalletConfig(): boolean;
     get supportedWalletTypes(): SupportedWalletTypes;
-    get isWalletTypeEnabled(): Partial<Record<WalletType, boolean>>;
+    get cosmosPrefix(): string | undefined;
+    get isWalletTypeEnabled(): Partial<Record<TWalletType, boolean>>;
     private platformUtils;
     private localStorageGetItem;
     private localStorageSetItem;
+    private localStorageRemoveItem;
     private sessionStorageGetItem;
     private sessionStorageSetItem;
     private sessionStorageRemoveItem;
@@ -128,7 +136,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;
@@ -144,12 +152,12 @@ 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;
@@ -159,11 +167,11 @@ 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;
+    protected constructPortalUrl(type: PortalUrlType, opts?: PortalUrlOptions): Promise<string>;
     /**
      * Constructs a new `ParaCore` instance.
      * @param env - `Environment` to use.
@@ -171,20 +179,18 @@ export declare abstract class ParaCore {
      * @param opts - Additional constructor options; see `ConstructorOpts`.
      * @returns - A new ParaCore instance.
      */
-    constructor(env: Environment, apiKey?: string, opts?: ConstructorOpts);
+    constructor(env: Environment, apiKey: string, opts?: ConstructorOpts);
+    private trackError;
+    private wrapMethodsWithErrorTracking;
     private initializeFromStorage;
-    private updateTelegramUserIdFromStorage;
+    private updateAuthInfoFromStorage;
     private updateUserIdFromStorage;
-    private updatePhoneFromStorage;
-    private updateCountryCodeFromStorage;
-    private updateEmailFromStorage;
     private updateWalletsFromStorage;
     private updateWalletIdsFromStorage;
     private updateSessionCookieFromStorage;
     private updateLoginEncryptionKeyPairFromStorage;
     private updateExternalWalletsFromStorage;
-    touchSession(regenerate?: boolean): Promise<Awaited<ReturnType<Client['touchSession']>>>;
-    private setSupportedWalletTypes;
+    touchSession(regenerate?: boolean): Promise<SessionInfo>;
     private getVerificationEmailProps;
     private getBackupKitEmailProps;
     /**
@@ -193,6 +199,12 @@ export declare abstract class ParaCore {
      * Init only needs to be called for storage that is async.
      */
     init(): 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.
@@ -208,7 +220,7 @@ export declare abstract class ParaCore {
      * @param phone - Phone number to set.
      * @param countryCode - Country Code to set.
      */
-    setPhoneNumber(phone: string, countryCode: CountryCallingCode): Promise<void>;
+    setPhoneNumber(phone: `+${number}` | string, countryCode?: string): Promise<void>;
     /**
      * Sets the farcaster username associated with the `ParaCore` instance.
      * @param farcasterUsername - Farcaster Username to set.
@@ -246,24 +258,17 @@ 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.
      */
     getEmail(): string | undefined;
-    /**
-     * Gets the phone object associated with the `ParaCore` instance.
-     * @returns - phone object with phone number and country code associated with the `ParaCore` instance.
-     */
-    getPhone(): {
-        phone?: string;
-        countryCode?: string;
-    };
     /**
      * Gets the formatted phone number associated with the `ParaCore` instance.
      * @returns - formatted phone number associated with the `ParaCore` instance.
      */
-    getPhoneNumber(): string | undefined;
+    getPhoneNumber(): `+${number}` | undefined;
     /**
      * Gets the farcaster username associated with the `ParaCore` instance.
      * @returns - farcaster username associated with the `ParaCore` instance.
@@ -280,10 +285,6 @@ export declare abstract class ParaCore {
      * @returns {Promise<AccountMetadata>} the user's account metadata.
      */
     getAccountMetadata(): Promise<AccountMetadata>;
-    /**
-     * The prefix for the instance's managed Cosmos wallets. Defaults to `'cosmos'`.
-     */
-    cosmosPrefix?: string;
     /**
      * 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.
@@ -300,14 +301,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;
+    findWallet(idOrAddress?: string, overrideType?: TWalletType, filter?: WalletFilters): Omit<Wallet, 'signer'> | undefined;
     get availableWallets(): Pick<Wallet, 'id' | 'type' | 'name' | 'address' | 'isExternal'>[];
     /**
      * 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;
@@ -318,29 +319,7 @@ export declare abstract class ParaCore {
      * @param partnerId: string - id of the partner to get the portal URL for
      * @returns - portal URL
      */
-    protected getPortalURL(partnerId?: string): 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>;
+    protected getPortalURL(): 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.
@@ -351,85 +330,25 @@ 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({ 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.
-     */
-    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({ phone, countryCode }: 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>;
-    /**
-     * Returns whether or not the user is connected with only an external wallet, not an external wallet with Para auth.
-     */
-    protected isUsingExternalWallet(): boolean;
-    /**
-     * 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, }: {
-        address: string;
-        signedMessage: string;
-        cosmosPublicKeyHex?: string;
-        cosmosSigner?: string;
-    }): 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>;
+    loginExternalWallet({ externalWallet, ...urlOptions }: CoreMethodParams<'loginExternalWallet'>): CoreMethodResponse<'loginExternalWallet'>;
+    verifyExternalWallet({ externalWallet, signedMessage, cosmosPublicKeyHex, cosmosSigner, ...urlOptions }: CoreMethodParams<'verifyExternalWallet'>): CoreMethodResponse<'verifyExternalWallet'>;
     /**
      * 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>;
+    verifyTelegram({ telegramAuthResponse, ...urlOptions }: CoreMethodParams<'verifyTelegram'>): CoreMethodResponse<'verifyTelegram'>;
     /**
      * Performs 2FA verification.
      * @param {Object} opts the options object
@@ -437,169 +356,66 @@ 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, countryCode, verificationCode, }: {
-        phone: string;
-        countryCode: string;
-        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(): 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): Promise<Set<AuthMethod>>;
+    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[]>;
-    private setAuth;
-    /**
-     * 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 }: Auth & {
-        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: Auth): 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;
-    }): Promise<boolean>;
-    waitForPasskeyAndCreateWallet({ popupWindow, }?: {
-        popupWindow?: Window;
-    }): Promise<AccountSetupResponse>;
+    waitForSignup({ isCanceled, onCancel, onPoll, }: CoreMethodParams<'waitForSignup'>): CoreMethodResponse<'waitForSignup'>;
+    waitForWalletCreation({ isCanceled, onCancel, }?: CoreMethodParams<'waitForWalletCreation'>): CoreMethodResponse<'waitForWalletCreation'>;
     /**
      * 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} the Farcaster connect URI
      */
-    getFarcasterConnectURL(): Promise<string>;
+    getFarcasterConnectUri(): CoreMethodResponse<'getFarcasterConnectUri'>;
     /**
      * 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<{
-        userExists: boolean;
-        username: string;
-        pfpUrl?: string | null;
-    }>;
+    verifyFarcaster({ isCanceled, onConnectUri, onCancel, onPoll, ...urlOptions }: CoreMethodParams<'verifyFarcaster'>): CoreMethodResponse<'verifyFarcaster'>;
     /**
      * 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 {TOAuthMethod} 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>;
+    getOAuthUrl({ method, deeplinkUrl, ...params }: CoreMethodParams<'getOAuthUrl'>): CoreMethodResponse<'getOAuthUrl'>;
     /**
      * 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.
@@ -608,13 +424,7 @@ export declare abstract class ParaCore {
      * @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;
-    }): Promise<{
-        email?: string;
-        isError?: boolean;
-        userExists: boolean;
-    }>;
+    verifyOAuth({ method, deeplinkUrl, isCanceled, onCancel, onPoll, onOAuthUrl, ...urlOptions }: CoreMethodParams<'verifyOAuth'>): CoreMethodResponse<'verifyOAuth'>;
     /**
      * Waits for the session to be active and sets up the user.
      *
@@ -623,10 +433,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;
-        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.
@@ -635,20 +442,12 @@ 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.
      **/
-    protected userSetupAfterLogin(): Promise<{
-        data: {
-            partnerId?: string;
-            needsWallet?: boolean;
-            sessionLookupId: string;
-        };
-    }>;
+    protected userSetupAfterLogin(): Promise<SessionInfo>;
     /**
      * Get transmission shares associated with session.
      * @param {Object} opts the options object.
@@ -664,7 +463,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>;
@@ -677,12 +476,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.
@@ -701,14 +495,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`
@@ -717,17 +504,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.
      *
@@ -740,44 +520,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: Exclude<TPregenIdentifierType, 'GUEST_ID'>;
-    }): 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
@@ -785,26 +537,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: Exclude<TPregenIdentifierType, 'GUEST_ID'>;
-        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.
@@ -812,11 +556,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.
@@ -824,10 +564,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.
@@ -835,25 +572,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[]>;
-    createGuestWallets({ types }?: CreateGuestWalletsParams): Promise<Wallet[]>;
+    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 }: GetWalletBalanceParams) => Promise<string | undefined>;
+    getWalletBalance: ({ walletId, rpcUrl, }: CoreMethodParams<'getWalletBalance'>) => CoreMethodResponse<'getWalletBalance'>;
     /**
      * Signs a message using one of the current wallets.
      *
@@ -865,12 +599,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.
@@ -880,24 +609,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.
@@ -907,13 +619,7 @@ 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.
      **/
@@ -923,24 +629,17 @@ export declare abstract class ParaCore {
      * @param {boolean} excludeSigners - whether or not to exclude the signer from the exported wallets.
      * @returns {string} the serialized session
      */
-    exportSession({ excludeSigners }?: {
-        excludeSigners?: boolean;
-    }): 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'>;
     /**
      * Logs the user out.
      * @param {Object} opts the options object.
@@ -949,6 +648,7 @@ export declare abstract class ParaCore {
     logout({ clearPregenWallets }?: {
         clearPregenWallets?: boolean;
     }): Promise<void>;
+    /** @deprecated */
     protected getSupportedCreateAuthMethods(): Promise<Set<AuthMethod>>;
     /**
      * Converts to a string, removing sensitive data when logging this class.
@@ -956,4 +656,19 @@ export declare abstract class ParaCore {
      * Doesn't work for all types of logging.
      **/
     toString(): string;
+    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'>;
 }