@imtbl/sdk 0.1.4-alpha → 0.1.6-alpha

package/dist/checkout_widgets.d.ts

@@ -1,4 +1,580 @@
 /// <reference path="global.d.ts" />
+/// <reference types="node" />
+declare type Bytes = ArrayLike<number>;
+declare type BytesLike = Bytes | string;
+interface Hexable {
+    toHexString(): string;
+}
+
+declare type BigNumberish = BigNumber | Bytes | bigint | string | number;
+declare class BigNumber implements Hexable {
+    readonly _hex: string;
+    readonly _isBigNumber: boolean;
+    constructor(constructorGuard: any, hex: string);
+    fromTwos(value: number): BigNumber;
+    toTwos(value: number): BigNumber;
+    abs(): BigNumber;
+    add(other: BigNumberish): BigNumber;
+    sub(other: BigNumberish): BigNumber;
+    div(other: BigNumberish): BigNumber;
+    mul(other: BigNumberish): BigNumber;
+    mod(other: BigNumberish): BigNumber;
+    pow(other: BigNumberish): BigNumber;
+    and(other: BigNumberish): BigNumber;
+    or(other: BigNumberish): BigNumber;
+    xor(other: BigNumberish): BigNumber;
+    mask(value: number): BigNumber;
+    shl(value: number): BigNumber;
+    shr(value: number): BigNumber;
+    eq(other: BigNumberish): boolean;
+    lt(other: BigNumberish): boolean;
+    lte(other: BigNumberish): boolean;
+    gt(other: BigNumberish): boolean;
+    gte(other: BigNumberish): boolean;
+    isNegative(): boolean;
+    isZero(): boolean;
+    toNumber(): number;
+    toBigInt(): bigint;
+    toString(): string;
+    toHexString(): string;
+    toJSON(key?: string): any;
+    static from(value: any): BigNumber;
+    static isBigNumber(value: any): value is BigNumber;
+}
+
+declare type Network$1 = {
+    name: string;
+    chainId: number;
+    ensAddress?: string;
+    _defaultProvider?: (providers: any, options?: any) => any;
+};
+declare type Networkish = Network$1 | string | number;
+
+declare type Deferrable<T> = {
+    [K in keyof T]: T[K] | Promise<T[K]>;
+};
+declare class Description<T = any> {
+    constructor(info: {
+        [K in keyof T]: T[K];
+    });
+}
+
+declare type AccessList = Array<{
+    address: string;
+    storageKeys: Array<string>;
+}>;
+declare type AccessListish = AccessList | Array<[string, Array<string>]> | Record<string, Array<string>>;
+interface Transaction {
+    hash?: string;
+    to?: string;
+    from?: string;
+    nonce: number;
+    gasLimit: BigNumber;
+    gasPrice?: BigNumber;
+    data: string;
+    value: BigNumber;
+    chainId: number;
+    r?: string;
+    s?: string;
+    v?: number;
+    type?: number | null;
+    accessList?: AccessList;
+    maxPriorityFeePerGas?: BigNumber;
+    maxFeePerGas?: BigNumber;
+}
+
+declare type ConnectionInfo = {
+    url: string;
+    headers?: {
+        [key: string]: string | number;
+    };
+    user?: string;
+    password?: string;
+    allowInsecureAuthentication?: boolean;
+    allowGzip?: boolean;
+    throttleLimit?: number;
+    throttleSlotInterval?: number;
+    throttleCallback?: (attempt: number, url: string) => Promise<boolean>;
+    skipFetchSetup?: boolean;
+    fetchOptions?: Record<string, string>;
+    errorPassThrough?: boolean;
+    timeout?: number;
+};
+interface OnceBlockable {
+    once(eventName: "block", handler: () => void): void;
+}
+
+declare type TransactionRequest = {
+    to?: string;
+    from?: string;
+    nonce?: BigNumberish;
+    gasLimit?: BigNumberish;
+    gasPrice?: BigNumberish;
+    data?: BytesLike;
+    value?: BigNumberish;
+    chainId?: number;
+    type?: number;
+    accessList?: AccessListish;
+    maxPriorityFeePerGas?: BigNumberish;
+    maxFeePerGas?: BigNumberish;
+    customData?: Record<string, any>;
+    ccipReadEnabled?: boolean;
+};
+interface TransactionResponse extends Transaction {
+    hash: string;
+    blockNumber?: number;
+    blockHash?: string;
+    timestamp?: number;
+    confirmations: number;
+    from: string;
+    raw?: string;
+    wait: (confirmations?: number) => Promise<TransactionReceipt>;
+}
+declare type BlockTag = string | number;
+interface _Block {
+    hash: string;
+    parentHash: string;
+    number: number;
+    timestamp: number;
+    nonce: string;
+    difficulty: number;
+    _difficulty: BigNumber;
+    gasLimit: BigNumber;
+    gasUsed: BigNumber;
+    miner: string;
+    extraData: string;
+    baseFeePerGas?: null | BigNumber;
+}
+interface Block extends _Block {
+    transactions: Array<string>;
+}
+interface BlockWithTransactions extends _Block {
+    transactions: Array<TransactionResponse>;
+}
+interface Log {
+    blockNumber: number;
+    blockHash: string;
+    transactionIndex: number;
+    removed: boolean;
+    address: string;
+    data: string;
+    topics: Array<string>;
+    transactionHash: string;
+    logIndex: number;
+}
+interface TransactionReceipt {
+    to: string;
+    from: string;
+    contractAddress: string;
+    transactionIndex: number;
+    root?: string;
+    gasUsed: BigNumber;
+    logsBloom: string;
+    blockHash: string;
+    transactionHash: string;
+    logs: Array<Log>;
+    blockNumber: number;
+    confirmations: number;
+    cumulativeGasUsed: BigNumber;
+    effectiveGasPrice: BigNumber;
+    byzantium: boolean;
+    type: number;
+    status?: number;
+}
+interface FeeData {
+    lastBaseFeePerGas: null | BigNumber;
+    maxFeePerGas: null | BigNumber;
+    maxPriorityFeePerGas: null | BigNumber;
+    gasPrice: null | BigNumber;
+}
+interface EventFilter {
+    address?: string;
+    topics?: Array<string | Array<string> | null>;
+}
+interface Filter extends EventFilter {
+    fromBlock?: BlockTag;
+    toBlock?: BlockTag;
+}
+interface FilterByBlockHash extends EventFilter {
+    blockHash?: string;
+}
+declare abstract class ForkEvent extends Description {
+    readonly expiry: number;
+    readonly _isForkEvent?: boolean;
+    static isForkEvent(value: any): value is ForkEvent;
+}
+declare type EventType = string | Array<string | Array<string>> | EventFilter | ForkEvent;
+declare type Listener = (...args: Array<any>) => void;
+declare abstract class Provider implements OnceBlockable {
+    abstract getNetwork(): Promise<Network$1>;
+    abstract getBlockNumber(): Promise<number>;
+    abstract getGasPrice(): Promise<BigNumber>;
+    getFeeData(): Promise<FeeData>;
+    abstract getBalance(addressOrName: string | Promise<string>, blockTag?: BlockTag | Promise<BlockTag>): Promise<BigNumber>;
+    abstract getTransactionCount(addressOrName: string | Promise<string>, blockTag?: BlockTag | Promise<BlockTag>): Promise<number>;
+    abstract getCode(addressOrName: string | Promise<string>, blockTag?: BlockTag | Promise<BlockTag>): Promise<string>;
+    abstract getStorageAt(addressOrName: string | Promise<string>, position: BigNumberish | Promise<BigNumberish>, blockTag?: BlockTag | Promise<BlockTag>): Promise<string>;
+    abstract sendTransaction(signedTransaction: string | Promise<string>): Promise<TransactionResponse>;
+    abstract call(transaction: Deferrable<TransactionRequest>, blockTag?: BlockTag | Promise<BlockTag>): Promise<string>;
+    abstract estimateGas(transaction: Deferrable<TransactionRequest>): Promise<BigNumber>;
+    abstract getBlock(blockHashOrBlockTag: BlockTag | string | Promise<BlockTag | string>): Promise<Block>;
+    abstract getBlockWithTransactions(blockHashOrBlockTag: BlockTag | string | Promise<BlockTag | string>): Promise<BlockWithTransactions>;
+    abstract getTransaction(transactionHash: string): Promise<TransactionResponse>;
+    abstract getTransactionReceipt(transactionHash: string): Promise<TransactionReceipt>;
+    abstract getLogs(filter: Filter): Promise<Array<Log>>;
+    abstract resolveName(name: string | Promise<string>): Promise<null | string>;
+    abstract lookupAddress(address: string | Promise<string>): Promise<null | string>;
+    abstract on(eventName: EventType, listener: Listener): Provider;
+    abstract once(eventName: EventType, listener: Listener): Provider;
+    abstract emit(eventName: EventType, ...args: Array<any>): boolean;
+    abstract listenerCount(eventName?: EventType): number;
+    abstract listeners(eventName?: EventType): Array<Listener>;
+    abstract off(eventName: EventType, listener?: Listener): Provider;
+    abstract removeAllListeners(eventName?: EventType): Provider;
+    addListener(eventName: EventType, listener: Listener): Provider;
+    removeListener(eventName: EventType, listener: Listener): Provider;
+    abstract waitForTransaction(transactionHash: string, confirmations?: number, timeout?: number): Promise<TransactionReceipt>;
+    readonly _isProvider: boolean;
+    constructor();
+    static isProvider(value: any): value is Provider;
+}
+
+declare type FormatFunc = (value: any) => any;
+declare type FormatFuncs = {
+    [key: string]: FormatFunc;
+};
+declare type Formats = {
+    transaction: FormatFuncs;
+    transactionRequest: FormatFuncs;
+    receipt: FormatFuncs;
+    receiptLog: FormatFuncs;
+    block: FormatFuncs;
+    blockWithTransactions: FormatFuncs;
+    filter: FormatFuncs;
+    filterLog: FormatFuncs;
+};
+declare class Formatter {
+    readonly formats: Formats;
+    constructor();
+    getDefaultFormats(): Formats;
+    accessList(accessList: Array<any>): AccessList;
+    number(number: any): number;
+    type(number: any): number;
+    bigNumber(value: any): BigNumber;
+    boolean(value: any): boolean;
+    hex(value: any, strict?: boolean): string;
+    data(value: any, strict?: boolean): string;
+    address(value: any): string;
+    callAddress(value: any): string;
+    contractAddress(value: any): string;
+    blockTag(blockTag: any): string;
+    hash(value: any, strict?: boolean): string;
+    difficulty(value: any): number;
+    uint256(value: any): string;
+    _block(value: any, format: any): Block;
+    block(value: any): Block;
+    blockWithTransactions(value: any): Block;
+    transactionRequest(value: any): any;
+    transactionResponse(transaction: any): TransactionResponse;
+    transaction(value: any): any;
+    receiptLog(value: any): any;
+    receipt(value: any): TransactionReceipt;
+    topics(value: any): any;
+    filter(value: any): any;
+    filterLog(value: any): any;
+    static check(format: {
+        [name: string]: FormatFunc;
+    }, object: any): any;
+    static allowNull(format: FormatFunc, nullValue?: any): FormatFunc;
+    static allowFalsish(format: FormatFunc, replaceValue: any): FormatFunc;
+    static arrayOf(format: FormatFunc): FormatFunc;
+}
+
+declare class Event$1 {
+    readonly listener: Listener;
+    readonly once: boolean;
+    readonly tag: string;
+    _lastBlockNumber: number;
+    _inflight: boolean;
+    constructor(tag: string, listener: Listener, once: boolean);
+    get event(): EventType;
+    get type(): string;
+    get hash(): string;
+    get filter(): Filter;
+    pollable(): boolean;
+}
+interface EnsResolver {
+    readonly name: string;
+    readonly address: string;
+    getAddress(coinType?: 60): Promise<null | string>;
+    getContentHash(): Promise<null | string>;
+    getText(key: string): Promise<null | string>;
+}
+interface EnsProvider {
+    resolveName(name: string): Promise<null | string>;
+    lookupAddress(address: string): Promise<null | string>;
+    getResolver(name: string): Promise<null | EnsResolver>;
+}
+interface Avatar {
+    url: string;
+    linkage: Array<{
+        type: string;
+        content: string;
+    }>;
+}
+declare class Resolver implements EnsResolver {
+    readonly provider: BaseProvider;
+    readonly name: string;
+    readonly address: string;
+    readonly _resolvedAddress: null | string;
+    _supportsEip2544: null | Promise<boolean>;
+    constructor(provider: BaseProvider, address: string, name: string, resolvedAddress?: string);
+    supportsWildcard(): Promise<boolean>;
+    _fetch(selector: string, parameters?: string): Promise<null | string>;
+    _fetchBytes(selector: string, parameters?: string): Promise<null | string>;
+    _getAddress(coinType: number, hexBytes: string): string;
+    getAddress(coinType?: number): Promise<string>;
+    getAvatar(): Promise<null | Avatar>;
+    getContentHash(): Promise<string>;
+    getText(key: string): Promise<string>;
+}
+declare class BaseProvider extends Provider implements EnsProvider {
+    _networkPromise: Promise<Network$1>;
+    _network: Network$1;
+    _events: Array<Event$1>;
+    formatter: Formatter;
+    _emitted: {
+        [eventName: string]: number | "pending";
+    };
+    _pollingInterval: number;
+    _poller: NodeJS.Timer;
+    _bootstrapPoll: NodeJS.Timer;
+    _lastBlockNumber: number;
+    _maxFilterBlockRange: number;
+    _fastBlockNumber: number;
+    _fastBlockNumberPromise: Promise<number>;
+    _fastQueryDate: number;
+    _maxInternalBlockNumber: number;
+    _internalBlockNumber: Promise<{
+        blockNumber: number;
+        reqTime: number;
+        respTime: number;
+    }>;
+    readonly anyNetwork: boolean;
+    disableCcipRead: boolean;
+    /**
+     *  ready
+     *
+     *  A Promise<Network> that resolves only once the provider is ready.
+     *
+     *  Sub-classes that call the super with a network without a chainId
+     *  MUST set this. Standard named networks have a known chainId.
+     *
+     */
+    constructor(network: Networkish | Promise<Network$1>);
+    _ready(): Promise<Network$1>;
+    get ready(): Promise<Network$1>;
+    static getFormatter(): Formatter;
+    static getNetwork(network: Networkish): Network$1;
+    ccipReadFetch(tx: Transaction, calldata: string, urls: Array<string>): Promise<null | string>;
+    _getInternalBlockNumber(maxAge: number): Promise<number>;
+    poll(): Promise<void>;
+    resetEventsBlock(blockNumber: number): void;
+    get network(): Network$1;
+    detectNetwork(): Promise<Network$1>;
+    getNetwork(): Promise<Network$1>;
+    get blockNumber(): number;
+    get polling(): boolean;
+    set polling(value: boolean);
+    get pollingInterval(): number;
+    set pollingInterval(value: number);
+    _getFastBlockNumber(): Promise<number>;
+    _setFastBlockNumber(blockNumber: number): void;
+    waitForTransaction(transactionHash: string, confirmations?: number, timeout?: number): Promise<TransactionReceipt>;
+    _waitForTransaction(transactionHash: string, confirmations: number, timeout: number, replaceable: {
+        data: string;
+        from: string;
+        nonce: number;
+        to: string;
+        value: BigNumber;
+        startBlock: number;
+    }): Promise<TransactionReceipt>;
+    getBlockNumber(): Promise<number>;
+    getGasPrice(): Promise<BigNumber>;
+    getBalance(addressOrName: string | Promise<string>, blockTag?: BlockTag | Promise<BlockTag>): Promise<BigNumber>;
+    getTransactionCount(addressOrName: string | Promise<string>, blockTag?: BlockTag | Promise<BlockTag>): Promise<number>;
+    getCode(addressOrName: string | Promise<string>, blockTag?: BlockTag | Promise<BlockTag>): Promise<string>;
+    getStorageAt(addressOrName: string | Promise<string>, position: BigNumberish | Promise<BigNumberish>, blockTag?: BlockTag | Promise<BlockTag>): Promise<string>;
+    _wrapTransaction(tx: Transaction, hash?: string, startBlock?: number): TransactionResponse;
+    sendTransaction(signedTransaction: string | Promise<string>): Promise<TransactionResponse>;
+    _getTransactionRequest(transaction: Deferrable<TransactionRequest>): Promise<Transaction>;
+    _getFilter(filter: Filter | FilterByBlockHash | Promise<Filter | FilterByBlockHash>): Promise<Filter | FilterByBlockHash>;
+    _call(transaction: TransactionRequest, blockTag: BlockTag, attempt: number): Promise<string>;
+    call(transaction: Deferrable<TransactionRequest>, blockTag?: BlockTag | Promise<BlockTag>): Promise<string>;
+    estimateGas(transaction: Deferrable<TransactionRequest>): Promise<BigNumber>;
+    _getAddress(addressOrName: string | Promise<string>): Promise<string>;
+    _getBlock(blockHashOrBlockTag: BlockTag | string | Promise<BlockTag | string>, includeTransactions?: boolean): Promise<Block | BlockWithTransactions>;
+    getBlock(blockHashOrBlockTag: BlockTag | string | Promise<BlockTag | string>): Promise<Block>;
+    getBlockWithTransactions(blockHashOrBlockTag: BlockTag | string | Promise<BlockTag | string>): Promise<BlockWithTransactions>;
+    getTransaction(transactionHash: string | Promise<string>): Promise<TransactionResponse>;
+    getTransactionReceipt(transactionHash: string | Promise<string>): Promise<TransactionReceipt>;
+    getLogs(filter: Filter | FilterByBlockHash | Promise<Filter | FilterByBlockHash>): Promise<Array<Log>>;
+    getEtherPrice(): Promise<number>;
+    _getBlockTag(blockTag: BlockTag | Promise<BlockTag>): Promise<BlockTag>;
+    getResolver(name: string): Promise<null | Resolver>;
+    _getResolver(name: string, operation?: string): Promise<string>;
+    resolveName(name: string | Promise<string>): Promise<null | string>;
+    lookupAddress(address: string | Promise<string>): Promise<null | string>;
+    getAvatar(nameOrAddress: string): Promise<null | string>;
+    perform(method: string, params: any): Promise<any>;
+    _startEvent(event: Event$1): void;
+    _stopEvent(event: Event$1): void;
+    _addEventListener(eventName: EventType, listener: Listener, once: boolean): this;
+    on(eventName: EventType, listener: Listener): this;
+    once(eventName: EventType, listener: Listener): this;
+    emit(eventName: EventType, ...args: Array<any>): boolean;
+    listenerCount(eventName?: EventType): number;
+    listeners(eventName?: EventType): Array<Listener>;
+    off(eventName: EventType, listener?: Listener): this;
+    removeAllListeners(eventName?: EventType): this;
+}
+
+interface TypedDataDomain {
+    name?: string;
+    version?: string;
+    chainId?: BigNumberish;
+    verifyingContract?: string;
+    salt?: BytesLike;
+}
+interface TypedDataField {
+    name: string;
+    type: string;
+}
+interface TypedDataSigner {
+    _signTypedData(domain: TypedDataDomain, types: Record<string, Array<TypedDataField>>, value: Record<string, any>): Promise<string>;
+}
+declare abstract class Signer {
+    readonly provider?: Provider;
+    abstract getAddress(): Promise<string>;
+    abstract signMessage(message: Bytes | string): Promise<string>;
+    abstract signTransaction(transaction: Deferrable<TransactionRequest>): Promise<string>;
+    abstract connect(provider: Provider): Signer;
+    readonly _isSigner: boolean;
+    constructor();
+    getBalance(blockTag?: BlockTag): Promise<BigNumber>;
+    getTransactionCount(blockTag?: BlockTag): Promise<number>;
+    estimateGas(transaction: Deferrable<TransactionRequest>): Promise<BigNumber>;
+    call(transaction: Deferrable<TransactionRequest>, blockTag?: BlockTag): Promise<string>;
+    sendTransaction(transaction: Deferrable<TransactionRequest>): Promise<TransactionResponse>;
+    getChainId(): Promise<number>;
+    getGasPrice(): Promise<BigNumber>;
+    getFeeData(): Promise<FeeData>;
+    resolveName(name: string): Promise<string>;
+    checkTransaction(transaction: Deferrable<TransactionRequest>): Deferrable<TransactionRequest>;
+    populateTransaction(transaction: Deferrable<TransactionRequest>): Promise<TransactionRequest>;
+    _checkProvider(operation?: string): void;
+    static isSigner(value: any): value is Signer;
+}
+
+declare class JsonRpcSigner extends Signer implements TypedDataSigner {
+    readonly provider: JsonRpcProvider;
+    _index: number;
+    _address: string;
+    constructor(constructorGuard: any, provider: JsonRpcProvider, addressOrIndex?: string | number);
+    connect(provider: Provider): JsonRpcSigner;
+    connectUnchecked(): JsonRpcSigner;
+    getAddress(): Promise<string>;
+    sendUncheckedTransaction(transaction: Deferrable<TransactionRequest>): Promise<string>;
+    signTransaction(transaction: Deferrable<TransactionRequest>): Promise<string>;
+    sendTransaction(transaction: Deferrable<TransactionRequest>): Promise<TransactionResponse>;
+    signMessage(message: Bytes | string): Promise<string>;
+    _legacySignMessage(message: Bytes | string): Promise<string>;
+    _signTypedData(domain: TypedDataDomain, types: Record<string, Array<TypedDataField>>, value: Record<string, any>): Promise<string>;
+    unlock(password: string): Promise<boolean>;
+}
+declare class UncheckedJsonRpcSigner extends JsonRpcSigner {
+    sendTransaction(transaction: Deferrable<TransactionRequest>): Promise<TransactionResponse>;
+}
+declare class JsonRpcProvider extends BaseProvider {
+    readonly connection: ConnectionInfo;
+    _pendingFilter: Promise<number>;
+    _nextId: number;
+    _eventLoopCache: Record<string, Promise<any>>;
+    get _cache(): Record<string, Promise<any>>;
+    constructor(url?: ConnectionInfo | string, network?: Networkish);
+    static defaultUrl(): string;
+    detectNetwork(): Promise<Network$1>;
+    _uncachedDetectNetwork(): Promise<Network$1>;
+    getSigner(addressOrIndex?: string | number): JsonRpcSigner;
+    getUncheckedSigner(addressOrIndex?: string | number): UncheckedJsonRpcSigner;
+    listAccounts(): Promise<Array<string>>;
+    send(method: string, params: Array<any>): Promise<any>;
+    prepareRequest(method: string, params: any): [string, Array<any>];
+    perform(method: string, params: any): Promise<any>;
+    _startEvent(event: Event$1): void;
+    _startPending(): void;
+    _stopEvent(event: Event$1): void;
+    static hexlifyTransaction(transaction: TransactionRequest, allowExtra?: {
+        [key: string]: boolean;
+    }): {
+        [key: string]: string | AccessList;
+    };
+}
+
+declare type ExternalProvider = {
+    isMetaMask?: boolean;
+    isStatus?: boolean;
+    host?: string;
+    path?: string;
+    sendAsync?: (request: {
+        method: string;
+        params?: Array<any>;
+    }, callback: (error: any, response: any) => void) => void;
+    send?: (request: {
+        method: string;
+        params?: Array<any>;
+    }, callback: (error: any, response: any) => void) => void;
+    request?: (request: {
+        method: string;
+        params?: Array<any>;
+    }) => Promise<any>;
+};
+declare type JsonRpcFetchFunc = (method: string, params?: Array<any>) => Promise<any>;
+declare class Web3Provider extends JsonRpcProvider {
+    readonly provider: ExternalProvider;
+    readonly jsonRpcFetchFunc: JsonRpcFetchFunc;
+    constructor(provider: ExternalProvider | JsonRpcFetchFunc, network?: Networkish);
+    send(method: string, params: Array<any>): Promise<any>;
+}
+
+/**
+ * Interface representing token information.
+ * @property {string} name - The token name.
+ * @property {string} symbol - The token symbol.
+ * @property {number} decimals - The token decimals.
+ * @property {string} [address] - The token contract address.
+ * @property {string} [icon] - The token icon URL/data:image.
+ */
+interface TokenInfo {
+    name: string;
+    symbol: string;
+    decimals: number;
+    address?: string;
+    icon?: string;
+}
+/**
+ * Interface representing the information of a network.
+ * @property {string} name - The name of the network.
+ * @property {number} chainId - The ID of the network.
+ * @property {TokenInfo} nativeCurrency - The info of the network's native currency.
+ * @property {boolean} isSupported - Flag indicating if the network is supported by the application.
+ */
+interface NetworkInfo {
+    name: string;
+    chainId: number;
+    nativeCurrency: TokenInfo;
+    isSupported: boolean;
+}
 /**
  * Enum representing the list of default supported providers.
  */
