@aerokit/sdk 12.44.0

package/dist/esm/http/client.mjs

@@ -0,0 +1,126 @@
+const HttpClientFacade = Java.type("org.eclipse.dirigible.components.api.http.HttpClientFacade");
+class HttpClient {
+  /**
+   * Executes a synchronous HTTP GET request.
+   * @param url The target URL.
+   * @param options Configuration options for the request.
+   * @returns The parsed response object containing status, headers, and body.
+   */
+  static get(url, options = {}) {
+    const requestUrl = HttpClient.buildUrl(url, options);
+    const response = HttpClientFacade.get(requestUrl, JSON.stringify(options));
+    return JSON.parse(response);
+  }
+  /**
+   * Executes a synchronous HTTP POST request.
+   * @param url The target URL.
+   * @param options Configuration options for the request, including request body in `text` or `data`.
+   * @returns The parsed response object.
+   */
+  static post(url, options = {}) {
+    const requestUrl = HttpClient.buildUrl(url, options);
+    const response = HttpClientFacade.post(requestUrl, JSON.stringify(options));
+    return JSON.parse(response);
+  }
+  /**
+   * Executes a synchronous HTTP PUT request.
+   * @param url The target URL.
+   * @param options Configuration options for the request.
+   * @returns The parsed response object.
+   */
+  static put(url, options = {}) {
+    const requestUrl = HttpClient.buildUrl(url, options);
+    const response = HttpClientFacade.put(requestUrl, JSON.stringify(options));
+    return JSON.parse(response);
+  }
+  /**
+   * Executes a synchronous HTTP PATCH request.
+   * @param url The target URL.
+   * @param options Configuration options for the request.
+   * @returns The parsed response object.
+   */
+  static patch(url, options = {}) {
+    const requestUrl = HttpClient.buildUrl(url, options);
+    const response = HttpClientFacade.patch(requestUrl, JSON.stringify(options));
+    return JSON.parse(response);
+  }
+  /**
+   * Executes a synchronous HTTP DELETE request.
+   * @param url The target URL.
+   * @param options Configuration options for the request.
+   * @returns The parsed response object.
+   */
+  static delete(url, options = {}) {
+    const requestUrl = HttpClient.buildUrl(url, options);
+    const response = HttpClientFacade.delete(requestUrl, JSON.stringify(options));
+    return JSON.parse(response);
+  }
+  /**
+   * Alias for {@link HttpClient.delete}. Executes a synchronous HTTP DELETE request.
+   * @param url The target URL.
+   * @param options Configuration options for the request.
+   * @returns The parsed response object.
+   */
+  static del(url, options = {}) {
+    return HttpClient.delete(url, options);
+  }
+  /**
+   * Executes a synchronous HTTP HEAD request (fetches headers only).
+   * @param url The target URL.
+   * @param options Configuration options for the request.
+   * @returns The parsed response object. The body (`text` and `data`) will typically be empty.
+   */
+  static head(url, options = {}) {
+    const requestUrl = HttpClient.buildUrl(url, options);
+    const response = HttpClientFacade.head(requestUrl, JSON.stringify(options));
+    return JSON.parse(response);
+  }
+  /**
+   * Executes a synchronous HTTP TRACE request.
+   * @param url The target URL.
+   * @param options Configuration options for the request.
+   * @returns The parsed response object.
+   */
+  static trace(url, options = {}) {
+    const requestUrl = HttpClient.buildUrl(url, options);
+    const response = HttpClientFacade.trace(requestUrl, JSON.stringify(options));
+    return JSON.parse(response);
+  }
+  /**
+   * @private
+   * Builds the request URL by appending query parameters from options.params,
+   * then removes `params` from the options object before passing it to the Java Facade.
+   * @param url The base URL.
+   * @param options The request options object.
+   * @returns The URL with appended query parameters.
+   */
+  static buildUrl(url, options) {
+    if (!options || !options.params || options.params.length === 0) {
+      return url;
+    }
+    let processedUrl = url;
+    let firstParam = true;
+    for (const param of options.params) {
+      if (firstParam) {
+        if (processedUrl.includes("?")) {
+          processedUrl += "&";
+        } else {
+          processedUrl += "?";
+        }
+        firstParam = false;
+      } else {
+        processedUrl += "&";
+      }
+      processedUrl += `${param.name}=${param.value}`;
+    }
+    delete options.params;
+    return processedUrl;
+  }
+}
+if (typeof module !== "undefined") {
+  module.exports = HttpClient;
+}
+export {
+  HttpClient
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/http/client.ts"],
  "sourcesContent": ["/**\n * Provides a JavaScript/TypeScript wrapper (Facade) for making synchronous HTTP requests.\n *\n */\n\nconst HttpClientFacade = Java.type(\"org.eclipse.dirigible.components.api.http.HttpClientFacade\");\n\n/**\n * Defines a single HTTP header, used for both request and response.\n */\nexport interface HttpClientHeader {\n    /** The name of the header (e.g., 'Content-Type', 'Authorization'). */\n    name: string;\n    /** The value of the header. */\n    value: string;\n}\n\n/**\n * Defines a query parameter that will be appended to the URL.\n */\nexport interface HttpClientParam {\n    /** The name of the URL query parameter (e.g., 'id'). */\n    name: string;\n    /** The value of the URL query parameter. */\n    value: string;\n}\n\n/**\n * Defines a file to be included in a multi-part form data request.\n */\nexport interface HttpClientFile {\n    /** The form field name for the file. */\n    name: string;\n    /** The file path or content (behavior depends on the underlying Java implementation). */\n    value: string;\n}\n\n/**\n * Configuration options for an HTTP request, mirroring the capabilities of the underlying Java client.\n */\nexport interface HttpClientRequestOptions {\n    /** Whether 'Expect: 100-Continue' handshake is enabled. Defaults to false. */\n    expectContinueEnabled?: boolean;\n    /** The proxy hostname to use for the request. */\n    proxyHost?: string;\n    /** The proxy port number. */\n    proxyPort?: number;\n    /** The cookie specification to use (e.g., 'default', 'netscape'). */\n    cookieSpec?: string;\n    /** Whether automatic redirects are enabled. Defaults to true. */\n    redirectsEnabled?: boolean;\n    /** Whether relative redirects should be allowed. Defaults to true. */\n    relativeRedirectsAllowed?: boolean;\n    /** Whether circular redirects (infinite loops) should be allowed. Defaults to false. */\n    circularRedirectsAllowed?: boolean;\n    /** The maximum number of redirects to follow. */\n    maxRedirects?: number;\n    /** Whether authentication handling is enabled. */\n    authenticationEnabled?: boolean;\n    /** Array of preferred authentication schemes for the target host. */\n    targetPreferredAuthSchemes?: string[];\n    /** Array of preferred authentication schemes for the proxy. */\n    proxyPreferredAuthSchemes?: string[];\n    /** Timeout in milliseconds for requesting a connection from the connection manager. */\n    connectionRequestTimeout?: number;\n    /** Timeout in milliseconds for establishing the connection. */\n    connectTimeout?: number;\n    /** Socket timeout (timeout for waiting for data) in milliseconds. */\n    socketTimeout?: number;\n    /** Whether automatic content compression (e.g., gzip) is enabled. */\n    contentCompressionEnabled?: boolean;\n    /** Whether to trust all SSL certificates (use only for testing non-production systems). */\n    sslTrustAllEnabled?: boolean;\n    /** Data to be sent as the request body, typically as an array of bytes/integers. */\n    data?: any[];\n    /** Text content to be sent as the request body. Takes precedence over `data`. */\n    text?: string;\n    /** Array of files for multi-part form data submissions. */\n    files?: HttpClientFile[];\n    /** The character encoding (charset) to use for the request body (e.g., 'UTF-8'). */\n    characterEncoding?: string;\n    /** Whether to enforce the character encoding. */\n    characterEncodingEnabled?: boolean;\n    /** The Content-Type header value for the request body. */\n    contentType?: string;\n    /** Array of custom headers to include in the request. */\n    headers?: HttpClientHeader[];\n    /** Array of query parameters to be appended to the URL. */\n    params?: HttpClientParam[];\n    /** If true, treats the response body as binary data. */\n    binary?: boolean;\n    /** Optional context map for advanced configuration of the underlying Java client. */\n    context?: { [key: string]: any };\n}\n\n/**\n * The structure of the response returned by the HttpClient methods.\n */\nexport interface HttpClientResponse {\n    /** The HTTP status code (e.g., 200, 404, 500). */\n    statusCode: number;\n    /** The status message returned by the server (e.g., 'OK', 'Not Found'). */\n    statusMessage: string;\n    /** Response body content as an array of bytes (if requested as binary). */\n    data: any[];\n    /** Response body content as a decoded string. */\n    text: string;\n    /** The protocol used (e.g., 'HTTP/1.1'). */\n    protocol: string;\n    /** Indicates if the response was processed as binary data. */\n    binary: boolean;\n    /** Array of all headers received in the response. */\n    headers: HttpClientHeader[]\n}\n\n/**\n * A static class providing methods for making synchronous HTTP requests.\n * All methods call the underlying Java Facade and parse the JSON response.\n */\nexport class HttpClient {\n\n    /**\n     * Executes a synchronous HTTP GET request.\n     * @param url The target URL.\n     * @param options Configuration options for the request.\n     * @returns The parsed response object containing status, headers, and body.\n     */\n    public static get(url: string, options: HttpClientRequestOptions = {}): HttpClientResponse {\n        const requestUrl = HttpClient.buildUrl(url, options);\n        // The Java Facade expects the configuration options as a JSON string\n        const response = HttpClientFacade.get(requestUrl, JSON.stringify(options));\n        return JSON.parse(response);\n    }\n\n    /**\n     * Executes a synchronous HTTP POST request.\n     * @param url The target URL.\n     * @param options Configuration options for the request, including request body in `text` or `data`.\n     * @returns The parsed response object.\n     */\n    public static post(url: string, options: HttpClientRequestOptions = {}): HttpClientResponse {\n        const requestUrl = HttpClient.buildUrl(url, options);\n        const response = HttpClientFacade.post(requestUrl, JSON.stringify(options));\n        return JSON.parse(response);\n    }\n\n    /**\n     * Executes a synchronous HTTP PUT request.\n     * @param url The target URL.\n     * @param options Configuration options for the request.\n     * @returns The parsed response object.\n     */\n    public static put(url: string, options: HttpClientRequestOptions = {}): HttpClientResponse {\n        const requestUrl = HttpClient.buildUrl(url, options);\n        const response = HttpClientFacade.put(requestUrl, JSON.stringify(options));\n        return JSON.parse(response);\n    }\n\n    /**\n     * Executes a synchronous HTTP PATCH request.\n     * @param url The target URL.\n     * @param options Configuration options for the request.\n     * @returns The parsed response object.\n     */\n    public static patch(url: string, options: HttpClientRequestOptions = {}): HttpClientResponse {\n        const requestUrl = HttpClient.buildUrl(url, options);\n        const response = HttpClientFacade.patch(requestUrl, JSON.stringify(options));\n        return JSON.parse(response);\n    }\n\n    /**\n     * Executes a synchronous HTTP DELETE request.\n     * @param url The target URL.\n     * @param options Configuration options for the request.\n     * @returns The parsed response object.\n     */\n    public static delete(url: string, options: HttpClientRequestOptions = {}): HttpClientResponse {\n        const requestUrl = HttpClient.buildUrl(url, options);\n        const response = HttpClientFacade.delete(requestUrl, JSON.stringify(options));\n        return JSON.parse(response);\n    }\n\n    /**\n     * Alias for {@link HttpClient.delete}. Executes a synchronous HTTP DELETE request.\n     * @param url The target URL.\n     * @param options Configuration options for the request.\n     * @returns The parsed response object.\n     */\n    public static del(url: string, options: HttpClientRequestOptions = {}): HttpClientResponse {\n        return HttpClient.delete(url, options);\n    }\n\n    /**\n     * Executes a synchronous HTTP HEAD request (fetches headers only).\n     * @param url The target URL.\n     * @param options Configuration options for the request.\n     * @returns The parsed response object. The body (`text` and `data`) will typically be empty.\n     */\n    public static head(url: string, options: HttpClientRequestOptions = {}): HttpClientResponse {\n        const requestUrl = HttpClient.buildUrl(url, options);\n        const response = HttpClientFacade.head(requestUrl, JSON.stringify(options));\n        return JSON.parse(response);\n    }\n\n    /**\n     * Executes a synchronous HTTP TRACE request.\n     * @param url The target URL.\n     * @param options Configuration options for the request.\n     * @returns The parsed response object.\n     */\n    public static trace(url: string, options: HttpClientRequestOptions = {}): HttpClientResponse {\n        const requestUrl = HttpClient.buildUrl(url, options);\n        const response = HttpClientFacade.trace(requestUrl, JSON.stringify(options));\n        return JSON.parse(response);\n    }\n\n    /**\n     * @private\n     * Builds the request URL by appending query parameters from options.params,\n     * then removes `params` from the options object before passing it to the Java Facade.\n     * @param url The base URL.\n     * @param options The request options object.\n     * @returns The URL with appended query parameters.\n     */\n    private static buildUrl(url: string, options: HttpClientRequestOptions): string {\n        if (!options || !options.params || options.params.length === 0) {\n            return url;\n        }\n\n        let processedUrl = url;\n        let firstParam = true;\n\n        for (const param of options.params) {\n            if (firstParam) {\n                // Check if the original URL already has query parameters\n                if (processedUrl.includes('?')) {\n                    processedUrl += '&';\n                } else {\n                    processedUrl += '?';\n                }\n                firstParam = false;\n            } else {\n                processedUrl += '&';\n            }\n\n            // Simple URL encoding of the value is assumed here for basic operation\n            processedUrl += `${param.name}=${param.value}`;\n        }\n\n        // Remove params from options because they are now part of the URL string.\n        delete options.params;\n\n        return processedUrl;\n    }\n}\n\n// @ts-ignore\nif (typeof module !== 'undefined') {\n\t// @ts-ignore\n\tmodule.exports = HttpClient;\n}"],
  "mappings": "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",
  "names": []
}


