@imtbl/sdk 0.1.4-alpha → 0.1.5-alpha

package/dist/checkout_widgets.d.ts

@@ -1,4 +1,552 @@
 /// <reference path="global.d.ts" />
+/// <reference types="node" />
+declare type Bytes = ArrayLike<number>;
+declare type BytesLike = Bytes | string;
+interface Hexable {
+    toHexString(): string;
+}
+
+declare type BigNumberish = BigNumber | Bytes | bigint | string | number;
+declare class BigNumber implements Hexable {
+    readonly _hex: string;
+    readonly _isBigNumber: boolean;
+    constructor(constructorGuard: any, hex: string);
+    fromTwos(value: number): BigNumber;
+    toTwos(value: number): BigNumber;
+    abs(): BigNumber;
+    add(other: BigNumberish): BigNumber;
+    sub(other: BigNumberish): BigNumber;
+    div(other: BigNumberish): BigNumber;
+    mul(other: BigNumberish): BigNumber;
+    mod(other: BigNumberish): BigNumber;
+    pow(other: BigNumberish): BigNumber;
+    and(other: BigNumberish): BigNumber;
+    or(other: BigNumberish): BigNumber;
+    xor(other: BigNumberish): BigNumber;
+    mask(value: number): BigNumber;
+    shl(value: number): BigNumber;
+    shr(value: number): BigNumber;
+    eq(other: BigNumberish): boolean;
+    lt(other: BigNumberish): boolean;
+    lte(other: BigNumberish): boolean;
+    gt(other: BigNumberish): boolean;
+    gte(other: BigNumberish): boolean;
+    isNegative(): boolean;
+    isZero(): boolean;
+    toNumber(): number;
+    toBigInt(): bigint;
+    toString(): string;
+    toHexString(): string;
+    toJSON(key?: string): any;
+    static from(value: any): BigNumber;
+    static isBigNumber(value: any): value is BigNumber;
+}
+
+declare type Network$1 = {
+    name: string;
+    chainId: number;
+    ensAddress?: string;
+    _defaultProvider?: (providers: any, options?: any) => any;
+};
+declare type Networkish = Network$1 | string | number;
+
+declare type Deferrable<T> = {
+    [K in keyof T]: T[K] | Promise<T[K]>;
+};
+declare class Description<T = any> {
+    constructor(info: {
+        [K in keyof T]: T[K];
+    });
+}
+
+declare type AccessList = Array<{
+    address: string;
+    storageKeys: Array<string>;
+}>;
+declare type AccessListish = AccessList | Array<[string, Array<string>]> | Record<string, Array<string>>;
+interface Transaction {
+    hash?: string;
+    to?: string;
+    from?: string;
+    nonce: number;
+    gasLimit: BigNumber;
+    gasPrice?: BigNumber;
+    data: string;
+    value: BigNumber;
+    chainId: number;
+    r?: string;
+    s?: string;
+    v?: number;
+    type?: number | null;
+    accessList?: AccessList;
+    maxPriorityFeePerGas?: BigNumber;
+    maxFeePerGas?: BigNumber;
+}
+
+declare type ConnectionInfo = {
+    url: string;
+    headers?: {
+        [key: string]: string | number;
+    };
+    user?: string;
+    password?: string;
+    allowInsecureAuthentication?: boolean;
+    allowGzip?: boolean;
+    throttleLimit?: number;
+    throttleSlotInterval?: number;
+    throttleCallback?: (attempt: number, url: string) => Promise<boolean>;
+    skipFetchSetup?: boolean;
+    fetchOptions?: Record<string, string>;
+    errorPassThrough?: boolean;
+    timeout?: number;
+};
+interface OnceBlockable {
+    once(eventName: "block", handler: () => void): void;
+}
+
+declare type TransactionRequest = {
+    to?: string;
+    from?: string;
+    nonce?: BigNumberish;
+    gasLimit?: BigNumberish;
+    gasPrice?: BigNumberish;
+    data?: BytesLike;
+    value?: BigNumberish;
+    chainId?: number;
+    type?: number;
+    accessList?: AccessListish;
+    maxPriorityFeePerGas?: BigNumberish;
+    maxFeePerGas?: BigNumberish;
+    customData?: Record<string, any>;
+    ccipReadEnabled?: boolean;
+};
+interface TransactionResponse extends Transaction {
+    hash: string;
+    blockNumber?: number;
+    blockHash?: string;
+    timestamp?: number;
+    confirmations: number;
+    from: string;
+    raw?: string;
+    wait: (confirmations?: number) => Promise<TransactionReceipt>;
+}
+declare type BlockTag = string | number;
+interface _Block {
+    hash: string;
+    parentHash: string;
+    number: number;
+    timestamp: number;
+    nonce: string;
+    difficulty: number;
+    _difficulty: BigNumber;
+    gasLimit: BigNumber;
+    gasUsed: BigNumber;
+    miner: string;
+    extraData: string;
+    baseFeePerGas?: null | BigNumber;
+}
+interface Block extends _Block {
+    transactions: Array<string>;
+}
+interface BlockWithTransactions extends _Block {
+    transactions: Array<TransactionResponse>;
+}
+interface Log {
+    blockNumber: number;
+    blockHash: string;
+    transactionIndex: number;
+    removed: boolean;
+    address: string;
+    data: string;
+    topics: Array<string>;
+    transactionHash: string;
+    logIndex: number;
+}
+interface TransactionReceipt {
+    to: string;
+    from: string;
+    contractAddress: string;
+    transactionIndex: number;
+    root?: string;
+    gasUsed: BigNumber;
+    logsBloom: string;
+    blockHash: string;
+    transactionHash: string;
+    logs: Array<Log>;
+    blockNumber: number;
+    confirmations: number;
+    cumulativeGasUsed: BigNumber;
+    effectiveGasPrice: BigNumber;
+    byzantium: boolean;
+    type: number;
+    status?: number;
+}
+interface FeeData {
+    lastBaseFeePerGas: null | BigNumber;
+    maxFeePerGas: null | BigNumber;
+    maxPriorityFeePerGas: null | BigNumber;
+    gasPrice: null | BigNumber;
+}
+interface EventFilter {
+    address?: string;
+    topics?: Array<string | Array<string> | null>;
+}
+interface Filter extends EventFilter {
+    fromBlock?: BlockTag;
+    toBlock?: BlockTag;
+}
+interface FilterByBlockHash extends EventFilter {
+    blockHash?: string;
+}
+declare abstract class ForkEvent extends Description {
+    readonly expiry: number;
+    readonly _isForkEvent?: boolean;
+    static isForkEvent(value: any): value is ForkEvent;
+}
+declare type EventType = string | Array<string | Array<string>> | EventFilter | ForkEvent;
+declare type Listener = (...args: Array<any>) => void;
+declare abstract class Provider implements OnceBlockable {
+    abstract getNetwork(): Promise<Network$1>;
+    abstract getBlockNumber(): Promise<number>;
+    abstract getGasPrice(): Promise<BigNumber>;
+    getFeeData(): Promise<FeeData>;
+    abstract getBalance(addressOrName: string | Promise<string>, blockTag?: BlockTag | Promise<BlockTag>): Promise<BigNumber>;
+    abstract getTransactionCount(addressOrName: string | Promise<string>, blockTag?: BlockTag | Promise<BlockTag>): Promise<number>;
+    abstract getCode(addressOrName: string | Promise<string>, blockTag?: BlockTag | Promise<BlockTag>): Promise<string>;
+    abstract getStorageAt(addressOrName: string | Promise<string>, position: BigNumberish | Promise<BigNumberish>, blockTag?: BlockTag | Promise<BlockTag>): Promise<string>;
+    abstract sendTransaction(signedTransaction: string | Promise<string>): Promise<TransactionResponse>;
+    abstract call(transaction: Deferrable<TransactionRequest>, blockTag?: BlockTag | Promise<BlockTag>): Promise<string>;
+    abstract estimateGas(transaction: Deferrable<TransactionRequest>): Promise<BigNumber>;
+    abstract getBlock(blockHashOrBlockTag: BlockTag | string | Promise<BlockTag | string>): Promise<Block>;
+    abstract getBlockWithTransactions(blockHashOrBlockTag: BlockTag | string | Promise<BlockTag | string>): Promise<BlockWithTransactions>;
+    abstract getTransaction(transactionHash: string): Promise<TransactionResponse>;
+    abstract getTransactionReceipt(transactionHash: string): Promise<TransactionReceipt>;
+    abstract getLogs(filter: Filter): Promise<Array<Log>>;
+    abstract resolveName(name: string | Promise<string>): Promise<null | string>;
+    abstract lookupAddress(address: string | Promise<string>): Promise<null | string>;
+    abstract on(eventName: EventType, listener: Listener): Provider;
+    abstract once(eventName: EventType, listener: Listener): Provider;
+    abstract emit(eventName: EventType, ...args: Array<any>): boolean;
+    abstract listenerCount(eventName?: EventType): number;
+    abstract listeners(eventName?: EventType): Array<Listener>;
+    abstract off(eventName: EventType, listener?: Listener): Provider;
+    abstract removeAllListeners(eventName?: EventType): Provider;
+    addListener(eventName: EventType, listener: Listener): Provider;
+    removeListener(eventName: EventType, listener: Listener): Provider;
+    abstract waitForTransaction(transactionHash: string, confirmations?: number, timeout?: number): Promise<TransactionReceipt>;
+    readonly _isProvider: boolean;
+    constructor();
+    static isProvider(value: any): value is Provider;
+}
+
+declare type FormatFunc = (value: any) => any;
+declare type FormatFuncs = {
+    [key: string]: FormatFunc;
+};
+declare type Formats = {
+    transaction: FormatFuncs;
+    transactionRequest: FormatFuncs;
+    receipt: FormatFuncs;
+    receiptLog: FormatFuncs;
+    block: FormatFuncs;
+    blockWithTransactions: FormatFuncs;
+    filter: FormatFuncs;
+    filterLog: FormatFuncs;
+};
+declare class Formatter {
+    readonly formats: Formats;
+    constructor();
+    getDefaultFormats(): Formats;
+    accessList(accessList: Array<any>): AccessList;
+    number(number: any): number;
+    type(number: any): number;
+    bigNumber(value: any): BigNumber;
+    boolean(value: any): boolean;
+    hex(value: any, strict?: boolean): string;
+    data(value: any, strict?: boolean): string;
+    address(value: any): string;
+    callAddress(value: any): string;
+    contractAddress(value: any): string;
+    blockTag(blockTag: any): string;
+    hash(value: any, strict?: boolean): string;
+    difficulty(value: any): number;
+    uint256(value: any): string;
+    _block(value: any, format: any): Block;
+    block(value: any): Block;
+    blockWithTransactions(value: any): Block;
+    transactionRequest(value: any): any;
+    transactionResponse(transaction: any): TransactionResponse;
+    transaction(value: any): any;
+    receiptLog(value: any): any;
+    receipt(value: any): TransactionReceipt;
+    topics(value: any): any;
+    filter(value: any): any;
+    filterLog(value: any): any;
+    static check(format: {
+        [name: string]: FormatFunc;
+    }, object: any): any;
+    static allowNull(format: FormatFunc, nullValue?: any): FormatFunc;
+    static allowFalsish(format: FormatFunc, replaceValue: any): FormatFunc;
+    static arrayOf(format: FormatFunc): FormatFunc;
+}
+
+declare class Event$1 {
+    readonly listener: Listener;
+    readonly once: boolean;
+    readonly tag: string;
+    _lastBlockNumber: number;
+    _inflight: boolean;
+    constructor(tag: string, listener: Listener, once: boolean);
+    get event(): EventType;
+    get type(): string;
+    get hash(): string;
+    get filter(): Filter;
+    pollable(): boolean;
+}
+interface EnsResolver {
+    readonly name: string;
+    readonly address: string;
+    getAddress(coinType?: 60): Promise<null | string>;
+    getContentHash(): Promise<null | string>;
+    getText(key: string): Promise<null | string>;
+}
+interface EnsProvider {
+    resolveName(name: string): Promise<null | string>;
+    lookupAddress(address: string): Promise<null | string>;
+    getResolver(name: string): Promise<null | EnsResolver>;
+}
+interface Avatar {
+    url: string;
+    linkage: Array<{
+        type: string;
+        content: string;
+    }>;
+}
+declare class Resolver implements EnsResolver {
+    readonly provider: BaseProvider;
+    readonly name: string;
+    readonly address: string;
+    readonly _resolvedAddress: null | string;
+    _supportsEip2544: null | Promise<boolean>;
+    constructor(provider: BaseProvider, address: string, name: string, resolvedAddress?: string);
+    supportsWildcard(): Promise<boolean>;
+    _fetch(selector: string, parameters?: string): Promise<null | string>;
+    _fetchBytes(selector: string, parameters?: string): Promise<null | string>;
+    _getAddress(coinType: number, hexBytes: string): string;
+    getAddress(coinType?: number): Promise<string>;
+    getAvatar(): Promise<null | Avatar>;
+    getContentHash(): Promise<string>;
+    getText(key: string): Promise<string>;
+}
+declare class BaseProvider extends Provider implements EnsProvider {
+    _networkPromise: Promise<Network$1>;
+    _network: Network$1;
+    _events: Array<Event$1>;
+    formatter: Formatter;
+    _emitted: {
+        [eventName: string]: number | "pending";
+    };
+    _pollingInterval: number;
+    _poller: NodeJS.Timer;
+    _bootstrapPoll: NodeJS.Timer;
+    _lastBlockNumber: number;
+    _maxFilterBlockRange: number;
+    _fastBlockNumber: number;
+    _fastBlockNumberPromise: Promise<number>;
+    _fastQueryDate: number;
+    _maxInternalBlockNumber: number;
+    _internalBlockNumber: Promise<{
+        blockNumber: number;
+        reqTime: number;
+        respTime: number;
+    }>;
+    readonly anyNetwork: boolean;
+    disableCcipRead: boolean;
+    /**
+     *  ready
+     *
+     *  A Promise<Network> that resolves only once the provider is ready.
+     *
+     *  Sub-classes that call the super with a network without a chainId
+     *  MUST set this. Standard named networks have a known chainId.
+     *
+     */
+    constructor(network: Networkish | Promise<Network$1>);
+    _ready(): Promise<Network$1>;
+    get ready(): Promise<Network$1>;
+    static getFormatter(): Formatter;
+    static getNetwork(network: Networkish): Network$1;
+    ccipReadFetch(tx: Transaction, calldata: string, urls: Array<string>): Promise<null | string>;
+    _getInternalBlockNumber(maxAge: number): Promise<number>;
+    poll(): Promise<void>;
+    resetEventsBlock(blockNumber: number): void;
+    get network(): Network$1;
+    detectNetwork(): Promise<Network$1>;
+    getNetwork(): Promise<Network$1>;
+    get blockNumber(): number;
+    get polling(): boolean;
+    set polling(value: boolean);
+    get pollingInterval(): number;
+    set pollingInterval(value: number);
+    _getFastBlockNumber(): Promise<number>;
+    _setFastBlockNumber(blockNumber: number): void;
+    waitForTransaction(transactionHash: string, confirmations?: number, timeout?: number): Promise<TransactionReceipt>;
+    _waitForTransaction(transactionHash: string, confirmations: number, timeout: number, replaceable: {
+        data: string;
+        from: string;
+        nonce: number;
+        to: string;
+        value: BigNumber;
+        startBlock: number;
+    }): Promise<TransactionReceipt>;
+    getBlockNumber(): Promise<number>;
+    getGasPrice(): Promise<BigNumber>;
+    getBalance(addressOrName: string | Promise<string>, blockTag?: BlockTag | Promise<BlockTag>): Promise<BigNumber>;
+    getTransactionCount(addressOrName: string | Promise<string>, blockTag?: BlockTag | Promise<BlockTag>): Promise<number>;
+    getCode(addressOrName: string | Promise<string>, blockTag?: BlockTag | Promise<BlockTag>): Promise<string>;
+    getStorageAt(addressOrName: string | Promise<string>, position: BigNumberish | Promise<BigNumberish>, blockTag?: BlockTag | Promise<BlockTag>): Promise<string>;
+    _wrapTransaction(tx: Transaction, hash?: string, startBlock?: number): TransactionResponse;
+    sendTransaction(signedTransaction: string | Promise<string>): Promise<TransactionResponse>;
+    _getTransactionRequest(transaction: Deferrable<TransactionRequest>): Promise<Transaction>;
+    _getFilter(filter: Filter | FilterByBlockHash | Promise<Filter | FilterByBlockHash>): Promise<Filter | FilterByBlockHash>;
+    _call(transaction: TransactionRequest, blockTag: BlockTag, attempt: number): Promise<string>;
+    call(transaction: Deferrable<TransactionRequest>, blockTag?: BlockTag | Promise<BlockTag>): Promise<string>;
+    estimateGas(transaction: Deferrable<TransactionRequest>): Promise<BigNumber>;
+    _getAddress(addressOrName: string | Promise<string>): Promise<string>;
+    _getBlock(blockHashOrBlockTag: BlockTag | string | Promise<BlockTag | string>, includeTransactions?: boolean): Promise<Block | BlockWithTransactions>;
+    getBlock(blockHashOrBlockTag: BlockTag | string | Promise<BlockTag | string>): Promise<Block>;
+    getBlockWithTransactions(blockHashOrBlockTag: BlockTag | string | Promise<BlockTag | string>): Promise<BlockWithTransactions>;
+    getTransaction(transactionHash: string | Promise<string>): Promise<TransactionResponse>;
+    getTransactionReceipt(transactionHash: string | Promise<string>): Promise<TransactionReceipt>;
+    getLogs(filter: Filter | FilterByBlockHash | Promise<Filter | FilterByBlockHash>): Promise<Array<Log>>;
+    getEtherPrice(): Promise<number>;
+    _getBlockTag(blockTag: BlockTag | Promise<BlockTag>): Promise<BlockTag>;
+    getResolver(name: string): Promise<null | Resolver>;
+    _getResolver(name: string, operation?: string): Promise<string>;
+    resolveName(name: string | Promise<string>): Promise<null | string>;
+    lookupAddress(address: string | Promise<string>): Promise<null | string>;
+    getAvatar(nameOrAddress: string): Promise<null | string>;
+    perform(method: string, params: any): Promise<any>;
+    _startEvent(event: Event$1): void;
+    _stopEvent(event: Event$1): void;
+    _addEventListener(eventName: EventType, listener: Listener, once: boolean): this;
+    on(eventName: EventType, listener: Listener): this;
+    once(eventName: EventType, listener: Listener): this;
+    emit(eventName: EventType, ...args: Array<any>): boolean;
+    listenerCount(eventName?: EventType): number;
+    listeners(eventName?: EventType): Array<Listener>;
+    off(eventName: EventType, listener?: Listener): this;
+    removeAllListeners(eventName?: EventType): this;
+}
+
+interface TypedDataDomain {
+    name?: string;
+    version?: string;
+    chainId?: BigNumberish;
+    verifyingContract?: string;
+    salt?: BytesLike;
+}
+interface TypedDataField {
+    name: string;
+    type: string;
+}
+interface TypedDataSigner {
+    _signTypedData(domain: TypedDataDomain, types: Record<string, Array<TypedDataField>>, value: Record<string, any>): Promise<string>;
+}
+declare abstract class Signer {
+    readonly provider?: Provider;
+    abstract getAddress(): Promise<string>;
+    abstract signMessage(message: Bytes | string): Promise<string>;
+    abstract signTransaction(transaction: Deferrable<TransactionRequest>): Promise<string>;
+    abstract connect(provider: Provider): Signer;
+    readonly _isSigner: boolean;
+    constructor();
+    getBalance(blockTag?: BlockTag): Promise<BigNumber>;
+    getTransactionCount(blockTag?: BlockTag): Promise<number>;
+    estimateGas(transaction: Deferrable<TransactionRequest>): Promise<BigNumber>;
+    call(transaction: Deferrable<TransactionRequest>, blockTag?: BlockTag): Promise<string>;
+    sendTransaction(transaction: Deferrable<TransactionRequest>): Promise<TransactionResponse>;
+    getChainId(): Promise<number>;
+    getGasPrice(): Promise<BigNumber>;
+    getFeeData(): Promise<FeeData>;
+    resolveName(name: string): Promise<string>;
+    checkTransaction(transaction: Deferrable<TransactionRequest>): Deferrable<TransactionRequest>;
+    populateTransaction(transaction: Deferrable<TransactionRequest>): Promise<TransactionRequest>;
+    _checkProvider(operation?: string): void;
+    static isSigner(value: any): value is Signer;
+}
+
+declare class JsonRpcSigner extends Signer implements TypedDataSigner {
+    readonly provider: JsonRpcProvider;
+    _index: number;
+    _address: string;
+    constructor(constructorGuard: any, provider: JsonRpcProvider, addressOrIndex?: string | number);
+    connect(provider: Provider): JsonRpcSigner;
+    connectUnchecked(): JsonRpcSigner;
+    getAddress(): Promise<string>;
+    sendUncheckedTransaction(transaction: Deferrable<TransactionRequest>): Promise<string>;
+    signTransaction(transaction: Deferrable<TransactionRequest>): Promise<string>;
+    sendTransaction(transaction: Deferrable<TransactionRequest>): Promise<TransactionResponse>;
+    signMessage(message: Bytes | string): Promise<string>;
+    _legacySignMessage(message: Bytes | string): Promise<string>;
+    _signTypedData(domain: TypedDataDomain, types: Record<string, Array<TypedDataField>>, value: Record<string, any>): Promise<string>;
+    unlock(password: string): Promise<boolean>;
+}
+declare class UncheckedJsonRpcSigner extends JsonRpcSigner {
+    sendTransaction(transaction: Deferrable<TransactionRequest>): Promise<TransactionResponse>;
+}
+declare class JsonRpcProvider extends BaseProvider {
+    readonly connection: ConnectionInfo;
+    _pendingFilter: Promise<number>;
+    _nextId: number;
+    _eventLoopCache: Record<string, Promise<any>>;
+    get _cache(): Record<string, Promise<any>>;
+    constructor(url?: ConnectionInfo | string, network?: Networkish);
+    static defaultUrl(): string;
+    detectNetwork(): Promise<Network$1>;
+    _uncachedDetectNetwork(): Promise<Network$1>;
+    getSigner(addressOrIndex?: string | number): JsonRpcSigner;
+    getUncheckedSigner(addressOrIndex?: string | number): UncheckedJsonRpcSigner;
+    listAccounts(): Promise<Array<string>>;
+    send(method: string, params: Array<any>): Promise<any>;
+    prepareRequest(method: string, params: any): [string, Array<any>];
+    perform(method: string, params: any): Promise<any>;
+    _startEvent(event: Event$1): void;
+    _startPending(): void;
+    _stopEvent(event: Event$1): void;
+    static hexlifyTransaction(transaction: TransactionRequest, allowExtra?: {
+        [key: string]: boolean;
+    }): {
+        [key: string]: string | AccessList;
+    };
+}
+
+declare type ExternalProvider = {
+    isMetaMask?: boolean;
+    isStatus?: boolean;
+    host?: string;
+    path?: string;
+    sendAsync?: (request: {
+        method: string;
+        params?: Array<any>;
+    }, callback: (error: any, response: any) => void) => void;
+    send?: (request: {
+        method: string;
+        params?: Array<any>;
+    }, callback: (error: any, response: any) => void) => void;
+    request?: (request: {
+        method: string;
+        params?: Array<any>;
+    }) => Promise<any>;
+};
+declare type JsonRpcFetchFunc = (method: string, params?: Array<any>) => Promise<any>;
+declare class Web3Provider extends JsonRpcProvider {
+    readonly provider: ExternalProvider;
+    readonly jsonRpcFetchFunc: JsonRpcFetchFunc;
+    constructor(provider: ExternalProvider | JsonRpcFetchFunc, network?: Networkish);
+    send(method: string, params: Array<any>): Promise<any>;
+}
+
 /**
  * Enum representing the list of default supported providers.
  */