@@ -14315,144 +14891,463 @@ declare global {
     }
 }
 
+/**
+ * Enum representing the events emitted by the widgets.
+ */
 declare enum IMTBLWidgetEvents {
     IMTBL_CONNECT_WIDGET_EVENT = "imtbl-connect-widget",
     IMTBL_WALLET_WIDGET_EVENT = "imtbl-wallet-widget",
     IMTBL_SWAP_WIDGET_EVENT = "imtbl-swap-widget",
     IMTBL_BRIDGE_WIDGET_EVENT = "imtbl-bridge-widget",
-    IMTBL_BUY_WIDGET_EVENT = "imtbl-buy-widget"
+    IMTBL_BUY_WIDGET_EVENT = "imtbl-buy-widget",
+    IMTBL_ONRAMP_WIDGET_EVENT = "imtbl-onramp-widget"
 }
+/**
+ * Enum representing possible Connect Widget event types.
+ */
 declare enum ConnectEventType {
     SUCCESS = "success",
     FAILURE = "failure",
     CLOSE_WIDGET = "close-widget"
 }
+/**
+ * Represents an event object emitted by the Connect Widget.
+ * @property {BuyEventType} type - The type of the event.
+ * @property {T} data - The data contained in the event.
+ */
 type ConnectEvent<T> = {
     type: ConnectEventType;
     data: T;
 };
