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

export interface PlasmaTestInterface extends utils.Interface {
  functions: {
    "IS_TEST()": FunctionFragment;
    "beamMainnetFork()": FunctionFragment;
    "failed()": FunctionFragment;
    "setUp()": FunctionFragment;
    "test_nonTransferability()": FunctionFragment;
    "test_transferability()": FunctionFragment;
  };

  getFunction(
    nameOrSignatureOrTopic:
      | "IS_TEST"
      | "beamMainnetFork"
      | "failed"
      | "setUp"
      | "test_nonTransferability"
      | "test_transferability"
  ): FunctionFragment;

  encodeFunctionData(functionFragment: "IS_TEST", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "beamMainnetFork",
    values?: undefined
  ): string;
  encodeFunctionData(functionFragment: "failed", values?: undefined): string;
  encodeFunctionData(functionFragment: "setUp", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "test_nonTransferability",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "test_transferability",
    values?: undefined
  ): string;

  decodeFunctionResult(functionFragment: "IS_TEST", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "beamMainnetFork",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "failed", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "setUp", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "test_nonTransferability",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "test_transferability",
    data: BytesLike
  ): Result;

  events: {
    "Log(string)": EventFragment;
    "LogAddress(address)": EventFragment;
    "LogArray(address[])": EventFragment;
    "LogArray(bool[])": EventFragment;
    "LogArray(bytes32[])": EventFragment;
    "LogArray(int256[])": EventFragment;
    "LogArray(string[])": EventFragment;
    "LogArray(uint256[])": EventFragment;
    "LogBytes(bytes)": EventFragment;
    "LogBytes32(bytes32)": EventFragment;
    "LogInt256(int256)": EventFragment;
    "LogNamedAddress(string,address)": EventFragment;
    "LogNamedArray(string,address[])": EventFragment;
    "LogNamedArray(string,bool[])": EventFragment;
    "LogNamedArray(string,bytes32[])": EventFragment;
    "LogNamedArray(string,int256[])": EventFragment;
    "LogNamedArray(string,string[])": EventFragment;
    "LogNamedArray(string,uint256[])": EventFragment;
    "LogNamedBytes(string,bytes)": EventFragment;
    "LogNamedBytes32(string,bytes32)": EventFragment;
    "LogNamedInt256(string,int256)": EventFragment;
    "LogNamedString(string,string)": EventFragment;
    "LogNamedUint256(string,uint256)": EventFragment;
    "LogString(string)": EventFragment;
    "LogUint256(uint256)": EventFragment;
  };

  getEvent(nameOrSignatureOrTopic: "Log"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "LogAddress"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "LogArray(address[])"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "LogArray(bool[])"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "LogArray(bytes32[])"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "LogArray(int256[])"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "LogArray(string[])"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "LogArray(uint256[])"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "LogBytes"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "LogBytes32"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "LogInt256"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "LogNamedAddress"): EventFragment;
  getEvent(
    nameOrSignatureOrTopic: "LogNamedArray(string,address[])"
  ): EventFragment;
  getEvent(
    nameOrSignatureOrTopic: "LogNamedArray(string,bool[])"
  ): EventFragment;
  getEvent(
    nameOrSignatureOrTopic: "LogNamedArray(string,bytes32[])"
  ): EventFragment;
  getEvent(
    nameOrSignatureOrTopic: "LogNamedArray(string,int256[])"
  ): EventFragment;
  getEvent(
    nameOrSignatureOrTopic: "LogNamedArray(string,string[])"
  ): EventFragment;
  getEvent(
    nameOrSignatureOrTopic: "LogNamedArray(string,uint256[])"
  ): EventFragment;
  getEvent(nameOrSignatureOrTopic: "LogNamedBytes"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "LogNamedBytes32"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "LogNamedInt256"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "LogNamedString"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "LogNamedUint256"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "LogString"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "LogUint256"): EventFragment;
}

export interface LogEventObject {
  err: string;
}
export type LogEvent = TypedEvent<[string], LogEventObject>;

export type LogEventFilter = TypedEventFilter<LogEvent>;

export interface LogAddressEventObject {
  value: string;
}
export type LogAddressEvent = TypedEvent<[string], LogAddressEventObject>;

export type LogAddressEventFilter = TypedEventFilter<LogAddressEvent>;

export interface LogArray_address_array_EventObject {
  value: string[];
}
export type LogArray_address_array_Event = TypedEvent<
  [string[]],
  LogArray_address_array_EventObject
>;

export type LogArray_address_array_EventFilter =
  TypedEventFilter<LogArray_address_array_Event>;

export interface LogArray_bool_array_EventObject {
  value: boolean[];
}
export type LogArray_bool_array_Event = TypedEvent<
  [boolean[]],
  LogArray_bool_array_EventObject
>;

export type LogArray_bool_array_EventFilter =
  TypedEventFilter<LogArray_bool_array_Event>;

export interface LogArray_bytes32_array_EventObject {
  value: string[];
}
export type LogArray_bytes32_array_Event = TypedEvent<
  [string[]],
  LogArray_bytes32_array_EventObject
>;