@@ -14454,5 +15002,56 @@ declare enum WidgetTheme {
     DARK = "dark",
     CUSTOM = "custom"
 }
+declare enum WidgetConnectionProviders {
+    METAMASK = "metamask"
+}
+declare enum CheckoutWidgetTagNames {
+    CONNECT = "imtbl-connect",
+    WALLET = "imtbl-wallet",
+    SWAP = "imtbl-swap",
+    BUY = "imtbl-buy",
+    BRIDGE = "imtbl-bridge",
+    EXAMPLe = "imtbl-example"
+}
+type CheckoutWidgetsConfig = {
+    theme?: WidgetTheme;
+};
+interface BridgeReactProps {
+    providerPreference: WidgetConnectionProviders;
+    fromContractAddress?: string;
+    amount?: string;
+    fromNetwork?: Network;
+}
+declare function BridgeReact(props: BridgeReactProps): JSX.Element;
+interface BuyReactProps {
+    providerPreference: WidgetConnectionProviders;
+    orderId: string;
+}
+declare function BuyReact(props: BuyReactProps): JSX.Element;
+declare function CheckoutWidgets(config?: CheckoutWidgetsConfig): void;
+declare function UpdateConfig(config: CheckoutWidgetsConfig): void;
+declare function SetProvider(tagName: CheckoutWidgetTagNames, provider: Web3Provider | null): void;
+interface ConnectReactProps {
+    providerPreference?: WidgetConnectionProviders;
+}
+declare function ConnectReact(props: ConnectReactProps): JSX.Element;
+interface SwapReactProps {
+    providerPreference: WidgetConnectionProviders;
+    fromContractAddress?: string;
+    amount?: string;
+    toContractAddress?: string;
+}
+declare function SwapReact(props: SwapReactProps): JSX.Element;
+interface WalletReactProps {
+    providerPreference?: WidgetConnectionProviders;
+}
+declare function WalletReact(props: WalletReactProps): JSX.Element;
+interface ExampleReactProps {
+    providerPreference: WidgetConnectionProviders;
+    fromContractAddress?: string;
+    amount?: string;
+    fromNetwork?: Network;
+}
+declare function ExampleReact(props: ExampleReactProps): JSX.Element;
 
