@imtbl/sdk 0.1.6 → 0.1.7-alpha.2

package/dist/checkout_sdk.d.ts

@@ -0,0 +1,986 @@
+/// <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 = {
+    name: string;
+    chainId: number;
+    ensAddress?: string;
+    _defaultProvider?: (providers: any, options?: any) => any;
+};
+declare type Networkish = Network | 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$1 {
+    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$1 {
+    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>;
+    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 {
+    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>;
+    _network: Network;
+    _events: Array<Event>;
+    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>);
+    _ready(): Promise<Network>;
+    get ready(): Promise<Network>;
+    static getFormatter(): Formatter;
+    static getNetwork(network: Networkish): Network;
+    ccipReadFetch(tx: Transaction$1, calldata: string, urls: Array<string>): Promise<null | string>;
+    _getInternalBlockNumber(maxAge: number): Promise<number>;
+    poll(): Promise<void>;
+    resetEventsBlock(blockNumber: number): void;
+    get network(): Network;
+    detectNetwork(): Promise<Network>;
+    getNetwork(): Promise<Network>;
+    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$1, hash?: string, startBlock?: number): TransactionResponse;
+    sendTransaction(signedTransaction: string | Promise<string>): Promise<TransactionResponse>;
+    _getTransactionRequest(transaction: Deferrable<TransactionRequest>): Promise<Transaction$1>;
+    _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): void;
+    _stopEvent(event: Event): 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>;
+    _uncachedDetectNetwork(): Promise<Network>;
+    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): void;
+    _startPending(): void;
+    _stopEvent(event: Event): 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>;
+}
+
+declare enum Environment {
+    PRODUCTION = "production",
+    SANDBOX = "sandbox"
+}
+declare class ImmutableConfiguration {
+    readonly environment: Environment;
+    readonly apiKey?: string;
+    constructor(options: {
+        environment: Environment;
+        apiKey?: string;
+    });
+}
+interface ModuleConfiguration<T> {
+    baseConfig: ImmutableConfiguration;
+    overrides?: T;
+}
+
+/**
+ * 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 parameters for {@link Checkout.getTokenAllowList}.
+ * @property {TokenFilterTypes} type - The type of token to retrieve.
+ * @property {ChainId}  chainId - The ID of the blockchain network.
+ * @property {TokenFilter[]} [exclude] - The tokens to exclude from the list.
+ */
+interface GetTokenAllowListParams {
+    type: TokenFilterTypes;
+    chainId?: ChainId;
+    exclude?: TokenFilter[];
+}
+/**
+ * Interface representing the result of {@link Checkout.getTokenAllowList}.
+ * @property {TokenInfo[]} tokens - The list of tokens allowed for the specified params.
+ */
+interface GetTokenAllowListResult {
+    tokens: TokenInfo[];
+}
+/**
+ * Enum representing the types of token filters available.
+ */
+declare enum TokenFilterTypes {
+    SWAP = "swap",
+    BRIDGE = "bridge",
+    ALL = "all"
+}
+/**
+ * Interface representing a token filter that can be used to exclude certain tokens.
+ * @property {string} address - The token contract address.
+ */
+interface TokenFilter {
+    address: string;
+}
+/**
+ * Enum representing the supported chains with their corresponding IDs.
+ */
+declare enum ChainId {
+    ETHEREUM = 1,
+    SEPOLIA = 11155111,
+    IMTBL_ZKEVM_DEVNET = 13373,
+    IMTBL_ZKEVM_TESTNET = 13372,
+    POLYGON_ZKEVM_TESTNET = 1442,
+    POLYGON_ZKEVM = 137
+}
+/**
+ * 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;
+}
+/**
+ * Type representing the details of a network.
+ * @property {string} chainIdHex - The hexadecimal ID of the network.
+ * @property {string} chainName - The name of the network.
+ * @property {string[]} rpcUrls - The RPS URLs of the network's node.
+ * @property {TokenInfo} nativeCurrency - The info of the network's native currency.
+ * @property {string[]} [blockExplorerUrls] - The URLs of the network's block explorer.
+ */
+type NetworkDetails = {
+    chainIdHex: string;
+    chainName: string;
+    rpcUrls: string[];
+    nativeCurrency: TokenInfo;
+    blockExplorerUrls?: string[];
+};
+/**
+ * Type representing the mapping between ChainId and NetworkDetails
+ */
+type NetworkMap = Map<ChainId, NetworkDetails>;
+/**
+ * Interface representing the parameters for {@link Checkout.switchNetwork}.
+ * @property {Web3Provider} provider - The provider to connect to the network.
+ * @property {ChainId} chainId - The ID of the network to switch to.
+ */
+interface SwitchNetworkParams {
+    provider: Web3Provider;
+    chainId: ChainId;
+}
+/**
+ * Interface representing the result of {@link Checkout.switchNetwork}.
+ * @property {NetworkInfo} network - The information of the network that was switched to.
+ */
+interface SwitchNetworkResult {
+    network: NetworkInfo;
+    provider: Web3Provider;
+}
+/**
+ * * Interface representing the parameters for {@link Checkout.getNetworkInfo}.
+ * @property {Web3Provider} provider - The provider to connect to the network.
+ */
+interface GetNetworkParams {
+    provider: Web3Provider;
+}
+/**
+ * Enum representing the types of filters that can be applied to get the allow list of networks.
+ */
+declare enum NetworkFilterTypes {
+    ALL = "all"
+}
+/**
+ * Interface representing a filter for filtering a specific network.
+ * @property {ChainId} chainId - The ID of the network to allow or disallow.
+ */
+interface NetworkFilter {
+    chainId: ChainId;
+}
+/**
+ * * Interface representing the parameters for {@link Checkout.getNetworkAllowList}.
+ * @property {NetworkFilterTypes} type - The type of allow list filter to apply.
+ * @property {NetworkFilter[]} [exclude] - The list of networks to exclude from the allow list.
+ */
+interface GetNetworkAllowListParams {
+    type: NetworkFilterTypes;
+    exclude?: NetworkFilter[];
+}
+/**
+ * Interface representing the result of {@link Checkout.getNetworkAllowList}.
+ * @property {NetworkInfo[]} networks - The list of allowed networks.
+ */
+interface GetNetworkAllowListResult {
+    networks: NetworkInfo[];
+}
+/**
+ * Interface representing the parameters for {@link Checkout.getBalance}.
+ * @property {@link Web3Provider} provider - The provider to connect to the network.
+ * @property {string} walletAddress - The wallet address.
+ * @property {string | undefined} contractAddress - The contract address of the token.
+ */
+interface GetBalanceParams {
+    provider: Web3Provider;
+    walletAddress: string;
+    contractAddress?: string;
+}
+/**
+ * Interface representing the result of {@link Checkout.getBalance}.
+ * @property {BigNumber} balance - The balance of the wallet for the token.
+ * @property {string} formattedBalance - The formatted balance of the wallet for the token.
+ * @property {TokenInfo} token - The token information.
+ */
+interface GetBalanceResult {
+    balance: BigNumber;
+    formattedBalance: string;
+    token: TokenInfo;
+}
+/**
+ * Interface representing the parameters for {@link Checkout.getAllBalances}.
+ * @property {Web3Provider} provider - The provider to connect to the network.
+ * @property {string} walletAddress - The wallet address.
+ * @property {ChainId} chainId - The ID of the network.
+ */
+interface GetAllBalancesParams {
+    provider: Web3Provider;
+    walletAddress: string;
+    chainId: ChainId;
+}
+/**
+ * Interface representing the result of {@link Checkout.getAllBalances}.
+ * @property {GetBalanceResult[]} balances - The array of balances of the wallet for every token.
+ */
+interface GetAllBalancesResult {
+    balances: GetBalanceResult[];
+}
+interface CheckoutOverrides {
+}
+interface CheckoutModuleConfiguration extends ModuleConfiguration<CheckoutOverrides> {
+}
+/**
+ * Enum representing the list of default supported providers.
+ */
+declare enum ConnectionProviders {
+    METAMASK = "metamask"
+}
+/**
+ * Interface representing the parameters for {@link Checkout.connect}.
+ * @property {ConnectionProviders} providerPreference - The preferred provider to connect to the network.
+ */
+type ConnectParams = {
+    providerPreference: ConnectionProviders;
+};
+/**
+ * Interface representing the result of {@link Checkout.connect}.
+ * @property {Web3Provider} provider - The provider used to connect to the network.
+ * @property {NetworkInfo} network - Information about the connected network.
+ */
+interface ConnectResult {
+    provider: Web3Provider;
+    network: NetworkInfo;
+}
+/**
+ * Interface representing the parameters for {@link Checkout.checkIsWalletConnected}.
+ * @property {ConnectionProviders} providerPreference - The preferred provider to use to check the connection status to th Web3 network.
+ */
+interface CheckConnectionParams {
+    providerPreference: ConnectionProviders;
+}
+/**
+ * Interface representing the result of {@link Checkout.checkIsWalletConnected}.
+ * @property {boolean} isConnected - A boolean indicating the connection status of th Web3 provider.
+ * @property {string} walletAddress - The wallet address used to check the connection.
+ */
+interface CheckConnectionResult {
+    isConnected: boolean;
+    walletAddress: string;
+}
+/**
+ * Interface representing the parameters for {@link Checkout.sendTransaction}.
+ * @property {Web3Provider} provider - The provider to connect to the network.
+ * @property {Transaction} transaction - The transaction to send.
+ */
+interface SendTransactionParams {
+    provider: Web3Provider;
+    transaction: Transaction;
+}
+/**
+ * Interface representing the result of {@link Checkout.sendTransaction}.
+ * @property {TransactionResponse} transactionResponse - The response of the transaction.
+ */
+interface SendTransactionResult {
+    transactionResponse: TransactionResponse;
+}
+/**
+ * Interface representing a blockchain transaction.
+ * @property {string} nonce - The transaction nonce.
+ * @property {string} gasPrice - The gas price of the transaction.
+ * @property {string} gas - The gas limit for the transaction.
+ * @property {string} to - The address of the recipient.
+ * @property {string} from - The address of the sender.
+ * @property {string} value - The value to transfer in wei.
+ * @property {string} data - The data to include in the transaction.
+ * @property {number} chainId - The ID of the chain the transaction is for.
+ */
+interface Transaction {
+    nonce: string;
+    gasPrice: string;
+    gas: string;
+    to: string;
+    from: string;
+    value: string;
+    data: string;
+    chainId: number;
+}
+/**
+ * Interface representing a wallet filter to be used in {@link GetWalletAllowListParams}.
+ * @property {ConnectionProviders} connectionProvider - The connection provider to filter wallets by.
+ */
+interface WalletFilter {
+    connectionProvider: ConnectionProviders;
+}
+/**
+ * Interface representing the parameters for {@link Checkout.getWalletAllowList}.
+ * @property {WalletFilterTypes} type - The type of wallets to filter by.
+ * @property {WalletFilter[]} [exclude] - An optional list of wallet filters to exclude from the allowed wallets list.
+ */
+interface GetWalletAllowListParams {
+    type: WalletFilterTypes;
+    exclude?: WalletFilter[];
+}
+/**
+ * Interface representing information about a wallet used in {@link GetWalletAllowListResult}.
+ * @property {ConnectionProviders} connectionProvider - The connection provider for the wallet.
+ * @property {string} name - The name of the wallet.
+ * @property {string} description - A description of the wallet.
+ * @property {string} icon - The URL/data:image of an icon for the wallet.
+ */
+interface WalletInfo {
+    connectionProvider: ConnectionProviders;
+    name: string;
+    description: string;
+    icon: string;
+}
+/**
+ * Interface representing the result of {@link Checkout.getWalletAllowList}.
+ * @property {WalletInfo[]} wallets - A list of {@link WalletInfo} objects representing the allowed wallets.
+ */
+interface GetWalletAllowListResult {
+    wallets: WalletInfo[];
+}
+/**
+ * Enum representing the platform filters used in {@link GetWalletAllowListParams}.
+ */
+declare enum WalletFilterTypes {
+    ALL = "all",
+    DESKTOP = "desktop",
+    MOBILE = "mobile"
+}
+/**
+ * The different types of errors that can be returned by the checkout process.
+ */
+declare enum CheckoutErrorType {
+    PROVIDER_PREFERENCE_ERROR = "PROVIDER_PREFERENCE_ERROR",
+    CONNECT_PROVIDER_ERROR = "CONNECT_PROVIDER_ERROR",
+    GET_BALANCE_ERROR = "GET_BALANCE_ERROR",
+    GET_ERC20_BALANCE_ERROR = "GET_ERC20_BALANCE_ERROR",
+    GET_NETWORK_INFO_ERROR = "GET_NETWORK_INFO_ERROR",
+    METAMASK_PROVIDER_ERROR = "METAMASK_PROVIDER_ERROR",
+    CHAIN_NOT_SUPPORTED_ERROR = "CHAIN_NOT_SUPPORTED_ERROR",
+    PROVIDER_REQUEST_MISSING_ERROR = "PROVIDER_REQUEST_MISSING_ERROR",
+    PROVIDER_REQUEST_FAILED_ERROR = "PROVIDER_REQUEST_FAILED_ERROR",
+    USER_REJECTED_REQUEST_ERROR = "USER_REJECTED_REQUEST_ERROR",
+    TRANSACTION_ERROR = "TRANSACTION_ERROR"
+}
+/**
+ * The type signature for an error.
+ * Contains a type that corresponds to a {@link CheckoutErrorType}, an optional message string and optional data object.
+ */
+type ErrorType = {
+    type: CheckoutErrorType;
+    message?: string;
+    data?: {
+        [key: string]: string;
+    };
+};
+declare class CheckoutConfiguration {
+    readonly environment: Environment;
+    readonly networkMap: NetworkMap;
+    constructor(config: CheckoutModuleConfiguration);
+}
+declare class Checkout {
+    readonly config: CheckoutConfiguration;
+    constructor(config?: CheckoutModuleConfiguration);
+    /**
+     * Check if a wallet is connected to the current application
+     * without requesting permission from the wallet and hence triggering a connect popup.
+     * @param {CheckConnectionParams} params - The necessary data required to verify a wallet connection status.
+     * @returns Wallet connection status details.
+     * @throws {@link ErrorType}
+     */
+    checkIsWalletConnected(params: CheckConnectionParams): Promise<CheckConnectionResult>;
+    /**
+     * Establish a connection with a wallet provider such as MetaMask and returns the provider object and the current network details.
+     * @param {ConnectParams} params - The necessary data required to establish a connection with a wallet provider.
+     * @returns Wallet provider and current network information.
+     * @throws {@link ErrorType}
+     */
+    connect(params: ConnectParams): Promise<ConnectResult>;
+    /**
+     * Switch the currently connected wallet to a new network.
+     * @param {SwitchNetworkParams} params - The necessary data required to switch network.
+     * @returns The new network information.
+     * @throws {@link ErrorType}
+     */
+    switchNetwork(params: SwitchNetworkParams): Promise<SwitchNetworkResult>;
+    /**
+     * Fetch the balance of the native token of the current connected network or,
+     * if a contract address is provided, it will return the balance of that ERC20 token. For example,
+     * if the wallet is connected to the Ethereum Mainnet then the function gets the wallet ETH L1 balance.
+     * @param {GetBalanceParams} params - The necessary data required to fetch the wallet balance.
+     * @returns Native token balance for the given wallet.
+     * @throws {@link ErrorType}
+     */
+    getBalance(params: GetBalanceParams): Promise<GetBalanceResult>;
+    /**
+     * Fetch all available balances (ERC20 & Native) of the current connected network of the given wallet.
+     * It will loop through the list of allowed tokens and check for balance on each one.
+     * @param {GetAllBalancesParams} params - The necessary data required to fetch all the wallet balances.
+     * @returns List of tokens balance for the given wallet.
+     * @throws {@link ErrorType}
+     */
+    getAllBalances(params: GetAllBalancesParams): Promise<GetAllBalancesResult>;
+    /**
+     * Fetch the list of available networks that a wallet can add or/and switch to.
+     * @param {GetNetworkAllowListParams} params - The necessary data required to fetch the list of available networks.
+     * @returns List of networks.
+     * @throws {@link ErrorType}
+     */
+    getNetworkAllowList(params: GetNetworkAllowListParams): Promise<GetNetworkAllowListResult>;
+    /**
+     * Get the list of tokens which are allowed to be used with the product.
+     * @param {GetTokenAllowListParams} params - The necessary data required to fetch the list of allowed tokens.
+     * @returns List of allowed tokens.
+     * @throws {@link ErrorType}
+     */
+    getTokenAllowList(params: GetTokenAllowListParams): Promise<GetTokenAllowListResult>;
+    /**
+     * Fetch the list of wallets which are available to connect with.
+     * @param {GetWalletAllowListParams} params - The necessary data required to fetch the list of allowed wallets.
+     * @returns List of allowed wallets.
+     * @throws {@link ErrorType}
+     */
+    getWalletAllowList(params: GetWalletAllowListParams): Promise<GetWalletAllowListResult>;
+    /**
+     * Send a generic transaction to the provider.
+     * @param {SendTransactionParams} params - The necessary data required to send a transaction.
+     * @returns Transaction response.
+     * @throws {@link ErrorType}
+     * @remarks
+     * Further documenation can be found at [MetaMask | Sending Transactions](https://docs.metamask.io/guide/sending-transactions.html).
+     */
+    sendTransaction(params: SendTransactionParams): Promise<SendTransactionResult>;
+    /**
+     * Get network information about the currently selected network.
+     * @param {GetNetworkParams} params - The necessary data required to get the current network information.
+     * @returns Network details.
+     * @throws {@link ErrorType}
+     */
+    getNetworkInfo(params: GetNetworkParams): Promise<NetworkInfo>;
+}
+
+export { ChainId, CheckConnectionParams, CheckConnectionResult, Checkout, CheckoutErrorType, CheckoutModuleConfiguration, ConnectParams, ConnectResult, ConnectionProviders, ErrorType, GetAllBalancesParams, GetAllBalancesResult, GetBalanceParams, GetBalanceResult, GetNetworkAllowListParams, GetNetworkAllowListResult, GetNetworkParams, GetTokenAllowListParams, GetTokenAllowListResult, GetWalletAllowListParams, GetWalletAllowListResult, NetworkFilter, NetworkFilterTypes, NetworkInfo, SendTransactionParams, SendTransactionResult, SwitchNetworkParams, SwitchNetworkResult, TokenFilter, TokenFilterTypes, TokenInfo, Transaction, WalletFilter, WalletFilterTypes, WalletInfo };