@tstdl/base 0.92.124 → 0.92.126

package/document-management/service-models/stats.view-model.js

@@ -0,0 +1,42 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { NumberProperty } from '../../schema/index.js';
+export class RequestStats {
+    total;
+    documentPending;
+    approvalPending;
+    approvals;
+    rejections;
+    closedWithoutDocument;
+}
+__decorate([
+    NumberProperty(),
+    __metadata("design:type", Number)
+], RequestStats.prototype, "total", void 0);
+__decorate([
+    NumberProperty(),
+    __metadata("design:type", Number)
+], RequestStats.prototype, "documentPending", void 0);
+__decorate([
+    NumberProperty(),
+    __metadata("design:type", Number)
+], RequestStats.prototype, "approvalPending", void 0);
+__decorate([
+    NumberProperty(),
+    __metadata("design:type", Number)
+], RequestStats.prototype, "approvals", void 0);
+__decorate([
+    NumberProperty(),
+    __metadata("design:type", Number)
+], RequestStats.prototype, "rejections", void 0);
+__decorate([
+    NumberProperty(),
+    __metadata("design:type", Number)
+], RequestStats.prototype, "closedWithoutDocument", void 0);

package/dom/file-select-dialog.d.ts

@@ -0,0 +1,7 @@
+import type { OneOrMany } from '../types.js';
+export type FileSelectDialogOptions = {
+    accept?: OneOrMany<string>;
+    multiple?: boolean;
+    capture?: string;
+};
+export declare function openFileSelectDialog({ accept, multiple, capture }?: FileSelectDialogOptions): Promise<File[] | null>;

package/dom/observation/intersection-observer.d.ts

@@ -0,0 +1,4 @@
+import { type Observable } from 'rxjs';
+import { type Signal } from '../../signals/api.js';
+export declare function observeIntersection$(element: Element, options?: IntersectionObserverInit): Observable<IntersectionObserverEntry>;
+export declare function observeIntersection(elements: Element, options?: IntersectionObserverInit): Signal<IntersectionObserverEntry | undefined>;

package/dom/observation/media-query-observer.d.ts

@@ -0,0 +1,12 @@
+import { type Signal } from '../../signals/api.js';
+import { type Observable } from 'rxjs';
+/**
+ * Creates an observable that emits whether the query matches
+ * @param query query to watch
+ */
+export declare function observeMediaQuery$(query: string): Observable<boolean>;
+/**
+ * Creates an signal that signals whether the query matches
+ * @param query query to watch
+ */
+export declare function observeMediaQuery(query: string): Signal<boolean>;

package/dom/observation/resize-observer.d.ts

@@ -0,0 +1,4 @@
+import { type Signal } from '../../signals/api.js';
+import { type Observable } from 'rxjs';
+export declare function observeResize$(element: Element, options?: ResizeObserverOptions): Observable<ResizeObserverEntry>;
+export declare function observeResize(elements: Element, options?: ResizeObserverOptions): Signal<ResizeObserverEntry | undefined>;

package/enumerable/async-enumerable.d.ts

