@aerokit/sdk 12.80.0 → 12.82.0

package/dist/dts/platform/workspace.d.ts

@@ -1,3 +1,45 @@
+/**
+ * @module platform/workspace
+ * @package @aerokit/sdk/platform
+ * @name Workspace
+ * @overview
+ *
+ * The Workspace module provides a wrapper for the platform's WorkspaceFacade, allowing developers to manage workspaces, projects, folders, and files in a structured manner. It abstracts the underlying Java API, providing a more intuitive and JavaScript-friendly interface for interacting with the platform's filesystem and project management capabilities.
+ *
+ * ### Key Features:
+ * - **Workspace Management**: Create, retrieve, list, and delete workspaces.
+ * - **Project Management**: Create, retrieve, list, copy, move, and delete projects within a workspace.
+ * - **Folder and File Management**: Create, retrieve, list, and delete folders and files within projects.
+ * - **Content Access**: Read and write file content as byte arrays or text strings.
+ *
+ * ### Use Cases:
+ * - **Project Organization**: This module is ideal for applications that need to organize code and resources into projects and workspaces on the platform.
+ * - **File Manipulation**: Developers can use this module to manage files and folders within their projects, including reading and writing file content.
+ *
+ * ### Example Usage:
+ * ```ts
+ * import { Workspace } from "@aerokit/sdk/platform";
+ *
+ * // Create a new workspace
+ * const workspace = Workspace.createWorkspace("MyWorkspace");
+ *
+ * // Create a new project within the workspace
+ * const project = workspace.createProject("MyProject");
+ *
+ * // Create a new folder within the project
+ * const folder = project.createFolder("src");
+ *
+ * // Create a new file within the folder with initial content
+ * const file = folder.createFile("index.js", [...]); // Initial content as byte array
+ *
+ * // Read file content as text
+ * const content = file.getText();
+ * console.log("File Content:", content);
+ *
+ * // Update file content with new text
+ * file.setText("console.log('Hello, World!');");
+ * ```
+ */
 /**
  * @class Workspace
  * @description Represents a logical container for projects, providing static methods for

package/dist/dts/qldb/index.d.ts

@@ -1,2 +1,14 @@
+/**
+ * @module qldb/index
+ * @package @aerokit/sdk/qldb
+ * @overview
+ *
+ * Provides simplified integration with Amazon QLDB (Quantum Ledger Database) for Aerokit SDK.
+ * The module exposes repository abstractions to interact with QLDB ledgers, execute statements,
+ * manage sessions and handle results in a structured way.
+ *
+ * The main components of this module are:
+ * - QLDBRepository: Primary interface for connecting to and operating on QLDB ledgers.
+ */
 export * from "./qldb";
 export { QLDBRepository as qldb } from "./qldb";

package/dist/dts/qldb/qldb.d.ts

@@ -1 +1,15 @@
+/**
+ * @module qldb/qldb
+ * @package @aerokit/sdk/qldb
+ * @name QLDBRepository
+ * @overview
+ *
+ * Entry point for Amazon QLDB repository integration in Aerokit SDK.
+ *
+ * Exposes the `QLDBRepository` class alias to the underlying Java implementation:
+ * `org.eclipse.dirigible.components.api.qldb.QLDBRepository`.
+ *
+ * This object is used to create and manage QLDB ledger sessions, execute statements,
+ * and handle transaction lifecycles from JavaScript code.
+ */
 export declare const QLDBRepository: any;

package/dist/dts/rabbitmq/consumer.d.ts

