@tstdl/base 0.92.124 → 0.92.125

package/types/browser/page-controller.d.ts

@@ -1,40 +0,0 @@
-import type { Page } from 'playwright';
-import type { AsyncDisposable } from '../../disposable/disposable.js';
-import { disposeAsync } from '../../disposable/disposable.js';
-import type { Logger } from '../../logger/logger.js';
-import type { BrowserContextController } from './browser-context-controller.js';
-import type { DocumentControllerOptions } from './document-controller.js';
-import { DocumentController } from './document-controller.js';
-import { ElementController } from './element-controller.js';
-import type { FrameController, FrameControllerOptions } from './frame-controller.js';
-import type { PdfRenderOptions } from './pdf-options.js';
-import type { Abortable } from './types.js';
-export type PageControllerOptions = DocumentControllerOptions;
-export type ScrollToCoordinates = {
-    x?: number;
-    y?: number;
-};
-export declare class PageController extends DocumentController<Page> implements AsyncDisposable {
-    /** @deprecated should be avoided */
-    readonly page: Page;
-    readonly options: PageControllerOptions;
-    constructor(page: Page, context: BrowserContextController, options?: PageControllerOptions);
-    [disposeAsync](): Promise<void>;
-    close(): Promise<void>;
-    /** finds pages opened by this page (having opener set to this page) */
-    opened(): Promise<PageController[]>;
-    opener(): Promise<PageController | null>;
-    setExtraHttpHeaders(headers: Record<string, string>): Promise<void>;
-    waitForClose(): Promise<void>;
-    url(): string;
-    /**
-     * @param frameSelector frame name, url or url predicate
-     * @returns
-     */
-    frame(frameSelector: Parameters<Page['frame']>[0], options?: FrameControllerOptions): FrameController;
-    renderPdf(options?: PdfRenderOptions & Abortable): Promise<Uint8Array>;
-    scroll(deltaX: number, deltaY: number): Promise<void>;
-    scrollTo(coordinatesOrController: ScrollToCoordinates | ElementController): Promise<void>;
-    renderPdfStream(options?: PdfRenderOptions & Abortable): ReadableStream<Uint8Array>;
-    attachLogger(logger: Logger): void;
-}

package/types/browser/types.d.ts

@@ -1,15 +0,0 @@
-import type { ValueOrProvider } from '../../utils/value-or-provider.js';
-export type TimeoutOptions = {
-    timeout?: number;
-};
-export type LoadState = 'load' | 'domcontentloaded' | 'networkidle';
-export type WaitForStateOptions = {
-    waitUntil: LoadState;
-};
-export type Abortable = {
-    abort?: AbortSignal;
-};
-export type Delay = ValueOrProvider<number>;
-export type ActionDelayOptions = {
-    actionDelay?: Delay;
-};

package/types/browser/utils.d.ts

@@ -1,17 +0,0 @@
-import type { Logger } from '../../logger/logger.js';
-import type { BrowserContext, ElementHandle, Frame, LaunchOptions, Locator, Page } from 'playwright';
-import type { NewBrowserContextOptions } from './browser-controller.js';
-import type { NewBrowserOptions } from './browser.service.js';
-import type { ActionDelayOptions, Delay, TimeoutOptions } from './types.js';
-export declare function getLaunchOptions(options: NewBrowserOptions): LaunchOptions;
-export declare function mergeNewBrowserContextOptions(a: NewBrowserContextOptions | undefined, b?: NewBrowserContextOptions, c?: NewBrowserContextOptions): NewBrowserContextOptions;
-export declare function attachLogger(loggable: Page | BrowserContext, logger: Logger): void;
-export declare function isLocator(locatorOrHandle: Locator | ElementHandle): locatorOrHandle is Locator;
-export declare function assertLocator(locatorOrHandle: Locator | ElementHandle, message?: string): asserts locatorOrHandle is Locator;
-export declare function assertLocatorPass(locatorOrHandle: Locator | ElementHandle, message?: string): Locator;
-export declare function isElementHandle(locatorOrHandle: Locator | ElementHandle): locatorOrHandle is ElementHandle;
-export declare function isPage(pageOrFrameOrContext: Page | Frame | BrowserContext): pageOrFrameOrContext is Page;
-export declare function isFrame(pageOrFrameOrContext: Page | Frame | BrowserContext): pageOrFrameOrContext is Frame;
-export declare function isBrowserContext(pageOrFrameOrContext: Page | Frame | BrowserContext): pageOrFrameOrContext is BrowserContext;
-export declare function prepareAction(options?: ActionDelayOptions & TimeoutOptions): Promise<void>;
-export declare function delay(milliseconds: Delay | undefined): Promise<void>;

