@opra/http 1.0.0-beta.3

package/esm/utils/convert-to-headers.js

@@ -0,0 +1,60 @@
+import { ARRAY_FIELD, COMMA_DELIMITED_FIELD, matchKnownFields, SEMICOLON_DELIMITED_FIELD, } from './match-known-fields.js';
+export function convertToHeaders(src, dst, joinDuplicateHeaders) {
+    for (let n = 0; n < src.length; n += 2) {
+        addHeaderLine(src[n], src[n + 1], dst, joinDuplicateHeaders);
+    }
+    return dst;
+}
+export function convertToHeadersDistinct(src, dst) {
+    const count = src.length % 2;
+    for (let n = 0; n < count; n += 2) {
+        addHeaderLineDistinct(src[n], src[n + 1], dst);
+    }
+    return dst;
+}
+function addHeaderLine(field, value, dest, joinDuplicateHeaders) {
+    if (value == null)
+        return;
+    field = field.toLowerCase();
+    const [, flag] = matchKnownFields(field);
+    // comma(0) or semicolon(2) delimited field
+    if (flag === COMMA_DELIMITED_FIELD || flag === SEMICOLON_DELIMITED_FIELD) {
+        // Make a delimited list
+        if (typeof dest[field] === 'string') {
+            dest[field] += (flag === COMMA_DELIMITED_FIELD ? ', ' : '; ') + value;
+        }
+        else {
+            dest[field] = value;
+        }
+    }
+    else if (flag === ARRAY_FIELD) {
+        // Array header -- only Set-Cookie at the moment
+        if (dest['set-cookie'] !== undefined) {
+            dest['set-cookie'].push(value);
+        }
+        else {
+            dest['set-cookie'] = [value];
+        }
+    }
+    else if (joinDuplicateHeaders) {
+        if (dest[field] === undefined) {
+            dest[field] = value;
+        }
+        else {
+            dest[field] += ', ' + value;
+        }
+    }
+    else if (dest[field] === undefined) {
+        // Drop duplicates
+        dest[field] = value;
+    }
+}
+function addHeaderLineDistinct(field, value, dest) {
+    field = field.toLowerCase();
+    if (!dest[field]) {
+        dest[field] = [value];
+    }
+    else {
+        dest[field].push(value);
+    }
+}

package/esm/utils/convert-to-raw-headers.js

@@ -0,0 +1,20 @@
+import { ARRAY_FIELD, COMMA_DELIMITED_FIELD, matchKnownFields, SEMICOLON_DELIMITED_FIELD, } from './match-known-fields.js';
+export function convertToRawHeaders(src) {
+    return Object.entries(src).reduce((a, [field, v]) => {
+        const [name, flag] = matchKnownFields(field);
+        if (flag === ARRAY_FIELD) {
+            if (Array.isArray(v))
+                v.forEach(x => a.push(name, String(x)));
+            else
+                a.push(name, String(v));
+            return a;
+        }
+        if (flag === COMMA_DELIMITED_FIELD || flag === SEMICOLON_DELIMITED_FIELD) {
+            v = Array.isArray(v) ? v.join(flag === COMMA_DELIMITED_FIELD ? ', ' : '; ') : String(v);
+        }
+        else
+            v = Array.isArray(v) ? String(v[0]) : String(v);
+        a.push(name, v);
+        return a;
+    }, []);
+}

package/esm/utils/match-known-fields.js