@@ -1,8 +1,29 @@
 /**
- * RabbitMQ Consumer
+ * @module rabbitmq/consumer
+ * @package @aerokit/sdk/rabbitmq
+ * @name Consumer
+ * @overview
  *
- * This facade provides static methods to start and stop listening on RabbitMQ queues,
- * wrapping the underlying Java implementation provided by the `RabbitMQFacade`.
+ * The RabbitMQ Consumer module provides a facade for managing message listeners on RabbitMQ queues. It allows developers to start and stop listening for messages on specified queues, delegating the handling of incoming messages to designated components or scripts. This module abstracts the underlying Java implementation, providing a simple interface for integrating RabbitMQ message consumption into applications built on the platform.
+ *
+ * ### Key Features:
+ * - **Start Listening**: The `startListening` method enables the application to begin consuming messages from a specified RabbitMQ queue, with a designated handler for processing incoming messages.
+ * - **Stop Listening**: The `stopListening` method allows the application to cease consuming messages from a specified queue for a given handler, providing control over message consumption.
+ *
+ * ### Use Cases:
+ * - **Message-Driven Architecture**: This module is ideal for applications that follow a message-driven architecture, allowing them to react to events or data changes by consuming messages from RabbitMQ queues.
+ * - **Integration with External Systems**: Developers can use this module to integrate their applications with external systems that communicate via RabbitMQ, enabling seamless data exchange and event handling.
+ *
+ * ### Example Usage:
+ * ```ts
+ * import { Consumer } from "@aerokit/sdk/rabbitmq";
+ *
+ * // Start listening on a RabbitMQ queue
+ * Consumer.startListening("myQueue", "myHandler");
+ *
+ * // Stop listening on the RabbitMQ queue
+ * Consumer.stopListening("myQueue", "myHandler");
+ * ```
  */
 export declare class Consumer {
     /**

package/dist/dts/rabbitmq/index.d.ts

@@ -1,3 +1,16 @@
+/**
+ * @module rabbitmq/index
+ * @package @aerokit/sdk/rabbitmq
+ * @overview
+ *
+ * This module provides RabbitMQ messaging capabilities for the Aerokit SDK.
+ * It includes consumer and producer abstractions to connect to AMQP brokers,
+ * send and receive messages, and manage queues/exchanges.
+ *
+ * The main components of this module are:
+ * - Consumer: Receives messages from queues and handles message processing.
+ * - Producer: Publishes messages to exchanges or queues.
+ */
 export * from "./consumer";
 export { Consumer as consumer } from "./consumer";
 export * from "./producer";

package/dist/dts/rabbitmq/producer.d.ts

@@ -1,8 +1,25 @@
 /**
- * RabbitMQ Producer
+ * @module rabbitmq/producer
+ * @package @aerokit/sdk/rabbitmq
+ * @name Producer
+ * @overview
  *
- * This facade provides a static method to send messages to a RabbitMQ queue,
- * wrapping the underlying Java implementation provided by the `RabbitMQFacade`.
+ * The RabbitMQ Producer module provides a simple facade for sending messages to RabbitMQ queues. It abstracts the underlying Java implementation, allowing developers to easily integrate message sending capabilities into their applications built on the platform. This module is designed to facilitate communication with RabbitMQ by providing a straightforward interface for sending messages to specified queues.
+ *
+ * ### Key Features:
+ * - **Message Sending**: The `send` method allows developers to send messages to a specified RabbitMQ queue with ease.
+ *
+ * ### Use Cases:
+ * - **Event-Driven Architecture**: This module is ideal for applications that follow an event-driven architecture, enabling them to publish events or data changes to RabbitMQ queues for consumption by other services or components.
+ * - **Integration with External Systems**: Developers can use this module to integrate their applications with external systems that communicate via RabbitMQ, facilitating seamless data exchange and event handling.
+ *
+ * ### Example Usage:
+ * ```ts
+ * import { Producer } from "@aerokit/sdk/rabbitmq";
+ *
+ * // Send a message to a RabbitMQ queue
+ * Producer.send("myQueue", "Hello, RabbitMQ!");
+ * ```
  */
 export declare class Producer {
     /**

package/dist/dts/redis/client.d.ts

@@ -1,8 +1,36 @@
 /**
- * Redis Client
+ * @module redis/client
+ * @package @aerokit/sdk/redis
+ * @name Client
+ * @overview
  *
- * This class serves as a facade for common Redis operations, providing a convenient
- * JavaScript interface that wraps the underlying Java Redis client implementation.
+ * The Redis Client module provides a JavaScript interface for interacting with Redis, a popular in-memory data structure store. This module serves as a facade for the underlying Java Redis client implementation, allowing developers to perform common Redis operations such as key-value manipulation and list management using a simple and intuitive API. The Client class abstracts the complexities of the Java implementation, providing a seamless experience for developers working with Redis in their applications built on the platform.
+ *
+ * ### Key Features:
+ * - **Key-Value Operations**: Methods for setting, getting, deleting, and checking the existence of keys, as well as incrementing and decrementing numeric values.
+ * - **List Operations**: Methods for managing lists, including pushing and popping elements from both ends of the list and retrieving list elements by index or range.
+ *
+ * ### Use Cases:
+ * - **Caching**: The Redis Client can be used to implement caching mechanisms in applications, improving performance by storing frequently accessed data in memory.
+ * - **Session Management**: Developers can use this module to manage user sessions in web applications by storing session data in Redis.
+ * - **Real-Time Data Processing**: The Redis Client is ideal for applications that require real-time data processing and quick access to data structures like lists and sets.
+ *
+ * ### Example Usage:
+ * ```ts
+ * import { Client } from "@aerokit/sdk/redis";
+ *
+ * const redisClient = new Client();
+ *
+ * // Set a key-value pair
+ * redisClient.set("myKey", "Hello, Redis!");
+ *
+ * // Get the value of a key
+ * const value = redisClient.get("myKey");
+ * console.log(value); // Output: Hello, Redis!
+ *
+ * // Push values to a list
+ * redisClient.rpush("myList", "item1", "item2", "item3");
+ * ```
  */
 export declare class Client {
     private readonly native;

package/dist/dts/redis/index.d.ts

@@ -1,2 +1,14 @@
+/**
+ * @module redis/index
+ * @package @aerokit/sdk/redis
+ * @overview
+ *
+ * This module provides Redis client integration for the Aerokit SDK.
+ * It exposes capabilities to connect to Redis servers, execute commands,
+ * and manage data structures and transactions.
+ *
+ * The main components of this module are:
+ * - Client: Redis client wrapper with command execution and connection management.
+ */
 export * from "./client";
 export { Client as client } from "./client";

package/dist/dts/security/decorators.d.ts

@@ -1,3 +1,37 @@
+/**
+ * @module security/decorators
+ * @package @aerokit/sdk/security
+ * @name Decorators
+ * @overview
+ *
+ * This module provides security-related decorators for enforcing role-based access control on classes and methods. The primary decorator, `@Roles`, allows developers to specify which user roles are required to access certain functionality within their application. By applying the `@Roles` decorator to a class or method, developers can ensure that only users with the appropriate roles can execute the associated code, enhancing the security of their applications.
+ *
+ * ### Key Features:
+ * - **Role-Based Access Control**: The `@Roles` decorator enables developers to define access control rules based on user roles, ensuring that only authorized users can access specific functionality.
+ * - **Class and Method Level Security**: The `@Roles` decorator can be applied at both the class and method levels, allowing for flexible security configurations.
+ *
+ * ### Use Cases:
+ * - **Securing API Endpoints**: Developers can use the `@Roles` decorator to protect API endpoints, ensuring that only users with the necessary roles can access certain routes or perform specific actions.
+ * - **Enforcing Business Logic**: By applying the `@Roles` decorator to methods that contain critical business logic, developers can prevent unauthorized access and maintain the integrity of their applications.
+ *
+ * ### Example Usage:
+ * ```ts
+ * import { Roles } from "@aerokit/sdk/security";
+ *
+ * @Roles(["admin"])
+ * class AdminController {
+ *     @Roles(["admin", "manager"])
+ *     deleteUser(userId: string) {
+ *         // Logic to delete a user, accessible only to admin and manager roles
+ *     }
+ *
+ *     @Roles(["admin"])
+ *     createUser(userData: any) {
+ *         // Logic to create a new user, accessible only to admin role
+ *     }
+ * }
+ * ```
+ */
 /**
  * @param {string[]} roles
  */

package/dist/dts/security/index.d.ts

@@ -1,3 +1,17 @@
+/**
+ * @module security/index
+ * @package @aerokit/sdk/security
+ * @overview
+ *
+ * Provides security helpers for user authentication, OAuth flows, and metadata decorators.
+ * It exposes user management utilities, OAuth integration, and useful security decorators
+ * for protected route handling and role-based access control.
+ *
+ * The main components of this module are:
+ * - User: User identity and authentication utilities.
+ * - OAuth: OAuth2 integration helpers for authentication flows.
+ * - Decorators: Security decorators for endpoint access control.
+ */
 export * from "./user";
 export { User as user } from "./user";
 export * from "./oauth";

package/dist/dts/security/oauth.d.ts

@@ -1,3 +1,30 @@
+/**
+ * @module security/oauth
+ * @package @aerokit/sdk/security
+ * @name OAuthClient
+ * @overview
+ *
+ * The OAuthClient class provides a simple interface for obtaining OAuth access tokens using the client credentials grant type. It abstracts the process of making HTTP requests to an OAuth token endpoint, allowing developers to easily integrate OAuth authentication into their applications. By providing the necessary configuration parameters such as the token endpoint URL, client ID, and client secret, developers can use this class to retrieve access tokens that can be used for authenticating API requests or accessing protected resources.
+ *
+ * ### Key Features:
+ * - **Token Retrieval**: The `getToken` method sends a POST request to the specified OAuth token endpoint with the client credentials and retrieves the access token.
+ * - **Configurable Grant Type**: While the default grant type is set to 'client_credentials', developers can specify other grant types if needed by providing it in the configuration.
+ *
+ * ### Use Cases:
+ * - **API Authentication**: The OAuthClient can be used to authenticate API requests by obtaining access tokens that are required for accessing protected endpoints.
+ * - **Integration with OAuth Providers**: Developers can use this class to integrate their applications with various OAuth providers that support the client credentials grant type, enabling secure access to resources.
+ *
+ * ### Example Usage:
+ * ```ts
+ * import { OAuthClient } from "@aerokit/sdk/security";
+ *
+ * const oauthClient = new OAuthClient({
+ *   url: "https://example.com/oauth/token",
+ *   clientId: "your-client-id",
+ *   clientSecret: "your-client-secret"
+ * });
+ * ```
+ */
 /**
  * Configuration structure for the OAuth client.
  */

package/dist/dts/security/user.d.ts

@@ -1,3 +1,42 @@
+/**
+ * @module security/user
+ * @package @aerokit/sdk/security
+ * @name User
+ * @overview
+ *
+ * The User class provides static methods to access the security and session context of the currently authenticated user. It serves as a facade for the underlying UserFacade component, allowing developers to easily retrieve information about the user's identity, roles, session timeout, authentication type, security token, invocation count, and preferred language. This class is essential for implementing role-based access control and managing user sessions within applications built on the platform.
+ *
+ * ### Key Features:
+ * - **User Identity**: Retrieve the principal name (username or ID) of the currently authenticated user.
+ * - **Role Checking**: Determine if the user is assigned to specific security roles, enabling role-based access control.
+ * - **Session Information**: Access session-related information such as remaining timeout and security tokens.
+ * - **Invocation Tracking**: Monitor the number of requests made by the user during their session.
+ * - **Localization Support**: Retrieve the user's preferred language setting for localization purposes.
+ *
+ * ### Use Cases:
+ * - **Access Control**: Use the `isInRole` method to enforce role-based access control in your application, ensuring that only authorized users can access certain functionality.
+ * - **Session Management**: Utilize session information to manage user sessions effectively, such as implementing session timeouts or tracking user activity.
+ * - **Localization**: Leverage the user's preferred language to provide localized content and enhance the user experience.
+ *
+ * ### Example Usage:
+ * ```ts
+ * import { User } from "@aerokit/sdk/security";
+ *
+ * // Check if the current user is an administrator
+ * if (User.isInRole("Administrator")) {
+ *     console.log(`Welcome, ${User.getName()}! You have administrator access.`);
+ * } else {
+ *     console.log(`Hello, ${User.getName()}. You do not have administrator access.`);
+ * }
+ *
+ * // Get session information
+ * const timeout = User.getTimeout();
+ * const authType = User.getAuthType();
+ * const securityToken = User.getSecurityToken();
+ * const invocationCount = User.getInvocationCount();
+ * const preferredLanguage = User.getLanguage();
+ * ```
+ */
 /**
  * Provides static access to the currently authenticated user's security and session context.
  * This class acts as a facade for the underlying UserFacade component.

package/dist/dts/template/engines.d.ts

@@ -1,3 +1,34 @@
+/**
+ * @module template/engines
+ * @package @aerokit/sdk/template
+ * @name TemplateEngines
+ * @overview
+ *
+ * The TemplateEngines module provides a unified interface for working with various server-side template engines, including Velocity, Mustache, and JavaScript. It allows developers to generate dynamic content by processing templates with provided parameters. The module abstracts the underlying template engine implementations, offering a consistent API for generating output from both raw template strings and templates stored in the registry.
+ *
+ * ### Key Features:
+ * - **Multiple Template Engines**: Supports Velocity, Mustache, and JavaScript template engines, allowing developers to choose the most suitable one for their use case.
+ * - **Dynamic Content Generation**: Enables the generation of dynamic content by processing templates with context parameters.
+ * - **File-Based Templates**: Provides functionality to load templates from the public registry and generate output based on their content.
+ *
+ * ### Use Cases:
+ * - **Email Templating**: Generate dynamic email content using templates stored in the registry.
+ * - **Report Generation**: Create dynamic reports by processing templates with data retrieved from various sources.
+ * - **Server-Side Rendering**: Use JavaScript templates for server-side rendering of HTML content.
+ *
+ * ### Example Usage:
+ * ```ts
+ * import { TemplateEngines } from "@aerokit/sdk/template";
+ *
+ * // Generate content from a raw template string
+ * const output = TemplateEngines.generate("template1", "Hello, {{name}}!", { name: "World" });
+ * console.log(output); // Output: Hello, World!
+ *
+ * // Generate content from a template file in the registry
+ * const fileOutput = TemplateEngines.generateFromFile("templates/email.mustache", { name: "Alice" });
+ * console.log(fileOutput); // Output depends on the content of 'email.mustache'
+ * ```
+ */
 /**
  * An internal wrapper class that adapts a native template engine implementation.
  * It manages the engine instance and optional custom start/end markers.

package/dist/dts/template/index.d.ts

@@ -1,2 +1,14 @@
+/**
+ * @module template/index
+ * @package @aerokit/sdk/template
+ * @overview
+ *
+ * This module provides template engine utilities for the Aerokit SDK.
+ * It exposes various template engines for rendering dynamic content,
+ * supporting multiple template languages and formatting options.
+ *
+ * The main components of this module are:
+ * - TemplateEngines: Registry and management of available template engines.
+ */
 export { TemplateEngines as engines } from "./engines";
 export * from "./engines";

package/dist/dts/utils/alphanumeric.d.ts

@@ -1,6 +1,40 @@
 /**
- * Transforms a string to an alphanumeric sequence, stripping non-conformant characters for it.
- * @param string {String} the string to transform
+ * @module utils/alphanumeric
+ * @package @aerokit/sdk/utils
+ * @name Alphanumeric
+ * @overview
+ *
+ * The Alphanumeric class provides a collection of static utility methods for generating and validating alphanumeric strings. It includes methods for transforming strings to alphanumeric format, generating random alphanumeric sequences, and validating whether a given string is numeric or alphanumeric. These utilities are essential for scenarios where input sanitization, random identifier generation, or format validation is required, making it easier for developers to handle common string manipulation tasks in a consistent manner.
+ *
+ * ### Key Features:
+ * - **String Transformation**: The `toAlphanumeric` method transforms a given string into an alphanumeric sequence by removing non-conformant characters.
+ * - **Random String Generation**: Methods like `randomString`, `alphanumeric`, and `alpha` allow for generating random strings of specified lengths and character sets.
+ * - **Validation Methods**: The `isNumeric` and `isAlphanumeric` methods provide a way to validate whether a string is purely numeric or alphanumeric, respectively.
+ *
+ * ### Use Cases:
+ * - **Input Sanitization**: The `toAlphanumeric` method can be used to sanitize user input by stripping out unwanted characters, ensuring that only valid alphanumeric characters are retained.
+ * - **Identifier Generation**: The random string generation methods are useful for creating unique identifiers, such as user IDs, session tokens, or any other scenario where a random string is needed.
+ * - **Format Validation**: The validation methods can be used to check if user input or data conforms to expected formats, such as ensuring that a string is numeric before processing it as a number.
+ *
+ * ### Example Usage:
+ * ```ts
+ * import { Alphanumeric } from "@aerokit/sdk/utils";
+ *
+ * // Transform a string to alphanumeric format
+ * const sanitized = Alphanumeric.toAlphanumeric("Hello, World! 123");
+ * console.log(sanitized); // Output: "HelloWorld123"
+ *
+ * // Generate a random alphanumeric string of length 8
+ * const randomId = Alphanumeric.alphanumeric(8, true);
+ * console.log(randomId); // Output: e.g., "a1b2c3d4"
+ *
+ * // Validate if a string is numeric
+ * const isNumeric = Alphanumeric.isNumeric("12345");
+ * console.log(isNumeric); // Output: true
+ *
+ * // Validate if a string is alphanumeric * const isAlphanumeric = Alphanumeric.isAlphanumeric("abc123");
+ * console.log(isAlphanumeric); // Output: true
+ * ```
  */
 export declare class Alphanumeric {
     static toAlphanumeric(string: string): string;

package/dist/dts/utils/base64.d.ts

@@ -1,3 +1,33 @@
+/**
+ * @module utils/base64
+ * @package @aerokit/sdk/utils
+ * @name Base64
+ * @overview
+ *
+ * The Base64 class provides static utility methods for encoding and decoding data using the Base64 encoding scheme. It supports both string and byte array inputs, allowing developers to easily convert data to and from Base64 format. The class abstracts the underlying Java implementation, providing a simple interface for performing Base64 operations in JavaScript.
+ *
+ * ### Key Features:
+ * - **Encoding**: Methods to encode strings or byte arrays into Base64 format, returning either a Base64 string or a byte array.
+ * - **Decoding**: Methods to decode Base64 strings or byte arrays back into their original byte array form.
+ *
+ * ### Use Cases:
+ * - **Data Serialization**: Base64 encoding is commonly used for serializing binary data (like images or files) into a text format that can be easily transmitted over text-based protocols such as HTTP.
+ * - **Authentication**: Base64 encoding is often used in authentication schemes (e.g., Basic Authentication) to encode credentials before transmission.
+ * - **Data Storage**: Developers can use Base64 encoding to store binary data in databases that only support text formats.
+ *
+ * ### Example Usage:
+ * ```ts
+ * import { Base64 } from "@aerokit/sdk/utils";
+ *
+ * // Encoding a string to Base64
+ * const encodedString = Base64.encode("Hello, World!");
+ * console.log(encodedString); // Output: SGVsbG8sIFdvcmxkIQ==
+ *
+ * // Decoding a Base64 string back to bytes
+ * const decodedBytes = Base64.decode(encodedString);
+ * console.log(decodedBytes); // Output: [72, 101, 108, 108, 111, 44, 32, 87, 111, 114, 108, 100, 33]
+ * ```
+ */
 /**
  * Utility class for performing **Base64 encoding and decoding** of data.
  * It handles conversion between JavaScript strings, JavaScript byte arrays (any[]),

package/dist/dts/utils/converter.d.ts

@@ -1,6 +1,41 @@
 /**
- * Utility class for converting and normalizing common data types (Date, Boolean)
- * within an object structure, typically for persistence or API consumption.
+ * @module utils/converter
+ * @package @aerokit/sdk/utils
+ * @name Converter
+ * @overview
+ *
+ * The Converter class provides static utility methods for converting and normalizing common data types such as Date and Boolean within an object structure. It is designed to facilitate the preparation of data for persistence or API consumption by ensuring that date values are consistently represented as timestamps or ISO strings, and that boolean values are strictly coerced to true or false. This class abstracts common data transformation patterns, allowing developers to easily convert and normalize their data without having to implement repetitive conversion logic throughout their codebase.
+ *
+ * ### Key Features:
+ * - **Date Conversion**: Methods to convert date properties into Unix timestamps or ISO 8601 strings, with handling for local timezone offsets.
+ * - **Boolean Conversion**: A method to coerce any truthy or falsy value into a strict boolean type.
+ *
+ * ### Use Cases:
+ * - **Data Preparation**: This class is useful for preparing data objects before saving them to a database or sending them in API requests, ensuring that date and boolean fields are in the expected format.
+ * - **Consistency**: By using these conversion methods, developers can maintain consistency in how dates and booleans are represented across their application, reducing bugs related to data formatting.
+ *
+ * ### Example Usage:
+ * ```ts
+ * import { Converter } from "@aerokit/sdk/utils";
+ *
+ * const obj = {
+ *   dateCreated: "2024-01-01T10:00:00Z",
+ *   birthday: "1990-05-15",
+ *   isActive: 1
+ * };
+ *
+ * Converter.setDate(obj, 'dateCreated');
+ * Converter.setLocalDate(obj, 'birthday');
+ * Converter.setBoolean(obj, 'isActive');
+ *
+ * console.log(obj);
+ * // Output:
+ * // {
+ * //   dateCreated: 1704096000000,
+ * //   birthday: "1990-05-15T00:00:00.000Z",
+ * //   isActive: true
+ * // }
+ * ```
  */
 export declare class Converter {
     /**

package/dist/dts/utils/digest.d.ts

@@ -1,3 +1,34 @@
+/**
+ * @module utils/digest
+ * @package @aerokit/sdk/utils
+ * @name Digest
+ * @overview
+ *
+ * The Digest class provides static utility methods for calculating cryptographic hash digests (MD5, SHA1, SHA256, SHA384, SHA512) from input data. It supports both string and byte array inputs, allowing developers to easily compute digests in various formats. The class abstracts the underlying Java implementation, providing a simple interface for performing digest operations in JavaScript.
+ *
+ * ### Key Features:
+ * - **Multiple Digest Algorithms**: Supports MD5, SHA1, SHA256, SHA384, and SHA512 digest algorithms.
+ * - **Flexible Input Types**: Accepts both string and byte array inputs for digest calculation.
+ * - **Output Formats**: Provides methods to return digest results as byte arrays or hexadecimal strings.
+ *
+ * ### Use Cases:
+ * - **Data Integrity**: Compute digests to verify the integrity of data by comparing computed digests with expected values.
+ * - **Password Hashing**: Use digest functions to hash passwords before storing them in a database (note: consider using a stronger hashing algorithm with salt for password storage).
+ * - **Unique Identifiers**: Generate unique identifiers for data based on their content by computing their digests.
+ *
+ * ### Example Usage:
+ * ```ts
+ * import { Digest } from "@aerokit/sdk/utils";
+ *
+ * // Calculate MD5 digest of a string and get it as a hex string
+ * const md5Hex = Digest.md5Hex("Hello, World!");
+ * console.log(md5Hex); // Output: 65a8e27d8879283831b664bd8b7f0ad4
+ *
+ * // Calculate SHA256 digest of a byte array and get it as a byte array
+ * const sha256Bytes = Digest.sha256([72, 101, 108, 108, 111]); // "Hello" in bytes
+ * console.log(sha256Bytes); // Output: [185, 105, 241, 149, 122, 223, 173, 190, ...]
+ * ```
+ */
 export declare class Digest {
     /**
      * Calculate MD5 digest from input (text or byte array) and return result as byte array

package/dist/dts/utils/escape.d.ts

@@ -1,7 +1,32 @@
 /**
- * Utility class for performing context-aware string escaping and unescaping operations,
- * delegating to a native Java EscapeFacade. These methods are essential for security
- * (preventing injection attacks) and ensuring correct data serialization across different formats.
+ * @module utils/escape
+ * @package @aerokit/sdk/utils
+ * @name Escape
+ * @overview
+ *
+ * The Escape class provides static utility methods for performing context-aware string escaping and unescaping operations. These methods are essential for ensuring that strings are safely embedded in various contexts (like HTML, JavaScript, JSON, etc.) without introducing security vulnerabilities such as injection attacks. The class delegates the actual escaping logic to a native Java EscapeFacade, providing a simple interface for JavaScript developers to utilize these functionalities.
+ *
+ * ### Key Features:
+ * - **Context-Aware Escaping**: Methods to escape strings for specific contexts such as CSV, JavaScript, HTML (3.2 and 4.0), Java, JSON, and XML.
+ * - **Unescaping Support**: Corresponding unescape methods to reverse the escaping process for each context.
+ * - **Security**: Helps prevent injection attacks by properly escaping special characters in strings before embedding them in different formats.
+ *
+ * ### Use Cases:
+ * - **Data Serialization**: Safely serialize data into formats like JSON or XML by escaping special characters.
+ * - **Web Development**: Escape user-generated content before embedding it in HTML or JavaScript to prevent XSS attacks.
+ * - **CSV Handling**: Escape values that contain commas, quotes, or newlines when generating CSV files.
+ *
+ * ### Example Usage:
+ * ```ts
+ * import { Escape } from "@aerokit/sdk/utils";
+ * // Escape a string for use in HTML
+ * const htmlSafe = Escape.escapeHtml4("<script>alert('XSS');</script>");
+ * console.log(htmlSafe); // Output: &lt;script&gt;alert(&#39;XSS&#39;);&lt;/script&gt;
+ *
+ * // Unescape the previously escaped HTML string
+ * const original = Escape.unescapeHtml4(htmlSafe);
+ * console.log(original); // Output: <script>alert('XSS');</script>
+ * ```
  */
 export declare class Escape {
     /**

package/dist/dts/utils/hex.d.ts

@@ -1,3 +1,33 @@
+/**
+ * @module utils/hex
+ * @package @aerokit/sdk/utils
+ * @name Hex
+ * @overview
+ *
+ * The Hex class provides static utility methods for encoding and decoding data using hexadecimal representation. It supports both string and byte array inputs, allowing developers to easily convert data to and from hexadecimal format. The class abstracts the underlying Java implementation, providing a simple interface for performing hexadecimal operations in JavaScript.
+ *
+ * ### Key Features:
+ * - **Encoding**: Methods to encode strings or byte arrays into hexadecimal format, returning either a hexadecimal string or a byte array.
+ * - **Decoding**: Methods to decode hexadecimal strings or byte arrays back into their original byte array form.
+ *
+ * ### Use Cases:
+ * - **Data Serialization**: Hexadecimal encoding is commonly used for representing binary data in a human-readable format, which can be useful for debugging or logging purposes.
+ * - **Cryptographic Operations**: Hexadecimal encoding is often used in cryptographic contexts to represent hash digests, keys, or other binary data in a readable format.
+ * - **Data Transmission**: Developers can use hexadecimal encoding to transmit binary data over text-based protocols where Base64 might not be suitable.
+ *
+ * ### Example Usage:
+ * ```ts
+ * import { Hex } from "@aerokit/sdk/utils";
+ *
+ * // Encoding a string to hexadecimal
+ * const hexString = Hex.encode("Hello, World!");
+ * console.log(hexString); // Output: 48656c6c6f2c20576f726c6421
+ *
+ * // Decoding a hexadecimal string back to bytes
+ * const decodedBytes = Hex.decode(hexString);
+ * console.log(decodedBytes); // Output: [72, 101, 108, 108, 111, 44, 32, 87, 111, 114, 108, 100, 33]
+ * ```
+ */
 /**
  * Utility class for performing **Hexadecimal encoding and decoding** of data.
  * It handles conversion between JavaScript strings, JavaScript byte arrays (any[]),