@tstdl/base 0.92.123 → 0.92.124

package/types/authentication/server/module.d.ts

@@ -0,0 +1,14 @@
+import type { Provider } from '../../../injector/provider.js';
+import type { InjectionToken } from '../../../injector/token.js';
+import type { DatabaseConfig } from '../../../orm/server/module.js';
+import { AuthenticationAncillaryService } from './authentication-ancillary.service.js';
+import { AuthenticationService, AuthenticationServiceOptions } from './authentication.service.js';
+export declare class AuthenticationModuleConfig {
+    database?: DatabaseConfig;
+    serviceOptions?: AuthenticationServiceOptions | Provider<AuthenticationServiceOptions>;
+    /** override default AuthenticationService */
+    authenticationService?: InjectionToken<AuthenticationService<any, any, any>>;
+    authenticationAncillaryService?: InjectionToken<AuthenticationAncillaryService<any, any, any>>;
+}
+export declare function configureAuthenticationServer(config: AuthenticationModuleConfig): void;
+export declare function migrateAuthenticationSchema(): Promise<void>;

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

@@ -0,0 +1,45 @@
+import type { BrowserContext, Page } from 'playwright';
+import type { AsyncDisposable } from '../../disposable/disposable.js';
+import { disposeAsync } from '../../disposable/disposable.js';
+import type { Resolvable } from '../../injector/interfaces.js';
+import { afterResolve, resolveArgumentType } from '../../injector/interfaces.js';
+import type { Logger } from '../../logger/logger.js';
+import type { Record } from '../../types.js';
+import type { Tagged } from 'type-fest';
+import type { NewBrowserContextOptions } from './browser-controller.js';
+import type { PageControllerOptions } from './page-controller.js';
+import { PageController } from './page-controller.js';
+export type BrowserContextControllerOptions = {
+    defaultNewPageOptions?: NewPageOptions;
+};
+export type NewPageOptions = {
+    extraHttpHeaders?: Record<string, string>;
+    controllerOptions?: PageControllerOptions;
+};
+export type BrowserContextState = Tagged<Record<string | number, unknown>, 'BrowserContextState'>;
+export type BrowserContextControllerArgument = NewBrowserContextOptions;
+export declare class BrowserContextController implements AsyncDisposable, Resolvable<BrowserContextControllerArgument> {
+    #private;
+    /** @deprecated should be avoided */
+    readonly context: BrowserContext;
+    readonly options: BrowserContextControllerOptions;
+    readonly [resolveArgumentType]: BrowserContextControllerArgument;
+    constructor(context: BrowserContext, options?: BrowserContextControllerOptions);
+    [afterResolve](): void;
+    initialize(): void;
+    [disposeAsync](): Promise<void>;
+    pages(): PageController[];
+    /**
+     * Get a controller for the page.
+     * @param page page to get controller for
+     * @param options options to use for the page controller *if* it is new. Ignored if there is already a controller associated.
+     */
+    getControllerByPage(page: Page, options?: PageControllerOptions): PageController;
+    close(): Promise<void>;
+    getState(): Promise<BrowserContextState>;
+    setExtraHttpHeaders(headers: Record<string, string | undefined>): Promise<void>;
+    newPage(options?: NewPageOptions): Promise<PageController>;
+    waitForNoPages(): Promise<void>;
+    waitForClose(): Promise<void>;
+    attachLogger(logger: Logger): void;
+}

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

