/* 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 MockSlasherInterface extends ethers.utils.Interface {
  functions: {
    "MAXCOEF()": FunctionFragment;
    "changeGovernance(address)": FunctionFragment;
    "checkNSignatures(bytes32,bytes[])": FunctionFragment;
    "defaultSlashAmount()": FunctionFragment;
    "draft(uint64,string,uint64,bytes[])": FunctionFragment;
    "drafterCoef()": FunctionFragment;
    "endOf(uint256)": FunctionFragment;
    "execute(string)": FunctionFragment;
    "executorCoef()": FunctionFragment;
    "getSlashAt(uint256)": FunctionFragment;
    "governance()": FunctionFragment;
    "init(address,address,address,address,uint256,uint256,uint64,uint64,uint64,uint64)": FunctionFragment;
    "initialize(address,address,address,address,uint256,uint256,uint64,uint64,uint64,uint64)": FunctionFragment;
    "majorCandidates()": FunctionFragment;
    "nonce()": FunctionFragment;
    "nonceOf(address)": FunctionFragment;
    "owner()": FunctionFragment;
    "publicNoticePeriod()": FunctionFragment;
    "reject(string)": FunctionFragment;
    "renounceOwnership()": FunctionFragment;
    "setDrafterCoef(uint64)": FunctionFragment;
    "setExecutorCoef(uint64)": FunctionFragment;
    "setValidatorCoef(uint64)": FunctionFragment;
    "slashExists(address)": FunctionFragment;
    "stake()": FunctionFragment;
    "transferOwnership(address)": FunctionFragment;
    "validatorCoef()": FunctionFragment;
  };

  encodeFunctionData(functionFragment: "MAXCOEF", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "changeGovernance",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "checkNSignatures",
    values: [BytesLike, BytesLike[]]
  ): string;
  encodeFunctionData(
    functionFragment: "defaultSlashAmount",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "draft",
    values: [BigNumberish, string, BigNumberish, BytesLike[]]
  ): string;
  encodeFunctionData(
    functionFragment: "drafterCoef",
    values?: undefined
  ): string;
  encodeFunctionData(functionFragment: "endOf", values: [BigNumberish]): string;
  encodeFunctionData(functionFragment: "execute", values: [string]): string;
  encodeFunctionData(
    functionFragment: "executorCoef",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "getSlashAt",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "governance",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "init",
    values: [
      string,
      string,
      string,
      string,
      BigNumberish,
      BigNumberish,
      BigNumberish,
      BigNumberish,
      BigNumberish,
      BigNumberish
    ]
  ): string;
  encodeFunctionData(
    functionFragment: "initialize",
    values: [
      string,
      string,
      string,
      string,
      BigNumberish,
      BigNumberish,
      BigNumberish,
      BigNumberish,
      BigNumberish,
      BigNumberish
    ]
  ): string;
  encodeFunctionData(
    functionFragment: "majorCandidates",
    values?: undefined
  ): string;
  encodeFunctionData(functionFragment: "nonce", values?: undefined): string;
  encodeFunctionData(functionFragment: "nonceOf", values: [string]): string;
  encodeFunctionData(functionFragment: "owner", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "publicNoticePeriod",
    values?: undefined
  ): string;
  encodeFunctionData(functionFragment: "reject", values: [string]): string;
  encodeFunctionData(
    functionFragment: "renounceOwnership",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "setDrafterCoef",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "setExecutorCoef",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "setValidatorCoef",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(functionFragment: "slashExists", values: [string]): string;
  encodeFunctionData(functionFragment: "stake", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "transferOwnership",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "validatorCoef",
    values?: undefined
  ): string;

  decodeFunctionResult(functionFragment: "MAXCOEF", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "changeGovernance",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "checkNSignatures",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "defaultSlashAmount",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "draft", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "drafterCoef",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "endOf", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "execute", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "executorCoef",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "getSlashAt", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "governance", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "init", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "initialize", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "majorCandidates",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "nonce", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "nonceOf", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "owner", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "publicNoticePeriod",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "reject", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "renounceOwnership",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setDrafterCoef",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setExecutorCoef",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setValidatorCoef",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "slashExists",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "stake", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "transferOwnership",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "validatorCoef",
    data: BytesLike
  ): Result;

  events: {
    "DefaultSlashAmountUpdated(uint256)": EventFragment;
    "DraftSlash(uint256,address,uint64,string,uint64)": EventFragment;
    "DrafterCoefUpdated(uint64)": EventFragment;
    "ExecuteSlash(uint256,address)": EventFragment;
    "ExecutorCoefUpdated(uint256)": EventFragment;
    "GovernanceUpdated(address)": EventFragment;
    "Initialized(uint8)": EventFragment;
    "MajorCandidatesUpdated(address)": EventFragment;
    "MaxCoefUpdated(uint256)": EventFragment;
    "OwnershipTransferred(address,address)": EventFragment;
    "PublicNoticePeriodUpdated(uint256)": EventFragment;
    "RejectSlash(uint256)": EventFragment;
    "StakeUpdated(address)": EventFragment;
    "ValidatorCoefUpdated(uint256)": EventFragment;
  };

  getEvent(nameOrSignatureOrTopic: "DefaultSlashAmountUpdated"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "DraftSlash"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "DrafterCoefUpdated"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "ExecuteSlash"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "ExecutorCoefUpdated"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "GovernanceUpdated"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "Initialized"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "MajorCandidatesUpdated"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "MaxCoefUpdated"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "OwnershipTransferred"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "PublicNoticePeriodUpdated"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "RejectSlash"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "StakeUpdated"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "ValidatorCoefUpdated"): EventFragment;
}

export type DefaultSlashAmountUpdatedEvent = TypedEvent<
  [BigNumber] & { amount: BigNumber }
>;

export type DraftSlashEvent = TypedEvent<
  [BigNumber, string, BigNumber, string, BigNumber] & {
    nonce: BigNumber;
    candidate: string;
    slashBlock: BigNumber;
    manifest: string;
    accuracy: BigNumber;
  }
>;

export type DrafterCoefUpdatedEvent = TypedEvent<
  [BigNumber] & { drafterCoef: BigNumber }
>;

export type ExecuteSlashEvent = TypedEvent<
  [BigNumber, string] & { nonce: BigNumber; executor: string }
>;

export type ExecutorCoefUpdatedEvent = TypedEvent<
  [BigNumber] & { executorCoef: BigNumber }
>;

export type GovernanceUpdatedEvent = TypedEvent<
  [string] & { governance: string }
>;

export type InitializedEvent = TypedEvent<[number] & { version: number }>;

export type MajorCandidatesUpdatedEvent = TypedEvent<
  [string] & { majorCandidates: string }
>;

export type MaxCoefUpdatedEvent = TypedEvent<
  [BigNumber] & { maxCoef: BigNumber }
>;

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

export type PublicNoticePeriodUpdatedEvent = TypedEvent<
  [BigNumber] & { period: BigNumber }
>;

export type RejectSlashEvent = TypedEvent<[BigNumber] & { nonce: BigNumber }>;

export type StakeUpdatedEvent = TypedEvent<[string] & { stake: string }>;

export type ValidatorCoefUpdatedEvent = TypedEvent<
  [BigNumber] & { validatorCoef: BigNumber }
>;

export class MockSlasher 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: MockSlasherInterface;

  functions: {
    MAXCOEF(overrides?: CallOverrides): Promise<[BigNumber]>;

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

    checkNSignatures(
      hash: BytesLike,
      signatures: BytesLike[],
      overrides?: CallOverrides
    ): Promise<[string[]] & { signers: string[] }>;

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

    draft(
      slashBlock: BigNumberish,
      manifest: string,
      accuracy: BigNumberish,
      signatures: BytesLike[],
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

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

    endOf(
      _nonce: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[BigNumber]>;

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

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

    getSlashAt(
      _nonce: BigNumberish,
      overrides?: CallOverrides
    ): Promise<
      [
        [string, string, string[], BigNumber, BigNumber, number] & {
          candidate: string;
          drafter: string;
          validators: string[];
          amount: BigNumber;
          timestamp: BigNumber;
          status: number;
        }
      ]
    >;

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

    init(
      newOwner: string,
      _governance: string,
      _stake: string,
      _majorCandidates: string,
      _defaultSlashAmount: BigNumberish,
      _publicNoticePeriod: BigNumberish,
      maxCoef: BigNumberish,
      _drafterCoef: BigNumberish,
      _validatorCoef: BigNumberish,
      _executorCoef: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    initialize(
      newOwner: string,
      _governance: string,
      _stake: string,
      _majorCandidates: string,
      _defaultSlashAmount: BigNumberish,
      _publicNoticePeriod: BigNumberish,
      maxCoef: BigNumberish,
      _drafterCoef: BigNumberish,
      _validatorCoef: BigNumberish,
      _executorCoef: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

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

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

    nonceOf(candidate: string, overrides?: CallOverrides): Promise<[BigNumber]>;

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

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

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

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

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

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

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

    slashExists(
      candidate: string,
      overrides?: CallOverrides
    ): Promise<[boolean]>;

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

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

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

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

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

  checkNSignatures(
    hash: BytesLike,
    signatures: BytesLike[],
    overrides?: CallOverrides
  ): Promise<string[]>;

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

  draft(
    slashBlock: BigNumberish,
    manifest: string,
    accuracy: BigNumberish,
    signatures: BytesLike[],
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

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

  endOf(_nonce: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;

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

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

  getSlashAt(
    _nonce: BigNumberish,
    overrides?: CallOverrides
  ): Promise<
    [string, string, string[], BigNumber, BigNumber, number] & {
      candidate: string;
      drafter: string;
      validators: string[];
      amount: BigNumber;
      timestamp: BigNumber;
      status: number;
    }
  >;

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

  init(
    newOwner: string,
    _governance: string,
    _stake: string,
    _majorCandidates: string,
    _defaultSlashAmount: BigNumberish,
    _publicNoticePeriod: BigNumberish,
    maxCoef: BigNumberish,
    _drafterCoef: BigNumberish,
    _validatorCoef: BigNumberish,
    _executorCoef: BigNumberish,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  initialize(
    newOwner: string,
    _governance: string,
    _stake: string,
    _majorCandidates: string,
    _defaultSlashAmount: BigNumberish,
    _publicNoticePeriod: BigNumberish,
    maxCoef: BigNumberish,
    _drafterCoef: BigNumberish,
    _validatorCoef: BigNumberish,
    _executorCoef: BigNumberish,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

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

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

  nonceOf(candidate: string, overrides?: CallOverrides): Promise<BigNumber>;

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

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

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

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

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

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

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

  slashExists(candidate: string, overrides?: CallOverrides): Promise<boolean>;

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

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

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

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

    changeGovernance(
      newGovernance: string,
      overrides?: CallOverrides
    ): Promise<void>;

    checkNSignatures(
      hash: BytesLike,
      signatures: BytesLike[],
      overrides?: CallOverrides
    ): Promise<string[]>;

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

    draft(
      slashBlock: BigNumberish,
      manifest: string,
      accuracy: BigNumberish,
      signatures: BytesLike[],
      overrides?: CallOverrides
    ): Promise<void>;

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

    endOf(_nonce: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;

    execute(manifest: string, overrides?: CallOverrides): Promise<void>;

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

    getSlashAt(
      _nonce: BigNumberish,
      overrides?: CallOverrides
    ): Promise<
      [string, string, string[], BigNumber, BigNumber, number] & {
        candidate: string;
        drafter: string;
        validators: string[];
        amount: BigNumber;
        timestamp: BigNumber;
        status: number;
      }
    >;

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

    init(
      newOwner: string,
      _governance: string,
      _stake: string,
      _majorCandidates: string,
      _defaultSlashAmount: BigNumberish,
      _publicNoticePeriod: BigNumberish,
      maxCoef: BigNumberish,
      _drafterCoef: BigNumberish,
      _validatorCoef: BigNumberish,
      _executorCoef: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    initialize(
      newOwner: string,
      _governance: string,
      _stake: string,
      _majorCandidates: string,
      _defaultSlashAmount: BigNumberish,
      _publicNoticePeriod: BigNumberish,
      maxCoef: BigNumberish,
      _drafterCoef: BigNumberish,
      _validatorCoef: BigNumberish,
      _executorCoef: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

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

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

    nonceOf(candidate: string, overrides?: CallOverrides): Promise<BigNumber>;

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

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

    reject(manifest: string, overrides?: CallOverrides): Promise<void>;

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

    setDrafterCoef(
      _drafterCoef: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    setExecutorCoef(
      _executorCoef: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    setValidatorCoef(
      _validatorCoef: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    slashExists(candidate: string, overrides?: CallOverrides): Promise<boolean>;

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

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

    validatorCoef(overrides?: CallOverrides): Promise<BigNumber>;
  };

  filters: {
    "DefaultSlashAmountUpdated(uint256)"(
      amount?: null
    ): TypedEventFilter<[BigNumber], { amount: BigNumber }>;

    DefaultSlashAmountUpdated(
      amount?: null
    ): TypedEventFilter<[BigNumber], { amount: BigNumber }>;

    "DraftSlash(uint256,address,uint64,string,uint64)"(
      nonce?: null,
      candidate?: null,
      slashBlock?: null,
      manifest?: null,
      accuracy?: null
    ): TypedEventFilter<
      [BigNumber, string, BigNumber, string, BigNumber],
      {
        nonce: BigNumber;
        candidate: string;
        slashBlock: BigNumber;
        manifest: string;
        accuracy: BigNumber;
      }
    >;

    DraftSlash(
      nonce?: null,
      candidate?: null,
      slashBlock?: null,
      manifest?: null,
      accuracy?: null
    ): TypedEventFilter<
      [BigNumber, string, BigNumber, string, BigNumber],
      {
        nonce: BigNumber;
        candidate: string;
        slashBlock: BigNumber;
        manifest: string;
        accuracy: BigNumber;
      }
    >;

    "DrafterCoefUpdated(uint64)"(
      drafterCoef?: null
    ): TypedEventFilter<[BigNumber], { drafterCoef: BigNumber }>;

    DrafterCoefUpdated(
      drafterCoef?: null
    ): TypedEventFilter<[BigNumber], { drafterCoef: BigNumber }>;

    "ExecuteSlash(uint256,address)"(
      nonce?: null,
      executor?: null
    ): TypedEventFilter<
      [BigNumber, string],
      { nonce: BigNumber; executor: string }
    >;

    ExecuteSlash(
      nonce?: null,
      executor?: null
    ): TypedEventFilter<
      [BigNumber, string],
      { nonce: BigNumber; executor: string }
    >;

    "ExecutorCoefUpdated(uint256)"(
      executorCoef?: null
    ): TypedEventFilter<[BigNumber], { executorCoef: BigNumber }>;

    ExecutorCoefUpdated(
      executorCoef?: null
    ): TypedEventFilter<[BigNumber], { executorCoef: BigNumber }>;

    "GovernanceUpdated(address)"(
      governance?: null
    ): TypedEventFilter<[string], { governance: string }>;

    GovernanceUpdated(
      governance?: null
    ): TypedEventFilter<[string], { governance: string }>;

    "Initialized(uint8)"(
      version?: null
    ): TypedEventFilter<[number], { version: number }>;

    Initialized(
      version?: null
    ): TypedEventFilter<[number], { version: number }>;

    "MajorCandidatesUpdated(address)"(
      majorCandidates?: null
    ): TypedEventFilter<[string], { majorCandidates: string }>;

    MajorCandidatesUpdated(
      majorCandidates?: null
    ): TypedEventFilter<[string], { majorCandidates: string }>;

    "MaxCoefUpdated(uint256)"(
      maxCoef?: null
    ): TypedEventFilter<[BigNumber], { maxCoef: BigNumber }>;

    MaxCoefUpdated(
      maxCoef?: null
    ): TypedEventFilter<[BigNumber], { maxCoef: BigNumber }>;

    "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 }
    >;

    "PublicNoticePeriodUpdated(uint256)"(
      period?: null
    ): TypedEventFilter<[BigNumber], { period: BigNumber }>;

    PublicNoticePeriodUpdated(
      period?: null
    ): TypedEventFilter<[BigNumber], { period: BigNumber }>;

    "RejectSlash(uint256)"(
      nonce?: null
    ): TypedEventFilter<[BigNumber], { nonce: BigNumber }>;

    RejectSlash(
      nonce?: null
    ): TypedEventFilter<[BigNumber], { nonce: BigNumber }>;

    "StakeUpdated(address)"(
      stake?: null
    ): TypedEventFilter<[string], { stake: string }>;

    StakeUpdated(stake?: null): TypedEventFilter<[string], { stake: string }>;

    "ValidatorCoefUpdated(uint256)"(
      validatorCoef?: null
    ): TypedEventFilter<[BigNumber], { validatorCoef: BigNumber }>;

    ValidatorCoefUpdated(
      validatorCoef?: null
    ): TypedEventFilter<[BigNumber], { validatorCoef: BigNumber }>;
  };

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

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

    checkNSignatures(
      hash: BytesLike,
      signatures: BytesLike[],
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

    draft(
      slashBlock: BigNumberish,
      manifest: string,
      accuracy: BigNumberish,
      signatures: BytesLike[],
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

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

    endOf(_nonce: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;

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

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

    getSlashAt(
      _nonce: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

    init(
      newOwner: string,
      _governance: string,
      _stake: string,
      _majorCandidates: string,
      _defaultSlashAmount: BigNumberish,
      _publicNoticePeriod: BigNumberish,
      maxCoef: BigNumberish,
      _drafterCoef: BigNumberish,
      _validatorCoef: BigNumberish,
      _executorCoef: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    initialize(
      newOwner: string,
      _governance: string,
      _stake: string,
      _majorCandidates: string,
      _defaultSlashAmount: BigNumberish,
      _publicNoticePeriod: BigNumberish,
      maxCoef: BigNumberish,
      _drafterCoef: BigNumberish,
      _validatorCoef: BigNumberish,
      _executorCoef: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

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

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

    nonceOf(candidate: string, overrides?: CallOverrides): Promise<BigNumber>;

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

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

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

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

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

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

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

    slashExists(
      candidate: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

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

    validatorCoef(overrides?: CallOverrides): Promise<BigNumber>;
  };

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

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

    checkNSignatures(
      hash: BytesLike,
      signatures: BytesLike[],
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

    draft(
      slashBlock: BigNumberish,
      manifest: string,
      accuracy: BigNumberish,
      signatures: BytesLike[],
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

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

    endOf(
      _nonce: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

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

    getSlashAt(
      _nonce: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

    init(
      newOwner: string,
      _governance: string,
      _stake: string,
      _majorCandidates: string,
      _defaultSlashAmount: BigNumberish,
      _publicNoticePeriod: BigNumberish,
      maxCoef: BigNumberish,
      _drafterCoef: BigNumberish,
      _validatorCoef: BigNumberish,
      _executorCoef: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    initialize(
      newOwner: string,
      _governance: string,
      _stake: string,
      _majorCandidates: string,
      _defaultSlashAmount: BigNumberish,
      _publicNoticePeriod: BigNumberish,
      maxCoef: BigNumberish,
      _drafterCoef: BigNumberish,
      _validatorCoef: BigNumberish,
      _executorCoef: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

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

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

    nonceOf(
      candidate: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

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

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

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

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

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

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

    slashExists(
      candidate: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

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

    validatorCoef(overrides?: CallOverrides): Promise<PopulatedTransaction>;
  };
}