@zajno/common 2.4.2 → 2.4.4

package/types/dates/calc.d.ts

@@ -1,4 +1,4 @@
-import { Granularity } from './types';
+import { Granularity } from './types.js';
 export declare function contains(start: Date | number, end: Date | number, target: Date | number, granularity?: Granularity): boolean;
 export declare function intersects(start1: Date | number, end1: Date | number, start2: Date | number, end2: Date | number, granularity?: Granularity): boolean;
 export declare function countDays(start: Date, end: Date, condition?: (d: Date) => boolean): number;

package/types/dates/convert.d.ts

@@ -1,4 +1,4 @@
-import { Granularity } from './types';
+import { Granularity } from './types.js';
 type DateFields<T> = {
     [P in keyof T]: T[P] extends Date ? P : never;
 }[keyof T];

package/types/dates/datex.d.ts

@@ -1,4 +1,4 @@
-import { Granularity } from './types';
+import { Granularity } from './types.js';
 export declare namespace DateX {
     type DateGranularity = Granularity | 'weekDay';
     function get(d: Date, g: DateGranularity, local: boolean): number;

package/types/dates/decompose.d.ts

@@ -1,4 +1,4 @@
-import { Granularity } from './types';
+import { Granularity } from './types.js';
 export type DecomposeGranularity = 'week' | 'day' | 'hour' | 'minute' | 'second';
 export declare function decomposeMs<K extends Granularity & DecomposeGranularity>(ms: number, ...grans: K[]): Record<K, number>;
 export declare function decompose(date: number | Date, local: boolean, ...grans: (Granularity & DecomposeGranularity)[]): Partial<Record<DecomposeGranularity, number>>;

package/types/dates/format.d.ts

@@ -1,4 +1,4 @@
-import { YearDate } from './yearDate';
+import { YearDate } from './yearDate.js';
 export declare namespace Format {
     const DefaultLocale = "en-US";
     enum Presets {

package/types/dates/index.d.ts

@@ -1,10 +1,10 @@
-export * from './calc';
-export * from './convert';
-export * from './datex';
-export * from './format';
-export * from './parse';
-export * from './period';
-export * from './shift';
-export * from './types';
-export * from './yearDate';
-export * from './decompose';
+export * from './calc.js';
+export * from './convert.js';
+export * from './datex.js';
+export * from './format.js';
+export * from './parse.js';
+export * from './period.js';
+export * from './shift.js';
+export * from './types.js';
+export * from './yearDate.js';
+export * from './decompose.js';

package/types/dates/period.d.ts

@@ -1,4 +1,4 @@
-import { Granularity } from './types';
+import { Granularity } from './types.js';
 export type Period = {
     amount: number;
     granularity: Granularity;

package/types/dates/shift.d.ts

@@ -1,4 +1,4 @@
-import { Granularity } from './types';
+import { Granularity } from './types.js';
 export declare function addDays(start: Date, amount: number, condition: (d: Date) => boolean, maxShift?: number): Date;
 export declare function shiftDate(date: Date | number, amount: number, granularity: Granularity, local?: boolean): Date;
 /** @deprecated Use {@link shiftDate} instead */

package/types/fields/index.d.ts

@@ -1,3 +1,3 @@
-export * from './filter';
-export * from './update';
-export * from './transfer';
+export * from './filter.js';
+export * from './update.js';
+export * from './transfer.js';

package/types/fields/update.d.ts

@@ -1,4 +1,4 @@
-import { Comparator } from '../types';
+import { Comparator } from '../types/index.js';
 export declare namespace Fields {
     type Getter<T> = (obj: Partial<T>) => (T[keyof T] | undefined);
     type Setter<T> = (obj: Partial<T>, val: T[keyof T] | undefined) => void;

package/types/functions/assert.d.ts

@@ -1,2 +1,2 @@
-import { Getter } from '../types';
+import { Getter } from '../types/index.js';
 export declare function assert(condition: boolean, error: Getter<string | Error>, objectToLog?: Getter<any>): asserts condition;

package/types/functions/disposer.symbols.d.ts

@@ -1,4 +1,4 @@
-import type { IDisposable } from './disposer';
+import type { IDisposable } from './disposer.js';
 export declare abstract class SymbolDisposable implements globalThis.Disposable, IDisposable {
     [Symbol.dispose]: () => void;
     abstract dispose(): void;

package/types/functions/safe.d.ts

@@ -1,4 +1,4 @@
-import { Nullable } from '../types';
+import { Nullable } from '../types/index.js';
 type LaxPromise<T> = Promise<T> | T | void;
 export declare function catchPromise(promise: LaxPromise<any>, cb?: (err: any) => void): void;
 export declare function wrapAsync<T, TArgs extends any[]>(fn: Nullable<(...args: TArgs) => LaxPromise<T>>, cb?: (err: any) => void): (...args: TArgs) => void;

package/types/functions/throttle.d.ts

@@ -1,4 +1,4 @@
-import { ILogger } from '../logger';
+import { ILogger } from '../logger/index.js';
 /** Runs a callback after a timeout, ignoring all consecutive calls until the first is processed.  */
 export declare class ThrottleAction<T = any> {
     timeout: number;

package/types/lazy/light.d.ts

@@ -1,2 +1,2 @@
-import type { ILazy } from './types';
+import type { ILazy } from './types.js';
 export declare function createLazy<T>(factory: () => T): ILazy<T>;

package/types/lazy/promise.d.ts

@@ -1,5 +1,5 @@
-import type { IExpireTracker } from '../structures/expire';
-import type { ILazyPromise } from './types';
+import type { IExpireTracker } from '../structures/expire.js';
+import type { ILazyPromise } from './types.js';
 export declare class LazyPromise<T> implements ILazyPromise<T> {
     private readonly _factory;
     private readonly initial;

package/types/lazy/singleton.d.ts

@@ -1,5 +1,5 @@
-import type { IExpireTracker } from '../structures/expire';
-import type { ILazy } from './types';
+import type { IExpireTracker } from '../structures/expire.js';
+import type { ILazy } from './types.js';
 export declare class Lazy<T> implements ILazy<T> {
     protected readonly _factory: (() => T);
     protected _instance: T | undefined;

package/types/lazy/types.d.ts

@@ -1,5 +1,5 @@
-import { IDisposable } from '../functions/disposer';
-import { IResetableModel } from '../models/types';
+import { IDisposable } from '../functions/disposer.js';
+import { IResetableModel } from '../models/types.js';
 export type ILazy<T> = IDisposable & IResetableModel & {
     readonly value: T;
     readonly hasValue: boolean;

package/types/logger/batch.d.ts

@@ -1,2 +1,2 @@
-import { ILogger } from './abstractions';
+import { ILogger } from './abstractions.js';
 export declare function batchLoggers(...loggers: ILogger[]): ILogger;

package/types/logger/console.d.ts

@@ -1,5 +1,5 @@
-import { ILogger } from './abstractions';
-import { NamedLogger } from './named';
+import { ILogger } from './abstractions.js';
+import { NamedLogger } from './named.js';
 export declare const CONSOLE: ILogger;
 export declare class ConsoleLogger extends NamedLogger {
     protected get implementation(): ILogger;

package/types/logger/file.d.ts

@@ -1,4 +1,4 @@
-import { ILogger } from './abstractions';
+import { ILogger } from './abstractions.js';
 export declare class FileLoggerNode implements ILogger {
     readonly extraLogger: ILogger;
     readonly instantFlush: boolean;

package/types/logger/index.d.ts

@@ -1,9 +1,9 @@
-import { ILogger, LoggerFunction } from './abstractions';
-import { ConsoleLogger } from './console';
-import { batchLoggers } from './batch';
-import { LoggerModes } from './manager';
+import { ILogger, LoggerFunction } from './abstractions.js';
+import { ConsoleLogger } from './console.js';
+import { batchLoggers } from './batch.js';
+import { LoggerModes } from './manager.js';
 export type { ILogger, LoggerFunction };
-export { NamedLogger } from './named';
+export { NamedLogger } from './named.js';
 export { ConsoleLogger, batchLoggers };
 export declare function createLogger(name: string | undefined, mode?: undefined | LoggerModes): ILogger;
 export declare function detachLogger(instance: ILogger, terminate?: boolean): boolean;

package/types/logger/manager.d.ts

@@ -1,6 +1,6 @@
-import { Getter } from '../types/getter';
-import { ILogger } from './abstractions';
-import { ProxyLogger } from './proxy';
+import { Getter } from '../types/getter.js';
+import { ILogger } from './abstractions.js';
+import { ProxyLogger } from './proxy.js';
 export type LoggerTypes = 'console';
 export type LoggerModes = LoggerTypes | false | Getter<ILogger>;
 export declare class LoggersManager {

package/types/logger/named.d.ts

@@ -1,4 +1,4 @@
-import { ILogger, ILoggerSwitchable, LoggerFunction } from './abstractions';
+import { ILogger, ILoggerSwitchable, LoggerFunction } from './abstractions.js';
 export declare const EMPTY_FUNCTION: () => void;
 export declare abstract class NamedLogger implements ILogger, ILoggerSwitchable {
     log: LoggerFunction;

package/types/logger/proxy.d.ts

@@ -1,5 +1,5 @@
-import { ILogger } from './abstractions';
-import { NamedLogger } from './named';
+import { ILogger } from './abstractions.js';
+import { NamedLogger } from './named.js';
 export declare const EMPTY_LOGGER: ILogger;
 export declare class ProxyLogger extends NamedLogger {
     protected get implementation(): ILogger;

package/types/math/arrays.d.ts

@@ -1,4 +1,4 @@
-import { Comparator, Getter, Nullable, Predicate } from '../types';
+import { Comparator, Getter, Nullable, Predicate } from '../types/index.js';
 /** type-safe `Array.isArray` wrapper  */
 export declare function isArray<T>(value: any): value is T[];
 export declare function arrayCompareG<T>(arr: ReadonlyArray<T> | null | undefined, cond: (current: T, previous: T | null) => boolean): T | null;

package/types/math/index.d.ts

@@ -1,5 +1,5 @@
-export * from './calc';
-export * from './arrays';
-export * from './distribution';
+export * from './calc.js';
+export * from './arrays.js';
+export * from './distribution.js';
 export declare function getNumberSuffix(num: number): "st" | "nd" | "rd" | "th";
 export declare function format(n: number, digits?: number): string;

package/types/math/object/helpers.d.ts

@@ -1,5 +1,5 @@
-import { DeepReadonly, DeepReadonlyPartial } from '../../types/deep';
-import { BasePair, IObjectOps, NumKey } from './types';
+import { DeepReadonly, DeepReadonlyPartial } from '../../types/deep.js';
+import { BasePair, IObjectOps, NumKey } from './types.js';
 export declare function _getValue<T extends object, TKey extends NumKey<T> = NumKey<T>>(o: DeepReadonlyPartial<T>, key: TKey): T[TKey] | null;
 export declare function _getInnerValue<T extends object, TKey extends string & keyof T>(o: DeepReadonly<T>, key: TKey): DeepReadonly<T[TKey]>;
 export declare function _getInnerValue<T extends object, TKey extends string & keyof T>(o: DeepReadonly<T> | number, key: TKey): DeepReadonly<T[TKey]> | number;

package/types/math/object/index.d.ts

@@ -1,5 +1,5 @@
-export * from './types';
-export { ObjectOps } from './ops';
-export { ObjectMath } from './math';
-export { CompositeObjectOps } from './ops.composite';
-export { CompositeObjectMath } from './math.composite';
+export * from './types.js';
+export { ObjectOps } from './ops.js';
+export { ObjectMath } from './math.js';
+export { CompositeObjectOps } from './ops.composite.js';
+export { CompositeObjectMath } from './math.composite.js';

package/types/math/object/math.composite.d.ts

@@ -1,7 +1,7 @@
-import { AnyObject } from '../../types';
-import { DeepReadonly } from '../../types/deep';
-import { CompositeObjectOps } from './ops.composite';
-import { AbsOptions, IObjectMath, MathPairsMap, RoundOptions } from './types';
+import { AnyObject } from '../../types/index.js';
+import { DeepReadonly } from '../../types/deep.js';
+import { CompositeObjectOps } from './ops.composite.js';
+import { AbsOptions, IObjectMath, MathPairsMap, RoundOptions } from './types.js';
 export declare class CompositeObjectMath<T extends AnyObject> extends CompositeObjectOps<T> implements IObjectMath<T> {
     private readonly _math;
     constructor(innerMath: MathPairsMap<T>);

package/types/math/object/math.d.ts

@@ -1,6 +1,6 @@
-import { DeepReadonly, DeepReadonlyPartial } from '../../types/deep';
-import { ObjectOps } from './ops';
-import { AbsOptions, DELETE_TYPE, IObjectMath, NumKey, RoundOptions } from './types';
+import { DeepReadonly, DeepReadonlyPartial } from '../../types/deep.js';
+import { ObjectOps } from './ops.js';
+import { AbsOptions, DELETE_TYPE, IObjectMath, NumKey, RoundOptions } from './types.js';
 export declare class ObjectMath<T extends object> extends ObjectOps<T> implements IObjectMath<T> {
     getTotal(o: DeepReadonlyPartial<T>): number;
     contains(base: DeepReadonly<T>, target: DeepReadonly<T>): boolean;

package/types/math/object/ops.composite.d.ts

@@ -1,6 +1,6 @@
-import { AnyObject } from '../../types';
-import { DeepReadonly } from '../../types/deep';
-import { IObjectOps, OpsPairsMap } from './types';
+import { AnyObject } from '../../types/index.js';
+import { DeepReadonly } from '../../types/deep.js';
+import { IObjectOps, OpsPairsMap } from './types.js';
 export declare class CompositeObjectOps<T extends AnyObject> implements IObjectOps<T> {
     readonly Empty: Readonly<T>;
     private readonly _ops;

package/types/math/object/ops.d.ts

@@ -1,6 +1,6 @@
-import { SkipCondition, SkipOptions } from '../../fields/skip';
-import { AnyObject, DeepPartial, DeepReadonly, Predicate } from '../../types';
-import { IObjectOps, NumKey } from './types';
+import { SkipCondition, SkipOptions } from '../../fields/skip.js';
+import { AnyObject, DeepPartial, DeepReadonly, Predicate } from '../../types/index.js';
+import { IObjectOps, NumKey } from './types.js';
 type Keys<T extends AnyObject> = NumKey<T>[];
 export declare class ObjectOps<T extends AnyObject> implements IObjectOps<T> {
     readonly keys: Keys<T>;

package/types/math/object/types.d.ts

@@ -1,4 +1,4 @@
-import { AnyObject, DeepReadonly, TypedKeys } from '../../types';
+import { AnyObject, DeepReadonly, TypedKeys } from '../../types/index.js';
 export type NumKey<T extends AnyObject> = TypedKeys<T, number>;
 export type AbsOptions = false | 'remove' | 'zero';
 export type RoundOptions = 'floor' | 'ceil' | 'round';

package/types/models/Loading.d.ts

@@ -1,9 +1,9 @@
-import type { IResetableModel, IValueModel } from './types';
+import type { IResetableModel, IValueModel } from './types.js';
 export type LoadingWorker<T> = () => (T | Promise<T>);
 export type LoadingResult<T = unknown> = {
-    exclusivenessFailed: true;
+    aborted: true;
 } | {
-    exclusivenessFailed: false;
+    aborted: false;
     result: T;
 };
 export declare function withLoading<T>(this: void, model: IValueModel<boolean>, cb: LoadingWorker<T>, exclusive?: boolean | 'throw'): Promise<LoadingResult<T>>;
@@ -29,3 +29,7 @@ export declare class LoadingModel implements IValueModel<boolean>, IResetableMod
      * Called in the ctor. Should be pure and should NOT access `this`. */
     protected pureConstructNumberModel(): IValueModel<number> & IResetableModel;
 }
+export declare class ExclusiveLoadingError extends Error {
+    readonly actionName?: string | undefined;
+    constructor(message?: string, actionName?: string | undefined);
+}

package/types/models/LogicModel.d.ts

@@ -1,8 +1,8 @@
-import { LoadingModel } from './Loading';
-import { Getter } from '../types';
-import { PromiseExtended } from '../structures/promiseExtended';
-import { ILogger } from '../logger';
-type RunOptions = {
+import { ExclusiveLoadingError, LoadingModel } from './Loading.js';
+import { Getter } from '../types/index.js';
+import { PromiseExtended } from '../structures/promiseExtended.js';
+import { ILogger } from '../logger/index.js';
+export type ActionRunOptions = {
     /** Action name, required for logging and joining. */
     name?: string;
     /** If set to truthy, will not start an action if another is still in progress.
@@ -29,6 +29,19 @@ export declare class LogicModel {
     private readonly _runningActionNames;
     constructor(name?: string, useFirstInit?: boolean);
     protected pureConstructLoadingModel(useFirstInit: boolean): LoadingModel;
-    protected runAction<T = unknown>(worker: () => Promise<T>, options?: RunOptions, errorCtx?: Getter<unknown>): PromiseExtended<T | undefined>;
+    protected runAction<T = unknown>(worker: () => Promise<T>, options?: ActionRunOptions, errorCtx?: Getter<unknown>): ActionResult<T>;
+}
+export type ActionResult<T, TCustomErrors extends Record<string, unknown> = Record<never, unknown>> = ReturnType<typeof ActionResult.expectExclusive<T | undefined, TCustomErrors>>;
+export declare namespace ActionResult {
+    type Expect = {
+        exclusive: ExclusiveLoadingError;
+    };
+    namespace Expect {
+        const Config: {
+            readonly name: "exclusive";
+            readonly ErrCtor: typeof ExclusiveLoadingError;
+        };
+    }
+    const expectExclusive: <T, TPrevErrors extends Record<string, unknown>>(promise: PromiseExtended<T, TPrevErrors>, processor?: ((error: ExclusiveLoadingError) => void | Partial<TPrevErrors & Record<"exclusive", ExclusiveLoadingError>>) | undefined) => PromiseExtended<T, TPrevErrors & Record<"exclusive", ExclusiveLoadingError>>;
+    function createSucceeded<T>(data: T): ActionResult<T>;
 }
-export {};

package/types/models/Model.d.ts

@@ -1,6 +1,6 @@
-import type { IResetableModel, IValueModel } from './types';
-import { Getter } from '../types/getter';
-import { Nullable } from '../types/misc';
+import type { IResetableModel, IValueModel } from './types.js';
+import { Getter } from '../types/getter.js';
+import { Nullable } from '../types/misc.js';
 export declare class Model<T> implements IValueModel<Nullable<T>>, IResetableModel {
     private _value;
     private readonly _defaultValue;

package/types/models/ValuesCollector.d.ts

@@ -1,4 +1,4 @@
-import type { IValueModel } from './types';
+import type { IValueModel } from './types.js';
 export interface IValueCollector<TSource, TValue> {
     getValue(source: TSource): TValue;
     setValue(source: TSource, value: TValue): void;

package/types/models/wrappers.d.ts

@@ -1,5 +1,5 @@
-import { Getter } from '../types/getter';
-import type { ILabel, IValueModel } from './types';
+import { Getter } from '../types/getter.js';
+import type { ILabel, IValueModel } from './types.js';
 export declare function withLabel<T, TModel extends IValueModel<T>, TLabel = string>(model: TModel, label: Getter<TLabel>): TModel & ILabel<TLabel>;
 export declare function inject<T, TModel extends IValueModel<T>>(model: TModel, source: IValueModel<T>): TModel;
 /**

package/types/observing/event.d.ts

@@ -1,5 +1,5 @@
-import type { Predicate } from '../types';
-import { ILogger } from '../logger';
+import type { Predicate } from '../types/index.js';
+import { ILogger } from '../logger/index.js';
 export type EventHandler<T = any> = (data?: T) => void | Promise<void>;
 type Unsubscribe = () => void;
 export interface IEvent<T = any> {

package/types/observing/event.late.d.ts

@@ -1,4 +1,4 @@
-import { Event, EventHandler } from './event';
+import { Event, EventHandler } from './event.js';
 export declare class OneTimeLateEvent<T = any> extends Event<T> {
     private _triggeredWith;
     private _triggered;

package/types/observing/progressTracker.d.ts

@@ -1,4 +1,4 @@
-import { ILogger } from '../logger';
+import { ILogger } from '../logger/index.js';
 export declare class ProgressTracker {
     readonly log: boolean | ILogger;
     private readonly _firstTimestamp;
@@ -10,7 +10,7 @@ export declare class ProgressTracker {
     private readonly _deltas;
     private readonly _changed;
     constructor(log?: boolean | ILogger);
-    get changed(): import("./event").IEvent<{
+    get changed(): import("./event.js").IEvent<{
         completed: number;
         total: number;
         currentProgress: number;

package/types/observing/throttledEvent.d.ts

@@ -1,4 +1,4 @@
-import { Event } from './event';
+import { Event } from './event.js';
 export declare class ThrottledEvent extends Event {
     private readonly _throttle;
     setTimeout(timeout: number): this;

package/types/observing/timer.d.ts

@@ -1,5 +1,5 @@
-import { IDisposable } from '../functions/disposer';
-import { EventHandler, IEvent } from './event';
+import { IDisposable } from '../functions/disposer.js';
+import { EventHandler, IEvent } from './event.js';
 export type TimerState = {
     timer: Timer;
     elapsed: number;

package/types/storage/index.d.ts

@@ -1,2 +1,2 @@
-export * from './types';
-export * from './wrappers';
+export * from './types.js';
+export * from './wrappers.js';

package/types/storage/types.d.ts

@@ -1,4 +1,4 @@
-import type { RemoveFirstParameter, Awaitify } from '../types/functions';
+import type { RemoveFirstParameter, Awaitify } from '../types/functions.js';
 export interface IStorage<T = string> {
     getValue(key: string): Promise<T | null>;
     setValue(key: string, value: T): Promise<void>;

package/types/storage/wrappers.d.ts

@@ -1,4 +1,4 @@
-import type { IKeyedStorage, IKeyedStorageSync, IStorage, IStorageSync } from './types';
+import type { IKeyedStorage, IKeyedStorageSync, IStorage, IStorageSync } from './types.js';
 export declare namespace Storages {
     function toAsync<T = string>(storage: IStorageSync<T>): IStorage<T>;
     function toKeyed<T = string>(storage: IStorage<T>, storageKey: string): IKeyedStorage<T>;

package/types/structures/path/builder.d.ts

@@ -1,5 +1,5 @@
-import { BaseInput, CombineBuilders, StaticBuilder, SwitchBuilder } from './types';
-export * from './types';
+import { BaseInput, CombineBuilders, StaticBuilder, SwitchBuilder } from './types.js';
+export * from './types.js';
 /** Tagged template literal to create a path builder */
 export declare function build<TArgs extends string[]>(strings: TemplateStringsArray, ...params: TArgs): SwitchBuilder<TArgs>;
 export declare const Empty: StaticBuilder;

package/types/structures/path/index.d.ts

@@ -1,2 +1,2 @@
-export * from './utils';
-export * as Path from './builder';
+export * from './utils.js';
+export * as Path from './builder.js';

package/types/structures/path/types.d.ts

@@ -1,5 +1,5 @@
-import type { LengthArray, Nullable } from '../../types/misc';
-import type { CombineOptions } from './utils';
+import type { LengthArray, Nullable } from '../../types/misc.js';
+import type { CombineOptions } from './utils.js';
 export type ArgValue = string | number;
 export type ObjectBuilderArgs<TArgs extends string> = Record<TArgs, ArgValue>;
 export type BuilderArgs<TArgs extends string, L extends number = number> = LengthArray<ArgValue, L> | Record<TArgs, ArgValue>;

package/types/structures/path/utils.d.ts

@@ -1,4 +1,4 @@
-import { Nullable } from '../../types/misc';
+import { Nullable } from '../../types/misc.js';
 export declare function indexTrim(str: string | null | undefined, ch: string): string;
 export type CombineOptions = {
     noTrim?: boolean;

package/types/structures/pool.d.ts

@@ -1,4 +1,4 @@
-import type { IDisposable } from '../functions/disposer';
+import type { IDisposable } from '../functions/disposer.js';
 export declare class Pool<T> {
     readonly factory: () => T;
     private readonly _container;

package/types/structures/promiseCache.d.ts

@@ -1,4 +1,4 @@
-import { ILogger } from '../logger';
+import { ILogger } from '../logger/index.js';
 export type DeferredGetter<T> = {
     readonly current: T | null | undefined;
     readonly promise: Promise<T | null>;

package/types/structures/promiseExtended.d.ts

@@ -1,4 +1,4 @@
-import type { Nullable } from '../types/misc';
+import type { Nullable } from '../types/misc.js';
 /**
  * The idea here is to wrap a promise (or promise getter) so it will never throw natively, but still be able to provide success/fail results:
  * - `onSuccess` for handling successful result: like `then` but to be called only if there was no error
@@ -47,6 +47,7 @@ export declare class PromiseExtended<T, TCustomErrors extends Record<string, unk
     static errored<T, TErrors extends Record<string, unknown>>(source: Error | Error[] | string): PromiseExtended<T, TErrors>;
     onError(cb: Nullable<(data: PromiseExtended.ErrorData & TCustomErrors) => void>): this;
     onSuccess(cb: Nullable<(data: T) => void>): this;
+    expectError<TName extends string, TError2 extends Error>(config: PromiseExtended.ErrorConfig<TName, TError2, TCustomErrors>): PromiseExtended<T, TCustomErrors & Record<TName, TError2>>;
     expectError<TName extends string, TError2 extends Error>(name: TName, ErrCtor: new (...args: any[]) => TError2, processor?: (value: TError2) => void | Partial<TCustomErrors & Record<TName, TError2>>): PromiseExtended<T, TCustomErrors & Record<TName, TError2>>;
     then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | null, onrejected?: ((reason: unknown) => TResult2 | PromiseLike<TResult2>) | null): PromiseExtended<TResult1 | TResult2, TCustomErrors>;
     catch<TResult = never>(onrejected?: ((reason: unknown) => TResult | PromiseLike<TResult>) | null): PromiseExtended<T | TResult, TCustomErrors>;
@@ -67,4 +68,12 @@ export declare namespace PromiseExtended {
         error: string;
         source: Error;
     };
+    type ErrorConfig<TName extends string, TError2 extends Error, TPrevErrors> = {
+        name: TName;
+        ErrCtor: new (...args: any[]) => TError2;
+        processor?: (value: TError2) => void | Partial<TPrevErrors & Record<TName, TError2>>;
+    };
+    namespace ErrorConfig {
+        function createExpecter<TName extends string, TError2 extends Error>(config: Omit<ErrorConfig<TName, TError2, unknown>, 'processor'>): <T, TPrevErrors extends Record<string, unknown>>(promise: PromiseExtended<T, TPrevErrors>, processor?: (error: TError2) => void | Partial<TPrevErrors & Record<TName, TError2>>) => PromiseExtended<T, TPrevErrors & Record<TName, TError2>>;
+    }
 }

package/types/structures/promiseProxy.d.ts

@@ -1,5 +1,5 @@
-import { LazyPromise } from '../lazy/promise';
-import { AnyObject, FunctionKeys, StringKeys } from '../types';
+import { LazyPromise } from '../lazy/promise.js';
+import { AnyObject, FunctionKeys, StringKeys } from '../types/index.js';
 declare const PromiseGetter = "__promise";
 type AllowedFnKeys<T extends AnyObject> = FunctionKeys<T, any[], void>;
 type PromiseProxy<T extends AnyObject, TKeys extends StringKeys<T> = StringKeys<T>, TFnKeys = never, TWrap extends object = object> = {

package/types/structures/queue/parallel.d.ts

@@ -10,9 +10,9 @@ export declare class ParallelQueue {
     private readonly _finished;
     get currentPriority(): number;
     get inProgress(): boolean;
-    get beforePriorityRun(): import("../../observing/event").IEvent<number>;
-    get afterPriorityRun(): import("../../observing/event").IEvent<number>;
-    get finished(): import("../../observing/event").IEvent<any>;
+    get beforePriorityRun(): import("../../observing/event.js").IEvent<number>;
+    get afterPriorityRun(): import("../../observing/event.js").IEvent<number>;
+    get finished(): import("../../observing/event.js").IEvent<any>;
     withLogger(name?: string): this;
     /** @returns A callback that will try to cancel queued item */
     enqueue(cb: QueueItem, priority?: number): () => void;

package/types/structures/queue/tasks.d.ts

@@ -1,4 +1,4 @@
-import type { ILogger } from '../../logger';
+import type { ILogger } from '../../logger/index.js';
 type Factory<T> = () => Promise<T>;
 export declare class TasksQueue<T> {
     readonly limit: number;

package/types/structures/subscribersMap.d.ts

@@ -1,4 +1,4 @@
-import { IDisposable } from '../functions/disposer';
+import { IDisposable } from '../functions/disposer.js';
 type Unsub = () => void;
 export declare class SubscribersMap implements IDisposable {
     readonly subscribe: null | ((key: string) => Promise<Unsub[]>);

package/types/structures/tempoCache.d.ts

@@ -1,5 +1,5 @@
-import type { ILazy, ILazyPromise } from '../lazy/types';
-import { ExpireTracker } from './expire';
+import type { ILazy, ILazyPromise } from '../lazy/types.js';
+import { ExpireTracker } from './expire.js';
 /**
  * Calls factory fn to fetch and store some value for a limited time.
  *

package/types/types/deep.d.ts

@@ -1,4 +1,4 @@
-import { AnyFunction } from './misc';
+import { AnyFunction } from './misc.js';
 export type DeepReadonly<T> = T extends Array<infer U> ? ReadonlyArray<DeepReadonly<U>> : (T extends AnyFunction ? T : (T extends object ? {
     readonly [P in keyof T]: DeepReadonly<T[P]>;
 } : T));

package/types/types/functions.d.ts

@@ -1,4 +1,4 @@
-import { AnyFunction } from './misc';
+import { AnyFunction } from './misc.js';
 export type TypedFn<A extends unknown[], R> = (...args: A) => R;
 export type Asyncify<T> = {
     [P in keyof T]: T[P] extends TypedFn<unknown[], Promise<unknown>> ? T[P] : (T[P] extends TypedFn<infer A, infer R> ? (...args: A) => Promise<R> : T[P]);