@@ -0,0 +1,78 @@
+import type { CancellationSignal } from '../cancellation/token.js';
+import { type AnyIterable } from '../utils/any-iterable-iterator.js';
+import type { AsyncComparator } from '../utils/sort.js';
+import type { Observable } from 'rxjs';
+import type { AsyncGroupSelectors, AsyncIteratorFunction, AsyncPredicate, AsyncReducer, AsyncRetryPredicate, ParallelizableIteratorFunction, ParallelizablePredicate, ThrottleFunction } from '../utils/async-iterable-helpers/index.js';
+import { type IterableItemMetadata, type TypePredicate } from '../utils/iterable-helpers/index.js';
+import type { EnumerableMethods } from './enumerable-methods.js';
+import { Enumerable } from './enumerable.js';
+export declare class AsyncEnumerable<T> implements EnumerableMethods, AsyncIterable<T> {
+    private readonly source;
+    constructor(source: AnyIterable<T>);
+    static from<T>(source: AnyIterable<T>): AsyncEnumerable<T>;
+    static fromDeferred<T>(source: () => AnyIterable<T> | Promise<AnyIterable<T>>): AsyncEnumerable<T>;
+    static fromObservable<T>(observable: Observable<T>): AsyncEnumerable<T>;
+    static fromRange(fromInclusive: number, toInclusive: number): AsyncEnumerable<number>;
+    assert<TPredicate extends T>(predicate: TypePredicate<T, TPredicate> | AsyncPredicate<T>): AsyncEnumerable<TPredicate>;
+    all(predicate?: AsyncPredicate<T>): Promise<boolean>;
+    any(predicate?: AsyncPredicate<T>): Promise<boolean>;
+    batch(size: number): AsyncEnumerable<T[]>;
+    buffer(size: number): AsyncEnumerable<T>;
+    cast<TNew extends T>(): AsyncEnumerable<TNew>;
+    concat<U>(...iterables: AnyIterable<U>[]): AsyncEnumerable<T | U>;
+    defaultIfEmpty<TDefault>(defaultValue: TDefault): AsyncEnumerable<T | TDefault>;
+    difference(iterable: AnyIterable<T>, selector?: AsyncIteratorFunction<T, unknown>): AsyncEnumerable<T>;
+    differenceMany(iterables: AnyIterable<T>[], selector?: AsyncIteratorFunction<T, unknown>): AsyncEnumerable<T>;
+    distinct(selector?: AsyncIteratorFunction<T, any>): AsyncEnumerable<T>;
+    drain(): Promise<void>;
+    includes(value: T): Promise<boolean>;
+    filter<TPredicate extends T = T>(predicate: TypePredicate<T, TPredicate> | AsyncPredicate<T>): AsyncEnumerable<TPredicate>;
+    filterNullOrUndefined(): AsyncEnumerable<NonNullable<T>>;
+    first<TPredicate extends T = T>(predicate?: TypePredicate<T, TPredicate> | AsyncPredicate<T>): Promise<TPredicate>;
+    firstOrDefault<D, TPredicate extends T = T>(defaultValue: D, predicate?: TypePredicate<T, TPredicate> | AsyncPredicate<T>): Promise<TPredicate | D>;
+    forceCast<TNew>(): AsyncEnumerable<TNew>;
+    forEach(func: AsyncIteratorFunction<T, any>): Promise<void>;
+    group<TGroup>(selector: AsyncIteratorFunction<T, TGroup>): AsyncEnumerable<[TGroup, T[]]>;
+    group<TGroup extends [any, ...any[]]>(...selectors: AsyncGroupSelectors<T, TGroup>): AsyncEnumerable<[TGroup['length'] extends 1 ? TGroup[0] : TGroup, T[]]>;
+    groupSingle<TGroup>(selector: AsyncIteratorFunction<T, TGroup>): AsyncEnumerable<[TGroup, T]>;
+    groupSingle<TGroup extends [any, ...any[]]>(...selectors: AsyncGroupSelectors<T, TGroup>): AsyncEnumerable<[TGroup['length'] extends 1 ? TGroup[0] : TGroup, T]>;
+    groupToMap<TGroup>(selector: AsyncIteratorFunction<T, TGroup>): Promise<Map<TGroup, T[]>>;
+    groupToMap<TGroup extends [any, ...any[]]>(...selectors: AsyncGroupSelectors<T, TGroup>): Promise<Map<TGroup['length'] extends 1 ? TGroup[0] : TGroup, T[]>>;
+    groupToSingleMap<TGroup>(selector: AsyncIteratorFunction<T, TGroup>): Promise<Map<TGroup, T>>;
+    groupToSingleMap<TGroup extends [any, ...any[]]>(...selectors: AsyncGroupSelectors<T, TGroup>): Promise<Map<TGroup['length'] extends 1 ? TGroup[0] : TGroup, T>>;
+    tap(tapper: AsyncIteratorFunction<T, any>): AsyncEnumerable<T>;
+    interruptEvery(value: number): AsyncEnumerable<T>;
+    interruptPerSecond(value: number): AsyncEnumerable<T>;
+    last<TPredicate extends T = T>(predicate?: TypePredicate<T, TPredicate> | AsyncPredicate<T>): Promise<TPredicate>;
+    lastOrDefault<D, TPredicate extends T = T>(defaultValue: D, predicate?: TypePredicate<T, TPredicate> | AsyncPredicate<T>): Promise<TPredicate | D>;
+    map<TOut>(mapper: AsyncIteratorFunction<T, TOut>): AsyncEnumerable<TOut>;
+    mapMany<TOut>(mapper: AsyncIteratorFunction<T, AnyIterable<TOut>>): AsyncEnumerable<TOut>;
+    materialize(): AsyncEnumerable<T>;
+    metadata(): AsyncEnumerable<IterableItemMetadata<T>>;
+    multiplex(count: number, bufferSize?: number): AsyncEnumerable<T>[];
+    pairwise(): AsyncEnumerable<[T, T]>;
+    reduce(reducer: AsyncReducer<T, T>): Promise<T>;
+    reduce<U>(reducer: AsyncReducer<T, U>, initialValue: U): Promise<U>;
+    retry(throwOnRetryFalse: boolean, predicate: AsyncRetryPredicate<T>): AsyncEnumerable<T>;
+    single<TPredicate extends T = T>(predicate?: TypePredicate<T, TPredicate> | AsyncPredicate<T>): Promise<TPredicate>;
+    singleOrDefault<D, TPredicate extends T = T>(defaultValue: D, predicate?: TypePredicate<T, TPredicate> | AsyncPredicate<T>): Promise<TPredicate | D>;
+    skip(count: number): AsyncEnumerable<T>;
+    sort(comparator?: AsyncComparator<T>): AsyncEnumerable<T>;
+    sortToArray(comparator?: AsyncComparator<T>): Promise<T[]>;
+    take(count: number): AsyncEnumerable<T>;
+    takeUntil(cancellationSignal: CancellationSignal): AsyncEnumerable<T>;
+    takeWhile(yieldLastOnFalse: boolean, predicate: AsyncPredicate<T>): AsyncEnumerable<T>;
+    throttle(delayOrThrottleFunction: number | ThrottleFunction): AsyncEnumerable<T>;
+    toArray(): Promise<T[]>;
+    toAsync(): this;
+    toIterator(): AsyncIterator<T>;
+    toSet(): Promise<Set<T>>;
+    toSync(): Promise<Enumerable<T>>;
+    while(predicate: AsyncPredicate<T>): AsyncEnumerable<T>;
+    parallelFilter(concurrency: number, keepOrder: boolean, predicate: ParallelizablePredicate<T>): AsyncEnumerable<T>;
+    parallelForEach(concurrency: number, func: ParallelizableIteratorFunction<T, any>): Promise<void>;
+    parallelGroup<TGroup>(concurrency: number, selector: ParallelizableIteratorFunction<T, TGroup>): Promise<Map<TGroup, T[]>>;
+    parallelTap(concurrency: number, keepOrder: boolean, tapper: ParallelizableIteratorFunction<T, any>): AsyncEnumerable<T>;
+    parallelMap<TOut>(concurrency: number, keepOrder: boolean, func: ParallelizableIteratorFunction<T, TOut>): AsyncEnumerable<TOut>;
+    [Symbol.asyncIterator](): AsyncIterableIterator<T>;
+}

