/* Autogenerated file. Do not edit manually. */
/* eslint-disable */
import type {
  BaseContract,
  BigNumber,
  BigNumberish,
  BytesLike,
  CallOverrides,
  ContractTransaction,
  Overrides,
  PopulatedTransaction,
  Signer,
  utils,
} from 'ethers';
import type {
  FunctionFragment,
  Result,
  EventFragment,
} from '@ethersproject/abi';
import type { Listener, Provider } from '@ethersproject/providers';
import type {
  TypedEventFilter,
  TypedEvent,
  TypedListener,
  OnEvent,
} from './common';

export declare namespace IERC4626StakeToken {
  export type SignatureParamsStruct = {
    v: BigNumberish;
    r: BytesLike;
    s: BytesLike;
  };

  export type SignatureParamsStructOutput = [number, string, string] & {
    v: number;
    r: string;
    s: string;
  };

  export type CooldownSnapshotStruct = {
    amount: BigNumberish;
    endOfCooldown: BigNumberish;
    withdrawalWindow: BigNumberish;
  };

  export type CooldownSnapshotStructOutput = [BigNumber, number, number] & {
    amount: BigNumber;
    endOfCooldown: number;
    withdrawalWindow: number;
  };
}

export interface IERC4626StakeTokenInterface extends utils.Interface {
  functions: {
    'MIN_ASSETS_REMAINING()': FunctionFragment;
    'allowance(address,address)': FunctionFragment;
    'approve(address,uint256)': FunctionFragment;
    'asset()': FunctionFragment;
    'balanceOf(address)': FunctionFragment;
    'convertToAssets(uint256)': FunctionFragment;
    'convertToShares(uint256)': FunctionFragment;
    'cooldown()': FunctionFragment;
    'cooldownNonces(address)': FunctionFragment;
    'cooldownOnBehalfOf(address)': FunctionFragment;
    'cooldownWithPermit(address,uint256,(uint8,bytes32,bytes32))': FunctionFragment;
    'decimals()': FunctionFragment;
    'deposit(uint256,address)': FunctionFragment;
    'depositWithPermit(uint256,address,uint256,(uint8,bytes32,bytes32))': FunctionFragment;
    'getCooldown()': FunctionFragment;
    'getMaxSlashableAssets()': FunctionFragment;
    'getStakerCooldown(address)': FunctionFragment;
    'getUnstakeWindow()': FunctionFragment;
    'isCooldownOperator(address,address)': FunctionFragment;
    'maxDeposit(address)': FunctionFragment;
    'maxMint(address)': FunctionFragment;
    'maxRedeem(address)': FunctionFragment;
    'maxWithdraw(address)': FunctionFragment;
    'mint(uint256,address)': FunctionFragment;
    'name()': FunctionFragment;
    'pause()': FunctionFragment;
    'previewDeposit(uint256)': FunctionFragment;
    'previewMint(uint256)': FunctionFragment;
    'previewRedeem(uint256)': FunctionFragment;
    'previewWithdraw(uint256)': FunctionFragment;
    'redeem(uint256,address,address)': FunctionFragment;
    'setCooldown(uint256)': FunctionFragment;
    'setCooldownOperator(address,bool)': FunctionFragment;
    'setUnstakeWindow(uint256)': FunctionFragment;
    'slash(address,uint256)': FunctionFragment;
    'symbol()': FunctionFragment;
    'totalAssets()': FunctionFragment;
    'totalSupply()': FunctionFragment;
    'transfer(address,uint256)': FunctionFragment;
    'transferFrom(address,address,uint256)': FunctionFragment;
    'unpause()': FunctionFragment;
    'withdraw(uint256,address,address)': FunctionFragment;
  };

  getFunction(
    nameOrSignatureOrTopic:
      | 'MIN_ASSETS_REMAINING'
      | 'allowance'
      | 'approve'
      | 'asset'
      | 'balanceOf'
      | 'convertToAssets'
      | 'convertToShares'
      | 'cooldown'
      | 'cooldownNonces'
      | 'cooldownOnBehalfOf'
      | 'cooldownWithPermit'
      | 'decimals'
      | 'deposit'
      | 'depositWithPermit'
      | 'getCooldown'
      | 'getMaxSlashableAssets'
      | 'getStakerCooldown'
      | 'getUnstakeWindow'
      | 'isCooldownOperator'
      | 'maxDeposit'
      | 'maxMint'
      | 'maxRedeem'
      | 'maxWithdraw'
      | 'mint'
      | 'name'
      | 'pause'
      | 'previewDeposit'
      | 'previewMint'
      | 'previewRedeem'
      | 'previewWithdraw'
      | 'redeem'
      | 'setCooldown'
      | 'setCooldownOperator'
      | 'setUnstakeWindow'
      | 'slash'
      | 'symbol'
      | 'totalAssets'
      | 'totalSupply'
      | 'transfer'
      | 'transferFrom'
      | 'unpause'
      | 'withdraw',
  ): FunctionFragment;