package/types/collections/observable/observable-sorted-array-list.d.ts

@@ -1,36 +0,0 @@
-import type { Comparator } from '../../../utils/sort.js';
-import type { ObservableSortedList } from './observable-list.js';
-import { ObservableListBase } from './observable-list-base.js';
-export declare class ObservableSortedArrayList<T extends TComparator, TComparator = T> extends ObservableListBase<T, ObservableSortedArrayList<T>> implements ObservableSortedList<T, TComparator> {
-    private readonly comparator;
-    backingArray: T[];
-    get self(): this;
-    get length(): number;
-    constructor(comparator?: Comparator<TComparator>);
-    get(index: number): T;
-    getFirst(): T;
-    getLast(): T;
-    getByComparison(value: TComparator): T | undefined;
-    getRangeByComparison(from: TComparator, to: TComparator): T[];
-    set(_index: number, _value: T): void;
-    addAt(_index: number, ..._values: T[]): void;
-    removeAt(index: number): T;
-    removeRange(index: number, count: number): T[];
-    clear(): void;
-    add(value: T): void;
-    addMany(values: T[]): void;
-    has(value: T): boolean;
-    hasByComparison(value: TComparator): boolean;
-    remove(value: T): boolean;
-    removeMany(values: T[]): number;
-    removeRangeByComparison(from: TComparator, to: TComparator): T[];
-    indexOf(value: T): number | undefined;
-    lastIndexOf(value: T): number | undefined;
-    indexOfByComparison(value: TComparator): number | undefined;
-    firstIndexOfByComparison(value: TComparator): number | undefined;
-    lastIndexOfByComparison(value: TComparator): number | undefined;
-    findFirstIndexEqualOrLargerThan(value: TComparator): number | undefined;
-    findLastIndexEqualOrSmallerThan(value: TComparator): number | undefined;
-    [Symbol.iterator](): IterableIterator<T>;
-    private verifyIndexIsInBounds;
-}

package/types/collections/sorted-array-list.d.ts

@@ -1,37 +0,0 @@
-import type { Comparator } from '../../utils/sort.js';
-import type { SortedList } from './sorted-list.js';
-export declare class SortedArrayList<T extends TComparator, TComparator = T> implements SortedList<T> {
-    private readonly comparator;
-    backingArray: T[];
-    get length(): number;
-    constructor(comparator?: Comparator<TComparator>);
-    static from<T extends TComparator, TComparator = T>(iterable: Iterable<T>, comparator?: Comparator<TComparator>): SortedArrayList<T, TComparator>;
-    [Symbol.iterator](): IterableIterator<T>;
-    clear(): void;
-    get(index: number): T;
-    getFirst(): T;
-    getLast(): T;
-    getByComparison(value: TComparator): T | undefined;
-    getRangeByComparison(from: TComparator, to: TComparator): T[];
-    set(_index: number, _value: T): void;
-    add(value: T): void;
-    addMany(values: T[]): void;
-    addAt(_index: number, ..._values: T[]): void;
-    removeFirst(): T;
-    removeLast(): T;
-    has(value: T): boolean;
-    hasByComparison(value: TComparator): boolean;
-    remove(value: T): boolean;
-    removeMany(values: T[]): number;
-    removeAt(index: number): T;
-    removeRange(index: number, count: number): T[];
-    removeRangeByComparison(from: TComparator, to: TComparator): T[];
-    indexOf(value: T): number | undefined;
-    lastIndexOf(value: T): number | undefined;
-    indexOfByComparison(value: TComparator): number | undefined;
-    firstIndexOfByComparison(value: TComparator): number | undefined;
-    lastIndexOfByComparison(value: TComparator): number | undefined;
-    findFirstIndexEqualOrLargerThan(value: TComparator): number | undefined;
-    findLastIndexEqualOrSmallerThan(value: TComparator): number | undefined;
-    private verifyIndexIsInBounds;
-}

package/types/context/context.d.ts