package/enumerable/enumerable.d.ts

@@ -0,0 +1,63 @@
+import type { CancellationSignal } from '../cancellation/token.js';
+import type { Comparator } from '../utils/sort.js';
+import type { GroupSelectors, IterableItemMetadata, IteratorFunction, Predicate, Reducer, TypePredicate } from '../utils/iterable-helpers/index.js';
+import { AsyncEnumerable } from './async-enumerable.js';
+import type { EnumerableMethods } from './enumerable-methods.js';
+export declare class Enumerable<T> implements EnumerableMethods, Iterable<T> {
+    private readonly source;
+    constructor(iterable: Iterable<T>);
+    static from<T>(source: Iterable<T>): Enumerable<T>;
+    static fromDeferred<T>(source: () => Iterable<T>): Enumerable<T>;
+    static fromRange(fromInclusive: number, toInclusive: number): Enumerable<number>;
+    assert<TPredicate extends T>(predicate: Predicate<T> | TypePredicate<T, TPredicate>): Enumerable<TPredicate>;
+    all(predicate?: Predicate<T>): boolean;
+    any(predicate?: Predicate<T>): boolean;
+    batch(size: number): Enumerable<T[]>;
+    cast<TNew extends T>(): Enumerable<TNew>;
+    concat<U>(...iterables: Iterable<U>[]): Enumerable<T | U>;
+    defaultIfEmpty<TDefault>(defaultValue: TDefault): Enumerable<T | TDefault>;
+    difference(iterable: Iterable<T>, selector?: IteratorFunction<T, unknown>): Enumerable<T>;
+    differenceMany(iterables: Iterable<T>[], selector?: IteratorFunction<T, unknown>): Enumerable<T>;
+    distinct(selector?: IteratorFunction<T, any>): Enumerable<T>;
+    includes(value: T): boolean;
+    drain(): void;
+    filter<TPredicate extends T = T>(predicate: Predicate<T> | TypePredicate<T, TPredicate>): Enumerable<TPredicate>;
+    filterNullOrUndefined(): Enumerable<NonNullable<T>>;
+    first<TPredicate extends T = T>(predicate?: Predicate<T> | TypePredicate<T, TPredicate>): TPredicate;
+    firstOrDefault<D, TPredicate extends T = T>(defaultValue: D, predicate?: Predicate<T> | TypePredicate<T, TPredicate>): TPredicate | D;
+    forEach(func: IteratorFunction<T, void>): void;
+    forceCast<TNew>(): Enumerable<TNew>;
+    group<TGroup>(selector: IteratorFunction<T, TGroup>): Enumerable<[TGroup, T[]]>;
+    group<TGroup extends [any, ...any[]]>(...selectors: GroupSelectors<T, TGroup>): Enumerable<[TGroup['length'] extends 1 ? TGroup[0] : TGroup, T[]]>;
+    groupSingle<TGroup>(selector: IteratorFunction<T, TGroup>): Enumerable<[TGroup, T]>;
+    groupSingle<TGroup extends [any, ...any[]]>(...selectors: GroupSelectors<T, TGroup>): Enumerable<[TGroup['length'] extends 1 ? TGroup[0] : TGroup, T]>;
+    groupToMap<TGroup>(selector: IteratorFunction<T, TGroup>): Map<TGroup, T[]>;
+    groupToMap<TGroup extends [any, ...any[]]>(...selectors: GroupSelectors<T, TGroup>): Map<TGroup['length'] extends 1 ? TGroup[0] : TGroup, T[]>;
+    groupToSingleMap<TGroup>(selector: IteratorFunction<T, TGroup>): Map<TGroup, T>;
+    groupToSingleMap<TGroup extends [any, ...any[]]>(...selectors: GroupSelectors<T, TGroup>): Map<TGroup['length'] extends 1 ? TGroup[0] : TGroup, T>;
+    tap(tapper: IteratorFunction<T, any>): Enumerable<T>;
+    last<TPredicate extends T = T>(predicate?: Predicate<T> | TypePredicate<T, TPredicate>): TPredicate;
+    lastOrDefault<D, TPredicate extends T = T>(defaultValue: D, predicate?: Predicate<T> | TypePredicate<T, TPredicate>): TPredicate | D;
+    map<TOut>(mapper: IteratorFunction<T, TOut>): Enumerable<TOut>;
+    mapMany<TOut>(mapper: IteratorFunction<T, Iterable<TOut>>): Enumerable<TOut>;
+    materialize(): Enumerable<T>;
+    metadata(): Enumerable<IterableItemMetadata<T>>;
+    pairwise(): Enumerable<[T, T]>;
+    reduce(reducer: Reducer<T, T>): T;
+    reduce<U>(reducer: Reducer<T, U>, initialValue: U): U;
+    single<TPredicate extends T = T>(predicate?: Predicate<T> | TypePredicate<T, TPredicate>): TPredicate;
+    singleOrDefault<D, TPredicate extends T = T>(defaultValue: D, predicate?: Predicate<T> | TypePredicate<T, TPredicate>): TPredicate | D;
+    skip(count: number): Enumerable<T>;
+    sort(comparator?: Comparator<T>): Enumerable<T>;
+    sortToArray(comparator?: Comparator<T>): T[];
+    take(count: number): Enumerable<T>;
+    takeUntil(cancellationSignal: CancellationSignal): Enumerable<T>;
+    takeWhile(yieldLastOnFalse: boolean, predicate: Predicate<T>): Enumerable<T>;
+    toArray(): T[];
+    toAsync(): AsyncEnumerable<T>;
+    toIterator(): Iterator<T>;
+    toSet(): Set<T>;
+    toSync(): this;
+    while(predicate: Predicate<T>): IterableIterator<T>;
+    [Symbol.iterator](): IterableIterator<T>;
+}