  encodeFunctionData(
    functionFragment: 'MIN_ASSETS_REMAINING',
    values?: undefined,
  ): string;
  encodeFunctionData(
    functionFragment: 'allowance',
    values: [string, string],
  ): string;
  encodeFunctionData(
    functionFragment: 'approve',
    values: [string, BigNumberish],
  ): string;
  encodeFunctionData(functionFragment: 'asset', values?: undefined): string;
  encodeFunctionData(functionFragment: 'balanceOf', values: [string]): string;
  encodeFunctionData(
    functionFragment: 'convertToAssets',
    values: [BigNumberish],
  ): string;
  encodeFunctionData(
    functionFragment: 'convertToShares',
    values: [BigNumberish],
  ): string;
  encodeFunctionData(functionFragment: 'cooldown', values?: undefined): string;
  encodeFunctionData(
    functionFragment: 'cooldownNonces',
    values: [string],
  ): string;
  encodeFunctionData(
    functionFragment: 'cooldownOnBehalfOf',
    values: [string],
  ): string;
  encodeFunctionData(
    functionFragment: 'cooldownWithPermit',
    values: [string, BigNumberish, IERC4626StakeToken.SignatureParamsStruct],
  ): string;
  encodeFunctionData(functionFragment: 'decimals', values?: undefined): string;
  encodeFunctionData(
    functionFragment: 'deposit',
    values: [BigNumberish, string],
  ): string;
  encodeFunctionData(
    functionFragment: 'depositWithPermit',
    values: [
      BigNumberish,
      string,
      BigNumberish,
      IERC4626StakeToken.SignatureParamsStruct,
    ],
  ): string;
  encodeFunctionData(
    functionFragment: 'getCooldown',
    values?: undefined,
  ): string;
  encodeFunctionData(
    functionFragment: 'getMaxSlashableAssets',
    values?: undefined,
  ): string;
  encodeFunctionData(
    functionFragment: 'getStakerCooldown',
    values: [string],
  ): string;
  encodeFunctionData(
    functionFragment: 'getUnstakeWindow',
    values?: undefined,
  ): string;
  encodeFunctionData(
    functionFragment: 'isCooldownOperator',
    values: [string, string],
  ): string;
  encodeFunctionData(functionFragment: 'maxDeposit', values: [string]): string;
  encodeFunctionData(functionFragment: 'maxMint', values: [string]): string;
  encodeFunctionData(functionFragment: 'maxRedeem', values: [string]): string;
  encodeFunctionData(functionFragment: 'maxWithdraw', values: [string]): string;
  encodeFunctionData(
    functionFragment: 'mint',
    values: [BigNumberish, string],
  ): string;
  encodeFunctionData(functionFragment: 'name', values?: undefined): string;
  encodeFunctionData(functionFragment: 'pause', values?: undefined): string;
  encodeFunctionData(
    functionFragment: 'previewDeposit',
    values: [BigNumberish],
  ): string;
  encodeFunctionData(
    functionFragment: 'previewMint',
    values: [BigNumberish],
  ): string;
  encodeFunctionData(
    functionFragment: 'previewRedeem',
    values: [BigNumberish],
  ): string;
  encodeFunctionData(
    functionFragment: 'previewWithdraw',
    values: [BigNumberish],
  ): string;
  encodeFunctionData(
    functionFragment: 'redeem',
    values: [BigNumberish, string, string],
  ): string;
  encodeFunctionData(
    functionFragment: 'setCooldown',
    values: [BigNumberish],
  ): string;
  encodeFunctionData(
    functionFragment: 'setCooldownOperator',
    values: [string, boolean],
  ): string;
  encodeFunctionData(
    functionFragment: 'setUnstakeWindow',
    values: [BigNumberish],
  ): string;
  encodeFunctionData(
    functionFragment: 'slash',
    values: [string, BigNumberish],
  ): string;
  encodeFunctionData(functionFragment: 'symbol', values?: undefined): string;
  encodeFunctionData(
    functionFragment: 'totalAssets',
    values?: undefined,
  ): string;
  encodeFunctionData(
    functionFragment: 'totalSupply',
    values?: undefined,
  ): string;
  encodeFunctionData(
    functionFragment: 'transfer',
    values: [string, BigNumberish],
  ): string;
  encodeFunctionData(
    functionFragment: 'transferFrom',
    values: [string, string, BigNumberish],
  ): string;
  encodeFunctionData(functionFragment: 'unpause', values?: undefined): string;
  encodeFunctionData(
    functionFragment: 'withdraw',
    values: [BigNumberish, string, string],
  ): string;

  decodeFunctionResult(
    functionFragment: 'MIN_ASSETS_REMAINING',
    data: BytesLike,
  ): Result;
  decodeFunctionResult(functionFragment: 'allowance', data: BytesLike): Result;
  decodeFunctionResult(functionFragment: 'approve', data: BytesLike): Result;
  decodeFunctionResult(functionFragment: 'asset', data: BytesLike): Result;
  decodeFunctionResult(functionFragment: 'balanceOf', data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: 'convertToAssets',
    data: BytesLike,
  ): Result;
  decodeFunctionResult(
    functionFragment: 'convertToShares',
    data: BytesLike,
  ): Result;
  decodeFunctionResult(functionFragment: 'cooldown', data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: 'cooldownNonces',
    data: BytesLike,
  ): Result;
  decodeFunctionResult(
    functionFragment: 'cooldownOnBehalfOf',
    data: BytesLike,
  ): Result;
  decodeFunctionResult(
    functionFragment: 'cooldownWithPermit',
    data: BytesLike,
  ): Result;
  decodeFunctionResult(functionFragment: 'decimals', data: BytesLike): Result;
  decodeFunctionResult(functionFragment: 'deposit', data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: 'depositWithPermit',
    data: BytesLike,
  ): Result;
  decodeFunctionResult(
    functionFragment: 'getCooldown',
    data: BytesLike,
  ): Result;
  decodeFunctionResult(
    functionFragment: 'getMaxSlashableAssets',
    data: BytesLike,
  ): Result;
  decodeFunctionResult(
    functionFragment: 'getStakerCooldown',
    data: BytesLike,
  ): Result;
  decodeFunctionResult(
    functionFragment: 'getUnstakeWindow',
    data: BytesLike,
  ): Result;
  decodeFunctionResult(
    functionFragment: 'isCooldownOperator',
    data: BytesLike,
  ): Result;
  decodeFunctionResult(functionFragment: 'maxDeposit', data: BytesLike): Result;
  decodeFunctionResult(functionFragment: 'maxMint', data: BytesLike): Result;
  decodeFunctionResult(functionFragment: 'maxRedeem', data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: 'maxWithdraw',
    data: BytesLike,
  ): Result;
  decodeFunctionResult(functionFragment: 'mint', data: BytesLike): Result;
  decodeFunctionResult(functionFragment: 'name', data: BytesLike): Result;
  decodeFunctionResult(functionFragment: 'pause', data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: 'previewDeposit',
    data: BytesLike,
  ): Result;
  decodeFunctionResult(
    functionFragment: 'previewMint',
    data: BytesLike,
  ): Result;
  decodeFunctionResult(
    functionFragment: 'previewRedeem',
    data: BytesLike,
  ): Result;
  decodeFunctionResult(
    functionFragment: 'previewWithdraw',
    data: BytesLike,
  ): Result;
  decodeFunctionResult(functionFragment: 'redeem', data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: 'setCooldown',
    data: BytesLike,
  ): Result;
  decodeFunctionResult(
    functionFragment: 'setCooldownOperator',
    data: BytesLike,
  ): Result;
  decodeFunctionResult(
    functionFragment: 'setUnstakeWindow',
    data: BytesLike,
  ): Result;
  decodeFunctionResult(functionFragment: 'slash', data: BytesLike): Result;
  decodeFunctionResult(functionFragment: 'symbol', data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: 'totalAssets',
    data: BytesLike,
  ): Result;
  decodeFunctionResult(
    functionFragment: 'totalSupply',
    data: BytesLike,
  ): Result;
  decodeFunctionResult(functionFragment: 'transfer', data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: 'transferFrom',
    data: BytesLike,
  ): Result;
  decodeFunctionResult(functionFragment: 'unpause', data: BytesLike): Result;
  decodeFunctionResult(functionFragment: 'withdraw', data: BytesLike): Result;

