@zelgadis87/utils-core 4.4.4 → 4.6.0

package/dist/async/Deferred.d.ts

@@ -1,34 +0,0 @@
-export interface ICancelable {
-    cancel(): void;
-}
-export interface ICancelablePromise<T> extends Promise<T>, ICancelable {
-}
-export declare class DeferredCanceledError extends Error {
-    constructor();
-}
-export declare class Deferred<T = void> implements ICancelablePromise<T> {
-    private _pending;
-    private readonly _internals;
-    get pending(): boolean;
-    /** @deprecated: Use resolve, then and catch directly; use asPromise to return a promise type. */
-    get promise(): Promise<T>;
-    constructor();
-    resolve(val: T): void;
-    reject(reason: Error): void;
-    cancel(): void;
-    resolveIfPending(val: T): void;
-    rejectIfPending(reason: Error): void;
-    cancelIfPending(): void;
-    then<R = T, S = T>(onFulfilled: ((value: T) => R | PromiseLike<R>) | null | undefined, onRejected?: ((reason: Error) => S | PromiseLike<S>) | null | undefined): Promise<R | S>;
-    catch<R = T>(onRejected: ((reason: Error) => R | PromiseLike<R>) | null | undefined): Promise<T | R>;
-    finally(onfinally: (() => void) | null | undefined): Promise<T>;
-    asPromise(): Promise<T>;
-    asCancelablePromise(): ICancelablePromise<T>;
-    protected createInternals(): {
-        promise: Promise<T>;
-        resolve: (value: T) => void;
-        reject: (reason: Error) => void;
-    };
-    get [Symbol.toStringTag](): string;
-}
-export default Deferred;

package/dist/async/RateThrottler.d.ts

@@ -1,13 +0,0 @@
-import { TFunction, TPromisable } from "..";
-import TimeFrequency from "../time/TimeFrequency";
-type TPromiseFactory<T, R> = TFunction<T, Promise<R>>;
-export declare class RateThrottler {
-    private readonly _frequency;
-    private readonly _availableSlots;
-    private readonly _waitingRequests;
-    constructor(_frequency: TimeFrequency);
-    get cooldown(): import("..").TimeDuration;
-    execute<T>(fn: TPromiseFactory<void, T>): Promise<T>;
-}
-export default RateThrottler;
-export declare function throttle<TParams extends unknown[], R>(fn: (...params: TParams) => TPromisable<R>, frequence: TimeFrequency): (...params: TParams) => Promise<R>;

package/dist/async/Semaphore.d.ts

@@ -1,14 +0,0 @@
-import { TAsyncProducer, TProducer, TimeDuration } from "..";
-export declare class Semaphore {
-    private _availableSlots;
-    private readonly _queuedRequests;
-    private _inProgress;
-    constructor(_availableSlots?: number);
-    private _awaitSlot;
-    private _releaseSlot;
-    execute<T>(fn: TAsyncProducer<T> | TProducer<T>, cooldown?: TimeDuration): Promise<T>;
-    get availableSlots(): number;
-    get queueSize(): number;
-    get inProgressSize(): number;
-}
-export default Semaphore;

package/dist/async/index.d.ts

@@ -1,4 +0,0 @@
-export * from './CancelableDeferred.ts';
-export * from './Deferred';
-export * from './RateThrottler';
-export * from './Semaphore';

package/dist/index.d.ts

@@ -1,8 +0,0 @@
-export * from './async/index.js';
-export * from './lazy/index.js';
-export * from './Logger.js';
-export * from './Optional.js';
-export * from './sorting/index.js';
-export * from './time/index.js';
-export * from './upgrade/index.js';
-export * from './utils/index.js';

package/dist/lazy/Lazy.d.ts

