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

export type ProposalWithoutVotesStruct = {
  id: BigNumberish;
  creator: string;
  executor: string;
  targets: string[];
  values: BigNumberish[];
  signatures: string[];
  calldatas: BytesLike[];
  withDelegatecalls: boolean[];
  startBlock: BigNumberish;
  endBlock: BigNumberish;
  executionTime: BigNumberish;
  forVotes: BigNumberish;
  againstVotes: BigNumberish;
  executed: boolean;
  canceled: boolean;
  strategy: string;
  ipfsHash: BytesLike;
};

export type ProposalWithoutVotesStructOutput = [
  BigNumber,
  string,
  string,
  string[],
  BigNumber[],
  string[],
  string[],
  boolean[],
  BigNumber,
  BigNumber,
  BigNumber,
  BigNumber,
  BigNumber,
  boolean,
  boolean,
  string,
  string
] & {
  id: BigNumber;
  creator: string;
  executor: string;
  targets: string[];
  values: BigNumber[];
  signatures: string[];
  calldatas: string[];
  withDelegatecalls: boolean[];
  startBlock: BigNumber;
  endBlock: BigNumber;
  executionTime: BigNumber;
  forVotes: BigNumber;
  againstVotes: BigNumber;
  executed: boolean;
  canceled: boolean;
  strategy: string;
  ipfsHash: string;
};

export type VoteStruct = { support: boolean; votingPower: BigNumberish };

export type VoteStructOutput = [boolean, BigNumber] & {
  support: boolean;
  votingPower: BigNumber;
};

export interface AaveGovernanceV2Interface extends utils.Interface {
  functions: {
    "DOMAIN_TYPEHASH()": FunctionFragment;
    "NAME()": FunctionFragment;
    "VOTE_EMITTED_TYPEHASH()": FunctionFragment;
    "__abdicate()": FunctionFragment;
    "authorizeExecutors(address[])": FunctionFragment;
    "cancel(uint256)": FunctionFragment;
    "create(address,address[],uint256[],string[],bytes[],bool[],bytes32)": FunctionFragment;
    "execute(uint256)": FunctionFragment;
    "getGovernanceStrategy()": FunctionFragment;
    "getGuardian()": FunctionFragment;
    "getProposalById(uint256)": FunctionFragment;
    "getProposalState(uint256)": FunctionFragment;
    "getProposalsCount()": FunctionFragment;
    "getVoteOnProposal(uint256,address)": FunctionFragment;
    "getVotingDelay()": FunctionFragment;
    "isExecutorAuthorized(address)": FunctionFragment;
    "owner()": FunctionFragment;
    "queue(uint256)": FunctionFragment;
    "renounceOwnership()": FunctionFragment;
    "setGovernanceStrategy(address)": FunctionFragment;
    "setVotingDelay(uint256)": FunctionFragment;
    "submitVote(uint256,bool)": FunctionFragment;
    "submitVoteBySignature(uint256,bool,uint8,bytes32,bytes32)": FunctionFragment;
    "transferOwnership(address)": FunctionFragment;
    "unauthorizeExecutors(address[])": FunctionFragment;
  };

  encodeFunctionData(
    functionFragment: "DOMAIN_TYPEHASH",
    values?: undefined
  ): string;
  encodeFunctionData(functionFragment: "NAME", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "VOTE_EMITTED_TYPEHASH",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "__abdicate",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "authorizeExecutors",
    values: [string[]]
  ): string;
  encodeFunctionData(
    functionFragment: "cancel",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "create",
    values: [
      string,
      string[],
      BigNumberish[],
      string[],
      BytesLike[],
      boolean[],
      BytesLike
    ]
  ): string;
  encodeFunctionData(
    functionFragment: "execute",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "getGovernanceStrategy",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "getGuardian",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "getProposalById",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "getProposalState",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "getProposalsCount",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "getVoteOnProposal",
    values: [BigNumberish, string]
  ): string;
  encodeFunctionData(
    functionFragment: "getVotingDelay",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "isExecutorAuthorized",
    values: [string]
  ): string;
  encodeFunctionData(functionFragment: "owner", values?: undefined): string;
  encodeFunctionData(functionFragment: "queue", values: [BigNumberish]): string;
  encodeFunctionData(
    functionFragment: "renounceOwnership",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "setGovernanceStrategy",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "setVotingDelay",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "submitVote",
    values: [BigNumberish, boolean]
  ): string;
  encodeFunctionData(
    functionFragment: "submitVoteBySignature",
    values: [BigNumberish, boolean, BigNumberish, BytesLike, BytesLike]
  ): string;
  encodeFunctionData(
    functionFragment: "transferOwnership",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "unauthorizeExecutors",
    values: [string[]]
  ): string;

