import { TAddress } from '../../../models/TAddress';
import { TAccount } from '../../../models/TAccount';
import { ClientEventsStream, TClientEventsStreamData } from '../../../clients/ClientEventsStream';
import { ContractBase } from '../../../contracts/ContractBase';
import { ContractStorageReaderBase } from '../../../contracts/ContractStorageReaderBase';
import { TxWriter } from '../../../txs/TxWriter';
import { ITxLogItem } from '../../../txs/receipt/ITxLogItem';
import { Web3Client } from '../../../clients/Web3Client';
import { IBlockchainExplorer } from '../../../explorer/IBlockchainExplorer';
import { SubjectStream } from '../../../class/SubjectStream';
import type { TAbiItem } from '../../../types/TAbi';
import type { TEth } from '../../../models/TEth';
import type { TOverrideReturns } from '../../../utils/types';
export declare class AmmRouterV2Contract extends ContractBase {
    address: TEth.Address;
    client: Web3Client;
    explorer: IBlockchainExplorer;
    constructor(address?: TEth.Address, client?: Web3Client, explorer?: IBlockchainExplorer);
    Types: TAmmRouterV2ContractTypes;
    $meta: {
        class: string;
    };
    $constructor(deployer: TSender, _factory: TAddress, _WETH: TAddress): Promise<TxWriter>;
    WETH(): Promise<TAddress>;
    addLiquidity(sender: TSender, tokenA: TAddress, tokenB: TAddress, amountADesired: bigint, amountBDesired: bigint, amountAMin: bigint, amountBMin: bigint, to: TAddress, deadline: bigint): Promise<TxWriter>;
    addLiquidityETH(sender: TSender, token: TAddress, amountTokenDesired: bigint, amountTokenMin: bigint, amountETHMin: bigint, to: TAddress, deadline: bigint): Promise<TxWriter>;
    factory(): Promise<TAddress>;
    getAmountIn(amountOut: bigint, reserveIn: bigint, reserveOut: bigint): Promise<bigint>;
    getAmountOut(amountIn: bigint, reserveIn: bigint, reserveOut: bigint): Promise<bigint>;
    getAmountsIn(amountOut: bigint, path: TAddress[]): Promise<bigint[]>;
    getAmountsOut(amountIn: bigint, path: TAddress[]): Promise<bigint[]>;
    quote(amountA: bigint, reserveA: bigint, reserveB: bigint): Promise<bigint>;
    removeLiquidity(sender: TSender, tokenA: TAddress, tokenB: TAddress, liquidity: bigint, amountAMin: bigint, amountBMin: bigint, to: TAddress, deadline: bigint): Promise<TxWriter>;
    removeLiquidityETH(sender: TSender, token: TAddress, liquidity: bigint, amountTokenMin: bigint, amountETHMin: bigint, to: TAddress, deadline: bigint): Promise<TxWriter>;
    removeLiquidityETHSupportingFeeOnTransferTokens(sender: TSender, token: TAddress, liquidity: bigint, amountTokenMin: bigint, amountETHMin: bigint, to: TAddress, deadline: bigint): Promise<TxWriter>;
    removeLiquidityETHWithPermit(sender: TSender, token: TAddress, liquidity: bigint, amountTokenMin: bigint, amountETHMin: bigint, to: TAddress, deadline: bigint, approveMax: boolean, v: number, r: TEth.Hex, s: TEth.Hex): Promise<TxWriter>;
    removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(sender: TSender, token: TAddress, liquidity: bigint, amountTokenMin: bigint, amountETHMin: bigint, to: TAddress, deadline: bigint, approveMax: boolean, v: number, r: TEth.Hex, s: TEth.Hex): Promise<TxWriter>;
    removeLiquidityWithPermit(sender: TSender, tokenA: TAddress, tokenB: TAddress, liquidity: bigint, amountAMin: bigint, amountBMin: bigint, to: TAddress, deadline: bigint, approveMax: boolean, v: number, r: TEth.Hex, s: TEth.Hex): Promise<TxWriter>;
    swapETHForExactTokens(sender: TSender, amountOut: bigint, path: TAddress[], to: TAddress, deadline: bigint): Promise<TxWriter>;
    swapExactETHForTokens(sender: TSender, amountOutMin: bigint, path: TAddress[], to: TAddress, deadline: bigint): Promise<TxWriter>;
    swapExactETHForTokensSupportingFeeOnTransferTokens(sender: TSender, amountOutMin: bigint, path: TAddress[], to: TAddress, deadline: bigint): Promise<TxWriter>;
    swapExactTokensForETH(sender: TSender, amountIn: bigint, amountOutMin: bigint, path: TAddress[], to: TAddress, deadline: bigint): Promise<TxWriter>;
    swapExactTokensForETHSupportingFeeOnTransferTokens(sender: TSender, amountIn: bigint, amountOutMin: bigint, path: TAddress[], to: TAddress, deadline: bigint): Promise<TxWriter>;
    swapExactTokensForTokens(sender: TSender, amountIn: bigint, amountOutMin: bigint, path: TAddress[], to: TAddress, deadline: bigint): Promise<TxWriter>;
    swapExactTokensForTokensSupportingFeeOnTransferTokens(sender: TSender, amountIn: bigint, amountOutMin: bigint, path: TAddress[], to: TAddress, deadline: bigint): Promise<TxWriter>;
    swapTokensForExactETH(sender: TSender, amountOut: bigint, amountInMax: bigint, path: TAddress[], to: TAddress, deadline: bigint): Promise<TxWriter>;
    swapTokensForExactTokens(sender: TSender, amountOut: bigint, amountInMax: bigint, path: TAddress[], to: TAddress, deadline: bigint): Promise<TxWriter>;
    $call(): IAmmRouterV2ContractTxCaller;
    $signed(): TOverrideReturns<IAmmRouterV2ContractTxCaller, Promise<{
        signed: TEth.Hex;
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
    }>>;
    $data(): IAmmRouterV2ContractTxData;
    $gas(): TOverrideReturns<IAmmRouterV2ContractTxCaller, Promise<{
        gas?: bigint;
        price?: bigint;
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
    }>>;
    onTransaction<TMethod extends keyof TAmmRouterV2ContractTypes['Methods']>(method: TMethod, options: Parameters<ContractBase['$onTransaction']>[0]): SubjectStream<{
        tx: TEth.Tx;
        block: TEth.Block<TEth.Hex>;
        calldata: {
            method: TMethod;
            arguments: TAmmRouterV2ContractTypes['Methods'][TMethod]['arguments'];
        };
    }>;
    onLog(event: keyof TEvents, cb?: (event: TClientEventsStreamData) => void): ClientEventsStream<TClientEventsStreamData>;
    getPastLogs<TEventName extends keyof TEvents>(events: TEventName[], options?: TEventLogOptions<TEventParams<TEventName>>): Promise<ITxLogItem<TEventParams<TEventName>, TEventName>[]>;
    getPastLogs<TEventName extends keyof TEvents>(event: TEventName, options?: TEventLogOptions<TEventParams<TEventName>>): Promise<ITxLogItem<TEventParams<TEventName>, TEventName>[]>;
    abi: TAbiItem[];
    storage: AmmRouterV2ContractStorageReader;
}
type TSender = TAccount & {
    value?: string | number | bigint;
};
type TEventLogOptions<TParams> = {
    fromBlock?: number | Date;
    toBlock?: number | Date;
    params?: TParams;
};
export type TAmmRouterV2ContractTypes = {
    Events: {};
    Methods: {
        WETH: {
            method: "WETH";
            arguments: [];
        };
        addLiquidity: {
            method: "addLiquidity";
            arguments: [tokenA: TAddress, tokenB: TAddress, amountADesired: bigint, amountBDesired: bigint, amountAMin: bigint, amountBMin: bigint, to: TAddress, deadline: bigint];
        };
        addLiquidityETH: {
            method: "addLiquidityETH";
            arguments: [token: TAddress, amountTokenDesired: bigint, amountTokenMin: bigint, amountETHMin: bigint, to: TAddress, deadline: bigint];
        };
        factory: {
            method: "factory";
            arguments: [];
        };
        getAmountIn: {
            method: "getAmountIn";
            arguments: [amountOut: bigint, reserveIn: bigint, reserveOut: bigint];
        };
        getAmountOut: {
            method: "getAmountOut";
            arguments: [amountIn: bigint, reserveIn: bigint, reserveOut: bigint];
        };
        getAmountsIn: {
            method: "getAmountsIn";
            arguments: [amountOut: bigint, path: TAddress[]];
        };
        getAmountsOut: {
            method: "getAmountsOut";
            arguments: [amountIn: bigint, path: TAddress[]];
        };
        quote: {
            method: "quote";
            arguments: [amountA: bigint, reserveA: bigint, reserveB: bigint];
        };
        removeLiquidity: {
            method: "removeLiquidity";
            arguments: [tokenA: TAddress, tokenB: TAddress, liquidity: bigint, amountAMin: bigint, amountBMin: bigint, to: TAddress, deadline: bigint];
        };
        removeLiquidityETH: {
            method: "removeLiquidityETH";
            arguments: [token: TAddress, liquidity: bigint, amountTokenMin: bigint, amountETHMin: bigint, to: TAddress, deadline: bigint];
        };
        removeLiquidityETHSupportingFeeOnTransferTokens: {
            method: "removeLiquidityETHSupportingFeeOnTransferTokens";
            arguments: [token: TAddress, liquidity: bigint, amountTokenMin: bigint, amountETHMin: bigint, to: TAddress, deadline: bigint];
        };
        removeLiquidityETHWithPermit: {
            method: "removeLiquidityETHWithPermit";
            arguments: [token: TAddress, liquidity: bigint, amountTokenMin: bigint, amountETHMin: bigint, to: TAddress, deadline: bigint, approveMax: boolean, v: number, r: TEth.Hex, s: TEth.Hex];
        };
        removeLiquidityETHWithPermitSupportingFeeOnTransferTokens: {
            method: "removeLiquidityETHWithPermitSupportingFeeOnTransferTokens";
            arguments: [token: TAddress, liquidity: bigint, amountTokenMin: bigint, amountETHMin: bigint, to: TAddress, deadline: bigint, approveMax: boolean, v: number, r: TEth.Hex, s: TEth.Hex];
        };
        removeLiquidityWithPermit: {
            method: "removeLiquidityWithPermit";
            arguments: [tokenA: TAddress, tokenB: TAddress, liquidity: bigint, amountAMin: bigint, amountBMin: bigint, to: TAddress, deadline: bigint, approveMax: boolean, v: number, r: TEth.Hex, s: TEth.Hex];
        };
        swapETHForExactTokens: {
            method: "swapETHForExactTokens";
            arguments: [amountOut: bigint, path: TAddress[], to: TAddress, deadline: bigint];
        };
        swapExactETHForTokens: {
            method: "swapExactETHForTokens";
            arguments: [amountOutMin: bigint, path: TAddress[], to: TAddress, deadline: bigint];
        };
        swapExactETHForTokensSupportingFeeOnTransferTokens: {
            method: "swapExactETHForTokensSupportingFeeOnTransferTokens";
            arguments: [amountOutMin: bigint, path: TAddress[], to: TAddress, deadline: bigint];
        };
        swapExactTokensForETH: {
            method: "swapExactTokensForETH";
            arguments: [amountIn: bigint, amountOutMin: bigint, path: TAddress[], to: TAddress, deadline: bigint];
        };
        swapExactTokensForETHSupportingFeeOnTransferTokens: {
            method: "swapExactTokensForETHSupportingFeeOnTransferTokens";
            arguments: [amountIn: bigint, amountOutMin: bigint, path: TAddress[], to: TAddress, deadline: bigint];
        };
        swapExactTokensForTokens: {
            method: "swapExactTokensForTokens";
            arguments: [amountIn: bigint, amountOutMin: bigint, path: TAddress[], to: TAddress, deadline: bigint];
        };
        swapExactTokensForTokensSupportingFeeOnTransferTokens: {
            method: "swapExactTokensForTokensSupportingFeeOnTransferTokens";
            arguments: [amountIn: bigint, amountOutMin: bigint, path: TAddress[], to: TAddress, deadline: bigint];
        };
        swapTokensForExactETH: {
            method: "swapTokensForExactETH";
            arguments: [amountOut: bigint, amountInMax: bigint, path: TAddress[], to: TAddress, deadline: bigint];
        };
        swapTokensForExactTokens: {
            method: "swapTokensForExactTokens";
            arguments: [amountOut: bigint, amountInMax: bigint, path: TAddress[], to: TAddress, deadline: bigint];
        };
    };
};
declare class AmmRouterV2ContractStorageReader extends ContractStorageReaderBase {
    address: TAddress;
    client: Web3Client;
    explorer: IBlockchainExplorer;
    constructor(address: TAddress, client: Web3Client, explorer: IBlockchainExplorer);
    $slots: any[];
}
interface IAmmRouterV2ContractTxCaller {
    addLiquidity(sender: TSender, tokenA: TAddress, tokenB: TAddress, amountADesired: bigint, amountBDesired: bigint, amountAMin: bigint, amountBMin: bigint, to: TAddress, deadline: bigint): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    addLiquidityETH(sender: TSender, token: TAddress, amountTokenDesired: bigint, amountTokenMin: bigint, amountETHMin: bigint, to: TAddress, deadline: bigint): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    removeLiquidity(sender: TSender, tokenA: TAddress, tokenB: TAddress, liquidity: bigint, amountAMin: bigint, amountBMin: bigint, to: TAddress, deadline: bigint): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    removeLiquidityETH(sender: TSender, token: TAddress, liquidity: bigint, amountTokenMin: bigint, amountETHMin: bigint, to: TAddress, deadline: bigint): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    removeLiquidityETHSupportingFeeOnTransferTokens(sender: TSender, token: TAddress, liquidity: bigint, amountTokenMin: bigint, amountETHMin: bigint, to: TAddress, deadline: bigint): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    removeLiquidityETHWithPermit(sender: TSender, token: TAddress, liquidity: bigint, amountTokenMin: bigint, amountETHMin: bigint, to: TAddress, deadline: bigint, approveMax: boolean, v: number, r: TEth.Hex, s: TEth.Hex): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(sender: TSender, token: TAddress, liquidity: bigint, amountTokenMin: bigint, amountETHMin: bigint, to: TAddress, deadline: bigint, approveMax: boolean, v: number, r: TEth.Hex, s: TEth.Hex): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    removeLiquidityWithPermit(sender: TSender, tokenA: TAddress, tokenB: TAddress, liquidity: bigint, amountAMin: bigint, amountBMin: bigint, to: TAddress, deadline: bigint, approveMax: boolean, v: number, r: TEth.Hex, s: TEth.Hex): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    swapETHForExactTokens(sender: TSender, amountOut: bigint, path: TAddress[], to: TAddress, deadline: bigint): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    swapExactETHForTokens(sender: TSender, amountOutMin: bigint, path: TAddress[], to: TAddress, deadline: bigint): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    swapExactETHForTokensSupportingFeeOnTransferTokens(sender: TSender, amountOutMin: bigint, path: TAddress[], to: TAddress, deadline: bigint): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    swapExactTokensForETH(sender: TSender, amountIn: bigint, amountOutMin: bigint, path: TAddress[], to: TAddress, deadline: bigint): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    swapExactTokensForETHSupportingFeeOnTransferTokens(sender: TSender, amountIn: bigint, amountOutMin: bigint, path: TAddress[], to: TAddress, deadline: bigint): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    swapExactTokensForTokens(sender: TSender, amountIn: bigint, amountOutMin: bigint, path: TAddress[], to: TAddress, deadline: bigint): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    swapExactTokensForTokensSupportingFeeOnTransferTokens(sender: TSender, amountIn: bigint, amountOutMin: bigint, path: TAddress[], to: TAddress, deadline: bigint): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    swapTokensForExactETH(sender: TSender, amountOut: bigint, amountInMax: bigint, path: TAddress[], to: TAddress, deadline: bigint): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    swapTokensForExactTokens(sender: TSender, amountOut: bigint, amountInMax: bigint, path: TAddress[], to: TAddress, deadline: bigint): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
}
interface IAmmRouterV2ContractTxData {
    addLiquidity(sender: TSender, tokenA: TAddress, tokenB: TAddress, amountADesired: bigint, amountBDesired: bigint, amountAMin: bigint, amountBMin: bigint, to: TAddress, deadline: bigint): Promise<TEth.TxLike>;
    addLiquidityETH(sender: TSender, token: TAddress, amountTokenDesired: bigint, amountTokenMin: bigint, amountETHMin: bigint, to: TAddress, deadline: bigint): Promise<TEth.TxLike>;
    removeLiquidity(sender: TSender, tokenA: TAddress, tokenB: TAddress, liquidity: bigint, amountAMin: bigint, amountBMin: bigint, to: TAddress, deadline: bigint): Promise<TEth.TxLike>;
    removeLiquidityETH(sender: TSender, token: TAddress, liquidity: bigint, amountTokenMin: bigint, amountETHMin: bigint, to: TAddress, deadline: bigint): Promise<TEth.TxLike>;
    removeLiquidityETHSupportingFeeOnTransferTokens(sender: TSender, token: TAddress, liquidity: bigint, amountTokenMin: bigint, amountETHMin: bigint, to: TAddress, deadline: bigint): Promise<TEth.TxLike>;
    removeLiquidityETHWithPermit(sender: TSender, token: TAddress, liquidity: bigint, amountTokenMin: bigint, amountETHMin: bigint, to: TAddress, deadline: bigint, approveMax: boolean, v: number, r: TEth.Hex, s: TEth.Hex): Promise<TEth.TxLike>;
    removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(sender: TSender, token: TAddress, liquidity: bigint, amountTokenMin: bigint, amountETHMin: bigint, to: TAddress, deadline: bigint, approveMax: boolean, v: number, r: TEth.Hex, s: TEth.Hex): Promise<TEth.TxLike>;
    removeLiquidityWithPermit(sender: TSender, tokenA: TAddress, tokenB: TAddress, liquidity: bigint, amountAMin: bigint, amountBMin: bigint, to: TAddress, deadline: bigint, approveMax: boolean, v: number, r: TEth.Hex, s: TEth.Hex): Promise<TEth.TxLike>;
    swapETHForExactTokens(sender: TSender, amountOut: bigint, path: TAddress[], to: TAddress, deadline: bigint): Promise<TEth.TxLike>;
    swapExactETHForTokens(sender: TSender, amountOutMin: bigint, path: TAddress[], to: TAddress, deadline: bigint): Promise<TEth.TxLike>;
    swapExactETHForTokensSupportingFeeOnTransferTokens(sender: TSender, amountOutMin: bigint, path: TAddress[], to: TAddress, deadline: bigint): Promise<TEth.TxLike>;
    swapExactTokensForETH(sender: TSender, amountIn: bigint, amountOutMin: bigint, path: TAddress[], to: TAddress, deadline: bigint): Promise<TEth.TxLike>;
    swapExactTokensForETHSupportingFeeOnTransferTokens(sender: TSender, amountIn: bigint, amountOutMin: bigint, path: TAddress[], to: TAddress, deadline: bigint): Promise<TEth.TxLike>;
    swapExactTokensForTokens(sender: TSender, amountIn: bigint, amountOutMin: bigint, path: TAddress[], to: TAddress, deadline: bigint): Promise<TEth.TxLike>;
    swapExactTokensForTokensSupportingFeeOnTransferTokens(sender: TSender, amountIn: bigint, amountOutMin: bigint, path: TAddress[], to: TAddress, deadline: bigint): Promise<TEth.TxLike>;
    swapTokensForExactETH(sender: TSender, amountOut: bigint, amountInMax: bigint, path: TAddress[], to: TAddress, deadline: bigint): Promise<TEth.TxLike>;
    swapTokensForExactTokens(sender: TSender, amountOut: bigint, amountInMax: bigint, path: TAddress[], to: TAddress, deadline: bigint): Promise<TEth.TxLike>;
}
type TEvents = TAmmRouterV2ContractTypes['Events'];
type TEventParams<TEventName extends keyof TEvents> = Partial<TEvents[TEventName]['outputParams']>;
export {};