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

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

interface BokkyPooBahsDateTimeContractInterface extends ethers.utils.Interface {
  functions: {
    "_daysFromDate(uint256,uint256,uint256)": FunctionFragment;
    "_daysToDate(uint256)": FunctionFragment;
    "_getDaysInMonth(uint256,uint256)": FunctionFragment;
    "_isLeapYear(uint256)": FunctionFragment;
    "_now()": FunctionFragment;
    "_nowDateTime()": FunctionFragment;
    "addDays(uint256,uint256)": FunctionFragment;
    "addHours(uint256,uint256)": FunctionFragment;
    "addMinutes(uint256,uint256)": FunctionFragment;
    "addMonths(uint256,uint256)": FunctionFragment;
    "addSeconds(uint256,uint256)": FunctionFragment;
    "addYears(uint256,uint256)": FunctionFragment;
    "diffDays(uint256,uint256)": FunctionFragment;
    "diffHours(uint256,uint256)": FunctionFragment;
    "diffMinutes(uint256,uint256)": FunctionFragment;
    "diffMonths(uint256,uint256)": FunctionFragment;
    "diffSeconds(uint256,uint256)": FunctionFragment;
    "diffYears(uint256,uint256)": FunctionFragment;
    "getDay(uint256)": FunctionFragment;
    "getDayOfWeek(uint256)": FunctionFragment;
    "getDaysInMonth(uint256)": FunctionFragment;
    "getDaysInYear(uint256)": FunctionFragment;
    "getHour(uint256)": FunctionFragment;
    "getMinute(uint256)": FunctionFragment;
    "getMonth(uint256)": FunctionFragment;
    "getSecond(uint256)": FunctionFragment;
    "getYear(uint256)": FunctionFragment;
    "isLeapYear(uint256)": FunctionFragment;
    "isValidDate(uint256,uint256,uint256)": FunctionFragment;
    "isValidDateTime(uint256,uint256,uint256,uint256,uint256,uint256)": FunctionFragment;
    "isWeekDay(uint256)": FunctionFragment;
    "isWeekEnd(uint256)": FunctionFragment;
    "subDays(uint256,uint256)": FunctionFragment;
    "subHours(uint256,uint256)": FunctionFragment;
    "subMinutes(uint256,uint256)": FunctionFragment;
    "subSeconds(uint256,uint256)": FunctionFragment;
    "timestampFromDate(uint256,uint256,uint256)": FunctionFragment;
    "timestampFromDateTime(uint256,uint256,uint256,uint256,uint256,uint256)": FunctionFragment;
    "timestampToDate(uint256)": FunctionFragment;
    "timestampToDateTime(uint256)": FunctionFragment;
  };

