lakutata 2.0.1 → 2.0.2

package/vendor/TypeDef.1.d.ts

@@ -1,490 +1,275 @@
-/*! *****************************************************************************
-Copyright (C) Microsoft. All rights reserved.
-Licensed under the Apache License, Version 2.0 (the "License"); you may not use
-this file except in compliance with the License. You may obtain a copy of the
-License at http://www.apache.org/licenses/LICENSE-2.0
-
-THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
-WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
-MERCHANTABLITY OR NON-INFRINGEMENT.
-
-See the Apache Version 2.0 License for specific language governing permissions
-and limitations under the License.
-***************************************************************************** */
-
-
-
-declare global {
-    namespace Reflect {
-        /**
-          * Applies a set of decorators to a target object.
-          * @param decorators An array of decorators.
-          * @param target The target object.
-          * @returns The result of applying the provided decorators.
-          * @remarks Decorators are applied in reverse order of their positions in the array.
-          * @example
-          *
-          *     class Example { }
-          *
-          *     // constructor
-          *     Example = Reflect.decorate(decoratorsArray, Example);
-          *
-          */
-        function decorate(decorators: ClassDecorator[], target: Function): Function;
-        /**
-          * Applies a set of decorators to a property of a target object.
-          * @param decorators An array of decorators.
-          * @param target The target object.
-          * @param propertyKey The property key to decorate.
-          * @param attributes A property descriptor.
-          * @remarks Decorators are applied in reverse order.
-          * @example
-          *
-          *     class Example {
-          *         // property declarations are not part of ES6, though they are valid in TypeScript:
-          *         // static staticProperty;
-          *         // property;
-          *
-          *         static staticMethod() { }
-          *         method() { }
-          *     }
-          *
-          *     // property (on constructor)
-          *     Reflect.decorate(decoratorsArray, Example, "staticProperty");
-          *
-          *     // property (on prototype)
-          *     Reflect.decorate(decoratorsArray, Example.prototype, "property");
-          *
-          *     // method (on constructor)
-          *     Object.defineProperty(Example, "staticMethod",
-          *         Reflect.decorate(decoratorsArray, Example, "staticMethod",
-          *             Object.getOwnPropertyDescriptor(Example, "staticMethod")));
-          *
-          *     // method (on prototype)
-          *     Object.defineProperty(Example.prototype, "method",
-          *         Reflect.decorate(decoratorsArray, Example.prototype, "method",
-          *             Object.getOwnPropertyDescriptor(Example.prototype, "method")));
-          *
-          */
-        function decorate(decorators: (PropertyDecorator | MethodDecorator)[], target: Object, propertyKey: string | symbol, attributes?: PropertyDescriptor): PropertyDescriptor;
-        /**
-          * A default metadata decorator factory that can be used on a class, class member, or parameter.
-          * @param metadataKey The key for the metadata entry.
-          * @param metadataValue The value for the metadata entry.
-          * @returns A decorator function.
-          * @remarks
-          * If `metadataKey` is already defined for the target and target key, the
-          * metadataValue for that key will be overwritten.
-          * @example
-          *
-          *     // constructor
-          *     @Reflect.metadata(key, value)
-          *     class Example {
-          *     }
-          *
-          *     // property (on constructor, TypeScript only)
-          *     class Example {
-          *         @Reflect.metadata(key, value)
-          *         static staticProperty;
-          *     }
-          *
-          *     // property (on prototype, TypeScript only)
-          *     class Example {
-          *         @Reflect.metadata(key, value)
-          *         property;
-          *     }
-          *
-          *     // method (on constructor)
-          *     class Example {
-          *         @Reflect.metadata(key, value)
-          *         static staticMethod() { }
-          *     }
-          *
-          *     // method (on prototype)
-          *     class Example {
-          *         @Reflect.metadata(key, value)
-          *         method() { }
-          *     }
-          *
-          */
-        function metadata(metadataKey: any, metadataValue: any): {
-            (target: Function): void;
-            (target: Object, propertyKey: string | symbol): void;
-        };
-        /**
-          * Define a unique metadata entry on the target.
-          * @param metadataKey A key used to store and retrieve metadata.
-          * @param metadataValue A value that contains attached metadata.
-          * @param target The target object on which to define metadata.
-          * @example
-          *
-          *     class Example {
-          *     }
-          *
-          *     // constructor
-          *     Reflect.defineMetadata("custom:annotation", options, Example);
-          *
-          *     // decorator factory as metadata-producing annotation.
-          *     function MyAnnotation(options): ClassDecorator {
-          *         return target => Reflect.defineMetadata("custom:annotation", options, target);
-          *     }
-          *
-          */
-        function defineMetadata(metadataKey: any, metadataValue: any, target: Object): void;
-        /**
-          * Define a unique metadata entry on the target.
-          * @param metadataKey A key used to store and retrieve metadata.
-          * @param metadataValue A value that contains attached metadata.
-          * @param target The target object on which to define metadata.
-          * @param propertyKey The property key for the target.
-          * @example
-          *
-          *     class Example {
-          *         // property declarations are not part of ES6, though they are valid in TypeScript:
-          *         // static staticProperty;
-          *         // property;
-          *
-          *         static staticMethod(p) { }
-          *         method(p) { }
-          *     }
-          *
-          *     // property (on constructor)
-          *     Reflect.defineMetadata("custom:annotation", Number, Example, "staticProperty");
-          *
-          *     // property (on prototype)
-          *     Reflect.defineMetadata("custom:annotation", Number, Example.prototype, "property");
-          *
-          *     // method (on constructor)
-          *     Reflect.defineMetadata("custom:annotation", Number, Example, "staticMethod");
-          *
-          *     // method (on prototype)
-          *     Reflect.defineMetadata("custom:annotation", Number, Example.prototype, "method");
-          *
-          *     // decorator factory as metadata-producing annotation.
-          *     function MyAnnotation(options): PropertyDecorator {
-          *         return (target, key) => Reflect.defineMetadata("custom:annotation", options, target, key);
-          *     }
-          *
-          */
-        function defineMetadata(metadataKey: any, metadataValue: any, target: Object, propertyKey: string | symbol): void;
-        /**
-          * Gets a value indicating whether the target object or its prototype chain has the provided metadata key defined.
-          * @param metadataKey A key used to store and retrieve metadata.
-          * @param target The target object on which the metadata is defined.
-          * @returns `true` if the metadata key was defined on the target object or its prototype chain; otherwise, `false`.
-          * @example
-          *
-          *     class Example {
-          *     }
-          *
-          *     // constructor
-          *     result = Reflect.hasMetadata("custom:annotation", Example);
-          *
-          */
-        function hasMetadata(metadataKey: any, target: Object): boolean;
-        /**
-          * Gets a value indicating whether the target object or its prototype chain has the provided metadata key defined.
-          * @param metadataKey A key used to store and retrieve metadata.
-          * @param target The target object on which the metadata is defined.
-          * @param propertyKey The property key for the target.
-          * @returns `true` if the metadata key was defined on the target object or its prototype chain; otherwise, `false`.
-          * @example
-          *
-          *     class Example {
-          *         // property declarations are not part of ES6, though they are valid in TypeScript:
-          *         // static staticProperty;
-          *         // property;
-          *
-          *         static staticMethod(p) { }
-          *         method(p) { }
-          *     }
-          *
-          *     // property (on constructor)
-          *     result = Reflect.hasMetadata("custom:annotation", Example, "staticProperty");
-          *
-          *     // property (on prototype)
-          *     result = Reflect.hasMetadata("custom:annotation", Example.prototype, "property");
-          *
-          *     // method (on constructor)
-          *     result = Reflect.hasMetadata("custom:annotation", Example, "staticMethod");
-          *
-          *     // method (on prototype)
-          *     result = Reflect.hasMetadata("custom:annotation", Example.prototype, "method");
-          *
-          */
-        function hasMetadata(metadataKey: any, target: Object, propertyKey: string | symbol): boolean;
-        /**
-          * Gets a value indicating whether the target object has the provided metadata key defined.
-          * @param metadataKey A key used to store and retrieve metadata.
-          * @param target The target object on which the metadata is defined.
-          * @returns `true` if the metadata key was defined on the target object; otherwise, `false`.
-          * @example
-          *
-          *     class Example {
-          *     }
-          *
-          *     // constructor
-          *     result = Reflect.hasOwnMetadata("custom:annotation", Example);
-          *
-          */
-        function hasOwnMetadata(metadataKey: any, target: Object): boolean;
-        /**
-          * Gets a value indicating whether the target object has the provided metadata key defined.
-          * @param metadataKey A key used to store and retrieve metadata.
-          * @param target The target object on which the metadata is defined.
-          * @param propertyKey The property key for the target.
-          * @returns `true` if the metadata key was defined on the target object; otherwise, `false`.
-          * @example
-          *
-          *     class Example {
-          *         // property declarations are not part of ES6, though they are valid in TypeScript:
-          *         // static staticProperty;
-          *         // property;
-          *
-          *         static staticMethod(p) { }
-          *         method(p) { }
-          *     }
-          *
-          *     // property (on constructor)
-          *     result = Reflect.hasOwnMetadata("custom:annotation", Example, "staticProperty");
-          *
-          *     // property (on prototype)
-          *     result = Reflect.hasOwnMetadata("custom:annotation", Example.prototype, "property");
-          *
-          *     // method (on constructor)
-          *     result = Reflect.hasOwnMetadata("custom:annotation", Example, "staticMethod");
-          *
-          *     // method (on prototype)
-          *     result = Reflect.hasOwnMetadata("custom:annotation", Example.prototype, "method");
-          *
-          */
-        function hasOwnMetadata(metadataKey: any, target: Object, propertyKey: string | symbol): boolean;
-        /**
-          * Gets the metadata value for the provided metadata key on the target object or its prototype chain.
-          * @param metadataKey A key used to store and retrieve metadata.
-          * @param target The target object on which the metadata is defined.
-          * @returns The metadata value for the metadata key if found; otherwise, `undefined`.
-          * @example
-          *
-          *     class Example {
-          *     }
-          *
-          *     // constructor
-          *     result = Reflect.getMetadata("custom:annotation", Example);
-          *
-          */
-        function getMetadata(metadataKey: any, target: Object): any;
-        /**
-          * Gets the metadata value for the provided metadata key on the target object or its prototype chain.
-          * @param metadataKey A key used to store and retrieve metadata.
-          * @param target The target object on which the metadata is defined.
-          * @param propertyKey The property key for the target.
-          * @returns The metadata value for the metadata key if found; otherwise, `undefined`.
-          * @example
-          *
-          *     class Example {
-          *         // property declarations are not part of ES6, though they are valid in TypeScript:
-          *         // static staticProperty;
-          *         // property;
-          *
-          *         static staticMethod(p) { }
-          *         method(p) { }
-          *     }
-          *
-          *     // property (on constructor)
-          *     result = Reflect.getMetadata("custom:annotation", Example, "staticProperty");
-          *
-          *     // property (on prototype)
-          *     result = Reflect.getMetadata("custom:annotation", Example.prototype, "property");
-          *
-          *     // method (on constructor)
-          *     result = Reflect.getMetadata("custom:annotation", Example, "staticMethod");
-          *
-          *     // method (on prototype)
-          *     result = Reflect.getMetadata("custom:annotation", Example.prototype, "method");
-          *
-          */
-        function getMetadata(metadataKey: any, target: Object, propertyKey: string | symbol): any;
-        /**
-          * Gets the metadata value for the provided metadata key on the target object.
-          * @param metadataKey A key used to store and retrieve metadata.
-          * @param target The target object on which the metadata is defined.
-          * @returns The metadata value for the metadata key if found; otherwise, `undefined`.
-          * @example
-          *
-          *     class Example {
-          *     }
-          *
-          *     // constructor
-          *     result = Reflect.getOwnMetadata("custom:annotation", Example);
-          *
-          */
-        function getOwnMetadata(metadataKey: any, target: Object): any;
-        /**
-          * Gets the metadata value for the provided metadata key on the target object.
-          * @param metadataKey A key used to store and retrieve metadata.
-          * @param target The target object on which the metadata is defined.
-          * @param propertyKey The property key for the target.
-          * @returns The metadata value for the metadata key if found; otherwise, `undefined`.
-          * @example
-          *
-          *     class Example {
-          *         // property declarations are not part of ES6, though they are valid in TypeScript:
-          *         // static staticProperty;
-          *         // property;
-          *
-          *         static staticMethod(p) { }
-          *         method(p) { }
-          *     }
-          *
-          *     // property (on constructor)
-          *     result = Reflect.getOwnMetadata("custom:annotation", Example, "staticProperty");
-          *
-          *     // property (on prototype)
-          *     result = Reflect.getOwnMetadata("custom:annotation", Example.prototype, "property");
-          *
-          *     // method (on constructor)
-          *     result = Reflect.getOwnMetadata("custom:annotation", Example, "staticMethod");
-          *
-          *     // method (on prototype)
-          *     result = Reflect.getOwnMetadata("custom:annotation", Example.prototype, "method");
-          *
-          */
-        function getOwnMetadata(metadataKey: any, target: Object, propertyKey: string | symbol): any;
-        /**
-          * Gets the metadata keys defined on the target object or its prototype chain.
-          * @param target The target object on which the metadata is defined.
-          * @returns An array of unique metadata keys.
-          * @example
-          *
-          *     class Example {
-          *     }
-          *
-          *     // constructor
-          *     result = Reflect.getMetadataKeys(Example);
-          *
-          */
-        function getMetadataKeys(target: Object): any[];
-        /**
-          * Gets the metadata keys defined on the target object or its prototype chain.
-          * @param target The target object on which the metadata is defined.
-          * @param propertyKey The property key for the target.
-          * @returns An array of unique metadata keys.
-          * @example
-          *
-          *     class Example {
-          *         // property declarations are not part of ES6, though they are valid in TypeScript:
-          *         // static staticProperty;
-          *         // property;
-          *
-          *         static staticMethod(p) { }
-          *         method(p) { }
-          *     }
-          *
-          *     // property (on constructor)
-          *     result = Reflect.getMetadataKeys(Example, "staticProperty");
-          *
-          *     // property (on prototype)
-          *     result = Reflect.getMetadataKeys(Example.prototype, "property");
-          *
-          *     // method (on constructor)
-          *     result = Reflect.getMetadataKeys(Example, "staticMethod");
-          *
-          *     // method (on prototype)
-          *     result = Reflect.getMetadataKeys(Example.prototype, "method");
-          *
-          */
-        function getMetadataKeys(target: Object, propertyKey: string | symbol): any[];
-        /**
-          * Gets the unique metadata keys defined on the target object.
-          * @param target The target object on which the metadata is defined.
-          * @returns An array of unique metadata keys.
-          * @example
-          *
-          *     class Example {
-          *     }
-          *
-          *     // constructor
-          *     result = Reflect.getOwnMetadataKeys(Example);
-          *
-          */
-        function getOwnMetadataKeys(target: Object): any[];
-        /**
-          * Gets the unique metadata keys defined on the target object.
-          * @param target The target object on which the metadata is defined.
-          * @param propertyKey The property key for the target.
-          * @returns An array of unique metadata keys.
-          * @example
-          *
-          *     class Example {
-          *         // property declarations are not part of ES6, though they are valid in TypeScript:
-          *         // static staticProperty;
-          *         // property;
-          *
-          *         static staticMethod(p) { }
-          *         method(p) { }
-          *     }
-          *
-          *     // property (on constructor)
-          *     result = Reflect.getOwnMetadataKeys(Example, "staticProperty");
-          *
-          *     // property (on prototype)
-          *     result = Reflect.getOwnMetadataKeys(Example.prototype, "property");
-          *
-          *     // method (on constructor)
-          *     result = Reflect.getOwnMetadataKeys(Example, "staticMethod");
-          *
-          *     // method (on prototype)
-          *     result = Reflect.getOwnMetadataKeys(Example.prototype, "method");
-          *
-          */
-        function getOwnMetadataKeys(target: Object, propertyKey: string | symbol): any[];
-        /**
-          * Deletes the metadata entry from the target object with the provided key.
-          * @param metadataKey A key used to store and retrieve metadata.
-          * @param target The target object on which the metadata is defined.
-          * @returns `true` if the metadata entry was found and deleted; otherwise, false.
-          * @example
-          *
-          *     class Example {
-          *     }
-          *
-          *     // constructor
-          *     result = Reflect.deleteMetadata("custom:annotation", Example);
-          *
-          */
-        function deleteMetadata(metadataKey: any, target: Object): boolean;
-        /**
-          * Deletes the metadata entry from the target object with the provided key.
-          * @param metadataKey A key used to store and retrieve metadata.
-          * @param target The target object on which the metadata is defined.
-          * @param propertyKey The property key for the target.
-          * @returns `true` if the metadata entry was found and deleted; otherwise, false.
-          * @example
-          *
-          *     class Example {
-          *         // property declarations are not part of ES6, though they are valid in TypeScript:
-          *         // static staticProperty;
-          *         // property;
-          *
-          *         static staticMethod(p) { }
-          *         method(p) { }
-          *     }
-          *
-          *     // property (on constructor)
-          *     result = Reflect.deleteMetadata("custom:annotation", Example, "staticProperty");
-          *
-          *     // property (on prototype)
-          *     result = Reflect.deleteMetadata("custom:annotation", Example.prototype, "property");
-          *
-          *     // method (on constructor)
-          *     result = Reflect.deleteMetadata("custom:annotation", Example, "staticMethod");
-          *
-          *     // method (on prototype)
-          *     result = Reflect.deleteMetadata("custom:annotation", Example.prototype, "method");
-          *
-          */
-        function deleteMetadata(metadataKey: any, target: Object, propertyKey: string | symbol): boolean;
-    }
+import './TypeDef.2.js';
+
+declare namespace UnitOfTime {
+    type Base = ('year' | 'years' | 'y' | 'month' | 'months' | 'M' | 'week' | 'weeks' | 'w' | 'day' | 'days' | 'd' | 'hour' | 'hours' | 'h' | 'minute' | 'minutes' | 'm' | 'second' | 'seconds' | 's' | 'millisecond' | 'milliseconds' | 'ms');
+    type _quarter = 'quarter' | 'quarters' | 'Q';
+    type _isoWeek = 'isoWeek' | 'isoWeeks' | 'W';
+    type _date = 'date' | 'dates' | 'D';
+    type DurationConstructor = Base | _quarter;
+    type DurationAs = Base;
+    type StartOf = Base | _quarter | _isoWeek | _date | null;
+    type Diff = Base | _quarter;
+    type MomentConstructor = Base | _date;
+    type All = Base | _quarter | _isoWeek | _date | 'weekYear' | 'weekYears' | 'gg' | 'isoWeekYear' | 'isoWeekYears' | 'GG' | 'dayOfYear' | 'dayOfYears' | 'DDD' | 'weekday' | 'weekdays' | 'e' | 'isoWeekday' | 'isoWeekdays' | 'E';
 }
+type TimeInput = Time | Date | string | number | (number | string)[] | null;
+type TimeObject = {
+    years: number;
+    months: number;
+    date: number;
+    hours: number;
+    minutes: number;
+    seconds: number;
+    milliseconds: number;
+};
+/**
+ * Time class
+ */
+declare class Time extends Date {
+    #private;
+    /**
+     * Constructor
+     * @param inp
+     */
+    constructor(inp?: TimeInput);
+    /**
+     * Get all timezone names
+     */
+    static timezones(): string[];
+    /**
+     * Returns the maximum value for a given instance (farthest into the future)
+     * @param times
+     */
+    static max(...times: Time[]): Time;
+    /**
+     * Returns the minimum value (most distant past) of the given instance
+     * @param times
+     */
+    static min(...times: Time[]): Time;
+    /**
+     * Update the current instance internal timestamp and return the current instance
+     * @param time
+     * @protected
+     */
+    protected updateTimestamp(time: number): this;
+    /**
+     * Get time zone offset
+     */
+    getTimezoneOffset(): number;
+    /**
+     * Get or set time zone
+     */
+    timezone(): string | undefined;
+    timezone(tz: string): this;
+    /**
+     * Get or set the number of milliseconds
+     */
+    milliseconds(): number;
+    milliseconds(value: number): this;
+    /**
+     * Get or set seconds
+     */
+    seconds(): number;
+    seconds(value: number): this;
+    /**
+     * Get or set minutes
+     */
+    minutes(): number;
+    minutes(value: number): this;
+    /**
+     * Get or set the hour
+     */
+    hours(): number;
+    hours(value: number): this;
+    /**
+     * Get or set the day of the month
+     * Accepts numbers from 1 to 31. If out of range it will bubble up to months
+     */
+    date(): number;
+    date(value: number): this;
+    /**
+     * Set to get or set the day of the week
+     */
+    weekday(): number;
+    weekday(value: number): this;
+    /**
+     * Get or set the ISO day of the week, 1 is Monday, 7 is Sunday
+     */
+    isoWeekday(): number;
+    isoWeekday(value: number): this;
+    /**
+     * Get or set the day of the year
+     * Accepts numbers from 1 to 366. If out of range it will bubble up to the year
+     */
+    dayOfYear(): number;
+    dayOfYear(value: number): this;
+    /**
+     * Gets or sets the week of the year
+     */
+    weeks(): number;
+    weeks(value: number): this;
+    /**
+     * Gets or sets the ISO week of the year
+     */
+    isoWeeks(): number;
+    isoWeeks(value: number): this;
+    /**
+     * Get or set the month
+     * Accepts numbers from 0 to 11. If out of range it will bubble up to the year
+     */
+    month(): number;
+    month(value: number): this;
+    /**
+     * Gets or sets the quarter (1 to 4)
+     */
+    quarters(): number;
+    quarters(value: number): this;
+    /**
+     * Get or set the year
+     * Accepts numbers from -270,000 to 270,000
+     */
+    year(): number;
+    year(value: number): this;
+    /**
+     * Gets or sets the week of the year in ISO time
+     */
+    isoWeekYear(): number;
+    isoWeekYear(value: number): this;
+    /**
+     * Gets the week number based on the locale of the current instance's year
+     */
+    weeksInYear(): number;
+    /**
+     * Get the week number of the year where the current instance is located based on the week number
+     */
+    isoWeeksInYear(): number;
+    /**
+     * Universal getter (Depends on input unit)
+     * @param unit
+     */
+    get(unit: UnitOfTime.All): number;
+    /**
+     * Universal setter (Depends on input unit)
+     * @param unit
+     * @param value
+     */
+    set(unit: UnitOfTime.All, value: number): this;
+    /**
+     * Increase time
+     * @param amount
+     * @param unit
+     */
+    add(amount: number, unit: UnitOfTime.DurationConstructor): this;
+    /**
+     * Minus time
+     * @param amount
+     * @param unit
+     */
+    subtract(amount: number, unit: UnitOfTime.DurationConstructor): this;
+    /**
+     * Set to the start of a time unit
+     * @param unit
+     */
+    startOf(unit: UnitOfTime.StartOf): this;
+    /**
+     * Set to the end of the time unit
+     * @param unit
+     */
+    endOf(unit: UnitOfTime.StartOf): this;
+    /**
+     * Format output time string
+     */
+    format(): string;
+    format(format: string): string;
+    /**
+     * Get time difference
+     * @param inp
+     * @param unit
+     * @param precise
+     */
+    diff(inp: TimeInput, unit?: UnitOfTime.Diff, precise?: boolean): number;
+    /**
+     * Outputs a Unix timestamp (number of seconds since the Unix epoch)
+     */
+    unix(): number;
+    /**
+     * Get the number of days in the current month
+     */
+    daysInMonth(): number;
+    /**
+     * This will return an array that reflects the parameters in new Date()
+     */
+    toArray(): [number, number, number, number, number, number, number];
+    /**
+     * Returns an object containing the year, month, day of the month, hour, minute, second, and millisecond
+     */
+    toObject(): TimeObject;
+    /**
+     * To string
+     */
+    toString(): string;
+    /**
+     * To time string
+     */
+    toTimeString(): string;
+    /**
+     * To UTC string
+     */
+    toUTCString(): string;
+    /**
+     * To date string
+     */
+    toDateString(): string;
+    /**
+     * Return ISO format time string
+     */
+    toISOString(): string;
+    /**
+     * Is current time before input time
+     * @param inp
+     * @param granularity
+     */
+    isBefore(inp?: TimeInput, granularity?: UnitOfTime.StartOf): boolean;
+    /**
+     * Is current time same with input time
+     * @param inp
+     * @param granularity
+     */
+    isSame(inp?: TimeInput, granularity?: UnitOfTime.StartOf): boolean;
+    /**
+     * Is current time after input time
+     * @param inp
+     * @param granularity
+     */
+    isAfter(inp?: TimeInput, granularity?: UnitOfTime.StartOf): boolean;
+    /**
+     * Is current time same or before input time
+     * @param inp
+     * @param granularity
+     */
+    isSameOrBefore(inp?: TimeInput, granularity?: UnitOfTime.StartOf): boolean;
+    /**
+     * Is current time same or after input time
+     * @param inp
+     * @param granularity
+     */
+    isSameOrAfter(inp?: TimeInput, granularity?: UnitOfTime.StartOf): boolean;
+    /**
+     * Is current time between two input times
+     * @param a
+     * @param b
+     * @param granularity
+     * @param inclusivity
+     */
+    isBetween(a: TimeInput, b: TimeInput, granularity?: UnitOfTime.StartOf, inclusivity?: '()' | '[)' | '(]' | '[]'): boolean;
+    /**
+     * Check current time instance is leap year
+     */
+    isLeapYear(): boolean;
+    /**
+     * Clone a time instance
+     */
+    clone(): Time;
+}
+
+export { Time as T };