package/enumeration/enumeration.d.ts

@@ -0,0 +1,5 @@
+import type { EnumerationObject } from '../types.js';
+export type EnumType<T extends EnumerationObject> = T[keyof T];
+export declare function defineEnum<const T extends EnumerationObject>(name: string, enumObject: T): T;
+export declare function tryGetEnumName(enumeration: EnumerationObject): string | undefined;
+export declare function getEnumName(enumeration: EnumerationObject): string;

package/errors/errors.localization.d.ts

@@ -0,0 +1,53 @@
+import type { SecretRequirementsError } from '../authentication/index.js';
+import { type HttpError, HttpErrorReason } from '../http/http.error.js';
+import { type Localization, type LocalizeItem } from '../text/localization.service.js';
+import type { Enumeration } from '../types.js';
+import type { ApiError } from './api.error.js';
+import type { BadRequestError } from './bad-request.error.js';
+import type { CustomError, CustomErrorStatic } from './custom.error.js';
+import type { ForbiddenError } from './forbidden.error.js';
+import type { InvalidCredentialsError } from './invalid-credentials.error.js';
+import type { InvalidTokenError } from './invalid-token.error.js';
+import type { MaxBytesExceededError } from './max-bytes-exceeded.error.js';
+import type { MethodNotAllowedError } from './method-not-allowed.error.js';
+import type { NotFoundError } from './not-found.error.js';
+import type { NotImplementedError } from './not-implemented.error.js';
+import type { NotSupportedError } from './not-supported.error.js';
+import type { TimeoutError } from './timeout.error.js';
+import type { UnauthorizedError } from './unauthorized.error.js';
+type ErrorLocalizationEntry<T extends CustomError> = {
+    header: LocalizeItem<T>;
+    message?: LocalizeItem<T>;
+};
+export type ErrorsLocalizationEntries<T extends CustomErrorStatic[]> = {
+    [ErrorName in T[number]['errorName']]: ErrorLocalizationEntry<InstanceType<Extract<T[number], {
+        errorName: ErrorName;
+    }>>>;
+};
+export type ErrorsLocalization<T extends CustomErrorStatic[] = CustomErrorStatic[], Enums extends Enumeration[] = Enumeration[]> = Localization<{
+    tstdl: {
+        errors: ErrorsLocalizationEntries<T>;
+    };
+}, Enums>;
+type TstdlErrors = [
+    typeof ApiError,
+    typeof BadRequestError,
+    typeof ForbiddenError,
+    typeof InvalidCredentialsError,
+    typeof InvalidTokenError,
+    typeof MaxBytesExceededError,
+    typeof MethodNotAllowedError,
+    typeof NotFoundError,
+    typeof NotImplementedError,
+    typeof NotSupportedError,
+    typeof TimeoutError,
+    typeof UnauthorizedError,
+    typeof HttpError,
+    typeof SecretRequirementsError
+];
+export declare const tstdlErrorsLocalizationKeys: import("../text/localization.service.js").ProxyLocalizationKeys<{
+    errors: ErrorsLocalizationEntries<CustomErrorStatic<CustomError>[]>;
+}>;
+export declare const germanTstdlErrorsLocalization: ErrorsLocalization<TstdlErrors, [typeof HttpErrorReason]>;
+export declare const englishTstdlErrorsLocalization: ErrorsLocalization<TstdlErrors>;
+export {};

