/* Autogenerated file. Do not edit manually. */
/* tslint:disable */
/* eslint-disable */

import {
  ethers,
  EventFilter,
  Signer,
  BigNumber,
  BigNumberish,
  PopulatedTransaction,
  Contract,
  ContractTransaction,
  Overrides,
  PayableOverrides,
  CallOverrides,
} from "ethers";
import { BytesLike } from "@ethersproject/bytes";
import { Listener, Provider } from "@ethersproject/providers";
import { FunctionFragment, EventFragment, Result } from "@ethersproject/abi";
import { TypedEventFilter, TypedEvent, TypedListener } from "./commons";

interface IAaveGovernanceV2Interface extends ethers.utils.Interface {
  functions: {
    "__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;
    "queue(uint256)": FunctionFragment;
    "setGovernanceStrategy(address)": FunctionFragment;
    "setVotingDelay(uint256)": FunctionFragment;
    "submitVote(uint256,bool)": FunctionFragment;
    "submitVoteBySignature(uint256,bool,uint8,bytes32,bytes32)": FunctionFragment;
    "unauthorizeExecutors(address[])": FunctionFragment;
  };

  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: "queue", values: [BigNumberish]): 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: "unauthorizeExecutors",
    values: [string[]]
  ): string;

  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: "queue", 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: "unauthorizeExecutors",
    data: BytesLike
  ): Result;

  events: {
    "ExecutorAuthorized(address)": EventFragment;
    "ExecutorUnauthorized(address)": EventFragment;
    "GovernanceStrategyChanged(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: "ProposalCanceled"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "ProposalCreated"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "ProposalExecuted"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "ProposalQueued"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "VoteEmitted"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "VotingDelayChanged"): EventFragment;
}

export class IAaveGovernanceV2 extends Contract {
  connect(signerOrProvider: Signer | Provider | string): this;
  attach(addressOrName: string): this;
  deployed(): Promise<this>;

  listeners<EventArgsArray extends Array<any>, EventArgsObject>(
    eventFilter?: TypedEventFilter<EventArgsArray, EventArgsObject>
  ): Array<TypedListener<EventArgsArray, EventArgsObject>>;
  off<EventArgsArray extends Array<any>, EventArgsObject>(
    eventFilter: TypedEventFilter<EventArgsArray, EventArgsObject>,
    listener: TypedListener<EventArgsArray, EventArgsObject>
  ): this;
  on<EventArgsArray extends Array<any>, EventArgsObject>(
    eventFilter: TypedEventFilter<EventArgsArray, EventArgsObject>,
    listener: TypedListener<EventArgsArray, EventArgsObject>
  ): this;
  once<EventArgsArray extends Array<any>, EventArgsObject>(
    eventFilter: TypedEventFilter<EventArgsArray, EventArgsObject>,
    listener: TypedListener<EventArgsArray, EventArgsObject>
  ): this;
  removeListener<EventArgsArray extends Array<any>, EventArgsObject>(
    eventFilter: TypedEventFilter<EventArgsArray, EventArgsObject>,
    listener: TypedListener<EventArgsArray, EventArgsObject>
  ): this;
  removeAllListeners<EventArgsArray extends Array<any>, EventArgsObject>(
    eventFilter: TypedEventFilter<EventArgsArray, EventArgsObject>
  ): this;

  listeners(eventName?: string): Array<Listener>;
  off(eventName: string, listener: Listener): this;
  on(eventName: string, listener: Listener): this;
  once(eventName: string, listener: Listener): this;
  removeListener(eventName: string, listener: Listener): this;
  removeAllListeners(eventName?: string): this;

  queryFilter<EventArgsArray extends Array<any>, EventArgsObject>(
    event: TypedEventFilter<EventArgsArray, EventArgsObject>,
    fromBlockOrBlockhash?: string | number | undefined,
    toBlock?: string | number | undefined
  ): Promise<Array<TypedEvent<EventArgsArray & EventArgsObject>>>;

  interface: IAaveGovernanceV2Interface;

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

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

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

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

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