@@ -0,0 +1,49 @@
+import type { Browser, BrowserContext } from 'playwright';
+import type { AsyncDisposable } from '../../disposable/disposable.js';
+import { disposeAsync } from '../../disposable/disposable.js';
+import type { Resolvable, resolveArgumentType } from '../../injector/interfaces.js';
+import type { Record } from '../../types.js';
+import type { BrowserContextControllerOptions, BrowserContextState, NewPageOptions } from './browser-context-controller.js';
+import { BrowserContextController } from './browser-context-controller.js';
+import type { NewBrowserOptions } from './browser.service.js';
+export type BrowserControllerOptions = {
+    defaultNewContextOptions?: NewBrowserContextOptions;
+};
+export type NewBrowserContextOptions = {
+    state?: BrowserContextState;
+    userAgent?: string;
+    colorScheme?: 'light' | 'dark' | 'no-preference';
+    locale?: string;
+    extraHttpHeaders?: Record<string, string | undefined>;
+    defaultNewPageOptions?: NewPageOptions;
+    viewport?: {
+        width: number;
+        height: number;
+    } | null;
+    proxy?: {
+        server: string;
+        bypass?: string;
+        username?: string;
+        password?: string;
+    };
+};
+export type BrowserControllerArgument = NewBrowserOptions;
+export declare class BrowserController implements AsyncDisposable, Resolvable<BrowserControllerArgument> {
+    /** @deprecated should be avoided */
+    readonly browser: Browser;
+    readonly options: BrowserControllerOptions | undefined;
+    readonly [resolveArgumentType]: BrowserControllerArgument;
+    constructor(browser: Browser, options?: BrowserControllerOptions);
+    [disposeAsync](): Promise<void>;
+    /**
+     * @deprecated for internal use
+     */
+    newRawContext(options?: NewBrowserContextOptions): Promise<{
+        context: BrowserContext;
+        controllerOptions: BrowserContextControllerOptions;
+    }>;
+    newContext(options?: NewBrowserContextOptions): Promise<BrowserContextController>;
+    close(): Promise<void>;
+    waitForNoContexts(): Promise<void>;
+    waitForClose(): Promise<void>;
+}

package/types/browser/browser.service.d.ts

@@ -0,0 +1,42 @@
+import type { Browser, LaunchOptions } from 'playwright';
+import type { AsyncDisposable } from '../../disposable/disposable.js';
+import { disposeAsync } from '../../disposable/disposable.js';
+import type { Resolvable, resolveArgumentType } from '../../injector/interfaces.js';
+import { BrowserContextController } from './browser-context-controller.js';
+import type { BrowserControllerOptions, NewBrowserContextOptions } from './browser-controller.js';
+import { BrowserController } from './browser-controller.js';
+export declare class BrowserServiceOptions {
+    defaultNewBrowserOptions?: NewBrowserOptions;
+}
+export type BrowserServiceArgument = BrowserServiceOptions;
+export type NewBrowserOptions = {
+    browser?: 'chromium' | 'firefox' | 'webkit';
+    headless?: boolean | 'new';
+    proxy?: LaunchOptions['proxy'];
+    windowSize?: {
+        width: number;
+        height: number;
+    };
+    /** @deprecated should be avoided */
+    browserArguments?: string[];
+    defaultNewContextOptions?: NewBrowserContextOptions;
+};
+export declare class BrowserService implements AsyncDisposable, Resolvable<BrowserServiceArgument> {
+    private readonly browsers;
+    private readonly persistentBrowserContexts;
+    readonly options: BrowserServiceOptions | undefined;
+    readonly [resolveArgumentType]: BrowserServiceArgument;
+    constructor(options?: BrowserServiceOptions);
+    [disposeAsync](): Promise<void>;
+    /**
+     * @deprecated internal use only
+     */
+    newRawBrowser(options?: NewBrowserOptions): Promise<{
+        browser: Browser;
+        controllerOptions: BrowserControllerOptions;
+    }>;
+    newBrowser(options?: NewBrowserOptions): Promise<BrowserController>;
+    newPersistentContext(dataDirectory: string, browserOptions?: NewBrowserOptions, contextOptions?: NewBrowserContextOptions): Promise<BrowserContextController>;
+    waitForNoBrowsers(): Promise<void>;
+    dispose(): Promise<void>;
+}

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

