@opra/core 0.20.3 → 0.21.0

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

@@ -1,9 +1,10 @@
+import { Task } from 'power-tasks';
 import { OpraAdapter } from '../adapter.js';
 import { ILogger } from '../interfaces/logger.interface.js';
 import { Request } from '../interfaces/request.interface.js';
 import { RequestContext } from '../interfaces/request-context.interface.js';
-import { HttpRequestMessage } from './http-request-message.js';
-import { HttpResponseMessage } from './http-response-message.js';
+import { HttpServerRequest } from './impl/http-server-request.js';
+import { HttpServerResponse } from './impl/http-server-response.js';
 /**
  * @namespace OpraHttpAdapter
  */
@@ -24,15 +25,9 @@ export declare abstract class OpraHttpAdapter extends OpraAdapter {
      * @param outgoing
      * @protected
      */
-    protected handler(incoming: HttpRequestMessage, outgoing: HttpResponseMessage): Promise<void>;
-    protected errorHandler(incoming: HttpRequestMessage, outgoing: HttpResponseMessage, errors: any[]): Promise<void>;
-    protected log(logType: keyof ILogger, incoming: HttpRequestMessage, message: string, ...optionalParams: any[]): void;
+    protected handler(incoming: HttpServerRequest, outgoing: HttpServerResponse): Promise<void>;
+    protected createRequestTask(request: Request, outgoing: HttpServerResponse): Task;
     protected executeRequest(context: RequestContext): Promise<void>;
-    /**
-     *
-     * @param incoming
-     * @protected
-     */
-    protected parseRequest(incoming: HttpRequestMessage): Promise<Request>;
-    protected sendResponse(context: RequestContext): Promise<void>;
+    protected handleError(incoming: HttpServerRequest, outgoing: HttpServerResponse, errors: any[]): Promise<void>;
+    protected log(logType: keyof ILogger, incoming: HttpServerRequest, message: string, ...optionalParams: any[]): void;
 }

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

@@ -0,0 +1,58 @@
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+import http, { IncomingHttpHeaders } from 'http';
+import * as stream from 'stream';
+import { Readable } from 'stream';
+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 interface HttpIncomingMessage extends Pick<http.IncomingMessage, 'httpVersion' | 'httpVersionMajor' | 'httpVersionMinor' | 'complete' | 'headers' | 'trailers' | 'rawHeaders' | 'rawTrailers' | 'method' | 'url'>, stream.Readable {
+}
+export declare namespace HttpIncomingMessageHost {
+    interface Initiator {
+        httpVersionMajor?: number;
+        httpVersionMinor?: number;
+        method?: string;
+        url?: string;
+        headers?: Record<string, any> | string[];
+        trailers?: Record<string, any> | string[];
+        body?: any;
+        ip?: string;
+        ips?: string[];
+    }
+}
+export interface HttpIncomingMessageHost extends stream.Readable {
+}
+/**
+ *
+ * @class HttpIncomingMessageHost
+ */
+export declare class HttpIncomingMessageHost implements HttpIncomingMessage {
+    httpVersionMajor: number;
+    httpVersionMinor: number;
+    method: string;
+    url: string;
+    rawHeaders: string[];
+    rawTrailers: string[];
+    body?: any;
+    complete: boolean;
+    ip?: string;
+    ips?: string[];
+    joinDuplicateHeaders: boolean;
+    constructor();
+    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[]>;
+    protected _readConfig(init: HttpIncomingMessageHost.Initiator): void;
+    protected _readBuffer(buf: Buffer | ArrayBuffer): void;
+    _readStream(readable: Readable): void;
+    static create(init?: HttpIncomingMessageHost.Initiator | Buffer | stream.Readable): HttpIncomingMessageHost;
+}

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

