@aerokit/sdk 12.44.0

package/dist/cjs/http/client-async.js

@@ -0,0 +1,224 @@
+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 client_async_exports = {};
+__export(client_async_exports, {
+  HttpAsyncClient: () => HttpAsyncClient,
+  getInstance: () => getInstance
+});
+module.exports = __toCommonJS(client_async_exports);
+const HttpClientAsyncFacade = Java.type("org.eclipse.dirigible.components.api.http.HttpClientAsyncFacade");
+const SpringBeanProvider = Java.type("org.eclipse.dirigible.components.spring.SpringBeanProvider");
+const httpClient = SpringBeanProvider.getBean(HttpClientAsyncFacade.class);
+class HttpAsyncClient {
+  /**
+   * Executes an asynchronous HTTP GET request.
+   * @param url The target URL.
+   * @param config The callback configuration object.
+   * @param options Request configuration options (e.g., headers, body, params).
+   */
+  getAsync(url, config, options) {
+    const newUrl = buildUrl(url, options);
+    const callback = createHttpResponseCallback(
+      httpClient,
+      config.success,
+      config.error,
+      config.cancel
+    );
+    if (options) {
+      httpClient.getAsync(newUrl, JSON.stringify(options), callback);
+    } else {
+      httpClient.getAsync(newUrl, JSON.stringify({}), callback);
+    }
+  }
+  /**
+   * Executes an asynchronous HTTP POST request.
+   * @param url The target URL.
+   * @param config The callback configuration object.
+   * @param options Request configuration options.
+   */
+  postAsync(url, config, options) {
+    const newUrl = buildUrl(url, options);
+    const callback = createHttpResponseCallback(
+      httpClient,
+      config.success,
+      config.error,
+      config.cancel
+    );
+    if (options) {
+      httpClient.postAsync(newUrl, JSON.stringify(options), callback);
+    } else {
+      httpClient.postAsync(newUrl, JSON.stringify({}), callback);
+    }
+  }
+  /**
+   * Executes an asynchronous HTTP PUT request.
+   * @param url The target URL.
+   * @param config The callback configuration object.
+   * @param options Request configuration options.
+   */
+  putAsync(url, config, options) {
+    const newUrl = buildUrl(url, options);
+    const callback = createHttpResponseCallback(
+      httpClient,
+      config.success,
+      config.error,
+      config.cancel
+    );
+    if (options) {
+      httpClient.putAsync(newUrl, JSON.stringify(options), callback);
+    } else {
+      httpClient.putAsync(newUrl, JSON.stringify({}), callback);
+    }
+  }
+  /**
+   * Executes an asynchronous HTTP PATCH request.
+   * @param url The target URL.
+   * @param config The callback configuration object.
+   * @param options Request configuration options.
+   */
+  patchAsync(url, config, options) {
+    const newUrl = buildUrl(url, options);
+    const callback = createHttpResponseCallback(
+      httpClient,
+      config.success,
+      config.error,
+      config.cancel
+    );
+    if (options) {
+      httpClient.patchAsync(newUrl, JSON.stringify(options), callback);
+    } else {
+      httpClient.patchAsync(newUrl, JSON.stringify({}), callback);
+    }
+  }
+  /**
+   * Executes an asynchronous HTTP DELETE request.
+   * @param url The target URL.
+   * @param config The callback configuration object.
+   * @param options Request configuration options.
+   */
+  deleteAsync(url, config, options) {
+    const newUrl = buildUrl(url, options);
+    const callback = createHttpResponseCallback(
+      httpClient,
+      config.success,
+      config.error,
+      config.cancel
+    );
+    if (options) {
+      httpClient.deleteAsync(newUrl, JSON.stringify(options), callback);
+    } else {
+      httpClient.deleteAsync(newUrl, JSON.stringify({}), callback);
+    }
+  }
+  /**
+   * Executes an asynchronous HTTP HEAD request.
+   * @param url The target URL.
+   * @param config The callback configuration object.
+   * @param options Request configuration options.
+   */
+  headAsync(url, config, options) {
+    const newUrl = buildUrl(url, options);
+    const callback = createHttpResponseCallback(
+      httpClient,
+      config.success,
+      config.error,
+      config.cancel
+    );
+    if (options) {
+      httpClient.headAsync(newUrl, JSON.stringify(options), callback);
+    } else {
+      httpClient.headAsync(newUrl, JSON.stringify({}), callback);
+    }
+  }
+  /**
+   * Executes an asynchronous HTTP TRACE request.
+   * @param url The target URL.
+   * @param config The callback configuration object.
+   * @param options Request configuration options.
+   */
+  traceAsync(url, config, options) {
+    const newUrl = buildUrl(url, options);
+    const callback = createHttpResponseCallback(
+      httpClient,
+      config.success,
+      config.error,
+      config.cancel
+    );
+    if (options) {
+      httpClient.traceAsync(newUrl, JSON.stringify(options), callback);
+    } else {
+      httpClient.traceAsync(newUrl, JSON.stringify({}), callback);
+    }
+  }
+  /**
+   * Initiates the execution of queued asynchronous requests (depending on the underlying Java client's threading model).
+   */
+  execute() {
+    httpClient.execute();
+  }
+}
+function getInstance() {
+  return new HttpAsyncClient();
+}
+;
+function createHttpResponseCallback(httpClient2, successCallback, errorCallback, cancelCallback) {
+  return httpClient2.createCallback(
+    createSuccessCallback(successCallback),
+    createErrorCallback(errorCallback),
+    createCancelCallback(cancelCallback)
+  );
+}
+function createSuccessCallback(callback) {
+  return "(function(httpResponse, isBinary, context) {\nvar response = {};\nresponse.statusCode = httpResponse.getStatusLine().getStatusCode();\nresponse.statusMessage = httpResponse.getStatusLine().getReasonPhrase();\nresponse.protocol = httpResponse.getProtocolVersion();\nresponse.binary = isBinary;\nvar headers = httpResponse.getAllHeaders();\nresponse.headers = [];\nfor (var i = 0; i < headers.length; i ++) {\n    response.headers.push({\n        name: headers[i].getName(),\n        value: headers[i].getValue()\n    });\n}\nvar entity = httpResponse.getEntity();\nif (entity) {\n    var inputStream = entity.getContent();\n    if (isBinary) {\n        // Uses Java IOUtils to read binary data\n        response.data = org.apache.commons.io.IOUtils.toByteArray(inputStream);\n    } else {\n        // Uses Java IOUtils to read text data\n        response.text = org.apache.commons.io.IOUtils.toString(inputStream);\n    }\n}\n(" + callback + ")(response, JSON.parse(context));\n})(__context.get('response'), __context.get('httpClientRequestOptions').isBinary(), __context.get('httpClientRequestOptions').getContext());\n";
+}
+function createErrorCallback(callback) {
+  if (callback) {
+    return "(" + callback + ")(__context.get('exception'))";
+  }
+  return void 0;
+}
+function createCancelCallback(callback) {
+  if (callback) {
+    return "(" + callback + ")()";
+  }
+  return void 0;
+}
+function buildUrl(url, options) {
+  if (options === void 0 || options === null || options.params === void 0 || options.params === null || options.params.length === 0) {
+    return url;
+  }
+  let newUrl = url;
+  for (let i = 0; i < options.params.length; i++) {
+    const param = options.params[i];
+    if (i === 0) {
+      if (newUrl.includes("?")) {
+        newUrl += "&";
+      } else {
+        newUrl += "?";
+      }
+      newUrl += param.name + "=" + param.value;
+    } else {
+      newUrl += "&" + param.name + "=" + param.value;
+    }
+  }
+  return newUrl;
+}
+if (typeof module !== "undefined") {
+  module.exports = { HttpAsyncClient, getInstance };
+}
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/http/client-async.ts"],
  "sourcesContent": ["/**\n * Provides a JavaScript/TypeScript wrapper (Facade) for making asynchronous HTTP requests.\n *\n */\n\n// --- Shared Interfaces (for documentation clarity) ---\n\n/** Defines a single HTTP header, used for both request and response. */\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/** Defines a query parameter that will be appended to the URL. */\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/** Defines a file to be included in a multi-part form data request. */\nexport interface HttpClientFile {\n    /** The form field name for the file. */\n    name: string;\n    /** The file path or content. */\n    value: string;\n}\n\n/** Configuration options for an HTTP request, mirroring the capabilities of the underlying Java client. */\nexport interface HttpClientRequestOptions {\n    expectContinueEnabled?: boolean;\n    proxyHost?: string;\n    proxyPort?: number;\n    cookieSpec?: string;\n    redirectsEnabled?: boolean;\n    relativeRedirectsAllowed?: boolean;\n    circularRedirectsAllowed?: boolean;\n    maxRedirects?: number;\n    authenticationEnabled?: boolean;\n    targetPreferredAuthSchemes?: string[];\n    proxyPreferredAuthSchemes?: string[];\n    connectionRequestTimeout?: number;\n    connectTimeout?: number;\n    socketTimeout?: number;\n    contentCompressionEnabled?: boolean;\n    sslTrustAllEnabled?: boolean;\n    data?: any[];\n    text?: string;\n    files?: HttpClientFile[];\n    characterEncoding?: string;\n    characterEncodingEnabled?: boolean;\n    contentType?: string;\n    headers?: HttpClientHeader[];\n    params?: HttpClientParam[];\n    binary?: boolean;\n    context?: { [key: string]: any };\n}\n\n/** The structure of the response returned by the HttpClient methods. */\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// --- Asynchronous Client Interfaces ---\n\n/**\n * Defines the callback structure for asynchronous requests.\n * Note: Callbacks are provided as strings containing executable JavaScript code.\n */\nexport interface HttpClientAsyncConfig {\n    /**\n     * Mandatory success callback as a **string of JavaScript code**.\n     * It will be executed with signature: `(response: HttpClientResponse, context: { [key: string]: any }) => void`\n     */\n    success: string;\n    /**\n     * Optional error callback as a **string of JavaScript code**.\n     * It will be executed with signature: `(exception: any) => void`\n     */\n    error?: string;\n    /**\n     * Optional cancel callback as a **string of JavaScript code**.\n     * It will be executed with signature: `() => void`\n     */\n    cancel?: string;\n}\n\n\n// --- Java Type Imports (Crucial for JVM integration) ---\n\n/** Imports the native Java class responsible for asynchronous HTTP execution. */\nconst HttpClientAsyncFacade = Java.type(\"org.eclipse.dirigible.components.api.http.HttpClientAsyncFacade\");\n\n/** Imports the native Java class for retrieving Spring-managed beans. */\nconst SpringBeanProvider = Java.type(\"org.eclipse.dirigible.components.spring.SpringBeanProvider\");\n\n/** Retrieves the singleton instance of the asynchronous HTTP client from the Spring context. */\nconst httpClient = SpringBeanProvider.getBean(HttpClientAsyncFacade.class);\n\n\n/**\n * The asynchronous HTTP client class. All request methods return immediately\n * and execute callbacks upon completion.\n */\nexport class HttpAsyncClient {\n\n    /**\n     * Executes an asynchronous HTTP GET request.\n     * @param url The target URL.\n     * @param config The callback configuration object.\n     * @param options Request configuration options (e.g., headers, body, params).\n     */\n\tgetAsync(url: string, config: HttpClientAsyncConfig, options?: HttpClientRequestOptions): void {\n\t\tconst newUrl = buildUrl(url, options);\n\t\tconst callback = createHttpResponseCallback(\n\t\t\thttpClient,\n\t\t\tconfig.success,\n\t\t\tconfig.error,\n\t\t\tconfig.cancel\n\t\t);\n\t\tif (options) {\n\t\t\thttpClient.getAsync(newUrl, JSON.stringify(options), callback);\n\t\t} else {\n\t\t\thttpClient.getAsync(newUrl, JSON.stringify({}), callback);\n\t\t}\n\t};\n\n    /**\n     * Executes an asynchronous HTTP POST request.\n     * @param url The target URL.\n     * @param config The callback configuration object.\n     * @param options Request configuration options.\n     */\n\tpostAsync(url: string, config: HttpClientAsyncConfig, options?: HttpClientRequestOptions): void {\n\t\tconst newUrl = buildUrl(url, options);\n\t\tconst callback = createHttpResponseCallback(\n\t\t\thttpClient,\n\t\t\tconfig.success,\n\t\t\tconfig.error,\n\t\t\tconfig.cancel\n\t\t);\n\t\tif (options) {\n\t\t\thttpClient.postAsync(newUrl, JSON.stringify(options), callback);\n\t\t} else {\n\t\t\thttpClient.postAsync(newUrl, JSON.stringify({}), callback);\n\t\t}\n\t};\n\n    /**\n     * Executes an asynchronous HTTP PUT request.\n     * @param url The target URL.\n     * @param config The callback configuration object.\n     * @param options Request configuration options.\n     */\n\tputAsync(url: string, config: HttpClientAsyncConfig, options?: HttpClientRequestOptions): void {\n\t\tconst newUrl = buildUrl(url, options);\n\t\tconst callback = createHttpResponseCallback(\n\t\t\thttpClient,\n\t\t\tconfig.success,\n\t\t\tconfig.error,\n\t\t\tconfig.cancel\n\t\t);\n\t\tif (options) {\n\t\t\thttpClient.putAsync(newUrl, JSON.stringify(options), callback);\n\t\t} else {\n\t\t\thttpClient.putAsync(newUrl, JSON.stringify({}), callback);\n\t\t}\n\t};\n\n    /**\n     * Executes an asynchronous HTTP PATCH request.\n     * @param url The target URL.\n     * @param config The callback configuration object.\n     * @param options Request configuration options.\n     */\n\tpatchAsync(url: string, config: HttpClientAsyncConfig, options?: HttpClientRequestOptions): void {\n\t\tconst newUrl = buildUrl(url, options);\n\t\tconst callback = createHttpResponseCallback(\n\t\t\thttpClient,\n\t\t\tconfig.success,\n\t\t\tconfig.error,\n\t\t\tconfig.cancel\n\t\t);\n\t\tif (options) {\n\t\t\thttpClient.patchAsync(newUrl, JSON.stringify(options), callback);\n\t\t} else {\n\t\t\thttpClient.patchAsync(newUrl, JSON.stringify({}), callback);\n\t\t}\n\t};\n\n    /**\n     * Executes an asynchronous HTTP DELETE request.\n     * @param url The target URL.\n     * @param config The callback configuration object.\n     * @param options Request configuration options.\n     */\n\tdeleteAsync(url: string, config: HttpClientAsyncConfig, options?: HttpClientRequestOptions): void {\n\t\tconst newUrl = buildUrl(url, options);\n\t\tconst callback = createHttpResponseCallback(\n\t\t\thttpClient,\n\t\t\tconfig.success,\n\t\t\tconfig.error,\n\t\t\tconfig.cancel\n\t\t);\n\t\tif (options) {\n\t\t\thttpClient.deleteAsync(newUrl, JSON.stringify(options), callback);\n\t\t} else {\n\t\t\thttpClient.deleteAsync(newUrl, JSON.stringify({}), callback);\n\t\t}\n\t};\n\n    /**\n     * Executes an asynchronous HTTP HEAD request.\n     * @param url The target URL.\n     * @param config The callback configuration object.\n     * @param options Request configuration options.\n     */\n\theadAsync(url: string, config: HttpClientAsyncConfig, options?: HttpClientRequestOptions): void {\n\t\tconst newUrl = buildUrl(url, options);\n\t\tconst callback = createHttpResponseCallback(\n\t\t\thttpClient,\n\t\t\tconfig.success,\n\t\t\tconfig.error,\n\t\t\tconfig.cancel\n\t\t);\n\t\tif (options) {\n\t\t\thttpClient.headAsync(newUrl, JSON.stringify(options), callback);\n\t\t} else {\n\t\t\thttpClient.headAsync(newUrl, JSON.stringify({}), callback);\n\t\t}\n\t};\n\n    /**\n     * Executes an asynchronous HTTP TRACE request.\n     * @param url The target URL.\n     * @param config The callback configuration object.\n     * @param options Request configuration options.\n     */\n\ttraceAsync(url: string, config: HttpClientAsyncConfig, options?: HttpClientRequestOptions): void {\n\t\tconst newUrl = buildUrl(url, options);\n\t\tconst callback = createHttpResponseCallback(\n\t\t\thttpClient,\n\t\t\tconfig.success,\n\t\t\tconfig.error,\n\t\t\tconfig.cancel\n\t\t);\n\t\tif (options) {\n\t\t\thttpClient.traceAsync(newUrl, JSON.stringify(options), callback);\n\t\t} else {\n\t\t\thttpClient.traceAsync(newUrl, JSON.stringify({}), callback);\n\t\t}\n\t};\n\n    /**\n     * Initiates the execution of queued asynchronous requests (depending on the underlying Java client's threading model).\n     */\n\texecute(): void {\n\t\thttpClient.execute();\n\t};\n}\n\n/**\n * Factory function to retrieve a new instance of the asynchronous client.\n * @returns A new instance of HttpAsyncClient.\n */\nexport function getInstance(): HttpAsyncClient {\n\treturn new HttpAsyncClient();\n};\n\n/**\n * Creates a native Java callback object that wraps the JavaScript success, error, and cancel callbacks.\n * This function uses the underlying Java HTTP client instance to generate the final callback object.\n * @param httpClient The Java HttpClientAsyncFacade instance.\n * @param successCallback JS code string for success.\n * @param errorCallback JS code string for error.\n * @param cancelCallback JS code string for cancel.\n * @returns A Java callback object.\n */\nfunction createHttpResponseCallback(httpClient: any, successCallback: string, errorCallback?: string, cancelCallback?: string): any {\n\treturn httpClient.createCallback(\n\t\tcreateSuccessCallback(successCallback),\n\t\tcreateErrorCallback(errorCallback),\n\t\tcreateCancelCallback(cancelCallback)\n\t);\n}\n\n/**\n * Generates the raw JavaScript string that will be executed in the JVM environment upon successful request completion.\n * This string handles parsing the Java HTTP response object and executing the user's defined callback function.\n * @param callback The user-provided success callback function code string.\n * @returns The complex JavaScript string for the success handler.\n */\nfunction createSuccessCallback(callback: string): string {\n\t// Note: This string uses Java utility classes (org.apache.commons.io.IOUtils) and context variables \n    // (__context) that are available in the specific JVM environment.\n    \n    // The structure maps the Java HTTP Response object into the standard HttpClientResponse interface.\n\treturn \"(function(httpResponse, isBinary, context) {\\n\"\n\t\t+ \"var response = {};\\n\"\n\t\t+ \"response.statusCode = httpResponse.getStatusLine().getStatusCode();\\n\"\n\t\t+ \"response.statusMessage = httpResponse.getStatusLine().getReasonPhrase();\\n\"\n\t\t+ \"response.protocol = httpResponse.getProtocolVersion();\\n\"\n\t\t+ \"response.binary = isBinary;\\n\"\n\n\t\t+ \"var headers = httpResponse.getAllHeaders();\\n\"\n\t\t+ \"response.headers = [];\\n\"\n\t\t+ \"for (var i = 0; i < headers.length; i ++) {\\n\"\n\t\t+ \"    response.headers.push({\\n\"\n\t\t+ \"        name: headers[i].getName(),\\n\"\n\t\t+ \"        value: headers[i].getValue()\\n\"\n\t\t+ \"    });\\n\"\n\t\t+ \"}\\n\"\n\n\t\t+ \"var entity = httpResponse.getEntity();\\n\"\n\t\t+ \"if (entity) {\\n\"\n\t\t+ \"    var inputStream = entity.getContent();\\n\"\n\t\t+ \"    if (isBinary) {\\n\"\n\t\t+ \"        // Uses Java IOUtils to read binary data\\n\"\n\t\t+ \"        response.data = org.apache.commons.io.IOUtils.toByteArray(inputStream);\\n\"\n\t\t+ \"    } else {\\n\"\n\t\t+ \"        // Uses Java IOUtils to read text data\\n\"\n\t\t+ \"        response.text = org.apache.commons.io.IOUtils.toString(inputStream);\\n\"\n\t\t+ \"    }\\n\"\n\t\t+ \"}\\n\"\n\n\t\t+ \"(\" + callback + \")(response, JSON.parse(context));\\n\"\n\t\t+ \"})(__context.get('response'), __context.get('httpClientRequestOptions').isBinary(), __context.get('httpClientRequestOptions').getContext());\\n\";\n}\n\n/**\n * Generates the raw JavaScript string for the error callback.\n * @param callback The user-provided error callback function code string.\n * @returns The JavaScript string for the error handler, or undefined.\n */\nfunction createErrorCallback(callback?: string): string | undefined {\n\tif (callback) {\n\t\treturn \"(\" + callback + \")(__context.get('exception'))\";\n\t}\n    return undefined;\n}\n\n/**\n * Generates the raw JavaScript string for the cancel callback.\n * @param callback The user-provided cancel callback function code string.\n * @returns The JavaScript string for the cancel handler, or undefined.\n */\nfunction createCancelCallback(callback?: string): string | undefined {\n\tif (callback) {\n\t\treturn \"(\" + callback + \")()\";\n\t}\n    return undefined;\n}\n\n/**\n * Builds the final URL by appending all query parameters defined in options.params.\n * The parameters are not removed from the options object as they are for the synchronous client,\n * since the options are passed as JSON string to the facade anyway.\n * @param url The base URL.\n * @param options The request options which may contain `params`.\n * @returns The URL with appended query parameters.\n */\nfunction buildUrl(url: string, options?: HttpClientRequestOptions): string {\n\tif (options === undefined || options === null || options.params === undefined || options.params === null || options.params.length === 0) {\n\t\treturn url;\n\t}\n\tlet newUrl = url;\n\tfor (let i = 0; i < options.params.length; i ++) {\n        const param = options.params[i];\n\t\tif (i === 0) {\n            // Check if URL already contains '?' and use '&' if so (improves robustness)\n            if (newUrl.includes('?')) {\n                newUrl += '&';\n            } else {\n                newUrl += '?';\n            }\n\t\t\tnewUrl += param.name + '=' + param.value;\n\t\t} else {\n\t\t\tnewUrl += '&' + param.name + '=' + param.value;\n\t\t}\n\t}\n\treturn newUrl;\n}\n\n// @ts-ignore\nif (typeof module !== 'undefined') {\n\t// @ts-ignore\n\tmodule.exports = { HttpAsyncClient, getInstance };\n}"],
  "mappings": "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",
  "names": ["httpClient"]
}


