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

export interface PendlePausingManagerInterface extends utils.Interface {
  functions: {
    "applyForgeHandlerChange()": FunctionFragment;
    "applyLiqMiningHandlerChange()": FunctionFragment;
    "applyMarketHandlerChange()": FunctionFragment;
    "checkLiqMiningStatus(address)": FunctionFragment;
    "checkMarketStatus(bytes32,address)": FunctionFragment;
    "checkYieldContractStatus(bytes32,address,uint256)": FunctionFragment;
    "forgeAssetExpiryCachedStatus(bytes32,address,uint256)": FunctionFragment;
    "forgeAssetExpiryLocked(bytes32,address,uint256)": FunctionFragment;
    "forgeAssetExpiryPaused(bytes32,address,uint256)": FunctionFragment;
    "forgeAssetLocked(bytes32,address)": FunctionFragment;
    "forgeAssetPaused(bytes32,address)": FunctionFragment;
    "forgeEmergencyHandler()": FunctionFragment;
    "forgeLocked(bytes32)": FunctionFragment;
    "forgePaused(bytes32)": FunctionFragment;
    "governanceManager()": FunctionFragment;
    "isPausingAdmin(address)": FunctionFragment;
    "liqMiningCachedStatus(address)": FunctionFragment;
    "liqMiningEmergencyHandler()": FunctionFragment;
    "liqMiningLocked(address)": FunctionFragment;
    "liqMiningPaused(address)": FunctionFragment;
    "lockForgeHandlerPermanently()": FunctionFragment;
    "lockLiqMiningHandlerPermanently()": FunctionFragment;
    "lockMarketHandlerPermanently()": FunctionFragment;
    "lockPausingManagerPermanently()": FunctionFragment;
    "marketCachedStatus(bytes32,address)": FunctionFragment;
    "marketEmergencyHandler()": FunctionFragment;
    "marketFactoryLocked(bytes32)": FunctionFragment;
    "marketFactoryPaused(bytes32)": FunctionFragment;
    "marketLocked(bytes32,address)": FunctionFragment;
    "marketPaused(bytes32,address)": FunctionFragment;
    "permForgeHandlerLocked()": FunctionFragment;
    "permLiqMiningHandlerLocked()": FunctionFragment;
    "permLocked()": FunctionFragment;
    "permMarketHandlerLocked()": FunctionFragment;
    "requestForgeHandlerChange(address)": FunctionFragment;
    "requestLiqMiningHandlerChange(address)": FunctionFragment;
    "requestMarketHandlerChange(address)": FunctionFragment;
    "setForgeAssetExpiryLocked(bytes32,address,uint256)": FunctionFragment;
    "setForgeAssetExpiryPaused(bytes32,address,uint256,bool)": FunctionFragment;
    "setForgeAssetLocked(bytes32,address)": FunctionFragment;
    "setForgeAssetPaused(bytes32,address,bool)": FunctionFragment;
    "setForgeLocked(bytes32)": FunctionFragment;
    "setForgePaused(bytes32,bool)": FunctionFragment;
    "setLiqMiningLocked(address)": FunctionFragment;
    "setLiqMiningPaused(address,bool)": FunctionFragment;
    "setMarketFactoryLocked(bytes32)": FunctionFragment;
    "setMarketFactoryPaused(bytes32,bool)": FunctionFragment;
    "setMarketLocked(bytes32,address)": FunctionFragment;
    "setMarketPaused(bytes32,address,bool)": FunctionFragment;
    "setPausingAdmin(address,bool)": FunctionFragment;
  };

