@aerokit/sdk 12.44.0

package/dist/esm/http/upload.mjs

@@ -0,0 +1,125 @@
+import { InputStream } from "@aerokit/sdk/io/streams";
+import { Bytes } from "@aerokit/sdk/io/bytes";
+const HttpUploadFacade = Java.type("org.eclipse.dirigible.components.api.http.HttpUploadFacade");
+class Upload {
+  /**
+   * Checks if the current incoming HTTP request contains multipart content
+   * (e.g., from an HTML form with `enctype="multipart/form-data"`).
+   * @returns True if the request is multipart, false otherwise.
+   */
+  static isMultipartContent() {
+    return HttpUploadFacade.isMultipartContent();
+  }
+  /**
+   * Parses the incoming multipart request content into a collection of file items.
+   * This operation typically consumes the request body.
+   * @returns A FileItems object representing all parts (files and form fields) of the request.
+   */
+  static parseRequest() {
+    return new FileItems(__context.get("files"));
+  }
+}
+class FileItems {
+  /**
+   * @param native The native Java collection object holding the file items.
+   */
+  constructor(native) {
+    this.native = native;
+  }
+  /**
+   * Retrieves a specific item (file or form field) by its index in the collection.
+   * @param index The zero-based index of the item.
+   * @returns A FileItem object representing the item at the specified index.
+   */
+  get(index) {
+    const native = this.native.get(index);
+    return new FileItem(native);
+  }
+  /**
+   * Returns the total number of items (files and form fields) in the collection.
+   * @returns The size of the collection.
+   */
+  size() {
+    return this.native.size();
+  }
+}
+class FileItem {
+  /**
+   * @param native The native Java object representing the file item.
+   */
+  constructor(native) {
+    this.native = native;
+  }
+  /**
+   * For a file upload, returns the original filename as reported by the client.
+   * For a regular form field, this is typically null or undefined.
+   * @returns The original filename string.
+   */
+  getName() {
+    return this.native.getOriginalFilename();
+  }
+  /**
+   * Returns the MIME type of the uploaded file or content part.
+   * @returns The content type string (e.g., 'image/png', 'text/plain').
+   */
+  getContentType() {
+    return this.native.getContentType();
+  }
+  /**
+   * Checks if the uploaded item is empty (e.g., a file upload with zero bytes).
+   * @returns True if the item is empty, false otherwise.
+   */
+  isEmpty() {
+    return this.native.isEmpty();
+  }
+  /**
+   * Returns the size of the uploaded item in bytes.
+   * @returns The size as a number.
+   */
+  getSize() {
+    return this.native.getSize();
+  }
+  /**
+   * Retrieves the content of the file item as a JavaScript array of bytes.
+   * This uses a utility (`Bytes.toJavaScriptBytes`) to convert the native Java byte array.
+   * @returns An array of bytes (`any[]`).
+   */
+  getBytes() {
+    const data = this.getBytesNative();
+    return Bytes.toJavaScriptBytes(data);
+  }
+  /**
+   * Retrieves the content of the file item as the native Java byte array.
+   * @returns The native byte array (`any[]`).
+   */
+  getBytesNative() {
+    return this.native.getBytes();
+  }
+  /**
+   * Retrieves the content of the file item as a string.
+   * Note: This assumes the content is text and may not handle all encodings correctly.
+   * It relies on JavaScript's `String.fromCharCode.apply` for conversion.
+   * @returns The content as a string.
+   */
+  getText() {
+    return String.fromCharCode.apply(null, this.getBytesNative());
+  }
+  /**
+   * Gets an input stream for reading the content of the file item.
+   * This is useful for handling large files without loading the entire content into memory.
+   * @returns An InputStream object wrapping the native input stream.
+   */
+  getInputStream() {
+    const native = this.native.getInputStream();
+    return new InputStream(native);
+  }
+}
+if (typeof module !== "undefined") {
+  module.exports = Upload;
+}
+export {
+  FileItem,
+  FileItems,
+  Upload
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/http/upload.ts"],
  "sourcesContent": ["/**\n * Provides a static fa\u00E7ade (`Upload` class) for checking and parsing\n * multipart/form-data HTTP requests, typically used for file uploads.\n */\nimport { InputStream } from \"@aerokit/sdk/io/streams\"\nimport { Bytes } from \"@aerokit/sdk/io/bytes\"\n\nconst HttpUploadFacade = Java.type(\"org.eclipse.dirigible.components.api.http.HttpUploadFacade\");\n\n/**\n * The static Upload class provides methods to determine if a request contains\n * multipart content and to parse that content into file items.\n */\nexport class Upload {\n\n    /**\n     * Checks if the current incoming HTTP request contains multipart content\n     * (e.g., from an HTML form with `enctype=\"multipart/form-data\"`).\n     * @returns True if the request is multipart, false otherwise.\n     */\n    public static isMultipartContent(): boolean {\n        return HttpUploadFacade.isMultipartContent();\n    }\n\n    /**\n     * Parses the incoming multipart request content into a collection of file items.\n     * This operation typically consumes the request body.\n     * @returns A FileItems object representing all parts (files and form fields) of the request.\n     */\n    public static parseRequest(): FileItems {\n        // The underlying native execution context (__context) is assumed to contain\n        // the parsed file items under the \"files\" key after the native facade processing.\n        // @ts-ignore: __context is assumed to be globally available in the runtime environment\n        return new FileItems(__context.get(\"files\"));\n    }\n}\n\n/**\n * Represents a collection of uploaded file and form field items parsed from a multipart request.\n */\nexport class FileItems {\n\n    private readonly native: any;\n\n    /**\n     * @param native The native Java collection object holding the file items.\n     */\n    constructor(native: any) {\n        this.native = native;\n    }\n\n    /**\n     * Retrieves a specific item (file or form field) by its index in the collection.\n     * @param index The zero-based index of the item.\n     * @returns A FileItem object representing the item at the specified index.\n     */\n    public get(index: number): FileItem {\n        const native = this.native.get(index);\n        return new FileItem(native);\n    }\n\n    /**\n     * Returns the total number of items (files and form fields) in the collection.\n     * @returns The size of the collection.\n     */\n    public size(): number {\n        return this.native.size();\n    }\n}\n\n/**\n * Represents a single item (either an uploaded file or a regular form field)\n * within a multipart request.\n */\nexport class FileItem {\n\n    private readonly native: any\n\n    /**\n     * @param native The native Java object representing the file item.\n     */\n    constructor(native: any) {\n        this.native = native;\n    }\n\n    /**\n     * For a file upload, returns the original filename as reported by the client.\n     * For a regular form field, this is typically null or undefined.\n     * @returns The original filename string.\n     */\n    public getName(): string {\n        return this.native.getOriginalFilename();\n    }\n\n    /**\n     * Returns the MIME type of the uploaded file or content part.\n     * @returns The content type string (e.g., 'image/png', 'text/plain').\n     */\n    public getContentType(): string {\n        return this.native.getContentType();\n    }\n\n    /**\n     * Checks if the uploaded item is empty (e.g., a file upload with zero bytes).\n     * @returns True if the item is empty, false otherwise.\n     */\n    public isEmpty(): boolean {\n        return this.native.isEmpty();\n    }\n\n    /**\n     * Returns the size of the uploaded item in bytes.\n     * @returns The size as a number.\n     */\n    public getSize(): number {\n        return this.native.getSize();\n    }\n\n    /**\n     * Retrieves the content of the file item as a JavaScript array of bytes.\n     * This uses a utility (`Bytes.toJavaScriptBytes`) to convert the native Java byte array.\n     * @returns An array of bytes (`any[]`).\n     */\n    public getBytes(): any[] {\n        const data = this.getBytesNative();\n        return Bytes.toJavaScriptBytes(data);\n    }\n\n    /**\n     * Retrieves the content of the file item as the native Java byte array.\n     * @returns The native byte array (`any[]`).\n     */\n    public getBytesNative(): any[] {\n        return this.native.getBytes();\n    }\n\n    /**\n     * Retrieves the content of the file item as a string.\n     * Note: This assumes the content is text and may not handle all encodings correctly.\n     * It relies on JavaScript's `String.fromCharCode.apply` for conversion.\n     * @returns The content as a string.\n     */\n    public getText(): string {\n        return String.fromCharCode.apply(null, this.getBytesNative());\n    }\n\n    /**\n     * Gets an input stream for reading the content of the file item.\n     * This is useful for handling large files without loading the entire content into memory.\n     * @returns An InputStream object wrapping the native input stream.\n     */\n    public getInputStream(): InputStream {\n        const native = this.native.getInputStream();\n        return new InputStream(native);\n    }\n}\n\n// @ts-ignore\nif (typeof module !== 'undefined') {\n\t// @ts-ignore\n\tmodule.exports = Upload;\n}\n"],
  "mappings": "AAIA,SAAS,mBAAmB;AAC5B,SAAS,aAAa;AAEtB,MAAM,mBAAmB,KAAK,KAAK,4DAA4D;AAMxF,MAAM,OAAO;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOhB,OAAc,qBAA8B;AACxC,WAAO,iBAAiB,mBAAmB;AAAA,EAC/C;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,OAAc,eAA0B;AAIpC,WAAO,IAAI,UAAU,UAAU,IAAI,OAAO,CAAC;AAAA,EAC/C;AACJ;AAKO,MAAM,UAAU;AAAA;AAAA;AAAA;AAAA,EAOnB,YAAY,QAAa;AACrB,SAAK,SAAS;AAAA,EAClB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOO,IAAI,OAAyB;AAChC,UAAM,SAAS,KAAK,OAAO,IAAI,KAAK;AACpC,WAAO,IAAI,SAAS,MAAM;AAAA,EAC9B;AAAA;AAAA;AAAA;AAAA;AAAA,EAMO,OAAe;AAClB,WAAO,KAAK,OAAO,KAAK;AAAA,EAC5B;AACJ;AAMO,MAAM,SAAS;AAAA;AAAA;AAAA;AAAA,EAOlB,YAAY,QAAa;AACrB,SAAK,SAAS;AAAA,EAClB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOO,UAAkB;AACrB,WAAO,KAAK,OAAO,oBAAoB;AAAA,EAC3C;AAAA;AAAA;AAAA;AAAA;AAAA,EAMO,iBAAyB;AAC5B,WAAO,KAAK,OAAO,eAAe;AAAA,EACtC;AAAA;AAAA;AAAA;AAAA;AAAA,EAMO,UAAmB;AACtB,WAAO,KAAK,OAAO,QAAQ;AAAA,EAC/B;AAAA;AAAA;AAAA;AAAA;AAAA,EAMO,UAAkB;AACrB,WAAO,KAAK,OAAO,QAAQ;AAAA,EAC/B;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOO,WAAkB;AACrB,UAAM,OAAO,KAAK,eAAe;AACjC,WAAO,MAAM,kBAAkB,IAAI;AAAA,EACvC;AAAA;AAAA;AAAA;AAAA;AAAA,EAMO,iBAAwB;AAC3B,WAAO,KAAK,OAAO,SAAS;AAAA,EAChC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQO,UAAkB;AACrB,WAAO,OAAO,aAAa,MAAM,MAAM,KAAK,eAAe,CAAC;AAAA,EAChE;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOO,iBAA8B;AACjC,UAAM,SAAS,KAAK,OAAO,eAAe;AAC1C,WAAO,IAAI,YAAY,MAAM;AAAA,EACjC;AACJ;AAGA,IAAI,OAAO,WAAW,aAAa;AAElC,SAAO,UAAU;AAClB;",
  "names": []
}


