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

export declare namespace IAttestation {
  export type StateStruct = {
    requestCID: PromiseOrValue<BytesLike>;
    responseCID: PromiseOrValue<BytesLike>;
    subgraphDeploymentId: PromiseOrValue<BytesLike>;
    r: PromiseOrValue<BytesLike>;
    s: PromiseOrValue<BytesLike>;
    v: PromiseOrValue<BigNumberish>;
  };

  export type StateStructOutput = [
    string,
    string,
    string,
    string,
    string,
    number
  ] & {
    requestCID: string;
    responseCID: string;
    subgraphDeploymentId: string;
    r: string;
    s: string;
    v: number;
  };

  export type ReceiptStruct = {
    requestCID: PromiseOrValue<BytesLike>;
    responseCID: PromiseOrValue<BytesLike>;
    subgraphDeploymentId: PromiseOrValue<BytesLike>;
  };

  export type ReceiptStructOutput = [string, string, string] & {
    requestCID: string;
    responseCID: string;
    subgraphDeploymentId: string;
  };
}

export declare namespace IDisputeManager {
  export type DisputeStruct = {
    indexer: PromiseOrValue<string>;
    fisherman: PromiseOrValue<string>;
    deposit: PromiseOrValue<BigNumberish>;
    relatedDisputeId: PromiseOrValue<BytesLike>;
    disputeType: PromiseOrValue<BigNumberish>;
    status: PromiseOrValue<BigNumberish>;
    createdAt: PromiseOrValue<BigNumberish>;
    cancellableAt: PromiseOrValue<BigNumberish>;
    stakeSnapshot: PromiseOrValue<BigNumberish>;
  };

  export type DisputeStructOutput = [
    string,
    string,
    BigNumber,
    string,
    number,
    number,
    BigNumber,
    BigNumber,
    BigNumber
  ] & {
    indexer: string;
    fisherman: string;
    deposit: BigNumber;
    relatedDisputeId: string;
    disputeType: number;
    status: number;
    createdAt: BigNumber;
    cancellableAt: BigNumber;
    stakeSnapshot: BigNumber;
  };
}

export interface IDisputeManagerToolshedInterface extends utils.Interface {
  functions: {
    "acceptDispute(bytes32,uint256)": FunctionFragment;
    "acceptDisputeConflict(bytes32,uint256,bool,uint256)": FunctionFragment;
    "arbitrator()": FunctionFragment;
    "areConflictingAttestations((bytes32,bytes32,bytes32,bytes32,bytes32,uint8),(bytes32,bytes32,bytes32,bytes32,bytes32,uint8))": FunctionFragment;
    "cancelDispute(bytes32)": FunctionFragment;
    "createAndAcceptLegacyDispute(address,address,uint256,uint256)": FunctionFragment;
    "createIndexingDispute(address,bytes32,uint256)": FunctionFragment;
    "createQueryDispute(bytes)": FunctionFragment;
    "createQueryDisputeConflict(bytes,bytes)": FunctionFragment;
    "disputeDeposit()": FunctionFragment;
    "disputePeriod()": FunctionFragment;
    "disputes(bytes32)": FunctionFragment;
    "drawDispute(bytes32)": FunctionFragment;
    "encodeReceipt((bytes32,bytes32,bytes32))": FunctionFragment;
    "fishermanRewardCut()": FunctionFragment;
    "getAttestationIndexer((bytes32,bytes32,bytes32,bytes32,bytes32,uint8))": FunctionFragment;
    "getDisputePeriod()": FunctionFragment;
    "getFishermanRewardCut()": FunctionFragment;
    "getStakeSnapshot(address)": FunctionFragment;
    "initialize(address,address,uint64,uint256,uint32,uint32)": FunctionFragment;
    "isDisputeCreated(bytes32)": FunctionFragment;
    "maxSlashingCut()": FunctionFragment;
    "owner()": FunctionFragment;
    "rejectDispute(bytes32)": FunctionFragment;
    "renounceOwnership()": FunctionFragment;
    "setArbitrator(address)": FunctionFragment;
    "setDisputeDeposit(uint256)": FunctionFragment;
    "setDisputePeriod(uint64)": FunctionFragment;
    "setFishermanRewardCut(uint32)": FunctionFragment;
    "setMaxSlashingCut(uint32)": FunctionFragment;
    "setSubgraphService(address)": FunctionFragment;
    "subgraphService()": FunctionFragment;
    "transferOwnership(address)": FunctionFragment;
  };

