/* Autogenerated file. Do not edit manually. */
/* tslint:disable */
/* eslint-disable */

import {
  ethers,
  EventFilter,
  Signer,
  BigNumber,
  BigNumberish,
  PopulatedTransaction,
  BaseContract,
  ContractTransaction,
  Overrides,
  CallOverrides,
} from "ethers";
import { BytesLike } from "@ethersproject/bytes";
import { Listener, Provider } from "@ethersproject/providers";
import { FunctionFragment, EventFragment, Result } from "@ethersproject/abi";
import type { TypedEventFilter, TypedEvent, TypedListener } from "./common";

interface L2GraphTokenLockWalletInterface extends ethers.utils.Interface {
  functions: {
    "acceptLock()": FunctionFragment;
    "amountPerPeriod()": FunctionFragment;
    "approveProtocol()": FunctionFragment;
    "availableAmount()": FunctionFragment;
    "beneficiary()": FunctionFragment;
    "cancelLock()": FunctionFragment;
    "changeBeneficiary(address)": FunctionFragment;
    "currentBalance()": FunctionFragment;
    "currentPeriod()": FunctionFragment;
    "currentTime()": FunctionFragment;
    "duration()": FunctionFragment;
    "endTime()": FunctionFragment;
    "initialize(address,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,uint8)": FunctionFragment;
    "initializeFromL1(address,address,(address,address,address,uint256,uint256,uint256))": FunctionFragment;
    "isAccepted()": FunctionFragment;
    "isInitialized()": FunctionFragment;
    "isRevoked()": FunctionFragment;
    "managedAmount()": FunctionFragment;
    "manager()": FunctionFragment;
    "owner()": FunctionFragment;
    "passedPeriods()": FunctionFragment;
    "periodDuration()": FunctionFragment;
    "periods()": FunctionFragment;
    "releasableAmount()": FunctionFragment;
    "release()": FunctionFragment;
    "releaseStartTime()": FunctionFragment;
    "releasedAmount()": FunctionFragment;
    "renounceOwnership()": FunctionFragment;
    "revocable()": FunctionFragment;
    "revoke()": FunctionFragment;
    "revokeProtocol()": FunctionFragment;
    "revokedAmount()": FunctionFragment;
    "setManager(address)": FunctionFragment;
    "sinceStartTime()": FunctionFragment;
    "startTime()": FunctionFragment;
    "surplusAmount()": FunctionFragment;
    "token()": FunctionFragment;
    "totalOutstandingAmount()": FunctionFragment;
    "transferOwnership(address)": FunctionFragment;
    "usedAmount()": FunctionFragment;
    "vestedAmount()": FunctionFragment;
    "vestingCliffTime()": FunctionFragment;
    "withdrawSurplus(uint256)": FunctionFragment;
  };

  encodeFunctionData(
    functionFragment: "acceptLock",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "amountPerPeriod",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "approveProtocol",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "availableAmount",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "beneficiary",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "cancelLock",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "changeBeneficiary",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "currentBalance",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "currentPeriod",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "currentTime",
    values?: undefined
  ): string;
  encodeFunctionData(functionFragment: "duration", values?: undefined): string;
  encodeFunctionData(functionFragment: "endTime", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "initialize",
    values: [
      string,
      string,
      string,
      string,
      BigNumberish,
      BigNumberish,
      BigNumberish,
      BigNumberish,
      BigNumberish,
      BigNumberish,
      BigNumberish
    ]
  ): string;
  encodeFunctionData(
    functionFragment: "initializeFromL1",
    values: [
      string,
      string,
      {
        l1Address: string;
        owner: string;
        beneficiary: string;
        managedAmount: BigNumberish;
        startTime: BigNumberish;
        endTime: BigNumberish;
      }
    ]
  ): string;
  encodeFunctionData(
    functionFragment: "isAccepted",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "isInitialized",
    values?: undefined
  ): string;
  encodeFunctionData(functionFragment: "isRevoked", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "managedAmount",
    values?: undefined
  ): string;
  encodeFunctionData(functionFragment: "manager", values?: undefined): string;
  encodeFunctionData(functionFragment: "owner", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "passedPeriods",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "periodDuration",
    values?: undefined
  ): string;
  encodeFunctionData(functionFragment: "periods", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "releasableAmount",
    values?: undefined
  ): string;
  encodeFunctionData(functionFragment: "release", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "releaseStartTime",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "releasedAmount",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "renounceOwnership",
    values?: undefined
  ): string;
  encodeFunctionData(functionFragment: "revocable", values?: undefined): string;
  encodeFunctionData(functionFragment: "revoke", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "revokeProtocol",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "revokedAmount",
    values?: undefined
  ): string;
  encodeFunctionData(functionFragment: "setManager", values: [string]): string;
  encodeFunctionData(
    functionFragment: "sinceStartTime",
    values?: undefined
  ): string;
  encodeFunctionData(functionFragment: "startTime", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "surplusAmount",
    values?: undefined
  ): string;
  encodeFunctionData(functionFragment: "token", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "totalOutstandingAmount",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "transferOwnership",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "usedAmount",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "vestedAmount",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "vestingCliffTime",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "withdrawSurplus",
    values: [BigNumberish]
  ): string;

