@opra/client 0.11.8 → 0.13.0

package/cjs/index.min.mjs

@@ -1,6 +1,9 @@
 'use strict';
 
 var buffer = require('buffer');
+var stream = require('@browsery/stream');
+var rxjs = require('rxjs');
+require('tslib');
 var fastTokenizer = require('fast-tokenizer');
 var fs = require('@browsery/fs');
 var i18next = require('@browsery/i18next');
@@ -14,10 +17,15 @@ var omit = require('lodash.omit');
 var promisify = require('putil-promisify');
 var isPlainObject = require('putil-isplainobject');
 var merge = require('putil-merge');
-var events = require('events');
-require('@browsery/http-parser');
-require('@browsery/stream');
-var rxjs = require('rxjs');
+var httpParser = require('@browsery/http-parser');
+
+function isFunction(value) {
+    return typeof value === 'function';
+}
+
+function isReadableStreamLike(obj) {
+    return isFunction(obj === null || obj === void 0 ? void 0 : obj.getReader);
+}
 
 const dotPattern$1 = /^([^.]+)\.(.*)$/;
 function pathToTree$1(arr, lowerCaseKeys) {
@@ -158,10 +166,8 @@ class I18n extends BaseI18n {
     async loadResourceDir(dirnames, deep, overwrite) {
         for (const dirname of Array.isArray(dirnames) ? dirnames : [dirnames]) {
             /* istanbul ignore next */
-            if (!(fs.statSync(dirname)).isDirectory()) {
-                // eslint-disable-next-line no-console
+            if (!(fs.existsSync(dirname)))
                 continue;
-            }
             const languageDirs = fs.readdirSync(dirname);
             for (const lang of languageDirs) {
                 const langDir = path.join(dirname, lang);
@@ -1119,10 +1125,6 @@ OpraFilterLexer.DecisionsToDFA = OpraFilterLexer._ATN.decisionToState.map((ds, i
 
 /* eslint-disable */
 class OpraFilterParser extends antlr4.Parser {
-    constructor(input) {
-        super(input);
-        this._interp = new antlr4.ParserATNSimulator(this, OpraFilterParser._ATN, OpraFilterParser.DecisionsToDFA, new antlr4.PredictionContextCache());
-    }
     get grammarFileName() {
         return "OpraFilter.g4";
     }
@@ -1141,6 +1143,10 @@ class OpraFilterParser extends antlr4.Parser {
     createFailedPredicateException(predicate, message) {
         return new antlr4.FailedPredicateException(this, predicate, message);
     }
+    constructor(input) {
+        super(input);
+        this._interp = new antlr4.ParserATNSimulator(this, OpraFilterParser._ATN, OpraFilterParser.DecisionsToDFA, new antlr4.PredictionContextCache());
+    }
     // @RuleVersion(0)
     root() {
         let localctx = new RootContext(this, this._ctx, this.state);
@@ -3544,13 +3550,19 @@ class ExternalConstant extends Literal {
     }
 }
 
-// Fix: antlr4 d.ts files is invalid
+// Fix: antlr4 d.ts files are invalid
 const ParseTreeVisitor = antlr4.tree.ParseTreeVisitor;
 class FilterTreeVisitor extends ParseTreeVisitor {
     constructor(options) {
         super();
         this._timeZone = options?.timeZone;
     }
+    visitChildren(node) {
+        const result = super.visitChildren(node);
+        if (Array.isArray(result) && result.length < 2)
+            return result[0];
+        return result;
+    }
     defaultResult() {
         return undefined;
     }
@@ -3655,7 +3667,7 @@ class OpraErrorListener extends antlr4.ErrorListener {
         this.errors = errors;
     }
     syntaxError(recognizer, offendingSymbol, line, column, msg, e) {
-        this.errors.push(new FilterParseError(msg, { recognizer, offendingSymbol, line, e }));
+        this.errors.push(new FilterParseError(msg, { recognizer, offendingSymbol, line, column, e }));
     }
 }
 
@@ -3796,51 +3808,51 @@ const _wrapEntryValue = (v) => {
 /**
  * https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers#controls
  */
-exports.HttpHeaders = void 0;
-(function (HttpHeaders) {
+exports.HttpHeaderCodes = void 0;
+(function (HttpHeaderCodes) {
     /* *** Custom Headers *** */
-    HttpHeaders["X_Opra_Version"] = "X-Opra-Version";
-    HttpHeaders["X_Opra_DataType"] = "X-Opra-DataType";
-    HttpHeaders["X_Opra_Count"] = "X-Opra-Count";
+    HttpHeaderCodes["X_Opra_Version"] = "X-Opra-Version";
+    HttpHeaderCodes["X_Opra_DataType"] = "X-Opra-DataType";
+    HttpHeaderCodes["X_Opra_Count"] = "X-Opra-Count";
     /* *** Authentication *** */
     /**
      * Defines the authentication method that should be used to access a resource.
      */
-    HttpHeaders["WWW_Authenticate"] = "WWW-Authenticate";
+    HttpHeaderCodes["WWW_Authenticate"] = "WWW-Authenticate";
     /**
      * Contains the credentials to authenticate a user-agent with a server.
      */
-    HttpHeaders["Authorization"] = "Authorization";
+    HttpHeaderCodes["Authorization"] = "Authorization";
     /**
      * Defines the authentication method that should be used to access a resource behind a proxy server.
      */
-    HttpHeaders["Proxy_Authenticate"] = "Proxy-Authenticate";
+    HttpHeaderCodes["Proxy_Authenticate"] = "Proxy-Authenticate";
     /**
      * Contains the credentials to authenticate a user agent with a proxy server.
      */
-    HttpHeaders["Proxy_Authorization"] = "Proxy-Authorization";
+    HttpHeaderCodes["Proxy_Authorization"] = "Proxy-Authorization";
     /* *** Caching *** */
     /**
      * The time, in seconds, that the object has been in a proxy cache.
      */
-    HttpHeaders["Age"] = "Age";
+    HttpHeaderCodes["Age"] = "Age";
     /**
      * Directives for caching mechanisms in both requests and responses.
      */
-    HttpHeaders["Cache_Control"] = "Cache-Control";
+    HttpHeaderCodes["Cache_Control"] = "Cache-Control";
     /**
      * Clears browsing data (e.g. cookies, storage, cache) associated with the requesting website.
      */
-    HttpHeaders["Clear_Site_Data"] = "Clear-Site-Data";
+    HttpHeaderCodes["Clear_Site_Data"] = "Clear-Site-Data";
     /**
      * The date/time after which the response is considered stale.
      */
-    HttpHeaders["Expires"] = "Expires";
+    HttpHeaderCodes["Expires"] = "Expires";
     /**
      * Implementation-specific header that may have various effects anywhere along the request-response chain.
      * Used for backwards compatibility with HTTP/1.0 caches where the Cache-Control header is not yet present.
      */
-    HttpHeaders["Pragma"] = "Pragma";
+    HttpHeaderCodes["Pragma"] = "Pragma";
     /* *** Conditionals *** */
     /**
      * The last modification date of the resource, used to compare several versions of the same resource.
@@ -3848,294 +3860,294 @@ exports.HttpHeaders = void 0;
      * Conditional requests using If-Modified-Since and If-Unmodified-Since
      * use this value to change the behavior of the request.
      */
-    HttpHeaders["Last_Modified"] = "Last-Modified";
+    HttpHeaderCodes["Last_Modified"] = "Last-Modified";
     /**
      * A unique string identifying the version of the resource.
      * Conditional requests using If-Match and If-None-Match use this value to change the behavior of the request.
      */
-    HttpHeaders["ETag"] = "ETag";
+    HttpHeaderCodes["ETag"] = "ETag";
     /**
      * Makes the request conditional, and applies the method only if the stored resource matches one of the given ETags.
      */
-    HttpHeaders["If_Match"] = "If-Match";
+    HttpHeaderCodes["If_Match"] = "If-Match";
     /**
      * Makes the request conditional, and applies the method only if the stored resource doesn't match
      * any of the given ETags. This is used to update caches (for safe requests), or to prevent uploading
      * a new resource when one already exists.
      */
-    HttpHeaders["If_None_Match"] = "If-None-Match";
+    HttpHeaderCodes["If_None_Match"] = "If-None-Match";
     /**
      * Makes the request conditional, and expects the resource to be transmitted only if it has been modified
      * after the given date. This is used to transmit data only when the cache is out of date.
      */
-    HttpHeaders["If_Modified_Since"] = "If-Modified-Since";
+    HttpHeaderCodes["If_Modified_Since"] = "If-Modified-Since";
     /**
      * Makes the request conditional, and expects the resource to be transmitted only if
      * it has not been modified after the given date. This ensures the coherence of a new
      * fragment of a specific range with previous ones, or to implement an optimistic
      * concurrency control system when modifying existing documents.
      */
-    HttpHeaders["If_Unmodified_Since"] = "If-Unmodified-Since";
+    HttpHeaderCodes["If_Unmodified_Since"] = "If-Unmodified-Since";
     /**
      * Determines how to match request headers to decide whether a cached response can be used
      * rather than requesting a fresh one from the origin server.
      */
-    HttpHeaders["Vary"] = "Vary";
+    HttpHeaderCodes["Vary"] = "Vary";
     /* *** Connection management *** */
     /**
      * Controls whether the network connection stays open after the current transaction finishes.
      */
-    HttpHeaders["Connection"] = "Connection";
+    HttpHeaderCodes["Connection"] = "Connection";
     /**
      * Controls how long a persistent connection should stay open.
      */
-    HttpHeaders["Keep_Alive"] = "Keep-Alive";
+    HttpHeaderCodes["Keep_Alive"] = "Keep-Alive";
     // Content negotiation
     /**
      * Informs the server about the types of data that can be sent back.
      */
-    HttpHeaders["Accept"] = "Accept";
+    HttpHeaderCodes["Accept"] = "Accept";
     /**
      * The encoding algorithm, usually a compression algorithm, that can be used on the resource sent back.
      */
-    HttpHeaders["Accept_Encoding"] = "Accept-Encoding";
+    HttpHeaderCodes["Accept_Encoding"] = "Accept-Encoding";
     /**
      * Informs the server about the human language the server is expected to send back.
      * This is a hint and is not necessarily under the full control of the user:
      * the server should always pay attention not to override an explicit user choice
      * (like selecting a language from a dropdown).
      */
-    HttpHeaders["Accept_Language"] = "Accept-Language";
+    HttpHeaderCodes["Accept_Language"] = "Accept-Language";
     /* *** Controls *** */
     /**
      * Indicates expectations that need to be fulfilled by the server to properly handle the request.
      */
-    HttpHeaders["Expect"] = "Expect";
+    HttpHeaderCodes["Expect"] = "Expect";
     /* *** Cookies *** */
     /**
      * Contains stored HTTP cookies previously sent by the server with the Set-Cookie header.
      */
-    HttpHeaders["Cookie"] = "Cookie";
+    HttpHeaderCodes["Cookie"] = "Cookie";
     /**
      * Send cookies from the server to the user-agent.
      */
-    HttpHeaders["Set_Cookie"] = "Set-Cookie";
+    HttpHeaderCodes["Set_Cookie"] = "Set-Cookie";
     /* *** CORS *** */
     /**
      * Indicates whether the response can be shared.
      */
-    HttpHeaders["Access_Control_Allow_Origin"] = "Access-Control-Allow-Origin";
+    HttpHeaderCodes["Access_Control_Allow_Origin"] = "Access-Control-Allow-Origin";
     /**
      * Indicates whether the response to the request can be exposed when the credentials flag is true.
      */
-    HttpHeaders["Access_Control_Allow_Credentials"] = "Access-Control-Allow-Credentials";
+    HttpHeaderCodes["Access_Control_Allow_Credentials"] = "Access-Control-Allow-Credentials";
     /**
      * Used in response to a preflight request to indicate which HTTP headers can be used when making the actual request.
      */
-    HttpHeaders["Access_Control_Allow_Headers"] = "Access-Control-Allow-Headers";
+    HttpHeaderCodes["Access_Control_Allow_Headers"] = "Access-Control-Allow-Headers";
     /**
      * Specifies the methods allowed when accessing the resource in response to a preflight request.
      */
-    HttpHeaders["Access_Control_Allow_Methods"] = "Access-Control-Allow-Methods";
+    HttpHeaderCodes["Access_Control_Allow_Methods"] = "Access-Control-Allow-Methods";
     /**
      * Indicates which headers can be exposed as part of the response by listing their names.
      */
-    HttpHeaders["Access_Control_Expose_Headers"] = "Access-Control-Expose-Headers";
+    HttpHeaderCodes["Access_Control_Expose_Headers"] = "Access-Control-Expose-Headers";
     /**
      * Indicates how long the results of a preflight request can be cached.
      */
-    HttpHeaders["Access_Control_Max_Age"] = "Access-Control-Max-Age";
+    HttpHeaderCodes["Access_Control_Max_Age"] = "Access-Control-Max-Age";
     /**
      * Used when issuing a preflight request to let the server know which HTTP headers will be
      * used when the actual request is made.
      */
-    HttpHeaders["Access_Control_Request_Headers"] = "Access-Control-Request-Headers";
+    HttpHeaderCodes["Access_Control_Request_Headers"] = "Access-Control-Request-Headers";
     /**
      * Used when issuing a preflight request to let the server know which HTTP method
      * will be used when the actual request is made.
      */
-    HttpHeaders["Access_Control_Request_Method"] = "Access-Control-Request-Method";
+    HttpHeaderCodes["Access_Control_Request_Method"] = "Access-Control-Request-Method";
     /**
      * Indicates where a fetch originates from.
      */
-    HttpHeaders["Origin"] = "Origin";
+    HttpHeaderCodes["Origin"] = "Origin";
     /**
      * Specifies origins that are allowed to see values of attributes retrieved via features of the Resource Timing API,
      * which would otherwise be reported as zero due to cross-origin restrictions.
      */
-    HttpHeaders["Timing_Allow_Origin"] = "Timing-Allow-Origin";
+    HttpHeaderCodes["Timing_Allow_Origin"] = "Timing-Allow-Origin";
     /* *** Downloads *** */
     /**
      * Indicates if the resource transmitted should be displayed inline (default behavior without the header),
      * or if it should be handled like a download and the browser should present a "Save As" dialog.
      */
-    HttpHeaders["Content_Disposition"] = "Content-Disposition";
+    HttpHeaderCodes["Content_Disposition"] = "Content-Disposition";
     /* *** Message body information *** */
     /**
      * Indicates to uniquely identifies MIME entities in several contexts.
      */
-    HttpHeaders["Content_ID"] = "Content-ID";
+    HttpHeaderCodes["Content_ID"] = "Content-ID";
     /**
      * The size of the resource, in decimal number of bytes.
      */
-    HttpHeaders["Content_Length"] = "Content-Length";
+    HttpHeaderCodes["Content_Length"] = "Content-Length";
     /**
      * Indicates the media type of the resource.
      */
-    HttpHeaders["Content_Type"] = "Content-Type";
+    HttpHeaderCodes["Content_Type"] = "Content-Type";
     /**
      * Indicates to specify how a MIME message or body part has been encoded,
      * so that it can be decoded by its recipient.
      */
-    HttpHeaders["Content_Transfer_Encoding"] = "Content-Transfer-Encoding";
+    HttpHeaderCodes["Content_Transfer_Encoding"] = "Content-Transfer-Encoding";
     /**
      * Used to specify the compression algorithm.
      */
-    HttpHeaders["Content_Encoding"] = "Content-Encoding";
+    HttpHeaderCodes["Content_Encoding"] = "Content-Encoding";
     /**
      * Describes the human language(s) intended for the audience, so that it allows a user to
      * differentiate according to the users' own preferred language.
      */
-    HttpHeaders["Content_Language"] = "Content-Language";
+    HttpHeaderCodes["Content_Language"] = "Content-Language";
     /**
      * Indicates an alternate location for the returned data.
      */
-    HttpHeaders["Content_Location"] = "Content-Location";
+    HttpHeaderCodes["Content_Location"] = "Content-Location";
     // Proxies
     /**
      * Contains information from the client-facing side of proxy servers that is altered or
      * lost when a proxy is involved in the path of the request.
      */
-    HttpHeaders["Forwarded"] = "Forwarded";
+    HttpHeaderCodes["Forwarded"] = "Forwarded";
     /**
      * Identifies the originating IP addresses of a client connecting to a web server
      * through an HTTP proxy or a load balancer.
      */
-    HttpHeaders["X_Forwarded_For"] = "X-Forwarded-For";
+    HttpHeaderCodes["X_Forwarded_For"] = "X-Forwarded-For";
     /**
      * Identifies the original host requested that a client used to connect to your proxy or load balancer.
      */
-    HttpHeaders["X_Forwarded_Host"] = "X-Forwarded-Host";
+    HttpHeaderCodes["X_Forwarded_Host"] = "X-Forwarded-Host";
     /**
      * Identifies the protocol (HTTP or HTTPS) that a client used to connect to your proxy or load balancer.
      */
-    HttpHeaders["X_Forwarded_Proto"] = "X-Forwarded-Proto";
+    HttpHeaderCodes["X_Forwarded_Proto"] = "X-Forwarded-Proto";
     /**
      * Added by proxies, both forward and reverse proxies, and can appear in the request headers and the response headers.
      */
-    HttpHeaders["Via"] = "Via";
+    HttpHeaderCodes["Via"] = "Via";
     /* *** Redirects *** */
     /**
      * Indicates the URL to redirect a page to.
      */
-    HttpHeaders["Location"] = "Location";
+    HttpHeaderCodes["Location"] = "Location";
     /* *** Request context *** */
     /**
      * Contains an Internet email address for a human user who controls the requesting user agent.
      */
-    HttpHeaders["From"] = "From";
+    HttpHeaderCodes["From"] = "From";
     /**
      * Specifies the domain name of the server (for virtual hosting), and (optionally)
      * the TCP port number on which the server is listening.
      */
-    HttpHeaders["Host"] = "Host";
+    HttpHeaderCodes["Host"] = "Host";
     /**
      * The address of the previous web page from which a link to the currently requested page was followed.
      */
-    HttpHeaders["Referer"] = "Referer";
+    HttpHeaderCodes["Referer"] = "Referer";
     /**
      * Governs which referrer information sent in the Referer header should be included with requests made.
      */
-    HttpHeaders["Referrer_Policy"] = "Referrer-Policy";
+    HttpHeaderCodes["Referrer_Policy"] = "Referrer-Policy";
     /**
      * Contains a characteristic string that allows the network protocol peers to identify the application type,
      * operating system, software vendor or software version of the requesting software user agent.
      */
-    HttpHeaders["User_Agent"] = "User-Agent";
+    HttpHeaderCodes["User_Agent"] = "User-Agent";
     /* *** Response context *** */
     /**
      * Lists the set of HTTP request methods supported by a resource.
      */
-    HttpHeaders["Allow"] = "Allow";
+    HttpHeaderCodes["Allow"] = "Allow";
     /**
      * Contains information about the software used by the origin server to handle the request.
      */
-    HttpHeaders["Server"] = "Server";
+    HttpHeaderCodes["Server"] = "Server";
     /* *** Range requests *** */
     /**
      * Indicates if the server supports range requests, and if so in which unit the range can be expressed.
      */
-    HttpHeaders["Accept_Ranges"] = "Accept-Ranges";
+    HttpHeaderCodes["Accept_Ranges"] = "Accept-Ranges";
     /**
      * Indicates the part of a document that the server should return.
      */
-    HttpHeaders["Range"] = "Range";
+    HttpHeaderCodes["Range"] = "Range";
     /**
      * Creates a conditional range request that is only fulfilled if the given etag or date matches
      * the remote resource. Used to prevent downloading two ranges from incompatible version of the resource.
      */
-    HttpHeaders["If_Range"] = "If-Range";
+    HttpHeaderCodes["If_Range"] = "If-Range";
     /**
      * Indicates where in a full body message a partial message belongs.
      */
-    HttpHeaders["Content_Range"] = "Content-Range";
+    HttpHeaderCodes["Content_Range"] = "Content-Range";
     /* *** Security *** */
     /**
      * Allows a server to declare an embedder policy for a given document.
      */
-    HttpHeaders["Cross_Origin_Embedder_Policy"] = "Cross-Origin-Embedder-Policy";
+    HttpHeaderCodes["Cross_Origin_Embedder_Policy"] = "Cross-Origin-Embedder-Policy";
     /**
      * Prevents other domains from opening/controlling a window.
      */
-    HttpHeaders["Cross_Origin_Opener_Policy"] = "Cross-Origin-Opener-Policy";
+    HttpHeaderCodes["Cross_Origin_Opener_Policy"] = "Cross-Origin-Opener-Policy";
     /**
      * Prevents other domains from reading the response of the resources to which this header is applied.
      */
-    HttpHeaders["Cross_Origin_Resource_Policy"] = "Cross-Origin-Resource-Policy";
+    HttpHeaderCodes["Cross_Origin_Resource_Policy"] = "Cross-Origin-Resource-Policy";
     /**
      * Controls resources the user agent is allowed to load for a given page.
      */
-    HttpHeaders["Content_Security_Policy"] = "Content-Security-Policy";
+    HttpHeaderCodes["Content_Security_Policy"] = "Content-Security-Policy";
     /**
      * Allows web developers to experiment with policies by monitoring, but not enforcing, their effects.
      * These violation reports consist of JSON documents sent via an HTTP POST request to the specified URI.
      */
-    HttpHeaders["Content_Security_Policy_Report_Only"] = "Content-Security-Policy-Report-Only";
+    HttpHeaderCodes["Content_Security_Policy_Report_Only"] = "Content-Security-Policy-Report-Only";
     /**
      * Allows sites to opt in to reporting and/or enforcement of Certificate Transparency requirements,
      * which prevents the use of misissued certificates for that site from going unnoticed.
      * When a site enables the Expect-CT header, they are requesting that Chrome check that
      * any certificate for that site appears in public CT logs.
      */
-    HttpHeaders["Expect_CT"] = "Expect-CT";
+    HttpHeaderCodes["Expect_CT"] = "Expect-CT";
     /**
      * Provides a mechanism to allow and deny the use of browser features in its own frame,
      * and in iframes that it embeds.
      */
-    HttpHeaders["Feature_Policy"] = "Feature-Policy";
+    HttpHeaderCodes["Feature_Policy"] = "Feature-Policy";
     /**
      * Force communication using HTTPS instead of HTTP.
      */
-    HttpHeaders["Strict_Transport_Security"] = "Strict-Transport-Security";
+    HttpHeaderCodes["Strict_Transport_Security"] = "Strict-Transport-Security";
     /**
      * Sends a signal to the server expressing the client's preference for an encrypted and authenticated response,
      * and that it can successfully handle the upgrade-insecure-requests directive.
      */
-    HttpHeaders["Upgrade_Insecure_Requests"] = "Upgrade-Insecure-Requests";
+    HttpHeaderCodes["Upgrade_Insecure_Requests"] = "Upgrade-Insecure-Requests";
     /**
      * Disables MIME sniffing and forces browser to use the type given in Content-Type.
      */
-    HttpHeaders["X_Content_Type_Options"] = "X-Content-Type-Options";
+    HttpHeaderCodes["X_Content_Type_Options"] = "X-Content-Type-Options";
     /**
      * The X-Download-Options HTTP header indicates that the browser (Internet Explorer)
      * should not display the option to "Open" a file that has been downloaded from an application,
      * to prevent phishing attacks as the file otherwise would gain access to execute in the context of the application.
      */
-    HttpHeaders["X_Download_Options"] = "X-Download-Options";
+    HttpHeaderCodes["X_Download_Options"] = "X-Download-Options";
     /**
      * Indicates whether a browser should be allowed to render a page in a <frame>, <iframe>, <embed> or <object>.
      */
-    HttpHeaders["X_Frame_Options"] = "X-Frame-Options";
+    HttpHeaderCodes["X_Frame_Options"] = "X-Frame-Options";
     /**
      * Specifies if a cross-domain policy file (crossdomain.xml) is allowed.
      * The file may define a policy to grant clients, such as Adobe's Flash Player (now obsolete),
@@ -4143,182 +4155,182 @@ exports.HttpHeaders = void 0;
      * permission to handle data across domains that would otherwise be restricted
      * due to the Same-Origin Policy. See the Cross-domain Policy File Specification for more information.
      */
-    HttpHeaders["X_Permitted_Cross_Domain_Policies"] = "X-Permitted-Cross-Domain-Policies";
+    HttpHeaderCodes["X_Permitted_Cross_Domain_Policies"] = "X-Permitted-Cross-Domain-Policies";
     /**
      * May be set by hosting environments or other frameworks and contains information about
      * them while not providing any usefulness to the application or its visitors.
      * Unset this header to avoid exposing potential vulnerabilities.
      */
-    HttpHeaders["X_Powered_By"] = "X-Powered-By";
+    HttpHeaderCodes["X_Powered_By"] = "X-Powered-By";
     /**
      * Enables cross-site scripting filtering.
      */
-    HttpHeaders["X_XSS_Protection"] = "X-XSS-Protection";
+    HttpHeaderCodes["X_XSS_Protection"] = "X-XSS-Protection";
     /* *** Transfer coding *** */
     /**
      * Specifies the form of encoding used to safely transfer the resource to the user.
      */
-    HttpHeaders["Transfer_Encoding"] = "Transfer-Encoding";
+    HttpHeaderCodes["Transfer_Encoding"] = "Transfer-Encoding";
     /**
      * Specifies the transfer encodings the user agent is willing to accept.
      */
-    HttpHeaders["TE"] = "TE";
+    HttpHeaderCodes["TE"] = "TE";
     /**
      * Allows the sender to include additional fields at the end of chunked message.
      */
-    HttpHeaders["Trailer"] = "Trailer";
+    HttpHeaderCodes["Trailer"] = "Trailer";
     /* *** WebSockets *** */
-    HttpHeaders["Sec_WebSocket_Key"] = "Sec-WebSocket-Key";
-    HttpHeaders["Sec_WebSocket_Extensions"] = "Sec-WebSocket-Extensions";
-    HttpHeaders["Sec_WebSocket_Accept"] = "Sec-WebSocket-Accept";
-    HttpHeaders["Sec_WebSocket_Protocol"] = "Sec-WebSocket-Protocol";
-    HttpHeaders["Sec_WebSocket_Version"] = "Sec-WebSocket-Version";
+    HttpHeaderCodes["Sec_WebSocket_Key"] = "Sec-WebSocket-Key";
+    HttpHeaderCodes["Sec_WebSocket_Extensions"] = "Sec-WebSocket-Extensions";
+    HttpHeaderCodes["Sec_WebSocket_Accept"] = "Sec-WebSocket-Accept";
+    HttpHeaderCodes["Sec_WebSocket_Protocol"] = "Sec-WebSocket-Protocol";
+    HttpHeaderCodes["Sec_WebSocket_Version"] = "Sec-WebSocket-Version";
     /* *** Other *** */
     /**
      * Contains the date and time at which the message was originated.
      */
-    HttpHeaders["Date"] = "Date";
+    HttpHeaderCodes["Date"] = "Date";
     /**
      * Indicates how long the user agent should wait before making a follow-up request.
      */
-    HttpHeaders["Retry_After"] = "Retry-After";
+    HttpHeaderCodes["Retry_After"] = "Retry-After";
     /**
      * Communicates one or more metrics and descriptions for the given request-response cycle.
      */
-    HttpHeaders["Server_Timing"] = "Server-Timing";
+    HttpHeaderCodes["Server_Timing"] = "Server-Timing";
     /**
      * Controls DNS prefetching, a feature by which browsers proactively perform domain name
      * resolution on both links that the user may choose to follow as well as URLs for items
      * referenced by the document, including images, CSS, JavaScript, and so forth.
      */
-    HttpHeaders["X_DNS_Prefetch_Control"] = "X-DNS-Prefetch-Control";
-})(exports.HttpHeaders || (exports.HttpHeaders = {}));
+    HttpHeaderCodes["X_DNS_Prefetch_Control"] = "X-DNS-Prefetch-Control";
+})(exports.HttpHeaderCodes || (exports.HttpHeaderCodes = {}));
 
 // noinspection JSUnusedGlobalSymbols
 /**
  * https://developer.mozilla.org/en-US/docs/Web/HTTP/Status#successful_responses
  */
-exports.HttpStatus = void 0;
-(function (HttpStatus) {
+exports.HttpStatusCodes = void 0;
+(function (HttpStatusCodes) {
     /* *** Information responses *** */
     /**
      * This interim response indicates that the client should continue the request or
      * ignore the response if the request is already finished.
      */
-    HttpStatus[HttpStatus["CONTINUE"] = 100] = "CONTINUE";
+    HttpStatusCodes[HttpStatusCodes["CONTINUE"] = 100] = "CONTINUE";
     /**
      * This code is sent in response to an Upgrade request header from the client and
      * indicates the protocol the server is switching to.
      */
-    HttpStatus[HttpStatus["SWITCHING_PROTOCOLS"] = 101] = "SWITCHING_PROTOCOLS";
+    HttpStatusCodes[HttpStatusCodes["SWITCHING_PROTOCOLS"] = 101] = "SWITCHING_PROTOCOLS";
     /**
      * This code indicates that the server has received and is processing the request, but no response is available yet.
      */
-    HttpStatus[HttpStatus["PROCESSING"] = 102] = "PROCESSING";
+    HttpStatusCodes[HttpStatusCodes["PROCESSING"] = 102] = "PROCESSING";
     /**
      * This status code is primarily intended to be used with the Link header, letting the user agent
      * start preloading resources while the server prepares a response.
      */
-    HttpStatus[HttpStatus["EARLYHINTS"] = 103] = "EARLYHINTS";
+    HttpStatusCodes[HttpStatusCodes["EARLYHINTS"] = 103] = "EARLYHINTS";
     /* *** Successful responses *** */
     /**
      * The request succeeded.
      */
-    HttpStatus[HttpStatus["OK"] = 200] = "OK";
+    HttpStatusCodes[HttpStatusCodes["OK"] = 200] = "OK";
     /**
      * The request succeeded, and a new resource was created as a result.
      * This is typically the response sent after POST requests, or some PUT requests.
      */
-    HttpStatus[HttpStatus["CREATED"] = 201] = "CREATED";
+    HttpStatusCodes[HttpStatusCodes["CREATED"] = 201] = "CREATED";
     /**
      * The request has been received but not yet acted upon. It is noncommittal,
      * since there is no way in HTTP to later send an asynchronous response indicating
      * the outcome of the request. It is intended for cases where another process or
      * server handles the request, or for batch processing.
      */
-    HttpStatus[HttpStatus["ACCEPTED"] = 202] = "ACCEPTED";
+    HttpStatusCodes[HttpStatusCodes["ACCEPTED"] = 202] = "ACCEPTED";
     /**
      * This response code means the returned metadata is not exactly the same as is available from
      * the origin server, but is collected from a local or a third-party copy. This is mostly used
      * for mirrors or backups of another resource. Except for that specific case, the 200 OK
      * response is preferred to this status.
      */
-    HttpStatus[HttpStatus["NON_AUTHORITATIVE_INFORMATION"] = 203] = "NON_AUTHORITATIVE_INFORMATION";
+    HttpStatusCodes[HttpStatusCodes["NON_AUTHORITATIVE_INFORMATION"] = 203] = "NON_AUTHORITATIVE_INFORMATION";
     /**
      * There is no content to send for this request, but the headers may be useful.
      * The user agent may update its cached headers for this resource with the new ones.
      */
-    HttpStatus[HttpStatus["NO_CONTENT"] = 204] = "NO_CONTENT";
+    HttpStatusCodes[HttpStatusCodes["NO_CONTENT"] = 204] = "NO_CONTENT";
     /**
      * Tells the user agent to reset the document which sent this request.
      */
-    HttpStatus[HttpStatus["RESET_CONTENT"] = 205] = "RESET_CONTENT";
+    HttpStatusCodes[HttpStatusCodes["RESET_CONTENT"] = 205] = "RESET_CONTENT";
     /**
      * This response code is used when the Range header is sent from the client to request only part of a resource.
      */
-    HttpStatus[HttpStatus["PARTIAL_CONTENT"] = 206] = "PARTIAL_CONTENT";
+    HttpStatusCodes[HttpStatusCodes["PARTIAL_CONTENT"] = 206] = "PARTIAL_CONTENT";
     /* *** Redirection messages *** */
     /**
      * The request has more than one possible response. The user agent or user should choose one of them.
      * (There is no standardized way of choosing one of the responses, but HTML links to the possibilities
      * are recommended so the user can pick.)
      */
-    HttpStatus[HttpStatus["AMBIGUOUS"] = 300] = "AMBIGUOUS";
+    HttpStatusCodes[HttpStatusCodes["AMBIGUOUS"] = 300] = "AMBIGUOUS";
     /**
      * The URL of the requested resource has been changed permanently. The new URL is given in the response.
      */
-    HttpStatus[HttpStatus["MOVED_PERMANENTLY"] = 301] = "MOVED_PERMANENTLY";
+    HttpStatusCodes[HttpStatusCodes["MOVED_PERMANENTLY"] = 301] = "MOVED_PERMANENTLY";
     /**
      * This response code means that the URI of requested resource has been changed temporarily.
      * Further changes in the URI might be made in the future. Therefore, this same URI should
      * be used by the client in future requests.
      */
-    HttpStatus[HttpStatus["FOUND"] = 302] = "FOUND";
+    HttpStatusCodes[HttpStatusCodes["FOUND"] = 302] = "FOUND";
     /**
      * This is used for caching purposes. It tells the client that the response has not been modified,
      * so the client can continue to use the same cached version of the response.
      */
-    HttpStatus[HttpStatus["SEE_OTHER"] = 303] = "SEE_OTHER";
+    HttpStatusCodes[HttpStatusCodes["SEE_OTHER"] = 303] = "SEE_OTHER";
     /**
      *
      */
-    HttpStatus[HttpStatus["NOT_MODIFIED"] = 304] = "NOT_MODIFIED";
+    HttpStatusCodes[HttpStatusCodes["NOT_MODIFIED"] = 304] = "NOT_MODIFIED";
     /**
      * The server sends this response to direct the client to get the requested resource at another
      * URI with same method that was used in the prior request. This has the same semantics as
      * the 302 Found HTTP response code, with the exception that the user agent must not change
      * the HTTP method used: if a POST was used in the first request, a POST must be used in the second request.
      */
-    HttpStatus[HttpStatus["TEMPORARY_REDIRECT"] = 307] = "TEMPORARY_REDIRECT";
+    HttpStatusCodes[HttpStatusCodes["TEMPORARY_REDIRECT"] = 307] = "TEMPORARY_REDIRECT";
     /**
      * This means that the resource is now permanently located at another URI, specified by the Location:
      * HTTP Response header. This has the same semantics as the 301 Moved Permanently HTTP response code,
      * with the exception that the user agent must not change the HTTP method used: if a POST was used
      * in the first request, a POST must be used in the second request.
      */
-    HttpStatus[HttpStatus["PERMANENT_REDIRECT"] = 308] = "PERMANENT_REDIRECT";
+    HttpStatusCodes[HttpStatusCodes["PERMANENT_REDIRECT"] = 308] = "PERMANENT_REDIRECT";
     /* *** Client error responses *** */
     /**
      * The server cannot or will not process the request due to something that is perceived to be a client error
      * (e.g., malformed request syntax, invalid request message framing, or deceptive request routing).
      */
-    HttpStatus[HttpStatus["BAD_REQUEST"] = 400] = "BAD_REQUEST";
+    HttpStatusCodes[HttpStatusCodes["BAD_REQUEST"] = 400] = "BAD_REQUEST";
     /**
      * Although the HTTP standard specifies "unauthorized", semantically this response means "unauthenticated".
      * That is, the client must authenticate itself to get the requested response.
      */
-    HttpStatus[HttpStatus["UNAUTHORIZED"] = 401] = "UNAUTHORIZED";
+    HttpStatusCodes[HttpStatusCodes["UNAUTHORIZED"] = 401] = "UNAUTHORIZED";
     /**
      * This response code is reserved for future use. The initial aim for creating this code was using
      * it for digital payment systems, however this status code is used very rarely and no standard convention exists.
      */
-    HttpStatus[HttpStatus["PAYMENT_REQUIRED"] = 402] = "PAYMENT_REQUIRED";
+    HttpStatusCodes[HttpStatusCodes["PAYMENT_REQUIRED"] = 402] = "PAYMENT_REQUIRED";
     /**
      * The client does not have access rights to the content; that is, it is unauthorized,
      * so the server is refusing to give the requested resource. Unlike 401 Unauthorized,
      * the client's identity is known to the server.
      */
-    HttpStatus[HttpStatus["FORBIDDEN"] = 403] = "FORBIDDEN";
+    HttpStatusCodes[HttpStatusCodes["FORBIDDEN"] = 403] = "FORBIDDEN";
     /**
      * The server can not find the requested resource. In the browser, this means the URL is not recognized.
      * In an API, this can also mean that the endpoint is valid but the resource itself does not exist.
@@ -4326,21 +4338,21 @@ exports.HttpStatus = void 0;
      * from an unauthorized client. This response code is probably the most well known due to its
      * frequent occurrence on the web.
      */
-    HttpStatus[HttpStatus["NOT_FOUND"] = 404] = "NOT_FOUND";
+    HttpStatusCodes[HttpStatusCodes["NOT_FOUND"] = 404] = "NOT_FOUND";
     /**
      * The request method is known by the server but is not supported by the target resource.
      * For example, an API may not allow calling DELETE to remove a resource.
      */
-    HttpStatus[HttpStatus["METHOD_NOT_ALLOWED"] = 405] = "METHOD_NOT_ALLOWED";
+    HttpStatusCodes[HttpStatusCodes["METHOD_NOT_ALLOWED"] = 405] = "METHOD_NOT_ALLOWED";
     /**
      * This response is sent when the web server, after performing server-driven content negotiation,
      * doesn't find any content that conforms to the criteria given by the user agent.
      */
-    HttpStatus[HttpStatus["NOT_ACCEPTABLE"] = 406] = "NOT_ACCEPTABLE";
+    HttpStatusCodes[HttpStatusCodes["NOT_ACCEPTABLE"] = 406] = "NOT_ACCEPTABLE";
     /**
      * This is similar to 401 Unauthorized but authentication is needed to be done by a proxy.
      */
-    HttpStatus[HttpStatus["PROXY_AUTHENTICATION_REQUIRED"] = 407] = "PROXY_AUTHENTICATION_REQUIRED";
+    HttpStatusCodes[HttpStatusCodes["PROXY_AUTHENTICATION_REQUIRED"] = 407] = "PROXY_AUTHENTICATION_REQUIRED";
     /**
      * This response is sent on an idle connection by some servers, even without any previous request by the client.
      * It means that the server would like to shut down this unused connection.
@@ -4348,107 +4360,107 @@ exports.HttpStatus = void 0;
      * like Chrome, Firefox 27+, or IE9, use HTTP pre-connection mechanisms to speed up surfing.
      * Also note that some servers merely shut down the connection without sending this message.
      */
-    HttpStatus[HttpStatus["REQUEST_TIMEOUT"] = 408] = "REQUEST_TIMEOUT";
+    HttpStatusCodes[HttpStatusCodes["REQUEST_TIMEOUT"] = 408] = "REQUEST_TIMEOUT";
     /**
      * This response is sent when a request conflicts with the current state of the server.
      */
-    HttpStatus[HttpStatus["CONFLICT"] = 409] = "CONFLICT";
+    HttpStatusCodes[HttpStatusCodes["CONFLICT"] = 409] = "CONFLICT";
     /**
      * This response is sent when the requested content has been permanently deleted from server,
      * with no forwarding address. Clients are expected to remove their caches and links to the resource.
      * The HTTP specification intends this status code to be used for "limited-time, promotional services".
      * APIs should not feel compelled to indicate resources that have been deleted with this status code.
      */
-    HttpStatus[HttpStatus["GONE"] = 410] = "GONE";
+    HttpStatusCodes[HttpStatusCodes["GONE"] = 410] = "GONE";
     /**
      * Server rejected the request because the Content-Length header field is not defined and the server requires it.
      */
-    HttpStatus[HttpStatus["LENGTH_REQUIRED"] = 411] = "LENGTH_REQUIRED";
+    HttpStatusCodes[HttpStatusCodes["LENGTH_REQUIRED"] = 411] = "LENGTH_REQUIRED";
     /**
      * The client has indicated preconditions in its headers which the server does not meet.
      */
-    HttpStatus[HttpStatus["PRECONDITION_FAILED"] = 412] = "PRECONDITION_FAILED";
+    HttpStatusCodes[HttpStatusCodes["PRECONDITION_FAILED"] = 412] = "PRECONDITION_FAILED";
     /**
      * Request entity is larger than limits defined by server. The server might close the connection or
      * return an Retry-After header field.
      */
-    HttpStatus[HttpStatus["PAYLOAD_TOO_LARGE"] = 413] = "PAYLOAD_TOO_LARGE";
+    HttpStatusCodes[HttpStatusCodes["PAYLOAD_TOO_LARGE"] = 413] = "PAYLOAD_TOO_LARGE";
     /**
      * The URI requested by the client is longer than the server is willing to interpret.
      */
-    HttpStatus[HttpStatus["URI_TOO_LONG"] = 414] = "URI_TOO_LONG";
+    HttpStatusCodes[HttpStatusCodes["URI_TOO_LONG"] = 414] = "URI_TOO_LONG";
     /**
      * The media format of the requested data is not supported by the server, so the server is rejecting the request.
      */
-    HttpStatus[HttpStatus["UNSUPPORTED_MEDIA_TYPE"] = 415] = "UNSUPPORTED_MEDIA_TYPE";
+    HttpStatusCodes[HttpStatusCodes["UNSUPPORTED_MEDIA_TYPE"] = 415] = "UNSUPPORTED_MEDIA_TYPE";
     /**
      * The range specified by the Range header field in the request cannot be fulfilled.
      * It's possible that the range is outside the size of the target URI's data.
      */
-    HttpStatus[HttpStatus["REQUESTED_RANGE_NOT_SATISFIABLE"] = 416] = "REQUESTED_RANGE_NOT_SATISFIABLE";
+    HttpStatusCodes[HttpStatusCodes["REQUESTED_RANGE_NOT_SATISFIABLE"] = 416] = "REQUESTED_RANGE_NOT_SATISFIABLE";
     /**
      * This response code means the expectation indicated by the Expect request header field cannot be met by the server.
      */
-    HttpStatus[HttpStatus["EXPECTATION_FAILED"] = 417] = "EXPECTATION_FAILED";
+    HttpStatusCodes[HttpStatusCodes["EXPECTATION_FAILED"] = 417] = "EXPECTATION_FAILED";
     /**
      * The server refuses the attempt to brew coffee with a teapot.
      */
-    HttpStatus[HttpStatus["I_AM_A_TEAPOT"] = 418] = "I_AM_A_TEAPOT";
+    HttpStatusCodes[HttpStatusCodes["I_AM_A_TEAPOT"] = 418] = "I_AM_A_TEAPOT";
     /**
      * The request was directed at a server that is not able to produce a response.
      * This can be sent by a server that is not configured to produce responses for
      * the combination of scheme and authority that are included in the request URI.
      */
-    HttpStatus[HttpStatus["MISDIRECTED_REQUEST"] = 421] = "MISDIRECTED_REQUEST";
+    HttpStatusCodes[HttpStatusCodes["MISDIRECTED_REQUEST"] = 421] = "MISDIRECTED_REQUEST";
     /**
      * The request was well-formed but was unable to be followed due to semantic errors.
      */
-    HttpStatus[HttpStatus["UNPROCESSABLE_ENTITY"] = 422] = "UNPROCESSABLE_ENTITY";
+    HttpStatusCodes[HttpStatusCodes["UNPROCESSABLE_ENTITY"] = 422] = "UNPROCESSABLE_ENTITY";
     /**
      * The resource that is being accessed is locked.
      */
-    HttpStatus[HttpStatus["LOCKED"] = 423] = "LOCKED";
+    HttpStatusCodes[HttpStatusCodes["LOCKED"] = 423] = "LOCKED";
     /**
      * The request failed due to failure of a previous request.
      */
-    HttpStatus[HttpStatus["FAILED_DEPENDENCY"] = 424] = "FAILED_DEPENDENCY";
+    HttpStatusCodes[HttpStatusCodes["FAILED_DEPENDENCY"] = 424] = "FAILED_DEPENDENCY";
     /**
      * Indicates that the server is unwilling to risk processing a request that might be replayed.
      */
-    HttpStatus[HttpStatus["TOO_EARLY"] = 425] = "TOO_EARLY";
+    HttpStatusCodes[HttpStatusCodes["TOO_EARLY"] = 425] = "TOO_EARLY";
     /**
      * The server refuses to perform the request using the current protocol but might be willing
      * to do so after the client upgrades to a different protocol. The server sends an Upgrade
      * header in a 426 response to indicate the required protocol(s).
      */
-    HttpStatus[HttpStatus["UPGRADE_REQUIRED"] = 428] = "UPGRADE_REQUIRED";
+    HttpStatusCodes[HttpStatusCodes["UPGRADE_REQUIRED"] = 428] = "UPGRADE_REQUIRED";
     /**
      * The origin server requires the request to be conditional. This response is intended to prevent
      * the 'lost update' problem, where a client GETs a resource's state, modifies it and PUTs
      * it back to the server, when meanwhile a third party has modified the state on the server,
      * leading to a conflict.
      */
-    HttpStatus[HttpStatus["PRECONDITION_REQUIRED"] = 428] = "PRECONDITION_REQUIRED";
+    HttpStatusCodes[HttpStatusCodes["PRECONDITION_REQUIRED"] = 428] = "PRECONDITION_REQUIRED";
     /**
      * The user has sent too many requests in a given amount of time ("rate limiting").
      */
-    HttpStatus[HttpStatus["TOO_MANY_REQUESTS"] = 429] = "TOO_MANY_REQUESTS";
+    HttpStatusCodes[HttpStatusCodes["TOO_MANY_REQUESTS"] = 429] = "TOO_MANY_REQUESTS";
     /* *** Server error responses *** */
     /**
      * The server has encountered a situation it does not know how to handle.
      */
-    HttpStatus[HttpStatus["INTERNAL_SERVER_ERROR"] = 500] = "INTERNAL_SERVER_ERROR";
+    HttpStatusCodes[HttpStatusCodes["INTERNAL_SERVER_ERROR"] = 500] = "INTERNAL_SERVER_ERROR";
     /**
      * The request method is not supported by the server and cannot be handled.
      * The only methods that servers are required to support (and therefore that must not return this code)
      * are GET and HEAD.
      */
-    HttpStatus[HttpStatus["NOT_IMPLEMENTED"] = 501] = "NOT_IMPLEMENTED";
+    HttpStatusCodes[HttpStatusCodes["NOT_IMPLEMENTED"] = 501] = "NOT_IMPLEMENTED";
     /**
      * This error response means that the server, while working as a gateway to get
      * a response needed to handle the request, got an invalid response.
      */
-    HttpStatus[HttpStatus["BAD_GATEWAY"] = 502] = "BAD_GATEWAY";
+    HttpStatusCodes[HttpStatusCodes["BAD_GATEWAY"] = 502] = "BAD_GATEWAY";
     /**
      * The server is not ready to handle the request. Common causes are a server that is down for maintenance
      * or that is overloaded. Note that together with this response, a user-friendly page explaining
@@ -4458,49 +4470,49 @@ exports.HttpStatus = void 0;
      * headers that are sent along with this response, as these temporary condition responses
      * should usually not be cached.
      */
-    HttpStatus[HttpStatus["SERVICE_UNAVAILABLE"] = 503] = "SERVICE_UNAVAILABLE";
+    HttpStatusCodes[HttpStatusCodes["SERVICE_UNAVAILABLE"] = 503] = "SERVICE_UNAVAILABLE";
     /**
      * This error response is given when the server is acting as a gateway and cannot get a response in time.
      */
-    HttpStatus[HttpStatus["GATEWAY_TIMEOUT"] = 504] = "GATEWAY_TIMEOUT";
+    HttpStatusCodes[HttpStatusCodes["GATEWAY_TIMEOUT"] = 504] = "GATEWAY_TIMEOUT";
     /**
      * The HTTP version used in the request is not supported by the server.
      */
-    HttpStatus[HttpStatus["HTTP_VERSION_NOT_SUPPORTED"] = 505] = "HTTP_VERSION_NOT_SUPPORTED";
+    HttpStatusCodes[HttpStatusCodes["HTTP_VERSION_NOT_SUPPORTED"] = 505] = "HTTP_VERSION_NOT_SUPPORTED";
     /**
      * The server has an internal configuration error: the chosen variant resource is configured
      * to engage in transparent content negotiation itself, and is therefore not a proper end
      * point in the negotiation process.
      */
-    HttpStatus[HttpStatus["VARIANT_ALSO_NEGOTIATES"] = 506] = "VARIANT_ALSO_NEGOTIATES";
+    HttpStatusCodes[HttpStatusCodes["VARIANT_ALSO_NEGOTIATES"] = 506] = "VARIANT_ALSO_NEGOTIATES";
     /**
      * The method could not be performed on the resource because the server is unable to store
      * the representation needed to successfully complete the request.
      */
-    HttpStatus[HttpStatus["INSUFFICIENT_STORAGE"] = 507] = "INSUFFICIENT_STORAGE";
+    HttpStatusCodes[HttpStatusCodes["INSUFFICIENT_STORAGE"] = 507] = "INSUFFICIENT_STORAGE";
     /**
      * The server detected an infinite loop while processing the request.
      */
-    HttpStatus[HttpStatus["LOOP_DETECTED"] = 508] = "LOOP_DETECTED";
+    HttpStatusCodes[HttpStatusCodes["LOOP_DETECTED"] = 508] = "LOOP_DETECTED";
     /**
      * Further extensions to the request are required for the server to fulfill it.
      */
-    HttpStatus[HttpStatus["NOT_EXTENDED"] = 510] = "NOT_EXTENDED";
+    HttpStatusCodes[HttpStatusCodes["NOT_EXTENDED"] = 510] = "NOT_EXTENDED";
     /**
      * Indicates that the client needs to authenticate to gain network access.
      */
-    HttpStatus[HttpStatus["NETWORK_AUTHENTICATION_REQUIRED"] = 511] = "NETWORK_AUTHENTICATION_REQUIRED";
-})(exports.HttpStatus || (exports.HttpStatus = {}));
+    HttpStatusCodes[HttpStatusCodes["NETWORK_AUTHENTICATION_REQUIRED"] = 511] = "NETWORK_AUTHENTICATION_REQUIRED";
+})(exports.HttpStatusCodes || (exports.HttpStatusCodes = {}));
 
-const knownKeys = Object.keys(exports.HttpHeaders);
-const knownKeysLower = knownKeys.map(x => x.toLowerCase());
+const knownKeys$1 = Object.keys(exports.HttpHeaderCodes);
+const knownKeysLower$1 = knownKeys$1.map(x => x.toLowerCase());
 function normalizeHeaders(headers, normalCase) {
     if (!headers)
         return {};
     return Object.keys(headers).reduce((o, k) => {
         const v = headers[k];
         const key = normalCase
-            ? knownKeys[knownKeysLower.indexOf(k.toLowerCase())] || camelize(k) :
+            ? knownKeys$1[knownKeysLower$1.indexOf(k.toLowerCase())] || camelize(k) :
             k.toLowerCase();
         if (k.toLowerCase() === 'set-cookie')
             o[key] = Array.isArray(v) ? v : [v];
@@ -4543,11 +4555,11 @@ class BatchMultipart {
     addRequestPart(content, part) {
         const headers = {
             ...normalizeHeaders(part?.headers || {}, true),
-            [exports.HttpHeaders.Content_Type]: 'application/http',
-            [exports.HttpHeaders.Content_Transfer_Encoding]: 'binary'
+            [exports.HttpHeaderCodes.Content_Type]: 'application/http',
+            [exports.HttpHeaderCodes.Content_Transfer_Encoding]: 'binary'
         };
         if (part?.contentId)
-            headers[exports.HttpHeaders.Content_ID] = part.contentId;
+            headers[exports.HttpHeaderCodes.Content_ID] = part.contentId;
         this._parts.push({
             headers,
             contentId: part?.contentId,
@@ -4558,11 +4570,11 @@ class BatchMultipart {
     addHttpResponse(content, part) {
         const headers = {
             ...normalizeHeaders(part?.headers || {}, true),
-            [exports.HttpHeaders.Content_Type]: 'application/http',
-            [exports.HttpHeaders.Content_Transfer_Encoding]: 'binary'
+            [exports.HttpHeaderCodes.Content_Type]: 'application/http',
+            [exports.HttpHeaderCodes.Content_Transfer_Encoding]: 'binary'
         };
         if (part?.contentId)
-            headers[exports.HttpHeaders.Content_ID] = part.contentId;
+            headers[exports.HttpHeaderCodes.Content_ID] = part.contentId;
         this._parts.push({
             headers,
             contentId: part?.contentId,
@@ -4573,11 +4585,11 @@ class BatchMultipart {
     addBatch(batch, part) {
         const headers = {
             ...normalizeHeaders(part?.headers || {}, true),
-            [exports.HttpHeaders.Content_Type]: 'application/http',
-            [exports.HttpHeaders.Content_Transfer_Encoding]: 'binary'
+            [exports.HttpHeaderCodes.Content_Type]: 'application/http',
+            [exports.HttpHeaderCodes.Content_Transfer_Encoding]: 'binary'
         };
         if (part?.contentId)
-            headers[exports.HttpHeaders.Content_ID] = part.contentId;
+            headers[exports.HttpHeaderCodes.Content_ID] = part.contentId;
         this._parts.push({
             headers,
             contentId: part?.contentId,
@@ -4649,7 +4661,7 @@ class BatchMultipart {
                 if (part.content instanceof HttpRequestContent)
                     s += (part.content.method || 'GET').toUpperCase() + ' ' + part.content.url + ' HTTP/1.1' + CRLF;
                 else
-                    s += 'HTTP/1.1 ' + part.content.status + (exports.HttpStatus[part.content.status] || 'Unknown') + CRLF;
+                    s += 'HTTP/1.1 ' + part.content.status + (exports.HttpStatusCodes[part.content.status] || 'Unknown') + CRLF;
                 if (part.content.headers) {
                     for (const [k, v] of Object.entries(part.content.headers)) {
                         if (v === '' || v == null)
@@ -4881,45 +4893,58 @@ function OprSearchResolver(options) {
     };
 }
 
+var _a$4, _b$2, _c$1, _d;
+function isMap(v) {
+    return v && typeof v.forEach === 'function';
+}
+const kKeyMap = Symbol('kKeyMap');
+const kKeyOrder = Symbol('kKeyOrder');
+const kWellKnownKeys = Symbol('kWellKnownKeys');
+const kOptions$3 = Symbol('kOptions');
+/**
+ * A Map implementation that supports case-insensitivity and ordered keys
+ */
 class ResponsiveMap extends Map {
-    constructor(data, wellKnownKeys) {
+    constructor(init, options) {
         super();
-        this._keyMap = new Map();
-        this._keyOrder = [];
-        this._wellKnownKeyMap = new Map();
-        if (wellKnownKeys)
-            wellKnownKeys.forEach(k => this._wellKnownKeyMap.set(k.toLowerCase(), k));
-        if (typeof data?.forEach === 'function') {
-            data.forEach((v, k) => this.set(k, v));
-        }
-        else if (data && typeof data === 'object')
-            Object.keys(data).forEach(k => this.set(k, data[k]));
+        this[_a$4] = new Map();
+        this[_b$2] = [];
+        this[_c$1] = new Map();
+        this[_d] = { caseSensitive: false };
+        this[kOptions$3].caseSensitive = !!options?.caseSensitive;
+        if (options?.wellKnownKeys)
+            options.wellKnownKeys.forEach(k => this[kWellKnownKeys].set(k.toLowerCase(), k));
+        if (isMap(init)) {
+            init.forEach((v, k) => this.set(k, v));
+        }
+        else if (init && typeof init === 'object')
+            Object.keys(init).forEach(k => this.set(k, init[k]));
     }
     clear() {
         super.clear();
-        this._keyMap.clear();
-        this._keyOrder = [];
+        this[kKeyMap].clear();
+        this[kKeyOrder] = [];
     }
     get(key) {
         const orgKey = this._getOriginalKey(key);
         return super.get(orgKey);
     }
     has(key) {
-        return this._keyMap.has(this._getLowerKey(key));
+        return this[kKeyMap].has(this._getStoringKey(key));
     }
     set(key, value) {
         key = this._getOriginalKey(key);
-        this._keyMap.set(this._getLowerKey(key), key);
-        if (!this._keyOrder.includes(key))
-            this._keyOrder.push(key);
+        this[kKeyMap].set(this._getStoringKey(key), key);
+        if (!this[kKeyOrder].includes(key))
+            this[kKeyOrder].push(key);
         return super.set(key, value);
     }
     keys() {
-        return this._keyOrder.values();
+        return this[kKeyOrder].values();
     }
     values() {
         let i = -1;
-        const arr = this._keyOrder;
+        const arr = this[kKeyOrder];
         const map = this;
         return {
             [Symbol.iterator]() {
@@ -4936,7 +4961,7 @@ class ResponsiveMap extends Map {
     }
     entries() {
         let i = -1;
-        const arr = this._keyOrder;
+        const arr = this[kKeyOrder];
         const map = this;
         return {
             [Symbol.iterator]() {
@@ -4953,27 +4978,31 @@ class ResponsiveMap extends Map {
     }
     delete(key) {
         const orgKey = this._getOriginalKey(key);
-        const k = this._getLowerKey(key);
-        this._keyMap.delete(k);
-        const i = this._keyOrder.indexOf(orgKey);
+        const k = this._getStoringKey(key);
+        this[kKeyMap].delete(k);
+        const i = this[kKeyOrder].indexOf(orgKey);
         if (i >= 0)
-            this._keyOrder.splice(i, 1);
+            this[kKeyOrder].splice(i, 1);
         return super.delete(orgKey);
     }
     sort(compareFn) {
-        this._keyOrder.sort(compareFn);
+        this[kKeyOrder].sort(compareFn);
         return this;
     }
-    [Symbol.iterator]() {
+    [(_a$4 = kKeyMap, _b$2 = kKeyOrder, _c$1 = kWellKnownKeys, _d = kOptions$3, Symbol.iterator)]() {
         return this.entries();
     }
     _getOriginalKey(key) {
+        if (this[kOptions$3].caseSensitive)
+            return key;
         if (typeof key === 'string')
-            return this._keyMap.get(key.toLowerCase()) ??
-                (this._wellKnownKeyMap.get(key.toLowerCase()) ?? key);
+            return this[kKeyMap].get(key.toLowerCase()) ??
+                (this[kWellKnownKeys].get(key.toLowerCase()) ?? key);
         return key;
     }
-    _getLowerKey(key) {
+    _getStoringKey(key) {
+        if (this[kOptions$3].caseSensitive)
+            return key;
         if (typeof key === 'string')
             return key.toLowerCase();
         return key;
@@ -5479,6 +5508,9 @@ class DataType {
     get ctor() {
         return this._metadata.ctor;
     }
+    get isBuiltin() {
+        return builtInTypes.has(this._name);
+    }
     parse(value) {
         return this._metadata.parse ? this._metadata.parse(value) : value;
     }
@@ -5726,6 +5758,9 @@ class CollectionResourceInfo extends ResourceInfo {
             metadata.search.sortFields = normalizeFieldArray(document, dataType, metadata.search.sortFields);
         }
     }
+    get instance() {
+        return this.metadata.instance;
+    }
     get keyFields() {
         return this.metadata.keyFields;
     }
@@ -5753,6 +5788,18 @@ class CollectionResourceInfo extends ResourceInfo {
     get search() {
         return this.metadata.search;
     }
+    getHandlerNames() {
+        const out = [];
+        collectionMethods.forEach(m => {
+            if (this.metadata[m])
+                out.push(m);
+        });
+        return out;
+    }
+    getHandler(method) {
+        const r = this.metadata[method];
+        return r && r.handler;
+    }
     getSchema(jsonOnly) {
         const out = super.getSchema(jsonOnly);
         if (out.keyFields.length < 2)
@@ -5785,6 +5832,14 @@ class SingletonResourceInfo extends ResourceInfo {
     get update() {
         return this.metadata.update;
     }
+    getHandlerNames() {
+        const out = [];
+        singletonMethods.forEach(m => {
+            if (this.metadata[m])
+                out.push(m);
+        });
+        return out;
+    }
     getSchema(jsonOnly) {
         const out = super.getSchema(jsonOnly);
         for (const k of singletonMethods) {
@@ -5824,25 +5879,25 @@ class OpraDocument {
         const t = this.types.get(name);
         if (t)
             return t;
-        throw new Error(`Data type "${name}" does not exists`);
+        throw new NotFoundError(`Data type "${name}" does not exists`);
     }
     getComplexDataType(name) {
         const t = this.getDataType(name);
         if (t && t instanceof ComplexType)
             return t;
-        throw new Error(`Data type "${name}" is not a ComplexType`);
+        throw new NotAcceptableError(`Data type "${name}" is not a ComplexType`);
     }
     getSimpleDataType(name) {
         const t = this.getDataType(name);
         if (t && t instanceof SimpleType)
             return t;
-        throw new Error(`Data type "${name}" is not a SimpleType`);
+        throw new NotAcceptableError(`Data type "${name}" is not a SimpleType`);
     }
     getUnionDataType(name) {
         const t = this.getDataType(name);
         if (t && t instanceof UnionType)
             return t;
-        throw new Error(`Data type "${name}" is not a UnionType`);
+        throw new NotAcceptableError(`Data type "${name}" is not a UnionType`);
     }
     get resources() {
         return this._resources;
@@ -5853,19 +5908,19 @@ class OpraDocument {
     getResource(name) {
         const t = this.resources.get(name);
         if (!t)
-            throw new Error(`Resource "${name}" does not exists`);
+            throw new NotFoundError(`Resource "${name}" does not exists`);
         return t;
     }
     getCollectionResource(name) {
         const t = this.getResource(name);
         if (!(t instanceof CollectionResourceInfo))
-            throw new Error(`"${name}" is not a CollectionResource`);
+            throw new NotAcceptableError(`"${name}" is not a CollectionResource`);
         return t;
     }
     getSingletonResource(name) {
         const t = this.getResource(name);
         if (!(t instanceof SingletonResourceInfo))
-            throw new Error(`"${name}" is not a SingletonResource`);
+            throw new NotAcceptableError(`"${name}" is not a SingletonResource`);
         return t;
     }
     getMetadata(jsonOnly) {
@@ -5906,7 +5961,7 @@ class OpraDocument {
             dataType = new UnionType(this, name, { ...schema, types: [] });
         }
         else
-            throw new TypeError(`Invalid data type schema`);
+            throw new InternalServerError(`Invalid data type schema`);
         this._types.set(name, dataType);
         if (isOwn)
             this._ownTypes.set(name, dataType);
@@ -5916,16 +5971,16 @@ class OpraDocument {
         if (exports.OpraSchema.isCollectionResource(schema) || exports.OpraSchema.isSingletonResource(schema)) {
             const dataType = this.getDataType(schema.type);
             if (!dataType)
-                throw new TypeError(`Datatype "${schema.type}" declared in CollectionResource (${name}) does not exists`);
+                throw new InternalServerError(`Datatype "${schema.type}" declared in CollectionResource (${name}) does not exists`);
             if (!(dataType instanceof ComplexType))
-                throw new TypeError(`${schema.type} is not an ComplexType`);
+                throw new InternalServerError(`${schema.type} is not an ComplexType`);
             if (exports.OpraSchema.isCollectionResource(schema))
                 this.resources.set(name, new CollectionResourceInfo(this, name, dataType, schema));
             else
                 this.resources.set(name, new SingletonResourceInfo(this, name, dataType, schema));
         }
         else
-            throw new TypeError(`Unknown resource kind (${schema.kind})`);
+            throw new InternalServerError(`Unknown resource kind (${schema.kind})`);
     }
     _initTypes() {
         for (const dataType of this._types.values()) {
@@ -6446,51 +6501,42 @@ class OpraURLPathComponent {
     }
 }
 
+var _a$3;
 const nodeInspectCustom$2 = Symbol.for('nodejs.util.inspect.custom');
-class OpraURLPath extends events.EventEmitter {
-    constructor(...args) {
-        super();
-        this._entries = [];
-        for (const x of args) {
-            if (isURL(x)) {
-                this._parse(x.pathname);
-                continue;
-            }
-            // noinspection SuspiciousTypeOfGuard
-            if (x instanceof OpraURLPath)
-                this._entries.push(...x._entries);
-            else
-                this.add(x);
-        }
+const kEntries$2 = Symbol('kEntries');
+const kOptions$2 = Symbol('kOptions');
+class OpraURLPath {
+    constructor(init, options) {
+        this[_a$3] = [];
+        this[kOptions$2] = { ...options, onChange: undefined };
+        if (Array.isArray(init))
+            this.join(...init);
+        else if (init)
+            this.join(init);
+        this[kOptions$2].onChange = options?.onChange;
     }
     get size() {
-        return this._entries.length;
+        return this[kEntries$2].length;
     }
-    add(component, key, typeCast) {
-        this._add(component, key, typeCast);
-        this.emit('change');
+    changed() {
+        if (this[kOptions$2].onChange)
+            this[kOptions$2].onChange();
     }
     clear() {
-        this._entries = [];
-        this.emit('change');
+        this[kEntries$2] = [];
+        this.changed();
     }
     get(index) {
-        return this._entries[index];
+        return this[kEntries$2][index];
     }
-    join(pathString) {
-        const pathTokenizer = fastTokenizer.tokenize(normalizePath(pathString, true), {
-            delimiters: '/', quotes: true, brackets: true,
-        });
-        for (const x of pathTokenizer) {
-            const p = decodePathComponent(x);
-            this._add(p);
-        }
-        this.emit('change');
+    join(...source) {
+        source.forEach(x => this._join(this[kEntries$2], x));
+        this.changed();
         return this;
     }
     entries() {
         let i = -1;
-        const arr = [...this._entries];
+        const arr = [...this[kEntries$2]];
         return {
             [Symbol.iterator]() {
                 return this;
@@ -6504,9 +6550,46 @@ class OpraURLPath extends events.EventEmitter {
             }
         };
     }
+    forEach(callback) {
+        for (const item of this[kEntries$2]) {
+            callback.call(this, item, this);
+        }
+    }
+    getResource(index) {
+        const v = this[kEntries$2][index];
+        return v == null ? undefined : v.resource;
+    }
+    getKey(index) {
+        const v = this[kEntries$2][index];
+        return v == null ? undefined : v.key;
+    }
+    pop() {
+        const out = this[kEntries$2].pop();
+        this.changed();
+        return out;
+    }
+    shift() {
+        const out = this[kEntries$2].shift();
+        this.changed();
+        return out;
+    }
+    slice(start, end) {
+        return new OpraURLPath(this[kEntries$2].slice(start, end));
+    }
+    splice(start, deleteCount, join) {
+        const items = (join ? this._join([], join) : []);
+        this[kEntries$2].splice(start, deleteCount, ...items);
+        this.changed();
+    }
+    unshift(join) {
+        return this.splice(0, 0, join);
+    }
+    toString() {
+        return this[kEntries$2].map(x => encodePathComponent(x.resource, x.key, x.typeCast)).join('/');
+    }
     values() {
         let i = -1;
-        const arr = [...this._entries];
+        const arr = [...this[kEntries$2]];
         return {
             [Symbol.iterator]() {
                 return this;
@@ -6520,59 +6603,56 @@ class OpraURLPath extends events.EventEmitter {
             }
         };
     }
-    forEach(callback) {
-        for (const item of this._entries) {
-            callback.call(this, item.resource, item.key, this);
+    _join(target, source) {
+        if (typeof source === 'string') {
+            const pathTokenizer = fastTokenizer.tokenize(normalizePath(source, true), {
+                delimiters: '/', quotes: true, brackets: true,
+            });
+            for (const x of pathTokenizer) {
+                const p = decodePathComponent(x);
+                target.push(new OpraURLPathComponent(p));
+            }
+            return;
         }
+        if (source instanceof OpraURLPath) {
+            target.push(...source[kEntries$2].map(x => new OpraURLPathComponent(x)));
+            return;
+        }
+        if (typeof source === 'object' && source.path instanceof OpraURLPath) {
+            this._join(target, source.path);
+            return;
+        }
+        if (isURL(source)) {
+            this._join(target, source.pathname);
+            return;
+        }
+        if (Array.isArray(source)) {
+            source.forEach(x => this._join(target, x));
+            return;
+        }
+        target.push(new OpraURLPathComponent(source));
     }
-    getResource(index) {
-        const v = this._entries[index];
-        return v == null ? undefined : v.resource;
-    }
-    getKey(index) {
-        const v = this._entries[index];
-        return v == null ? undefined : v.key;
-    }
-    toString() {
-        return this._entries.map(x => encodePathComponent(x.resource, x.key, x.typeCast)).join('/');
+    /* istanbul ignore next */
+    [(_a$3 = kEntries$2, nodeInspectCustom$2)]() {
+        return this[kEntries$2];
     }
     [Symbol.iterator]() {
         return this.entries();
     }
-    /* istanbul ignore next */
-    [nodeInspectCustom$2]() {
-        return this._entries;
-    }
-    _add(component, key, typeCast) {
-        if (component instanceof OpraURLPathComponent) {
-            this._entries.push(component);
-        }
-        else if (typeof component === 'object')
-            this._entries.push(new OpraURLPathComponent(component));
-        else
-            this._entries.push(new OpraURLPathComponent({ resource: component, key, typeCast }));
-    }
-    _parse(v) {
-        if (!v)
-            return;
-        const pathTokenizer = fastTokenizer.tokenize(v, { delimiters: '/', quotes: true, brackets: true });
-        for (const x of pathTokenizer) {
-            if (!x)
-                continue;
-            const p = decodePathComponent(x);
-            this._add(p);
-        }
-        this.emit('change');
+    get [Symbol.toStringTag]() {
+        return 'OpraURLPath';
     }
 }
+OpraURLPath.kEntries = kEntries$2;
+OpraURLPath.kOptions = kOptions$2;
 
-class Format {
+class HttpParamCodec {
 }
 
 const trueValues = ['true', 't', 'yes', 'y', '1'];
 const falseValues = ['false', 'f', 'no', 'n', '0'];
-class BooleanFormat extends Format {
-    parse(value) {
+class BooleanCodec extends HttpParamCodec {
+    decode(value) {
         if (value === '')
             return true;
         // noinspection SuspiciousTypeOfGuard
@@ -6584,7 +6664,7 @@ class BooleanFormat extends Format {
             return false;
         throw new TypeError(`"${value}" is not a valid boolean`);
     }
-    stringify(value) {
+    encode(value) {
         return typeof value === 'boolean' ?
             (value ? 'true' : 'false') : '';
     }
@@ -6593,7 +6673,7 @@ class BooleanFormat extends Format {
 /* eslint-disable max-len */
 // noinspection RegExpUnnecessaryNonCapturingGroup
 const DATE_FORMAT_PATTERN = /^(\d{4})(?:-?(0[1-9]|1[012])(?:-?([123]0|[012][1-9]|31))?)?(?:[T ]?([01][0-9]|2[0-3]):?([0-5][0-9]):?([0-5][0-9])?(?:\.(\d+))?(?:(Z)|(?:([+-])([01]?[0-9]|2[0-3]):?([0-5][0-9])?))?)?$/;
-class DateFormat extends Format {
+class DateCodec extends HttpParamCodec {
     constructor(options) {
         super();
         this.max = options?.max ? coerceToDateString(options.max) : undefined;
@@ -6601,7 +6681,7 @@ class DateFormat extends Format {
         this.time = options?.time ?? true;
         this.timeZone = options?.timeZone ?? true;
     }
-    parse(value) {
+    decode(value) {
         const v = coerceToDateString(value, this.time, this.timeZone);
         if (this.min != null && v < this.min)
             throw new TypeError(`Value must be ${this.min} or greater.`);
@@ -6609,7 +6689,7 @@ class DateFormat extends Format {
             throw new TypeError(`Value must be ${this.max} or less.`);
         return v;
     }
-    stringify(value) {
+    encode(value) {
         return coerceToDateString(value, this.time, this.timeZone);
     }
 }
@@ -6630,25 +6710,25 @@ function coerceToDateString(value, time, timeZone) {
     return v;
 }
 
-class FilterFormat extends Format {
-    parse(value) {
+class FilterCodec extends HttpParamCodec {
+    decode(value) {
         if (value instanceof Expression)
             return value;
         return parseFilter(value);
     }
-    stringify(value) {
+    encode(value) {
         // @ts-ignore
         return value ? '' + value : '';
     }
 }
 
-class NumberFormat extends Format {
+class NumberCodec extends HttpParamCodec {
     constructor(options) {
         super();
         this.max = options?.max;
         this.min = options?.min;
     }
-    parse(value) {
+    decode(value) {
         // noinspection SuspiciousTypeOfGuard
         const v = typeof value === 'number' ? value : parseFloat(value);
         if (isNaN(v))
@@ -6659,18 +6739,18 @@ class NumberFormat extends Format {
             throw new TypeError(`Value must be ${this.max} or less.`);
         return v;
     }
-    stringify(value) {
+    encode(value) {
         return typeof value === 'number' ? '' + value : '';
     }
 }
 
-class IntegerFormat extends NumberFormat {
+class IntegerCodec extends NumberCodec {
     constructor(options) {
         super(options);
         this.enum = options?.enum;
     }
-    parse(value) {
-        const v = super.parse(value);
+    decode(value) {
+        const v = super.decode(value);
         if (!Number.isInteger(v))
             throw new TypeError(`"${value}" is not a valid integer`);
         if (this.enum && !this.enum.includes(v))
@@ -6679,14 +6759,14 @@ class IntegerFormat extends NumberFormat {
     }
 }
 
-class StringFormat extends Format {
+class StringCodec extends HttpParamCodec {
     constructor(options) {
         super();
         this.maxLength = options?.maxLength;
         this.minLength = options?.minLength;
         this.enum = options?.enum;
     }
-    parse(value) {
+    decode(value) {
         if (this.minLength != null && value.length < this.minLength)
             throw new TypeError(`Value must be at least ${this.minLength} character${this.minLength > 1 ? 's' : ''} long.`);
         if (this.maxLength != null && value.length > this.maxLength)
@@ -6695,406 +6775,588 @@ class StringFormat extends Format {
             throw new TypeError(`"${value}" is not one of allowed enum values (${this.enum}).`);
         return value;
     }
-    stringify(value) {
+    encode(value) {
         return value == null ? '' : '' + value;
     }
 }
 
-const internalFormats = {
-    'integer': new IntegerFormat(),
-    'number': new NumberFormat(),
-    'string': new StringFormat(),
-    'boolean': new BooleanFormat(),
-    'date': new DateFormat(),
-    'filter': new FilterFormat()
+/**
+ * Encode input string with standard encodeURIComponent and then un-encode specific characters.
+ */
+const ENCODING_REGEX = /%(\d[a-f0-9])/gi;
+const ENCODING_REPLACEMENTS = {
+    '2C': ',',
+    '2F': '/',
+    '24': '$',
+    '3A': ':',
+    '3B': ';',
+    '3D': '=',
+    '3F': '?',
+    '40': '@'
 };
-const nodeInspectCustom$1 = Symbol.for('nodejs.util.inspect.custom');
-class OpraURLSearchParams extends events.EventEmitter {
-    constructor(init) {
-        super();
-        this._params = new ResponsiveMap();
-        this._entries = new ResponsiveMap();
-        this._size = 0;
-        this.defineParam('$filter', { format: 'filter' });
-        this.defineParam('$limit', { format: new IntegerFormat({ min: 0 }) });
-        this.defineParam('$skip', { format: new IntegerFormat({ min: 0 }) });
-        this.defineParam('$pick', { format: 'string', array: 'strict' });
-        this.defineParam('$omit', { format: 'string', array: 'strict' });
-        this.defineParam('$include', { format: 'string', array: 'strict' });
-        this.defineParam('$sort', { format: 'string', array: 'strict' });
-        this.defineParam('$distinct', { format: 'boolean' });
-        this.defineParam('$count', { format: 'boolean' });
-        if (init) {
-            if (typeof init === 'string')
-                this.parse(init);
-            else
-                this.addAll(init);
-        }
+function encodeURIParam(v) {
+    return encodeURIComponent(v).replace(ENCODING_REGEX, (s, t) => ENCODING_REPLACEMENTS[t] ?? s);
+}
+
+var _a$2, _b$1, _c;
+const kEntries$1 = Symbol('kEntries');
+const kSize$1 = Symbol('kSize');
+const kParamDefs = Symbol('kParamDefs');
+const kOptions$1 = Symbol('kOptions');
+const defaultKeyDecoder = (s) => decodeURIComponent(s);
+const defaultValueDecoder = (s) => decodeURIComponent(s);
+const defaultKeyEncoder = (s) => encodeURIParam(s);
+const defaultValueEncoder = (s) => encodeURIParam(s);
+const internalCodecs = {
+    'boolean': new BooleanCodec(),
+    'date': new DateCodec(),
+    'filter': new FilterCodec(),
+    'integer': new IntegerCodec(),
+    'number': new NumberCodec(),
+    'string': new StringCodec()
+};
+class HttpParams {
+    constructor(init, options) {
+        this[_a$2] = new ResponsiveMap();
+        this[_b$1] = 0;
+        this[_c] = new Map();
+        this[kOptions$1] = { ...options, onChange: undefined };
+        const defineParams = options?.params;
+        if (defineParams)
+            Object.keys(defineParams).forEach(key => this.define(key, defineParams[key]));
+        if (init)
+            this.appendAll(init);
+        this[kOptions$1].onChange = options?.onChange;
     }
     get size() {
-        return this._size;
+        return this[kSize$1];
     }
-    addAll(values) {
-        let changed = false;
-        if (typeof values.forEach === 'function') {
-            values.forEach((value, name) => {
-                changed = this._add(name, value) || changed;
-            });
+    /**
+     * Appends a new value to the existing set of values for a parameter
+     * and returns this instance
+     */
+    append(name, value) {
+        this._append(name, value);
+        this.changed();
+        return this;
+    }
+    appendAll(input) {
+        if (typeof input === 'string') {
+            if (input && input.startsWith('?'))
+                input = input.substring(1);
+            if (!input)
+                return this;
+            const tokenizer = fastTokenizer.tokenize(input, { delimiters: '&', quotes: true, brackets: true });
+            for (const token of tokenizer) {
+                if (!token)
+                    continue;
+                const itemTokenizer = fastTokenizer.tokenize(token, {
+                    delimiters: '=',
+                    quotes: true,
+                    brackets: true
+                });
+                const k = this.decodeKey(itemTokenizer.next() || '');
+                const v = this.decodeValue(itemTokenizer.join('='), k);
+                this._append(k, v);
+            }
         }
-        else if (typeof values === 'object') ;
+        else if (input.forEach && typeof input.forEach === 'function')
+            input.forEach((value, name) => this._append(name, value));
         else
-            throw new TypeError(`Invalid argument`);
-        if (changed)
-            this.emit('change');
+            Object.keys(input).forEach(name => this._append(name, input[name]));
+        return this;
     }
-    append(name, value) {
-        if (this._add(name, value))
-            this.emit('change');
+    changed() {
+        if (this[kOptions$1].onChange)
+            this[kOptions$1].onChange();
     }
     clear() {
-        this._entries.clear();
-        this._size = 0;
-        this.emit('change');
+        if (this[kEntries$1].size) {
+            this[kEntries$1].clear();
+            this[kSize$1] = 0;
+            this.changed();
+        }
     }
-    defineParam(name, options) {
-        if (!name)
-            throw new Error('Parameter name required');
-        const meta = {
-            ...options,
-            name,
-            format: options?.format || 'string'
-        };
-        if (typeof meta.format === 'string' && !internalFormats[meta.format])
-            throw new Error(`Unknown data format "${meta.format}"`);
-        meta.format = meta.format || 'string';
-        this._params.set(name, meta);
+    /**
+     * Deletes values for a given parameter
+     */
+    delete(name, value) {
+        if (this._delete(name, value))
+            this.changed();
         return this;
     }
-    delete(name) {
-        if (this._delete(name))
-            this.emit('change');
-    }
+    /**
+     * Returns an iterable of key, value pairs for every entry in the map.
+     */
     entries() {
-        const items = [];
-        this.forEach((value, name) => {
-            items.push([name, value]);
-        });
-        return items.values();
-    }
-    forEach(callback) {
-        for (const [name, entry] of this._entries.entries()) {
-            for (let i = 0; i < entry.length; i++) {
-                callback(entry[i], name, this);
+        const iter = this[kEntries$1].entries();
+        let i = 0;
+        let key;
+        let values;
+        return {
+            [Symbol.iterator]() {
+                return this;
+            },
+            next() {
+                if (values) {
+                    if (i >= values.length) {
+                        values = undefined;
+                        i = 0;
+                    }
+                }
+                if (!values) {
+                    const n = iter.next();
+                    if (n.done)
+                        return { done: true, value: undefined };
+                    key = n.value[0];
+                    values = n.value[1];
+                }
+                return {
+                    done: false,
+                    value: [key, values[i++]]
+                };
             }
+        };
+    }
+    forEach(callbackFn, thisArg) {
+        const iterator = this.entries();
+        let entry = iterator.next();
+        while (!entry.done) {
+            callbackFn.call(thisArg || this, entry.value[1], entry.value[0], this);
+            entry = iterator.next();
         }
     }
-    get(name, index) {
-        const entry = this._entries.get(name);
-        const v = entry && entry[index || 0];
-        return v == null ? null : v;
+    /**
+     * Retrieves value of a given parameter at given index
+     */
+    get(name, index = 0) {
+        const values = this[kEntries$1].get(name.toLowerCase());
+        return values && values.length > index ? values[index] : null;
     }
+    /**
+     * Retrieves an array of values for a given parameter.
+     */
     getAll(name) {
-        const entry = this._entries.get(name);
-        return entry ? entry.slice(0) : [];
-    }
-    has(name) {
-        return this._entries.has(name);
+        const entry = this[kEntries$1].get(name);
+        return entry ? entry.slice(0) : null;
     }
+    /**
+     * Retrieves the names of the parameters.
+     */
     keys() {
-        return this._entries.keys();
-    }
-    set(name, value) {
-        this._delete(name);
-        this._add(name, value);
-        this.emit('change');
-    }
-    sort(compareFn) {
-        this._entries.sort(compareFn);
-        this.emit('change');
+        return this[kEntries$1].keys();
     }
+    /**
+     * Retrieves the names of the parameters.
+     */
     values() {
         const items = [];
         this.forEach((value) => items.push(value));
         return items.values();
     }
+    /**
+     * Checks for existence of a parameter.
+     */
+    has(name) {
+        return this[kEntries$1].has(name);
+    }
+    /**
+     * Sets or modifies a value for a given parameter.
+     * If the header already exists, its value is replaced with the given value
+     */
+    set(name, value) {
+        this._set(name, value);
+        this.changed();
+        return this;
+    }
+    sort(compareFn) {
+        this[kEntries$1].sort(compareFn);
+        this.changed();
+        return this;
+    }
+    /**
+     * Serializes the body to an encoded string, where key-value pairs (separated by `=`) are
+     * separated by `&`s.
+     */
     toString() {
-        let out = '';
+        const out = [];
         this.forEach((v, k) => {
-            const qi = this._params.get(k);
-            const format = qi
-                ? (typeof qi.format === 'string' ? internalFormats[qi.format] : qi.format)
-                : undefined;
-            const stringify = (x) => encodeURIComponent(format ? format.stringify(x, k) : (x == null ? '' : '' + x));
-            const val = Array.isArray(v)
-                ? v.map(stringify).join(qi?.arrayDelimiter || ',')
-                : stringify(v);
-            if (val) {
-                if (out.length > 0)
-                    out += '&';
-                out += k + '=' + val;
-            }
+            out.push(this.encodeKey(k) +
+                (v ? '=' + this.encodeValue(v, k) : ''));
         });
-        return out;
+        return out.join('&');
     }
-    parse(input) {
-        this._entries.clear();
-        this._size = 0;
-        if (input && input.startsWith('?'))
-            input = input.substring(1);
-        if (!input)
-            return;
-        const tokenizer = fastTokenizer.tokenize(input, { delimiters: '&', quotes: true, brackets: true });
-        for (const token of tokenizer) {
-            if (!token)
-                continue;
-            const itemTokenizer = fastTokenizer.tokenize(token, {
-                delimiters: '=',
-                quotes: true,
-                brackets: true,
-            });
-            const k = decodeURIComponent(itemTokenizer.next() || '');
-            const v = itemTokenizer.join('=');
-            const qi = this._params.get(k);
-            if (qi?.array) {
-                const values = fastTokenizer.splitString(v, {
-                    delimiters: qi?.arrayDelimiter || ',',
+    define(name, options) {
+        if (!name)
+            throw new Error('Parameter name required');
+        if (typeof options?.codec === 'string' && !internalCodecs[options.codec])
+            throw new Error(`Unknown url parameter format name "${options.codec}"`);
+        const codec = (typeof options?.codec === 'string'
+            ? internalCodecs[options.codec]
+            : options?.codec) || internalCodecs.string;
+        const meta = {
+            ...options,
+            codec
+        };
+        this[kParamDefs].set(name, meta);
+        return this;
+    }
+    encodeKey(key) {
+        return (this[kOptions$1].encodeKey || defaultKeyEncoder)(key);
+    }
+    decodeKey(key) {
+        return (this[kOptions$1].decodeKey || defaultKeyDecoder)(key);
+    }
+    encodeValue(value, key) {
+        const prmDef = this[kParamDefs].get(key);
+        if (prmDef) {
+            const delimReplace = '%' + (prmDef.arrayDelimiter || ',').charCodeAt(0).toString(16).toUpperCase();
+            const fn = (x) => encodeURIParam(prmDef.codec.encode(x)).replaceAll(',', delimReplace);
+            return Array.isArray(value)
+                ? value.map((v) => fn(v)).join(prmDef.arrayDelimiter || ',')
+                : fn(value);
+        }
+        return (this[kOptions$1].encodeValue || defaultValueEncoder)(value);
+    }
+    decodeValue(value, key) {
+        const prmDef = this[kParamDefs].get(key);
+        const valueDecoder = (this[kOptions$1].decodeValue || defaultValueDecoder);
+        let val = value;
+        if (prmDef) {
+            if (prmDef.array) {
+                val = fastTokenizer.splitString(value, {
+                    delimiters: prmDef.arrayDelimiter || ',',
                     brackets: true,
-                    quotes: true
-                }).map((x) => decodeURIComponent(x));
-                this._add(k, values);
+                    quotes: true,
+                    keepQuotes: false
+                }).map((x) => valueDecoder(x));
             }
-            else {
-                this._add(k, decodeURIComponent(v));
+            else
+                val = valueDecoder(val);
+            const fn = (x) => prmDef.codec.decode(valueDecoder(x));
+            val = Array.isArray(val) ? val.map(fn) : fn(val);
+            if (prmDef.array === 'strict')
+                val = Array.isArray(val) ? val : [val];
+            else if (prmDef.array)
+                val = Array.isArray(val) && val.length === 1 ? val[0] : val;
+            if (Array.isArray(val)) {
+                if (prmDef.minArrayItems && val.length < prmDef.minArrayItems)
+                    throw new Error(`"${key}" parameter requires at least ${prmDef.minArrayItems} values`);
+                if (prmDef.maxArrayItems && val.length > prmDef.maxArrayItems)
+                    throw new Error(`"${key}" parameter accepts up to ${prmDef.maxArrayItems} values`);
             }
+            return val;
         }
-        this.emit('change');
+        return valueDecoder(value);
     }
-    toURLSearchParams() {
-        const out = new URLSearchParams();
-        this.forEach((v, k) => {
-            const qi = this._params.get(k);
-            const format = qi
-                ? (typeof qi.format === 'string' ? internalFormats[qi.format] : qi.format)
-                : undefined;
-            const stringify = (x) => format ? format.stringify(x, k) : (x == null ? '' : '' + x);
-            const val = Array.isArray(v)
-                ? v.map(stringify).join(qi?.arrayDelimiter || ',')
-                : stringify(v);
-            out.append(k, val);
-        });
-        return out;
+    _append(name, value) {
+        let values = this[kEntries$1].get(name);
+        if (!values) {
+            values = [];
+            this[kEntries$1].set(name, values);
+        }
+        values.push(value ?? null);
+        this[kSize$1] += 1;
     }
-    [Symbol.iterator]() {
-        return this.entries();
+    _delete(name, value) {
+        const oldValues = this[kEntries$1].get(name);
+        if (!oldValues)
+            return false;
+        const oldSize = this[kSize$1];
+        if (value) {
+            const valueToDelete = Array.isArray(value) ? value : [value];
+            const newValues = oldValues.filter(x => !valueToDelete.includes(x));
+            this[kEntries$1].set(name, newValues);
+            this[kSize$1] += -oldValues.length + newValues.length;
+        }
+        else {
+            this[kEntries$1].delete(name);
+            this[kSize$1] -= oldValues.length;
+        }
+        return oldSize !== this[kSize$1];
     }
-    get [Symbol.toStringTag]() {
-        return 'URLSearchParams';
+    _set(name, value, index) {
+        if (value == null) {
+            this._delete(name);
+            return;
+        }
+        const values = this[kEntries$1].get(name);
+        if (!values) {
+            this[kEntries$1].set(name, [value]);
+            this[kSize$1] += 1;
+            return;
+        }
+        if (index == null || index < 0) {
+            this[kEntries$1].set(name, [value]);
+            this[kSize$1] += -(values.length) + 1;
+            return;
+        }
+        const oldLen = values.length;
+        values[Math.min(index, values.length)] = value;
+        this[kSize$1] += -oldLen + values.length;
     }
-    [nodeInspectCustom$1]() {
-        return this._entries;
+    [(_a$2 = kEntries$1, _b$1 = kSize$1, _c = kParamDefs, Symbol.iterator)]() {
+        return this.entries();
     }
-    _delete(name) {
-        const a = this._entries.get(name);
-        if (!a)
-            return false;
-        this._size -= a.length;
-        this._entries.delete(name);
-        return true;
+    get [Symbol.toStringTag]() {
+        return 'HttpParams';
     }
-    _add(name, value) {
-        const qi = this._params.get(name);
-        const format = qi ?
-            (typeof qi.format === 'string' ? internalFormats[qi.format] : qi.format) : undefined;
-        const fn = (x) => format ? format.parse(x, name) : x;
-        let v = Array.isArray(value) ? value.map(fn) : fn(value);
-        if (qi) {
-            if (qi.array === 'strict')
-                v = Array.isArray(v) ? v : [v];
-            else if (qi.array)
-                v = Array.isArray(v) && v.length === 1 ? v[0] : v;
-            if (Array.isArray(v)) {
-                if (qi.minArrayItems && v.length < qi.minArrayItems)
-                    throw new Error(`"${name}" parameter requires at least ${qi.minArrayItems} values`);
-                if (qi.maxArrayItems && v.length > qi.maxArrayItems)
-                    throw new Error(`"${name}" parameter accepts up to ${qi.maxArrayItems} values`);
+}
+HttpParams.kEntries = kEntries$1;
+HttpParams.kSize = kSize$1;
+HttpParams.kParamDefs = kParamDefs;
+HttpParams.kOptions = kOptions$1;
+
+class OpraURLSearchParams extends HttpParams {
+    constructor(init, options) {
+        super(init, {
+            ...options,
+            params: {
+                '$filter': { codec: 'filter' },
+                '$limit': { codec: new IntegerCodec({ min: 0 }) },
+                '$skip': { codec: new IntegerCodec({ min: 0 }) },
+                '$pick': { codec: 'string', array: 'strict' },
+                '$omit': { codec: 'string', array: 'strict' },
+                '$include': { codec: 'string', array: 'strict' },
+                '$sort': { codec: 'string', array: 'strict' },
+                '$distinct': { codec: 'boolean' },
+                '$count': { codec: 'boolean' },
+                ...options?.params
             }
-        }
-        let entry = this._entries.get(name);
-        if (!entry) {
-            entry = [];
-            this._entries.set(name, entry);
-        }
-        entry.push(v);
-        this._size++;
-        return true;
+        });
+    }
+    get [Symbol.toStringTag]() {
+        return 'URLSearchParams';
     }
 }
 
-const nodeInspectCustom = Symbol.for('nodejs.util.inspect.custom');
+var _a$1;
+const nodeInspectCustom$1 = Symbol.for('nodejs.util.inspect.custom');
 const urlRegEx = /^(?:((?:[A-Z][A-Z+-.]+:)+)\/\/([^/?]+))?(.*)?$/i;
 const schemeRegEx = /^([A-Z][A-Z+-.]+:?)+$/i;
 const hostRegEx = /^([^/:]+)(?::(\d+))?$/;
 const hostnameRegEx = /^([^/:]+)$/;
-const CONTEXT_KEY = Symbol.for('opra.url.context');
-const PATH_KEY = Symbol.for('opra.url.path');
-const SEARCHPARAMS_KEY = Symbol.for('opra.url.searchparams');
+const kContext = Symbol('kContext');
+const kPath = Symbol('kPath');
+const kSearchParams = Symbol('kSearchParams');
 class OpraURL {
-    constructor(input, pathPrefix) {
-        Object.defineProperty(this, CONTEXT_KEY, {
-            writable: true,
-            configurable: true,
-            enumerable: false,
-            value: {}
-        });
-        Object.defineProperty(this, PATH_KEY, {
-            writable: true,
-            configurable: true,
-            enumerable: false,
-            value: new OpraURLPath()
+    constructor(input, arg1) {
+        this[_a$1] = {
+            protocol: '',
+            username: '',
+            pathname: '',
+            prefix: '',
+            hostname: '',
+            port: '',
+            hash: '',
+            password: '',
+            search: '',
+            address: '',
+            needUpdate: true
+        };
+        this[kPath] = new OpraURLPath('', {
+            onChange: () => this._changed()
         });
-        Object.defineProperty(this, SEARCHPARAMS_KEY, {
-            writable: true,
-            configurable: true,
-            enumerable: false,
-            value: new OpraURLSearchParams()
+        this[kSearchParams] = new OpraURLSearchParams('', {
+            onChange: () => this._changed()
         });
-        this.searchParams.on('change', () => this._invalidate());
-        this.path.on('change', () => this._invalidate());
-        if (pathPrefix)
-            this.setPrefix(pathPrefix);
+        const base = typeof arg1 === 'object' ? arg1.base : arg1;
+        if (typeof arg1 === 'object') {
+            const defineParams = arg1?.params;
+            if (defineParams)
+                Object.keys(defineParams).forEach(key => this.searchParams.define(key, defineParams[key]));
+        }
         if (input)
-            this.parse(input);
+            this.parse(typeof input === 'object' ? input.toString() : input);
+        if (base) {
+            const baseUrl = base instanceof OpraURL ? base : new OpraURL(base);
+            this[kContext].protocol = baseUrl.protocol;
+            this[kContext].hostname = baseUrl.hostname;
+            this[kContext].port = baseUrl.port;
+            this[kContext].prefix = baseUrl.pathname;
+        }
     }
     get address() {
         this._update();
-        let out = '';
-        if (this.hostname) {
-            out += this.protocol + '//' +
-                (this.username || this.password
-                    ? ((this.username ? encodeURIComponent(this.username) : '') +
-                        (this.password ? ':' + encodeURIComponent(this.password) : '') + '@')
-                    : '') + this.host;
+        return this[kContext].address;
+    }
+    get host() {
+        return this.hostname ? (this.hostname + (this.port ? ':' + this.port : '')) : '';
+    }
+    set host(v) {
+        if (v) {
+            const m = hostRegEx.exec(v);
+            if (!m)
+                throw Object.assign(new TypeError('Invalid host'), {
+                    host: v,
+                    code: 'ERR_INVALID_URL'
+                });
+            this[kContext].hostname = m[1];
+            this[kContext].port = m[2] || '';
+        }
+        else {
+            this[kContext].hostname = '';
+            this[kContext].port = '';
+        }
+        this._changed();
+    }
+    get hostname() {
+        return this[kContext].hostname || '';
+    }
+    set hostname(v) {
+        if (v) {
+            if (!hostnameRegEx.test(v))
+                throw Object.assign(new TypeError('Invalid hostname'), {
+                    hostname: v,
+                    code: 'ERR_INVALID_URL'
+                });
+            this[kContext].hostname = v;
         }
-        return out + this.pathPrefix + this.pathname;
+        else
+            this[kContext].hostname = '';
+        this._changed();
     }
     get href() {
         return this.address + this.search + this.hash;
     }
-    get protocol() {
-        return this[CONTEXT_KEY].protocol || 'http:';
-    }
-    set protocol(v) {
-        if (!schemeRegEx.test(v))
-            throw Object.assign(new TypeError('Invalid protocol'), {
-                protocol: v,
-                code: 'ERR_INVALID_URL'
-            });
-        this[CONTEXT_KEY].protocol = v + (v.endsWith(':') ? '' : ':');
-    }
-    get username() {
-        return this[CONTEXT_KEY].username || '';
-    }
-    set username(v) {
-        this[CONTEXT_KEY].username = v;
-    }
-    get password() {
-        return this[CONTEXT_KEY].password || '';
+    get password() {
+        return this[kContext].password;
     }
     set password(v) {
-        this[CONTEXT_KEY].password = v;
+        this[kContext].password = v || '';
+        this._changed();
     }
-    get host() {
-        return this.hostname ? (this.hostname + (this.port ? ':' + this.port : '')) : '';
+    get port() {
+        return this[kContext].port;
     }
-    set host(v) {
-        const m = hostRegEx.exec(v);
-        if (!m)
-            throw Object.assign(new TypeError('Invalid host'), {
-                host: v,
-                code: 'ERR_INVALID_URL'
-            });
-        this[CONTEXT_KEY].hostname = m[1];
-        this[CONTEXT_KEY].port = m[2] ? parseInt(m[2], 10) : null;
+    set port(value) {
+        if (value) {
+            // noinspection SuspiciousTypeOfGuard
+            const v = parseInt(value, 10);
+            if (isNaN(v) || v < 1 || v > 35535 || v % 1 > 0)
+                throw Object.assign(new TypeError('Invalid port'), {
+                    hostname: v,
+                    code: 'ERR_INVALID_URL'
+                });
+            this[kContext].port = value;
+        }
+        else
+            this[kContext].port = '';
+        this._changed();
     }
-    get hostname() {
-        return this[CONTEXT_KEY].hostname || '';
+    get prefix() {
+        return this[kContext].prefix;
     }
-    set hostname(v) {
-        if (!hostnameRegEx.test(v))
-            throw Object.assign(new TypeError('Invalid hostname'), {
-                hostname: v,
-                code: 'ERR_INVALID_URL'
-            });
-        this[CONTEXT_KEY].hostname = v;
+    set prefix(value) {
+        if (value) {
+            const url = new OpraURL(value);
+            this[kContext].prefix = url.pathname;
+        }
+        else
+            this[kContext].prefix = '';
+        this._changed();
     }
-    get port() {
-        const v = this[CONTEXT_KEY].port;
-        return v == null ? null : v;
+    get protocol() {
+        return this[kContext].protocol || 'http:';
     }
-    set port(v) {
-        if (v == null) {
-            this[CONTEXT_KEY].port = null;
-            return;
+    set protocol(v) {
+        if (v) {
+            if (!schemeRegEx.test(v))
+                throw Object.assign(new TypeError('Invalid protocol'), {
+                    protocol: v,
+                    code: 'ERR_INVALID_URL'
+                });
+            this[kContext].protocol = v + (v.endsWith(':') ? '' : ':');
         }
-        // noinspection SuspiciousTypeOfGuard
-        if (typeof v !== 'number' || isNaN(v) || v < 1 || v > 35535 || v % 1 > 0)
-            throw Object.assign(new TypeError('Invalid port'), {
-                hostname: v,
-                code: 'ERR_INVALID_URL'
-            });
-        this[CONTEXT_KEY].port = v;
+        else
+            this[kContext].protocol = '';
+        this._changed();
     }
-    get origin() {
-        return this.hostname ? (this.protocol + '//' + this.hostname) : '';
+    get username() {
+        return this[kContext].username;
     }
-    get pathPrefix() {
-        return this[CONTEXT_KEY].pathPrefix || '';
+    set username(v) {
+        this[kContext].username = v || '';
+        this._changed();
     }
-    set pathPrefix(v) {
-        if (!v) {
-            this[CONTEXT_KEY].pathPrefix = '';
-            return;
-        }
-        v = normalizePath(fastTokenizer.tokenize(v, { delimiters: '#?', quotes: true, brackets: true }).next() || '', true);
-        if (v.includes('://'))
-            this[CONTEXT_KEY].pathPrefix = v;
-        else
-            this[CONTEXT_KEY].pathPrefix = v ? '/' + v : '';
+    get origin() {
+        return this.hostname ? (this.protocol + '//' + this.hostname) : '';
     }
     get path() {
-        return this[PATH_KEY];
+        return this[kPath];
     }
     get pathname() {
         this._update();
-        return this[CONTEXT_KEY].pathname || '';
+        return this[kContext].pathname || '';
     }
     set pathname(v) {
         this._setPathname(v, false);
     }
     get searchParams() {
-        return this[SEARCHPARAMS_KEY];
+        return this[kSearchParams];
     }
     get hash() {
-        return this[CONTEXT_KEY].hash || '';
+        return this[kContext].hash || '';
     }
     set hash(v) {
-        this[CONTEXT_KEY].hash = v ? (v.startsWith('#') ? v : '#' + v) : '';
+        this[kContext].hash = v ? (v.startsWith('#') ? v : '#' + v) : '';
+        this._changed();
     }
     get search() {
         this._update();
-        return this[CONTEXT_KEY].search || '';
+        return this[kContext].search || '';
     }
     set search(v) {
-        this.searchParams.parse(v);
+        this.searchParams.clear();
+        this.searchParams.appendAll(v);
     }
-    addPath(name, key) {
-        this.path.add(name, key);
+    parse(input) {
+        const m = urlRegEx.exec(input);
+        if (!m)
+            throw Object.assign(new TypeError('Invalid URL'), {
+                input,
+                code: 'ERR_INVALID_URL'
+            });
+        this.protocol = m[1];
+        const isAbsolute = !!m[2];
+        if (isAbsolute) {
+            let tokens = fastTokenizer.splitString(m[2], { delimiters: '@' });
+            if (tokens.length > 1) {
+                this.host = tokens[1];
+                tokens = fastTokenizer.splitString(tokens[0], { delimiters: ':' });
+                this.username = tokens[0] ? decodeURIComponent(tokens[0]) : '';
+                this.password = tokens[1] ? decodeURIComponent(tokens[1]) : '';
+            }
+            else
+                this.host = tokens[0];
+        }
+        else {
+            this.host = '';
+            this.username = '';
+            this.password = '';
+        }
+        input = m[3] || '';
+        let tokenizer = fastTokenizer.tokenize(input, { delimiters: '#', quotes: true, brackets: true });
+        input = tokenizer.next() || '';
+        this.hash = tokenizer.join('#');
+        tokenizer = fastTokenizer.tokenize(input, { delimiters: '?', quotes: true, brackets: true });
+        this._setPathname(tokenizer.next() || '', isAbsolute);
+        this.searchParams.clear();
+        this.searchParams.appendAll(tokenizer.join('&'));
+        this._changed();
+    }
+    join(...source) {
+        this.path.join(...source);
         return this;
     }
-    addSearchParam(name, value) {
+    addParam(name, value) {
         this.searchParams.append(name, value);
         return this;
     }
+    setParam(name, value) {
+        this.searchParams.set(name, value);
+        return this;
+    }
     setHost(v) {
         this.host = v;
         return this;
@@ -7108,11 +7370,11 @@ class OpraURL {
         return this;
     }
     setPort(v) {
-        this.port = v;
+        this.port = v ? String(v) : '';
         return this;
     }
     setPrefix(v) {
-        this.pathPrefix = v;
+        this.prefix = v;
         return this;
     }
     setPathname(v) {
@@ -7127,46 +7389,11 @@ class OpraURL {
         this.search = v;
         return this;
     }
-    setSearchParam(name, value) {
-        this.searchParams.set(name, value);
-        return this;
-    }
-    parse(input) {
-        const m = urlRegEx.exec(input);
-        if (!m)
-            throw Object.assign(new TypeError('Invalid URL'), {
-                input,
-                code: 'ERR_INVALID_URL'
-            });
-        if (m[1])
-            this.protocol = m[1];
-        if (m[2]) {
-            let tokens = fastTokenizer.splitString(m[2], { delimiters: '@' });
-            if (tokens.length > 1) {
-                this.host = tokens[1];
-                tokens = fastTokenizer.splitString(tokens[0], { delimiters: ':' });
-                this.username = tokens[0] ? decodeURIComponent(tokens[0]) : '';
-                this.password = tokens[1] ? decodeURIComponent(tokens[1]) : '';
-            }
-            else
-                this.host = tokens[0];
-        }
-        input = m[3] || '';
-        let tokenizer = fastTokenizer.tokenize(input, { delimiters: '#', quotes: true, brackets: true });
-        input = tokenizer.next() || '';
-        this.hash = tokenizer.join('#');
-        tokenizer = fastTokenizer.tokenize(input, { delimiters: '?', quotes: true, brackets: true });
-        this._setPathname(tokenizer.next() || '', true);
-        // this.path.join()
-        this.searchParams.clear();
-        this.searchParams.parse(tokenizer.join('&'));
-        return this;
-    }
     toString() {
         return this.href;
     }
     /* istanbul ignore next */
-    [nodeInspectCustom]() {
+    [(_a$1 = kContext, nodeInspectCustom$1)]() {
         this._update();
         return {
             protocol: this.protocol,
@@ -7175,7 +7402,7 @@ class OpraURL {
             host: this.host,
             hostname: this.hostname,
             origin: this.origin,
-            pathPrefix: this.pathPrefix,
+            pathPrefix: this.prefix,
             path: this.path,
             pathname: this.pathname,
             search: this.search,
@@ -7183,27 +7410,34 @@ class OpraURL {
             hash: this.hash,
         };
     }
-    _invalidate() {
-        this[CONTEXT_KEY].needUpdate = true;
-    }
     _update() {
-        if (!this[CONTEXT_KEY].needUpdate)
+        if (!this[kContext].needUpdate)
             return;
-        this[CONTEXT_KEY].needUpdate = false;
+        const ctx = this[kContext];
+        ctx.needUpdate = false;
         let s = this.path.toString();
-        this[CONTEXT_KEY].pathname = s ? '/' + s : '';
+        ctx.pathname = s ? '/' + s : '';
         s = this.searchParams.toString();
-        this[CONTEXT_KEY].search = s ? '?' + s : '';
+        ctx.search = s ? '?' + s : '';
+        let address = '';
+        if (ctx.hostname) {
+            address += (ctx.protocol || 'http:') + '//' +
+                (ctx.username || ctx.password
+                    ? ((ctx.username ? encodeURIComponent(ctx.username) : '') +
+                        (ctx.password ? ':' + encodeURIComponent(ctx.password) : '') + '@')
+                    : '') + this.host;
+        }
+        ctx.address = address + ctx.prefix + ctx.pathname;
     }
-    _setPathname(v, inclSvcRoot) {
+    _setPathname(v, trimPrefix) {
         this.path.clear();
         if (!v)
             return;
         const pathTokenizer = fastTokenizer.tokenize(normalizePath(v, true), {
             delimiters: '/', quotes: true, brackets: true,
         });
-        if (inclSvcRoot && this.pathPrefix) {
-            const prefixTokenizer = fastTokenizer.tokenize(normalizePath(this.pathPrefix, true), {
+        if (trimPrefix && this.prefix) {
+            const prefixTokenizer = fastTokenizer.tokenize(normalizePath(this.prefix, true), {
                 delimiters: '/', quotes: true, brackets: true,
             });
             for (const a of prefixTokenizer) {
@@ -7214,12 +7448,428 @@ class OpraURL {
         }
         for (const x of pathTokenizer) {
             const p = decodePathComponent(x);
-            this.path.add(p);
+            this.path.join(p);
         }
+        this._changed();
+    }
+    _changed() {
+        this[kContext].needUpdate = true;
     }
 }
+OpraURL.kContext = kContext;
+OpraURL.kPath = kPath;
+OpraURL.kSearchParams = kSearchParams;
 
-buffer.Buffer.from('\r\n');
+const crlfBuffer = buffer.Buffer.from('\r\n');
+const kHeaders = Symbol('kHeaders');
+const kHeadersCount = Symbol('kHeadersCount');
+const kTrailers = Symbol('kTrailers');
+const kTrailersCount = Symbol('kTrailersCount');
+// todo: Check is this class should be in common library
+class HttpRequestNode extends stream.Readable {
+    constructor() {
+        super(...arguments);
+        this.aborted = false;
+    }
+    get headers() {
+        if (!this[kHeaders])
+            this[kHeaders] = arrayToHeaders(this.rawHeaders);
+        return this[kHeaders];
+    }
+    get headersCount() {
+        return this[kHeadersCount];
+    }
+    get trailers() {
+        if (!this[kTrailers])
+            this[kTrailers] = arrayToHeaders(this.rawTrailers);
+        return this[kTrailers];
+    }
+    get trailersCount() {
+        return this[kTrailersCount];
+    }
+    _read() {
+        if (this.data) {
+            this.push(this.data);
+        }
+        this.push(null);
+    }
+    static parse(input) {
+        const parser = new httpParser.HTTPParser(httpParser.HTTPParser.REQUEST);
+        const out = new HttpRequestNode();
+        const bodyChunks = [];
+        parser[httpParser.HTTPParser.kOnHeadersComplete] = function (req) {
+            out.shouldKeepAlive = req.shouldKeepAlive;
+            out.upgrade = req.upgrade;
+            out.method = httpParser.HTTPParser.methods[req.method];
+            out.url = req.url;
+            out.originalUrl = req.url;
+            out.httpVersionMajor = req.versionMajor;
+            out.httpVersionMinor = req.versionMinor;
+            out.httpVersion = req.versionMajor + '.' + req.versionMinor;
+            out.rawHeaders = req.headers;
+            out[kHeadersCount] = Math.ceil(req.headers.length / 2);
+            out[kTrailersCount] = 0;
+        };
+        parser[httpParser.HTTPParser.kOnBody] = function (chunk, offset, length) {
+            bodyChunks.push(chunk.subarray(offset, offset + length));
+        };
+        // This is actually the event for trailers, go figure.
+        parser[httpParser.HTTPParser.kOnHeaders] = function (t) {
+            out.rawTrailers = t;
+            out[kTrailersCount] = Math.ceil(t.length / 2);
+        };
+        parser[httpParser.HTTPParser.kOnMessageComplete] = function () {
+            out.complete = true;
+        };
+        // Since we are sending the entire Buffer at once here all callbacks above happen synchronously.
+        // The parser does not do _anything_ asynchronous.
+        // However, you can of course call execute() multiple times with multiple chunks, e.g. from a stream.
+        // But then you have to refactor the entire logic to be async (e.g. resolve a Promise in kOnMessageComplete and add timeout logic).
+        parser.execute(input);
+        if (!out.complete)
+            parser.execute(crlfBuffer);
+        parser.finish();
+        if (!out.complete) {
+            throw new Error('Could not parse request');
+        }
+        out.rawTrailers = out.rawTrailers || [];
+        if (bodyChunks.length)
+            out.data = buffer.Buffer.concat(bodyChunks);
+        out.resume();
+        return out;
+    }
+}
+function arrayToHeaders(arr) {
+    const headers = {};
+    for (let i = 0; i < arr.length; i++) {
+        const k = arr[i].toLowerCase();
+        const v = arr[++i];
+        const trgV = headers[k];
+        // Array header -- only Set-Cookie at the moment
+        if (trgV && k === 'set-cookie') {
+            const a = Array.isArray(trgV) ? trgV : [trgV];
+            a.push(v);
+            headers[k] = a;
+        }
+        else if (typeof trgV === 'string') {
+            headers[k] += (k === 'cookie' ? '; ' : ', ') + v;
+        }
+        else
+            headers[k] = v;
+    }
+    return headers;
+}
+
+var _a, _b;
+const knownKeys = Object.keys(exports.HttpHeaderCodes);
+const knownKeysLower = knownKeys.map(x => x.toLowerCase());
+const nodeInspectCustom = Symbol.for('nodejs.util.inspect.custom');
+const kEntries = Symbol('kEntries');
+const kSize = Symbol('kSize');
+const kOptions = Symbol('kOptions');
+class HttpHeaders {
+    constructor(init, options) {
+        this[_a] = new ResponsiveMap();
+        this[_b] = 0;
+        this[kOptions] = { ...options, onChange: undefined };
+        if (init)
+            this.appendAll(init);
+        this[kOptions].onChange = options?.onChange;
+    }
+    get size() {
+        return this[kSize];
+    }
+    /**
+     * Appends a new value to the existing set of values for a header
+     * and returns this instance
+     */
+    append(name, value) {
+        this._append(name, value);
+        this.changed();
+        return this;
+    }
+    /**
+     * Appends multiple values to the existing set of values for a header
+     * and returns this instance
+     */
+    appendAll(headers) {
+        if (typeof headers === 'string') {
+            headers.split('\n').forEach(line => {
+                const index = line.indexOf(':');
+                if (index > 0) {
+                    const name = line.slice(0, index);
+                    const value = line.slice(index + 1).trim();
+                    this._append(name, value);
+                }
+            });
+        }
+        else if (headers.forEach && typeof headers.forEach === 'function')
+            headers.forEach((value, name) => this._append(name, value));
+        else
+            Object.keys(headers).forEach(name => this._append(name, headers[name]));
+        this.changed();
+        return this;
+    }
+    changed() {
+        if (this[kOptions].onChange)
+            this[kOptions].onChange();
+    }
+    clear() {
+        if (this[kEntries].size) {
+            this[kEntries].clear();
+            this[kSize] = 0;
+            this.changed();
+        }
+    }
+    /**
+     * Deletes values for a given header
+     */
+    delete(name, value) {
+        if (this._delete(name, value))
+            this.changed();
+        return this;
+    }
+    /**
+     * Returns an iterable of key, value pairs for every entry in the map.
+     */
+    entries() {
+        const iter = this[kEntries].entries();
+        let i = 0;
+        let key;
+        let values;
+        return {
+            [Symbol.iterator]() {
+                return this;
+            },
+            next() {
+                if (values) {
+                    if (i >= values.length) {
+                        values = undefined;
+                        i = 0;
+                    }
+                }
+                if (!values) {
+                    const n = iter.next();
+                    if (n.done)
+                        return { done: true, value: undefined };
+                    key = n.value[0];
+                    values = n.value[1];
+                }
+                return {
+                    done: false,
+                    value: [key, values[i++]]
+                };
+            }
+        };
+    }
+    forEach(callbackFn, thisArg) {
+        const iterator = this.entries();
+        let entry = iterator.next();
+        while (!entry.done) {
+            callbackFn.call(thisArg || this, entry.value[1], entry.value[0], this);
+            entry = iterator.next();
+        }
+    }
+    /**
+     * Retrieves value of a given header at given index
+     */
+    get(name, index = 0) {
+        const values = this[kEntries].get(name.toLowerCase());
+        return values && values.length > index ? values[index] : null;
+    }
+    /**
+     * Retrieves an array of values for a given header.
+     */
+    getAll(name) {
+        const entry = this[kEntries].get(name);
+        return entry ? entry.slice(0) : null;
+    }
+    /**
+     * Retrieves the names of the headers.
+     */
+    keys() {
+        return this[kEntries].keys();
+    }
+    /**
+     * Checks for existence of a given header.
+     */
+    has(name) {
+        return this[kEntries].has(name);
+    }
+    /**
+     * Sets or modifies a value for a given header.
+     * If the header already exists, its value is replaced with the given value
+     */
+    set(name, value) {
+        this._set(name, String(value));
+        this.changed();
+        return this;
+    }
+    sort(compareFn) {
+        this[kEntries].sort(compareFn);
+        this.changed();
+        return this;
+    }
+    _append(name, value) {
+        const i = knownKeysLower.indexOf(name);
+        const normalizedName = knownKeys[i] || name;
+        let values = this[kEntries].get(normalizedName);
+        if (!values) {
+            values = [];
+            this[kEntries].set(normalizedName, values);
+        }
+        const oldSize = values.length;
+        if (Array.isArray(value))
+            values.push(...value.map(x => String(x)));
+        else
+            values.push(String(value));
+        this[kSize] = -oldSize + values.length;
+    }
+    _delete(name, value) {
+        const oldValues = this[kEntries].get(name);
+        if (!oldValues)
+            return false;
+        const oldSize = this[kSize];
+        if (value) {
+            const valueToDelete = Array.isArray(value) ? value.map(x => String(x)) : [String(value)];
+            const newValues = oldValues.filter(x => !valueToDelete.includes(x));
+            this[kEntries].set(name, newValues);
+            this[kSize] += -oldValues.length + newValues.length;
+        }
+        else {
+            this[kEntries].delete(name);
+            this[kSize] -= oldValues.length;
+        }
+        return oldSize !== this[kSize];
+    }
+    _set(name, value) {
+        if (value == null) {
+            this._delete(name);
+            return;
+        }
+        const oldValues = this[kEntries].get(name);
+        const i = knownKeysLower.indexOf(name);
+        const normalizedName = knownKeys[i] || name;
+        const newValues = Array.isArray(value) ? value : [value];
+        this[kEntries].set(normalizedName, newValues);
+        this[kSize] += -(oldValues?.length || 0) + newValues.length;
+    }
+    [(_a = kEntries, _b = kSize, nodeInspectCustom)]() {
+        return this[kEntries];
+    }
+    [Symbol.iterator]() {
+        return this.entries();
+    }
+    get [Symbol.toStringTag]() {
+        return 'HttpHeaders';
+    }
+}
+HttpHeaders.kEntries = kEntries;
+HttpHeaders.kSize = kSize;
+HttpHeaders.kOptions = kOptions;
+
+/// <reference lib="dom" />
+const directCopyProperties = ['cache', 'credentials', 'destination', 'headers', 'integrity',
+    'keepalive', 'mode', 'redirect', 'referrer', 'referrerPolicy'];
+class HttpRequest {
+    constructor(init) {
+        this.cache = init?.cache || 'default';
+        this.credentials = init?.credentials || 'same-origin';
+        this.destination = init?.destination || '';
+        this.headers = new HttpHeaders(init?.headers);
+        this.integrity = init?.integrity || '';
+        this.keepalive = init?.keepalive ?? false;
+        this.method = (init?.method || 'GET').toUpperCase();
+        this.mode = init?.mode || 'cors';
+        this.redirect = init?.redirect || 'follow';
+        this.mode = init?.mode || 'cors';
+        this.referrer = init?.referrer || '';
+        this.referrerPolicy = init?.referrerPolicy || '';
+        this.signal = init?.signal || new AbortController().signal;
+        this.body = init?.body;
+        this.urlInstance = new OpraURL(init?.url);
+        if (init?.params)
+            this.params.appendAll(init.params);
+    }
+    /** Returns the URL of request as a string. */
+    get url() {
+        return this.urlInstance.href;
+    }
+    set url(value) {
+        this.urlInstance.parse(value);
+    }
+    /** Returns the searchParams of the URL as OpraURLSearchParams */
+    get params() {
+        return this.urlInstance.searchParams;
+    }
+    /** Returns the path part of URL as OpraURLPath */
+    get path() {
+        return this.urlInstance.path;
+    }
+    clone(...update) {
+        const out = new HttpRequest();
+        out.merge(this);
+        for (const upd of update) {
+            out.merge(upd);
+        }
+        return out;
+    }
+    merge(update) {
+        directCopyProperties.forEach(k => {
+            if (update[k] != null)
+                this[k] = update[k];
+        });
+        if (update.headers) {
+            const h = update.headers instanceof HttpHeaders
+                ? update.headers
+                : new HttpHeaders(update.headers);
+            h.forEach((v, k) => {
+                if (k.toLowerCase() === 'set-cookie') {
+                    this.headers.append(k, v);
+                }
+                else
+                    this.headers.set(k, v);
+            });
+        }
+    }
+    inset(src) {
+        directCopyProperties.forEach(k => {
+            if (this[k] == null && src[k] != null)
+                this[k] = src[k];
+        });
+        if (src.headers) {
+            const h = src.headers instanceof HttpHeaders
+                ? src.headers
+                : new HttpHeaders(src.headers);
+            h.forEach((v, k) => {
+                if (k.toLowerCase() === 'set-cookie') {
+                    this.headers.append(k, v);
+                }
+                else if (!this.headers.has(k))
+                    this.headers.set(k, v);
+            });
+        }
+    }
+}
+
+class HttpResponse {
+    constructor(init) {
+        /**
+         * Returns true if response has body to be received
+         */
+        this.hasBody = false;
+        this.headers = new HttpHeaders(init?.headers);
+        this.status = init?.status || 200;
+        this.statusText = init?.statusText || 'OK';
+        this.url = init?.url || null;
+        this.ok = this.status >= 200 && this.status < 300;
+        this.body = init?.body;
+        this.hasBody = init?.body != null || !!init?.hasBody;
+    }
+    clone(update) {
+        return new HttpResponse({ ...this, ...update });
+    }
+}
 
 class ClientError extends Error {
     constructor(init, cause) {
@@ -7239,259 +7889,146 @@ const JSON_CONTENT_TYPE_PATTERN = /^application\/([\w-]+\+)?\bjson\b/i;
 const TEXT_CONTENT_TYPE_PATTERN = /^text\/.*$/i;
 const FORMDATA_CONTENT_TYPE_PATTERN = /^multipart\/\bform-data\b/i;
 
-class HttpRequest extends rxjs.Observable {
-    constructor(_handler, options = {}) {
+const kHandler = Symbol('kHandler');
+const kRequest = Symbol('kRequest');
+class HttpRequestHost extends rxjs.Observable {
+    constructor(handler, options) {
         super((subscriber) => {
-            if (options.observe === 'response') {
-                this.fetch().then(v => {
-                    subscriber.next(v);
-                    subscriber.complete();
-                }).catch(e => subscriber.error(e));
-                return;
-            }
-            this.resolve().then(v => {
-                subscriber.next(v);
-                subscriber.complete();
-            }).catch(e => subscriber.error(e));
+            handler(options?.observe || 'body', this[kRequest]).subscribe((subscriber));
         });
-        this._handler = _handler;
-        this.options = options;
+        this[kHandler] = handler;
+        this[kRequest] = new HttpRequest(options?.http);
         this.contentId = uid.uid(6);
-        this.options = options;
     }
     header(name, value) {
-        this._headers = this._headers || {};
-        this._headers[name] = value;
+        this[kRequest].headers.append(name, value);
         return this;
     }
-    /**
-     * Sends the request
-     */
-    async fetch() {
-        const promise = this._promise || (this._promise = new Promise((resolve, reject) => {
-            setTimeout(() => {
-                this._execute().then(resolve).catch(reject);
-            }, 0);
-        }));
-        return await promise;
+    param(name, value) {
+        this[kRequest].params.append(name, value);
+        return this;
     }
-    /**
-     * Sends the request and returns response data
-     */
-    async resolve() {
-        const resp = await this.fetch();
-        return resp.data;
+    async fetch(observe) {
+        return rxjs.lastValueFrom(this[kHandler](observe || 'body', this[kRequest]));
     }
     with(cb) {
         cb(this);
         return this;
     }
-    binding() {
-        return {};
-    }
-    async _execute() {
-        const req = this.prepare();
-        return await this._handler(req);
-    }
 }
+HttpRequestHost.kHandler = kHandler;
+HttpRequestHost.kRequest = kRequest;
 
-function mergeRawHttpRequests(target, ...other) {
-    let params;
-    const arr = [target, ...other];
-    let headers;
-    for (let i = arr.length - 1; i >= 0; i--) {
-        const o = arr[i];
-        if (o?.headers) {
-            headers = headers || {};
-            Object.assign(headers, normalizeHeaders(o.headers));
-        }
-    }
-    for (const o of arr) {
-        if (!o)
-            continue;
-        Object.assign(target, o);
-        if (o?.params) {
-            params = params || new OpraURLSearchParams();
-            o.params.forEach((v, n) => params?.append(n, v));
-        }
-    }
-    target.headers = headers;
-    target.params = params;
-    return target;
-}
-
-class CollectionCreateRequest extends HttpRequest {
-    constructor(_handler, resource, data, options = {}) {
-        super(_handler, options);
-        this._handler = _handler;
-        this.resource = resource;
-        this.data = data;
-        this.options = options;
-    }
-    prepare() {
-        const searchParams = new OpraURLSearchParams();
-        if (this.options.include)
-            searchParams.set('$include', this.options.include);
-        if (this.options.pick)
-            searchParams.set('$pick', this.options.pick);
-        if (this.options.omit)
-            searchParams.set('$omit', this.options.omit);
-        return mergeRawHttpRequests({
-            method: 'POST',
-            path: this.resource.name,
-            params: searchParams,
-            body: this.data,
-        }, this.options.http);
-    }
-}
-
-class CollectionDeleteManyRequest extends HttpRequest {
-    constructor(_handler, resource, options = {}) {
-        super(_handler, options);
-        this._handler = _handler;
+class CollectionCreateRequest extends HttpRequestHost {
+    constructor(handler, resource, data, options) {
+        super(handler, options);
         this.resource = resource;
-        this.options = options;
-    }
-    prepare() {
-        const searchParams = new OpraURLSearchParams();
-        if (this.options.filter)
-            searchParams.set('$filter', this.options.filter);
-        return mergeRawHttpRequests({
-            method: 'DELETE',
-            path: this.resource.name,
-            params: searchParams,
-        }, this.options.http);
+        const request = this[HttpRequestHost.kRequest];
+        request.method = 'POST';
+        request.url = this.resource.name;
+        request.body = data;
+        if (options?.include)
+            request.params.set('$include', options.include);
+        if (options?.pick)
+            request.params.set('$pick', options.pick);
+        if (options?.omit)
+            request.params.set('$omit', options.omit);
     }
 }
 
-class CollectionDeleteRequest extends HttpRequest {
-    constructor(_handler, resource, keyValue, options = {}) {
-        super(_handler, options);
-        this._handler = _handler;
+class CollectionDeleteManyRequest extends HttpRequestHost {
+    constructor(handler, resource, options) {
+        super(handler, options);
         this.resource = resource;
-        this.keyValue = keyValue;
-        this.options = options;
-    }
-    prepare() {
-        if (this.keyValue == null || this.keyValue === '')
-            throw new TypeError('Key value required to perform "delete" request');
-        const path = new OpraURLPath({ resource: this.resource.name, key: this.keyValue });
-        return mergeRawHttpRequests({
-            method: 'DELETE',
-            path: path.toString(),
-        }, this.options.http);
+        const request = this[HttpRequestHost.kRequest];
+        request.method = 'DELETE';
+        request.url = this.resource.name;
+        if (options?.filter)
+            request.params.set('$filter', options.filter);
     }
 }
 
-class CollectionGetRequest extends HttpRequest {
-    constructor(_handler, resource, keyValue, options = {}) {
-        super(_handler, options);
-        this._handler = _handler;
+class CollectionDeleteRequest extends HttpRequestHost {
+    constructor(handler, resource, id, options) {
+        super(handler, options);
         this.resource = resource;
-        this.keyValue = keyValue;
-        this.options = options;
-    }
-    prepare() {
-        if (this.keyValue == null || this.keyValue === '')
-            throw new TypeError('Key value required to perform "get" request');
-        const path = new OpraURLPath({ resource: this.resource.name, key: this.keyValue });
-        const searchParams = new OpraURLSearchParams();
-        if (this.options.include)
-            searchParams.set('$include', this.options.include);
-        if (this.options.pick)
-            searchParams.set('$pick', this.options.pick);
-        if (this.options.omit)
-            searchParams.set('$omit', this.options.omit);
-        return mergeRawHttpRequests({
-            method: 'GET',
-            path: path.toString(),
-            params: searchParams
-        }, this.options.http);
+        const request = this[HttpRequestHost.kRequest];
+        request.method = 'DELETE';
+        request.path.join({ resource: this.resource.name, key: id });
     }
 }
 
-class CollectionSearchRequest extends HttpRequest {
-    constructor(_handler, resource, options = {}) {
-        super(_handler, options);
-        this._handler = _handler;
+class CollectionGetRequest extends HttpRequestHost {
+    constructor(handler, resource, id, options) {
+        super(handler, options);
         this.resource = resource;
-        this.options = options;
-    }
-    prepare() {
-        const searchParams = new OpraURLSearchParams();
-        if (this.options.include)
-            searchParams.set('$include', this.options.include);
-        if (this.options.pick)
-            searchParams.set('$pick', this.options.pick);
-        if (this.options.omit)
-            searchParams.set('$omit', this.options.omit);
-        if (this.options.sort)
-            searchParams.set('$sort', this.options.sort);
-        if (this.options.filter)
-            searchParams.set('$filter', this.options.filter);
-        if (this.options.limit != null)
-            searchParams.set('$limit', this.options.limit);
-        if (this.options.skip != null)
-            searchParams.set('$skip', this.options.skip);
-        if (this.options.count != null)
-            searchParams.set('$count', this.options.count);
-        if (this.options.distinct != null)
-            searchParams.set('$distinct', this.options.distinct);
-        return mergeRawHttpRequests({
-            method: 'GET',
-            path: this.resource.name,
-            params: searchParams
-        }, this.options.http);
+        const request = this[HttpRequestHost.kRequest];
+        request.method = 'GET';
+        request.path.join({ resource: this.resource.name, key: id });
+        if (options?.include)
+            request.params.set('$include', options.include);
+        if (options?.pick)
+            request.params.set('$pick', options.pick);
+        if (options?.omit)
+            request.params.set('$omit', options.omit);
     }
 }
 
-class CollectionUpdateManyRequest extends HttpRequest {
-    constructor(_handler, resource, data, options = {}) {
-        super(_handler, options);
-        this._handler = _handler;
+class CollectionSearchRequest extends HttpRequestHost {
+    constructor(handler, resource, options) {
+        super(handler, options);
         this.resource = resource;
-        this.data = data;
-        this.options = options;
-    }
-    prepare() {
-        const searchParams = new OpraURLSearchParams();
-        if (this.options.filter)
-            searchParams.set('$filter', this.options.filter);
-        return mergeRawHttpRequests({
-            method: 'PATCH',
-            path: this.resource.name,
-            params: searchParams,
-            body: this.data
-        }, this.options.http);
+        const request = this[HttpRequestHost.kRequest];
+        request.method = 'GET';
+        request.url = this.resource.name;
+        if (options?.include)
+            request.params.set('$include', options.include);
+        if (options?.pick)
+            request.params.set('$pick', options.pick);
+        if (options?.omit)
+            request.params.set('$omit', options.omit);
+        if (options?.sort)
+            request.params.set('$sort', options.sort);
+        if (options?.filter)
+            request.params.set('$filter', options.filter);
+        if (options?.limit != null)
+            request.params.set('$limit', options.limit);
+        if (options?.skip != null)
+            request.params.set('$skip', options.skip);
+        if (options?.count != null)
+            request.params.set('$count', options.count);
+        if (options?.distinct != null)
+            request.params.set('$distinct', options.distinct);
+    }
+}
+
+class CollectionUpdateManyRequest extends HttpRequestHost {
+    constructor(handler, resource, data, options) {
+        super(handler, options);
+        this.resource = resource;
+        const request = this[HttpRequestHost.kRequest];
+        request.method = 'PATCH';
+        request.url = this.resource.name;
+        request.body = data;
+        if (options?.filter)
+            request.params.set('$filter', options.filter);
     }
 }
 
-class CollectionUpdateRequest extends HttpRequest {
-    constructor(_handler, resource, keyValue, data, options = {}) {
-        super(_handler, options);
-        this._handler = _handler;
+class CollectionUpdateRequest extends HttpRequestHost {
+    constructor(handler, resource, id, data, options) {
+        super(handler, options);
         this.resource = resource;
-        this.keyValue = keyValue;
-        this.data = data;
-        this.options = options;
-    }
-    prepare() {
-        if (this.keyValue == null || this.keyValue === '')
-            throw new TypeError('Key value required to perform "get" request');
-        const path = new OpraURLPath({ resource: this.resource.name, key: this.keyValue });
-        const searchParams = new OpraURLSearchParams();
-        if (this.options.include)
-            searchParams.set('$include', this.options.include);
-        if (this.options.pick)
-            searchParams.set('$pick', this.options.pick);
-        if (this.options.omit)
-            searchParams.set('$omit', this.options.omit);
-        return mergeRawHttpRequests({
-            method: 'PATCH',
-            path: path.toString(),
-            params: searchParams,
-            body: this.data
-        }, this.options.http);
+        const request = this[HttpRequestHost.kRequest];
+        request.method = 'PATCH';
+        request.path.join({ resource: this.resource.name, key: id });
+        request.body = data;
+        if (options?.include)
+            request.params.set('$include', options.include);
+        if (options?.pick)
+            request.params.set('$pick', options.pick);
+        if (options?.omit)
+            request.params.set('$omit', options.omit);
     }
 }
 
@@ -7503,133 +8040,68 @@ class HttpCollectionService {
     create(data, options) {
         return new CollectionCreateRequest(this._handler, this.resource, data, options);
     }
-    delete(keyValue, options) {
-        return new CollectionDeleteRequest(this._handler, this.resource, keyValue, options);
+    delete(id, options) {
+        return new CollectionDeleteRequest(this._handler, this.resource, id, options);
     }
     deleteMany(options) {
         return new CollectionDeleteManyRequest(this._handler, this.resource, options);
     }
-    get(keyValue, options) {
-        return new CollectionGetRequest(this._handler, this.resource, keyValue, options);
+    get(id, options) {
+        return new CollectionGetRequest(this._handler, this.resource, id, options);
     }
     search(options) {
         return new CollectionSearchRequest(this._handler, this.resource, options);
     }
-    update(keyValue, data, options) {
-        return new CollectionUpdateRequest(this._handler, this.resource, keyValue, data, options);
+    update(id, data, options) {
+        return new CollectionUpdateRequest(this._handler, this.resource, id, data, options);
     }
     updateMany(data, options) {
         return new CollectionUpdateManyRequest(this._handler, this.resource, data, options);
     }
 }
 
-class HttpSingletonGetRequest extends HttpRequest {
-    constructor(_handler, resource, options = {}) {
-        super(_handler, options);
-        this._handler = _handler;
+class SingletonDeleteRequest extends HttpRequestHost {
+    constructor(handler, resource, options) {
+        super(handler, options);
         this.resource = resource;
-        this.options = options;
-    }
-    prepare() {
-        const searchParams = new URLSearchParams();
-        if (this.options.include)
-            searchParams.set('$include', '' + this.options.include);
-        if (this.options.pick)
-            searchParams.set('$pick', '' + this.options.pick);
-        if (this.options.omit)
-            searchParams.set('$omit', '' + this.options.omit);
-        return mergeRawHttpRequests({
-            method: 'GET',
-            path: this.resource.name,
-            params: searchParams
-        }, this.options.http);
+        const request = this[HttpRequestHost.kRequest];
+        request.method = 'DELETE';
+        request.url = this.resource.name;
     }
 }
 
-class HttpSingletonService {
-    constructor(resource, _handler) {
+class SingletonGetRequest extends HttpRequestHost {
+    constructor(handler, resource, options) {
+        super(handler, options);
         this.resource = resource;
-        this._handler = _handler;
-    }
-    get(options) {
-        return new HttpSingletonGetRequest(this._handler, this.resource, options);
+        const request = this[HttpRequestHost.kRequest];
+        request.method = 'GET';
+        request.url = this.resource.name;
+        if (options?.include)
+            request.params.set('$include', options.include);
+        if (options?.pick)
+            request.params.set('$pick', options.pick);
+        if (options?.omit)
+            request.params.set('$omit', options.omit);
     }
 }
 
-class BatchRequest extends HttpRequest {
-    constructor(_handler, requests, options = {}) {
-        super(_handler, options);
+class HttpSingletonService {
+    constructor(resource, _handler) {
+        this.resource = resource;
         this._handler = _handler;
-        this.requests = requests;
-        this.options = options;
-        this._results = new WeakMap();
-        this._listeners = new Set();
-        requests.forEach(request => {
-            // Overwrite the _execute method
-            Object.defineProperty(request, '_execute', {
-                writable: true,
-                enumerable: false,
-                configurable: true,
-                value: () => {
-                    return new Promise((resolve, reject) => {
-                        const x = this._results.get(request);
-                        if (x) {
-                            if (x.error)
-                                return reject(x.error);
-                            return resolve(x.response);
-                        }
-                        const callback = (error, response) => {
-                            this._listeners.delete(callback);
-                            if (error)
-                                return reject(error);
-                            resolve(response);
-                        };
-                        this._listeners.add(callback);
-                    });
-                }
-            });
-        });
     }
-    prepare() {
-        const batch = this._buildBatchMultipart(this);
-        const headers = {
-            'content-type': 'multipart/mixed;boundary=' + batch.boundary
-        };
-        return mergeRawHttpRequests({
-            method: 'POST',
-            path: '/$batch',
-            headers,
-            body: batch.stream()
-        }, this.options.http);
-    }
-    _buildBatchMultipart(batch) {
-        const multipart = new BatchMultipart();
-        for (const req of batch.requests) {
-            const prepared = req.prepare();
-            if (req instanceof BatchRequest) {
-                const subMultipart = this._buildBatchMultipart(req);
-                multipart.addBatch(subMultipart);
-                continue;
-            }
-            multipart.addRequestPart({
-                method: prepared.method,
-                url: prepared.path,
-                headers: prepared.headers,
-                data: prepared.body
-            });
-        }
-        return multipart;
+    get(options) {
+        return new SingletonGetRequest(this._handler, this.resource, options);
     }
-    async _execute() {
-        const req = this.prepare();
-        const resp = await this._handler(req);
-        return resp;
+    delete(options) {
+        return new SingletonDeleteRequest(this._handler, this.resource, options);
     }
 }
 
 const documentCache = new Map();
 const documentResolverCaches = new Map();
-class OpraHttpClient {
+class OpraHttpClientBase {
     constructor(serviceUrl, options) {
         this._serviceUrl = serviceUrl;
         this._metadata = options?.document;
@@ -7638,7 +8110,13 @@ class OpraHttpClient {
             if (document)
                 this._metadata = document;
         }
-        this.defaults = options?.defaults || {};
+        this.defaults = {
+            ...options?.defaults,
+            headers: options?.defaults?.headers instanceof HttpHeaders
+                ? options?.defaults?.headers : new HttpHeaders(options?.defaults?.headers),
+            params: options?.defaults?.params instanceof HttpParams
+                ? options?.defaults?.params : new HttpParams(options?.defaults?.headers)
+        };
     }
     get serviceUrl() {
         return this._serviceUrl;
@@ -7663,20 +8141,23 @@ class OpraHttpClient {
         promise = this._resolveMetadata();
         documentResolverCaches.set(cacheName, promise);
         return promise
-            .catch(() => void 0)
+            .catch((e) => {
+            // @ts-ignore
+            throw new Error('Unable to fetch metadata from ' + this.serviceUrl, e);
+        })
             .finally(() => documentResolverCaches.delete(cacheName));
     }
-    batch(requests) {
-        this._assertMetadata();
-        return new BatchRequest(req => this._handleRequest(req), requests);
-    }
+    // batch(requests: HttpRequestHost<any>[]): BatchRequest {
+    // this._assertMetadata();
+    // return new BatchRequest(request => this._sendRequest('response', request, requests);
+    // }
     collection(name) {
         this._assertMetadata();
         // If name argument is a class, we extract name from the class
         if (typeof name === 'function')
             name = name.name;
         const resource = this.metadata.getCollectionResource(name);
-        return new HttpCollectionService(resource, req => this._handleRequest(req));
+        return new HttpCollectionService(resource, this._sendRequest.bind(this));
     }
     singleton(name) {
         this._assertMetadata();
@@ -7684,87 +8165,138 @@ class OpraHttpClient {
         if (typeof name === 'function')
             name = name.name;
         const resource = this.metadata.getSingletonResource(name);
-        return new HttpSingletonService(resource, req => this._handleRequest(req));
+        return new HttpSingletonService(resource, this._sendRequest.bind(this));
     }
     async _resolveMetadata() {
-        const resp = await this._handleRequest({
+        const body = await rxjs.lastValueFrom(this._sendRequest('body', new HttpRequest({
             method: 'GET',
-            path: '/$metadata',
-            headers: { 'accept': 'application/json' }
-        });
-        this._metadata = new OpraDocument(resp.data);
-    }
-    async _handleRequest(req) {
-        mergeRawHttpRequests(req, this.defaults);
-        let url = joinPath(this.serviceUrl, req.path);
-        if (req.params)
-            url += '?' + req.params.toString();
-        if (req.body) {
-            if (typeof req.body === 'object') {
-                if (!(isReadable(req.body) || isReadableStream(req.body) || buffer.Buffer.isBuffer(req.body))) {
-                    if (!req.headers?.['content-type']) {
-                        req.headers = req.headers || {};
-                        req.headers['content-type'] = 'application/json';
+            url: '$metadata',
+            headers: new HttpHeaders({ 'accept': 'application/json' })
+        })));
+        this._metadata = new OpraDocument(body);
+    }
+    _sendRequest(observe, request) {
+        return new rxjs.Observable(subscriber => {
+            try {
+                request.inset(this.defaults);
+                const url = request.url.includes('://') ? request.url : joinPath(this.serviceUrl, request.url);
+                let body;
+                if (request.body) {
+                    let contentType = request.headers.get('Content-Type');
+                    if (typeof request.body === 'string' || typeof request.body === 'number' || typeof request.body === 'boolean') {
+                        contentType = 'text/plain;charset=UTF-8"';
+                        body = String(request.body);
+                        request.headers.delete('Content-Size');
+                        delete request.duplex;
+                    }
+                    else if (isReadableStreamLike(request.body)) {
+                        contentType = 'application/octet-stream';
+                        body = request.body;
+                        request.duplex = 'half';
+                    }
+                    else if (isReadable(request.body)) {
+                        contentType = 'application/octet-stream';
+                        body = stream.Readable.toWeb(request.body);
+                        request.duplex = 'half';
                     }
-                    req.body = JSON.stringify(req.body);
+                    else if (buffer.Buffer.isBuffer(request.body)) {
+                        contentType = 'application/octet-stream';
+                        body = request.body;
+                        request.headers.set('Content-Size', request.body.length);
+                        delete request.duplex;
+                    }
+                    else if (isBlob(request.body)) {
+                        contentType = request.body.type || 'application/octet-stream';
+                        body = request.body;
+                        request.headers.set('Content-Size', request.body.length);
+                        delete request.duplex;
+                    }
+                    else {
+                        contentType = 'application/json';
+                        body = JSON.stringify(request.body);
+                        request.headers.delete('Content-Size');
+                        delete request.duplex;
+                    }
+                    if (!request.headers.has('Content-Type') && contentType)
+                        request.headers.set('Content-Type', contentType);
+                    request.body = body;
                 }
+                this._fetch(url, request)
+                    .then(response => this._handleResponse(observe, subscriber, request, response))
+                    .catch(error => subscriber.error(error));
+                if (observe === 'events')
+                    subscriber.next({ event: 'sent', request });
             }
-        }
-        return this._fetch(url, req);
-    }
-    async _fetch(url, req) {
-        const resp = await fetch(url, req);
-        let data;
-        if (resp.body) {
-            if (JSON_CONTENT_TYPE_PATTERN.test(resp.headers.get('Content-Type') || '')) {
-                data = await resp.json();
-                if (typeof data === 'string')
-                    data = JSON.parse(data);
+            catch (error) {
+                subscriber.error(error);
             }
-            else if (TEXT_CONTENT_TYPE_PATTERN.test(resp.headers.get('Content-Type') || ''))
-                data = await resp.text();
-            else if (FORMDATA_CONTENT_TYPE_PATTERN.test(resp.headers.get('Content-Type') || ''))
-                data = await resp.formData();
-            else
-                data = await resp.arrayBuffer();
-        }
-        if (resp.status >= 400 && resp.status < 600) {
-            throw new ClientError({
-                message: resp.status + ' ' + resp.statusText,
-                status: resp.status,
-                issues: data?.errors
+        });
+    }
+    _fetch(url, init = {}) {
+        return fetch(url, init);
+    }
+    _createResponse(init) {
+        return new HttpResponse(init);
+    }
+    _handleResponse(observe, subscriber, request, fetchResponse) {
+        const headers = new HttpHeaders(fetchResponse.headers);
+        if (observe === 'events') {
+            const response = this._createResponse({
+                url: fetchResponse.url,
+                headers,
+                status: fetchResponse.status,
+                statusText: fetchResponse.statusText,
+                hasBody: !!fetchResponse.body
             });
+            subscriber.next({ event: 'headers-received', request, response });
         }
-        const out = {
-            get headers() {
-                return resp.headers;
-            },
-            get ok() {
-                return resp.ok;
-            },
-            get redirected() {
-                return resp.redirected;
-            },
-            get status() {
-                return resp.status;
-            },
-            get statusText() {
-                return resp.statusText;
-            },
-            get type() {
-                return resp.type;
-            },
-            get url() {
-                return resp.url;
-            },
-            get contentId() {
-                return resp.headers.get('Content-ID');
-            },
-            get data() {
-                return data;
+        Promise
+            .resolve(fetchResponse.body)
+            .then(async (inputStream) => {
+            if (!inputStream)
+                return;
+            if (JSON_CONTENT_TYPE_PATTERN.test(fetchResponse.headers.get('Content-Type') || '')) {
+                const body = await fetchResponse.json();
+                if (typeof body === 'string')
+                    return JSON.parse(body);
+                return body;
             }
-        };
-        return out;
+            if (TEXT_CONTENT_TYPE_PATTERN.test(fetchResponse.headers.get('Content-Type') || ''))
+                return await fetchResponse.text();
+            if (FORMDATA_CONTENT_TYPE_PATTERN.test(fetchResponse.headers.get('Content-Type') || ''))
+                return await fetchResponse.formData();
+            const buf = await fetchResponse.arrayBuffer();
+            return buf.byteLength ? buf : undefined;
+        })
+            .then(body => {
+            if (fetchResponse.status >= 400 && fetchResponse.status < 600) {
+                subscriber.error(new ClientError({
+                    message: fetchResponse.status + ' ' + fetchResponse.statusText,
+                    status: fetchResponse.status,
+                    issues: body?.errors
+                }));
+                subscriber.complete();
+                return;
+            }
+            if (observe === 'body') {
+                subscriber.next(body);
+            }
+            else {
+                const response = this._createResponse({
+                    url: fetchResponse.url,
+                    headers,
+                    status: fetchResponse.status,
+                    statusText: fetchResponse.statusText,
+                    body
+                });
+                if (observe === 'events')
+                    subscriber.next({ event: 'response', request, response });
+                else
+                    subscriber.next(response);
+            }
+            subscriber.complete();
+        })
+            .catch(error => subscriber.error(error));
     }
     _assertMetadata() {
         if (!this._metadata)
@@ -7777,6 +8309,8 @@ class OpraHttpClient {
         return client;
     }
 }
+class OpraHttpClient extends OpraHttpClientBase {
+}
 
 Object.defineProperty(exports, 'uid', {
     enumerable: true,
@@ -7810,7 +8344,7 @@ exports.Ast = Ast;
 exports.BadRequestError = BadRequestError;
 exports.BaseI18n = BaseI18n;
 exports.BatchMultipart = BatchMultipart;
-exports.BatchRequest = BatchRequest;
+exports.BooleanCodec = BooleanCodec;
 exports.BooleanLiteral = BooleanLiteral;
 exports.COMPLEXTYPE_FIELDS = COMPLEXTYPE_FIELDS;
 exports.ClientError = ClientError;
@@ -7835,18 +8369,27 @@ exports.ComplexType = ComplexType;
 exports.ContainerResourceInfo = ContainerResourceInfo;
 exports.DATATYPE_METADATA = DATATYPE_METADATA;
 exports.DataType = DataType;
+exports.DateCodec = DateCodec;
 exports.DateLiteral = DateLiteral;
 exports.DocumentBuilder = DocumentBuilder;
 exports.Expression = Expression;
 exports.FailedDependencyError = FailedDependencyError;
 exports.FieldGetQuery = FieldGetQuery;
+exports.FilterCodec = FilterCodec;
 exports.FilterTreeVisitor = FilterTreeVisitor;
 exports.ForbiddenError = ForbiddenError;
 exports.HttpCollectionService = HttpCollectionService;
-exports.HttpSingletonGetRequest = HttpSingletonGetRequest;
+exports.HttpHeaders = HttpHeaders;
+exports.HttpParamCodec = HttpParamCodec;
+exports.HttpParams = HttpParams;
+exports.HttpRequest = HttpRequest;
+exports.HttpRequestHost = HttpRequestHost;
+exports.HttpRequestNode = HttpRequestNode;
+exports.HttpResponse = HttpResponse;
 exports.HttpSingletonService = HttpSingletonService;
 exports.I18n = I18n;
 exports.IGNORE_RESOLVER_METHOD = IGNORE_RESOLVER_METHOD;
+exports.IntegerCodec = IntegerCodec;
 exports.InternalServerError = InternalServerError;
 exports.Literal = Literal;
 exports.LogicalExpression = LogicalExpression;
@@ -7856,6 +8399,7 @@ exports.MixinType = MixinType;
 exports.NotAcceptableError = NotAcceptableError;
 exports.NotFoundError = NotFoundError;
 exports.NullLiteral = NullLiteral;
+exports.NumberCodec = NumberCodec;
 exports.NumberLiteral = NumberLiteral;
 exports.OmitType = OmitType;
 exports.OprCollectionResource = OprCollectionResource;
@@ -7873,6 +8417,7 @@ exports.OpraDocument = OpraDocument;
 exports.OpraErrorListener = OpraErrorListener;
 exports.OpraException = OpraException;
 exports.OpraHttpClient = OpraHttpClient;
+exports.OpraHttpClientBase = OpraHttpClientBase;
 exports.OpraURL = OpraURL;
 exports.OpraURLPath = OpraURLPath;
 exports.OpraURLPathComponent = OpraURLPathComponent;
@@ -7887,8 +8432,11 @@ exports.ResourceInfo = ResourceInfo;
 exports.ResourceNotFoundError = ResourceNotFoundError;
 exports.ResponsiveMap = ResponsiveMap;
 exports.SimpleType = SimpleType;
+exports.SingletonDeleteRequest = SingletonDeleteRequest;
 exports.SingletonGetQuery = SingletonGetQuery;
+exports.SingletonGetRequest = SingletonGetRequest;
 exports.SingletonResourceInfo = SingletonResourceInfo;
+exports.StringCodec = StringCodec;
 exports.StringLiteral = StringLiteral;
 exports.Term = Term;
 exports.TimeLiteral = TimeLiteral;