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 AmmVaultV2Contract extends ContractBase {
    address: TEth.Address;
    client: Web3Client;
    explorer: IBlockchainExplorer;
    constructor(address?: TEth.Address, client?: Web3Client, explorer?: IBlockchainExplorer);
    Types: TAmmVaultV2ContractTypes;
    $meta: {
        class: string;
    };
    $constructor(deployer: TSender, _token: TAddress, _receiptToken: TAddress, _masterchef: TAddress, _admin: TAddress, _treasury: TAddress): Promise<TxWriter>;
    MAX_CALL_FEE(): Promise<bigint>;
    MAX_PERFORMANCE_FEE(): Promise<bigint>;
    MAX_WITHDRAW_FEE(): Promise<bigint>;
    MAX_WITHDRAW_FEE_PERIOD(): Promise<bigint>;
    admin(): Promise<TAddress>;
    available(): Promise<bigint>;
    balanceOf(): Promise<bigint>;
    calculateHarvestCakeRewards(): Promise<bigint>;
    calculateTotalPendingCakeRewards(): Promise<bigint>;
    callFee(): Promise<bigint>;
    deposit(sender: TSender, _amount: bigint): Promise<TxWriter>;
    emergencyWithdraw(sender: TSender): Promise<TxWriter>;
    getPricePerFullShare(): Promise<bigint>;
    harvest(sender: TSender): Promise<TxWriter>;
    inCaseTokensGetStuck(sender: TSender, _token: TAddress): Promise<TxWriter>;
    lastHarvestedTime(): Promise<bigint>;
    masterchef(): Promise<TAddress>;
    owner(): Promise<TAddress>;
    pause(sender: TSender): Promise<TxWriter>;
    paused(): Promise<boolean>;
    performanceFee(): Promise<bigint>;
    receiptToken(): Promise<TAddress>;
    renounceOwnership(sender: TSender): Promise<TxWriter>;
    setAdmin(sender: TSender, _admin: TAddress): Promise<TxWriter>;
    setCallFee(sender: TSender, _callFee: bigint): Promise<TxWriter>;
    setPerformanceFee(sender: TSender, _performanceFee: bigint): Promise<TxWriter>;
    setTreasury(sender: TSender, _treasury: TAddress): Promise<TxWriter>;
    setWithdrawFee(sender: TSender, _withdrawFee: bigint): Promise<TxWriter>;
    setWithdrawFeePeriod(sender: TSender, _withdrawFeePeriod: bigint): Promise<TxWriter>;
    token(): Promise<TAddress>;
    totalShares(): Promise<bigint>;
    transferOwnership(sender: TSender, newOwner: TAddress): Promise<TxWriter>;
    treasury(): Promise<TAddress>;
    unpause(sender: TSender): Promise<TxWriter>;
    userInfo(input0: TAddress): Promise<{
        shares: bigint;
        lastDepositedTime: bigint;
        cakeAtLastUserAction: bigint;
        lastUserActionTime: bigint;
    }>;
    withdraw(sender: TSender, _shares: bigint): Promise<TxWriter>;
    withdrawAll(sender: TSender): Promise<TxWriter>;
    withdrawFee(): Promise<bigint>;
    withdrawFeePeriod(): Promise<bigint>;
    $call(): IAmmVaultV2ContractTxCaller;
    $signed(): TOverrideReturns<IAmmVaultV2ContractTxCaller, Promise<{
        signed: TEth.Hex;
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
    }>>;
    $data(): IAmmVaultV2ContractTxData;
    $gas(): TOverrideReturns<IAmmVaultV2ContractTxCaller, Promise<{
        gas?: bigint;
        price?: bigint;
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
    }>>;
    onTransaction<TMethod extends keyof TAmmVaultV2ContractTypes['Methods']>(method: TMethod, options: Parameters<ContractBase['$onTransaction']>[0]): SubjectStream<{
        tx: TEth.Tx;
        block: TEth.Block<TEth.Hex>;
        calldata: {
            method: TMethod;
            arguments: TAmmVaultV2ContractTypes['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>[]>;
    onDeposit(fn?: (event: TClientEventsStreamData<TEventArguments<'Deposit'>>) => void): ClientEventsStream<TClientEventsStreamData<TEventArguments<'Deposit'>>>;
    onHarvest(fn?: (event: TClientEventsStreamData<TEventArguments<'Harvest'>>) => void): ClientEventsStream<TClientEventsStreamData<TEventArguments<'Harvest'>>>;
    onOwnershipTransferred(fn?: (event: TClientEventsStreamData<TEventArguments<'OwnershipTransferred'>>) => void): ClientEventsStream<TClientEventsStreamData<TEventArguments<'OwnershipTransferred'>>>;
    onPause(fn?: (event: TClientEventsStreamData<TEventArguments<'Pause'>>) => void): ClientEventsStream<TClientEventsStreamData<TEventArguments<'Pause'>>>;
    onPaused(fn?: (event: TClientEventsStreamData<TEventArguments<'Paused'>>) => void): ClientEventsStream<TClientEventsStreamData<TEventArguments<'Paused'>>>;
    onUnpause(fn?: (event: TClientEventsStreamData<TEventArguments<'Unpause'>>) => void): ClientEventsStream<TClientEventsStreamData<TEventArguments<'Unpause'>>>;
    onUnpaused(fn?: (event: TClientEventsStreamData<TEventArguments<'Unpaused'>>) => void): ClientEventsStream<TClientEventsStreamData<TEventArguments<'Unpaused'>>>;
    onWithdraw(fn?: (event: TClientEventsStreamData<TEventArguments<'Withdraw'>>) => void): ClientEventsStream<TClientEventsStreamData<TEventArguments<'Withdraw'>>>;
    extractLogsDeposit(tx: TEth.TxReceipt): ITxLogItem<TEventParams<'Deposit'>>[];
    extractLogsHarvest(tx: TEth.TxReceipt): ITxLogItem<TEventParams<'Harvest'>>[];
    extractLogsOwnershipTransferred(tx: TEth.TxReceipt): ITxLogItem<TEventParams<'OwnershipTransferred'>>[];
    extractLogsPause(tx: TEth.TxReceipt): ITxLogItem<TEventParams<'Pause'>>[];
    extractLogsPaused(tx: TEth.TxReceipt): ITxLogItem<TEventParams<'Paused'>>[];
    extractLogsUnpause(tx: TEth.TxReceipt): ITxLogItem<TEventParams<'Unpause'>>[];
    extractLogsUnpaused(tx: TEth.TxReceipt): ITxLogItem<TEventParams<'Unpaused'>>[];
    extractLogsWithdraw(tx: TEth.TxReceipt): ITxLogItem<TEventParams<'Withdraw'>>[];
    getPastLogsDeposit(options?: {
        fromBlock?: number | Date;
        toBlock?: number | Date;
        params?: {
            sender?: TAddress;
        };
    }): Promise<ITxLogItem<TEventParams<'Deposit'>>[]>;
    getPastLogsHarvest(options?: {
        fromBlock?: number | Date;
        toBlock?: number | Date;
        params?: {
            sender?: TAddress;
        };
    }): Promise<ITxLogItem<TEventParams<'Harvest'>>[]>;
    getPastLogsOwnershipTransferred(options?: {
        fromBlock?: number | Date;
        toBlock?: number | Date;
        params?: {
            previousOwner?: TAddress;
            newOwner?: TAddress;
        };
    }): Promise<ITxLogItem<TEventParams<'OwnershipTransferred'>>[]>;
    getPastLogsPause(options?: {
        fromBlock?: number | Date;
        toBlock?: number | Date;
        params?: {};
    }): Promise<ITxLogItem<TEventParams<'Pause'>>[]>;
    getPastLogsPaused(options?: {
        fromBlock?: number | Date;
        toBlock?: number | Date;
        params?: {};
    }): Promise<ITxLogItem<TEventParams<'Paused'>>[]>;
    getPastLogsUnpause(options?: {
        fromBlock?: number | Date;
        toBlock?: number | Date;
        params?: {};
    }): Promise<ITxLogItem<TEventParams<'Unpause'>>[]>;
    getPastLogsUnpaused(options?: {
        fromBlock?: number | Date;
        toBlock?: number | Date;
        params?: {};
    }): Promise<ITxLogItem<TEventParams<'Unpaused'>>[]>;
    getPastLogsWithdraw(options?: {
        fromBlock?: number | Date;
        toBlock?: number | Date;
        params?: {
            sender?: TAddress;
        };
    }): Promise<ITxLogItem<TEventParams<'Withdraw'>>[]>;
    abi: TAbiItem[];
    storage: AmmVaultV2ContractStorageReader;
}
type TSender = TAccount & {
    value?: string | number | bigint;
};
type TEventLogOptions<TParams> = {
    fromBlock?: number | Date;
    toBlock?: number | Date;
    params?: TParams;
};
export type TAmmVaultV2ContractTypes = {
    Events: {
        Deposit: {
            outputParams: {
                _sender: TAddress;
                amount: bigint;
                shares: bigint;
                lastDepositedTime: bigint;
            };
            outputArgs: [_sender: TAddress, amount: bigint, shares: bigint, lastDepositedTime: bigint];
        };
        Harvest: {
            outputParams: {
                _sender: TAddress;
                performanceFee: bigint;
                callFee: bigint;
            };
            outputArgs: [_sender: TAddress, performanceFee: bigint, callFee: bigint];
        };
        OwnershipTransferred: {
            outputParams: {
                previousOwner: TAddress;
                newOwner: TAddress;
            };
            outputArgs: [previousOwner: TAddress, newOwner: TAddress];
        };
        Pause: {
            outputParams: {};
            outputArgs: [];
        };
        Paused: {
            outputParams: {
                account: TAddress;
            };
            outputArgs: [account: TAddress];
        };
        Unpause: {
            outputParams: {};
            outputArgs: [];
        };
        Unpaused: {
            outputParams: {
                account: TAddress;
            };
            outputArgs: [account: TAddress];
        };
        Withdraw: {
            outputParams: {
                _sender: TAddress;
                amount: bigint;
                shares: bigint;
            };
            outputArgs: [_sender: TAddress, amount: bigint, shares: bigint];
        };
    };
    Methods: {
        MAX_CALL_FEE: {
            method: "MAX_CALL_FEE";
            arguments: [];
        };
        MAX_PERFORMANCE_FEE: {
            method: "MAX_PERFORMANCE_FEE";
            arguments: [];
        };
        MAX_WITHDRAW_FEE: {
            method: "MAX_WITHDRAW_FEE";
            arguments: [];
        };
        MAX_WITHDRAW_FEE_PERIOD: {
            method: "MAX_WITHDRAW_FEE_PERIOD";
            arguments: [];
        };
        admin: {
            method: "admin";
            arguments: [];
        };
        available: {
            method: "available";
            arguments: [];
        };
        balanceOf: {
            method: "balanceOf";
            arguments: [];
        };
        calculateHarvestCakeRewards: {
            method: "calculateHarvestCakeRewards";
            arguments: [];
        };
        calculateTotalPendingCakeRewards: {
            method: "calculateTotalPendingCakeRewards";
            arguments: [];
        };
        callFee: {
            method: "callFee";
            arguments: [];
        };
        deposit: {
            method: "deposit";
            arguments: [_amount: bigint];
        };
        emergencyWithdraw: {
            method: "emergencyWithdraw";
            arguments: [];
        };
        getPricePerFullShare: {
            method: "getPricePerFullShare";
            arguments: [];
        };
        harvest: {
            method: "harvest";
            arguments: [];
        };
        inCaseTokensGetStuck: {
            method: "inCaseTokensGetStuck";
            arguments: [_token: TAddress];
        };
        lastHarvestedTime: {
            method: "lastHarvestedTime";
            arguments: [];
        };
        masterchef: {
            method: "masterchef";
            arguments: [];
        };
        owner: {
            method: "owner";
            arguments: [];
        };
        pause: {
            method: "pause";
            arguments: [];
        };
        paused: {
            method: "paused";
            arguments: [];
        };
        performanceFee: {
            method: "performanceFee";
            arguments: [];
        };
        receiptToken: {
            method: "receiptToken";
            arguments: [];
        };
        renounceOwnership: {
            method: "renounceOwnership";
            arguments: [];
        };
        setAdmin: {
            method: "setAdmin";
            arguments: [_admin: TAddress];
        };
        setCallFee: {
            method: "setCallFee";
            arguments: [_callFee: bigint];
        };
        setPerformanceFee: {
            method: "setPerformanceFee";
            arguments: [_performanceFee: bigint];
        };
        setTreasury: {
            method: "setTreasury";
            arguments: [_treasury: TAddress];
        };
        setWithdrawFee: {
            method: "setWithdrawFee";
            arguments: [_withdrawFee: bigint];
        };
        setWithdrawFeePeriod: {
            method: "setWithdrawFeePeriod";
            arguments: [_withdrawFeePeriod: bigint];
        };
        token: {
            method: "token";
            arguments: [];
        };
        totalShares: {
            method: "totalShares";
            arguments: [];
        };
        transferOwnership: {
            method: "transferOwnership";
            arguments: [newOwner: TAddress];
        };
        treasury: {
            method: "treasury";
            arguments: [];
        };
        unpause: {
            method: "unpause";
            arguments: [];
        };
        userInfo: {
            method: "userInfo";
            arguments: [input0: TAddress];
        };
        withdraw: {
            method: "withdraw";
            arguments: [_shares: bigint];
        };
        withdrawAll: {
            method: "withdrawAll";
            arguments: [];
        };
        withdrawFee: {
            method: "withdrawFee";
            arguments: [];
        };
        withdrawFeePeriod: {
            method: "withdrawFeePeriod";
            arguments: [];
        };
    };
};
declare class AmmVaultV2ContractStorageReader extends ContractStorageReaderBase {
    address: TAddress;
    client: Web3Client;
    explorer: IBlockchainExplorer;
    constructor(address: TAddress, client: Web3Client, explorer: IBlockchainExplorer);
    _owner(): Promise<TAddress>;
    _paused(): Promise<boolean>;
    userInfo(key: TAddress): Promise<{
        shares: bigint;
        lastDepositedTime: bigint;
        cakeAtLastUserAction: bigint;
        lastUserActionTime: bigint;
    }>;
    totalShares(): Promise<bigint>;
    lastHarvestedTime(): Promise<bigint>;
    admin(): Promise<TAddress>;
    treasury(): Promise<TAddress>;
    performanceFee(): Promise<bigint>;
    callFee(): Promise<bigint>;
    withdrawFee(): Promise<bigint>;
    withdrawFeePeriod(): Promise<bigint>;
    $slots: {
        slot: number;
        position: number;
        name: string;
        size: number;
        type: string;
    }[];
}
interface IAmmVaultV2ContractTxCaller {
    deposit(sender: TSender, _amount: bigint): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    emergencyWithdraw(sender: TSender): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    harvest(sender: TSender): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    inCaseTokensGetStuck(sender: TSender, _token: TAddress): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    pause(sender: TSender): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    renounceOwnership(sender: TSender): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    setAdmin(sender: TSender, _admin: TAddress): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    setCallFee(sender: TSender, _callFee: bigint): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    setPerformanceFee(sender: TSender, _performanceFee: bigint): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    setTreasury(sender: TSender, _treasury: TAddress): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    setWithdrawFee(sender: TSender, _withdrawFee: bigint): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    setWithdrawFeePeriod(sender: TSender, _withdrawFeePeriod: bigint): 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;
    }>;
    unpause(sender: TSender): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    withdraw(sender: TSender, _shares: bigint): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    withdrawAll(sender: TSender): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
}
interface IAmmVaultV2ContractTxData {
    deposit(sender: TSender, _amount: bigint): Promise<TEth.TxLike>;
    emergencyWithdraw(sender: TSender): Promise<TEth.TxLike>;
    harvest(sender: TSender): Promise<TEth.TxLike>;
    inCaseTokensGetStuck(sender: TSender, _token: TAddress): Promise<TEth.TxLike>;
    pause(sender: TSender): Promise<TEth.TxLike>;
    renounceOwnership(sender: TSender): Promise<TEth.TxLike>;
    setAdmin(sender: TSender, _admin: TAddress): Promise<TEth.TxLike>;
    setCallFee(sender: TSender, _callFee: bigint): Promise<TEth.TxLike>;
    setPerformanceFee(sender: TSender, _performanceFee: bigint): Promise<TEth.TxLike>;
    setTreasury(sender: TSender, _treasury: TAddress): Promise<TEth.TxLike>;
    setWithdrawFee(sender: TSender, _withdrawFee: bigint): Promise<TEth.TxLike>;
    setWithdrawFeePeriod(sender: TSender, _withdrawFeePeriod: bigint): Promise<TEth.TxLike>;
    transferOwnership(sender: TSender, newOwner: TAddress): Promise<TEth.TxLike>;
    unpause(sender: TSender): Promise<TEth.TxLike>;
    withdraw(sender: TSender, _shares: bigint): Promise<TEth.TxLike>;
    withdrawAll(sender: TSender): Promise<TEth.TxLike>;
}
type TEvents = TAmmVaultV2ContractTypes['Events'];
type TEventParams<TEventName extends keyof TEvents> = Partial<TEvents[TEventName]['outputParams']>;
type TEventArguments<TEventName extends keyof TEvents> = Partial<TEvents[TEventName]['outputArgs']>;
export {};