  events: {
    'Approval(address,address,uint256)': EventFragment;
    'CooldownChanged(uint256,uint256)': EventFragment;
    'CooldownOperatorSet(address,address,bool)': EventFragment;
    'Deposit(address,address,uint256,uint256)': EventFragment;
    'Slashed(address,uint256)': EventFragment;
    'StakerCooldownUpdated(address,uint256,uint256,uint256)': EventFragment;
    'Transfer(address,address,uint256)': EventFragment;
    'UnstakeWindowChanged(uint256,uint256)': EventFragment;
    'Withdraw(address,address,address,uint256,uint256)': EventFragment;
  };

  getEvent(nameOrSignatureOrTopic: 'Approval'): EventFragment;
  getEvent(nameOrSignatureOrTopic: 'CooldownChanged'): EventFragment;
  getEvent(nameOrSignatureOrTopic: 'CooldownOperatorSet'): EventFragment;
  getEvent(nameOrSignatureOrTopic: 'Deposit'): EventFragment;
  getEvent(nameOrSignatureOrTopic: 'Slashed'): EventFragment;
  getEvent(nameOrSignatureOrTopic: 'StakerCooldownUpdated'): EventFragment;
  getEvent(nameOrSignatureOrTopic: 'Transfer'): EventFragment;
  getEvent(nameOrSignatureOrTopic: 'UnstakeWindowChanged'): EventFragment;
  getEvent(nameOrSignatureOrTopic: 'Withdraw'): EventFragment;
}

export interface ApprovalEventObject {
  owner: string;
  spender: string;
  value: BigNumber;
}
export type ApprovalEvent = TypedEvent<
  [string, string, BigNumber],
  ApprovalEventObject
>;

export type ApprovalEventFilter = TypedEventFilter<ApprovalEvent>;

export interface CooldownChangedEventObject {
  oldCooldown: BigNumber;
  newCooldown: BigNumber;
}
export type CooldownChangedEvent = TypedEvent<
  [BigNumber, BigNumber],
  CooldownChangedEventObject
>;

export type CooldownChangedEventFilter = TypedEventFilter<CooldownChangedEvent>;

export interface CooldownOperatorSetEventObject {
  user: string;
  operator: string;
  flag: boolean;
}
export type CooldownOperatorSetEvent = TypedEvent<
  [string, string, boolean],
  CooldownOperatorSetEventObject
>;

export type CooldownOperatorSetEventFilter =
  TypedEventFilter<CooldownOperatorSetEvent>;

export interface DepositEventObject {
  sender: string;
  owner: string;
  assets: BigNumber;
  shares: BigNumber;
}
export type DepositEvent = TypedEvent<
  [string, string, BigNumber, BigNumber],
  DepositEventObject
>;

export type DepositEventFilter = TypedEventFilter<DepositEvent>;

export interface SlashedEventObject {
  destination: string;
  amount: BigNumber;
}
export type SlashedEvent = TypedEvent<[string, BigNumber], SlashedEventObject>;

export type SlashedEventFilter = TypedEventFilter<SlashedEvent>;

export interface StakerCooldownUpdatedEventObject {
  user: string;
  amount: BigNumber;
  endOfCooldown: BigNumber;
  unstakeWindow: BigNumber;
}
export type StakerCooldownUpdatedEvent = TypedEvent<
  [string, BigNumber, BigNumber, BigNumber],
  StakerCooldownUpdatedEventObject
>;

export type StakerCooldownUpdatedEventFilter =
  TypedEventFilter<StakerCooldownUpdatedEvent>;

export interface TransferEventObject {
  from: string;
  to: string;
  value: BigNumber;
}
export type TransferEvent = TypedEvent<
  [string, string, BigNumber],
  TransferEventObject
>;

export type TransferEventFilter = TypedEventFilter<TransferEvent>;

export interface UnstakeWindowChangedEventObject {
  oldUnstakeWindow: BigNumber;
  newUnstakeWindow: BigNumber;
}
export type UnstakeWindowChangedEvent = TypedEvent<
  [BigNumber, BigNumber],
  UnstakeWindowChangedEventObject
>;

export type UnstakeWindowChangedEventFilter =
  TypedEventFilter<UnstakeWindowChangedEvent>;

export interface WithdrawEventObject {
  sender: string;
  receiver: string;
  owner: string;
  assets: BigNumber;
  shares: BigNumber;
}
export type WithdrawEvent = TypedEvent<
  [string, string, string, BigNumber, BigNumber],
  WithdrawEventObject