+/**
+ * Type representing a Connect Widget event with type SUCCESS.
+ * @property {ConnectionProviders} providerPreference - The user's preferred connection provider.
+ */
 type ConnectionSuccess = {
     providerPreference: ConnectionProviders;
 };
+/**
+ * Type representing a Connect Widget event with type FAILURE.
+ * @property {string} reason - A description of the reason for the failed connection attempt.
+ */
 type ConnectionFailed = {
     reason: string;
 };
+/**
+ * Enum representing possible Wallet Widget event types.
+ */
 declare enum WalletEventType {
     CLOSE_WIDGET = "close-widget",
-    NETWORK_SWITCH = "network-switch"
+    NETWORK_SWITCH = "network-switch",
+    ADD_COINS = "add-coins",
+    REQUEST_SWAP = "request-swap",
+    REQUEST_BRIDGE = "request-bridge",
+    REQUEST_ONRAMP = "request-onramp"
 }
+/**
+ * Type representing the data emitted by the network switch event.
+ * @property {string} network - The name of the selected network.
+ * @property {number} chainId - The chain ID of the selected network.
+ */
 type WalletNetworkSwitchEvent = {
     network: string;
     chainId: number;
 };
+type WalletAddCoinsEvent = {
+    network?: NetworkInfo;
+    token?: TokenInfo;
+    tokenAmount?: string;
+};
+type WalletRequestSwapEvent = {
+    fromTokenAddress: string;
+    toTokenAddress: string;
+    amount: string;
+};
+type WalletRequestBridgeEvent = {
+    fromNetwork: string;
+    tokenAddress: string;
+    amount: string;
+};
+type WalletRequestOnrampEvent = {
+    tokenAddress: string;
+    amount: string;
+};
+/**
+ * Represents an event object emitted by the Wallet Widget.
+ * @property {WalletEventType} type - The type of the event.
+ * @property {T} data - The data contained in the event.
+ */
 type WalletEvent<T> = {
     type: WalletEventType;
     data: T;
 };
