/* 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 interface PoodleTrustedNodesInterface extends utils.Interface {
  functions: {
    "GENERATIONS_PER_YEAR()": FunctionFragment;
    "GENERATION_START()": FunctionFragment;
    "MIN_GENERATION_DURATION()": FunctionFragment;
    "annualUpdate()": FunctionFragment;
    "canImplementInterfaceForAddress(bytes32,address)": FunctionFragment;
    "clone()": FunctionFragment;
    "cohort()": FunctionFragment;
    "distrust(address)": FunctionFragment;
    "fullyVestedRewards(address)": FunctionFragment;
    "getTrustedNodesFromCohort(uint256)": FunctionFragment;
    "hoard()": FunctionFragment;
    "implementation()": FunctionFragment;
    "initialize(address)": FunctionFragment;
    "isTrusted(address)": FunctionFragment;
    "lastYearVotingRecord(address)": FunctionFragment;
    "newCohort(address[])": FunctionFragment;
    "numTrustees()": FunctionFragment;
    "policy()": FunctionFragment;
    "policyCommand(address,bytes)": FunctionFragment;
    "provePoodles()": FunctionFragment;
    "recordVote(address)": FunctionFragment;
    "redeemVoteRewards()": FunctionFragment;
    "setExpectedInterfaceSet(address)": FunctionFragment;
    "trust(address)": FunctionFragment;
    "unallocatedRewardsCount()": FunctionFragment;
    "voteReward()": FunctionFragment;
    "votingRecord(address)": FunctionFragment;
    "yearEnd()": FunctionFragment;
    "yearStartGen()": FunctionFragment;
  };

  getFunction(
    nameOrSignatureOrTopic:
      | "GENERATIONS_PER_YEAR"
      | "GENERATION_START"
      | "MIN_GENERATION_DURATION"
      | "annualUpdate"
      | "canImplementInterfaceForAddress"
      | "clone"
      | "cohort"
      | "distrust"
      | "fullyVestedRewards"
      | "getTrustedNodesFromCohort"
      | "hoard"
      | "implementation"
      | "initialize"
      | "isTrusted"
      | "lastYearVotingRecord"
      | "newCohort"
      | "numTrustees"
      | "policy"
      | "policyCommand"
      | "provePoodles"
      | "recordVote"
      | "redeemVoteRewards"
      | "setExpectedInterfaceSet"
      | "trust"
      | "unallocatedRewardsCount"
      | "voteReward"
      | "votingRecord"
      | "yearEnd"
      | "yearStartGen"
  ): FunctionFragment;

  encodeFunctionData(
    functionFragment: "GENERATIONS_PER_YEAR",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "GENERATION_START",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "MIN_GENERATION_DURATION",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "annualUpdate",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "canImplementInterfaceForAddress",
    values: [PromiseOrValue<BytesLike>, PromiseOrValue<string>]
  ): string;
  encodeFunctionData(functionFragment: "clone", values?: undefined): string;
  encodeFunctionData(functionFragment: "cohort", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "distrust",
    values: [PromiseOrValue<string>]
  ): string;
  encodeFunctionData(
    functionFragment: "fullyVestedRewards",
    values: [PromiseOrValue<string>]
  ): string;
  encodeFunctionData(
    functionFragment: "getTrustedNodesFromCohort",
    values: [PromiseOrValue<BigNumberish>]
  ): string;
  encodeFunctionData(functionFragment: "hoard", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "implementation",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "initialize",
    values: [PromiseOrValue<string>]
  ): string;
  encodeFunctionData(
    functionFragment: "isTrusted",
    values: [PromiseOrValue<string>]
  ): string;
  encodeFunctionData(
    functionFragment: "lastYearVotingRecord",
    values: [PromiseOrValue<string>]
  ): string;
  encodeFunctionData(
    functionFragment: "newCohort",
    values: [PromiseOrValue<string>[]]
  ): string;
  encodeFunctionData(
    functionFragment: "numTrustees",
    values?: undefined
  ): string;
  encodeFunctionData(functionFragment: "policy", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "policyCommand",
    values: [PromiseOrValue<string>, PromiseOrValue<BytesLike>]
  ): string;
  encodeFunctionData(
    functionFragment: "provePoodles",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "recordVote",
    values: [PromiseOrValue<string>]
  ): string;
  encodeFunctionData(
    functionFragment: "redeemVoteRewards",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "setExpectedInterfaceSet",
    values: [PromiseOrValue<string>]
  ): string;
  encodeFunctionData(
    functionFragment: "trust",
    values: [PromiseOrValue<string>]
  ): string;
  encodeFunctionData(
    functionFragment: "unallocatedRewardsCount",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "voteReward",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "votingRecord",
    values: [PromiseOrValue<string>]
  ): string;
  encodeFunctionData(functionFragment: "yearEnd", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "yearStartGen",
    values?: undefined
  ): string;

  decodeFunctionResult(
    functionFragment: "GENERATIONS_PER_YEAR",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "GENERATION_START",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "MIN_GENERATION_DURATION",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "annualUpdate",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "canImplementInterfaceForAddress",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "clone", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "cohort", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "distrust", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "fullyVestedRewards",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getTrustedNodesFromCohort",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "hoard", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "implementation",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "initialize", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "isTrusted", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "lastYearVotingRecord",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "newCohort", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "numTrustees",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "policy", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "policyCommand",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "provePoodles",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "recordVote", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "redeemVoteRewards",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setExpectedInterfaceSet",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "trust", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "unallocatedRewardsCount",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "voteReward", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "votingRecord",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "yearEnd", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "yearStartGen",
    data: BytesLike
  ): Result;

  events: {
    "FundingRequest(uint256)": EventFragment;
    "RewardsTrackingUpdate(uint256,uint256)": EventFragment;
    "TrustedNodeAddition(address,uint256)": EventFragment;
    "TrustedNodeRemoval(address,uint256)": EventFragment;
    "VotingRewardRedemption(address,uint256)": EventFragment;
  };

  getEvent(nameOrSignatureOrTopic: "FundingRequest"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "RewardsTrackingUpdate"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "TrustedNodeAddition"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "TrustedNodeRemoval"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "VotingRewardRedemption"): EventFragment;
}

export interface FundingRequestEventObject {
  amount: BigNumber;
}
export type FundingRequestEvent = TypedEvent<
  [BigNumber],
  FundingRequestEventObject
>;

export type FundingRequestEventFilter = TypedEventFilter<FundingRequestEvent>;

export interface RewardsTrackingUpdateEventObject {
  nextUpdateTimestamp: BigNumber;
  newRewardsCount: BigNumber;
}
export type RewardsTrackingUpdateEvent = TypedEvent<
  [BigNumber, BigNumber],
  RewardsTrackingUpdateEventObject
>;

export type RewardsTrackingUpdateEventFilter =
  TypedEventFilter<RewardsTrackingUpdateEvent>;

export interface TrustedNodeAdditionEventObject {
  node: string;
  cohort: BigNumber;
}
export type TrustedNodeAdditionEvent = TypedEvent<
  [string, BigNumber],
  TrustedNodeAdditionEventObject
>;

export type TrustedNodeAdditionEventFilter =
  TypedEventFilter<TrustedNodeAdditionEvent>;

export interface TrustedNodeRemovalEventObject {
  node: string;
  cohort: BigNumber;
}
export type TrustedNodeRemovalEvent = TypedEvent<
  [string, BigNumber],
  TrustedNodeRemovalEventObject
>;

export type TrustedNodeRemovalEventFilter =
  TypedEventFilter<TrustedNodeRemovalEvent>;

export interface VotingRewardRedemptionEventObject {
  recipient: string;
  amount: BigNumber;
}
export type VotingRewardRedemptionEvent = TypedEvent<
  [string, BigNumber],
  VotingRewardRedemptionEventObject
>;

export type VotingRewardRedemptionEventFilter =
  TypedEventFilter<VotingRewardRedemptionEvent>;

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

  interface: PoodleTrustedNodesInterface;

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

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

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

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

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

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

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

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

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

    getTrustedNodesFromCohort(
      _cohort: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<[string[]]>;

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

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

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

    isTrusted(
      _node: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<[boolean]>;

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

    newCohort(
      _newCohort: PromiseOrValue<string>[],
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  getTrustedNodesFromCohort(
    _cohort: PromiseOrValue<BigNumberish>,
    overrides?: CallOverrides
  ): Promise<string[]>;

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

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

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

  isTrusted(
    _node: PromiseOrValue<string>,
    overrides?: CallOverrides
  ): Promise<boolean>;

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

  newCohort(
    _newCohort: PromiseOrValue<string>[],
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    distrust(
      _node: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<void>;

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

    getTrustedNodesFromCohort(
      _cohort: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<string[]>;

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

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

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

    isTrusted(
      _node: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<boolean>;

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

    newCohort(
      _newCohort: PromiseOrValue<string>[],
      overrides?: CallOverrides
    ): Promise<void>;

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

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

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

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

    recordVote(
      _who: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<void>;

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

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

    trust(
      _node: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<void>;

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

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

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

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

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

  filters: {
    "FundingRequest(uint256)"(amount?: null): FundingRequestEventFilter;
    FundingRequest(amount?: null): FundingRequestEventFilter;

    "RewardsTrackingUpdate(uint256,uint256)"(
      nextUpdateTimestamp?: null,
      newRewardsCount?: null
    ): RewardsTrackingUpdateEventFilter;
    RewardsTrackingUpdate(
      nextUpdateTimestamp?: null,
      newRewardsCount?: null
    ): RewardsTrackingUpdateEventFilter;

    "TrustedNodeAddition(address,uint256)"(
      node?: PromiseOrValue<string> | null,
      cohort?: null
    ): TrustedNodeAdditionEventFilter;
    TrustedNodeAddition(
      node?: PromiseOrValue<string> | null,
      cohort?: null
    ): TrustedNodeAdditionEventFilter;

    "TrustedNodeRemoval(address,uint256)"(
      node?: PromiseOrValue<string> | null,
      cohort?: null
    ): TrustedNodeRemovalEventFilter;
    TrustedNodeRemoval(
      node?: PromiseOrValue<string> | null,
      cohort?: null
    ): TrustedNodeRemovalEventFilter;

    "VotingRewardRedemption(address,uint256)"(
      recipient?: PromiseOrValue<string> | null,
      amount?: null
    ): VotingRewardRedemptionEventFilter;
    VotingRewardRedemption(
      recipient?: PromiseOrValue<string> | null,
      amount?: null
    ): VotingRewardRedemptionEventFilter;
  };

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

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

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

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

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

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

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

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

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

    getTrustedNodesFromCohort(
      _cohort: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

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

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

    isTrusted(
      _node: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

    newCohort(
      _newCohort: PromiseOrValue<string>[],
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    getTrustedNodesFromCohort(
      _cohort: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

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

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

    isTrusted(
      _node: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

    newCohort(
      _newCohort: PromiseOrValue<string>[],
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

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

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

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

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

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

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

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

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

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

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

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

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

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