>;

export type WithdrawEventFilter = TypedEventFilter<WithdrawEvent>;

export interface IERC4626StakeToken extends BaseContract {
  connect(signerOrProvider: Signer | Provider | string): this;
  attach(addressOrName: string): this;
  deployed(): Promise<this>;

  interface: IERC4626StakeTokenInterface;

  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: {
    MIN_ASSETS_REMAINING(overrides?: CallOverrides): Promise<[BigNumber]>;

    allowance(
      owner: string,
      spender: string,
      overrides?: CallOverrides,
    ): Promise<[BigNumber]>;

    approve(
      spender: string,
      value: BigNumberish,
      overrides?: Overrides & { from?: string },
    ): Promise<ContractTransaction>;

    asset(
      overrides?: CallOverrides,
    ): Promise<[string] & { assetTokenAddress: string }>;

    balanceOf(account: string, overrides?: CallOverrides): Promise<[BigNumber]>;

    convertToAssets(
      shares: BigNumberish,
      overrides?: CallOverrides,
    ): Promise<[BigNumber] & { assets: BigNumber }>;

    convertToShares(
      assets: BigNumberish,
      overrides?: CallOverrides,
    ): Promise<[BigNumber] & { shares: BigNumber }>;

    cooldown(
      overrides?: Overrides & { from?: string },
    ): Promise<ContractTransaction>;

    cooldownNonces(
      owner: string,
      overrides?: CallOverrides,
    ): Promise<[BigNumber]>;

    cooldownOnBehalfOf(
      from: string,
      overrides?: Overrides & { from?: string },
    ): Promise<ContractTransaction>;

    cooldownWithPermit(
      user: string,
      deadline: BigNumberish,
      sig: IERC4626StakeToken.SignatureParamsStruct,
      overrides?: Overrides & { from?: string },
    ): Promise<ContractTransaction>;

    decimals(overrides?: CallOverrides): Promise<[number]>;

    deposit(
      assets: BigNumberish,
      receiver: string,
      overrides?: Overrides & { from?: string },
    ): Promise<ContractTransaction>;

    depositWithPermit(
      assets: BigNumberish,
      receiver: string,
      deadline: BigNumberish,
      sig: IERC4626StakeToken.SignatureParamsStruct,
      overrides?: Overrides & { from?: string },
    ): Promise<ContractTransaction>;

    getCooldown(overrides?: CallOverrides): Promise<[BigNumber]>;

    getMaxSlashableAssets(overrides?: CallOverrides): Promise<[BigNumber]>;

    getStakerCooldown(
      user: string,
      overrides?: CallOverrides,
    ): Promise<[IERC4626StakeToken.CooldownSnapshotStructOutput]>;

    getUnstakeWindow(overrides?: CallOverrides): Promise<[BigNumber]>;

    isCooldownOperator(
      user: string,
      operator: string,
      overrides?: CallOverrides,
    ): Promise<[boolean]>;

    maxDeposit(
      receiver: string,
      overrides?: CallOverrides,
    ): Promise<[BigNumber] & { maxAssets: BigNumber }>;

    maxMint(
      receiver: string,
      overrides?: CallOverrides,
    ): Promise<[BigNumber] & { maxShares: BigNumber }>;

    maxRedeem(
      owner: string,
      overrides?: CallOverrides,
    ): Promise<[BigNumber] & { maxShares: BigNumber }>;

    maxWithdraw(
      owner: string,
      overrides?: CallOverrides,
    ): Promise<[BigNumber] & { maxAssets: BigNumber }>;

    mint(
      shares: BigNumberish,
      receiver: string,
      overrides?: Overrides & { from?: string },
    ): Promise<ContractTransaction>;

    name(overrides?: CallOverrides): Promise<[string]>;

    pause(
      overrides?: Overrides & { from?: string },
    ): Promise<ContractTransaction>;

    previewDeposit(
      assets: BigNumberish,
      overrides?: CallOverrides,
    ): Promise<[BigNumber] & { shares: BigNumber }>;

    previewMint(
      shares: BigNumberish,
      overrides?: CallOverrides,
    ): Promise<[BigNumber] & { assets: BigNumber }>;

    previewRedeem(
      shares: BigNumberish,
      overrides?: CallOverrides,
    ): Promise<[BigNumber] & { assets: BigNumber }>;

    previewWithdraw(
      assets: BigNumberish,
      overrides?: CallOverrides,
    ): Promise<[BigNumber] & { shares: BigNumber }>;

    redeem(
      shares: BigNumberish,
      receiver: string,
      owner: string,
      overrides?: Overrides & { from?: string },
    ): Promise<ContractTransaction>;

    setCooldown(
      cooldown: BigNumberish,
      overrides?: Overrides & { from?: string },
    ): Promise<ContractTransaction>;

    setCooldownOperator(
      operator: string,
      flag: boolean,
      overrides?: Overrides & { from?: string },
    ): Promise<ContractTransaction>;

    setUnstakeWindow(
      newUnstakeWindow: BigNumberish,
      overrides?: Overrides & { from?: string },
    ): Promise<ContractTransaction>;

    slash(
      destination: string,
      amount: BigNumberish,
      overrides?: Overrides & { from?: string },
    ): Promise<ContractTransaction>;

    symbol(overrides?: CallOverrides): Promise<[string]>;

    totalAssets(
      overrides?: CallOverrides,
    ): Promise<[BigNumber] & { totalManagedAssets: BigNumber }>;

    totalSupply(overrides?: CallOverrides): Promise<[BigNumber]>;

    transfer(
      to: string,
      value: BigNumberish,
      overrides?: Overrides & { from?: string },
    ): Promise<ContractTransaction>;

    transferFrom(
      from: string,
      to: string,
      value: BigNumberish,
      overrides?: Overrides & { from?: string },
    ): Promise<ContractTransaction>;

    unpause(
      overrides?: Overrides & { from?: string },
    ): Promise<ContractTransaction>;

    withdraw(
      assets: BigNumberish,
      receiver: string,
      owner: string,
      overrides?: Overrides & { from?: string },
    ): Promise<ContractTransaction>;
  };