package/errors/not-supported.error.d.ts

@@ -0,0 +1,7 @@
+import type { EnumerationObject } from '../types.js';
+import { CustomError } from './custom.error.js';
+export declare class NotSupportedError extends CustomError {
+    static readonly errorName = "NotSupportedError";
+    constructor(message?: string);
+    static fromEnum(enumeration: EnumerationObject, name: string, value: any): NotSupportedError;
+}

package/examples/api/authentication.d.ts

@@ -0,0 +1 @@
+import '../../polyfills.js';

package/examples/api/basic-overview.d.ts

@@ -0,0 +1 @@
+import '../../polyfills.js';

package/examples/api/custom-authentication.d.ts

@@ -0,0 +1 @@
+import '../../polyfills.js';

package/examples/api/streaming.d.ts

@@ -0,0 +1 @@
+import '../../polyfills.js';

package/examples/browser/basic.d.ts

@@ -0,0 +1 @@
+import '../../polyfills.js';

package/examples/document-management/main.d.ts

@@ -0,0 +1,21 @@
+import '../../polyfills.js';
+import type { DocumentCollection, DocumentWorkflowStep } from '../../document-management/index.js';
+import { DocumentManagementAncillaryService, type DocumentCollectionMetadata } from '../../document-management/server/index.js';
+export declare class TestDocumentManagementAncillaryService extends DocumentManagementAncillaryService {
+    _resolveMetadata(collections: DocumentCollection[]): DocumentCollectionMetadata[];
+    canReadCollection(_collectionId: string, _token?: unknown): boolean;
+    canWriteCollection(_collectionId: string, _token?: unknown): boolean;
+    canApproveDocument(_documentId: string, _token?: unknown): boolean;
+    canRejectDocument(_documentId: string, _token?: unknown): boolean;
+    canReadDocumentRequest(_requestId: string, _token?: unknown): boolean;
+    canAssignDocumentToRequest(_requestId: string, _documentId: string, _token?: unknown): boolean;
+    canManageCategoriesAndTypes(_token?: unknown): boolean;
+    canReadDocumentRequestsTemplates(_token?: unknown): boolean;
+    canManageDocumentRequestsTemplates(_token?: unknown): boolean;
+    canCreateUnassignedDocument(_token?: unknown): boolean;
+    canCreateRequestAssignedDocument(_token?: unknown): boolean;
+    canDeleteDocument(_documentId: string, _token?: unknown): boolean;
+    canManageDocumentRequest(_token?: unknown): boolean;
+    canManageValidationDefinitions(_token?: unknown): boolean;
+    canProgressDocumentWorkflow(_documentId: string, _currentWorkflowStep: DocumentWorkflowStep, _token?: unknown): boolean;
+}

package/examples/http/client.d.ts

@@ -0,0 +1 @@
+import '../../polyfills.js';

package/examples/mail/templates/hello-name.d.ts

@@ -0,0 +1,5 @@
+type HelloMailContext = {
+    name: string;
+};
+declare const template: import("../../../mail/index.js").MailTemplate<HelloMailContext>;
+export default template;