@@ -1,22 +0,0 @@
-/**
- * Class that stores a value that is computationally/memory intensive to initialize.
- * The initialization of the value is done once and only if required (lazy initialization).
- * @author gtomberli
- */
-export declare class Lazy<T> {
-    private _value;
-    private _initialized;
-    private _generator;
-    private constructor();
-    get value(): T | undefined;
-    getOrCreate(): T;
-    getOrThrow(errorMessage?: "Value not initialized"): T;
-    or(t: T): T;
-    isPresent(): boolean;
-    isEmpty(): boolean;
-    ifPresent(fn: (t: T) => void): void;
-    ifEmpty(fn: () => void): void;
-    apply(fnPresent: (t: T) => void, fnEmpty: () => void): void;
-    static of<T>(generator: () => T): Lazy<T>;
-}
-export default Lazy;

package/dist/lazy/LazyAsync.d.ts

@@ -1,24 +0,0 @@
-export declare class LazyAsync<T> {
-    private _promise;
-    private _pending;
-    private _resolvedValue;
-    private _error;
-    private _generator;
-    private constructor();
-    getOrCreate(): Promise<T>;
-    isPresent(): boolean;
-    isEmpty(): boolean;
-    isPending(): boolean;
-    isReady(): boolean;
-    isResolved(): boolean;
-    isError(): boolean;
-    ifPresent(fn: (t: Promise<T>) => void): void;
-    ifEmpty(fn: () => void): void;
-    ifPending(fn: (t: Promise<T>) => void): void;
-    ifReady(fn: (t: Promise<T>) => void): void;
-    ifResolved(fn: (t: T) => void): void;
-    ifError(fn: (err: Error) => void): void;
-    getOrThrow(errorMessage?: "Value not initialized"): Promise<T> | never;
-    static of<T>(generator: () => Promise<T>): LazyAsync<T>;
-}
-export default LazyAsync;

package/dist/lazy/index.d.ts

@@ -1,2 +0,0 @@
-export * from './Lazy.js';
-export * from './LazyAsync.js';

package/dist/sorting/ComparisonChain.d.ts

@@ -1,57 +0,0 @@
-import { TFunction, TKeysOfType, TReadableArray } from "../utils/index.js";
-import { TComparisonDirection, TComparisonFunction, TComparisonResult } from "./types.js";
-type TCompareValueOptions = {
-    nullsFirst: boolean;
-    direction: TComparisonDirection;
-};
-type TLooseCompareValueOptions = Partial<TCompareValueOptions> | TComparisonDirection;
-declare function compareStrings(options?: TLooseCompareValueOptions & {
-    ignoreCase?: boolean;
-}): TComparisonFunction<string>;
-declare function compareBooleans(options: Partial<TCompareValueOptions> & {
-    truesFirst: boolean;
-}): TComparisonFunction<boolean>;
-/**
- * Creates a ComparisonChain V1.
- * Usage: ComparisonChain.createWith<number>( c => c.compareUsingNumbers() ).sort( [ 100, 1, 10, 5 ] );
- * @deprecated[2023-10-22]: Use createSorterFor instead.
- **/
-export declare class ComparisonChain<T> {
-    private readonly _fns;
-    private readonly _reversed;
-    private constructor();
-    compare: (a: T, b: T) => TComparisonResult;
-    sort: <A extends TReadableArray<T>>(arr: A) => A extends Array<T> ? Array<T> : ReadonlyArray<T>;
-    then(getFn: (compare: TChain<T>) => TComparisonFunction<T>): ComparisonChain<T>;
-    thenBy(cmp: ComparisonChain<T> | TComparisonFunction<T>): ComparisonChain<T>;
-    thenChain<R>(transform: TFunction<T, R>, getFn: (compare: TChain<R>) => TComparisonFunction<R>): ComparisonChain<T>;
-    thenChainBy<R>(transform: TFunction<T, R>, cmp: ComparisonChain<R> | TComparisonFunction<R>): ComparisonChain<T>;
-    reversed(): ComparisonChain<T>;
-    private doCompare;
-    static create<T>(): {
-        using: (getFn: (chainable: TChain<T>) => TComparisonFunction<T>) => ComparisonChain<T>;
-        usingTransformation: <R>(transform: TFunction<T, R>, getFn: (chainable: TChain<R>) => TComparisonFunction<R>) => ComparisonChain<T>;
-    };
-    static createWith<T>(getFn: (chainable: TChain<T>) => TComparisonFunction<T>): ComparisonChain<T>;
-    static createWithTransformation<T, R>(transform: TFunction<T, R>, getFn: (chainable: TChain<R>) => TComparisonFunction<R>): ComparisonChain<T>;
-}
-export default ComparisonChain;
-declare function createCompare<T>(): {
-    compareUsingGetter: {
-        (getter: TFunction<T, string>, options?: TLooseCompareValueOptions): TComparisonFunction<T>;
-        (getter: TFunction<T, number>, options?: TLooseCompareValueOptions): TComparisonFunction<T>;
-        (getter: TFunction<T, Date>, options?: TLooseCompareValueOptions): TComparisonFunction<T>;
-    };
-    compareUsingField: (field: keyof T & TKeysOfType<T, string | number | Date>, options?: TLooseCompareValueOptions) => TComparisonFunction<T>;
-    compareUsingStrings: typeof compareStrings;
-    compareUsingStringsIgnoringCase: (options?: TLooseCompareValueOptions) => TComparisonFunction<string>;
-    compareUsingBooleans: typeof compareBooleans;
-    compareUsingNumbers: (options?: TLooseCompareValueOptions) => TComparisonFunction<number>;
-    compareUsingDates: (options?: TLooseCompareValueOptions) => TComparisonFunction<Date>;
-    compareUsingFunction: (fn: TComparisonFunction<T>) => TComparisonFunction<T>;
-    placeFirst: (arr: Array<T>) => TComparisonFunction<T>;
-    placeFirstInOrder: (arr: Array<T>) => TComparisonFunction<T>;
-    placeLast: (arr: Array<T>) => TComparisonFunction<T>;
-    placeLastInOrder: (arr: Array<T>) => TComparisonFunction<T>;
-};
-type TChain<T> = ReturnType<typeof createCompare<T>>;