@@ -0,0 +1,45 @@
+import { HttpHeaderCodes } from '@opra/common';
+export const NO_DUPLICATES_FIELD = 0;
+export const COMMA_DELIMITED_FIELD = 1;
+export const SEMICOLON_DELIMITED_FIELD = 2;
+export const ARRAY_FIELD = 3;
+const ARRAY_HEADERS = ['set-cookie'];
+const NO_DUPLICATES_HEADERS = [
+    'age',
+    'from',
+    'etag',
+    'server',
+    'referer',
+    'referrer',
+    'expires',
+    'location',
+    'user-agent',
+    'retry-after',
+    'content-type',
+    'content-length',
+    'max-forwards',
+    'last-modified',
+    'authorization',
+    'proxy-authorization',
+    'if-modified-since',
+    'if-unmodified-since',
+];
+const SEMICOLON_DELIMITED_HEADERS = ['cookie'];
+const KNOWN_FIELDS = Object.values(HttpHeaderCodes).reduce((o, k) => {
+    const n = k.toLowerCase();
+    o[n] = [
+        k,
+        NO_DUPLICATES_HEADERS.includes(n)
+            ? NO_DUPLICATES_FIELD
+            : ARRAY_HEADERS.includes(n)
+                ? ARRAY_FIELD
+                : SEMICOLON_DELIMITED_HEADERS.includes(n)
+                    ? SEMICOLON_DELIMITED_FIELD
+                    : COMMA_DELIMITED_FIELD,
+    ];
+    return o;
+}, {});
+export function matchKnownFields(field) {
+    const x = KNOWN_FIELDS[field.toLowerCase()];
+    return x ? x : [field, COMMA_DELIMITED_FIELD];
+}

package/esm/utils/wrap-exception.js

@@ -0,0 +1,30 @@
+import { BadRequestError, FailedDependencyError, ForbiddenError, InternalServerError, MethodNotAllowedError, NotAcceptableError, NotFoundError, OpraHttpError, UnauthorizedError, UnprocessableEntityError, } from '@opra/common';
+export function wrapException(error) {
+    if (error instanceof OpraHttpError)
+        return error;
+    let status = 500;
+    if (typeof error.status === 'number')
+        status = error.status;
+    else if (typeof error.getStatus === 'function')
+        status = error.getStatus();
+    switch (status) {
+        case 400:
+            return new BadRequestError(error);
+        case 401:
+            return new UnauthorizedError(error);
+        case 403:
+            return new ForbiddenError(error);
+        case 404:
+            return new NotFoundError(error);
+        case 405:
+            return new MethodNotAllowedError(error);
+        case 406:
+            return new NotAcceptableError(error);
+        case 422:
+            return new UnprocessableEntityError(error);
+        case 424:
+            return new FailedDependencyError(error);
+        default:
+            return new InternalServerError(error);
+    }
+}

package/i18n/en/error.json

@@ -0,0 +1,21 @@
+{
+  "BAD_REQUEST": "Bad request",
+  "FAILED_DEPENDENCY": "The request failed due to failure of a previous request",
+  "FORBIDDEN": "You are not authorized to perform this action",
+  "INTERNAL_SERVER_ERROR": "Internal server error",
+  "METHOD_NOT_ALLOWED": "Method not allowed",
+  "NOT_ACCEPTABLE": "Not acceptable",
+  "NOT_FOUND": "Not found",
+  "UNAUTHORIZED": "You have not been authenticated to perform this action",
+  "UNPROCESSABLE_ENTITY": "Unprocessable entity",
+  "REQUEST_VALIDATION": "Request validation failed",
+  "RESPONSE_VALIDATION": "Response validation failed",
+  "RESOURCE_NOT_AVAILABLE": "Resource is not available or you dont have access",
+  "RESOURCE_CONFLICT": "There is already an other {{resource}} resource with same field values ({{fields}})",
+  "OPERATION_FORBIDDEN": "The {{resource}} resource does not accept '{{operation}}' operations",
+  "ACTION_NOT_FOUND": "The {{resource}} resource doesn't have an action named '{{action}}'",
+  "UNKNOWN_FIELD": "Unknown field '{{field}}'",
+  "UNACCEPTED_SORT_FIELD": "Field '{{field}}' is not available for sort operation",
+  "UNACCEPTED_FILTER_FIELD": "Field '{{field}}' is not available for filter operation",
+  "UNACCEPTED_FILTER_OPERATION": "'{{operation}}' for field '{{field}}' is not available for filter operation"
+}

package/package.json