  encodeFunctionData(
    functionFragment: "_daysFromDate",
    values: [BigNumberish, BigNumberish, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "_daysToDate",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "_getDaysInMonth",
    values: [BigNumberish, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "_isLeapYear",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(functionFragment: "_now", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "_nowDateTime",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "addDays",
    values: [BigNumberish, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "addHours",
    values: [BigNumberish, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "addMinutes",
    values: [BigNumberish, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "addMonths",
    values: [BigNumberish, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "addSeconds",
    values: [BigNumberish, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "addYears",
    values: [BigNumberish, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "diffDays",
    values: [BigNumberish, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "diffHours",
    values: [BigNumberish, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "diffMinutes",
    values: [BigNumberish, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "diffMonths",
    values: [BigNumberish, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "diffSeconds",
    values: [BigNumberish, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "diffYears",
    values: [BigNumberish, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "getDay",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "getDayOfWeek",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "getDaysInMonth",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "getDaysInYear",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "getHour",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "getMinute",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "getMonth",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "getSecond",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "getYear",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "isLeapYear",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "isValidDate",
    values: [BigNumberish, BigNumberish, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "isValidDateTime",
    values: [
      BigNumberish,
      BigNumberish,
      BigNumberish,
      BigNumberish,
      BigNumberish,
      BigNumberish
    ]
  ): string;
  encodeFunctionData(
    functionFragment: "isWeekDay",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "isWeekEnd",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "subDays",
    values: [BigNumberish, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "subHours",
    values: [BigNumberish, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "subMinutes",
    values: [BigNumberish, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "subSeconds",
    values: [BigNumberish, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "timestampFromDate",
    values: [BigNumberish, BigNumberish, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "timestampFromDateTime",
    values: [
      BigNumberish,
      BigNumberish,
      BigNumberish,
      BigNumberish,
      BigNumberish,
      BigNumberish
    ]
  ): string;
  encodeFunctionData(
    functionFragment: "timestampToDate",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "timestampToDateTime",
    values: [BigNumberish]
  ): string;

  decodeFunctionResult(
    functionFragment: "_daysFromDate",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "_daysToDate",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "_getDaysInMonth",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "_isLeapYear",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "_now", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "_nowDateTime",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "addDays", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "addHours", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "addMinutes", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "addMonths", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "addSeconds", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "addYears", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "diffDays", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "diffHours", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "diffMinutes",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "diffMonths", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "diffSeconds",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "diffYears", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "getDay", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "getDayOfWeek",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getDaysInMonth",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getDaysInYear",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "getHour", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "getMinute", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "getMonth", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "getSecond", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "getYear", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "isLeapYear", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "isValidDate",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "isValidDateTime",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "isWeekDay", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "isWeekEnd", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "subDays", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "subHours", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "subMinutes", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "subSeconds", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "timestampFromDate",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "timestampFromDateTime",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "timestampToDate",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "timestampToDateTime",
    data: BytesLike
  ): Result;

  events: {};
}

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

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

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

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

  interface: BokkyPooBahsDateTimeContractInterface;

  functions: {
    _daysFromDate(
      year: BigNumberish,
      month: BigNumberish,
      day: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[BigNumber] & { _days: BigNumber }>;

    _daysToDate(
      _days: BigNumberish,
      overrides?: CallOverrides
    ): Promise<
      [BigNumber, BigNumber, BigNumber] & {
        year: BigNumber;
        month: BigNumber;
        day: BigNumber;
      }
    >;

    _getDaysInMonth(
      year: BigNumberish,
      month: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[BigNumber] & { daysInMonth: BigNumber }>;

    _isLeapYear(
      year: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[boolean] & { leapYear: boolean }>;

    _now(
      overrides?: CallOverrides
    ): Promise<[BigNumber] & { timestamp: BigNumber }>;

    _nowDateTime(
      overrides?: CallOverrides
    ): Promise<
      [BigNumber, BigNumber, BigNumber, BigNumber, BigNumber, BigNumber] & {
        year: BigNumber;
        month: BigNumber;
        day: BigNumber;
        hour: BigNumber;
        minute: BigNumber;
        second: BigNumber;
      }
    >;

    addDays(
      timestamp: BigNumberish,
      _days: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[BigNumber] & { newTimestamp: BigNumber }>;

    addHours(
      timestamp: BigNumberish,
      _hours: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[BigNumber] & { newTimestamp: BigNumber }>;

    addMinutes(
      timestamp: BigNumberish,
      _minutes: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[BigNumber] & { newTimestamp: BigNumber }>;

    addMonths(
      timestamp: BigNumberish,
      _months: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[BigNumber] & { newTimestamp: BigNumber }>;

    addSeconds(
      timestamp: BigNumberish,
      _seconds: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[BigNumber] & { newTimestamp: BigNumber }>;

    addYears(
      timestamp: BigNumberish,
      _years: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[BigNumber] & { newTimestamp: BigNumber }>;

    diffDays(
      fromTimestamp: BigNumberish,
      toTimestamp: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[BigNumber] & { _days: BigNumber }>;

    diffHours(
      fromTimestamp: BigNumberish,
      toTimestamp: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[BigNumber] & { _hours: BigNumber }>;

    diffMinutes(
      fromTimestamp: BigNumberish,
      toTimestamp: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[BigNumber] & { _minutes: BigNumber }>;

    diffMonths(
      fromTimestamp: BigNumberish,
      toTimestamp: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[BigNumber] & { _months: BigNumber }>;

    diffSeconds(
      fromTimestamp: BigNumberish,
      toTimestamp: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[BigNumber] & { _seconds: BigNumber }>;

    diffYears(
      fromTimestamp: BigNumberish,
      toTimestamp: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[BigNumber] & { _years: BigNumber }>;

    getDay(
      timestamp: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[BigNumber] & { day: BigNumber }>;

    getDayOfWeek(
      timestamp: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[BigNumber] & { dayOfWeek: BigNumber }>;

    getDaysInMonth(
      timestamp: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[BigNumber] & { daysInMonth: BigNumber }>;

    getDaysInYear(
      timestamp: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[BigNumber] & { daysInYear: BigNumber }>;

    getHour(
      timestamp: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[BigNumber] & { hour: BigNumber }>;

    getMinute(
      timestamp: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[BigNumber] & { minute: BigNumber }>;

    getMonth(
      timestamp: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[BigNumber] & { month: BigNumber }>;

    getSecond(
      timestamp: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[BigNumber] & { second: BigNumber }>;

    getYear(
      timestamp: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[BigNumber] & { year: BigNumber }>;

    isLeapYear(
      timestamp: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[boolean] & { leapYear: boolean }>;

    isValidDate(
      year: BigNumberish,
      month: BigNumberish,
      day: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[boolean] & { valid: boolean }>;

    isValidDateTime(
      year: BigNumberish,
      month: BigNumberish,
      day: BigNumberish,
      hour: BigNumberish,
      minute: BigNumberish,
      second: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[boolean] & { valid: boolean }>;

    isWeekDay(
      timestamp: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[boolean] & { weekDay: boolean }>;

    isWeekEnd(
      timestamp: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[boolean] & { weekEnd: boolean }>;

    subDays(
      timestamp: BigNumberish,
      _days: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[BigNumber] & { newTimestamp: BigNumber }>;

    subHours(
      timestamp: BigNumberish,
      _hours: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[BigNumber] & { newTimestamp: BigNumber }>;

    subMinutes(
      timestamp: BigNumberish,
      _minutes: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[BigNumber] & { newTimestamp: BigNumber }>;

    subSeconds(
      timestamp: BigNumberish,
      _seconds: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[BigNumber] & { newTimestamp: BigNumber }>;

    timestampFromDate(
      year: BigNumberish,
      month: BigNumberish,
      day: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[BigNumber] & { timestamp: BigNumber }>;

    timestampFromDateTime(
      year: BigNumberish,
      month: BigNumberish,
      day: BigNumberish,
      hour: BigNumberish,
      minute: BigNumberish,
      second: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[BigNumber] & { timestamp: BigNumber }>;

    timestampToDate(
      timestamp: BigNumberish,
      overrides?: CallOverrides
    ): Promise<
      [BigNumber, BigNumber, BigNumber] & {
        year: BigNumber;
        month: BigNumber;
        day: BigNumber;
      }
    >;

    timestampToDateTime(
      timestamp: BigNumberish,
      overrides?: CallOverrides
    ): Promise<
      [BigNumber, BigNumber, BigNumber, BigNumber, BigNumber, BigNumber] & {
        year: BigNumber;
        month: BigNumber;
        day: BigNumber;
        hour: BigNumber;
        minute: BigNumber;
        second: BigNumber;
      }
    >;
  };

  _daysFromDate(
    year: BigNumberish,
    month: BigNumberish,
    day: BigNumberish,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  _daysToDate(
    _days: BigNumberish,
    overrides?: CallOverrides
  ): Promise<
    [BigNumber, BigNumber, BigNumber] & {
      year: BigNumber;
      month: BigNumber;
      day: BigNumber;
    }
  >;

  _getDaysInMonth(
    year: BigNumberish,
    month: BigNumberish,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  _isLeapYear(year: BigNumberish, overrides?: CallOverrides): Promise<boolean>;

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

  _nowDateTime(
    overrides?: CallOverrides
  ): Promise<
    [BigNumber, BigNumber, BigNumber, BigNumber, BigNumber, BigNumber] & {
      year: BigNumber;
      month: BigNumber;
      day: BigNumber;
      hour: BigNumber;
      minute: BigNumber;
      second: BigNumber;
    }
  >;

  addDays(
    timestamp: BigNumberish,
    _days: BigNumberish,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  addHours(
    timestamp: BigNumberish,
    _hours: BigNumberish,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  addMinutes(
    timestamp: BigNumberish,
    _minutes: BigNumberish,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  addMonths(
    timestamp: BigNumberish,
    _months: BigNumberish,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  addSeconds(
    timestamp: BigNumberish,
    _seconds: BigNumberish,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  addYears(
    timestamp: BigNumberish,
    _years: BigNumberish,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  diffDays(
    fromTimestamp: BigNumberish,
    toTimestamp: BigNumberish,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  diffHours(
    fromTimestamp: BigNumberish,
    toTimestamp: BigNumberish,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  diffMinutes(
    fromTimestamp: BigNumberish,
    toTimestamp: BigNumberish,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  diffMonths(
    fromTimestamp: BigNumberish,
    toTimestamp: BigNumberish,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  diffSeconds(
    fromTimestamp: BigNumberish,
    toTimestamp: BigNumberish,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  diffYears(
    fromTimestamp: BigNumberish,
    toTimestamp: BigNumberish,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  getDay(
    timestamp: BigNumberish,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  getDayOfWeek(
    timestamp: BigNumberish,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  getDaysInMonth(
    timestamp: BigNumberish,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  getDaysInYear(
    timestamp: BigNumberish,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  getHour(
    timestamp: BigNumberish,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  getMinute(
    timestamp: BigNumberish,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  getMonth(
    timestamp: BigNumberish,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  getSecond(
    timestamp: BigNumberish,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  getYear(
    timestamp: BigNumberish,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  isLeapYear(
    timestamp: BigNumberish,
    overrides?: CallOverrides
  ): Promise<boolean>;

  isValidDate(
    year: BigNumberish,
    month: BigNumberish,
    day: BigNumberish,
    overrides?: CallOverrides
  ): Promise<boolean>;

  isValidDateTime(
    year: BigNumberish,
    month: BigNumberish,
    day: BigNumberish,
    hour: BigNumberish,
    minute: BigNumberish,
    second: BigNumberish,
    overrides?: CallOverrides
  ): Promise<boolean>;

  isWeekDay(
    timestamp: BigNumberish,
    overrides?: CallOverrides
  ): Promise<boolean>;

  isWeekEnd(
    timestamp: BigNumberish,
    overrides?: CallOverrides
  ): Promise<boolean>;

  subDays(
    timestamp: BigNumberish,
    _days: BigNumberish,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  subHours(
    timestamp: BigNumberish,
    _hours: BigNumberish,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  subMinutes(
    timestamp: BigNumberish,
    _minutes: BigNumberish,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  subSeconds(
    timestamp: BigNumberish,
    _seconds: BigNumberish,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  timestampFromDate(
    year: BigNumberish,
    month: BigNumberish,
    day: BigNumberish,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  timestampFromDateTime(
    year: BigNumberish,
    month: BigNumberish,
    day: BigNumberish,
    hour: BigNumberish,
    minute: BigNumberish,
    second: BigNumberish,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  timestampToDate(
    timestamp: BigNumberish,
    overrides?: CallOverrides
  ): Promise<
    [BigNumber, BigNumber, BigNumber] & {
      year: BigNumber;
      month: BigNumber;
      day: BigNumber;
    }
  >;

  timestampToDateTime(
    timestamp: BigNumberish,
    overrides?: CallOverrides
  ): Promise<
    [BigNumber, BigNumber, BigNumber, BigNumber, BigNumber, BigNumber] & {
      year: BigNumber;
      month: BigNumber;
      day: BigNumber;
      hour: BigNumber;
      minute: BigNumber;
      second: BigNumber;
    }
  >;

  callStatic: {
    _daysFromDate(
      year: BigNumberish,
      month: BigNumberish,
      day: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    _daysToDate(
      _days: BigNumberish,
      overrides?: CallOverrides
    ): Promise<
      [BigNumber, BigNumber, BigNumber] & {
        year: BigNumber;
        month: BigNumber;
        day: BigNumber;
      }
    >;

    _getDaysInMonth(
      year: BigNumberish,
      month: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    _isLeapYear(
      year: BigNumberish,
      overrides?: CallOverrides
    ): Promise<boolean>;

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

    _nowDateTime(
      overrides?: CallOverrides
    ): Promise<
      [BigNumber, BigNumber, BigNumber, BigNumber, BigNumber, BigNumber] & {
        year: BigNumber;
        month: BigNumber;
        day: BigNumber;
        hour: BigNumber;
        minute: BigNumber;
        second: BigNumber;
      }
    >;

    addDays(
      timestamp: BigNumberish,
      _days: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    addHours(
      timestamp: BigNumberish,
      _hours: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    addMinutes(
      timestamp: BigNumberish,
      _minutes: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    addMonths(
      timestamp: BigNumberish,
      _months: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    addSeconds(
      timestamp: BigNumberish,
      _seconds: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    addYears(
      timestamp: BigNumberish,
      _years: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    diffDays(
      fromTimestamp: BigNumberish,
      toTimestamp: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    diffHours(
      fromTimestamp: BigNumberish,
      toTimestamp: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    diffMinutes(
      fromTimestamp: BigNumberish,
      toTimestamp: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    diffMonths(
      fromTimestamp: BigNumberish,
      toTimestamp: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    diffSeconds(
      fromTimestamp: BigNumberish,
      toTimestamp: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    diffYears(
      fromTimestamp: BigNumberish,
      toTimestamp: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    getDay(
      timestamp: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    getDayOfWeek(
      timestamp: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    getDaysInMonth(
      timestamp: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    getDaysInYear(
      timestamp: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    getHour(
      timestamp: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    getMinute(
      timestamp: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    getMonth(
      timestamp: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    getSecond(
      timestamp: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    getYear(
      timestamp: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    isLeapYear(
      timestamp: BigNumberish,
      overrides?: CallOverrides
    ): Promise<boolean>;

    isValidDate(
      year: BigNumberish,
      month: BigNumberish,
      day: BigNumberish,
      overrides?: CallOverrides
    ): Promise<boolean>;

    isValidDateTime(
      year: BigNumberish,
      month: BigNumberish,
      day: BigNumberish,
      hour: BigNumberish,
      minute: BigNumberish,
      second: BigNumberish,
      overrides?: CallOverrides
    ): Promise<boolean>;

    isWeekDay(
      timestamp: BigNumberish,
      overrides?: CallOverrides
    ): Promise<boolean>;

    isWeekEnd(
      timestamp: BigNumberish,
      overrides?: CallOverrides
    ): Promise<boolean>;

    subDays(
      timestamp: BigNumberish,
      _days: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    subHours(
      timestamp: BigNumberish,
      _hours: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    subMinutes(
      timestamp: BigNumberish,
      _minutes: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    subSeconds(
      timestamp: BigNumberish,
      _seconds: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    timestampFromDate(
      year: BigNumberish,
      month: BigNumberish,
      day: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    timestampFromDateTime(
      year: BigNumberish,
      month: BigNumberish,
      day: BigNumberish,
      hour: BigNumberish,
      minute: BigNumberish,
      second: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    timestampToDate(
      timestamp: BigNumberish,
      overrides?: CallOverrides
    ): Promise<
      [BigNumber, BigNumber, BigNumber] & {
        year: BigNumber;
        month: BigNumber;
        day: BigNumber;
      }
    >;

    timestampToDateTime(
      timestamp: BigNumberish,
      overrides?: CallOverrides
    ): Promise<
      [BigNumber, BigNumber, BigNumber, BigNumber, BigNumber, BigNumber] & {
        year: BigNumber;
        month: BigNumber;
        day: BigNumber;
        hour: BigNumber;
        minute: BigNumber;
        second: BigNumber;
      }
    >;
  };

  filters: {};

  estimateGas: {
    _daysFromDate(
      year: BigNumberish,
      month: BigNumberish,
      day: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    _daysToDate(
      _days: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    _getDaysInMonth(
      year: BigNumberish,
      month: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    _isLeapYear(
      year: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

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

    addDays(
      timestamp: BigNumberish,
      _days: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    addHours(
      timestamp: BigNumberish,
      _hours: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    addMinutes(
      timestamp: BigNumberish,
      _minutes: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    addMonths(
      timestamp: BigNumberish,
      _months: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    addSeconds(
      timestamp: BigNumberish,
      _seconds: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    addYears(
      timestamp: BigNumberish,
      _years: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    diffDays(
      fromTimestamp: BigNumberish,
      toTimestamp: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    diffHours(
      fromTimestamp: BigNumberish,
      toTimestamp: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    diffMinutes(
      fromTimestamp: BigNumberish,
      toTimestamp: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    diffMonths(
      fromTimestamp: BigNumberish,
      toTimestamp: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    diffSeconds(
      fromTimestamp: BigNumberish,
      toTimestamp: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    diffYears(
      fromTimestamp: BigNumberish,
      toTimestamp: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    getDay(
      timestamp: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    getDayOfWeek(
      timestamp: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    getDaysInMonth(
      timestamp: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    getDaysInYear(
      timestamp: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    getHour(
      timestamp: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    getMinute(
      timestamp: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    getMonth(
      timestamp: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    getSecond(
      timestamp: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    getYear(
      timestamp: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    isLeapYear(
      timestamp: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    isValidDate(
      year: BigNumberish,
      month: BigNumberish,
      day: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    isValidDateTime(
      year: BigNumberish,
      month: BigNumberish,
      day: BigNumberish,
      hour: BigNumberish,
      minute: BigNumberish,
      second: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    isWeekDay(
      timestamp: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    isWeekEnd(
      timestamp: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    subDays(
      timestamp: BigNumberish,
      _days: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    subHours(
      timestamp: BigNumberish,
      _hours: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    subMinutes(
      timestamp: BigNumberish,
      _minutes: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    subSeconds(
      timestamp: BigNumberish,
      _seconds: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    timestampFromDate(
      year: BigNumberish,
      month: BigNumberish,
      day: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    timestampFromDateTime(
      year: BigNumberish,
      month: BigNumberish,
      day: BigNumberish,
      hour: BigNumberish,
      minute: BigNumberish,
      second: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    timestampToDate(
      timestamp: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    timestampToDateTime(
      timestamp: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;
  };

  populateTransaction: {
    _daysFromDate(
      year: BigNumberish,
      month: BigNumberish,
      day: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    _daysToDate(
      _days: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    _getDaysInMonth(
      year: BigNumberish,
      month: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    _isLeapYear(
      year: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

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

    addDays(
      timestamp: BigNumberish,
      _days: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    addHours(
      timestamp: BigNumberish,
      _hours: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    addMinutes(
      timestamp: BigNumberish,
      _minutes: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    addMonths(
      timestamp: BigNumberish,
      _months: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    addSeconds(
      timestamp: BigNumberish,
      _seconds: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    addYears(
      timestamp: BigNumberish,
      _years: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    diffDays(
      fromTimestamp: BigNumberish,
      toTimestamp: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    diffHours(
      fromTimestamp: BigNumberish,
      toTimestamp: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    diffMinutes(
      fromTimestamp: BigNumberish,
      toTimestamp: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    diffMonths(
      fromTimestamp: BigNumberish,
      toTimestamp: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    diffSeconds(
      fromTimestamp: BigNumberish,
      toTimestamp: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    diffYears(
      fromTimestamp: BigNumberish,
      toTimestamp: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    getDay(
      timestamp: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    getDayOfWeek(
      timestamp: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    getDaysInMonth(
      timestamp: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    getDaysInYear(
      timestamp: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    getHour(
      timestamp: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    getMinute(
      timestamp: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    getMonth(
      timestamp: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    getSecond(
      timestamp: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    getYear(
      timestamp: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    isLeapYear(
      timestamp: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    isValidDate(
      year: BigNumberish,
      month: BigNumberish,
      day: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    isValidDateTime(
      year: BigNumberish,
      month: BigNumberish,
      day: BigNumberish,
      hour: BigNumberish,
      minute: BigNumberish,
      second: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    isWeekDay(
      timestamp: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    isWeekEnd(
      timestamp: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    subDays(
      timestamp: BigNumberish,
      _days: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    subHours(
      timestamp: BigNumberish,
      _hours: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    subMinutes(
      timestamp: BigNumberish,
      _minutes: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    subSeconds(
      timestamp: BigNumberish,
      _seconds: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    timestampFromDate(
      year: BigNumberish,
      month: BigNumberish,
      day: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    timestampFromDateTime(
      year: BigNumberish,
      month: BigNumberish,
      day: BigNumberish,
      hour: BigNumberish,
      minute: BigNumberish,
      second: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    timestampToDate(
      timestamp: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    timestampToDateTime(
      timestamp: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;
  };
}