+/**
+ * Represents an event object emitted by the Swap Widget.
+ * @property {SwapEventType} type - The type of the event.
+ * @property {T} data - The data contained in the event.
+ */
 type SwapEvent<T> = {
     type: SwapEventType;
     data: T;
 };
+/**
+ * Enum representing possible Swap Widget event types.
+ */
 declare enum SwapEventType {
     SUCCESS = "success",
     FAILURE = "failure"
 }
+/**
+ * Type representing a Swap Widget with type SUCCESS.
+ * @property {number} timestamp - The timestamp of the successful swap.
+ */
 type SwapSuccess = {
     timestamp: number;
 };
+/**
+ * Type representing a Swap Widget with type FAILURE.
+ * @property {string} reason - The reason why the swap failed.
+ * @property {number} timestamp - The timestamp of the failed swap.
+ */
 type SwapFailed = {
     reason: string;
     timestamp: number;
 };
+/**
+ * Represents an event object emitted by the Bridge Widget.
+ * @property {BridgeEventType} type - The type of the event.
+ * @property {T} data - The data associated with the event.
+ */
 type BridgeEvent<T> = {
     type: BridgeEventType;
     data: T;
 };
+/**
+ * Enum of possible Bridge Widget event types.
+ */
 declare enum BridgeEventType {
     CLOSE_WIDGET = "close-widget",
     SUCCESS = "success",
     FAILURE = "failure"
 }
