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 AmmMasterChefV2Contract extends ContractBase {
    address: TEth.Address;
    client: Web3Client;
    explorer: IBlockchainExplorer;
    constructor(address?: TEth.Address, client?: Web3Client, explorer?: IBlockchainExplorer);
    Types: TAmmMasterChefV2ContractTypes;
    $meta: {
        class: string;
    };
    $constructor(deployer: TSender, _cake: TAddress, _syrup: TAddress, _devaddr: TAddress, _cakePerBlock: bigint, _startBlock: bigint): Promise<TxWriter>;
    BONUS_MULTIPLIER(): Promise<bigint>;
    add(sender: TSender, _allocPoint: bigint, _lpToken: TAddress, _withUpdate: boolean): Promise<TxWriter>;
    cake(): Promise<TAddress>;
    cakePerBlock(): Promise<bigint>;
    deposit(sender: TSender, _pid: bigint, _amount: bigint): Promise<TxWriter>;
    dev(sender: TSender, _devaddr: TAddress): Promise<TxWriter>;
    devaddr(): Promise<TAddress>;
    emergencyWithdraw(sender: TSender, _pid: bigint): Promise<TxWriter>;
    enterStaking(sender: TSender, _amount: bigint): Promise<TxWriter>;
    getMultiplier(_from: bigint, _to: bigint): Promise<bigint>;
    leaveStaking(sender: TSender, _amount: bigint): Promise<TxWriter>;
    massUpdatePools(sender: TSender): Promise<TxWriter>;
    migrate(sender: TSender, _pid: bigint): Promise<TxWriter>;
    migrator(): Promise<TAddress>;
    owner(): Promise<TAddress>;
    pendingCake(_pid: bigint, _user: TAddress): Promise<bigint>;
    poolInfo(input0: bigint): Promise<{
        lpToken: TAddress;
        allocPoint: bigint;
        lastRewardBlock: bigint;
        accCakePerShare: bigint;
    }>;
    poolLength(): Promise<bigint>;
    renounceOwnership(sender: TSender): Promise<TxWriter>;
    set(sender: TSender, _pid: bigint, _allocPoint: bigint, _withUpdate: boolean): Promise<TxWriter>;
    setMigrator(sender: TSender, _migrator: TAddress): Promise<TxWriter>;
    startBlock(): Promise<bigint>;
    syrup(): Promise<TAddress>;
    totalAllocPoint(): Promise<bigint>;
    transferOwnership(sender: TSender, newOwner: TAddress): Promise<TxWriter>;
    updateMultiplier(sender: TSender, multiplierNumber: bigint): Promise<TxWriter>;
    updatePool(sender: TSender, _pid: bigint): Promise<TxWriter>;
    userInfo(input0: bigint, input1: TAddress): Promise<{
        amount: bigint;
        rewardDebt: bigint;
    }>;
    withdraw(sender: TSender, _pid: bigint, _amount: bigint): Promise<TxWriter>;
    $call(): IAmmMasterChefV2ContractTxCaller;
    $signed(): TOverrideReturns<IAmmMasterChefV2ContractTxCaller, Promise<{
        signed: TEth.Hex;
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
    }>>;
    $data(): IAmmMasterChefV2ContractTxData;
    $gas(): TOverrideReturns<IAmmMasterChefV2ContractTxCaller, Promise<{
        gas?: bigint;
        price?: bigint;
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
    }>>;
    onTransaction<TMethod extends keyof TAmmMasterChefV2ContractTypes['Methods']>(method: TMethod, options: Parameters<ContractBase['$onTransaction']>[0]): SubjectStream<{
        tx: TEth.Tx;
        block: TEth.Block<TEth.Hex>;
        calldata: {
            method: TMethod;
            arguments: TAmmMasterChefV2ContractTypes['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'>>>;
    onEmergencyWithdraw(fn?: (event: TClientEventsStreamData<TEventArguments<'EmergencyWithdraw'>>) => void): ClientEventsStream<TClientEventsStreamData<TEventArguments<'EmergencyWithdraw'>>>;
    onOwnershipTransferred(fn?: (event: TClientEventsStreamData<TEventArguments<'OwnershipTransferred'>>) => void): ClientEventsStream<TClientEventsStreamData<TEventArguments<'OwnershipTransferred'>>>;
    onWithdraw(fn?: (event: TClientEventsStreamData<TEventArguments<'Withdraw'>>) => void): ClientEventsStream<TClientEventsStreamData<TEventArguments<'Withdraw'>>>;
    extractLogsDeposit(tx: TEth.TxReceipt): ITxLogItem<TEventParams<'Deposit'>>[];
    extractLogsEmergencyWithdraw(tx: TEth.TxReceipt): ITxLogItem<TEventParams<'EmergencyWithdraw'>>[];
    extractLogsOwnershipTransferred(tx: TEth.TxReceipt): ITxLogItem<TEventParams<'OwnershipTransferred'>>[];
    extractLogsWithdraw(tx: TEth.TxReceipt): ITxLogItem<TEventParams<'Withdraw'>>[];
    getPastLogsDeposit(options?: {
        fromBlock?: number | Date;
        toBlock?: number | Date;
        params?: {
            user?: TAddress;
            pid?: bigint;
        };
    }): Promise<ITxLogItem<TEventParams<'Deposit'>>[]>;
    getPastLogsEmergencyWithdraw(options?: {
        fromBlock?: number | Date;
        toBlock?: number | Date;
        params?: {
            user?: TAddress;
            pid?: bigint;
        };
    }): Promise<ITxLogItem<TEventParams<'EmergencyWithdraw'>>[]>;
    getPastLogsOwnershipTransferred(options?: {
        fromBlock?: number | Date;
        toBlock?: number | Date;
        params?: {
            previousOwner?: TAddress;
            newOwner?: TAddress;
        };
    }): Promise<ITxLogItem<TEventParams<'OwnershipTransferred'>>[]>;
    getPastLogsWithdraw(options?: {
        fromBlock?: number | Date;
        toBlock?: number | Date;
        params?: {
            user?: TAddress;
            pid?: bigint;
        };
    }): Promise<ITxLogItem<TEventParams<'Withdraw'>>[]>;
    abi: TAbiItem[];
    storage: AmmMasterChefV2ContractStorageReader;
}
type TSender = TAccount & {
    value?: string | number | bigint;
};
type TEventLogOptions<TParams> = {
    fromBlock?: number | Date;
    toBlock?: number | Date;
    params?: TParams;
};
export type TAmmMasterChefV2ContractTypes = {
    Events: {
        Deposit: {
            outputParams: {
                user: TAddress;
                pid: bigint;
                amount: bigint;
            };
            outputArgs: [user: TAddress, pid: bigint, amount: bigint];
        };
        EmergencyWithdraw: {
            outputParams: {
                user: TAddress;
                pid: bigint;
                amount: bigint;
            };
            outputArgs: [user: TAddress, pid: bigint, amount: bigint];
        };
        OwnershipTransferred: {
            outputParams: {
                previousOwner: TAddress;
                newOwner: TAddress;
            };
            outputArgs: [previousOwner: TAddress, newOwner: TAddress];
        };
        Withdraw: {
            outputParams: {
                user: TAddress;
                pid: bigint;
                amount: bigint;
            };
            outputArgs: [user: TAddress, pid: bigint, amount: bigint];
        };
    };
    Methods: {
        BONUS_MULTIPLIER: {
            method: "BONUS_MULTIPLIER";
            arguments: [];
        };
        add: {
            method: "add";
            arguments: [_allocPoint: bigint, _lpToken: TAddress, _withUpdate: boolean];
        };
        cake: {
            method: "cake";
            arguments: [];
        };
        cakePerBlock: {
            method: "cakePerBlock";
            arguments: [];
        };
        deposit: {
            method: "deposit";
            arguments: [_pid: bigint, _amount: bigint];
        };
        dev: {
            method: "dev";
            arguments: [_devaddr: TAddress];
        };
        devaddr: {
            method: "devaddr";
            arguments: [];
        };
        emergencyWithdraw: {
            method: "emergencyWithdraw";
            arguments: [_pid: bigint];
        };
        enterStaking: {
            method: "enterStaking";
            arguments: [_amount: bigint];
        };
        getMultiplier: {
            method: "getMultiplier";
            arguments: [_from: bigint, _to: bigint];
        };
        leaveStaking: {
            method: "leaveStaking";
            arguments: [_amount: bigint];
        };
        massUpdatePools: {
            method: "massUpdatePools";
            arguments: [];
        };
        migrate: {
            method: "migrate";
            arguments: [_pid: bigint];
        };
        migrator: {
            method: "migrator";
            arguments: [];
        };
        owner: {
            method: "owner";
            arguments: [];
        };
        pendingCake: {
            method: "pendingCake";
            arguments: [_pid: bigint, _user: TAddress];
        };
        poolInfo: {
            method: "poolInfo";
            arguments: [input0: bigint];
        };
        poolLength: {
            method: "poolLength";
            arguments: [];
        };
        renounceOwnership: {
            method: "renounceOwnership";
            arguments: [];
        };
        set: {
            method: "set";
            arguments: [_pid: bigint, _allocPoint: bigint, _withUpdate: boolean];
        };
        setMigrator: {
            method: "setMigrator";
            arguments: [_migrator: TAddress];
        };
        startBlock: {
            method: "startBlock";
            arguments: [];
        };
        syrup: {
            method: "syrup";
            arguments: [];
        };
        totalAllocPoint: {
            method: "totalAllocPoint";
            arguments: [];
        };
        transferOwnership: {
            method: "transferOwnership";
            arguments: [newOwner: TAddress];
        };
        updateMultiplier: {
            method: "updateMultiplier";
            arguments: [multiplierNumber: bigint];
        };
        updatePool: {
            method: "updatePool";
            arguments: [_pid: bigint];
        };
        userInfo: {
            method: "userInfo";
            arguments: [input0: bigint, input1: TAddress];
        };
        withdraw: {
            method: "withdraw";
            arguments: [_pid: bigint, _amount: bigint];
        };
    };
};
declare class AmmMasterChefV2ContractStorageReader extends ContractStorageReaderBase {
    address: TAddress;
    client: Web3Client;
    explorer: IBlockchainExplorer;
    constructor(address: TAddress, client: Web3Client, explorer: IBlockchainExplorer);
    _owner(): Promise<TAddress>;
    cake(): Promise<TAddress>;
    syrup(): Promise<TAddress>;
    devaddr(): Promise<TAddress>;
    cakePerBlock(): Promise<bigint>;
    BONUS_MULTIPLIER(): Promise<bigint>;
    migrator(): Promise<TAddress>;
    poolInfo(): Promise<{
        lpToken: TAddress;
        allocPoint: bigint;
        lastRewardBlock: bigint;
        accCakePerShare: bigint;
    }[]>;
    userInfo(key: bigint): Promise<Record<string | number, {
        amount: bigint;
        rewardDebt: bigint;
    }>>;
    totalAllocPoint(): Promise<bigint>;
    startBlock(): Promise<bigint>;
    $slots: {
        slot: number;
        position: number;
        name: string;
        size: number;
        type: string;
    }[];
}
interface IAmmMasterChefV2ContractTxCaller {
    add(sender: TSender, _allocPoint: bigint, _lpToken: TAddress, _withUpdate: boolean): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    deposit(sender: TSender, _pid: bigint, _amount: bigint): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    dev(sender: TSender, _devaddr: TAddress): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    emergencyWithdraw(sender: TSender, _pid: bigint): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    enterStaking(sender: TSender, _amount: bigint): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    leaveStaking(sender: TSender, _amount: bigint): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    massUpdatePools(sender: TSender): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    migrate(sender: TSender, _pid: bigint): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    renounceOwnership(sender: TSender): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    set(sender: TSender, _pid: bigint, _allocPoint: bigint, _withUpdate: boolean): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    setMigrator(sender: TSender, _migrator: TAddress): 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;
    }>;
    updateMultiplier(sender: TSender, multiplierNumber: bigint): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    updatePool(sender: TSender, _pid: bigint): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    withdraw(sender: TSender, _pid: bigint, _amount: bigint): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
}
interface IAmmMasterChefV2ContractTxData {
    add(sender: TSender, _allocPoint: bigint, _lpToken: TAddress, _withUpdate: boolean): Promise<TEth.TxLike>;
    deposit(sender: TSender, _pid: bigint, _amount: bigint): Promise<TEth.TxLike>;
    dev(sender: TSender, _devaddr: TAddress): Promise<TEth.TxLike>;
    emergencyWithdraw(sender: TSender, _pid: bigint): Promise<TEth.TxLike>;
    enterStaking(sender: TSender, _amount: bigint): Promise<TEth.TxLike>;
    leaveStaking(sender: TSender, _amount: bigint): Promise<TEth.TxLike>;
    massUpdatePools(sender: TSender): Promise<TEth.TxLike>;
    migrate(sender: TSender, _pid: bigint): Promise<TEth.TxLike>;
    renounceOwnership(sender: TSender): Promise<TEth.TxLike>;
    set(sender: TSender, _pid: bigint, _allocPoint: bigint, _withUpdate: boolean): Promise<TEth.TxLike>;
    setMigrator(sender: TSender, _migrator: TAddress): Promise<TEth.TxLike>;
    transferOwnership(sender: TSender, newOwner: TAddress): Promise<TEth.TxLike>;
    updateMultiplier(sender: TSender, multiplierNumber: bigint): Promise<TEth.TxLike>;
    updatePool(sender: TSender, _pid: bigint): Promise<TEth.TxLike>;
    withdraw(sender: TSender, _pid: bigint, _amount: bigint): Promise<TEth.TxLike>;
}
type TEvents = TAmmMasterChefV2ContractTypes['Events'];
type TEventParams<TEventName extends keyof TEvents> = Partial<TEvents[TEventName]['outputParams']>;
type TEventArguments<TEventName extends keyof TEvents> = Partial<TEvents[TEventName]['outputArgs']>;
export {};