@aerokit/sdk 12.44.0

package/dist/esm/http/response.mjs

@@ -0,0 +1,433 @@
+import { OutputStream } from "@aerokit/sdk/io/streams";
+const HttpResponseFacade = Java.type("org.eclipse.dirigible.components.api.http.HttpResponseFacade");
+const OutputStreamWriter = Java.type("java.io.OutputStreamWriter");
+const StandardCharsets = Java.type("java.nio.charset.StandardCharsets");
+class Response {
+  static {
+    // --- Standard HTTP Status Code Constants (Informational, Success, Redirection, Client Error, Server Error) ---
+    this.ACCEPTED = 202;
+  }
+  static {
+    this.BAD_GATEWAY = 502;
+  }
+  static {
+    this.BAD_REQUEST = 400;
+  }
+  static {
+    this.CONFLICT = 409;
+  }
+  static {
+    this.CONTINUE = 100;
+  }
+  static {
+    this.CREATED = 201;
+  }
+  static {
+    this.EXPECTATION_FAILED = 417;
+  }
+  static {
+    this.FORBIDDEN = 403;
+  }
+  static {
+    this.FOUND = 302;
+  }
+  static {
+    this.GATEWAY_TIMEOUT = 504;
+  }
+  static {
+    this.GONE = 410;
+  }
+  static {
+    this.HTTP_VERSION_NOT_SUPPORTED = 505;
+  }
+  static {
+    this.INTERNAL_SERVER_ERROR = 500;
+  }
+  static {
+    this.LENGTH_REQUIRED = 411;
+  }
+  static {
+    this.METHOD_NOT_ALLOWED = 405;
+  }
+  static {
+    this.MOVED_PERMANENTLY = 301;
+  }
+  static {
+    this.MOVED_TEMPORARILY = 302;
+  }
+  static {
+    this.MULTIPLE_CHOICES = 300;
+  }
+  static {
+    this.NO_CONTENT = 204;
+  }
+  static {
+    this.NON_AUTHORITATIVE_INFORMATION = 203;
+  }
+  static {
+    this.NOT_ACCEPTABLE = 406;
+  }
+  static {
+    this.NOT_FOUND = 404;
+  }
+  static {
+    this.NOT_IMPLEMENTED = 501;
+  }
+  static {
+    this.NOT_MODIFIED = 304;
+  }
+  static {
+    this.OK = 200;
+  }
+  static {
+    this.PARTIAL_CONTENT = 206;
+  }
+  static {
+    this.PAYMENT_REQUIRED = 402;
+  }
+  static {
+    this.PRECONDITION_FAILED = 412;
+  }
+  static {
+    this.PROXY_AUTHENTICATION_REQUIRED = 407;
+  }
+  static {
+    this.REQUEST_ENTITY_TOO_LARGE = 413;
+  }
+  static {
+    this.REQUEST_TIMEOUT = 408;
+  }
+  static {
+    this.REQUEST_URI_TOO_LONG = 414;
+  }
+  static {
+    this.REQUESTED_RANGE_NOT_SATISFIABLE = 416;
+  }
+  static {
+    this.RESET_CONTENT = 205;
+  }
+  static {
+    this.SEE_OTHER = 303;
+  }
+  static {
+    this.SERVICE_UNAVAILABLE = 503;
+  }
+  static {
+    this.SWITCHING_PROTOCOLS = 101;
+  }
+  static {
+    this.TEMPORARY_REDIRECT = 307;
+  }
+  static {
+    this.UNAUTHORIZED = 401;
+  }
+  static {
+    this.UNSUPPORTED_MEDIA_TYPE = 415;
+  }
+  static {
+    this.USE_PROXY = 305;
+  }
+  static {
+    this.UNPROCESSABLE_CONTENT = 422;
+  }
+  static {
+    /**
+     * Mapping between HTTP response codes (string) and their corresponding reason-phrases
+     * as defined in RFC 7231, section 6.1.
+     */
+    this.HttpCodesReasons = {
+      "100": "Continue",
+      "101": "Switching Protocols",
+      "200": "OK",
+      "201": "Created",
+      "202": "Accepted",
+      "203": "Non-Authoritative Information",
+      "204": "No Content",
+      "205": "Reset Content",
+      "206": "Partial Content",
+      "300": "Multiple Choices",
+      "301": "Moved Permanently",
+      "302": "Found",
+      "303": "See Other",
+      "304": "Not Modified",
+      "305": "Use Proxy",
+      "307": "Temporary Redirect",
+      "400": "Bad Request",
+      "401": "Unauthorized",
+      "402": "Payment Required",
+      "403": "Forbidden",
+      "404": "Not Found",
+      "405": "Method Not Allowed",
+      "406": "Not Acceptable",
+      "407": "Proxy Authentication Required",
+      "408": "Request Timeout",
+      "409": "Conflict",
+      "410": "Gone",
+      "411": "Length Required",
+      "412": "Precondition Failed",
+      "413": "Payload Too Large",
+      "414": "URI Too Large",
+      "415": "Unsupported Media Type",
+      "416": "Range Not Satisfiable",
+      "417": "Expectation Failed",
+      "422": "Unprocessable Content",
+      "426": "Upgrade Required",
+      "500": "Internal Server Error",
+      "501": "Not Implemented",
+      "502": "Bad Gateway",
+      "503": "Service Unavailable",
+      "504": "Gateway Timmeout",
+      "505": "HTTP Version Not Supported",
+      /**
+      * Utility method that accepts an HTTP code and returns its corresponding reason-phrase.
+      * @param code The HTTP status code (number).
+      * @returns The reason phrase string.
+      * @throws Error if the code is not a valid integer in the range [100-505].
+      */
+      getReason: (code) => {
+        if (isNaN(code) || code < 100 || code > 505) {
+          throw Error("Illegal argument for code[" + code + "]. Valid HTTP codes are integer numbers in the range [100-505].");
+        }
+        return Response.HttpCodesReasons[String(code)];
+      }
+    };
+  }
+  /**
+   * Checks if the response façade is currently valid or connected to an active request context.
+   * @returns True if valid, false otherwise.
+   */
+  static isValid() {
+    return HttpResponseFacade.isValid();
+  }
+  /**
+   * Serializes a JavaScript object to JSON, sets the `Content-Type: application/json` header,
+   * and writes the JSON string to the response output stream.
+   * @param obj The JavaScript object to be serialized and sent.
+   */
+  static json(obj) {
+    Response.addHeader("Content-Type", "application/json");
+    const objJson = JSON.stringify(obj);
+    Response.print(objJson);
+  }
+  /**
+   * Writes a string of text to the response body using **UTF-8** encoding.
+   * Note: This method automatically handles flushing the output stream.
+   * @param text The string content to write.
+   */
+  static print(text) {
+    text = text && text.toString() || "";
+    const out = Response.getOutputStream().native;
+    const writer = new OutputStreamWriter(out, StandardCharsets.UTF_8);
+    writer.write(text);
+    writer.flush();
+  }
+  /**
+   * Writes a string of text followed by a newline character (`\n`) to the response body
+   * using **UTF-8** encoding.
+   * @param text The string content to write.
+   */
+  static println(text) {
+    text = text && text.toString() || "";
+    const out = Response.getOutputStream().native;
+    const writer = new OutputStreamWriter(out, StandardCharsets.UTF_8);
+    writer.write(text);
+    writer.write("\n");
+    writer.flush();
+  }
+  /**
+   * Writes an array of bytes directly to the response output stream, typically used for binary data.
+   * @param bytes The array of bytes to write.
+   */
+  static write(bytes) {
+    if (!bytes) {
+      bytes = [];
+    }
+    HttpResponseFacade.write(bytes);
+  }
+  /**
+   * Checks if the response headers and status have already been sent to the client.
+   * @returns True if the response is committed, false otherwise.
+   */
+  static isCommitted() {
+    return HttpResponseFacade.isCommitted();
+  }
+  /**
+   * Sets the value of the `Content-Type` header.
+   * @param contentType The MIME type string (e.g., 'text/html', 'application/pdf').
+   */
+  static setContentType(contentType) {
+    HttpResponseFacade.setContentType(contentType);
+  }
+  /**
+   * Forces any buffered output to be written to the client.
+   */
+  static flush() {
+    HttpResponseFacade.flush();
+  }
+  /**
+   * Closes the response output stream.
+   */
+  static close() {
+    HttpResponseFacade.close();
+  }
+  /**
+   * Adds a cookie to the response. The cookie object is serialized to JSON before being passed
+   * to the underlying Java facade.
+   * @param cookie The cookie definition object.
+   */
+  static addCookie(cookie) {
+    HttpResponseFacade.addCookie(JSON.stringify(cookie));
+  }
+  /**
+   * Checks if a response header with the specified name has already been set.
+   * @param name The name of the header.
+   * @returns True if the header exists, false otherwise.
+   */
+  static containsHeader(name) {
+    return HttpResponseFacade.containsHeader(name);
+  }
+  /**
+   * Encodes a URL for use in redirects or forms, including session information if necessary.
+   * @param url The URL to encode.
+   * @returns The encoded URL string.
+   */
+  static encodeURL(url) {
+    return HttpResponseFacade.encodeURL(url);
+  }
+  /**
+   * Gets the character encoding used for the response body.
+   * @returns The character encoding string.
+   */
+  static getCharacterEncoding() {
+    return HttpResponseFacade.getCharacterEncoding();
+  }
+  /**
+   * Encodes a URL for use in the `Location` header of a redirect response.
+   * @param url The redirect URL to encode.
+   * @returns The encoded redirect URL string.
+   */
+  static encodeRedirectURL(url) {
+    return HttpResponseFacade.encodeRedirectURL(url);
+  }
+  /**
+   * Gets the current `Content-Type` header value.
+   * @returns The content type string.
+   */
+  static getContentType() {
+    return HttpResponseFacade.getContentType();
+  }
+  /**
+   * Sends an HTTP error response to the client with the specified status code and optional message.
+   * This bypasses the normal response body writing process.
+   * @param status The HTTP status code (e.g., 404, 500).
+   * @param message An optional message to include in the error response.
+   */
+  static sendError(status, message) {
+    HttpResponseFacade.sendError(status, message);
+  }
+  /**
+   * Sets the character encoding to be used for the response body (e.g., 'UTF-8').
+   * @param charset The character set string.
+   */
+  static setCharacterEncoding(charset) {
+    HttpResponseFacade.setCharacterEncoding(charset);
+  }
+  /**
+   * Sends a redirect response (status code 302 by default) to the client.
+   * @param location The new URL to redirect the client to.
+   */
+  static sendRedirect(location) {
+    HttpResponseFacade.sendRedirect(location);
+  }
+  /**
+   * Sets the `Content-Length` header for the response.
+   * @param length The size of the response body in bytes.
+   */
+  static setContentLength(length) {
+    HttpResponseFacade.setContentLength(length);
+  }
+  /**
+   * Sets a response header with the given name and value. If the header already exists, its value is overwritten.
+   * @param name The name of the header.
+   * @param value The value of the header.
+   */
+  static setHeader(name, value) {
+    HttpResponseFacade.setHeader(name, value);
+  }
+  /**
+   * Adds a response header with the given name and value. If the header already exists, a second header with the same name is added.
+   * @param name The name of the header.
+   * @param value The value of the header.
+   */
+  static addHeader(name, value) {
+    HttpResponseFacade.addHeader(name, value);
+  }
+  /**
+   * Sets the HTTP status code for the response.
+   * @param status The integer status code (e.g., 200, 404).
+   */
+  static setStatus(status) {
+    HttpResponseFacade.setStatus(status);
+  }
+  /**
+   * Clears all buffers, status code, and headers from the response, allowing a new response to be generated.
+   * This is only possible if the response has not yet been committed.
+   */
+  static reset() {
+    HttpResponseFacade.reset();
+  }
+  /**
+   * Gets the value of a specific header. If multiple headers with the same name exist, it returns the first one.
+   * @param name The name of the header.
+   * @returns The header value string.
+   */
+  static getHeader(name) {
+    return HttpResponseFacade.getHeader(name);
+  }
+  /**
+   * Sets the locale for the response, which may affect language and date/time formatting.
+   * @param language The language code (e.g., 'en', 'fr').
+   * @param country The optional country code (e.g., 'US', 'GB').
+   * @param variant The optional variant code.
+   */
+  static setLocale(language, country, variant) {
+    return HttpResponseFacade.setLocale(language, country, variant);
+  }
+  /**
+   * Gets all header values for a specific header name as an array of strings.
+   * @param name The name of the header.
+   * @returns An array of header values.
+   */
+  static getHeaders(name) {
+    return JSON.parse(HttpResponseFacade.getHeaders(name));
+  }
+  /**
+   * Gets the names of all headers that have been set on the response.
+   * @returns An array of header names.
+   */
+  static getHeaderNames() {
+    return JSON.parse(HttpResponseFacade.getHeaderNames());
+  }
+  /**
+   * Gets the currently set locale string for the response.
+   * @returns The locale string.
+   */
+  static getLocale() {
+    return HttpResponseFacade.getLocale();
+  }
+  /**
+   * Gets the underlying output stream object, wrapped in the SDK's `OutputStream` class.
+   * This is useful for writing raw or large amounts of data.
+   * @returns The output stream object.
+   */
+  static getOutputStream() {
+    return new OutputStream(HttpResponseFacade.getOutputStream());
+  }
+}
+if (typeof module !== "undefined") {
+  module.exports = Response;
+}
+export {
+  Response
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/http/response.ts"],
  "sourcesContent": ["/**\n * Provides a static fa\u00E7ade (`Response` class) for managing the HTTP response.\n * This class wraps a native Java HTTP response object, offering methods for setting\n * status codes, headers, cookies, and writing content (text, JSON, or binary).\n */\n\nimport { OutputStream } from \"@aerokit/sdk/io/streams\"\n\nconst HttpResponseFacade = Java.type(\"org.eclipse.dirigible.components.api.http.HttpResponseFacade\");\nconst OutputStreamWriter = Java.type(\"java.io.OutputStreamWriter\");\nconst StandardCharsets = Java.type(\"java.nio.charset.StandardCharsets\");\n\n/**\n * Defines the structure for an HTTP cookie, including its name, value, and optional attributes.\n */\nexport interface Cookie {\n    /** The name of the cookie. */\n    name: string;\n    /** The value of the cookie. */\n    value: string;\n    /** Key-value map of cookie attributes (e.g., 'maxAge', 'path', 'domain', 'secure', 'httpOnly'). */\n    attributes: { [key: string]: string };\n }\n\n/**\n * The static Response class providing standardized HTTP status codes and methods\n * for constructing the server's response.\n */\nexport class Response {\n\n    // --- Standard HTTP Status Code Constants (Informational, Success, Redirection, Client Error, Server Error) ---\n\n    public static readonly ACCEPTED = 202;\n    public static readonly BAD_GATEWAY = 502;\n    public static readonly BAD_REQUEST = 400;\n    public static readonly CONFLICT = 409;\n    public static readonly CONTINUE = 100;\n    public static readonly CREATED = 201;\n    public static readonly EXPECTATION_FAILED = 417;\n    public static readonly FORBIDDEN = 403;\n    public static readonly FOUND = 302;\n    public static readonly GATEWAY_TIMEOUT = 504;\n    public static readonly GONE = 410;\n    public static readonly HTTP_VERSION_NOT_SUPPORTED = 505;\n    public static readonly INTERNAL_SERVER_ERROR = 500;\n    public static readonly LENGTH_REQUIRED = 411;\n    public static readonly METHOD_NOT_ALLOWED = 405;\n    public static readonly MOVED_PERMANENTLY = 301;\n    public static readonly MOVED_TEMPORARILY = 302;\n    public static readonly MULTIPLE_CHOICES = 300;\n    public static readonly NO_CONTENT = 204;\n    public static readonly NON_AUTHORITATIVE_INFORMATION = 203;\n    public static readonly NOT_ACCEPTABLE = 406;\n    public static readonly NOT_FOUND = 404;\n    public static readonly NOT_IMPLEMENTED = 501;\n    public static readonly NOT_MODIFIED = 304;\n    public static readonly OK = 200;\n    public static readonly PARTIAL_CONTENT = 206;\n    public static readonly PAYMENT_REQUIRED = 402;\n    public static readonly PRECONDITION_FAILED = 412;\n    public static readonly PROXY_AUTHENTICATION_REQUIRED = 407;\n    public static readonly REQUEST_ENTITY_TOO_LARGE = 413;\n    public static readonly REQUEST_TIMEOUT = 408;\n    public static readonly REQUEST_URI_TOO_LONG = 414;\n    public static readonly REQUESTED_RANGE_NOT_SATISFIABLE = 416;\n    public static readonly RESET_CONTENT = 205;\n    public static readonly SEE_OTHER = 303;\n    public static readonly SERVICE_UNAVAILABLE = 503;\n    public static readonly SWITCHING_PROTOCOLS = 101;\n    public static readonly TEMPORARY_REDIRECT = 307;\n    public static readonly UNAUTHORIZED = 401;\n    public static readonly UNSUPPORTED_MEDIA_TYPE = 415;\n    public static readonly USE_PROXY = 305;\n    public static readonly UNPROCESSABLE_CONTENT = 422;\n\n    /**\n     * Mapping between HTTP response codes (string) and their corresponding reason-phrases\n     * as defined in RFC 7231, section 6.1.\n     */\n    public static readonly HttpCodesReasons = {\n        \"100\": \"Continue\", \"101\": \"Switching Protocols\", \"200\": \"OK\", \"201\": \"Created\",\n        \"202\": \"Accepted\", \"203\": \"Non-Authoritative Information\", \"204\": \"No Content\",\n        \"205\": \"Reset Content\", \"206\": \"Partial Content\", \"300\": \"Multiple Choices\",\n        \"301\": \"Moved Permanently\", \"302\": \"Found\", \"303\": \"See Other\", \"304\": \"Not Modified\",\n        \"305\": \"Use Proxy\", \"307\": \"Temporary Redirect\", \"400\": \"Bad Request\",\n        \"401\": \"Unauthorized\", \"402\": \"Payment Required\", \"403\": \"Forbidden\",\n        \"404\": \"Not Found\", \"405\": \"Method Not Allowed\", \"406\": \"Not Acceptable\",\n        \"407\": \"Proxy Authentication Required\", \"408\": \"Request Timeout\", \"409\": \"Conflict\",\n        \"410\": \"Gone\", \"411\": \"Length Required\", \"412\": \"Precondition Failed\",\n        \"413\": \"Payload Too Large\", \"414\": \"URI Too Large\", \"415\": \"Unsupported Media Type\",\n        \"416\": \"Range Not Satisfiable\", \"417\": \"Expectation Failed\", \"422\": \"Unprocessable Content\",\n        \"426\": \"Upgrade Required\", \"500\": \"Internal Server Error\", \"501\": \"Not Implemented\",\n        \"502\": \"Bad Gateway\", \"503\": \"Service Unavailable\", \"504\": \"Gateway Timmeout\",\n        \"505\": \"HTTP Version Not Supported\",\n\n        /**\n        * Utility method that accepts an HTTP code and returns its corresponding reason-phrase.\n        * @param code The HTTP status code (number).\n        * @returns The reason phrase string.\n        * @throws Error if the code is not a valid integer in the range [100-505].\n        */\n        getReason: (code: number): string => {\n            if (isNaN(code) || code < 100 || code > 505) {\n                throw Error('Illegal argument for code[' + code + ']. Valid HTTP codes are integer numbers in the range [100-505].')\n            }\n            return Response.HttpCodesReasons[String(code)];\n        }\n    }\n\n    /**\n     * Checks if the response fa\u00E7ade is currently valid or connected to an active request context.\n     * @returns True if valid, false otherwise.\n     */\n    public static isValid(): boolean {\n        return HttpResponseFacade.isValid();\n    }\n\n    /**\n     * Serializes a JavaScript object to JSON, sets the `Content-Type: application/json` header,\n     * and writes the JSON string to the response output stream.\n     * @param obj The JavaScript object to be serialized and sent.\n     */\n    public static json(obj: any): void {\n        Response.addHeader(\"Content-Type\", \"application/json\")\n        const objJson = JSON.stringify(obj);\n        Response.print(objJson);\n    }\n\n    /**\n     * Writes a string of text to the response body using **UTF-8** encoding.\n     * Note: This method automatically handles flushing the output stream.\n     * @param text The string content to write.\n     */\n    public static print(text: string): void {\n        text = (text && text.toString()) || \"\";\n        const out = Response.getOutputStream().native;\n        // Use Java I/O to ensure explicit UTF-8 encoding\n        const writer = new OutputStreamWriter(out, StandardCharsets.UTF_8);\n        writer.write(text);\n        writer.flush();\n    }\n\n    /**\n     * Writes a string of text followed by a newline character (`\\n`) to the response body\n     * using **UTF-8** encoding.\n     * @param text The string content to write.\n     */\n    public static println(text: string): void {\n        text = (text && text.toString()) || \"\";\n        const out = Response.getOutputStream().native;\n        const writer = new OutputStreamWriter(out, StandardCharsets.UTF_8);\n        writer.write(text);\n        writer.write(\"\\n\");\n        writer.flush();\n    }\n\n    /**\n     * Writes an array of bytes directly to the response output stream, typically used for binary data.\n     * @param bytes The array of bytes to write.\n     */\n    public static write(bytes: any[]): void {\n        if (!bytes) {\n            bytes = [];\n        }\n        HttpResponseFacade.write(bytes);\n    }\n\n    /**\n     * Checks if the response headers and status have already been sent to the client.\n     * @returns True if the response is committed, false otherwise.\n     */\n    public static isCommitted(): boolean {\n        return HttpResponseFacade.isCommitted();\n    }\n\n    /**\n     * Sets the value of the `Content-Type` header.\n     * @param contentType The MIME type string (e.g., 'text/html', 'application/pdf').\n     */\n    public static setContentType(contentType: string): void {\n        HttpResponseFacade.setContentType(contentType);\n    }\n\n    /**\n     * Forces any buffered output to be written to the client.\n     */\n    public static flush(): void {\n        HttpResponseFacade.flush();\n    }\n\n    /**\n     * Closes the response output stream.\n     */\n    public static close(): void {\n        HttpResponseFacade.close();\n    }\n\n    /**\n     * Adds a cookie to the response. The cookie object is serialized to JSON before being passed\n     * to the underlying Java facade.\n     * @param cookie The cookie definition object.\n     */\n    public static addCookie(cookie: Cookie): void {\n        HttpResponseFacade.addCookie(JSON.stringify(cookie));\n    }\n\n    /**\n     * Checks if a response header with the specified name has already been set.\n     * @param name The name of the header.\n     * @returns True if the header exists, false otherwise.\n     */\n    public static containsHeader(name: string): boolean {\n        return HttpResponseFacade.containsHeader(name);\n    }\n\n    /**\n     * Encodes a URL for use in redirects or forms, including session information if necessary.\n     * @param url The URL to encode.\n     * @returns The encoded URL string.\n     */\n    public static encodeURL(url: string): string {\n        return HttpResponseFacade.encodeURL(url);\n    }\n\n    /**\n     * Gets the character encoding used for the response body.\n     * @returns The character encoding string.\n     */\n    public static getCharacterEncoding(): string {\n        return HttpResponseFacade.getCharacterEncoding();\n    }\n\n    /**\n     * Encodes a URL for use in the `Location` header of a redirect response.\n     * @param url The redirect URL to encode.\n     * @returns The encoded redirect URL string.\n     */\n    public static encodeRedirectURL(url: string): string {\n        return HttpResponseFacade.encodeRedirectURL(url);\n    }\n\n    /**\n     * Gets the current `Content-Type` header value.\n     * @returns The content type string.\n     */\n    public static getContentType(): string {\n        return HttpResponseFacade.getContentType();\n    }\n\n    /**\n     * Sends an HTTP error response to the client with the specified status code and optional message.\n     * This bypasses the normal response body writing process.\n     * @param status The HTTP status code (e.g., 404, 500).\n     * @param message An optional message to include in the error response.\n     */\n    public static sendError(status: number, message?: string): void {\n        HttpResponseFacade.sendError(status, message);\n    }\n\n    /**\n     * Sets the character encoding to be used for the response body (e.g., 'UTF-8').\n     * @param charset The character set string.\n     */\n    public static setCharacterEncoding(charset: string): void {\n        HttpResponseFacade.setCharacterEncoding(charset);\n    }\n\n    /**\n     * Sends a redirect response (status code 302 by default) to the client.\n     * @param location The new URL to redirect the client to.\n     */\n    public static sendRedirect(location: string): void {\n        HttpResponseFacade.sendRedirect(location);\n    }\n\n    /**\n     * Sets the `Content-Length` header for the response.\n     * @param length The size of the response body in bytes.\n     */\n    public static setContentLength(length: number): void {\n        HttpResponseFacade.setContentLength(length);\n    }\n\n    /**\n     * Sets a response header with the given name and value. If the header already exists, its value is overwritten.\n     * @param name The name of the header.\n     * @param value The value of the header.\n     */\n    public static setHeader(name: string, value: string): void {\n        HttpResponseFacade.setHeader(name, value);\n    }\n\n    /**\n     * Adds a response header with the given name and value. If the header already exists, a second header with the same name is added.\n     * @param name The name of the header.\n     * @param value The value of the header.\n     */\n    public static addHeader(name: string, value: string): void {\n        HttpResponseFacade.addHeader(name, value);\n    }\n\n    /**\n     * Sets the HTTP status code for the response.\n     * @param status The integer status code (e.g., 200, 404).\n     */\n    public static setStatus(status: number): void {\n        HttpResponseFacade.setStatus(status);\n    }\n\n    /**\n     * Clears all buffers, status code, and headers from the response, allowing a new response to be generated.\n     * This is only possible if the response has not yet been committed.\n     */\n    public static reset(): void {\n        HttpResponseFacade.reset();\n    }\n\n    /**\n     * Gets the value of a specific header. If multiple headers with the same name exist, it returns the first one.\n     * @param name The name of the header.\n     * @returns The header value string.\n     */\n    public static getHeader(name: string): string {\n        return HttpResponseFacade.getHeader(name);\n    }\n\n    /**\n     * Sets the locale for the response, which may affect language and date/time formatting.\n     * @param language The language code (e.g., 'en', 'fr').\n     * @param country The optional country code (e.g., 'US', 'GB').\n     * @param variant The optional variant code.\n     */\n    public static setLocale(language: string, country?: string, variant?: string): void {\n        return HttpResponseFacade.setLocale(language, country, variant);\n    }\n\n    /**\n     * Gets all header values for a specific header name as an array of strings.\n     * @param name The name of the header.\n     * @returns An array of header values.\n     */\n    public static getHeaders(name: string): string[] {\n        return JSON.parse(HttpResponseFacade.getHeaders(name));\n    }\n\n    /**\n     * Gets the names of all headers that have been set on the response.\n     * @returns An array of header names.\n     */\n    public static getHeaderNames(): string[] {\n        return JSON.parse(HttpResponseFacade.getHeaderNames());\n    }\n\n    /**\n     * Gets the currently set locale string for the response.\n     * @returns The locale string.\n     */\n    public static getLocale(): string {\n        return HttpResponseFacade.getLocale();\n    }\n\n    /**\n     * Gets the underlying output stream object, wrapped in the SDK's `OutputStream` class.\n     * This is useful for writing raw or large amounts of data.\n     * @returns The output stream object.\n     */\n    public static getOutputStream(): OutputStream {\n        return new OutputStream(HttpResponseFacade.getOutputStream());\n    }\n}\n\n// @ts-ignore\nif (typeof module !== 'undefined') {\n\t// @ts-ignore\n\tmodule.exports = Response;\n}\n"],
  "mappings": "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",
  "names": []
}


package/dist/esm/http/rs/resource-common.mjs

@@ -0,0 +1,13 @@
+function handlerFunction(thiz, configuration, sHandlerFuncName, fHandler) {
+  if (fHandler !== void 0) {
+    if (typeof fHandler !== "function" && typeof fHandler !== "string") {
+      throw new Error(`Invalid argument: ${sHandlerFuncName} method argument must be a valid javascript function or string, but instead is ${typeof fHandler}`);
+    }
+    configuration[sHandlerFuncName] = fHandler;
+  }
+  return thiz;
+}
+export {
+  handlerFunction
+};
+//# sourceMappingURL=data:application/json;base64,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