@@ -1,10 +0,0 @@
-import type { Function, SimplifyObject } from '../../types.js';
-/**
- * Creates a new context provider
- * @param name name of of the context used for function names
- */
-export declare function createContextProvider<Context, const Name extends string>(name: Name): SimplifyObject<Record<`getCurrent${Name}Context`, {
-    (required: true, debugFn: Function): Context;
-    (required?: false, debugFn?: Function): Context | null;
-    (required: boolean, debugFn: Function): Context | null;
-}> & Record<`setCurrent${Name}Context`, (context: Context | null) => Context | null> & Record<`runIn${Name}Context`, <ReturnT>(context: Context, fn: () => ReturnT) => ReturnT> & Record<`isIn${Name}Context`, () => boolean> & Record<`assertIn${Name}Context`, (debugFnOrMessage: Function | string) => void>>;

package/types/data-structures/array-list.d.ts

@@ -1,30 +0,0 @@
-import type { Predicate } from '../../utils/iterable-helpers/types.js';
-import { List } from './list.js';
-export declare class ArrayList<T> extends List<T, ArrayList<T>> {
-    private backingArray;
-    constructor(items?: Iterable<T>);
-    /**
-     * creates a new {@link ArrayList} from existing array without copying data
-     * @param array array to use as new backing array for this {@link ArrayList}
-     */
-    static fromArray<T>(array: T[]): ArrayList<T>;
-    protected _at(index: number): T;
-    protected _indexOf(item: T, fromIndex?: number): number | undefined;
-    findIndex(predicate: Predicate<T>): number | undefined;
-    protected _lastIndexOf(item: T, fromIndex?: number): number | undefined;
-    findLastIndex(predicate: Predicate<T>): number | undefined;
-    includes(item: T): boolean;
-    prepend(item: T): void;
-    prependMany(items: Iterable<T>): void;
-    add(item: T): void;
-    addMany(items: Iterable<T>): void;
-    protected _set(index: number, item: T): void;
-    remove(item: T): boolean;
-    protected _removeAt(index: number): T;
-    protected _removeManyAt(index: number, count: number): T[];
-    clone(): ArrayList<T>;
-    items(): IterableIterator<T>;
-    itemsReverse(): IterableIterator<T>;
-    protected _clear(): void;
-    private updateSize;
-}

package/types/data-structures/circular-buffer.d.ts

@@ -1,56 +0,0 @@
-import { type Observable } from 'rxjs';
-import { type CancellationSignal } from '../../cancellation/token.js';
-import { Collection } from './collection.js';
-export declare class CircularBuffer<T> extends Collection<T, IterableIterator<T>, CircularBuffer<T>> {
-    private readonly maxBufferSizeSubject;
-    private readonly overflowSubject;
-    private backingArray;
-    private writeIndex;
-    private readIndex;
-    /** Emits overwritten items */
-    readonly overflow$: Observable<T>;
-    /** Emits count of free slots in the buffer */
-    readonly freeSlots$: Observable<number>;
-    /** Emits when the buffer is full */
-    readonly onFull$: Observable<void>;
-    /** Emits when the buffer has free slots */
-    readonly onFreeSlots$: Observable<void>;
-    /** Emits whether the buffer is full */
-    readonly isFull$: Observable<boolean>;
-    /** Emits whether the buffer has free slots */
-    readonly hasFreeSlots$: Observable<boolean>;
-    /** Resolves when the buffer is full */
-    get $onFull(): Promise<void>;
-    /** Resolves when the buffer has items */
-    get $onFreeSlots(): Promise<void>;
-    /** Size of buffer */
-    get bufferSize(): number;
-    /** Size of buffer */
-    get maxBufferSize(): number;
-    /** Count of free slots in buffer */
-    get freeSlots(): number;
-    /** Whether the buffer is full */
-    get isFull(): boolean;
-    /** Whether the buffer has free slots */
-    get hasFreeSlots(): boolean;
-    constructor(maxBufferSize?: number);
-    includes(item: T): boolean;
-    add(item: T): void;
-    addMany(items: Iterable<T>): void;
-    remove(): T;
-    tryRemove(): T | undefined;
-    clone(newMaxBufferSize?: number | undefined): CircularBuffer<T>;
-    items(): IterableIterator<T>;
-    /** Yields all items from the buffer and removes them */
-    consume(): IterableIterator<T>;
-    /**
-     * Yields all items from the buffer, removes them and waits fore more
-     * @param cancellationSignal token to cancel iteration
-     * @param yieldOutstandingItems whether to yield all outstanding items or exit immdiately when {@link cancellationSignal} is set
-     * @returns
-     */
-    consumeAsync(cancellationSignal?: CancellationSignal, yieldOutstandingItems?: boolean): AsyncIterable<T>;
-    protected _clear(): void;
-    private increaseBufferSizeIfNeeded;
-    private resize;
-}