+/**
+ * Type representing a Bridge Widget event with type SUCCESS
+ * @property {number} timestamp - The UNIX timestamp (in milliseconds) when the event occurred.
+ */
 type BridgeSuccess = {
     timestamp: number;
 };
+/**
+ * Type representing a Bridge Widget event with type FAILURE
+ * @property {string} reason - The reason for the failure.
+ * @property {number} timestamp - The UNIX timestamp (in milliseconds) when the event occurred.
+ */
 type BridgeFailed = {
     reason: string;
     timestamp: number;
 };
+/**
+ * Represents an event object emitted by the Buy Widget.
+ * @property {BuyEventType} type - The type of the event.
+ * @property {T} data - The data contained in the event.
+ */
 type BuyEvent<T> = {
     type: BuyEventType;
     data: T;
 };
+/**
+ * Enum representing possible Buy Widget event types.
+ */
 declare enum BuyEventType {
     SUCCESS = "success",
     FAILURE = "failure",
     NOT_CONNECTED = "not_connected",
     CLOSE = "close"
 }
+/**
+ * Type representing a Buy Widget event with type CLOSE.
+ */
 type BuyClose = {};
+/**
+ * Type representing a Buy Widget event with type NOT_CONNECTED.
+ * @property {string} providerPreference - The preferred provider used for the connection within the Buy Widget.
+ */
 type BuyNotConnected = {
     providerPreference: string;
 };
