@collabland/staking-contracts/dist/types/StartNft.d.ts

Staking contracts supported by Collab.Land

import type { BaseContract, BigNumber, BigNumberish, BytesLike, CallOverrides, ContractTransaction, Overrides, PopulatedTransaction, Signer, utils } from "ethers";
import type { FunctionFragment, Result, EventFragment } from "@ethersproject/abi";
import type { Listener, Provider } from "@ethersproject/providers";
import type { TypedEventFilter, TypedEvent, TypedListener, OnEvent } from "./common.js";
export declare namespace Staking {
    type ItemInfoStruct = {
        owner: string;
        poolId: BigNumberish;
        timestamp: BigNumberish;
        addressBTC: string;
    };
    type ItemInfoStructOutput = [string, BigNumber, BigNumber, string] & {
        owner: string;
        poolId: BigNumber;
        timestamp: BigNumber;
        addressBTC: string;
    };
}
export interface StartNftInterface extends utils.Interface {
    functions: {
        "batchStakeERC721(uint256,uint256[],string)": FunctionFragment;
        "batchUnstakeERC721(uint256[])": FunctionFragment;
        "createPool(uint256,uint256,uint256,uint256,string,string)": FunctionFragment;
        "currentPoolId()": FunctionFragment;
        "getAllStakedERC721(address)": FunctionFragment;
        "getAllStakedERC721Pool(uint256)": FunctionFragment;
        "getAllStakedERC721PoolByUser(uint256,address)": FunctionFragment;
        "getStakedERC721(address,uint256)": FunctionFragment;
        "getStakedERC721Pool(uint256,uint256)": FunctionFragment;
        "onERC721Received(address,address,uint256,bytes)": FunctionFragment;
        "owner()": FunctionFragment;
        "poolInfos(uint256)": FunctionFragment;
        "renounceOwnership()": FunctionFragment;
        "setPoolInformation(uint256,uint256,uint256,uint256,uint256,string,string)": FunctionFragment;
        "setUnlockPeriod(uint256)": FunctionFragment;
        "stakeERC721(uint256,uint256,string)": FunctionFragment;
        "stakingPaused()": FunctionFragment;
        "stakingUnlock()": FunctionFragment;
        "toggleStakingPaused()": FunctionFragment;
        "transferOwnership(address)": FunctionFragment;
        "unstakeERC721(uint256)": FunctionFragment;
    };
    getFunction(nameOrSignatureOrTopic: "batchStakeERC721" | "batchUnstakeERC721" | "createPool" | "currentPoolId" | "getAllStakedERC721" | "getAllStakedERC721Pool" | "getAllStakedERC721PoolByUser" | "getStakedERC721" | "getStakedERC721Pool" | "onERC721Received" | "owner" | "poolInfos" | "renounceOwnership" | "setPoolInformation" | "setUnlockPeriod" | "stakeERC721" | "stakingPaused" | "stakingUnlock" | "toggleStakingPaused" | "transferOwnership" | "unstakeERC721"): FunctionFragment;
    encodeFunctionData(functionFragment: "batchStakeERC721", values: [BigNumberish, BigNumberish[], string]): string;
    encodeFunctionData(functionFragment: "batchUnstakeERC721", values: [BigNumberish[]]): string;
    encodeFunctionData(functionFragment: "createPool", values: [
        BigNumberish,
        BigNumberish,
        BigNumberish,
        BigNumberish,
        string,
        string
    ]): string;
    encodeFunctionData(functionFragment: "currentPoolId", values?: undefined): string;
    encodeFunctionData(functionFragment: "getAllStakedERC721", values: [string]): string;
    encodeFunctionData(functionFragment: "getAllStakedERC721Pool", values: [BigNumberish]): string;
    encodeFunctionData(functionFragment: "getAllStakedERC721PoolByUser", values: [BigNumberish, string]): string;
    encodeFunctionData(functionFragment: "getStakedERC721", values: [string, BigNumberish]): string;
    encodeFunctionData(functionFragment: "getStakedERC721Pool", values: [BigNumberish, BigNumberish]): string;
    encodeFunctionData(functionFragment: "onERC721Received", values: [string, string, BigNumberish, BytesLike]): string;
    encodeFunctionData(functionFragment: "owner", values?: undefined): string;
    encodeFunctionData(functionFragment: "poolInfos", values: [BigNumberish]): string;
    encodeFunctionData(functionFragment: "renounceOwnership", values?: undefined): string;
    encodeFunctionData(functionFragment: "setPoolInformation", values: [
        BigNumberish,
        BigNumberish,
        BigNumberish,
        BigNumberish,
        BigNumberish,
        string,
        string
    ]): string;
    encodeFunctionData(functionFragment: "setUnlockPeriod", values: [BigNumberish]): string;
    encodeFunctionData(functionFragment: "stakeERC721", values: [BigNumberish, BigNumberish, string]): string;
    encodeFunctionData(functionFragment: "stakingPaused", values?: undefined): string;
    encodeFunctionData(functionFragment: "stakingUnlock", values?: undefined): string;
    encodeFunctionData(functionFragment: "toggleStakingPaused", values?: undefined): string;
    encodeFunctionData(functionFragment: "transferOwnership", values: [string]): string;
    encodeFunctionData(functionFragment: "unstakeERC721", values: [BigNumberish]): string;
    decodeFunctionResult(functionFragment: "batchStakeERC721", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "batchUnstakeERC721", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "createPool", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "currentPoolId", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "getAllStakedERC721", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "getAllStakedERC721Pool", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "getAllStakedERC721PoolByUser", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "getStakedERC721", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "getStakedERC721Pool", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "onERC721Received", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "owner", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "poolInfos", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "renounceOwnership", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "setPoolInformation", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "setUnlockPeriod", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "stakeERC721", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "stakingPaused", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "stakingUnlock", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "toggleStakingPaused", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "transferOwnership", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "unstakeERC721", data: BytesLike): Result;
    events: {
        "OwnershipTransferred(address,address)": EventFragment;
        "PauseUpdated(bool)": EventFragment;
        "PoolCreated(uint256,uint256,uint256,uint256,uint256,string,string)": EventFragment;
        "PoolInformationsUpdated(uint256,uint256,uint256,uint256,uint256,string,string)": EventFragment;
        "Staked721(address,uint256,uint256)": EventFragment;
        "UnlockPeriodUpdated(uint256)": EventFragment;
        "Unstaked721(address,uint256,uint256)": EventFragment;
    };
    getEvent(nameOrSignatureOrTopic: "OwnershipTransferred"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "PauseUpdated"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "PoolCreated"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "PoolInformationsUpdated"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "Staked721"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "UnlockPeriodUpdated"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "Unstaked721"): EventFragment;
}
export interface OwnershipTransferredEventObject {
    previousOwner: string;
    newOwner: string;
}
export type OwnershipTransferredEvent = TypedEvent<[
    string,
    string
], OwnershipTransferredEventObject>;
export type OwnershipTransferredEventFilter = TypedEventFilter<OwnershipTransferredEvent>;
export interface PauseUpdatedEventObject {
    notPaused: boolean;
}
export type PauseUpdatedEvent = TypedEvent<[boolean], PauseUpdatedEventObject>;
export type PauseUpdatedEventFilter = TypedEventFilter<PauseUpdatedEvent>;
export interface PoolCreatedEventObject {
    nextPoolId: BigNumber;
    firstTokenAllowed: BigNumber;
    limitPool: BigNumber;
    costElectricity: BigNumber;
    lifeTime: BigNumber;
    typeMachine: string;
    area: string;
}
export type PoolCreatedEvent = TypedEvent<[
    BigNumber,
    BigNumber,
    BigNumber,
    BigNumber,
    BigNumber,
    string,
    string
], PoolCreatedEventObject>;
export type PoolCreatedEventFilter = TypedEventFilter<PoolCreatedEvent>;
export interface PoolInformationsUpdatedEventObject {
    poolId: BigNumber;
    firstTokenAllowed: BigNumber;
    limitPool: BigNumber;
    costElectricity: BigNumber;
    lifetime: BigNumber;
    typeMachine: string;
    area: string;
}
export type PoolInformationsUpdatedEvent = TypedEvent<[
    BigNumber,
    BigNumber,
    BigNumber,
    BigNumber,
    BigNumber,
    string,
    string
], PoolInformationsUpdatedEventObject>;
export type PoolInformationsUpdatedEventFilter = TypedEventFilter<PoolInformationsUpdatedEvent>;
export interface Staked721EventObject {
    owner: string;
    itemId: BigNumber;
    poolId: BigNumber;
}
export type Staked721Event = TypedEvent<[
    string,
    BigNumber,
    BigNumber
], Staked721EventObject>;
export type Staked721EventFilter = TypedEventFilter<Staked721Event>;
export interface UnlockPeriodUpdatedEventObject {
    period: BigNumber;
}
export type UnlockPeriodUpdatedEvent = TypedEvent<[
    BigNumber
], UnlockPeriodUpdatedEventObject>;
export type UnlockPeriodUpdatedEventFilter = TypedEventFilter<UnlockPeriodUpdatedEvent>;
export interface Unstaked721EventObject {
    owner: string;
    itemId: BigNumber;
    poolId: BigNumber;
}
export type Unstaked721Event = TypedEvent<[
    string,
    BigNumber,
    BigNumber
], Unstaked721EventObject>;
export type Unstaked721EventFilter = TypedEventFilter<Unstaked721Event>;
export interface StartNft extends BaseContract {
    connect(signerOrProvider: Signer | Provider | string): this;
    attach(addressOrName: string): this;
    deployed(): Promise<this>;
    interface: StartNftInterface;
    queryFilter<TEvent extends TypedEvent>(event: TypedEventFilter<TEvent>, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TEvent>>;
    listeners<TEvent extends TypedEvent>(eventFilter?: TypedEventFilter<TEvent>): Array<TypedListener<TEvent>>;
    listeners(eventName?: string): Array<Listener>;
    removeAllListeners<TEvent extends TypedEvent>(eventFilter: TypedEventFilter<TEvent>): this;
    removeAllListeners(eventName?: string): this;
    off: OnEvent<this>;
    on: OnEvent<this>;
    once: OnEvent<this>;
    removeListener: OnEvent<this>;
    functions: {
        batchStakeERC721(_poolId: BigNumberish, _tokenIds: BigNumberish[], _addressBTC: string, overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        batchUnstakeERC721(_tokenIds: BigNumberish[], overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        createPool(_firstTokenAllowed: BigNumberish, _limitPool: BigNumberish, _costElectricity: BigNumberish, _lifeTime: BigNumberish, _typeMachine: string, _area: string, overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        currentPoolId(overrides?: CallOverrides): Promise<[BigNumber]>;
        getAllStakedERC721(_user: string, overrides?: CallOverrides): Promise<[BigNumber[]]>;
        getAllStakedERC721Pool(_poolId: BigNumberish, overrides?: CallOverrides): Promise<[BigNumber[]]>;
        getAllStakedERC721PoolByUser(_poolId: BigNumberish, _user: string, overrides?: CallOverrides): Promise<[BigNumber[]]>;
        getStakedERC721(_user: string, _tokenId: BigNumberish, overrides?: CallOverrides): Promise<[Staking.ItemInfoStructOutput]>;
        getStakedERC721Pool(_poolId: BigNumberish, _tokenId: BigNumberish, overrides?: CallOverrides): Promise<[Staking.ItemInfoStructOutput]>;
        onERC721Received(arg0: string, arg1: string, arg2: BigNumberish, arg3: BytesLike, overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        owner(overrides?: CallOverrides): Promise<[string]>;
        poolInfos(arg0: BigNumberish, overrides?: CallOverrides): Promise<[
            BigNumber,
            BigNumber,
            BigNumber,
            BigNumber,
            string,
            string
        ] & {
            firstTokenAllowed: BigNumber;
            limitPool: BigNumber;
            costElectricity: BigNumber;
            lifeTime: BigNumber;
            typeMachine: string;
            area: string;
        }>;
        renounceOwnership(overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        setPoolInformation(_poolId: BigNumberish, _firstTokenAllowed: BigNumberish, _limitPool: BigNumberish, _costElectricity: BigNumberish, _lifeTime: BigNumberish, _typeMachine: string, _area: string, overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        setUnlockPeriod(_period: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        stakeERC721(_poolId: BigNumberish, _tokenId: BigNumberish, _addressBTC: string, overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        stakingPaused(overrides?: CallOverrides): Promise<[boolean]>;
        stakingUnlock(overrides?: CallOverrides): Promise<[BigNumber]>;
        toggleStakingPaused(overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        transferOwnership(newOwner: string, overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        unstakeERC721(_tokenId: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
    };
    batchStakeERC721(_poolId: BigNumberish, _tokenIds: BigNumberish[], _addressBTC: string, overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    batchUnstakeERC721(_tokenIds: BigNumberish[], overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    createPool(_firstTokenAllowed: BigNumberish, _limitPool: BigNumberish, _costElectricity: BigNumberish, _lifeTime: BigNumberish, _typeMachine: string, _area: string, overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    currentPoolId(overrides?: CallOverrides): Promise<BigNumber>;
    getAllStakedERC721(_user: string, overrides?: CallOverrides): Promise<BigNumber[]>;
    getAllStakedERC721Pool(_poolId: BigNumberish, overrides?: CallOverrides): Promise<BigNumber[]>;
    getAllStakedERC721PoolByUser(_poolId: BigNumberish, _user: string, overrides?: CallOverrides): Promise<BigNumber[]>;
    getStakedERC721(_user: string, _tokenId: BigNumberish, overrides?: CallOverrides): Promise<Staking.ItemInfoStructOutput>;
    getStakedERC721Pool(_poolId: BigNumberish, _tokenId: BigNumberish, overrides?: CallOverrides): Promise<Staking.ItemInfoStructOutput>;
    onERC721Received(arg0: string, arg1: string, arg2: BigNumberish, arg3: BytesLike, overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    owner(overrides?: CallOverrides): Promise<string>;
    poolInfos(arg0: BigNumberish, overrides?: CallOverrides): Promise<[
        BigNumber,
        BigNumber,
        BigNumber,
        BigNumber,
        string,
        string
    ] & {
        firstTokenAllowed: BigNumber;
        limitPool: BigNumber;
        costElectricity: BigNumber;
        lifeTime: BigNumber;
        typeMachine: string;
        area: string;
    }>;
    renounceOwnership(overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    setPoolInformation(_poolId: BigNumberish, _firstTokenAllowed: BigNumberish, _limitPool: BigNumberish, _costElectricity: BigNumberish, _lifeTime: BigNumberish, _typeMachine: string, _area: string, overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    setUnlockPeriod(_period: BigNumberish, overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    stakeERC721(_poolId: BigNumberish, _tokenId: BigNumberish, _addressBTC: string, overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    stakingPaused(overrides?: CallOverrides): Promise<boolean>;
    stakingUnlock(overrides?: CallOverrides): Promise<BigNumber>;
    toggleStakingPaused(overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    transferOwnership(newOwner: string, overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    unstakeERC721(_tokenId: BigNumberish, overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    callStatic: {
        batchStakeERC721(_poolId: BigNumberish, _tokenIds: BigNumberish[], _addressBTC: string, overrides?: CallOverrides): Promise<void>;
        batchUnstakeERC721(_tokenIds: BigNumberish[], overrides?: CallOverrides): Promise<void>;
        createPool(_firstTokenAllowed: BigNumberish, _limitPool: BigNumberish, _costElectricity: BigNumberish, _lifeTime: BigNumberish, _typeMachine: string, _area: string, overrides?: CallOverrides): Promise<void>;
        currentPoolId(overrides?: CallOverrides): Promise<BigNumber>;
        getAllStakedERC721(_user: string, overrides?: CallOverrides): Promise<BigNumber[]>;
        getAllStakedERC721Pool(_poolId: BigNumberish, overrides?: CallOverrides): Promise<BigNumber[]>;
        getAllStakedERC721PoolByUser(_poolId: BigNumberish, _user: string, overrides?: CallOverrides): Promise<BigNumber[]>;
        getStakedERC721(_user: string, _tokenId: BigNumberish, overrides?: CallOverrides): Promise<Staking.ItemInfoStructOutput>;
        getStakedERC721Pool(_poolId: BigNumberish, _tokenId: BigNumberish, overrides?: CallOverrides): Promise<Staking.ItemInfoStructOutput>;
        onERC721Received(arg0: string, arg1: string, arg2: BigNumberish, arg3: BytesLike, overrides?: CallOverrides): Promise<string>;
        owner(overrides?: CallOverrides): Promise<string>;
        poolInfos(arg0: BigNumberish, overrides?: CallOverrides): Promise<[
            BigNumber,
            BigNumber,
            BigNumber,
            BigNumber,
            string,
            string
        ] & {
            firstTokenAllowed: BigNumber;
            limitPool: BigNumber;
            costElectricity: BigNumber;
            lifeTime: BigNumber;
            typeMachine: string;
            area: string;
        }>;
        renounceOwnership(overrides?: CallOverrides): Promise<void>;
        setPoolInformation(_poolId: BigNumberish, _firstTokenAllowed: BigNumberish, _limitPool: BigNumberish, _costElectricity: BigNumberish, _lifeTime: BigNumberish, _typeMachine: string, _area: string, overrides?: CallOverrides): Promise<void>;
        setUnlockPeriod(_period: BigNumberish, overrides?: CallOverrides): Promise<void>;
        stakeERC721(_poolId: BigNumberish, _tokenId: BigNumberish, _addressBTC: string, overrides?: CallOverrides): Promise<void>;
        stakingPaused(overrides?: CallOverrides): Promise<boolean>;
        stakingUnlock(overrides?: CallOverrides): Promise<BigNumber>;
        toggleStakingPaused(overrides?: CallOverrides): Promise<void>;
        transferOwnership(newOwner: string, overrides?: CallOverrides): Promise<void>;
        unstakeERC721(_tokenId: BigNumberish, overrides?: CallOverrides): Promise<void>;
    };
    filters: {
        "OwnershipTransferred(address,address)"(previousOwner?: string | null, newOwner?: string | null): OwnershipTransferredEventFilter;
        OwnershipTransferred(previousOwner?: string | null, newOwner?: string | null): OwnershipTransferredEventFilter;
        "PauseUpdated(bool)"(notPaused?: null): PauseUpdatedEventFilter;
        PauseUpdated(notPaused?: null): PauseUpdatedEventFilter;
        "PoolCreated(uint256,uint256,uint256,uint256,uint256,string,string)"(nextPoolId?: null, firstTokenAllowed?: null, limitPool?: null, costElectricity?: null, lifeTime?: null, typeMachine?: null, area?: null): PoolCreatedEventFilter;
        PoolCreated(nextPoolId?: null, firstTokenAllowed?: null, limitPool?: null, costElectricity?: null, lifeTime?: null, typeMachine?: null, area?: null): PoolCreatedEventFilter;
        "PoolInformationsUpdated(uint256,uint256,uint256,uint256,uint256,string,string)"(poolId?: null, firstTokenAllowed?: null, limitPool?: null, costElectricity?: null, lifetime?: null, typeMachine?: null, area?: null): PoolInformationsUpdatedEventFilter;
        PoolInformationsUpdated(poolId?: null, firstTokenAllowed?: null, limitPool?: null, costElectricity?: null, lifetime?: null, typeMachine?: null, area?: null): PoolInformationsUpdatedEventFilter;
        "Staked721(address,uint256,uint256)"(owner?: string | null, itemId?: null, poolId?: null): Staked721EventFilter;
        Staked721(owner?: string | null, itemId?: null, poolId?: null): Staked721EventFilter;
        "UnlockPeriodUpdated(uint256)"(period?: null): UnlockPeriodUpdatedEventFilter;
        UnlockPeriodUpdated(period?: null): UnlockPeriodUpdatedEventFilter;
        "Unstaked721(address,uint256,uint256)"(owner?: string | null, itemId?: null, poolId?: null): Unstaked721EventFilter;
        Unstaked721(owner?: string | null, itemId?: null, poolId?: null): Unstaked721EventFilter;
    };
    estimateGas: {
        batchStakeERC721(_poolId: BigNumberish, _tokenIds: BigNumberish[], _addressBTC: string, overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        batchUnstakeERC721(_tokenIds: BigNumberish[], overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        createPool(_firstTokenAllowed: BigNumberish, _limitPool: BigNumberish, _costElectricity: BigNumberish, _lifeTime: BigNumberish, _typeMachine: string, _area: string, overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        currentPoolId(overrides?: CallOverrides): Promise<BigNumber>;
        getAllStakedERC721(_user: string, overrides?: CallOverrides): Promise<BigNumber>;
        getAllStakedERC721Pool(_poolId: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;
        getAllStakedERC721PoolByUser(_poolId: BigNumberish, _user: string, overrides?: CallOverrides): Promise<BigNumber>;
        getStakedERC721(_user: string, _tokenId: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;
        getStakedERC721Pool(_poolId: BigNumberish, _tokenId: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;
        onERC721Received(arg0: string, arg1: string, arg2: BigNumberish, arg3: BytesLike, overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        owner(overrides?: CallOverrides): Promise<BigNumber>;
        poolInfos(arg0: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;
        renounceOwnership(overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        setPoolInformation(_poolId: BigNumberish, _firstTokenAllowed: BigNumberish, _limitPool: BigNumberish, _costElectricity: BigNumberish, _lifeTime: BigNumberish, _typeMachine: string, _area: string, overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        setUnlockPeriod(_period: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        stakeERC721(_poolId: BigNumberish, _tokenId: BigNumberish, _addressBTC: string, overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        stakingPaused(overrides?: CallOverrides): Promise<BigNumber>;
        stakingUnlock(overrides?: CallOverrides): Promise<BigNumber>;
        toggleStakingPaused(overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        transferOwnership(newOwner: string, overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        unstakeERC721(_tokenId: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
    };
    populateTransaction: {
        batchStakeERC721(_poolId: BigNumberish, _tokenIds: BigNumberish[], _addressBTC: string, overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        batchUnstakeERC721(_tokenIds: BigNumberish[], overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        createPool(_firstTokenAllowed: BigNumberish, _limitPool: BigNumberish, _costElectricity: BigNumberish, _lifeTime: BigNumberish, _typeMachine: string, _area: string, overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        currentPoolId(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        getAllStakedERC721(_user: string, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        getAllStakedERC721Pool(_poolId: BigNumberish, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        getAllStakedERC721PoolByUser(_poolId: BigNumberish, _user: string, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        getStakedERC721(_user: string, _tokenId: BigNumberish, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        getStakedERC721Pool(_poolId: BigNumberish, _tokenId: BigNumberish, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        onERC721Received(arg0: string, arg1: string, arg2: BigNumberish, arg3: BytesLike, overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        owner(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        poolInfos(arg0: BigNumberish, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        renounceOwnership(overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        setPoolInformation(_poolId: BigNumberish, _firstTokenAllowed: BigNumberish, _limitPool: BigNumberish, _costElectricity: BigNumberish, _lifeTime: BigNumberish, _typeMachine: string, _area: string, overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        setUnlockPeriod(_period: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        stakeERC721(_poolId: BigNumberish, _tokenId: BigNumberish, _addressBTC: string, overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        stakingPaused(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        stakingUnlock(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        toggleStakingPaused(overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        transferOwnership(newOwner: string, overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        unstakeERC721(_tokenId: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
    };
}