@imtbl/sdk 0.4.3 → 0.4.4-alpha.1

package/dist/checkout_sdk.d.ts

@@ -0,0 +1,1188 @@
+/// <reference types="node" />
+import { ExchangeContracts } from 'config';
+
+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 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 Network = {
+    name: string;
+    chainId: number;
+    ensAddress?: string;
+    _defaultProvider?: (providers: any, options?: any) => any;
+};
+declare type Networkish = Network | string | number;
+
+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>;
+    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;
+}
+
+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 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, 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, 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): 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;
+}
+
+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 a token
+ * @property {number} chainId - The chain ID
+ * @property {string} address - The token address
+ * @property {number} decimals - The token decimals
+ * @property {string | undefined} symbol - The token symbol or undefined if it is not available
+ * @property {string | undefined} name - The token name or undefined if it is not available
+ */
+type TokenInfo$1 = {
+    chainId: number;
+    address: string;
+    decimals: number;
+    symbol?: string;
+    name?: string;
+};
+interface ExchangeOverrides {
+    rpcURL: string;
+    exchangeContracts: ExchangeContracts;
+    commonRoutingTokens: TokenInfo$1[];
+    nativeToken: TokenInfo$1;
+}
+
+/**
+ * @typedef {string} Address - Represents an Ethereum address.
+ */
+type Address = string;
+/**
+ * @typedef {Address | 'NATIVE'} FungibleToken - Represents a fungible token, either an ERC20 token address or the native token.
+ */
+type FungibleToken = Address | 'NATIVE';
+
+/**
+ * Enum representing different chain IDs.
+ * @enum {number}
+ * @property {number} IMTBL_ZKEVM_MAINNET - The chain ID for IMTBL ZKEVM Mainnet.
+ * @property {number} IMTBL_ZKEVM_TESTNET - The chain ID for IMTBL ZKEVM Testnet.
+ * @property {number} IMTBL_ZKEVM_DEVNET - The chain ID for IMTBL ZKEVM Devnet.
+ * @property {number} ETHEREUM - The chain ID for Ethereum.
+ * @property {number} SEPOLIA - The chain ID for Sepolia.
+ */
+declare enum ChainId {
+    IMTBL_ZKEVM_MAINNET = 13371,
+    IMTBL_ZKEVM_TESTNET = 13372,
+    IMTBL_ZKEVM_DEVNET = 13433,
+    ETHEREUM = 1,
+    SEPOLIA = 11155111
+}
+/**
+ * Enum representing different chain names.
+ * @enum {number}
+ * @property {number} IMTBL_ZKEVM_MAINNET - The chain name for IMTBL ZKEVM Mainnet.
+ * @property {number} IMTBL_ZKEVM_TESTNET - The chain name for IMTBL ZKEVM Testnet.
+ * @property {number} IMTBL_ZKEVM_DEVNET - The chain name for IMTBL ZKEVM Devnet.
+ * @property {number} ETHEREUM - The chain name for Ethereum.
+ * @property {number} SEPOLIA - The chain name for Sepolia.
+ */
+declare enum ChainName {
+    ETHEREUM = "Ethereum",
+    SEPOLIA = "Sepolia",
+    IMTBL_ZKEVM_TESTNET = "Immutable zkEVM Test",
+    IMTBL_ZKEVM_DEVNET = "Immutable zkEVM Dev",
+    IMTBL_ZKEVM_MAINNET = "Immutable zkEVM"
+}
+/**
+ * Represents information about a token.
+ * @interface TokenInfo
+ * @property {string} name - The name of the token.
+ * @property {string} symbol - The symbol of the token.
+ * @property {number} decimals - The number of decimal places the token supports.
+ * @property {string | undefined} [address] - The address of the token.
+ * @property {string | undefined} [icon] - The URL of the token's icon.
+ */
+interface TokenInfo {
+    name: string;
+    symbol: string;
+    decimals: number;
+    address?: string;
+    icon?: string;
+}
+/**
+ * Interface representing the parameters for {@link Checkout.getBalance}.
+ * @property {Web3Provider} provider - The provider used to get the balance.
+ * @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 used to get the balances.
+ * @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> {
+}
+/**
+ * A type representing various remotely defined configurations which are
+ * accessible via the Checkout config and configured based on the Environment.
+ * @property {DexConfig} dex - The config used for the DEX.
+ * @property {AllowedNetworkConfig[]} allowedNetworks - An array representing the allowed networks.
+ * @property {GasEstimateTokenConfig | undefined} gasEstimateTokens - The config for the tokens used to estimate gas.
+ */
+type RemoteConfiguration = {
+    dex: DexConfig;
+    allowedNetworks: AllowedNetworkConfig[];
+    gasEstimateTokens?: GasEstimateTokenConfig;
+};
+/**
+ * A type representing the configuration for the DEX.
+ * @property {ExchangeOverrides | undefined} overrides - The DEX overrides.
+ * @property {TokenInfo[] | undefined} tokens - An array of tokens compatible with the DEX.
+ */
+type DexConfig = {
+    overrides?: ExchangeOverrides;
+    tokens?: TokenInfo[];
+};
+/**
+ * A type representing an allowed network.
+ * @property {number} chainId - The network chain id.
+ */
+type AllowedNetworkConfig = {
+    chainId: number;
+};
+/**
+ * A type representing the required information to estimate gas for a transaction.
+ * @type {{ [key: string]: { bridgeToL2Addresses?: GasEstimateBridgeToL2TokenConfig, swapAddresses?: GasEstimateSwapTokenConfig } }}
+ * - A map of addresses for estimating gas keyed by the network chain id.
+ * @property {GasEstimateBridgeToL2TokenConfig | undefined} bridgeToL2Addresses
+ * - The type representing the addresses for a bridge to layer 2 gas estimate.
+ * @property {GasEstimateSwapTokenConfig | undefined} swapAddresses - The type representing the addresses for a swap gas estimate
+ */
+type GasEstimateTokenConfig = {
+    [key: string]: {
+        bridgeToL2Addresses?: GasEstimateBridgeToL2TokenConfig;
+        swapAddresses?: GasEstimateSwapTokenConfig;
+    };
+};
+/**
+ * A type representing the config for a bridge to layer 2 gas estimate.
+ * @property {string | 'NATIVE'} gasTokenAddress - The address of the gas token.
+ * @property {string} fromAddress - The address of the token being bridged.
+ */
+type GasEstimateBridgeToL2TokenConfig = {
+    gasTokenAddress: string | 'NATIVE';
+    fromAddress: string;
+};
+/**
+ * A type representing the config for a swap gas estimate.
+ * @property {string} inAddress - The in token address.
+ * @property {string} outAddress - The out token address.
+ */
+type GasEstimateSwapTokenConfig = {
+    inAddress: string;
+    outAddress: string;
+};
+/**
+ * Represents information about a network.
+ * @interface NetworkInfo
+ * @property {string} name - The name of the network.
+ * @property {number} chainId - The chain ID of the network.
+ * @property {TokenInfo} nativeCurrency - Information about the native currency of the network.
+ * @property {boolean} isSupported - Indicates whether the network is supported.
+ */
+interface NetworkInfo {
+    name: string;
+    chainId: number;
+    nativeCurrency: TokenInfo;
+    isSupported: boolean;
+}
+/**
+ * Interface representing the params of {@link Checkout.connect}.
+ * @property {Web3Provider} provider - The provider used to connect to the network.
+ */
+interface ConnectParams {
+    provider: Web3Provider;
+}
+/**
+ * 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 params of {@link Checkout.checkIsWalletConnected}.
+ * @property {Web3Provider} provider - The provider used to connect to the network.
+ */
+interface CheckConnectionParams {
+    provider: Web3Provider;
+}
+/**
+ * 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;
+}
+/**
+ * An enum representing the type of gas estimate.
+ * @enum {string}
+ * @property {string} BRIDGE_TO_L2 - The gas estimate type for a bridge to L2 transaction.
+ * @property {string} SWAP - The gas estimate type for a swap transaction.
+ */
+declare enum GasEstimateType {
+    BRIDGE_TO_L2 = "BRIDGE_TO_L2",
+    SWAP = "SWAP"
+}
+/**
+ * Represents the parameters for estimating gas usage, which can be either
+ * GasEstimateBridgeToL2Params or GasEstimateSwapParams {@link Checkout.gasEstimate}.
+ * @typedef {GasEstimateBridgeToL2Params | GasEstimateSwapParams} GasEstimateParams
+ */
+type GasEstimateParams = GasEstimateBridgeToL2Params | GasEstimateSwapParams;
+/**
+ * An interface representing the parameters for estimating gas for a bridge to L2 transaction {@link Checkout.gasEstimate}.
+ * @param {GasEstimateType.BRIDGE_TO_L2} gasEstimateType - The type of gas estimate.
+ * @param {boolean} isSpendingCapApprovalRequired - Whether or not spending cap approval is required.
+ * @param {FungibleToken | undefined} tokenAddress - The address of the fungible token to use in the transaction.
+ */
+interface GasEstimateBridgeToL2Params {
+    gasEstimateType: GasEstimateType.BRIDGE_TO_L2;
+    isSpendingCapApprovalRequired: boolean;
+    tokenAddress?: FungibleToken;
+}
+/**
+ * An interface representing the parameters for a gas estimate swap {@link Checkout.gasEstimate}.
+ * @interface
+ * @property {GasEstimateType.SWAP} gasEstimateType - The type of gas estimate, which is always "swap".
+ */
+interface GasEstimateSwapParams {
+    gasEstimateType: GasEstimateType.SWAP;
+}
+/**
+ * An interface representing the result of a gas estimate for a swap transaction {@link Checkout.gasEstimate}.
+ * @interface GasEstimateSwapResult
+ * @property {GasEstimateType.SWAP} gasEstimateType - The type of gas estimate, which is always "SWAP".
+ * @property {TokenAmountEstimate} gasFee - The estimated gas fee for the swap transaction.
+ */
+interface GasEstimateSwapResult {
+    gasEstimateType: GasEstimateType.SWAP;
+    gasFee: TokenAmountEstimate;
+}
+/**
+ * An interface representing the result of a gas estimate for a bridge to L2 transaction {@link Checkout.gasEstimate}.
+ * @interface GasEstimateBridgeToL2Result
+ * @property {GasEstimateType.BRIDGE_TO_L2} gasEstimateType - The type of gas estimate.
+ * @property {TokenAmountEstimate} gasFee - The estimated gas fee for the transaction.
+ * @property {TokenAmountEstimate} bridgeFee - The estimated bridge fee for the transaction.
+ * @property {boolean} bridgeable - A boolean indicating whether the transaction is bridgeable.
+ */
+interface GasEstimateBridgeToL2Result {
+    gasEstimateType: GasEstimateType.BRIDGE_TO_L2;
+    gasFee: TokenAmountEstimate;
+    bridgeFee: TokenAmountEstimate;
+    bridgeable: boolean;
+}
+interface TokenAmountEstimate {
+    estimatedAmount?: BigNumber;
+    token?: TokenInfo;
+}
+/**
+ * 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;
+}
+/**
+ * Represents the result of switching the network in a Web3 application {@link Checkout.switchNetwork}.
+ * @interface SwitchNetworkResult
+ * @property {NetworkInfo} network - The information about the switched network.
+ * @property {Web3Provider} provider - The Web3 provider for the switched network.
+ */
+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;
+}
+/**
+ * * 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[];
+}
+/**
+ * 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.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 {
+    ALL = "all",
+    SWAP = "swap",
+    BRIDGE = "bridge"
+}
+/**
+ * Interface representing a token filter that can be used to exclude certain tokens.
+ * @property {string} address - The token contract address.
+ */
+interface TokenFilter {
+    address: string;
+}
+/**
+ * Interface representing the parameters for {@link Checkout.sendTransaction}.
+ * @property {Web3Provider} provider - The provider to connect to the network.
+ * @property {TransactionRequest} transaction - The transaction to send.
+ */
+interface SendTransactionParams {
+    provider: Web3Provider;
+    transaction: TransactionRequest;
+}
+/**
+ * Interface representing the result of {@link Checkout.sendTransaction}.
+ * @property {TransactionResponse} transactionResponse - The response of the transaction.
+ */
+interface SendTransactionResult {
+    transactionResponse: TransactionResponse;
+}
+/**
+ * Enum representing the names of different wallet providers.
+ */
+declare enum WalletProviderName {
+    METAMASK = "metamask"
+}
+/**
+ * Interface for the parameters required to create a wallet provider {@link Checkout.createProvider}.
+ * @interface CreateProviderParams
+ * @property {WalletProviderName} walletProvider - The name of the wallet provider.
+ */
+interface CreateProviderParams {
+    walletProvider: WalletProviderName;
+}
+/**
+ * Represents the result of creating a Web3 provider {@link Checkout.createProvider}.
+ * @property {Web3Provider} provider - The created Web3 provider.
+ * @property {WalletProviderName} providerName - The name of the wallet provider.
+ */
+type CreateProviderResult = {
+    provider: Web3Provider;
+    walletProviderName: WalletProviderName;
+};
+/**
+ * Interface representing a wallet filter to be used in {@link GetWalletAllowListParams}.
+ * @property {WalletProviderName} connectionProvider - The connection provider to filter wallets by.
+ */
+interface WalletFilter {
+    walletProvider: WalletProviderName;
+}
+/**
+ * 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 {WalletProviderName} walletProvider - The connection provider for the wallet.
+ * @property {string} name - The name of the wallet.
+ * @property {string | undefined} description - A description of the wallet.
+ * @property {string | undefined} icon - The URL/data:image of an icon for the wallet.
+ */
+interface WalletInfo {
+    walletProvider: WalletProviderName;
+    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"
+}
+/**
+ * Base URL for the checkout API based on the environment.
+ * @property {string} DEVELOPMENT - The base URL for the development environment.
+ * @property {string} SANDBOX - The base URL for the sandbox environment.
+ * @property {string} PRODUCTION - The base URL for the production environment.
+ */
+declare const CHECKOUT_API_BASE_URL: {
+    [x: string]: string;
+    sandbox: string;
+    production: string;
+};
+type NetworkDetails = {
+    chainIdHex: string;
+    chainName: string;
+    rpcUrls: string[];
+    nativeCurrency: TokenInfo;
+    blockExplorerUrls?: string[];
+};
+type NetworkMap = Map<ChainId, NetworkDetails>;
+/**
+ * Enum representing different types of errors that can occur during the checkout process.
+ */
+declare enum CheckoutErrorType {
+    WEB3_PROVIDER_ERROR = "WEB3_PROVIDER_ERROR",
+    PROVIDER_ERROR = "PROVIDER_ERROR",
+    DEFAULT_PROVIDER_ERROR = "DEFAULT_PROVIDER_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_FAILED = "TRANSACTION_FAILED",
+    INSUFFICIENT_FUNDS = "INSUFFICIENT_FUNDS",
+    UNPREDICTABLE_GAS_LIMIT = "UNPREDICTABLE_GAS_LIMIT",
+    INVALID_GAS_ESTIMATE_TYPE = "INVALID_GAS_ESTIMATE_TYPE"
+}
+/**
+ * Represents an error object with a specific type, optional message, and optional data.
+ * @property {CheckoutErrorType} type - The type of the error.
+ * @property {string | undefined} [message] - The error message.
+ * @property {Object.<string, string> | undefined} [data] - Additional data associated with the error.
+ */
+type ErrorType = {
+    type: CheckoutErrorType;
+    message?: string;
+    data?: {
+        [key: string]: string;
+    };
+};
+type RemoteConfigParams = {
+    isDevelopment: boolean;
+    isProduction: boolean;
+};
+declare class RemoteConfigFetcher {
+    constructor(params: RemoteConfigParams);
+    getConfig(key?: keyof RemoteConfiguration): Promise<RemoteConfiguration | RemoteConfiguration[keyof RemoteConfiguration] | undefined>;
+    getTokens(chainId: ChainId): Promise<TokenInfo[]>;
+}
+declare class CheckoutConfiguration {
+    readonly isDevelopment: boolean;
+    readonly isLocal: boolean;
+    readonly isProduction: boolean;
+    readonly remote: RemoteConfigFetcher;
+    readonly environment: Environment;
+    readonly networkMap: NetworkMap;
+    constructor(config: CheckoutModuleConfiguration);
+}
+declare class Checkout {
+    readonly config: CheckoutConfiguration;
+    /**
+     * Constructs a new instance of the CheckoutModule class.
+     * @param {CheckoutModuleConfiguration} [config=SANDBOX_CONFIGURATION] - The configuration object for the CheckoutModule.
+     */
+    constructor(config?: CheckoutModuleConfiguration);
+    /**
+     * Creates a provider using the given parameters.
+     * @param {CreateProviderParams} params - The parameters for creating the provider.
+     * @returns {Promise<CreateProviderResult>} A promise that resolves to the created provider.
+     */
+    createProvider(params: CreateProviderParams): Promise<CreateProviderResult>;
+    /**
+     * Checks if a wallet is connected to the specified provider.
+     * @param {CheckConnectionParams} params - The parameters for checking the wallet connection.
+     * @returns {Promise<CheckConnectionResult>} - A promise that resolves to the result of the check.
+     */
+    checkIsWalletConnected(params: CheckConnectionParams): Promise<CheckConnectionResult>;
+    /**
+     * Connects to a blockchain network using the specified provider.
+     * @param {ConnectParams} params - The parameters for connecting to the network.
+     * @returns {Promise<ConnectResult>} A promise that resolves to an object containing the provider and network information.
+     * @throws {Error} If the provider is not valid or if there is an error connecting to the network.
+     */
+    connect(params: ConnectParams): Promise<ConnectResult>;
+    /**
+     * Switches the network for the current wallet provider.
+     * @param {SwitchNetworkParams} params - The parameters for switching the network.
+     * @returns {Promise<SwitchNetworkResult>} - A promise that resolves to the result of switching the network.
+     */
+    switchNetwork(params: SwitchNetworkParams): Promise<SwitchNetworkResult>;
+    /**
+     * Retrieves the balance of a wallet address.
+     * @param {GetBalanceParams} params - The parameters for retrieving the balance.
+     * @returns {Promise<GetBalanceResult>} - A promise that resolves to the balance result.
+     */
+    getBalance(params: GetBalanceParams): Promise<GetBalanceResult>;
+    /**
+     * Retrieves the balances of all tokens for a given wallet address on a specific chain.
+     * @param {GetAllBalancesParams} params - The parameters for retrieving the balances.
+     * @returns {Promise<GetAllBalancesResult>} - A promise that resolves to the result of retrieving the balances.
+     */
+    getAllBalances(params: GetAllBalancesParams): Promise<GetAllBalancesResult>;
+    /**
+     * Retrieves the supported networks based on the provided parameters.
+     * @param {GetNetworkAllowListParams} params - The parameters for retrieving the network allow list.
+     * @returns {Promise<GetNetworkAllowListResult>} - A promise that resolves to the network allow list result.
+     */
+    getNetworkAllowList(params: GetNetworkAllowListParams): Promise<GetNetworkAllowListResult>;
+    /**
+     * Retrieves the supported tokens based on the provided parameters.
+     * @param {GetTokenAllowListParams} params - The parameters for retrieving the token allow list.
+     * @returns {Promise<GetTokenAllowListResult>} - A promise that resolves to the token allow list result.
+     */
+    getTokenAllowList(params: GetTokenAllowListParams): Promise<GetTokenAllowListResult>;
+    /**
+     * Retrieves the default supported wallets based on the provided parameters.
+     * @param {GetWalletAllowListParams} params - The parameters for retrieving the wallet allow list.
+     * @returns {Promise<GetWalletAllowListResult>} - A promise that resolves to the wallet allow list result.
+     */
+    getWalletAllowList(params: GetWalletAllowListParams): Promise<GetWalletAllowListResult>;
+    /**
+     * Sends a transaction using the specified provider and transaction parameters.
+     * @param {SendTransactionParams} params - The parameters for sending the transaction.
+     * @returns {Promise<SendTransactionResult>} A promise that resolves to the result of the transaction.
+     */
+    sendTransaction(params: SendTransactionParams): Promise<SendTransactionResult>;
+    /**
+     * Retrieves network information using the specified provider.
+     * @param {GetNetworkParams} params - The parameters for retrieving network information.
+     * @returns {Promise<NetworkInfo>} A promise that resolves to the network information.
+     */
+    getNetworkInfo(params: GetNetworkParams): Promise<NetworkInfo>;
+    /**
+     * Checks if the given object is a Web3 provider.
+     * @param {Web3Provider} web3Provider - The object to check.
+     * @returns {boolean} - True if the object is a Web3 provider, false otherwise.
+     */
+    static isWeb3Provider(web3Provider: Web3Provider): boolean;
+    /**
+     * Estimates the gas required for a swap or bridge transaction.
+     * @param {GasEstimateParams} params - The parameters for the gas estimation.
+     * @returns {Promise<GasEstimateSwapResult | GasEstimateBridgeToL2Result>} - A promise that resolves to the gas estimation result.
+     */
+    gasEstimate(params: GasEstimateParams): Promise<GasEstimateSwapResult | GasEstimateBridgeToL2Result>;
+}
+
+export { AllowedNetworkConfig, CHECKOUT_API_BASE_URL, ChainId, ChainName, CheckConnectionParams, CheckConnectionResult, Checkout, CheckoutErrorType, CheckoutModuleConfiguration, ConnectParams, ConnectResult, DexConfig, ErrorType, GasEstimateBridgeToL2Result, GasEstimateParams, GasEstimateSwapResult, GasEstimateTokenConfig, GasEstimateType, GetAllBalancesParams, GetAllBalancesResult, GetBalanceParams, GetBalanceResult, GetNetworkAllowListParams, GetNetworkAllowListResult, GetNetworkParams, GetTokenAllowListParams, GetTokenAllowListResult, GetWalletAllowListParams, GetWalletAllowListResult, NetworkFilter, NetworkFilterTypes, NetworkInfo, RemoteConfiguration, SendTransactionParams, SendTransactionResult, SwitchNetworkParams, SwitchNetworkResult, TokenFilter, TokenFilterTypes, TokenInfo, WalletFilter, WalletFilterTypes, WalletInfo, WalletProviderName };