    "cancel(uint256)"(
      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>;

    "create(address,address[],uint256[],string[],bytes[],bool[],bytes32)"(
      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>;

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

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

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

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

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

    getProposalById(
      proposalId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<
      [
        [
          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;
        }
      ]
    >;

    "getProposalById(uint256)"(
      proposalId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<
      [
        [
          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;
        }
      ]
    >;

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

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

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

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

    getVoteOnProposal(
      proposalId: BigNumberish,
      voter: string,
      overrides?: CallOverrides
    ): Promise<
      [[boolean, BigNumber] & { support: boolean; votingPower: BigNumber }]
    >;

    "getVoteOnProposal(uint256,address)"(
      proposalId: BigNumberish,
      voter: string,
      overrides?: CallOverrides
    ): Promise<
      [[boolean, BigNumber] & { support: boolean; votingPower: BigNumber }]
    >;

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

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

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

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

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

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

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

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

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

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

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

    "submitVote(uint256,bool)"(
      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>;

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

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

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

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

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

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

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

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

  "cancel(uint256)"(
    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>;

  "create(address,address[],uint256[],string[],bytes[],bool[],bytes32)"(
    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>;

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

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

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

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

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

  getProposalById(
    proposalId: BigNumberish,
    overrides?: CallOverrides
  ): Promise<
    [
      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;
    }
  >;

  "getProposalById(uint256)"(
    proposalId: BigNumberish,
    overrides?: CallOverrides
  ): Promise<
    [
      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;
    }
  >;

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

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

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

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

  getVoteOnProposal(
    proposalId: BigNumberish,
    voter: string,
    overrides?: CallOverrides
  ): Promise<
    [boolean, BigNumber] & { support: boolean; votingPower: BigNumber }
  >;

  "getVoteOnProposal(uint256,address)"(
    proposalId: BigNumberish,
    voter: string,
    overrides?: CallOverrides
  ): Promise<
    [boolean, BigNumber] & { support: boolean; votingPower: BigNumber }
  >;

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

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

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

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

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

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

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

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

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

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

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

  "submitVote(uint256,bool)"(
    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>;

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

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

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

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

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

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

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

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

    "cancel(uint256)"(
      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>;

    "create(address,address[],uint256[],string[],bytes[],bool[],bytes32)"(
      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>;

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

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

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

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

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

    getProposalById(
      proposalId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<
      [
        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;
      }
    >;

    "getProposalById(uint256)"(
      proposalId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<
      [
        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;
      }
    >;

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

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

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

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

    getVoteOnProposal(
      proposalId: BigNumberish,
      voter: string,
      overrides?: CallOverrides
    ): Promise<
      [boolean, BigNumber] & { support: boolean; votingPower: BigNumber }
    >;

    "getVoteOnProposal(uint256,address)"(
      proposalId: BigNumberish,
      voter: string,
      overrides?: CallOverrides
    ): Promise<
      [boolean, BigNumber] & { support: boolean; votingPower: BigNumber }
    >;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  filters: {
    ExecutorAuthorized(
      executor: null
    ): TypedEventFilter<[string], { executor: string }>;

    ExecutorUnauthorized(
      executor: null
    ): TypedEventFilter<[string], { executor: string }>;

    GovernanceStrategyChanged(
      newStrategy: string | null,
      initiatorChange: string | null
    ): TypedEventFilter<
      [string, string],
      { newStrategy: string; initiatorChange: string }
    >;

    ProposalCanceled(
      id: null
    ): TypedEventFilter<[BigNumber], { id: BigNumber }>;

    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
    ): TypedEventFilter<
      [
        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;
      }
    >;

    ProposalExecuted(
      id: null,
      initiatorExecution: string | null
    ): TypedEventFilter<
      [BigNumber, string],
      { id: BigNumber; initiatorExecution: string }
    >;

    ProposalQueued(
      id: null,
      executionTime: null,
      initiatorQueueing: string | null
    ): TypedEventFilter<
      [BigNumber, BigNumber, string],
      { id: BigNumber; executionTime: BigNumber; initiatorQueueing: string }
    >;

    VoteEmitted(
      id: null,
      voter: string | null,
      support: null,
      votingPower: null
    ): TypedEventFilter<
      [BigNumber, string, boolean, BigNumber],
      { id: BigNumber; voter: string; support: boolean; votingPower: BigNumber }
    >;

    VotingDelayChanged(
      newVotingDelay: null,
      initiatorChange: string | null
    ): TypedEventFilter<
      [BigNumber, string],
      { newVotingDelay: BigNumber; initiatorChange: string }
    >;
  };

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

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

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

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

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

    "cancel(uint256)"(
      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>;

    "create(address,address[],uint256[],string[],bytes[],bool[],bytes32)"(
      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>;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    "submitVote(uint256,bool)"(
      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>;

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

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

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

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

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

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

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

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

    "cancel(uint256)"(
      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>;

    "create(address,address[],uint256[],string[],bytes[],bool[],bytes32)"(
      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>;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    "submitVote(uint256,bool)"(
      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>;

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

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

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