package/dist/sorting/Sorter.d.ts

@@ -1,100 +0,0 @@
-import { TConditionalParameterOptions, TFunction, TKeysOfType, TPositiveNumber, TReadableArray } from "../utils/index.js";
-import { TComparisonFunction } from "./types.js";
-type TComparable<T> = {
-    compare: TComparisonFunction<T>;
-};
-export type TSorter<T> = {
-    get then(): TSorterStep<T, TSorter<T>>;
-    reversed: () => TSorter<T>;
-    compare: TComparisonFunction<T>;
-    sort: (arr: TReadableArray<T>) => Array<T>;
-    top: (arr: TReadableArray<T>, n: TPositiveNumber) => Array<T>;
-    bottom: (arr: TReadableArray<T>, n: TPositiveNumber) => Array<T>;
-    first: (arr: TReadableArray<T>) => T | null;
-    last: (arr: TReadableArray<T>) => T | null;
-};
-type TSorterStepForRecords<T, Ret> = {
-    usingStrings: (field: TKeysOfType<T, string>) => TSorterStep<string, Ret>;
-    usingNumbers: (field: TKeysOfType<T, number>) => TSorterStep<number, Ret>;
-    usingBooleans: (field: TKeysOfType<T, boolean>) => TSorterStep<boolean, Ret>;
-    usingDates: (field: TKeysOfType<T, Date>) => TSorterStep<Date, Ret>;
-};
-type TSorterStepForNumbers<_T, Ret> = {
-    inAscendingOrder(opts?: {
-        nullsFirst?: boolean;
-    }): Ret;
-    inDescendingOrder(opts?: {
-        nullsFirst?: boolean;
-    }): Ret;
-};
-type TSorterStepForStrings<_T, Ret> = {
-    inLexographicalOrder(opts?: {
-        nullsFirst?: boolean;
-    }): Ret;
-    inLexographicalOrderIgnoringCase(opts?: {
-        nullsFirst?: boolean;
-    }): Ret;
-    inReverseLexographicalOrder(opts?: {
-        nullsFirst?: boolean;
-    }): Ret;
-    inReverseLexographicalOrderIgnoringCase(opts?: {
-        nullsFirst?: boolean;
-    }): Ret;
-};
-type TSorterStepForBooleans<_T, Ret> = {
-    truesFirst(opts?: {
-        nullsFirst?: boolean;
-    }): Ret;
-    falsesFirst(opts?: {
-        nullsFirst?: boolean;
-    }): Ret;
-};
-type TSorterStepForDates<_T, Ret> = {
-    mostAncientFirst(opts?: {
-        nullsFirst?: boolean;
-    }): Ret;
-    mostRecentFirst(opts?: {
-        nullsFirst?: boolean;
-    }): Ret;
-};
-type TSorterStepForChainables<T, Ret> = {
-    chain: (chain: TComparable<T>) => Ret;
-};
-type TSorterStepForUsing<T, Ret> = {
-    using: <X>(transform: TFunction<T, X>) => TSorterStep<X, Ret>;
-};
-type TSorterStepForPrioritizable<T extends string | number, Ret> = {
-    prioritizing(arr: T[], options?: TConditionalParameterOptions<TPrioritizeOptions, typeof defaultPrioritizeOptions>): Ret;
-    deprioritizing(arr: Array<T>, options?: TConditionalParameterOptions<TPrioritizeOptions, typeof defaultPrioritizeOptions>): Ret;
-    prioritizingWithEqualWeight(arr: T[], options?: TConditionalParameterOptions<TPrioritizeOptions, typeof defaultPrioritizeOptions>): Ret;
-    deprioritizingWithEqualWeight(arr: Array<T>, options?: TConditionalParameterOptions<TPrioritizeOptions, typeof defaultPrioritizeOptions>): Ret;
-};
-type TSorterStep<T, Ret> = {} & (T extends Record<string | number | symbol, unknown> ? TSorterStepForRecords<T, Ret> : {}) & (T extends number ? TSorterStepForNumbers<T, Ret> : {}) & (T extends string ? TSorterStepForStrings<T, Ret> : {}) & (T extends boolean ? TSorterStepForBooleans<T, Ret> : {}) & (T extends Date ? TSorterStepForDates<T, Ret> : {}) & (T extends string ? TSorterStepForPrioritizable<string, Ret> : {}) & (T extends number ? TSorterStepForPrioritizable<number, Ret> : {}) & TSorterStepForChainables<T, Ret> & TSorterStepForUsing<T, Ret>;
-type TSorterStarter<T> = TSorterStep<T, TSorter<T>>;
-export type TSorterBuilder<T> = (builder: TSorterStarter<T>) => TSorter<T>;
-type TPrioritizeOptions = {};
-declare const defaultPrioritizeOptions: {};
-/**
- * @deprecated[2023-10-19]: Use {@link Sorter.createFor} instead.
- **/
-export declare function createSorterFor<T>(): TSorterStarter<T>;
-export declare const Sorter: {
-    createFor: <T>() => TSorterStarter<T>;
-    sort: <T>(arr: TReadableArray<T>, builder: TSorterBuilder<T>) => T[];
-    top: <T>(arr: TReadableArray<T>, n: TPositiveNumber, builder: TSorterBuilder<T>) => T[];
-    bottom: <T>(arr: TReadableArray<T>, n: TPositiveNumber, builder: TSorterBuilder<T>) => T[];
-    first: <T>(arr: TReadableArray<T>, builder: TSorterBuilder<T>) => T | null;
-    last: <T>(arr: TReadableArray<T>, builder: TSorterBuilder<T>) => T | null;
-};
-/**
- * @deprecated[2023-11-01]: Use {@link Sorter} instead.
- **/
-export declare const Sorting: {
-    createFor: <T>() => TSorterStarter<T>;
-    sort: <T>(arr: TReadableArray<T>, builder: TSorterBuilder<T>) => T[];
-    top: <T>(arr: TReadableArray<T>, n: TPositiveNumber, builder: TSorterBuilder<T>) => T[];
-    bottom: <T>(arr: TReadableArray<T>, n: TPositiveNumber, builder: TSorterBuilder<T>) => T[];
-    first: <T>(arr: TReadableArray<T>, builder: TSorterBuilder<T>) => T | null;
-    last: <T>(arr: TReadableArray<T>, builder: TSorterBuilder<T>) => T | null;
-};
-export default Sorter;