  encodeFunctionData(
    functionFragment: "applyForgeHandlerChange",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "applyLiqMiningHandlerChange",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "applyMarketHandlerChange",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "checkLiqMiningStatus",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "checkMarketStatus",
    values: [BytesLike, string]
  ): string;
  encodeFunctionData(
    functionFragment: "checkYieldContractStatus",
    values: [BytesLike, string, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "forgeAssetExpiryCachedStatus",
    values: [BytesLike, string, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "forgeAssetExpiryLocked",
    values: [BytesLike, string, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "forgeAssetExpiryPaused",
    values: [BytesLike, string, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "forgeAssetLocked",
    values: [BytesLike, string]
  ): string;
  encodeFunctionData(
    functionFragment: "forgeAssetPaused",
    values: [BytesLike, string]
  ): string;
  encodeFunctionData(
    functionFragment: "forgeEmergencyHandler",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "forgeLocked",
    values: [BytesLike]
  ): string;
  encodeFunctionData(
    functionFragment: "forgePaused",
    values: [BytesLike]
  ): string;
  encodeFunctionData(
    functionFragment: "governanceManager",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "isPausingAdmin",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "liqMiningCachedStatus",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "liqMiningEmergencyHandler",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "liqMiningLocked",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "liqMiningPaused",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "lockForgeHandlerPermanently",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "lockLiqMiningHandlerPermanently",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "lockMarketHandlerPermanently",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "lockPausingManagerPermanently",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "marketCachedStatus",
    values: [BytesLike, string]
  ): string;
  encodeFunctionData(
    functionFragment: "marketEmergencyHandler",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "marketFactoryLocked",
    values: [BytesLike]
  ): string;
  encodeFunctionData(
    functionFragment: "marketFactoryPaused",
    values: [BytesLike]
  ): string;
  encodeFunctionData(
    functionFragment: "marketLocked",
    values: [BytesLike, string]
  ): string;
  encodeFunctionData(
    functionFragment: "marketPaused",
    values: [BytesLike, string]
  ): string;
  encodeFunctionData(
    functionFragment: "permForgeHandlerLocked",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "permLiqMiningHandlerLocked",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "permLocked",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "permMarketHandlerLocked",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "requestForgeHandlerChange",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "requestLiqMiningHandlerChange",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "requestMarketHandlerChange",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "setForgeAssetExpiryLocked",
    values: [BytesLike, string, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "setForgeAssetExpiryPaused",
    values: [BytesLike, string, BigNumberish, boolean]
  ): string;
  encodeFunctionData(
    functionFragment: "setForgeAssetLocked",
    values: [BytesLike, string]
  ): string;
  encodeFunctionData(
    functionFragment: "setForgeAssetPaused",
    values: [BytesLike, string, boolean]
  ): string;
  encodeFunctionData(
    functionFragment: "setForgeLocked",
    values: [BytesLike]
  ): string;
  encodeFunctionData(
    functionFragment: "setForgePaused",
    values: [BytesLike, boolean]
  ): string;
  encodeFunctionData(
    functionFragment: "setLiqMiningLocked",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "setLiqMiningPaused",
    values: [string, boolean]
  ): string;
  encodeFunctionData(
    functionFragment: "setMarketFactoryLocked",
    values: [BytesLike]
  ): string;
  encodeFunctionData(
    functionFragment: "setMarketFactoryPaused",
    values: [BytesLike, boolean]
  ): string;
  encodeFunctionData(
    functionFragment: "setMarketLocked",
    values: [BytesLike, string]
  ): string;
  encodeFunctionData(
    functionFragment: "setMarketPaused",
    values: [BytesLike, string, boolean]
  ): string;
  encodeFunctionData(
    functionFragment: "setPausingAdmin",
    values: [string, boolean]
  ): string;

  decodeFunctionResult(
    functionFragment: "applyForgeHandlerChange",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "applyLiqMiningHandlerChange",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "applyMarketHandlerChange",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "checkLiqMiningStatus",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "checkMarketStatus",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "checkYieldContractStatus",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "forgeAssetExpiryCachedStatus",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "forgeAssetExpiryLocked",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "forgeAssetExpiryPaused",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "forgeAssetLocked",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "forgeAssetPaused",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "forgeEmergencyHandler",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "forgeLocked",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "forgePaused",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "governanceManager",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "isPausingAdmin",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "liqMiningCachedStatus",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "liqMiningEmergencyHandler",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "liqMiningLocked",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "liqMiningPaused",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "lockForgeHandlerPermanently",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "lockLiqMiningHandlerPermanently",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "lockMarketHandlerPermanently",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "lockPausingManagerPermanently",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "marketCachedStatus",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "marketEmergencyHandler",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "marketFactoryLocked",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "marketFactoryPaused",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "marketLocked",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "marketPaused",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "permForgeHandlerLocked",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "permLiqMiningHandlerLocked",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "permLocked", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "permMarketHandlerLocked",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "requestForgeHandlerChange",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "requestLiqMiningHandlerChange",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "requestMarketHandlerChange",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setForgeAssetExpiryLocked",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setForgeAssetExpiryPaused",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setForgeAssetLocked",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setForgeAssetPaused",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setForgeLocked",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setForgePaused",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setLiqMiningLocked",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setLiqMiningPaused",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setMarketFactoryLocked",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setMarketFactoryPaused",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setMarketLocked",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setMarketPaused",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setPausingAdmin",
    data: BytesLike
  ): Result;

  events: {
    "AddPausingAdmin(address)": EventFragment;
    "ForgeEmergencyHandlerSet(address)": EventFragment;
    "ForgeHandlerLocked()": EventFragment;
    "LiqMiningEmergencyHandlerSet(address)": EventFragment;
    "LiqMiningHandlerLocked()": EventFragment;
    "MarketEmergencyHandlerSet(address)": EventFragment;
    "MarketHandlerLocked()": EventFragment;
    "PausingManagerLocked()": EventFragment;
    "PendingForgeEmergencyHandler(address)": EventFragment;
    "PendingLiqMiningEmergencyHandler(address)": EventFragment;
    "PendingMarketEmergencyHandler(address)": EventFragment;
    "RemovePausingAdmin(address)": EventFragment;
    "SetForgeAssetExpiryLocked(bytes32,address,uint256)": EventFragment;
    "SetForgeAssetExpiryPaused(bytes32,address,uint256,bool)": EventFragment;
    "SetForgeAssetLocked(bytes32,address)": EventFragment;
    "SetForgeAssetPaused(bytes32,address,bool)": EventFragment;
    "SetForgeLocked(bytes32)": EventFragment;
    "SetForgePaused(bytes32,bool)": EventFragment;
    "SetLiqMiningLocked(address)": EventFragment;
    "SetLiqMiningPaused(address,bool)": EventFragment;
    "SetMarketFactoryLocked(bytes32)": EventFragment;
    "SetMarketFactoryPaused(bytes32,bool)": EventFragment;
    "SetMarketLocked(bytes32,address)": EventFragment;
    "SetMarketPaused(bytes32,address,bool)": EventFragment;
  };

  getEvent(nameOrSignatureOrTopic: "AddPausingAdmin"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "ForgeEmergencyHandlerSet"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "ForgeHandlerLocked"): EventFragment;
  getEvent(
    nameOrSignatureOrTopic: "LiqMiningEmergencyHandlerSet"
  ): EventFragment;
  getEvent(nameOrSignatureOrTopic: "LiqMiningHandlerLocked"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "MarketEmergencyHandlerSet"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "MarketHandlerLocked"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "PausingManagerLocked"): EventFragment;
  getEvent(
    nameOrSignatureOrTopic: "PendingForgeEmergencyHandler"
  ): EventFragment;
  getEvent(
    nameOrSignatureOrTopic: "PendingLiqMiningEmergencyHandler"
  ): EventFragment;
  getEvent(
    nameOrSignatureOrTopic: "PendingMarketEmergencyHandler"
  ): EventFragment;
  getEvent(nameOrSignatureOrTopic: "RemovePausingAdmin"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "SetForgeAssetExpiryLocked"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "SetForgeAssetExpiryPaused"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "SetForgeAssetLocked"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "SetForgeAssetPaused"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "SetForgeLocked"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "SetForgePaused"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "SetLiqMiningLocked"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "SetLiqMiningPaused"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "SetMarketFactoryLocked"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "SetMarketFactoryPaused"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "SetMarketLocked"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "SetMarketPaused"): EventFragment;
}

export type AddPausingAdminEvent = TypedEvent<[string], { admin: string }>;

export type AddPausingAdminEventFilter = TypedEventFilter<AddPausingAdminEvent>;

export type ForgeEmergencyHandlerSetEvent = TypedEvent<
  [string],
  { forgeEmergencyHandler: string }
>;

export type ForgeEmergencyHandlerSetEventFilter =
  TypedEventFilter<ForgeEmergencyHandlerSetEvent>;

export type ForgeHandlerLockedEvent = TypedEvent<[], {}>;

export type ForgeHandlerLockedEventFilter =
  TypedEventFilter<ForgeHandlerLockedEvent>;

export type LiqMiningEmergencyHandlerSetEvent = TypedEvent<
  [string],
  { liqMiningEmergencyHandler: string }
>;

export type LiqMiningEmergencyHandlerSetEventFilter =
  TypedEventFilter<LiqMiningEmergencyHandlerSetEvent>;

export type LiqMiningHandlerLockedEvent = TypedEvent<[], {}>;

export type LiqMiningHandlerLockedEventFilter =
  TypedEventFilter<LiqMiningHandlerLockedEvent>;

export type MarketEmergencyHandlerSetEvent = TypedEvent<
  [string],
  { marketEmergencyHandler: string }
>;

export type MarketEmergencyHandlerSetEventFilter =
  TypedEventFilter<MarketEmergencyHandlerSetEvent>;

export type MarketHandlerLockedEvent = TypedEvent<[], {}>;

export type MarketHandlerLockedEventFilter =
  TypedEventFilter<MarketHandlerLockedEvent>;

export type PausingManagerLockedEvent = TypedEvent<[], {}>;

export type PausingManagerLockedEventFilter =
  TypedEventFilter<PausingManagerLockedEvent>;

export type PendingForgeEmergencyHandlerEvent = TypedEvent<
  [string],
  { _pendingForgeHandler: string }
>;

export type PendingForgeEmergencyHandlerEventFilter =
  TypedEventFilter<PendingForgeEmergencyHandlerEvent>;

export type PendingLiqMiningEmergencyHandlerEvent = TypedEvent<
  [string],
  { _pendingLiqMiningHandler: string }
>;

export type PendingLiqMiningEmergencyHandlerEventFilter =
  TypedEventFilter<PendingLiqMiningEmergencyHandlerEvent>;

export type PendingMarketEmergencyHandlerEvent = TypedEvent<
  [string],
  { _pendingMarketHandler: string }
>;

export type PendingMarketEmergencyHandlerEventFilter =
  TypedEventFilter<PendingMarketEmergencyHandlerEvent>;

export type RemovePausingAdminEvent = TypedEvent<[string], { admin: string }>;

export type RemovePausingAdminEventFilter =
  TypedEventFilter<RemovePausingAdminEvent>;

export type SetForgeAssetExpiryLockedEvent = TypedEvent<
  [string, string, BigNumber],
  { forgeId: string; underlyingAsset: string; expiry: BigNumber }
>;

export type SetForgeAssetExpiryLockedEventFilter =
  TypedEventFilter<SetForgeAssetExpiryLockedEvent>;

export type SetForgeAssetExpiryPausedEvent = TypedEvent<
  [string, string, BigNumber, boolean],
  {
    forgeId: string;
    underlyingAsset: string;
    expiry: BigNumber;
    settingToPaused: boolean;
  }
>;

export type SetForgeAssetExpiryPausedEventFilter =
  TypedEventFilter<SetForgeAssetExpiryPausedEvent>;

export type SetForgeAssetLockedEvent = TypedEvent<
  [string, string],
  { forgeId: string; underlyingAsset: string }
>;

export type SetForgeAssetLockedEventFilter =
  TypedEventFilter<SetForgeAssetLockedEvent>;

export type SetForgeAssetPausedEvent = TypedEvent<
  [string, string, boolean],
  { forgeId: string; underlyingAsset: string; settingToPaused: boolean }
>;

export type SetForgeAssetPausedEventFilter =
  TypedEventFilter<SetForgeAssetPausedEvent>;

export type SetForgeLockedEvent = TypedEvent<[string], { forgeId: string }>;

export type SetForgeLockedEventFilter = TypedEventFilter<SetForgeLockedEvent>;

export type SetForgePausedEvent = TypedEvent<
  [string, boolean],
  { forgeId: string; settingToPaused: boolean }
>;

export type SetForgePausedEventFilter = TypedEventFilter<SetForgePausedEvent>;

export type SetLiqMiningLockedEvent = TypedEvent<
  [string],
  { liqMiningContract: string }
>;

export type SetLiqMiningLockedEventFilter =
  TypedEventFilter<SetLiqMiningLockedEvent>;

export type SetLiqMiningPausedEvent = TypedEvent<
  [string, boolean],
  { liqMiningContract: string; settingToPaused: boolean }
>;

export type SetLiqMiningPausedEventFilter =
  TypedEventFilter<SetLiqMiningPausedEvent>;

export type SetMarketFactoryLockedEvent = TypedEvent<
  [string],
  { marketFactoryId: string }
>;

export type SetMarketFactoryLockedEventFilter =
  TypedEventFilter<SetMarketFactoryLockedEvent>;

export type SetMarketFactoryPausedEvent = TypedEvent<
  [string, boolean],
  { marketFactoryId: string; settingToPaused: boolean }
>;

export type SetMarketFactoryPausedEventFilter =
  TypedEventFilter<SetMarketFactoryPausedEvent>;

export type SetMarketLockedEvent = TypedEvent<
  [string, string],
  { marketFactoryId: string; market: string }
>;

export type SetMarketLockedEventFilter = TypedEventFilter<SetMarketLockedEvent>;

export type SetMarketPausedEvent = TypedEvent<
  [string, string, boolean],
  { marketFactoryId: string; market: string; settingToPaused: boolean }
>;

export type SetMarketPausedEventFilter = TypedEventFilter<SetMarketPausedEvent>;

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

  interface: PendlePausingManagerInterface;

  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: {
    applyForgeHandlerChange(
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

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

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

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

    checkMarketStatus(
      marketFactoryId: BytesLike,
      market: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    checkYieldContractStatus(
      forgeId: BytesLike,
      underlyingAsset: string,
      expiry: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    forgeAssetExpiryCachedStatus(
      arg0: BytesLike,
      arg1: string,
      arg2: BigNumberish,
      overrides?: CallOverrides
    ): Promise<
      [BigNumber, boolean, boolean] & {
        timestamp: BigNumber;
        paused: boolean;
        locked: boolean;
      }
    >;

    forgeAssetExpiryLocked(
      arg0: BytesLike,
      arg1: string,
      arg2: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[boolean]>;

    forgeAssetExpiryPaused(
      arg0: BytesLike,
      arg1: string,
      arg2: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[boolean]>;

    forgeAssetLocked(
      arg0: BytesLike,
      arg1: string,
      overrides?: CallOverrides
    ): Promise<[boolean]>;

    forgeAssetPaused(
      arg0: BytesLike,
      arg1: string,
      overrides?: CallOverrides
    ): Promise<[boolean]>;

    forgeEmergencyHandler(
      overrides?: CallOverrides
    ): Promise<
      [string, string, BigNumber] & {
        handler: string;
        pendingHandler: string;
        timelockDeadline: BigNumber;
      }
    >;

    forgeLocked(arg0: BytesLike, overrides?: CallOverrides): Promise<[boolean]>;

    forgePaused(arg0: BytesLike, overrides?: CallOverrides): Promise<[boolean]>;

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

    isPausingAdmin(arg0: string, overrides?: CallOverrides): Promise<[boolean]>;

    liqMiningCachedStatus(
      arg0: string,
      overrides?: CallOverrides
    ): Promise<
      [BigNumber, boolean, boolean] & {
        timestamp: BigNumber;
        paused: boolean;
        locked: boolean;
      }
    >;

    liqMiningEmergencyHandler(
      overrides?: CallOverrides
    ): Promise<
      [string, string, BigNumber] & {
        handler: string;
        pendingHandler: string;
        timelockDeadline: BigNumber;
      }
    >;

    liqMiningLocked(
      arg0: string,
      overrides?: CallOverrides
    ): Promise<[boolean]>;

    liqMiningPaused(
      arg0: string,
      overrides?: CallOverrides
    ): Promise<[boolean]>;

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

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

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

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

    marketCachedStatus(
      arg0: BytesLike,
      arg1: string,
      overrides?: CallOverrides
    ): Promise<
      [BigNumber, boolean, boolean] & {
        timestamp: BigNumber;
        paused: boolean;
        locked: boolean;
      }
    >;

    marketEmergencyHandler(
      overrides?: CallOverrides
    ): Promise<
      [string, string, BigNumber] & {
        handler: string;
        pendingHandler: string;
        timelockDeadline: BigNumber;
      }
    >;

    marketFactoryLocked(
      arg0: BytesLike,
      overrides?: CallOverrides
    ): Promise<[boolean]>;

    marketFactoryPaused(
      arg0: BytesLike,
      overrides?: CallOverrides
    ): Promise<[boolean]>;

    marketLocked(
      arg0: BytesLike,
      arg1: string,
      overrides?: CallOverrides
    ): Promise<[boolean]>;

    marketPaused(
      arg0: BytesLike,
      arg1: string,
      overrides?: CallOverrides
    ): Promise<[boolean]>;

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

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

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

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

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

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

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

    setForgeAssetExpiryLocked(
      forgeId: BytesLike,
      underlyingAsset: string,
      expiry: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    setForgeAssetExpiryPaused(
      forgeId: BytesLike,
      underlyingAsset: string,
      expiry: BigNumberish,
      settingToPaused: boolean,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    setForgeAssetLocked(
      forgeId: BytesLike,
      underlyingAsset: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    setForgeAssetPaused(
      forgeId: BytesLike,
      underlyingAsset: string,
      settingToPaused: boolean,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    setForgeLocked(
      forgeId: BytesLike,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    setForgePaused(
      forgeId: BytesLike,
      settingToPaused: boolean,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

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

    setLiqMiningPaused(
      liqMiningContract: string,
      settingToPaused: boolean,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    setMarketFactoryLocked(
      marketFactoryId: BytesLike,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    setMarketFactoryPaused(
      marketFactoryId: BytesLike,
      settingToPaused: boolean,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    setMarketLocked(
      marketFactoryId: BytesLike,
      market: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    setMarketPaused(
      marketFactoryId: BytesLike,
      market: string,
      settingToPaused: boolean,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    setPausingAdmin(
      admin: string,
      isAdmin: boolean,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;
  };

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

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

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

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

  checkMarketStatus(
    marketFactoryId: BytesLike,
    market: string,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  checkYieldContractStatus(
    forgeId: BytesLike,
    underlyingAsset: string,
    expiry: BigNumberish,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  forgeAssetExpiryCachedStatus(
    arg0: BytesLike,
    arg1: string,
    arg2: BigNumberish,
    overrides?: CallOverrides
  ): Promise<
    [BigNumber, boolean, boolean] & {
      timestamp: BigNumber;
      paused: boolean;
      locked: boolean;
    }
  >;

  forgeAssetExpiryLocked(
    arg0: BytesLike,
    arg1: string,
    arg2: BigNumberish,
    overrides?: CallOverrides
  ): Promise<boolean>;

  forgeAssetExpiryPaused(
    arg0: BytesLike,
    arg1: string,
    arg2: BigNumberish,
    overrides?: CallOverrides
  ): Promise<boolean>;

  forgeAssetLocked(
    arg0: BytesLike,
    arg1: string,
    overrides?: CallOverrides
  ): Promise<boolean>;

  forgeAssetPaused(
    arg0: BytesLike,
    arg1: string,
    overrides?: CallOverrides
  ): Promise<boolean>;

  forgeEmergencyHandler(
    overrides?: CallOverrides
  ): Promise<
    [string, string, BigNumber] & {
      handler: string;
      pendingHandler: string;
      timelockDeadline: BigNumber;
    }
  >;

  forgeLocked(arg0: BytesLike, overrides?: CallOverrides): Promise<boolean>;

  forgePaused(arg0: BytesLike, overrides?: CallOverrides): Promise<boolean>;

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

  isPausingAdmin(arg0: string, overrides?: CallOverrides): Promise<boolean>;

  liqMiningCachedStatus(
    arg0: string,
    overrides?: CallOverrides
  ): Promise<
    [BigNumber, boolean, boolean] & {
      timestamp: BigNumber;
      paused: boolean;
      locked: boolean;
    }
  >;

  liqMiningEmergencyHandler(
    overrides?: CallOverrides
  ): Promise<
    [string, string, BigNumber] & {
      handler: string;
      pendingHandler: string;
      timelockDeadline: BigNumber;
    }
  >;

  liqMiningLocked(arg0: string, overrides?: CallOverrides): Promise<boolean>;

  liqMiningPaused(arg0: string, overrides?: CallOverrides): Promise<boolean>;

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

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

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

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

  marketCachedStatus(
    arg0: BytesLike,
    arg1: string,
    overrides?: CallOverrides
  ): Promise<
    [BigNumber, boolean, boolean] & {
      timestamp: BigNumber;
      paused: boolean;
      locked: boolean;
    }
  >;

  marketEmergencyHandler(
    overrides?: CallOverrides
  ): Promise<
    [string, string, BigNumber] & {
      handler: string;
      pendingHandler: string;
      timelockDeadline: BigNumber;
    }
  >;

  marketFactoryLocked(
    arg0: BytesLike,
    overrides?: CallOverrides
  ): Promise<boolean>;

  marketFactoryPaused(
    arg0: BytesLike,
    overrides?: CallOverrides
  ): Promise<boolean>;

  marketLocked(
    arg0: BytesLike,
    arg1: string,
    overrides?: CallOverrides
  ): Promise<boolean>;

  marketPaused(
    arg0: BytesLike,
    arg1: string,
    overrides?: CallOverrides
  ): Promise<boolean>;

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

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

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

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

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

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

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

  setForgeAssetExpiryLocked(
    forgeId: BytesLike,
    underlyingAsset: string,
    expiry: BigNumberish,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  setForgeAssetExpiryPaused(
    forgeId: BytesLike,
    underlyingAsset: string,
    expiry: BigNumberish,
    settingToPaused: boolean,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  setForgeAssetLocked(
    forgeId: BytesLike,
    underlyingAsset: string,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  setForgeAssetPaused(
    forgeId: BytesLike,
    underlyingAsset: string,
    settingToPaused: boolean,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  setForgeLocked(
    forgeId: BytesLike,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  setForgePaused(
    forgeId: BytesLike,
    settingToPaused: boolean,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

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

  setLiqMiningPaused(
    liqMiningContract: string,
    settingToPaused: boolean,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  setMarketFactoryLocked(
    marketFactoryId: BytesLike,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  setMarketFactoryPaused(
    marketFactoryId: BytesLike,
    settingToPaused: boolean,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  setMarketLocked(
    marketFactoryId: BytesLike,
    market: string,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  setMarketPaused(
    marketFactoryId: BytesLike,
    market: string,
    settingToPaused: boolean,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  setPausingAdmin(
    admin: string,
    isAdmin: boolean,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

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

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

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

    checkLiqMiningStatus(
      liqMiningContract: string,
      overrides?: CallOverrides
    ): Promise<[boolean, boolean] & { _paused: boolean; _locked: boolean }>;

    checkMarketStatus(
      marketFactoryId: BytesLike,
      market: string,
      overrides?: CallOverrides
    ): Promise<[boolean, boolean] & { _paused: boolean; _locked: boolean }>;

    checkYieldContractStatus(
      forgeId: BytesLike,
      underlyingAsset: string,
      expiry: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[boolean, boolean] & { _paused: boolean; _locked: boolean }>;

    forgeAssetExpiryCachedStatus(
      arg0: BytesLike,
      arg1: string,
      arg2: BigNumberish,
      overrides?: CallOverrides
    ): Promise<
      [BigNumber, boolean, boolean] & {
        timestamp: BigNumber;
        paused: boolean;
        locked: boolean;
      }
    >;

    forgeAssetExpiryLocked(
      arg0: BytesLike,
      arg1: string,
      arg2: BigNumberish,
      overrides?: CallOverrides
    ): Promise<boolean>;

    forgeAssetExpiryPaused(
      arg0: BytesLike,
      arg1: string,
      arg2: BigNumberish,
      overrides?: CallOverrides
    ): Promise<boolean>;

    forgeAssetLocked(
      arg0: BytesLike,
      arg1: string,
      overrides?: CallOverrides
    ): Promise<boolean>;

    forgeAssetPaused(
      arg0: BytesLike,
      arg1: string,
      overrides?: CallOverrides
    ): Promise<boolean>;

    forgeEmergencyHandler(
      overrides?: CallOverrides
    ): Promise<
      [string, string, BigNumber] & {
        handler: string;
        pendingHandler: string;
        timelockDeadline: BigNumber;
      }
    >;

    forgeLocked(arg0: BytesLike, overrides?: CallOverrides): Promise<boolean>;

    forgePaused(arg0: BytesLike, overrides?: CallOverrides): Promise<boolean>;

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

    isPausingAdmin(arg0: string, overrides?: CallOverrides): Promise<boolean>;

    liqMiningCachedStatus(
      arg0: string,
      overrides?: CallOverrides
    ): Promise<
      [BigNumber, boolean, boolean] & {
        timestamp: BigNumber;
        paused: boolean;
        locked: boolean;
      }
    >;

    liqMiningEmergencyHandler(
      overrides?: CallOverrides
    ): Promise<
      [string, string, BigNumber] & {
        handler: string;
        pendingHandler: string;
        timelockDeadline: BigNumber;
      }
    >;

    liqMiningLocked(arg0: string, overrides?: CallOverrides): Promise<boolean>;

    liqMiningPaused(arg0: string, overrides?: CallOverrides): Promise<boolean>;

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

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

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

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

    marketCachedStatus(
      arg0: BytesLike,
      arg1: string,
      overrides?: CallOverrides
    ): Promise<
      [BigNumber, boolean, boolean] & {
        timestamp: BigNumber;
        paused: boolean;
        locked: boolean;
      }
    >;

    marketEmergencyHandler(
      overrides?: CallOverrides
    ): Promise<
      [string, string, BigNumber] & {
        handler: string;
        pendingHandler: string;
        timelockDeadline: BigNumber;
      }
    >;

    marketFactoryLocked(
      arg0: BytesLike,
      overrides?: CallOverrides
    ): Promise<boolean>;

    marketFactoryPaused(
      arg0: BytesLike,
      overrides?: CallOverrides
    ): Promise<boolean>;

    marketLocked(
      arg0: BytesLike,
      arg1: string,
      overrides?: CallOverrides
    ): Promise<boolean>;

    marketPaused(
      arg0: BytesLike,
      arg1: string,
      overrides?: CallOverrides
    ): Promise<boolean>;

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

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

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

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

    requestForgeHandlerChange(
      _pendingForgeHandler: string,
      overrides?: CallOverrides
    ): Promise<void>;

    requestLiqMiningHandlerChange(
      _pendingLiqMiningHandler: string,
      overrides?: CallOverrides
    ): Promise<void>;

    requestMarketHandlerChange(
      _pendingMarketHandler: string,
      overrides?: CallOverrides
    ): Promise<void>;

    setForgeAssetExpiryLocked(
      forgeId: BytesLike,
      underlyingAsset: string,
      expiry: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    setForgeAssetExpiryPaused(
      forgeId: BytesLike,
      underlyingAsset: string,
      expiry: BigNumberish,
      settingToPaused: boolean,
      overrides?: CallOverrides
    ): Promise<void>;

    setForgeAssetLocked(
      forgeId: BytesLike,
      underlyingAsset: string,
      overrides?: CallOverrides
    ): Promise<void>;

    setForgeAssetPaused(
      forgeId: BytesLike,
      underlyingAsset: string,
      settingToPaused: boolean,
      overrides?: CallOverrides
    ): Promise<void>;

    setForgeLocked(
      forgeId: BytesLike,
      overrides?: CallOverrides
    ): Promise<void>;

    setForgePaused(
      forgeId: BytesLike,
      settingToPaused: boolean,
      overrides?: CallOverrides
    ): Promise<void>;

    setLiqMiningLocked(
      liqMiningContract: string,
      overrides?: CallOverrides
    ): Promise<void>;

    setLiqMiningPaused(
      liqMiningContract: string,
      settingToPaused: boolean,
      overrides?: CallOverrides
    ): Promise<void>;

    setMarketFactoryLocked(
      marketFactoryId: BytesLike,
      overrides?: CallOverrides
    ): Promise<void>;

    setMarketFactoryPaused(
      marketFactoryId: BytesLike,
      settingToPaused: boolean,
      overrides?: CallOverrides
    ): Promise<void>;

    setMarketLocked(
      marketFactoryId: BytesLike,
      market: string,
      overrides?: CallOverrides
    ): Promise<void>;

    setMarketPaused(
      marketFactoryId: BytesLike,
      market: string,
      settingToPaused: boolean,
      overrides?: CallOverrides
    ): Promise<void>;

    setPausingAdmin(
      admin: string,
      isAdmin: boolean,
      overrides?: CallOverrides
    ): Promise<void>;
  };

  filters: {
    "AddPausingAdmin(address)"(admin?: null): AddPausingAdminEventFilter;
    AddPausingAdmin(admin?: null): AddPausingAdminEventFilter;

    "ForgeEmergencyHandlerSet(address)"(
      forgeEmergencyHandler?: null
    ): ForgeEmergencyHandlerSetEventFilter;
    ForgeEmergencyHandlerSet(
      forgeEmergencyHandler?: null
    ): ForgeEmergencyHandlerSetEventFilter;

    "ForgeHandlerLocked()"(): ForgeHandlerLockedEventFilter;
    ForgeHandlerLocked(): ForgeHandlerLockedEventFilter;

    "LiqMiningEmergencyHandlerSet(address)"(
      liqMiningEmergencyHandler?: null
    ): LiqMiningEmergencyHandlerSetEventFilter;
    LiqMiningEmergencyHandlerSet(
      liqMiningEmergencyHandler?: null
    ): LiqMiningEmergencyHandlerSetEventFilter;

    "LiqMiningHandlerLocked()"(): LiqMiningHandlerLockedEventFilter;
    LiqMiningHandlerLocked(): LiqMiningHandlerLockedEventFilter;

    "MarketEmergencyHandlerSet(address)"(
      marketEmergencyHandler?: null
    ): MarketEmergencyHandlerSetEventFilter;
    MarketEmergencyHandlerSet(
      marketEmergencyHandler?: null
    ): MarketEmergencyHandlerSetEventFilter;

    "MarketHandlerLocked()"(): MarketHandlerLockedEventFilter;
    MarketHandlerLocked(): MarketHandlerLockedEventFilter;

    "PausingManagerLocked()"(): PausingManagerLockedEventFilter;
    PausingManagerLocked(): PausingManagerLockedEventFilter;

    "PendingForgeEmergencyHandler(address)"(
      _pendingForgeHandler?: null
    ): PendingForgeEmergencyHandlerEventFilter;
    PendingForgeEmergencyHandler(
      _pendingForgeHandler?: null
    ): PendingForgeEmergencyHandlerEventFilter;

    "PendingLiqMiningEmergencyHandler(address)"(
      _pendingLiqMiningHandler?: null
    ): PendingLiqMiningEmergencyHandlerEventFilter;
    PendingLiqMiningEmergencyHandler(
      _pendingLiqMiningHandler?: null
    ): PendingLiqMiningEmergencyHandlerEventFilter;

    "PendingMarketEmergencyHandler(address)"(
      _pendingMarketHandler?: null
    ): PendingMarketEmergencyHandlerEventFilter;
    PendingMarketEmergencyHandler(
      _pendingMarketHandler?: null
    ): PendingMarketEmergencyHandlerEventFilter;

    "RemovePausingAdmin(address)"(admin?: null): RemovePausingAdminEventFilter;
    RemovePausingAdmin(admin?: null): RemovePausingAdminEventFilter;

    "SetForgeAssetExpiryLocked(bytes32,address,uint256)"(
      forgeId?: null,
      underlyingAsset?: null,
      expiry?: null
    ): SetForgeAssetExpiryLockedEventFilter;
    SetForgeAssetExpiryLocked(
      forgeId?: null,
      underlyingAsset?: null,
      expiry?: null
    ): SetForgeAssetExpiryLockedEventFilter;

    "SetForgeAssetExpiryPaused(bytes32,address,uint256,bool)"(
      forgeId?: null,
      underlyingAsset?: null,
      expiry?: null,
      settingToPaused?: null
    ): SetForgeAssetExpiryPausedEventFilter;
    SetForgeAssetExpiryPaused(
      forgeId?: null,
      underlyingAsset?: null,
      expiry?: null,
      settingToPaused?: null
    ): SetForgeAssetExpiryPausedEventFilter;

    "SetForgeAssetLocked(bytes32,address)"(
      forgeId?: null,
      underlyingAsset?: null
    ): SetForgeAssetLockedEventFilter;
    SetForgeAssetLocked(
      forgeId?: null,
      underlyingAsset?: null
    ): SetForgeAssetLockedEventFilter;

    "SetForgeAssetPaused(bytes32,address,bool)"(
      forgeId?: null,
      underlyingAsset?: null,
      settingToPaused?: null
    ): SetForgeAssetPausedEventFilter;
    SetForgeAssetPaused(
      forgeId?: null,
      underlyingAsset?: null,
      settingToPaused?: null
    ): SetForgeAssetPausedEventFilter;

    "SetForgeLocked(bytes32)"(forgeId?: null): SetForgeLockedEventFilter;
    SetForgeLocked(forgeId?: null): SetForgeLockedEventFilter;

    "SetForgePaused(bytes32,bool)"(
      forgeId?: null,
      settingToPaused?: null
    ): SetForgePausedEventFilter;
    SetForgePaused(
      forgeId?: null,
      settingToPaused?: null
    ): SetForgePausedEventFilter;

    "SetLiqMiningLocked(address)"(
      liqMiningContract?: null
    ): SetLiqMiningLockedEventFilter;
    SetLiqMiningLocked(liqMiningContract?: null): SetLiqMiningLockedEventFilter;

    "SetLiqMiningPaused(address,bool)"(
      liqMiningContract?: null,
      settingToPaused?: null
    ): SetLiqMiningPausedEventFilter;
    SetLiqMiningPaused(
      liqMiningContract?: null,
      settingToPaused?: null
    ): SetLiqMiningPausedEventFilter;

    "SetMarketFactoryLocked(bytes32)"(
      marketFactoryId?: null
    ): SetMarketFactoryLockedEventFilter;
    SetMarketFactoryLocked(
      marketFactoryId?: null
    ): SetMarketFactoryLockedEventFilter;

    "SetMarketFactoryPaused(bytes32,bool)"(
      marketFactoryId?: null,
      settingToPaused?: null
    ): SetMarketFactoryPausedEventFilter;
    SetMarketFactoryPaused(
      marketFactoryId?: null,
      settingToPaused?: null
    ): SetMarketFactoryPausedEventFilter;

    "SetMarketLocked(bytes32,address)"(
      marketFactoryId?: null,
      market?: null
    ): SetMarketLockedEventFilter;
    SetMarketLocked(
      marketFactoryId?: null,
      market?: null
    ): SetMarketLockedEventFilter;

    "SetMarketPaused(bytes32,address,bool)"(
      marketFactoryId?: null,
      market?: null,
      settingToPaused?: null
    ): SetMarketPausedEventFilter;
    SetMarketPaused(
      marketFactoryId?: null,
      market?: null,
      settingToPaused?: null
    ): SetMarketPausedEventFilter;
  };

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

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

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

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

    checkMarketStatus(
      marketFactoryId: BytesLike,
      market: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    checkYieldContractStatus(
      forgeId: BytesLike,
      underlyingAsset: string,
      expiry: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    forgeAssetExpiryCachedStatus(
      arg0: BytesLike,
      arg1: string,
      arg2: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    forgeAssetExpiryLocked(
      arg0: BytesLike,
      arg1: string,
      arg2: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    forgeAssetExpiryPaused(
      arg0: BytesLike,
      arg1: string,
      arg2: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    forgeAssetLocked(
      arg0: BytesLike,
      arg1: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    forgeAssetPaused(
      arg0: BytesLike,
      arg1: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

    forgeLocked(arg0: BytesLike, overrides?: CallOverrides): Promise<BigNumber>;

    forgePaused(arg0: BytesLike, overrides?: CallOverrides): Promise<BigNumber>;

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

    isPausingAdmin(arg0: string, overrides?: CallOverrides): Promise<BigNumber>;

    liqMiningCachedStatus(
      arg0: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

    liqMiningLocked(
      arg0: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    liqMiningPaused(
      arg0: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

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

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

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

    marketCachedStatus(
      arg0: BytesLike,
      arg1: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

    marketFactoryLocked(
      arg0: BytesLike,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    marketFactoryPaused(
      arg0: BytesLike,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    marketLocked(
      arg0: BytesLike,
      arg1: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    marketPaused(
      arg0: BytesLike,
      arg1: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

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

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

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

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

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

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

    setForgeAssetExpiryLocked(
      forgeId: BytesLike,
      underlyingAsset: string,
      expiry: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    setForgeAssetExpiryPaused(
      forgeId: BytesLike,
      underlyingAsset: string,
      expiry: BigNumberish,
      settingToPaused: boolean,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    setForgeAssetLocked(
      forgeId: BytesLike,
      underlyingAsset: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    setForgeAssetPaused(
      forgeId: BytesLike,
      underlyingAsset: string,
      settingToPaused: boolean,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    setForgeLocked(
      forgeId: BytesLike,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    setForgePaused(
      forgeId: BytesLike,
      settingToPaused: boolean,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

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

    setLiqMiningPaused(
      liqMiningContract: string,
      settingToPaused: boolean,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    setMarketFactoryLocked(
      marketFactoryId: BytesLike,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    setMarketFactoryPaused(
      marketFactoryId: BytesLike,
      settingToPaused: boolean,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    setMarketLocked(
      marketFactoryId: BytesLike,
      market: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    setMarketPaused(
      marketFactoryId: BytesLike,
      market: string,
      settingToPaused: boolean,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    setPausingAdmin(
      admin: string,
      isAdmin: boolean,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;
  };

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

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

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

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

    checkMarketStatus(
      marketFactoryId: BytesLike,
      market: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    checkYieldContractStatus(
      forgeId: BytesLike,
      underlyingAsset: string,
      expiry: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    forgeAssetExpiryCachedStatus(
      arg0: BytesLike,
      arg1: string,
      arg2: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    forgeAssetExpiryLocked(
      arg0: BytesLike,
      arg1: string,
      arg2: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    forgeAssetExpiryPaused(
      arg0: BytesLike,
      arg1: string,
      arg2: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    forgeAssetLocked(
      arg0: BytesLike,
      arg1: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    forgeAssetPaused(
      arg0: BytesLike,
      arg1: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

    forgeLocked(
      arg0: BytesLike,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    forgePaused(
      arg0: BytesLike,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

    isPausingAdmin(
      arg0: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    liqMiningCachedStatus(
      arg0: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

    liqMiningLocked(
      arg0: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    liqMiningPaused(
      arg0: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

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

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

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

    marketCachedStatus(
      arg0: BytesLike,
      arg1: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

    marketFactoryLocked(
      arg0: BytesLike,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    marketFactoryPaused(
      arg0: BytesLike,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    marketLocked(
      arg0: BytesLike,
      arg1: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    marketPaused(
      arg0: BytesLike,
      arg1: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

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

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

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

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

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

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

    setForgeAssetExpiryLocked(
      forgeId: BytesLike,
      underlyingAsset: string,
      expiry: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    setForgeAssetExpiryPaused(
      forgeId: BytesLike,
      underlyingAsset: string,
      expiry: BigNumberish,
      settingToPaused: boolean,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    setForgeAssetLocked(
      forgeId: BytesLike,
      underlyingAsset: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    setForgeAssetPaused(
      forgeId: BytesLike,
      underlyingAsset: string,
      settingToPaused: boolean,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    setForgeLocked(
      forgeId: BytesLike,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    setForgePaused(
      forgeId: BytesLike,
      settingToPaused: boolean,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

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

    setLiqMiningPaused(
      liqMiningContract: string,
      settingToPaused: boolean,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    setMarketFactoryLocked(
      marketFactoryId: BytesLike,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    setMarketFactoryPaused(
      marketFactoryId: BytesLike,
      settingToPaused: boolean,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    setMarketLocked(
      marketFactoryId: BytesLike,
      market: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    setMarketPaused(
      marketFactoryId: BytesLike,
      market: string,
      settingToPaused: boolean,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    setPausingAdmin(
      admin: string,
      isAdmin: boolean,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;
  };
}