@@ -0,0 +1,72 @@
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+import http, { OutgoingHttpHeaders } from 'http';
+import * as stream from 'stream';
+import type { HttpIncomingMessage } from './http-incoming-message-host.js';
+export declare const kOutHeaders: unique symbol;
+export declare const kOutTrailers: unique symbol;
+export declare const kErrored: unique symbol;
+declare global {
+    interface Headers {
+        keys(): IterableIterator<string>;
+        entries(): IterableIterator<[string, any]>;
+    }
+}
+export interface HttpOutgoingMessage extends Pick<http.ServerResponse, 'addTrailers' | 'getHeader' | 'getHeaders' | 'getHeaderNames' | 'removeHeader' | 'hasHeader' | 'headersSent' | 'statusCode' | 'statusMessage' | 'sendDate'>, stream.Writable {
+    req?: HttpIncomingMessage;
+    appendHeader(name: string, value: string | readonly string[]): this;
+    setHeader(name: string, value: number | string | readonly string[]): this;
+}
+export declare namespace HttpOutgoingMessageHost {
+    interface Initiator {
+        req?: HttpIncomingMessage;
+        statusCode?: number;
+        statusMessage?: string;
+        headers?: OutgoingHttpHeaders | Headers | Map<string, any> | string[];
+        chunkedEncoding?: boolean;
+        sendDate?: boolean;
+        strictContentLength?: boolean;
+        body?: any;
+    }
+}
+export interface HttpOutgoingMessageHost extends stream.Writable {
+}
+/**
+ *
+ * @class HttpOutgoingMessageHost
+ */
+export declare class HttpOutgoingMessageHost {
+    protected _headersSent: boolean;
+    protected _closed: boolean;
+    protected [kErrored]: Error | null;
+    protected [kOutHeaders]: Record<string, any>;
+    protected [kOutTrailers]: Record<string, any>;
+    finished: boolean;
+    req?: HttpIncomingMessage;
+    statusCode: number;
+    statusMessage: string;
+    chunkedEncoding: boolean;
+    sendDate: boolean;
+    strictContentLength: boolean;
+    body?: any;
+    constructor();
+    get headersSent(): boolean;
+    get closed(): boolean;
+    get errored(): Error | null;
+    appendHeader(name: string, value: number | string | readonly string[]): this;
+    addTrailers(headers: OutgoingHttpHeaders | [string, string][] | readonly [string, string][]): void;
+    setHeader(name: any, value: any): this;
+    setHeaders(headers: Headers | Map<string, any> | Record<string, any>): this;
+    getHeader(name: string): any;
+    getHeaderNames(): string[];
+    getRawHeaderNames(): any[];
+    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;
+    protected _readConfig(init: HttpOutgoingMessageHost.Initiator): void;
+    static create(init?: HttpOutgoingMessageHost.Initiator): HttpOutgoingMessageHost;
+}

package/types/adapter/http/{http-request-message.d.ts → impl/http-server-request.d.ts}

@@ -1,88 +1,71 @@
 /// <reference types="node" />
 /// <reference types="node" />