package/examples/orm/schemas.d.ts

@@ -0,0 +1,3 @@
+import { User } from './user.model.js';
+export declare const mySchema: import("../../orm/server/database-schema.js").DatabaseSchema<"my_application">;
+export declare const user: import("../../orm/server/types.js").PgTableFromType<typeof User, "my_application">;

package/examples/orm/user.model.d.ts

@@ -0,0 +1,13 @@
+import { Entity, Integer } from '../../orm/index.js';
+export declare enum Foo {
+    Bar = 0,
+    Baz = 1
+}
+export declare class User extends Entity {
+    static entityName: string;
+    name: string;
+    nickNames: string[];
+    age: Integer | null;
+    hasAge: boolean;
+    mail: string;
+}

package/examples/pdf/templates/hello-name.d.ts

@@ -0,0 +1,2 @@
+declare const template: import("../../../pdf/pdf.service.js").PdfTemplate<any>;
+export default template;

package/examples/reflection/basic.d.ts

@@ -0,0 +1,11 @@
+import { type ReflectionRegistry } from '../../reflection/index.js';
+export declare class Foo {
+    private readonly registry;
+    get someGetter(): number;
+    static get someStaticGetter(): number;
+    someProperty: number;
+    static someStaticProperty: number;
+    constructor(registry: ReflectionRegistry);
+    static someStaticMethod(_parameter: string): void;
+    someMethod(_parameter: bigint): void;
+}

package/examples/template/templates/hello-jsx.d.ts

@@ -0,0 +1,4 @@
+export declare const template: import("../../../templates/template.model.js").Template<{
+    template: true;
+}, any, any>;
+export default template;

package/examples/template/templates/hello-name.d.ts

@@ -0,0 +1,4 @@
+declare const template: import("../../../templates/template.model.js").Template<{
+    template: true;
+}, any, any>;
+export default template;

package/function/log.d.ts

@@ -0,0 +1,8 @@
+import type { Logger } from '../logger/logger.js';
+export type WrapLogOptions = {
+    fnName?: string;
+    logResult?: boolean;
+    logger?: Logger;
+    trace?: boolean;
+};
+export declare function wrapLog(fn: Function, { fnName, logResult, logger, trace }?: WrapLogOptions): Function;

package/http/client/adapters/undici.adapter.d.ts

@@ -0,0 +1,20 @@
+import type { Dispatcher } from 'undici';
+import type { Resolvable } from '../../../injector/index.js';
+import { resolveArgumentType } from '../../../injector/index.js';
+import type { HttpClientRequest } from '../http-client-request.js';
+import { HttpClientResponse } from '../http-client-response.js';
+import { HttpClientAdapter } from '../http-client.adapter.js';
+export type UndiciHttpClientAdapterOptions = {
+    dispatcher?: Dispatcher;
+};
+export declare class UndiciHttpClientAdapter extends HttpClientAdapter implements Resolvable<UndiciHttpClientAdapterOptions> {
+    private readonly options;
+    readonly [resolveArgumentType]: UndiciHttpClientAdapterOptions;
+    call(httpClientRequest: HttpClientRequest): Promise<HttpClientResponse>;
+}
+/**
+ * @param register whether to register for {@link HttpClientAdapter}
+ */
+export declare function configureUndiciHttpClientAdapter(options?: UndiciHttpClientAdapterOptions & {
+    register?: boolean;
+}): void;

package/http/client/http-client-request.d.ts