  getFunction(
    nameOrSignatureOrTopic:
      | "acceptDispute"
      | "acceptDisputeConflict"
      | "arbitrator"
      | "areConflictingAttestations"
      | "cancelDispute"
      | "createAndAcceptLegacyDispute"
      | "createIndexingDispute"
      | "createQueryDispute"
      | "createQueryDisputeConflict"
      | "disputeDeposit"
      | "disputePeriod"
      | "disputes"
      | "drawDispute"
      | "encodeReceipt"
      | "fishermanRewardCut"
      | "getAttestationIndexer"
      | "getDisputePeriod"
      | "getFishermanRewardCut"
      | "getStakeSnapshot"
      | "initialize"
      | "isDisputeCreated"
      | "maxSlashingCut"
      | "owner"
      | "rejectDispute"
      | "renounceOwnership"
      | "setArbitrator"
      | "setDisputeDeposit"
      | "setDisputePeriod"
      | "setFishermanRewardCut"
      | "setMaxSlashingCut"
      | "setSubgraphService"
      | "subgraphService"
      | "transferOwnership"
  ): FunctionFragment;

  encodeFunctionData(
    functionFragment: "acceptDispute",
    values: [PromiseOrValue<BytesLike>, PromiseOrValue<BigNumberish>]
  ): string;
  encodeFunctionData(
    functionFragment: "acceptDisputeConflict",
    values: [
      PromiseOrValue<BytesLike>,
      PromiseOrValue<BigNumberish>,
      PromiseOrValue<boolean>,
      PromiseOrValue<BigNumberish>
    ]
  ): string;
  encodeFunctionData(
    functionFragment: "arbitrator",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "areConflictingAttestations",
    values: [IAttestation.StateStruct, IAttestation.StateStruct]
  ): string;
  encodeFunctionData(
    functionFragment: "cancelDispute",
    values: [PromiseOrValue<BytesLike>]
  ): string;
  encodeFunctionData(
    functionFragment: "createAndAcceptLegacyDispute",
    values: [
      PromiseOrValue<string>,
      PromiseOrValue<string>,
      PromiseOrValue<BigNumberish>,
      PromiseOrValue<BigNumberish>
    ]
  ): string;
  encodeFunctionData(
    functionFragment: "createIndexingDispute",
    values: [
      PromiseOrValue<string>,
      PromiseOrValue<BytesLike>,
      PromiseOrValue<BigNumberish>
    ]
  ): string;
  encodeFunctionData(
    functionFragment: "createQueryDispute",
    values: [PromiseOrValue<BytesLike>]
  ): string;
  encodeFunctionData(
    functionFragment: "createQueryDisputeConflict",
    values: [PromiseOrValue<BytesLike>, PromiseOrValue<BytesLike>]
  ): string;
  encodeFunctionData(
    functionFragment: "disputeDeposit",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "disputePeriod",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "disputes",
    values: [PromiseOrValue<BytesLike>]
  ): string;
  encodeFunctionData(
    functionFragment: "drawDispute",
    values: [PromiseOrValue<BytesLike>]
  ): string;
  encodeFunctionData(
    functionFragment: "encodeReceipt",
    values: [IAttestation.ReceiptStruct]
  ): string;
  encodeFunctionData(
    functionFragment: "fishermanRewardCut",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "getAttestationIndexer",
    values: [IAttestation.StateStruct]
  ): string;
  encodeFunctionData(
    functionFragment: "getDisputePeriod",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "getFishermanRewardCut",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "getStakeSnapshot",
    values: [PromiseOrValue<string>]
  ): string;
  encodeFunctionData(
    functionFragment: "initialize",
    values: [
      PromiseOrValue<string>,
      PromiseOrValue<string>,
      PromiseOrValue<BigNumberish>,
      PromiseOrValue<BigNumberish>,
      PromiseOrValue<BigNumberish>,
      PromiseOrValue<BigNumberish>
    ]
  ): string;
  encodeFunctionData(
    functionFragment: "isDisputeCreated",
    values: [PromiseOrValue<BytesLike>]
  ): string;
  encodeFunctionData(
    functionFragment: "maxSlashingCut",
    values?: undefined
  ): string;
  encodeFunctionData(functionFragment: "owner", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "rejectDispute",
    values: [PromiseOrValue<BytesLike>]
  ): string;
  encodeFunctionData(
    functionFragment: "renounceOwnership",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "setArbitrator",
    values: [PromiseOrValue<string>]
  ): string;
  encodeFunctionData(
    functionFragment: "setDisputeDeposit",
    values: [PromiseOrValue<BigNumberish>]
  ): string;
  encodeFunctionData(
    functionFragment: "setDisputePeriod",
    values: [PromiseOrValue<BigNumberish>]
  ): string;
  encodeFunctionData(
    functionFragment: "setFishermanRewardCut",
    values: [PromiseOrValue<BigNumberish>]
  ): string;
  encodeFunctionData(
    functionFragment: "setMaxSlashingCut",
    values: [PromiseOrValue<BigNumberish>]
  ): string;
  encodeFunctionData(
    functionFragment: "setSubgraphService",
    values: [PromiseOrValue<string>]
  ): string;
  encodeFunctionData(
    functionFragment: "subgraphService",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "transferOwnership",
    values: [PromiseOrValue<string>]
  ): string;

