@merkl/contracts 1.2.30 → 1.2.31

package/dist/src/VotingEscrowIncreasing.d.ts

@@ -0,0 +1,683 @@
+import type { BaseContract, BigNumber, BigNumberish, BytesLike, CallOverrides, ContractTransaction, Overrides, PayableOverrides, 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, PromiseOrValue } from "./common";
+export declare namespace ILockedBalanceIncreasing {
+    type LockedBalanceStruct = {
+        amount: PromiseOrValue<BigNumberish>;
+        start: PromiseOrValue<BigNumberish>;
+    };
+    type LockedBalanceStructOutput = [BigNumber, number] & {
+        amount: BigNumber;
+        start: number;
+    };
+}
+export interface VotingEscrowIncreasingInterface extends utils.Interface {
+    functions: {
+        "ESCROW_ADMIN_ROLE()": FunctionFragment;
+        "PAUSER_ROLE()": FunctionFragment;
+        "SWEEPER_ROLE()": FunctionFragment;
+        "beginWithdrawal(uint256)": FunctionFragment;
+        "clock()": FunctionFragment;
+        "createLock(uint256)": FunctionFragment;
+        "createLockFor(uint256,address)": FunctionFragment;
+        "curve()": FunctionFragment;
+        "dao()": FunctionFragment;
+        "decimals()": FunctionFragment;
+        "implementation()": FunctionFragment;
+        "initialize(address,address,address,uint256)": FunctionFragment;
+        "isApprovedOrOwner(address,uint256)": FunctionFragment;
+        "isVoting(uint256)": FunctionFragment;
+        "lastLockId()": FunctionFragment;
+        "lockNFT()": FunctionFragment;
+        "locked(uint256)": FunctionFragment;
+        "minDeposit()": FunctionFragment;
+        "ownedTokens(address)": FunctionFragment;
+        "pause()": FunctionFragment;
+        "paused()": FunctionFragment;
+        "proxiableUUID()": FunctionFragment;
+        "queue()": FunctionFragment;
+        "resetVotesAndBeginWithdrawal(uint256)": FunctionFragment;
+        "setClock(address)": FunctionFragment;
+        "setCurve(address)": FunctionFragment;
+        "setLockNFT(address)": FunctionFragment;
+        "setMinDeposit(uint256)": FunctionFragment;
+        "setQueue(address)": FunctionFragment;
+        "setVoter(address)": FunctionFragment;
+        "sweep()": FunctionFragment;
+        "sweepNFT(uint256,address)": FunctionFragment;
+        "token()": FunctionFragment;
+        "totalLocked()": FunctionFragment;
+        "totalVotingPower()": FunctionFragment;
+        "totalVotingPowerAt(uint256)": FunctionFragment;
+        "unpause()": FunctionFragment;
+        "upgradeTo(address)": FunctionFragment;
+        "upgradeToAndCall(address,bytes)": FunctionFragment;
+        "voter()": FunctionFragment;
+        "votingPower(uint256)": FunctionFragment;
+        "votingPowerAt(uint256,uint256)": FunctionFragment;
+        "votingPowerForAccount(address)": FunctionFragment;
+        "withdraw(uint256)": FunctionFragment;
+    };
+    getFunction(nameOrSignatureOrTopic: "ESCROW_ADMIN_ROLE" | "PAUSER_ROLE" | "SWEEPER_ROLE" | "beginWithdrawal" | "clock" | "createLock" | "createLockFor" | "curve" | "dao" | "decimals" | "implementation" | "initialize" | "isApprovedOrOwner" | "isVoting" | "lastLockId" | "lockNFT" | "locked" | "minDeposit" | "ownedTokens" | "pause" | "paused" | "proxiableUUID" | "queue" | "resetVotesAndBeginWithdrawal" | "setClock" | "setCurve" | "setLockNFT" | "setMinDeposit" | "setQueue" | "setVoter" | "sweep" | "sweepNFT" | "token" | "totalLocked" | "totalVotingPower" | "totalVotingPowerAt" | "unpause" | "upgradeTo" | "upgradeToAndCall" | "voter" | "votingPower" | "votingPowerAt" | "votingPowerForAccount" | "withdraw"): FunctionFragment;
+    encodeFunctionData(functionFragment: "ESCROW_ADMIN_ROLE", values?: undefined): string;
+    encodeFunctionData(functionFragment: "PAUSER_ROLE", values?: undefined): string;
+    encodeFunctionData(functionFragment: "SWEEPER_ROLE", values?: undefined): string;
+    encodeFunctionData(functionFragment: "beginWithdrawal", values: [PromiseOrValue<BigNumberish>]): string;
+    encodeFunctionData(functionFragment: "clock", values?: undefined): string;
+    encodeFunctionData(functionFragment: "createLock", values: [PromiseOrValue<BigNumberish>]): string;
+    encodeFunctionData(functionFragment: "createLockFor", values: [PromiseOrValue<BigNumberish>, PromiseOrValue<string>]): string;
+    encodeFunctionData(functionFragment: "curve", values?: undefined): string;
+    encodeFunctionData(functionFragment: "dao", values?: undefined): string;
+    encodeFunctionData(functionFragment: "decimals", values?: undefined): string;
+    encodeFunctionData(functionFragment: "implementation", values?: undefined): string;
+    encodeFunctionData(functionFragment: "initialize", values: [
+        PromiseOrValue<string>,
+        PromiseOrValue<string>,
+        PromiseOrValue<string>,
+        PromiseOrValue<BigNumberish>
+    ]): string;
+    encodeFunctionData(functionFragment: "isApprovedOrOwner", values: [PromiseOrValue<string>, PromiseOrValue<BigNumberish>]): string;
+    encodeFunctionData(functionFragment: "isVoting", values: [PromiseOrValue<BigNumberish>]): string;
+    encodeFunctionData(functionFragment: "lastLockId", values?: undefined): string;
+    encodeFunctionData(functionFragment: "lockNFT", values?: undefined): string;
+    encodeFunctionData(functionFragment: "locked", values: [PromiseOrValue<BigNumberish>]): string;
+    encodeFunctionData(functionFragment: "minDeposit", values?: undefined): string;
+    encodeFunctionData(functionFragment: "ownedTokens", values: [PromiseOrValue<string>]): string;
+    encodeFunctionData(functionFragment: "pause", values?: undefined): string;
+    encodeFunctionData(functionFragment: "paused", values?: undefined): string;
+    encodeFunctionData(functionFragment: "proxiableUUID", values?: undefined): string;
+    encodeFunctionData(functionFragment: "queue", values?: undefined): string;
+    encodeFunctionData(functionFragment: "resetVotesAndBeginWithdrawal", values: [PromiseOrValue<BigNumberish>]): string;
+    encodeFunctionData(functionFragment: "setClock", values: [PromiseOrValue<string>]): string;
+    encodeFunctionData(functionFragment: "setCurve", values: [PromiseOrValue<string>]): string;
+    encodeFunctionData(functionFragment: "setLockNFT", values: [PromiseOrValue<string>]): string;
+    encodeFunctionData(functionFragment: "setMinDeposit", values: [PromiseOrValue<BigNumberish>]): string;
+    encodeFunctionData(functionFragment: "setQueue", values: [PromiseOrValue<string>]): string;
+    encodeFunctionData(functionFragment: "setVoter", values: [PromiseOrValue<string>]): string;
+    encodeFunctionData(functionFragment: "sweep", values?: undefined): string;
+    encodeFunctionData(functionFragment: "sweepNFT", values: [PromiseOrValue<BigNumberish>, PromiseOrValue<string>]): string;
+    encodeFunctionData(functionFragment: "token", values?: undefined): string;
+    encodeFunctionData(functionFragment: "totalLocked", values?: undefined): string;
+    encodeFunctionData(functionFragment: "totalVotingPower", values?: undefined): string;
+    encodeFunctionData(functionFragment: "totalVotingPowerAt", values: [PromiseOrValue<BigNumberish>]): string;
+    encodeFunctionData(functionFragment: "unpause", values?: undefined): string;
+    encodeFunctionData(functionFragment: "upgradeTo", values: [PromiseOrValue<string>]): string;
+    encodeFunctionData(functionFragment: "upgradeToAndCall", values: [PromiseOrValue<string>, PromiseOrValue<BytesLike>]): string;
+    encodeFunctionData(functionFragment: "voter", values?: undefined): string;
+    encodeFunctionData(functionFragment: "votingPower", values: [PromiseOrValue<BigNumberish>]): string;
+    encodeFunctionData(functionFragment: "votingPowerAt", values: [PromiseOrValue<BigNumberish>, PromiseOrValue<BigNumberish>]): string;
+    encodeFunctionData(functionFragment: "votingPowerForAccount", values: [PromiseOrValue<string>]): string;
+    encodeFunctionData(functionFragment: "withdraw", values: [PromiseOrValue<BigNumberish>]): string;
+    decodeFunctionResult(functionFragment: "ESCROW_ADMIN_ROLE", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "PAUSER_ROLE", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "SWEEPER_ROLE", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "beginWithdrawal", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "clock", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "createLock", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "createLockFor", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "curve", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "dao", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "decimals", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "implementation", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "initialize", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "isApprovedOrOwner", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "isVoting", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "lastLockId", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "lockNFT", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "locked", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "minDeposit", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "ownedTokens", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "pause", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "paused", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "proxiableUUID", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "queue", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "resetVotesAndBeginWithdrawal", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "setClock", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "setCurve", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "setLockNFT", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "setMinDeposit", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "setQueue", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "setVoter", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "sweep", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "sweepNFT", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "token", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "totalLocked", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "totalVotingPower", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "totalVotingPowerAt", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "unpause", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "upgradeTo", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "upgradeToAndCall", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "voter", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "votingPower", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "votingPowerAt", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "votingPowerForAccount", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "withdraw", data: BytesLike): Result;
+    events: {
+        "AdminChanged(address,address)": EventFragment;
+        "BeaconUpgraded(address)": EventFragment;
+        "Deposit(address,uint256,uint256,uint256,uint256)": EventFragment;
+        "Initialized(uint8)": EventFragment;
+        "MinDepositSet(uint256)": EventFragment;
+        "Paused(address)": EventFragment;
+        "Sweep(address,uint256)": EventFragment;
+        "SweepNFT(address,uint256)": EventFragment;
+        "Unpaused(address)": EventFragment;
+        "Upgraded(address)": EventFragment;
+        "Withdraw(address,uint256,uint256,uint256,uint256)": EventFragment;
+    };
+    getEvent(nameOrSignatureOrTopic: "AdminChanged"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "BeaconUpgraded"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "Deposit"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "Initialized"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "MinDepositSet"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "Paused"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "Sweep"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "SweepNFT"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "Unpaused"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "Upgraded"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "Withdraw"): EventFragment;
+}
+export interface AdminChangedEventObject {
+    previousAdmin: string;
+    newAdmin: string;
+}
+export type AdminChangedEvent = TypedEvent<[
+    string,
+    string
+], AdminChangedEventObject>;
+export type AdminChangedEventFilter = TypedEventFilter<AdminChangedEvent>;
+export interface BeaconUpgradedEventObject {
+    beacon: string;
+}
+export type BeaconUpgradedEvent = TypedEvent<[
+    string
+], BeaconUpgradedEventObject>;
+export type BeaconUpgradedEventFilter = TypedEventFilter<BeaconUpgradedEvent>;
+export interface DepositEventObject {
+    depositor: string;
+    tokenId: BigNumber;
+    startTs: BigNumber;
+    value: BigNumber;
+    newTotalLocked: BigNumber;
+}
+export type DepositEvent = TypedEvent<[
+    string,
+    BigNumber,
+    BigNumber,
+    BigNumber,
+    BigNumber
+], DepositEventObject>;
+export type DepositEventFilter = TypedEventFilter<DepositEvent>;
+export interface InitializedEventObject {
+    version: number;
+}
+export type InitializedEvent = TypedEvent<[number], InitializedEventObject>;
+export type InitializedEventFilter = TypedEventFilter<InitializedEvent>;
+export interface MinDepositSetEventObject {
+    minDeposit: BigNumber;
+}
+export type MinDepositSetEvent = TypedEvent<[
+    BigNumber
+], MinDepositSetEventObject>;
+export type MinDepositSetEventFilter = TypedEventFilter<MinDepositSetEvent>;
+export interface PausedEventObject {
+    account: string;
+}
+export type PausedEvent = TypedEvent<[string], PausedEventObject>;
+export type PausedEventFilter = TypedEventFilter<PausedEvent>;
+export interface SweepEventObject {
+    to: string;
+    amount: BigNumber;
+}
+export type SweepEvent = TypedEvent<[string, BigNumber], SweepEventObject>;
+export type SweepEventFilter = TypedEventFilter<SweepEvent>;
+export interface SweepNFTEventObject {
+    to: string;
+    tokenId: BigNumber;
+}
+export type SweepNFTEvent = TypedEvent<[
+    string,
+    BigNumber
+], SweepNFTEventObject>;
+export type SweepNFTEventFilter = TypedEventFilter<SweepNFTEvent>;
+export interface UnpausedEventObject {
+    account: string;
+}
+export type UnpausedEvent = TypedEvent<[string], UnpausedEventObject>;
+export type UnpausedEventFilter = TypedEventFilter<UnpausedEvent>;
+export interface UpgradedEventObject {
+    implementation: string;
+}
+export type UpgradedEvent = TypedEvent<[string], UpgradedEventObject>;
+export type UpgradedEventFilter = TypedEventFilter<UpgradedEvent>;
+export interface WithdrawEventObject {
+    depositor: string;
+    tokenId: BigNumber;
+    value: BigNumber;
+    ts: BigNumber;
+    newTotalLocked: BigNumber;
+}
+export type WithdrawEvent = TypedEvent<[
+    string,
+    BigNumber,
+    BigNumber,
+    BigNumber,
+    BigNumber
+], WithdrawEventObject>;
+export type WithdrawEventFilter = TypedEventFilter<WithdrawEvent>;
+export interface VotingEscrowIncreasing extends BaseContract {
+    connect(signerOrProvider: Signer | Provider | string): this;
+    attach(addressOrName: string): this;
+    deployed(): Promise<this>;
+    interface: VotingEscrowIncreasingInterface;
+    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: {
+        ESCROW_ADMIN_ROLE(overrides?: CallOverrides): Promise<[string]>;
+        PAUSER_ROLE(overrides?: CallOverrides): Promise<[string]>;
+        SWEEPER_ROLE(overrides?: CallOverrides): Promise<[string]>;
+        beginWithdrawal(_tokenId: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        clock(overrides?: CallOverrides): Promise<[string]>;
+        createLock(_value: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        createLockFor(_value: PromiseOrValue<BigNumberish>, _to: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        curve(overrides?: CallOverrides): Promise<[string]>;
+        dao(overrides?: CallOverrides): Promise<[string]>;
+        decimals(overrides?: CallOverrides): Promise<[number]>;
+        implementation(overrides?: CallOverrides): Promise<[string]>;
+        initialize(_token: PromiseOrValue<string>, _dao: PromiseOrValue<string>, _clock: PromiseOrValue<string>, _initialMinDeposit: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        isApprovedOrOwner(_spender: PromiseOrValue<string>, _tokenId: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<[boolean]>;
+        isVoting(_tokenId: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<[boolean]>;
+        lastLockId(overrides?: CallOverrides): Promise<[BigNumber]>;
+        lockNFT(overrides?: CallOverrides): Promise<[string]>;
+        locked(_tokenId: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<[ILockedBalanceIncreasing.LockedBalanceStructOutput]>;
+        minDeposit(overrides?: CallOverrides): Promise<[BigNumber]>;
+        ownedTokens(_owner: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[BigNumber[]] & {
+            tokenIds: BigNumber[];
+        }>;
+        pause(overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        paused(overrides?: CallOverrides): Promise<[boolean]>;
+        proxiableUUID(overrides?: CallOverrides): Promise<[string]>;
+        queue(overrides?: CallOverrides): Promise<[string]>;
+        resetVotesAndBeginWithdrawal(_tokenId: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        setClock(_clock: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        setCurve(_curve: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        setLockNFT(_nft: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        setMinDeposit(_minDeposit: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        setQueue(_queue: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        setVoter(_voter: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        sweep(overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        sweepNFT(_tokenId: PromiseOrValue<BigNumberish>, _to: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        token(overrides?: CallOverrides): Promise<[string]>;
+        totalLocked(overrides?: CallOverrides): Promise<[BigNumber]>;
+        totalVotingPower(overrides?: CallOverrides): Promise<[BigNumber]>;
+        totalVotingPowerAt(_timestamp: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<[BigNumber]>;
+        unpause(overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        upgradeTo(newImplementation: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        upgradeToAndCall(newImplementation: PromiseOrValue<string>, data: PromiseOrValue<BytesLike>, overrides?: PayableOverrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        voter(overrides?: CallOverrides): Promise<[string]>;
+        votingPower(_tokenId: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<[BigNumber]>;
+        votingPowerAt(_tokenId: PromiseOrValue<BigNumberish>, _t: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<[BigNumber]>;
+        votingPowerForAccount(_account: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[BigNumber] & {
+            accountVotingPower: BigNumber;
+        }>;
+        withdraw(_tokenId: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+    };
+    ESCROW_ADMIN_ROLE(overrides?: CallOverrides): Promise<string>;
+    PAUSER_ROLE(overrides?: CallOverrides): Promise<string>;
+    SWEEPER_ROLE(overrides?: CallOverrides): Promise<string>;
+    beginWithdrawal(_tokenId: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    clock(overrides?: CallOverrides): Promise<string>;
+    createLock(_value: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    createLockFor(_value: PromiseOrValue<BigNumberish>, _to: PromiseOrValue<string>, overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    curve(overrides?: CallOverrides): Promise<string>;
+    dao(overrides?: CallOverrides): Promise<string>;
+    decimals(overrides?: CallOverrides): Promise<number>;
+    implementation(overrides?: CallOverrides): Promise<string>;
+    initialize(_token: PromiseOrValue<string>, _dao: PromiseOrValue<string>, _clock: PromiseOrValue<string>, _initialMinDeposit: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    isApprovedOrOwner(_spender: PromiseOrValue<string>, _tokenId: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<boolean>;
+    isVoting(_tokenId: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<boolean>;
+    lastLockId(overrides?: CallOverrides): Promise<BigNumber>;
+    lockNFT(overrides?: CallOverrides): Promise<string>;
+    locked(_tokenId: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<ILockedBalanceIncreasing.LockedBalanceStructOutput>;
+    minDeposit(overrides?: CallOverrides): Promise<BigNumber>;
+    ownedTokens(_owner: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber[]>;
+    pause(overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    paused(overrides?: CallOverrides): Promise<boolean>;
+    proxiableUUID(overrides?: CallOverrides): Promise<string>;
+    queue(overrides?: CallOverrides): Promise<string>;
+    resetVotesAndBeginWithdrawal(_tokenId: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    setClock(_clock: PromiseOrValue<string>, overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    setCurve(_curve: PromiseOrValue<string>, overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    setLockNFT(_nft: PromiseOrValue<string>, overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    setMinDeposit(_minDeposit: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    setQueue(_queue: PromiseOrValue<string>, overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    setVoter(_voter: PromiseOrValue<string>, overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    sweep(overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    sweepNFT(_tokenId: PromiseOrValue<BigNumberish>, _to: PromiseOrValue<string>, overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    token(overrides?: CallOverrides): Promise<string>;
+    totalLocked(overrides?: CallOverrides): Promise<BigNumber>;
+    totalVotingPower(overrides?: CallOverrides): Promise<BigNumber>;
+    totalVotingPowerAt(_timestamp: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<BigNumber>;
+    unpause(overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    upgradeTo(newImplementation: PromiseOrValue<string>, overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    upgradeToAndCall(newImplementation: PromiseOrValue<string>, data: PromiseOrValue<BytesLike>, overrides?: PayableOverrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    voter(overrides?: CallOverrides): Promise<string>;
+    votingPower(_tokenId: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<BigNumber>;
+    votingPowerAt(_tokenId: PromiseOrValue<BigNumberish>, _t: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<BigNumber>;
+    votingPowerForAccount(_account: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
+    withdraw(_tokenId: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    callStatic: {
+        ESCROW_ADMIN_ROLE(overrides?: CallOverrides): Promise<string>;
+        PAUSER_ROLE(overrides?: CallOverrides): Promise<string>;
+        SWEEPER_ROLE(overrides?: CallOverrides): Promise<string>;
+        beginWithdrawal(_tokenId: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<void>;
+        clock(overrides?: CallOverrides): Promise<string>;
+        createLock(_value: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<BigNumber>;
+        createLockFor(_value: PromiseOrValue<BigNumberish>, _to: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
+        curve(overrides?: CallOverrides): Promise<string>;
+        dao(overrides?: CallOverrides): Promise<string>;
+        decimals(overrides?: CallOverrides): Promise<number>;
+        implementation(overrides?: CallOverrides): Promise<string>;
+        initialize(_token: PromiseOrValue<string>, _dao: PromiseOrValue<string>, _clock: PromiseOrValue<string>, _initialMinDeposit: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<void>;
+        isApprovedOrOwner(_spender: PromiseOrValue<string>, _tokenId: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<boolean>;
+        isVoting(_tokenId: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<boolean>;
+        lastLockId(overrides?: CallOverrides): Promise<BigNumber>;
+        lockNFT(overrides?: CallOverrides): Promise<string>;
+        locked(_tokenId: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<ILockedBalanceIncreasing.LockedBalanceStructOutput>;
+        minDeposit(overrides?: CallOverrides): Promise<BigNumber>;
+        ownedTokens(_owner: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber[]>;
+        pause(overrides?: CallOverrides): Promise<void>;
+        paused(overrides?: CallOverrides): Promise<boolean>;
+        proxiableUUID(overrides?: CallOverrides): Promise<string>;
+        queue(overrides?: CallOverrides): Promise<string>;
+        resetVotesAndBeginWithdrawal(_tokenId: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<void>;
+        setClock(_clock: PromiseOrValue<string>, overrides?: CallOverrides): Promise<void>;
+        setCurve(_curve: PromiseOrValue<string>, overrides?: CallOverrides): Promise<void>;
+        setLockNFT(_nft: PromiseOrValue<string>, overrides?: CallOverrides): Promise<void>;
+        setMinDeposit(_minDeposit: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<void>;
+        setQueue(_queue: PromiseOrValue<string>, overrides?: CallOverrides): Promise<void>;
+        setVoter(_voter: PromiseOrValue<string>, overrides?: CallOverrides): Promise<void>;
+        sweep(overrides?: CallOverrides): Promise<void>;
+        sweepNFT(_tokenId: PromiseOrValue<BigNumberish>, _to: PromiseOrValue<string>, overrides?: CallOverrides): Promise<void>;
+        token(overrides?: CallOverrides): Promise<string>;
+        totalLocked(overrides?: CallOverrides): Promise<BigNumber>;
+        totalVotingPower(overrides?: CallOverrides): Promise<BigNumber>;
+        totalVotingPowerAt(_timestamp: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<BigNumber>;
+        unpause(overrides?: CallOverrides): Promise<void>;
+        upgradeTo(newImplementation: PromiseOrValue<string>, overrides?: CallOverrides): Promise<void>;
+        upgradeToAndCall(newImplementation: PromiseOrValue<string>, data: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<void>;
+        voter(overrides?: CallOverrides): Promise<string>;
+        votingPower(_tokenId: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<BigNumber>;
+        votingPowerAt(_tokenId: PromiseOrValue<BigNumberish>, _t: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<BigNumber>;
+        votingPowerForAccount(_account: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
+        withdraw(_tokenId: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<void>;
+    };
+    filters: {
+        "AdminChanged(address,address)"(previousAdmin?: null, newAdmin?: null): AdminChangedEventFilter;
+        AdminChanged(previousAdmin?: null, newAdmin?: null): AdminChangedEventFilter;
+        "BeaconUpgraded(address)"(beacon?: PromiseOrValue<string> | null): BeaconUpgradedEventFilter;
+        BeaconUpgraded(beacon?: PromiseOrValue<string> | null): BeaconUpgradedEventFilter;
+        "Deposit(address,uint256,uint256,uint256,uint256)"(depositor?: PromiseOrValue<string> | null, tokenId?: PromiseOrValue<BigNumberish> | null, startTs?: PromiseOrValue<BigNumberish> | null, value?: null, newTotalLocked?: null): DepositEventFilter;
+        Deposit(depositor?: PromiseOrValue<string> | null, tokenId?: PromiseOrValue<BigNumberish> | null, startTs?: PromiseOrValue<BigNumberish> | null, value?: null, newTotalLocked?: null): DepositEventFilter;
+        "Initialized(uint8)"(version?: null): InitializedEventFilter;
+        Initialized(version?: null): InitializedEventFilter;
+        "MinDepositSet(uint256)"(minDeposit?: null): MinDepositSetEventFilter;
+        MinDepositSet(minDeposit?: null): MinDepositSetEventFilter;
+        "Paused(address)"(account?: null): PausedEventFilter;
+        Paused(account?: null): PausedEventFilter;
+        "Sweep(address,uint256)"(to?: PromiseOrValue<string> | null, amount?: null): SweepEventFilter;
+        Sweep(to?: PromiseOrValue<string> | null, amount?: null): SweepEventFilter;
+        "SweepNFT(address,uint256)"(to?: PromiseOrValue<string> | null, tokenId?: null): SweepNFTEventFilter;
+        SweepNFT(to?: PromiseOrValue<string> | null, tokenId?: null): SweepNFTEventFilter;
+        "Unpaused(address)"(account?: null): UnpausedEventFilter;
+        Unpaused(account?: null): UnpausedEventFilter;
+        "Upgraded(address)"(implementation?: PromiseOrValue<string> | null): UpgradedEventFilter;
+        Upgraded(implementation?: PromiseOrValue<string> | null): UpgradedEventFilter;
+        "Withdraw(address,uint256,uint256,uint256,uint256)"(depositor?: PromiseOrValue<string> | null, tokenId?: PromiseOrValue<BigNumberish> | null, value?: null, ts?: null, newTotalLocked?: null): WithdrawEventFilter;
+        Withdraw(depositor?: PromiseOrValue<string> | null, tokenId?: PromiseOrValue<BigNumberish> | null, value?: null, ts?: null, newTotalLocked?: null): WithdrawEventFilter;
+    };
+    estimateGas: {
+        ESCROW_ADMIN_ROLE(overrides?: CallOverrides): Promise<BigNumber>;
+        PAUSER_ROLE(overrides?: CallOverrides): Promise<BigNumber>;
+        SWEEPER_ROLE(overrides?: CallOverrides): Promise<BigNumber>;
+        beginWithdrawal(_tokenId: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        clock(overrides?: CallOverrides): Promise<BigNumber>;
+        createLock(_value: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        createLockFor(_value: PromiseOrValue<BigNumberish>, _to: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        curve(overrides?: CallOverrides): Promise<BigNumber>;
+        dao(overrides?: CallOverrides): Promise<BigNumber>;
+        decimals(overrides?: CallOverrides): Promise<BigNumber>;
+        implementation(overrides?: CallOverrides): Promise<BigNumber>;
+        initialize(_token: PromiseOrValue<string>, _dao: PromiseOrValue<string>, _clock: PromiseOrValue<string>, _initialMinDeposit: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        isApprovedOrOwner(_spender: PromiseOrValue<string>, _tokenId: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<BigNumber>;
+        isVoting(_tokenId: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<BigNumber>;
+        lastLockId(overrides?: CallOverrides): Promise<BigNumber>;
+        lockNFT(overrides?: CallOverrides): Promise<BigNumber>;
+        locked(_tokenId: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<BigNumber>;
+        minDeposit(overrides?: CallOverrides): Promise<BigNumber>;
+        ownedTokens(_owner: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
+        pause(overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        paused(overrides?: CallOverrides): Promise<BigNumber>;
+        proxiableUUID(overrides?: CallOverrides): Promise<BigNumber>;
+        queue(overrides?: CallOverrides): Promise<BigNumber>;
+        resetVotesAndBeginWithdrawal(_tokenId: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        setClock(_clock: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        setCurve(_curve: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        setLockNFT(_nft: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        setMinDeposit(_minDeposit: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        setQueue(_queue: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        setVoter(_voter: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        sweep(overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        sweepNFT(_tokenId: PromiseOrValue<BigNumberish>, _to: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        token(overrides?: CallOverrides): Promise<BigNumber>;
+        totalLocked(overrides?: CallOverrides): Promise<BigNumber>;
+        totalVotingPower(overrides?: CallOverrides): Promise<BigNumber>;
+        totalVotingPowerAt(_timestamp: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<BigNumber>;
+        unpause(overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        upgradeTo(newImplementation: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        upgradeToAndCall(newImplementation: PromiseOrValue<string>, data: PromiseOrValue<BytesLike>, overrides?: PayableOverrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        voter(overrides?: CallOverrides): Promise<BigNumber>;
+        votingPower(_tokenId: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<BigNumber>;
+        votingPowerAt(_tokenId: PromiseOrValue<BigNumberish>, _t: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<BigNumber>;
+        votingPowerForAccount(_account: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
+        withdraw(_tokenId: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+    };
+    populateTransaction: {
+        ESCROW_ADMIN_ROLE(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        PAUSER_ROLE(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        SWEEPER_ROLE(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        beginWithdrawal(_tokenId: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        clock(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        createLock(_value: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        createLockFor(_value: PromiseOrValue<BigNumberish>, _to: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        curve(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        dao(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        decimals(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        implementation(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        initialize(_token: PromiseOrValue<string>, _dao: PromiseOrValue<string>, _clock: PromiseOrValue<string>, _initialMinDeposit: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        isApprovedOrOwner(_spender: PromiseOrValue<string>, _tokenId: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        isVoting(_tokenId: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        lastLockId(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        lockNFT(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        locked(_tokenId: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        minDeposit(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        ownedTokens(_owner: PromiseOrValue<string>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        pause(overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        paused(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        proxiableUUID(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        queue(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        resetVotesAndBeginWithdrawal(_tokenId: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        setClock(_clock: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        setCurve(_curve: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        setLockNFT(_nft: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        setMinDeposit(_minDeposit: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        setQueue(_queue: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        setVoter(_voter: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        sweep(overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        sweepNFT(_tokenId: PromiseOrValue<BigNumberish>, _to: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        token(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        totalLocked(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        totalVotingPower(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        totalVotingPowerAt(_timestamp: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        unpause(overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        upgradeTo(newImplementation: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        upgradeToAndCall(newImplementation: PromiseOrValue<string>, data: PromiseOrValue<BytesLike>, overrides?: PayableOverrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        voter(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        votingPower(_tokenId: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        votingPowerAt(_tokenId: PromiseOrValue<BigNumberish>, _t: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        votingPowerForAccount(_account: PromiseOrValue<string>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        withdraw(_tokenId: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+    };
+}