package/types/data-structures/collection.d.ts

@@ -1,65 +0,0 @@
-import { type Observable } from 'rxjs';
-import type { ToJson } from '../../interfaces.js';
-import { type Signal } from '../../signals/index.js';
-export declare abstract class Collection<T, TItemsIterator extends IterableIterator<any>, TThis extends Collection<T, TItemsIterator, TThis> = Collection<T, TItemsIterator, any>> implements Iterable<T>, ToJson {
-    private readonly sizeSubject;
-    private readonly changeSubject;
-    private readonly clearSubject;
-    /** Emits size of collection */
-    readonly size$: Observable<number>;
-    /** Size of collection */
-    readonly $size: Signal<number>;
-    /** Emits collection on change */
-    readonly change$: Observable<TThis>;
-    /** Emits collection on subscribe and change */
-    readonly observe$: Observable<TThis>;
-    /** Notifies on change */
-    readonly $observe: Signal<TThis>;
-    readonly clear$: Observable<TThis>;
-    /** Emits whether the collection is empty */
-    readonly isEmpty$: Observable<boolean>;
-    /** Whether the collection is empty */
-    readonly $isEmpty: Signal<boolean>;
-    /** Emits whether the collection has items */
-    readonly hasItems$: Observable<boolean>;
-    /** Whether the collection has items */
-    readonly $hasItems: Signal<boolean>;
-    /** Emits when the collection is empty */
-    readonly onEmpty$: Observable<undefined>;
-    /** Emits when the collection has items */
-    readonly onItems$: Observable<undefined>;
-    /** Resolves when the collection is empty */
-    get $onEmpty(): Promise<void>;
-    /** Resolves when the collection has items */
-    get $onItems(): Promise<void>;
-    /** Size of collection */
-    get size(): number;
-    /** Whether the collection is empty */
-    get isEmpty(): boolean;
-    /** Whether the collection has items */
-    get hasItems(): boolean;
-    constructor();
-    [Symbol.iterator](): TItemsIterator;
-    toArray(): T[];
-    toJSON(): T[];
-    /** Remove all items */
-    clear(): void;
-    /** Sets collection size */
-    protected setSize(size: number): void;
-    /** Increment collection size by amount (default 1) */
-    protected incrementSize(amount?: number): void;
-    /** Decrement collection size by amount (default 1) */
-    protected decrementSize(amount?: number): void;
-    protected emitChange(): void;
-    abstract includes(item: T): boolean;
-    /** Add item to collection */
-    abstract add(item: T): void;
-    /** Add many items to collection */
-    abstract addMany(items: Iterable<T>): void;
-    /** Clone collection */
-    abstract clone(): TThis;
-    /** Yields all items from the collection */
-    abstract items(): TItemsIterator;
-    /** Clear all data - size is set to 0 automatically */
-    protected abstract _clear(): void;
-}

package/types/data-structures/context-data-map.d.ts

@@ -1,11 +0,0 @@
-import type { Record } from '../../types.js';
-export declare class ContextDataMap {
-    private readonly data;
-    constructor();
-    has(key: PropertyKey): boolean;
-    tryGet<T>(key: PropertyKey): T | undefined;
-    tryGet<T, D>(key: PropertyKey, defaultValue: D): T | D;
-    get<T>(key: PropertyKey): T;
-    set(key: PropertyKey, value: any, mergeValue?: boolean): void;
-    setMany(data: Record | readonly [PropertyKey, any][], mergeValues?: boolean): void;
-}

package/types/data-structures/index-out-of-bounds.error.d.ts

@@ -1,8 +0,0 @@
-import { CustomError } from '../../errors/custom.error.js';
-export declare class IndexOutOfBoundsError extends CustomError {
-    constructor({ index, count, size }: {
-        index: number;
-        count?: number;
-        size?: number;
-    });
-}

package/types/data-structures/linked-list.d.ts

