/* Autogenerated file. Do not edit manually. */
/* 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,
} from './common';

export interface AaveTokenV3Interface extends utils.Interface {
  functions: {
    'DELEGATE_BY_TYPE_TYPEHASH()': FunctionFragment;
    'DELEGATE_TYPEHASH()': FunctionFragment;
    'DOMAIN_SEPARATOR()': FunctionFragment;
    'PERMIT_TYPEHASH()': FunctionFragment;
    'POWER_SCALE_FACTOR()': FunctionFragment;
    'REVISION()': FunctionFragment;
    '_nonces(address)': FunctionFragment;
    'allowance(address,address)': FunctionFragment;
    'approve(address,uint256)': FunctionFragment;
    'balanceOf(address)': FunctionFragment;
    'decimals()': FunctionFragment;
    'decreaseAllowance(address,uint256)': FunctionFragment;
    'delegate(address)': FunctionFragment;
    'delegateByType(address,uint8)': FunctionFragment;
    'eip712Domain()': FunctionFragment;
    'getDelegateeByType(address,uint8)': FunctionFragment;
    'getDelegates(address)': FunctionFragment;
    'getPowerCurrent(address,uint8)': FunctionFragment;
    'getPowersCurrent(address)': FunctionFragment;
    'increaseAllowance(address,uint256)': FunctionFragment;
    'initialize()': FunctionFragment;
    'metaDelegate(address,address,uint256,uint8,bytes32,bytes32)': FunctionFragment;
    'metaDelegateByType(address,address,uint8,uint256,uint8,bytes32,bytes32)': FunctionFragment;
    'name()': FunctionFragment;
    'permit(address,address,uint256,uint256,uint8,bytes32,bytes32)': FunctionFragment;
    'symbol()': FunctionFragment;
    'totalSupply()': FunctionFragment;
    'transfer(address,uint256)': FunctionFragment;
    'transferFrom(address,address,uint256)': FunctionFragment;
  };

  getFunction(
    nameOrSignatureOrTopic:
      | 'DELEGATE_BY_TYPE_TYPEHASH'
      | 'DELEGATE_TYPEHASH'
      | 'DOMAIN_SEPARATOR'
      | 'PERMIT_TYPEHASH'
      | 'POWER_SCALE_FACTOR'
      | 'REVISION'
      | '_nonces'
      | 'allowance'
      | 'approve'
      | 'balanceOf'
      | 'decimals'
      | 'decreaseAllowance'
      | 'delegate'
      | 'delegateByType'
      | 'eip712Domain'
      | 'getDelegateeByType'
      | 'getDelegates'
      | 'getPowerCurrent'
      | 'getPowersCurrent'
      | 'increaseAllowance'
      | 'initialize'
      | 'metaDelegate'
      | 'metaDelegateByType'
      | 'name'
      | 'permit'
      | 'symbol'
      | 'totalSupply'
      | 'transfer'
      | 'transferFrom',
  ): FunctionFragment;

  encodeFunctionData(
    functionFragment: 'DELEGATE_BY_TYPE_TYPEHASH',
    values?: undefined,
  ): string;
  encodeFunctionData(
    functionFragment: 'DELEGATE_TYPEHASH',
    values?: undefined,
  ): string;
  encodeFunctionData(
    functionFragment: 'DOMAIN_SEPARATOR',
    values?: undefined,
  ): string;
  encodeFunctionData(
    functionFragment: 'PERMIT_TYPEHASH',
    values?: undefined,
  ): string;
  encodeFunctionData(
    functionFragment: 'POWER_SCALE_FACTOR',
    values?: undefined,
  ): string;
  encodeFunctionData(functionFragment: 'REVISION', values?: undefined): string;
  encodeFunctionData(functionFragment: '_nonces', values: [string]): string;
  encodeFunctionData(
    functionFragment: 'allowance',
    values: [string, string],
  ): string;
  encodeFunctionData(
    functionFragment: 'approve',
    values: [string, BigNumberish],
  ): string;
  encodeFunctionData(functionFragment: 'balanceOf', values: [string]): string;
  encodeFunctionData(functionFragment: 'decimals', values?: undefined): string;
  encodeFunctionData(
    functionFragment: 'decreaseAllowance',
    values: [string, BigNumberish],
  ): string;
  encodeFunctionData(functionFragment: 'delegate', values: [string]): string;
  encodeFunctionData(
    functionFragment: 'delegateByType',
    values: [string, BigNumberish],
  ): string;
  encodeFunctionData(
    functionFragment: 'eip712Domain',
    values?: undefined,
  ): string;
  encodeFunctionData(
    functionFragment: 'getDelegateeByType',
    values: [string, BigNumberish],
  ): string;
  encodeFunctionData(
    functionFragment: 'getDelegates',
    values: [string],
  ): string;
  encodeFunctionData(
    functionFragment: 'getPowerCurrent',
    values: [string, BigNumberish],
  ): string;
  encodeFunctionData(
    functionFragment: 'getPowersCurrent',
    values: [string],
  ): string;
  encodeFunctionData(
    functionFragment: 'increaseAllowance',
    values: [string, BigNumberish],
  ): string;
  encodeFunctionData(
    functionFragment: 'initialize',
    values?: undefined,
  ): string;
  encodeFunctionData(
    functionFragment: 'metaDelegate',
    values: [string, string, BigNumberish, BigNumberish, BytesLike, BytesLike],
  ): string;
  encodeFunctionData(
    functionFragment: 'metaDelegateByType',
    values: [
      string,
      string,
      BigNumberish,
      BigNumberish,
      BigNumberish,
      BytesLike,
      BytesLike,
    ],
  ): string;
  encodeFunctionData(functionFragment: 'name', values?: undefined): string;
  encodeFunctionData(
    functionFragment: 'permit',
    values: [
      string,
      string,
      BigNumberish,
      BigNumberish,
      BigNumberish,
      BytesLike,
      BytesLike,
    ],
  ): string;
  encodeFunctionData(functionFragment: 'symbol', values?: undefined): string;
  encodeFunctionData(
    functionFragment: 'totalSupply',
    values?: undefined,
  ): string;
  encodeFunctionData(
    functionFragment: 'transfer',
    values: [string, BigNumberish],
  ): string;
  encodeFunctionData(
    functionFragment: 'transferFrom',
    values: [string, string, BigNumberish],
  ): string;

  decodeFunctionResult(
    functionFragment: 'DELEGATE_BY_TYPE_TYPEHASH',
    data: BytesLike,
  ): Result;
  decodeFunctionResult(
    functionFragment: 'DELEGATE_TYPEHASH',
    data: BytesLike,
  ): Result;
  decodeFunctionResult(
    functionFragment: 'DOMAIN_SEPARATOR',
    data: BytesLike,
  ): Result;
  decodeFunctionResult(
    functionFragment: 'PERMIT_TYPEHASH',
    data: BytesLike,
  ): Result;
  decodeFunctionResult(
    functionFragment: 'POWER_SCALE_FACTOR',
    data: BytesLike,
  ): Result;
  decodeFunctionResult(functionFragment: 'REVISION', data: BytesLike): Result;
  decodeFunctionResult(functionFragment: '_nonces', data: BytesLike): Result;
  decodeFunctionResult(functionFragment: 'allowance', data: BytesLike): Result;
  decodeFunctionResult(functionFragment: 'approve', data: BytesLike): Result;
  decodeFunctionResult(functionFragment: 'balanceOf', data: BytesLike): Result;
  decodeFunctionResult(functionFragment: 'decimals', data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: 'decreaseAllowance',
    data: BytesLike,
  ): Result;
  decodeFunctionResult(functionFragment: 'delegate', data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: 'delegateByType',
    data: BytesLike,
  ): Result;
  decodeFunctionResult(
    functionFragment: 'eip712Domain',
    data: BytesLike,
  ): Result;
  decodeFunctionResult(
    functionFragment: 'getDelegateeByType',
    data: BytesLike,
  ): Result;
  decodeFunctionResult(
    functionFragment: 'getDelegates',
    data: BytesLike,
  ): Result;
  decodeFunctionResult(
    functionFragment: 'getPowerCurrent',
    data: BytesLike,
  ): Result;
  decodeFunctionResult(
    functionFragment: 'getPowersCurrent',
    data: BytesLike,
  ): Result;
  decodeFunctionResult(
    functionFragment: 'increaseAllowance',
    data: BytesLike,
  ): Result;
  decodeFunctionResult(functionFragment: 'initialize', data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: 'metaDelegate',
    data: BytesLike,
  ): Result;
  decodeFunctionResult(
    functionFragment: 'metaDelegateByType',
    data: BytesLike,
  ): Result;
  decodeFunctionResult(functionFragment: 'name', data: BytesLike): Result;
  decodeFunctionResult(functionFragment: 'permit', data: BytesLike): Result;
  decodeFunctionResult(functionFragment: 'symbol', data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: 'totalSupply',
    data: BytesLike,
  ): Result;
  decodeFunctionResult(functionFragment: 'transfer', data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: 'transferFrom',
    data: BytesLike,
  ): Result;

  events: {
    'Approval(address,address,uint256)': EventFragment;
    'DelegateChanged(address,address,uint8)': EventFragment;
    'EIP712DomainChanged()': EventFragment;
    'Transfer(address,address,uint256)': EventFragment;
  };

  getEvent(nameOrSignatureOrTopic: 'Approval'): EventFragment;
  getEvent(nameOrSignatureOrTopic: 'DelegateChanged'): EventFragment;
  getEvent(nameOrSignatureOrTopic: 'EIP712DomainChanged'): EventFragment;
  getEvent(nameOrSignatureOrTopic: 'Transfer'): EventFragment;
}

export interface ApprovalEventObject {
  owner: string;
  spender: string;
  value: BigNumber;
}
export type ApprovalEvent = TypedEvent<
  [string, string, BigNumber],
  ApprovalEventObject
>;

export type ApprovalEventFilter = TypedEventFilter<ApprovalEvent>;

export interface DelegateChangedEventObject {
  delegator: string;
  delegatee: string;
  delegationType: number;
}
export type DelegateChangedEvent = TypedEvent<
  [string, string, number],
  DelegateChangedEventObject
>;

export type DelegateChangedEventFilter = TypedEventFilter<DelegateChangedEvent>;

export interface EIP712DomainChangedEventObject {}
export type EIP712DomainChangedEvent = TypedEvent<
  [],
  EIP712DomainChangedEventObject
>;

export type EIP712DomainChangedEventFilter =
  TypedEventFilter<EIP712DomainChangedEvent>;

export interface TransferEventObject {
  from: string;
  to: string;
  value: BigNumber;
}
export type TransferEvent = TypedEvent<
  [string, string, BigNumber],
  TransferEventObject
>;

export type TransferEventFilter = TypedEventFilter<TransferEvent>;

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

  interface: AaveTokenV3Interface;

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

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

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

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

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

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

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

    allowance(
      owner: string,
      spender: string,
      overrides?: CallOverrides,
    ): Promise<[BigNumber]>;

    approve(
      spender: string,
      amount: BigNumberish,
      overrides?: Overrides & { from?: string },
    ): Promise<ContractTransaction>;

    balanceOf(account: string, overrides?: CallOverrides): Promise<[BigNumber]>;

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

    decreaseAllowance(
      spender: string,
      subtractedValue: BigNumberish,
      overrides?: Overrides & { from?: string },
    ): Promise<ContractTransaction>;

    delegate(
      delegatee: string,
      overrides?: Overrides & { from?: string },
    ): Promise<ContractTransaction>;

    delegateByType(
      delegatee: string,
      delegationType: BigNumberish,
      overrides?: Overrides & { from?: string },
    ): Promise<ContractTransaction>;

    eip712Domain(overrides?: CallOverrides): Promise<
      [string, string, string, BigNumber, string, string, BigNumber[]] & {
        fields: string;
        name: string;
        version: string;
        chainId: BigNumber;
        verifyingContract: string;
        salt: string;
        extensions: BigNumber[];
      }
    >;

    getDelegateeByType(
      delegator: string,
      delegationType: BigNumberish,
      overrides?: CallOverrides,
    ): Promise<[string]>;

    getDelegates(
      delegator: string,
      overrides?: CallOverrides,
    ): Promise<[string, string]>;

    getPowerCurrent(
      user: string,
      delegationType: BigNumberish,
      overrides?: CallOverrides,
    ): Promise<[BigNumber]>;

    getPowersCurrent(
      user: string,
      overrides?: CallOverrides,
    ): Promise<[BigNumber, BigNumber]>;

    increaseAllowance(
      spender: string,
      addedValue: BigNumberish,
      overrides?: Overrides & { from?: string },
    ): Promise<ContractTransaction>;

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

    metaDelegate(
      delegator: string,
      delegatee: string,
      deadline: BigNumberish,
      v: BigNumberish,
      r: BytesLike,
      s: BytesLike,
      overrides?: Overrides & { from?: string },
    ): Promise<ContractTransaction>;

    metaDelegateByType(
      delegator: string,
      delegatee: string,
      delegationType: BigNumberish,
      deadline: BigNumberish,
      v: BigNumberish,
      r: BytesLike,
      s: BytesLike,
      overrides?: Overrides & { from?: string },
    ): Promise<ContractTransaction>;

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

    permit(
      owner: string,
      spender: string,
      value: BigNumberish,
      deadline: BigNumberish,
      v: BigNumberish,
      r: BytesLike,
      s: BytesLike,
      overrides?: Overrides & { from?: string },
    ): Promise<ContractTransaction>;

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

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

    transfer(
      to: string,
      amount: BigNumberish,
      overrides?: Overrides & { from?: string },
    ): Promise<ContractTransaction>;

    transferFrom(
      from: string,
      to: string,
      amount: BigNumberish,
      overrides?: Overrides & { from?: string },
    ): Promise<ContractTransaction>;
  };

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

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

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

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

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

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

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

  allowance(
    owner: string,
    spender: string,
    overrides?: CallOverrides,
  ): Promise<BigNumber>;

  approve(
    spender: string,
    amount: BigNumberish,
    overrides?: Overrides & { from?: string },
  ): Promise<ContractTransaction>;

  balanceOf(account: string, overrides?: CallOverrides): Promise<BigNumber>;

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

  decreaseAllowance(
    spender: string,
    subtractedValue: BigNumberish,
    overrides?: Overrides & { from?: string },
  ): Promise<ContractTransaction>;

  delegate(
    delegatee: string,
    overrides?: Overrides & { from?: string },
  ): Promise<ContractTransaction>;

  delegateByType(
    delegatee: string,
    delegationType: BigNumberish,
    overrides?: Overrides & { from?: string },
  ): Promise<ContractTransaction>;

  eip712Domain(overrides?: CallOverrides): Promise<
    [string, string, string, BigNumber, string, string, BigNumber[]] & {
      fields: string;
      name: string;
      version: string;
      chainId: BigNumber;
      verifyingContract: string;
      salt: string;
      extensions: BigNumber[];
    }
  >;

  getDelegateeByType(
    delegator: string,
    delegationType: BigNumberish,
    overrides?: CallOverrides,
  ): Promise<string>;

  getDelegates(
    delegator: string,
    overrides?: CallOverrides,
  ): Promise<[string, string]>;

  getPowerCurrent(
    user: string,
    delegationType: BigNumberish,
    overrides?: CallOverrides,
  ): Promise<BigNumber>;

  getPowersCurrent(
    user: string,
    overrides?: CallOverrides,
  ): Promise<[BigNumber, BigNumber]>;

  increaseAllowance(
    spender: string,
    addedValue: BigNumberish,
    overrides?: Overrides & { from?: string },
  ): Promise<ContractTransaction>;

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

  metaDelegate(
    delegator: string,
    delegatee: string,
    deadline: BigNumberish,
    v: BigNumberish,
    r: BytesLike,
    s: BytesLike,
    overrides?: Overrides & { from?: string },
  ): Promise<ContractTransaction>;

  metaDelegateByType(
    delegator: string,
    delegatee: string,
    delegationType: BigNumberish,
    deadline: BigNumberish,
    v: BigNumberish,
    r: BytesLike,
    s: BytesLike,
    overrides?: Overrides & { from?: string },
  ): Promise<ContractTransaction>;

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

  permit(
    owner: string,
    spender: string,
    value: BigNumberish,
    deadline: BigNumberish,
    v: BigNumberish,
    r: BytesLike,
    s: BytesLike,
    overrides?: Overrides & { from?: string },
  ): Promise<ContractTransaction>;

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

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

  transfer(
    to: string,
    amount: BigNumberish,
    overrides?: Overrides & { from?: string },
  ): Promise<ContractTransaction>;

  transferFrom(
    from: string,
    to: string,
    amount: BigNumberish,
    overrides?: Overrides & { from?: string },
  ): Promise<ContractTransaction>;

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

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

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

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

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

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

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

    allowance(
      owner: string,
      spender: string,
      overrides?: CallOverrides,
    ): Promise<BigNumber>;

    approve(
      spender: string,
      amount: BigNumberish,
      overrides?: CallOverrides,
    ): Promise<boolean>;

    balanceOf(account: string, overrides?: CallOverrides): Promise<BigNumber>;

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

    decreaseAllowance(
      spender: string,
      subtractedValue: BigNumberish,
      overrides?: CallOverrides,
    ): Promise<boolean>;

    delegate(delegatee: string, overrides?: CallOverrides): Promise<void>;

    delegateByType(
      delegatee: string,
      delegationType: BigNumberish,
      overrides?: CallOverrides,
    ): Promise<void>;

    eip712Domain(overrides?: CallOverrides): Promise<
      [string, string, string, BigNumber, string, string, BigNumber[]] & {
        fields: string;
        name: string;
        version: string;
        chainId: BigNumber;
        verifyingContract: string;
        salt: string;
        extensions: BigNumber[];
      }
    >;

    getDelegateeByType(
      delegator: string,
      delegationType: BigNumberish,
      overrides?: CallOverrides,
    ): Promise<string>;

    getDelegates(
      delegator: string,
      overrides?: CallOverrides,
    ): Promise<[string, string]>;

    getPowerCurrent(
      user: string,
      delegationType: BigNumberish,
      overrides?: CallOverrides,
    ): Promise<BigNumber>;

    getPowersCurrent(
      user: string,
      overrides?: CallOverrides,
    ): Promise<[BigNumber, BigNumber]>;

    increaseAllowance(
      spender: string,
      addedValue: BigNumberish,
      overrides?: CallOverrides,
    ): Promise<boolean>;

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

    metaDelegate(
      delegator: string,
      delegatee: string,
      deadline: BigNumberish,
      v: BigNumberish,
      r: BytesLike,
      s: BytesLike,
      overrides?: CallOverrides,
    ): Promise<void>;

    metaDelegateByType(
      delegator: string,
      delegatee: string,
      delegationType: BigNumberish,
      deadline: BigNumberish,
      v: BigNumberish,
      r: BytesLike,
      s: BytesLike,
      overrides?: CallOverrides,
    ): Promise<void>;

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

    permit(
      owner: string,
      spender: string,
      value: BigNumberish,
      deadline: BigNumberish,
      v: BigNumberish,
      r: BytesLike,
      s: BytesLike,
      overrides?: CallOverrides,
    ): Promise<void>;

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

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

    transfer(
      to: string,
      amount: BigNumberish,
      overrides?: CallOverrides,
    ): Promise<boolean>;

    transferFrom(
      from: string,
      to: string,
      amount: BigNumberish,
      overrides?: CallOverrides,
    ): Promise<boolean>;
  };

  filters: {
    'Approval(address,address,uint256)'(
      owner?: string | null,
      spender?: string | null,
      value?: null,
    ): ApprovalEventFilter;
    Approval(
      owner?: string | null,
      spender?: string | null,
      value?: null,
    ): ApprovalEventFilter;

    'DelegateChanged(address,address,uint8)'(
      delegator?: string | null,
      delegatee?: string | null,
      delegationType?: null,
    ): DelegateChangedEventFilter;
    DelegateChanged(
      delegator?: string | null,
      delegatee?: string | null,
      delegationType?: null,
    ): DelegateChangedEventFilter;

    'EIP712DomainChanged()'(): EIP712DomainChangedEventFilter;
    EIP712DomainChanged(): EIP712DomainChangedEventFilter;

    'Transfer(address,address,uint256)'(
      from?: string | null,
      to?: string | null,
      value?: null,
    ): TransferEventFilter;
    Transfer(
      from?: string | null,
      to?: string | null,
      value?: null,
    ): TransferEventFilter;
  };

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

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

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

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

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

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

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

    allowance(
      owner: string,
      spender: string,
      overrides?: CallOverrides,
    ): Promise<BigNumber>;

    approve(
      spender: string,
      amount: BigNumberish,
      overrides?: Overrides & { from?: string },
    ): Promise<BigNumber>;

    balanceOf(account: string, overrides?: CallOverrides): Promise<BigNumber>;

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

    decreaseAllowance(
      spender: string,
      subtractedValue: BigNumberish,
      overrides?: Overrides & { from?: string },
    ): Promise<BigNumber>;

    delegate(
      delegatee: string,
      overrides?: Overrides & { from?: string },
    ): Promise<BigNumber>;

    delegateByType(
      delegatee: string,
      delegationType: BigNumberish,
      overrides?: Overrides & { from?: string },
    ): Promise<BigNumber>;

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

    getDelegateeByType(
      delegator: string,
      delegationType: BigNumberish,
      overrides?: CallOverrides,
    ): Promise<BigNumber>;

    getDelegates(
      delegator: string,
      overrides?: CallOverrides,
    ): Promise<BigNumber>;

    getPowerCurrent(
      user: string,
      delegationType: BigNumberish,
      overrides?: CallOverrides,
    ): Promise<BigNumber>;

    getPowersCurrent(
      user: string,
      overrides?: CallOverrides,
    ): Promise<BigNumber>;

    increaseAllowance(
      spender: string,
      addedValue: BigNumberish,
      overrides?: Overrides & { from?: string },
    ): Promise<BigNumber>;

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

    metaDelegate(
      delegator: string,
      delegatee: string,
      deadline: BigNumberish,
      v: BigNumberish,
      r: BytesLike,
      s: BytesLike,
      overrides?: Overrides & { from?: string },
    ): Promise<BigNumber>;

    metaDelegateByType(
      delegator: string,
      delegatee: string,
      delegationType: BigNumberish,
      deadline: BigNumberish,
      v: BigNumberish,
      r: BytesLike,
      s: BytesLike,
      overrides?: Overrides & { from?: string },
    ): Promise<BigNumber>;

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

    permit(
      owner: string,
      spender: string,
      value: BigNumberish,
      deadline: BigNumberish,
      v: BigNumberish,
      r: BytesLike,
      s: BytesLike,
      overrides?: Overrides & { from?: string },
    ): Promise<BigNumber>;

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

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

    transfer(
      to: string,
      amount: BigNumberish,
      overrides?: Overrides & { from?: string },
    ): Promise<BigNumber>;

    transferFrom(
      from: string,
      to: string,
      amount: BigNumberish,
      overrides?: Overrides & { from?: string },
    ): Promise<BigNumber>;
  };

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

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

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

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

    POWER_SCALE_FACTOR(
      overrides?: CallOverrides,
    ): Promise<PopulatedTransaction>;

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

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

    allowance(
      owner: string,
      spender: string,
      overrides?: CallOverrides,
    ): Promise<PopulatedTransaction>;

    approve(
      spender: string,
      amount: BigNumberish,
      overrides?: Overrides & { from?: string },
    ): Promise<PopulatedTransaction>;

    balanceOf(
      account: string,
      overrides?: CallOverrides,
    ): Promise<PopulatedTransaction>;

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

    decreaseAllowance(
      spender: string,
      subtractedValue: BigNumberish,
      overrides?: Overrides & { from?: string },
    ): Promise<PopulatedTransaction>;

    delegate(
      delegatee: string,
      overrides?: Overrides & { from?: string },
    ): Promise<PopulatedTransaction>;

    delegateByType(
      delegatee: string,
      delegationType: BigNumberish,
      overrides?: Overrides & { from?: string },
    ): Promise<PopulatedTransaction>;

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

    getDelegateeByType(
      delegator: string,
      delegationType: BigNumberish,
      overrides?: CallOverrides,
    ): Promise<PopulatedTransaction>;

    getDelegates(
      delegator: string,
      overrides?: CallOverrides,
    ): Promise<PopulatedTransaction>;

    getPowerCurrent(
      user: string,
      delegationType: BigNumberish,
      overrides?: CallOverrides,
    ): Promise<PopulatedTransaction>;

    getPowersCurrent(
      user: string,
      overrides?: CallOverrides,
    ): Promise<PopulatedTransaction>;

    increaseAllowance(
      spender: string,
      addedValue: BigNumberish,
      overrides?: Overrides & { from?: string },
    ): Promise<PopulatedTransaction>;

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

    metaDelegate(
      delegator: string,
      delegatee: string,
      deadline: BigNumberish,
      v: BigNumberish,
      r: BytesLike,
      s: BytesLike,
      overrides?: Overrides & { from?: string },
    ): Promise<PopulatedTransaction>;

    metaDelegateByType(
      delegator: string,
      delegatee: string,
      delegationType: BigNumberish,
      deadline: BigNumberish,
      v: BigNumberish,
      r: BytesLike,
      s: BytesLike,
      overrides?: Overrides & { from?: string },
    ): Promise<PopulatedTransaction>;

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

    permit(
      owner: string,
      spender: string,
      value: BigNumberish,
      deadline: BigNumberish,
      v: BigNumberish,
      r: BytesLike,
      s: BytesLike,
      overrides?: Overrides & { from?: string },
    ): Promise<PopulatedTransaction>;

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

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

    transfer(
      to: string,
      amount: BigNumberish,
      overrides?: Overrides & { from?: string },
    ): Promise<PopulatedTransaction>;

    transferFrom(
      from: string,
      to: string,
      amount: BigNumberish,
      overrides?: Overrides & { from?: string },
    ): Promise<PopulatedTransaction>;
  };
}