  decodeFunctionResult(
    functionFragment: "acceptDispute",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "acceptDisputeConflict",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "arbitrator", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "areConflictingAttestations",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "cancelDispute",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "createAndAcceptLegacyDispute",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "createIndexingDispute",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "createQueryDispute",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "createQueryDisputeConflict",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "disputeDeposit",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "disputePeriod",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "disputes", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "drawDispute",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "encodeReceipt",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "fishermanRewardCut",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getAttestationIndexer",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getDisputePeriod",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getFishermanRewardCut",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getStakeSnapshot",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "initialize", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "isDisputeCreated",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "maxSlashingCut",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "owner", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "rejectDispute",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "renounceOwnership",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setArbitrator",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setDisputeDeposit",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setDisputePeriod",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setFishermanRewardCut",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setMaxSlashingCut",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setSubgraphService",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "subgraphService",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "transferOwnership",
    data: BytesLike
  ): Result;

  events: {
    "ArbitratorSet(address)": EventFragment;
    "DisputeAccepted(bytes32,address,address,uint256)": EventFragment;
    "DisputeCancelled(bytes32,address,address,uint256)": EventFragment;
    "DisputeDepositSet(uint256)": EventFragment;
    "DisputeDrawn(bytes32,address,address,uint256)": EventFragment;
    "DisputeLinked(bytes32,bytes32)": EventFragment;
    "DisputePeriodSet(uint64)": EventFragment;
    "DisputeRejected(bytes32,address,address,uint256)": EventFragment;
    "FishermanRewardCutSet(uint32)": EventFragment;
    "IndexingDisputeCreated(bytes32,address,address,uint256,address,bytes32,uint256,uint256,uint256)": EventFragment;
    "LegacyDisputeCreated(bytes32,address,address,address,uint256,uint256)": EventFragment;
    "MaxSlashingCutSet(uint32)": EventFragment;
    "QueryDisputeCreated(bytes32,address,address,uint256,bytes32,bytes,uint256,uint256)": EventFragment;
    "SubgraphServiceSet(address)": EventFragment;
  };

  getEvent(nameOrSignatureOrTopic: "ArbitratorSet"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "DisputeAccepted"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "DisputeCancelled"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "DisputeDepositSet"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "DisputeDrawn"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "DisputeLinked"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "DisputePeriodSet"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "DisputeRejected"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "FishermanRewardCutSet"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "IndexingDisputeCreated"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "LegacyDisputeCreated"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "MaxSlashingCutSet"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "QueryDisputeCreated"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "SubgraphServiceSet"): EventFragment;
}

export interface ArbitratorSetEventObject {
  arbitrator: string;
}
export type ArbitratorSetEvent = TypedEvent<[string], ArbitratorSetEventObject>;

export type ArbitratorSetEventFilter = TypedEventFilter<ArbitratorSetEvent>;

export interface DisputeAcceptedEventObject {
  disputeId: string;
  indexer: string;
  fisherman: string;
  tokens: BigNumber;
}
export type DisputeAcceptedEvent = TypedEvent<
  [string, string, string, BigNumber],
  DisputeAcceptedEventObject
>;

export type DisputeAcceptedEventFilter = TypedEventFilter<DisputeAcceptedEvent>;

export interface DisputeCancelledEventObject {
  disputeId: string;
  indexer: string;
  fisherman: string;
  tokens: BigNumber;
}
export type DisputeCancelledEvent = TypedEvent<
  [string, string, string, BigNumber],
  DisputeCancelledEventObject
>;

export type DisputeCancelledEventFilter =
  TypedEventFilter<DisputeCancelledEvent>;

export interface DisputeDepositSetEventObject {
  disputeDeposit: BigNumber;
}
export type DisputeDepositSetEvent = TypedEvent<
  [BigNumber],
  DisputeDepositSetEventObject
>;

export type DisputeDepositSetEventFilter =
  TypedEventFilter<DisputeDepositSetEvent>;

export interface DisputeDrawnEventObject {
  disputeId: string;
  indexer: string;
  fisherman: string;
  tokens: BigNumber;
}
export type DisputeDrawnEvent = TypedEvent<
  [string, string, string, BigNumber],
  DisputeDrawnEventObject
>;

export type DisputeDrawnEventFilter = TypedEventFilter<DisputeDrawnEvent>;

export interface DisputeLinkedEventObject {
  disputeId1: string;
  disputeId2: string;
}
export type DisputeLinkedEvent = TypedEvent<
  [string, string],
  DisputeLinkedEventObject
>;

export type DisputeLinkedEventFilter = TypedEventFilter<DisputeLinkedEvent>;