@@ -0,0 +1,89 @@
+{
+  "name": "@opra/http",
+  "version": "1.0.0-beta.3",
+  "description": "Opra Http Server Adapter",
+  "author": "Panates",
+  "license": "MIT",
+  "dependencies": {
+    "@browsery/antlr4": "^4.13.3-r1",
+    "@browsery/http-parser": "^0.5.9-r1",
+    "@browsery/type-is": "^1.6.18-r5",
+    "@opra/common": "^1.0.0-beta.3",
+    "@opra/core": "^1.0.0-beta.3",
+    "accepts": "^1.3.8",
+    "base64-stream": "^1.0.0",
+    "busboy": "^1.6.0",
+    "bytes": "^3.1.2",
+    "content-disposition": "^0.5.4",
+    "content-type": "^1.0.5",
+    "cookie": "^0.6.0",
+    "cookie-signature": "^1.2.1",
+    "cppzst": "^2.0.12",
+    "encodeurl": "^2.0.0",
+    "fast-tokenizer": "^1.7.0",
+    "fresh": "^0.5.2",
+    "iconv-lite": "^0.6.3",
+    "mime-types": "^2.1.35",
+    "node-events-async": "^1.0.0",
+    "power-tasks": "^1.11.0",
+    "putil-isplainobject": "^1.1.5",
+    "putil-merge": "^3.13.0",
+    "putil-varhelpers": "^1.6.5",
+    "range-parser": "^1.2.1",
+    "raw-body": "^3.0.0",
+    "reflect-metadata": "^0.2.2",
+    "super-fast-md5": "^1.0.3",
+    "tslib": "^2.7.0",
+    "valgen": "^5.10.0",
+    "vary": "^1.1.2"
+  },
+  "optionalDependencies": {
+    "express": "^4.x.x || ^5.x.x",
+    "fastify": "^4.x.x || ^5.x.x"
+  },
+  "type": "module",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./types/index.d.ts",
+        "default": "./esm/index.js"
+      },
+      "require": {
+        "types": "./types/index.d.cts",
+        "default": "./cjs/index.js"
+      },
+      "default": "./esm/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "main": "./cjs/index.js",
+  "module": "./esm/index.js",
+  "types": "./types/index.d.ts",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/panates/opra.git",
+    "directory": "packages/http"
+  },
+  "engines": {
+    "node": ">=16.0",
+    "npm": ">=7.0.0"
+  },
+  "files": [
+    "cjs/",
+    "esm/",
+    "i18n/",
+    "types/",
+    "LICENSE",
+    "README.md"
+  ],
+  "keywords": [
+    "opra",
+    "rest",
+    "api",
+    "openapi",
+    "http",
+    "web",
+    "swagger",
+    "raml"
+  ]
+}

package/types/express-adapter.d.ts

@@ -0,0 +1,13 @@
+import { ApiDocument, HttpController } from '@opra/common';
+import { type Application } from 'express';
+import { HttpAdapter } from './http-adapter.js';
+export declare class ExpressAdapter extends HttpAdapter {
+    readonly app: Application;
+    protected _controllerInstances: Map<HttpController, any>;
+    constructor(app: Application, document: ApiDocument, options?: HttpAdapter.Options);
+    get platform(): string;
+    close(): Promise<void>;
+    getControllerInstance<T>(controllerPath: string): T | undefined;
+    protected _initRouter(basePath?: string): void;
+    protected _createControllers(controller: HttpController): void;
+}

package/types/http-adapter.d.ts

