@aerokit/sdk 12.44.0

package/dist/cjs/http/index.js

@@ -0,0 +1,59 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var http_exports = {};
+__export(http_exports, {
+  asyncClient: () => asyncClient,
+  client: () => import_client.HttpClient,
+  decorators: () => decorators,
+  errors: () => errors,
+  request: () => import_request.Request,
+  response: () => import_response.Response,
+  rs: () => rs,
+  session: () => import_session.Session,
+  upload: () => import_upload.Upload,
+  utils: () => import_utils.HttpUtils
+});
+module.exports = __toCommonJS(http_exports);
+var asyncClient = __toESM(require("./client-async"));
+__reExport(http_exports, require("./client"), module.exports);
+var import_client = require("./client");
+var decorators = __toESM(require("./decorators"));
+__reExport(http_exports, require("./decorators"), module.exports);
+__reExport(http_exports, require("./request"), module.exports);
+var import_request = require("./request");
+__reExport(http_exports, require("./response"), module.exports);
+var import_response = require("./response");
+var rs = __toESM(require("./rs"));
+__reExport(http_exports, require("./session"), module.exports);
+var import_session = require("./session");
+__reExport(http_exports, require("./upload"), module.exports);
+var import_upload = require("./upload");
+var errors = __toESM(require("./errors"));
+var import_utils = require("./utils");
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vc3JjL2h0dHAvaW5kZXgudHMiXSwKICAic291cmNlc0NvbnRlbnQiOiBbImV4cG9ydCAqIGFzIGFzeW5jQ2xpZW50IGZyb20gXCIuL2NsaWVudC1hc3luY1wiO1xuZXhwb3J0ICogZnJvbSBcIi4vY2xpZW50XCI7XG5leHBvcnQgeyBIdHRwQ2xpZW50IGFzIGNsaWVudCB9IGZyb20gXCIuL2NsaWVudFwiO1xuZXhwb3J0ICogYXMgZGVjb3JhdG9ycyBmcm9tIFwiLi9kZWNvcmF0b3JzXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9kZWNvcmF0b3JzXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9yZXF1ZXN0XCI7XG5leHBvcnQgeyBSZXF1ZXN0IGFzIHJlcXVlc3QgfSBmcm9tIFwiLi9yZXF1ZXN0XCI7XG5leHBvcnQgKiBmcm9tIFwiLi9yZXNwb25zZVwiO1xuZXhwb3J0IHsgUmVzcG9uc2UgYXMgcmVzcG9uc2UgfSBmcm9tIFwiLi9yZXNwb25zZVwiO1xuZXhwb3J0ICogYXMgcnMgZnJvbSBcIi4vcnNcIjtcbmV4cG9ydCAqIGZyb20gXCIuL3Nlc3Npb25cIjtcbmV4cG9ydCB7IFNlc3Npb24gYXMgc2Vzc2lvbiB9IGZyb20gXCIuL3Nlc3Npb25cIjtcbmV4cG9ydCAqIGZyb20gXCIuL3VwbG9hZFwiO1xuZXhwb3J0IHsgVXBsb2FkIGFzIHVwbG9hZCB9IGZyb20gXCIuL3VwbG9hZFwiO1xuZXhwb3J0ICogYXMgZXJyb3JzIGZyb20gXCIuL2Vycm9yc1wiO1xuZXhwb3J0IHsgSHR0cFV0aWxzIGFzIHV0aWxzIH0gZnJvbSBcIi4vdXRpbHNcIjtcbiJdLAogICJtYXBwaW5ncyI6ICI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUEsa0JBQTZCO0FBQzdCLHlCQUFjLHFCQURkO0FBRUEsb0JBQXFDO0FBQ3JDLGlCQUE0QjtBQUM1Qix5QkFBYyx5QkFKZDtBQUtBLHlCQUFjLHNCQUxkO0FBTUEscUJBQW1DO0FBQ25DLHlCQUFjLHVCQVBkO0FBUUEsc0JBQXFDO0FBQ3JDLFNBQW9CO0FBQ3BCLHlCQUFjLHNCQVZkO0FBV0EscUJBQW1DO0FBQ25DLHlCQUFjLHFCQVpkO0FBYUEsb0JBQWlDO0FBQ2pDLGFBQXdCO0FBQ3hCLG1CQUFtQzsiLAogICJuYW1lcyI6IFtdCn0K