export type LogArray_bytes32_array_EventFilter =
  TypedEventFilter<LogArray_bytes32_array_Event>;

export interface LogArray_int256_array_EventObject {
  value: BigNumber[];
}
export type LogArray_int256_array_Event = TypedEvent<
  [BigNumber[]],
  LogArray_int256_array_EventObject
>;

export type LogArray_int256_array_EventFilter =
  TypedEventFilter<LogArray_int256_array_Event>;

export interface LogArray_string_array_EventObject {
  value: string[];
}
export type LogArray_string_array_Event = TypedEvent<
  [string[]],
  LogArray_string_array_EventObject
>;

export type LogArray_string_array_EventFilter =
  TypedEventFilter<LogArray_string_array_Event>;

export interface LogArray_uint256_array_EventObject {
  value: BigNumber[];
}
export type LogArray_uint256_array_Event = TypedEvent<
  [BigNumber[]],
  LogArray_uint256_array_EventObject
>;

export type LogArray_uint256_array_EventFilter =
  TypedEventFilter<LogArray_uint256_array_Event>;

export interface LogBytesEventObject {
  value: string;
}
export type LogBytesEvent = TypedEvent<[string], LogBytesEventObject>;

export type LogBytesEventFilter = TypedEventFilter<LogBytesEvent>;

export interface LogBytes32EventObject {
  value: string;
}
export type LogBytes32Event = TypedEvent<[string], LogBytes32EventObject>;

export type LogBytes32EventFilter = TypedEventFilter<LogBytes32Event>;

export interface LogInt256EventObject {
  value: BigNumber;
}
export type LogInt256Event = TypedEvent<[BigNumber], LogInt256EventObject>;

export type LogInt256EventFilter = TypedEventFilter<LogInt256Event>;

export interface LogNamedAddressEventObject {
  key: string;
  value: string;
}
export type LogNamedAddressEvent = TypedEvent<
  [string, string],
  LogNamedAddressEventObject
>;

export type LogNamedAddressEventFilter = TypedEventFilter<LogNamedAddressEvent>;

export interface LogNamedArray_string_address_array_EventObject {
  key: string;
  value: string[];
}
export type LogNamedArray_string_address_array_Event = TypedEvent<
  [string, string[]],
  LogNamedArray_string_address_array_EventObject
>;

export type LogNamedArray_string_address_array_EventFilter =
  TypedEventFilter<LogNamedArray_string_address_array_Event>;

export interface LogNamedArray_string_bool_array_EventObject {
  key: string;
  value: boolean[];
}
export type LogNamedArray_string_bool_array_Event = TypedEvent<
  [string, boolean[]],
  LogNamedArray_string_bool_array_EventObject
>;

export type LogNamedArray_string_bool_array_EventFilter =
  TypedEventFilter<LogNamedArray_string_bool_array_Event>;

export interface LogNamedArray_string_bytes32_array_EventObject {
  key: string;
  value: string[];
}
export type LogNamedArray_string_bytes32_array_Event = TypedEvent<
  [string, string[]],
  LogNamedArray_string_bytes32_array_EventObject
>;

export type LogNamedArray_string_bytes32_array_EventFilter =
  TypedEventFilter<LogNamedArray_string_bytes32_array_Event>;

export interface LogNamedArray_string_int256_array_EventObject {
  key: string;
  value: BigNumber[];
}
export type LogNamedArray_string_int256_array_Event = TypedEvent<
  [string, BigNumber[]],
  LogNamedArray_string_int256_array_EventObject
>;

export type LogNamedArray_string_int256_array_EventFilter =
  TypedEventFilter<LogNamedArray_string_int256_array_Event>;

export interface LogNamedArray_string_string_array_EventObject {
  key: string;
  value: string[];
}
export type LogNamedArray_string_string_array_Event = TypedEvent<
  [string, string[]],
  LogNamedArray_string_string_array_EventObject
>;

export type LogNamedArray_string_string_array_EventFilter =
  TypedEventFilter<LogNamedArray_string_string_array_Event>;

export interface LogNamedArray_string_uint256_array_EventObject {
  key: string;
  value: BigNumber[];
}
export type LogNamedArray_string_uint256_array_Event = TypedEvent<
  [string, BigNumber[]],
  LogNamedArray_string_uint256_array_EventObject
>;

export type LogNamedArray_string_uint256_array_EventFilter =
  TypedEventFilter<LogNamedArray_string_uint256_array_Event>;

export interface LogNamedBytesEventObject {
  key: string;
  value: string;
}
export type LogNamedBytesEvent = TypedEvent<
  [string, string],
  LogNamedBytesEventObject
>;

export type LogNamedBytesEventFilter = TypedEventFilter<LogNamedBytesEvent>;

export interface LogNamedBytes32EventObject {
  key: string;
  value: string;
}
export type LogNamedBytes32Event = TypedEvent<
  [string, string],
  LogNamedBytes32EventObject
>;

export type LogNamedBytes32EventFilter = TypedEventFilter<LogNamedBytes32Event>;

export interface LogNamedInt256EventObject {
  key: string;
  value: BigNumber;
}
export type LogNamedInt256Event = TypedEvent<
  [string, BigNumber],
  LogNamedInt256EventObject