@@ -0,0 +1,32 @@
+import { ApiDocument, HttpApi, OpraSchema } from '@opra/common';
+import { PlatformAdapter } from '@opra/core';
+import { HttpContext } from './http-context.js';
+import { HttpHandler } from './http-handler.js';
+export declare namespace HttpAdapter {
+    type NextCallback = () => Promise<void>;
+    /**
+     * @type InterceptorFunction
+     */
+    type InterceptorFunction = IHttpInterceptor['intercept'];
+    /**
+     * @interface IHttpInterceptor
+     */
+    type IHttpInterceptor = {
+        intercept(context: HttpContext, next: NextCallback): Promise<void>;
+    };
+    interface Options extends PlatformAdapter.Options {
+        basePath?: string;
+        interceptors?: (InterceptorFunction | IHttpInterceptor)[];
+    }
+}
+/**
+ *
+ * @class HttpAdapter
+ */
+export declare abstract class HttpAdapter extends PlatformAdapter {
+    readonly handler: HttpHandler;
+    readonly protocol: OpraSchema.Transport;
+    interceptors: (HttpAdapter.InterceptorFunction | HttpAdapter.IHttpInterceptor)[];
+    protected constructor(document: ApiDocument, options?: HttpAdapter.Options);
+    get api(): HttpApi;
+}

package/types/http-context.d.ts

@@ -0,0 +1,44 @@
+import { HttpController, HttpMediaType, HttpOperation, OpraSchema } from '@opra/common';
+import { ExecutionContext } from '@opra/core';
+import type { HttpAdapter } from './http-adapter';
+import { MultipartReader } from './impl/multipart-reader.js';
+import type { HttpIncoming } from './interfaces/http-incoming.interface.js';
+import type { HttpOutgoing } from './interfaces/http-outgoing.interface.js';
+export declare namespace HttpContext {
+    interface Initiator extends Omit<ExecutionContext.Initiator, 'document' | 'protocol'> {
+        adapter: HttpAdapter;
+        request: HttpIncoming;
+        response: HttpOutgoing;
+        controller?: HttpController;
+        controllerInstance?: any;
+        operation?: HttpOperation;
+        operationHandler?: Function;
+        cookies?: Record<string, any>;
+        headers?: Record<string, any>;
+        pathParams?: Record<string, any>;
+        queryParams?: Record<string, any>;
+        mediaType?: HttpMediaType;
+        body?: any;
+    }
+}
+export declare class HttpContext extends ExecutionContext {
+    protected _body?: any;
+    protected _multipartReader?: MultipartReader;
+    readonly protocol: OpraSchema.Transport;
+    readonly adapter: HttpAdapter;
+    readonly controller?: HttpController;
+    readonly controllerInstance?: any;
+    readonly operation?: HttpOperation;
+    readonly operationHandler?: Function;
+    readonly request: HttpIncoming;
+    readonly response: HttpOutgoing;
+    readonly mediaType?: HttpMediaType;
+    readonly cookies: Record<string, any>;
+    readonly headers: Record<string, any>;
+    readonly pathParams: Record<string, any>;
+    readonly queryParams: Record<string, any>;
+    constructor(init: HttpContext.Initiator);
+    get isMultipart(): boolean;
+    getMultipartReader(): Promise<MultipartReader>;
+    getBody<T>(): Promise<T>;
+}

package/types/http-handler.d.ts

@@ -0,0 +1,74 @@
+import { HttpOperationResponse, OpraException, OpraHttpError } from '@opra/common';
+import { AssetCache, kAssetCache } from '@opra/core';
+import type { HttpAdapter } from './http-adapter';
+import { HttpContext } from './http-context.js';
+/**
+ * @namespace
+ */
+export declare namespace HttpHandler {
+    /**
+     * @interface ResponseArgs
+     */
+    interface ResponseArgs {
+        statusCode: number;
+        contentType?: string;
+        operationResponse?: HttpOperationResponse;
+        body?: any;
+        projection?: string[] | '*';
+    }
+}
+/**
+ * @class HttpHandler
+ */
+export declare class HttpHandler {
+    readonly adapter: HttpAdapter;
+    protected [kAssetCache]: AssetCache;
+    onError?: (context: HttpContext, error: OpraException) => void | Promise<void>;
+    constructor(adapter: HttpAdapter);
+    /**
+     * Main http request handler
+     * @param context
+     * @protected
+     */
+    handleRequest(context: HttpContext): Promise<void>;
+    /**
+     *
+     * @param context
+     */
+    parseRequest(context: HttpContext): Promise<void>;
+    /**
+     *
+     * @param context
+     * @protected
+     */
+    protected _parseParameters(context: HttpContext): Promise<void>;
+    /**
+     *
+     * @param context
+     * @protected
+     */
+    protected _parseContentType(context: HttpContext): Promise<void>;
+    /**
+     *
+     * @param context
+     * @protected
+     */
+    protected _executeRequest(context: HttpContext): Promise<any>;
+    /**
+     *
+     * @param context
+     * @param responseValue
+     * @protected
+     */
+    sendResponse(context: HttpContext, responseValue?: any): Promise<void>;
+    protected _sendErrorResponse(context: HttpContext): Promise<void>;
+    sendDocumentSchema(context: HttpContext): Promise<void>;
+    /**
+     *
+     * @param context
+     * @param body
+     * @protected
+     */
+    protected _determineResponseArgs(context: HttpContext, body: any): HttpHandler.ResponseArgs;
+    protected _wrapExceptions(exceptions: any[]): OpraHttpError[];
+}

