/* Autogenerated file. Do not edit manually. */
/* tslint:disable */
/* eslint-disable */
import type {
  BaseContract,
  BigNumber,
  BigNumberish,
  BytesLike,
  CallOverrides,
  ContractTransaction,
  Overrides,
  PayableOverrides,
  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 declare namespace GoodFundManager {
  export type InterestInfoStruct = {
    contractAddress: string;
    interestBalance: BigNumberish;
    collectedInterestSoFar: BigNumberish;
    gasCostSoFar: BigNumberish;
    maxGasAmountSoFar: BigNumberish;
    maxGasLargerOrEqualRequired: boolean;
  };

  export type InterestInfoStructOutput = [
    string,
    BigNumber,
    BigNumber,
    BigNumber,
    BigNumber,
    boolean
  ] & {
    contractAddress: string;
    interestBalance: BigNumber;
    collectedInterestSoFar: BigNumber;
    gasCostSoFar: BigNumber;
    maxGasAmountSoFar: BigNumber;
    maxGasLargerOrEqualRequired: boolean;
  };
}

export interface GoodFundManagerTestInterface extends utils.Interface {
  functions: {
    "activeContracts(uint256)": FunctionFragment;
    "avatar()": FunctionFragment;
    "calcSortedContracts()": FunctionFragment;
    "collectInterest(address[],bool)": FunctionFragment;
    "collectInterestTimeThreshold()": FunctionFragment;
    "dao()": FunctionFragment;
    "gasCostExceptInterestCollect()": FunctionFragment;
    "gdMintGasCost()": FunctionFragment;
    "getActiveContractsCount()": FunctionFragment;
    "getGasPriceInGD(uint256)": FunctionFragment;
    "getGasPriceIncDAIorDAI(uint256,bool)": FunctionFragment;
    "initialize(address)": FunctionFragment;
    "interestMultiplier()": FunctionFragment;
    "isActiveContract(address)": FunctionFragment;
    "lastCollectedInterest()": FunctionFragment;
    "lastCollectedInterestBlock()": FunctionFragment;
    "minCollectInterestIntervalDays()": FunctionFragment;
    "mintReward(address,address)": FunctionFragment;
    "nameService()": FunctionFragment;
    "nativeToken()": FunctionFragment;
    "proxiableUUID()": FunctionFragment;
    "rewardsForStakingContract(address)": FunctionFragment;
    "setCollectInterestTimeThreshold(uint256)": FunctionFragment;
    "setGasCost(uint256)": FunctionFragment;
    "setGasCostExceptInterestCollect(uint256)": FunctionFragment;
    "setInterestMultiplier(uint8)": FunctionFragment;
    "setStakingReward(uint32,address,uint32,uint32,bool)": FunctionFragment;
    "testSorting(uint256[],address[])": FunctionFragment;
    "updateAvatar()": FunctionFragment;
    "upgradeTo(address)": FunctionFragment;
    "upgradeToAndCall(address,bytes)": FunctionFragment;
  };

  getFunction(
    nameOrSignatureOrTopic:
      | "activeContracts"
      | "avatar"
      | "calcSortedContracts"
      | "collectInterest"
      | "collectInterestTimeThreshold"
      | "dao"
      | "gasCostExceptInterestCollect"
      | "gdMintGasCost"
      | "getActiveContractsCount"
      | "getGasPriceInGD"
      | "getGasPriceIncDAIorDAI"
      | "initialize"
      | "interestMultiplier"
      | "isActiveContract"
      | "lastCollectedInterest"
      | "lastCollectedInterestBlock"
      | "minCollectInterestIntervalDays"
      | "mintReward"
      | "nameService"
      | "nativeToken"
      | "proxiableUUID"
      | "rewardsForStakingContract"
      | "setCollectInterestTimeThreshold"
      | "setGasCost"
      | "setGasCostExceptInterestCollect"
      | "setInterestMultiplier"
      | "setStakingReward"
      | "testSorting"
      | "updateAvatar"
      | "upgradeTo"
      | "upgradeToAndCall"
  ): FunctionFragment;

  encodeFunctionData(
    functionFragment: "activeContracts",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(functionFragment: "avatar", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "calcSortedContracts",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "collectInterest",
    values: [string[], boolean]
  ): string;
  encodeFunctionData(
    functionFragment: "collectInterestTimeThreshold",
    values?: undefined
  ): string;
  encodeFunctionData(functionFragment: "dao", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "gasCostExceptInterestCollect",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "gdMintGasCost",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "getActiveContractsCount",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "getGasPriceInGD",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "getGasPriceIncDAIorDAI",
    values: [BigNumberish, boolean]
  ): string;
  encodeFunctionData(functionFragment: "initialize", values: [string]): string;
  encodeFunctionData(
    functionFragment: "interestMultiplier",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "isActiveContract",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "lastCollectedInterest",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "lastCollectedInterestBlock",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "minCollectInterestIntervalDays",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "mintReward",
    values: [string, string]
  ): string;
  encodeFunctionData(
    functionFragment: "nameService",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "nativeToken",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "proxiableUUID",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "rewardsForStakingContract",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "setCollectInterestTimeThreshold",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "setGasCost",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "setGasCostExceptInterestCollect",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "setInterestMultiplier",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "setStakingReward",
    values: [BigNumberish, string, BigNumberish, BigNumberish, boolean]
  ): string;
  encodeFunctionData(
    functionFragment: "testSorting",
    values: [BigNumberish[], string[]]
  ): string;
  encodeFunctionData(
    functionFragment: "updateAvatar",
    values?: undefined
  ): string;
  encodeFunctionData(functionFragment: "upgradeTo", values: [string]): string;
  encodeFunctionData(
    functionFragment: "upgradeToAndCall",
    values: [string, BytesLike]
  ): string;

  decodeFunctionResult(
    functionFragment: "activeContracts",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "avatar", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "calcSortedContracts",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "collectInterest",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "collectInterestTimeThreshold",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "dao", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "gasCostExceptInterestCollect",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "gdMintGasCost",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getActiveContractsCount",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getGasPriceInGD",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getGasPriceIncDAIorDAI",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "initialize", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "interestMultiplier",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "isActiveContract",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "lastCollectedInterest",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "lastCollectedInterestBlock",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "minCollectInterestIntervalDays",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "mintReward", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "nameService",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "nativeToken",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "proxiableUUID",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "rewardsForStakingContract",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setCollectInterestTimeThreshold",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "setGasCost", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "setGasCostExceptInterestCollect",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setInterestMultiplier",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setStakingReward",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "testSorting",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "updateAvatar",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "upgradeTo", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "upgradeToAndCall",
    data: BytesLike
  ): Result;

  events: {
    "AdminChanged(address,address)": EventFragment;
    "BeaconUpgraded(address)": EventFragment;
    "CollectInterestTimeThresholdSet(uint256)": EventFragment;
    "FundsTransferred(address,address,address[],uint256,uint256,uint256)": EventFragment;
    "GasCostExceptInterestCollectSet(uint256)": EventFragment;
    "GasCostSet(uint256)": EventFragment;
    "Initialized(uint8)": EventFragment;
    "InterestMultiplierSet(uint8)": EventFragment;
    "StakingRewardMinted(address,address,uint256)": EventFragment;
    "StakingRewardSet(uint32,address,uint32,uint32,bool)": EventFragment;
    "Upgraded(address)": EventFragment;
  };

  getEvent(nameOrSignatureOrTopic: "AdminChanged"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "BeaconUpgraded"): EventFragment;
  getEvent(
    nameOrSignatureOrTopic: "CollectInterestTimeThresholdSet"
  ): EventFragment;
  getEvent(nameOrSignatureOrTopic: "FundsTransferred"): EventFragment;
  getEvent(
    nameOrSignatureOrTopic: "GasCostExceptInterestCollectSet"
  ): EventFragment;
  getEvent(nameOrSignatureOrTopic: "GasCostSet"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "Initialized"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "InterestMultiplierSet"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "StakingRewardMinted"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "StakingRewardSet"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "Upgraded"): EventFragment;
}

export interface AdminChangedEventObject {
  previousAdmin: string;
  newAdmin: string;
}
export type AdminChangedEvent = TypedEvent<
  [string, string],
  AdminChangedEventObject
>;

export type AdminChangedEventFilter = TypedEventFilter<AdminChangedEvent>;

export interface BeaconUpgradedEventObject {
  beacon: string;
}
export type BeaconUpgradedEvent = TypedEvent<
  [string],
  BeaconUpgradedEventObject
>;

export type BeaconUpgradedEventFilter = TypedEventFilter<BeaconUpgradedEvent>;

export interface CollectInterestTimeThresholdSetEventObject {
  newCollectInterestTimeThreshold: BigNumber;
}
export type CollectInterestTimeThresholdSetEvent = TypedEvent<
  [BigNumber],
  CollectInterestTimeThresholdSetEventObject
>;

export type CollectInterestTimeThresholdSetEventFilter =
  TypedEventFilter<CollectInterestTimeThresholdSetEvent>;

export interface FundsTransferredEventObject {
  caller: string;
  reserve: string;
  stakings: string[];
  cDAIinterestEarned: BigNumber;
  gdUBI: BigNumber;
  gdReward: BigNumber;
}
export type FundsTransferredEvent = TypedEvent<
  [string, string, string[], BigNumber, BigNumber, BigNumber],
  FundsTransferredEventObject
>;

export type FundsTransferredEventFilter =
  TypedEventFilter<FundsTransferredEvent>;

export interface GasCostExceptInterestCollectSetEventObject {
  newGasCostExceptInterestCollect: BigNumber;
}
export type GasCostExceptInterestCollectSetEvent = TypedEvent<
  [BigNumber],
  GasCostExceptInterestCollectSetEventObject
>;

export type GasCostExceptInterestCollectSetEventFilter =
  TypedEventFilter<GasCostExceptInterestCollectSetEvent>;

export interface GasCostSetEventObject {
  newGasCost: BigNumber;
}
export type GasCostSetEvent = TypedEvent<[BigNumber], GasCostSetEventObject>;

export type GasCostSetEventFilter = TypedEventFilter<GasCostSetEvent>;

export interface InitializedEventObject {
  version: number;
}
export type InitializedEvent = TypedEvent<[number], InitializedEventObject>;

export type InitializedEventFilter = TypedEventFilter<InitializedEvent>;

export interface InterestMultiplierSetEventObject {
  newInterestMultiplier: number;
}
export type InterestMultiplierSetEvent = TypedEvent<
  [number],
  InterestMultiplierSetEventObject
>;

export type InterestMultiplierSetEventFilter =
  TypedEventFilter<InterestMultiplierSetEvent>;

export interface StakingRewardMintedEventObject {
  stakingContract: string;
  staker: string;
  gdReward: BigNumber;
}
export type StakingRewardMintedEvent = TypedEvent<
  [string, string, BigNumber],
  StakingRewardMintedEventObject
>;

export type StakingRewardMintedEventFilter =
  TypedEventFilter<StakingRewardMintedEvent>;

export interface StakingRewardSetEventObject {
  _rewardsPerBlock: number;
  _stakingAddress: string;
  _blockStart: number;
  _blockEnd: number;
  _isBlackListed: boolean;
}
export type StakingRewardSetEvent = TypedEvent<
  [number, string, number, number, boolean],
  StakingRewardSetEventObject
>;

export type StakingRewardSetEventFilter =
  TypedEventFilter<StakingRewardSetEvent>;

export interface UpgradedEventObject {
  implementation: string;
}
export type UpgradedEvent = TypedEvent<[string], UpgradedEventObject>;

export type UpgradedEventFilter = TypedEventFilter<UpgradedEvent>;

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

  interface: GoodFundManagerTestInterface;

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

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

    calcSortedContracts(
      overrides?: CallOverrides
    ): Promise<[GoodFundManager.InterestInfoStructOutput[]]>;

    collectInterest(
      _stakingContracts: string[],
      _forceAndWaiverRewards: boolean,
      overrides?: Overrides & { from?: string }
    ): Promise<ContractTransaction>;

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

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

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

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

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

    getGasPriceInGD(
      _gasAmount: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[BigNumber]>;

    getGasPriceIncDAIorDAI(
      _gasAmount: BigNumberish,
      _inDAI: boolean,
      overrides?: CallOverrides
    ): Promise<[BigNumber]>;

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

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

    isActiveContract(
      _contract: string,
      overrides?: CallOverrides
    ): Promise<[boolean] & { isActive: boolean }>;

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

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

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

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

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

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

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

    rewardsForStakingContract(
      arg0: string,
      overrides?: CallOverrides
    ): Promise<
      [number, BigNumber, BigNumber, boolean] & {
        blockReward: number;
        blockStart: BigNumber;
        blockEnd: BigNumber;
        isBlackListed: boolean;
      }
    >;

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

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

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

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

    setStakingReward(
      _rewardsPerBlock: BigNumberish,
      _stakingAddress: string,
      _blockStart: BigNumberish,
      _blockEnd: BigNumberish,
      _isBlackListed: boolean,
      overrides?: Overrides & { from?: string }
    ): Promise<ContractTransaction>;

    testSorting(
      data: BigNumberish[],
      addresses: string[],
      overrides?: CallOverrides
    ): Promise<[BigNumber[], string[]]>;

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

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

    upgradeToAndCall(
      newImplementation: string,
      data: BytesLike,
      overrides?: PayableOverrides & { from?: string }
    ): Promise<ContractTransaction>;
  };

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

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

  calcSortedContracts(
    overrides?: CallOverrides
  ): Promise<GoodFundManager.InterestInfoStructOutput[]>;

  collectInterest(
    _stakingContracts: string[],
    _forceAndWaiverRewards: boolean,
    overrides?: Overrides & { from?: string }
  ): Promise<ContractTransaction>;

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

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

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

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

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

  getGasPriceInGD(
    _gasAmount: BigNumberish,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  getGasPriceIncDAIorDAI(
    _gasAmount: BigNumberish,
    _inDAI: boolean,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

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

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

  isActiveContract(
    _contract: string,
    overrides?: CallOverrides
  ): Promise<boolean>;

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

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

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

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

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

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

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

  rewardsForStakingContract(
    arg0: string,
    overrides?: CallOverrides
  ): Promise<
    [number, BigNumber, BigNumber, boolean] & {
      blockReward: number;
      blockStart: BigNumber;
      blockEnd: BigNumber;
      isBlackListed: boolean;
    }
  >;

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

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

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

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

  setStakingReward(
    _rewardsPerBlock: BigNumberish,
    _stakingAddress: string,
    _blockStart: BigNumberish,
    _blockEnd: BigNumberish,
    _isBlackListed: boolean,
    overrides?: Overrides & { from?: string }
  ): Promise<ContractTransaction>;

  testSorting(
    data: BigNumberish[],
    addresses: string[],
    overrides?: CallOverrides
  ): Promise<[BigNumber[], string[]]>;

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

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

  upgradeToAndCall(
    newImplementation: string,
    data: BytesLike,
    overrides?: PayableOverrides & { from?: string }
  ): Promise<ContractTransaction>;

  callStatic: {
    activeContracts(
      arg0: BigNumberish,
      overrides?: CallOverrides
    ): Promise<string>;

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

    calcSortedContracts(
      overrides?: CallOverrides
    ): Promise<GoodFundManager.InterestInfoStructOutput[]>;

    collectInterest(
      _stakingContracts: string[],
      _forceAndWaiverRewards: boolean,
      overrides?: CallOverrides
    ): Promise<void>;

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

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

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

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

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

    getGasPriceInGD(
      _gasAmount: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    getGasPriceIncDAIorDAI(
      _gasAmount: BigNumberish,
      _inDAI: boolean,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

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

    isActiveContract(
      _contract: string,
      overrides?: CallOverrides
    ): Promise<boolean>;

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

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

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

    mintReward(
      _token: string,
      _user: string,
      overrides?: CallOverrides
    ): Promise<void>;

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

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

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

    rewardsForStakingContract(
      arg0: string,
      overrides?: CallOverrides
    ): Promise<
      [number, BigNumber, BigNumber, boolean] & {
        blockReward: number;
        blockStart: BigNumber;
        blockEnd: BigNumber;
        isBlackListed: boolean;
      }
    >;

    setCollectInterestTimeThreshold(
      _timeThreshold: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    setGasCost(
      _gasAmount: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    setGasCostExceptInterestCollect(
      _gasAmount: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    setInterestMultiplier(
      _newMultiplier: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    setStakingReward(
      _rewardsPerBlock: BigNumberish,
      _stakingAddress: string,
      _blockStart: BigNumberish,
      _blockEnd: BigNumberish,
      _isBlackListed: boolean,
      overrides?: CallOverrides
    ): Promise<void>;

    testSorting(
      data: BigNumberish[],
      addresses: string[],
      overrides?: CallOverrides
    ): Promise<[BigNumber[], string[]]>;

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

    upgradeTo(
      newImplementation: string,
      overrides?: CallOverrides
    ): Promise<void>;

    upgradeToAndCall(
      newImplementation: string,
      data: BytesLike,
      overrides?: CallOverrides
    ): Promise<void>;
  };

  filters: {
    "AdminChanged(address,address)"(
      previousAdmin?: null,
      newAdmin?: null
    ): AdminChangedEventFilter;
    AdminChanged(
      previousAdmin?: null,
      newAdmin?: null
    ): AdminChangedEventFilter;

    "BeaconUpgraded(address)"(
      beacon?: string | null
    ): BeaconUpgradedEventFilter;
    BeaconUpgraded(beacon?: string | null): BeaconUpgradedEventFilter;

    "CollectInterestTimeThresholdSet(uint256)"(
      newCollectInterestTimeThreshold?: null
    ): CollectInterestTimeThresholdSetEventFilter;
    CollectInterestTimeThresholdSet(
      newCollectInterestTimeThreshold?: null
    ): CollectInterestTimeThresholdSetEventFilter;

    "FundsTransferred(address,address,address[],uint256,uint256,uint256)"(
      caller?: string | null,
      reserve?: null,
      stakings?: null,
      cDAIinterestEarned?: null,
      gdUBI?: null,
      gdReward?: null
    ): FundsTransferredEventFilter;
    FundsTransferred(
      caller?: string | null,
      reserve?: null,
      stakings?: null,
      cDAIinterestEarned?: null,
      gdUBI?: null,
      gdReward?: null
    ): FundsTransferredEventFilter;

    "GasCostExceptInterestCollectSet(uint256)"(
      newGasCostExceptInterestCollect?: null
    ): GasCostExceptInterestCollectSetEventFilter;
    GasCostExceptInterestCollectSet(
      newGasCostExceptInterestCollect?: null
    ): GasCostExceptInterestCollectSetEventFilter;

    "GasCostSet(uint256)"(newGasCost?: null): GasCostSetEventFilter;
    GasCostSet(newGasCost?: null): GasCostSetEventFilter;

    "Initialized(uint8)"(version?: null): InitializedEventFilter;
    Initialized(version?: null): InitializedEventFilter;

    "InterestMultiplierSet(uint8)"(
      newInterestMultiplier?: null
    ): InterestMultiplierSetEventFilter;
    InterestMultiplierSet(
      newInterestMultiplier?: null
    ): InterestMultiplierSetEventFilter;

    "StakingRewardMinted(address,address,uint256)"(
      stakingContract?: null,
      staker?: null,
      gdReward?: null
    ): StakingRewardMintedEventFilter;
    StakingRewardMinted(
      stakingContract?: null,
      staker?: null,
      gdReward?: null
    ): StakingRewardMintedEventFilter;

    "StakingRewardSet(uint32,address,uint32,uint32,bool)"(
      _rewardsPerBlock?: null,
      _stakingAddress?: null,
      _blockStart?: null,
      _blockEnd?: null,
      _isBlackListed?: null
    ): StakingRewardSetEventFilter;
    StakingRewardSet(
      _rewardsPerBlock?: null,
      _stakingAddress?: null,
      _blockStart?: null,
      _blockEnd?: null,
      _isBlackListed?: null
    ): StakingRewardSetEventFilter;

    "Upgraded(address)"(implementation?: string | null): UpgradedEventFilter;
    Upgraded(implementation?: string | null): UpgradedEventFilter;
  };

  estimateGas: {
    activeContracts(
      arg0: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

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

    collectInterest(
      _stakingContracts: string[],
      _forceAndWaiverRewards: boolean,
      overrides?: Overrides & { from?: string }
    ): Promise<BigNumber>;

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

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

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

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

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

    getGasPriceInGD(
      _gasAmount: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    getGasPriceIncDAIorDAI(
      _gasAmount: BigNumberish,
      _inDAI: boolean,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

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

    isActiveContract(
      _contract: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

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

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

    mintReward(
      _token: string,
      _user: string,
      overrides?: Overrides & { from?: string }
    ): Promise<BigNumber>;

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

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

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

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

    setCollectInterestTimeThreshold(
      _timeThreshold: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<BigNumber>;

    setGasCost(
      _gasAmount: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<BigNumber>;

    setGasCostExceptInterestCollect(
      _gasAmount: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<BigNumber>;

    setInterestMultiplier(
      _newMultiplier: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<BigNumber>;

    setStakingReward(
      _rewardsPerBlock: BigNumberish,
      _stakingAddress: string,
      _blockStart: BigNumberish,
      _blockEnd: BigNumberish,
      _isBlackListed: boolean,
      overrides?: Overrides & { from?: string }
    ): Promise<BigNumber>;

    testSorting(
      data: BigNumberish[],
      addresses: string[],
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

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

    upgradeToAndCall(
      newImplementation: string,
      data: BytesLike,
      overrides?: PayableOverrides & { from?: string }
    ): Promise<BigNumber>;
  };

  populateTransaction: {
    activeContracts(
      arg0: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

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

    collectInterest(
      _stakingContracts: string[],
      _forceAndWaiverRewards: boolean,
      overrides?: Overrides & { from?: string }
    ): Promise<PopulatedTransaction>;

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

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

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

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

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

    getGasPriceInGD(
      _gasAmount: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    getGasPriceIncDAIorDAI(
      _gasAmount: BigNumberish,
      _inDAI: boolean,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

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

    isActiveContract(
      _contract: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

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

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

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

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

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

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

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

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

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

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

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

    setStakingReward(
      _rewardsPerBlock: BigNumberish,
      _stakingAddress: string,
      _blockStart: BigNumberish,
      _blockEnd: BigNumberish,
      _isBlackListed: boolean,
      overrides?: Overrides & { from?: string }
    ): Promise<PopulatedTransaction>;

    testSorting(
      data: BigNumberish[],
      addresses: string[],
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

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

    upgradeToAndCall(
      newImplementation: string,
      data: BytesLike,
      overrides?: PayableOverrides & { from?: string }
    ): Promise<PopulatedTransaction>;
  };
}