@zkp2p/contracts-v2 0.3.0 → 0.3.1-rc.0

package/_types/types/contracts/interfaces/IStakeVault.d.ts

@@ -0,0 +1,1232 @@
+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, PromiseOrValue } from "../../common";
+export declare namespace IIntentRiskHook {
+    type FeeAllocationStruct = {
+        feeType: PromiseOrValue<BigNumberish>;
+        recipient: PromiseOrValue<string>;
+        amount: PromiseOrValue<BigNumberish>;
+    };
+    type FeeAllocationStructOutput = [number, string, BigNumber] & {
+        feeType: number;
+        recipient: string;
+        amount: BigNumber;
+    };
+}
+export declare namespace IStakeVault {
+    type DeferredStakeStruct = {
+        staker: PromiseOrValue<string>;
+        controller: PromiseOrValue<string>;
+        grossAmount: PromiseOrValue<BigNumberish>;
+        feeAmount: PromiseOrValue<BigNumberish>;
+        releaseTime: PromiseOrValue<BigNumberish>;
+        funded: PromiseOrValue<boolean>;
+    };
+    type DeferredStakeStructOutput = [
+        string,
+        string,
+        BigNumber,
+        BigNumber,
+        BigNumber,
+        boolean
+    ] & {
+        staker: string;
+        controller: string;
+        grossAmount: BigNumber;
+        feeAmount: BigNumber;
+        releaseTime: BigNumber;
+        funded: boolean;
+    };
+    type ExitRequestStruct = {
+        exiting: PromiseOrValue<boolean>;
+        requestedAt: PromiseOrValue<BigNumberish>;
+        availableAt: PromiseOrValue<BigNumberish>;
+    };
+    type ExitRequestStructOutput = [boolean, BigNumber, BigNumber] & {
+        exiting: boolean;
+        requestedAt: BigNumber;
+        availableAt: BigNumber;
+    };
+    type ReservationStruct = {
+        staker: PromiseOrValue<string>;
+        controller: PromiseOrValue<string>;
+        amount: PromiseOrValue<BigNumberish>;
+        releaseTime: PromiseOrValue<BigNumberish>;
+        active: PromiseOrValue<boolean>;
+    };
+    type ReservationStructOutput = [
+        string,
+        string,
+        BigNumber,
+        BigNumber,
+        boolean
+    ] & {
+        staker: string;
+        controller: string;
+        amount: BigNumber;
+        releaseTime: BigNumber;
+        active: boolean;
+    };
+    type StakeWithdrawalRequestStruct = {
+        amount: PromiseOrValue<BigNumberish>;
+        requestedAt: PromiseOrValue<BigNumberish>;
+        availableAt: PromiseOrValue<BigNumberish>;
+    };
+    type StakeWithdrawalRequestStructOutput = [
+        BigNumber,
+        BigNumber,
+        BigNumber
+    ] & {
+        amount: BigNumber;
+        requestedAt: BigNumber;
+        availableAt: BigNumber;
+    };
+}
+export interface IStakeVaultInterface extends utils.Interface {
+    functions: {
+        "acceptController()": FunctionFragment;
+        "allowedStakeOwner(address)": FunctionFragment;
+        "authorizeDeferredStake(bytes32,address,uint64)": FunctionFragment;
+        "cancelExit()": FunctionFragment;
+        "cancelStakeWithdrawal()": FunctionFragment;
+        "claimableCompensation(address)": FunctionFragment;
+        "claimableFees(address)": FunctionFragment;
+        "clearStakeOwner()": FunctionFragment;
+        "controller()": FunctionFragment;
+        "depositStake(uint256)": FunctionFragment;
+        "depositStakeFor(address,uint256)": FunctionFragment;
+        "eligibleStake(address)": FunctionFragment;
+        "freeStake(address)": FunctionFragment;
+        "getDeferredFeeAllocations(bytes32)": FunctionFragment;
+        "getDeferredStake(bytes32)": FunctionFragment;
+        "getExitRequest(address)": FunctionFragment;
+        "getReservation(bytes32)": FunctionFragment;
+        "getStakeWithdrawalRequest(address)": FunctionFragment;
+        "increaseReservation(bytes32,uint256,uint64)": FunctionFragment;
+        "initializeController(address)": FunctionFragment;
+        "isExiting(address)": FunctionFragment;
+        "proposeController(address)": FunctionFragment;
+        "recordDeferredStake(bytes32,address,uint256,uint64,(uint8,address,uint256)[])": FunctionFragment;
+        "releaseDeferredStake(bytes32)": FunctionFragment;
+        "releaseDeferredStakeAuthorization(bytes32)": FunctionFragment;
+        "releaseReservation(bytes32)": FunctionFragment;
+        "requestExit()": FunctionFragment;
+        "requestStakeWithdrawal(uint256)": FunctionFragment;
+        "reserveStake(address,bytes32,uint256,uint64)": FunctionFragment;
+        "reservedStake(address)": FunctionFragment;
+        "setAllowedStakeOwner(address)": FunctionFragment;
+        "setStakeDelegationEnabled(bool)": FunctionFragment;
+        "setStakeOperationsPaused(bool,bool)": FunctionFragment;
+        "setTakerAuthorization(address,bool)": FunctionFragment;
+        "setTakerAuthorizations(address[],bool)": FunctionFragment;
+        "slashDeferredStake(bytes32,address)": FunctionFragment;
+        "slashReservation(bytes32,address,uint256)": FunctionFragment;
+        "stakeBalance(address)": FunctionFragment;
+        "stakeDelegationEnabled(address)": FunctionFragment;
+        "stakeOwnerOf(address)": FunctionFragment;
+        "stakeToken()": FunctionFragment;
+        "totalClaimableFees()": FunctionFragment;
+        "totalDeferredFees()": FunctionFragment;
+        "totalLiabilities()": FunctionFragment;
+        "updateReservation(bytes32,uint256,uint64)": FunctionFragment;
+        "withdrawCompensation(address)": FunctionFragment;
+        "withdrawFeeClaim(address)": FunctionFragment;
+        "withdrawFeeClaimFor(address)": FunctionFragment;
+        "withdrawRequestedStake(address)": FunctionFragment;
+        "withdrawStake(address)": FunctionFragment;
+    };
+    getFunction(nameOrSignatureOrTopic: "acceptController" | "allowedStakeOwner" | "authorizeDeferredStake" | "cancelExit" | "cancelStakeWithdrawal" | "claimableCompensation" | "claimableFees" | "clearStakeOwner" | "controller" | "depositStake" | "depositStakeFor" | "eligibleStake" | "freeStake" | "getDeferredFeeAllocations" | "getDeferredStake" | "getExitRequest" | "getReservation" | "getStakeWithdrawalRequest" | "increaseReservation" | "initializeController" | "isExiting" | "proposeController" | "recordDeferredStake" | "releaseDeferredStake" | "releaseDeferredStakeAuthorization" | "releaseReservation" | "requestExit" | "requestStakeWithdrawal" | "reserveStake" | "reservedStake" | "setAllowedStakeOwner" | "setStakeDelegationEnabled" | "setStakeOperationsPaused" | "setTakerAuthorization" | "setTakerAuthorizations" | "slashDeferredStake" | "slashReservation" | "stakeBalance" | "stakeDelegationEnabled" | "stakeOwnerOf" | "stakeToken" | "totalClaimableFees" | "totalDeferredFees" | "totalLiabilities" | "updateReservation" | "withdrawCompensation" | "withdrawFeeClaim" | "withdrawFeeClaimFor" | "withdrawRequestedStake" | "withdrawStake"): FunctionFragment;
+    encodeFunctionData(functionFragment: "acceptController", values?: undefined): string;
+    encodeFunctionData(functionFragment: "allowedStakeOwner", values: [PromiseOrValue<string>]): string;
+    encodeFunctionData(functionFragment: "authorizeDeferredStake", values: [
+        PromiseOrValue<BytesLike>,
+        PromiseOrValue<string>,
+        PromiseOrValue<BigNumberish>
+    ]): string;
+    encodeFunctionData(functionFragment: "cancelExit", values?: undefined): string;
+    encodeFunctionData(functionFragment: "cancelStakeWithdrawal", values?: undefined): string;
+    encodeFunctionData(functionFragment: "claimableCompensation", values: [PromiseOrValue<string>]): string;
+    encodeFunctionData(functionFragment: "claimableFees", values: [PromiseOrValue<string>]): string;
+    encodeFunctionData(functionFragment: "clearStakeOwner", values?: undefined): string;
+    encodeFunctionData(functionFragment: "controller", values?: undefined): string;
+    encodeFunctionData(functionFragment: "depositStake", values: [PromiseOrValue<BigNumberish>]): string;
+    encodeFunctionData(functionFragment: "depositStakeFor", values: [PromiseOrValue<string>, PromiseOrValue<BigNumberish>]): string;
+    encodeFunctionData(functionFragment: "eligibleStake", values: [PromiseOrValue<string>]): string;
+    encodeFunctionData(functionFragment: "freeStake", values: [PromiseOrValue<string>]): string;
+    encodeFunctionData(functionFragment: "getDeferredFeeAllocations", values: [PromiseOrValue<BytesLike>]): string;
+    encodeFunctionData(functionFragment: "getDeferredStake", values: [PromiseOrValue<BytesLike>]): string;
+    encodeFunctionData(functionFragment: "getExitRequest", values: [PromiseOrValue<string>]): string;
+    encodeFunctionData(functionFragment: "getReservation", values: [PromiseOrValue<BytesLike>]): string;
+    encodeFunctionData(functionFragment: "getStakeWithdrawalRequest", values: [PromiseOrValue<string>]): string;
+    encodeFunctionData(functionFragment: "increaseReservation", values: [
+        PromiseOrValue<BytesLike>,
+        PromiseOrValue<BigNumberish>,
+        PromiseOrValue<BigNumberish>
+    ]): string;
+    encodeFunctionData(functionFragment: "initializeController", values: [PromiseOrValue<string>]): string;
+    encodeFunctionData(functionFragment: "isExiting", values: [PromiseOrValue<string>]): string;
+    encodeFunctionData(functionFragment: "proposeController", values: [PromiseOrValue<string>]): string;
+    encodeFunctionData(functionFragment: "recordDeferredStake", values: [
+        PromiseOrValue<BytesLike>,
+        PromiseOrValue<string>,
+        PromiseOrValue<BigNumberish>,
+        PromiseOrValue<BigNumberish>,
+        IIntentRiskHook.FeeAllocationStruct[]
+    ]): string;
+    encodeFunctionData(functionFragment: "releaseDeferredStake", values: [PromiseOrValue<BytesLike>]): string;
+    encodeFunctionData(functionFragment: "releaseDeferredStakeAuthorization", values: [PromiseOrValue<BytesLike>]): string;
+    encodeFunctionData(functionFragment: "releaseReservation", values: [PromiseOrValue<BytesLike>]): string;
+    encodeFunctionData(functionFragment: "requestExit", values?: undefined): string;
+    encodeFunctionData(functionFragment: "requestStakeWithdrawal", values: [PromiseOrValue<BigNumberish>]): string;
+    encodeFunctionData(functionFragment: "reserveStake", values: [
+        PromiseOrValue<string>,
+        PromiseOrValue<BytesLike>,
+        PromiseOrValue<BigNumberish>,
+        PromiseOrValue<BigNumberish>
+    ]): string;
+    encodeFunctionData(functionFragment: "reservedStake", values: [PromiseOrValue<string>]): string;
+    encodeFunctionData(functionFragment: "setAllowedStakeOwner", values: [PromiseOrValue<string>]): string;
+    encodeFunctionData(functionFragment: "setStakeDelegationEnabled", values: [PromiseOrValue<boolean>]): string;
+    encodeFunctionData(functionFragment: "setStakeOperationsPaused", values: [PromiseOrValue<boolean>, PromiseOrValue<boolean>]): string;
+    encodeFunctionData(functionFragment: "setTakerAuthorization", values: [PromiseOrValue<string>, PromiseOrValue<boolean>]): string;
+    encodeFunctionData(functionFragment: "setTakerAuthorizations", values: [PromiseOrValue<string>[], PromiseOrValue<boolean>]): string;
+    encodeFunctionData(functionFragment: "slashDeferredStake", values: [PromiseOrValue<BytesLike>, PromiseOrValue<string>]): string;
+    encodeFunctionData(functionFragment: "slashReservation", values: [
+        PromiseOrValue<BytesLike>,
+        PromiseOrValue<string>,
+        PromiseOrValue<BigNumberish>
+    ]): string;
+    encodeFunctionData(functionFragment: "stakeBalance", values: [PromiseOrValue<string>]): string;
+    encodeFunctionData(functionFragment: "stakeDelegationEnabled", values: [PromiseOrValue<string>]): string;
+    encodeFunctionData(functionFragment: "stakeOwnerOf", values: [PromiseOrValue<string>]): string;
+    encodeFunctionData(functionFragment: "stakeToken", values?: undefined): string;
+    encodeFunctionData(functionFragment: "totalClaimableFees", values?: undefined): string;
+    encodeFunctionData(functionFragment: "totalDeferredFees", values?: undefined): string;
+    encodeFunctionData(functionFragment: "totalLiabilities", values?: undefined): string;
+    encodeFunctionData(functionFragment: "updateReservation", values: [
+        PromiseOrValue<BytesLike>,
+        PromiseOrValue<BigNumberish>,
+        PromiseOrValue<BigNumberish>
+    ]): string;
+    encodeFunctionData(functionFragment: "withdrawCompensation", values: [PromiseOrValue<string>]): string;
+    encodeFunctionData(functionFragment: "withdrawFeeClaim", values: [PromiseOrValue<string>]): string;
+    encodeFunctionData(functionFragment: "withdrawFeeClaimFor", values: [PromiseOrValue<string>]): string;
+    encodeFunctionData(functionFragment: "withdrawRequestedStake", values: [PromiseOrValue<string>]): string;
+    encodeFunctionData(functionFragment: "withdrawStake", values: [PromiseOrValue<string>]): string;
+    decodeFunctionResult(functionFragment: "acceptController", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "allowedStakeOwner", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "authorizeDeferredStake", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "cancelExit", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "cancelStakeWithdrawal", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "claimableCompensation", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "claimableFees", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "clearStakeOwner", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "controller", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "depositStake", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "depositStakeFor", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "eligibleStake", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "freeStake", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "getDeferredFeeAllocations", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "getDeferredStake", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "getExitRequest", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "getReservation", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "getStakeWithdrawalRequest", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "increaseReservation", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "initializeController", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "isExiting", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "proposeController", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "recordDeferredStake", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "releaseDeferredStake", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "releaseDeferredStakeAuthorization", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "releaseReservation", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "requestExit", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "requestStakeWithdrawal", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "reserveStake", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "reservedStake", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "setAllowedStakeOwner", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "setStakeDelegationEnabled", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "setStakeOperationsPaused", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "setTakerAuthorization", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "setTakerAuthorizations", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "slashDeferredStake", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "slashReservation", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "stakeBalance", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "stakeDelegationEnabled", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "stakeOwnerOf", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "stakeToken", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "totalClaimableFees", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "totalDeferredFees", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "totalLiabilities", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "updateReservation", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "withdrawCompensation", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "withdrawFeeClaim", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "withdrawFeeClaimFor", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "withdrawRequestedStake", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "withdrawStake", data: BytesLike): Result;
+    events: {
+        "AllowedStakeOwnerUpdated(address,address)": EventFragment;
+        "CompensationCredited(bytes32,address,uint256,uint256)": EventFragment;
+        "CompensationWithdrawn(address,address,uint256)": EventFragment;
+        "ControllerAccepted(address,address)": EventFragment;
+        "ControllerInitialized(address)": EventFragment;
+        "ControllerProposed(address,address,uint64)": EventFragment;
+        "DeferredFeeCancelled(bytes32,address,uint8,uint256)": EventFragment;
+        "DeferredFeeContingent(bytes32,address,uint8,uint256)": EventFragment;
+        "DeferredFeeVested(bytes32,address,uint8,uint256,uint256)": EventFragment;
+        "DeferredStakeAuthorizationReleased(bytes32,address,address)": EventFragment;
+        "DeferredStakeAuthorized(bytes32,address,address,uint64)": EventFragment;
+        "DeferredStakeFunded(bytes32,address,uint256,uint256,uint256,uint64)": EventFragment;
+        "DeferredStakeReleased(bytes32,address,uint256,uint256,uint256)": EventFragment;
+        "DeferredStakeSlashed(bytes32,address,address,uint256,uint256)": EventFragment;
+        "ExitCancelled(address)": EventFragment;
+        "ExitRequested(address,uint64,uint64)": EventFragment;
+        "FeeClaimWithdrawn(address,address,uint256)": EventFragment;
+        "StakeDelegationEnabledUpdated(address,bool)": EventFragment;
+        "StakeDeposited(address,uint256,uint256)": EventFragment;
+        "StakeOperationsPausedUpdated(bool,bool)": EventFragment;
+        "StakeReservationReleased(bytes32,address,uint256,uint256)": EventFragment;
+        "StakeReservationUpdated(bytes32,address,uint256,uint256,uint256,uint64)": EventFragment;
+        "StakeReserved(bytes32,address,address,uint256,uint256,uint64)": EventFragment;
+        "StakeSlashed(bytes32,address,address,uint256,uint256,uint256)": EventFragment;
+        "StakeWithdrawalCancelled(address,uint256)": EventFragment;
+        "StakeWithdrawalRequested(address,uint256,uint64,uint64)": EventFragment;
+        "StakeWithdrawn(address,address,uint256)": EventFragment;
+        "TakerAuthorizationUpdated(address,address,bool)": EventFragment;
+    };
+    getEvent(nameOrSignatureOrTopic: "AllowedStakeOwnerUpdated"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "CompensationCredited"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "CompensationWithdrawn"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "ControllerAccepted"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "ControllerInitialized"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "ControllerProposed"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "DeferredFeeCancelled"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "DeferredFeeContingent"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "DeferredFeeVested"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "DeferredStakeAuthorizationReleased"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "DeferredStakeAuthorized"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "DeferredStakeFunded"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "DeferredStakeReleased"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "DeferredStakeSlashed"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "ExitCancelled"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "ExitRequested"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "FeeClaimWithdrawn"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "StakeDelegationEnabledUpdated"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "StakeDeposited"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "StakeOperationsPausedUpdated"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "StakeReservationReleased"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "StakeReservationUpdated"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "StakeReserved"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "StakeSlashed"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "StakeWithdrawalCancelled"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "StakeWithdrawalRequested"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "StakeWithdrawn"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "TakerAuthorizationUpdated"): EventFragment;
+}
+export interface AllowedStakeOwnerUpdatedEventObject {
+    taker: string;
+    allowedStakeOwner: string;
+}
+export type AllowedStakeOwnerUpdatedEvent = TypedEvent<[
+    string,
+    string
+], AllowedStakeOwnerUpdatedEventObject>;
+export type AllowedStakeOwnerUpdatedEventFilter = TypedEventFilter<AllowedStakeOwnerUpdatedEvent>;
+export interface CompensationCreditedEventObject {
+    intentHash: string;
+    maker: string;
+    amount: BigNumber;
+    newClaimableBalance: BigNumber;
+}
+export type CompensationCreditedEvent = TypedEvent<[
+    string,
+    string,
+    BigNumber,
+    BigNumber
+], CompensationCreditedEventObject>;
+export type CompensationCreditedEventFilter = TypedEventFilter<CompensationCreditedEvent>;
+export interface CompensationWithdrawnEventObject {
+    maker: string;
+    recipient: string;
+    amount: BigNumber;
+}
+export type CompensationWithdrawnEvent = TypedEvent<[
+    string,
+    string,
+    BigNumber
+], CompensationWithdrawnEventObject>;
+export type CompensationWithdrawnEventFilter = TypedEventFilter<CompensationWithdrawnEvent>;
+export interface ControllerAcceptedEventObject {
+    previousController: string;
+    newController: string;
+}
+export type ControllerAcceptedEvent = TypedEvent<[
+    string,
+    string
+], ControllerAcceptedEventObject>;
+export type ControllerAcceptedEventFilter = TypedEventFilter<ControllerAcceptedEvent>;
+export interface ControllerInitializedEventObject {
+    controller: string;
+}
+export type ControllerInitializedEvent = TypedEvent<[
+    string
+], ControllerInitializedEventObject>;
+export type ControllerInitializedEventFilter = TypedEventFilter<ControllerInitializedEvent>;
+export interface ControllerProposedEventObject {
+    currentController: string;
+    pendingController: string;
+    validAt: BigNumber;
+}
+export type ControllerProposedEvent = TypedEvent<[
+    string,
+    string,
+    BigNumber
+], ControllerProposedEventObject>;
+export type ControllerProposedEventFilter = TypedEventFilter<ControllerProposedEvent>;
+export interface DeferredFeeCancelledEventObject {
+    intentHash: string;
+    recipient: string;
+    feeType: number;
+    amount: BigNumber;
+}
+export type DeferredFeeCancelledEvent = TypedEvent<[
+    string,
+    string,
+    number,
+    BigNumber
+], DeferredFeeCancelledEventObject>;
+export type DeferredFeeCancelledEventFilter = TypedEventFilter<DeferredFeeCancelledEvent>;
+export interface DeferredFeeContingentEventObject {
+    intentHash: string;
+    recipient: string;
+    feeType: number;
+    amount: BigNumber;
+}
+export type DeferredFeeContingentEvent = TypedEvent<[
+    string,
+    string,
+    number,
+    BigNumber
+], DeferredFeeContingentEventObject>;
+export type DeferredFeeContingentEventFilter = TypedEventFilter<DeferredFeeContingentEvent>;
+export interface DeferredFeeVestedEventObject {
+    intentHash: string;
+    recipient: string;
+    feeType: number;
+    amount: BigNumber;
+    newClaimableBalance: BigNumber;
+}
+export type DeferredFeeVestedEvent = TypedEvent<[
+    string,
+    string,
+    number,
+    BigNumber,
+    BigNumber
+], DeferredFeeVestedEventObject>;
+export type DeferredFeeVestedEventFilter = TypedEventFilter<DeferredFeeVestedEvent>;
+export interface DeferredStakeAuthorizationReleasedEventObject {
+    intentHash: string;
+    staker: string;
+    controller: string;
+}
+export type DeferredStakeAuthorizationReleasedEvent = TypedEvent<[
+    string,
+    string,
+    string
+], DeferredStakeAuthorizationReleasedEventObject>;
+export type DeferredStakeAuthorizationReleasedEventFilter = TypedEventFilter<DeferredStakeAuthorizationReleasedEvent>;
+export interface DeferredStakeAuthorizedEventObject {
+    intentHash: string;
+    staker: string;
+    controller: string;
+    releaseTime: BigNumber;
+}
+export type DeferredStakeAuthorizedEvent = TypedEvent<[
+    string,
+    string,
+    string,
+    BigNumber
+], DeferredStakeAuthorizedEventObject>;
+export type DeferredStakeAuthorizedEventFilter = TypedEventFilter<DeferredStakeAuthorizedEvent>;
+export interface DeferredStakeFundedEventObject {
+    intentHash: string;
+    staker: string;
+    grossAmount: BigNumber;
+    feeAmount: BigNumber;
+    netAmount: BigNumber;
+    releaseTime: BigNumber;
+}
+export type DeferredStakeFundedEvent = TypedEvent<[
+    string,
+    string,
+    BigNumber,
+    BigNumber,
+    BigNumber,
+    BigNumber
+], DeferredStakeFundedEventObject>;
+export type DeferredStakeFundedEventFilter = TypedEventFilter<DeferredStakeFundedEvent>;
+export interface DeferredStakeReleasedEventObject {
+    intentHash: string;
+    staker: string;
+    releasedGrossAmount: BigNumber;
+    vestedFeeAmount: BigNumber;
+    netStakeReleased: BigNumber;
+}
+export type DeferredStakeReleasedEvent = TypedEvent<[
+    string,
+    string,
+    BigNumber,
+    BigNumber,
+    BigNumber
+], DeferredStakeReleasedEventObject>;
+export type DeferredStakeReleasedEventFilter = TypedEventFilter<DeferredStakeReleasedEvent>;
+export interface DeferredStakeSlashedEventObject {
+    intentHash: string;
+    staker: string;
+    maker: string;
+    slashedGrossAmount: BigNumber;
+    cancelledFeeAmount: BigNumber;
+}
+export type DeferredStakeSlashedEvent = TypedEvent<[
+    string,
+    string,
+    string,
+    BigNumber,
+    BigNumber
+], DeferredStakeSlashedEventObject>;
+export type DeferredStakeSlashedEventFilter = TypedEventFilter<DeferredStakeSlashedEvent>;
+export interface ExitCancelledEventObject {
+    staker: string;
+}
+export type ExitCancelledEvent = TypedEvent<[string], ExitCancelledEventObject>;
+export type ExitCancelledEventFilter = TypedEventFilter<ExitCancelledEvent>;
+export interface ExitRequestedEventObject {
+    staker: string;
+    requestedAt: BigNumber;
+    availableAt: BigNumber;
+}
+export type ExitRequestedEvent = TypedEvent<[
+    string,
+    BigNumber,
+    BigNumber
+], ExitRequestedEventObject>;
+export type ExitRequestedEventFilter = TypedEventFilter<ExitRequestedEvent>;
+export interface FeeClaimWithdrawnEventObject {
+    beneficiary: string;
+    recipient: string;
+    amount: BigNumber;
+}
+export type FeeClaimWithdrawnEvent = TypedEvent<[
+    string,
+    string,
+    BigNumber
+], FeeClaimWithdrawnEventObject>;
+export type FeeClaimWithdrawnEventFilter = TypedEventFilter<FeeClaimWithdrawnEvent>;
+export interface StakeDelegationEnabledUpdatedEventObject {
+    taker: string;
+    enabled: boolean;
+}
+export type StakeDelegationEnabledUpdatedEvent = TypedEvent<[
+    string,
+    boolean
+], StakeDelegationEnabledUpdatedEventObject>;
+export type StakeDelegationEnabledUpdatedEventFilter = TypedEventFilter<StakeDelegationEnabledUpdatedEvent>;
+export interface StakeDepositedEventObject {
+    staker: string;
+    amount: BigNumber;
+    newStakeBalance: BigNumber;
+}
+export type StakeDepositedEvent = TypedEvent<[
+    string,
+    BigNumber,
+    BigNumber
+], StakeDepositedEventObject>;
+export type StakeDepositedEventFilter = TypedEventFilter<StakeDepositedEvent>;
+export interface StakeOperationsPausedUpdatedEventObject {
+    depositsPaused: boolean;
+    reservationsPaused: boolean;
+}
+export type StakeOperationsPausedUpdatedEvent = TypedEvent<[
+    boolean,
+    boolean
+], StakeOperationsPausedUpdatedEventObject>;
+export type StakeOperationsPausedUpdatedEventFilter = TypedEventFilter<StakeOperationsPausedUpdatedEvent>;
+export interface StakeReservationReleasedEventObject {
+    intentHash: string;
+    staker: string;
+    amount: BigNumber;
+    totalReserved: BigNumber;
+}
+export type StakeReservationReleasedEvent = TypedEvent<[
+    string,
+    string,
+    BigNumber,
+    BigNumber
+], StakeReservationReleasedEventObject>;
+export type StakeReservationReleasedEventFilter = TypedEventFilter<StakeReservationReleasedEvent>;
+export interface StakeReservationUpdatedEventObject {
+    intentHash: string;
+    staker: string;
+    previousAmount: BigNumber;
+    newAmount: BigNumber;
+    totalReserved: BigNumber;
+    releaseTime: BigNumber;
+}
+export type StakeReservationUpdatedEvent = TypedEvent<[
+    string,
+    string,
+    BigNumber,
+    BigNumber,
+    BigNumber,
+    BigNumber
+], StakeReservationUpdatedEventObject>;
+export type StakeReservationUpdatedEventFilter = TypedEventFilter<StakeReservationUpdatedEvent>;
+export interface StakeReservedEventObject {
+    intentHash: string;
+    staker: string;
+    controller: string;
+    amount: BigNumber;
+    totalReserved: BigNumber;
+    releaseTime: BigNumber;
+}
+export type StakeReservedEvent = TypedEvent<[
+    string,
+    string,
+    string,
+    BigNumber,
+    BigNumber,
+    BigNumber
+], StakeReservedEventObject>;
+export type StakeReservedEventFilter = TypedEventFilter<StakeReservedEvent>;
+export interface StakeSlashedEventObject {
+    intentHash: string;
+    staker: string;
+    maker: string;
+    amount: BigNumber;
+    remainingStake: BigNumber;
+    remainingReservation: BigNumber;
+}
+export type StakeSlashedEvent = TypedEvent<[
+    string,
+    string,
+    string,
+    BigNumber,
+    BigNumber,
+    BigNumber
+], StakeSlashedEventObject>;
+export type StakeSlashedEventFilter = TypedEventFilter<StakeSlashedEvent>;
+export interface StakeWithdrawalCancelledEventObject {
+    stakeOwner: string;
+    amount: BigNumber;
+}
+export type StakeWithdrawalCancelledEvent = TypedEvent<[
+    string,
+    BigNumber
+], StakeWithdrawalCancelledEventObject>;
+export type StakeWithdrawalCancelledEventFilter = TypedEventFilter<StakeWithdrawalCancelledEvent>;
+export interface StakeWithdrawalRequestedEventObject {
+    stakeOwner: string;
+    amount: BigNumber;
+    requestedAt: BigNumber;
+    availableAt: BigNumber;
+}
+export type StakeWithdrawalRequestedEvent = TypedEvent<[
+    string,
+    BigNumber,
+    BigNumber,
+    BigNumber
+], StakeWithdrawalRequestedEventObject>;
+export type StakeWithdrawalRequestedEventFilter = TypedEventFilter<StakeWithdrawalRequestedEvent>;
+export interface StakeWithdrawnEventObject {
+    staker: string;
+    recipient: string;
+    amount: BigNumber;
+}
+export type StakeWithdrawnEvent = TypedEvent<[
+    string,
+    string,
+    BigNumber
+], StakeWithdrawnEventObject>;
+export type StakeWithdrawnEventFilter = TypedEventFilter<StakeWithdrawnEvent>;
+export interface TakerAuthorizationUpdatedEventObject {
+    stakeOwner: string;
+    taker: string;
+    authorized: boolean;
+}
+export type TakerAuthorizationUpdatedEvent = TypedEvent<[
+    string,
+    string,
+    boolean
+], TakerAuthorizationUpdatedEventObject>;
+export type TakerAuthorizationUpdatedEventFilter = TypedEventFilter<TakerAuthorizationUpdatedEvent>;
+export interface IStakeVault extends BaseContract {
+    connect(signerOrProvider: Signer | Provider | string): this;
+    attach(addressOrName: string): this;
+    deployed(): Promise<this>;
+    interface: IStakeVaultInterface;
+    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: {
+        acceptController(overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        allowedStakeOwner(_taker: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[string]>;
+        authorizeDeferredStake(_intentHash: PromiseOrValue<BytesLike>, _staker: PromiseOrValue<string>, _releaseTime: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        cancelExit(overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        cancelStakeWithdrawal(overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        claimableCompensation(_maker: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[BigNumber]>;
+        claimableFees(_beneficiary: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[BigNumber]>;
+        clearStakeOwner(overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        controller(overrides?: CallOverrides): Promise<[string]>;
+        depositStake(_amount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        depositStakeFor(_taker: PromiseOrValue<string>, _amount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        eligibleStake(_staker: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[BigNumber]>;
+        freeStake(_staker: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[BigNumber]>;
+        getDeferredFeeAllocations(_intentHash: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<[IIntentRiskHook.FeeAllocationStructOutput[]]>;
+        getDeferredStake(_intentHash: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<[IStakeVault.DeferredStakeStructOutput]>;
+        getExitRequest(_staker: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[IStakeVault.ExitRequestStructOutput]>;
+        getReservation(_intentHash: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<[IStakeVault.ReservationStructOutput]>;
+        getStakeWithdrawalRequest(_staker: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[IStakeVault.StakeWithdrawalRequestStructOutput]>;
+        increaseReservation(_positionId: PromiseOrValue<BytesLike>, _amount: PromiseOrValue<BigNumberish>, _releaseTime: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        initializeController(_controller: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        isExiting(_staker: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[boolean]>;
+        proposeController(_controller: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        recordDeferredStake(_intentHash: PromiseOrValue<BytesLike>, _staker: PromiseOrValue<string>, _grossAmount: PromiseOrValue<BigNumberish>, _releaseTime: PromiseOrValue<BigNumberish>, _feeAllocations: IIntentRiskHook.FeeAllocationStruct[], overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        releaseDeferredStake(_intentHash: PromiseOrValue<BytesLike>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        releaseDeferredStakeAuthorization(_intentHash: PromiseOrValue<BytesLike>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        releaseReservation(_intentHash: PromiseOrValue<BytesLike>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        requestExit(overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        requestStakeWithdrawal(_amount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        reserveStake(_staker: PromiseOrValue<string>, _intentHash: PromiseOrValue<BytesLike>, _amount: PromiseOrValue<BigNumberish>, _releaseTime: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        reservedStake(_staker: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[BigNumber]>;
+        setAllowedStakeOwner(_stakeOwner: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        setStakeDelegationEnabled(_enabled: PromiseOrValue<boolean>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        setStakeOperationsPaused(_depositsPaused: PromiseOrValue<boolean>, _reservationsPaused: PromiseOrValue<boolean>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        setTakerAuthorization(_taker: PromiseOrValue<string>, _authorized: PromiseOrValue<boolean>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        setTakerAuthorizations(_takers: PromiseOrValue<string>[], _authorized: PromiseOrValue<boolean>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        slashDeferredStake(_intentHash: PromiseOrValue<BytesLike>, _maker: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        slashReservation(_intentHash: PromiseOrValue<BytesLike>, _maker: PromiseOrValue<string>, _amount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        stakeBalance(_staker: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[BigNumber]>;
+        stakeDelegationEnabled(_taker: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[boolean]>;
+        stakeOwnerOf(_taker: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[string]>;
+        stakeToken(overrides?: CallOverrides): Promise<[string]>;
+        totalClaimableFees(overrides?: CallOverrides): Promise<[BigNumber]>;
+        totalDeferredFees(overrides?: CallOverrides): Promise<[BigNumber]>;
+        totalLiabilities(overrides?: CallOverrides): Promise<[BigNumber]>;
+        updateReservation(_intentHash: PromiseOrValue<BytesLike>, _newAmount: PromiseOrValue<BigNumberish>, _releaseTime: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        withdrawCompensation(_recipient: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        withdrawFeeClaim(_recipient: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        withdrawFeeClaimFor(_beneficiary: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        withdrawRequestedStake(_recipient: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        withdrawStake(_recipient: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+    };
+    acceptController(overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    allowedStakeOwner(_taker: PromiseOrValue<string>, overrides?: CallOverrides): Promise<string>;
+    authorizeDeferredStake(_intentHash: PromiseOrValue<BytesLike>, _staker: PromiseOrValue<string>, _releaseTime: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    cancelExit(overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    cancelStakeWithdrawal(overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    claimableCompensation(_maker: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
+    claimableFees(_beneficiary: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
+    clearStakeOwner(overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    controller(overrides?: CallOverrides): Promise<string>;
+    depositStake(_amount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    depositStakeFor(_taker: PromiseOrValue<string>, _amount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    eligibleStake(_staker: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
+    freeStake(_staker: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
+    getDeferredFeeAllocations(_intentHash: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<IIntentRiskHook.FeeAllocationStructOutput[]>;
+    getDeferredStake(_intentHash: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<IStakeVault.DeferredStakeStructOutput>;
+    getExitRequest(_staker: PromiseOrValue<string>, overrides?: CallOverrides): Promise<IStakeVault.ExitRequestStructOutput>;
+    getReservation(_intentHash: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<IStakeVault.ReservationStructOutput>;
+    getStakeWithdrawalRequest(_staker: PromiseOrValue<string>, overrides?: CallOverrides): Promise<IStakeVault.StakeWithdrawalRequestStructOutput>;
+    increaseReservation(_positionId: PromiseOrValue<BytesLike>, _amount: PromiseOrValue<BigNumberish>, _releaseTime: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    initializeController(_controller: PromiseOrValue<string>, overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    isExiting(_staker: PromiseOrValue<string>, overrides?: CallOverrides): Promise<boolean>;
+    proposeController(_controller: PromiseOrValue<string>, overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    recordDeferredStake(_intentHash: PromiseOrValue<BytesLike>, _staker: PromiseOrValue<string>, _grossAmount: PromiseOrValue<BigNumberish>, _releaseTime: PromiseOrValue<BigNumberish>, _feeAllocations: IIntentRiskHook.FeeAllocationStruct[], overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    releaseDeferredStake(_intentHash: PromiseOrValue<BytesLike>, overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    releaseDeferredStakeAuthorization(_intentHash: PromiseOrValue<BytesLike>, overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    releaseReservation(_intentHash: PromiseOrValue<BytesLike>, overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    requestExit(overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    requestStakeWithdrawal(_amount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    reserveStake(_staker: PromiseOrValue<string>, _intentHash: PromiseOrValue<BytesLike>, _amount: PromiseOrValue<BigNumberish>, _releaseTime: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    reservedStake(_staker: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
+    setAllowedStakeOwner(_stakeOwner: PromiseOrValue<string>, overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    setStakeDelegationEnabled(_enabled: PromiseOrValue<boolean>, overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    setStakeOperationsPaused(_depositsPaused: PromiseOrValue<boolean>, _reservationsPaused: PromiseOrValue<boolean>, overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    setTakerAuthorization(_taker: PromiseOrValue<string>, _authorized: PromiseOrValue<boolean>, overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    setTakerAuthorizations(_takers: PromiseOrValue<string>[], _authorized: PromiseOrValue<boolean>, overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    slashDeferredStake(_intentHash: PromiseOrValue<BytesLike>, _maker: PromiseOrValue<string>, overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    slashReservation(_intentHash: PromiseOrValue<BytesLike>, _maker: PromiseOrValue<string>, _amount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    stakeBalance(_staker: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
+    stakeDelegationEnabled(_taker: PromiseOrValue<string>, overrides?: CallOverrides): Promise<boolean>;
+    stakeOwnerOf(_taker: PromiseOrValue<string>, overrides?: CallOverrides): Promise<string>;
+    stakeToken(overrides?: CallOverrides): Promise<string>;
+    totalClaimableFees(overrides?: CallOverrides): Promise<BigNumber>;
+    totalDeferredFees(overrides?: CallOverrides): Promise<BigNumber>;
+    totalLiabilities(overrides?: CallOverrides): Promise<BigNumber>;
+    updateReservation(_intentHash: PromiseOrValue<BytesLike>, _newAmount: PromiseOrValue<BigNumberish>, _releaseTime: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    withdrawCompensation(_recipient: PromiseOrValue<string>, overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    withdrawFeeClaim(_recipient: PromiseOrValue<string>, overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    withdrawFeeClaimFor(_beneficiary: PromiseOrValue<string>, overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    withdrawRequestedStake(_recipient: PromiseOrValue<string>, overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    withdrawStake(_recipient: PromiseOrValue<string>, overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    callStatic: {
+        acceptController(overrides?: CallOverrides): Promise<void>;
+        allowedStakeOwner(_taker: PromiseOrValue<string>, overrides?: CallOverrides): Promise<string>;
+        authorizeDeferredStake(_intentHash: PromiseOrValue<BytesLike>, _staker: PromiseOrValue<string>, _releaseTime: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<void>;
+        cancelExit(overrides?: CallOverrides): Promise<void>;
+        cancelStakeWithdrawal(overrides?: CallOverrides): Promise<void>;
+        claimableCompensation(_maker: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
+        claimableFees(_beneficiary: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
+        clearStakeOwner(overrides?: CallOverrides): Promise<void>;
+        controller(overrides?: CallOverrides): Promise<string>;
+        depositStake(_amount: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<void>;
+        depositStakeFor(_taker: PromiseOrValue<string>, _amount: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<void>;
+        eligibleStake(_staker: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
+        freeStake(_staker: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
+        getDeferredFeeAllocations(_intentHash: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<IIntentRiskHook.FeeAllocationStructOutput[]>;
+        getDeferredStake(_intentHash: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<IStakeVault.DeferredStakeStructOutput>;
+        getExitRequest(_staker: PromiseOrValue<string>, overrides?: CallOverrides): Promise<IStakeVault.ExitRequestStructOutput>;
+        getReservation(_intentHash: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<IStakeVault.ReservationStructOutput>;
+        getStakeWithdrawalRequest(_staker: PromiseOrValue<string>, overrides?: CallOverrides): Promise<IStakeVault.StakeWithdrawalRequestStructOutput>;
+        increaseReservation(_positionId: PromiseOrValue<BytesLike>, _amount: PromiseOrValue<BigNumberish>, _releaseTime: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<void>;
+        initializeController(_controller: PromiseOrValue<string>, overrides?: CallOverrides): Promise<void>;
+        isExiting(_staker: PromiseOrValue<string>, overrides?: CallOverrides): Promise<boolean>;
+        proposeController(_controller: PromiseOrValue<string>, overrides?: CallOverrides): Promise<void>;
+        recordDeferredStake(_intentHash: PromiseOrValue<BytesLike>, _staker: PromiseOrValue<string>, _grossAmount: PromiseOrValue<BigNumberish>, _releaseTime: PromiseOrValue<BigNumberish>, _feeAllocations: IIntentRiskHook.FeeAllocationStruct[], overrides?: CallOverrides): Promise<void>;
+        releaseDeferredStake(_intentHash: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<void>;
+        releaseDeferredStakeAuthorization(_intentHash: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<void>;
+        releaseReservation(_intentHash: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<void>;
+        requestExit(overrides?: CallOverrides): Promise<void>;
+        requestStakeWithdrawal(_amount: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<void>;
+        reserveStake(_staker: PromiseOrValue<string>, _intentHash: PromiseOrValue<BytesLike>, _amount: PromiseOrValue<BigNumberish>, _releaseTime: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<void>;
+        reservedStake(_staker: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
+        setAllowedStakeOwner(_stakeOwner: PromiseOrValue<string>, overrides?: CallOverrides): Promise<void>;
+        setStakeDelegationEnabled(_enabled: PromiseOrValue<boolean>, overrides?: CallOverrides): Promise<void>;
+        setStakeOperationsPaused(_depositsPaused: PromiseOrValue<boolean>, _reservationsPaused: PromiseOrValue<boolean>, overrides?: CallOverrides): Promise<void>;
+        setTakerAuthorization(_taker: PromiseOrValue<string>, _authorized: PromiseOrValue<boolean>, overrides?: CallOverrides): Promise<void>;
+        setTakerAuthorizations(_takers: PromiseOrValue<string>[], _authorized: PromiseOrValue<boolean>, overrides?: CallOverrides): Promise<void>;
+        slashDeferredStake(_intentHash: PromiseOrValue<BytesLike>, _maker: PromiseOrValue<string>, overrides?: CallOverrides): Promise<void>;
+        slashReservation(_intentHash: PromiseOrValue<BytesLike>, _maker: PromiseOrValue<string>, _amount: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<void>;
+        stakeBalance(_staker: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
+        stakeDelegationEnabled(_taker: PromiseOrValue<string>, overrides?: CallOverrides): Promise<boolean>;
+        stakeOwnerOf(_taker: PromiseOrValue<string>, overrides?: CallOverrides): Promise<string>;
+        stakeToken(overrides?: CallOverrides): Promise<string>;
+        totalClaimableFees(overrides?: CallOverrides): Promise<BigNumber>;
+        totalDeferredFees(overrides?: CallOverrides): Promise<BigNumber>;
+        totalLiabilities(overrides?: CallOverrides): Promise<BigNumber>;
+        updateReservation(_intentHash: PromiseOrValue<BytesLike>, _newAmount: PromiseOrValue<BigNumberish>, _releaseTime: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<void>;
+        withdrawCompensation(_recipient: PromiseOrValue<string>, overrides?: CallOverrides): Promise<void>;
+        withdrawFeeClaim(_recipient: PromiseOrValue<string>, overrides?: CallOverrides): Promise<void>;
+        withdrawFeeClaimFor(_beneficiary: PromiseOrValue<string>, overrides?: CallOverrides): Promise<void>;
+        withdrawRequestedStake(_recipient: PromiseOrValue<string>, overrides?: CallOverrides): Promise<void>;
+        withdrawStake(_recipient: PromiseOrValue<string>, overrides?: CallOverrides): Promise<void>;
+    };
+    filters: {
+        "AllowedStakeOwnerUpdated(address,address)"(taker?: PromiseOrValue<string> | null, allowedStakeOwner?: PromiseOrValue<string> | null): AllowedStakeOwnerUpdatedEventFilter;
+        AllowedStakeOwnerUpdated(taker?: PromiseOrValue<string> | null, allowedStakeOwner?: PromiseOrValue<string> | null): AllowedStakeOwnerUpdatedEventFilter;
+        "CompensationCredited(bytes32,address,uint256,uint256)"(intentHash?: PromiseOrValue<BytesLike> | null, maker?: PromiseOrValue<string> | null, amount?: null, newClaimableBalance?: null): CompensationCreditedEventFilter;
+        CompensationCredited(intentHash?: PromiseOrValue<BytesLike> | null, maker?: PromiseOrValue<string> | null, amount?: null, newClaimableBalance?: null): CompensationCreditedEventFilter;
+        "CompensationWithdrawn(address,address,uint256)"(maker?: PromiseOrValue<string> | null, recipient?: PromiseOrValue<string> | null, amount?: null): CompensationWithdrawnEventFilter;
+        CompensationWithdrawn(maker?: PromiseOrValue<string> | null, recipient?: PromiseOrValue<string> | null, amount?: null): CompensationWithdrawnEventFilter;
+        "ControllerAccepted(address,address)"(previousController?: PromiseOrValue<string> | null, newController?: PromiseOrValue<string> | null): ControllerAcceptedEventFilter;
+        ControllerAccepted(previousController?: PromiseOrValue<string> | null, newController?: PromiseOrValue<string> | null): ControllerAcceptedEventFilter;
+        "ControllerInitialized(address)"(controller?: PromiseOrValue<string> | null): ControllerInitializedEventFilter;
+        ControllerInitialized(controller?: PromiseOrValue<string> | null): ControllerInitializedEventFilter;
+        "ControllerProposed(address,address,uint64)"(currentController?: PromiseOrValue<string> | null, pendingController?: PromiseOrValue<string> | null, validAt?: null): ControllerProposedEventFilter;
+        ControllerProposed(currentController?: PromiseOrValue<string> | null, pendingController?: PromiseOrValue<string> | null, validAt?: null): ControllerProposedEventFilter;
+        "DeferredFeeCancelled(bytes32,address,uint8,uint256)"(intentHash?: PromiseOrValue<BytesLike> | null, recipient?: PromiseOrValue<string> | null, feeType?: PromiseOrValue<BigNumberish> | null, amount?: null): DeferredFeeCancelledEventFilter;
+        DeferredFeeCancelled(intentHash?: PromiseOrValue<BytesLike> | null, recipient?: PromiseOrValue<string> | null, feeType?: PromiseOrValue<BigNumberish> | null, amount?: null): DeferredFeeCancelledEventFilter;
+        "DeferredFeeContingent(bytes32,address,uint8,uint256)"(intentHash?: PromiseOrValue<BytesLike> | null, recipient?: PromiseOrValue<string> | null, feeType?: PromiseOrValue<BigNumberish> | null, amount?: null): DeferredFeeContingentEventFilter;
+        DeferredFeeContingent(intentHash?: PromiseOrValue<BytesLike> | null, recipient?: PromiseOrValue<string> | null, feeType?: PromiseOrValue<BigNumberish> | null, amount?: null): DeferredFeeContingentEventFilter;
+        "DeferredFeeVested(bytes32,address,uint8,uint256,uint256)"(intentHash?: PromiseOrValue<BytesLike> | null, recipient?: PromiseOrValue<string> | null, feeType?: PromiseOrValue<BigNumberish> | null, amount?: null, newClaimableBalance?: null): DeferredFeeVestedEventFilter;
+        DeferredFeeVested(intentHash?: PromiseOrValue<BytesLike> | null, recipient?: PromiseOrValue<string> | null, feeType?: PromiseOrValue<BigNumberish> | null, amount?: null, newClaimableBalance?: null): DeferredFeeVestedEventFilter;
+        "DeferredStakeAuthorizationReleased(bytes32,address,address)"(intentHash?: PromiseOrValue<BytesLike> | null, staker?: PromiseOrValue<string> | null, controller?: PromiseOrValue<string> | null): DeferredStakeAuthorizationReleasedEventFilter;
+        DeferredStakeAuthorizationReleased(intentHash?: PromiseOrValue<BytesLike> | null, staker?: PromiseOrValue<string> | null, controller?: PromiseOrValue<string> | null): DeferredStakeAuthorizationReleasedEventFilter;
+        "DeferredStakeAuthorized(bytes32,address,address,uint64)"(intentHash?: PromiseOrValue<BytesLike> | null, staker?: PromiseOrValue<string> | null, controller?: PromiseOrValue<string> | null, releaseTime?: null): DeferredStakeAuthorizedEventFilter;
+        DeferredStakeAuthorized(intentHash?: PromiseOrValue<BytesLike> | null, staker?: PromiseOrValue<string> | null, controller?: PromiseOrValue<string> | null, releaseTime?: null): DeferredStakeAuthorizedEventFilter;
+        "DeferredStakeFunded(bytes32,address,uint256,uint256,uint256,uint64)"(intentHash?: PromiseOrValue<BytesLike> | null, staker?: PromiseOrValue<string> | null, grossAmount?: null, feeAmount?: null, netAmount?: null, releaseTime?: null): DeferredStakeFundedEventFilter;
+        DeferredStakeFunded(intentHash?: PromiseOrValue<BytesLike> | null, staker?: PromiseOrValue<string> | null, grossAmount?: null, feeAmount?: null, netAmount?: null, releaseTime?: null): DeferredStakeFundedEventFilter;
+        "DeferredStakeReleased(bytes32,address,uint256,uint256,uint256)"(intentHash?: PromiseOrValue<BytesLike> | null, staker?: PromiseOrValue<string> | null, releasedGrossAmount?: null, vestedFeeAmount?: null, netStakeReleased?: null): DeferredStakeReleasedEventFilter;
+        DeferredStakeReleased(intentHash?: PromiseOrValue<BytesLike> | null, staker?: PromiseOrValue<string> | null, releasedGrossAmount?: null, vestedFeeAmount?: null, netStakeReleased?: null): DeferredStakeReleasedEventFilter;
+        "DeferredStakeSlashed(bytes32,address,address,uint256,uint256)"(intentHash?: PromiseOrValue<BytesLike> | null, staker?: PromiseOrValue<string> | null, maker?: PromiseOrValue<string> | null, slashedGrossAmount?: null, cancelledFeeAmount?: null): DeferredStakeSlashedEventFilter;
+        DeferredStakeSlashed(intentHash?: PromiseOrValue<BytesLike> | null, staker?: PromiseOrValue<string> | null, maker?: PromiseOrValue<string> | null, slashedGrossAmount?: null, cancelledFeeAmount?: null): DeferredStakeSlashedEventFilter;
+        "ExitCancelled(address)"(staker?: PromiseOrValue<string> | null): ExitCancelledEventFilter;
+        ExitCancelled(staker?: PromiseOrValue<string> | null): ExitCancelledEventFilter;
+        "ExitRequested(address,uint64,uint64)"(staker?: PromiseOrValue<string> | null, requestedAt?: null, availableAt?: null): ExitRequestedEventFilter;
+        ExitRequested(staker?: PromiseOrValue<string> | null, requestedAt?: null, availableAt?: null): ExitRequestedEventFilter;
+        "FeeClaimWithdrawn(address,address,uint256)"(beneficiary?: PromiseOrValue<string> | null, recipient?: PromiseOrValue<string> | null, amount?: null): FeeClaimWithdrawnEventFilter;
+        FeeClaimWithdrawn(beneficiary?: PromiseOrValue<string> | null, recipient?: PromiseOrValue<string> | null, amount?: null): FeeClaimWithdrawnEventFilter;
+        "StakeDelegationEnabledUpdated(address,bool)"(taker?: PromiseOrValue<string> | null, enabled?: null): StakeDelegationEnabledUpdatedEventFilter;
+        StakeDelegationEnabledUpdated(taker?: PromiseOrValue<string> | null, enabled?: null): StakeDelegationEnabledUpdatedEventFilter;
+        "StakeDeposited(address,uint256,uint256)"(staker?: PromiseOrValue<string> | null, amount?: null, newStakeBalance?: null): StakeDepositedEventFilter;
+        StakeDeposited(staker?: PromiseOrValue<string> | null, amount?: null, newStakeBalance?: null): StakeDepositedEventFilter;
+        "StakeOperationsPausedUpdated(bool,bool)"(depositsPaused?: null, reservationsPaused?: null): StakeOperationsPausedUpdatedEventFilter;
+        StakeOperationsPausedUpdated(depositsPaused?: null, reservationsPaused?: null): StakeOperationsPausedUpdatedEventFilter;
+        "StakeReservationReleased(bytes32,address,uint256,uint256)"(intentHash?: PromiseOrValue<BytesLike> | null, staker?: PromiseOrValue<string> | null, amount?: null, totalReserved?: null): StakeReservationReleasedEventFilter;
+        StakeReservationReleased(intentHash?: PromiseOrValue<BytesLike> | null, staker?: PromiseOrValue<string> | null, amount?: null, totalReserved?: null): StakeReservationReleasedEventFilter;
+        "StakeReservationUpdated(bytes32,address,uint256,uint256,uint256,uint64)"(intentHash?: PromiseOrValue<BytesLike> | null, staker?: PromiseOrValue<string> | null, previousAmount?: null, newAmount?: null, totalReserved?: null, releaseTime?: null): StakeReservationUpdatedEventFilter;
+        StakeReservationUpdated(intentHash?: PromiseOrValue<BytesLike> | null, staker?: PromiseOrValue<string> | null, previousAmount?: null, newAmount?: null, totalReserved?: null, releaseTime?: null): StakeReservationUpdatedEventFilter;
+        "StakeReserved(bytes32,address,address,uint256,uint256,uint64)"(intentHash?: PromiseOrValue<BytesLike> | null, staker?: PromiseOrValue<string> | null, controller?: PromiseOrValue<string> | null, amount?: null, totalReserved?: null, releaseTime?: null): StakeReservedEventFilter;
+        StakeReserved(intentHash?: PromiseOrValue<BytesLike> | null, staker?: PromiseOrValue<string> | null, controller?: PromiseOrValue<string> | null, amount?: null, totalReserved?: null, releaseTime?: null): StakeReservedEventFilter;
+        "StakeSlashed(bytes32,address,address,uint256,uint256,uint256)"(intentHash?: PromiseOrValue<BytesLike> | null, staker?: PromiseOrValue<string> | null, maker?: PromiseOrValue<string> | null, amount?: null, remainingStake?: null, remainingReservation?: null): StakeSlashedEventFilter;
+        StakeSlashed(intentHash?: PromiseOrValue<BytesLike> | null, staker?: PromiseOrValue<string> | null, maker?: PromiseOrValue<string> | null, amount?: null, remainingStake?: null, remainingReservation?: null): StakeSlashedEventFilter;
+        "StakeWithdrawalCancelled(address,uint256)"(stakeOwner?: PromiseOrValue<string> | null, amount?: null): StakeWithdrawalCancelledEventFilter;
+        StakeWithdrawalCancelled(stakeOwner?: PromiseOrValue<string> | null, amount?: null): StakeWithdrawalCancelledEventFilter;
+        "StakeWithdrawalRequested(address,uint256,uint64,uint64)"(stakeOwner?: PromiseOrValue<string> | null, amount?: null, requestedAt?: null, availableAt?: null): StakeWithdrawalRequestedEventFilter;
+        StakeWithdrawalRequested(stakeOwner?: PromiseOrValue<string> | null, amount?: null, requestedAt?: null, availableAt?: null): StakeWithdrawalRequestedEventFilter;
+        "StakeWithdrawn(address,address,uint256)"(staker?: PromiseOrValue<string> | null, recipient?: PromiseOrValue<string> | null, amount?: null): StakeWithdrawnEventFilter;
+        StakeWithdrawn(staker?: PromiseOrValue<string> | null, recipient?: PromiseOrValue<string> | null, amount?: null): StakeWithdrawnEventFilter;
+        "TakerAuthorizationUpdated(address,address,bool)"(stakeOwner?: PromiseOrValue<string> | null, taker?: PromiseOrValue<string> | null, authorized?: null): TakerAuthorizationUpdatedEventFilter;
+        TakerAuthorizationUpdated(stakeOwner?: PromiseOrValue<string> | null, taker?: PromiseOrValue<string> | null, authorized?: null): TakerAuthorizationUpdatedEventFilter;
+    };
+    estimateGas: {
+        acceptController(overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        allowedStakeOwner(_taker: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
+        authorizeDeferredStake(_intentHash: PromiseOrValue<BytesLike>, _staker: PromiseOrValue<string>, _releaseTime: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        cancelExit(overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        cancelStakeWithdrawal(overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        claimableCompensation(_maker: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
+        claimableFees(_beneficiary: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
+        clearStakeOwner(overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        controller(overrides?: CallOverrides): Promise<BigNumber>;
+        depositStake(_amount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        depositStakeFor(_taker: PromiseOrValue<string>, _amount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        eligibleStake(_staker: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
+        freeStake(_staker: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
+        getDeferredFeeAllocations(_intentHash: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<BigNumber>;
+        getDeferredStake(_intentHash: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<BigNumber>;
+        getExitRequest(_staker: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
+        getReservation(_intentHash: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<BigNumber>;
+        getStakeWithdrawalRequest(_staker: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
+        increaseReservation(_positionId: PromiseOrValue<BytesLike>, _amount: PromiseOrValue<BigNumberish>, _releaseTime: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        initializeController(_controller: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        isExiting(_staker: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
+        proposeController(_controller: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        recordDeferredStake(_intentHash: PromiseOrValue<BytesLike>, _staker: PromiseOrValue<string>, _grossAmount: PromiseOrValue<BigNumberish>, _releaseTime: PromiseOrValue<BigNumberish>, _feeAllocations: IIntentRiskHook.FeeAllocationStruct[], overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        releaseDeferredStake(_intentHash: PromiseOrValue<BytesLike>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        releaseDeferredStakeAuthorization(_intentHash: PromiseOrValue<BytesLike>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        releaseReservation(_intentHash: PromiseOrValue<BytesLike>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        requestExit(overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        requestStakeWithdrawal(_amount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        reserveStake(_staker: PromiseOrValue<string>, _intentHash: PromiseOrValue<BytesLike>, _amount: PromiseOrValue<BigNumberish>, _releaseTime: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        reservedStake(_staker: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
+        setAllowedStakeOwner(_stakeOwner: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        setStakeDelegationEnabled(_enabled: PromiseOrValue<boolean>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        setStakeOperationsPaused(_depositsPaused: PromiseOrValue<boolean>, _reservationsPaused: PromiseOrValue<boolean>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        setTakerAuthorization(_taker: PromiseOrValue<string>, _authorized: PromiseOrValue<boolean>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        setTakerAuthorizations(_takers: PromiseOrValue<string>[], _authorized: PromiseOrValue<boolean>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        slashDeferredStake(_intentHash: PromiseOrValue<BytesLike>, _maker: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        slashReservation(_intentHash: PromiseOrValue<BytesLike>, _maker: PromiseOrValue<string>, _amount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        stakeBalance(_staker: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
+        stakeDelegationEnabled(_taker: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
+        stakeOwnerOf(_taker: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
+        stakeToken(overrides?: CallOverrides): Promise<BigNumber>;
+        totalClaimableFees(overrides?: CallOverrides): Promise<BigNumber>;
+        totalDeferredFees(overrides?: CallOverrides): Promise<BigNumber>;
+        totalLiabilities(overrides?: CallOverrides): Promise<BigNumber>;
+        updateReservation(_intentHash: PromiseOrValue<BytesLike>, _newAmount: PromiseOrValue<BigNumberish>, _releaseTime: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        withdrawCompensation(_recipient: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        withdrawFeeClaim(_recipient: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        withdrawFeeClaimFor(_beneficiary: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        withdrawRequestedStake(_recipient: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        withdrawStake(_recipient: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+    };
+    populateTransaction: {
+        acceptController(overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        allowedStakeOwner(_taker: PromiseOrValue<string>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        authorizeDeferredStake(_intentHash: PromiseOrValue<BytesLike>, _staker: PromiseOrValue<string>, _releaseTime: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        cancelExit(overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        cancelStakeWithdrawal(overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        claimableCompensation(_maker: PromiseOrValue<string>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        claimableFees(_beneficiary: PromiseOrValue<string>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        clearStakeOwner(overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        controller(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        depositStake(_amount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        depositStakeFor(_taker: PromiseOrValue<string>, _amount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        eligibleStake(_staker: PromiseOrValue<string>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        freeStake(_staker: PromiseOrValue<string>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        getDeferredFeeAllocations(_intentHash: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        getDeferredStake(_intentHash: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        getExitRequest(_staker: PromiseOrValue<string>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        getReservation(_intentHash: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        getStakeWithdrawalRequest(_staker: PromiseOrValue<string>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        increaseReservation(_positionId: PromiseOrValue<BytesLike>, _amount: PromiseOrValue<BigNumberish>, _releaseTime: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        initializeController(_controller: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        isExiting(_staker: PromiseOrValue<string>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        proposeController(_controller: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        recordDeferredStake(_intentHash: PromiseOrValue<BytesLike>, _staker: PromiseOrValue<string>, _grossAmount: PromiseOrValue<BigNumberish>, _releaseTime: PromiseOrValue<BigNumberish>, _feeAllocations: IIntentRiskHook.FeeAllocationStruct[], overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        releaseDeferredStake(_intentHash: PromiseOrValue<BytesLike>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        releaseDeferredStakeAuthorization(_intentHash: PromiseOrValue<BytesLike>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        releaseReservation(_intentHash: PromiseOrValue<BytesLike>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        requestExit(overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        requestStakeWithdrawal(_amount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        reserveStake(_staker: PromiseOrValue<string>, _intentHash: PromiseOrValue<BytesLike>, _amount: PromiseOrValue<BigNumberish>, _releaseTime: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        reservedStake(_staker: PromiseOrValue<string>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        setAllowedStakeOwner(_stakeOwner: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        setStakeDelegationEnabled(_enabled: PromiseOrValue<boolean>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        setStakeOperationsPaused(_depositsPaused: PromiseOrValue<boolean>, _reservationsPaused: PromiseOrValue<boolean>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        setTakerAuthorization(_taker: PromiseOrValue<string>, _authorized: PromiseOrValue<boolean>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        setTakerAuthorizations(_takers: PromiseOrValue<string>[], _authorized: PromiseOrValue<boolean>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        slashDeferredStake(_intentHash: PromiseOrValue<BytesLike>, _maker: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        slashReservation(_intentHash: PromiseOrValue<BytesLike>, _maker: PromiseOrValue<string>, _amount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        stakeBalance(_staker: PromiseOrValue<string>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        stakeDelegationEnabled(_taker: PromiseOrValue<string>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        stakeOwnerOf(_taker: PromiseOrValue<string>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        stakeToken(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        totalClaimableFees(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        totalDeferredFees(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        totalLiabilities(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        updateReservation(_intentHash: PromiseOrValue<BytesLike>, _newAmount: PromiseOrValue<BigNumberish>, _releaseTime: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        withdrawCompensation(_recipient: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        withdrawFeeClaim(_recipient: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        withdrawFeeClaimFor(_beneficiary: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        withdrawRequestedStake(_recipient: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        withdrawStake(_recipient: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+    };
+}