package/dist/esm/http/decorators.mjs

@@ -0,0 +1,47 @@
+import * as rs from "@aerokit/sdk/http/rs";
+const router = rs.service();
+let instance = null;
+function Controller(ctr, context) {
+  instance = new ctr();
+  router.execute();
+}
+function Documentation(documentation) {
+  return function(value, context) {
+  };
+}
+const Get = createRequestDecorator("get");
+const Post = createRequestDecorator("post");
+const Put = createRequestDecorator("put");
+const Patch = createRequestDecorator("patch");
+const Delete = createRequestDecorator("delete");
+const Head = createRequestDecorator("head");
+const Options = createRequestDecorator("options");
+function createRequestDecorator(httpMethod) {
+  return function(path, consumesMimeTypes = ["*/*"], producesMimeTypes = ["application/json"]) {
+    return function(target, propertyKey, descriptor) {
+      const handler = descriptor ? descriptor.value : target;
+      router.resource(path)[httpMethod]((ctx, req, res) => {
+        handleRequest(req, res, ctx, handler);
+      }).consumes(consumesMimeTypes).produces(producesMimeTypes);
+    };
+  };
+}
+function handleRequest(req, res, ctx, handler) {
+  const body = req.json();
+  const maybeResponseBody = handler.apply(instance || {}, [body, ctx, req, res]);
+  if (maybeResponseBody) {
+    res.json(maybeResponseBody);
+  }
+}
+export {
+  Controller,
+  Delete,
+  Documentation,
+  Get,
+  Head,
+  Options,
+  Patch,
+  Post,
+  Put
+};
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vc3JjL2h0dHAvZGVjb3JhdG9ycy50cyJdLAogICJzb3VyY2VzQ29udGVudCI6IFsiaW1wb3J0ICogYXMgcnMgZnJvbSBcIkBhZXJva2l0L3Nkay9odHRwL3JzXCJcblxuY29uc3Qgcm91dGVyID0gcnMuc2VydmljZSgpO1xubGV0IGluc3RhbmNlID0gbnVsbDtcblxuZXhwb3J0IGZ1bmN0aW9uIENvbnRyb2xsZXIoY3RyOiB7IG5ldygpIH0sIGNvbnRleHQ6IENsYXNzRGVjb3JhdG9yQ29udGV4dCk6IHZvaWQge1xuICAgIGluc3RhbmNlID0gbmV3IGN0cigpO1xuICAgIHJvdXRlci5leGVjdXRlKCk7XG59XG5cbmV4cG9ydCBmdW5jdGlvbiBEb2N1bWVudGF0aW9uKGRvY3VtZW50YXRpb246IHN0cmluZykge1xuICByZXR1cm4gZnVuY3Rpb24gKFxuICAgIHZhbHVlOiBhbnksXG4gICAgY29udGV4dDogQ2xhc3NEZWNvcmF0b3JDb250ZXh0IHwgQ2xhc3NGaWVsZERlY29yYXRvckNvbnRleHQgfCBDbGFzc01ldGhvZERlY29yYXRvckNvbnRleHRcbiAgKSB7fTtcbn1cblxuZXhwb3J0IGNvbnN0IEdldCA9IGNyZWF0ZVJlcXVlc3REZWNvcmF0b3IoXCJnZXRcIilcbmV4cG9ydCBjb25zdCBQb3N0ID0gY3JlYXRlUmVxdWVzdERlY29yYXRvcihcInBvc3RcIilcbmV4cG9ydCBjb25zdCBQdXQgPSBjcmVhdGVSZXF1ZXN0RGVjb3JhdG9yKFwicHV0XCIpXG5leHBvcnQgY29uc3QgUGF0Y2ggPSBjcmVhdGVSZXF1ZXN0RGVjb3JhdG9yKFwicGF0Y2hcIilcbmV4cG9ydCBjb25zdCBEZWxldGUgPSBjcmVhdGVSZXF1ZXN0RGVjb3JhdG9yKFwiZGVsZXRlXCIpXG5leHBvcnQgY29uc3QgSGVhZCA9IGNyZWF0ZVJlcXVlc3REZWNvcmF0b3IoXCJoZWFkXCIpXG5leHBvcnQgY29uc3QgT3B0aW9ucyA9IGNyZWF0ZVJlcXVlc3REZWNvcmF0b3IoXCJvcHRpb25zXCIpXG5cbmZ1bmN0aW9uIGNyZWF0ZVJlcXVlc3REZWNvcmF0b3IoaHR0cE1ldGhvZCkge1xuICAgIHJldHVybiBmdW5jdGlvbiAocGF0aDogc3RyaW5nLCBjb25zdW1lc01pbWVUeXBlczogdW5kZWZpbmVkIHwgc3RyaW5nIHwgc3RyaW5nW10gPSBbJyovKiddLCBwcm9kdWNlc01pbWVUeXBlczogdW5kZWZpbmVkIHwgc3RyaW5nIHwgc3RyaW5nW10gPSBbJ2FwcGxpY2F0aW9uL2pzb24nXSk6IGFueSB7XG4gICAgICAgIHJldHVybiBmdW5jdGlvbiAodGFyZ2V0LCBwcm9wZXJ0eUtleSwgZGVzY3JpcHRvcikge1xuICAgICAgICAgICAgY29uc3QgaGFuZGxlciA9IGRlc2NyaXB0b3IgPyBkZXNjcmlwdG9yLnZhbHVlIDogdGFyZ2V0O1xuICAgICAgICAgICAgcm91dGVyLnJlc291cmNlKHBhdGgpW2h0dHBNZXRob2RdKChjdHgsIHJlcSwgcmVzKSA9PiB7XG4gICAgICAgICAgICAgICAgaGFuZGxlUmVxdWVzdChyZXEsIHJlcywgY3R4LCBoYW5kbGVyKTtcbiAgICAgICAgICAgIH0pLmNvbnN1bWVzKGNvbnN1bWVzTWltZVR5cGVzKS5wcm9kdWNlcyhwcm9kdWNlc01pbWVUeXBlcyk7XG4gICAgICAgIH07XG4gICAgfVxufVxuXG5mdW5jdGlvbiBoYW5kbGVSZXF1ZXN0KHJlcSwgcmVzLCBjdHgsIGhhbmRsZXIpIHtcbiAgICBjb25zdCBib2R5ID0gcmVxLmpzb24oKTtcbiAgICBjb25zdCBtYXliZVJlc3BvbnNlQm9keSA9IGhhbmRsZXIuYXBwbHkoaW5zdGFuY2UgfHwge30sIFtib2R5LCBjdHgsIHJlcSwgcmVzXSk7XG4gICAgaWYgKG1heWJlUmVzcG9uc2VCb2R5KSB7XG4gICAgICAgIHJlcy5qc29uKG1heWJlUmVzcG9uc2VCb2R5KTtcbiAgICB9XG59XG4iXSwKICAibWFwcGluZ3MiOiAiQUFBQSxZQUFZLFFBQVE7QUFFcEIsTUFBTSxTQUFTLEdBQUcsUUFBUTtBQUMxQixJQUFJLFdBQVc7QUFFUixTQUFTLFdBQVcsS0FBZ0IsU0FBc0M7QUFDN0UsYUFBVyxJQUFJLElBQUk7QUFDbkIsU0FBTyxRQUFRO0FBQ25CO0FBRU8sU0FBUyxjQUFjLGVBQXVCO0FBQ25ELFNBQU8sU0FDTCxPQUNBLFNBQ0E7QUFBQSxFQUFDO0FBQ0w7QUFFTyxNQUFNLE1BQU0sdUJBQXVCLEtBQUs7QUFDeEMsTUFBTSxPQUFPLHVCQUF1QixNQUFNO0FBQzFDLE1BQU0sTUFBTSx1QkFBdUIsS0FBSztBQUN4QyxNQUFNLFFBQVEsdUJBQXVCLE9BQU87QUFDNUMsTUFBTSxTQUFTLHVCQUF1QixRQUFRO0FBQzlDLE1BQU0sT0FBTyx1QkFBdUIsTUFBTTtBQUMxQyxNQUFNLFVBQVUsdUJBQXVCLFNBQVM7QUFFdkQsU0FBUyx1QkFBdUIsWUFBWTtBQUN4QyxTQUFPLFNBQVUsTUFBYyxvQkFBbUQsQ0FBQyxLQUFLLEdBQUcsb0JBQW1ELENBQUMsa0JBQWtCLEdBQVE7QUFDckssV0FBTyxTQUFVLFFBQVEsYUFBYSxZQUFZO0FBQzlDLFlBQU0sVUFBVSxhQUFhLFdBQVcsUUFBUTtBQUNoRCxhQUFPLFNBQVMsSUFBSSxFQUFFLFVBQVUsRUFBRSxDQUFDLEtBQUssS0FBSyxRQUFRO0FBQ2pELHNCQUFjLEtBQUssS0FBSyxLQUFLLE9BQU87QUFBQSxNQUN4QyxDQUFDLEVBQUUsU0FBUyxpQkFBaUIsRUFBRSxTQUFTLGlCQUFpQjtBQUFBLElBQzdEO0FBQUEsRUFDSjtBQUNKO0FBRUEsU0FBUyxjQUFjLEtBQUssS0FBSyxLQUFLLFNBQVM7QUFDM0MsUUFBTSxPQUFPLElBQUksS0FBSztBQUN0QixRQUFNLG9CQUFvQixRQUFRLE1BQU0sWUFBWSxDQUFDLEdBQUcsQ0FBQyxNQUFNLEtBQUssS0FBSyxHQUFHLENBQUM7QUFDN0UsTUFBSSxtQkFBbUI7QUFDbkIsUUFBSSxLQUFLLGlCQUFpQjtBQUFBLEVBQzlCO0FBQ0o7IiwKICAibmFtZXMiOiBbXQp9Cg==