package/dist/sorting/index.d.ts

@@ -1,4 +0,0 @@
-export * from './types.js';
-export { default as ComparisonChain } from './ComparisonChain.js';
-export * from './Sorter.js';
-export * from './types.js';

package/dist/sorting/types.d.ts

@@ -1,5 +0,0 @@
-import { TBiFunction } from "../utils/functions.js";
-export type TComparisonResult = -1 | 0 | 1;
-export type TStrictComparisonResult = -1 | 1;
-export type TComparisonFunction<T> = TBiFunction<T, T, TComparisonResult>;
-export type TComparisonDirection = 'ASC' | 'DESC';

package/dist/time/RandomTimeDuration.d.ts

@@ -1,9 +0,0 @@
-import TimeDuration from "./TimeDuration.js";
-export default class RandomTimeDuration {
-    private constructor();
-    static ms: (a: number, b: number) => TimeDuration;
-    static seconds: (a: number, b: number) => TimeDuration;
-    static minutes: (a: number, b: number) => TimeDuration;
-    static hours: (a: number, b: number) => TimeDuration;
-    static days: (a: number, b: number) => TimeDuration;
-}

package/dist/time/TimeBase.d.ts

@@ -1,38 +0,0 @@
-import TimeUnit from "./TimeUnit";
-export default abstract class TimeBase<T> {
-    private readonly _ms;
-    protected constructor(value: number, unit: TimeUnit);
-    protected abstract create(value: number, unit: TimeUnit): T;
-    get ms(): number;
-    get seconds(): number;
-    get minutes(): number;
-    get hours(): number;
-    get days(): number;
-    addMs(milliseconds: number): T;
-    addSeconds(seconds: number): T;
-    addMinutes(minutes: number): T;
-    addHours(hours: number): T;
-    addDays(days: number): T;
-    removeDays(days: number): T;
-    addUnits(n: number, unit: TimeUnit): T;
-    removeMs(milliseconds: number): T;
-    removeSeconds(seconds: number): T;
-    removeMinutes(minutes: number): T;
-    removeHours(hours: number): T;
-    removeUnits(n: number, unit: TimeUnit): T;
-    getUnit(unit: TimeUnit): number;
-    protected toUnits(): {
-        days: number;
-        hours: number;
-        minutes: number;
-        seconds: number;
-    };
-    protected static toMs(units: {
-        days?: number;
-        hours?: number;
-        minutes?: number;
-        seconds?: number;
-        ms?: number;
-    }): number;
-    toJSON(): number;
-}