+/**
+ * Type representing a Buy Widget event with type SUCCESS.
+ * @property {number} timestamp - The timestamp of the successful buy.
+ */
 type BuySuccess = {
     timestamp: number;
 };
+/**
+ * Type representing a Buy Widget event with type FAILURE.
+ * @property {string} reason - The reason why the buy failed.
+ * @property {number} timestamp - The timestamp of the failed buy.
+ */
 type BuyFailed = {
     reason: string;
     timestamp: number;
 };
-interface ImtblConnectProps extends undefined<undefined<HTMLElement>, HTMLElement> {
+type OnRampEvent<T> = {
+    type: OnRampEventType;
+    data: T;
+};
+declare enum OnRampEventType {
+}
+/**
+ * Props for the Connect Widget component
+ * @property {string} providerPreference - The preferred wallet provider to connect to.
+ * @property {string} theme - The theme to use.
+ */
+interface ImtblConnectProps extends React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement> {
     providerPreference: string;
     theme: string;
 }
-interface ImtblWalletProps extends undefined<undefined<HTMLElement>, HTMLElement> {
+/**
+ * Props for the Wallet Widget component
+ * @property {string} providerPreference - The preferred wallet provider to connect to.
+ * @property {string} theme - The theme to use.
+ */
+interface ImtblWalletProps extends React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement> {
     providerPreference: string;
+    isOnRampEnabled?: string;
+    isSwapEnabled?: string;
+    isBridgeEnabled?: string;
     theme: string;
 }
-interface ImtblSwapProps extends undefined<undefined<HTMLElement>, HTMLElement> {
+/**
+ * Props for the Swap Widget component
+ * @property {string} providerPreference - The preferred wallet provider to connect to.
+ * @property {string} theme - The theme to use.
+ * @property {string} amount - The amount to swap.
+ * @property {string} fromContractAddress - The contract address of the source token.
+ * @property {string} toContractAddress - The contract address of the destination token.
+ */
+interface ImtblSwapProps extends React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement> {
     providerPreference: string;
     theme: string;
     amount: string;
     fromContractAddress: string;
     toContractAddress: string;
 }
-interface ImtblBridgeProps extends undefined<undefined<HTMLElement>, HTMLElement> {
+/**
+ * Props for the Bridge Widget component
+ * @property {string} providerPreference - The preferred wallet provider to connect to.
+ * @property {string} theme - The theme to use.
+ * @property {string} fromContractAddress - The contract address of the source token.
+ * @property {string} fromNetwork - The network of the source token.
+ * @property {string} amount - The amount to bridge.
+ */
+interface ImtblBridgeProps extends React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement> {
     providerPreference: string;
     theme: string;
     fromContractAddress: string;
     fromNetwork: string;
     amount: string;
 }
-interface ImtblExampleProps extends undefined<undefined<HTMLElement>, HTMLElement> {
+/**
+ * Props for the Example Widget component
+ * @property {string} providerPreference - The preferred wallet provider to connect to.
+ * @property {string} theme - The theme to use.
+ * @experimental
+ */
+interface ImtblExampleProps extends React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement> {
     providerPreference: string;
     theme: string;
 }
-interface ImtblBuyProps extends undefined<undefined<HTMLElement>, HTMLElement> {
+/**
+ * Props for the Buy Widget component
+ * @property {string} providerPreference - The preferred wallet provider to connect to.
+ * @property {string} theme - The theme to use.
+ * @property {string} orderId - The id of the order to buy.
+ */
+interface ImtblBuyProps extends React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement> {
     providerPreference: string;
     theme: string;
     orderId: string;
 }
-interface ImtblTransitionExampleProps extends undefined<undefined<HTMLElement>, HTMLElement> {
+/**
+ * Props for the TransitionExample Widget component
+ * @property {string} providerPreference - The preferred wallet provider to connect to.
+ * @property {string} theme - The theme to use.
+ */
+interface ImtblTransitionExampleProps extends React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement> {
     providerPreference: string;
     theme: string;
 }
-interface ImtblInnerWidgetExampleProps extends undefined<undefined<HTMLElement>, HTMLElement> {
+/**
+ * Props for the InnerWidgetExample Widget component
+ * @property {string} providerPreference - The preferred wallet provider to connect to.
+ * @property {string} theme - The theme to use.
+ */
+interface ImtblInnerWidgetExampleProps extends React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement> {
     providerPreference: string;
     theme: string;
 }
-interface ImtblOuterWidgetExampleProps extends undefined<undefined<HTMLElement>, HTMLElement> {
+/**
+ * Props for the OuterWidgetExample Widget component
+ * @property {string} providerPreference - The preferred wallet provider to connect to.
+ * @property {string} theme - The theme to use.
+ */
+interface ImtblOuterWidgetExampleProps extends React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement> {
     providerPreference: string;
     theme: string;
 }
+/**
+ * Enum representing the networks supported by Checkout.
+ */
 declare enum Network {
     ETHEREUM = "Ethereum",
     GOERLI = "Goerli",
     POLYGON = "Polygon"
 }
+/**
+ * Enum representing the themes for the Checkout widgets.
+ */
 declare enum WidgetTheme {
     LIGHT = "light",
     DARK = "dark",
     CUSTOM = "custom"
 }
+/**
+ * Enum representing the default Web3 providers supported by the Checkout widgets.
+ */
+declare enum WidgetConnectionProviders {
+    METAMASK = "metamask"
+}
+/**
+ * Enum representing list of Checkout Widgets DOM tags.
+ */
+declare enum CheckoutWidgetTagNames {
+    CONNECT = "imtbl-connect",
+    WALLET = "imtbl-wallet",
+    SWAP = "imtbl-swap",
+    BUY = "imtbl-buy",
+    BRIDGE = "imtbl-bridge",
+    EXAMPLE = "imtbl-example"
+}
+/**
+ * Represents the configuration options for the Checkout Widgets.
+ * @property {WidgetTheme} theme - The theme of the Checkout Widget.
+ */
+type CheckoutWidgetsConfig = {
+    theme?: WidgetTheme;
+};
+/**
+ * Interface representing the props for the Bridge Widget component.
+ * @property {WidgetConnectionProviders} providerPreference - The preferred provider for the Bridge Widget (default: {@link WidgetConnectionProviders.METAMASK}).
+ * @property {string} fromContractAddress - The contract address to send tokens from.
+ * @property {string} amount - The amount of tokens to send.
+ * @property {Network} fromNetwork - The network to send tokens from.
+ */
+interface BridgeReactProps {
+    providerPreference: WidgetConnectionProviders;
+    fromContractAddress?: string;
+    amount?: string;
+    fromNetwork?: Network;
+}
+/**
+ * A React functional component that renders the Checkout Bridge Widget.
+ * @param {BridgeReactProps} props - The props for the Bridge Widget component.
+ * @returns {JSX.Element} - The rendered Bridge Widget component.
+ */
+declare function BridgeReact(props: BridgeReactProps): JSX.Element;
+/**
+ * Interface representing the props for the Buy Widget component.
+ * @property {WidgetConnectionProviders} providerPreference - The preferred provider for the Buy Widget (default: {@link WidgetConnectionProviders.METAMASK}).
+ * @property {string} orderId - The ID that identifies the open buy order associated to the assets to buy.
+ */
+interface BuyReactProps {
+    providerPreference: WidgetConnectionProviders;
+    orderId: string;
+}
+/**
+ * A React functional component that renders the Checkout Buy Widget.
+ * @param {BuyReactProps} props - The props for the Buy Widget component.
+ * @returns {JSX.Element} - The rendered Buy Widget component.
+ */
+declare function BuyReact(props: BuyReactProps): JSX.Element;
+/**
+ * Interface representing the props for the Connect Widget component.
+ * @property {WidgetConnectionProviders} providerPreference - The preferred provider for the Connect Widget (default: {@link WidgetConnectionProviders.METAMASK}).
+ */
+interface ConnectReactProps {
+    providerPreference?: WidgetConnectionProviders;
+}
+/**
+ * A React functional component that renders the Checkout Connect Widget.
+ * @param {ConnectReactProps} props - The props for the Connect Widget component.
+ * @returns {JSX.Element} - The rendered Connect Widget component.
+ */
+declare function ConnectReact(props: ConnectReactProps): JSX.Element;
+/**
+ * Interface representing the props for the Swap Widget component.
+ * @property {WidgetConnectionProviders} providerPreference - The preferred provider for the Swap Widget (default: {@link WidgetConnectionProviders.METAMASK}).
+ * @property {string} fromContractAddress - The contract address to swap tokens from.
+ * @property {string} amount - The amount of tokens to send.
+ * @property {Network} toContractAddress - The contract address to swap tokens to.
+ */
+interface SwapReactProps {
+    providerPreference: WidgetConnectionProviders;
+    fromContractAddress?: string;
+    amount?: string;
+    toContractAddress?: string;
+}
+/**
+ * A React functional component that renders the Checkout Swap Widget.
+ * @param {SwapReactProps} props - The props for the Swap Widget component.
+ * @returns {JSX.Element} - The rendered Swap Widget component.
+ */
+declare function SwapReact(props: SwapReactProps): JSX.Element;
+/**
+ * Interface representing the props for the Wallet Widget component.
+ * @property {WidgetConnectionProviders} providerPreference - The preferred provider for the Wallet Widget (default: {@link WidgetConnectionProviders.METAMASK}).
+ */
+interface WalletReactProps {
+    providerPreference?: WidgetConnectionProviders;
+    isOnRampEnabled?: boolean;
+    isSwapEnabled?: boolean;
+    isBridgeEnabled?: boolean;
+}
+/**
+ * A React functional component that renders the Checkout Wallet Widget.
+ * @param {WalletReactProps} props - The props for the Wallet Widget component.
+ * @returns {JSX.Element} - The rendered Wallet Widget component.
+ */
+declare function WalletReact(props: WalletReactProps): JSX.Element;
+/**
+ * Interface representing the props for the Example Widget component.
+ * @experimental
+ */
+interface ExampleReactProps {
+    providerPreference: WidgetConnectionProviders;
+    fromContractAddress?: string;
+    amount?: string;
+    fromNetwork?: Network;
+}
+/**
+ * A React functional component that renders the Checkout Example Widget.
+ * @experimental
+ */
+declare function ExampleReact(props: ExampleReactProps): JSX.Element;
+/**
+ * CheckoutWidgets allows to inject the Checkout Widgets into your application.
+ * @param {CheckoutWidgetsConfig|undefined} config - Checkout Widget global configurations.
+ */
+declare function CheckoutWidgets(config?: CheckoutWidgetsConfig): void;
+/**
+ * UpdateConfig allows to update the configuration of an existing Checkout Widgets instance.
+ * @param {CheckoutWidgetsConfig} config - new Checkout Widget global configurations.
+ */
+declare function UpdateConfig(config: CheckoutWidgetsConfig): void;
+/**
+ * SetProvider allows to set the provider for an existing Checkout Widgets instance.
+ * @param {CheckoutWidgetTagNames} tagName - target Checkout Widget widget.
+ * @param {Web3Provider} provider - the provider to connect to the blockchain network.
+ */
+declare function SetProvider(tagName: CheckoutWidgetTagNames, provider: Web3Provider | null): void;
 
-export { BridgeEvent, BridgeEventType, BridgeFailed, BridgeSuccess, BuyClose, BuyEvent, BuyEventType, BuyFailed, BuyNotConnected, BuySuccess, ConnectEvent, ConnectEventType, ConnectionFailed, ConnectionProviders, ConnectionSuccess, IMTBLWidgetEvents, ImtblBridgeProps, ImtblBuyProps, ImtblConnectProps, ImtblExampleProps, ImtblInnerWidgetExampleProps, ImtblOuterWidgetExampleProps, ImtblSwapProps, ImtblTransitionExampleProps, ImtblWalletProps, Network, SwapEvent, SwapEventType, SwapFailed, SwapSuccess, WalletEvent, WalletEventType, WalletNetworkSwitchEvent, WidgetTheme };
+export { BridgeEvent, BridgeEventType, BridgeFailed, BridgeReact, BridgeReactProps, BridgeSuccess, BuyClose, BuyEvent, BuyEventType, BuyFailed, BuyNotConnected, BuyReact, BuyReactProps, BuySuccess, CheckoutWidgetTagNames, CheckoutWidgets, CheckoutWidgetsConfig, ConnectEvent, ConnectEventType, ConnectReact, ConnectReactProps, ConnectionFailed, ConnectionSuccess, ExampleReact, ExampleReactProps, IMTBLWidgetEvents, ImtblBridgeProps, ImtblBuyProps, ImtblConnectProps, ImtblExampleProps, ImtblInnerWidgetExampleProps, ImtblOuterWidgetExampleProps, ImtblSwapProps, ImtblTransitionExampleProps, ImtblWalletProps, Network, OnRampEvent, OnRampEventType, SetProvider, SwapEvent, SwapEventType, SwapFailed, SwapReact, SwapReactProps, SwapSuccess, UpdateConfig, WalletAddCoinsEvent, WalletEvent, WalletEventType, WalletNetworkSwitchEvent, WalletReact, WalletReactProps, WalletRequestBridgeEvent, WalletRequestOnrampEvent, WalletRequestSwapEvent, WidgetConnectionProviders, WidgetTheme };