@@ -0,0 +1,122 @@
+import { type CancellationSignal } from '../../cancellation/index.js';
+import { dispose, type Disposable } from '../../disposable/index.js';
+import type { OneOrMany, Record, TypedOmit, UndefinableJson, UndefinableJsonObject } from '../../types.js';
+import { HttpForm, type HttpFormObject } from '../http-form.js';
+import { HttpHeaders, type HttpHeadersObject } from '../http-headers.js';
+import { HttpQuery, type HttpQueryObject } from '../http-query.js';
+import { HttpUrlParameters, type HttpUrlParametersObject } from '../http-url-parameters.js';
+import type { HttpMethod } from '../types.js';
+/** Only one type at a time is supported. If multiple are set, behaviour is undefined */
+export type HttpRequestBody = {
+    text?: string;
+    json?: UndefinableJson;
+    form?: HttpForm;
+    formData?: FormData;
+    binary?: Uint8Array | Blob | ReadableStream<Uint8Array>;
+};
+export type HttpRequestAuthorization = {
+    basic?: {
+        username: string;
+        password: string;
+    };
+    bearer?: string;
+    token?: string;
+};
+export type HttpFormDataObjectValue = string | number | boolean | Uint8Array | Blob;
+export type HttpFormDataObject = Record<string, OneOrMany<HttpFormDataObjectValue>>;
+export type HttpClientRequestOptions = Partial<TypedOmit<HttpClientRequest, 'url' | 'method' | 'abortSignal' | 'abort' | 'headers' | 'query' | 'body'>> & {
+    urlParameter?: HttpUrlParametersObject | HttpUrlParameters;
+    headers?: HttpHeadersObject | HttpHeaders;
+    query?: HttpQueryObject | HttpQuery;
+    credentials?: HttpRequestCredentials;
+    authorization?: HttpRequestAuthorization;
+    body?: TypedOmit<HttpRequestBody, 'form' | 'formData'> & {
+        form?: HttpFormObject | HttpForm;
+        formData?: HttpFormDataObject | FormData;
+    };
+    abortSignal?: CancellationSignal;
+};
+export type HttpRequestCredentials = 'omit' | 'same-origin' | 'include';
+export type HttpClientRequestObject = HttpClientRequestOptions & {
+    url: string;
+    method?: HttpMethod;
+};
+export declare class HttpClientRequest implements Disposable {
+    #private;
+    url: string;
+    method: HttpMethod;
+    headers: HttpHeaders;
+    /**
+     * Automatically maps parameters to `urlParameters`, `query` and `body`
+     * depending on whether the `url` has parameters specified, the request `method`
+     * and if there is already a `body` or not
+     * @see mapParameters
+     * @see mapParametersToUrl
+     * @see mapParametersToQuery
+     * @see mapParametersToBody
+     */
+    parameters: UndefinableJsonObject | undefined;
+    /** If false, disable parameters mapping completely */
+    mapParameters: boolean;
+    mapParametersToUrl: boolean;
+    mapParametersToQuery: boolean;
+    mapParametersToBody: boolean;
+    /**
+     * Parameters for url
+     * @example
+     * {
+     *   url: 'http://domain.tld/users/:userId',
+     *   urlParameters: { userId: 123 }
+     * }
+     * // -> http://domain.tld/users/123
+     */
+    urlParameters: HttpUrlParameters;
+    /**
+     * Separator for url parameter array
+     * @default ','
+     * @example
+     * {
+     *   url: 'http://domain.tld/users/:userId',
+     *   urlParameters: { userId: [123, 456] },
+     *   urlParametersSeparator: ';'
+     * }
+     * // -> http://domain.tld/users/123;456
+     */
+    urlParametersSeparator: string;
+    /**
+     * Url query
+     * @example
+     * {
+     *   url: 'http://domain.tld/search',
+     *   query: { categories: [3, 8], limit: 10 }
+     * }
+     * // -> http://domain.tld/search?categories=3&categories=8&limit=10
+     */
+    query: HttpQuery;
+    credentials: HttpRequestCredentials | undefined;
+    authorization: HttpRequestAuthorization | undefined;
+    body: HttpRequestBody | undefined;
+    /**
+     * Request timeout in milliseconds
+     * @default 30000
+     */
+    timeout: number;
+    throwOnNon200: boolean;
+    /**
+     * Can be used to store data for middleware etc.
+     *
+     * will not be used for actual request
+     */
+    context: Record<string>;
+    /**
+     * Can be used to cancel the request. Throws HttpError
+     */
+    get abortSignal(): CancellationSignal;
+    constructor(url: string, method?: HttpMethod, options?: HttpClientRequestOptions);
+    constructor(requestObject: HttpClientRequestObject);
+    [dispose](): void;
+    /** Abort the request */
+    abort(): void;
+    clone(): HttpClientRequest;
+    asObject(): HttpClientRequestObject;
+}

package/http/client/http-client-response.d.ts

@@ -0,0 +1,28 @@
+import type { TypedOmit } from '../../types.js';
+import { HttpBody, type HttpBodySource } from '../http-body.js';
+import { HttpHeaders, type HttpHeadersObject } from '../http-headers.js';
+import type { HttpClientRequest, HttpClientRequestObject } from './http-client-request.js';
+export type HttpClientResponseObject = TypedOmit<HttpClientResponse, 'hasBody' | 'request' | 'headers' | 'close' | 'asObject'> & {
+    request: HttpClientRequestObject;
+    headers: HttpHeadersObject;
+};
+export type HttpClientResponseOptions = {
+    request: HttpClientRequest;
+    statusCode: number;
+    statusMessage: string | null;
+    headers: HttpHeadersObject | HttpHeaders;
+    body: HttpBody | HttpBodySource;
+    closeHandler: () => void;
+};
+export declare class HttpClientResponse {
+    private readonly closeHandler;
+    readonly request: HttpClientRequest;
+    readonly statusCode: number;
+    readonly statusMessage: string | null;
+    readonly headers: HttpHeaders;
+    readonly body: HttpBody;
+    get hasBody(): boolean;
+    constructor(options: HttpClientResponseOptions);
+    close(): void;
+    asObject(): HttpClientResponseObject;
+}

