@tstdl/base 0.92.122 → 0.92.124

package/types/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/types/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/types/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;
+}

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

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

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

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

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

package/types/http/http-value-map.d.ts

@@ -0,0 +1,36 @@
+import type { OneOrMany, Record } from '../../types.js';
+import type { HttpValue, NormalizedHttpValue, NormalizedHttpValueObject } from './types.js';
+export type HttpValueMapInput = Record<string, OneOrMany<HttpValue> | undefined> | Iterable<[string, OneOrMany<HttpValue> | undefined]>;
+export declare abstract class HttpValueMap<TThis extends HttpValueMap<any>> implements Iterable<[string, OneOrMany<HttpValue>]> {
+    private readonly valueType;
+    private readonly caseInsensitive;
+    private readonly map;
+    constructor(valueType: string, caseInsensitive: boolean, input?: HttpValueMapInput);
+    /** check if entry is available */
+    has(key: string): boolean;
+    /** get value. Throws if entry not set */
+    get(key: string): OneOrMany<HttpValue>;
+    /** try to get value */
+    tryGet(key: string): OneOrMany<HttpValue> | undefined;
+    /** get single value, throws if multiple values are set */
+    getSingle(key: string): HttpValue;
+    /** try to get single value, throws if multiple values are set */
+    tryGetSingle(key: string): HttpValue | undefined;
+    /** replace entry */
+    set(key: string, value: OneOrMany<HttpValue> | undefined): void;
+    /** set entry if missing */
+    setIfMissing(key: string, value: OneOrMany<HttpValue> | undefined): void;
+    setMany(input: HttpValueMapInput): void;
+    /** add value to existing entry or create new entry */
+    append(key: string, value: OneOrMany<HttpValue>): void;
+    /** remove entry */
+    remove(key: string): void;
+    /** remove all entries */
+    clear(): void;
+    asObject(): Record<string, OneOrMany<HttpValue>>;
+    asNormalizedObject(): NormalizedHttpValueObject;
+    normalizedEntries(): Iterable<[string, OneOrMany<NormalizedHttpValue>]>;
+    [Symbol.iterator](): Iterator<[string, OneOrMany<HttpValue>]>;
+    private normalizeKey;
+    abstract clone(): TThis;
+}

package/types/http/http.error.d.ts

@@ -0,0 +1,28 @@
+import type { TypedOmit, UndefinableJson } from '../../types.js';
+import type { ErrorExtraInfo } from '../../utils/format-error.js';
+import { CustomError } from '../errors/custom.error.js';
+import type { HttpClientRequest, HttpClientRequestObject, HttpClientResponse, HttpClientResponseObject } from './client/index.js';
+export declare enum HttpErrorReason {
+    Unknown = "Unknown",
+    Cancelled = "Cancelled",
+    Network = "Network",
+    InvalidRequest = "InvalidRequest",
+    StatusCode = "StatusCode",
+    /** Valid http response containing an error */
+    ErrorResponse = "ErrorResponse",
+    /** Invalid http response */
+    ResponseError = "ResponseError",
+    Timeout = "Timeout"
+}
+export declare class HttpError extends CustomError implements ErrorExtraInfo {
+    static readonly errorName = "HttpError";
+    readonly reason: HttpErrorReason;
+    readonly request: HttpClientRequestObject;
+    readonly response: TypedOmit<HttpClientResponseObject, 'request'> | undefined;
+    readonly responseBody: UndefinableJson | Uint8Array;
+    readonly requestInstance: HttpClientRequest;
+    readonly responseInstance: HttpClientResponse | undefined;
+    constructor(reason: HttpErrorReason, request: HttpClientRequest, response?: HttpClientResponse, responseBody?: UndefinableJson | Uint8Array, cause?: Error | string);
+    static create(reason: HttpErrorReason, request: HttpClientRequest, response: HttpClientResponse | undefined, cause?: Error | string): Promise<HttpError>;
+    getExtraInfo(): UndefinableJson | undefined;
+}

package/types/http/server/http-server-request.d.ts