@@ -0,0 +1,104 @@
+import type { ElementHandle, Locator } from 'playwright';
+import type { Merge, NonUndefinable, TypedOmit } from '../../types.js';
+import type { ActionDelayOptions, Delay, TimeoutOptions } from './types.js';
+export type TypeDelayOptions = {
+    typeDelay?: Delay;
+};
+export type ClickDelayOptions = {
+    clickDelay?: Delay;
+};
+export type ElementControllerOptions = {
+    actionDelay?: Delay;
+    typeDelay?: Delay;
+};
+type LocatorOptions<K extends keyof Locator, I extends keyof Parameters<Locator[K]>> = NonUndefinable<Parameters<Locator[K]>[I]>;
+type Methods = 'isVisible' | 'isHidden' | 'isEnabled' | 'isDisabled' | 'isChecked' | 'isEditable' | 'fill' | 'type' | 'press' | 'check' | 'uncheck' | 'setChecked' | 'selectOption' | 'setInputFiles' | 'click' | 'hover' | 'focus' | 'tap' | 'selectText' | 'inputValue';
+export type Filter = {
+    has?: ElementController;
+    hasNot?: ElementController;
+    hasText?: string | RegExp;
+    hasNotText?: string | RegExp;
+};
+export type BoundingBox = {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+};
+export declare class ElementController<T extends Locator | ElementHandle = Locator | ElementHandle> implements Pick<Locator, Methods> {
+    readonly locatorOrHandle: T;
+    readonly options: ElementControllerOptions;
+    constructor(locatorOrHandle: T, options?: ElementControllerOptions);
+    getAll(): Promise<ElementController<Locator>[]>;
+    getAllHandles(): Promise<ElementController<ElementHandle>[]>;
+    /**
+     * Get an controller with elements contained in this and the provided controller.
+     * Requires locator based controller
+     * @param elementController
+     */
+    and(elementController: ElementController): ElementController<Locator>;
+    /**
+     * Get an controller with elements contained in this and the provided controller.
+     * Requires locator based controller
+     * @param elementController
+     */
+    or(elementController: ElementController): ElementController<Locator>;
+    /**
+     * Filter out elements with by provided filter.
+     * Requires locator based controller.
+     */
+    filter(filter: Filter): ElementController<Locator>;
+    /**
+     * Locate elements in subtree with provided selector/controller and filter.
+     * Requires locator based controller.
+     */
+    locate(selectorOrController: string | ElementController, filter?: Filter): ElementController<Locator>;
+    first(): ElementController<Locator>;
+    last(): ElementController<Locator>;
+    nth(index: number): ElementController<Locator>;
+    evaluate<R, A>(fn: string | ((element: SVGElement | HTMLElement, argument: A) => R | Promise<R>), argument: A): Promise<R>;
+    evaluate<R, A>(fn: string | ((element: SVGElement | HTMLElement, argument?: A) => R | Promise<R>), argument?: A): Promise<R>;
+    /**
+     * Wait for element state
+     * @param state some states may only be usable for either locator or handle
+     * @param options options
+     */
+    waitFor(state?: Parameters<ElementHandle['waitForElementState']>[0] | NonNullable<LocatorOptions<'waitFor', '0'>['state']>, options?: Parameters<ElementHandle['waitForElementState']>[1]): Promise<void>;
+    boundingBox(options?: TimeoutOptions): Promise<BoundingBox | null>;
+    scrollIntoViewIfNeeded(options?: TimeoutOptions): Promise<void>;
+    /**
+     * Counts matching elements for locator based or returns 1 for handle based.
+     */
+    count(): Promise<number>;
+    /**
+     * Check if element exists
+     * @param options.state which state is required in order to be deemed existing
+     * @param options.timeout how long to wait for the element before being deemed not existing (default: 250ms)
+     */
+    exists(options?: {
+        state?: 'visible' | 'attached';
+    } & TimeoutOptions): Promise<boolean>;
+    isVisible(): Promise<boolean>;
+    isHidden(): Promise<boolean>;
+    isEnabled(): Promise<boolean>;
+    isDisabled(): Promise<boolean>;
+    isChecked(): Promise<boolean>;
+    isEditable(): Promise<boolean>;
+    clear(options?: Merge<LocatorOptions<'clear', 1>, ActionDelayOptions>): Promise<void>;
+    fill(text: string, options?: Merge<LocatorOptions<'fill', 1>, ActionDelayOptions>): Promise<void>;
+    type(text: string, options?: Merge<TypedOmit<LocatorOptions<'type', 1>, 'delay'>, ActionDelayOptions & TypeDelayOptions>): Promise<void>;
+    press(key: string, options?: Merge<LocatorOptions<'press', 1>, ActionDelayOptions>): Promise<void>;
+    check(options?: Merge<LocatorOptions<'check', 1>, ActionDelayOptions>): Promise<void>;
+    uncheck(options?: Merge<LocatorOptions<'uncheck', 1>, ActionDelayOptions>): Promise<void>;
+    setChecked(checked: boolean, options?: Merge<LocatorOptions<'setChecked', 1>, ActionDelayOptions>): Promise<void>;
+    selectOption(option: string | string[], options?: Merge<LocatorOptions<'selectOption', 1>, ActionDelayOptions>): Promise<string[]>;
+    setInputFiles(files: LocatorOptions<'setInputFiles', 0>, options?: Merge<LocatorOptions<'setInputFiles', 1>, ActionDelayOptions>): Promise<void>;
+    click(options?: Merge<TypedOmit<LocatorOptions<'click', 0>, 'delay'>, ActionDelayOptions & ClickDelayOptions>): Promise<void>;
+    dblclick(options?: Merge<TypedOmit<LocatorOptions<'click', 0>, 'delay'>, ActionDelayOptions & ClickDelayOptions>): Promise<void>;
+    hover(options?: Merge<LocatorOptions<'hover', 1>, ActionDelayOptions>): Promise<void>;
+    focus(options?: Merge<LocatorOptions<'focus', 1>, ActionDelayOptions>): Promise<void>;
+    tap(options?: Merge<LocatorOptions<'tap', 1>, ActionDelayOptions>): Promise<void>;
+    selectText(options?: Merge<LocatorOptions<'selectText', 1>, ActionDelayOptions>): Promise<void>;
+    inputValue(options?: LocatorOptions<'inputValue', 0>): Promise<string>;
+}
+export {};

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