@@ -1,57 +0,0 @@
-import type { TryDereference } from '../../serializer/serializable.js';
-import { Serializable } from '../../serializer/serializable.js';
-import type { Predicate } from '../../utils/iterable-helpers/types.js';
-import { List } from './list.js';
-export type LinkedListNode<T> = {
-    /** item of node */
-    item: T;
-    /** previous node. Warning: it is not safe to use this reference on a removed node */
-    previous: LinkedListNode<T> | undefined;
-    /** next node. Warning: it is not safe to use this reference on a removed node */
-    next: LinkedListNode<T> | undefined;
-};
-export declare class LinkedList<T> extends List<T, LinkedList<T>> implements Serializable<LinkedList<T>, T[]> {
-    private head;
-    private tail;
-    get firstNode(): LinkedListNode<T> | undefined;
-    get lastNode(): LinkedListNode<T> | undefined;
-    constructor(items?: Iterable<T>);
-    [Serializable.serialize](instance: LinkedList<T>): T[];
-    [Serializable.deserialize](data: T[], tryDereference: TryDereference): LinkedList<T>;
-    protected _at(index: number): T;
-    /** get node at index */
-    nodeAt(index: number): LinkedListNode<T>;
-    protected _indexOf(item: T, fromIndex?: number): number | undefined;
-    nodeOf(item: T): LinkedListNode<T> | undefined;
-    findIndex(predicate: Predicate<T>): number | undefined;
-    protected _lastIndexOf(item: T, fromIndex?: number): number | undefined;
-    findLastIndex(predicate: Predicate<T>): number | undefined;
-    lastNodeOf(item: T): LinkedListNode<T> | undefined;
-    protected _set(index: number, item: T): void;
-    includes(item: T): boolean;
-    add(item: T): LinkedListNode<T>;
-    prepend(item: T): LinkedListNode<T>;
-    /** add item after node */
-    addAfterNode(node: LinkedListNode<T>, item: T): LinkedListNode<T>;
-    /** add item before node */
-    addBeforeNode(node: LinkedListNode<T>, item: T): LinkedListNode<T>;
-    addMany(items: Iterable<T>): void;
-    /** add many items at the start */
-    prependMany(items: Iterable<T>): void;
-    remove(item: T): boolean;
-    protected _removeAt(index: number): T;
-    protected _removeManyAt(index: number, count?: number): T[];
-    /** remove node at index */
-    removeNodeAt(index: number): LinkedListNode<T>;
-    /** remove node */
-    removeNode(node: LinkedListNode<T>): void;
-    removeManyNodesAt(index: number, count?: number): LinkedListNode<T>[];
-    clone(): LinkedList<T>;
-    items(): IterableIterator<T>;
-    itemsReverse(): IterableIterator<T>;
-    /** yields all nodes from the list */
-    nodes(): IterableIterator<LinkedListNode<T>>;
-    /** yields all nodes from the list in reverse */
-    nodesReverse(): IterableIterator<LinkedListNode<T>>;
-    protected _clear(): void;
-}

package/types/data-structures/list.d.ts

