@mocanetwork/airkit 0.5.0-beta.2

package/dist/types/common/realm/user/types.d.ts

@@ -0,0 +1,78 @@
+export type AuthCredentials = {
+    accessToken: string;
+    refreshToken: string;
+    partnerAccessToken: string;
+};
+export type RealmDetailsV1 = {
+    name?: string;
+    node: string;
+    status: "not_minted" | "minting" | "minted";
+    tokenId?: string;
+    imageUrl?: string;
+    eoaAddress?: string;
+    abstractAccountAddress?: string;
+    partnerUserId?: string;
+};
+export type AirIdDetails = {
+    id: string;
+    name?: string;
+    node: string;
+    status: "not_minted" | "minting" | "minted";
+    tokenId?: string;
+    imageUrl?: string;
+};
+export type MintTransaction = {
+    id: string;
+    transactionHash: string;
+};
+export type GlobalId = {
+    id: string;
+    abstractAccountAddress: string;
+};
+export type RealmUserV1 = {
+    realmId: RealmDetailsV1;
+    mintTransaction?: MintTransaction;
+};
+export type LoggedInLoginResponse = {
+    status: "logged_in";
+} & AuthCredentials & {
+    user: GlobalId;
+};
+type PartnerLinkageRequiredLoginResponse = {
+    status: "partner_linkage_required";
+} & AuthCredentials & {
+    user: GlobalId;
+};
+export type LoggedInLoginV1Response = {
+    status: "logged_in";
+} & AuthCredentials & RealmUserV1;
+type PartnerLinkageRequiredLoginV1Response = {
+    status: "partner_linkage_required";
+} & AuthCredentials & RealmUserV1;
+type EmailRequiredLoginResponse = {
+    status: "email_required";
+};
+type EmailVerificationRequiredLoginResponse = {
+    status: "email_verification_required";
+    email: string;
+};
+type LoginRequiredLoginResponse = {
+    status: "login_required";
+};
+export type LoginResponse = LoggedInLoginResponse | PartnerLinkageRequiredLoginResponse | EmailRequiredLoginResponse | EmailVerificationRequiredLoginResponse | LoginRequiredLoginResponse;
+export type LoginV1Response = LoggedInLoginV1Response | PartnerLinkageRequiredLoginV1Response | EmailRequiredLoginResponse | EmailVerificationRequiredLoginResponse | LoginRequiredLoginResponse;
+export type MeResponseV1 = {
+    realmId: RealmDetailsV1;
+};
+export type MeResponse = {
+    user: GlobalId & {
+        email?: string;
+        airIds: Omit<AirIdDetails, "id">[];
+    };
+};
+export type PartnerUserResponse = {
+    partnerId: string;
+    partnerUserId: string;
+    airId?: Omit<AirIdDetails, "id">;
+};
+export {};

package/dist/types/common/realm/wallet/bybit/bybit.d.ts

@@ -0,0 +1,2 @@
+import { RealmLoginWallet } from "..";
+export declare const BYBIT: RealmLoginWallet;

package/dist/types/common/realm/wallet/coinbase/coinbase.d.ts

@@ -0,0 +1,2 @@
+import { RealmLoginWallet } from "..";
+export declare const COINBASE: RealmLoginWallet;

package/dist/types/common/realm/wallet/cryptoCom/cryptoCom.d.ts

@@ -0,0 +1,2 @@
+import { RealmLoginWallet } from "..";
+export declare const CRYPTO_COM: RealmLoginWallet;

package/dist/types/common/realm/wallet/index.d.ts