package/dist/esm/http/errors/ForbiddenError.mjs

@@ -0,0 +1,22 @@
+class ForbiddenError extends Error {
+  /**
+   * Creates an instance of ForbiddenError.
+   *
+   * @param message The error message. Defaults to "You don't have permission to access this resource".
+   */
+  constructor(message = "You don't have permission to access this resource") {
+    super(message);
+    /**
+     * The name of the error, set to "ForbiddenError".
+     */
+    this.name = "ForbiddenError";
+    /**
+     * Captures the stack trace when the error is instantiated.
+     */
+    this.stack = new Error().stack;
+  }
+}
+export {
+  ForbiddenError
+};
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vLi4vc3JjL2h0dHAvZXJyb3JzL0ZvcmJpZGRlbkVycm9yLnRzIl0sCiAgInNvdXJjZXNDb250ZW50IjogWyIvKipcbiAqIEN1c3RvbSBlcnJvciBjbGFzcyByZXByZXNlbnRpbmcgYSA0MDMgRm9yYmlkZGVuIHN0YXR1cywgaW5kaWNhdGluZ1xuICogdGhhdCB0aGUgdXNlciBkb2VzIG5vdCBoYXZlIHBlcm1pc3Npb24gdG8gYWNjZXNzIHRoZSByZXF1ZXN0ZWQgcmVzb3VyY2UuXG4gKi9cbmV4cG9ydCBjbGFzcyBGb3JiaWRkZW5FcnJvciBleHRlbmRzIEVycm9yIHtcbiAgICAvKipcbiAgICAgKiBUaGUgbmFtZSBvZiB0aGUgZXJyb3IsIHNldCB0byBcIkZvcmJpZGRlbkVycm9yXCIuXG4gICAgICovXG4gICAgcmVhZG9ubHkgbmFtZSA9IFwiRm9yYmlkZGVuRXJyb3JcIjtcbiAgICAvKipcbiAgICAgKiBDYXB0dXJlcyB0aGUgc3RhY2sgdHJhY2Ugd2hlbiB0aGUgZXJyb3IgaXMgaW5zdGFudGlhdGVkLlxuICAgICAqL1xuICAgIHJlYWRvbmx5IHN0YWNrID0gKG5ldyBFcnJvcigpKS5zdGFjaztcblxuICAgIC8qKlxuICAgICAqIENyZWF0ZXMgYW4gaW5zdGFuY2Ugb2YgRm9yYmlkZGVuRXJyb3IuXG4gICAgICpcbiAgICAgKiBAcGFyYW0gbWVzc2FnZSBUaGUgZXJyb3IgbWVzc2FnZS4gRGVmYXVsdHMgdG8gXCJZb3UgZG9uJ3QgaGF2ZSBwZXJtaXNzaW9uIHRvIGFjY2VzcyB0aGlzIHJlc291cmNlXCIuXG4gICAgICovXG4gICAgY29uc3RydWN0b3IobWVzc2FnZTogc3RyaW5nID0gXCJZb3UgZG9uJ3QgaGF2ZSBwZXJtaXNzaW9uIHRvIGFjY2VzcyB0aGlzIHJlc291cmNlXCIpIHtcbiAgICAgICAgc3VwZXIobWVzc2FnZSk7XG4gICAgfVxufSJdLAogICJtYXBwaW5ncyI6ICJBQUlPLE1BQU0sdUJBQXVCLE1BQU07QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUEsRUFldEMsWUFBWSxVQUFrQixxREFBcUQ7QUFDL0UsVUFBTSxPQUFPO0FBWmpCO0FBQUE7QUFBQTtBQUFBLFNBQVMsT0FBTztBQUloQjtBQUFBO0FBQUE7QUFBQSxTQUFTLFFBQVMsSUFBSSxNQUFNLEVBQUc7QUFBQSxFQVMvQjtBQUNKOyIsCiAgIm5hbWVzIjogW10KfQo=