package/dist/time/TimeDuration.d.ts

@@ -1,79 +0,0 @@
-import { ICancelable, ICancelablePromise } from "../async/Deferred.js";
-import { TComparisonResult } from "../sorting/index.js";
-import { TIntervalHandle, TTimeoutHandle } from "../utils/index.js";
-import TimeBase from "./TimeBase";
-import TimeInstant from "./TimeInstant";
-import TimeUnit from "./TimeUnit";
-export declare class TimeDuration extends TimeBase<TimeDuration> {
-    protected constructor(value: number, unit: TimeUnit);
-    protected create(value: number, unit: TimeUnit): TimeDuration;
-    addDuration(duration: TimeDuration): TimeDuration;
-    removeDuration(duration: TimeDuration): TimeDuration;
-    removeUnits(n: number, unit: TimeUnit): TimeDuration;
-    /** @deprecated: Use multiplyBy instead **/
-    multiply(times: number): TimeDuration;
-    multiplyBy(times: number): TimeDuration;
-    divideBy(times: number): TimeDuration;
-    /**
-     * Returns the current duration in a human readable format, prioritizing the most significant unit of time and excluding the rest.
-     * @todo[2023-06] Should allow more customization options
-     * @todo[2023-06] By default should show the secondary unit only when actually needed (eg, 1h 20m & 3h, instead of 1h 20m & 3h 28m)
-     * @todo[2023-06] Should not allow negative durations, as this is a duration and not an instant.
-     * @returns the duration, with only the most significant units displayed as a human readable string, eg: 1d 20h, 10m 30s.
-    */
-    get formatted(): string;
-    /**
-        * @deprecated[2023-06] this method makes no sense, as durations are positive by default.
-        */
-    absolute(): TimeDuration;
-    interval(cb: () => unknown): TIntervalHandle;
-    timeout(cb: () => unknown): TTimeoutHandle;
-    promise(): ICancelablePromise<void>;
-    delay(cb: () => unknown): ICancelable;
-    debounce<T>(fn: (t: T) => void): (t: T) => void;
-    toDigitalClock(): string;
-    get asSeconds(): string;
-    fromNow(): TimeInstant;
-    differenceFrom(other: TimeDuration): TimeDuration;
-    /** @deprecated: Use fromNow instead **/
-    addCurrentTime(): TimeInstant;
-    isGreaterThan(other: TimeDuration): boolean;
-    isLessThan(other: TimeDuration): boolean;
-    compareTo(other: TimeDuration): TComparisonResult;
-    atLeast(other: TimeDuration): TimeDuration;
-    atMost(other: TimeDuration): TimeDuration;
-    isEmpty(): boolean;
-    isNotEmpty(): boolean;
-    /**
-        * This method is used to provide a better DX when inspecting a TimeInstant object in DevTools.
-        */
-    protected get _duration(): string;
-    toString(): string;
-    static parseHumanTime(humanTime: string): TimeDuration;
-    static compare(a: TimeDuration, b: TimeDuration): TComparisonResult;
-    static ms: IDurationConstructor;
-    static seconds: IDurationConstructor;
-    static minutes: IDurationConstructor;
-    static hours: IDurationConstructor;
-    static days: IDurationConstructor;
-    static shamefulUnref: (ms: TAllowedTimeDuration) => number;
-    static shamefulRef: (ms: TAllowedTimeDuration) => TimeDuration;
-    static unref: (ms: TValidTimeDuration) => TPredefinedTimeDuration;
-    static ref: (ms: TValidTimeDuration) => TimeDuration;
-    static fromMs(ms: number): TimeDuration;
-    static distanceFromNow(instant: TimeInstant): TimeDuration;
-    static distance(instant1: TimeInstant, instant2: TimeInstant): TimeDuration;
-    static greatest(duration1: TimeDuration, duration2: TimeDuration): TimeDuration;
-    static lowest(duration1: TimeDuration, duration2: TimeDuration): TimeDuration;
-    static ZERO: TimeDuration;
-    static fromJSON(ms: number): TimeDuration;
-}
-interface IDurationConstructor {
-    (a: number): TimeDuration;
-    /** @deprecated[2023-06] Use RandomTimeDuration instead */ (a: number, b?: number): TimeDuration;
-}
-export type TPredefinedTimeDuration = 0 | 50 | 100 | 150 | 200 | 250 | 300 | 500 | 1000 | 1500 | 2000 | 2500 | 5000;
-export type TValidTimeDuration = TimeDuration | TPredefinedTimeDuration;
-type TAllowedTimeDuration = TValidTimeDuration | number;
-export declare function isAllowedTimeDuration(t: unknown): t is TAllowedTimeDuration;
-export default TimeDuration;