@@ -0,0 +1,22 @@
+export interface RealmLoginWallet {
+    id: string;
+    rdns: string;
+    name: string;
+    displayName?: string;
+    icon?: string;
+    downloadUrls?: Record<string, string>;
+    mobile?: Record<string, string>;
+    supportRequestPermissions: boolean;
+    supportMobileWalletConnectDeeplink: boolean;
+}
+export declare const WALLET_MAP: Record<string, RealmLoginWallet>;
+export declare const WALLET_RDNS_MAP: Record<string, RealmLoginWallet>;
+export type RealmLoginWalletId = keyof typeof WALLET_MAP;
+export declare const DEFAULT_LOGIN_METHODS: Array<RealmLoginWalletId>;
+export declare const DEFAULT_SIGNUP_METHODS: Array<RealmLoginWalletId>;
+export declare const DEFAULT_RECOMMENDED_WALLETS: Array<RealmLoginWalletId>;
+export type WalletToken = {
+    type: "wallet" | string;
+    partnerId: string;
+    nonce: string;
+};

package/dist/types/common/realm/wallet/metamask/metamask.d.ts

@@ -0,0 +1,2 @@
+import { RealmLoginWallet } from "..";
+export declare const METAMASK: RealmLoginWallet;

package/dist/types/common/realm/wallet/okx/okx.d.ts

@@ -0,0 +1,2 @@
+import { RealmLoginWallet } from "..";
+export declare const OKX: RealmLoginWallet;

package/dist/types/common/realm/wallet/phantom/phantom.d.ts

@@ -0,0 +1,2 @@
+import { RealmLoginWallet } from "..";
+export declare const PHANTOM: RealmLoginWallet;

package/dist/types/common/realm/wallet/rabby/rabby.d.ts

@@ -0,0 +1,2 @@
+import { RealmLoginWallet } from "..";
+export declare const RABBY: RealmLoginWallet;

package/dist/types/common/realm/wallet/rainbow/rainbow.d.ts

@@ -0,0 +1,2 @@
+import { RealmLoginWallet } from "..";
+export declare const RAINBOW: RealmLoginWallet;

package/dist/types/common/realm/wallet/trust/trust.d.ts

@@ -0,0 +1,2 @@
+import { RealmLoginWallet } from "..";
+export declare const TRUST: RealmLoginWallet;

package/dist/types/common/types.d.ts

@@ -0,0 +1,8 @@
+export type Jsonable = string | number | boolean | null | undefined | readonly Jsonable[] | {
+    readonly [key: string]: Jsonable;
+} | {
+    toJSON(): Jsonable;
+};
+export type Optional<T, K extends keyof T> = Omit<T, K> & {
+    [P in keyof T]?: T[P] | undefined;
+};

package/dist/types/common/utils.d.ts

@@ -0,0 +1,2 @@
+import { AirIdDetails } from "./realm/user/types";
+export declare const parseAirId: (airIdDetail?: Omit<AirIdDetails, "id">) => string | undefined;

package/dist/types/communicationProvider.d.ts