  decodeFunctionResult(functionFragment: "acceptLock", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "amountPerPeriod",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "approveProtocol",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "availableAmount",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "beneficiary",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "cancelLock", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "changeBeneficiary",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "currentBalance",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "currentPeriod",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "currentTime",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "duration", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "endTime", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "initialize", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "initializeFromL1",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "isAccepted", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "isInitialized",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "isRevoked", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "managedAmount",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "manager", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "owner", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "passedPeriods",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "periodDuration",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "periods", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "releasableAmount",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "release", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "releaseStartTime",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "releasedAmount",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "renounceOwnership",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "revocable", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "revoke", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "revokeProtocol",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "revokedAmount",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "setManager", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "sinceStartTime",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "startTime", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "surplusAmount",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "token", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "totalOutstandingAmount",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "transferOwnership",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "usedAmount", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "vestedAmount",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "vestingCliffTime",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "withdrawSurplus",
    data: BytesLike
  ): Result;

  events: {
    "BeneficiaryChanged(address)": EventFragment;
    "LockAccepted()": EventFragment;
    "LockCanceled()": EventFragment;
    "ManagerUpdated(address,address)": EventFragment;
    "OwnershipTransferred(address,address)": EventFragment;
    "TokenDestinationsApproved()": EventFragment;
    "TokenDestinationsRevoked()": EventFragment;
    "TokensReleased(address,uint256)": EventFragment;
    "TokensRevoked(address,uint256)": EventFragment;
    "TokensWithdrawn(address,uint256)": EventFragment;
  };

  getEvent(nameOrSignatureOrTopic: "BeneficiaryChanged"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "LockAccepted"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "LockCanceled"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "ManagerUpdated"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "OwnershipTransferred"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "TokenDestinationsApproved"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "TokenDestinationsRevoked"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "TokensReleased"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "TokensRevoked"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "TokensWithdrawn"): EventFragment;
}

export type BeneficiaryChangedEvent = TypedEvent<
  [string] & { newBeneficiary: string }
>;

export type LockAcceptedEvent = TypedEvent<[] & {}>;

export type LockCanceledEvent = TypedEvent<[] & {}>;

export type ManagerUpdatedEvent = TypedEvent<
  [string, string] & { _oldManager: string; _newManager: string }
>;

export type OwnershipTransferredEvent = TypedEvent<
  [string, string] & { previousOwner: string; newOwner: string }
>;

export type TokenDestinationsApprovedEvent = TypedEvent<[] & {}>;

export type TokenDestinationsRevokedEvent = TypedEvent<[] & {}>;

export type TokensReleasedEvent = TypedEvent<
  [string, BigNumber] & { beneficiary: string; amount: BigNumber }
>;

export type TokensRevokedEvent = TypedEvent<
  [string, BigNumber] & { beneficiary: string; amount: BigNumber }
>;

export type TokensWithdrawnEvent = TypedEvent<
  [string, BigNumber] & { beneficiary: string; amount: BigNumber }
