/* 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 CurrencyGovernance {
  export type VoteStruct = {
    proposal: PromiseOrValue<string>;
    score: PromiseOrValue<BigNumberish>;
  };

  export type VoteStructOutput = [string, BigNumber] & {
    proposal: string;
    score: BigNumber;
  };
}

export interface CurrencyGovernanceInterface extends utils.Interface {
  functions: {
    "GENERATION_START()": FunctionFragment;
    "IDEMPOTENT_INFLATION_MULTIPLIER()": FunctionFragment;
    "MAX_DATA()": FunctionFragment;
    "MIN_GENERATION_DURATION()": FunctionFragment;
    "PROPOSAL_TIME()": FunctionFragment;
    "REVEAL_TIME()": FunctionFragment;
    "VOTING_TIME()": FunctionFragment;
    "canImplementInterfaceForAddress(bytes32,address)": FunctionFragment;
    "clone()": FunctionFragment;
    "commit(bytes32)": FunctionFragment;
    "commitments(address)": FunctionFragment;
    "compute()": FunctionFragment;
    "currentStage()": FunctionFragment;
    "implementation()": FunctionFragment;
    "initialize(address)": FunctionFragment;
    "leader()": FunctionFragment;
    "pause()": FunctionFragment;
    "paused()": FunctionFragment;
    "pauser()": FunctionFragment;
    "policy()": FunctionFragment;
    "policyCommand(address,bytes)": FunctionFragment;
    "proposalEnds()": FunctionFragment;
    "proposals(address)": FunctionFragment;
    "propose(uint256,uint256,uint256,uint256,uint256,string)": FunctionFragment;
    "reveal(bytes32,(address,uint256)[])": FunctionFragment;
    "revealEnds()": FunctionFragment;
    "score(address)": FunctionFragment;
    "setExpectedInterfaceSet(address)": FunctionFragment;
    "setPauser(address)": FunctionFragment;
    "unpause()": FunctionFragment;
    "unpropose()": FunctionFragment;
    "updateStage()": FunctionFragment;
    "votingEnds()": FunctionFragment;
    "winner()": FunctionFragment;
  };

  getFunction(
    nameOrSignatureOrTopic:
      | "GENERATION_START"
      | "IDEMPOTENT_INFLATION_MULTIPLIER"
      | "MAX_DATA"
      | "MIN_GENERATION_DURATION"
      | "PROPOSAL_TIME"
      | "REVEAL_TIME"
      | "VOTING_TIME"
      | "canImplementInterfaceForAddress"
      | "clone"
      | "commit"
      | "commitments"
      | "compute"
      | "currentStage"
      | "implementation"
      | "initialize"
      | "leader"
      | "pause"
      | "paused"
      | "pauser"
      | "policy"
      | "policyCommand"
      | "proposalEnds"
      | "proposals"
      | "propose"
      | "reveal"
      | "revealEnds"
      | "score"
      | "setExpectedInterfaceSet"
      | "setPauser"
      | "unpause"
      | "unpropose"
      | "updateStage"
      | "votingEnds"
      | "winner"
  ): FunctionFragment;

  encodeFunctionData(
    functionFragment: "GENERATION_START",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "IDEMPOTENT_INFLATION_MULTIPLIER",
    values?: undefined
  ): string;
  encodeFunctionData(functionFragment: "MAX_DATA", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "MIN_GENERATION_DURATION",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "PROPOSAL_TIME",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "REVEAL_TIME",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "VOTING_TIME",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "canImplementInterfaceForAddress",
    values: [PromiseOrValue<BytesLike>, PromiseOrValue<string>]
  ): string;
  encodeFunctionData(functionFragment: "clone", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "commit",
    values: [PromiseOrValue<BytesLike>]
  ): string;
  encodeFunctionData(
    functionFragment: "commitments",
    values: [PromiseOrValue<string>]
  ): string;
  encodeFunctionData(functionFragment: "compute", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "currentStage",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "implementation",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "initialize",
    values: [PromiseOrValue<string>]
  ): string;
  encodeFunctionData(functionFragment: "leader", values?: undefined): string;
  encodeFunctionData(functionFragment: "pause", values?: undefined): string;
  encodeFunctionData(functionFragment: "paused", values?: undefined): string;
  encodeFunctionData(functionFragment: "pauser", values?: undefined): string;
  encodeFunctionData(functionFragment: "policy", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "policyCommand",
    values: [PromiseOrValue<string>, PromiseOrValue<BytesLike>]
  ): string;
  encodeFunctionData(
    functionFragment: "proposalEnds",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "proposals",
    values: [PromiseOrValue<string>]
  ): string;
  encodeFunctionData(
    functionFragment: "propose",
    values: [
      PromiseOrValue<BigNumberish>,
      PromiseOrValue<BigNumberish>,
      PromiseOrValue<BigNumberish>,
      PromiseOrValue<BigNumberish>,
      PromiseOrValue<BigNumberish>,
      PromiseOrValue<string>
    ]
  ): string;
  encodeFunctionData(
    functionFragment: "reveal",
    values: [PromiseOrValue<BytesLike>, CurrencyGovernance.VoteStruct[]]
  ): string;
  encodeFunctionData(
    functionFragment: "revealEnds",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "score",
    values: [PromiseOrValue<string>]
  ): string;
  encodeFunctionData(
    functionFragment: "setExpectedInterfaceSet",
    values: [PromiseOrValue<string>]
  ): string;
  encodeFunctionData(
    functionFragment: "setPauser",
    values: [PromiseOrValue<string>]
  ): string;
  encodeFunctionData(functionFragment: "unpause", values?: undefined): string;
  encodeFunctionData(functionFragment: "unpropose", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "updateStage",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "votingEnds",
    values?: undefined
  ): string;
  encodeFunctionData(functionFragment: "winner", values?: undefined): string;

  decodeFunctionResult(
    functionFragment: "GENERATION_START",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "IDEMPOTENT_INFLATION_MULTIPLIER",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "MAX_DATA", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "MIN_GENERATION_DURATION",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "PROPOSAL_TIME",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "REVEAL_TIME",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "VOTING_TIME",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "canImplementInterfaceForAddress",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "clone", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "commit", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "commitments",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "compute", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "currentStage",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "implementation",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "initialize", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "leader", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "pause", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "paused", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "pauser", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "policy", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "policyCommand",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "proposalEnds",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "proposals", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "propose", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "reveal", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "revealEnds", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "score", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "setExpectedInterfaceSet",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "setPauser", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "unpause", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "unpropose", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "updateStage",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "votingEnds", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "winner", data: BytesLike): Result;

  events: {
    "Paused(address)": EventFragment;
    "PauserAssignment(address)": EventFragment;
    "ProposalCreation(address,uint256,uint256,uint256,uint256,uint256,string)": EventFragment;
    "ProposalRetraction(address)": EventFragment;
    "RevealStart()": EventFragment;
    "Unpaused(address)": EventFragment;
    "VoteCast(address)": EventFragment;
    "VoteResult(address)": EventFragment;
    "VoteReveal(address,tuple[])": EventFragment;
    "VoteStart()": EventFragment;
  };

  getEvent(nameOrSignatureOrTopic: "Paused"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "PauserAssignment"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "ProposalCreation"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "ProposalRetraction"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "RevealStart"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "Unpaused"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "VoteCast"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "VoteResult"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "VoteReveal"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "VoteStart"): EventFragment;
}

export interface PausedEventObject {
  account: string;
}
export type PausedEvent = TypedEvent<[string], PausedEventObject>;

export type PausedEventFilter = TypedEventFilter<PausedEvent>;

export interface PauserAssignmentEventObject {
  pauser: string;
}
export type PauserAssignmentEvent = TypedEvent<
  [string],
  PauserAssignmentEventObject
>;

export type PauserAssignmentEventFilter =
  TypedEventFilter<PauserAssignmentEvent>;

export interface ProposalCreationEventObject {
  trusteeAddress: string;
  _numberOfRecipients: BigNumber;
  _randomInflationReward: BigNumber;
  _lockupDuration: BigNumber;
  _lockupInterest: BigNumber;
  _inflationMultiplier: BigNumber;
  _description: string;
}
export type ProposalCreationEvent = TypedEvent<
  [string, BigNumber, BigNumber, BigNumber, BigNumber, BigNumber, string],
  ProposalCreationEventObject
>;

export type ProposalCreationEventFilter =
  TypedEventFilter<ProposalCreationEvent>;

export interface ProposalRetractionEventObject {
  trustee: string;
}
export type ProposalRetractionEvent = TypedEvent<
  [string],
  ProposalRetractionEventObject
>;

export type ProposalRetractionEventFilter =
  TypedEventFilter<ProposalRetractionEvent>;

export interface RevealStartEventObject {}
export type RevealStartEvent = TypedEvent<[], RevealStartEventObject>;

export type RevealStartEventFilter = TypedEventFilter<RevealStartEvent>;

export interface UnpausedEventObject {
  account: string;
}
export type UnpausedEvent = TypedEvent<[string], UnpausedEventObject>;

export type UnpausedEventFilter = TypedEventFilter<UnpausedEvent>;

export interface VoteCastEventObject {
  trustee: string;
}
export type VoteCastEvent = TypedEvent<[string], VoteCastEventObject>;

export type VoteCastEventFilter = TypedEventFilter<VoteCastEvent>;

export interface VoteResultEventObject {
  winner: string;
}
export type VoteResultEvent = TypedEvent<[string], VoteResultEventObject>;

export type VoteResultEventFilter = TypedEventFilter<VoteResultEvent>;

export interface VoteRevealEventObject {
  voter: string;
  votes: CurrencyGovernance.VoteStructOutput[];
}
export type VoteRevealEvent = TypedEvent<
  [string, CurrencyGovernance.VoteStructOutput[]],
  VoteRevealEventObject
>;

export type VoteRevealEventFilter = TypedEventFilter<VoteRevealEvent>;

export interface VoteStartEventObject {}
export type VoteStartEvent = TypedEvent<[], VoteStartEventObject>;

export type VoteStartEventFilter = TypedEventFilter<VoteStartEvent>;

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

  interface: CurrencyGovernanceInterface;

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

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

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

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

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

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

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

    canImplementInterfaceForAddress(
      arg0: PromiseOrValue<BytesLike>,
      _addr: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<[string]>;

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

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

    commitments(
      arg0: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<[string]>;

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

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

    implementation(
      overrides?: CallOverrides
    ): Promise<[string] & { _impl: string }>;

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

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

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

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

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

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

    policyCommand(
      _delegate: PromiseOrValue<string>,
      _data: PromiseOrValue<BytesLike>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

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

    proposals(
      arg0: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<
      [BigNumber, BigNumber, BigNumber, BigNumber, BigNumber, string] & {
        numberOfRecipients: BigNumber;
        randomInflationReward: BigNumber;
        lockupDuration: BigNumber;
        lockupInterest: BigNumber;
        inflationMultiplier: BigNumber;
        description: string;
      }
    >;

    propose(
      _numberOfRecipients: PromiseOrValue<BigNumberish>,
      _randomInflationReward: PromiseOrValue<BigNumberish>,
      _lockupDuration: PromiseOrValue<BigNumberish>,
      _lockupInterest: PromiseOrValue<BigNumberish>,
      _inflationMultiplier: PromiseOrValue<BigNumberish>,
      _description: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    reveal(
      _seed: PromiseOrValue<BytesLike>,
      _votes: CurrencyGovernance.VoteStruct[],
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  canImplementInterfaceForAddress(
    arg0: PromiseOrValue<BytesLike>,
    _addr: PromiseOrValue<string>,
    overrides?: CallOverrides
  ): Promise<string>;

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

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

  commitments(
    arg0: PromiseOrValue<string>,
    overrides?: CallOverrides
  ): Promise<string>;

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

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

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

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

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

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

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

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

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

  policyCommand(
    _delegate: PromiseOrValue<string>,
    _data: PromiseOrValue<BytesLike>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

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

  proposals(
    arg0: PromiseOrValue<string>,
    overrides?: CallOverrides
  ): Promise<
    [BigNumber, BigNumber, BigNumber, BigNumber, BigNumber, string] & {
      numberOfRecipients: BigNumber;
      randomInflationReward: BigNumber;
      lockupDuration: BigNumber;
      lockupInterest: BigNumber;
      inflationMultiplier: BigNumber;
      description: string;
    }
  >;

  propose(
    _numberOfRecipients: PromiseOrValue<BigNumberish>,
    _randomInflationReward: PromiseOrValue<BigNumberish>,
    _lockupDuration: PromiseOrValue<BigNumberish>,
    _lockupInterest: PromiseOrValue<BigNumberish>,
    _inflationMultiplier: PromiseOrValue<BigNumberish>,
    _description: PromiseOrValue<string>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  reveal(
    _seed: PromiseOrValue<BytesLike>,
    _votes: CurrencyGovernance.VoteStruct[],
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    canImplementInterfaceForAddress(
      arg0: PromiseOrValue<BytesLike>,
      _addr: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<string>;

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

    commit(
      _commitment: PromiseOrValue<BytesLike>,
      overrides?: CallOverrides
    ): Promise<void>;

    commitments(
      arg0: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<string>;

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

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

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

    initialize(
      _self: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<void>;

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

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

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

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

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

    policyCommand(
      _delegate: PromiseOrValue<string>,
      _data: PromiseOrValue<BytesLike>,
      overrides?: CallOverrides
    ): Promise<void>;

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

    proposals(
      arg0: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<
      [BigNumber, BigNumber, BigNumber, BigNumber, BigNumber, string] & {
        numberOfRecipients: BigNumber;
        randomInflationReward: BigNumber;
        lockupDuration: BigNumber;
        lockupInterest: BigNumber;
        inflationMultiplier: BigNumber;
        description: string;
      }
    >;

    propose(
      _numberOfRecipients: PromiseOrValue<BigNumberish>,
      _randomInflationReward: PromiseOrValue<BigNumberish>,
      _lockupDuration: PromiseOrValue<BigNumberish>,
      _lockupInterest: PromiseOrValue<BigNumberish>,
      _inflationMultiplier: PromiseOrValue<BigNumberish>,
      _description: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<void>;

    reveal(
      _seed: PromiseOrValue<BytesLike>,
      _votes: CurrencyGovernance.VoteStruct[],
      overrides?: CallOverrides
    ): Promise<void>;

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

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

    setExpectedInterfaceSet(
      _addr: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<void>;

    setPauser(
      _pauser: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<void>;

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

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

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

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

    winner(overrides?: CallOverrides): Promise<string>;
  };

  filters: {
    "Paused(address)"(account?: null): PausedEventFilter;
    Paused(account?: null): PausedEventFilter;

    "PauserAssignment(address)"(
      pauser?: PromiseOrValue<string> | null
    ): PauserAssignmentEventFilter;
    PauserAssignment(
      pauser?: PromiseOrValue<string> | null
    ): PauserAssignmentEventFilter;

    "ProposalCreation(address,uint256,uint256,uint256,uint256,uint256,string)"(
      trusteeAddress?: PromiseOrValue<string> | null,
      _numberOfRecipients?: null,
      _randomInflationReward?: null,
      _lockupDuration?: null,
      _lockupInterest?: null,
      _inflationMultiplier?: null,
      _description?: null
    ): ProposalCreationEventFilter;
    ProposalCreation(
      trusteeAddress?: PromiseOrValue<string> | null,
      _numberOfRecipients?: null,
      _randomInflationReward?: null,
      _lockupDuration?: null,
      _lockupInterest?: null,
      _inflationMultiplier?: null,
      _description?: null
    ): ProposalCreationEventFilter;

    "ProposalRetraction(address)"(
      trustee?: PromiseOrValue<string> | null
    ): ProposalRetractionEventFilter;
    ProposalRetraction(
      trustee?: PromiseOrValue<string> | null
    ): ProposalRetractionEventFilter;

    "RevealStart()"(): RevealStartEventFilter;
    RevealStart(): RevealStartEventFilter;

    "Unpaused(address)"(account?: null): UnpausedEventFilter;
    Unpaused(account?: null): UnpausedEventFilter;

    "VoteCast(address)"(
      trustee?: PromiseOrValue<string> | null
    ): VoteCastEventFilter;
    VoteCast(trustee?: PromiseOrValue<string> | null): VoteCastEventFilter;

    "VoteResult(address)"(
      winner?: PromiseOrValue<string> | null
    ): VoteResultEventFilter;
    VoteResult(winner?: PromiseOrValue<string> | null): VoteResultEventFilter;

    "VoteReveal(address,tuple[])"(
      voter?: PromiseOrValue<string> | null,
      votes?: null
    ): VoteRevealEventFilter;
    VoteReveal(
      voter?: PromiseOrValue<string> | null,
      votes?: null
    ): VoteRevealEventFilter;

    "VoteStart()"(): VoteStartEventFilter;
    VoteStart(): VoteStartEventFilter;
  };

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

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

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

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

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

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

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

    canImplementInterfaceForAddress(
      arg0: PromiseOrValue<BytesLike>,
      _addr: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

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

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

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

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

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

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

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

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

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

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

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

    policyCommand(
      _delegate: PromiseOrValue<string>,
      _data: PromiseOrValue<BytesLike>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

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

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

    propose(
      _numberOfRecipients: PromiseOrValue<BigNumberish>,
      _randomInflationReward: PromiseOrValue<BigNumberish>,
      _lockupDuration: PromiseOrValue<BigNumberish>,
      _lockupInterest: PromiseOrValue<BigNumberish>,
      _inflationMultiplier: PromiseOrValue<BigNumberish>,
      _description: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    reveal(
      _seed: PromiseOrValue<BytesLike>,
      _votes: CurrencyGovernance.VoteStruct[],
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    canImplementInterfaceForAddress(
      arg0: PromiseOrValue<BytesLike>,
      _addr: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

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

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

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

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

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

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

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

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

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

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

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

    policyCommand(
      _delegate: PromiseOrValue<string>,
      _data: PromiseOrValue<BytesLike>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

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

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

    propose(
      _numberOfRecipients: PromiseOrValue<BigNumberish>,
      _randomInflationReward: PromiseOrValue<BigNumberish>,
      _lockupDuration: PromiseOrValue<BigNumberish>,
      _lockupInterest: PromiseOrValue<BigNumberish>,
      _inflationMultiplier: PromiseOrValue<BigNumberish>,
      _description: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

    reveal(
      _seed: PromiseOrValue<BytesLike>,
      _votes: CurrencyGovernance.VoteStruct[],
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

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

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

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

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

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

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

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

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

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