package/dist/cjs/http/request.js

@@ -0,0 +1,281 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var request_exports = {};
+__export(request_exports, {
+  Request: () => Request
+});
+module.exports = __toCommonJS(request_exports);
+var import_streams = require("@aerokit/sdk/io/streams");
+const HttpRequestFacade = Java.type("org.eclipse.dirigible.components.api.http.HttpRequestFacade");
+class Request {
+  /**
+   * Determines whether the current thread is handling a valid HTTP request.
+   *
+   * @returns `true` if called in a valid HTTP request context, otherwise `false`.
+   */
+  static isValid() {
+    return HttpRequestFacade.isValid();
+  }
+  /** Returns the HTTP method (GET, POST, PUT, DELETE, etc.). */
+  static getMethod() {
+    return HttpRequestFacade.getMethod();
+  }
+  /** Returns the authenticated remote user name if available. */
+  static getRemoteUser() {
+    return HttpRequestFacade.getRemoteUser();
+  }
+  /** Returns the portion of the request path following the servlet path. */
+  static getPathInfo() {
+    return HttpRequestFacade.getPathInfo();
+  }
+  /** Returns the translated file system path for the request. */
+  static getPathTranslated() {
+    return HttpRequestFacade.getPathTranslated();
+  }
+  /**
+   * Returns the value of a specific HTTP header.
+   *
+   * @param name - Header name to retrieve.
+   * @returns The header value or `undefined` if not found.
+   */
+  static getHeader(name) {
+    const header = HttpRequestFacade.getHeader(name);
+    return header ? header : void 0;
+  }
+  /**
+   * Checks whether the remote user has the given role.
+   *
+   * @param role - The role name to check.
+   */
+  static isUserInRole(role) {
+    return HttpRequestFacade.isUserInRole(role);
+  }
+  /**
+   * Returns a request attribute value previously associated with the request.
+   *
+   * @param name - The attribute name.
+   * @returns A string value or `undefined`.
+   */
+  static getAttribute(name) {
+    const attribute = HttpRequestFacade.getAttribute(name);
+    return attribute ? attribute : void 0;
+  }
+  /** Returns the authentication type if known (BASIC, CLIENT_CERT, etc.). */
+  static getAuthType() {
+    return HttpRequestFacade.getAuthType();
+  }
+  /**
+   * Returns all cookies sent with the request.
+   *
+   * @returns An array of Cookie objects.
+   */
+  static getCookies() {
+    return JSON.parse(HttpRequestFacade.getCookies());
+  }
+  /** Returns all available request attribute names. */
+  static getAttributeNames() {
+    return JSON.parse(HttpRequestFacade.getAttributeNames());
+  }
+  /** Returns the character encoding used in the request body. */
+  static getCharacterEncoding() {
+    return HttpRequestFacade.getCharacterEncoding();
+  }
+  /** Returns the size of the request body in bytes, if known. */
+  static getContentLength() {
+    return HttpRequestFacade.getContentLength();
+  }
+  /**
+   * Returns all values of a specific header.
+   *
+   * @param name - Header name to retrieve.
+   */
+  static getHeaders(name) {
+    return JSON.parse(HttpRequestFacade.getHeaders(name));
+  }
+  /** Returns the MIME content type of the request body. */
+  static getContentType() {
+    return HttpRequestFacade.getContentType();
+  }
+  /** Returns the raw request body as a byte array. */
+  static getBytes() {
+    return JSON.parse(HttpRequestFacade.getBytes());
+  }
+  /**
+   * Returns the request body as text. This is computed once and cached.
+   */
+  static getText() {
+    if (!Request.TEXT_DATA) {
+      Request.TEXT_DATA = HttpRequestFacade.getText();
+    }
+    return Request.TEXT_DATA;
+  }
+  /**
+   * Returns the request body parsed as JSON if valid.
+   *
+   * @returns A JSON object or `undefined` if parsing fails.
+   */
+  static json() {
+    return Request.getJSON();
+  }
+  /** Same as json(); explicit form. */
+  static getJSON() {
+    try {
+      return JSON.parse(Request.getText());
+    } catch (e) {
+      return void 0;
+    }
+  }
+  /** Returns a request parameter value. */
+  static getParameter(name) {
+    return HttpRequestFacade.getParameter(name);
+  }
+  /** Returns a map of request parameters to arrays of values. */
+  static getParameters() {
+    return JSON.parse(HttpRequestFacade.getParameters());
+  }
+  /** Returns the allocated request resource path. */
+  static getResourcePath() {
+    return HttpRequestFacade.getResourcePath();
+  }
+  /** Returns all header names. */
+  static getHeaderNames() {
+    return JSON.parse(HttpRequestFacade.getHeaderNames());
+  }
+  /** Returns all parameter names. */
+  static getParameterNames() {
+    return JSON.parse(HttpRequestFacade.getParameterNames());
+  }
+  /** Returns all values for a given parameter name. */
+  static getParameterValues(name) {
+    return JSON.parse(HttpRequestFacade.getParameterValues(name));
+  }
+  /** Returns the HTTP protocol version. */
+  static getProtocol() {
+    return HttpRequestFacade.getProtocol();
+  }
+  /** Returns the transport scheme (e.g., http, https). */
+  static getScheme() {
+    return HttpRequestFacade.getScheme();
+  }
+  /** Returns the context path of the request. */
+  static getContextPath() {
+    return HttpRequestFacade.getContextPath();
+  }
+  /** Returns the server host name. */
+  static getServerName() {
+    return HttpRequestFacade.getServerName();
+  }
+  /** Returns the server port number. */
+  static getServerPort() {
+    return HttpRequestFacade.getServerPort();
+  }
+  /** Returns the full raw query string. */
+  static getQueryString() {
+    return HttpRequestFacade.getQueryString();
+  }
+  /**
+   * Parses the query string and returns a map of parameter keys to values.
+   * If the same key appears multiple times, values are collected into arrays.
+   */
+  static getQueryParametersMap() {
+    let queryString = Request.getQueryString();
+    if (!queryString)
+      return {};
+    queryString = decodeURI(queryString);
+    let queryStringSegments = queryString.split("&");
+    let queryMap = {};
+    queryStringSegments.forEach(function(seg) {
+      seg = seg.replace("amp;", "");
+      const kv = seg.split("=");
+      const key = kv[0].trim();
+      const value = kv[1] === void 0 ? true : kv[1].trim();
+      if (queryMap[key] !== void 0) {
+        if (!Array.isArray(queryMap[key]))
+          queryMap[key] = [queryMap[key]];
+        queryMap[key].push(value);
+      } else {
+        queryMap[key] = value;
+      }
+    });
+    return queryMap;
+  }
+  /** Returns the remote client IP address. */
+  static getRemoteAddress() {
+    return HttpRequestFacade.getRemoteAddress();
+  }
+  /** Returns the remote client host name. */
+  static getRemoteHost() {
+    return HttpRequestFacade.getRemoteHost();
+  }
+  /** Assigns a new attribute to the request. */
+  static setAttribute(name, value) {
+    HttpRequestFacade.setAttribute(name, value);
+  }
+  /** Removes an attribute from the request. */
+  static removeAttribute(name) {
+    HttpRequestFacade.removeAttribute(name);
+  }
+  /** Returns the client locale preferences. */
+  static getLocale() {
+    return JSON.parse(HttpRequestFacade.getLocale());
+  }
+  /** Returns the full request URI. */
+  static getRequestURI() {
+    return HttpRequestFacade.getRequestURI();
+  }
+  /** Returns `true` if the request was made over HTTPS. */
+  static isSecure() {
+    return HttpRequestFacade.isSecure();
+  }
+  /** Returns the full request URL including protocol and host. */
+  static getRequestURL() {
+    return HttpRequestFacade.getRequestURL();
+  }
+  /** Returns the internal service path for routing. */
+  static getServicePath() {
+    return HttpRequestFacade.getServicePath();
+  }
+  /** Returns the remote client port number. */
+  static getRemotePort() {
+    return HttpRequestFacade.getRemotePort();
+  }
+  /** Returns the local network host name. */
+  static getLocalName() {
+    return HttpRequestFacade.getLocalName();
+  }
+  /** Returns the local IP address. */
+  static getLocalAddress() {
+    return HttpRequestFacade.getLocalAddress();
+  }
+  /** Returns the server local port number handling the request. */
+  static getLocalPort() {
+    return HttpRequestFacade.getLocalPort();
+  }
+  /**
+   * Returns the request body as a binary input stream.
+   *
+   * Useful for processing binary uploads.
+   */
+  static getInputStream() {
+    return import_streams.Streams.createInputStream(HttpRequestFacade.getInputStream());
+  }
+}
+if (typeof module !== "undefined") {
+  module.exports = Request;
+}
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/http/request.ts"],
  "sourcesContent": ["/**\n * The Request API under the HTTP module is responsible for\n * managing standard HTTP request parameters, headers, cookies,\n * and request metadata provided to server-side scripting services.\n *\n */\n\nimport { InputStream, Streams } from \"@aerokit/sdk/io/streams\";\nimport { Cookie } from \"./response\";\n\nconst HttpRequestFacade = Java.type(\"org.eclipse.dirigible.components.api.http.HttpRequestFacade\");\n\n/**\n * Represents the HTTP Request object available within a service execution\n * context. It provides access to HTTP metadata, query parameters, request\n * body content, cookies, and security information.\n *\n * All functions in this class are static: no instance of `Request`\n * needs to be created.\n */\nexport class Request {\n\n    private static TEXT_DATA: string;\n\n    /**\n     * Determines whether the current thread is handling a valid HTTP request.\n     *\n     * @returns `true` if called in a valid HTTP request context, otherwise `false`.\n     */\n    public static isValid(): boolean {\n        return HttpRequestFacade.isValid();\n    }\n\n    /** Returns the HTTP method (GET, POST, PUT, DELETE, etc.). */\n    public static getMethod(): string {\n        return HttpRequestFacade.getMethod();\n    }\n\n    /** Returns the authenticated remote user name if available. */\n    public static getRemoteUser(): string {\n        return HttpRequestFacade.getRemoteUser();\n    }\n\n    /** Returns the portion of the request path following the servlet path. */\n    public static getPathInfo(): string {\n        return HttpRequestFacade.getPathInfo();\n    }\n\n    /** Returns the translated file system path for the request. */\n    public static getPathTranslated(): string {\n        return HttpRequestFacade.getPathTranslated();\n    }\n\n    /**\n     * Returns the value of a specific HTTP header.\n     *\n     * @param name - Header name to retrieve.\n     * @returns The header value or `undefined` if not found.\n     */\n    public static getHeader(name: string): string {\n        const header = HttpRequestFacade.getHeader(name);\n        return header ? header : undefined;\n    }\n\n    /**\n     * Checks whether the remote user has the given role.\n     *\n     * @param role - The role name to check.\n     */\n    public static isUserInRole(role: string): boolean {\n        return HttpRequestFacade.isUserInRole(role);\n    }\n\n    /**\n     * Returns a request attribute value previously associated with the request.\n     *\n     * @param name - The attribute name.\n     * @returns A string value or `undefined`.\n     */\n    public static getAttribute(name: string): string | undefined {\n        const attribute = HttpRequestFacade.getAttribute(name);\n        return attribute ? attribute : undefined;\n    }\n\n    /** Returns the authentication type if known (BASIC, CLIENT_CERT, etc.). */\n    public static getAuthType(): string {\n        return HttpRequestFacade.getAuthType();\n    }\n\n    /**\n     * Returns all cookies sent with the request.\n     *\n     * @returns An array of Cookie objects.\n     */\n    public static getCookies(): Cookie[] {\n        return JSON.parse(HttpRequestFacade.getCookies());\n    }\n\n    /** Returns all available request attribute names. */\n    public static getAttributeNames(): string[] {\n        return JSON.parse(HttpRequestFacade.getAttributeNames());\n    }\n\n    /** Returns the character encoding used in the request body. */\n    public static getCharacterEncoding(): string {\n        return HttpRequestFacade.getCharacterEncoding();\n    }\n\n    /** Returns the size of the request body in bytes, if known. */\n    public static getContentLength(): number {\n        return HttpRequestFacade.getContentLength();\n    }\n\n    /**\n     * Returns all values of a specific header.\n     *\n     * @param name - Header name to retrieve.\n     */\n    public static getHeaders(name: string): string[] {\n        return JSON.parse(HttpRequestFacade.getHeaders(name));\n    }\n\n    /** Returns the MIME content type of the request body. */\n    public static getContentType(): string {\n        return HttpRequestFacade.getContentType();\n    }\n\n    /** Returns the raw request body as a byte array. */\n    public static getBytes(): any[] {\n        return JSON.parse(HttpRequestFacade.getBytes());\n    }\n\n    /**\n     * Returns the request body as text. This is computed once and cached.\n     */\n    public static getText() {\n        if (!Request.TEXT_DATA) {\n            Request.TEXT_DATA = HttpRequestFacade.getText();\n        }\n        return Request.TEXT_DATA;\n    }\n\n    /**\n     * Returns the request body parsed as JSON if valid.\n     *\n     * @returns A JSON object or `undefined` if parsing fails.\n     */\n    public static json(): { [key: string]: any } | undefined {\n        return Request.getJSON();\n    }\n\n    /** Same as json(); explicit form. */\n    public static getJSON(): { [key: string]: any } | undefined {\n        try {\n            return JSON.parse(Request.getText());\n        } catch (e) {\n            return undefined;\n        }\n    }\n\n    /** Returns a request parameter value. */\n    public static getParameter(name: string): string {\n        return HttpRequestFacade.getParameter(name);\n    }\n\n    /** Returns a map of request parameters to arrays of values. */\n    public static getParameters(): { [key: string]: string[] } {\n        return JSON.parse(HttpRequestFacade.getParameters());\n    }\n\n    /** Returns the allocated request resource path. */\n    public static getResourcePath(): string {\n        return HttpRequestFacade.getResourcePath();\n    }\n\n    /** Returns all header names. */\n    public static getHeaderNames(): string[] {\n        return JSON.parse(HttpRequestFacade.getHeaderNames());\n    }\n\n    /** Returns all parameter names. */\n    public static getParameterNames(): string[] {\n        return JSON.parse(HttpRequestFacade.getParameterNames());\n    }\n\n    /** Returns all values for a given parameter name. */\n    public static getParameterValues(name: string): string[] {\n        return JSON.parse(HttpRequestFacade.getParameterValues(name));\n    }\n\n    /** Returns the HTTP protocol version. */\n    public static getProtocol(): string {\n        return HttpRequestFacade.getProtocol();\n    }\n\n    /** Returns the transport scheme (e.g., http, https). */\n    public static getScheme(): string {\n        return HttpRequestFacade.getScheme();\n    }\n\n    /** Returns the context path of the request. */\n    public static getContextPath(): string {\n        return HttpRequestFacade.getContextPath();\n    }\n\n    /** Returns the server host name. */\n    public static getServerName(): string {\n        return HttpRequestFacade.getServerName();\n    }\n\n    /** Returns the server port number. */\n    public static getServerPort(): number {\n        return HttpRequestFacade.getServerPort();\n    }\n\n    /** Returns the full raw query string. */\n    public static getQueryString(): string {\n        return HttpRequestFacade.getQueryString();\n    }\n\n    /**\n     * Parses the query string and returns a map of parameter keys to values.\n     * If the same key appears multiple times, values are collected into arrays.\n     */\n    public static getQueryParametersMap(): { [key: string]: string | string[] } {\n        let queryString = Request.getQueryString();\n        if (!queryString)\n            return {}\n\n        queryString = decodeURI(queryString);\n        let queryStringSegments = queryString.split('&');\n\n        let queryMap: { [key: string]: any } = {};\n        queryStringSegments.forEach(function (seg) {\n            seg = seg.replace('amp;', '');\n            const kv = seg.split('=');\n            const key = kv[0].trim();\n            const value = kv[1] === undefined ? true : kv[1].trim();\n            if (queryMap[key] !== undefined) {\n                if (!Array.isArray(queryMap[key]))\n                    queryMap[key] = [queryMap[key]];\n                queryMap[key].push(value);\n            } else {\n                queryMap[key] = value;\n            }\n        });\n        return queryMap;\n    }\n\n    /** Returns the remote client IP address. */\n    public static getRemoteAddress(): string {\n        return HttpRequestFacade.getRemoteAddress();\n    }\n\n    /** Returns the remote client host name. */\n    public static getRemoteHost(): string {\n        return HttpRequestFacade.getRemoteHost();\n    }\n\n    /** Assigns a new attribute to the request. */\n    public static setAttribute(name: string, value: string): void {\n        HttpRequestFacade.setAttribute(name, value);\n    }\n\n    /** Removes an attribute from the request. */\n    public static removeAttribute(name: string): void {\n        HttpRequestFacade.removeAttribute(name);\n    }\n\n    /** Returns the client locale preferences. */\n    public static getLocale(): any {\n        return JSON.parse(HttpRequestFacade.getLocale());\n    }\n\n    /** Returns the full request URI. */\n    public static getRequestURI(): string {\n        return HttpRequestFacade.getRequestURI();\n    }\n\n    /** Returns `true` if the request was made over HTTPS. */\n    public static isSecure(): boolean {\n        return HttpRequestFacade.isSecure();\n    }\n\n    /** Returns the full request URL including protocol and host. */\n    public static getRequestURL(): string {\n        return HttpRequestFacade.getRequestURL();\n    }\n\n    /** Returns the internal service path for routing. */\n    public static getServicePath(): string {\n        return HttpRequestFacade.getServicePath();\n    }\n\n    /** Returns the remote client port number. */\n    public static getRemotePort(): number {\n        return HttpRequestFacade.getRemotePort();\n    }\n\n    /** Returns the local network host name. */\n    public static getLocalName(): string {\n        return HttpRequestFacade.getLocalName();\n    }\n\n    /** Returns the local IP address. */\n    public static getLocalAddress(): string {\n        return HttpRequestFacade.getLocalAddress();\n    }\n\n    /** Returns the server local port number handling the request. */\n    public static getLocalPort(): number {\n        return HttpRequestFacade.getLocalPort();\n    }\n\n    /**\n     * Returns the request body as a binary input stream.\n     *\n     * Useful for processing binary uploads.\n     */\n    public static getInputStream(): InputStream {\n        return Streams.createInputStream(HttpRequestFacade.getInputStream());\n    }\n}\n\n// @ts-ignore\nif (typeof module !== 'undefined') {\n\t// @ts-ignore\n\tmodule.exports = Request;\n}\n"],
  "mappings": "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",
  "names": []
}