package/types/impl/http-incoming.host.d.ts

@@ -0,0 +1,22 @@
+import parseRange from 'range-parser';
+import type { HttpIncoming } from '../interfaces/http-incoming.interface.js';
+import { BodyReader } from '../utils/body-reader.js';
+export interface HttpIncomingHost extends HttpIncoming {
+}
+export declare class HttpIncomingHost implements HttpIncoming {
+    body?: any;
+    get protocol(): string;
+    get secure(): boolean;
+    get hostname(): string | undefined;
+    get fresh(): boolean;
+    get xhr(): boolean;
+    header(name: string): any;
+    get(name: string): any;
+    accepts(...types: any): any;
+    acceptsCharsets(...charsets: any): any;
+    acceptsEncodings(...encoding: any): any;
+    acceptsLanguages(...lang: any): any;
+    is(type: string | string[], ...otherTypes: string[]): string | false | null;
+    range(size: number, options: any): parseRange.Ranges | parseRange.Result | undefined;
+    readBody(options: BodyReader.Options): Promise<string | Buffer | undefined>;
+}

package/types/impl/http-outgoing.host.d.ts

@@ -0,0 +1,17 @@
+import type { CookieOptions, HttpOutgoing } from '../interfaces/http-outgoing.interface.js';
+export interface HttpOutgoingHost extends HttpOutgoing {
+}
+export declare class HttpOutgoingHost {
+    attachment(filename?: string): this;
+    contentType(type: any): this;
+    setHeader(field: string | Record<string, any>, val?: any): this;
+    clearCookie(name: string, options: CookieOptions): this;
+    cookie(name: string, value: any, options?: CookieOptions): this;
+    status(code: number): this;
+    sendStatus(statusCode: number): this;
+    links(links: Record<string, string>): this;
+    location(url: string): this;
+    redirect(arg0: string | number, arg1?: string): void;
+    send(body: any): this;
+    vary(field: string): this;
+}

package/types/impl/multipart-reader.d.ts

@@ -0,0 +1,46 @@
+import { HttpMediaType } from '@opra/common';
+import busboy from 'busboy';
+import { EventEmitter } from 'events';
+import type { StrictOmit } from 'ts-gems';
+import type { HttpContext } from '../http-context.js';
+export declare namespace MultipartReader {
+    interface Options extends StrictOmit<busboy.BusboyConfig, 'headers'> {
+        tempDirectory?: string;
+    }
+    interface FieldInfo {
+        kind: 'field';
+        field: string;
+        value?: any;
+        mimeType?: string;
+        encoding?: string;
+    }
+    interface FileInfo {
+        kind: 'file';
+        field: string;
+        filename: string;
+        storedPath: string;
+        mimeType?: string;
+        encoding?: string;
+    }
+    type Item = FieldInfo | FileInfo;
+}
+export declare class MultipartReader extends EventEmitter {
+    protected context: HttpContext;
+    protected mediaType?: HttpMediaType | undefined;
+    protected _started: boolean;
+    protected _finished: boolean;
+    protected _cancelled: boolean;
+    protected _form: busboy.Busboy;
+    protected _items: MultipartReader.Item[];
+    protected _stack: MultipartReader.Item[];
+    protected tempDirectory: string;
+    constructor(context: HttpContext, options?: MultipartReader.Options, mediaType?: HttpMediaType | undefined);
+    get items(): MultipartReader.Item[];
+    getNext(): Promise<MultipartReader.Item | undefined>;
+    getAll(): Promise<MultipartReader.Item[]>;
+    getAll_(): Promise<MultipartReader.Item[]>;
+    cancel(): void;
+    resume(): void;
+    pause(): void;
+    purge(): Promise<PromiseSettledResult<any>[]>;
+}