package/dist/time/TimeFrequency.d.ts

@@ -1,10 +0,0 @@
-import { TPositiveNumber } from "../utils";
-import TimeDuration from "./TimeDuration";
-export default class TimeFrequency {
-    readonly times: TPositiveNumber;
-    readonly period: TimeDuration;
-    constructor(times: TPositiveNumber, period: TimeDuration);
-    get frequency(): TimeDuration;
-    static onceEvery(period: TimeDuration): TimeFrequency;
-    static twiceEvery(period: TimeDuration): TimeFrequency;
-}

package/dist/time/TimeInstant.d.ts

@@ -1,171 +0,0 @@
-import { ICancelable, ICancelablePromise } from "../async/Deferred.js";
-import { TComparisonResult } from "../sorting/index.js";
-import TimeBase from "./TimeBase";
-import TimeDuration from "./TimeDuration";
-import { TTimeInstantBuilder, TTimeInstantCreationParameters } from "./TimeInstantBuilder.js";
-import TimeUnit from "./TimeUnit";
-import { TDayOfMonth, TDayOfWeek, TIso8601DateString, TIso8601DateUtcString, TMonth, TWeekNumber } from "./types";
-export declare class TimeInstant extends TimeBase<TimeInstant> {
-    protected constructor(number: number, unit: TimeUnit);
-    protected create(value: number, unit: TimeUnit): TimeInstant;
-    addDuration(duration: TimeDuration): TimeInstant;
-    removeDuration(duration: TimeDuration): TimeInstant;
-    distanceFrom(instant: TimeInstant): TimeDuration;
-    distanceFromNow(): TimeDuration;
-    distanceFromStartOfDay(): TimeDuration;
-    atStartOfDay(): TimeInstant;
-    distanceFromEndOfDay(): TimeDuration;
-    atEndOfDay(): TimeInstant;
-    promise(): ICancelablePromise<void>;
-    delay(cb: () => unknown): ICancelable;
-    ensureInTheFuture(): void;
-    ensureInThePast(): void;
-    isToday(): boolean;
-    /**
-     * @returns the time as HH:mm:ss
-     * @deprecated [2024-12-11] this method is too ambigous and should be removed.
-     */
-    asTimeString(): string;
-    /**
-     * @returns the date as dd/MM/yyyy
-     * @deprecated [2024-12-11] this method is too ambigous and should be removed.
-     */
-    asDateString(): string;
-    /**
-     * Formats this instant using the given pattern. The pattern can contain the following tokens:
-     *
-     * | Token | Description                     | Example                       |
-     * |:------|:--------------------------------|:------------------------------|
-     * | D     | Weekday, 1 letter               | W                             |
-     * | DD    | Weekday, 3 letters              | Wed                           |
-     * | DDD   | Weekday, long                   | Wednesday                     |
-     * | d     | Day of the month, no padding    | 3                             |
-     * | dd    | Day of the month, padded to 2   | 03                            |
-     * | M     | Month, numeric                  | 3                             |
-     * | MM    | Month, 2 digits                 | 03                            |
-     * | MMM   | Month, 3 letters                | Mar                           |
-     * | MMMM  | Month, long                     | March                         |
-     * | y     | Year, numeric                   | 2021                          |
-     * | yy    | Year, 2 digits                  | 21                            |
-     * | yyyy  | Year, numeric                   | 2021                          |
-     * | h     | Hours, no padding               | 6                             |
-     * | hh    | Hours, padded to 2              | 06                            |
-     * | H     | Hours in 24-format, no padding  | 18                            |
-     * | HH    | Hours in 24-format, padded to 2 | 18                            |
-     * | m     | Minutes, no padding             | 7                             |
-     * | m     | Minutes, padded to 2            | 07                            |
-     * | s     | Seconds, no padding             | 8                             |
-     * | ss    | Seconds, padded to 2            | 08                            |
-     * | S     | Milliseconds, no padding        | 9                             |
-     * | SS    | Milliseconds, padded to 2       | 09                            |
-     * | SSS   | Milliseconds, padded to 3       | 009                           |
-     * | G     | Era, narrow                     | A                             |
-     * | GG    | Era, short                      | AD                            |
-     * | GGG   | Era, long                       | Anno Domino                   |
-     * | Z     | Time zone, short                | GMT+1                         |
-     * | ZZ    | Time short, long	C              | entral European Standard Time |
-     * | P     | Period of the day, narrow       | in the morning                |
-     * | PP    | Period of the day, short        | in the morning                |
-     * | PPP   | Period of the day, long         | in the morning                |
-     * | a     | Meridiem                        | pm                            |
-     * @param pattern The pattern to use. Refer to the token table above for details.
-     * @param config An optional locale and timeZone definition to use during the format.
-     * @returns a string, formatted using the given pattern, at the given timeZone with the given locale.
-     */
-    format(pattern: string, config?: {
-        locale?: string;
-        timeZone?: string;
-    }): string;
-    /**
- * @returns this instant, in ISO 8601 format (eg, 2024-11-01T15:49:22.024Z). The format is meant to always be realiable.
- */
-    asIso8601(): TIso8601DateUtcString;
-    /**
-     * @returns this instant, in a human readable format. The format COULD change in the future, do NOT use this method for consistent outputs.
-     * @deprecated [2024-12-11] this method is too broad and ambigous and should be removed.
-     */
-    asHumanTimestamp(): string;
-    toUnixTimestamp(): number;
-    toDate(): Date;
-    toDateUTC(): Date;
-    get isInThePast(): boolean;
-    get isInTheFuture(): boolean;
-    isAfter(other: TimeInstant): boolean;
-    isBefore(other: TimeInstant): boolean;
-    compareTo(other: TimeInstant): TComparisonResult;
-    /**
-        * @deprecated[04/07/2023]: Use distanceFromNow instead
-        */
-    fromNow(): TimeDuration;
-    /**
-        * @deprecated[04/07/2023]: Use distanceFrom instead
-        */
-    from(instant: TimeInstant): TimeDuration;
-    /**
-        * @deprecated[04/07/2023]: Use distanceFromUnixTimestamp instead
-        */
-    fromTimestamp(timestamp: number): TimeDuration;
-    distanceFromUnixTimestamp(timestamp: number): TimeDuration;
-    atTime(parameters: Partial<TTimeInstantCreationParameters & {
-        year: never;
-        month: never;
-        date: never;
-    }>): TimeInstant;
-    atDate(parameters: Partial<TTimeInstantCreationParameters & {
-        hours: never;
-        minutes: never;
-        seconds: never;
-        milliseconds: never;
-    }>): TimeInstant;
-    at(parameters: Partial<TTimeInstantCreationParameters>): TimeInstant;
-    isBetween(start: TimeInstant, end: TimeInstant): boolean;
-    static fromDate(date: Date): TimeInstant;
-    static fromUnixTimestamp(unixTimestamp: number): TimeInstant;
-    static fromUnixSeconds(unixSeconds: number): TimeInstant;
-    static fromParameters(parameters: Partial<TTimeInstantCreationParameters>, referenceDate?: Date | TimeInstant): TimeInstant;
-    static highest(instant1: TimeInstant, instant2: TimeInstant): TimeInstant;
-    static lowest(instant1: TimeInstant, instant2: TimeInstant): TimeInstant;
-    static builder(): TTimeInstantBuilder;
-    /**
-        * @deprecated[19/07/2023] Use {@link fromParameters} instead.
-        */
-    static fromUnits({ date, month, year, hours, minutes, seconds }: {
-        date: number;
-        month: number;
-        year: number;
-        hours?: number;
-        minutes?: number;
-        seconds?: number;
-    }): TimeInstant;
-    static fromIso8601(str: TIso8601DateString): TimeInstant;
-    static tryFromIso8601(str: string): TimeInstant;
-    static now(): TimeInstant;
-    static get currentTimeStamp(): number;
-    static compare(a: TimeInstant, b: TimeInstant): TComparisonResult;
-    roundedToStartOf(unit: TimeUnit): TimeInstant;
-    roundedToEndOf(unit: TimeUnit): TimeInstant;
-    roundedToNext(unit: TimeUnit, factor?: number): TimeInstant;
-    roundedToPrevious(unit: TimeUnit, factor?: number): TimeInstant;
-    roundedTo(unit: TimeUnit, factor?: number): TimeInstant;
-    get dayOfMonth(): TDayOfMonth;
-    get dayOfWeek(): TDayOfWeek;
-    get month(): TMonth;
-    get year(): number;
-    /**
-        * Returns the week number represented by this instant, according to the ISO 8601 standard.
-        * Please note that the instant and the week number could be of two different years, eg the friday 1st january is actually part of week 52 of the previous year.
-        */
-    get weekNumber(): {
-        weekNumber: TWeekNumber;
-        year: number;
-    };
-    /**
-        * This method is used to provide a better DX when inspecting a TimeInstant object in DevTools.
-        */
-    protected get _time(): string;
-    toString(): string;
-    static ZERO: TimeInstant;
-    static fromJSON(ms: number): TimeInstant;
-}
-export declare function isTimeInstant(x: unknown): x is TimeInstant;
-export default TimeInstant;