  MIN_ASSETS_REMAINING(overrides?: CallOverrides): Promise<BigNumber>;

  allowance(
    owner: string,
    spender: string,
    overrides?: CallOverrides,
  ): Promise<BigNumber>;

  approve(
    spender: string,
    value: BigNumberish,
    overrides?: Overrides & { from?: string },
  ): Promise<ContractTransaction>;

  asset(overrides?: CallOverrides): Promise<string>;

  balanceOf(account: string, overrides?: CallOverrides): Promise<BigNumber>;

  convertToAssets(
    shares: BigNumberish,
    overrides?: CallOverrides,
  ): Promise<BigNumber>;

  convertToShares(
    assets: BigNumberish,
    overrides?: CallOverrides,
  ): Promise<BigNumber>;

  cooldown(
    overrides?: Overrides & { from?: string },
  ): Promise<ContractTransaction>;

  cooldownNonces(owner: string, overrides?: CallOverrides): Promise<BigNumber>;

  cooldownOnBehalfOf(
    from: string,
    overrides?: Overrides & { from?: string },
  ): Promise<ContractTransaction>;

  cooldownWithPermit(
    user: string,
    deadline: BigNumberish,
    sig: IERC4626StakeToken.SignatureParamsStruct,
    overrides?: Overrides & { from?: string },
  ): Promise<ContractTransaction>;

  decimals(overrides?: CallOverrides): Promise<number>;

  deposit(
    assets: BigNumberish,
    receiver: string,
    overrides?: Overrides & { from?: string },
  ): Promise<ContractTransaction>;

  depositWithPermit(
    assets: BigNumberish,
    receiver: string,
    deadline: BigNumberish,
    sig: IERC4626StakeToken.SignatureParamsStruct,
    overrides?: Overrides & { from?: string },
  ): Promise<ContractTransaction>;

  getCooldown(overrides?: CallOverrides): Promise<BigNumber>;

  getMaxSlashableAssets(overrides?: CallOverrides): Promise<BigNumber>;

  getStakerCooldown(
    user: string,
    overrides?: CallOverrides,
  ): Promise<IERC4626StakeToken.CooldownSnapshotStructOutput>;

  getUnstakeWindow(overrides?: CallOverrides): Promise<BigNumber>;

  isCooldownOperator(
    user: string,
    operator: string,
    overrides?: CallOverrides,
  ): Promise<boolean>;

  maxDeposit(receiver: string, overrides?: CallOverrides): Promise<BigNumber>;

  maxMint(receiver: string, overrides?: CallOverrides): Promise<BigNumber>;

  maxRedeem(owner: string, overrides?: CallOverrides): Promise<BigNumber>;

  maxWithdraw(owner: string, overrides?: CallOverrides): Promise<BigNumber>;

  mint(
    shares: BigNumberish,
    receiver: string,
    overrides?: Overrides & { from?: string },
  ): Promise<ContractTransaction>;

  name(overrides?: CallOverrides): Promise<string>;

  pause(
    overrides?: Overrides & { from?: string },
  ): Promise<ContractTransaction>;

  previewDeposit(
    assets: BigNumberish,
    overrides?: CallOverrides,
  ): Promise<BigNumber>;

  previewMint(
    shares: BigNumberish,
    overrides?: CallOverrides,
  ): Promise<BigNumber>;

  previewRedeem(
    shares: BigNumberish,
    overrides?: CallOverrides,
  ): Promise<BigNumber>;

  previewWithdraw(
    assets: BigNumberish,
    overrides?: CallOverrides,
  ): Promise<BigNumber>;

  redeem(
    shares: BigNumberish,
    receiver: string,
    owner: string,
    overrides?: Overrides & { from?: string },
  ): Promise<ContractTransaction>;

  setCooldown(
    cooldown: BigNumberish,
    overrides?: Overrides & { from?: string },
  ): Promise<ContractTransaction>;

  setCooldownOperator(
    operator: string,
    flag: boolean,
    overrides?: Overrides & { from?: string },
  ): Promise<ContractTransaction>;

  setUnstakeWindow(
    newUnstakeWindow: BigNumberish,
    overrides?: Overrides & { from?: string },
  ): Promise<ContractTransaction>;

  slash(
    destination: string,
    amount: BigNumberish,
    overrides?: Overrides & { from?: string },
  ): Promise<ContractTransaction>;

  symbol(overrides?: CallOverrides): Promise<string>;

  totalAssets(overrides?: CallOverrides): Promise<BigNumber>;

  totalSupply(overrides?: CallOverrides): Promise<BigNumber>;

  transfer(
    to: string,
    value: BigNumberish,
    overrides?: Overrides & { from?: string },
  ): Promise<ContractTransaction>;

  transferFrom(
    from: string,
    to: string,
    value: BigNumberish,
    overrides?: Overrides & { from?: string },
  ): Promise<ContractTransaction>;

  unpause(
    overrides?: Overrides & { from?: string },
  ): Promise<ContractTransaction>;

  withdraw(
    assets: BigNumberish,
    receiver: string,
    owner: string,
    overrides?: Overrides & { from?: string },
  ): Promise<ContractTransaction>;