@@ -1,78 +0,0 @@
-import type { Predicate } from '../../utils/iterable-helpers/types.js';
-import { Collection } from './collection.js';
-export declare abstract class List<T, TThis extends Collection<T, IterableIterator<T>, TThis>> extends Collection<T, IterableIterator<T>, TThis> {
-    /** Get item at index */
-    at(index: number): T;
-    /**
-     * Find index of first occurrence of item
-     * @param item item to search for
-     * @param fromIndex index to start search at
-     */
-    indexOf(item: T, fromIndex?: number): number | undefined;
-    /** Index of item (last occurrence) */
-    /**
-     * Find index of last occurrence of item
-     * @param item item to search for
-     * @param fromIndex index to start from (backwards)
-     */
-    lastIndexOf(item: T, fromIndex?: number): number | undefined;
-    /** Set item at index */
-    set(index: number, item: T): void;
-    /** Remove item at index */
-    removeAt(index: number): T;
-    /** Remove first item */
-    removeFirst(): T;
-    /** Remove last item */
-    removeLast(): T;
-    /**
-     * Remove many items at index
-     * @param index index to start removing at
-     * @param count how many items to remove. If not defined, all items starting at `index` are removed
-     */
-    removeManyAt(index: number, count?: number): T[];
-    /**
-     * Remove range of items at `fromIndex` to `toIndex`
-     * @param fromIndex index to start removing at
-     * @param toIndex index to remove to
-     */
-    removeRange(fromIndex: number, toIndex: number): T[];
-    protected ensureBounds(index: number, count?: number): void;
-    protected normalizeIndex(index: number): number;
-    /** Yields all items from the list in reverse */
-    abstract itemsReverse(): IterableIterator<T>;
-    /** Get item at index */
-    protected abstract _at(index: number): T;
-    /**
-     * Find index of first occurrence of item
-     * @param item item to search for
-     * @param fromIndex index to start search at
-     */
-    protected abstract _indexOf(item: T, fromIndex?: number): number | undefined;
-    /** Index of match (first occurrence) */
-    protected abstract findIndex(predicate: Predicate<T>): number | undefined;
-    /** Index of item (last occurrence) */
-    /**
-     * Find index of last occurrence of item
-     * @param item item to search for
-     * @param fromIndex index to start from (backwards)
-     */
-    protected abstract _lastIndexOf(item: T, fromIndex?: number): number | undefined;
-    /** Index of match (last occurrence) */
-    protected abstract findLastIndex(predicate: Predicate<T>): number | undefined;
-    /** Set item at index */
-    protected abstract _set(index: number, item: T): void;
-    /** Add item to start of list */
-    protected abstract prepend(item: T): void;
-    /** Add many items to start of list */
-    protected abstract prependMany(items: Iterable<T>): void;
-    /** Remove item */
-    protected abstract remove(item: T): boolean;
-    /** Remove item at index */
-    protected abstract _removeAt(index: number): T;
-    /**
-     * Remove many items at index
-     * @param index index to start removing at
-     * @param count how many items to remove. If not defined, all items starting at `index` are removed
-     */
-    protected abstract _removeManyAt(index: number, count?: number): T[];
-}

package/types/data-structures/sorted-array-list.d.ts

@@ -1,49 +0,0 @@
-import type { TryDereference } from '../../serializer/serializable.js';
-import { Serializable } from '../../serializer/serializable.js';
-import type { Predicate } from '../../utils/iterable-helpers/types.js';
-import type { Comparator } from '../../utils/sort.js';
-import { List } from './list.js';
-export type RangeType = 'inclusive' | 'exclusive';
-export declare class SortedArrayList<T extends TComparator, TComparator = T> extends List<T, SortedArrayList<T, TComparator>> implements Serializable<SortedArrayList<T, TComparator>, T[]> {
-    private readonly comparator;
-    private backingArray;
-    constructor(items?: Iterable<T>, comparator?: Comparator<TComparator>);
-    /**
-     * creates a new {@link SortedArrayList} from existing *sorted* array without copying data.
-     * If an unsorted array is provided, behaviour is undefined
-     * @param array array to use as new backing array for this {@link SortedArrayList}
-     */
-    static fromSortedArray<T extends TComparator, TComparator>(array: T[]): SortedArrayList<T, TComparator>;
-    [Serializable.serialize](instance: SortedArrayList<T, TComparator>): T[];
-    [Serializable.deserialize](data: T[], tryDereference: TryDereference): SortedArrayList<T, TComparator>;
-    protected _at(index: number): T;
-    /** find index of item, can be any occurrence of it */
-    fastIndexOf(item: TComparator, fromIndex?: number): number | undefined;
-    protected _indexOf(item: TComparator, fromIndex?: number): number | undefined;
-    findIndex(predicate: Predicate<T>): number | undefined;
-    protected _lastIndexOf(item: TComparator, fromIndex?: number): number | undefined;
-    findLastIndex(predicate: Predicate<T>): number | undefined;
-    includes(item: T): boolean;
-    /** same as {@link add} as it is sorted */
-    prepend(item: T): void;
-    /** same as {@link addMany} as it is sorted */
-    prependMany(items: Iterable<T>): void;
-    add(item: T): void;
-    addMany(items: Iterable<T>): void;
-    /** same as `removeAt(index); add(item);` as it is sorted */
-    protected _set(index: number, item: T): void;
-    remove(item: T): boolean;
-    protected _removeAt(index: number): T;
-    protected _removeManyAt(index: number, count: number): T[];
-    /**
-     * remove items
-     * @param from
-     * @param to
-     */
-    removeRangeByComparison(_from: TComparator, _fromType: RangeType, _to: TComparator, _toType: RangeType): void;
-    clone(): SortedArrayList<T, TComparator>;
-    items(): IterableIterator<T>;
-    itemsReverse(): IterableIterator<T>;
-    protected _clear(): void;
-    private updateSize;
-}