package/dist/esm/http/utils.mjs

@@ -0,0 +1,87 @@
+import { response } from "@aerokit/sdk/http";
+class HttpUtils {
+  /**
+   * Sends a successful response with HTTP status 200 (OK).
+   * The provided entity is serialized as the JSON response body.
+   * @param entity The data entity to return in the response body.
+   */
+  static sendResponseOk(entity) {
+    HttpUtils.sendResponse(200, entity);
+  }
+  /**
+   * Sends a successful response with HTTP status 201 (Created).
+   * Typically used after a resource has been successfully created.
+   * @param entity The data entity of the newly created resource.
+   */
+  static sendResponseCreated(entity) {
+    HttpUtils.sendResponse(201, entity);
+  }
+  /**
+   * Sends a successful response with HTTP status 204 (No Content).
+   * Typically used for successful DELETE requests or updates that do not return a body.
+   */
+  static sendResponseNoContent() {
+    HttpUtils.sendResponse(204);
+  }
+  /**
+   * Sends an error response with HTTP status 400 (Bad Request).
+   * Used when the request could not be understood or processed due to client-side errors (e.g., validation failure).
+   * @param message A descriptive error message explaining why the request was invalid.
+   */
+  static sendResponseBadRequest(message) {
+    HttpUtils.sendResponse(400, {
+      "code": 400,
+      "message": message
+    });
+  }
+  /**
+   * Sends an error response with HTTP status 403 (Forbidden).
+   * Used when the client is authenticated but does not have the necessary permissions to access the resource.
+   * @param message A descriptive error message.
+   */
+  static sendForbiddenRequest(message) {
+    HttpUtils.sendResponse(403, {
+      "code": 403,
+      "message": message
+    });
+  }
+  /**
+   * Sends an error response with HTTP status 404 (Not Found).
+   * Used when the requested resource could not be found.
+   * @param message A descriptive error message.
+   */
+  static sendResponseNotFound(message) {
+    HttpUtils.sendResponse(404, {
+      "code": 404,
+      "message": message
+    });
+  }
+  /**
+   * Sends an error response with HTTP status 500 (Internal Server Error).
+   * Used for unexpected server-side conditions encountered during processing.
+   * @param message A descriptive error message (should mask internal details in production).
+   */
+  static sendInternalServerError(message) {
+    HttpUtils.sendResponse(500, {
+      "code": 500,
+      "message": message
+    });
+  }
+  /**
+   * Generic private method to set the response status, content type, and body.
+   * If a body is provided, it is stringified into JSON and written to the response.
+   * @param status The HTTP status code to set (e.g., 200, 404, 500).
+   * @param body The JavaScript object or string to be serialized as the response body (optional).
+   */
+  static sendResponse(status, body) {
+    response.setContentType("application/json");
+    response.setStatus(status);
+    if (body) {
+      response.println(JSON.stringify(body));
+    }
+  }
+}
+export {
+  HttpUtils
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm/index.mjs

@@ -0,0 +1 @@
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFtdLAogICJzb3VyY2VzQ29udGVudCI6IFtdLAogICJtYXBwaW5ncyI6ICIiLAogICJuYW1lcyI6IFtdCn0K

package/dist/esm/indexing/index.mjs

@@ -0,0 +1,9 @@
+export * from "./searcher";
+import { Searcher } from "./searcher";
+export * from "./writer";
+import { Writer } from "./writer";
+export {
+  Searcher as searcher,
+  Writer as writer
+};
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vc3JjL2luZGV4aW5nL2luZGV4LnRzIl0sCiAgInNvdXJjZXNDb250ZW50IjogWyJleHBvcnQgKiBmcm9tIFwiLi9zZWFyY2hlclwiO1xuZXhwb3J0IHsgU2VhcmNoZXIgYXMgc2VhcmNoZXIgfSBmcm9tIFwiLi9zZWFyY2hlclwiO1xuZXhwb3J0ICogZnJvbSBcIi4vd3JpdGVyXCI7XG5leHBvcnQgeyBXcml0ZXIgYXMgd3JpdGVyIH0gZnJvbSBcIi4vd3JpdGVyXCI7XG4iXSwKICAibWFwcGluZ3MiOiAiQUFBQSxjQUFjO0FBQ2QsU0FBcUIsZ0JBQWdCO0FBQ3JDLGNBQWM7QUFDZCxTQUFtQixjQUFjOyIsCiAgIm5hbWVzIjogW10KfQo=

package/dist/esm/indexing/searcher.mjs

@@ -0,0 +1,51 @@
+const IndexingFacade = Java.type("org.eclipse.dirigible.components.api.indexing.IndexingFacade");
+class Searcher {
+  /**
+   * Executes a keyword search against a specified index.
+   * @param index The name or identifier of the index to search (e.g., 'documents', 'products').
+   * @param term The keyword or search phrase to look for.
+   * @returns An array of result objects, parsed from the native JSON string output.
+   */
+  static search(index, term) {
+    const results = IndexingFacade.search(index, term);
+    return JSON.parse(results);
+  }
+  /**
+   * Finds all entries in the index that were indexed before the specified date.
+   * @param index The name or identifier of the index.
+   * @param date The Date object representing the upper bound (exclusive) of the time range.
+   * @returns An array of result objects, parsed from the native JSON string output.
+   */
+  static before(index, date) {
+    const results = IndexingFacade.before(index, "" + date.getTime());
+    return JSON.parse(results);
+  }
+  /**
+   * Finds all entries in the index that were indexed after the specified date.
+   * @param index The name or identifier of the index.
+   * @param date The Date object representing the lower bound (exclusive) of the time range.
+   * @returns An array of result objects, parsed from the native JSON string output.
+   */
+  static after(index, date) {
+    const results = IndexingFacade.after(index, "" + date.getTime());
+    return JSON.parse(results);
+  }
+  /**
+   * Finds all entries in the index that were indexed within the specified date range.
+   * @param index The name or identifier of the index.
+   * @param lower The Date object for the lower bound (exclusive).
+   * @param upper The Date object for the upper bound (exclusive).
+   * @returns An array of result objects, parsed from the native JSON string output.
+   */
+  static between(index, lower, upper) {
+    const results = IndexingFacade.between(index, "" + lower.getTime(), "" + upper.getTime());
+    return JSON.parse(results);
+  }
+}
+if (typeof module !== "undefined") {
+  module.exports = Searcher;
+}
+export {
+  Searcher
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm/indexing/writer.mjs

@@ -0,0 +1,26 @@
+const IndexingFacade = Java.type("org.eclipse.dirigible.components.api.indexing.IndexingFacade");
+class Writer {
+  /**
+   * Adds a new document entry to the specified index.
+   *
+   * @param index The name or identifier of the index (e.g., 'documents', 'users').
+   * @param location A unique identifier or path for the indexed document (e.g., a file path or URL).
+   * @param contents The full-text content of the document to be indexed and made searchable.
+   * @param lastModified The Date object representing the last modification time of the document. Defaults to the current date/time if omitted.
+   * @param parameters Optional key-value map of additional metadata to associate with the document.
+   */
+  static add(index, location, contents, lastModified = /* @__PURE__ */ new Date(), parameters) {
+    let map = "{}";
+    if (parameters) {
+      map = JSON.stringify(parameters);
+    }
+    IndexingFacade.add(index, location, contents, "" + lastModified.getTime(), map);
+  }
+}
+if (typeof module !== "undefined") {
+  module.exports = Writer;
+}
+export {
+  Writer
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm/integrations/index.mjs

@@ -0,0 +1,6 @@
+export * from "./integrations";
+import { Integrations } from "./integrations";
+export {
+  Integrations as integrations
+};
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vc3JjL2ludGVncmF0aW9ucy9pbmRleC50cyJdLAogICJzb3VyY2VzQ29udGVudCI6IFsiZXhwb3J0ICogZnJvbSBcIi4vaW50ZWdyYXRpb25zXCI7XG5leHBvcnQgeyBJbnRlZ3JhdGlvbnMgYXMgaW50ZWdyYXRpb25zIH0gZnJvbSBcIi4vaW50ZWdyYXRpb25zXCI7Il0sCiAgIm1hcHBpbmdzIjogIkFBQUEsY0FBYztBQUNkLFNBQXlCLG9CQUFvQjsiLAogICJuYW1lcyI6IFtdCn0K

package/dist/esm/integrations/integrations.mjs

@@ -0,0 +1,36 @@
+const SpringBeanProvider = Java.type("org.eclipse.dirigible.components.spring.SpringBeanProvider");
+const Invoker = Java.type("org.eclipse.dirigible.components.engine.camel.invoke.Invoker");
+const invoker = SpringBeanProvider.getBean(Invoker.class);
+const CamelMessage = Java.type("org.apache.camel.Message");
+class Integrations {
+  /**
+   * Synchronously invokes a specified Camel route.
+   *
+   * @param routeId The unique identifier of the Camel route to be executed.
+   * @param payload The initial message body/payload for the route.
+   * @param headers A map of headers to set on the initial Camel Message.
+   * @param exchangeProperties A map of properties to set on the Camel Exchange context.
+   * @returns The final result (the body of the resulting Camel Message) after the route has completed execution.
+   */
+  static invokeRoute(routeId, payload, headers, exchangeProperties) {
+    return invoker.invokeRoute(routeId, payload, headers, exchangeProperties);
+  }
+  /**
+   * Retrieves the current message being processed by the underlying integration
+   * engine's context. This is typically used within a route endpoint (e.g., a script component)
+   * to access or modify the message.
+   *
+   * Note: '__context' is assumed to be a global or context-injected variable.
+   * @returns The current IntegrationMessage wrapper.
+   */
+  static getInvokingRouteMessage() {
+    return __context.camelMessage;
+  }
+}
+if (typeof module !== "undefined") {
+  module.exports = Integrations;
+}
+export {
+  Integrations
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm/io/bytes.mjs

@@ -0,0 +1,82 @@
+const JString = Java.type("java.lang.String");
+const JByte = Java.type("java.lang.Byte");
+const JArray = Java.type("java.lang.reflect.Array");
+const BytesFacade = Java.type("org.eclipse.dirigible.components.api.io.BytesFacade");
+class Bytes {
+  /**
+   * Converts a native JavaScript byte array (an array of numbers) to a Java byte array.
+   * This is used internally by the API layer to pass data to Java methods.
+   *
+   * @param bytes The JavaScript array of bytes (e.g., [104, 101, 108, 108, 111]).
+   * @returns A native Java byte array (internal representation).
+   */
+  static toJavaBytes(bytes) {
+    const internalBytes = JArray.newInstance(JByte.TYPE, bytes.length);
+    for (let i = 0; i < bytes.length; i++) {
+      internalBytes[i] = bytes[i];
+    }
+    return internalBytes;
+  }
+  /**
+   * Converts a native Java byte array back to a JavaScript array of numbers.
+   * This is used internally by the API layer to retrieve data from Java methods.
+   *
+   * @param internalBytes The native Java byte array.
+   * @returns A JavaScript array containing the byte values (numbers).
+   */
+  static toJavaScriptBytes(internalBytes) {
+    const bytes = [];
+    for (let i = 0; i < internalBytes.length; i++) {
+      bytes.push(internalBytes[i]);
+    }
+    return bytes;
+  }
+  /**
+   * Converts a standard text string into a byte array using the default platform encoding.
+   *
+   * @param text The input text string.
+   * @returns A JavaScript array representing the bytes of the text.
+   */
+  static textToByteArray(text) {
+    const javaString = new JString(text);
+    const native = BytesFacade.textToByteArray(text);
+    return Bytes.toJavaScriptBytes(native);
+  }
+  /**
+   * Converts a byte array back into a text string.
+   *
+   * @param data The JavaScript array of bytes.
+   * @returns The reconstructed text string.
+   */
+  static byteArrayToText(data) {
+    const native = Bytes.toJavaBytes(data);
+    return String.fromCharCode.apply(String, Bytes.toJavaScriptBytes(native));
+  }
+  /**
+   * Converts a 32-bit integer value into a byte array, respecting the specified byte order.
+   *
+   * @param value The integer value to convert.
+   * @param byteOrder Specifies the byte ordering: "BIG_ENDIAN" (most significant byte first) or "LITTLE_ENDIAN" (least significant byte first).
+   * @returns A JavaScript array representing the 4-byte integer.
+   */
+  static intToByteArray(value, byteOrder) {
+    return BytesFacade.intToByteArray(value, byteOrder);
+  }
+  /**
+   * Converts a 4-byte array back into a 32-bit integer value, respecting the specified byte order.
+   *
+   * @param data The 4-byte array (JavaScript array of numbers).
+   * @param byteOrder Specifies the byte ordering used during conversion.
+   * @returns The reconstructed integer value.
+   */
+  static byteArrayToInt(data, byteOrder) {
+    return BytesFacade.byteArrayToInt(data, byteOrder);
+  }
+}
+if (typeof module !== "undefined") {
+  module.exports = Bytes;
+}
+export {
+  Bytes
+};
+//# sourceMappingURL=data:application/json;base64,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