>;

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

  listeners<EventArgsArray extends Array<any>, EventArgsObject>(
    eventFilter?: TypedEventFilter<EventArgsArray, EventArgsObject>
  ): Array<TypedListener<EventArgsArray, EventArgsObject>>;
  off<EventArgsArray extends Array<any>, EventArgsObject>(
    eventFilter: TypedEventFilter<EventArgsArray, EventArgsObject>,
    listener: TypedListener<EventArgsArray, EventArgsObject>
  ): this;
  on<EventArgsArray extends Array<any>, EventArgsObject>(
    eventFilter: TypedEventFilter<EventArgsArray, EventArgsObject>,
    listener: TypedListener<EventArgsArray, EventArgsObject>
  ): this;
  once<EventArgsArray extends Array<any>, EventArgsObject>(
    eventFilter: TypedEventFilter<EventArgsArray, EventArgsObject>,
    listener: TypedListener<EventArgsArray, EventArgsObject>
  ): this;
  removeListener<EventArgsArray extends Array<any>, EventArgsObject>(
    eventFilter: TypedEventFilter<EventArgsArray, EventArgsObject>,
    listener: TypedListener<EventArgsArray, EventArgsObject>
  ): this;
  removeAllListeners<EventArgsArray extends Array<any>, EventArgsObject>(
    eventFilter: TypedEventFilter<EventArgsArray, EventArgsObject>
  ): this;

  listeners(eventName?: string): Array<Listener>;
  off(eventName: string, listener: Listener): this;
  on(eventName: string, listener: Listener): this;
  once(eventName: string, listener: Listener): this;
  removeListener(eventName: string, listener: Listener): this;
  removeAllListeners(eventName?: string): this;

  queryFilter<EventArgsArray extends Array<any>, EventArgsObject>(
    event: TypedEventFilter<EventArgsArray, EventArgsObject>,
    fromBlockOrBlockhash?: string | number | undefined,
    toBlock?: string | number | undefined
  ): Promise<Array<TypedEvent<EventArgsArray & EventArgsObject>>>;

  interface: L2GraphTokenLockWalletInterface;

  functions: {
    acceptLock(
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

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

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

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

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

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

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

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

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

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

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

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

    initialize(
      _manager: string,
      _owner: string,
      _beneficiary: string,
      _token: string,
      _managedAmount: BigNumberish,
      _startTime: BigNumberish,
      _endTime: BigNumberish,
      _periods: BigNumberish,
      _releaseStartTime: BigNumberish,
      _vestingCliffTime: BigNumberish,
      _revocable: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    initializeFromL1(
      _manager: string,
      _token: string,
      _walletData: {
        l1Address: string;
        owner: string;
        beneficiary: string;
        managedAmount: BigNumberish;
        startTime: BigNumberish;
        endTime: BigNumberish;
      },
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    isAccepted(overrides?: CallOverrides): Promise<[boolean]>;

    isInitialized(overrides?: CallOverrides): Promise<[boolean]>;

    isRevoked(overrides?: CallOverrides): Promise<[boolean]>;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    withdrawSurplus(
      _amount: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;
  };

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

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

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

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

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

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

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

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

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

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

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

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

  initialize(
    _manager: string,
    _owner: string,
    _beneficiary: string,
    _token: string,
    _managedAmount: BigNumberish,
    _startTime: BigNumberish,
    _endTime: BigNumberish,
    _periods: BigNumberish,
    _releaseStartTime: BigNumberish,
    _vestingCliffTime: BigNumberish,
    _revocable: BigNumberish,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  initializeFromL1(
    _manager: string,
    _token: string,
    _walletData: {
      l1Address: string;
      owner: string;
      beneficiary: string;
      managedAmount: BigNumberish;
      startTime: BigNumberish;
      endTime: BigNumberish;
    },
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  isAccepted(overrides?: CallOverrides): Promise<boolean>;

  isInitialized(overrides?: CallOverrides): Promise<boolean>;

  isRevoked(overrides?: CallOverrides): Promise<boolean>;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  withdrawSurplus(
    _amount: BigNumberish,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  callStatic: {
    acceptLock(overrides?: CallOverrides): Promise<void>;

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

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

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

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

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

    changeBeneficiary(
      _newBeneficiary: string,
      overrides?: CallOverrides
    ): Promise<void>;

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

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

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

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

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

    initialize(
      _manager: string,
      _owner: string,
      _beneficiary: string,
      _token: string,
      _managedAmount: BigNumberish,
      _startTime: BigNumberish,
      _endTime: BigNumberish,
      _periods: BigNumberish,
      _releaseStartTime: BigNumberish,
      _vestingCliffTime: BigNumberish,
      _revocable: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    initializeFromL1(
      _manager: string,
      _token: string,
      _walletData: {
        l1Address: string;
        owner: string;
        beneficiary: string;
        managedAmount: BigNumberish;
        startTime: BigNumberish;
        endTime: BigNumberish;
      },
      overrides?: CallOverrides
    ): Promise<void>;

    isAccepted(overrides?: CallOverrides): Promise<boolean>;

    isInitialized(overrides?: CallOverrides): Promise<boolean>;

    isRevoked(overrides?: CallOverrides): Promise<boolean>;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    setManager(_newManager: string, overrides?: CallOverrides): Promise<void>;

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

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

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

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

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

    transferOwnership(
      newOwner: string,
      overrides?: CallOverrides
    ): Promise<void>;

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

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

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

    withdrawSurplus(
      _amount: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;
  };

  filters: {
    "BeneficiaryChanged(address)"(
      newBeneficiary?: null
    ): TypedEventFilter<[string], { newBeneficiary: string }>;

    BeneficiaryChanged(
      newBeneficiary?: null
    ): TypedEventFilter<[string], { newBeneficiary: string }>;

    "LockAccepted()"(): TypedEventFilter<[], {}>;

    LockAccepted(): TypedEventFilter<[], {}>;

    "LockCanceled()"(): TypedEventFilter<[], {}>;

    LockCanceled(): TypedEventFilter<[], {}>;

    "ManagerUpdated(address,address)"(
      _oldManager?: string | null,
      _newManager?: string | null
    ): TypedEventFilter<
      [string, string],
      { _oldManager: string; _newManager: string }
    >;

    ManagerUpdated(
      _oldManager?: string | null,
      _newManager?: string | null
    ): TypedEventFilter<
      [string, string],
      { _oldManager: string; _newManager: string }
    >;

    "OwnershipTransferred(address,address)"(
      previousOwner?: string | null,
      newOwner?: string | null
    ): TypedEventFilter<
      [string, string],
      { previousOwner: string; newOwner: string }
    >;

    OwnershipTransferred(
      previousOwner?: string | null,
      newOwner?: string | null
    ): TypedEventFilter<
      [string, string],
      { previousOwner: string; newOwner: string }
    >;

    "TokenDestinationsApproved()"(): TypedEventFilter<[], {}>;

    TokenDestinationsApproved(): TypedEventFilter<[], {}>;

    "TokenDestinationsRevoked()"(): TypedEventFilter<[], {}>;

    TokenDestinationsRevoked(): TypedEventFilter<[], {}>;

    "TokensReleased(address,uint256)"(
      beneficiary?: string | null,
      amount?: null
    ): TypedEventFilter<
      [string, BigNumber],
      { beneficiary: string; amount: BigNumber }
    >;

    TokensReleased(
      beneficiary?: string | null,
      amount?: null
    ): TypedEventFilter<
      [string, BigNumber],
      { beneficiary: string; amount: BigNumber }
    >;

    "TokensRevoked(address,uint256)"(
      beneficiary?: string | null,
      amount?: null
    ): TypedEventFilter<
      [string, BigNumber],
      { beneficiary: string; amount: BigNumber }
    >;

    TokensRevoked(
      beneficiary?: string | null,
      amount?: null
    ): TypedEventFilter<
      [string, BigNumber],
      { beneficiary: string; amount: BigNumber }
    >;

    "TokensWithdrawn(address,uint256)"(
      beneficiary?: string | null,
      amount?: null
    ): TypedEventFilter<
      [string, BigNumber],
      { beneficiary: string; amount: BigNumber }
    >;

    TokensWithdrawn(
      beneficiary?: string | null,
      amount?: null
    ): TypedEventFilter<
      [string, BigNumber],
      { beneficiary: string; amount: BigNumber }
    >;
  };

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

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

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

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

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

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

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

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

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

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

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

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

    initialize(
      _manager: string,
      _owner: string,
      _beneficiary: string,
      _token: string,
      _managedAmount: BigNumberish,
      _startTime: BigNumberish,
      _endTime: BigNumberish,
      _periods: BigNumberish,
      _releaseStartTime: BigNumberish,
      _vestingCliffTime: BigNumberish,
      _revocable: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    initializeFromL1(
      _manager: string,
      _token: string,
      _walletData: {
        l1Address: string;
        owner: string;
        beneficiary: string;
        managedAmount: BigNumberish;
        startTime: BigNumberish;
        endTime: BigNumberish;
      },
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    withdrawSurplus(
      _amount: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;
  };

  populateTransaction: {
    acceptLock(
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

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

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

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

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

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

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

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

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

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

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

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

    initialize(
      _manager: string,
      _owner: string,
      _beneficiary: string,
      _token: string,
      _managedAmount: BigNumberish,
      _startTime: BigNumberish,
      _endTime: BigNumberish,
      _periods: BigNumberish,
      _releaseStartTime: BigNumberish,
      _vestingCliffTime: BigNumberish,
      _revocable: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    initializeFromL1(
      _manager: string,
      _token: string,
      _walletData: {
        l1Address: string;
        owner: string;
        beneficiary: string;
        managedAmount: BigNumberish;
        startTime: BigNumberish;
        endTime: BigNumberish;
      },
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    withdrawSurplus(
      _amount: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;
  };
}