export interface DisputePeriodSetEventObject {
  disputePeriod: BigNumber;
}
export type DisputePeriodSetEvent = TypedEvent<
  [BigNumber],
  DisputePeriodSetEventObject
>;

export type DisputePeriodSetEventFilter =
  TypedEventFilter<DisputePeriodSetEvent>;

export interface DisputeRejectedEventObject {
  disputeId: string;
  indexer: string;
  fisherman: string;
  tokens: BigNumber;
}
export type DisputeRejectedEvent = TypedEvent<
  [string, string, string, BigNumber],
  DisputeRejectedEventObject
>;

export type DisputeRejectedEventFilter = TypedEventFilter<DisputeRejectedEvent>;

export interface FishermanRewardCutSetEventObject {
  fishermanRewardCut: number;
}
export type FishermanRewardCutSetEvent = TypedEvent<
  [number],
  FishermanRewardCutSetEventObject
>;

export type FishermanRewardCutSetEventFilter =
  TypedEventFilter<FishermanRewardCutSetEvent>;

export interface IndexingDisputeCreatedEventObject {
  disputeId: string;
  indexer: string;
  fisherman: string;
  tokens: BigNumber;
  allocationId: string;
  poi: string;
  blockNumber: BigNumber;
  stakeSnapshot: BigNumber;
  cancellableAt: BigNumber;
}
export type IndexingDisputeCreatedEvent = TypedEvent<
  [
    string,
    string,
    string,
    BigNumber,
    string,
    string,
    BigNumber,
    BigNumber,
    BigNumber
  ],
  IndexingDisputeCreatedEventObject
>;

export type IndexingDisputeCreatedEventFilter =
  TypedEventFilter<IndexingDisputeCreatedEvent>;

export interface LegacyDisputeCreatedEventObject {
  disputeId: string;
  indexer: string;
  fisherman: string;
  allocationId: string;
  tokensSlash: BigNumber;
  tokensRewards: BigNumber;
}
export type LegacyDisputeCreatedEvent = TypedEvent<
  [string, string, string, string, BigNumber, BigNumber],
  LegacyDisputeCreatedEventObject
>;

export type LegacyDisputeCreatedEventFilter =
  TypedEventFilter<LegacyDisputeCreatedEvent>;

export interface MaxSlashingCutSetEventObject {
  maxSlashingCut: number;
}
export type MaxSlashingCutSetEvent = TypedEvent<
  [number],
  MaxSlashingCutSetEventObject
>;

export type MaxSlashingCutSetEventFilter =
  TypedEventFilter<MaxSlashingCutSetEvent>;

export interface QueryDisputeCreatedEventObject {
  disputeId: string;
  indexer: string;
  fisherman: string;
  tokens: BigNumber;
  subgraphDeploymentId: string;
  attestation: string;
  stakeSnapshot: BigNumber;
  cancellableAt: BigNumber;
}
export type QueryDisputeCreatedEvent = TypedEvent<
  [string, string, string, BigNumber, string, string, BigNumber, BigNumber],
  QueryDisputeCreatedEventObject
>;

export type QueryDisputeCreatedEventFilter =
  TypedEventFilter<QueryDisputeCreatedEvent>;

export interface SubgraphServiceSetEventObject {
  subgraphService: string;
}
export type SubgraphServiceSetEvent = TypedEvent<
  [string],
  SubgraphServiceSetEventObject
>;