  callStatic: {
    MIN_ASSETS_REMAINING(overrides?: CallOverrides): Promise<BigNumber>;

    allowance(
      owner: string,
      spender: string,
      overrides?: CallOverrides,
    ): Promise<BigNumber>;

    approve(
      spender: string,
      value: BigNumberish,
      overrides?: CallOverrides,
    ): Promise<boolean>;

    asset(overrides?: CallOverrides): Promise<string>;

    balanceOf(account: string, overrides?: CallOverrides): Promise<BigNumber>;

    convertToAssets(
      shares: BigNumberish,
      overrides?: CallOverrides,
    ): Promise<BigNumber>;

    convertToShares(
      assets: BigNumberish,
      overrides?: CallOverrides,
    ): Promise<BigNumber>;

    cooldown(overrides?: CallOverrides): Promise<void>;

    cooldownNonces(
      owner: string,
      overrides?: CallOverrides,
    ): Promise<BigNumber>;

    cooldownOnBehalfOf(from: string, overrides?: CallOverrides): Promise<void>;

    cooldownWithPermit(
      user: string,
      deadline: BigNumberish,
      sig: IERC4626StakeToken.SignatureParamsStruct,
      overrides?: CallOverrides,
    ): Promise<void>;

    decimals(overrides?: CallOverrides): Promise<number>;

    deposit(
      assets: BigNumberish,
      receiver: string,
      overrides?: CallOverrides,
    ): Promise<BigNumber>;

    depositWithPermit(
      assets: BigNumberish,
      receiver: string,
      deadline: BigNumberish,
      sig: IERC4626StakeToken.SignatureParamsStruct,
      overrides?: CallOverrides,
    ): Promise<BigNumber>;

    getCooldown(overrides?: CallOverrides): Promise<BigNumber>;

    getMaxSlashableAssets(overrides?: CallOverrides): Promise<BigNumber>;

    getStakerCooldown(
      user: string,
      overrides?: CallOverrides,
    ): Promise<IERC4626StakeToken.CooldownSnapshotStructOutput>;

    getUnstakeWindow(overrides?: CallOverrides): Promise<BigNumber>;

    isCooldownOperator(
      user: string,
      operator: string,
      overrides?: CallOverrides,
    ): Promise<boolean>;

    maxDeposit(receiver: string, overrides?: CallOverrides): Promise<BigNumber>;

    maxMint(receiver: string, overrides?: CallOverrides): Promise<BigNumber>;

    maxRedeem(owner: string, overrides?: CallOverrides): Promise<BigNumber>;

    maxWithdraw(owner: string, overrides?: CallOverrides): Promise<BigNumber>;

    mint(
      shares: BigNumberish,
      receiver: string,
      overrides?: CallOverrides,
    ): Promise<BigNumber>;

    name(overrides?: CallOverrides): Promise<string>;

    pause(overrides?: CallOverrides): Promise<void>;

    previewDeposit(
      assets: BigNumberish,
      overrides?: CallOverrides,
    ): Promise<BigNumber>;

    previewMint(
      shares: BigNumberish,
      overrides?: CallOverrides,
    ): Promise<BigNumber>;

    previewRedeem(
      shares: BigNumberish,
      overrides?: CallOverrides,
    ): Promise<BigNumber>;

    previewWithdraw(
      assets: BigNumberish,
      overrides?: CallOverrides,
    ): Promise<BigNumber>;

    redeem(
      shares: BigNumberish,
      receiver: string,
      owner: string,
      overrides?: CallOverrides,
    ): Promise<BigNumber>;

    setCooldown(
      cooldown: BigNumberish,
      overrides?: CallOverrides,
    ): Promise<void>;

    setCooldownOperator(
      operator: string,
      flag: boolean,
      overrides?: CallOverrides,
    ): Promise<void>;

    setUnstakeWindow(
      newUnstakeWindow: BigNumberish,
      overrides?: CallOverrides,
    ): Promise<void>;

    slash(
      destination: string,
      amount: BigNumberish,
      overrides?: CallOverrides,
    ): Promise<BigNumber>;

    symbol(overrides?: CallOverrides): Promise<string>;

    totalAssets(overrides?: CallOverrides): Promise<BigNumber>;

    totalSupply(overrides?: CallOverrides): Promise<BigNumber>;

    transfer(
      to: string,
      value: BigNumberish,
      overrides?: CallOverrides,
    ): Promise<boolean>;

    transferFrom(
      from: string,
      to: string,
      value: BigNumberish,
      overrides?: CallOverrides,
    ): Promise<boolean>;

    unpause(overrides?: CallOverrides): Promise<void>;

    withdraw(
      assets: BigNumberish,
      receiver: string,
      owner: string,
      overrides?: CallOverrides,
    ): Promise<BigNumber>;
  };

  filters: {
    'Approval(address,address,uint256)'(
      owner?: string | null,
      spender?: string | null,
      value?: null,
    ): ApprovalEventFilter;
    Approval(
      owner?: string | null,
      spender?: string | null,
      value?: null,
    ): ApprovalEventFilter;

    'CooldownChanged(uint256,uint256)'(
      oldCooldown?: null,
      newCooldown?: null,
    ): CooldownChangedEventFilter;
    CooldownChanged(
      oldCooldown?: null,
      newCooldown?: null,
    ): CooldownChangedEventFilter;

    'CooldownOperatorSet(address,address,bool)'(
      user?: string | null,
      operator?: string | null,
      flag?: null,
    ): CooldownOperatorSetEventFilter;
    CooldownOperatorSet(
      user?: string | null,
      operator?: string | null,
      flag?: null,
    ): CooldownOperatorSetEventFilter;

    'Deposit(address,address,uint256,uint256)'(
      sender?: string | null,
      owner?: string | null,
      assets?: null,
      shares?: null,
    ): DepositEventFilter;
    Deposit(
      sender?: string | null,
      owner?: string | null,
      assets?: null,
      shares?: null,
    ): DepositEventFilter;

    'Slashed(address,uint256)'(
      destination?: string | null,
      amount?: null,
    ): SlashedEventFilter;
    Slashed(destination?: string | null, amount?: null): SlashedEventFilter;

    'StakerCooldownUpdated(address,uint256,uint256,uint256)'(
      user?: string | null,
      amount?: null,
      endOfCooldown?: null,
      unstakeWindow?: null,
    ): StakerCooldownUpdatedEventFilter;
    StakerCooldownUpdated(
      user?: string | null,
      amount?: null,
      endOfCooldown?: null,
      unstakeWindow?: null,
    ): StakerCooldownUpdatedEventFilter;

    'Transfer(address,address,uint256)'(
      from?: string | null,
      to?: string | null,
      value?: null,
    ): TransferEventFilter;
    Transfer(
      from?: string | null,
      to?: string | null,
      value?: null,
    ): TransferEventFilter;

    'UnstakeWindowChanged(uint256,uint256)'(
      oldUnstakeWindow?: null,
      newUnstakeWindow?: null,
    ): UnstakeWindowChangedEventFilter;
    UnstakeWindowChanged(
      oldUnstakeWindow?: null,
      newUnstakeWindow?: null,
    ): UnstakeWindowChangedEventFilter;

    'Withdraw(address,address,address,uint256,uint256)'(
      sender?: string | null,
      receiver?: string | null,
      owner?: string | null,
      assets?: null,
      shares?: null,
    ): WithdrawEventFilter;
    Withdraw(
      sender?: string | null,
      receiver?: string | null,
      owner?: string | null,
      assets?: null,
      shares?: null,
    ): WithdrawEventFilter;
  };

