@imtbl/sdk 0.28.5-alpha.3 → 0.28.6-alpha

package/dist/index.d.ts

@@ -1,3 +1,6 @@
+/// <reference types="node" />
+import { ProviderConfiguration as ProviderConfiguration$1, ExchangeContracts } from 'config';
+
 declare enum Environment {
     PRODUCTION = "production",
     SANDBOX = "sandbox"
@@ -871,7 +874,7 @@ interface BlockchainMetadata {
  * @export
  * @interface Chain
  */
-interface Chain {
+interface Chain$1 {
     /**
      * The id of chain
      * @type {string}
@@ -915,7 +918,7 @@ interface Activity {
      * @type {Chain}
      * @memberof Activity
      */
-    'chain': Chain;
+    'chain': Chain$1;
     /**
      *
      * @type {ActivityType}
@@ -958,7 +961,7 @@ interface Activity {
  * @type ChainWithDetails
  * @export
  */
-type ChainWithDetails = Chain;
+type ChainWithDetails = Chain$1;
 
 /**
  * Immutable zkEVM API
@@ -1004,7 +1007,7 @@ interface Collection$1 {
      * @type {Chain}
      * @memberof Collection
      */
-    'chain': Chain;
+    'chain': Chain$1;
     /**
      * The name of the collection
      * @type {string}
@@ -1271,7 +1274,7 @@ interface Metadata {
      * @type {Chain}
      * @memberof Metadata
      */
-    'chain': Chain;
+    'chain': Chain$1;
     /**
      * The contract address of the metadata
      * @type {string}
@@ -1383,7 +1386,7 @@ interface NFT {
      * @type {Chain}
      * @memberof NFT
      */
-    'chain': Chain;
+    'chain': Chain$1;
     /**
      * An `uint256` token id as string
      * @type {string}
@@ -1558,7 +1561,7 @@ interface Token$1 {
      * @type {Chain}
      * @memberof Token
      */
-    'chain': Chain;
+    'chain': Chain$1;
     /**
      * The address of token contract
      * @type {string}
@@ -1645,7 +1648,7 @@ interface GetTokenResult {
  * @export
  * @interface Page
  */
-interface Page {
+interface Page$2 {
     /**
      * First item as an encoded string
      * @type {string}
@@ -1689,7 +1692,7 @@ interface ListActivitiesResult {
      * @type {Page}
      * @memberof ListActivitiesResult
      */
-    'page': Page;
+    'page': Page$2;
 }
 
 /**
@@ -1721,7 +1724,7 @@ interface ListChainsResult {
      * @type {Page}
      * @memberof ListChainsResult
      */
-    'page': Page;
+    'page': Page$2;
 }
 
 /**
@@ -1747,7 +1750,7 @@ interface NFTWithOwner {
      * @type {Chain}
      * @memberof NFTWithOwner
      */
-    'chain': Chain;
+    'chain': Chain$1;
     /**
      * The address of NFT contract
      * @type {string}
@@ -1809,7 +1812,7 @@ interface ListCollectionOwnersResult {
      * @type {Page}
      * @memberof ListCollectionOwnersResult
      */
-    'page': Page;
+    'page': Page$2;
 }
 
 /**
@@ -1841,7 +1844,7 @@ interface ListCollectionsResult {
      * @type {Page}
      * @memberof ListCollectionsResult
      */
-    'page': Page;
+    'page': Page$2;
 }
 
 /**
@@ -1873,7 +1876,7 @@ interface ListMetadataResult {
      * @type {Page}
      * @memberof ListMetadataResult
      */
-    'page': Page;
+    'page': Page$2;
 }
 
 /**
@@ -1899,7 +1902,7 @@ interface NFTOwner {
      * @type {Chain}
      * @memberof NFTOwner
      */
-    'chain': Chain;
+    'chain': Chain$1;
     /**
      * The address of NFT contract
      * @type {string}
@@ -1961,7 +1964,7 @@ interface ListNFTOwnersResult {
      * @type {Page}
      * @memberof ListNFTOwnersResult
      */
-    'page': Page;
+    'page': Page$2;
 }
 
 /**
@@ -1993,7 +1996,7 @@ interface ListNFTsResult {
      * @type {Page}
      * @memberof ListNFTsResult
      */
-    'page': Page;
+    'page': Page$2;
 }
 
 /**
@@ -2025,7 +2028,7 @@ interface ListTokensResult {
      * @type {Page}
      * @memberof ListTokensResult
      */
-    'page': Page;
+    'page': Page$2;
 }
 
 /**
@@ -2126,7 +2129,7 @@ interface RefreshCollectionMetadataResult {
      * @type {Chain}
      * @memberof RefreshCollectionMetadataResult
      */
-    'chain': Chain;
+    'chain': Chain$1;
     /**
      *
      * @type {CollectionMetadata}
@@ -3959,6 +3962,7 @@ declare type Network = {
     ensAddress?: string;
     _defaultProvider?: (providers: any, options?: any) => any;
 };
+declare type Networkish = Network | string | number;
 
 declare type AccessList = Array<{
     address: string;
@@ -3984,6 +3988,23 @@ interface Transaction {
     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;
 }
@@ -4079,6 +4100,9 @@ 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;
@@ -4120,6 +4144,20 @@ declare abstract class Provider$1 implements OnceBlockable {
     static isProvider(value: any): value is Provider$1;
 }
 
+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$1;
     abstract getAddress(): Promise<string>;
@@ -4143,6 +4181,294 @@ declare abstract class Signer {
     static isSigner(value: any): value is Signer;
 }
 
+interface PopulatedTransaction {
+    to?: string;
+    from?: string;
+    nonce?: number;
+    gasLimit?: BigNumber;
+    gasPrice?: BigNumber;
+    data?: string;
+    value?: BigNumber;
+    chainId?: number;
+    type?: number;
+    accessList?: AccessList;
+    maxFeePerGas?: BigNumber;
+    maxPriorityFeePerGas?: BigNumber;
+    customData?: Record<string, any>;
+    ccipReadEnabled?: boolean;
+}
+
+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$1 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$1 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$1>;
+    _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$1): 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>;
+}
+
 // TypeScript Version: 3.0
 
 type AxiosRequestHeaders = Record<string, string | number | boolean>;
@@ -4944,7 +5270,7 @@ declare type FeeTokenData = FeeData;
  * @export
  * @interface FeeToken
  */