@@ -0,0 +1,82 @@
+import { ProviderEvents } from "@web3auth/auth";
+import type { Duplex } from "readable-stream";
+import BaseProvider from "./baseProvider";
+import { CommunicationProviderState, ProviderOptions, UnValidatedJsonRpcRequest } from "./interfaces";
+import PopupHandler from "./PopupHandler";
+type CommunicationProviderEvents = ProviderEvents & {
+    connect: (payload: {
+        currentLoginProvider: string;
+        isLoggedIn: boolean;
+    }) => void;
+    disconnect: (err: Error) => void;
+};
+/**
+ * @param connectionStream - A Node.js duplex stream
+ * @param  opts - An options bag
+ */
+declare class CommunicationProvider extends BaseProvider<CommunicationProviderState, CommunicationProviderEvents> {
+    protected static defaultState: CommunicationProviderState;
+    tryWindowHandle: (payload: UnValidatedJsonRpcRequest | UnValidatedJsonRpcRequest[], cb: (...args: unknown[]) => void) => void;
+    onLoginStateHandle?: (isLoggedIn: boolean) => Promise<void>;
+    windowRefs: Map<string, PopupHandler>;
+    iframeUrl: string;
+    private iframeId;
+    constructor(connectionStream: Duplex, { maxEventListeners, jsonRpcStreamName }: ProviderOptions, state: Partial<CommunicationProviderState>);
+    get isLoggedIn(): boolean;
+    get isExternalWallet(): boolean;
+    get isIFrameFullScreen(): boolean;
+    /**
+     * Returns whether the inPage provider is connected to Torus.
+     */
+    isConnected(): boolean;
+    initializeState(params: Record<string, unknown>): Promise<void>;
+    hideTorusButton(): void;
+    showTorusButton(): void;
+    moveToBackground(): void;
+    moveToForeground(): void;
+    setIframeVisibility({ isVisible }: {
+        isVisible: boolean;
+    }): void;
+    displayIframe({ isFull, rid }?: {
+        isFull?: boolean;
+        rid?: string;
+    }, walletRequest?: boolean): void;
+    /**
+     * Scenarios:
+     * - Login request or pre-open confirmation windows
+     * We try to open here or send a rpc request to iframe that window is blocked.
+     */
+    handleWindow(windowId: string, { url, target, features, timeout }?: {
+        url?: string;
+        target?: string;
+        features?: string;
+        timeout?: number;
+    }): Promise<void>;
+    /**
+     * Internal RPC method. Forwards requests to background via the RPC engine.
+     * Also remap ids inbound and outbound
+     */
+    protected rpcRequest(payload: UnValidatedJsonRpcRequest | UnValidatedJsonRpcRequest[], callback: (...args: unknown[]) => void): void;
+    /**
+     * When the provider becomes connected, updates internal state and emits
+     * required events. Idempotent.
+     *
+     * @param currentLoginProvider - The login Provider
+     * emits TorusInpageProvider#connect
+     */
+    protected handleConnect(currentLoginProvider: string, isLoggedIn: boolean): void;
+    /**
+     * When the provider becomes disconnected, updates internal state and emits
+     * required events. Idempotent with respect to the isRecoverable parameter.
+     *
+     * Error codes per the CloseEvent status codes as required by EIP-1193:
+     * https://developer.mozilla.org/en-US/docs/Web/API/CloseEvent#Status_codes
+     *
+     * @param isRecoverable - Whether the disconnection is recoverable.
+     * @param errorMessage - A custom error message.
+     * emits TorusInpageProvider#disconnect
+     */
+    protected handleDisconnect(isRecoverable: boolean, errorMessage?: string): void;
+    private handleCloseWindow;
+}
+export default CommunicationProvider;

package/dist/types/embed.d.ts

@@ -0,0 +1,42 @@
+import { COMMUNICATION_JRPC_METHODS } from "@toruslabs/base-controllers";
+import { type METHOD_TYPES_TYPE } from "@toruslabs/ethereum-controllers";
+import { TorusInPageProvider } from "./inPageProvider";
+import { ClaimRealmIdOptions, CtorArgs, EMBED_BUILD_ENV_TYPE, EmbedEventListener, EmbedParams, RealmConnectResult, RealmLoginResult, RealmUserInfo } from "./interfaces";
+export declare const COMMUNICATION_UNSAFE_METHODS: Set<Partial<(typeof COMMUNICATION_JRPC_METHODS)[keyof typeof COMMUNICATION_JRPC_METHODS]>>;
+export declare const PROVIDER_UNSAFE_METHODS: Set<Partial<METHOD_TYPES_TYPE>>;
+declare class RealmEmbed {
+    #private;
+    constructor({ modalZIndex, partnerId }: CtorArgs);
+    get isConnected(): boolean;
+    get isInitialized(): boolean;
+    get isLoggedIn(): boolean;
+    get getBuildEnv(): EMBED_BUILD_ENV_TYPE;
+    get walletAddresses(): {
+        eoa: string;
+        aa?: string;
+    } | null;
+    get sessionId(): string | null;
+    get realmId(): string | null;
+    get provider(): TorusInPageProvider | null;
+    init({ buildEnv, enableLogging, skipRehydration, }?: EmbedParams): Promise<void>;
+    moveToBackground(): void;
+    moveToForeground(): void;
+    getUserInfo(): Promise<RealmUserInfo | null>;
+    login<T extends boolean>(options?: {
+        skipClaiming: T;
+        token?: string;
+        authToken?: string;
+        legacy?: boolean;
+    }): Promise<T extends true ? RealmLoginResult | RealmConnectResult : RealmLoginResult>;
+    _deploySmartAccount(): Promise<void>;
+    private _loginWithSessionId;
+    private _showWalletWidget;
+    claimRealmId(options?: ClaimRealmIdOptions): Promise<RealmLoginResult>;
+    logout(): Promise<void>;
+    cleanUp(): Promise<void>;
+    clearInit(): Promise<void>;
+    on(listener: EmbedEventListener): void;
+    off(listener: EmbedEventListener): void;
+    clearEventListeners(): void;
+}
+export default RealmEmbed;