  estimateGas: {
    MIN_ASSETS_REMAINING(overrides?: CallOverrides): Promise<BigNumber>;

    allowance(
      owner: string,
      spender: string,
      overrides?: CallOverrides,
    ): Promise<BigNumber>;

    approve(
      spender: string,
      value: BigNumberish,
      overrides?: Overrides & { from?: string },
    ): Promise<BigNumber>;

    asset(overrides?: CallOverrides): Promise<BigNumber>;

    balanceOf(account: string, overrides?: CallOverrides): Promise<BigNumber>;

    convertToAssets(
      shares: BigNumberish,
      overrides?: CallOverrides,
    ): Promise<BigNumber>;

    convertToShares(
      assets: BigNumberish,
      overrides?: CallOverrides,
    ): Promise<BigNumber>;

    cooldown(overrides?: Overrides & { from?: string }): Promise<BigNumber>;

    cooldownNonces(
      owner: string,
      overrides?: CallOverrides,
    ): Promise<BigNumber>;

    cooldownOnBehalfOf(
      from: string,
      overrides?: Overrides & { from?: string },
    ): Promise<BigNumber>;

    cooldownWithPermit(
      user: string,
      deadline: BigNumberish,
      sig: IERC4626StakeToken.SignatureParamsStruct,
      overrides?: Overrides & { from?: string },
    ): Promise<BigNumber>;

    decimals(overrides?: CallOverrides): Promise<BigNumber>;

    deposit(
      assets: BigNumberish,
      receiver: string,
      overrides?: Overrides & { from?: string },
    ): Promise<BigNumber>;

    depositWithPermit(
      assets: BigNumberish,
      receiver: string,
      deadline: BigNumberish,
      sig: IERC4626StakeToken.SignatureParamsStruct,
      overrides?: Overrides & { from?: string },
    ): Promise<BigNumber>;

    getCooldown(overrides?: CallOverrides): Promise<BigNumber>;

    getMaxSlashableAssets(overrides?: CallOverrides): Promise<BigNumber>;

    getStakerCooldown(
      user: string,
      overrides?: CallOverrides,
    ): Promise<BigNumber>;

    getUnstakeWindow(overrides?: CallOverrides): Promise<BigNumber>;

    isCooldownOperator(
      user: string,
      operator: string,
      overrides?: CallOverrides,
    ): Promise<BigNumber>;

    maxDeposit(receiver: string, overrides?: CallOverrides): Promise<BigNumber>;

    maxMint(receiver: string, overrides?: CallOverrides): Promise<BigNumber>;

    maxRedeem(owner: string, overrides?: CallOverrides): Promise<BigNumber>;

    maxWithdraw(owner: string, overrides?: CallOverrides): Promise<BigNumber>;

    mint(
      shares: BigNumberish,
      receiver: string,
      overrides?: Overrides & { from?: string },
    ): Promise<BigNumber>;

    name(overrides?: CallOverrides): Promise<BigNumber>;

    pause(overrides?: Overrides & { from?: string }): Promise<BigNumber>;

    previewDeposit(
      assets: BigNumberish,
      overrides?: CallOverrides,
    ): Promise<BigNumber>;

    previewMint(
      shares: BigNumberish,
      overrides?: CallOverrides,
    ): Promise<BigNumber>;

    previewRedeem(
      shares: BigNumberish,
      overrides?: CallOverrides,
    ): Promise<BigNumber>;

    previewWithdraw(
      assets: BigNumberish,
      overrides?: CallOverrides,
    ): Promise<BigNumber>;

    redeem(
      shares: BigNumberish,
      receiver: string,
      owner: string,
      overrides?: Overrides & { from?: string },
    ): Promise<BigNumber>;

    setCooldown(
      cooldown: BigNumberish,
      overrides?: Overrides & { from?: string },
    ): Promise<BigNumber>;

    setCooldownOperator(
      operator: string,
      flag: boolean,
      overrides?: Overrides & { from?: string },
    ): Promise<BigNumber>;

    setUnstakeWindow(
      newUnstakeWindow: BigNumberish,
      overrides?: Overrides & { from?: string },
    ): Promise<BigNumber>;

    slash(
      destination: string,
      amount: BigNumberish,
      overrides?: Overrides & { from?: string },
    ): Promise<BigNumber>;

    symbol(overrides?: CallOverrides): Promise<BigNumber>;

    totalAssets(overrides?: CallOverrides): Promise<BigNumber>;

    totalSupply(overrides?: CallOverrides): Promise<BigNumber>;

    transfer(
      to: string,
      value: BigNumberish,
      overrides?: Overrides & { from?: string },
    ): Promise<BigNumber>;

    transferFrom(
      from: string,
      to: string,
      value: BigNumberish,
      overrides?: Overrides & { from?: string },
    ): Promise<BigNumber>;

    unpause(overrides?: Overrides & { from?: string }): Promise<BigNumber>;

    withdraw(
      assets: BigNumberish,
      receiver: string,
      owner: string,
      overrides?: Overrides & { from?: string },
    ): Promise<BigNumber>;
  };

