@gooddollar/goodprotocol/types/contracts/ubi/UBIScheme.ts

GoodDollar Protocol

/* 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 interface UBISchemeInterface extends utils.Interface {
  functions: {
    "activeUsersCount()": FunctionFragment;
    "avatar()": FunctionFragment;
    "checkEntitlement(address)": FunctionFragment;
    "checkEntitlement()": FunctionFragment;
    "claim()": FunctionFragment;
    "claimDay(uint256)": FunctionFragment;
    "currentCycleLength()": FunctionFragment;
    "currentDay()": FunctionFragment;
    "currentDayInCycle()": FunctionFragment;
    "cycleLength()": FunctionFragment;
    "dailyCyclePool()": FunctionFragment;
    "dailyUBIHistory(uint256)": FunctionFragment;
    "dailyUbi()": FunctionFragment;
    "dao()": FunctionFragment;
    "estimateNextDailyUBI()": FunctionFragment;
    "firstClaimPool()": FunctionFragment;
    "fish(address)": FunctionFragment;
    "fishMulti(address[])": FunctionFragment;
    "fishedUsersAddresses(address)": FunctionFragment;
    "getClaimAmount(uint256)": FunctionFragment;
    "getClaimerCount(uint256)": FunctionFragment;
    "getDailyStats()": FunctionFragment;
    "hasClaimed(address)": FunctionFragment;
    "initialize(address,address,uint256)": FunctionFragment;
    "isActiveUser(address)": FunctionFragment;
    "isNotNewUser(address)": FunctionFragment;
    "iterationGasLimit()": FunctionFragment;
    "lastClaimed(address)": FunctionFragment;
    "lastWithdrawDay()": FunctionFragment;
    "maxInactiveDays()": FunctionFragment;
    "minActiveUsers()": FunctionFragment;
    "nameService()": FunctionFragment;
    "nativeToken()": FunctionFragment;
    "pause(bool)": FunctionFragment;
    "paused()": FunctionFragment;
    "periodStart()": FunctionFragment;
    "proxiableUUID()": FunctionFragment;
    "setActiveUserCount(uint256)": FunctionFragment;
    "setCycleLength(uint256)": FunctionFragment;
    "setDay()": FunctionFragment;
    "setShouldWithdrawFromDAO(bool)": FunctionFragment;
    "setUseFirstClaimPool(bool)": FunctionFragment;
    "shouldWithdrawFromDAO()": FunctionFragment;
    "startOfCycle()": FunctionFragment;
    "totalClaimsPerUser(address)": FunctionFragment;
    "updateAvatar()": FunctionFragment;
    "upgradeTo(address)": FunctionFragment;
    "upgradeToAndCall(address,bytes)": FunctionFragment;
    "useFirstClaimPool()": FunctionFragment;
    "withdraw(uint256,address)": FunctionFragment;
  };

  getFunction(
    nameOrSignatureOrTopic:
      | "activeUsersCount"
      | "avatar"
      | "checkEntitlement(address)"
      | "checkEntitlement()"
      | "claim"
      | "claimDay"
      | "currentCycleLength"
      | "currentDay"
      | "currentDayInCycle"
      | "cycleLength"
      | "dailyCyclePool"
      | "dailyUBIHistory"
      | "dailyUbi"
      | "dao"
      | "estimateNextDailyUBI"
      | "firstClaimPool"
      | "fish"
      | "fishMulti"
      | "fishedUsersAddresses"
      | "getClaimAmount"
      | "getClaimerCount"
      | "getDailyStats"
      | "hasClaimed"
      | "initialize"
      | "isActiveUser"
      | "isNotNewUser"
      | "iterationGasLimit"
      | "lastClaimed"
      | "lastWithdrawDay"
      | "maxInactiveDays"
      | "minActiveUsers"
      | "nameService"
      | "nativeToken"
      | "pause"
      | "paused"
      | "periodStart"
      | "proxiableUUID"
      | "setActiveUserCount"
      | "setCycleLength"
      | "setDay"
      | "setShouldWithdrawFromDAO"
      | "setUseFirstClaimPool"
      | "shouldWithdrawFromDAO"
      | "startOfCycle"
      | "totalClaimsPerUser"
      | "updateAvatar"
      | "upgradeTo"
      | "upgradeToAndCall"
      | "useFirstClaimPool"
      | "withdraw"
  ): FunctionFragment;

  encodeFunctionData(
    functionFragment: "activeUsersCount",
    values?: undefined
  ): string;
  encodeFunctionData(functionFragment: "avatar", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "checkEntitlement(address)",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "checkEntitlement()",
    values?: undefined
  ): string;
  encodeFunctionData(functionFragment: "claim", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "claimDay",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "currentCycleLength",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "currentDay",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "currentDayInCycle",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "cycleLength",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "dailyCyclePool",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "dailyUBIHistory",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(functionFragment: "dailyUbi", values?: undefined): string;
  encodeFunctionData(functionFragment: "dao", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "estimateNextDailyUBI",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "firstClaimPool",
    values?: undefined
  ): string;
  encodeFunctionData(functionFragment: "fish", values: [string]): string;
  encodeFunctionData(functionFragment: "fishMulti", values: [string[]]): string;
  encodeFunctionData(
    functionFragment: "fishedUsersAddresses",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "getClaimAmount",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "getClaimerCount",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "getDailyStats",
    values?: undefined
  ): string;
  encodeFunctionData(functionFragment: "hasClaimed", values: [string]): string;
  encodeFunctionData(
    functionFragment: "initialize",
    values: [string, string, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "isActiveUser",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "isNotNewUser",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "iterationGasLimit",
    values?: undefined
  ): string;
  encodeFunctionData(functionFragment: "lastClaimed", values: [string]): string;
  encodeFunctionData(
    functionFragment: "lastWithdrawDay",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "maxInactiveDays",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "minActiveUsers",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "nameService",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "nativeToken",
    values?: undefined
  ): string;
  encodeFunctionData(functionFragment: "pause", values: [boolean]): string;
  encodeFunctionData(functionFragment: "paused", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "periodStart",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "proxiableUUID",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "setActiveUserCount",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "setCycleLength",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(functionFragment: "setDay", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "setShouldWithdrawFromDAO",
    values: [boolean]
  ): string;
  encodeFunctionData(
    functionFragment: "setUseFirstClaimPool",
    values: [boolean]
  ): string;
  encodeFunctionData(
    functionFragment: "shouldWithdrawFromDAO",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "startOfCycle",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "totalClaimsPerUser",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "updateAvatar",
    values?: undefined
  ): string;
  encodeFunctionData(functionFragment: "upgradeTo", values: [string]): string;
  encodeFunctionData(
    functionFragment: "upgradeToAndCall",
    values: [string, BytesLike]
  ): string;
  encodeFunctionData(
    functionFragment: "useFirstClaimPool",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "withdraw",
    values: [BigNumberish, string]
  ): string;

  decodeFunctionResult(
    functionFragment: "activeUsersCount",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "avatar", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "checkEntitlement(address)",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "checkEntitlement()",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "claim", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "claimDay", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "currentCycleLength",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "currentDay", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "currentDayInCycle",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "cycleLength",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "dailyCyclePool",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "dailyUBIHistory",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "dailyUbi", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "dao", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "estimateNextDailyUBI",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "firstClaimPool",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "fish", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "fishMulti", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "fishedUsersAddresses",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getClaimAmount",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getClaimerCount",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getDailyStats",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "hasClaimed", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "initialize", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "isActiveUser",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "isNotNewUser",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "iterationGasLimit",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "lastClaimed",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "lastWithdrawDay",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "maxInactiveDays",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "minActiveUsers",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "nameService",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "nativeToken",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "pause", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "paused", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "periodStart",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "proxiableUUID",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setActiveUserCount",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setCycleLength",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "setDay", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "setShouldWithdrawFromDAO",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setUseFirstClaimPool",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "shouldWithdrawFromDAO",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "startOfCycle",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "totalClaimsPerUser",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "updateAvatar",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "upgradeTo", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "upgradeToAndCall",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "useFirstClaimPool",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "withdraw", data: BytesLike): Result;

  events: {
    "ActivatedUser(address)": EventFragment;
    "AdminChanged(address,address)": EventFragment;
    "BeaconUpgraded(address)": EventFragment;
    "CycleLengthSet(uint256)": EventFragment;
    "DaySet(uint256)": EventFragment;
    "InactiveUserFished(address,address,uint256)": EventFragment;
    "Initialized(uint8)": EventFragment;
    "ShouldWithdrawFromDAOSet(bool)": EventFragment;
    "TotalFished(uint256)": EventFragment;
    "UBICalculated(uint256,uint256,uint256)": EventFragment;
    "UBIClaimed(address,uint256)": EventFragment;
    "UBICycleCalculated(uint256,uint256,uint256,uint256)": EventFragment;
    "Upgraded(address)": EventFragment;
    "WithdrawFromDao(uint256,uint256)": EventFragment;
  };

  getEvent(nameOrSignatureOrTopic: "ActivatedUser"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "AdminChanged"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "BeaconUpgraded"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "CycleLengthSet"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "DaySet"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "InactiveUserFished"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "Initialized"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "ShouldWithdrawFromDAOSet"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "TotalFished"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "UBICalculated"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "UBIClaimed"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "UBICycleCalculated"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "Upgraded"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "WithdrawFromDao"): EventFragment;
}

export interface ActivatedUserEventObject {
  account: string;
}
export type ActivatedUserEvent = TypedEvent<[string], ActivatedUserEventObject>;

export type ActivatedUserEventFilter = TypedEventFilter<ActivatedUserEvent>;

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 CycleLengthSetEventObject {
  newCycleLength: BigNumber;
}
export type CycleLengthSetEvent = TypedEvent<
  [BigNumber],
  CycleLengthSetEventObject
>;

export type CycleLengthSetEventFilter = TypedEventFilter<CycleLengthSetEvent>;

export interface DaySetEventObject {
  newDay: BigNumber;
}
export type DaySetEvent = TypedEvent<[BigNumber], DaySetEventObject>;

export type DaySetEventFilter = TypedEventFilter<DaySetEvent>;

export interface InactiveUserFishedEventObject {
  caller: string;
  fished_account: string;
  claimAmount: BigNumber;
}
export type InactiveUserFishedEvent = TypedEvent<
  [string, string, BigNumber],
  InactiveUserFishedEventObject
>;

export type InactiveUserFishedEventFilter =
  TypedEventFilter<InactiveUserFishedEvent>;

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

export type InitializedEventFilter = TypedEventFilter<InitializedEvent>;

export interface ShouldWithdrawFromDAOSetEventObject {
  ShouldWithdrawFromDAO: boolean;
}
export type ShouldWithdrawFromDAOSetEvent = TypedEvent<
  [boolean],
  ShouldWithdrawFromDAOSetEventObject
>;

export type ShouldWithdrawFromDAOSetEventFilter =
  TypedEventFilter<ShouldWithdrawFromDAOSetEvent>;

export interface TotalFishedEventObject {
  total: BigNumber;
}
export type TotalFishedEvent = TypedEvent<[BigNumber], TotalFishedEventObject>;

export type TotalFishedEventFilter = TypedEventFilter<TotalFishedEvent>;

export interface UBICalculatedEventObject {
  day: BigNumber;
  dailyUbi: BigNumber;
  blockNumber: BigNumber;
}
export type UBICalculatedEvent = TypedEvent<
  [BigNumber, BigNumber, BigNumber],
  UBICalculatedEventObject
>;

export type UBICalculatedEventFilter = TypedEventFilter<UBICalculatedEvent>;

export interface UBIClaimedEventObject {
  claimer: string;
  amount: BigNumber;
}
export type UBIClaimedEvent = TypedEvent<
  [string, BigNumber],
  UBIClaimedEventObject
>;

export type UBIClaimedEventFilter = TypedEventFilter<UBIClaimedEvent>;

export interface UBICycleCalculatedEventObject {
  day: BigNumber;
  pool: BigNumber;
  cycleLength: BigNumber;
  dailyUBIPool: BigNumber;
}
export type UBICycleCalculatedEvent = TypedEvent<
  [BigNumber, BigNumber, BigNumber, BigNumber],
  UBICycleCalculatedEventObject
>;

export type UBICycleCalculatedEventFilter =
  TypedEventFilter<UBICycleCalculatedEvent>;

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

export type UpgradedEventFilter = TypedEventFilter<UpgradedEvent>;

export interface WithdrawFromDaoEventObject {
  prevBalance: BigNumber;
  newBalance: BigNumber;
}
export type WithdrawFromDaoEvent = TypedEvent<
  [BigNumber, BigNumber],
  WithdrawFromDaoEventObject
>;

export type WithdrawFromDaoEventFilter = TypedEventFilter<WithdrawFromDaoEvent>;

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

  interface: UBISchemeInterface;

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

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

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

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

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

    claimDay(
      arg0: BigNumberish,
      overrides?: CallOverrides
    ): Promise<
      [BigNumber, BigNumber] & {
        amountOfClaimers: BigNumber;
        claimAmount: BigNumber;
      }
    >;

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

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

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

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

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

    dailyUBIHistory(
      arg0: BigNumberish,
      overrides?: CallOverrides
    ): Promise<
      [boolean, BigNumber] & { hasWithdrawn: boolean; openAmount: BigNumber }
    >;

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

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

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

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

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

    fishMulti(
      _accounts: string[],
      overrides?: Overrides & { from?: string }
    ): Promise<ContractTransaction>;

    fishedUsersAddresses(
      arg0: string,
      overrides?: CallOverrides
    ): Promise<[boolean]>;

    getClaimAmount(
      day: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[BigNumber]>;

    getClaimerCount(
      day: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[BigNumber]>;

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

    hasClaimed(account: string, overrides?: CallOverrides): Promise<[boolean]>;

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

    isActiveUser(
      _account: string,
      overrides?: CallOverrides
    ): Promise<[boolean]>;

    isNotNewUser(
      _account: string,
      overrides?: CallOverrides
    ): Promise<[boolean]>;

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

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

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

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

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

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

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

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

    paused(overrides?: CallOverrides): Promise<[boolean]>;

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

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

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

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

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

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

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

    shouldWithdrawFromDAO(overrides?: CallOverrides): Promise<[boolean]>;

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

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

    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>;

    useFirstClaimPool(overrides?: CallOverrides): Promise<[boolean]>;

    withdraw(
      _amount: BigNumberish,
      _recipient: string,
      overrides?: Overrides & { from?: string }
    ): Promise<ContractTransaction>;
  };

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

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

  "checkEntitlement(address)"(
    _member: string,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

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

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

  claimDay(
    arg0: BigNumberish,
    overrides?: CallOverrides
  ): Promise<
    [BigNumber, BigNumber] & {
      amountOfClaimers: BigNumber;
      claimAmount: BigNumber;
    }
  >;

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

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

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

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

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

  dailyUBIHistory(
    arg0: BigNumberish,
    overrides?: CallOverrides
  ): Promise<
    [boolean, BigNumber] & { hasWithdrawn: boolean; openAmount: BigNumber }
  >;

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

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

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

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

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

  fishMulti(
    _accounts: string[],
    overrides?: Overrides & { from?: string }
  ): Promise<ContractTransaction>;

  fishedUsersAddresses(
    arg0: string,
    overrides?: CallOverrides
  ): Promise<boolean>;

  getClaimAmount(
    day: BigNumberish,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  getClaimerCount(
    day: BigNumberish,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

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

  hasClaimed(account: string, overrides?: CallOverrides): Promise<boolean>;

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

  isActiveUser(_account: string, overrides?: CallOverrides): Promise<boolean>;

  isNotNewUser(_account: string, overrides?: CallOverrides): Promise<boolean>;

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

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

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

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

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

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

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

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

  paused(overrides?: CallOverrides): Promise<boolean>;

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

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

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

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

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

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

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

  shouldWithdrawFromDAO(overrides?: CallOverrides): Promise<boolean>;

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

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

  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>;

  useFirstClaimPool(overrides?: CallOverrides): Promise<boolean>;

  withdraw(
    _amount: BigNumberish,
    _recipient: string,
    overrides?: Overrides & { from?: string }
  ): Promise<ContractTransaction>;

  callStatic: {
    activeUsersCount(overrides?: CallOverrides): Promise<BigNumber>;

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

    "checkEntitlement(address)"(
      _member: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

    claim(overrides?: CallOverrides): Promise<boolean>;

    claimDay(
      arg0: BigNumberish,
      overrides?: CallOverrides
    ): Promise<
      [BigNumber, BigNumber] & {
        amountOfClaimers: BigNumber;
        claimAmount: BigNumber;
      }
    >;

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

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

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

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

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

    dailyUBIHistory(
      arg0: BigNumberish,
      overrides?: CallOverrides
    ): Promise<
      [boolean, BigNumber] & { hasWithdrawn: boolean; openAmount: BigNumber }
    >;

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

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

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

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

    fish(_account: string, overrides?: CallOverrides): Promise<boolean>;

    fishMulti(
      _accounts: string[],
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    fishedUsersAddresses(
      arg0: string,
      overrides?: CallOverrides
    ): Promise<boolean>;

    getClaimAmount(
      day: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    getClaimerCount(
      day: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

    hasClaimed(account: string, overrides?: CallOverrides): Promise<boolean>;

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

    isActiveUser(_account: string, overrides?: CallOverrides): Promise<boolean>;

    isNotNewUser(_account: string, overrides?: CallOverrides): Promise<boolean>;

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

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

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

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

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

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

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

    pause(_pause: boolean, overrides?: CallOverrides): Promise<void>;

    paused(overrides?: CallOverrides): Promise<boolean>;

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

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

    setActiveUserCount(
      _activeUserCount: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    setCycleLength(
      _newLength: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

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

    setShouldWithdrawFromDAO(
      _shouldWithdraw: boolean,
      overrides?: CallOverrides
    ): Promise<void>;

    setUseFirstClaimPool(
      _use: boolean,
      overrides?: CallOverrides
    ): Promise<void>;

    shouldWithdrawFromDAO(overrides?: CallOverrides): Promise<boolean>;

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

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

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

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

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

    useFirstClaimPool(overrides?: CallOverrides): Promise<boolean>;

    withdraw(
      _amount: BigNumberish,
      _recipient: string,
      overrides?: CallOverrides
    ): Promise<void>;
  };

  filters: {
    "ActivatedUser(address)"(account?: string | null): ActivatedUserEventFilter;
    ActivatedUser(account?: string | null): ActivatedUserEventFilter;

    "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;

    "CycleLengthSet(uint256)"(newCycleLength?: null): CycleLengthSetEventFilter;
    CycleLengthSet(newCycleLength?: null): CycleLengthSetEventFilter;

    "DaySet(uint256)"(newDay?: null): DaySetEventFilter;
    DaySet(newDay?: null): DaySetEventFilter;

    "InactiveUserFished(address,address,uint256)"(
      caller?: string | null,
      fished_account?: string | null,
      claimAmount?: null
    ): InactiveUserFishedEventFilter;
    InactiveUserFished(
      caller?: string | null,
      fished_account?: string | null,
      claimAmount?: null
    ): InactiveUserFishedEventFilter;

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

    "ShouldWithdrawFromDAOSet(bool)"(
      ShouldWithdrawFromDAO?: null
    ): ShouldWithdrawFromDAOSetEventFilter;
    ShouldWithdrawFromDAOSet(
      ShouldWithdrawFromDAO?: null
    ): ShouldWithdrawFromDAOSetEventFilter;

    "TotalFished(uint256)"(total?: null): TotalFishedEventFilter;
    TotalFished(total?: null): TotalFishedEventFilter;

    "UBICalculated(uint256,uint256,uint256)"(
      day?: null,
      dailyUbi?: null,
      blockNumber?: null
    ): UBICalculatedEventFilter;
    UBICalculated(
      day?: null,
      dailyUbi?: null,
      blockNumber?: null
    ): UBICalculatedEventFilter;

    "UBIClaimed(address,uint256)"(
      claimer?: string | null,
      amount?: null
    ): UBIClaimedEventFilter;
    UBIClaimed(claimer?: string | null, amount?: null): UBIClaimedEventFilter;

    "UBICycleCalculated(uint256,uint256,uint256,uint256)"(
      day?: null,
      pool?: null,
      cycleLength?: null,
      dailyUBIPool?: null
    ): UBICycleCalculatedEventFilter;
    UBICycleCalculated(
      day?: null,
      pool?: null,
      cycleLength?: null,
      dailyUBIPool?: null
    ): UBICycleCalculatedEventFilter;

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

    "WithdrawFromDao(uint256,uint256)"(
      prevBalance?: null,
      newBalance?: null
    ): WithdrawFromDaoEventFilter;
    WithdrawFromDao(
      prevBalance?: null,
      newBalance?: null
    ): WithdrawFromDaoEventFilter;
  };

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

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

    "checkEntitlement(address)"(
      _member: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    fishMulti(
      _accounts: string[],
      overrides?: Overrides & { from?: string }
    ): Promise<BigNumber>;

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

    getClaimAmount(
      day: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    getClaimerCount(
      day: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

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

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

    isActiveUser(
      _account: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    isNotNewUser(
      _account: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

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

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

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

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

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

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

    pause(
      _pause: boolean,
      overrides?: Overrides & { from?: string }
    ): Promise<BigNumber>;

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

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

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

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

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

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

    setShouldWithdrawFromDAO(
      _shouldWithdraw: boolean,
      overrides?: Overrides & { from?: string }
    ): Promise<BigNumber>;

    setUseFirstClaimPool(
      _use: boolean,
      overrides?: Overrides & { from?: string }
    ): Promise<BigNumber>;

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

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

    totalClaimsPerUser(
      arg0: 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>;

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

    withdraw(
      _amount: BigNumberish,
      _recipient: string,
      overrides?: Overrides & { from?: string }
    ): Promise<BigNumber>;
  };

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

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

    "checkEntitlement(address)"(
      _member: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    fishMulti(
      _accounts: string[],
      overrides?: Overrides & { from?: string }
    ): Promise<PopulatedTransaction>;

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

    getClaimAmount(
      day: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    getClaimerCount(
      day: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

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

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

    isActiveUser(
      _account: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    isNotNewUser(
      _account: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    totalClaimsPerUser(
      arg0: 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>;

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

    withdraw(
      _amount: BigNumberish,
      _recipient: string,
      overrides?: Overrides & { from?: string }
    ): Promise<PopulatedTransaction>;
  };
}