@zelgadis87/utils-core 5.2.12 → 5.3.0

package/.rollup/index.d.ts

@@ -0,0 +1,1303 @@
+interface ICancelable {
+    cancel(): void;
+}
+interface ICancelablePromise<T> extends Promise<T>, ICancelable {
+}
+declare class DeferredCanceledError extends Error {
+    constructor();
+}
+declare class Deferred<T = void> implements ICancelablePromise<T> {
+    private _pending;
+    private readonly _internals;
+    get pending(): boolean;
+    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;
+}
+
+declare function constant<T>(v: T): () => T;
+declare function identity<T>(t: T): T;
+
+declare const constantNull: () => null;
+declare const constantTrue: () => boolean;
+declare const constantFalse: () => boolean;
+declare const constantUndefined: () => undefined;
+declare const alwaysTrue: () => boolean;
+declare const alwaysFalse: () => boolean;
+declare const constantZero: () => number;
+declare const constantOne: () => number;
+
+type TBooleanOrPredicate = boolean | TPredicate<void>;
+type TIff<T> = {
+    elseIf<R>(pred: TBooleanOrPredicate, valueIfTrue: R): TIff<T | R>;
+    otherwise<R>(valueIfElse: R): T | R;
+};
+declare function iff<T>(firstPredicate: TBooleanOrPredicate, valueIfTrue: T): TIff<T>;
+
+declare class PredicateBuilder<T> {
+    private _currentPredicate;
+    and(predicate: TPredicate<T>): this;
+    or(predicate: TPredicate<T>): this;
+    toPredicate(): TPredicate<T>;
+}
+
+type TFunction<A, R> = (a: A) => R;
+type TTransformer<A, R> = TFunction<A, R>;
+type TVoidFunction = TFunction<void, void>;
+type TProducer<R> = TFunction<void, R>;
+type TConsumer<T> = TFunction<T, void>;
+type TPredicate<T> = TFunction<T, boolean>;
+type TTypePredicate<T, R extends T> = (t: T) => t is R;
+type TIdentityFunction<T> = TFunction<T, T>;
+type TBiFunction<A, B, R> = (a: A, b: B) => R;
+type TBiConsumer<A, B> = TBiFunction<A, B, void>;
+type TBiPredicate<T> = TBiFunction<T, T, boolean>;
+type TAccumulator<A, B> = TBiFunction<A, B, A>;
+type TAsyncFunction<A, R> = TFunction<A, Promise<R>>;
+type TAsyncVoidFunction = TAsyncFunction<void, void>;
+type TAsyncProducer<R> = TAsyncFunction<void, R>;
+type TAsyncConsumer<T> = TAsyncFunction<T, void>;
+type TAsyncPredicate<T> = TAsyncFunction<T, boolean>;
+type TAsyncBiFunction<A, B, R> = TBiFunction<A, B, Promise<R>>;
+type TAsyncBiConsumer<A, B> = TAsyncBiFunction<A, B, void>;
+type TAsyncBiPredicate<T> = TAsyncBiFunction<T, T, boolean>;
+type TAnyFunction<R> = (...args: unknown[]) => R;
+type TAsyncAnyFunction<R> = (...args: unknown[]) => Promise<R>;
+declare function isFunction(t: unknown): t is Function;
+declare function noop(): void;
+declare function filterWithTypePredicate<T, R extends T>(filter: TPredicate<T>): TTypePredicate<T, R>;
+declare function not<T>(predicate: TPredicate<T>): TPredicate<T>;
+declare function and<T>(a: TPredicate<T>, b: TPredicate<T>): TPredicate<T>;
+declare function or<T>(a: TPredicate<T>, b: TPredicate<T>): TPredicate<T>;
+declare function xor<T>(a: TPredicate<T>, b: TPredicate<T>): TPredicate<T>;
+declare function pipedInvoke<T, A>(op1: TFunction<T, A>): TFunction<T, A>;
+declare function pipedInvoke<T, A, B>(op1: TFunction<T, A>, op2: TFunction<A, B>): TFunction<T, B>;
+declare function pipedInvoke<T, A, B, C>(op1: TFunction<T, A>, op2: TFunction<A, B>, op3: TFunction<B, C>): TFunction<T, C>;
+declare function pipedInvoke<T, A, B, C, D>(op1: TFunction<T, A>, op2: TFunction<A, B>, op3: TFunction<B, C>, op4: TFunction<C, D>): TFunction<T, D>;
+declare function pipedInvoke<T, A, B, C, D, E>(op1: TFunction<T, A>, op2: TFunction<A, B>, op3: TFunction<B, C>, op4: TFunction<C, D>, op5: TFunction<D, E>): TFunction<T, E>;
+declare function pipedInvoke<T, A, B, C, D, E, F>(op1: TFunction<T, A>, op2: TFunction<A, B>, op3: TFunction<B, C>, op4: TFunction<C, D>, op5: TFunction<D, E>, op6: TFunction<E, F>): TFunction<T, F>;
+declare function pipedInvoke<T, A, B, C, D, E, F, G>(op1: TFunction<T, A>, op2: TFunction<A, B>, op3: TFunction<B, C>, op4: TFunction<C, D>, op5: TFunction<D, E>, op6: TFunction<E, F>, op7: TFunction<F, G>): TFunction<T, G>;
+declare function pipedInvoke<T, A, B, C, D, E, F, G, H>(op1: TFunction<T, A>, op2: TFunction<A, B>, op3: TFunction<B, C>, op4: TFunction<C, D>, op5: TFunction<D, E>, op6: TFunction<E, F>, op7: TFunction<F, G>, op8: TFunction<G, H>): TFunction<T, H>;
+declare function pipedInvoke<T, A, B, C, D, E, F, G, H, I>(op1: TFunction<T, A>, op2: TFunction<A, B>, op3: TFunction<B, C>, op4: TFunction<C, D>, op5: TFunction<D, E>, op6: TFunction<E, F>, op7: TFunction<F, G>, op8: TFunction<G, H>, op9: TFunction<H, I>): TFunction<T, I>;
+declare function pipedInvoke<T, A, B, C, D, E, F, G, H, I>(op1: TFunction<T, A>, op2: TFunction<A, B>, op3: TFunction<B, C>, op4: TFunction<C, D>, op5: TFunction<D, E>, op6: TFunction<E, F>, op7: TFunction<F, G>, op8: TFunction<G, H>, op9: TFunction<H, I>, ...operations: TFunction<any, any>[]): TFunction<T, unknown>;
+declare function pipedInvokeFromArray<T, R>(fns: Array<TFunction<any, any>>): TFunction<any, any>;
+
+declare class Optional<T> implements TOptional<T> {
+    private _present;
+    private _value;
+    private constructor();
+    getRawValue(): T | undefined;
+    get(): T;
+    getOrElseThrow(errorProducer: TProducer<Error>): T;
+    set(t: T): void;
+    protected setNullable(t: T | null | undefined): void | this;
+    clear(): void;
+    isEmpty(): this is TEmptyOptional<T>;
+    isPresent(): this is TPresentOptional<T>;
+    ifEmpty(callback: TVoidFunction): void;
+    ifPresent(callback: TConsumer<T>): void;
+    ifPresentThenClear(callback: TConsumer<T>): void;
+    apply(callbackIfPresent: TConsumer<T>, callbackIfEmpty: TVoidFunction): any;
+    orElseReturn(newValue: T): T;
+    orElse: (newValue: T) => T;
+    orElseProduce(newValueProducer: TProducer<T>): T;
+    orElseGet: (newValueProducer: TProducer<T>) => T;
+    orElseReturnAndApply(newValue: T): T;
+    orElseProduceAndApply(newValueProducer: TProducer<T>): T;
+    orElseReturnNullableAndApply(newValue: T | null | undefined): TOptional<T>;
+    orElseProduceNullableAndApply(newValueProducer: TProducer<T | null | undefined>): TOptional<T>;
+    orElseReturnNullable(newValue: T | null | undefined): any;
+    orElseNullable: (newValue: T | null | undefined) => any;
+    orElseProduceNullable(newValueProducer: TProducer<T | null | undefined>): any;
+    orElseGetNullable: (newValueProducer: TProducer<T | null | undefined>) => any;
+    orElseThrow(errorProducer: TProducer<Error>): TPresentOptional<T>;
+    throwIfPresent(errorProducer: TFunction<T, Error>): any;
+    mapTo<R>(mapper: TFunction<T, R | null | undefined>): any;
+    flatMapTo<R>(mapper: TFunction<T, TOptional<R>>): any;
+    filter(predicate: TPredicate<T>): this | TEmptyOptional<T>;
+    static empty<T>(): TEmptyOptional<T>;
+    static of<T>(t: T): TPresentOptional<T>;
+    static ofNullable<T>(t: T | null | undefined): TOptional<T>;
+}
+
+type TOptional<T> = {
+    /**
+     * @returns the currently stored value, if any; throws {@link ErrorGetEmptyOptional} otherwise;
+     */
+    get(): T;
+    /**
+     * @returns the currently stored value, if any; returns undefined otherwise;
+     */
+    getRawValue(): T | undefined;
+    /**
+     * @returns the currently stored value, if any; throws the error generated by errorProducer otherwise;
+     */
+    getOrElseThrow: (errorProducer: TProducer<Error>) => T;
+    /**
+     * Places a new value inside this optional. Throws {@link ErrorSetEmptyOptional} if t is null or undefined.
+     */
+    set(t: T): void;
+    /**
+     * Clears the current value from this optional, if any.
+     */
+    clear(): void;
+    isEmpty(): boolean;
+    isPresent(): boolean;
+    ifEmpty(callback: TVoidFunction): void;
+    ifPresent(callback: TConsumer<T>): void;
+    apply<RP = void, RE = void>(callbackIfPresent: TFunction<T, RP>, callbackIfEmpty: TProducer<RE>): RP | RE;
+    throwIfPresent: (errorGenerator: TFunction<T, Error>) => TEmptyOptional<T>;
+    /** @deprecated[2025.07.25]: Replace with {@link orElseReturn} (drop-in replacement) */
+    orElse: (newValue: T) => T;
+    /** @deprecated[2025.07.25]: Replace with {@link orElseProduce} (drop-in replacement) */
+    orElseGet: (newValueProducer: TProducer<T>) => T;
+    /** @deprecated[2025.07.25]: Replace with {@link orElseReturnNullabe} (drop-in replacement) */
+    orElseNullable: (newValue: T | null | undefined) => TOptional<T>;
+    /** @deprecated[2025.07.25]: Replace with {@link orElseProduceNullable} (drop-in replacement) */
+    orElseGetNullable: (newValueProducer: TProducer<T | null | undefined>) => TOptional<T>;
+    orElseReturn: (newValue: T) => T;
+    orElseProduce: (newValueProducer: TProducer<T>) => T;
+    orElseReturnNullable: (newValue: T | null | undefined) => TOptional<T>;
+    orElseProduceNullable: (newValueProducer: TProducer<T | null | undefined>) => TOptional<T>;
+    orElseReturnAndApply: (newValue: T) => T;
+    orElseProduceAndApply: (newValueProducer: TProducer<T>) => T;
+    orElseReturnNullableAndApply: (newValue: T | null | undefined) => TOptional<T>;
+    orElseProduceNullableAndApply: (newValueProducer: TProducer<T | null | undefined>) => TOptional<T>;
+    orElseThrow: (errorProducer: TProducer<Error>) => TPresentOptional<T>;
+    mapTo<R>(mapper: TFunction<T, R>): TOptional<R>;
+    flatMapTo<R>(mapper: TFunction<T, TOptional<R>>): TOptional<R>;
+    filter(predicate: TPredicate<T>): TOptional<T>;
+};
+type TEmptyOptional<T> = TOptional<T> & {
+    get(): never;
+    isEmpty(): true;
+    isPresent(): false;
+    apply<RP = void, RE = void>(callbackIfPresent: TFunction<T, RP>, callbackIfEmpty: TProducer<RE>): RE;
+};
+type TPresentOptional<T> = TOptional<T> & {
+    get(): T;
+    isEmpty(): false;
+    isPresent(): true;
+    apply<RP = void, RE = void>(callbackIfPresent: TFunction<T, RP>, callbackIfEmpty: TProducer<RE>): RP;
+};
+declare class ErrorGetEmptyOptional extends Error {
+    constructor();
+}
+declare class ErrorSetEmptyOptional extends Error {
+    constructor();
+}
+declare class ErrorCannotInstantiatePresentOptionalWithEmptyValue extends Error {
+    constructor();
+}
+
+declare class TimeUnit {
+    readonly multiplier: number;
+    private constructor();
+    toUnit(value: number, unit: TimeUnit): number;
+    toMs(value: number): number;
+    toSeconds(value: number): number;
+    toMinutes(value: number): number;
+    toHours(value: number): number;
+    toDays(value: number): number;
+    static readonly MILLISECONDS: TimeUnit;
+    static readonly SECONDS: TimeUnit;
+    static readonly MINUTES: TimeUnit;
+    static readonly HOURS: TimeUnit;
+    static readonly DAYS: TimeUnit;
+}
+
+type TTimeInUnits = {
+    milliseconds: number;
+    seconds: number;
+    minutes: number;
+    hours: number;
+    days: number;
+};
+declare abstract class TimeBase<T> {
+    private readonly _ms;
+    protected constructor(value: number, unit: TimeUnit);
+    protected abstract create(value: number, unit: TimeUnit): T;
+    /**
+     * Total number of milliseconds, rounded down.
+     */
+    get ms(): number;
+    /**
+     * Total number of seconds, rounded down.
+     */
+    get seconds(): number;
+    /**
+     * Total number of minutes, rounded down.
+     */
+    get minutes(): number;
+    /**
+     * Total number of hours, rounded down.
+     */
+    get hours(): number;
+    /**
+     * Total number of days, rounded down.
+     */
+    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(): TTimeInUnits;
+    protected static unitsToMs(units: Partial<TTimeInUnits>): number;
+    toJSON(): number;
+}
+
+declare const monthNames: {
+    readonly january: 1;
+    readonly february: 2;
+    readonly march: 3;
+    readonly april: 4;
+    readonly may: 5;
+    readonly june: 6;
+    readonly july: 7;
+    readonly august: 8;
+    readonly september: 9;
+    readonly october: 10;
+    readonly november: 11;
+    readonly december: 12;
+};
+
+type TOneDigit = `${TDigit}`;
+type TTwoDigits = `${TDigit}${TDigit}`;
+type TThreeDigits = `${TDigit}${TDigit}${TDigit}`;
+type TFourDigits = `${TDigit}${TDigit}${TDigit}${TDigit}`;
+type TUpToTwoDigits = TOneDigit | `${TDigit1_9}${TDigit}`;
+type TUpToThreeDigits = TUpToTwoDigits | `${TDigit1_9}${TDigit}${TDigit}`;
+type TUpToFourDigits = TUpToThreeDigits | `${TDigit1_9}${TDigit}${TDigit}${TDigit}`;
+type TTwoDigitsMonth = TTwoDigits & TParseableInt<`0${TDigit1_9}` | '10' | '11' | '12'>;
+type TTwoDigitsDate = TTwoDigits & TParseableInt<`0${TDigit1_9}` | `1${TDigit}` | `2${TDigit}` | '30' | '31'>;
+type TTwoDigitsHour = TTwoDigits & TParseableInt<`0${TDigit1_9}` | `1${TDigit}` | '20' | '21' | '22' | '23' | '24'>;
+type TTwoDigitsMinute = TTwoDigits & TParseableInt<`0${TDigit1_9}` | `1${TDigit}` | `2${TDigit}` | `3${TDigit}` | `4${TDigit}` | `5${TDigit}`>;
+type TTwoDigitsSecond = TTwoDigits & TParseableInt<`0${TDigit1_9}` | `1${TDigit}` | `2${TDigit}` | `3${TDigit}` | `4${TDigit}` | `5${TDigit}`>;
+type TThreeDigitsMillisecond = TThreeDigits;
+type TFourDigitsYear = TFourDigits;
+type TFourDigitsMillisecond = `${'+' | '-'}${TThreeDigits}`;
+type TYear = TPositiveNumber;
+type TMonth = 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12;
+type TMonthName = keyof typeof monthNames;
+type TDayOfMonth = 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20 | 21 | 22 | 23 | 24 | 25 | 26 | 27 | 28 | 29 | 30 | 31;
+type TWeekNumber = 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20 | 21 | 22 | 23 | 24 | 25 | 26 | 27 | 28 | 29 | 30 | 31 | 32 | 33 | 34 | 35 | 36 | 37 | 38 | 39 | 40 | 41 | 42 | 43 | 44 | 45 | 46 | 47 | 48 | 49 | 50 | 51 | 52 | 53;
+type TDayOfWeek = 1 | 2 | 3 | 4 | 5 | 6 | 7;
+type THourOfDay = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20 | 21 | 22 | 23;
+type TMinuteOfHour = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20 | 21 | 22 | 23 | 24 | 25 | 26 | 27 | 28 | 29 | 30 | 31 | 32 | 33 | 34 | 35 | 36 | 37 | 38 | 39 | 40 | 41 | 42 | 43 | 44 | 45 | 46 | 47 | 48 | 49 | 50 | 51 | 52 | 53 | 54 | 55 | 56 | 57 | 58 | 59;
+type TSecondOfMinute = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20 | 21 | 22 | 23 | 24 | 25 | 26 | 27 | 28 | 29 | 30 | 31 | 32 | 33 | 34 | 35 | 36 | 37 | 38 | 39 | 40 | 41 | 42 | 43 | 44 | 45 | 46 | 47 | 48 | 49 | 50 | 51 | 52 | 53 | 54 | 55 | 56 | 57 | 58 | 59;
+type TMillisecondOfSecond = TNumber0_1000;
+type TIso8601DateString = `${string}-${string}-${string}T${string}:${string}:${string}.${string}${string}`;
+type TIso8601DateUtcString = `${string}-${string}-${string}T${string}:${string}:${string}.${string}Z`;
+
+type TRelativeSignum = '+' | '-';
+type TRelativeNumber = `${TRelativeSignum}${TUpToTwoDigits}`;
+type TTimeInstantParameters = {
+    year: TYear;
+    month: TMonth;
+    date: TDayOfMonth;
+    hours: THourOfDay;
+    minutes: TMinuteOfHour;
+    seconds: TSecondOfMinute;
+    milliseconds: TMillisecondOfSecond;
+};
+type TTimeInstantCreationParameters = {
+    year: TTimeInstantParameters["year"] | {
+        absolute: TTimeInstantParameters["year"];
+    } | TRelativeNumber | {
+        relative: number;
+        relativeTo: 'now' | TimeInstant;
+    } | 'next' | 'last' | 'current' | undefined;
+    month: TTimeInstantParameters["month"] | {
+        absolute: TTimeInstantParameters["month"];
+    } | TMonthName | TRelativeNumber | {
+        relative: number;
+        relativeTo: 'now' | TimeInstant;
+    } | 'next' | 'last' | 'current' | undefined;
+    date: TTimeInstantParameters["date"] | {
+        absolute: TTimeInstantParameters["date"];
+    } | TRelativeNumber | {
+        relative: number;
+        relativeTo: 'now' | TimeInstant;
+    } | 'next' | 'last' | 'current' | undefined;
+    hours: TTimeInstantParameters["hours"] | {
+        absolute: TTimeInstantParameters["hours"];
+    } | TRelativeNumber | {
+        relative: number;
+        relativeTo: 'now' | TimeInstant;
+    } | 'next' | 'last' | 'current' | undefined;
+    minutes: TTimeInstantParameters["minutes"] | {
+        absolute: TTimeInstantParameters["minutes"];
+    } | TRelativeNumber | {
+        relative: number;
+        relativeTo: 'now' | TimeInstant;
+    } | 'next' | 'last' | 'current' | undefined;
+    seconds: TTimeInstantParameters["seconds"] | {
+        absolute: TTimeInstantParameters["seconds"];
+    } | TRelativeNumber | {
+        relative: number;
+        relativeTo: 'now' | TimeInstant;
+    } | 'next' | 'last' | 'current' | undefined;
+    milliseconds: TTimeInstantParameters["milliseconds"] | {
+        absolute: TTimeInstantParameters["milliseconds"];
+    } | TRelativeNumber | {
+        relative: number;
+        relativeTo: 'now' | TimeInstant;
+    } | 'next' | 'last' | 'current' | undefined;
+};
+declare function timeInstantBuilder(): {
+    year: (x: TTimeInstantCreationParameters["year"]) => /*elided*/ any;
+    month: (x: TTimeInstantCreationParameters["month"]) => /*elided*/ any;
+    date: (x: TTimeInstantCreationParameters["date"]) => /*elided*/ any;
+    hours: (x: TTimeInstantCreationParameters["hours"]) => /*elided*/ any;
+    minutes: (x: TTimeInstantCreationParameters["minutes"]) => /*elided*/ any;
+    seconds: (x: TTimeInstantCreationParameters["seconds"]) => /*elided*/ any;
+    milliseconds: (x: TTimeInstantCreationParameters["milliseconds"]) => /*elided*/ any;
+    values: (x: Partial<TTimeInstantCreationParameters>) => /*elided*/ any;
+    relativeTo: (x: TimeInstant | Date) => /*elided*/ any;
+    build: () => TimeInstant;
+};
+type TTimeInstantBuilder = ReturnType<typeof timeInstantBuilder>;
+
+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;
+    distanceFromUnixTimestamp(timestamp: number): TimeDuration;
+    timeLeftFrom(instant: TimeInstant): TimeDuration;
+    timeLeftFromNow(): TimeDuration;
+    distanceFromStartOfDay(): TimeDuration;
+    atStartOfDay(): TimeInstant;
+    distanceFromEndOfDay(): TimeDuration;
+    atEndOfDay(): TimeInstant;
+    promise(): Promise<void>;
+    cancelablePromise(): ICancelablePromise<void>;
+    delay(cb: () => unknown): void;
+    cancelableDelay(cb: () => unknown): ICancelable;
+    ensureInTheFuture(): void;
+    ensureInThePast(): void;
+    isToday(): boolean;
+    /**
+     * Formats this instant using the given pattern. The pattern can contain the following tokens:
+     *
+     * Note: Implementation inspired by the small-date library (https://github.com/robinweser/small-date).
+     *
+     * | 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;
+    /**
+     * Parses a date string using the given pattern and creates a TimeInstant.
+     * This method is the inverse of format() - parsing a formatted string should recreate the original instant.
+     *
+     * For partial patterns (e.g., time-only or date-only), the missing components are taken from the base instant.
+     * For example, parsing "14:30" with base set to yesterday at midnight will result in yesterday at 14:30.
+     *
+     * Note: Currently performs basic validation (e.g., month 1-12, day 1-31) but does not validate
+     * calendar-specific constraints (e.g., February 30th, April 31st). Invalid dates may be
+     * normalized by the underlying Date constructor.
+     *
+     * @param dateString The date string to parse
+     * @param pattern The pattern used to parse the string (same tokens as format())
+     * @param base The base TimeInstant to use for partial patterns (defaults to now)
+     * @param config An optional locale and timeZone definition to use during parsing
+     * @returns A TimeInstant parsed from the string
+     * @throws Error if the string doesn't match the pattern or contains invalid basic values
+     * @todo Add calendar-aware validation to reject dates like February 30th, April 31st
+     */
+    static fromString(dateString: string, pattern: string, base?: TimeInstant, config?: {
+        locale?: string;
+        timeZone?: string;
+    }): TimeInstant;
+    static parse(dateString: string, pattern: string, config?: {
+        locale?: string;
+        timeZone?: string;
+    }): Partial<TTimeInstantParameters>;
+    /**
+ * @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, containing both the date and the time. The format COULD change in the future, do NOT use this method for consistent outputs.
+     */
+    asHumanTimestamp(): string;
+    toUnixTimestamp(): number;
+    toDate(): Date;
+    toParameters(): TTimeInstantParameters;
+    /**
+     * @returns true if the instant is in the past, false otherwise
+     */
+    isInThePast(): boolean;
+    /**
+     * @returns true if the instant is in the future, false otherwise
+     */
+    isInTheFuture(): boolean;
+    isAfter(other: TimeInstant): boolean;
+    isBefore(other: TimeInstant): boolean;
+    compareTo(other: TimeInstant): TComparisonResult;
+    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;
+    static fromIso8601(str: string): TimeInstant;
+    /**
+     * @deprecated [2025.10.19]: Use fromIso8601 instead.
+     */
+    static tryFromIso8601: typeof TimeInstant.fromIso8601;
+    static now(): TimeInstant;
+    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;
+    /**
+     * 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;
+}
+declare function isTimeInstant(x: unknown): x is TimeInstant;
+
+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;
+    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;
+    interval(cb: () => unknown): TIntervalHandle;
+    timeout(cb: () => unknown): TTimeoutHandle;
+    cancelablePromise(): ICancelablePromise<void>;
+    promise(): Promise<void>;
+    delay(cb: () => unknown): void;
+    cancelableDelay(cb: () => unknown): ICancelable;
+    debounce<T>(fn: (t: T) => void): (t: T) => void;
+    toDigitalClock(): string;
+    get asSeconds(): string;
+    fromNow(): TimeInstant;
+    differenceFrom(other: TimeDuration): TimeDuration;
+    isGreaterThan(other: TimeDuration): boolean;
+    isLessThan(other: TimeDuration): boolean;
+    compareTo(other: TimeDuration): TComparisonResult;
+    atLeast(other: TimeDuration): TimeDuration;
+    atMost(other: TimeDuration): TimeDuration;
+    isEmpty(): boolean;
+    isNotEmpty(): boolean;
+    toUnits(): TTimeInUnits;
+    /**
+        * 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: (value: number) => TimeDuration;
+    static seconds: (value: number) => TimeDuration;
+    static minutes: (value: number) => TimeDuration;
+    static hours: (value: number) => TimeDuration;
+    static days: (value: number) => TimeDuration;
+    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;
+    static fromUnits(parameters: Partial<TTimeInUnits>): TimeDuration;
+}
+type TPredefinedTimeDuration = 0 | 50 | 100 | 150 | 200 | 250 | 300 | 500 | 1000 | 1500 | 2000 | 2500 | 5000;
+type TValidTimeDuration = TimeDuration | TPredefinedTimeDuration;
+type TAllowedTimeDuration = TValidTimeDuration | number;
+declare function isAllowedTimeDuration(t: unknown): t is TAllowedTimeDuration;
+
+type TComparisonResult = -1 | 0 | 1;
+type TStrictComparisonResult = -1 | 1;
+type TComparisonFunction<T> = TBiFunction<T, T, TComparisonResult>;
+type TComparisonDirection = 'ASC' | 'DESC';
+
+type TComparable<T> = {
+    compare: TComparisonFunction<T>;
+};
+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>) => TSorterStepUsing<string, Ret>;
+    usingNumbers: (field: TKeysOfType<T, number>) => TSorterStepUsing<number, Ret>;
+    usingBooleans: (field: TKeysOfType<T, boolean>) => TSorterStepUsing<boolean, Ret>;
+    usingDates: (field: TKeysOfType<T, Date>) => TSorterStepUsing<Date, Ret>;
+    usingTimeInstant: (field: TKeysOfType<T, TimeInstant>) => TSorterStepUsing<TimeInstant, Ret>;
+    usingTimeDuration: (field: TKeysOfType<T, TimeDuration>) => TSorterStepUsing<TimeDuration, Ret>;
+};
+type TSorterStepForNumbers<_T, Ret> = {
+    inAscendingOrder(opts?: {
+        nullsFirst?: boolean;
+    }): Ret;
+    inDescendingOrder(opts?: {
+        nullsFirst?: boolean;
+    }): Ret;
+};
+type TSorterStepForStrings<_T, Ret> = {
+    /** @deprecated: Use inLexographicalOrder instead */ inLexographicalOrder(opts?: {
+        nullsFirst?: boolean;
+    }): Ret;
+    /** @deprecated: Use inLexographicalOrderIgnoringCase instead */ inLexographicalOrderIgnoringCase(opts?: {
+        nullsFirst?: boolean;
+    }): Ret;
+    /** @deprecated: Use inReverseLexographicalOrder instead */ inReverseLexographicalOrder(opts?: {
+        nullsFirst?: boolean;
+    }): Ret;
+    /** @deprecated: Use inReverseLexographicalOrderIgnoringCase instead */ inReverseLexographicalOrderIgnoringCase(opts?: {
+        nullsFirst?: boolean;
+    }): Ret;
+    inLexicographicalOrder(opts?: {
+        nullsFirst?: boolean;
+    }): Ret;
+    inLexicographicalOrderIgnoringCase(opts?: {
+        nullsFirst?: boolean;
+    }): Ret;
+    inReverseLexicographicalOrder(opts?: {
+        nullsFirst?: boolean;
+    }): Ret;
+    inReverseLexicographicalOrderIgnoringCase(opts?: {
+        nullsFirst?: boolean;
+    }): Ret;
+};
+type TSorterStepForBooleans<_T, Ret> = {
+    truesFirst(opts?: {
+        nullsFirst?: boolean;
+    }): Ret;
+    falsesFirst(opts?: {
+        nullsFirst?: boolean;
+    }): Ret;
+};
+type TSorterStepForDates<_T, Ret> = {
+    oldestDateFirst(opts?: {
+        nullsFirst?: boolean;
+    }): Ret;
+    newestDateFirst(opts?: {
+        nullsFirst?: boolean;
+    }): Ret;
+};
+type TSorterStepForTimeInstant<_T, Ret> = {
+    oldestFirst(opts?: {
+        nullsFirst?: boolean;
+    }): Ret;
+    newestFirst(opts?: {
+        nullsFirst?: boolean;
+    }): Ret;
+};
+type TSorterStepForTimeDuration<_T, Ret> = {
+    longestFirst(opts?: {
+        nullsFirst?: boolean;
+    }): Ret;
+    shortestFirst(opts?: {
+        nullsFirst?: boolean;
+    }): Ret;
+};
+type TSorterStepForChainables<T, Ret> = {
+    chain: (chain: TComparable<T>) => Ret;
+    chainFunction: (fn: TComparisonFunction<T>) => Ret;
+};
+type TSorterStepForUsing<T, Ret> = {
+    using: <X>(transform: TFunction<T, X>) => TSorterStepUsing<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 TSorterStepUsing<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 TimeInstant ? TSorterStepForTimeInstant<T, Ret> : {}) & (T extends TimeDuration ? TSorterStepForTimeDuration<T, Ret> : {}) & (T extends string ? TSorterStepForPrioritizable<string, Ret> : {}) & (T extends number ? TSorterStepForPrioritizable<number, Ret> : {});
+type TSorterStep<T, Ret> = TSorterStepUsing<T, Ret> & TSorterStepForChainables<T, Ret> & TSorterStepForUsing<T, Ret>;
+type TSorterStarter<T> = TSorterStepUsing<T, TSorter<T>> & TSorterStepForUsing<T, TSorter<T>> & {
+    usingFunction: (fn: TComparisonFunction<T>) => TSorter<T>;
+};
+type TSorterBuilder<T> = (builder: TSorterStarter<T>) => TSorter<T>;
+type TPrioritizeOptions = {};
+declare const defaultPrioritizeOptions: {};
+declare const Sorter: {
+    createFor: <T>(_template?: 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;
+};
+
+type TMaybe<T> = T | null;
+declare function ensureDefined<T>(v: T, name?: string): T;
+declare function isDefined<T>(x: T | null | undefined): x is T;
+declare function isNullOrUndefined(x: unknown): x is null | undefined;
+declare function ifDefined<R>(source: TMaybe<R>, callback: TConsumer<R>): void;
+declare function mapDefined<R, S>(source: TMaybe<R>, mapper: TFunction<R, S>): TMaybe<S>;
+declare function ifNullOrUndefined(source: TMaybe<unknown>, callback: TVoidFunction): void;
+declare function throwIfNullOrUndefined(source: TMaybe<unknown>, errorProducer?: TProducer<Error>): void;
+
+declare function groupByString<V, K extends TKeysOfType<V, string>>(arr: TReadableArray<V>, field: K): Record<V[K] & string, V[]>;
+declare function groupByNumber<V, K extends TKeysOfType<V, number>>(arr: TReadableArray<V>, field: K): Record<V[K] & number, V[]>;
+declare function groupByBoolean<V, K extends TKeysOfType<V, boolean>>(arr: TReadableArray<V>, field: K): Record<"true" | "false", V[]>;
+declare function groupBySymbol<V, K extends TKeysOfType<V, symbol>>(arr: TReadableArray<V>, field: K): Record<V[K] & symbol, V[]>;
+declare function groupByStringWith<V, K extends string>(arr: TReadableArray<V>, getter: TFunction<V, K>): Record<K, V[]>;
+declare function groupByNumberWith<V, K extends number>(arr: TReadableArray<V>, getter: TFunction<V, K>): Record<K, V[]>;
+declare function groupByBooleanWith<V, K extends boolean>(arr: TReadableArray<V>, getter: TFunction<V, K>): Record<"true" | "false", V[]>;
+declare function groupBySymbolWith<V, K extends symbol>(arr: TReadableArray<V>, getter: TFunction<V, K>): Record<K, V[]>;
+
+declare function indexByString<V, K extends TKeysOfType<V, string>>(arr: V[], field: K): Record<V[K] & string, V>;
+declare function indexByNumber<V, K extends TKeysOfType<V, number>>(arr: V[], field: K): Record<V[K] & number, V>;
+declare function indexBySymbol<V, K extends TKeysOfType<V, symbol>>(arr: V[], field: K): Record<V[K] & symbol, V>;
+declare function indexByStringWith<V>(arr: V[], getter: TFunction<V, string>): Record<string, V>;
+declare function indexByNumberWith<V>(arr: V[], getter: TFunction<V, number>): Record<number, V>;
+declare function indexBySymbolWith<V>(arr: V[], getter: TFunction<V, symbol>): Record<symbol, V>;
+
+declare function average(arr: TReadableArray<number>): number;
+declare function sum(arr: TReadableArray<number>): number;
+declare function sumBy<T>(arr: TReadableArray<T>, getter: (t: T) => number): number;
+declare function min(arr: TReadableArray<number>): number;
+declare function minBy<T>(arr: TReadableArray<T>, getter: (t: T) => number): number;
+declare function max(arr: TReadableArray<number>): number;
+declare function maxBy<T>(arr: TReadableArray<T>, getter: (t: T) => number): number;
+
+declare function uniq<T>(arr: T[]): T[];
+declare function uniqBy<T, K>(arr: T[], getter: TFunction<T, K>): T[];
+declare function uniqByKey<T, K extends keyof T>(arr: T[], key: K): T[];
+
+type TReadableArray<T> = Array<T> | ReadonlyArray<T>;
+type TArrayable<T> = T | T[];
+type TEmptyArray = [];
+declare function ensureArray<const T>(t: T | Array<T> | null | undefined): Array<T>;
+declare function ensureReadableArray<const T>(t: T | Array<T> | ReadonlyArray<T> | null | undefined): TReadableArray<T>;
+declare function isArray<const T>(t: unknown): t is Array<T>;
+/**
+ * Generate a new copy of an array with:
+ * - the first instance of an item matching the predicate being replaced with the given argument
+ * - the given argument added as last item of the array if the predicate did not produce a match
+ * @param arr - the original array of items
+ * @param item - the item to insert or update
+ * @param predicate - a function that returns true iff an item is equal to the given argument
+ * @returns a new copy of the array with the item updated or added in last place
+ */
+declare function upsert<T>(arr: ReadonlyArray<T>, item: T, isEqual: TBiPredicate<T>): Array<T>;
+declare function range(start: number, end: number): Array<number>;
+declare function fill<T>(length: number, value: T): Array<T>;
+declare function extendArray<T extends Record<string | number | symbol, unknown>, X extends Record<string | number | symbol, unknown>>(arr: TReadableArray<T>, props: X): Array<(T & X)>;
+declare function extendArrayWith<T extends Record<string | number | symbol, unknown>, X extends Record<string | number | symbol, unknown>>(arr: TReadableArray<T>, propsFn: (t: T) => X): Array<(T & X)>;
+declare function reverse<T>(arr: TReadableArray<T>): Array<T>;
+declare function first<T>(arr: TReadableArray<T>, defaultValue?: TMaybe<T>): TMaybe<T>;
+declare function last<T>(arr: TReadableArray<T>, defaultValue?: TMaybe<T>): TMaybe<T>;
+declare const head: typeof first;
+declare function tail<T>(arr: TReadableArray<T>): T[];
+declare function sortedArray<T>(arr: Array<T>, sortFn?: TComparisonFunction<T> | undefined): Array<T>;
+declare function sortedArray<T>(arr: ReadonlyArray<T>, sortFn?: TComparisonFunction<T> | undefined): ReadonlyArray<T>;
+/**
+ * Custom implementation of includes which allows checking for arbitrary items inside the array.
+ */
+declare function arrayIncludes<T>(arr: TReadableArray<T>, item: unknown, fromIndex?: number): boolean;
+/** @deprecated[2025.11.08]: Use {@link arrayIncludes} instead. */
+declare const includes: typeof arrayIncludes;
+declare function mapTruthys<T, R>(arr: Array<T>, mapper: (value: T, index: number, array: T[]) => R | undefined): Array<R>;
+declare function flatMapTruthys<T, R>(arr: Array<T>, mapper: (value: T, index: number, array: T[]) => R | undefined): Array<R>;
+declare function filterMap<T, R>(array: T[], filterFn: TPredicate<T>, mapFn: TTransformer<T, R>): R[];
+declare function filterMapReduce<T, U, R>(array: T[], filterFn: TPredicate<T>, mapFn: TTransformer<T, U>, reduceFn: TAccumulator<R, U>, initialValue: R): R;
+/**
+ * Partitions the given array in two groups, in the first one there will be any and only values of the array that match the given predicate, in the second one there will be any and only values that don't.
+ * @param arr the array of items
+ * @param predicate the predicate to use to partition the array
+ * @returns a tuple, where the first array contains items matching the predicate, and the second array contains items not matching the predicate.
+ */
+declare function partition<T>(arr: T[], predicate: TPredicate<T>): [T[], T[]];
+/**
+ * Maps the first truthy value in the array using the provided mapping function.
+ * @param arr - The array of items.
+ * @param mapFn - The mapping function.
+ * @returns The first truthy value returned by the mapping function, or null if no truthy value is found.
+ */
+declare function mapFirstTruthy<T, R>(arr: T[], mapFn: TTransformer<T, R>): R | null;
+declare function listToDict<T, K extends string, V>(arr: T[], mapFn: TTransformer<T, [K, V]>): Record<K, V>;
+declare function shallowArrayEquals(a: unknown[], b: unknown[]): boolean;
+declare function findInArray<T>(arr: T[], predicate: TPredicate<T>): TOptional<T>;
+declare function findIndexInArray<T>(arr: T[], predicate: TPredicate<T>): TOptional<number>;
+declare function zip<T, R>(ts: T[], rs: R[]): [T, R][];
+declare function unzip<T, R>(arr: [T, R][]): [T[], R[]];
+/**
+ * Gets the element at the specified index in the array, wrapped in an Optional.
+ * Returns an empty Optional if the index is out of bounds (negative or >= array length).
+ * @param arr - The array to get the element from
+ * @param index - The index of the element to retrieve
+ * @returns An Optional containing the element at the index, or empty if index is out of bounds
+ */
+declare function arrayGet<T>(arr: TReadableArray<T>, index: number): TEmptyOptional<T> | TPresentOptional<T>;
+
+declare function isTrue(x: unknown): x is true;
+declare function isFalse(x: unknown): x is false;
+
+declare function dictToEntries<V, K extends string = string>(obj: Record<K, V>): [K, V][];
+declare function entriesToDict<V, K extends string = string>(entries: [K, V][]): Record<K, V>;
+declare function entriesToEntries<K1 extends string, V1, K2 extends string, V2>(dict: Record<K1, V1>, mapper: TFunction<[K1, V1], [K2, V2]>): Record<K2, V2>;
+/** @deprecated[2025.08.01]: Compatibility layer. */
+declare const mapEntries: typeof entriesToEntries;
+declare function entriesToList<K1 extends string, V1, R>(dict: Record<K1, V1>, mapper: TFunction<[K1, V1], R>): Array<R>;
+
+type TEmpty = Record<string, never>;
+type TKeysOfType<T, V> = {
+    [K in keyof T]-?: T[K] extends V ? K : never;
+}[keyof T];
+declare function dictToList<T>(obj: Record<string | number, T>): T[];
+declare function pick<T extends object, K extends keyof T>(o: T, keys: K[]): Pick<T, K>;
+type TOptionsWithoutDefaults<T, R> = Partial<T> & Required<Omit<T, keyof R>>;
+type TOptionalKeysForType<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? K : never;
+}[keyof T];
+type TRequiredKeysForType<T> = Exclude<keyof T, TOptionalKeysForType<T>>;
+type TAllKeysOptional<T> = TRequiredKeysForType<T> extends never ? true : false;
+type TConditionalParameter<T> = TAllKeysOptional<T> extends true ? T | undefined : T;
+type TConditionalParameterOptions<T, R> = TConditionalParameter<TOptionsWithoutDefaults<T, R>>;
+/**
+ * Given a type T, replaces all fields of type From to fields of type To.
+ */
+type TReplaceType<T, From, To> = {
+    [K in keyof T]: T[K] extends From ? To : T[K];
+};
+/**
+ * Given a type T, make field K required instead of optional.
+ */
+type TWithRequiredProperty<T, K extends keyof T> = T & {
+    [Property in K]-?: T[Property];
+};
+/**
+ * Given a type T, make all fields required instead of optional.
+ */
+type TWithRequiredProperties<T> = Required<T>;
+/**
+ * Type that forces a record to contain a few properties, but allows for extraneous properties.
+ */
+type TWithExtras<R extends Record<any, any>, T extends Record<any, any> = Record<string, unknown>> = R & T;
+/**
+ * Types that improves the human readability of a Typescript type.
+ */
+type TPrettify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+declare function shallowRecordEquals(a: Record<string, unknown>, b: Record<string, unknown>): boolean;
+/**
+ * A utility type that checks if any property in a record type `T` has the `never` type.
+ * This type evaluates to `true` if at least one property in `T` is of type `never`, and `false` otherwise.
+ * It's commonly used to create compile-time assertions that prevent unintended changes where properties might accidentally become `never` due to type mismatches.
+ *
+ * @example Advanced usage for type guards
+ * ```typescript
+ * type TMap = { a: string; b: number; c: boolean };
+ * type TJsonSerializable = string | number | boolean;
+ *
+ * type TFiltered = {
+ *   [K in keyof TMap]: TMap[K] extends TJsonSerializable ? TMap[K] : never;
+ * };
+ *
+ * // If TMap changes and some property becomes not serializable, TFiltered will have 'never' values
+ * const _guard: THasNever<TFiltered> = false; // Compile error if any property became 'never'
+ * ```
+ */
+type THasNever<T> = {
+    [K in keyof T]: [T[K]] extends [never] ? true : false;
+}[keyof T] extends false ? false : true;
+
+type TCssRuleDeclarationKey = TKeysOfType<CSSStyleDeclaration, string> & string;
+type TCssVariableDeclarationKey = `--${string}`;
+type TCssGenericDeclarationKey = TCssRuleDeclarationKey | TCssVariableDeclarationKey;
+type TCssDeclarationRulesDictionary = Partial<Record<TCssGenericDeclarationKey, string>>;
+type TCssSelectorDeclarationRulesDictionary = {
+    [selector: string]: TCssDeclarationRulesDictionary | TCssSelectorDeclarationRulesDictionary;
+};
+declare function cssDeclarationRulesDictionaryToCss(syleDeclarationRulesForSelectorsProduceable: TProduceable<TCssSelectorDeclarationRulesDictionary>, indent?: number): string;
+declare function transformCssDictionary(dict: TCssSelectorDeclarationRulesDictionary, transformer: (key: TCssGenericDeclarationKey, value: string) => string): TCssSelectorDeclarationRulesDictionary;
+type TProduceable<T> = T | TProducer<T>;
+
+/**
+ * Define a new type that is true if T is the empty object, false otherwise.
+ */
+type TIsEmptyObject<T> = keyof T extends never ? true : false;
+/**
+ * Defines a new type that is the empty array, if T is an empty object, or is the array containing T if T is not the empty object.<br/>
+ * This type can be used as function argument, to conditionally require an argument based on type T.<br/>
+ * Usage example:
+ * ```
+ * type TMetadata = { a: {}, b: {}, c: { x: 1 } };
+ * function foo<X extends keyof TMetadata>( type: X, metadata: TMetadata[X] ) { ... };
+ * export function fooWrapper<X extends keyof TMetadata>( type: X, ...args: TConditionalOptionalType<TMetadata[X]> ) {
+ * 	const bar = foo( type, args.length === 0 ? void 0 : args[ 0 ] );
+ * }
+ * ```
+ */
+type TConditionalOptionalType<T> = TIsEmptyObject<T> extends true ? [] : [T];
+type TEmptyObject = Record<string, never>;
+
+type TOperation<T, E = Error> = {
+    success: false;
+    error: E;
+} | {
+    success: true;
+    data: T;
+};
+type TAsyncOperation<T, E = Error> = Promise<TOperation<T, E>>;
+type TOperationTuple<T, E = Error> = [T, undefined] | [undefined, E];
+type TAsyncOperationTuple<T, E = Error> = Promise<TOperationTuple<T, E>>;
+type TValidation<T, E = Error> = {
+    success: false;
+    errors: E[];
+} | {
+    success: true;
+    data: T;
+};
+type TAsyncValidation<T, E = Error> = Promise<TValidation<T, E>>;
+declare const Operation: {
+    ok: <const T>(data: T) => {
+        readonly success: true;
+        readonly data: T;
+    };
+    ko: <const E>(error: E) => {
+        readonly success: false;
+        readonly error: E;
+    };
+};
+
+declare function withTryCatch<R>(fn: TFunction<void, R>, errMapFn?: TTransformer<Error, Error>): TOperationTuple<R, Error>;
+declare function withTryCatchAsync<R>(fn: TFunction<void, Promise<R>>, errMapFn?: TTransformer<Error, Error>): TAsyncOperationTuple<R, Error>;
+
+declare function asError(e: unknown): Error;
+declare function isError(e: unknown): e is Error;
+declare function getMessageFromError(error: Error): string;
+declare function getStackFromError(error: Error): string;
+declare function getCauseMessageFromError(error: Error): string;
+declare function getCauseStackFromError(error: Error): string;
+/**
+ * Throws an error if a switch discriminated union type does not cover all the expected cases.
+ * Expected usage: `
+ * switch ( x.type ) {
+ *   case "x": return doX();
+ *   case "y": return doY();
+ *   ...
+ *   default: throw new NonExhaustiveSwitchError( x satisfies never );
+ * }`
+ */
+declare class NonExhaustiveSwitchError extends Error {
+    constructor(value: unknown);
+}
+
+type TJsonPrimitive = string | number | boolean | null | undefined;
+type TJsonArray = Array<TJsonSerializable> | ReadonlyArray<TJsonSerializable>;
+type TJsonObject = {
+    [key: string]: TJsonSerializable;
+};
+type TJsonSerializable = TJsonPrimitive | TJsonArray | TJsonObject;
+declare function tryToParseJson<T extends TJsonSerializable>(jsonContent: string): [T, undefined] | [undefined, Error];
+declare function parseJson<T extends TJsonSerializable>(jsonContent: string): T;
+declare function stringifyJson(jsonSerializable: TJsonSerializable, minify?: boolean): string;
+declare function jsonCloneDeep<A extends TJsonSerializable>(a: A): A;
+declare function omitFromJsonObject<T extends TJsonObject, K extends keyof T>(o: T, ...keys: K[]): Omit<T, K>;
+
+type TRoundMode = 'toNearest' | 'toLower' | 'toUpper' | 'towardsZero' | 'awayFromZero';
+declare function round(n: number, precision?: number, mode?: TRoundMode): number;
+
+declare const roundToNearest: (n: number, precision?: number) => number;
+declare const roundToLower: (n: number, precision?: number) => number;
+declare const roundToUpper: (n: number, precision?: number) => number;
+declare const roundTowardsZero: (n: number, precision?: number) => number;
+declare const roundAwayFromZero: (n: number, precision?: number) => number;
+
+type TNumericString = `${number}`;
+type TNumericFloatingPointString = `${number}.${number}`;
+type TPositiveNumber = number;
+type TNegativeNumber = number;
+type TZero = 0;
+type TDigit = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9;
+type TDigit1_9 = 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9;
+type TNumber0_100 = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20 | 21 | 22 | 23 | 24 | 25 | 26 | 27 | 28 | 29 | 30 | 31 | 32 | 33 | 34 | 35 | 36 | 37 | 38 | 39 | 40 | 41 | 42 | 43 | 44 | 45 | 46 | 47 | 48 | 49 | 50 | 51 | 52 | 53 | 54 | 55 | 56 | 57 | 58 | 59 | 60 | 61 | 62 | 63 | 64 | 65 | 66 | 67 | 68 | 69 | 70 | 71 | 72 | 73 | 74 | 75 | 76 | 77 | 78 | 79 | 80 | 81 | 82 | 83 | 84 | 85 | 86 | 87 | 88 | 89 | 90 | 91 | 92 | 93 | 94 | 95 | 96 | 97 | 98 | 99 | 100;
+type TNumber0_1000 = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20 | 21 | 22 | 23 | 24 | 25 | 26 | 27 | 28 | 29 | 30 | 31 | 32 | 33 | 34 | 35 | 36 | 37 | 38 | 39 | 40 | 41 | 42 | 43 | 44 | 45 | 46 | 47 | 48 | 49 | 50 | 51 | 52 | 53 | 54 | 55 | 56 | 57 | 58 | 59 | 60 | 61 | 62 | 63 | 64 | 65 | 66 | 67 | 68 | 69 | 70 | 71 | 72 | 73 | 74 | 75 | 76 | 77 | 78 | 79 | 80 | 81 | 82 | 83 | 84 | 85 | 86 | 87 | 88 | 89 | 90 | 91 | 92 | 93 | 94 | 95 | 96 | 97 | 98 | 99 | 100 | 101 | 102 | 103 | 104 | 105 | 106 | 107 | 108 | 109 | 110 | 111 | 112 | 113 | 114 | 115 | 116 | 117 | 118 | 119 | 120 | 121 | 122 | 123 | 124 | 125 | 126 | 127 | 128 | 129 | 130 | 131 | 132 | 133 | 134 | 135 | 136 | 137 | 138 | 139 | 140 | 141 | 142 | 143 | 144 | 145 | 146 | 147 | 148 | 149 | 150 | 151 | 152 | 153 | 154 | 155 | 156 | 157 | 158 | 159 | 160 | 161 | 162 | 163 | 164 | 165 | 166 | 167 | 168 | 169 | 170 | 171 | 172 | 173 | 174 | 175 | 176 | 177 | 178 | 179 | 180 | 181 | 182 | 183 | 184 | 185 | 186 | 187 | 188 | 189 | 190 | 191 | 192 | 193 | 194 | 195 | 196 | 197 | 198 | 199 | 200 | 201 | 202 | 203 | 204 | 205 | 206 | 207 | 208 | 209 | 210 | 211 | 212 | 213 | 214 | 215 | 216 | 217 | 218 | 219 | 220 | 221 | 222 | 223 | 224 | 225 | 226 | 227 | 228 | 229 | 230 | 231 | 232 | 233 | 234 | 235 | 236 | 237 | 238 | 239 | 240 | 241 | 242 | 243 | 244 | 245 | 246 | 247 | 248 | 249 | 250 | 251 | 252 | 253 | 254 | 255 | 256 | 257 | 258 | 259 | 260 | 261 | 262 | 263 | 264 | 265 | 266 | 267 | 268 | 269 | 270 | 271 | 272 | 273 | 274 | 275 | 276 | 277 | 278 | 279 | 280 | 281 | 282 | 283 | 284 | 285 | 286 | 287 | 288 | 289 | 290 | 291 | 292 | 293 | 294 | 295 | 296 | 297 | 298 | 299 | 300 | 301 | 302 | 303 | 304 | 305 | 306 | 307 | 308 | 309 | 310 | 311 | 312 | 313 | 314 | 315 | 316 | 317 | 318 | 319 | 320 | 321 | 322 | 323 | 324 | 325 | 326 | 327 | 328 | 329 | 330 | 331 | 332 | 333 | 334 | 335 | 336 | 337 | 338 | 339 | 340 | 341 | 342 | 343 | 344 | 345 | 346 | 347 | 348 | 349 | 350 | 351 | 352 | 353 | 354 | 355 | 356 | 357 | 358 | 359 | 360 | 361 | 362 | 363 | 364 | 365 | 366 | 367 | 368 | 369 | 370 | 371 | 372 | 373 | 374 | 375 | 376 | 377 | 378 | 379 | 380 | 381 | 382 | 383 | 384 | 385 | 386 | 387 | 388 | 389 | 390 | 391 | 392 | 393 | 394 | 395 | 396 | 397 | 398 | 399 | 400 | 401 | 402 | 403 | 404 | 405 | 406 | 407 | 408 | 409 | 410 | 411 | 412 | 413 | 414 | 415 | 416 | 417 | 418 | 419 | 420 | 421 | 422 | 423 | 424 | 425 | 426 | 427 | 428 | 429 | 430 | 431 | 432 | 433 | 434 | 435 | 436 | 437 | 438 | 439 | 440 | 441 | 442 | 443 | 444 | 445 | 446 | 447 | 448 | 449 | 450 | 451 | 452 | 453 | 454 | 455 | 456 | 457 | 458 | 459 | 460 | 461 | 462 | 463 | 464 | 465 | 466 | 467 | 468 | 469 | 470 | 471 | 472 | 473 | 474 | 475 | 476 | 477 | 478 | 479 | 480 | 481 | 482 | 483 | 484 | 485 | 486 | 487 | 488 | 489 | 490 | 491 | 492 | 493 | 494 | 495 | 496 | 497 | 498 | 499 | 500 | 501 | 502 | 503 | 504 | 505 | 506 | 507 | 508 | 509 | 510 | 511 | 512 | 513 | 514 | 515 | 516 | 517 | 518 | 519 | 520 | 521 | 522 | 523 | 524 | 525 | 526 | 527 | 528 | 529 | 530 | 531 | 532 | 533 | 534 | 535 | 536 | 537 | 538 | 539 | 540 | 541 | 542 | 543 | 544 | 545 | 546 | 547 | 548 | 549 | 550 | 551 | 552 | 553 | 554 | 555 | 556 | 557 | 558 | 559 | 560 | 561 | 562 | 563 | 564 | 565 | 566 | 567 | 568 | 569 | 570 | 571 | 572 | 573 | 574 | 575 | 576 | 577 | 578 | 579 | 580 | 581 | 582 | 583 | 584 | 585 | 586 | 587 | 588 | 589 | 590 | 591 | 592 | 593 | 594 | 595 | 596 | 597 | 598 | 599 | 600 | 601 | 602 | 603 | 604 | 605 | 606 | 607 | 608 | 609 | 610 | 611 | 612 | 613 | 614 | 615 | 616 | 617 | 618 | 619 | 620 | 621 | 622 | 623 | 624 | 625 | 626 | 627 | 628 | 629 | 630 | 631 | 632 | 633 | 634 | 635 | 636 | 637 | 638 | 639 | 640 | 641 | 642 | 643 | 644 | 645 | 646 | 647 | 648 | 649 | 650 | 651 | 652 | 653 | 654 | 655 | 656 | 657 | 658 | 659 | 660 | 661 | 662 | 663 | 664 | 665 | 666 | 667 | 668 | 669 | 670 | 671 | 672 | 673 | 674 | 675 | 676 | 677 | 678 | 679 | 680 | 681 | 682 | 683 | 684 | 685 | 686 | 687 | 688 | 689 | 690 | 691 | 692 | 693 | 694 | 695 | 696 | 697 | 698 | 699 | 700 | 701 | 702 | 703 | 704 | 705 | 706 | 707 | 708 | 709 | 710 | 711 | 712 | 713 | 714 | 715 | 716 | 717 | 718 | 719 | 720 | 721 | 722 | 723 | 724 | 725 | 726 | 727 | 728 | 729 | 730 | 731 | 732 | 733 | 734 | 735 | 736 | 737 | 738 | 739 | 740 | 741 | 742 | 743 | 744 | 745 | 746 | 747 | 748 | 749 | 750 | 751 | 752 | 753 | 754 | 755 | 756 | 757 | 758 | 759 | 760 | 761 | 762 | 763 | 764 | 765 | 766 | 767 | 768 | 769 | 770 | 771 | 772 | 773 | 774 | 775 | 776 | 777 | 778 | 779 | 780 | 781 | 782 | 783 | 784 | 785 | 786 | 787 | 788 | 789 | 790 | 791 | 792 | 793 | 794 | 795 | 796 | 797 | 798 | 799 | 800 | 801 | 802 | 803 | 804 | 805 | 806 | 807 | 808 | 809 | 810 | 811 | 812 | 813 | 814 | 815 | 816 | 817 | 818 | 819 | 820 | 821 | 822 | 823 | 824 | 825 | 826 | 827 | 828 | 829 | 830 | 831 | 832 | 833 | 834 | 835 | 836 | 837 | 838 | 839 | 840 | 841 | 842 | 843 | 844 | 845 | 846 | 847 | 848 | 849 | 850 | 851 | 852 | 853 | 854 | 855 | 856 | 857 | 858 | 859 | 860 | 861 | 862 | 863 | 864 | 865 | 866 | 867 | 868 | 869 | 870 | 871 | 872 | 873 | 874 | 875 | 876 | 877 | 878 | 879 | 880 | 881 | 882 | 883 | 884 | 885 | 886 | 887 | 888 | 889 | 890 | 891 | 892 | 893 | 894 | 895 | 896 | 897 | 898 | 899 | 900 | 901 | 902 | 903 | 904 | 905 | 906 | 907 | 908 | 909 | 910 | 911 | 912 | 913 | 914 | 915 | 916 | 917 | 918 | 919 | 920 | 921 | 922 | 923 | 924 | 925 | 926 | 927 | 928 | 929 | 930 | 931 | 932 | 933 | 934 | 935 | 936 | 937 | 938 | 939 | 940 | 941 | 942 | 943 | 944 | 945 | 946 | 947 | 948 | 949 | 950 | 951 | 952 | 953 | 954 | 955 | 956 | 957 | 958 | 959 | 960 | 961 | 962 | 963 | 964 | 965 | 966 | 967 | 968 | 969 | 970 | 971 | 972 | 973 | 974 | 975 | 976 | 977 | 978 | 979 | 980 | 981 | 982 | 983 | 984 | 985 | 986 | 987 | 988 | 989 | 990 | 991 | 992 | 993 | 994 | 995 | 996 | 997 | 998 | 999;
+type TNumber0_5 = 0 | 1 | 2 | 3 | 4 | 5;
+type TNumber0_10 = TNumber0_5 | 6 | 7 | 8 | 9 | 10;
+type TNumber0_15 = TNumber0_10 | 11 | 12 | 13 | 14 | 15;
+type TNumber0_20 = TNumber0_15 | 16 | 17 | 18 | 19 | 20;
+type TNumber1_10 = Exclude<TNumber0_10, 0>;
+type TParseInt<T> = T extends `${infer N extends number}` ? N : never;
+type TParseableInt<T> = T extends `${number}` ? T : never;
+declare function ensurePositiveNumber(v: number, name?: string): number;
+declare function ensureNonNegativeNumber(v: number, name?: string): number;
+declare function ensureNonPositiveNumber(v: number, name?: string): number;
+declare function ensureNegativeNumber(v: number, name?: string): number;
+declare function incrementBy(n: number): TFunction<number, number>;
+declare function multiplyBy(n: number): TFunction<number, number>;
+declare function divideBy(n: number): TFunction<number, number>;
+declare const increment: TFunction<number, number>;
+declare const decrement: TFunction<number, number>;
+declare const decrementBy: (n: number) => TFunction<number, number>;
+declare function isNumber(v: unknown): v is number;
+declare function isPositiveNumber(v: number): v is TPositiveNumber;
+declare function isNegativeNumber(v: number): v is TNegativeNumber;
+declare function isZero(v: number): v is TZero;
+declare function clamp(n: number, min: number, max: number): number;
+declare function clampInt0_100(n: number): TNumber0_100;
+declare function tryToParseNumber(numberStr: string): TOperationTuple<number, Error>;
+
+type TTimeoutHandle = ReturnType<typeof setTimeout>;
+type TIntervalHandle = ReturnType<typeof setInterval>;
+type TPrimitive = string | number | boolean | null;
+
+type TPromisable<T> = T | Promise<T>;
+declare function asPromise<T>(promisable: TPromisable<T>): Promise<T>;
+declare function promiseSequence<R>(...fns: TFunction<void, Promise<R>>[]): TFunction<void, Promise<R[]>>;
+declare function delayPromise<T>(duration: TimeDuration): TAsyncFunction<T, T>;
+declare class TimeoutError extends Error {
+}
+declare function awaitAtMost<T>(promise: Promise<T>, duration: TimeDuration): Promise<T>;
+declare const NEVER: Promise<unknown>;
+
+declare function randomNumberInInterval(min: number, max: number): number;
+declare const randomId: (length: TPositiveNumber) => string;
+
+declare class StringParts {
+    private readonly _parts;
+    private constructor();
+    toUpperCase(): StringParts;
+    toLowerCase(): StringParts;
+    capitalizeFirst(): StringParts;
+    capitalizeEach(): StringParts;
+    get parts(): string[];
+    get tail(): string[];
+    get first(): TMaybe<string>;
+    get last(): TMaybe<string>;
+    get length(): number;
+    trim(): StringParts;
+    toSnakeCase(): string;
+    toCamelCase(): string;
+    toKebabCase(): string;
+    toPascalCase(): string;
+    toHumanCase(): string;
+    join(separator: string): string;
+    mergeWith({ parts: otherParts }: {
+        parts: TReadableArray<string>;
+    }): StringParts;
+    slice(start: number, end?: number): StringParts;
+    splice(start: number, deleteCount: number, ...items: string[]): StringParts;
+    push(part: string): StringParts;
+    shift(part: string): StringParts;
+    reverse(): StringParts;
+    static fromString: (s: string, separator?: string | RegExp) => StringParts;
+    static fromParts: (...parts: string[]) => StringParts;
+    /**
+     * Tries to convert a word in PascalCase to an array of words. Will not work if there are spaces or special characters. Does not cope well on uppercase abbreviations (eg, "CSS").
+     * @param s a string in PascalCase.
+     * @returns a StringParts where each sub-word in PascalCase is now a part.
+     */
+    static tryToParsePascalCaseWord(s: string): StringParts;
+}
+
+type THtmlString = string;
+type TUrl = string;
+type TRelativeUrl = string;
+declare function hashCode(str: string): number;
+declare function repeat(char: string, times: number): string;
+declare function capitalizeWord(word: string): string;
+declare function splitWords(text: string, regEx?: RegExp): string[];
+declare function stringToNumber(s: string | null | undefined): number | null;
+declare function pad(str: string, n: number, char: string, where?: 'left' | 'right'): string;
+declare function padLeft(str: string, n: number, char: string): string;
+declare function padRight(str: string, n: number, char: string): string;
+declare function ellipsis(str: string, maxLength: number): string;
+declare function pluralize(n: number, singular: string, plural?: string): string;
+declare function isString(source: unknown): source is string;
+declare function isEmpty(source: string): boolean;
+declare function isNullOrUndefinedOrEmpty(source: TMaybe<string>): boolean;
+declare function wrapWithString(str: string, delimiter: string): string;
+declare function wrapWithString(str: string, start: string, end: string): string;
+
+declare 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;
+}
+
+type TPromiseFactory<T, R> = TFunction<T, Promise<R>>;
+declare class RateThrottler {
+    private readonly _frequency;
+    private readonly _availableSlots;
+    private readonly _waitingRequests;
+    constructor(_frequency: TimeFrequency);
+    get cooldown(): TimeDuration;
+    execute<T>(fn: TPromiseFactory<void, T>): Promise<T>;
+}
+
+declare function throttle<TParams extends unknown[], R>(fn: (...params: TParams) => TPromisable<R>, frequence: TimeFrequency): (...params: TParams) => Promise<R>;
+
+declare class Semaphore {
+    private _availableSlots;
+    private readonly _queuedRequests;
+    private _inProgress;
+    /** Creates a new Semaphore with a single slot. */
+    constructor();
+    /** Creates a new Semaphore with the specified amounts of slots. */
+    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;
+}
+
+/**
+ * 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
+ */
+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>;
+}
+
+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>;
+}
+
+declare class LazyDictionary<K extends string | number | symbol, T> {
+    private readonly _generator;
+    private readonly _dictionary;
+    private constructor();
+    static of<K extends string | number | symbol, T>(generator: TFunction<K, T>): LazyDictionary<K, T>;
+    getOrCreate(key: K): T;
+    getOrThrow(key: K, errorMessage?: "Value not initialized"): T;
+}
+
+declare const LEVELS: readonly ["trace", "log", "debug", "info", "warn", "error"];
+type TLogLevel = keyof Console & typeof LEVELS[number];
+type TLoggerOpts = {
+    console: Console;
+    enabled: boolean;
+    minLevel: Uppercase<TLogLevel>;
+};
+declare class Logger {
+    readonly name: string;
+    private enabled;
+    private console;
+    private minLevel;
+    constructor(name: string, args?: Partial<TLoggerOpts>);
+    get trace(): (...args: any[]) => void;
+    get log(): (...args: any[]) => void;
+    get debug(): (...args: any[]) => void;
+    get info(): (...args: any[]) => void;
+    get warn(): (...args: any[]) => void;
+    get error(): (...args: any[]) => void;
+    private logWrap;
+}
+
+declare 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;
+}
+
+declare class TimeRange {
+    readonly start: TimeInstant;
+    readonly duration: TimeDuration;
+    readonly end: TimeInstant;
+    protected constructor(start: TimeInstant, duration: TimeDuration);
+    static fromInstants(a: TimeInstant, b: TimeInstant): TimeRange;
+    static fromInstantWithDuration(a: TimeInstant, d: TimeDuration): TimeRange;
+    static fromNowWithDuration(d: TimeDuration): TimeRange;
+}
+
+declare class UnavailableUpgradeError<T> extends Error {
+    readonly data: T;
+    readonly from: number;
+    readonly to: number;
+    constructor(data: T, from: number, to: number);
+}
+declare class EmptyUpgradeError<T> extends Error {
+    readonly data: T;
+    readonly from: number;
+    readonly to: number;
+    constructor(data: T, from: number, to: number);
+}
+
+type TUpgradable = TJsonObject & {
+    $version: number;
+};
+type TUpgradableAtVersion<XStar extends TUpgradable, N extends XStar["$version"]> = Extract<XStar, {
+    $version: N;
+}>;
+type TVersionMap<XStar extends TUpgradable> = {
+    [XVersionNumber in XStar["$version"]]: TUpgradableAtVersion<XStar, XVersionNumber>;
+};
+type TPossibleVersion<XStar extends TUpgradable> = XStar["$version"] & number;
+type TPossibleFromVersion<XStar extends TUpgradable, XLatest extends XStar> = Exclude<TPossibleVersion<XStar>, XLatest["$version"]>;
+type TUpgradeFunction<XStar extends TUpgradable, XFrom extends XStar, XTo extends XStar> = TFunction<Readonly<TVersionMap<XStar>[XFrom["$version"]]>, TPromisable<TVersionMap<XStar>[XTo["$version"]]>>;
+
+declare const VERSION_FIELD = "$version";
+interface IDataUpgrader<XStar extends TUpgradable, XLatest extends XStar> {
+    upgrade(data: XStar): Promise<XLatest>;
+}
+declare class DataUpgrader<X extends TUpgradable, XLatest extends X> implements IDataUpgrader<X, XLatest> {
+    private latestVersion;
+    private transitions;
+    private constructor();
+    addTransition<XFrom extends TVersionMap<X>[XFromNumber], XTo extends TVersionMap<X>[XToNumber], XFromNumber extends TPossibleFromVersion<X, XLatest>, XToNumber extends Exclude<TPossibleVersion<X>, XFromNumber>>(from: XFromNumber, to: XToNumber, apply: TUpgradeFunction<X, XFrom, XTo>): this;
+    upgrade(data: X): Promise<XLatest>;
+    isLatestVersion(data: X): data is XLatest;
+    static create<X extends TUpgradable, XLatestVersion extends X>(latest: XLatestVersion[typeof VERSION_FIELD]): DataUpgrader<X, XLatestVersion>;
+    static Errors: {
+        readonly EmptyUpgrade: typeof EmptyUpgradeError;
+        readonly UnavailableUpgrade: typeof UnavailableUpgradeError;
+    };
+}
+declare function isUpgradable(obj: TJsonSerializable): obj is TUpgradable;
+
+export { DataUpgrader, Deferred, DeferredCanceledError, ErrorCannotInstantiatePresentOptionalWithEmptyValue, ErrorGetEmptyOptional, ErrorSetEmptyOptional, Lazy, LazyAsync, LazyDictionary, Logger, NEVER, NonExhaustiveSwitchError, Operation, Optional, PredicateBuilder, RandomTimeDuration, RateThrottler, Semaphore, Sorter, StringParts, TimeDuration, TimeFrequency, TimeInstant, TimeRange, TimeUnit, TimeoutError, alwaysFalse, alwaysTrue, and, arrayGet, arrayIncludes, asError, asPromise, average, awaitAtMost, capitalizeWord, clamp, clampInt0_100, constant, constantFalse, constantNull, constantOne, constantTrue, constantUndefined, constantZero, cssDeclarationRulesDictionaryToCss, decrement, decrementBy, delayPromise, dictToEntries, dictToList, divideBy, ellipsis, ensureArray, ensureDefined, ensureNegativeNumber, ensureNonNegativeNumber, ensureNonPositiveNumber, ensurePositiveNumber, ensureReadableArray, entriesToDict, entriesToEntries, entriesToList, extendArray, extendArrayWith, fill, filterMap, filterMapReduce, filterWithTypePredicate, findInArray, findIndexInArray, first, flatMapTruthys, getCauseMessageFromError, getCauseStackFromError, getMessageFromError, getStackFromError, groupByBoolean, groupByBooleanWith, groupByNumber, groupByNumberWith, groupByString, groupByStringWith, groupBySymbol, groupBySymbolWith, hashCode, head, identity, ifDefined, ifNullOrUndefined, iff, includes, increment, incrementBy, indexByNumber, indexByNumberWith, indexByString, indexByStringWith, indexBySymbol, indexBySymbolWith, isAllowedTimeDuration, isArray, isDefined, isEmpty, isError, isFalse, isFunction, isNegativeNumber, isNullOrUndefined, isNullOrUndefinedOrEmpty, isNumber, isPositiveNumber, isString, isTimeInstant, isTrue, isUpgradable, isZero, jsonCloneDeep, last, listToDict, mapDefined, mapEntries, mapFirstTruthy, mapTruthys, max, maxBy, min, minBy, multiplyBy, noop, not, omitFromJsonObject, or, pad, padLeft, padRight, parseJson, partition, pick, pipedInvoke, pipedInvokeFromArray, pluralize, promiseSequence, randomId, randomNumberInInterval, range, repeat, reverse, round, roundAwayFromZero, roundToLower, roundToNearest, roundToUpper, roundTowardsZero, shallowArrayEquals, shallowRecordEquals, sortedArray, splitWords, stringToNumber, stringifyJson, sum, sumBy, tail, throttle, throwIfNullOrUndefined, transformCssDictionary, tryToParseJson, tryToParseNumber, uniq, uniqBy, uniqByKey, unzip, upsert, withTryCatch, withTryCatchAsync, wrapWithString, xor, zip };
+export type { ICancelable, ICancelablePromise, IDataUpgrader, TAccumulator, TAllKeysOptional, TAnyFunction, TArrayable, TAsyncAnyFunction, TAsyncBiConsumer, TAsyncBiFunction, TAsyncBiPredicate, TAsyncConsumer, TAsyncFunction, TAsyncOperation, TAsyncOperationTuple, TAsyncPredicate, TAsyncProducer, TAsyncValidation, TAsyncVoidFunction, TBiConsumer, TBiFunction, TBiPredicate, TComparisonDirection, TComparisonFunction, TComparisonResult, TConditionalOptionalType, TConditionalParameter, TConditionalParameterOptions, TConsumer, TCssDeclarationRulesDictionary, TCssSelectorDeclarationRulesDictionary, TDayOfMonth, TDayOfWeek, TDigit, TDigit1_9, TEmpty, TEmptyArray, TEmptyObject, TEmptyOptional, TFourDigits, TFourDigitsMillisecond, TFourDigitsYear, TFunction, THasNever, THourOfDay, THtmlString, TIdentityFunction, TIntervalHandle, TIsEmptyObject, TIso8601DateString, TIso8601DateUtcString, TJsonArray, TJsonObject, TJsonPrimitive, TJsonSerializable, TKeysOfType, TLoggerOpts, TMaybe, TMillisecondOfSecond, TMinuteOfHour, TMonth, TMonthName, TNegativeNumber, TNumber0_10, TNumber0_100, TNumber0_1000, TNumber0_15, TNumber0_20, TNumber0_5, TNumber1_10, TNumericFloatingPointString, TNumericString, TOneDigit, TOperation, TOperationTuple, TOptional, TOptionalKeysForType, TOptionsWithoutDefaults, TParseInt, TParseableInt, TPositiveNumber, TPredefinedTimeDuration, TPredicate, TPresentOptional, TPrettify, TPrimitive, TProducer, TPromisable, TReadableArray, TRelativeUrl, TReplaceType, TRequiredKeysForType, TSecondOfMinute, TSorter, TSorterBuilder, TStrictComparisonResult, TThreeDigits, TThreeDigitsMillisecond, TTimeInUnits, TTimeoutHandle, TTransformer, TTwoDigits, TTwoDigitsDate, TTwoDigitsHour, TTwoDigitsMinute, TTwoDigitsMonth, TTwoDigitsSecond, TTypePredicate, TUpToFourDigits, TUpToThreeDigits, TUpToTwoDigits, TUpgradable, TUrl, TValidTimeDuration, TValidation, TVoidFunction, TWeekNumber, TWithExtras, TWithRequiredProperties, TWithRequiredProperty, TYear, TZero };