package/dist/cjs/http/client.js

@@ -0,0 +1,145 @@
+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 client_exports = {};
+__export(client_exports, {
+  HttpClient: () => HttpClient
+});
+module.exports = __toCommonJS(client_exports);
+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;
+}
+//# 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/cjs/http/decorators.js

@@ -0,0 +1,76 @@
+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 __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 decorators_exports = {};
+__export(decorators_exports, {
+  Controller: () => Controller,
+  Delete: () => Delete,
+  Documentation: () => Documentation,
+  Get: () => Get,
+  Head: () => Head,
+  Options: () => Options,
+  Patch: () => Patch,
+  Post: () => Post,
+  Put: () => Put
+});
+module.exports = __toCommonJS(decorators_exports);
+var rs = __toESM(require("@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);
+  }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/cjs/http/errors/ForbiddenError.js

@@ -0,0 +1,41 @@
+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 ForbiddenError_exports = {};
+__export(ForbiddenError_exports, {
+  ForbiddenError: () => ForbiddenError
+});
+module.exports = __toCommonJS(ForbiddenError_exports);
+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;
+  }
+}
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vLi4vc3JjL2h0dHAvZXJyb3JzL0ZvcmJpZGRlbkVycm9yLnRzIl0sCiAgInNvdXJjZXNDb250ZW50IjogWyIvKipcbiAqIEN1c3RvbSBlcnJvciBjbGFzcyByZXByZXNlbnRpbmcgYSA0MDMgRm9yYmlkZGVuIHN0YXR1cywgaW5kaWNhdGluZ1xuICogdGhhdCB0aGUgdXNlciBkb2VzIG5vdCBoYXZlIHBlcm1pc3Npb24gdG8gYWNjZXNzIHRoZSByZXF1ZXN0ZWQgcmVzb3VyY2UuXG4gKi9cbmV4cG9ydCBjbGFzcyBGb3JiaWRkZW5FcnJvciBleHRlbmRzIEVycm9yIHtcbiAgICAvKipcbiAgICAgKiBUaGUgbmFtZSBvZiB0aGUgZXJyb3IsIHNldCB0byBcIkZvcmJpZGRlbkVycm9yXCIuXG4gICAgICovXG4gICAgcmVhZG9ubHkgbmFtZSA9IFwiRm9yYmlkZGVuRXJyb3JcIjtcbiAgICAvKipcbiAgICAgKiBDYXB0dXJlcyB0aGUgc3RhY2sgdHJhY2Ugd2hlbiB0aGUgZXJyb3IgaXMgaW5zdGFudGlhdGVkLlxuICAgICAqL1xuICAgIHJlYWRvbmx5IHN0YWNrID0gKG5ldyBFcnJvcigpKS5zdGFjaztcblxuICAgIC8qKlxuICAgICAqIENyZWF0ZXMgYW4gaW5zdGFuY2Ugb2YgRm9yYmlkZGVuRXJyb3IuXG4gICAgICpcbiAgICAgKiBAcGFyYW0gbWVzc2FnZSBUaGUgZXJyb3IgbWVzc2FnZS4gRGVmYXVsdHMgdG8gXCJZb3UgZG9uJ3QgaGF2ZSBwZXJtaXNzaW9uIHRvIGFjY2VzcyB0aGlzIHJlc291cmNlXCIuXG4gICAgICovXG4gICAgY29uc3RydWN0b3IobWVzc2FnZTogc3RyaW5nID0gXCJZb3UgZG9uJ3QgaGF2ZSBwZXJtaXNzaW9uIHRvIGFjY2VzcyB0aGlzIHJlc291cmNlXCIpIHtcbiAgICAgICAgc3VwZXIobWVzc2FnZSk7XG4gICAgfVxufSJdLAogICJtYXBwaW5ncyI6ICI7Ozs7Ozs7Ozs7Ozs7Ozs7O0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUlPLE1BQU0sdUJBQXVCLE1BQU07QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUEsRUFldEMsWUFBWSxVQUFrQixxREFBcUQ7QUFDL0UsVUFBTSxPQUFPO0FBWmpCO0FBQUE7QUFBQTtBQUFBLFNBQVMsT0FBTztBQUloQjtBQUFBO0FBQUE7QUFBQSxTQUFTLFFBQVMsSUFBSSxNQUFNLEVBQUc7QUFBQSxFQVMvQjtBQUNKOyIsCiAgIm5hbWVzIjogW10KfQo=