  decodeFunctionResult(
    functionFragment: "DOMAIN_TYPEHASH",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "NAME", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "VOTE_EMITTED_TYPEHASH",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "__abdicate", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "authorizeExecutors",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "cancel", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "create", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "execute", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "getGovernanceStrategy",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getGuardian",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getProposalById",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getProposalState",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getProposalsCount",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getVoteOnProposal",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getVotingDelay",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "isExecutorAuthorized",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "owner", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "queue", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "renounceOwnership",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setGovernanceStrategy",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setVotingDelay",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "submitVote", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "submitVoteBySignature",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "transferOwnership",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "unauthorizeExecutors",
    data: BytesLike
  ): Result;

  events: {
    "ExecutorAuthorized(address)": EventFragment;
    "ExecutorUnauthorized(address)": EventFragment;
    "GovernanceStrategyChanged(address,address)": EventFragment;
    "OwnershipTransferred(address,address)": EventFragment;
    "ProposalCanceled(uint256)": EventFragment;
    "ProposalCreated(uint256,address,address,address[],uint256[],string[],bytes[],bool[],uint256,uint256,address,bytes32)": EventFragment;
    "ProposalExecuted(uint256,address)": EventFragment;
    "ProposalQueued(uint256,uint256,address)": EventFragment;
    "VoteEmitted(uint256,address,bool,uint256)": EventFragment;
    "VotingDelayChanged(uint256,address)": EventFragment;
  };

  getEvent(nameOrSignatureOrTopic: "ExecutorAuthorized"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "ExecutorUnauthorized"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "GovernanceStrategyChanged"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "OwnershipTransferred"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "ProposalCanceled"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "ProposalCreated"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "ProposalExecuted"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "ProposalQueued"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "VoteEmitted"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "VotingDelayChanged"): EventFragment;
}

export type ExecutorAuthorizedEvent = TypedEvent<
  [string],
  { executor: string }
>;

export type ExecutorAuthorizedEventFilter = TypedEventFilter<ExecutorAuthorizedEvent>;

export type ExecutorUnauthorizedEvent = TypedEvent<
  [string],
  { executor: string }
>;

export type ExecutorUnauthorizedEventFilter = TypedEventFilter<ExecutorUnauthorizedEvent>;

export type GovernanceStrategyChangedEvent = TypedEvent<
  [string, string],
  { newStrategy: string; initiatorChange: string }
>;

export type GovernanceStrategyChangedEventFilter = TypedEventFilter<GovernanceStrategyChangedEvent>;

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

export type OwnershipTransferredEventFilter = TypedEventFilter<OwnershipTransferredEvent>;

export type ProposalCanceledEvent = TypedEvent<[BigNumber], { id: BigNumber }>;

export type ProposalCanceledEventFilter = TypedEventFilter<ProposalCanceledEvent>;

export type ProposalCreatedEvent = TypedEvent<
  [
    BigNumber,
    string,
    string,
    string[],
    BigNumber[],
    string[],
    string[],
    boolean[],
    BigNumber,
    BigNumber,
    string,
    string
  ],
  {
    id: BigNumber;
    creator: string;
    executor: string;
    targets: string[];
    values: BigNumber[];
    signatures: string[];
    calldatas: string[];
    withDelegatecalls: boolean[];
    startBlock: BigNumber;
    endBlock: BigNumber;
    strategy: string;
    ipfsHash: string;
  }
>;

export type ProposalCreatedEventFilter = TypedEventFilter<ProposalCreatedEvent>;

export type ProposalExecutedEvent = TypedEvent<
  [BigNumber, string],
  { id: BigNumber; initiatorExecution: string }
>;

export type ProposalExecutedEventFilter = TypedEventFilter<ProposalExecutedEvent>;

export type ProposalQueuedEvent = TypedEvent<
  [BigNumber, BigNumber, string],
  { id: BigNumber; executionTime: BigNumber; initiatorQueueing: string }
>;

export type ProposalQueuedEventFilter = TypedEventFilter<ProposalQueuedEvent>;

export type VoteEmittedEvent = TypedEvent<
  [BigNumber, string, boolean, BigNumber],
  { id: BigNumber; voter: string; support: boolean; votingPower: BigNumber }
>;

export type VoteEmittedEventFilter = TypedEventFilter<VoteEmittedEvent>;

export type VotingDelayChangedEvent = TypedEvent<
  [BigNumber, string],
  { newVotingDelay: BigNumber; initiatorChange: string }
>;