package/dist/esm/http/errors/ValidationError.mjs

@@ -0,0 +1,22 @@
+class ValidationError extends Error {
+  /**
+   * Creates an instance of ValidationError.
+   *
+   * @param message The detailed message describing the validation failure.
+   */
+  constructor(message) {
+    super(message);
+    /**
+     * The name of the error, set to "ValidationError".
+     */
+    this.name = "ValidationError";
+    /**
+     * Captures the stack trace when the error is instantiated.
+     */
+    this.stack = new Error().stack;
+  }
+}
+export {
+  ValidationError
+};
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vLi4vc3JjL2h0dHAvZXJyb3JzL1ZhbGlkYXRpb25FcnJvci50cyJdLAogICJzb3VyY2VzQ29udGVudCI6IFsiLyoqXG4gKiBDdXN0b20gZXJyb3IgY2xhc3MgdXNlZCBmb3IgcmVwcmVzZW50aW5nIGZhaWx1cmVzIGR1ZSB0byBpbnZhbGlkIGlucHV0XG4gKiBvciBkYXRhIHRoYXQgdmlvbGF0ZXMgZG9tYWluLXNwZWNpZmljIHZhbGlkYXRpb24gcnVsZXMuXG4gKi9cbmV4cG9ydCBjbGFzcyBWYWxpZGF0aW9uRXJyb3IgZXh0ZW5kcyBFcnJvciB7XG4gICAgLyoqXG4gICAgICogVGhlIG5hbWUgb2YgdGhlIGVycm9yLCBzZXQgdG8gXCJWYWxpZGF0aW9uRXJyb3JcIi5cbiAgICAgKi9cbiAgICByZWFkb25seSBuYW1lID0gXCJWYWxpZGF0aW9uRXJyb3JcIjtcbiAgICAvKipcbiAgICAgKiBDYXB0dXJlcyB0aGUgc3RhY2sgdHJhY2Ugd2hlbiB0aGUgZXJyb3IgaXMgaW5zdGFudGlhdGVkLlxuICAgICAqL1xuICAgIHJlYWRvbmx5IHN0YWNrID0gKG5ldyBFcnJvcigpKS5zdGFjaztcblxuICAgIC8qKlxuICAgICAqIENyZWF0ZXMgYW4gaW5zdGFuY2Ugb2YgVmFsaWRhdGlvbkVycm9yLlxuICAgICAqXG4gICAgICogQHBhcmFtIG1lc3NhZ2UgVGhlIGRldGFpbGVkIG1lc3NhZ2UgZGVzY3JpYmluZyB0aGUgdmFsaWRhdGlvbiBmYWlsdXJlLlxuICAgICAqL1xuICAgIGNvbnN0cnVjdG9yKG1lc3NhZ2U6IHN0cmluZykge1xuICAgICAgICBzdXBlcihtZXNzYWdlKTtcbiAgICB9XG59Il0sCiAgIm1hcHBpbmdzIjogIkFBSU8sTUFBTSx3QkFBd0IsTUFBTTtBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQSxFQWV2QyxZQUFZLFNBQWlCO0FBQ3pCLFVBQU0sT0FBTztBQVpqQjtBQUFBO0FBQUE7QUFBQSxTQUFTLE9BQU87QUFJaEI7QUFBQTtBQUFBO0FBQUEsU0FBUyxRQUFTLElBQUksTUFBTSxFQUFHO0FBQUEsRUFTL0I7QUFDSjsiLAogICJuYW1lcyI6IFtdCn0K