-interface FeeToken {
+interface FeeToken$1 {
     /**
      *
      * @type {FeeTokenData}
@@ -4981,7 +5307,7 @@ declare type FeeTokenTypeEnum = typeof FeeTokenTypeEnum[keyof typeof FeeTokenTyp
  * Details of the fee currency
  * @export
  */
-declare type OrderFeeInfoToken = FeeToken;
+declare type OrderFeeInfoToken = FeeToken$1;
 
 /**
  * Immutable X API
@@ -5192,7 +5518,7 @@ declare type AssetOrders = OrderDetails;
  * @export
  * @interface Fee
  */
-interface Fee {
+interface Fee$3 {
     /**
      * Wallet address
      * @type {string}
@@ -5254,7 +5580,7 @@ interface Asset {
      * @type {Array<Fee>}
      * @memberof Asset
      */
-    'fees'?: Array<Fee>;
+    'fees'?: Array<Fee$3>;
     /**
      * [DEPRECATED] Internal Immutable X Token ID
      * @type {string}
@@ -5402,7 +5728,7 @@ interface AssetWithOrders {
      * @type {Array<Fee>}
      * @memberof AssetWithOrders
      */
-    'fees'?: Array<Fee>;
+    'fees'?: Array<Fee$3>;
     /**
      * [DEPRECATED] Internal Immutable X Token ID
      * @type {string}
@@ -8900,7 +9226,7 @@ interface Mint {
      * @type {Array<Fee>}
      * @memberof Mint
      */
-    'fees'?: Array<Fee>;
+    'fees'?: Array<Fee$3>;
     /**
      * Status of this mint
      * @type {string}
@@ -9430,7 +9756,7 @@ declare type TradeB = TradeSide;
  * @export
  * @interface Trade
  */
-interface Trade {
+interface Trade$2 {
     /**
      *
      * @type {TradeA}
@@ -9498,7 +9824,7 @@ interface ListTradesResponse {
      * @type {Array<Trade>}
      * @memberof ListTradesResponse
      */
-    'result': Array<Trade>;
+    'result': Array<Trade$2>;
 }
 
 /**
@@ -12938,7 +13264,7 @@ declare class TradesApi extends BaseAPI {
      * @throws {RequiredError}
      * @memberof TradesApi
      */
-    getTradeV3(requestParameters: TradesApiGetTradeV3Request, options?: AxiosRequestConfig): Promise<AxiosResponse<Trade, any>>;
+    getTradeV3(requestParameters: TradesApiGetTradeV3Request, options?: AxiosRequestConfig): Promise<AxiosResponse<Trade$2, any>>;
     /**
      * Get a list of trades (V3)
      * @summary Get a list of trades (V3)
@@ -13920,7 +14246,7 @@ declare class ImmutableXClient {
      * @returns a promise that resolves with the requested Trade
      * @throws {@link index.IMXError}
      */
-    getTrade(request: TradesApiGetTradeV3Request): Promise<Trade>;
+    getTrade(request: TradesApiGetTradeV3Request): Promise<Trade$2>;
     /**
      * Get a list of Trades
      * @param request - optional object containing the parameters to be provided in the API request
@@ -14095,12 +14421,6 @@ interface IMXProvider {
      * @return {Promise<RegisterUserResponse>} Returns a promise that resolves with the user registration response
      */
     registerOffchain(): Promise<RegisterUserResponse>;
-    /**
-     *  Checks if a User is registered off-chain
-     *
-     *  @return {Promise<boolean>} Returns a promise that resolves with true if the User is registered with IMX, false otherwise
-     */
-    isRegisteredOffchain(): Promise<boolean>;
     /**
      * Checks if a User is registered on-chain
      *
@@ -14173,23 +14493,11 @@ interface IMXProvider {
     completeWithdrawal(starkPublicKey: string, token: AnyToken): Promise<TransactionResponse>;
 }
 
-interface ProviderOverrides {
-    immutableXConfig: ImmutableXConfiguration;
-}
-interface ProviderModuleConfiguration extends ModuleConfiguration<ProviderOverrides> {
-}
-declare class ProviderConfiguration {
-    readonly immutableXConfig: ImmutableXConfiguration;
-    readonly baseConfig: ImmutableConfiguration;
-    constructor({ baseConfig, overrides }: ProviderModuleConfiguration);
-}
-
 declare class GenericIMXProvider implements IMXProvider {
     private readonly config;
     private readonly signers;
-    constructor(config: ProviderConfiguration, ethSigner: Signer, starkSigner: StarkSigner);
+    constructor(config: ProviderConfiguration$1, ethSigner: Signer, starkSigner: StarkSigner);
     getAddress(): Promise<string>;
-    isRegisteredOffchain(): Promise<boolean>;
     registerOffchain(): Promise<RegisterUserResponse>;
     batchNftTransfer(request: Array<NftTransferDetails>): Promise<CreateTransferResponse>;
     cancelOrder(request: GetSignableCancelOrderRequest): Promise<CancelOrderResponse>;
@@ -14205,11 +14513,22 @@ declare class GenericIMXProvider implements IMXProvider {
 
 declare class MetaMaskIMXProvider extends GenericIMXProvider {
     private static imxSigner;
-    static connect(config: ProviderConfiguration): Promise<MetaMaskIMXProvider>;
+    static connect(config: ProviderConfiguration$1): Promise<MetaMaskIMXProvider>;
     static disconnect(): Promise<void>;
     static signMessage(message: string): Promise<string>;
 }
 
+interface ProviderOverrides {
+    immutableXConfig: ImmutableXConfiguration;
+}
+interface ProviderModuleConfiguration extends ModuleConfiguration<ProviderOverrides> {
+}
+declare class ProviderConfiguration {
+    readonly immutableXConfig: ImmutableXConfiguration;
+    readonly baseConfig: ImmutableConfiguration;
+    constructor({ baseConfig, overrides }: ProviderModuleConfiguration);
+}
+
 type UserProfile = {
     email?: string;
     nickname?: string;
@@ -14217,7 +14536,7 @@ type UserProfile = {
 };
 declare enum Networks {
     PRODUCTION = "mainnet",
-    SANDBOX = "sepolia"
+    SANDBOX = "goerli"
 }
 interface OidcConfiguration {
     clientId: string;
@@ -14334,7 +14653,7 @@ type Provider = {
     removeListener: (event: string, listener: (...args: any[]) => void) => void;
     isPassport: boolean;
 };
-declare enum ProviderEvent {
+declare enum ProviderEvent$1 {
     ACCOUNTS_CHANGED = "accountsChanged"
 }
 type AccountsChangedEvent = Array<string>;
@@ -14410,8 +14729,6 @@ type passport_d_PassportOverrides = PassportOverrides;
 type passport_d_Provider = Provider;
 type passport_d_ProviderErrorCode = ProviderErrorCode;
 declare const passport_d_ProviderErrorCode: typeof ProviderErrorCode;
-type passport_d_ProviderEvent = ProviderEvent;
-declare const passport_d_ProviderEvent: typeof ProviderEvent;
 type passport_d_RequestArguments = RequestArguments;
 type passport_d_RpcErrorCode = RpcErrorCode;
 declare const passport_d_RpcErrorCode: typeof RpcErrorCode;
@@ -14433,7 +14750,7 @@ declare namespace passport_d {
     passport_d_PassportOverrides as PassportOverrides,
     passport_d_Provider as Provider,
     passport_d_ProviderErrorCode as ProviderErrorCode,
-    passport_d_ProviderEvent as ProviderEvent,
+    ProviderEvent$1 as ProviderEvent,
     passport_d_RequestArguments as RequestArguments,
     passport_d_RpcErrorCode as RpcErrorCode,
     passport_d_TypedDataPayload as TypedDataPayload,
@@ -14441,20 +14758,3538 @@ declare namespace passport_d {
   };
 }
 
-type provider_d_GenericIMXProvider = GenericIMXProvider;
-declare const provider_d_GenericIMXProvider: typeof GenericIMXProvider;
-type provider_d_IMXProvider = IMXProvider;
-type provider_d_MetaMaskIMXProvider = MetaMaskIMXProvider;
-declare const provider_d_MetaMaskIMXProvider: typeof MetaMaskIMXProvider;
-type provider_d_ProviderConfiguration = ProviderConfiguration;
-declare const provider_d_ProviderConfiguration: typeof ProviderConfiguration;
-declare namespace provider_d {
-  export {
-    provider_d_GenericIMXProvider as GenericIMXProvider,
-    provider_d_IMXProvider as IMXProvider,
-    provider_d_MetaMaskIMXProvider as MetaMaskIMXProvider,
-    provider_d_ProviderConfiguration as ProviderConfiguration,
+interface OrderbookOverrides {
+    provider?: JsonRpcProvider | Web3Provider;
+    seaportContractAddress?: string;
+    zoneContractAddress?: string;
+    chainName?: string;
+    apiEndpoint?: string;
+}
+interface OrderbookModuleConfiguration {
+    seaportContractAddress: string;
+    zoneContractAddress: string;
+    apiEndpoint: string;
+    chainName: string;
+    provider: JsonRpcProvider | Web3Provider;
+}
+
+type ApiRequestOptions = {
+    readonly method: 'GET' | 'PUT' | 'POST' | 'DELETE' | 'OPTIONS' | 'HEAD' | 'PATCH';
+    readonly url: string;
+    readonly path?: Record<string, any>;
+    readonly cookies?: Record<string, any>;
+    readonly headers?: Record<string, any>;
+    readonly query?: Record<string, any>;
+    readonly formData?: Record<string, any>;
+    readonly body?: any;
+    readonly mediaType?: string;
+    readonly responseHeader?: string;
+    readonly errors?: Record<number, string>;
+};
+
+interface OnCancel {
+    readonly isResolved: boolean;
+    readonly isRejected: boolean;
+    readonly isCancelled: boolean;
+    (cancelHandler: () => void): void;
+}
+declare class CancelablePromise<T> implements Promise<T> {
+    readonly [Symbol.toStringTag]: string;
+    private _isResolved;
+    private _isRejected;
+    private _isCancelled;
+    private readonly _cancelHandlers;
+    private readonly _promise;
+    private _resolve?;
+    private _reject?;
+    constructor(executor: (resolve: (value: T | PromiseLike<T>) => void, reject: (reason?: any) => void, onCancel: OnCancel) => void);
+    then<TResult1 = T, TResult2 = never>(onFulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | null, onRejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null): Promise<TResult1 | TResult2>;
+    catch<TResult = never>(onRejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null): Promise<T | TResult>;
+    finally(onFinally?: (() => void) | null): Promise<T>;
+    cancel(): void;
+    get isCancelled(): boolean;
+}
+
+type Resolver<T> = (options: ApiRequestOptions) => Promise<T>;
+type Headers = Record<string, string>;
+type OpenAPIConfig = {
+    BASE: string;
+    VERSION: string;
+    WITH_CREDENTIALS: boolean;
+    CREDENTIALS: 'include' | 'omit' | 'same-origin';
+    TOKEN?: string | Resolver<string>;
+    USERNAME?: string | Resolver<string>;
+    PASSWORD?: string | Resolver<string>;
+    HEADERS?: Headers | Resolver<Headers>;
+    ENCODE_PATH?: (path: string) => string;
+};
+
+declare abstract class BaseHttpRequest {
+    readonly config: OpenAPIConfig;
+    constructor(config: OpenAPIConfig);
+    abstract request<T>(options: ApiRequestOptions): CancelablePromise<T>;
+}
+
+type CancelOrdersRequestBody = {
+    /**
+     * Address of the user initiating the cancel request
+     */
+    account_address: string;
+    /**
+     * List of order ids proposed for cancellation
+     */
+    orders: Array<string>;
+    /**
+     * Signature generated by the user for the specific cancellation request
+     */
+    signature: string;
+};
+
+type FailedOrderCancellation = {
+    /**
+     * ID of the order which failed to be cancelled
+     */
+    order: string;
+    /**
+     * Reason code indicating why the order failed to be cancelled
+     */
+    reason_code: FailedOrderCancellation.reason_code;
+};
+declare namespace FailedOrderCancellation {
+    /**
+     * Reason code indicating why the order failed to be cancelled
+     */
+    enum reason_code {
+        FILLED = "FILLED"
+    }
+}
+
+type CancelOrdersResultData = {
+    /**
+     * Orders which were successfully cancelled
+     */
+    successful_cancellations: Array<string>;
+    /**
+     * Orders which are marked for cancellation but the cancellation cannot be guaranteed
+     */
+    pending_cancellations: Array<string>;
+    /**
+     * Orders which failed to be cancelled
+     */
+    failed_cancellations: Array<FailedOrderCancellation>;
+};
+
+type CancelOrdersResult = {
+    result: CancelOrdersResultData;
+};
+
+/**
+ * The name of chain
+ */
+type ChainName$1 = string;
+
+type Fee$2 = {
+    /**
+     * Fee payable to recipient upon settlement
+     */
+    amount: string;
+    /**
+     * Fee type
+     */
+    fee_type: Fee$2.fee_type;
+    /**
+     * Wallet address of fee recipient
+     */
+    recipient: string;
+};
+declare namespace Fee$2 {
+    /**
+     * Fee type
+     */
+    enum fee_type {
+        ROYALTY = "ROYALTY",
+        MAKER_ECOSYSTEM = "MAKER_ECOSYSTEM",
+        TAKER_ECOSYSTEM = "TAKER_ECOSYSTEM",
+        PROTOCOL = "PROTOCOL"
+    }
+}
+
+type ERC20Item$1 = {
+    /**
+     * Token type user is offering, which in this case is ERC20
+     */
+    item_type: 'ERC20';
+    /**
+     * Address of ERC20 token
+     */
+    contract_address: string;
+    /**
+     * A string representing the starting price at which the user is willing to sell the token. This value is provided in the smallest unit of the token (e.g., wei for Ethereum).
+     */
+    start_amount: string;
+};
+
+type ERC721Item$1 = {
+    /**
+     * Token type user is offering, which in this case is ERC721
+     */
+    item_type: 'ERC721';
+    /**
+     * Address of ERC721 token
+     */
+    contract_address: string;
+    /**
+     * ID of ERC721 token
+     */
+    token_id: string;
+};
+
+type NativeItem$1 = {
+    /**
+     * Token type user is offering, which in this case is the native IMX token
+     */
+    item_type: 'NATIVE';
+    /**
+     * A string representing the starting price at which the user is willing to sell the token. This value is provided in the smallest unit of the token (e.g., wei for Ethereum).
+     */
+    start_amount: string;
+};
+
+type Item = (NativeItem$1 | ERC20Item$1 | ERC721Item$1);
+
+type ProtocolData = {
+    /**
+     * The Order type
+     */
+    order_type: ProtocolData.order_type;
+    /**
+     * Immutable zone address
+     */
+    zone_address: string;
+    /**
+     * big.Int or uint256 string for order counter
+     */
+    counter: string;
+    /**
+     * Immutable Seaport contract address
+     */
+    seaport_address: string;
+    /**
+     * Immutable Seaport contract version
+     */
+    seaport_version: string;
+};
+declare namespace ProtocolData {
+    /**
+     * The Order type
+     */
+    enum order_type {
+        FULL_RESTRICTED = "FULL_RESTRICTED"
+    }
+}
+
+type CreateListingRequestBody = {
+    account_address: string;
+    order_hash: string;
+    /**
+     * Buy item for listing should either be NATIVE or ERC20 item
+     */
+    buy: Array<Item>;
+    /**
+     * Buy fees should only include maker marketplace fees and should be no more than two entries as more entires will incur more gas. It is best practice to have this as few as possible.
+     */
+    fees: Array<Fee$2>;
+    /**
+     * Time after which the Order is considered expired
+     */
+    end_at: string;
+    protocol_data: ProtocolData;
+    /**
+     * A random value added to the create Order request
+     */
+    salt: string;
+    /**
+     * Sell item for listing should be an ERC721 item
+     */
+    sell: Array<Item>;
+    /**
+     * Digital signature generated by the user for the specific Order
+     */
+    signature: string;
+    /**
+     * Time after which Order is considered active
+     */
+    start_at: string;
+};
+
+/**
+ * The chain details
+ */
+type Chain = {
+    /**
+     * The id of chain
+     */
+    id: string;
+    /**
+     * The name of chain
+     */
+    name: string;
+};
+
+type ActiveOrderStatus = {
+    /**
+     * The order status that indicates an order can be fulfilled.
+     */
+    name: 'ACTIVE';
+};
+
+type CancelledOrderStatus = {
+    /**
+     * The order status indicating a order is has been cancelled or about to be cancelled.
+     */
+    name: 'CANCELLED';
+    /**
+     * Whether the cancellation of the order is pending
+     */
+    pending: boolean;
+    /**
+     * Whether the cancellation was done on-chain or off-chain
+     */
+    cancellation_type: CancelledOrderStatus.cancellation_type;
+};
+declare namespace CancelledOrderStatus {
+    /**
+     * Whether the cancellation was done on-chain or off-chain
+     */
+    enum cancellation_type {
+        ON_CHAIN = "ON_CHAIN",
+        OFF_CHAIN = "OFF_CHAIN"
+    }
+}
+
+type ExpiredOrderStatus = {
+    /**
+     * A terminal order status indicating that an order cannot be fulfilled due to expiry.
+     */
+    name: 'EXPIRED';
+};
+
+type FilledOrderStatus = {
+    /**
+     * A terminal order status indicating that an order has been fulfilled.
+     */
+    name: 'FILLED';
+};
+
+type InactiveOrderStatus = {
+    /**
+     * The order status that indicates an order cannot be fulfilled.
+     */
+    name: 'INACTIVE';
+    /**
+     * Whether the order offerer has sufficient approvals
+     */
+    sufficient_approvals: boolean;
+    /**
+     * Whether the order offerer still has sufficient balance to complete the order
+     */
+    sufficient_balances: boolean;
+};
+
+type PendingOrderStatus = {
+    /**
+     * The order status that indicates the order is yet to be active due to various reasons.
+     */
+    name: 'PENDING';
+    /**
+     * Whether the order has been evaluated after its creation
+     */
+    evaluated: boolean;
+    /**
+     * Whether the order has reached its specified start time
+     */
+    started: boolean;
+};
+
+/**
+ * The Order status
+ */
+type OrderStatus = (CancelledOrderStatus | PendingOrderStatus | ActiveOrderStatus | InactiveOrderStatus | FilledOrderStatus | ExpiredOrderStatus);
+
+type Order$1 = {
+    account_address: string;
+    buy: Array<Item>;
+    fees: Array<Fee$2>;
+    chain: Chain;
+    /**
+     * Time the Order is created
+     */
+    created_at: string;
+    /**
+     * Time after which the Order is considered expired
+     */
+    end_at: string;
+    /**
+     * Global Order identifier
+     */
+    id: string;
+    protocol_data: ProtocolData;
+    /**
+     * A random value added to the create Order request
+     */
+    salt: string;
+    sell: Array<Item>;
+    /**
+     * Digital signature generated by the user for the specific Order
+     */
+    signature: string;
+    /**
+     * Time after which Order is considered active
+     */
+    start_at: string;
+    status: OrderStatus;
+    /**
+     * Time the Order is last updated
+     */
+    updated_at: string;
+};
+
+type FulfillableOrder = {
+    extra_data: string;
+    order: Order$1;
+};
+
+type FulfillmentDataRequest = {
+    order_id: string;
+    fees: Array<Fee$2>;
+};
+
+type ListingResult$1 = {
+    result: Order$1;
+};
+
+/**
+ * Pagination properties
+ */
+type Page$1 = {
+    /**
+     * First item as an encoded string
+     */
+    previous_cursor: string | null;
+    /**
+     * Last item as an encoded string
+     */
+    next_cursor: string | null;
+};
+
+type ListListingsResult$1 = {
+    page: Page$1;
+    result: Array<Order$1>;
+};
+
+/**
+ * The metadata related to the transaction in which the activity occurred
+ */
+type TradeBlockchainMetadata = {
+    /**
+     * The transaction hash of the trade
+     */
+    transaction_hash: string;
+    /**
+     * EVM block number (uint64 as string)
+     */
+    block_number: string;
+    /**
+     * Transaction index in a block (uint32 as string)
+     */
+    transaction_index: string;
+    /**
+     * The log index of the fulfillment event in a block (uint32 as string)
+     */
+    log_index: string;
+};
+
+type Trade$1 = {
+    buy: Array<Item>;
+    buyer_address: string;
+    buyer_fees: Array<Fee$2>;
+    chain: Chain;
+    order_id: string;
+    blockchain_metadata: TradeBlockchainMetadata;
+    /**
+     * Time the on-chain trade event is indexed by the order book system
+     */
+    indexed_at: string;
+    /**
+     * Global Trade identifier
+     */
+    id: string;
+    sell: Array<Item>;
+    seller_address: string;
+    maker_address: string;
+    taker_address: string;
+};
+
+type ListTradeResult = {
+    page: Page$1;
+    result: Array<Trade$1>;
+};
+
+/**
+ * The Order status
+ */
+declare enum OrderStatusName {
+    PENDING = "PENDING",
+    ACTIVE = "ACTIVE",
+    INACTIVE = "INACTIVE",
+    FILLED = "FILLED",
+    EXPIRED = "EXPIRED",
+    CANCELLED = "CANCELLED"
+}
+
+/**
+ * Encoded page cursor to retrieve previous or next page. Use the value returned in the response.
+ */
+type PageCursor = string;
+
+/**
+ * Maximum number of items to return
+ */
+type PageSize = number;
+
+type TradeResult$1 = {
+    result: Trade$1;
+};
+
+type UnfulfillableOrder$1 = {
+    /**
+     * OrderID for the requested but unfulfillable order
+     */
+    order_id: string;
+    /**
+     * Nullable string containing error reason if the signing is unsuccessful for the order
+     */
+    reason: string;
+};
+
+declare class OrdersService {
+    readonly httpRequest: BaseHttpRequest;
+    constructor(httpRequest: BaseHttpRequest);
+    /**
+     * Cancel one or more orders
+     * Cancel one or more orders
+     * @returns CancelOrdersResult Orders cancellation response.
+     * @throws ApiError
+     */
+    cancelOrders({ chainName, requestBody, }: {
+        chainName: ChainName$1;
+        requestBody: CancelOrdersRequestBody;
+    }): CancelablePromise<CancelOrdersResult>;
+    /**
+     * List all listings
+     * List all listings
+     * @returns ListListingsResult OK response.
+     * @throws ApiError
+     */
+    listListings({ chainName, status, sellItemContractAddress, buyItemContractAddress, sellItemTokenId, fromUpdatedAt, pageSize, sortBy, sortDirection, pageCursor, }: {
+        chainName: ChainName$1;
+        /**
+         * Order status to filter by
+         */
+        status?: OrderStatusName;
+        /**
+         * Sell item contract address to filter by
+         */
+        sellItemContractAddress?: string;
+        /**
+         * Buy item contract address to filter by
+         */
+        buyItemContractAddress?: string;
+        /**
+         * Sell item token identifier to filter by
+         */
+        sellItemTokenId?: string;
+        /**
+         * From updated at including given date
+         */
+        fromUpdatedAt?: string;
+        /**
+         * Maximum number of orders to return per page
+         */
+        pageSize?: PageSize;
+        /**
+         * Order field to sort by
+         */
+        sortBy?: 'created_at' | 'updated_at' | 'buy_item_amount';
+        /**
+         * Ascending or descending direction for sort
+         */
+        sortDirection?: 'asc' | 'desc';
+        /**
+         * Page cursor to retrieve previous or next page. Use the value returned in the response.
+         */
+        pageCursor?: PageCursor;
+    }): CancelablePromise<ListListingsResult$1>;
+    /**
+     * Create a listing
+     * Create a listing
+     * @returns ListingResult Created response.
+     * @throws ApiError
+     */
+    createListing({ chainName, requestBody, }: {
+        chainName: ChainName$1;
+        requestBody: CreateListingRequestBody;
+    }): CancelablePromise<ListingResult$1>;
+    /**
+     * Get a single listing by ID
+     * Get a single listing by ID
+     * @returns ListingResult OK response.
+     * @throws ApiError
+     */
+    getListing({ chainName, listingId, }: {
+        chainName: ChainName$1;
+        /**
+         * Global Order identifier
+         */
+        listingId: string;
+    }): CancelablePromise<ListingResult$1>;
+    /**
+     * Retrieve fulfillment data for orders
+     * Retrieve signed fulfillment data based on the list of order IDs and corresponding fees.
+     * @returns any Successful response
+     * @throws ApiError
+     */
+    fulfillmentData({ chainName, requestBody, }: {
+        chainName: ChainName$1;
+        requestBody: Array<FulfillmentDataRequest>;
+    }): CancelablePromise<{
+        result: {
+            fulfillable_orders: Array<FulfillableOrder>;
+            unfulfillable_orders: Array<UnfulfillableOrder$1>;
+        };
+    }>;
+    /**
+     * List all trades
+     * List all trades
+     * @returns ListTradeResult OK response.
+     * @throws ApiError
+     */
+    listTrades({ chainName, accountAddress, fromIndexedAt, pageSize, sortBy, sortDirection, pageCursor, }: {
+        chainName: ChainName$1;
+        accountAddress?: string;
+        /**
+         * From indexed at including given date
+         */
+        fromIndexedAt?: string;
+        /**
+         * Maximum number of trades to return per page
+         */
+        pageSize?: PageSize;
+        /**
+         * Trade field to sort by
+         */
+        sortBy?: 'indexed_at';
+        /**
+         * Ascending or descending direction for sort
+         */
+        sortDirection?: 'asc' | 'desc';
+        /**
+         * Page cursor to retrieve previous or next page. Use the value returned in the response.
+         */
+        pageCursor?: PageCursor;
+    }): CancelablePromise<ListTradeResult>;
+    /**
+     * Get a single trade by ID
+     * Get a single trade by ID
+     * @returns TradeResult OK response.
+     * @throws ApiError
+     */
+    getTrade({ chainName, tradeId, }: {
+        chainName: ChainName$1;
+        /**
+         * Global Trade identifier
+         */
+        tradeId: string;
+    }): CancelablePromise<TradeResult$1>;
+}
+
+declare enum OrderType {
+    FULL_OPEN = 0,
+    PARTIAL_OPEN = 1,
+    FULL_RESTRICTED = 2,
+    PARTIAL_RESTRICTED = 3
+}
+declare enum ItemType$1 {
+    NATIVE = 0,
+    ERC20 = 1,
+    ERC721 = 2,
+    ERC1155 = 3,
+    ERC721_WITH_CRITERIA = 4,
+    ERC1155_WITH_CRITERIA = 5
+}
+
+type OfferItem = {
+    itemType: ItemType$1;
+    token: string;
+    identifierOrCriteria: string;
+    startAmount: string;
+    endAmount: string;
+};
+type ConsiderationItem = {
+    itemType: ItemType$1;
+    token: string;
+    identifierOrCriteria: string;
+    startAmount: string;
+    endAmount: string;
+    recipient: string;
+};
+type OrderParameters = {
+    offerer: string;
+    zone: string;
+    orderType: OrderType;
+    startTime: BigNumberish;
+    endTime: BigNumberish;
+    zoneHash: string;
+    salt: string;
+    offer: OfferItem[];
+    consideration: ConsiderationItem[];
+    totalOriginalConsiderationItems: BigNumberish;
+    conduitKey: string;
+};
+type OrderComponents = OrderParameters & {
+    counter: BigNumberish;
+};
+
+interface ERC721Item {
+    type: 'ERC721';
+    contractAddress: string;
+    tokenId: string;
+}
+interface ERC20Item {
+    type: 'ERC20';
+    contractAddress: string;
+    amount: string;
+}
+interface NativeItem {
+    type: 'NATIVE';
+    amount: string;
+}
+interface RoyaltyInfo {
+    recipient: string;
+    amountRequired: string;
+}
+interface PrepareListingParams {
+    makerAddress: string;
+    sell: ERC721Item;
+    buy: ERC20Item | NativeItem;
+    orderExpiry?: Date;
+}
+interface PrepareListingResponse {
+    actions: Action[];
+    orderComponents: OrderComponents;
+    orderHash: string;
+}
+interface PrepareCancelOrdersResponse {
+    signableAction: SignableAction;
+}
+interface CreateListingParams {
+    orderComponents: OrderComponents;
+    orderHash: string;
+    orderSignature: string;
+    makerFees: FeeValue[];
+}
+type ListListingsParams = Omit<Parameters<typeof OrdersService.prototype.listListings>[0], 'chainName'>;
+type ListTradesParams = Omit<Parameters<typeof OrdersService.prototype.listTrades>[0], 'chainName'>;
+declare enum FeeType {
+    MAKER_ECOSYSTEM = "MAKER_ECOSYSTEM",
+    TAKER_ECOSYSTEM = "TAKER_ECOSYSTEM",
+    PROTOCOL = "PROTOCOL",
+    ROYALTY = "ROYALTY"
+}
+interface FeeValue {
+    recipient: string;
+    amount: string;
+}
+interface Fee$1 extends FeeValue {
+    type: FeeType;
+}
+declare enum TransactionPurpose {
+    APPROVAL = "APPROVAL",
+    FULFILL_ORDER = "FULFILL_ORDER",
+    CANCEL = "CANCEL"
+}
+declare enum SignablePurpose {
+    CREATE_LISTING = "CREATE_LISTING",
+    OFF_CHAIN_CANCELLATION = "OFF_CHAIN_CANCELLATION"
+}
+declare enum ActionType {
+    TRANSACTION = "TRANSACTION",
+    SIGNABLE = "SIGNABLE"
+}
+type TransactionBuilder = () => Promise<PopulatedTransaction>;
+interface TransactionAction {
+    type: ActionType.TRANSACTION;
+    purpose: TransactionPurpose;
+    buildTransaction: TransactionBuilder;
+}
+interface SignableAction {
+    type: ActionType.SIGNABLE;
+    purpose: SignablePurpose;
+    message: {
+        domain: TypedDataDomain;
+        types: Record<string, TypedDataField[]>;
+        value: Record<string, any>;
+    };
+}
+type Action = TransactionAction | SignableAction;
+interface FulfillmentListing {
+    listingId: string;
+    takerFees: Array<FeeValue>;
+}
+type FulfillBulkOrdersResponse = FulfillBulkOrdersInsufficientBalanceResponse | FulfillBulkOrdersSufficientBalanceResponse;
+interface FulfillBulkOrdersSufficientBalanceResponse {
+    sufficientBalance: true;
+    actions: Action[];
+    expiration: string;
+    fulfillableOrders: Order[];
+    unfulfillableOrders: UnfulfillableOrder[];
+}
+interface FulfillBulkOrdersInsufficientBalanceResponse {
+    sufficientBalance: false;
+    fulfillableOrders: Order[];
+    unfulfillableOrders: UnfulfillableOrder[];
+}
+interface UnfulfillableOrder {
+    orderId: string;
+    reason: string;
+}
+interface FulfillOrderResponse {
+    actions: Action[];
+    /**
+     * User MUST submit the fulfillment transaction before the expiration
+     * Submitting after the expiration will result in a on chain revert
+     */
+    expiration: string;
+    order: Order;
+}
+interface CancelOrdersOnChainResponse {
+    cancellationAction: TransactionAction;
+}
+interface Order {
+    id: string;
+    accountAddress: string;
+    buy: (ERC20Item | NativeItem)[];
+    sell: ERC721Item[];
+    fees: Fee$1[];
+    chain: {
+        id: string;
+        name: string;
+    };
+    createdAt: string;
+    updatedAt: string;
+    /**
+     * Time after which the Order is considered active
+     */
+    startAt: string;
+    /**
+     * Time after which the Order is expired
+     */
+    endAt: string;
+    protocolData: {
+        orderType: 'FULL_RESTRICTED';
+        zoneAddress: string;
+        counter: string;
+        seaportAddress: string;
+        seaportVersion: string;
+    };
+    salt: string;
+    signature: string;
+    status: OrderStatus;
+}
+interface ListingResult {
+    result: Order;
+}
+interface ListListingsResult {
+    page: Page;
+    result: Order[];
+}
+interface Page {
+    /**
+     * First item as an encoded string
+     */
+    previousCursor: string | null;
+    /**
+     * Last item as an encoded string
+     */
+    nextCursor: string | null;
+}
+interface Trade {
+    id: string;
+    orderId: string;
+    chain: {
+        id: string;
+        name: string;
+    };
+    buy: (ERC20Item | NativeItem)[];
+    sell: ERC721Item[];
+    buyerFees: Fee$1[];
+    sellerAddress: string;
+    buyerAddress: string;
+    makerAddress: string;
+    takerAddress: string;
+    /**
+     * Time the on-chain event was indexed by the Immutable order book service
+     */
+    indexedAt: string;
+    blockchainMetadata: {
+        /**
+         * The transaction hash of the trade
+         */
+        transactionHash: string;
+        /**
+         * EVM block number (uint64 as string)
+         */
+        blockNumber: string;
+        /**
+         * Transaction index in a block (uint32 as string)
+         */
+        transactionIndex: string;
+        /**
+         * The log index of the fulfillment event in a block (uint32 as string)
+         */
+        logIndex: string;
+    };
+}
+interface TradeResult {
+    result: Trade;
+}
+interface ListTradesResult {
+    page: Page;
+    result: Trade[];
+}
+
+/**
+ * zkEVM orderbook SDK
+ * @constructor
+ * @param {OrderbookModuleConfiguration} config - Configuration for Immutable services.
+ */
+declare class Orderbook {
+    private apiClient;
+    private seaport;
+    private orderbookConfig;
+    constructor(config: ModuleConfiguration<OrderbookOverrides>);
+    /**
+     * Return the configuration for the orderbook module.
+     * @return {OrderbookModuleConfiguration} The configuration for the orderbook module.
+     */
+    config(): OrderbookModuleConfiguration;
+    /**
+     * Get an order by ID
+     * @param {string} listingId - The listingId to find.
+     * @return {ListingResult} The returned order result.
+     */
+    getListing(listingId: string): Promise<ListingResult>;
+    /**
+     * Get a trade by ID
+     * @param {string} tradeId - The tradeId to find.
+     * @return {TradeResult} The returned order result.
+     */
+    getTrade(tradeId: string): Promise<TradeResult>;
+    /**
+     * List orders. This method is used to get a list of orders filtered by conditions specified
+     * in the params object.
+     * @param {ListListingsParams} listOrderParams - Filtering, ordering and page parameters.
+     * @return {ListListingsResult} The paged orders.
+     */
+    listListings(listOrderParams: ListListingsParams): Promise<ListListingsResult>;
+    /**
+     * List trades. This method is used to get a list of trades filtered by conditions specified
+     * in the params object
+     * @param {ListTradesParams} listTradesParams - Filtering, ordering and page parameters.
+     * @return {ListTradesResult} The paged trades.
+     */
+    listTrades(listTradesParams: ListTradesParams): Promise<ListTradesResult>;
+    /**
+     * Get required transactions and messages for signing prior to creating a listing
+     * through the createListing method
+     * @param {PrepareListingParams} prepareListingParams - Details about the listing to be created.
+     * @return {PrepareListingResponse} PrepareListingResponse includes
+     * the unsigned approval transaction, the typed order message for signing and
+     * the order components that can be submitted to `createListing` with a signature.
+     */
+    prepareListing({ makerAddress, sell, buy, orderExpiry, }: PrepareListingParams): Promise<PrepareListingResponse>;
+    /**
+     * Create an order
+     * @param {CreateListingParams} createListingParams - create an order with the given params.
+     * @return {ListingResult} The result of the order created in the Immutable services.
+     */
+    createListing(createListingParams: CreateListingParams): Promise<ListingResult>;
+    /**
+     * Get unsigned transactions that can be submitted to fulfil an open order. If the approval
+     * transaction exists it must be signed and submitted to the chain before the fulfilment
+     * transaction can be submitted or it will be reverted.
+     * @param {string} listingId - The listingId to fulfil.
+     * @param {string} fulfillerAddress - The address of the account fulfilling the order.
+     * @return {FulfillOrderResponse} Approval and fulfilment transactions.
+     */
+    fulfillOrder(listingId: string, takerAddress: string, takerFees: FeeValue[]): Promise<FulfillOrderResponse>;
+    fulfillBulkOrders(listings: Array<FulfillmentListing>, takerAddress: string): Promise<FulfillBulkOrdersResponse>;
+    /**
+     * Cancelling orders is a gasless alternative to on-chain cancellation exposed with
+     * `cancelOrdersOnChain`. For the orderbook to authenticate the cancellation, the creator
+     * of the orders must sign an EIP712 message containing the orderIds
+     * @param {string} orderIds - The orderIds to attempt to cancel.
+     * @return {PrepareCancelOrdersResponse} The signable action to cancel the orders.
+     */
+    prepareOrderCancellations(orderIds: string[]): Promise<PrepareCancelOrdersResponse>;
+    /**
+     * Cancelling orders is a gasless alternative to on-chain cancellation exposed with
+     * `cancelOrdersOnChain`. Orders cancelled this way cannot be fulfilled and will be removed
+     * from the orderbook. If there is pending fulfillment data outstanding for the order, its
+     * cancellation will be pending until the fulfillment window has passed.
+     * `prepareOffchainOrderCancellations` can be used to get the signable action that is signed
+     * to get the signature required for this call.
+     * @param {string[]} orderIds - The orderIds to attempt to cancel.
+     * @param {string} accountAddress - The address of the account cancelling the orders.
+     * @param {string} accountAddress - The address of the account cancelling the orders.
+     * @return {CancelOrdersResult} The result of the off-chain cancellation request
+     */
+    cancelOrders(orderIds: string[], accountAddress: string, signature: string): Promise<CancelOrdersResult>;
+    /**
+     * Get an unsigned order cancellation transaction. Orders can only be cancelled by
+     * the account that created them. All of the orders must be from the same seaport contract.
+     * If trying to cancel orders from multiple seaport contracts, group the orderIds by seaport
+     * contract and call this method for each group.
+     * @param {string[]} orderIds - The orderIds to cancel.
+     * @param {string} accountAddress - The address of the account cancelling the order.
+     * @return {CancelOrdersOnChainResponse} The unsigned cancel order action
+     */
+    cancelOrdersOnChain(orderIds: string[], accountAddress: string): Promise<CancelOrdersOnChainResponse>;
+}
+
+declare const constants: {
+    estimatedFulfillmentGasGwei: number;
+};
+
+type orderbook_d_Action = Action;
+type orderbook_d_ActionType = ActionType;
+declare const orderbook_d_ActionType: typeof ActionType;
+type orderbook_d_CancelOrdersOnChainResponse = CancelOrdersOnChainResponse;
+type orderbook_d_CreateListingParams = CreateListingParams;
+type orderbook_d_ERC20Item = ERC20Item;
+type orderbook_d_ERC721Item = ERC721Item;
+type orderbook_d_FeeType = FeeType;
+declare const orderbook_d_FeeType: typeof FeeType;
+type orderbook_d_FeeValue = FeeValue;
+type orderbook_d_FulfillBulkOrdersInsufficientBalanceResponse = FulfillBulkOrdersInsufficientBalanceResponse;
+type orderbook_d_FulfillBulkOrdersResponse = FulfillBulkOrdersResponse;
+type orderbook_d_FulfillBulkOrdersSufficientBalanceResponse = FulfillBulkOrdersSufficientBalanceResponse;
+type orderbook_d_FulfillOrderResponse = FulfillOrderResponse;
+type orderbook_d_FulfillmentListing = FulfillmentListing;
+type orderbook_d_ListListingsParams = ListListingsParams;
+type orderbook_d_ListListingsResult = ListListingsResult;
+type orderbook_d_ListTradesParams = ListTradesParams;
+type orderbook_d_ListTradesResult = ListTradesResult;
+type orderbook_d_ListingResult = ListingResult;
+type orderbook_d_NativeItem = NativeItem;
+type orderbook_d_Order = Order;
+type orderbook_d_OrderStatusName = OrderStatusName;
+declare const orderbook_d_OrderStatusName: typeof OrderStatusName;
+type orderbook_d_Orderbook = Orderbook;
+declare const orderbook_d_Orderbook: typeof Orderbook;
+type orderbook_d_Page = Page;
+type orderbook_d_PrepareCancelOrdersResponse = PrepareCancelOrdersResponse;
+type orderbook_d_PrepareListingParams = PrepareListingParams;
+type orderbook_d_PrepareListingResponse = PrepareListingResponse;
+type orderbook_d_RoyaltyInfo = RoyaltyInfo;
+type orderbook_d_SignableAction = SignableAction;
+type orderbook_d_SignablePurpose = SignablePurpose;
+declare const orderbook_d_SignablePurpose: typeof SignablePurpose;
+type orderbook_d_Trade = Trade;
+type orderbook_d_TradeResult = TradeResult;
+type orderbook_d_TransactionAction = TransactionAction;
+type orderbook_d_TransactionBuilder = TransactionBuilder;
+type orderbook_d_TransactionPurpose = TransactionPurpose;
+declare const orderbook_d_TransactionPurpose: typeof TransactionPurpose;
+type orderbook_d_UnfulfillableOrder = UnfulfillableOrder;
+declare const orderbook_d_constants: typeof constants;
+declare namespace orderbook_d {
+  export {
+    orderbook_d_Action as Action,
+    orderbook_d_ActionType as ActionType,
+    orderbook_d_CancelOrdersOnChainResponse as CancelOrdersOnChainResponse,
+    orderbook_d_CreateListingParams as CreateListingParams,
+    orderbook_d_ERC20Item as ERC20Item,
+    orderbook_d_ERC721Item as ERC721Item,
+    Fee$1 as Fee,
+    orderbook_d_FeeType as FeeType,
+    orderbook_d_FeeValue as FeeValue,
+    orderbook_d_FulfillBulkOrdersInsufficientBalanceResponse as FulfillBulkOrdersInsufficientBalanceResponse,
+    orderbook_d_FulfillBulkOrdersResponse as FulfillBulkOrdersResponse,
+    orderbook_d_FulfillBulkOrdersSufficientBalanceResponse as FulfillBulkOrdersSufficientBalanceResponse,
+    orderbook_d_FulfillOrderResponse as FulfillOrderResponse,
+    orderbook_d_FulfillmentListing as FulfillmentListing,
+    orderbook_d_ListListingsParams as ListListingsParams,
+    orderbook_d_ListListingsResult as ListListingsResult,
+    orderbook_d_ListTradesParams as ListTradesParams,
+    orderbook_d_ListTradesResult as ListTradesResult,
+    orderbook_d_ListingResult as ListingResult,
+    orderbook_d_NativeItem as NativeItem,
+    orderbook_d_Order as Order,
+    orderbook_d_OrderStatusName as OrderStatusName,
+    orderbook_d_Orderbook as Orderbook,
+    orderbook_d_Page as Page,
+    orderbook_d_PrepareCancelOrdersResponse as PrepareCancelOrdersResponse,
+    orderbook_d_PrepareListingParams as PrepareListingParams,
+    orderbook_d_PrepareListingResponse as PrepareListingResponse,
+    orderbook_d_RoyaltyInfo as RoyaltyInfo,
+    orderbook_d_SignableAction as SignableAction,
+    orderbook_d_SignablePurpose as SignablePurpose,
+    orderbook_d_Trade as Trade,
+    orderbook_d_TradeResult as TradeResult,
+    orderbook_d_TransactionAction as TransactionAction,
+    orderbook_d_TransactionBuilder as TransactionBuilder,
+    orderbook_d_TransactionPurpose as TransactionPurpose,
+    orderbook_d_UnfulfillableOrder as UnfulfillableOrder,
+    orderbook_d_constants as constants,
+  };
+}
+
+type provider_d_GenericIMXProvider = GenericIMXProvider;
+declare const provider_d_GenericIMXProvider: typeof GenericIMXProvider;
+type provider_d_IMXProvider = IMXProvider;
+type provider_d_MetaMaskIMXProvider = MetaMaskIMXProvider;
+declare const provider_d_MetaMaskIMXProvider: typeof MetaMaskIMXProvider;
+type provider_d_ProviderConfiguration = ProviderConfiguration;
+declare const provider_d_ProviderConfiguration: typeof ProviderConfiguration;
+declare namespace provider_d {
+  export {
+    provider_d_GenericIMXProvider as GenericIMXProvider,
+    provider_d_IMXProvider as IMXProvider,
+    provider_d_MetaMaskIMXProvider as MetaMaskIMXProvider,
+    provider_d_ProviderConfiguration as ProviderConfiguration,
+  };
+}
+
+/**
+ * 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 = 13472,
+    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 OrderFee {
+    amount: FeeToken | FeePercentage;
+    recipient: string;
+}
+interface FeeToken {
+    token: string;
+}
+interface FeePercentage {
+    percentageDecimal: number;
+}
+
+type BuyResult = BuyResultSuccess | BuyResultFailed | BuyResultInsufficientFunds;
+/**
+ * Represents the result of {@link Checkout.buy}
+ * @property {CheckoutStatus.SUCCESS} status - The status to indicate success
+ * @property {SmartCheckoutSufficient} smartCheckoutResult - The sufficient result of smart checkout
+ */
+type BuyResultSuccess = {
+    status: CheckoutStatus.SUCCESS;
+    smartCheckoutResult: SmartCheckoutSufficient;
+};
+/**
+ * Represents the result of {@link Checkout.buy}
+ * @property {CheckoutStatus.FAILED} status - The status to indicate failure
+ * @property {string} transactionHash - The transaction hash of the failed transaction
+ * @property {string} reason - The reason for the failure
+ * @property {SmartCheckoutSufficient} smartCheckoutResult - The sufficient result of smart checkout
+ */
+type BuyResultFailed = {
+    status: CheckoutStatus.FAILED;
+    transactionHash: string;
+    reason: string;
+    smartCheckoutResult: SmartCheckoutSufficient;
+};
+/**
+ * Represents the result of {@link Checkout.buy}
+ * @property {CheckoutStatus.INSUFFICIENT_FUNDS} status - The status to indicate insufficient funds
+ * @property {SmartCheckoutInsufficient} smartCheckoutResult - The insufficient result of smart checkout
+ */
+type BuyResultInsufficientFunds = {
+    status: CheckoutStatus.INSUFFICIENT_FUNDS;
+    smartCheckoutResult: SmartCheckoutInsufficient;
+};
+type SellResult = SellResultSuccess | SellResultFailed | SellResultInsufficientFunds;
+/**
+ * Represents the result of {@link Checkout.sell}
+ * @property {CheckoutStatus.SUCCESS} status - The status to indicate success
+ * @property {SmartCheckoutSufficient} smartCheckoutResult - The sufficient result of smart checkout
+ */
+type SellResultSuccess = {
+    status: CheckoutStatus.SUCCESS;
+    orderIds: string[];
+    smartCheckoutResult: SmartCheckoutSufficient;
+};
+/**
+ * Represents the result of {@link Checkout.sell}
+ * @property {CheckoutStatus.FAILED} status - The status to indicate failure
+ * @property {string} transactionHash - The transaction hash of the failed transaction
+ * @property {string} reason - The reason for the failure
+ * @property {SmartCheckoutSufficient} smartCheckoutResult - The sufficient result of smart checkout
+ */
+type SellResultFailed = {
+    status: CheckoutStatus.FAILED;
+    transactionHash: string;
+    reason: string;
+    smartCheckoutResult: SmartCheckoutSufficient;
+};
+/**
+ * Represents the result of {@link Checkout.sell}
+ * @property {CheckoutStatus.INSUFFICIENT_FUNDS} status - The status to indicate insufficient funds
+ * @property {SmartCheckoutInsufficient} smartCheckoutResult - The insufficient result of smart checkout
+ */
+type SellResultInsufficientFunds = {
+    status: CheckoutStatus.INSUFFICIENT_FUNDS;
+    smartCheckoutResult: SmartCheckoutInsufficient;
+};
+type CancelResult = CancelResultSuccess | CancelResultFailed;
+/**
+ * Represents the result of {@link Checkout.cancel}
+ * @property {CheckoutStatus.SUCCESS} status - The status to indicate success
+ */
+type CancelResultSuccess = {
+    status: CheckoutStatus.SUCCESS;
+};
+/**
+ * Represents the result of {@link Checkout.cancel}
+ * @property {CheckoutStatus.FAILED} status - The status to indicate failure
+ * @property {string} transactionHash - The transaction hash of the failed transaction
+ * @property {string} reason - The reason for the failure
+ */
+type CancelResultFailed = {
+    status: CheckoutStatus.FAILED;
+    transactionHash: string;
+    reason: string;
+};
+/**
+ * An enum representing the checkout status types
+ * @enum {string}
+ * @property {string} SUCCESS - If checkout succeeded as the transactions were able to be processed
+ * @property {string} FAILED - If checkout failed due to transactions not settling on chain
+ * @property {string} INSUFFICIENT_FUNDS - If checkout failed due to insufficient funds
+ */
+declare enum CheckoutStatus {
+    SUCCESS = "SUCCESS",
+    FAILED = "FAILED",
+    INSUFFICIENT_FUNDS = "INSUFFICIENT_FUNDS"
+}
+/**
+ * The type representing the order to buy
+ * @property {string} orderId - the id of the order to buy
+ * @property {Array<OrderFee>} takerFees - array of order fees to apply to the order
+ */
+type BuyOrder = {
+    id: string;
+    takerFees?: OrderFee[];
+};
+/**
+ * The type representing the sell order to create a listing from
+ * @property {SellToken} sellToken - the token to be listed for sale
+ * @property {BuyToken} buyToken - the token info of the price of the item
+ * @property {OrderFee[]} makerFees - option array of makerFees to be applied to the listing
+ */
+type SellOrder = {
+    sellToken: SellToken;
+    buyToken: BuyToken;
+    makerFees?: OrderFee[];
+};
+/**
+ * Represents the token that the item can be bought with once listed for sale.
+ * NativeBuyToken or ERC20BuyToken {@link Checkout.smartCheckout}.
+ */
+type BuyToken = NativeBuyToken | ERC20BuyToken;
+/**
+ * Represents a native buy token
+ * @property {ItemType} type - The type indicate this is a native token.
+ * @property {string} amount - The amount of native token.
+ */
+type NativeBuyToken = {
+    type: ItemType.NATIVE;
+    amount: string;
+};
+/**
+ * Represents a ERC20 buy token
+ * @property {ItemType} type - The type indicate this is a ERC20 token.
+ * @property {string} amount - The amount of native token.
+ * @property {string} contractAddress - The contract address of the ERC20.
+ */
+type ERC20BuyToken = {
+    type: ItemType.ERC20;
+    amount: string;
+    contractAddress: string;
+};
+/**
+ * The SellToken type
+ * @property {string} id - The ERC721 token id
+ * @property {string} collectionAddress - The ERC721 collection address
+ */
+type SellToken = {
+    id: string;
+    collectionAddress: string;
+};
+/**
+ * Interface representing the parameters for {@link Checkout.smartCheckout}
+ * @property {Web3Provider} provider - The provider to use for smart checkout.
+ * @property {ItemRequirement[]} itemRequirements - The item requirements for the transaction.
+ * @property {FulfillmentTransaction | GasAmount} transactionOrGasAmount - The transaction or gas amount.
+ */
+interface SmartCheckoutParams {
+    provider: Web3Provider;
+    itemRequirements: (NativeItemRequirement | ERC20ItemRequirement | ERC721ItemRequirement)[];
+    transactionOrGasAmount: FulfillmentTransaction | GasAmount;
+}
+/**
+ * Represents a native item requirement for a transaction.
+ * @property {ItemType.NATIVE} type - The type to indicate this is a native item requirement.
+ * @property {string} amount - The amount of the item.
+ */
+type NativeItemRequirement = {
+    type: ItemType.NATIVE;
+    amount: string;
+};
+/**
+ * Represents an ERC20 item requirement for a transaction.
+ * @property {ItemType.ERC20} type - The type to indicate this is a ERC20 item requirement.
+ * @property {string} amount - The amount of the item.
+ * @property {string} contractAddress - The contract address of the ERC20.
+ * @property {string} spenderAddress - The contract address of the approver.
+ */
+type ERC20ItemRequirement = {
+    type: ItemType.ERC20;
+    contractAddress: string;
+    amount: string;
+    spenderAddress: string;
+};
+/**
+ * Represents an ERC721 item requirement for a transaction.
+ * @property {ItemType.ERC721} type - The type to indicate this is a ERC721 item requirement.
+ * @property {string} contractAddress - The contract address of the ERC721 collection.
+ * @property {string} id - The ID of this ERC721 in the collection.
+ * @property {string} spenderAddress - The contract address of the approver.
+ */
+type ERC721ItemRequirement = {
+    type: ItemType.ERC721;
+    contractAddress: string;
+    id: string;
+    spenderAddress: string;
+};
+/**
+ * An enum representing the item types
+ * @enum {string}
+ * @property {string} NATIVE - If the item is a native token.
+ * @property {string} ERC20 - If the item is an ERC20 token.
+ * @property {string} ERC721 - If the item is an ERC721 token.
+ */
+declare enum ItemType {
+    NATIVE = "NATIVE",
+    ERC20 = "ERC20",
+    ERC721 = "ERC721"
+}
+/**
+ * An enum representing transaction or gas types
+ * @enum {string}
+ * @property {string} TRANSACTION - If the type is a transaction
+ * @property {string} GAS - If the type is the gas amount
+ */
+declare enum TransactionOrGasType {
+    TRANSACTION = "TRANSACTION",
+    GAS = "GAS"
+}
+/**
+ * The fulfillment transaction which contains the transaction to send.
+ * @property {TransactionOrGasType} type - The type to indicate this is a fulfillment transaction.
+ * @property {TransactionRequest} transaction - The transaction to send.
+ */
+type FulfillmentTransaction = {
+    type: TransactionOrGasType.TRANSACTION;
+    transaction: TransactionRequest;
+};
+/**
+ * The gas amount which contains the gas token and the gas limit.
+ * @property {TransactionOrGasType} type - The type to indicate this is a gas amount.
+ * @property {GasToken} gasToken - The gas token.
+ */
+type GasAmount = {
+    type: TransactionOrGasType.GAS;
+    gasToken: GasToken;
+};
+/**
+ * Represents the gas token which is either a native token or an ERC20 token.
+ */
+type GasToken = NativeGas | ERC20Gas;
+/**
+ * An enum representing the gas token types
+ * @enum {string}
+ * @property {string} NATIVE - If the gas token is a native token.
+ * @property {string} ERC20 - If the gas token is an ERC20 token.
+ */
+declare enum GasTokenType {
+    NATIVE = "NATIVE",
+    ERC20 = "ERC20"
+}
+/**
+ * Represents a native gas token.
+ * @property {GasTokenType} type - The type to indicate this is a native gas token.
+ * @property {BigNumber} limit - The gas limit.
+ */
+type NativeGas = {
+    type: GasTokenType.NATIVE;
+    limit: BigNumber;
+};
+/**
+ * Represents an ERC20 gas token.
+ * @property {GasTokenType} type - The type to indicate this is an ERC20 gas token.
+ * @property {string} contractAddress - The contract address of the ERC20.
+ * @property {BigNumber} limit - The gas limit.
+ */
+type ERC20Gas = {
+    type: GasTokenType.ERC20;
+    contractAddress: string;
+    limit: BigNumber;
+};
+/**
+ * The type representing the result of {@link Checkout.smartCheckout}.
+ */
+type SmartCheckoutResult = SmartCheckoutSufficient | SmartCheckoutInsufficient;
+/**
+ * Represents the result of {@link Checkout.smartCheckout} when smart checkout is sufficient.
+ * @property {boolean} sufficient - Indicates that smart checkout determined the user had sufficient funds.
+ * @property {TransactionRequirement[]} transactionRequirements - The transaction requirements smart checkout
+ * determined were required for the transaction.
+ */
+type SmartCheckoutSufficient = {
+    sufficient: true;
+    transactionRequirements: TransactionRequirement[];
+};
+/**
+ * Represents the result of {@link Checkout.smartCheckout} when smart checkout is insufficient.
+ * @property {boolean} sufficient - Indicates that smart checkout determined the user has insufficient funds
+ * @property {TransactionRequirement[]} transactionRequirements - The transaction requirements smart checkout
+ * determined were required for the transaction.
+ * @property {SmartCheckoutRouter} router - The type containing the funding routes the user can take to fulfill the transaction requirements
+ */
+type SmartCheckoutInsufficient = {
+    sufficient: false;
+    transactionRequirements: TransactionRequirement[];
+    router: SmartCheckoutRouter;
+};
+/**
+ * Represents the routing outcome for a transaction.
+ * @property {AvailableRoutingOptions} availableRoutingOptions - The routing options available to the user
+ * @property {RoutingOutcome} routingOutcome - The routing outcome for the transaction which
+ * includes the funding routes if routes were found
+ */
+type SmartCheckoutRouter = {
+    availableRoutingOptions: AvailableRoutingOptions;
+    routingOutcome: RoutingOutcome;
+};
+/**
+ * An enum representing the routing outcome types
+ * @enum {string}
+ * @property {string} ROUTES_FOUND - If funding routes were found for the transaction.
+ * @property {string} NO_ROUTES_FOUND - If no funding routes were found for the transaction.
+ * @property {string} NO_ROUTE_OPTIONS - If no routing options were available for the transaction.
+ */
+declare enum RoutingOutcomeType {
+    ROUTES_FOUND = "ROUTES_FOUND",
+    NO_ROUTES_FOUND = "NO_ROUTES_FOUND",
+    NO_ROUTE_OPTIONS = "NO_ROUTE_OPTIONS"
+}
+type RoutingOutcome = RoutesFound | NoRoutesFound | NoRouteOptions;
+/**
+ * Represents a routing outcome where funding routes were found.
+ * @property {RoutingOutcomeType.ROUTES_FOUND} type - Indicates that funding routes were found for the transaction.
+ * @property {AvailableRoutingOptions} fundingRoutes - The funding routes found for the transaction.
+ */
+type RoutesFound = {
+    type: RoutingOutcomeType.ROUTES_FOUND;
+    fundingRoutes: FundingRoute[];
+};
+/**
+ * Represents a routing outcome where no funding routes were found.
+ * @property {RoutingOutcomeType.NO_ROUTES_FOUND} type - Indicates that no funding routes were found for the transaction.
+ * @property {string} message - The message indicating why no funding routes were found.
+ */
+type NoRoutesFound = {
+    type: RoutingOutcomeType.NO_ROUTES_FOUND;
+    message: string;
+};
+/**
+ * Represents a routing outcome where no routing options were available for the transaction.
+ * @property {RoutingOutcomeType.NO_ROUTE_OPTIONS} type - Indicates that no routing options were available for the transaction.
+ * @property {string} message - The message indicating why no routing options were available.
+ */
+type NoRouteOptions = {
+    type: RoutingOutcomeType.NO_ROUTE_OPTIONS;
+    message: string;
+};
+/**
+ * Represents a funding route
+ * @property {number} priority - The priority of the route
+ * @property {FundingStep[]} steps - The steps associated with this funding route
+ */
+type FundingRoute = {
+    priority: number;
+    steps: FundingStep[];
+};
+/**
+ * Represents a fee
+ * @property {BigNumber} amount - The amount of the fee
+ * @property {string} formatted - The formatted amount of the fee
+ * @property {TokenInfo | undefined} token - The token info for the fee
+ */
+type Fee = {
+    amount: BigNumber;
+    formattedAmount: string;
+    token?: TokenInfo;
+};
+type FundingStep = BridgeFundingStep | SwapFundingStep | OnRampFundingStep;
+/**
+ * Represents a bridge funding route
+ * @property {FundingStepType.BRIDGE} type - Indicates that this is a bridge funding step
+ * @property {number} chainId - The chain id the bridge should be executed on
+ * @property {FundingItem} fundingItem - The funding item for the bridge
+ * @property {BridgeFees} fees - The fees for the bridge
+ */
+type BridgeFundingStep = {
+    type: FundingStepType.BRIDGE;
+    chainId: number;
+    fundingItem: FundingItem;
+    fees: BridgeFees;
+};
+/**
+ * Represents the fees for a bridge funding step
+ * @property {Fee} approvalGasFees - The approval gas fees for the bridge
+ * @property {Fee} bridgeGasFees - The bridge gas fees for the bridge
+ * @property {Fee[]} bridgeFees - Additional bridge fees for the bridge
+ */
+type BridgeFees = {
+    approvalGasFees: Fee;
+    bridgeGasFees: Fee;
+    bridgeFees: Fee[];
+};
+/**
+ * Represents a swap funding route
+ * @property {FundingStepType.SWAP} type - Indicates that this is a swap funding step
+ * @property {number} chainId - The chain id the swap should be executed on
+ * @property {FundingItem} fundingItem - The funding item for the swap
+ * @property {SwapFees} fees - The fees for the swap
+ */
+type SwapFundingStep = {
+    type: FundingStepType.SWAP;
+    chainId: number;
+    fundingItem: FundingItem;
+    fees: SwapFees;
+};
+/**
+ * Represents the fees for a swap funding step
+ * @property {Fee} approvalGasFees - The approval gas fees for the swap
+ * @property {Fee} swapGasFees - The swap gas fees for the swap
+ * @property {Fee[]} swapFees - Additional swap fees for the swap
+ */
+type SwapFees = {
+    approvalGasFees: Fee;
+    swapGasFees: Fee;
+    swapFees: Fee[];
+};
+/**
+ * Represents an onramp funding route
+ * @property {FundingStepType.ONRAMP} type - Indicates that this is an onramp funding step
+ * @property {number} chainId - The chain id the onramp should provide funds to
+ * @property {FundingItem} fundingItem - The item to be onramped
+ */
+type OnRampFundingStep = {
+    type: FundingStepType.ONRAMP;
+    chainId: number;
+    fundingItem: FundingItem;
+};
+/**
+ * An enum representing the funding step types
+ * @enum {string}
+ * @property {string} BRIDGE - If the funding step is a bridge.
+ * @property {string} SWAP - If the funding step is a swap.
+ * @property {string} ONRAMP - If the funding step is an onramp.
+ */
+declare enum FundingStepType {
+    BRIDGE = "BRIDGE",
+    SWAP = "SWAP",
+    ONRAMP = "ONRAMP"
+}
+/**
+ * Represents a funding item
+ * @property {ItemType.NATIVE | ItemType.ERC20} type - The type of the funding item
+ * @property {FundsRequired} fundsRequired - The amount of funds required of this funding item
+ * @property {UserBalance} userBalance - The current user balance of this funding item
+ * @property {TokenInfo} token - The token info for the funding item
+ */
+type FundingItem = {
+    type: ItemType.NATIVE | ItemType.ERC20;
+    fundsRequired: FundsRequired;
+    userBalance: UserBalance;
+    token: TokenInfo;
+};
+/**
+ * Represents the funds required of a funding item
+ * @property {BigNumber} amount - The amount of funds required
+ * @property {string} formattedAmount - The formatted amount of funds required
+ */
+type FundsRequired = {
+    amount: BigNumber;
+    formattedAmount: string;
+};
+/**
+ * Represents the user balance of a funding item
+ * @property {BigNumber} balance - The balance of the funding item
+ * @property {string} formattedBalance - The formatted balance of the funding item
+ */
+type UserBalance = {
+    balance: BigNumber;
+    formattedBalance: string;
+};
+/**
+ * Represents the transaction requirement for a transaction.
+ * @property {ItemType} type - The type of the transaction requirement.
+ * @property {boolean} sufficient - If the user address has sufficient funds to cover the transaction.
+ * @property {ItemBalance} required - The required item balance.
+ * @property {ItemBalance} current - The current item balance.
+ * @property {BalanceDelta} delta - The delta between the required and current balances.
+ */
+type TransactionRequirement = {
+    type: ItemType;
+    sufficient: boolean;
+    required: ItemBalance;
+    current: ItemBalance;
+    delta: BalanceDelta;
+};
+/**
+ * Represents the balance for either a native or ERC20 token.
+ * @property {ItemType.NATIVE | ItemType.ERC20} type - Type to indicate this is a native or ERC20 token.
+ * @property {BigNumber} balance - The balance of the item.
+ * @property {string} formattedBalance - The formatted balance of the item.
+ * @property {TokenInfo} token - The token info of the item.
+ */
+type TokenBalance = {
+    type: ItemType.NATIVE | ItemType.ERC20;
+    balance: BigNumber;
+    formattedBalance: string;
+    token: TokenInfo;
+};
+/**
+ * Represents the balance for an ERC721.
+ * @property {ItemType.ERC721} type - Type to indicate this is an ERC721 token.
+ * @property {BigNumber} balance - The balance of the item.
+ * @property {string} formattedBalance - The formatted balance of the item.
+ * @property {string} contractAddress - The contract address of the ERC721 collection.
+ * @property {string} id - The ID of the ERC721 in the collection.
+ */
+type ERC721Balance = {
+    type: ItemType.ERC721;
+    balance: BigNumber;
+    formattedBalance: string;
+    contractAddress: string;
+    id: string;
+};
+/**
+ * Type representing the balance of an item.
+ */
+type ItemBalance = ERC721Balance | TokenBalance;
+/**
+ * Represents the delta between two balances.
+ * @property {BigNumber} balance - The delta of the balance.
+ * @property {string} formattedBalance - The formatted balance of the delta.
+ */
+type BalanceDelta = {
+    balance: BigNumber;
+    formattedBalance: string;
+};
+/**
+ * A type representing the Smart Checkout routing options available for a user
+ * if they are configured and enabled (not geo-blocked etc.)
+ * @property {boolean | undefined} onRamp - If the user can use onramp
+ * @property {boolean | undefined} swap - If the user can use swap
+ * @property {boolean | undefined} bridge - If the user can use bridge
+ */
+type AvailableRoutingOptions = {
+    onRamp?: boolean;
+    swap?: boolean;
+    bridge?: boolean;
+};
+
+/**
+ * Interface representing the parameters for {@link Checkout.buy}
+ * @property {Web3Provider} provider - The provider to use for the buy.
+ * @property {Array<BuyOrder>} orders - The orders to buy
+ * Currently only processes the first order in the array until batch processing is supported.
+ */
+interface BuyParams {
+    provider: Web3Provider;
+    orders: Array<BuyOrder>;
+}
+
+/**
+ * Interface representing the parameters for {@link Checkout.cancel}
+ * @property {Web3Provider} provider - The provider to use for the cancel.
+ * @property {string[]} orderIds - The order IDs to cancel.
+ * Currently only processes the first order in the array until batch processing is supported.
+ */
+interface CancelParams {
+    provider: Web3Provider;
+    orderIds: string[];
+}
+
+/**
+ * Type representing an ERC20 token
+ * @property {string} type - The token type, used to discriminate between {@link ERC20} and {@link Native}
+ * @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 ERC20 = {
+    type: 'erc20';
+    chainId: number;
+    address: string;
+    decimals: number;
+    symbol?: string;
+    name?: string;
+};
+/**
+ * Type representing a native token
+ * @property {string} type - The token type, used to discriminate between {@link ERC20} and {@link Native}
+ * @property {number} chainId - The chain ID
+ * @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 Native = {
+    type: 'native';
+    chainId: number;
+    decimals: number;
+    symbol?: string;
+    name?: string;
+};
+/**
+ * Type representing a token, either an {@link ERC20} or {@link Native}
+ */
+type Coin = ERC20 | Native;
+/**
+ * Type representing the overrides for the {@link Exchange} module
+ * @property {string} rpcURL - The RPC URL for the chain
+ * @property {ExchangeContracts} exchangeContracts - The DEX contract addresses
+ * @property {ERC20[]} commonRoutingTokens - The tokens used to find available pools for a swap
+ * @property {Coin} nativeToken - The native token of the chain
+ * @property {ERC20} wrappedNativeToken - The wrapped native token of the chain
+ */
+type ExchangeOverrides = {
+    rpcURL: string;
+    exchangeContracts: ExchangeContracts;
+    commonRoutingTokens: ERC20[];
+    nativeToken: Coin;
+    wrappedNativeToken: ERC20;
+};
+
+interface CheckoutOverrides {
+}
+/**
+ * A type representing checkout SDK configurations.
+ * @property {boolean} isOnRampEnabled - To enable on-ramp feature in Checkout sdk.
+ * @property {boolean} isSwapEnabled - To enable swap feature in Checkout sdk.
+ * @property {boolean} isBridgeEnabled - To enable bridge feature in Checkout sdk.
+ * @property {Passport} passport - To enable passport wallet with Checkout sdk.
+*/
+interface CheckoutModuleConfiguration extends ModuleConfiguration<CheckoutOverrides> {
+    isOnRampEnabled?: boolean;
+    isSwapEnabled?: boolean;
+    isBridgeEnabled?: boolean;
+    passport?: Passport;
+}
+/**
+ * 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 {OnRampConfig} onramp - The config used for the OnRamp
+ * @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;
+    onramp: OnRampConfig;
+    bridge: BridgeConfig;
+    allowedNetworks: AllowedNetworkConfig[];
+    gasEstimateTokens?: GasEstimateTokenConfig;
+    imxAddressMapping?: ImxAddressConfig;
+};
+/**
+ * A type representing the fee structure for an OnRamp provider
+ * @property {string | undefined} minPercentage - minimum percentage fee shown if a fee range is provided
+ * @property {string | undefined} maxPercentage - maximum percentage fee shown if a fee range is provided
+ * @property {string | undefined} feePercentage - specific fee percentage shown if there is no range provided
+ */
+type OnRampProviderFees = {
+    minPercentage?: string;
+    maxPercentage?: string;
+    feePercentage?: string;
+};
+/**
+ * A type representing the configuration for the OnRamp for a specific provider.
+ * @property {string} publishableApiKey - on ramp provider publishable api-key
+ * @property {TokenInfo[]} tokens - allowed tokens for the OnRamp provider
+ * @property {OnRampProviderFees} fees - on ramp provider transaction fees
+ */
+type OnRampProviderConfig = {
+    publishableApiKey: string;
+    tokens: TokenInfo[];
+    fees: OnRampProviderFees;
+};
+/**
+ * A type representing the configuration for the OnRamp.
+ * @property {OnRampProviderConfig} transak - OnRamp config for Transak provider
+ */
+type OnRampConfig = {
+    [key: string]: OnRampProviderConfig;
+};
+/**
+ * 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 the configuration for the Bridge.
+ * @property {TokenInfo[] | undefined} tokens - An array of tokens compatible with the Bridge.
+ */
+type BridgeConfig = {
+    tokens?: TokenInfo[];
+};
+/**
+ * A type representing an allowed network.
+ * @property {number} chainId - The network chain id.
+ */
+type AllowedNetworkConfig = {
+    chainId: number;
+};
+/**
+ * A type representing the IMX address mappings across available networks.
+ * @type {{ [chainId: string]: string }}
+ */
+type ImxAddressConfig = {
+    [chainId: string]: string;
+};
+/**
+ * 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;
+};
+/**
+ * A type representing all the feature flags available.
+ * @property {TokenInfo[] | undefined} allowed - List of allowed tokens for a given chain.
+ * @property {boolean | undefined} blockscout - Feature flag to enable/disable blockscout integration.
+ */
+type ChainTokensConfig = {
+    allowed?: TokenInfo[];
+    blockscout?: boolean;
+};
+
+/**
+ * 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;
+}
+
+/**
+ * @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';
+
+/**
+ * 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.sell}
+ * @property {Web3Provider} provider - The provider to use for the sell.
+ * @property {Array<SellOrder>} orders - An array of sell orders to execute.
+ * Currently only processes the first order in the array until batch processing is supported.
+ */
+interface SellParams {
+    provider: Web3Provider;
+    orders: Array<SellOrder>;
+}
+
+/**
+ * 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",
+    ONRAMP = "onramp"
+}
+/**
+ * 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 {
+    PASSPORT = "passport",
+    METAMASK = "metamask"
+}
+/**
+ * Interface for the parameters required to create a wallet provider {@link Checkout.createProvider}.
+ * @interface CreateProviderParams
+ * @property {WalletProviderName} walletProviderName - The wallet provider name to create a provider for.
+ */
+interface CreateProviderParams {
+    walletProviderName: WalletProviderName;
+}
+/**
+ * Represents the result of creating a Web3 provider {@link Checkout.createProvider}.
+ * @property {Web3Provider} provider - The created Web3 provider.
+ * @property {WalletProviderName} walletProviderName - The wallet provider name of the provider that was created.
+ */
+type CreateProviderResult = {
+    provider: Web3Provider;
+    walletProviderName: WalletProviderName;
+};
+
+/**
+ * Interface representing a wallet filter to be used in {@link GetWalletAllowListParams}.
+ * @property {WalletProviderName} walletProviderName - The wallet provider name to filter wallets by.
+ */
+interface WalletFilter {
+    walletProviderName: 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} walletProviderName - The wallet provider name for 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 {
+    walletProviderName: WalletProviderName;
+    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>;
+
+/**
+ * An enum representing the type of exchange.
+ * @enum {string}
+ * @property {string} ONRAMP - The exchange type for transacting.
+ */
+declare enum ExchangeType {
+    ONRAMP = "onramp"
+}
+/**
+ * Interface representing the result of {@link Checkout.createFiatRampUrl}.
+ * @property {ExchangeType} exchangeType - The ExchangeType specified.
+ * @property {Web3Provider} web3Provider - The Web3Provider used to exchange.
+ * @property {string | undefined} tokenAmount - The token amount specified as input.
+ * @property {string | undefined} tokenAddress - The token address specified as input.
+ * @property {Passport | undefined} passport - The Passport instance specified as input.
+ */
+interface FiatRampParams {
+    exchangeType: ExchangeType;
+    web3Provider: Web3Provider;
+    tokenAmount?: string;
+    tokenAddress?: string;
+    passport?: any;
+}
+
+type RemoteConfigParams = {
+    isDevelopment: boolean;
+    isProduction: boolean;
+};
+declare class RemoteConfigFetcher {
+    private isDevelopment;
+    private isProduction;
+    private configCache;
+    private tokensCache;
+    constructor(params: RemoteConfigParams);
+    private static makeHttpRequest;
+    private getEndpoint;
+    private loadConfig;
+    private loadConfigTokens;
+    getConfig(key?: keyof RemoteConfiguration): Promise<RemoteConfiguration | RemoteConfiguration[keyof RemoteConfiguration] | undefined>;
+    getTokensConfig(chainId: ChainId): Promise<ChainTokensConfig>;
+}
+
+declare class CheckoutConfiguration {
+    readonly isDevelopment: boolean;
+    readonly isProduction: boolean;
+    readonly isOnRampEnabled: boolean;
+    readonly isSwapEnabled: boolean;
+    readonly isBridgeEnabled: boolean;
+    readonly remote: RemoteConfigFetcher;
+    readonly environment: Environment;
+    readonly networkMap: NetworkMap;
+    constructor(config: CheckoutModuleConfiguration);
+}
+
+interface FiatRampWidgetParams {
+    exchangeType: ExchangeType;
+    isPassport: boolean;
+    walletAddress?: string;
+    tokenAmount?: string;
+    tokenSymbol?: string;
+    email?: string;
+}
+declare class FiatRampService {
+    readonly config: CheckoutConfiguration;
+    /**
+     * Constructs a new instance of the FiatRampService class.
+     * @param {CheckoutConfiguration} config - The config required for the FiatRampService.
+     */
+    constructor(config: CheckoutConfiguration);
+    feeEstimate(): Promise<OnRampProviderFees>;
+    createWidgetUrl(params: FiatRampWidgetParams): Promise<string>;
+    private getTransakWidgetUrl;
+}
+
+type AvailabilityService = {
+    checkDexAvailability: () => Promise<boolean>;
+};
+
+/**
+ * Enum representing the themes for the widgets.
+ */
+declare enum WidgetTheme {
+    LIGHT = "light",
+    DARK = "dark"
+}
+
+/**
+ * Represents the local configuration options for the Checkout Widgets.
+ * @property {WidgetTheme | undefined} theme - The theme of the Checkout Widget (default: "DARK")
+ */
+type WidgetConfiguration = {
+    theme?: WidgetTheme;
+};
+
+/**
+ * Enum representing the events emitted by the widgets.
+ */
+declare enum IMTBLWidgetEvents {
+    IMTBL_WIDGETS_PROVIDER = "imtbl-widgets-provider",
+    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_ONRAMP_WIDGET_EVENT = "imtbl-onramp-widget",
+    IMTBL_SALE_WIDGET_EVENT = "imtbl-sale-widget"
+}
+/**
+ * Enum for events raised for about provider objects
+ */
+declare enum ProviderEventType {
+    PROVIDER_UPDATED = "PROVIDER_UPDATED"
+}
+/**
+ * Payload type for the PROVIDER_UPDATED event
+ */
+type ProviderUpdated = {
+    provider: Web3Provider;
+};
+
+/**
+ * Enum representing possible Connect Widget event types.
+ */
+declare enum ConnectEventType {
+    CLOSE_WIDGET = "close-widget",
+    SUCCESS = "success",
+    FAILURE = "failure"
+}
+/**
+ * Represents a successful connection.
+ * @property {Web3Provider} provider - The connected provider.
+ * @property {WalletProviderName | undefined} walletProviderName - The wallet provider name of the connected provider.
+ */
+type ConnectionSuccess = {
+    provider: Web3Provider;
+    walletProviderName: WalletProviderName | undefined;
+};
+/**
+ * Represents a connection failure with a reason.
+ * @property {string} reason - The reason for the failed connection.
+ */
+type ConnectionFailed = {
+    reason: string;
+};
+
+/**
+ * Enum representing possible Wallet Widget event types.
+ */
+declare enum WalletEventType {
+    CLOSE_WIDGET = "close-widget",
+    NETWORK_SWITCH = "network-switch",
+    DISCONNECT_WALLET = "disconnect-wallet"
+}
+/**
+ * Represents an event that is triggered when the user switches the network in their wallet.
+ * @property {string} network - The name of the network that the user switched to.
+ * @property {number} chainId - The chain ID of the network that the user switched to.
+ * @property {Web3Provider} provider - The Web3 provider object for the switched network.
+ */
+type WalletNetworkSwitchEvent = {
+    network: string;
+    chainId: number;
+    provider: Web3Provider;
+};
+/**
+ * Represents an event that is triggered when a wallet is disconnected.
+ */
+type WalletDisconnectWalletEvent = {};
+
+/**
+ * Enum representing possible Swap Widget event types.
+ */
+declare enum SwapEventType {
+    CLOSE_WIDGET = "close-widget",
+    SUCCESS = "success",
+    FAILURE = "failure",
+    REJECTED = "rejected"
+}
+/**
+ * Represents a successful swap transaction.
+ * @property {string} transactionHash - The hash of the successful transaction.
+ */
+type SwapSuccess = {
+    transactionHash: string;
+};
+/**
+ * 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;
+};
+/**
+ * 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 SwapRejected = {
+    reason: string;
+    timestamp: number;
+};
+
+/**
+ * Enum representing possible Sale Widget event types.
+ */
+declare enum SaleEventType {
+    CLOSE_WIDGET = "close-widget",
+    SUCCESS = "success",
+    FAILURE = "failure",
+    REJECTED = "rejected"
+}
+/**
+ * Represents a successful Sale transaction.
+ * @property {string} transactionHash - The hash of the successful transaction.
+ */
+type SaleSuccess = {
+    transactions: {
+        method: string;
+        hash: string | undefined;
+    }[];
+    [key: string]: unknown;
+};
+/**
+ * Type representing a Sale Widget with type FAILURE.
+ * @property {string} reason - The reason why the swap failed.
+ * @property {number} timestamp - The timestamp of the failed swap.
+ */
+type SaleFailed = {
+    reason: string;
+    timestamp: number;
+};
+
+/**
+ * Enum of possible Bridge Widget event types.
+ */
+declare enum BridgeEventType {
+    CLOSE_WIDGET = "close-widget",
+    SUCCESS = "success",
+    FAILURE = "failure"
+}
+/**
+ * Represents a successful bridge transaction.
+ * @property {string} transactionHash - The hash of the successful transaction.
+ */
+type BridgeSuccess = {
+    transactionHash: string;
+};
+/**
+ * Represents a failed bridge transaction.
+ * @property {string} reason - The reason for the failed transaction.
+ * @property {number} timestamp - The timestamp of the failed transaction.
+ */
+type BridgeFailed = {
+    reason: string;
+    timestamp: number;
+};
+
+/**
+ * Enum representing different types of orchestration events.
+ */
+declare enum OrchestrationEventType {
+    REQUEST_CONNECT = "request-connect",
+    REQUEST_WALLET = "request-wallet",
+    REQUEST_SWAP = "request-swap",
+    REQUEST_BRIDGE = "request-bridge",
+    REQUEST_ONRAMP = "request-onramp"
+}
+/**
+ * Represents the connect event object when the connect widget is requested.
+ * @property {string} walletProviderName - The wallet provider name.
+ */
+type RequestConnectEvent = {
+    walletProviderName: string;
+};
+/**
+ * Represents the wallet event object when the wallet widget is requested.
+ * @property {string} walletProviderName - The wallet provider name.
+ */
+type RequestWalletEvent = {
+    walletProviderName: string;
+};
+/**
+ * Represents the swap event object when the swap widget is requested.
+ * @property {string} fromTokenAddress - The address of the token to swap from.
+ * @property {string} toTokenAddress - The address of the token to swap to.
+ * @property {string} amount - The amount of from tokens to swap.
+ */
+type RequestSwapEvent = {
+    fromTokenAddress: string;
+    toTokenAddress: string;
+    amount: string;
+};
+/**
+ * Represents the bridge event object when the bridge widget is requested.
+ * @property {string} tokenAddress - The address of the token to bridge.
+ * @property {string} amount - The amount of tokens to bridge.
+ */
+type RequestBridgeEvent = {
+    tokenAddress: string;
+    amount: string;
+};
+/**
+ * Represents the onramp event object when the onramp widget is requested.
+ * @property {string} tokenAddress - The address of the token to be used for onramp.
+ * @property {string} amount - The amount of tokens to onramp.
+ */
+type RequestOnrampEvent = {
+    tokenAddress: string;
+    amount: string;
+};
+type OrchestrationEventData = RequestConnectEvent | RequestWalletEvent | RequestSwapEvent | RequestBridgeEvent | RequestOnrampEvent;
+
+/**
+ * Enum of possible OnRamp Widget event types.
+ */
+declare enum OnRampEventType {
+    CLOSE_WIDGET = "close-widget",
+    SUCCESS = "success",
+    FAILURE = "failure"
+}
+/**
+ * Represents a successful on-ramp transaction.
+ * @property {string} transactionHash - The transaction hash of the successful transaction.
+ */
+type OnRampSuccess = {
+    transactionHash: string;
+};
+/**
+ * Type representing a On-ramp Widget with type FAILURE.
+ * @property {string} reason - The reason why the on-ramp failed.
+ * @property {number} timestamp - The timestamp of the failed transaction.
+ */
+type OnRampFailed = {
+    reason: string;
+    timestamp: number;
+};
+
+declare enum ConnectTargetLayer {
+    LAYER1 = "LAYER1",
+    LAYER2 = "LAYER2"
+}
+type ConnectWidgetParams = {};
+
+/**
+ * Bridge Widget parameters
+ * @property {string | undefined} fromContractAddress - The contract address of the token to bridge from, used to populate the bridge form token field
+ * @property {string | undefined} amount - The formatted amount to bridge, used to populate the bridge form amount field
+ * @property {WalletProviderName | undefined} walletProviderName - The wallet provider name to use for the bridge widget
+ */
+type BridgeWidgetParams = {
+    fromContractAddress?: string;
+    amount?: string;
+    walletProviderName?: WalletProviderName;
+};
+
+/**
+ * Wallet Widget parameters
+ * @property {WalletProviderName | undefined} walletProviderName - The wallet provider name to use for the wallet widget
+ * @property {Web3Provider | undefined} web3Provider - The ethers Web3Provider
+ */
+type WalletWidgetParams = {
+    walletProviderName?: WalletProviderName;
+};
+
+/**
+ * Swap Widget parameters
+ * @property {string | undefined} amount - The formatted amount to swap, used to populate the swap from amount field
+ * @property {string | undefined} fromContractAddress - The contract address of the token to swap from
+ * @property {string | undefined} toContractAddress - The contract address of the token to swap to
+ * @property {WalletProviderName | undefined} walletProviderName - The wallet provider name to use for the swap widget
+ */
+interface SwapWidgetParams {
+    amount?: string;
+    fromContractAddress?: string;
+    toContractAddress?: string;
+    walletProviderName?: WalletProviderName;
+}
+
+/**
+ * OnRamp Widget parameters
+ * @property {string | undefined} contractAddress - The contract address of the token to onramp
+ * @property {string | undefined} amount - The formatted amount to onramp, used to populate the onramp form amount field
+ * @property {WalletProviderName | undefined} walletProviderName - The wallet provider name to use for the onramp widget
+ */
+type OnRampWidgetParams = {
+    contractAddress?: string;
+    amount?: string;
+    walletProviderName?: WalletProviderName;
+};
+
+/**
+ * Sale Widget parameters
+ * @property {string} amount - The total price to pay for the items in the sale
+ * @property {SaleItem[]} items - The list of products to be purchased
+ * @property {WalletProviderName | undefined} walletProviderName - The wallet provider name to default to if no web3Provider is passed
+ */
+type SaleWidgetParams = {
+    amount?: string;
+    environmentId?: string;
+    fromContractAddress?: string;
+    items?: SaleItem[];
+    walletProviderName?: WalletProviderName;
+};
+type SaleItem = {
+    productId: string;
+    qty: number;
+    name: string;
+    image: string;
+    description: string;
+};
+
+type ConnectWidgetConfiguration = {} & WidgetConfiguration;
+
+type BridgeWidgetConfiguration = {} & WidgetConfiguration;
+
+type WalletWidgetConfiguration = {} & WidgetConfiguration;
+
+type SwapWidgetConfiguration = {} & WidgetConfiguration;
+
+type OnrampWidgetConfiguration = {} & WidgetConfiguration;
+
+type SaleWidgetConfiguration = {} & WidgetConfiguration;
+
+/**
+ * Enum representing the list of widget types.
+ */
+declare enum WidgetType {
+    CONNECT = "connect",
+    WALLET = "wallet",
+    SWAP = "swap",
+    BRIDGE = "bridge",
+    ONRAMP = "onramp",
+    SALE = "sale"
+}
+/**
+ * Widget properties definition for each widget. Used for creating and updating widgets
+ */
+type WidgetProperties<T extends WidgetType> = {
+    config?: WidgetConfigurations[T];
+    provider?: Web3Provider;
+};
+type WidgetConfigurations = {
+    [WidgetType.CONNECT]: ConnectWidgetConfiguration;
+    [WidgetType.WALLET]: WalletWidgetConfiguration;
+    [WidgetType.SWAP]: SwapWidgetConfiguration;
+    [WidgetType.BRIDGE]: BridgeWidgetConfiguration;
+    [WidgetType.ONRAMP]: OnrampWidgetConfiguration;
+    [WidgetType.SALE]: SaleWidgetConfiguration;
+};
+type WidgetParameters = {
+    [WidgetType.CONNECT]: ConnectWidgetParams;
+    [WidgetType.WALLET]: WalletWidgetParams;
+    [WidgetType.SWAP]: SwapWidgetParams;
+    [WidgetType.BRIDGE]: BridgeWidgetParams;
+    [WidgetType.ONRAMP]: OnRampWidgetParams;
+    [WidgetType.SALE]: SaleWidgetParams;
+};
+/**
+ * Represents all the possible event types that are emitted by the widgets.
+ */
+type WidgetEventTypes = {
+    [WidgetType.CONNECT]: ConnectEventType | OrchestrationEventType;
+    [WidgetType.WALLET]: WalletEventType | OrchestrationEventType;
+    [WidgetType.SWAP]: SwapEventType | OrchestrationEventType;
+    [WidgetType.BRIDGE]: BridgeEventType | OrchestrationEventType;
+    [WidgetType.ONRAMP]: OnRampEventType | OrchestrationEventType;
+    [WidgetType.SALE]: SaleEventType | OrchestrationEventType;
+};
+type OrchestrationMapping = {
+    [OrchestrationEventType.REQUEST_CONNECT]: RequestConnectEvent;
+    [OrchestrationEventType.REQUEST_WALLET]: RequestWalletEvent;
+    [OrchestrationEventType.REQUEST_SWAP]: RequestSwapEvent;
+    [OrchestrationEventType.REQUEST_BRIDGE]: RequestBridgeEvent;
+    [OrchestrationEventType.REQUEST_ONRAMP]: RequestOnrampEvent;
+};
+type ProviderEventMapping = {
+    [ProviderEventType.PROVIDER_UPDATED]: ProviderUpdated;
+};
+/**
+ * Mapping of widget type, to each of it's events and then each event's payload
+ * Update this whenever a new event is created and used by a widget
+ * Each widget also has all of the orchestration events
+*/
+type WidgetEventData = {
+    [WidgetType.CONNECT]: {
+        [ConnectEventType.SUCCESS]: ConnectionSuccess;
+        [ConnectEventType.FAILURE]: ConnectionFailed;
+        [ConnectEventType.CLOSE_WIDGET]: {};
+    } & OrchestrationMapping & ProviderEventMapping;
+    [WidgetType.WALLET]: {
+        [WalletEventType.NETWORK_SWITCH]: WalletNetworkSwitchEvent;
+        [WalletEventType.DISCONNECT_WALLET]: WalletDisconnectWalletEvent;
+        [WalletEventType.CLOSE_WIDGET]: {};
+    } & OrchestrationMapping & ProviderEventMapping;
+    [WidgetType.SWAP]: {
+        [SwapEventType.SUCCESS]: SwapSuccess;
+        [SwapEventType.FAILURE]: SwapFailed;
+        [SwapEventType.REJECTED]: SwapRejected;
+        [SwapEventType.CLOSE_WIDGET]: {};
+    } & OrchestrationMapping & ProviderEventMapping;
+    [WidgetType.BRIDGE]: {
+        [BridgeEventType.SUCCESS]: BridgeSuccess;
+        [BridgeEventType.FAILURE]: BridgeFailed;
+        [BridgeEventType.CLOSE_WIDGET]: {};
+    } & OrchestrationMapping & ProviderEventMapping;
+    [WidgetType.ONRAMP]: {
+        [OnRampEventType.SUCCESS]: OnRampSuccess;
+        [OnRampEventType.FAILURE]: OnRampFailed;
+        [OnRampEventType.CLOSE_WIDGET]: {};
+    } & OrchestrationMapping & ProviderEventMapping;
+    [WidgetType.SALE]: {
+        [SaleEventType.SUCCESS]: SaleSuccess;
+        [SaleEventType.FAILURE]: SaleFailed;
+        [SaleEventType.REJECTED]: any;
+        [SaleEventType.CLOSE_WIDGET]: {};
+    } & OrchestrationMapping & ProviderEventMapping;
+};
+/**
+ * Represents an event emitted by a widget. The event type should match the event data
+ */
+/**
+ * Represents an event emitted by a widget.
+ * @template T - The widget type
+ * @template KEventName - The widget event name.
+ * @property {KEventName} type - The type of the event.
+ * @property {WidgetEventData[T][KEventName]} data - The data associated with the widget event.
+ */
+type WidgetEvent<T extends WidgetType, KEventName extends keyof WidgetEventData[T]> = {
+    type: KEventName;
+    data: WidgetEventData[T][KEventName];
+};
+/**
+ * Represents an event emitted by a widget.
+ * @template KEventName - The orchestration event name.
+ * @property {KEventName} type - The type of the event.
+ * @property {OrchestrationMapping[KEventName]} data - The data associated with the event.
+ */
+type OrchestrationEvent<KEventName extends keyof OrchestrationMapping> = {
+    type: KEventName;
+    data: OrchestrationMapping[KEventName];
+};
+/**
+ * Represents an event emitted by a widget.
+ * @template KEventName - The provider event name.
+ * @property {KEventName} type - The type of the event.
+ * @property {ProviderEventMapping[KEventName]} data - The data associated with the event.
+ */
+type ProviderEvent<KEventName extends keyof ProviderEventMapping> = {
+    type: KEventName;
+    data: ProviderEventMapping[KEventName];
+};
+interface IWidgetsFactory {
+    /**
+     * Create a new widget instance.
+     * @param type widget type to instantiate.
+     */
+    create<T extends WidgetType>(type: T, config?: WidgetConfigurations[T], provider?: Web3Provider): Widget<T>;
+    updateProvider(provider: Web3Provider): void;
+}
+/**
+ * Widget interface. Every widget implements this interface.
+ */
+interface Widget<T extends WidgetType> {
+    /**
+     * Mount a widget to a DOM ref element.
+     * @param id ID of the DOM element where the widget will be mounted.
+     */
+    mount(id: string, params?: WidgetParameters[T]): void;
+    /**
+     * Unmount a widget and reset parameters
+     */
+    unmount(): void;
+    /**
+     * Update the widget parameters
+     * @param params Widget specific parameters including configuration
+     */
+    update(params: WidgetProperties<T>): void;
+    /**
+     * Add a listener for a widget event.
+     * @param event Widget specific event name.
+     * @param callback function to execute when the event is received.
+     */
+    addListener<KEventName extends keyof WidgetEventData[T]>(type: KEventName, callback: (data: WidgetEventData[T][KEventName]) => void): void;
+    /**
+     * Removes an event listener for a widget event.
+     * @param type Widget specific event name.
+     */
+    removeListener<KEventName extends keyof WidgetEventData[T]>(type: KEventName): void;
+}
+/**
+ * Represents the version of the Checkout Widgets to use defaults to (0.1.9-alpha)
+ * @property {number} major - The major version of the widgets, must specify a major version even if it is 0.
+ * @property {number | undefined} minor - The minor version of the widgets, leaving this blank will use the latest minor based on major
+ * @property {number | undefined} patch - The patch version of the widgets, leaving this blank will use the latest minor based on minor
+ * @property {'alpha' | undefined} prerelease - The prerelease version of the widgets, can only be 'alpha'. Do not use in production.
+ * @property {number | undefined} build - The build version of the widgets. Do not use in production.
+ *
+ * @example
+ * { major: 0 } - use default version 0.1.9-alpha
+ * { major: 1 } - use version 1.x.x, pickup all new minor and patch versions released
+ * { major: 1, minor: 1 } - use version 1.1.x, pickup all new patch versions released
+ * { major: 1, minor: 2, patch: 3 } - use version 1.2.3 specifically
+ */
+type SemanticVersion = {
+    major: number;
+    minor?: number;
+    patch?: number;
+    prerelease?: 'alpha';
+    build?: number;
+};
+/**
+ * Represents the global configuration options for the Checkout Widgets.
+ * @property {WidgetTheme | undefined} theme - The theme of the Checkout Widget (default: "DARK")
+ * @property {Environment | undefined} environment - The environment configuration (default: "SANDBOX")
+ * @property {SemanticVersion | undefined} version - The version of the checkout widgets js file to use (default: "0.1.x")
+ * @property {boolean | undefined} isOnRampEnabled - Enable on-ramp top-up method (default: "true")
+ * @property {boolean | undefined} isSwapEnabled - Enable swap top-up method (default: "true")
+ * @property {boolean | undefined} isBridgeEnabled - Enable bridge top-up method (default: "true")
+ */
+type CheckoutWidgetsConfig = {
+    theme?: WidgetTheme;
+    environment?: Environment;
+    version?: SemanticVersion;
+    isOnRampEnabled?: boolean;
+    isSwapEnabled?: boolean;
+    isBridgeEnabled?: boolean;
+};
+
+/**
+ * Represents the configuration options for instantiating the Checkout Widgets factory.
+ * @property {WidgetConfiguration} config - global configuration options for the widgets.
+ * @property {SemanticVersion | undefined} version - version of the Checkout widgets bundle (default latest version will be used).
+ */
+type WidgetsInit = {
+    config: WidgetConfiguration;
+    version?: SemanticVersion;
+};
+
+declare class Checkout {
+    private readOnlyProviders;
+    readonly config: CheckoutConfiguration;
+    readonly fiatRampService: FiatRampService;
+    readonly availability: AvailabilityService;
+    readonly passport?: Passport;
+    /**
+     * Constructs a new instance of the CheckoutModule class.
+     * @param {CheckoutModuleConfiguration} [config=SANDBOX_CONFIGURATION] - The configuration object for the CheckoutModule.
+     */
+    constructor(config?: CheckoutModuleConfiguration);
+    /**
+     * Loads the widgets bundle and initiate the widgets factory.
+     * @param {WidgetsInit} init - The initialisation parameters for loading the widgets bundle and applying configuration
+     */
+    widgets(init: WidgetsInit): Promise<ImmutableCheckoutWidgets.WidgetsFactory>;
+    /**
+     * 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>;
+    /**
+     * Determines the requirements for performing a buy.
+     * @param {BuyParams} params - The parameters for the buy.
+    */
+    buy(params: BuyParams): Promise<BuyResult>;
+    /**
+     * Determines the requirements for performing a sell.
+     * @param {SellParams} params - The parameters for the sell.
+     * Only currently actions the first order in the array until we support batch processing.
+     * Only currently actions the first fee in the fees array of each order until we support multiple fees.
+    */
+    sell(params: SellParams): Promise<SellResult>;
+    /**
+     * Cancels a sell.
+     * @param {CancelParams} params - The parameters for the cancel.
+     */
+    cancel(params: CancelParams): Promise<CancelResult>;
+    /**
+     * Determines the transaction requirements to complete a purchase.
+     * @params {SmartCheckoutParams} params - The parameters for smart checkout.
+     */
+    smartCheckout(params: SmartCheckoutParams): Promise<SmartCheckoutResult>;
+    /**
+     * 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>;
+    /**
+     * Creates and returns a URL for the fiat ramp widget.
+     * @param {FiatRampParams} params - The parameters for creating the url.
+     * @returns {Promise<string>} - A promise that resolves to a string url.
+     */
+    createFiatRampUrl(params: FiatRampParams): Promise<string>;
+    /**
+     * Fetches fiat ramp fee estimations.
+     * @returns {Promise<OnRampProviderFees>} - A promise that resolves to OnRampProviderFees.
+     */
+    getExchangeFeeEstimate(): Promise<OnRampProviderFees>;
+    /**
+     * Fetches Swap widget availability.
+     * @returns {Promise<boolean>} - A promise that resolves to a boolean.
+     */
+    isSwapAvailable(): Promise<boolean>;
+}
+
+/**
+ * Declares global interfaces and namespaces for the application.
+ * @global
+ * @namespace ImmutableCheckoutWidgets
+ * */
+declare global {
+    namespace ImmutableCheckoutWidgets {
+        class WidgetsFactory implements IWidgetsFactory {
+            constructor(sdk: Checkout, config: CheckoutWidgetsConfig);
+            create<T extends WidgetType>(type: T, config?: WidgetConfigurations[T], provider?: Web3Provider): Widget<T>;
+            updateProvider(provider: Web3Provider): void;
+        }
+        class Connect<T extends WidgetType> implements Widget<T> {
+            constructor(sdk: Checkout, props: WidgetProperties<T>);
+            mount(id: string, params?: WidgetParameters[T]): void;
+            unmount(): void;
+            update(props: WidgetProperties<T>): void;
+            addListener<KEventName extends keyof WidgetEventData[T]>(type: KEventName, callback: (data: WidgetEventData[T][KEventName]) => void): void;
+            removeListener<KEventName extends keyof WidgetEventData[T]>(type: KEventName): void;
+        }
+        class Bridge<T extends WidgetType> implements Widget<T> {
+            constructor(sdk: Checkout, props: WidgetProperties<T>);
+            mount(id: string, params?: WidgetParameters[T]): void;
+            unmount(): void;
+            update(props: WidgetProperties<T>): void;
+            addListener<KEventName extends keyof WidgetEventData[T]>(type: KEventName, callback: (data: WidgetEventData[T][KEventName]) => void): void;
+            removeListener<KEventName extends keyof WidgetEventData[T]>(type: KEventName): void;
+        }
+        class Wallet<T extends WidgetType> implements Widget<T> {
+            constructor(sdk: Checkout, props: WidgetProperties<T>);
+            mount(id: string, params?: WidgetParameters[T]): void;
+            unmount(): void;
+            update(props: WidgetProperties<T>): void;
+            addListener<KEventName extends keyof WidgetEventData[T]>(type: KEventName, callback: (data: WidgetEventData[T][KEventName]) => void): void;
+            removeListener<KEventName extends keyof WidgetEventData[T]>(type: KEventName): void;
+        }
+        class Swap<T extends WidgetType> implements Widget<T> {
+            constructor(sdk: Checkout, props: WidgetProperties<T>);
+            mount(id: string, params?: WidgetParameters[T]): void;
+            unmount(): void;
+            update(props: WidgetProperties<T>): void;
+            addListener<KEventName extends keyof WidgetEventData[T]>(type: KEventName, callback: (data: WidgetEventData[T][KEventName]) => void): void;
+            removeListener<KEventName extends keyof WidgetEventData[T]>(type: KEventName): void;
+        }
+        class OnRamp<T extends WidgetType> implements Widget<T> {
+            constructor(sdk: Checkout, props: WidgetProperties<T>);
+            mount(id: string, params?: WidgetParameters[T]): void;
+            unmount(): void;
+            update(props: WidgetProperties<T>): void;
+            addListener<KEventName extends keyof WidgetEventData[T]>(type: KEventName, callback: (data: WidgetEventData[T][KEventName]) => void): void;
+            removeListener<KEventName extends keyof WidgetEventData[T]>(type: KEventName): void;
+        }
+        class Sale<T extends WidgetType> implements Widget<T> {
+            constructor(sdk: Checkout, props: WidgetProperties<T>);
+            mount(id: string, params?: WidgetParameters[T]): void;
+            unmount(): void;
+            update(props: WidgetProperties<T>): void;
+            addListener<KEventName extends keyof WidgetEventData[T]>(type: KEventName, callback: (data: WidgetEventData[T][KEventName]) => void): void;
+            removeListener<KEventName extends keyof WidgetEventData[T]>(type: KEventName): void;
+        }
+    }
+}
+
+/**
+ * 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_INDEXER_BALANCE_ERROR = "GET_INDEXER_BALANCE_ERROR",
+    GET_ERC20_BALANCE_ERROR = "GET_ERC20_BALANCE_ERROR",
+    GET_ERC721_BALANCE_ERROR = "GET_ERC721_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",
+    UNSUPPORTED_TOKEN_TYPE_ERROR = "UNSUPPORTED_TOKEN_TYPE_ERROR",
+    UNSUPPORTED_BALANCE_REQUIREMENT_ERROR = "UNSUPPORTED_BALANCE_REQUIREMENT_ERROR",
+    GET_ORDER_LISTING_ERROR = "GET_ORDER_LISTING_ERROR",
+    CANCEL_ORDER_LISTING_ERROR = "CANCEL_ORDER_LISTING_ERROR",
+    PREPARE_ORDER_LISTING_ERROR = "PREPARE_ORDER_LISTING_ERROR",
+    CREATE_ORDER_LISTING_ERROR = "CREATE_ORDER_LISTING_ERROR",
+    FULFILL_ORDER_LISTING_ERROR = "FULFILL_ORDER_LISTING_ERROR",
+    SWITCH_NETWORK_UNSUPPORTED = "SWITCH_NETWORK_UNSUPPORTED",
+    GET_ERC20_ALLOWANCE_ERROR = "GET_ERC20_ALLOWANCE_ERROR",
+    GET_ERC721_ALLOWANCE_ERROR = "GET_ERC721_ALLOWANCE_ERROR",
+    EXECUTE_APPROVAL_TRANSACTION_ERROR = "EXECUTE_APPROVAL_TRANSACTION_ERROR",
+    EXECUTE_FULFILLMENT_TRANSACTION_ERROR = "EXECUTE_FULFILLMENT_TRANSACTION_ERROR",
+    SIGN_MESSAGE_ERROR = "SIGN_MESSAGE_ERROR",
+    BRIDGE_GAS_ESTIMATE_ERROR = "BRIDGE_GAS_ESTIMATE_ERROR",
+    ORDER_FEE_ERROR = "ORDER_FEE_ERROR",
+    ITEM_REQUIREMENTS_ERROR = "ITEM_REQUIREMENTS_ERROR",
+    API_ERROR = "API_ERROR",
+    ORDER_EXPIRED_ERROR = "ORDER_EXPIRED_ERROR",
+    WIDGETS_SCRIPT_LOAD_ERROR = "WIDGETS_SCRIPT_LOAD_ERROR"
+}
+/**
+ * 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 checkout_sdk_d_AllowedNetworkConfig = AllowedNetworkConfig;
+type checkout_sdk_d_AvailableRoutingOptions = AvailableRoutingOptions;
+type checkout_sdk_d_BalanceDelta = BalanceDelta;
+type checkout_sdk_d_BridgeEventType = BridgeEventType;
+declare const checkout_sdk_d_BridgeEventType: typeof BridgeEventType;
+type checkout_sdk_d_BridgeFailed = BridgeFailed;
+type checkout_sdk_d_BridgeFundingStep = BridgeFundingStep;
+type checkout_sdk_d_BridgeSuccess = BridgeSuccess;
+type checkout_sdk_d_BridgeWidgetConfiguration = BridgeWidgetConfiguration;
+type checkout_sdk_d_BridgeWidgetParams = BridgeWidgetParams;
+type checkout_sdk_d_BuyOrder = BuyOrder;
+type checkout_sdk_d_BuyParams = BuyParams;
+type checkout_sdk_d_BuyResult = BuyResult;
+type checkout_sdk_d_BuyResultFailed = BuyResultFailed;
+type checkout_sdk_d_BuyResultInsufficientFunds = BuyResultInsufficientFunds;
+type checkout_sdk_d_BuyResultSuccess = BuyResultSuccess;
+type checkout_sdk_d_BuyToken = BuyToken;
+declare const checkout_sdk_d_CHECKOUT_API_BASE_URL: typeof CHECKOUT_API_BASE_URL;
+type checkout_sdk_d_CancelParams = CancelParams;
+type checkout_sdk_d_CancelResult = CancelResult;
+type checkout_sdk_d_CancelResultFailed = CancelResultFailed;
+type checkout_sdk_d_CancelResultSuccess = CancelResultSuccess;
+type checkout_sdk_d_ChainId = ChainId;
+declare const checkout_sdk_d_ChainId: typeof ChainId;
+type checkout_sdk_d_ChainName = ChainName;
+declare const checkout_sdk_d_ChainName: typeof ChainName;
+type checkout_sdk_d_CheckConnectionParams = CheckConnectionParams;
+type checkout_sdk_d_CheckConnectionResult = CheckConnectionResult;
+type checkout_sdk_d_Checkout = Checkout;
+declare const checkout_sdk_d_Checkout: typeof Checkout;
+type checkout_sdk_d_CheckoutConfiguration = CheckoutConfiguration;
+declare const checkout_sdk_d_CheckoutConfiguration: typeof CheckoutConfiguration;
+type checkout_sdk_d_CheckoutErrorType = CheckoutErrorType;
+declare const checkout_sdk_d_CheckoutErrorType: typeof CheckoutErrorType;
+type checkout_sdk_d_CheckoutModuleConfiguration = CheckoutModuleConfiguration;
+type checkout_sdk_d_CheckoutStatus = CheckoutStatus;
+declare const checkout_sdk_d_CheckoutStatus: typeof CheckoutStatus;
+type checkout_sdk_d_CheckoutWidgetsConfig = CheckoutWidgetsConfig;
+type checkout_sdk_d_ConnectEventType = ConnectEventType;
+declare const checkout_sdk_d_ConnectEventType: typeof ConnectEventType;
+type checkout_sdk_d_ConnectParams = ConnectParams;
+type checkout_sdk_d_ConnectResult = ConnectResult;
+type checkout_sdk_d_ConnectTargetLayer = ConnectTargetLayer;
+declare const checkout_sdk_d_ConnectTargetLayer: typeof ConnectTargetLayer;
+type checkout_sdk_d_ConnectWidgetConfiguration = ConnectWidgetConfiguration;
+type checkout_sdk_d_ConnectWidgetParams = ConnectWidgetParams;
+type checkout_sdk_d_ConnectionFailed = ConnectionFailed;
+type checkout_sdk_d_ConnectionSuccess = ConnectionSuccess;
+type checkout_sdk_d_DexConfig = DexConfig;
+type checkout_sdk_d_ERC20ItemRequirement = ERC20ItemRequirement;
+type checkout_sdk_d_ERC721Balance = ERC721Balance;
+type checkout_sdk_d_ERC721ItemRequirement = ERC721ItemRequirement;
+type checkout_sdk_d_ErrorType = ErrorType;
+type checkout_sdk_d_ExchangeType = ExchangeType;
+declare const checkout_sdk_d_ExchangeType: typeof ExchangeType;
+type checkout_sdk_d_FeePercentage = FeePercentage;
+type checkout_sdk_d_FeeToken = FeeToken;
+type checkout_sdk_d_FiatRampParams = FiatRampParams;
+type checkout_sdk_d_FulfillmentTransaction = FulfillmentTransaction;
+type checkout_sdk_d_FundingItem = FundingItem;
+type checkout_sdk_d_FundingRoute = FundingRoute;
+type checkout_sdk_d_FundingStep = FundingStep;
+type checkout_sdk_d_FundingStepType = FundingStepType;
+declare const checkout_sdk_d_FundingStepType: typeof FundingStepType;
+type checkout_sdk_d_GasAmount = GasAmount;
+type checkout_sdk_d_GasEstimateBridgeToL2Result = GasEstimateBridgeToL2Result;
+type checkout_sdk_d_GasEstimateParams = GasEstimateParams;
+type checkout_sdk_d_GasEstimateSwapResult = GasEstimateSwapResult;
+type checkout_sdk_d_GasEstimateTokenConfig = GasEstimateTokenConfig;
+type checkout_sdk_d_GasEstimateType = GasEstimateType;
+declare const checkout_sdk_d_GasEstimateType: typeof GasEstimateType;
+type checkout_sdk_d_GasToken = GasToken;
+type checkout_sdk_d_GasTokenType = GasTokenType;
+declare const checkout_sdk_d_GasTokenType: typeof GasTokenType;
+type checkout_sdk_d_GetAllBalancesParams = GetAllBalancesParams;
+type checkout_sdk_d_GetAllBalancesResult = GetAllBalancesResult;
+type checkout_sdk_d_GetBalanceParams = GetBalanceParams;
+type checkout_sdk_d_GetBalanceResult = GetBalanceResult;
+type checkout_sdk_d_GetNetworkAllowListParams = GetNetworkAllowListParams;
+type checkout_sdk_d_GetNetworkAllowListResult = GetNetworkAllowListResult;
+type checkout_sdk_d_GetNetworkParams = GetNetworkParams;
+type checkout_sdk_d_GetTokenAllowListParams = GetTokenAllowListParams;
+type checkout_sdk_d_GetTokenAllowListResult = GetTokenAllowListResult;
+type checkout_sdk_d_GetWalletAllowListParams = GetWalletAllowListParams;
+type checkout_sdk_d_GetWalletAllowListResult = GetWalletAllowListResult;
+type checkout_sdk_d_IMTBLWidgetEvents = IMTBLWidgetEvents;
+declare const checkout_sdk_d_IMTBLWidgetEvents: typeof IMTBLWidgetEvents;
+type checkout_sdk_d_IWidgetsFactory = IWidgetsFactory;
+type checkout_sdk_d_ItemBalance = ItemBalance;
+type checkout_sdk_d_ItemType = ItemType;
+declare const checkout_sdk_d_ItemType: typeof ItemType;
+type checkout_sdk_d_NativeItemRequirement = NativeItemRequirement;
+type checkout_sdk_d_NetworkFilter = NetworkFilter;
+type checkout_sdk_d_NetworkFilterTypes = NetworkFilterTypes;
+declare const checkout_sdk_d_NetworkFilterTypes: typeof NetworkFilterTypes;
+type checkout_sdk_d_NetworkInfo = NetworkInfo;
+type checkout_sdk_d_NoRouteOptions = NoRouteOptions;
+type checkout_sdk_d_NoRoutesFound = NoRoutesFound;
+type checkout_sdk_d_OnRampEventType = OnRampEventType;
+declare const checkout_sdk_d_OnRampEventType: typeof OnRampEventType;
+type checkout_sdk_d_OnRampFailed = OnRampFailed;
+type checkout_sdk_d_OnRampFundingStep = OnRampFundingStep;
+type checkout_sdk_d_OnRampProviderFees = OnRampProviderFees;
+type checkout_sdk_d_OnRampSuccess = OnRampSuccess;
+type checkout_sdk_d_OnRampWidgetParams = OnRampWidgetParams;
+type checkout_sdk_d_OnrampWidgetConfiguration = OnrampWidgetConfiguration;
+type checkout_sdk_d_OrchestrationEvent<KEventName extends keyof OrchestrationMapping> = OrchestrationEvent<KEventName>;
+type checkout_sdk_d_OrchestrationEventData = OrchestrationEventData;
+type checkout_sdk_d_OrchestrationEventType = OrchestrationEventType;
+declare const checkout_sdk_d_OrchestrationEventType: typeof OrchestrationEventType;
+type checkout_sdk_d_OrderFee = OrderFee;
+type checkout_sdk_d_ProviderEvent<KEventName extends keyof ProviderEventMapping> = ProviderEvent<KEventName>;
+type checkout_sdk_d_ProviderEventType = ProviderEventType;
+declare const checkout_sdk_d_ProviderEventType: typeof ProviderEventType;
+type checkout_sdk_d_ProviderUpdated = ProviderUpdated;
+type checkout_sdk_d_RemoteConfiguration = RemoteConfiguration;
+type checkout_sdk_d_RequestBridgeEvent = RequestBridgeEvent;
+type checkout_sdk_d_RequestConnectEvent = RequestConnectEvent;
+type checkout_sdk_d_RequestOnrampEvent = RequestOnrampEvent;
+type checkout_sdk_d_RequestSwapEvent = RequestSwapEvent;
+type checkout_sdk_d_RequestWalletEvent = RequestWalletEvent;
+type checkout_sdk_d_RoutesFound = RoutesFound;
+type checkout_sdk_d_RoutingOutcome = RoutingOutcome;
+type checkout_sdk_d_RoutingOutcomeType = RoutingOutcomeType;
+declare const checkout_sdk_d_RoutingOutcomeType: typeof RoutingOutcomeType;
+type checkout_sdk_d_SaleEventType = SaleEventType;
+declare const checkout_sdk_d_SaleEventType: typeof SaleEventType;
+type checkout_sdk_d_SaleFailed = SaleFailed;
+type checkout_sdk_d_SaleItem = SaleItem;
+type checkout_sdk_d_SaleSuccess = SaleSuccess;
+type checkout_sdk_d_SaleWidgetConfiguration = SaleWidgetConfiguration;
+type checkout_sdk_d_SaleWidgetParams = SaleWidgetParams;
+type checkout_sdk_d_SellOrder = SellOrder;
+type checkout_sdk_d_SellParams = SellParams;
+type checkout_sdk_d_SellResult = SellResult;
+type checkout_sdk_d_SellResultFailed = SellResultFailed;
+type checkout_sdk_d_SellResultInsufficientFunds = SellResultInsufficientFunds;
+type checkout_sdk_d_SellResultSuccess = SellResultSuccess;
+type checkout_sdk_d_SellToken = SellToken;
+type checkout_sdk_d_SemanticVersion = SemanticVersion;
+type checkout_sdk_d_SendTransactionParams = SendTransactionParams;
+type checkout_sdk_d_SendTransactionResult = SendTransactionResult;
+type checkout_sdk_d_SmartCheckoutInsufficient = SmartCheckoutInsufficient;
+type checkout_sdk_d_SmartCheckoutParams = SmartCheckoutParams;
+type checkout_sdk_d_SmartCheckoutResult = SmartCheckoutResult;
+type checkout_sdk_d_SmartCheckoutRouter = SmartCheckoutRouter;
+type checkout_sdk_d_SmartCheckoutSufficient = SmartCheckoutSufficient;
+type checkout_sdk_d_SwapEventType = SwapEventType;
+declare const checkout_sdk_d_SwapEventType: typeof SwapEventType;
+type checkout_sdk_d_SwapFailed = SwapFailed;
+type checkout_sdk_d_SwapFundingStep = SwapFundingStep;
+type checkout_sdk_d_SwapRejected = SwapRejected;
+type checkout_sdk_d_SwapSuccess = SwapSuccess;
+type checkout_sdk_d_SwapWidgetConfiguration = SwapWidgetConfiguration;
+type checkout_sdk_d_SwapWidgetParams = SwapWidgetParams;
+type checkout_sdk_d_SwitchNetworkParams = SwitchNetworkParams;
+type checkout_sdk_d_SwitchNetworkResult = SwitchNetworkResult;
+type checkout_sdk_d_TokenAmountEstimate = TokenAmountEstimate;
+type checkout_sdk_d_TokenBalance = TokenBalance;
+type checkout_sdk_d_TokenFilter = TokenFilter;
+type checkout_sdk_d_TokenFilterTypes = TokenFilterTypes;
+declare const checkout_sdk_d_TokenFilterTypes: typeof TokenFilterTypes;
+type checkout_sdk_d_TokenInfo = TokenInfo;
+type checkout_sdk_d_TransactionOrGasType = TransactionOrGasType;
+declare const checkout_sdk_d_TransactionOrGasType: typeof TransactionOrGasType;
+type checkout_sdk_d_TransactionRequirement = TransactionRequirement;
+type checkout_sdk_d_WalletDisconnectWalletEvent = WalletDisconnectWalletEvent;
+type checkout_sdk_d_WalletEventType = WalletEventType;
+declare const checkout_sdk_d_WalletEventType: typeof WalletEventType;
+type checkout_sdk_d_WalletFilter = WalletFilter;
+type checkout_sdk_d_WalletFilterTypes = WalletFilterTypes;
+declare const checkout_sdk_d_WalletFilterTypes: typeof WalletFilterTypes;
+type checkout_sdk_d_WalletInfo = WalletInfo;
+type checkout_sdk_d_WalletNetworkSwitchEvent = WalletNetworkSwitchEvent;
+type checkout_sdk_d_WalletProviderName = WalletProviderName;
+declare const checkout_sdk_d_WalletProviderName: typeof WalletProviderName;
+type checkout_sdk_d_WalletWidgetConfiguration = WalletWidgetConfiguration;
+type checkout_sdk_d_WalletWidgetParams = WalletWidgetParams;
+type checkout_sdk_d_Widget<T extends WidgetType> = Widget<T>;
+type checkout_sdk_d_WidgetConfiguration = WidgetConfiguration;
+type checkout_sdk_d_WidgetConfigurations = WidgetConfigurations;
+type checkout_sdk_d_WidgetEvent<T extends WidgetType, KEventName extends keyof WidgetEventData[T]> = WidgetEvent<T, KEventName>;
+type checkout_sdk_d_WidgetEventData = WidgetEventData;
+type checkout_sdk_d_WidgetEventTypes = WidgetEventTypes;
+type checkout_sdk_d_WidgetParameters = WidgetParameters;
+type checkout_sdk_d_WidgetProperties<T extends WidgetType> = WidgetProperties<T>;
+type checkout_sdk_d_WidgetTheme = WidgetTheme;
+declare const checkout_sdk_d_WidgetTheme: typeof WidgetTheme;
+type checkout_sdk_d_WidgetType = WidgetType;
+declare const checkout_sdk_d_WidgetType: typeof WidgetType;
+declare namespace checkout_sdk_d {
+  export {
+    checkout_sdk_d_AllowedNetworkConfig as AllowedNetworkConfig,
+    checkout_sdk_d_AvailableRoutingOptions as AvailableRoutingOptions,
+    checkout_sdk_d_BalanceDelta as BalanceDelta,
+    checkout_sdk_d_BridgeEventType as BridgeEventType,
+    checkout_sdk_d_BridgeFailed as BridgeFailed,
+    checkout_sdk_d_BridgeFundingStep as BridgeFundingStep,
+    checkout_sdk_d_BridgeSuccess as BridgeSuccess,
+    checkout_sdk_d_BridgeWidgetConfiguration as BridgeWidgetConfiguration,
+    checkout_sdk_d_BridgeWidgetParams as BridgeWidgetParams,
+    checkout_sdk_d_BuyOrder as BuyOrder,
+    checkout_sdk_d_BuyParams as BuyParams,
+    checkout_sdk_d_BuyResult as BuyResult,
+    checkout_sdk_d_BuyResultFailed as BuyResultFailed,
+    checkout_sdk_d_BuyResultInsufficientFunds as BuyResultInsufficientFunds,
+    checkout_sdk_d_BuyResultSuccess as BuyResultSuccess,
+    checkout_sdk_d_BuyToken as BuyToken,
+    checkout_sdk_d_CHECKOUT_API_BASE_URL as CHECKOUT_API_BASE_URL,
+    checkout_sdk_d_CancelParams as CancelParams,
+    checkout_sdk_d_CancelResult as CancelResult,
+    checkout_sdk_d_CancelResultFailed as CancelResultFailed,
+    checkout_sdk_d_CancelResultSuccess as CancelResultSuccess,
+    checkout_sdk_d_ChainId as ChainId,
+    checkout_sdk_d_ChainName as ChainName,
+    checkout_sdk_d_CheckConnectionParams as CheckConnectionParams,
+    checkout_sdk_d_CheckConnectionResult as CheckConnectionResult,
+    checkout_sdk_d_Checkout as Checkout,
+    checkout_sdk_d_CheckoutConfiguration as CheckoutConfiguration,
+    checkout_sdk_d_CheckoutErrorType as CheckoutErrorType,
+    checkout_sdk_d_CheckoutModuleConfiguration as CheckoutModuleConfiguration,
+    checkout_sdk_d_CheckoutStatus as CheckoutStatus,
+    checkout_sdk_d_CheckoutWidgetsConfig as CheckoutWidgetsConfig,
+    checkout_sdk_d_ConnectEventType as ConnectEventType,
+    checkout_sdk_d_ConnectParams as ConnectParams,
+    checkout_sdk_d_ConnectResult as ConnectResult,
+    checkout_sdk_d_ConnectTargetLayer as ConnectTargetLayer,
+    checkout_sdk_d_ConnectWidgetConfiguration as ConnectWidgetConfiguration,
+    checkout_sdk_d_ConnectWidgetParams as ConnectWidgetParams,
+    checkout_sdk_d_ConnectionFailed as ConnectionFailed,
+    checkout_sdk_d_ConnectionSuccess as ConnectionSuccess,
+    checkout_sdk_d_DexConfig as DexConfig,
+    checkout_sdk_d_ERC20ItemRequirement as ERC20ItemRequirement,
+    checkout_sdk_d_ERC721Balance as ERC721Balance,
+    checkout_sdk_d_ERC721ItemRequirement as ERC721ItemRequirement,
+    checkout_sdk_d_ErrorType as ErrorType,
+    checkout_sdk_d_ExchangeType as ExchangeType,
+    checkout_sdk_d_FeePercentage as FeePercentage,
+    checkout_sdk_d_FeeToken as FeeToken,
+    checkout_sdk_d_FiatRampParams as FiatRampParams,
+    checkout_sdk_d_FulfillmentTransaction as FulfillmentTransaction,
+    checkout_sdk_d_FundingItem as FundingItem,
+    checkout_sdk_d_FundingRoute as FundingRoute,
+    checkout_sdk_d_FundingStep as FundingStep,
+    checkout_sdk_d_FundingStepType as FundingStepType,
+    checkout_sdk_d_GasAmount as GasAmount,
+    checkout_sdk_d_GasEstimateBridgeToL2Result as GasEstimateBridgeToL2Result,
+    checkout_sdk_d_GasEstimateParams as GasEstimateParams,
+    checkout_sdk_d_GasEstimateSwapResult as GasEstimateSwapResult,
+    checkout_sdk_d_GasEstimateTokenConfig as GasEstimateTokenConfig,
+    checkout_sdk_d_GasEstimateType as GasEstimateType,
+    checkout_sdk_d_GasToken as GasToken,
+    checkout_sdk_d_GasTokenType as GasTokenType,
+    checkout_sdk_d_GetAllBalancesParams as GetAllBalancesParams,
+    checkout_sdk_d_GetAllBalancesResult as GetAllBalancesResult,
+    checkout_sdk_d_GetBalanceParams as GetBalanceParams,
+    checkout_sdk_d_GetBalanceResult as GetBalanceResult,
+    checkout_sdk_d_GetNetworkAllowListParams as GetNetworkAllowListParams,
+    checkout_sdk_d_GetNetworkAllowListResult as GetNetworkAllowListResult,
+    checkout_sdk_d_GetNetworkParams as GetNetworkParams,
+    checkout_sdk_d_GetTokenAllowListParams as GetTokenAllowListParams,
+    checkout_sdk_d_GetTokenAllowListResult as GetTokenAllowListResult,
+    checkout_sdk_d_GetWalletAllowListParams as GetWalletAllowListParams,
+    checkout_sdk_d_GetWalletAllowListResult as GetWalletAllowListResult,
+    checkout_sdk_d_IMTBLWidgetEvents as IMTBLWidgetEvents,
+    checkout_sdk_d_IWidgetsFactory as IWidgetsFactory,
+    checkout_sdk_d_ItemBalance as ItemBalance,
+    checkout_sdk_d_ItemType as ItemType,
+    checkout_sdk_d_NativeItemRequirement as NativeItemRequirement,
+    checkout_sdk_d_NetworkFilter as NetworkFilter,
+    checkout_sdk_d_NetworkFilterTypes as NetworkFilterTypes,
+    checkout_sdk_d_NetworkInfo as NetworkInfo,
+    checkout_sdk_d_NoRouteOptions as NoRouteOptions,
+    checkout_sdk_d_NoRoutesFound as NoRoutesFound,
+    checkout_sdk_d_OnRampEventType as OnRampEventType,
+    checkout_sdk_d_OnRampFailed as OnRampFailed,
+    checkout_sdk_d_OnRampFundingStep as OnRampFundingStep,
+    checkout_sdk_d_OnRampProviderFees as OnRampProviderFees,
+    checkout_sdk_d_OnRampSuccess as OnRampSuccess,
+    checkout_sdk_d_OnRampWidgetParams as OnRampWidgetParams,
+    checkout_sdk_d_OnrampWidgetConfiguration as OnrampWidgetConfiguration,
+    checkout_sdk_d_OrchestrationEvent as OrchestrationEvent,
+    checkout_sdk_d_OrchestrationEventData as OrchestrationEventData,
+    checkout_sdk_d_OrchestrationEventType as OrchestrationEventType,
+    checkout_sdk_d_OrderFee as OrderFee,
+    checkout_sdk_d_ProviderEvent as ProviderEvent,
+    checkout_sdk_d_ProviderEventType as ProviderEventType,
+    checkout_sdk_d_ProviderUpdated as ProviderUpdated,
+    checkout_sdk_d_RemoteConfiguration as RemoteConfiguration,
+    checkout_sdk_d_RequestBridgeEvent as RequestBridgeEvent,
+    checkout_sdk_d_RequestConnectEvent as RequestConnectEvent,
+    checkout_sdk_d_RequestOnrampEvent as RequestOnrampEvent,
+    checkout_sdk_d_RequestSwapEvent as RequestSwapEvent,
+    checkout_sdk_d_RequestWalletEvent as RequestWalletEvent,
+    checkout_sdk_d_RoutesFound as RoutesFound,
+    checkout_sdk_d_RoutingOutcome as RoutingOutcome,
+    checkout_sdk_d_RoutingOutcomeType as RoutingOutcomeType,
+    checkout_sdk_d_SaleEventType as SaleEventType,
+    checkout_sdk_d_SaleFailed as SaleFailed,
+    checkout_sdk_d_SaleItem as SaleItem,
+    checkout_sdk_d_SaleSuccess as SaleSuccess,
+    checkout_sdk_d_SaleWidgetConfiguration as SaleWidgetConfiguration,
+    checkout_sdk_d_SaleWidgetParams as SaleWidgetParams,
+    checkout_sdk_d_SellOrder as SellOrder,
+    checkout_sdk_d_SellParams as SellParams,
+    checkout_sdk_d_SellResult as SellResult,
+    checkout_sdk_d_SellResultFailed as SellResultFailed,
+    checkout_sdk_d_SellResultInsufficientFunds as SellResultInsufficientFunds,
+    checkout_sdk_d_SellResultSuccess as SellResultSuccess,
+    checkout_sdk_d_SellToken as SellToken,
+    checkout_sdk_d_SemanticVersion as SemanticVersion,
+    checkout_sdk_d_SendTransactionParams as SendTransactionParams,
+    checkout_sdk_d_SendTransactionResult as SendTransactionResult,
+    checkout_sdk_d_SmartCheckoutInsufficient as SmartCheckoutInsufficient,
+    checkout_sdk_d_SmartCheckoutParams as SmartCheckoutParams,
+    checkout_sdk_d_SmartCheckoutResult as SmartCheckoutResult,
+    checkout_sdk_d_SmartCheckoutRouter as SmartCheckoutRouter,
+    checkout_sdk_d_SmartCheckoutSufficient as SmartCheckoutSufficient,
+    checkout_sdk_d_SwapEventType as SwapEventType,
+    checkout_sdk_d_SwapFailed as SwapFailed,
+    checkout_sdk_d_SwapFundingStep as SwapFundingStep,
+    checkout_sdk_d_SwapRejected as SwapRejected,
+    checkout_sdk_d_SwapSuccess as SwapSuccess,
+    checkout_sdk_d_SwapWidgetConfiguration as SwapWidgetConfiguration,
+    checkout_sdk_d_SwapWidgetParams as SwapWidgetParams,
+    checkout_sdk_d_SwitchNetworkParams as SwitchNetworkParams,
+    checkout_sdk_d_SwitchNetworkResult as SwitchNetworkResult,
+    checkout_sdk_d_TokenAmountEstimate as TokenAmountEstimate,
+    checkout_sdk_d_TokenBalance as TokenBalance,
+    checkout_sdk_d_TokenFilter as TokenFilter,
+    checkout_sdk_d_TokenFilterTypes as TokenFilterTypes,
+    checkout_sdk_d_TokenInfo as TokenInfo,
+    checkout_sdk_d_TransactionOrGasType as TransactionOrGasType,
+    checkout_sdk_d_TransactionRequirement as TransactionRequirement,
+    checkout_sdk_d_WalletDisconnectWalletEvent as WalletDisconnectWalletEvent,
+    checkout_sdk_d_WalletEventType as WalletEventType,
+    checkout_sdk_d_WalletFilter as WalletFilter,
+    checkout_sdk_d_WalletFilterTypes as WalletFilterTypes,
+    checkout_sdk_d_WalletInfo as WalletInfo,
+    checkout_sdk_d_WalletNetworkSwitchEvent as WalletNetworkSwitchEvent,
+    checkout_sdk_d_WalletProviderName as WalletProviderName,
+    checkout_sdk_d_WalletWidgetConfiguration as WalletWidgetConfiguration,
+    checkout_sdk_d_WalletWidgetParams as WalletWidgetParams,
+    checkout_sdk_d_Widget as Widget,
+    checkout_sdk_d_WidgetConfiguration as WidgetConfiguration,
+    checkout_sdk_d_WidgetConfigurations as WidgetConfigurations,
+    checkout_sdk_d_WidgetEvent as WidgetEvent,
+    checkout_sdk_d_WidgetEventData as WidgetEventData,
+    checkout_sdk_d_WidgetEventTypes as WidgetEventTypes,
+    checkout_sdk_d_WidgetParameters as WidgetParameters,
+    checkout_sdk_d_WidgetProperties as WidgetProperties,
+    checkout_sdk_d_WidgetTheme as WidgetTheme,
+    checkout_sdk_d_WidgetType as WidgetType,
   };
 }
 
-export { blockchain_data_d as blockchainData, config_d as config, immutablex_client_d as immutablexClient, passport_d as passport, provider_d as provider };
+export { blockchain_data_d as blockchainData, checkout_sdk_d as checkoutSdk, config_d as config, immutablex_client_d as immutablexClient, orderbook_d as orderbook, passport_d as passport, provider_d as provider };