package/dist/types/error.d.ts

@@ -0,0 +1,9 @@
+import { BaseError } from "./common/error";
+import { AirErrorName } from "./common/realm/error/types";
+type AirServiceErrorName = AirErrorName | "NOT_INITIALISED" | "ALREADY_INITIALISED" | "NOT_LOGGED_IN" | "NOT_CONNECTED";
+export declare class AirServiceError extends BaseError<AirServiceErrorName> {
+    static from(error: unknown): AirServiceError;
+}
+export declare class RealmEmbedError extends AirServiceError {
+}
+export {};

package/dist/types/iframeController.d.ts

@@ -0,0 +1,18 @@
+interface IframeState {
+    isVisible: boolean;
+}
+export declare class IframeController {
+    private static defaultState;
+    private state;
+    private _iframeElement;
+    private iframeUrl;
+    private iframeId;
+    constructor(iframeUrl: string, iframeId: string, state?: Partial<IframeState>);
+    get iframeElement(): HTMLIFrameElement | null;
+    createIframe(): HTMLIFrameElement;
+    setIframeVisibility(isVisible: boolean): void;
+    updateIframeState(): void;
+    destroy(): void;
+    postMessage(message: unknown): void;
+}
+export {};

package/dist/types/inPageProvider.d.ts

@@ -0,0 +1,106 @@
+import { ProviderEvents, RequestArguments } from "@web3auth/auth";
+import type { Duplex } from "readable-stream";
+import BaseProvider from "./baseProvider";
+import { InPageProviderState, ProviderOptions, UnValidatedJsonRpcRequest } from "./interfaces";
+type AirInPageProviderEvents = ProviderEvents & {
+    connect: (payload: {
+        chainId: string;
+    }) => void;
+    disconnect: (err: Error) => void;
+    notification: (payload: unknown) => void;
+    message: (payload: {
+        type: string;
+        data: unknown;
+    }) => void;
+    accountsChanged: (payload: unknown[]) => void;
+    chainChanged: (chainId: string) => void;
+    data: (payload: RequestArguments<unknown>) => void;
+};
+/**
+ * @param connectionStream - A Node.js duplex stream
+ * @param opts - An options bag
+ */
+declare class AirInPageProvider extends BaseProvider<InPageProviderState, AirInPageProviderEvents> {
+    protected static defaultState: InPageProviderState;
+    /**
+     * The chain ID of the currently connected EVM chain.
+     * See [chainId.network]{@link https://chainid.network} for more information.
+     */
+    chainId: string | null;
+    /**
+     * The user's currently selected EVM address.
+     * If null, Torus is either locked or the user has not permitted any
+     * addresses to be viewed.
+     */
+    selectedAddress: string | null;
+    tryWindowHandle: (payload: UnValidatedJsonRpcRequest | UnValidatedJsonRpcRequest[], cb: (...args: unknown[]) => void) => void;
+    constructor(connectionStream: Duplex, { maxEventListeners, jsonRpcStreamName }: ProviderOptions);
+    /**
+     * Returns whether the inpage provider is connected to Torus.
+     */
+    isConnected(): boolean;
+    /**
+     * Constructor helper.
+     * Populates initial state by calling 'wallet_getProviderState' and emits
+     * necessary events.
+     */
+    initializeState(): Promise<void>;
+    /**
+     * Internal RPC method. Forwards requests to background via the RPC engine.
+     * Also remap ids inbound and outbound
+     */
+    rpcRequest(payload: UnValidatedJsonRpcRequest | UnValidatedJsonRpcRequest[], callback: (...args: unknown[]) => void, isInternal?: boolean): void;
+    /**
+     * When the provider becomes connected, updates internal state and emits
+     * required events. Idempotent.
+     *
+     * @param chainId - The ID of the newly connected chain.
+     * emits TorusInpageProvider#connect
+     */
+    protected handleConnect(chainId: string): void;
+    /**
+     * When the provider becomes disconnected, updates internal state and emits
+     * required events. Idempotent with respect to the isRecoverable parameter.
+     *
+     * Error codes per the CloseEvent status codes as required by EIP-1193:
+     * https://developer.mozilla.org/en-US/docs/Web/API/CloseEvent#Status_codes
+     *
+     * @param isRecoverable - Whether the disconnection is recoverable.
+     * @param errorMessage - A custom error message.
+     * emits TorusInpageProvider#disconnect
+     */
+    protected handleDisconnect(isRecoverable: boolean, errorMessage?: string): void;
+    /**
+     * Called when accounts may have changed.
+     */
+    protected handleAccountsChanged(accounts: unknown[], isEthAccounts?: boolean, isInternal?: boolean): void;
+    /**
+     * Upon receipt of a new chainId and networkVersion, emits corresponding
+     * events and sets relevant public state.
+     * Does nothing if neither the chainId nor the networkVersion are different
+     * from existing values.
+     *
+     * emits TorusInpageProvider#chainChanged
+     * @param networkInfo - An object with network info.
+     */
+    protected handleChainChanged({ chainId }?: {
+        chainId?: string;
+    }): void;
+    /**
+     * Upon receipt of a new isUnlocked state, sets relevant public state.
+     * Calls the accounts changed handler with the received accounts, or an empty
+     * array.
+     *
+     * Does nothing if the received value is equal to the existing value.
+     * There are no lock/unlock events.
+     *
+     * @param opts - Options bag.
+     */
+    protected handleUnlockStateChanged({ accounts, isUnlocked }?: {
+        accounts?: string[];
+        isUnlocked?: boolean;
+    }): void;
+}
+export default AirInPageProvider;
+export declare class TorusInPageProvider extends AirInPageProvider {
+}