export type VotingDelayChangedEventFilter = TypedEventFilter<VotingDelayChangedEvent>;

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

  interface: AaveGovernanceV2Interface;

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

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

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

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

    authorizeExecutors(
      executors: string[],
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

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

    create(
      executor: string,
      targets: string[],
      values: BigNumberish[],
      signatures: string[],
      calldatas: BytesLike[],
      withDelegatecalls: boolean[],
      ipfsHash: BytesLike,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    execute(
      proposalId: BigNumberish,
      overrides?: PayableOverrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

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

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

    getProposalById(
      proposalId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[ProposalWithoutVotesStructOutput]>;

    getProposalState(
      proposalId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[number]>;

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

    getVoteOnProposal(
      proposalId: BigNumberish,
      voter: string,
      overrides?: CallOverrides
    ): Promise<[VoteStructOutput]>;

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

    isExecutorAuthorized(
      executor: string,
      overrides?: CallOverrides
    ): Promise<[boolean]>;

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

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

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

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

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

    submitVote(
      proposalId: BigNumberish,
      support: boolean,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    submitVoteBySignature(
      proposalId: BigNumberish,
      support: boolean,
      v: BigNumberish,
      r: BytesLike,
      s: BytesLike,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

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

    unauthorizeExecutors(
      executors: string[],
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;
  };

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

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

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

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

  authorizeExecutors(
    executors: string[],
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

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

  create(
    executor: string,
    targets: string[],
    values: BigNumberish[],
    signatures: string[],
    calldatas: BytesLike[],
    withDelegatecalls: boolean[],
    ipfsHash: BytesLike,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  execute(
    proposalId: BigNumberish,
    overrides?: PayableOverrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

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

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

  getProposalById(
    proposalId: BigNumberish,
    overrides?: CallOverrides
  ): Promise<ProposalWithoutVotesStructOutput>;

  getProposalState(
    proposalId: BigNumberish,
    overrides?: CallOverrides
  ): Promise<number>;

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

  getVoteOnProposal(
    proposalId: BigNumberish,
    voter: string,
    overrides?: CallOverrides
  ): Promise<VoteStructOutput>;

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

  isExecutorAuthorized(
    executor: string,
    overrides?: CallOverrides
  ): Promise<boolean>;

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

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

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

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

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

  submitVote(
    proposalId: BigNumberish,
    support: boolean,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  submitVoteBySignature(
    proposalId: BigNumberish,
    support: boolean,
    v: BigNumberish,
    r: BytesLike,
    s: BytesLike,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

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

  unauthorizeExecutors(
    executors: string[],
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  callStatic: {
    DOMAIN_TYPEHASH(overrides?: CallOverrides): Promise<string>;

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

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

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

    authorizeExecutors(
      executors: string[],
      overrides?: CallOverrides
    ): Promise<void>;

    cancel(proposalId: BigNumberish, overrides?: CallOverrides): Promise<void>;

    create(
      executor: string,
      targets: string[],
      values: BigNumberish[],
      signatures: string[],
      calldatas: BytesLike[],
      withDelegatecalls: boolean[],
      ipfsHash: BytesLike,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    execute(proposalId: BigNumberish, overrides?: CallOverrides): Promise<void>;

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

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

    getProposalById(
      proposalId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<ProposalWithoutVotesStructOutput>;

    getProposalState(
      proposalId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<number>;

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

    getVoteOnProposal(
      proposalId: BigNumberish,
      voter: string,
      overrides?: CallOverrides
    ): Promise<VoteStructOutput>;

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

    isExecutorAuthorized(
      executor: string,
      overrides?: CallOverrides
    ): Promise<boolean>;

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

    queue(proposalId: BigNumberish, overrides?: CallOverrides): Promise<void>;

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

    setGovernanceStrategy(
      governanceStrategy: string,
      overrides?: CallOverrides
    ): Promise<void>;

    setVotingDelay(
      votingDelay: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    submitVote(
      proposalId: BigNumberish,
      support: boolean,
      overrides?: CallOverrides
    ): Promise<void>;

    submitVoteBySignature(
      proposalId: BigNumberish,
      support: boolean,
      v: BigNumberish,
      r: BytesLike,
      s: BytesLike,
      overrides?: CallOverrides
    ): Promise<void>;

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

    unauthorizeExecutors(
      executors: string[],
      overrides?: CallOverrides
    ): Promise<void>;
  };

  filters: {
    "ExecutorAuthorized(address)"(
      executor?: null
    ): ExecutorAuthorizedEventFilter;
    ExecutorAuthorized(executor?: null): ExecutorAuthorizedEventFilter;

    "ExecutorUnauthorized(address)"(
      executor?: null
    ): ExecutorUnauthorizedEventFilter;
    ExecutorUnauthorized(executor?: null): ExecutorUnauthorizedEventFilter;

    "GovernanceStrategyChanged(address,address)"(
      newStrategy?: string | null,
      initiatorChange?: string | null
    ): GovernanceStrategyChangedEventFilter;
    GovernanceStrategyChanged(
      newStrategy?: string | null,
      initiatorChange?: string | null
    ): GovernanceStrategyChangedEventFilter;

    "OwnershipTransferred(address,address)"(
      previousOwner?: string | null,
      newOwner?: string | null
    ): OwnershipTransferredEventFilter;
    OwnershipTransferred(
      previousOwner?: string | null,
      newOwner?: string | null
    ): OwnershipTransferredEventFilter;

    "ProposalCanceled(uint256)"(id?: null): ProposalCanceledEventFilter;
    ProposalCanceled(id?: null): ProposalCanceledEventFilter;

    "ProposalCreated(uint256,address,address,address[],uint256[],string[],bytes[],bool[],uint256,uint256,address,bytes32)"(
      id?: null,
      creator?: string | null,
      executor?: string | null,
      targets?: null,
      values?: null,
      signatures?: null,
      calldatas?: null,
      withDelegatecalls?: null,
      startBlock?: null,
      endBlock?: null,
      strategy?: null,
      ipfsHash?: null
    ): ProposalCreatedEventFilter;
    ProposalCreated(
      id?: null,
      creator?: string | null,
      executor?: string | null,
      targets?: null,
      values?: null,
      signatures?: null,
      calldatas?: null,
      withDelegatecalls?: null,
      startBlock?: null,
      endBlock?: null,
      strategy?: null,
      ipfsHash?: null
    ): ProposalCreatedEventFilter;

    "ProposalExecuted(uint256,address)"(
      id?: null,
      initiatorExecution?: string | null
    ): ProposalExecutedEventFilter;
    ProposalExecuted(
      id?: null,
      initiatorExecution?: string | null
    ): ProposalExecutedEventFilter;

    "ProposalQueued(uint256,uint256,address)"(
      id?: null,
      executionTime?: null,
      initiatorQueueing?: string | null
    ): ProposalQueuedEventFilter;
    ProposalQueued(
      id?: null,
      executionTime?: null,
      initiatorQueueing?: string | null
    ): ProposalQueuedEventFilter;

    "VoteEmitted(uint256,address,bool,uint256)"(
      id?: null,
      voter?: string | null,
      support?: null,
      votingPower?: null
    ): VoteEmittedEventFilter;
    VoteEmitted(
      id?: null,
      voter?: string | null,
      support?: null,
      votingPower?: null
    ): VoteEmittedEventFilter;

    "VotingDelayChanged(uint256,address)"(
      newVotingDelay?: null,
      initiatorChange?: string | null
    ): VotingDelayChangedEventFilter;
    VotingDelayChanged(
      newVotingDelay?: null,
      initiatorChange?: string | null
    ): VotingDelayChangedEventFilter;
  };

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

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

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

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

    authorizeExecutors(
      executors: string[],
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

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

    create(
      executor: string,
      targets: string[],
      values: BigNumberish[],
      signatures: string[],
      calldatas: BytesLike[],
      withDelegatecalls: boolean[],
      ipfsHash: BytesLike,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    execute(
      proposalId: BigNumberish,
      overrides?: PayableOverrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

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

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

    getProposalById(
      proposalId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    getProposalState(
      proposalId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

    getVoteOnProposal(
      proposalId: BigNumberish,
      voter: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

    isExecutorAuthorized(
      executor: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

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

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

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

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

    submitVote(
      proposalId: BigNumberish,
      support: boolean,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    submitVoteBySignature(
      proposalId: BigNumberish,
      support: boolean,
      v: BigNumberish,
      r: BytesLike,
      s: BytesLike,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

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

    unauthorizeExecutors(
      executors: string[],
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;
  };

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

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

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

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

    authorizeExecutors(
      executors: string[],
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

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

    create(
      executor: string,
      targets: string[],
      values: BigNumberish[],
      signatures: string[],
      calldatas: BytesLike[],
      withDelegatecalls: boolean[],
      ipfsHash: BytesLike,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    execute(
      proposalId: BigNumberish,
      overrides?: PayableOverrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

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

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

    getProposalById(
      proposalId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    getProposalState(
      proposalId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

    getVoteOnProposal(
      proposalId: BigNumberish,
      voter: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

    isExecutorAuthorized(
      executor: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

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

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

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

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

    submitVote(
      proposalId: BigNumberish,
      support: boolean,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    submitVoteBySignature(
      proposalId: BigNumberish,
      support: boolean,
      v: BigNumberish,
      r: BytesLike,
      s: BytesLike,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

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

    unauthorizeExecutors(
      executors: string[],
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;
  };
}