package/dist/cjs/http/errors/ValidationError.js

@@ -0,0 +1,41 @@
+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 ValidationError_exports = {};
+__export(ValidationError_exports, {
+  ValidationError: () => ValidationError
+});
+module.exports = __toCommonJS(ValidationError_exports);
+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;
+  }
+}
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vLi4vc3JjL2h0dHAvZXJyb3JzL1ZhbGlkYXRpb25FcnJvci50cyJdLAogICJzb3VyY2VzQ29udGVudCI6IFsiLyoqXG4gKiBDdXN0b20gZXJyb3IgY2xhc3MgdXNlZCBmb3IgcmVwcmVzZW50aW5nIGZhaWx1cmVzIGR1ZSB0byBpbnZhbGlkIGlucHV0XG4gKiBvciBkYXRhIHRoYXQgdmlvbGF0ZXMgZG9tYWluLXNwZWNpZmljIHZhbGlkYXRpb24gcnVsZXMuXG4gKi9cbmV4cG9ydCBjbGFzcyBWYWxpZGF0aW9uRXJyb3IgZXh0ZW5kcyBFcnJvciB7XG4gICAgLyoqXG4gICAgICogVGhlIG5hbWUgb2YgdGhlIGVycm9yLCBzZXQgdG8gXCJWYWxpZGF0aW9uRXJyb3JcIi5cbiAgICAgKi9cbiAgICByZWFkb25seSBuYW1lID0gXCJWYWxpZGF0aW9uRXJyb3JcIjtcbiAgICAvKipcbiAgICAgKiBDYXB0dXJlcyB0aGUgc3RhY2sgdHJhY2Ugd2hlbiB0aGUgZXJyb3IgaXMgaW5zdGFudGlhdGVkLlxuICAgICAqL1xuICAgIHJlYWRvbmx5IHN0YWNrID0gKG5ldyBFcnJvcigpKS5zdGFjaztcblxuICAgIC8qKlxuICAgICAqIENyZWF0ZXMgYW4gaW5zdGFuY2Ugb2YgVmFsaWRhdGlvbkVycm9yLlxuICAgICAqXG4gICAgICogQHBhcmFtIG1lc3NhZ2UgVGhlIGRldGFpbGVkIG1lc3NhZ2UgZGVzY3JpYmluZyB0aGUgdmFsaWRhdGlvbiBmYWlsdXJlLlxuICAgICAqL1xuICAgIGNvbnN0cnVjdG9yKG1lc3NhZ2U6IHN0cmluZykge1xuICAgICAgICBzdXBlcihtZXNzYWdlKTtcbiAgICB9XG59Il0sCiAgIm1hcHBpbmdzIjogIjs7Ozs7Ozs7Ozs7Ozs7Ozs7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBO0FBSU8sTUFBTSx3QkFBd0IsTUFBTTtBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQSxFQWV2QyxZQUFZLFNBQWlCO0FBQ3pCLFVBQU0sT0FBTztBQVpqQjtBQUFBO0FBQUE7QUFBQSxTQUFTLE9BQU87QUFJaEI7QUFBQTtBQUFBO0FBQUEsU0FBUyxRQUFTLElBQUksTUFBTSxFQUFHO0FBQUEsRUFTL0I7QUFDSjsiLAogICJuYW1lcyI6IFtdCn0K

package/dist/cjs/http/errors.js

@@ -0,0 +1,26 @@
+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 errors_exports = {};
+__export(errors_exports, {
+  ForbiddenError: () => import_ForbiddenError.ForbiddenError,
+  ValidationError: () => import_ValidationError.ValidationError
+});
+module.exports = __toCommonJS(errors_exports);
+var import_ForbiddenError = require("./errors/ForbiddenError");
+var import_ValidationError = require("./errors/ValidationError");
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vc3JjL2h0dHAvZXJyb3JzLnRzIl0sCiAgInNvdXJjZXNDb250ZW50IjogWyJleHBvcnQgeyBGb3JiaWRkZW5FcnJvciB9IGZyb20gXCIuL2Vycm9ycy9Gb3JiaWRkZW5FcnJvclwiO1xuZXhwb3J0IHsgVmFsaWRhdGlvbkVycm9yIH0gZnJvbSBcIi4vZXJyb3JzL1ZhbGlkYXRpb25FcnJvclwiOyJdLAogICJtYXBwaW5ncyI6ICI7Ozs7Ozs7Ozs7Ozs7Ozs7O0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUEsNEJBQStCO0FBQy9CLDZCQUFnQzsiLAogICJuYW1lcyI6IFtdCn0K