@@ -0,0 +1,23 @@
+import type { StringMap } from '../../../types.js';
+import { CookieParser } from '../cookie-parser.js';
+import type { HttpBodySource } from '../http-body.js';
+import { HttpBody } from '../http-body.js';
+import type { HttpHeaders } from '../http-headers.js';
+import type { HttpQuery } from '../http-query.js';
+import type { HttpMethod } from '../types.js';
+export type HttpServerRequestObject = Pick<HttpServerRequest, 'url' | 'method' | 'headers' | 'query' | 'ip'> & {
+    body: HttpBody | HttpBodySource;
+    context?: StringMap;
+};
+export declare class HttpServerRequest {
+    readonly url: URL;
+    readonly method: HttpMethod;
+    readonly headers: HttpHeaders;
+    readonly cookies: CookieParser;
+    readonly query: HttpQuery;
+    readonly body: HttpBody;
+    readonly ip: string;
+    context: StringMap;
+    get hasBody(): boolean;
+    constructor(data: HttpServerRequestObject);
+}

package/types/http/server/http-server-response.d.ts

@@ -0,0 +1,38 @@
+import type { SetCookieOptions } from '../../../cookie/cookie.js';
+import type { ServerSentEventsSource } from '../../../sse/server-sent-events-source.js';
+import type { Record } from '../../../types.js';
+import type { HttpHeadersInput } from '../http-headers.js';
+import { HttpHeaders } from '../http-headers.js';
+export type SetCookieObject = SetCookieOptions & {
+    value: string;
+};
+export type HttpServerResponseOptions = {
+    statusCode?: number | undefined;
+    statusMessage?: string | undefined;
+    headers?: HttpHeadersInput | HttpHeaders;
+    cookies?: Record<string, SetCookieObject>;
+    body?: {
+        stream?: ReadableStream<Uint8Array>;
+        buffer?: Uint8Array;
+        text?: string;
+        json?: unknown;
+        events?: ServerSentEventsSource;
+    };
+};
+export declare class HttpServerResponse {
+    statusCode: number | undefined;
+    statusMessage: string | undefined;
+    headers: HttpHeaders;
+    body: undefined | {
+        stream?: ReadableStream<Uint8Array>;
+        buffer?: Uint8Array;
+        text?: string;
+        json?: unknown;
+        events?: ServerSentEventsSource;
+    };
+    constructor(response?: HttpServerResponseOptions);
+    static fromObject(options?: HttpServerResponseOptions): HttpServerResponse;
+    static redirect(url: string, options?: HttpServerResponseOptions): HttpServerResponse;
+    update(options: HttpServerResponseOptions): void;
+}
+export declare function redirect(url: string, options?: HttpServerResponseOptions): HttpServerResponse;

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

@@ -0,0 +1,16 @@
+import type { AsyncDisposable } from '../../../disposable/index.js';
+import { disposeAsync } from '../../../disposable/index.js';
+import type { HttpServerRequest, HttpServerResponse } from '../../../http/server/index.js';
+export type HttpServerRequestContext<Context = unknown> = {
+    request: HttpServerRequest;
+    context: Context;
+    respond(response: HttpServerResponse): Promise<void>;
+    close(): Promise<void>;
+};
+export declare abstract class HttpServer<Context = unknown> implements AsyncIterable<HttpServerRequestContext<Context>>, AsyncDisposable {
+    abstract readonly connectedSocketsCount: number;
+    abstract listen(port: number): Promise<void>;
+    abstract close(timeout: number): Promise<void>;
+    abstract [Symbol.asyncIterator](): AsyncIterator<HttpServerRequestContext<Context>>;
+    abstract [disposeAsync](): Promise<void>;
+}

package/types/http/server/node/node-http-server.d.ts

@@ -0,0 +1,22 @@
+import * as Http from 'node:http';
+import { disposeAsync, type AsyncDisposable } from '../../../../disposable/index.js';
+import { Logger } from '../../../../logger/index.js';
+import { HttpServer, type HttpServerRequestContext } from '../http-server.js';
+export type NodeHttpServerContext = {
+    nodeRequest: Http.IncomingMessage;
+    nodeResponse: Http.ServerResponse;
+};
+export declare class NodeHttpServer extends HttpServer<NodeHttpServerContext> implements AsyncDisposable {
+    private readonly httpServer;
+    private readonly sockets;
+    private readonly requestIterable;
+    private readonly logger;
+    private untrackConnectedSockets?;
+    get connectedSocketsCount(): number;
+    constructor(logger: Logger);
+    [disposeAsync](): Promise<void>;
+    listen(port: number): Promise<void>;
+    close(timeout: number): Promise<void>;
+    [Symbol.asyncIterator](): AsyncIterator<HttpServerRequestContext<NodeHttpServerContext>>;
+    private handleRequest;
+}