package/dist/esm/http/errors.mjs

@@ -0,0 +1,7 @@
+import { ForbiddenError } from "./errors/ForbiddenError";
+import { ValidationError } from "./errors/ValidationError";
+export {
+  ForbiddenError,
+  ValidationError
+};
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vc3JjL2h0dHAvZXJyb3JzLnRzIl0sCiAgInNvdXJjZXNDb250ZW50IjogWyJleHBvcnQgeyBGb3JiaWRkZW5FcnJvciB9IGZyb20gXCIuL2Vycm9ycy9Gb3JiaWRkZW5FcnJvclwiO1xuZXhwb3J0IHsgVmFsaWRhdGlvbkVycm9yIH0gZnJvbSBcIi4vZXJyb3JzL1ZhbGlkYXRpb25FcnJvclwiOyJdLAogICJtYXBwaW5ncyI6ICJBQUFBLFNBQVMsc0JBQXNCO0FBQy9CLFNBQVMsdUJBQXVCOyIsCiAgIm5hbWVzIjogW10KfQo=

package/dist/esm/http/index.mjs

@@ -0,0 +1,29 @@
+import * as asyncClient from "./client-async";
+export * from "./client";
+import { HttpClient } from "./client";
+import * as decorators from "./decorators";
+export * from "./decorators";
+export * from "./request";
+import { Request } from "./request";
+export * from "./response";
+import { Response } from "./response";
+import * as rs from "./rs";
+export * from "./session";
+import { Session } from "./session";
+export * from "./upload";
+import { Upload } from "./upload";
+import * as errors from "./errors";
+import { HttpUtils } from "./utils";
+export {
+  asyncClient,
+  HttpClient as client,
+  decorators,
+  errors,
+  Request as request,
+  Response as response,
+  rs,
+  Session as session,
+  Upload as upload,
+  HttpUtils as utils
+};
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vc3JjL2h0dHAvaW5kZXgudHMiXSwKICAic291cmNlc0NvbnRlbnQiOiBbImV4cG9ydCAqIGFzIGFzeW5jQ2xpZW50IGZyb20gXCIuL2NsaWVudC1hc3luY1wiO1xuZXhwb3J0ICogZnJvbSBcIi4vY2xpZW50XCI7XG5leHBvcnQgeyBIdHRwQ2xpZW50IGFzIGNsaWVudCB9IGZyb20gXCIuL2NsaWVudFwiO1xuZXhwb3J0ICogYXMgZGVjb3JhdG9ycyBmcm9tIFwiLi9kZWNvcmF0b3JzXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9kZWNvcmF0b3JzXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9yZXF1ZXN0XCI7XG5leHBvcnQgeyBSZXF1ZXN0IGFzIHJlcXVlc3QgfSBmcm9tIFwiLi9yZXF1ZXN0XCI7XG5leHBvcnQgKiBmcm9tIFwiLi9yZXNwb25zZVwiO1xuZXhwb3J0IHsgUmVzcG9uc2UgYXMgcmVzcG9uc2UgfSBmcm9tIFwiLi9yZXNwb25zZVwiO1xuZXhwb3J0ICogYXMgcnMgZnJvbSBcIi4vcnNcIjtcbmV4cG9ydCAqIGZyb20gXCIuL3Nlc3Npb25cIjtcbmV4cG9ydCB7IFNlc3Npb24gYXMgc2Vzc2lvbiB9IGZyb20gXCIuL3Nlc3Npb25cIjtcbmV4cG9ydCAqIGZyb20gXCIuL3VwbG9hZFwiO1xuZXhwb3J0IHsgVXBsb2FkIGFzIHVwbG9hZCB9IGZyb20gXCIuL3VwbG9hZFwiO1xuZXhwb3J0ICogYXMgZXJyb3JzIGZyb20gXCIuL2Vycm9yc1wiO1xuZXhwb3J0IHsgSHR0cFV0aWxzIGFzIHV0aWxzIH0gZnJvbSBcIi4vdXRpbHNcIjtcbiJdLAogICJtYXBwaW5ncyI6ICJBQUFBLFlBQVksaUJBQWlCO0FBQzdCLGNBQWM7QUFDZCxTQUF1QixrQkFBYztBQUNyQyxZQUFZLGdCQUFnQjtBQUM1QixjQUFjO0FBQ2QsY0FBYztBQUNkLFNBQW9CLGVBQWU7QUFDbkMsY0FBYztBQUNkLFNBQXFCLGdCQUFnQjtBQUNyQyxZQUFZLFFBQVE7QUFDcEIsY0FBYztBQUNkLFNBQW9CLGVBQWU7QUFDbkMsY0FBYztBQUNkLFNBQW1CLGNBQWM7QUFDakMsWUFBWSxZQUFZO0FBQ3hCLFNBQXNCLGlCQUFhOyIsCiAgIm5hbWVzIjogW10KfQo=

package/dist/esm/http/request.mjs

@@ -0,0 +1,262 @@
+import { Streams } from "@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 Streams.createInputStream(HttpRequestFacade.getInputStream());
+  }
+}
+if (typeof module !== "undefined") {
+  module.exports = Request;
+}
+export {
+  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": []
}