package/types/impl/node-incoming-message.host.d.ts

@@ -0,0 +1,45 @@
+import { type HTTPParserJS } from '@browsery/http-parser';
+import type { IncomingHttpHeaders } from 'http';
+import { Duplex, Readable } from 'stream';
+import type { NodeIncomingMessage } from '../interfaces/node-incoming-message.interface.js';
+export declare const CRLF: Buffer;
+export declare const kHeaders: unique symbol;
+export declare const kHeadersDistinct: unique symbol;
+export declare const kTrailers: unique symbol;
+export declare const kTrailersDistinct: unique symbol;
+export declare const kHttpParser: unique symbol;
+/**
+ *
+ * @class NodeIncomingMessageHost
+ */
+export declare class NodeIncomingMessageHost extends Duplex implements NodeIncomingMessage {
+    protected [kHeaders]?: IncomingHttpHeaders;
+    protected [kHeadersDistinct]?: NodeJS.Dict<string[]>;
+    protected [kTrailers]?: NodeJS.Dict<string>;
+    protected [kTrailersDistinct]?: NodeJS.Dict<string[]>;
+    protected [kHttpParser]: HTTPParserJS | undefined;
+    protected _readStream?: Readable;
+    httpVersionMajor: number;
+    httpVersionMinor: number;
+    method: string;
+    url: string;
+    rawHeaders: string[];
+    rawTrailers: string[];
+    params?: Record<string, any>;
+    cookies?: Record<string, any>;
+    body?: Buffer;
+    complete: boolean;
+    ip?: string;
+    ips?: string[];
+    joinDuplicateHeaders: boolean;
+    constructor(init?: NodeIncomingMessage.Initiator);
+    get httpVersion(): string;
+    get headers(): IncomingHttpHeaders;
+    set headers(headers: IncomingHttpHeaders);
+    get headersDistinct(): NodeJS.Dict<string[]>;
+    get trailers(): NodeJS.Dict<string>;
+    set trailers(trailers: NodeJS.Dict<string>);
+    get trailersDistinct(): NodeJS.Dict<string[]>;
+    _read(size: number): void;
+    _write(chunk: any, encoding: BufferEncoding, callback: (error?: Error | null) => void): void;
+}

package/types/impl/node-outgoing-message.host.d.ts