package/types/http/types.d.ts

@@ -0,0 +1,10 @@
+import type { OneOrMany, WritableOneOrMany } from '../../types.js';
+export type HttpValue = string | number | boolean | null;
+export type NormalizedHttpValue = string;
+export type HttpValueObject = Record<string, OneOrMany<HttpValue>>;
+export type NormalizedHttpValueObject = Record<string, WritableOneOrMany<string>>;
+export type HttpMethod = 'HEAD' | 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE' | 'OPTIONS';
+export declare function normalizeHttpValue(value: OneOrMany<HttpValue>): WritableOneOrMany<string>;
+export declare function normalizeSingleHttpValue(value: HttpValue): string;
+export declare function denormalizeHttpValue(value: OneOrMany<HttpValue>): OneOrMany<HttpValue>;
+export declare function denormlizeSingleHttpValue(value: HttpValue): HttpValue;

package/types/http/utils.d.ts

@@ -0,0 +1,18 @@
+import type { HttpHeaders } from '../../http/http-headers.js';
+import type { UndefinableJson } from '../../types.js';
+import type { AnyIterable } from '../../utils/any-iterable-iterator.js';
+type Body = Uint8Array | Blob | AnyIterable<Uint8Array> | ReadableStream<Uint8Array>;
+export type ReadBodyOptions = {
+    maxBytes?: number;
+};
+export type ReadBodyAsJsonOptions = ReadBodyOptions & {
+    fallbackToText?: boolean;
+};
+export declare function readBodyAsBinaryStream(body: Body, headers: HttpHeaders, options?: ReadBodyOptions): ReadableStream<Uint8Array>;
+export declare function readBodyAsBuffer(body: Body, headers: HttpHeaders, options?: ReadBodyOptions): Promise<Uint8Array>;
+export declare function readBodyAsText(body: Body, headers: HttpHeaders, options?: ReadBodyOptions): Promise<string>;
+export declare function readBodyAsTextStream(body: Body, headers: HttpHeaders, options?: ReadBodyOptions): ReadableStream<string>;
+export declare function readBodyAsJson(body: Body, headers: HttpHeaders, options?: ReadBodyAsJsonOptions): Promise<UndefinableJson>;
+export declare function readBody(body: Body, headers: HttpHeaders, options?: ReadBodyOptions): Promise<string | UndefinableJson | Uint8Array>;
+export declare function readBodyAsStream(body: Body, headers: HttpHeaders, options?: ReadBodyOptions): ReadableStream<string> | ReadableStream<Uint8Array>;
+export {};

package/types/image-service/imgproxy/imgproxy-image-service.d.ts

@@ -0,0 +1,24 @@
+import { resolveArgumentType } from '../../../injector/index.js';
+import type { Resolvable } from '../../../injector/interfaces.js';
+import type { ImageOptions } from '../image-service.js';
+import { ImageService } from '../image-service.js';
+export type ImgproxyImageServiceConfig = {
+    endpoint: string;
+    key: string;
+    salt: string;
+    signatureSize: number;
+};
+export declare const IMGPROXY_IMAGE_SERVICE_CONFIG: import("../../../injector/index.js").InjectionToken<ImgproxyImageServiceConfig, never>;
+export declare class ImgproxyImageService extends ImageService implements Resolvable<ImgproxyImageServiceConfig> {
+    #private;
+    readonly endpoint: string;
+    readonly [resolveArgumentType]: ImgproxyImageServiceConfig;
+    constructor(endpoint: string, key: string, salt: string, signatureSize: number);
+    getUrl(resourceUri: string, options?: ImageOptions): Promise<string>;
+}
+/**
+ * configure imgproxy image service module
+ * @param defaultConfig default configuration
+ * @param register whether to register for {@link ImageService}
+ */
+export declare function configureImgproxyImageService(defaultConfig: ImgproxyImageServiceConfig, register?: boolean): void;

package/types/index.d.ts

@@ -1,2 +1,8 @@
-export type * from './geo-json.js';
-export type * from './tagged.js';
+/**
+ * Core of tstdl
+ *
+ * @module Core
+ */
+export * from './core.js';
+export * from './import.js';
+export * from './require.js';

package/types/injector/decorators.d.ts