@@ -0,0 +1,16 @@
+import type { Frame, FrameLocator, Locator, Page } from 'playwright';
+import type { NonUndefinable, SimplifyObject } from '../../types.js';
+import type { ElementControllerOptions } from './element-controller.js';
+import { ElementController } from './element-controller.js';
+export declare class LocatorController<T extends Page | Frame | Locator | FrameLocator = Page | Frame | Locator | FrameLocator> {
+    protected readonly elementControllerOptions: ElementControllerOptions;
+    readonly locatable: T;
+    constructor(locatable: T, elementControllerOptions: ElementControllerOptions);
+    getBySelector(selector: string, options?: SimplifyObject<Pick<NonUndefinable<Parameters<Page['locator']>[1]>, 'hasText' | 'hasNotText'>>): ElementController<Locator>;
+    getByRole(role: Parameters<Page['getByRole']>[0], options?: Parameters<Page['getByRole']>[1]): ElementController<Locator>;
+    getByLabel(text: Parameters<Page['getByLabel']>[0], options?: Parameters<Page['getByLabel']>[1]): ElementController<Locator>;
+    getByAltText(text: Parameters<Page['getByAltText']>[0], options?: Parameters<Page['getByAltText']>[1]): ElementController<Locator>;
+    getByPlaceholder(text: Parameters<Page['getByPlaceholder']>[0], options?: Parameters<Page['getByPlaceholder']>[1]): ElementController<Locator>;
+    getByText(text: Parameters<Page['getByText']>[0], options?: Parameters<Page['getByText']>[1]): ElementController<Locator>;
+    getByTitle(text: Parameters<Page['getByTitle']>[0], options?: Parameters<Page['getByTitle']>[1]): ElementController<Locator>;
+}

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

@@ -0,0 +1,40 @@
+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

@@ -0,0 +1,15 @@
+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

@@ -0,0 +1,17 @@
+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

@@ -0,0 +1,36 @@
+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

@@ -0,0 +1,37 @@
+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

@@ -0,0 +1,10 @@
+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

@@ -0,0 +1,30 @@
+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

@@ -0,0 +1,56 @@
+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

@@ -0,0 +1,65 @@
+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

@@ -0,0 +1,11 @@
+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

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