>;

export type LogNamedInt256EventFilter = TypedEventFilter<LogNamedInt256Event>;

export interface LogNamedStringEventObject {
  key: string;
  value: string;
}
export type LogNamedStringEvent = TypedEvent<
  [string, string],
  LogNamedStringEventObject
>;

export type LogNamedStringEventFilter = TypedEventFilter<LogNamedStringEvent>;

export interface LogNamedUint256EventObject {
  key: string;
  value: BigNumber;
}
export type LogNamedUint256Event = TypedEvent<
  [string, BigNumber],
  LogNamedUint256EventObject
>;

export type LogNamedUint256EventFilter = TypedEventFilter<LogNamedUint256Event>;

export interface LogStringEventObject {
  value: string;
}
export type LogStringEvent = TypedEvent<[string], LogStringEventObject>;

export type LogStringEventFilter = TypedEventFilter<LogStringEvent>;

export interface LogUint256EventObject {
  value: BigNumber;
}
export type LogUint256Event = TypedEvent<[BigNumber], LogUint256EventObject>;

export type LogUint256EventFilter = TypedEventFilter<LogUint256Event>;

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

  interface: PlasmaTestInterface;

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

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

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

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

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

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

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

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

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

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

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

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

  callStatic: {
    IS_TEST(overrides?: CallOverrides): Promise<boolean>;

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

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

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

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

    test_transferability(overrides?: CallOverrides): Promise<void>;
  };

  filters: {
    "Log(string)"(err?: null): LogEventFilter;
    Log(err?: null): LogEventFilter;

    "LogAddress(address)"(value?: null): LogAddressEventFilter;
    LogAddress(value?: null): LogAddressEventFilter;

    "LogArray(address[])"(value?: null): LogArray_address_array_EventFilter;
    "LogArray(bool[])"(value?: null): LogArray_bool_array_EventFilter;
    "LogArray(bytes32[])"(value?: null): LogArray_bytes32_array_EventFilter;
    "LogArray(int256[])"(value?: null): LogArray_int256_array_EventFilter;
    "LogArray(string[])"(value?: null): LogArray_string_array_EventFilter;
    "LogArray(uint256[])"(value?: null): LogArray_uint256_array_EventFilter;

    "LogBytes(bytes)"(value?: null): LogBytesEventFilter;
    LogBytes(value?: null): LogBytesEventFilter;

    "LogBytes32(bytes32)"(value?: null): LogBytes32EventFilter;
    LogBytes32(value?: null): LogBytes32EventFilter;

    "LogInt256(int256)"(value?: null): LogInt256EventFilter;
    LogInt256(value?: null): LogInt256EventFilter;

    "LogNamedAddress(string,address)"(
      key?: null,
      value?: null
    ): LogNamedAddressEventFilter;
    LogNamedAddress(key?: null, value?: null): LogNamedAddressEventFilter;

    "LogNamedArray(string,address[])"(
      key?: null,
      value?: null
    ): LogNamedArray_string_address_array_EventFilter;
    "LogNamedArray(string,bool[])"(
      key?: null,
      value?: null
    ): LogNamedArray_string_bool_array_EventFilter;
    "LogNamedArray(string,bytes32[])"(
      key?: null,
      value?: null
    ): LogNamedArray_string_bytes32_array_EventFilter;
    "LogNamedArray(string,int256[])"(
      key?: null,
      value?: null
    ): LogNamedArray_string_int256_array_EventFilter;
    "LogNamedArray(string,string[])"(
      key?: null,
      value?: null
    ): LogNamedArray_string_string_array_EventFilter;
    "LogNamedArray(string,uint256[])"(
      key?: null,
      value?: null
    ): LogNamedArray_string_uint256_array_EventFilter;

    "LogNamedBytes(string,bytes)"(
      key?: null,
      value?: null
    ): LogNamedBytesEventFilter;
    LogNamedBytes(key?: null, value?: null): LogNamedBytesEventFilter;

    "LogNamedBytes32(string,bytes32)"(
      key?: null,
      value?: null
    ): LogNamedBytes32EventFilter;
    LogNamedBytes32(key?: null, value?: null): LogNamedBytes32EventFilter;

    "LogNamedInt256(string,int256)"(
      key?: null,
      value?: null
    ): LogNamedInt256EventFilter;
    LogNamedInt256(key?: null, value?: null): LogNamedInt256EventFilter;

    "LogNamedString(string,string)"(
      key?: null,
      value?: null
    ): LogNamedStringEventFilter;
    LogNamedString(key?: null, value?: null): LogNamedStringEventFilter;

    "LogNamedUint256(string,uint256)"(
      key?: null,
      value?: null
    ): LogNamedUint256EventFilter;
    LogNamedUint256(key?: null, value?: null): LogNamedUint256EventFilter;

    "LogString(string)"(value?: null): LogStringEventFilter;
    LogString(value?: null): LogStringEventFilter;

    "LogUint256(uint256)"(value?: null): LogUint256EventFilter;
    LogUint256(value?: null): LogUint256EventFilter;
  };

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

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

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

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

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

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

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

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

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

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

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

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