export type SubgraphServiceSetEventFilter =
  TypedEventFilter<SubgraphServiceSetEvent>;

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

  interface: IDisputeManagerToolshedInterface;

  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: {
    acceptDispute(
      disputeId: PromiseOrValue<BytesLike>,
      tokensSlash: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    acceptDisputeConflict(
      disputeId: PromiseOrValue<BytesLike>,
      tokensSlash: PromiseOrValue<BigNumberish>,
      acceptDisputeInConflict: PromiseOrValue<boolean>,
      tokensSlashRelated: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

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

    areConflictingAttestations(
      attestation1: IAttestation.StateStruct,
      attestation2: IAttestation.StateStruct,
      overrides?: CallOverrides
    ): Promise<[boolean]>;

    cancelDispute(
      disputeId: PromiseOrValue<BytesLike>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    createAndAcceptLegacyDispute(
      allocationId: PromiseOrValue<string>,
      fisherman: PromiseOrValue<string>,
      tokensSlash: PromiseOrValue<BigNumberish>,
      tokensRewards: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    createIndexingDispute(
      allocationId: PromiseOrValue<string>,
      poi: PromiseOrValue<BytesLike>,
      blockNumber: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    createQueryDispute(
      attestationData: PromiseOrValue<BytesLike>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    createQueryDisputeConflict(
      attestationData1: PromiseOrValue<BytesLike>,
      attestationData2: PromiseOrValue<BytesLike>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

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

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

    disputes(
      disputeId: PromiseOrValue<BytesLike>,
      overrides?: CallOverrides
    ): Promise<[IDisputeManager.DisputeStructOutput]>;

    drawDispute(
      disputeId: PromiseOrValue<BytesLike>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    encodeReceipt(
      receipt: IAttestation.ReceiptStruct,
      overrides?: CallOverrides
    ): Promise<[string]>;

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

    getAttestationIndexer(
      attestation: IAttestation.StateStruct,
      overrides?: CallOverrides
    ): Promise<[string]>;

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

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

    getStakeSnapshot(
      indexer: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<[BigNumber]>;

    initialize(
      owner: PromiseOrValue<string>,
      arbitrator: PromiseOrValue<string>,
      disputePeriod: PromiseOrValue<BigNumberish>,
      disputeDeposit: PromiseOrValue<BigNumberish>,
      fishermanRewardCut_: PromiseOrValue<BigNumberish>,
      maxSlashingCut_: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    isDisputeCreated(
      disputeId: PromiseOrValue<BytesLike>,
      overrides?: CallOverrides
    ): Promise<[boolean]>;

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

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

    rejectDispute(
      disputeId: PromiseOrValue<BytesLike>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

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

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

    setDisputeDeposit(
      disputeDeposit: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    setDisputePeriod(
      disputePeriod: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    setFishermanRewardCut(
      fishermanRewardCut_: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    setMaxSlashingCut(
      maxSlashingCut_: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

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

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

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

  acceptDispute(
    disputeId: PromiseOrValue<BytesLike>,
    tokensSlash: PromiseOrValue<BigNumberish>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  acceptDisputeConflict(
    disputeId: PromiseOrValue<BytesLike>,
    tokensSlash: PromiseOrValue<BigNumberish>,
    acceptDisputeInConflict: PromiseOrValue<boolean>,
    tokensSlashRelated: PromiseOrValue<BigNumberish>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

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

  areConflictingAttestations(
    attestation1: IAttestation.StateStruct,
    attestation2: IAttestation.StateStruct,
    overrides?: CallOverrides
  ): Promise<boolean>;

  cancelDispute(
    disputeId: PromiseOrValue<BytesLike>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  createAndAcceptLegacyDispute(
    allocationId: PromiseOrValue<string>,
    fisherman: PromiseOrValue<string>,
    tokensSlash: PromiseOrValue<BigNumberish>,
    tokensRewards: PromiseOrValue<BigNumberish>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  createIndexingDispute(
    allocationId: PromiseOrValue<string>,
    poi: PromiseOrValue<BytesLike>,
    blockNumber: PromiseOrValue<BigNumberish>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  createQueryDispute(
    attestationData: PromiseOrValue<BytesLike>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  createQueryDisputeConflict(
    attestationData1: PromiseOrValue<BytesLike>,
    attestationData2: PromiseOrValue<BytesLike>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

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

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

  disputes(
    disputeId: PromiseOrValue<BytesLike>,
    overrides?: CallOverrides
  ): Promise<IDisputeManager.DisputeStructOutput>;

  drawDispute(
    disputeId: PromiseOrValue<BytesLike>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  encodeReceipt(
    receipt: IAttestation.ReceiptStruct,
    overrides?: CallOverrides
  ): Promise<string>;

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

  getAttestationIndexer(
    attestation: IAttestation.StateStruct,
    overrides?: CallOverrides
  ): Promise<string>;

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

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

  getStakeSnapshot(
    indexer: PromiseOrValue<string>,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  initialize(
    owner: PromiseOrValue<string>,
    arbitrator: PromiseOrValue<string>,
    disputePeriod: PromiseOrValue<BigNumberish>,
    disputeDeposit: PromiseOrValue<BigNumberish>,
    fishermanRewardCut_: PromiseOrValue<BigNumberish>,
    maxSlashingCut_: PromiseOrValue<BigNumberish>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  isDisputeCreated(
    disputeId: PromiseOrValue<BytesLike>,
    overrides?: CallOverrides
  ): Promise<boolean>;

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

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

  rejectDispute(
    disputeId: PromiseOrValue<BytesLike>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

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

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

  setDisputeDeposit(
    disputeDeposit: PromiseOrValue<BigNumberish>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  setDisputePeriod(
    disputePeriod: PromiseOrValue<BigNumberish>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  setFishermanRewardCut(
    fishermanRewardCut_: PromiseOrValue<BigNumberish>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  setMaxSlashingCut(
    maxSlashingCut_: PromiseOrValue<BigNumberish>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

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

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

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

  callStatic: {
    acceptDispute(
      disputeId: PromiseOrValue<BytesLike>,
      tokensSlash: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<void>;

    acceptDisputeConflict(
      disputeId: PromiseOrValue<BytesLike>,
      tokensSlash: PromiseOrValue<BigNumberish>,
      acceptDisputeInConflict: PromiseOrValue<boolean>,
      tokensSlashRelated: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<void>;

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

    areConflictingAttestations(
      attestation1: IAttestation.StateStruct,
      attestation2: IAttestation.StateStruct,
      overrides?: CallOverrides
    ): Promise<boolean>;

    cancelDispute(
      disputeId: PromiseOrValue<BytesLike>,
      overrides?: CallOverrides
    ): Promise<void>;

    createAndAcceptLegacyDispute(
      allocationId: PromiseOrValue<string>,
      fisherman: PromiseOrValue<string>,
      tokensSlash: PromiseOrValue<BigNumberish>,
      tokensRewards: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<string>;

    createIndexingDispute(
      allocationId: PromiseOrValue<string>,
      poi: PromiseOrValue<BytesLike>,
      blockNumber: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<string>;

    createQueryDispute(
      attestationData: PromiseOrValue<BytesLike>,
      overrides?: CallOverrides
    ): Promise<string>;

    createQueryDisputeConflict(
      attestationData1: PromiseOrValue<BytesLike>,
      attestationData2: PromiseOrValue<BytesLike>,
      overrides?: CallOverrides
    ): Promise<[string, string]>;

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

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

    disputes(
      disputeId: PromiseOrValue<BytesLike>,
      overrides?: CallOverrides
    ): Promise<IDisputeManager.DisputeStructOutput>;

    drawDispute(
      disputeId: PromiseOrValue<BytesLike>,
      overrides?: CallOverrides
    ): Promise<void>;

    encodeReceipt(
      receipt: IAttestation.ReceiptStruct,
      overrides?: CallOverrides
    ): Promise<string>;

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

    getAttestationIndexer(
      attestation: IAttestation.StateStruct,
      overrides?: CallOverrides
    ): Promise<string>;

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

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

    getStakeSnapshot(
      indexer: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    initialize(
      owner: PromiseOrValue<string>,
      arbitrator: PromiseOrValue<string>,
      disputePeriod: PromiseOrValue<BigNumberish>,
      disputeDeposit: PromiseOrValue<BigNumberish>,
      fishermanRewardCut_: PromiseOrValue<BigNumberish>,
      maxSlashingCut_: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<void>;

    isDisputeCreated(
      disputeId: PromiseOrValue<BytesLike>,
      overrides?: CallOverrides
    ): Promise<boolean>;

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

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

    rejectDispute(
      disputeId: PromiseOrValue<BytesLike>,
      overrides?: CallOverrides
    ): Promise<void>;

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

    setArbitrator(
      arbitrator: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<void>;

    setDisputeDeposit(
      disputeDeposit: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<void>;

    setDisputePeriod(
      disputePeriod: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<void>;

    setFishermanRewardCut(
      fishermanRewardCut_: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<void>;

    setMaxSlashingCut(
      maxSlashingCut_: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<void>;

    setSubgraphService(
      subgraphService: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<void>;

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

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

  filters: {
    "ArbitratorSet(address)"(
      arbitrator?: PromiseOrValue<string> | null
    ): ArbitratorSetEventFilter;
    ArbitratorSet(
      arbitrator?: PromiseOrValue<string> | null
    ): ArbitratorSetEventFilter;

    "DisputeAccepted(bytes32,address,address,uint256)"(
      disputeId?: PromiseOrValue<BytesLike> | null,
      indexer?: PromiseOrValue<string> | null,
      fisherman?: PromiseOrValue<string> | null,
      tokens?: null
    ): DisputeAcceptedEventFilter;
    DisputeAccepted(
      disputeId?: PromiseOrValue<BytesLike> | null,
      indexer?: PromiseOrValue<string> | null,
      fisherman?: PromiseOrValue<string> | null,
      tokens?: null
    ): DisputeAcceptedEventFilter;

    "DisputeCancelled(bytes32,address,address,uint256)"(
      disputeId?: PromiseOrValue<BytesLike> | null,
      indexer?: PromiseOrValue<string> | null,
      fisherman?: PromiseOrValue<string> | null,
      tokens?: null
    ): DisputeCancelledEventFilter;
    DisputeCancelled(
      disputeId?: PromiseOrValue<BytesLike> | null,
      indexer?: PromiseOrValue<string> | null,
      fisherman?: PromiseOrValue<string> | null,
      tokens?: null
    ): DisputeCancelledEventFilter;

    "DisputeDepositSet(uint256)"(
      disputeDeposit?: null
    ): DisputeDepositSetEventFilter;
    DisputeDepositSet(disputeDeposit?: null): DisputeDepositSetEventFilter;

    "DisputeDrawn(bytes32,address,address,uint256)"(
      disputeId?: PromiseOrValue<BytesLike> | null,
      indexer?: PromiseOrValue<string> | null,
      fisherman?: PromiseOrValue<string> | null,
      tokens?: null
    ): DisputeDrawnEventFilter;
    DisputeDrawn(
      disputeId?: PromiseOrValue<BytesLike> | null,
      indexer?: PromiseOrValue<string> | null,
      fisherman?: PromiseOrValue<string> | null,
      tokens?: null
    ): DisputeDrawnEventFilter;

    "DisputeLinked(bytes32,bytes32)"(
      disputeId1?: PromiseOrValue<BytesLike> | null,
      disputeId2?: PromiseOrValue<BytesLike> | null
    ): DisputeLinkedEventFilter;
    DisputeLinked(
      disputeId1?: PromiseOrValue<BytesLike> | null,
      disputeId2?: PromiseOrValue<BytesLike> | null
    ): DisputeLinkedEventFilter;

    "DisputePeriodSet(uint64)"(
      disputePeriod?: null
    ): DisputePeriodSetEventFilter;
    DisputePeriodSet(disputePeriod?: null): DisputePeriodSetEventFilter;

    "DisputeRejected(bytes32,address,address,uint256)"(
      disputeId?: PromiseOrValue<BytesLike> | null,
      indexer?: PromiseOrValue<string> | null,
      fisherman?: PromiseOrValue<string> | null,
      tokens?: null
    ): DisputeRejectedEventFilter;
    DisputeRejected(
      disputeId?: PromiseOrValue<BytesLike> | null,
      indexer?: PromiseOrValue<string> | null,
      fisherman?: PromiseOrValue<string> | null,
      tokens?: null
    ): DisputeRejectedEventFilter;

    "FishermanRewardCutSet(uint32)"(
      fishermanRewardCut?: null
    ): FishermanRewardCutSetEventFilter;
    FishermanRewardCutSet(
      fishermanRewardCut?: null
    ): FishermanRewardCutSetEventFilter;

    "IndexingDisputeCreated(bytes32,address,address,uint256,address,bytes32,uint256,uint256,uint256)"(
      disputeId?: PromiseOrValue<BytesLike> | null,
      indexer?: PromiseOrValue<string> | null,
      fisherman?: PromiseOrValue<string> | null,
      tokens?: null,
      allocationId?: null,
      poi?: null,
      blockNumber?: null,
      stakeSnapshot?: null,
      cancellableAt?: null
    ): IndexingDisputeCreatedEventFilter;
    IndexingDisputeCreated(
      disputeId?: PromiseOrValue<BytesLike> | null,
      indexer?: PromiseOrValue<string> | null,
      fisherman?: PromiseOrValue<string> | null,
      tokens?: null,
      allocationId?: null,
      poi?: null,
      blockNumber?: null,
      stakeSnapshot?: null,
      cancellableAt?: null
    ): IndexingDisputeCreatedEventFilter;

    "LegacyDisputeCreated(bytes32,address,address,address,uint256,uint256)"(
      disputeId?: PromiseOrValue<BytesLike> | null,
      indexer?: PromiseOrValue<string> | null,
      fisherman?: PromiseOrValue<string> | null,
      allocationId?: null,
      tokensSlash?: null,
      tokensRewards?: null
    ): LegacyDisputeCreatedEventFilter;
    LegacyDisputeCreated(
      disputeId?: PromiseOrValue<BytesLike> | null,
      indexer?: PromiseOrValue<string> | null,
      fisherman?: PromiseOrValue<string> | null,
      allocationId?: null,
      tokensSlash?: null,
      tokensRewards?: null
    ): LegacyDisputeCreatedEventFilter;

    "MaxSlashingCutSet(uint32)"(
      maxSlashingCut?: null
    ): MaxSlashingCutSetEventFilter;
    MaxSlashingCutSet(maxSlashingCut?: null): MaxSlashingCutSetEventFilter;

    "QueryDisputeCreated(bytes32,address,address,uint256,bytes32,bytes,uint256,uint256)"(
      disputeId?: PromiseOrValue<BytesLike> | null,
      indexer?: PromiseOrValue<string> | null,
      fisherman?: PromiseOrValue<string> | null,
      tokens?: null,
      subgraphDeploymentId?: null,
      attestation?: null,
      stakeSnapshot?: null,
      cancellableAt?: null
    ): QueryDisputeCreatedEventFilter;
    QueryDisputeCreated(
      disputeId?: PromiseOrValue<BytesLike> | null,
      indexer?: PromiseOrValue<string> | null,
      fisherman?: PromiseOrValue<string> | null,
      tokens?: null,
      subgraphDeploymentId?: null,
      attestation?: null,
      stakeSnapshot?: null,
      cancellableAt?: null
    ): QueryDisputeCreatedEventFilter;

    "SubgraphServiceSet(address)"(
      subgraphService?: PromiseOrValue<string> | null
    ): SubgraphServiceSetEventFilter;
    SubgraphServiceSet(
      subgraphService?: PromiseOrValue<string> | null
    ): SubgraphServiceSetEventFilter;
  };

  estimateGas: {
    acceptDispute(
      disputeId: PromiseOrValue<BytesLike>,
      tokensSlash: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    acceptDisputeConflict(
      disputeId: PromiseOrValue<BytesLike>,
      tokensSlash: PromiseOrValue<BigNumberish>,
      acceptDisputeInConflict: PromiseOrValue<boolean>,
      tokensSlashRelated: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

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

    areConflictingAttestations(
      attestation1: IAttestation.StateStruct,
      attestation2: IAttestation.StateStruct,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    cancelDispute(
      disputeId: PromiseOrValue<BytesLike>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    createAndAcceptLegacyDispute(
      allocationId: PromiseOrValue<string>,
      fisherman: PromiseOrValue<string>,
      tokensSlash: PromiseOrValue<BigNumberish>,
      tokensRewards: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    createIndexingDispute(
      allocationId: PromiseOrValue<string>,
      poi: PromiseOrValue<BytesLike>,
      blockNumber: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    createQueryDispute(
      attestationData: PromiseOrValue<BytesLike>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    createQueryDisputeConflict(
      attestationData1: PromiseOrValue<BytesLike>,
      attestationData2: PromiseOrValue<BytesLike>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

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

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

    disputes(
      disputeId: PromiseOrValue<BytesLike>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    drawDispute(
      disputeId: PromiseOrValue<BytesLike>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    encodeReceipt(
      receipt: IAttestation.ReceiptStruct,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

    getAttestationIndexer(
      attestation: IAttestation.StateStruct,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

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

    getStakeSnapshot(
      indexer: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    initialize(
      owner: PromiseOrValue<string>,
      arbitrator: PromiseOrValue<string>,
      disputePeriod: PromiseOrValue<BigNumberish>,
      disputeDeposit: PromiseOrValue<BigNumberish>,
      fishermanRewardCut_: PromiseOrValue<BigNumberish>,
      maxSlashingCut_: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    isDisputeCreated(
      disputeId: PromiseOrValue<BytesLike>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

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

    rejectDispute(
      disputeId: PromiseOrValue<BytesLike>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

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

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

    setDisputeDeposit(
      disputeDeposit: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    setDisputePeriod(
      disputePeriod: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    setFishermanRewardCut(
      fishermanRewardCut_: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    setMaxSlashingCut(
      maxSlashingCut_: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

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

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

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

  populateTransaction: {
    acceptDispute(
      disputeId: PromiseOrValue<BytesLike>,
      tokensSlash: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

    acceptDisputeConflict(
      disputeId: PromiseOrValue<BytesLike>,
      tokensSlash: PromiseOrValue<BigNumberish>,
      acceptDisputeInConflict: PromiseOrValue<boolean>,
      tokensSlashRelated: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

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

    areConflictingAttestations(
      attestation1: IAttestation.StateStruct,
      attestation2: IAttestation.StateStruct,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    cancelDispute(
      disputeId: PromiseOrValue<BytesLike>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

    createAndAcceptLegacyDispute(
      allocationId: PromiseOrValue<string>,
      fisherman: PromiseOrValue<string>,
      tokensSlash: PromiseOrValue<BigNumberish>,
      tokensRewards: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

    createIndexingDispute(
      allocationId: PromiseOrValue<string>,
      poi: PromiseOrValue<BytesLike>,
      blockNumber: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

    createQueryDispute(
      attestationData: PromiseOrValue<BytesLike>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

    createQueryDisputeConflict(
      attestationData1: PromiseOrValue<BytesLike>,
      attestationData2: PromiseOrValue<BytesLike>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

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

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

    disputes(
      disputeId: PromiseOrValue<BytesLike>,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    drawDispute(
      disputeId: PromiseOrValue<BytesLike>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

    encodeReceipt(
      receipt: IAttestation.ReceiptStruct,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

    getAttestationIndexer(
      attestation: IAttestation.StateStruct,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

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

    getStakeSnapshot(
      indexer: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    initialize(
      owner: PromiseOrValue<string>,
      arbitrator: PromiseOrValue<string>,
      disputePeriod: PromiseOrValue<BigNumberish>,
      disputeDeposit: PromiseOrValue<BigNumberish>,
      fishermanRewardCut_: PromiseOrValue<BigNumberish>,
      maxSlashingCut_: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

    isDisputeCreated(
      disputeId: PromiseOrValue<BytesLike>,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

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

    rejectDispute(
      disputeId: PromiseOrValue<BytesLike>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

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

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

    setDisputeDeposit(
      disputeDeposit: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

    setDisputePeriod(
      disputePeriod: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

    setFishermanRewardCut(
      fishermanRewardCut_: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

    setMaxSlashingCut(
      maxSlashingCut_: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

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

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

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