package/http/client/http-client.d.ts

@@ -0,0 +1,56 @@
+import { resolveArgumentType } from '../../injector/index.js';
+import type { Resolvable } from '../../injector/interfaces.js';
+import type { OneOrMany, UndefinableJson } from '../../types.js';
+import type { HttpMethod, HttpValue } from '../types.js';
+import type { ReadBodyOptions } from '../utils.js';
+import { HttpClientOptions } from './http-client-options.js';
+import type { HttpClientRequestOptions } from './http-client-request.js';
+import { HttpClientRequest } from './http-client-request.js';
+import type { HttpClientResponse } from './http-client-response.js';
+import type { HttpClientMiddleware } from './middleware.js';
+export type HttpClientArgument = HttpClientOptions;
+export declare class HttpClient implements Resolvable<HttpClientArgument> {
+    private readonly adapter;
+    private readonly middleware;
+    private readonly headers;
+    private readonly internalStartMiddleware;
+    private readonly internalEndMiddleware;
+    private composedMiddleware;
+    readonly options: HttpClientOptions;
+    readonly [resolveArgumentType]: HttpClientOptions;
+    constructor();
+    addMiddleware(middleware: HttpClientMiddleware): void;
+    setDefaultHeader(name: string, value: OneOrMany<HttpValue>): void;
+    deleteDefaultHeader(name: string): void;
+    head(url: string, options?: HttpClientRequestOptions): Promise<HttpClientResponse>;
+    get(url: string, options?: HttpClientRequestOptions): Promise<HttpClientResponse>;
+    getText(url: string, options?: HttpClientRequestOptions): Promise<string>;
+    getJson<T = UndefinableJson>(url: string, options?: HttpClientRequestOptions): Promise<T>;
+    getBuffer(url: string, options?: HttpClientRequestOptions): Promise<Uint8Array>;
+    getStream(url: string, options?: HttpClientRequestOptions): ReadableStream<string> | ReadableStream<Uint8Array>;
+    getTextStream(url: string, options?: HttpClientRequestOptions): ReadableStream<string>;
+    getBinaryStream(url: string, options?: HttpClientRequestOptions, readOptions?: ReadBodyOptions): ReadableStream<Uint8Array>;
+    post(url: string, options?: HttpClientRequestOptions): Promise<HttpClientResponse>;
+    postText(url: string, options?: HttpClientRequestOptions): Promise<string>;
+    postJson<T = UndefinableJson>(url: string, options?: HttpClientRequestOptions): Promise<T>;
+    postBuffer(url: string, options?: HttpClientRequestOptions): Promise<Uint8Array>;
+    postStream(url: string, options?: HttpClientRequestOptions): ReadableStream<Uint8Array>;
+    put(url: string, options?: HttpClientRequestOptions): Promise<HttpClientResponse>;
+    putText(url: string, options?: HttpClientRequestOptions): Promise<string>;
+    putJson<T = UndefinableJson>(url: string, options?: HttpClientRequestOptions): Promise<T>;
+    putBuffer(url: string, options?: HttpClientRequestOptions): Promise<Uint8Array>;
+    putStream(url: string, options?: HttpClientRequestOptions): ReadableStream<Uint8Array>;
+    patch(url: string, options?: HttpClientRequestOptions): Promise<HttpClientResponse>;
+    patchText(url: string, options?: HttpClientRequestOptions): Promise<string>;
+    patchJson<T = UndefinableJson>(url: string, options?: HttpClientRequestOptions): Promise<T>;
+    patchBuffer(url: string, options?: HttpClientRequestOptions): Promise<Uint8Array>;
+    patchStream(url: string, options?: HttpClientRequestOptions): ReadableStream<Uint8Array>;
+    delete(url: string, options?: HttpClientRequestOptions): Promise<HttpClientResponse>;
+    deleteText(url: string, options?: HttpClientRequestOptions): Promise<string>;
+    deleteJson<T = UndefinableJson>(url: string, options?: HttpClientRequestOptions): Promise<T>;
+    deleteBuffer(url: string, options?: HttpClientRequestOptions): Promise<Uint8Array>;
+    deleteStream(url: string, options?: HttpClientRequestOptions): ReadableStream<Uint8Array>;
+    request(method: HttpMethod, url: string, options?: HttpClientRequestOptions): Promise<HttpClientResponse>;
+    rawRequest(request: HttpClientRequest): Promise<HttpClientResponse>;
+    private updateMiddleware;
+}