@tstdl/base 0.92.124 → 0.92.126

package/types/enumerable/async-enumerable.d.ts

@@ -1,78 +0,0 @@
-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/types/enumerable/enumerable.d.ts

@@ -1,63 +0,0 @@
-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/types/enumeration/enumeration.d.ts

@@ -1,5 +0,0 @@
-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/types/errors/errors.localization.d.ts

@@ -1,53 +0,0 @@
-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/types/errors/not-supported.error.d.ts

@@ -1,7 +0,0 @@
-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/types/examples/api/authentication.d.ts

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

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

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

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

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

package/types/examples/api/streaming.d.ts

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

package/types/examples/browser/basic.d.ts

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

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

@@ -1,21 +0,0 @@
-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/types/examples/http/client.d.ts

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

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

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

package/types/examples/orm/schemas.d.ts

@@ -1,3 +0,0 @@
-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/types/examples/orm/user.model.d.ts

@@ -1,13 +0,0 @@
-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/types/examples/pdf/templates/hello-name.d.ts

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

package/types/examples/reflection/basic.d.ts

@@ -1,11 +0,0 @@
-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/types/examples/template/templates/hello-jsx.d.ts

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

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

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

package/types/function/log.d.ts

@@ -1,8 +0,0 @@
-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/types/http/client/adapters/undici.adapter.d.ts

@@ -1,20 +0,0 @@
-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/types/http/client/http-client-request.d.ts

@@ -1,122 +0,0 @@
-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/types/http/client/http-client-response.d.ts

@@ -1,28 +0,0 @@
-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/types/http/client/http-client.d.ts

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

package/types/http/client/middleware.d.ts

@@ -1,10 +0,0 @@
-import type { AsyncMiddleware, AsyncMiddlewareNext, ComposedAsyncMiddleware } from '../../../utils/middleware.js';
-import type { HttpClientRequest } from './http-client-request.js';
-import type { HttpClientResponse } from './http-client-response.js';
-export type HttpClientMiddlewareContext = {
-    request: HttpClientRequest;
-    response?: HttpClientResponse;
-};
-export type HttpClientMiddleware = AsyncMiddleware<HttpClientMiddlewareContext>;
-export type HttpClientMiddlewareNext = AsyncMiddlewareNext;
-export type ComposedHttpClientMiddleware = ComposedAsyncMiddleware<HttpClientMiddlewareContext>;

package/types/http/client/module.d.ts

@@ -1,12 +0,0 @@
-import type { OneOrMany, Type } from '../../../types.js';
-import { HttpClientOptions } from './http-client-options.js';
-import { HttpClientAdapter } from './http-client.adapter.js';
-import type { HttpClientMiddleware } from './middleware.js';
-export type HttpClientModuleConfig = HttpClientOptions & {
-    adapter?: Type<HttpClientAdapter>;
-    /**
-     * Middlewares to add
-     */
-    middleware?: OneOrMany<HttpClientMiddleware>;
-};
-export declare function configureHttpClient({ adapter, middleware, ...rest }: HttpClientModuleConfig): void;

package/types/http/client/tokens.d.ts

@@ -1,2 +0,0 @@
-import type { HttpClientMiddleware } from './middleware.js';
-export declare const HTTP_CLIENT_MIDDLEWARE: import("../../../injector/token.js").InjectionToken<HttpClientMiddleware, never>;

package/types/http/http-body.d.ts

@@ -1,21 +0,0 @@
-import type { UndefinableJson } from '../../types.js';
-import type { AnyIterable } from '../../utils/any-iterable-iterator.js';
-import type { HttpHeaders } from './http-headers.js';
-import type { ReadBodyOptions } from './utils.js';
-export type HttpBodySource = undefined | Uint8Array | Blob | AnyIterable<Uint8Array> | ReadableStream<Uint8Array>;
-export declare class HttpBody {
-    private readonly body;
-    private readonly headers;
-    private bodyAlreadyRead;
-    get available(): boolean;
-    get byteLength(): number | undefined;
-    constructor(body: HttpBodySource, headers: HttpHeaders);
-    readAsBuffer(options?: ReadBodyOptions): Promise<Uint8Array>;
-    readAsText(options?: ReadBodyOptions): Promise<string>;
-    readAsJson<T = UndefinableJson>(options?: ReadBodyOptions): Promise<T>;
-    read(options?: ReadBodyOptions): Promise<string | UndefinableJson | Uint8Array>;
-    readAsBinaryStream(options?: ReadBodyOptions): ReadableStream<Uint8Array>;
-    readAsTextStream(options?: ReadBodyOptions): ReadableStream<string>;
-    readAsStream(options?: ReadBodyOptions): ReadableStream<string> | ReadableStream<Uint8Array>;
-    private prepareBodyRead;
-}