package/dist/types/index.d.ts

@@ -0,0 +1,4 @@
+export { default as AirService } from "./airService";
+export { default as RealmEmbed } from "./embed";
+export { default as AirInPageProvider } from "./inPageProvider";
+export * from "./interfaces";

package/dist/types/interfaces.d.ts

@@ -0,0 +1,261 @@
+import { LOGIN_PROVIDER_TYPE } from "@toruslabs/base-controllers";
+import { JRPCRequest } from "@web3auth/auth";
+import { LogLevelDesc } from "loglevel";
+import { AirRehydrationResult, RealmRehydrationResult } from "./common/realm/messaging/types";
+import { REALM_LOGIN_PROVIDER_TYPE } from "./common/realm/partner/config";
+import { AirIdDetails } from "./common/realm/user/types";
+export { CONFIRMATION_STRATEGY, type CONFIRMATION_STRATEGY_TYPE } from "@toruslabs/base-controllers";
+export type { AirRehydrationResult, RealmRehydrationResult };
+export declare const EMBED_BUILD_ENV: {
+    readonly PRODUCTION: "production";
+    readonly STAGING: "staging";
+    readonly DEVELOPMENT: "development";
+    readonly TESTING: "testing";
+};
+export type EMBED_BUILD_ENV_TYPE = (typeof EMBED_BUILD_ENV)[keyof typeof EMBED_BUILD_ENV];
+export declare const BUTTON_POSITION: {
+    readonly BOTTOM_LEFT: "bottom-left";
+    readonly TOP_LEFT: "top-left";
+    readonly BOTTOM_RIGHT: "bottom-right";
+    readonly TOP_RIGHT: "top-right";
+};
+export type BUTTON_POSITION_TYPE = (typeof BUTTON_POSITION)[keyof typeof BUTTON_POSITION];
+export interface CtorArgs {
+    /**
+     * Z-index of the modal and iframe
+     * @defaultValue 99999
+     */
+    modalZIndex?: number;
+    partnerId: string;
+}
+export interface PaymentParams {
+    /**
+     * Address to send the funds to
+     */
+    selectedAddress?: string;
+    /**
+     * Default fiat currency for the user to make the payment in
+     */
+    selectedCurrency?: string;
+    /**
+     * Amount to buy in the selectedCurrency
+     */
+    fiatValue?: number;
+    /**
+     * Cryptocurrency to buy
+     */
+    selectedCryptoCurrency?: string;
+}
+export declare const EXTERNAL_LOGIN_PROVIDER: {
+    readonly METAMASK: "metamask";
+    readonly WALLET_CONNECT: "walletconnect";
+    readonly WAGMI: "wagmi";
+};
+export type EXTERNAL_LOGIN_PROVIDER_TYPE = (typeof EXTERNAL_LOGIN_PROVIDER)[keyof typeof EXTERNAL_LOGIN_PROVIDER];
+export interface LoginParams {
+    loginProvider?: REALM_LOGIN_PROVIDER_TYPE | EXTERNAL_LOGIN_PROVIDER_TYPE;
+    login_hint?: string;
+}
+export interface LoginWithSessionIdParams {
+    sessionId: string;
+}
+export interface UserInfo {
+    /**
+     * Email of the logged in user
+     */
+    email: string;
+    /**
+     * Full name of the logged in user
+     */
+    name: string;
+    /**
+     * Profile image of the logged in user
+     */
+    profileImage: string;
+    /**
+     * verifier of the logged in user (google, facebook etc)
+     */
+    verifier: string;
+    /**
+     * Verifier Id of the logged in user
+     *
+     * email for google,
+     * id for facebook,
+     * username for reddit,
+     * id for twitch,
+     * id for discord
+     */
+    verifierId: string;
+}
+export interface AirUrlConfig {
+    authUrl?: string;
+    walletUrl?: string;
+    logLevel?: LogLevelDesc;
+}
+export interface EmbedParams {
+    /**
+     * Build Environment of WsEmbed.
+     *
+     * production uses https://wallet.web3auth.io,
+     *
+     * staging uses https://staging-wallet.web3auth.io,
+     *
+     * testing uses https://develop-wallet.web3auth.io (latest internal build)
+     *
+     * development uses https://localhost:4050 (expects wallet-services-frontend to be run locally),
+     *
+     * @defaultValue production
+     */
+    buildEnv?: EMBED_BUILD_ENV_TYPE;
+    /**
+     * Enables or disables logging.
+     *
+     * Defaults to false in prod and true in other environments
+     */
+    enableLogging?: boolean;
+    skipRehydration?: boolean;
+}
+export interface ProviderOptions {
+    /**
+     * The name of the stream used to connect to the wallet.
+     */
+    jsonRpcStreamName?: string;
+    /**
+     * The maximum number of event listeners.
+     */
+    maxEventListeners?: number;
+}
+export interface BaseProviderState {
+    isConnected: boolean;
+    initialized: boolean;
+    isPermanentlyDisconnected: boolean;
+    hasEmittedConnection: boolean;
+}
+export interface InPageProviderState extends BaseProviderState {
+    accounts: null | string[];
+    isUnlocked: boolean;
+}
+export interface CommunicationProviderState extends BaseProviderState {
+    buttonPosition: string;
+    isLoggedIn: boolean;
+    widgetVisibility: boolean;
+    currentLoginProvider: LOGIN_PROVIDER_TYPE | EXTERNAL_LOGIN_PROVIDER_TYPE;
+    isIFrameFullScreen: boolean;
+    isBackground: boolean;
+}
+export type Maybe<T> = Partial<T> | T | null | undefined;
+export interface UnValidatedJsonRpcRequest extends JRPCRequest<unknown> {
+    windowId?: string;
+}
+export type AirWalletAddresses = {
+    eoa: string;
+    aa: string;
+};
+export type RealmWalletAddresses = {
+    eoa: string;
+    aa?: string;
+};
+export type AirInitializationResult = {
+    rehydration: AirRehydrationResult;
+};
+export type RealmInitializationResult = {
+    rehydration: RealmRehydrationResult;
+};
+export type RealmConnectResult = {
+    isLoggedIn: false;
+    addresses: RealmWalletAddresses;
+    token: string;
+    sessionId?: string;
+};
+export type RealmLoginResult = {
+    isLoggedIn: true;
+    realmId: string;
+    addresses: Required<RealmWalletAddresses>;
+    token: string;
+    sessionId?: string;
+};
+export type AirEmbedConnectResult = RealmConnectResult;
+export type AirEmbedLoginResult = RealmLoginResult;
+export type RealmUserInfo = UserInfo & {
+    realmId: string;
+};
+export type EmbedEventOnInitialized = {
+    event: "initialized";
+    result: RealmInitializationResult;
+};
+export type EmbedEventOnConnected = {
+    event: "connected";
+    result: RealmConnectResult;
+};
+export type EmbedEventOnLoggedIn = {
+    event: "logged_in";
+    result: RealmLoginResult;
+};
+export type EmbedEventOnLoggedOut = {
+    event: "logged_out";
+};
+export type EmbedEventOnReset = {
+    event: "reset";
+};
+export type EmbedEventOnMintingStarted = {
+    event: "minting_started";
+};
+export type EmbedEventOnMintingFailed = {
+    event: "minting_failed";
+    errorMessage?: string;
+};
+export type EmbedEventData = EmbedEventOnInitialized | EmbedEventOnConnected | EmbedEventOnLoggedIn | EmbedEventOnLoggedOut | EmbedEventOnReset | EmbedEventOnMintingStarted | EmbedEventOnMintingFailed;
+export type AirUserDetails = {
+    id: string;
+    abstractAccountAddress: string;
+    email?: string;
+    airIds: AirIdDetails[];
+};
+export type AirPartnerUserDetails = {
+    partnerId: string;
+    partnerUserId: string;
+    airId?: AirIdDetails;
+};
+export type AirLoginResult = {
+    isLoggedIn: boolean;
+    id: string;
+    abstractAccountAddress: string;
+    token: string;
+};
+export type AirWalletLoadedResult = {
+    isLoggedIn: boolean;
+    airId?: string;
+    addresses: AirWalletAddresses;
+};
+export type AirEventOnInitialized = {
+    event: "initialized";
+};
+export type AirEventOnLoggedIn = {
+    event: "logged_in";
+    result: AirLoginResult;
+};
+export type AirEventWalletLoaded = {
+    event: "wallet_loaded";
+    result: AirWalletLoadedResult;
+};
+export type AirEventWalletMintingStarted = {
+    event: "minting_started";
+};
+export type AirEventWalletMintingFailed = {
+    event: "minting_failed";
+    errorMessage?: string;
+};
+export type AirEventOnLoggedOut = {
+    event: "logged_out";
+};
+export type AirEventData = AirEventOnInitialized | AirEventOnLoggedIn | AirEventWalletLoaded | AirEventWalletMintingStarted | AirEventWalletMintingFailed | AirEventOnLoggedOut;
+export type EmbedEventListener = (data: EmbedEventData) => void;
+export type AirEventListener = (data: AirEventData) => void;
+export type ClaimAirIdOptions = {
+    token?: string;
+    background?: false;
+} | {
+    token: string;
+    background: true;
+};
+export type ClaimRealmIdOptions = ClaimAirIdOptions;