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 OneInchRouterContract extends ContractBase {
    address: TEth.Address;
    client: Web3Client;
    explorer: IBlockchainExplorer;
    constructor(address?: TEth.Address, client?: Web3Client, explorer?: IBlockchainExplorer);
    Types: TOneInchRouterContractTypes;
    $meta: {
        class: string;
    };
    destroy(sender: TSender): Promise<TxWriter>;
    discountedSwap(sender: TSender, caller: TAddress, desc: {
        srcToken: TAddress;
        dstToken: TAddress;
        srcReceiver: TAddress;
        dstReceiver: TAddress;
        amount: bigint;
        minReturnAmount: bigint;
        flags: bigint;
        permit: TEth.Hex;
    }, data: TEth.Hex): Promise<TxWriter>;
    owner(): Promise<TAddress>;
    renounceOwnership(sender: TSender): Promise<TxWriter>;
    rescueFunds(sender: TSender, token: TAddress, amount: bigint): Promise<TxWriter>;
    swap(sender: TSender, caller: TAddress, desc: {
        srcToken: TAddress;
        dstToken: TAddress;
        srcReceiver: TAddress;
        dstReceiver: TAddress;
        amount: bigint;
        minReturnAmount: bigint;
        flags: bigint;
        permit: TEth.Hex;
    }, data: TEth.Hex): Promise<TxWriter>;
    transferOwnership(sender: TSender, newOwner: TAddress): Promise<TxWriter>;
    unoswap(sender: TSender, srcToken: TAddress, amount: bigint, minReturn: bigint, input3: TEth.Hex[]): Promise<TxWriter>;
    unoswapWithPermit(sender: TSender, srcToken: TAddress, amount: bigint, minReturn: bigint, pools: TEth.Hex[], permit: TEth.Hex): Promise<TxWriter>;
    $call(): IOneInchRouterContractTxCaller;
    $signed(): TOverrideReturns<IOneInchRouterContractTxCaller, Promise<{
        signed: TEth.Hex;
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
    }>>;
    $data(): IOneInchRouterContractTxData;
    $gas(): TOverrideReturns<IOneInchRouterContractTxCaller, Promise<{
        gas?: bigint;
        price?: bigint;
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
    }>>;
    onTransaction<TMethod extends keyof TOneInchRouterContractTypes['Methods']>(method: TMethod, options: Parameters<ContractBase['$onTransaction']>[0]): SubjectStream<{
        tx: TEth.Tx;
        block: TEth.Block<TEth.Hex>;
        calldata: {
            method: TMethod;
            arguments: TOneInchRouterContractTypes['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>[]>;
    onError(fn?: (event: TClientEventsStreamData<TEventArguments<'Error'>>) => void): ClientEventsStream<TClientEventsStreamData<TEventArguments<'Error'>>>;
    onOwnershipTransferred(fn?: (event: TClientEventsStreamData<TEventArguments<'OwnershipTransferred'>>) => void): ClientEventsStream<TClientEventsStreamData<TEventArguments<'OwnershipTransferred'>>>;
    onSwapped(fn?: (event: TClientEventsStreamData<TEventArguments<'Swapped'>>) => void): ClientEventsStream<TClientEventsStreamData<TEventArguments<'Swapped'>>>;
    extractLogsError(tx: TEth.TxReceipt): ITxLogItem<TEventParams<'Error'>>[];
    extractLogsOwnershipTransferred(tx: TEth.TxReceipt): ITxLogItem<TEventParams<'OwnershipTransferred'>>[];
    extractLogsSwapped(tx: TEth.TxReceipt): ITxLogItem<TEventParams<'Swapped'>>[];
    getPastLogsError(options?: {
        fromBlock?: number | Date;
        toBlock?: number | Date;
        params?: {};
    }): Promise<ITxLogItem<TEventParams<'Error'>>[]>;
    getPastLogsOwnershipTransferred(options?: {
        fromBlock?: number | Date;
        toBlock?: number | Date;
        params?: {
            previousOwner?: TAddress;
            newOwner?: TAddress;
        };
    }): Promise<ITxLogItem<TEventParams<'OwnershipTransferred'>>[]>;
    getPastLogsSwapped(options?: {
        fromBlock?: number | Date;
        toBlock?: number | Date;
        params?: {};
    }): Promise<ITxLogItem<TEventParams<'Swapped'>>[]>;
    abi: TAbiItem[];
    storage: OneInchRouterContractStorageReader;
}
type TSender = TAccount & {
    value?: string | number | bigint;
};
type TEventLogOptions<TParams> = {
    fromBlock?: number | Date;
    toBlock?: number | Date;
    params?: TParams;
};
export type TOneInchRouterContractTypes = {
    Events: {
        Error: {
            outputParams: {
                reason: string;
            };
            outputArgs: [reason: string];
        };
        OwnershipTransferred: {
            outputParams: {
                previousOwner: TAddress;
                newOwner: TAddress;
            };
            outputArgs: [previousOwner: TAddress, newOwner: TAddress];
        };
        Swapped: {
            outputParams: {
                _sender: TAddress;
                srcToken: TAddress;
                dstToken: TAddress;
                dstReceiver: TAddress;
                spentAmount: bigint;
                returnAmount: bigint;
            };
            outputArgs: [_sender: TAddress, srcToken: TAddress, dstToken: TAddress, dstReceiver: TAddress, spentAmount: bigint, returnAmount: bigint];
        };
    };
    Methods: {
        destroy: {
            method: "destroy";
            arguments: [];
        };
        discountedSwap: {
            method: "discountedSwap";
            arguments: [caller: TAddress, desc: {
                srcToken: TAddress;
                dstToken: TAddress;
                srcReceiver: TAddress;
                dstReceiver: TAddress;
                amount: bigint;
                minReturnAmount: bigint;
                flags: bigint;
                permit: TEth.Hex;
            }, data: TEth.Hex];
        };
        owner: {
            method: "owner";
            arguments: [];
        };
        renounceOwnership: {
            method: "renounceOwnership";
            arguments: [];
        };
        rescueFunds: {
            method: "rescueFunds";
            arguments: [token: TAddress, amount: bigint];
        };
        swap: {
            method: "swap";
            arguments: [caller: TAddress, desc: {
                srcToken: TAddress;
                dstToken: TAddress;
                srcReceiver: TAddress;
                dstReceiver: TAddress;
                amount: bigint;
                minReturnAmount: bigint;
                flags: bigint;
                permit: TEth.Hex;
            }, data: TEth.Hex];
        };
        transferOwnership: {
            method: "transferOwnership";
            arguments: [newOwner: TAddress];
        };
        unoswap: {
            method: "unoswap";
            arguments: [srcToken: TAddress, amount: bigint, minReturn: bigint, input3: TEth.Hex[]];
        };
        unoswapWithPermit: {
            method: "unoswapWithPermit";
            arguments: [srcToken: TAddress, amount: bigint, minReturn: bigint, pools: TEth.Hex[], permit: TEth.Hex];
        };
    };
};
declare class OneInchRouterContractStorageReader extends ContractStorageReaderBase {
    address: TAddress;
    client: Web3Client;
    explorer: IBlockchainExplorer;
    constructor(address: TAddress, client: Web3Client, explorer: IBlockchainExplorer);
    _owner(): Promise<TAddress>;
    $slots: {
        slot: number;
        position: number;
        name: string;
        size: number;
        type: string;
    }[];
}
interface IOneInchRouterContractTxCaller {
    destroy(sender: TSender): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    discountedSwap(sender: TSender, caller: TAddress, desc: {
        srcToken: TAddress;
        dstToken: TAddress;
        srcReceiver: TAddress;
        dstReceiver: TAddress;
        amount: bigint;
        minReturnAmount: bigint;
        flags: bigint;
        permit: TEth.Hex;
    }, data: TEth.Hex): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    renounceOwnership(sender: TSender): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    rescueFunds(sender: TSender, token: TAddress, amount: bigint): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    swap(sender: TSender, caller: TAddress, desc: {
        srcToken: TAddress;
        dstToken: TAddress;
        srcReceiver: TAddress;
        dstReceiver: TAddress;
        amount: bigint;
        minReturnAmount: bigint;
        flags: bigint;
        permit: TEth.Hex;
    }, data: TEth.Hex): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    transferOwnership(sender: TSender, newOwner: TAddress): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    unoswap(sender: TSender, srcToken: TAddress, amount: bigint, minReturn: bigint, input3: TEth.Hex[]): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    unoswapWithPermit(sender: TSender, srcToken: TAddress, amount: bigint, minReturn: bigint, pools: TEth.Hex[], permit: TEth.Hex): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
}
interface IOneInchRouterContractTxData {
    destroy(sender: TSender): Promise<TEth.TxLike>;
    discountedSwap(sender: TSender, caller: TAddress, desc: {
        srcToken: TAddress;
        dstToken: TAddress;
        srcReceiver: TAddress;
        dstReceiver: TAddress;
        amount: bigint;
        minReturnAmount: bigint;
        flags: bigint;
        permit: TEth.Hex;
    }, data: TEth.Hex): Promise<TEth.TxLike>;
    renounceOwnership(sender: TSender): Promise<TEth.TxLike>;
    rescueFunds(sender: TSender, token: TAddress, amount: bigint): Promise<TEth.TxLike>;
    swap(sender: TSender, caller: TAddress, desc: {
        srcToken: TAddress;
        dstToken: TAddress;
        srcReceiver: TAddress;
        dstReceiver: TAddress;
        amount: bigint;
        minReturnAmount: bigint;
        flags: bigint;
        permit: TEth.Hex;
    }, data: TEth.Hex): Promise<TEth.TxLike>;
    transferOwnership(sender: TSender, newOwner: TAddress): Promise<TEth.TxLike>;
    unoswap(sender: TSender, srcToken: TAddress, amount: bigint, minReturn: bigint, input3: TEth.Hex[]): Promise<TEth.TxLike>;
    unoswapWithPermit(sender: TSender, srcToken: TAddress, amount: bigint, minReturn: bigint, pools: TEth.Hex[], permit: TEth.Hex): Promise<TEth.TxLike>;
}
type TEvents = TOneInchRouterContractTypes['Events'];
type TEventParams<TEventName extends keyof TEvents> = Partial<TEvents[TEventName]['outputParams']>;
type TEventArguments<TEventName extends keyof TEvents> = Partial<TEvents[TEventName]['outputArgs']>;
export {};