@@ -0,0 +1,82 @@
+import { type Decorator } from '../../reflection/index.js';
+import type { Constructor, OneOrMany, Record, Simplify, TypedOmit } from '../../types.js';
+import type { Provider } from './provider.js';
+import type { InjectionToken } from './token.js';
+import type { InjectMetadata } from './type-info.js';
+import type { ArgumentProvider, ForwardRefInjectionToken, Mapper, RegistrationOptions } from './types.js';
+export type InjectDecorator = Decorator<'accessor' | 'constructorParameter'>;
+export type InjectableOptions<T, A, C extends Record = Record> = RegistrationOptions<T, A, C> & {
+    /** Aliases (tokens) for the class. Useful for example for circular dependencies when you can't use the class itself as a token */
+    alias?: OneOrMany<InjectionToken>;
+    /** Custom provider. Useful for example if initialization is required */
+    provider?: Provider<T, A, C>;
+};
+export type InjectableOptionsWithoutLifecycle<T, A> = Simplify<TypedOmit<InjectableOptions<T, A>, 'lifecycle'>>;
+/**
+ * Helper decorator to replace a class definition with an other
+ * can be used for example to type external classes with the {@link Resolvable} interface
+ * @param constructor class to replace with
+ */
+export declare function ReplaceClass<T>(constructor: Constructor<T>): ClassDecorator;
+/**
+ * Globally registers the class for injection
+ * @param options registration options
+ */
+export declare function Injectable<T = any, A = any, C extends Record = Record>(options?: InjectableOptions<T, A, C>): ClassDecorator;
+/**
+ * Registers the class in the global container with singleton lifecycle. Decorated class is not modified in any way
+ * @param options registration options
+ */
+export declare function Singleton<T = any, A = any>(options?: InjectableOptionsWithoutLifecycle<T, A>): ClassDecorator;
+/**
+ * Registers the class in the global container with scoped lifecycle. Decorated class is not modified in any way
+ * @param options registration options
+ */
+export declare function Scoped<T = any, A = any>(lifecycle: 'resolution' | 'injector', options?: InjectableOptionsWithoutLifecycle<T, A>): ClassDecorator;
+/**
+ * Sets the token used to resolve the parameter
+ * @param token token used for resolving
+ * @param argument resolve argument
+ * @param mapperOrKey map the resolved value. If {@link PropertyKey} is provided, that property of the resolved value will be injected
+ */
+export declare function Inject<T, A>(token?: InjectionToken<T, A>, argument?: A, mapperOrKey?: Mapper<T> | keyof T): InjectDecorator;
+/**
+ * Sets the token used to resolve the parameter. Resolves all providers
+ * @param token token used for resolving
+ * @param argument resolve argument
+ * @param mapperOrKey map the resolved value. If {@link PropertyKey} is provided, that property of the resolved value will be injected
+ */
+export declare function InjectAll<T, A>(token?: InjectionToken<T, A>, argument?: A, mapperOrKey?: Mapper<T> | keyof T): InjectDecorator;
+/**
+ * Sets the argument used for resolving the parameter
+ * @param argument
+ */
+export declare function ResolveArg<T>(argument: T): InjectDecorator;
+/**
+ * Sets the argument provider used for resolving the parameter
+ * @param argumentProvider
+ */
+export declare function ResolveArgProvider<T>(argumentProvider: ArgumentProvider<T>): InjectDecorator;
+/**
+ * Injects the argument used for resolving the class instead of resolving the parameter
+ * @param argument
+ * @param mapperOrKey map the resolved value. If {@link PropertyKey} is provided, that property of the resolved value will be injected
+ */
+export declare function InjectArg<T>(mapperOrKey?: Mapper<T> | keyof T): InjectDecorator;
+/**
+ * Sets the argument used for resolving the decorated parameter to the the argument provided for parent resolve
+ * @param mapper map the argument (for example to select a property instead of forwarding the whole object)
+ */
+export declare function ForwardArg(): InjectDecorator;
+export declare function ForwardArg<T, U>(mapper: Mapper<T, U>): InjectDecorator;
+/**
+ * Marks the argument as optional
+ * @param argument
+ */
+export declare function Optional(): InjectDecorator;
+/**
+ * Resolve using ForwardRef to handle circular dependencies. Resolve logic derefs all ForwardRefs which are direct properties of resolved instances automatically
+ * @param token token to resolve
+ * @param argument resolve argument
+ */
+export declare function ForwardRef<T extends object, A>(token?: ForwardRefInjectionToken<T>, argument?: A, options?: Pick<InjectMetadata, 'forwardRefTypeHint'>): InjectDecorator;