package/types/database/module.d.ts

@@ -1,8 +0,0 @@
-import { Alphabet } from '../../utils/alphabet.js';
-export type DatabaseModuleConfig = {
-    idLength?: number;
-    idAlphabet?: Alphabet;
-    idGenerator?: () => string;
-};
-export declare const databaseModuleConfig: DatabaseModuleConfig;
-export declare function configureDatabase(config: DatabaseModuleConfig): void;

package/types/database/mongo/classes.d.ts

@@ -1,21 +0,0 @@
-import type { Entity } from '../../../database/index.js';
-import type { Resolvable, resolveArgumentType } from '../../../injector/interfaces.js';
-import { Db, Collection as MongoCollection, MongoClient as MongoMongoClient } from 'mongodb';
-import type { MongoDocument } from './model/document.js';
-import type { MongoConnection, MongoRepositoryConfig } from './types.js';
-export type MongoClientArgument = MongoConnection;
-/** database name */
-export type DatabaseArgument = string | {
-    connection?: MongoConnection;
-    database?: string;
-};
-export type CollectionArgument<T extends Entity<any> = Entity, TDb extends Entity<any> = T> = MongoRepositoryConfig<T, TDb>;
-export declare class MongoClient extends MongoMongoClient implements Resolvable<MongoClientArgument> {
-    readonly [resolveArgumentType]: MongoClientArgument;
-}
-export declare class Database extends Db implements Resolvable<DatabaseArgument> {
-    readonly [resolveArgumentType]: DatabaseArgument;
-}
-export declare class Collection<T extends Entity<any> = Entity, TDb extends Entity<any> = T> extends MongoCollection<MongoDocument<TDb>> implements Resolvable<CollectionArgument<T, TDb>> {
-    readonly [resolveArgumentType]: CollectionArgument<T, TDb>;
-}

package/types/database/mongo/model/document.d.ts

@@ -1,29 +0,0 @@
-import type { Entity, MaybeNewEntity, NewEntity } from '../../../../database/index.js';
-import type { OptionalId, OptionalUnlessRequiredId, WithId } from 'mongodb';
-import type { ProjectedEntity, Projection } from '../mongo-base.repository.js';
-import { ProjectionMode } from '../mongo-base.repository.js';
-export type MongoDocument<T extends MaybeNewEntity> = OptionalUnlessRequiredId<Omit<T, 'id'> & {
-    _id: T['id'];
-}>;
-export type MongoDocumentWithPartialId<T extends MaybeNewEntity> = OptionalId<Omit<T, 'id'> & {
-    _id?: T['id'];
-}>;
-export type MongoDocumentWithoutId<T extends MaybeNewEntity> = Omit<T, 'id'>;
-export declare function toEntity<T extends Entity>(document: WithId<MongoDocument<T>> | MongoDocument<T>): T;
-export declare function toNewEntity<T extends MaybeNewEntity>(entity: T): NewEntity<T>;
-export declare function toProjectedEntity<T extends Entity, M extends ProjectionMode, P extends Projection<T, M>>(document: MongoDocument<T> | MongoDocumentWithPartialId<T>): ProjectedEntity<T, M, P>;
-export declare function toMongoProjection<T extends Entity, M extends ProjectionMode, P extends Projection<T, M>>(mode: M, projection: P): Projection<MongoDocument<T>, M>;
-export declare function toMongoDocument<T extends Entity>(entity: T): MongoDocument<T>;
-export declare function toMongoDocumentWithPartialId<T extends MaybeNewEntity>(entity: T): MongoDocumentWithPartialId<T>;
-export declare function toMongoDocumentWithoutId<T extends Entity>(entity: MaybeNewEntity<T>): MongoDocumentWithoutId<T>;
-export declare function mongoDocumentFromMaybeNewEntity<T extends Entity>(entity: MaybeNewEntity<T>): MongoDocument<T>;
-export declare function renameIdPropertyToUnderscoreId<T extends {
-    id: any;
-}>(object: T): Omit<T, 'id'> & {
-    _id: T['id'];
-};
-export declare function renameIdPropertyToUnderscoreId<T extends {
-    id?: any;
-}>(object: T): Omit<T, 'id'> & {
-    _id?: T['id'];
-};