-export { BridgeEvent, BridgeEventType, BridgeFailed, BridgeSuccess, BuyClose, BuyEvent, BuyEventType, BuyFailed, BuyNotConnected, BuySuccess, ConnectEvent, ConnectEventType, ConnectionFailed, ConnectionProviders, ConnectionSuccess, IMTBLWidgetEvents, ImtblBridgeProps, ImtblBuyProps, ImtblConnectProps, ImtblExampleProps, ImtblInnerWidgetExampleProps, ImtblOuterWidgetExampleProps, ImtblSwapProps, ImtblTransitionExampleProps, ImtblWalletProps, Network, SwapEvent, SwapEventType, SwapFailed, SwapSuccess, WalletEvent, WalletEventType, WalletNetworkSwitchEvent, WidgetTheme };
+export { BridgeEvent, BridgeEventType, BridgeFailed, BridgeReact, BridgeReactProps, BridgeSuccess, BuyClose, BuyEvent, BuyEventType, BuyFailed, BuyNotConnected, BuyReact, BuyReactProps, BuySuccess, CheckoutWidgetTagNames, CheckoutWidgets, CheckoutWidgetsConfig, ConnectEvent, ConnectEventType, ConnectReact, ConnectReactProps, ConnectionFailed, ConnectionSuccess, ExampleReact, ExampleReactProps, IMTBLWidgetEvents, ImtblBridgeProps, ImtblBuyProps, ImtblConnectProps, ImtblExampleProps, ImtblInnerWidgetExampleProps, ImtblOuterWidgetExampleProps, ImtblSwapProps, ImtblTransitionExampleProps, ImtblWalletProps, Network, SetProvider, SwapEvent, SwapEventType, SwapFailed, SwapReact, SwapReactProps, SwapSuccess, UpdateConfig, WalletEvent, WalletEventType, WalletNetworkSwitchEvent, WalletReact, WalletReactProps, WidgetConnectionProviders, WidgetTheme };