  populateTransaction: {
    MIN_ASSETS_REMAINING(
      overrides?: CallOverrides,
    ): Promise<PopulatedTransaction>;

    allowance(
      owner: string,
      spender: string,
      overrides?: CallOverrides,
    ): Promise<PopulatedTransaction>;

    approve(
      spender: string,
      value: BigNumberish,
      overrides?: Overrides & { from?: string },
    ): Promise<PopulatedTransaction>;

    asset(overrides?: CallOverrides): Promise<PopulatedTransaction>;

    balanceOf(
      account: string,
      overrides?: CallOverrides,
    ): Promise<PopulatedTransaction>;

    convertToAssets(
      shares: BigNumberish,
      overrides?: CallOverrides,
    ): Promise<PopulatedTransaction>;

    convertToShares(
      assets: BigNumberish,
      overrides?: CallOverrides,
    ): Promise<PopulatedTransaction>;

    cooldown(
      overrides?: Overrides & { from?: string },
    ): Promise<PopulatedTransaction>;

    cooldownNonces(
      owner: string,
      overrides?: CallOverrides,
    ): Promise<PopulatedTransaction>;

    cooldownOnBehalfOf(
      from: string,
      overrides?: Overrides & { from?: string },
    ): Promise<PopulatedTransaction>;

    cooldownWithPermit(
      user: string,
      deadline: BigNumberish,
      sig: IERC4626StakeToken.SignatureParamsStruct,
      overrides?: Overrides & { from?: string },
    ): Promise<PopulatedTransaction>;

    decimals(overrides?: CallOverrides): Promise<PopulatedTransaction>;

    deposit(
      assets: BigNumberish,
      receiver: string,
      overrides?: Overrides & { from?: string },
    ): Promise<PopulatedTransaction>;

    depositWithPermit(
      assets: BigNumberish,
      receiver: string,
      deadline: BigNumberish,
      sig: IERC4626StakeToken.SignatureParamsStruct,
      overrides?: Overrides & { from?: string },
    ): Promise<PopulatedTransaction>;

    getCooldown(overrides?: CallOverrides): Promise<PopulatedTransaction>;

    getMaxSlashableAssets(
      overrides?: CallOverrides,
    ): Promise<PopulatedTransaction>;

    getStakerCooldown(
      user: string,
      overrides?: CallOverrides,
    ): Promise<PopulatedTransaction>;

    getUnstakeWindow(overrides?: CallOverrides): Promise<PopulatedTransaction>;

    isCooldownOperator(
      user: string,
      operator: string,
      overrides?: CallOverrides,
    ): Promise<PopulatedTransaction>;

    maxDeposit(
      receiver: string,
      overrides?: CallOverrides,
    ): Promise<PopulatedTransaction>;

    maxMint(
      receiver: string,
      overrides?: CallOverrides,
    ): Promise<PopulatedTransaction>;

    maxRedeem(
      owner: string,
      overrides?: CallOverrides,
    ): Promise<PopulatedTransaction>;

    maxWithdraw(
      owner: string,
      overrides?: CallOverrides,
    ): Promise<PopulatedTransaction>;

    mint(
      shares: BigNumberish,
      receiver: string,
      overrides?: Overrides & { from?: string },
    ): Promise<PopulatedTransaction>;

    name(overrides?: CallOverrides): Promise<PopulatedTransaction>;

    pause(
      overrides?: Overrides & { from?: string },
    ): Promise<PopulatedTransaction>;

    previewDeposit(
      assets: BigNumberish,
      overrides?: CallOverrides,
    ): Promise<PopulatedTransaction>;

    previewMint(
      shares: BigNumberish,
      overrides?: CallOverrides,
    ): Promise<PopulatedTransaction>;

    previewRedeem(
      shares: BigNumberish,
      overrides?: CallOverrides,
    ): Promise<PopulatedTransaction>;

    previewWithdraw(
      assets: BigNumberish,
      overrides?: CallOverrides,
    ): Promise<PopulatedTransaction>;

    redeem(
      shares: BigNumberish,
      receiver: string,
      owner: string,
      overrides?: Overrides & { from?: string },
    ): Promise<PopulatedTransaction>;

    setCooldown(
      cooldown: BigNumberish,
      overrides?: Overrides & { from?: string },
    ): Promise<PopulatedTransaction>;

    setCooldownOperator(
      operator: string,
      flag: boolean,
      overrides?: Overrides & { from?: string },
    ): Promise<PopulatedTransaction>;

    setUnstakeWindow(
      newUnstakeWindow: BigNumberish,
      overrides?: Overrides & { from?: string },
    ): Promise<PopulatedTransaction>;

    slash(
      destination: string,
      amount: BigNumberish,
      overrides?: Overrides & { from?: string },
    ): Promise<PopulatedTransaction>;

    symbol(overrides?: CallOverrides): Promise<PopulatedTransaction>;

    totalAssets(overrides?: CallOverrides): Promise<PopulatedTransaction>;

    totalSupply(overrides?: CallOverrides): Promise<PopulatedTransaction>;

    transfer(
      to: string,
      value: BigNumberish,
      overrides?: Overrides & { from?: string },
    ): Promise<PopulatedTransaction>;

    transferFrom(
      from: string,
      to: string,
      value: BigNumberish,
      overrides?: Overrides & { from?: string },
    ): Promise<PopulatedTransaction>;

    unpause(
      overrides?: Overrides & { from?: string },
    ): Promise<PopulatedTransaction>;

    withdraw(
      assets: BigNumberish,
      receiver: string,
      owner: string,
      overrides?: Overrides & { from?: string },
    ): Promise<PopulatedTransaction>;
  };
}