-/// <reference types="node" />
-/// <reference types="node" />
-import { IncomingHttpHeaders } from 'http';
-import { Readable } from 'stream';
-import { HttpMessage } from './http-message.host.js';
-export interface HttpRequestMessage extends HttpMessage {
+import { Options as RangeParserOptions, Ranges as RangeParserRanges, Result as RangeParserResult } from 'range-parser';
+import stream from 'stream';
+import { HttpIncomingMessage, HttpIncomingMessageHost } from './http-incoming-message-host.js';
+import type { HttpServerResponse } from './http-server-response.js';
+export declare namespace HttpServerRequest {
+    function create(instance?: HttpIncomingMessage | HttpIncomingMessageHost.Initiator | Buffer | stream.Readable): HttpServerRequest;
+}
+export interface HttpServerRequest extends HttpIncomingMessage {
+    res: HttpServerResponse;
+    body?: any;
     /**
-     * In case of server request, the HTTP version sent by the client. In the case of
-     * client response, the HTTP version of the connected-to server.
-     * Probably either `'1.1'` or `'1.0'`.
-     *
-     * Also `message.httpVersionMajor` is the first integer and`message.httpVersionMinor` is the second.
-     * @since v0.1.1
+     * Return the protocol string "http" or "https"
+     * When the "X-Forwarded-Proto" header field will be trusted
+     * and used if present.
      */
-    httpVersion: string;
-    httpVersionMajor: number;
-    httpVersionMinor: number;
+    protocol: string;
     /**
-     * The request/response headers object.
+     * Return the remote address from the trusted proxy.
      *
-     * Key-value pairs of header names and values. Header names are lower-cased.
-     */
-    readonly headers: IncomingHttpHeaders;
-    /**
-     * The raw request/response headers list exactly as they were received.
-     */
-    rawHeaders: string[];
-    /**
-     * The request/response trailers object.
+     * This is the remote address on the socket unless "trust proxy" is set.
      */
-    readonly trailers: NodeJS.Dict<string>;
+    ip: string;
     /**
-     * The raw request/response trailer keys and values exactly as they were received.
+     * When "trust proxy" is set, trusted proxy addresses + client.
+     *
+     * For example if the value were "client, proxy1, proxy2"
+     * you would receive the array `["client", "proxy1", "proxy2"]`
+     * where "proxy2" is the furthest down-stream and "proxy1" and
+     * "proxy2" were trusted.
      */
-    rawTrailers: string[];
-    readonly complete: boolean;
-    readonly upgrade?: any;
+    ips: string[];
     /**
-     * Return the protocol string "http" or "https"
-     * when requested with TLS. When the "trust proxy"
-     * setting is enabled the "X-Forwarded-Proto" header
-     * field will be trusted. If you're running behind
-     * a reverse proxy that supplies https for you this
-     * may be enabled.
+     * Short-hand for:
+     *    req.protocol === 'https'
      */
-    protocol: string;
+    secure: boolean;
     /**
-     * Short-hand for:
+     * Parse the "Host" header field to a hostname.
      *
-     *    req.protocol == 'https'
+     * When the "trust proxy" setting trusts the socket
+     * address, the "X-Forwarded-Host" header field will
+     * be trusted.
      */
-    secure: boolean;
+    hostname?: string;
     /**
-     * Return the remote address, or when
-     * "trust proxy" is `true` return
-     * the upstream addr.
+     * Check if the request is fresh, aka
+     * Last-Modified and/or the ETag still match.
      */
-    ip: string;
+    fresh: boolean;
     /**
-     * When "trust proxy" is `true`, parse
-     * the "X-Forwarded-For" ip address list.
+     * Check if the request was an _XMLHttpRequest_.
      *
-     * For example if the value were "client, proxy1, proxy2"
-     * you would receive the array `["client", "proxy1", "proxy2"]`
-     * where "proxy2" is the furthest down-stream.
      */
-    ips: string[];
+    xhr: boolean;
     /**
-     * Parse the "Host" header field hostname.
+     * Secret value for cookie encryption
+     *
      */
-    hostname: string;
-    method: string;
-    url: string;
-    baseUrl: string;
-    query: Record<string, any>;
+    secret?: string;
     /**
      * Return request header.
      *
      * The `Referrer` header field is special-cased,
      * both `Referrer` and `Referer` are interchangeable.
      *
-     * Examples:
-     *
+     * @example
      *     req.get('Content-Type');
      *     // => "text/plain"
      *
@@ -92,12 +75,11 @@ export interface HttpRequestMessage extends HttpMessage {
      *     req.get('Something');
      *     // => undefined
      *
-     * Aliased as `req.header()`.
      */
-    get(name: 'set-cookie'): string[] | undefined;
-    get(name: string): string | undefined;
     header(name: 'set-cookie'): string[] | undefined;
     header(name: string): string | undefined;
+    get(name: 'set-cookie'): string[] | undefined;
+    get(name: string): string | undefined;
     /**
      * Check if the given `type(s)` is acceptable, returning
      * the best match when true, otherwise `undefined`, in which
@@ -105,12 +87,11 @@ export interface HttpRequestMessage extends HttpMessage {
      *
      * The `type` value may be a single mime type string
      * such as "application/json", the extension name
-     * such as "json", a comma-delimted list such as "json, html, text/plain",
+     * such as "json", a comma-delimited list such as "json, html, text/plain",
      * or an array `["json", "html", "text/plain"]`. When a list
      * or array is given the _best_ match, if any is returned.
      *
-     * Examples:
-     *
+     * @example
      *     // Accept: text/html
      *     req.accepts('html');
      *     // => "html"
@@ -147,8 +128,7 @@ export interface HttpRequestMessage extends HttpMessage {
      * For more information, or if you have issues or concerns, see accepts.
      */
     acceptsCharsets(): string[];
-    acceptsCharsets(charset: string): string | false;
-    acceptsCharsets(charset: string[]): string | false;
+    acceptsCharsets(charsets: string[]): string | false;
     acceptsCharsets(...charset: string[]): string | false;
     /**
      * Returns the first accepted encoding of the specified encodings,
@@ -158,8 +138,7 @@ export interface HttpRequestMessage extends HttpMessage {
      * For more information, or if you have issues or concerns, see accepts.
      */
     acceptsEncodings(): string[];
-    acceptsEncodings(encoding: string): string | false;
-    acceptsEncodings(encoding: string[]): string | false;
+    acceptsEncodings(encodings: string[]): string | false;
     acceptsEncodings(...encoding: string[]): string | false;
     /**
      * Returns the first accepted language of the specified languages,
@@ -176,8 +155,7 @@ export interface HttpRequestMessage extends HttpMessage {
      * Check if the incoming request contains the "Content-Type"
      * header field, and it contains the give mime `type`.
      *
-     * Examples:
-     *
+     * @example
      *      // With Content-Type: text/html; charset=utf-8
      *      req.is('html');
      *      req.is('text/html');
@@ -195,19 +173,8 @@ export interface HttpRequestMessage extends HttpMessage {
      */
     is(type: string | string[]): string | false | null;
     is(...types: string[]): string | false | null;
-}
-export declare namespace HttpRequestMessage {
-    interface Initiator extends HttpMessage.Initiator {
-        httpVersionMajor?: number;
-        httpVersionMinor?: number;
-        method: string;
-        url: string;
-        protocol?: string;
-        baseUrl?: string;
-        ip?: string;
-        ips?: [];
-    }
-    function create(init: Initiator): HttpRequestMessage;
-    function fromBuffer(buffer: Buffer | ArrayBuffer): HttpRequestMessage;
-    function fromStream(readable: Readable): Promise<HttpRequestMessage>;
+    /**
+     * Parse Range header field, capping to the given `size`.
+     */
+    range(size: number, options?: RangeParserOptions): RangeParserRanges | RangeParserResult | undefined;
 }

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

@@ -0,0 +1,137 @@
+import { HttpOutgoingMessage, HttpOutgoingMessageHost } from './http-outgoing-message-host.js';
+import type { HttpServerRequest } from './http-server-request.js';
+export declare namespace HttpServerResponse {
+    function create(instance?: HttpOutgoingMessage | HttpOutgoingMessageHost.Initiator): HttpServerResponse;
+}
+export interface HttpServerResponse extends HttpOutgoingMessage {
+    req?: HttpServerRequest;
+    /**
+     * Set _Content-Disposition_ header to _attachment_ with optional `filename`.
+     */
+    attachment(this: HttpServerResponse, filename?: string): this;
+    /** Clear cookie `name`. */
+    clearCookie(name: string, options?: CookieOptions): this;
+    /**
+     * Set cookie `name` to `val`, with the given `options`.
+     *
+     * Options:
+     *
+     *    - `maxAge`   max-age in milliseconds, converted to `expires`
+     *    - `signed`   sign the cookie
+     *    - `path`     defaults to "/"
+     *
+     * Examples:
+     *
+     *    // "Remember Me" for 15 minutes
+     *    res.cookie('rememberme', '1', { expires: new Date(Date.now() + 900000), httpOnly: true });
+     *
+     *    // save as above
+     *    res.cookie('rememberme', '1', { maxAge: 900000, httpOnly: true })
+     */
+    cookie(name: string, val: string, options: CookieOptions): this;
+    cookie(name: string, val: any, options: CookieOptions): this;
+    cookie(name: string, val: any): this;
+    /**
+     * Set _Content-Type_ response header with `type` through `mime.lookup()`
+     * when it does not contain "/", or set the Content-Type to `type` otherwise.
+     *
+     * @example
+     *     res.type('.html');
+     *     res.type('html');
+     *     res.type('json');
+     *     res.type('application/json');
+     *     res.type('png');
+     */
+    contentType(type: string): this;
+    /**
+     * Set Link header field with the given `links`.
+     *
+     * Examples:
+     *
+     *    res.links({
+     *      next: 'http://api.example.com/users?page=2',
+     *      last: 'http://api.example.com/users?page=5'
+     *    });
+     */
+    links(links: Record<string, string>): this;
+    /**
+     * Set the location header to `url`.
+     *
+     * The given `url` can also be the name of a mapped url, for
+     * example by default express supports "back" which redirects
+     * to the _Referrer_ or _Referer_ headers or "/".
+     *
+     * Examples:
+     *
+     *    res.location('/foo/bar').;
+     *    res.location('http://example.com');
+     *    res.location('../login'); // /blog/post/1 -> /blog/login
+     *
+     * Mounting:
+     *
+     *   When an application is mounted and `res.location()`
+     *   is given a path that does _not_ lead with "/" it becomes
+     *   relative to the mount-point. For example if the application
+     *   is mounted at "/blog", the following would become "/blog/login".
+     *
+     *      res.location('login');
+     *
+     *   While the leading slash would result in a location of "/login":
+     *
+     *      res.location('/login');
+     */
+    location(url: string): this;
+    /**
+     * Redirect to the given `url` with optional response `status`
+     * defaulting to 302.
+     *
+     * The resulting `url` is determined by `res.location()`, so
+     * it will play nicely with mounted apps, relative paths,
+     * `"back"` etc.
+     *
+     * Examples:
+     *
+     *    res.redirect('back');
+     *    res.redirect('/foo/bar');
+     *    res.redirect('http://example.com');
+     *    res.redirect(301, 'http://example.com');
+     *    res.redirect('http://example.com', 301);
+     *    res.redirect('../login'); // /blog/post/1 -> /blog/login
+     */
+    redirect(url: string): void;
+    redirect(status: number, url: string): void;
+    /**
+     * Set status `code`.
+     */
+    status(code: number): this;
+    /**
+     * Send given HTTP status code.
+     *
+     * Sets the response status to `statusCode` and the body of the
+     * response to the standard description from node's http.STATUS_CODES
+     * or the statusCode number if no description.
+     */
+    sendStatus(statusCode: number): any;
+    /**
+     * Send a response.
+     *
+     * @example
+     *     res.send(new Buffer('wahoo'));
+     *     res.send({ some: 'json' });
+     *     res.send('<p>some html</p>');
+     *     res.status(404).send('Sorry, cant find that');
+     */
+    send(body?: any): this;
+}
+export interface CookieOptions {
+    secret?: string;
+    maxAge?: number;
+    signed?: boolean;
+    expires?: Date;
+    httpOnly?: boolean;
+    path?: string;
+    domain?: string;
+    secure?: boolean;
+    encode?: ((val: string) => string);
+    sameSite?: boolean | 'lax' | 'strict' | 'none';
+}

package/types/adapter/http/request-parsers/parse-collection-request.d.ts

@@ -0,0 +1,4 @@
+import { Collection, OpraURL } from '@opra/common';
+import { Request } from '../../interfaces/request.interface.js';
+import { HttpServerRequest } from '../impl/http-server-request.js';
+export declare function parseCollectionRequest(incoming: HttpServerRequest, resource: Collection, url: OpraURL): Promise<Request>;

package/types/adapter/http/request-parsers/parse-request.d.ts

@@ -0,0 +1,4 @@
+import { ApiDocument } from '@opra/common';
+import { Request } from '../../interfaces/request.interface.js';
+import { HttpServerRequest } from '../impl/http-server-request.js';
+export declare function parseRequest(api: ApiDocument, incoming: HttpServerRequest): Promise<Request>;

package/types/adapter/http/request-parsers/parse-singleton-request.d.ts

@@ -0,0 +1,4 @@
+import { OpraURL, Singleton } from '@opra/common';
+import { Request } from '../../interfaces/request.interface.js';
+import { HttpServerRequest } from '../impl/http-server-request.js';
+export declare function parseSingletonRequest(incoming: HttpServerRequest, resource: Singleton, url: OpraURL): Promise<Request>;

package/types/adapter/interfaces/request-context.interface.d.ts

@@ -1,6 +1,6 @@
 import { ApiDocument } from '@opra/common';
-import { HttpRequestMessage } from '../http/http-request-message.js';
-import { HttpResponseMessage } from '../http/http-response-message.js';
+import { HttpServerRequest } from '../http/impl/http-server-request.js';
+import { HttpServerResponse } from '../http/impl/http-server-response.js';
 import { Request } from './request.interface.js';
 import { Response } from './response.interface.js';
 export declare namespace RequestContext {
@@ -13,15 +13,19 @@ export interface RequestContext {
     readonly request: Request;
     readonly response: Response;
     user?: any;
-    switchToHttp(): HttpRequestContext;
-    switchToWs(): WsRequestContext;
-    switchToRpc(): RpcRequestContext;
+    switchToHttp(): HttpMessageContext;
+    switchToWs(): WsMessageContext;
+    switchToRpc(): RpcMessageContext;
 }
-export interface HttpRequestContext extends Omit<RequestContext, 'request' | 'response'> {
-    readonly request: HttpRequestMessage;
-    readonly response: HttpResponseMessage;
+export interface HttpMessageContext {
+    readonly platform: string;
+    readonly request: HttpServerRequest;
+    readonly response: HttpServerResponse;
+    switchToContext(): RequestContext;
 }
-export interface WsRequestContext extends Omit<RequestContext, 'request' | 'response'> {
+export interface WsMessageContext {
+    switchToContext(): RequestContext;
 }
-export interface RpcRequestContext extends Omit<RequestContext, 'request' | 'response'> {
+export interface RpcMessageContext {
+    switchToContext(): RequestContext;
 }

package/types/adapter/interfaces/request.interface.d.ts

@@ -1,6 +1,7 @@
 import { OpraSchema, Resource } from '@opra/common';
-import type { HttpRequestMessage } from '../http/http-request-message.js';
+import { HttpServerRequest } from '../http/impl/http-server-request.js';
 export interface Request {
+    readonly contentId: string;
     readonly kind: string;
     readonly resource: Resource;
     readonly resourceKind: OpraSchema.Resource.Kind;
@@ -8,7 +9,7 @@ export interface Request {
     readonly crud: 'create' | 'read' | 'update' | 'delete';
     readonly many: boolean;
     readonly args: any;
-    switchToHttp(): HttpRequestMessage;
+    switchToHttp(): HttpServerRequest;
     switchToWs(): never;
     switchToRpc(): never;
 }

package/types/adapter/interfaces/response.interface.d.ts

@@ -1,4 +1,4 @@
-import type { HttpResponseMessage } from '../http/http-response-message.js';
+import { HttpServerResponse } from '../http/impl/http-server-response.js';
 export interface Response {
     /**
      * Result value
@@ -16,7 +16,7 @@ export interface Response {
      * Total count of matched entities. (Used in "search" operation with "count" option
      */
     count?: number;
-    switchToHttp(): HttpResponseMessage;
+    switchToHttp(): HttpServerResponse;
     switchToWs(): never;
     switchToRpc(): never;
 }

package/types/adapter/request-context.host.d.ts

@@ -1,19 +1,22 @@
 import { AsyncEventEmitter } from 'strict-typed-events';
 import { ApiDocument } from '@opra/common';
 import { Request } from './interfaces/request.interface.js';
-import { HttpRequestContext, RequestContext, RpcRequestContext, WsRequestContext } from './interfaces/request-context.interface.js';
+import { HttpMessageContext, RequestContext, RpcMessageContext, WsMessageContext } from './interfaces/request-context.interface.js';
 import { Response } from './interfaces/response.interface.js';
-export declare abstract class RequestContextHost extends AsyncEventEmitter implements RequestContext {
+export declare class RequestContextHost extends AsyncEventEmitter implements RequestContext {
     readonly protocol: RequestContext.Protocol;
     readonly platform: string;
     readonly api: ApiDocument;
     protected _request: Request;
     protected _response: Response;
     user?: any;
-    protected constructor(protocol: RequestContext.Protocol, platform: string, api: ApiDocument, _request: Request, _response: Response);
+    protected _http?: HttpMessageContext;
+    protected _ws?: WsMessageContext;
+    protected _rpc?: RpcMessageContext;
+    constructor(protocol: RequestContext.Protocol, platform: string, api: ApiDocument, _request: Request, _response: Response);
     get request(): Request;
     get response(): Response;
-    switchToHttp(): HttpRequestContext;
-    switchToWs(): WsRequestContext;
-    switchToRpc(): RpcRequestContext;
+    switchToHttp(): HttpMessageContext;
+    switchToWs(): WsMessageContext;
+    switchToRpc(): RpcMessageContext;
 }