/* Autogenerated file. Do not edit manually. */
/* tslint:disable */
/* eslint-disable */
import {
  BaseContract,
  BigNumber,
  BigNumberish,
  BytesLike,
  CallOverrides,
  ContractTransaction,
  Overrides,
  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 interface GaugeControllerInterface extends utils.Interface {
  functions: {
    "commit_transfer_ownership(address)": FunctionFragment;
    "apply_transfer_ownership()": FunctionFragment;
    "gauge_types(address)": FunctionFragment;
    "add_gauge(address,int128)": FunctionFragment;
    "checkpoint()": FunctionFragment;
    "checkpoint_gauge(address)": FunctionFragment;
    "gauge_relative_weight(address)": FunctionFragment;
    "gauge_relative_weight_write(address)": FunctionFragment;
    "add_type(string)": FunctionFragment;
    "change_type_weight(int128,uint256)": FunctionFragment;
    "change_gauge_weight(address,uint256)": FunctionFragment;
    "vote_for_gauge_weights(address,uint256)": FunctionFragment;
    "get_gauge_weight(address)": FunctionFragment;
    "get_type_weight(int128)": FunctionFragment;
    "get_total_weight()": FunctionFragment;
    "get_weights_sum_per_type(int128)": FunctionFragment;
    "admin()": FunctionFragment;
    "future_admin()": FunctionFragment;
    "token()": FunctionFragment;
    "voting_escrow()": FunctionFragment;
    "n_gauge_types()": FunctionFragment;
    "n_gauges()": FunctionFragment;
    "gauge_type_names(int128)": FunctionFragment;
    "gauges(uint256)": FunctionFragment;
    "vote_user_slopes(address,address)": FunctionFragment;
    "vote_user_power(address)": FunctionFragment;
    "last_user_vote(address,address)": FunctionFragment;
    "points_weight(address,uint256)": FunctionFragment;
    "time_weight(address)": FunctionFragment;
    "points_sum(int128,uint256)": FunctionFragment;
    "time_sum(uint256)": FunctionFragment;
    "points_total(uint256)": FunctionFragment;
    "time_total()": FunctionFragment;
    "points_type_weight(int128,uint256)": FunctionFragment;
    "time_type_weight(uint256)": FunctionFragment;
  };

  encodeFunctionData(
    functionFragment: "commit_transfer_ownership",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "apply_transfer_ownership",
    values?: undefined
  ): string;
  encodeFunctionData(functionFragment: "gauge_types", values: [string]): string;
  encodeFunctionData(
    functionFragment: "add_gauge",
    values: [string, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "checkpoint",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "checkpoint_gauge",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "gauge_relative_weight",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "gauge_relative_weight_write",
    values: [string]
  ): string;
  encodeFunctionData(functionFragment: "add_type", values: [string]): string;
  encodeFunctionData(
    functionFragment: "change_type_weight",
    values: [BigNumberish, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "change_gauge_weight",
    values: [string, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "vote_for_gauge_weights",
    values: [string, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "get_gauge_weight",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "get_type_weight",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "get_total_weight",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "get_weights_sum_per_type",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(functionFragment: "admin", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "future_admin",
    values?: undefined
  ): string;
  encodeFunctionData(functionFragment: "token", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "voting_escrow",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "n_gauge_types",
    values?: undefined
  ): string;
  encodeFunctionData(functionFragment: "n_gauges", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "gauge_type_names",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "gauges",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "vote_user_slopes",
    values: [string, string]
  ): string;
  encodeFunctionData(
    functionFragment: "vote_user_power",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "last_user_vote",
    values: [string, string]
  ): string;
  encodeFunctionData(
    functionFragment: "points_weight",
    values: [string, BigNumberish]
  ): string;
  encodeFunctionData(functionFragment: "time_weight", values: [string]): string;
  encodeFunctionData(
    functionFragment: "points_sum",
    values: [BigNumberish, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "time_sum",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "points_total",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "time_total",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "points_type_weight",
    values: [BigNumberish, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "time_type_weight",
    values: [BigNumberish]
  ): string;

  decodeFunctionResult(
    functionFragment: "commit_transfer_ownership",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "apply_transfer_ownership",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "gauge_types",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "add_gauge", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "checkpoint", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "checkpoint_gauge",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "gauge_relative_weight",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "gauge_relative_weight_write",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "add_type", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "change_type_weight",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "change_gauge_weight",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "vote_for_gauge_weights",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "get_gauge_weight",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "get_type_weight",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "get_total_weight",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "get_weights_sum_per_type",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "admin", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "future_admin",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "token", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "voting_escrow",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "n_gauge_types",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "n_gauges", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "gauge_type_names",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "gauges", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "vote_user_slopes",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "vote_user_power",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "last_user_vote",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "points_weight",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "time_weight",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "points_sum", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "time_sum", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "points_total",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "time_total", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "points_type_weight",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "time_type_weight",
    data: BytesLike
  ): Result;

  events: {
    "CommitOwnership(address)": EventFragment;
    "ApplyOwnership(address)": EventFragment;
    "AddType(string,int128)": EventFragment;
    "NewTypeWeight(int128,uint256,uint256,uint256)": EventFragment;
    "NewGaugeWeight(address,uint256,uint256,uint256)": EventFragment;
    "VoteForGauge(uint256,address,address,uint256)": EventFragment;
    "NewGauge(address,int128,uint256)": EventFragment;
  };

  getEvent(nameOrSignatureOrTopic: "CommitOwnership"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "ApplyOwnership"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "AddType"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "NewTypeWeight"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "NewGaugeWeight"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "VoteForGauge"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "NewGauge"): EventFragment;
}

export type CommitOwnershipEvent = TypedEvent<[string], { admin: string }>;

export type CommitOwnershipEventFilter = TypedEventFilter<CommitOwnershipEvent>;

export type ApplyOwnershipEvent = TypedEvent<[string], { admin: string }>;

export type ApplyOwnershipEventFilter = TypedEventFilter<ApplyOwnershipEvent>;

export type AddTypeEvent = TypedEvent<
  [string, BigNumber],
  { name: string; type_id: BigNumber }
>;

export type AddTypeEventFilter = TypedEventFilter<AddTypeEvent>;

export type NewTypeWeightEvent = TypedEvent<
  [BigNumber, BigNumber, BigNumber, BigNumber],
  {
    type_id: BigNumber;
    time: BigNumber;
    weight: BigNumber;
    total_weight: BigNumber;
  }
>;

export type NewTypeWeightEventFilter = TypedEventFilter<NewTypeWeightEvent>;

export type NewGaugeWeightEvent = TypedEvent<
  [string, BigNumber, BigNumber, BigNumber],
  {
    gauge_address: string;
    time: BigNumber;
    weight: BigNumber;
    total_weight: BigNumber;
  }
>;

export type NewGaugeWeightEventFilter = TypedEventFilter<NewGaugeWeightEvent>;

export type VoteForGaugeEvent = TypedEvent<
  [BigNumber, string, string, BigNumber],
  { time: BigNumber; user: string; gauge_addr: string; weight: BigNumber }
>;

export type VoteForGaugeEventFilter = TypedEventFilter<VoteForGaugeEvent>;

export type NewGaugeEvent = TypedEvent<
  [string, BigNumber, BigNumber],
  { addr: string; gauge_type: BigNumber; weight: BigNumber }
>;

export type NewGaugeEventFilter = TypedEventFilter<NewGaugeEvent>;

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

  interface: GaugeControllerInterface;

  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: {
    commit_transfer_ownership(
      addr: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

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

    gauge_types(_addr: string, overrides?: CallOverrides): Promise<[BigNumber]>;

    "add_gauge(address,int128)"(
      addr: string,
      gauge_type: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    "add_gauge(address,int128,uint256)"(
      addr: string,
      gauge_type: BigNumberish,
      weight: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

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

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

    "gauge_relative_weight(address)"(
      addr: string,
      overrides?: CallOverrides
    ): Promise<[BigNumber]>;

    "gauge_relative_weight(address,uint256)"(
      addr: string,
      time: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[BigNumber]>;

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

    "gauge_relative_weight_write(address,uint256)"(
      addr: string,
      time: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

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

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

    change_type_weight(
      type_id: BigNumberish,
      weight: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    change_gauge_weight(
      addr: string,
      weight: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    vote_for_gauge_weights(
      _gauge_addr: string,
      _user_weight: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    get_gauge_weight(
      addr: string,
      overrides?: CallOverrides
    ): Promise<[BigNumber]>;

    get_type_weight(
      type_id: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[BigNumber]>;

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

    get_weights_sum_per_type(
      type_id: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[BigNumber]>;

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

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

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

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

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

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

    gauge_type_names(
      arg0: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[string]>;

    gauges(arg0: BigNumberish, overrides?: CallOverrides): Promise<[string]>;

    vote_user_slopes(
      arg0: string,
      arg1: string,
      overrides?: CallOverrides
    ): Promise<
      [BigNumber, BigNumber, BigNumber] & {
        slope: BigNumber;
        power: BigNumber;
        end: BigNumber;
      }
    >;

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

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

    points_weight(
      arg0: string,
      arg1: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[BigNumber, BigNumber] & { bias: BigNumber; slope: BigNumber }>;

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

    points_sum(
      arg0: BigNumberish,
      arg1: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[BigNumber, BigNumber] & { bias: BigNumber; slope: BigNumber }>;

    time_sum(
      arg0: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[BigNumber]>;

    points_total(
      arg0: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[BigNumber]>;

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

    points_type_weight(
      arg0: BigNumberish,
      arg1: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[BigNumber]>;

    time_type_weight(
      arg0: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[BigNumber]>;
  };

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

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

  gauge_types(_addr: string, overrides?: CallOverrides): Promise<BigNumber>;

  "add_gauge(address,int128)"(
    addr: string,
    gauge_type: BigNumberish,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  "add_gauge(address,int128,uint256)"(
    addr: string,
    gauge_type: BigNumberish,
    weight: BigNumberish,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

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

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

  "gauge_relative_weight(address)"(
    addr: string,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  "gauge_relative_weight(address,uint256)"(
    addr: string,
    time: BigNumberish,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

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

  "gauge_relative_weight_write(address,uint256)"(
    addr: string,
    time: BigNumberish,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

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

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

  change_type_weight(
    type_id: BigNumberish,
    weight: BigNumberish,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  change_gauge_weight(
    addr: string,
    weight: BigNumberish,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  vote_for_gauge_weights(
    _gauge_addr: string,
    _user_weight: BigNumberish,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  get_gauge_weight(addr: string, overrides?: CallOverrides): Promise<BigNumber>;

  get_type_weight(
    type_id: BigNumberish,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

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

  get_weights_sum_per_type(
    type_id: BigNumberish,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

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

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

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

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

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

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

  gauge_type_names(
    arg0: BigNumberish,
    overrides?: CallOverrides
  ): Promise<string>;

  gauges(arg0: BigNumberish, overrides?: CallOverrides): Promise<string>;

  vote_user_slopes(
    arg0: string,
    arg1: string,
    overrides?: CallOverrides
  ): Promise<
    [BigNumber, BigNumber, BigNumber] & {
      slope: BigNumber;
      power: BigNumber;
      end: BigNumber;
    }
  >;

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

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

  points_weight(
    arg0: string,
    arg1: BigNumberish,
    overrides?: CallOverrides
  ): Promise<[BigNumber, BigNumber] & { bias: BigNumber; slope: BigNumber }>;

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

  points_sum(
    arg0: BigNumberish,
    arg1: BigNumberish,
    overrides?: CallOverrides
  ): Promise<[BigNumber, BigNumber] & { bias: BigNumber; slope: BigNumber }>;

  time_sum(arg0: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;

  points_total(
    arg0: BigNumberish,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

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

  points_type_weight(
    arg0: BigNumberish,
    arg1: BigNumberish,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  time_type_weight(
    arg0: BigNumberish,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  callStatic: {
    commit_transfer_ownership(
      addr: string,
      overrides?: CallOverrides
    ): Promise<void>;

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

    gauge_types(_addr: string, overrides?: CallOverrides): Promise<BigNumber>;

    "add_gauge(address,int128)"(
      addr: string,
      gauge_type: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    "add_gauge(address,int128,uint256)"(
      addr: string,
      gauge_type: BigNumberish,
      weight: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

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

    checkpoint_gauge(addr: string, overrides?: CallOverrides): Promise<void>;

    "gauge_relative_weight(address)"(
      addr: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    "gauge_relative_weight(address,uint256)"(
      addr: string,
      time: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    "gauge_relative_weight_write(address)"(
      addr: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    "gauge_relative_weight_write(address,uint256)"(
      addr: string,
      time: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    "add_type(string)"(_name: string, overrides?: CallOverrides): Promise<void>;

    "add_type(string,uint256)"(
      _name: string,
      weight: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    change_type_weight(
      type_id: BigNumberish,
      weight: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    change_gauge_weight(
      addr: string,
      weight: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    vote_for_gauge_weights(
      _gauge_addr: string,
      _user_weight: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    get_gauge_weight(
      addr: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    get_type_weight(
      type_id: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

    get_weights_sum_per_type(
      type_id: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

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

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

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

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

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

    gauge_type_names(
      arg0: BigNumberish,
      overrides?: CallOverrides
    ): Promise<string>;

    gauges(arg0: BigNumberish, overrides?: CallOverrides): Promise<string>;

    vote_user_slopes(
      arg0: string,
      arg1: string,
      overrides?: CallOverrides
    ): Promise<
      [BigNumber, BigNumber, BigNumber] & {
        slope: BigNumber;
        power: BigNumber;
        end: BigNumber;
      }
    >;

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

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

    points_weight(
      arg0: string,
      arg1: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[BigNumber, BigNumber] & { bias: BigNumber; slope: BigNumber }>;

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

    points_sum(
      arg0: BigNumberish,
      arg1: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[BigNumber, BigNumber] & { bias: BigNumber; slope: BigNumber }>;

    time_sum(arg0: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;

    points_total(
      arg0: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

    points_type_weight(
      arg0: BigNumberish,
      arg1: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    time_type_weight(
      arg0: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;
  };

  filters: {
    "CommitOwnership(address)"(admin?: null): CommitOwnershipEventFilter;
    CommitOwnership(admin?: null): CommitOwnershipEventFilter;

    "ApplyOwnership(address)"(admin?: null): ApplyOwnershipEventFilter;
    ApplyOwnership(admin?: null): ApplyOwnershipEventFilter;

    "AddType(string,int128)"(name?: null, type_id?: null): AddTypeEventFilter;
    AddType(name?: null, type_id?: null): AddTypeEventFilter;

    "NewTypeWeight(int128,uint256,uint256,uint256)"(
      type_id?: null,
      time?: null,
      weight?: null,
      total_weight?: null
    ): NewTypeWeightEventFilter;
    NewTypeWeight(
      type_id?: null,
      time?: null,
      weight?: null,
      total_weight?: null
    ): NewTypeWeightEventFilter;

    "NewGaugeWeight(address,uint256,uint256,uint256)"(
      gauge_address?: null,
      time?: null,
      weight?: null,
      total_weight?: null
    ): NewGaugeWeightEventFilter;
    NewGaugeWeight(
      gauge_address?: null,
      time?: null,
      weight?: null,
      total_weight?: null
    ): NewGaugeWeightEventFilter;

    "VoteForGauge(uint256,address,address,uint256)"(
      time?: null,
      user?: null,
      gauge_addr?: null,
      weight?: null
    ): VoteForGaugeEventFilter;
    VoteForGauge(
      time?: null,
      user?: null,
      gauge_addr?: null,
      weight?: null
    ): VoteForGaugeEventFilter;

    "NewGauge(address,int128,uint256)"(
      addr?: null,
      gauge_type?: null,
      weight?: null
    ): NewGaugeEventFilter;
    NewGauge(
      addr?: null,
      gauge_type?: null,
      weight?: null
    ): NewGaugeEventFilter;
  };

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

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

    gauge_types(_addr: string, overrides?: CallOverrides): Promise<BigNumber>;

    "add_gauge(address,int128)"(
      addr: string,
      gauge_type: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    "add_gauge(address,int128,uint256)"(
      addr: string,
      gauge_type: BigNumberish,
      weight: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

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

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

    "gauge_relative_weight(address)"(
      addr: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    "gauge_relative_weight(address,uint256)"(
      addr: string,
      time: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

    "gauge_relative_weight_write(address,uint256)"(
      addr: string,
      time: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

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

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

    change_type_weight(
      type_id: BigNumberish,
      weight: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    change_gauge_weight(
      addr: string,
      weight: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    vote_for_gauge_weights(
      _gauge_addr: string,
      _user_weight: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    get_gauge_weight(
      addr: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    get_type_weight(
      type_id: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

    get_weights_sum_per_type(
      type_id: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

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

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

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

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

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

    gauge_type_names(
      arg0: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    gauges(arg0: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;

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

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

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

    points_weight(
      arg0: string,
      arg1: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

    points_sum(
      arg0: BigNumberish,
      arg1: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    time_sum(arg0: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;

    points_total(
      arg0: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

    points_type_weight(
      arg0: BigNumberish,
      arg1: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    time_type_weight(
      arg0: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;
  };

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

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

    gauge_types(
      _addr: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    "add_gauge(address,int128)"(
      addr: string,
      gauge_type: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    "add_gauge(address,int128,uint256)"(
      addr: string,
      gauge_type: BigNumberish,
      weight: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

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

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

    "gauge_relative_weight(address)"(
      addr: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    "gauge_relative_weight(address,uint256)"(
      addr: string,
      time: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

    "gauge_relative_weight_write(address,uint256)"(
      addr: string,
      time: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

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

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

    change_type_weight(
      type_id: BigNumberish,
      weight: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    change_gauge_weight(
      addr: string,
      weight: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    vote_for_gauge_weights(
      _gauge_addr: string,
      _user_weight: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    get_gauge_weight(
      addr: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    get_type_weight(
      type_id: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

    get_weights_sum_per_type(
      type_id: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

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

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

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

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

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

    gauge_type_names(
      arg0: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    gauges(
      arg0: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

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

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

    points_weight(
      arg0: string,
      arg1: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

    points_sum(
      arg0: BigNumberish,
      arg1: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    time_sum(
      arg0: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    points_total(
      arg0: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

    points_type_weight(
      arg0: BigNumberish,
      arg1: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    time_type_weight(
      arg0: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;
  };
}