@@ -0,0 +1,49 @@
+import type { OutgoingHttpHeaders } from 'http';
+import { Duplex } from 'stream';
+import type { NodeIncomingMessage } from '../interfaces/node-incoming-message.interface.js';
+import type { NodeOutgoingMessage } from '../interfaces/node-outgoing-message.interface.js';
+export declare const kOutHeaders: unique symbol;
+export declare const kOutTrailers: unique symbol;
+declare global {
+    interface Headers {
+        keys(): IterableIterator<string>;
+        entries(): IterableIterator<[string, any]>;
+    }
+}
+/**
+ *
+ * @class NodeOutgoingMessageHost
+ */
+export declare class NodeOutgoingMessageHost extends Duplex implements NodeOutgoingMessage {
+    protected [kOutHeaders]?: Record<string, any>;
+    protected [kOutTrailers]?: Record<string, any>;
+    protected _headersSent: boolean;
+    protected _httpVersionMajor?: number;
+    protected _httpVersionMinor?: number;
+    finished: boolean;
+    req: NodeIncomingMessage;
+    statusCode: number;
+    statusMessage: string;
+    chunkedEncoding: boolean;
+    sendDate: boolean;
+    strictContentLength: boolean;
+    body?: any;
+    constructor(init?: NodeOutgoingMessage.Initiator);
+    get httpVersionMajor(): number | undefined;
+    get httpVersionMinor(): number | undefined;
+    get headersSent(): boolean;
+    appendHeader(name: string, value: number | string | readonly string[]): this;
+    addTrailers(headers: OutgoingHttpHeaders | [string, string][] | readonly [string, string][]): void;
+    flushHeaders(): void;
+    setHeader(name: string, value: number | string | readonly string[]): this;
+    setHeaders(headers: Headers | Map<string, any> | Record<string, any>): this;
+    getHeader(name: string): any;
+    getHeaderNames(): string[];
+    getRawHeaderNames(): string[];
+    getHeaders(): OutgoingHttpHeaders;
+    hasHeader(name: string): boolean;
+    removeHeader(name: string): void;
+    end(cb?: () => void): this;
+    end(chunk: any, cb?: () => void): this;
+    end(chunk: any, encoding: BufferEncoding, cb?: () => void): this;
+}

package/types/index.d.cts

@@ -0,0 +1,22 @@
+import 'reflect-metadata';
+import * as HttpIncomingHost_ from './impl/http-incoming.host.js';
+import * as HttpOutgoingHost_ from './impl/http-outgoing.host.js';
+import * as NodeIncomingMessageHost_ from './impl/node-incoming-message.host.js';
+import * as NodeOutgoingMessageHost_ from './impl/node-outgoing-message.host.js';
+export * from './express-adapter.js';
+export * from './http-adapter.js';
+export * from './http-context.js';
+export * from './http-handler.js';
+export * from './impl/multipart-reader.js';
+export * from './interfaces/http-incoming.interface.js';
+export * from './interfaces/http-outgoing.interface.js';
+export * from './interfaces/node-incoming-message.interface.js';
+export * from './interfaces/node-outgoing-message.interface.js';
+export * from './type-guards.js';
+export * from './utils/wrap-exception.js';
+export declare namespace classes {
+    export import HttpIncomingHost = HttpIncomingHost_.HttpIncomingHost;
+    export import HttpOutgoingHost = HttpOutgoingHost_.HttpOutgoingHost;
+    export import NodeIncomingMessageHost = NodeIncomingMessageHost_.NodeIncomingMessageHost;
+    export import NodeOutgoingMessageHost = NodeOutgoingMessageHost_.NodeOutgoingMessageHost;
+}

package/types/index.d.ts

@@ -0,0 +1,22 @@
+import 'reflect-metadata';
+import * as HttpIncomingHost_ from './impl/http-incoming.host.js';
+import * as HttpOutgoingHost_ from './impl/http-outgoing.host.js';
+import * as NodeIncomingMessageHost_ from './impl/node-incoming-message.host.js';
+import * as NodeOutgoingMessageHost_ from './impl/node-outgoing-message.host.js';
+export * from './express-adapter.js';
+export * from './http-adapter.js';
+export * from './http-context.js';
+export * from './http-handler.js';
+export * from './impl/multipart-reader.js';
+export * from './interfaces/http-incoming.interface.js';
+export * from './interfaces/http-outgoing.interface.js';
+export * from './interfaces/node-incoming-message.interface.js';
+export * from './interfaces/node-outgoing-message.interface.js';
+export * from './type-guards.js';
+export * from './utils/wrap-exception.js';
+export declare namespace classes {
+    export import HttpIncomingHost = HttpIncomingHost_.HttpIncomingHost;
+    export import HttpOutgoingHost = HttpOutgoingHost_.HttpOutgoingHost;
+    export import NodeIncomingMessageHost = NodeIncomingMessageHost_.NodeIncomingMessageHost;
+    export import NodeOutgoingMessageHost = NodeOutgoingMessageHost_.NodeOutgoingMessageHost;
+}