@aerokit/sdk 12.80.0 → 12.82.0

package/dist/dts/io/bytes.d.ts

@@ -1,6 +1,37 @@
 /**
- * Provides utilities for converting and manipulating byte arrays,
- * facilitating conversions between JavaScript arrays, Java arrays, text, and integers.
+ * @module io/bytes
+ * @package @aerokit/sdk/io
+ * @name Bytes
+ * @overview
+ *
+ * The Bytes class provides static methods for converting and manipulating byte arrays, facilitating conversions between JavaScript arrays, Java arrays, text, and integers. It serves as a utility for bridging data types between the JavaScript environment and native Java components, particularly in scenarios where byte-level data manipulation is required.
+ *
+ * ### Key Features:
+ * - **Byte Array Conversion**: Methods to convert between JavaScript byte arrays (arrays of numbers) and native Java byte arrays, enabling seamless data exchange with Java methods.
+ * - **Text Encoding/Decoding**: Methods to convert text strings to byte arrays and vice versa, using the default platform encoding (UTF-8).
+ * - **Integer Conversion**: Methods to convert 32-bit integers to byte arrays and back, with support for both big-endian and little-endian byte orders.
+ *
+ * ### Use Cases:
+ * - **File Handling**: When working with file uploads or downloads, the Bytes class can be used to convert file content between different formats.
+ * - **Network Communication**: In scenarios involving network communication where data is transmitted as bytes, the Bytes class can facilitate encoding and decoding of messages.
+ * - **Data Serialization**: For applications that require custom serialization of data into byte formats, the Bytes class provides essential utilities for handling such conversions.
+ *
+ * ### Example Usage:
+ * ```ts
+ * import { Bytes } from "@aerokit/sdk/io";
+ *
+ * // Convert text to byte array and back
+ * const text = "Hello, World!";
+ * const byteArray = Bytes.textToByteArray(text);
+ * const reconstructedText = Bytes.byteArrayToText(byteArray);
+ * console.log(reconstructedText); // Output: Hello, World!
+ *
+ * // Convert integer to byte array and back
+ * const intValue = 123456789;
+ * const intByteArray = Bytes.intToByteArray(intValue, "BIG_ENDIAN");
+ * const reconstructedInt = Bytes.byteArrayToInt(intByteArray, "BIG_ENDIAN");
+ * console.log(reconstructedInt); // Output: 123456789
+ * ```
  */
 /**
  * The Bytes class provides static methods for byte array operations, primarily

package/dist/dts/io/files.d.ts

@@ -1,6 +1,38 @@
 /**
- * Provides a comprehensive static façade for file and directory operations,
- * abstracting the underlying Java file system implementation.
+ * @module io/files
+ * @package @aerokit/sdk/io
+ * @name Files
+ * @overview
+ *
+ * The Files class provides a comprehensive static façade for file and directory operations, abstracting the underlying Java file system implementation. It offers a wide range of methods for checking file properties, reading and writing content, managing file metadata, and performing common file system tasks such as copying, moving, and deleting files and directories.
+ *
+ * ### Key Features:
+ * - **File Property Checks**: Methods to check if a path exists, is a file or directory, is readable/writable/executable, and more.
+ * - **Content Manipulation**: Methods to read and write both text and binary content to files, with automatic conversion between Java byte arrays and JavaScript arrays.
+ * - **Metadata Management**: Methods to get and set file metadata such as last modified time, owner, and permissions.
+ * - **File System Operations**: Methods to create files and directories, copy and move files/directories, delete files/directories, and create temporary files/directories.
+ * - **Directory Traversal**: Methods to traverse directory structures and list contents with support for glob patterns.
+ *
+ * ### Use Cases:
+ * - **File Handling in Applications**: Essential for any application that needs to read from or write to the file system, such as configuration management, data storage, or log handling.
+ * - **Scripting and Automation**: Useful for scripts that perform file system maintenance, batch processing of files, or automated generation of content.
+ * - **Data Processing**: When working with data files, the Files class can be used to read input data, process it, and write output results back to the file system.
+ *
+ * ### Example Usage:
+ * ```ts
+ * import { Files } from "@aerokit/sdk/io";
+ *
+ * // Check if a file exists and read its content
+ * const filePath = "/path/to/file.txt";
+ * if (Files.exists(filePath)) {
+ *     const content = Files.readText(filePath);
+ *     console.log(content);
+ * }
+ *
+ * // Write text to a new file
+ * const newFilePath = "/path/to/newfile.txt";
+ * Files.writeText(newFilePath, "Hello, World!");
+ * ```
  */
 import { InputStream, OutputStream } from "@aerokit/sdk/io/streams";
 /**

package/dist/dts/io/image.d.ts

@@ -1,6 +1,31 @@
 /**
- * Provides a static façade for image manipulation operations,
- * primarily focusing on resizing image streams.
+ * @module io/image
+ * @package @aerokit/sdk/io
+ * @name Image
+ * @overview
+ *
+ * The Image class provides a static façade for performing common image manipulation operations, primarily focusing on resizing images. It allows developers to easily resize images by specifying the desired dimensions and output format, while abstracting away the complexities of handling image processing directly.
+ *
+ * ### Key Features:
+ * - **Image Resizing**: The `resize` method enables resizing an image to specified dimensions and output format, making it suitable for various use cases such as generating thumbnails or optimizing images for web delivery.
+ *
+ * ### Use Cases:
+ * - **Thumbnail Generation**: Developers can use the Image class to create smaller versions of images for use as thumbnails in galleries or listings.
+ * - **Image Optimization**: Resizing images to appropriate dimensions can help optimize them for faster loading times on websites and applications.
+ *
+ * ### Example Usage:
+ * ```ts
+ * import { Image } from "@aerokit/sdk/io";
+ * import { InputStream } from "@aerokit/sdk/io/streams";
+ *
+ * // Assume we have an InputStream containing the original image data
+ * const originalImageStream = new InputStream(...);
+ *
+ * // Resize the image to 200x200 pixels in PNG format
+ * const resizedImageStream = Image.resize(originalImageStream, "png", 200, 200);
+ *
+ * // The resizedImageStream can now be used for further processing or output
+ * ```
  */
 import { InputStream } from "@aerokit/sdk/io/streams";
 /**

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

@@ -1,3 +1,17 @@
+/**
+ * @module io/index
+ * @package @aerokit/sdk/io
+ * @overview
+ *
+ * This module provides functionalities for input/output operations within the Aerokit SDK. It includes classes and methods for handling various types of data, such as bytes, files, images, streams, and zip archives.
+ *
+ * The main components of this module are:
+ * - Bytes: Represents a byte array and provides methods for manipulating byte data.
+ * - Files: Represents file operations and provides methods for reading, writing, and managing files.
+ * - Image: Represents image processing functionalities and provides methods for manipulating images.
+ * - Streams: Represents stream operations and provides methods for handling data streams.
+ * - Zip: Represents zip archive functionalities and provides methods for creating and extracting zip files.
+ */
 export * from "./bytes";
 export { Bytes as bytes } from "./bytes";
 export * from "./files";

package/dist/dts/io/streams.d.ts

@@ -1,3 +1,43 @@
+/**
+ * @module io/streams
+ * @package @aerokit/sdk/io
+ * @name Streams
+ * @overview
+ *
+ * The Streams module provides core functionality for input/output stream management, including stream creation, data transfer, and byte array handling. It abstracts the complexities of working with streams in JavaScript by providing a set of classes and methods that wrap native Java stream objects, allowing developers to easily read from and write to streams in a consistent manner.
+ *
+ * ### Key Features:
+ * - **Stream Copying**: Methods for copying data between input and output streams, with support for both small and large data transfers.
+ * - **Resource Stream Creation**: Ability to create input streams from resources accessible via the class loader, facilitating access to bundled resources.
+ * - **Byte Array Handling**: Methods for creating streams from JavaScript byte arrays and retrieving byte data from streams in both JavaScript and native formats.
+ * - **Text Handling**: Methods for reading and writing text data to streams, with automatic encoding and decoding based on the platform's default character set.
+ *
+ * ### Use Cases:
+ * - **File I/O**: Reading from and writing to files using streams, which is essential for handling large files without consuming excessive memory.
+ * - **Network Communication**: Managing input and output streams for network sockets or HTTP requests/responses.
+ * - **Data Transformation**: Using streams to transform data on-the-fly, such as compressing or encrypting data as it is read or written.
+ *
+ * ### Example Usage:
+ * ```ts
+ * import { Streams, InputStream, OutputStream } from "@aerokit/sdk/io";
+ *
+ * // Create an input stream from a resource
+ * const inputStream = Streams.getResourceAsByteArrayInputStream("data/input.txt");
+ *
+ * // Create an output stream to write to a file
+ * const outputStream = new OutputStream(...);
+ *
+ * // Copy data from the input stream to the output stream
+ * Streams.copy(inputStream, outputStream);
+ *
+ * // Read text from the input stream
+ * const text = inputStream.readText();
+ * console.log(text);
+ *
+ * // Write text to the output stream
+ * outputStream.writeText("Hello, World!");
+ * ```
+ */
 /**
  * The Streams class provides static utility methods for stream creation,
  * manipulation, and data copying.

package/dist/dts/io/zip.d.ts

@@ -1,3 +1,35 @@
+/**
+ * @module io/zip
+ * @package @aerokit/sdk/io
+ * @name Zip
+ * @overview
+ *
+ * The Zip class provides a façade for handling ZIP archive operations, including file compression, decompression, and stream-based entry processing. It allows developers to easily create and extract ZIP files using both file paths and stream-based APIs, abstracting away the complexities of working with ZIP archives directly.
+ *
+ * ### Key Features:
+ * - **File-Based Operations**: The `zip` and `unzip` methods allow for straightforward compression and extraction of files and directories using file system paths.
+ * - **Stream-Based APIs**: The `createZipInputStream` and `createZipOutputStream` methods enable working with ZIP data in memory or through network streams, providing flexibility for various use cases.
+ *
+ * ### Use Cases:
+ * - **File Archiving**: Developers can use the Zip class to create ZIP archives of files and directories for backup, distribution, or storage purposes.
+ * - **Data Streaming**: The stream-based APIs are useful for scenarios where ZIP data needs to be processed on-the-fly, such as streaming a ZIP file over HTTP or processing ZIP data from an external source without saving it to disk.
+ *
+ * ### Example Usage:
+ * ```ts
+ * import { Zip } from "@aerokit/sdk/io";
+ * * // Zip a directory
+ * Zip.zip('/path/to/source', '/path/to/archive.zip');
+ * // Unzip an archive
+ * Zip.unzip('/path/to/archive.zip', '/path/to/destination');
+ * // Create a ZipOutputStream to write ZIP data to an OutputStream
+ * const outputStream = new OutputStream(...);
+ * const zipOutputStream = Zip.createZipOutputStream(outputStream);
+ * zipOutputStream.createZipEntry('file.txt');
+ * zipOutputStream.writeText('Hello, ZIP!');
+ * zipOutputStream.closeEntry();
+ * zipOutputStream.close();
+ * ```
+ */
 import { InputStream, OutputStream } from "@aerokit/sdk/io/streams";
 /**
  * The Zip class provides static utility methods for managing ZIP archives

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

@@ -1,3 +1,32 @@
+/**
+ * @module job/decorators
+ * @package @aerokit/sdk/job
+ * @name Decorators
+ * @overview
+ *
+ * This module provides a set of decorators for defining scheduled jobs in a declarative manner. The decorators allow developers to annotate classes to specify that they should be executed according to a specified schedule, making it easier to create and manage scheduled tasks within the application.
+ *
+ * ### Key Features:
+ * - **Scheduled Decorator**: The `@Scheduled` decorator is used to mark a class as a scheduled job, which will be executed based on a cron expression defined in the decorator's options.
+ *
+ * ### Use Cases:
+ * - **Task Scheduling**: These decorators are primarily used for defining tasks that need to run at specific intervals or times, such as data cleanup, report generation, or any recurring background processing.
+ * - **Code Organization**: By using decorators, developers can keep their code organized and maintainable, separating the scheduling logic from the business logic within their job classes.
+ *
+ * ### Example Usage:
+ * ```ts
+ * import { Scheduled } from "@aerokit/sdk/job";
+ *
+ * @Scheduled({ expression: "0/10 * * * * ?", group: "defined" })
+ * class MyScheduledJob {
+ *     execute() {
+ *         // Logic to be executed every 10 seconds
+ *     }
+ * }
+ *
+ * // The job will be automatically scheduled based on the provided cron expression.
+ * ```
+ */
 export interface ScheduledOptions {
     expression: string;
     group?: string;

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

@@ -1,3 +1,14 @@
+/**
+ * @module job/index
+ * @package @aerokit/sdk/job
+ * @overview
+ *
+ * This module provides functionalities for job scheduling and execution within the Aerokit SDK. It includes classes and methods for defining, scheduling, and managing jobs in a modular architecture.
+ *
+ * The main components of this module are:
+ * - Scheduler: Represents a job scheduler that allows you to define and manage scheduled jobs.
+ * - Decorators: Provides decorators for defining jobs and their properties in a declarative manner.
+ */
 export { Scheduler as scheduler } from "./scheduler";
 export * from "./scheduler";
 export * as decorators from "./decorators";

package/dist/dts/job/scheduler.d.ts

@@ -1,6 +1,37 @@
 /**
- * Provides the API for managing scheduled jobs and tasks within the platform,
- * allowing users to retrieve, enable, disable, and trigger jobs, as well as log output.
+ * @module job/scheduler
+ * @package @aerokit/sdk/job
+ * @name Scheduler
+ * @overview
+ *
+ * The Scheduler class provides a static façade for managing scheduled jobs and tasks within the platform. It allows users to retrieve job definitions, enable or disable jobs, trigger immediate execution, and log output associated with specific job instances. The Scheduler interacts with the underlying job scheduling system to facilitate the execution of recurring tasks based on cron expressions or other scheduling criteria.
+ *
+ * ### Key Features:
+ * - **Job Retrieval**: Methods to retrieve all job definitions or a specific job by name.
+ * - **Job Control**: Methods to enable, disable, or trigger jobs on demand.
+ * - **Logging**: Methods to log messages at various levels (standard, error, warning, info) for specific job instances.
+ *
+ * ### Use Cases:
+ * - **Task Scheduling**: Developers can use the Scheduler to manage tasks that need to run at specific intervals, such as data cleanup, report generation, or any recurring background processing.
+ * - **Monitoring and Debugging**: The logging methods allow developers to track the execution of jobs and diagnose issues by associating log messages with specific job instances.
+ *
+ * ### Example Usage:
+ * ```ts
+ * import { Scheduler } from "@aerokit/sdk/job";
+ *
+ * // Retrieve all job definitions
+ * const jobs = Scheduler.getJobs();
+ * console.log(jobs);
+ *
+ * // Enable a specific job
+ * Scheduler.enable("myScheduledJob");
+ *
+ * // Trigger a job immediately with parameters
+ * Scheduler.trigger("myScheduledJob", { param1: "value1", param2: "value2" });
+ *
+ * // Log a message for a specific job instance
+ * Scheduler.log("myScheduledJob", "This is a log message for the job instance.");
+ * ```
  */
 /**
  * The Scheduler class provides static methods for interacting with the job scheduler,

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

@@ -1 +1,11 @@
+/**
+ * @module junit/index
+ * @package @aerokit/sdk/junit
+ * @overview
+ *
+ * This module provides functionalities for JUnit testing within the Aerokit SDK. It includes classes and methods for defining and executing JUnit tests, as well as managing test suites and test cases in a modular architecture.
+ *
+ * The main components of this module are:
+ * - JUnit: Represents a registry for managing JUnit tests and provides methods to define and execute tests.
+ */
 export * from "./junit";

package/dist/dts/junit/junit.d.ts

@@ -1,3 +1,34 @@
+/**
+ * @module junit/junit
+ * @package @aerokit/sdk/junit
+ * @name JUnit
+ * @overview
+ *
+ * The JUnit module provides a set of utility functions for defining tests and performing assertions, wrapping the native JUnit Assertions for use in TypeScript/JavaScript tests. It allows developers to write test cases in a familiar format while leveraging the powerful assertion capabilities of JUnit, making it easier to validate code behavior and ensure correctness.
+ *
+ * ### Key Features:
+ * - **Test Definition**: The `test` function allows developers to define individual test cases with a descriptive name and a function containing the test logic.
+ * - **Assertions**: Functions such as `assertEquals`, `assertNotEquals`, `assertTrue`, `assertFalse`, and `fail` provide a variety of assertion methods to validate conditions and compare values within tests.
+ *
+ * ### Use Cases:
+ * - **Unit Testing**: These utilities are primarily used for writing unit tests to verify the functionality of individual components or functions in isolation.
+ * - **Integration Testing**: They can also be used in integration tests to validate the behavior of multiple components working together, ensuring that they interact correctly.
+ *
+ * ### Example Usage:
+ * ```ts
+ * import { test, assertEquals, assertTrue } from "@aerokit/sdk/junit";
+ *
+ * test("should add two numbers correctly", () => {
+ *     const result = add(2, 3);
+ *     assertEquals(5, result);
+ * });
+ *
+ * test("should return true for valid input", () => {
+ *     const isValid = validateInput("valid input");
+ *     assertTrue(isValid);
+ * });
+ * ```
+ */
 /**
  * Defines a test case.
  *

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

@@ -1,3 +1,34 @@
+/**
+ * @module kafka/consumer
+ * @package @aerokit/sdk/kafka
+ * @name Consumer
+ * @overview
+ *
+ * The Consumer module provides an API for configuring and managing Kafka consumers, allowing scripts to start and stop listening to specific topics. It abstracts the complexities of Kafka consumer configuration and lifecycle management, enabling developers to easily integrate Kafka message consumption into their applications.
+ *
+ * ### Key Features:
+ * - **Topic Configuration**: The `Consumer.topic` method allows developers to create a topic configuration wrapper with specified destination and properties.
+ * - **Background Listening**: The `startListening` method starts a background process that listens for messages on the configured topic, invoking a specified handler function for incoming messages.
+ * - **Graceful Shutdown**: The `stopListening` method allows developers to stop the background listening process based on the topic and configuration.
+ *
+ * ### Use Cases:
+ * - **Real-time Data Processing**: Developers can use this module to consume messages from Kafka topics in real-time, enabling use cases such as stream processing, event-driven architectures, and microservices communication.
+ * - **Integration with Other Systems**: By consuming Kafka messages, applications can integrate with other systems that produce messages to Kafka, facilitating data flow across different components of an ecosystem.
+ *
+ * ### Example Usage:
+ * ```ts
+ * import { Consumer } from "@aerokit/sdk/kafka";
+ *
+ * // Create a consumer for the "orders" topic with specific configuration
+ * const ordersConsumer = Consumer.topic("orders", { "group.id": "order-processors" });
+ *
+ * // Start listening to the "orders" topic with a message handler and timeout
+ * ordersConsumer.startListening("handleOrderMessage", 30000);
+ *
+ * // Later, stop listening to the "orders" topic
+ * ordersConsumer.stopListening();
+ * ```
+ */
 /**
  * The Consumer class acts as the main entry point for creating and configuring
  * Kafka topic consumers.

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

@@ -1,3 +1,14 @@
+/**
+ * @module kafka/index
+ * @package @aerokit/sdk/kafka
+ * @overview
+ *
+ * This module provides functionalities for Kafka integration within the Aerokit SDK. It includes classes and methods for producing and consuming messages from Kafka topics, as well as managing Kafka configurations and connections.
+ *
+ * The main components of this module are:
+ * - Consumer: Represents a Kafka consumer that can subscribe to topics and consume messages.
+ * - Producer: Represents a Kafka producer that can send messages to topics.
+ */
 export { Consumer as consumer } from "./consumer";
 export * from "./consumer";
 export { Producer as producer } from "./producer";

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

@@ -1,3 +1,34 @@
+/**
+ * @module kafka/producer
+ * @package @aerokit/sdk/kafka
+ * @name Producer
+ * @overview
+ *
+ * The Producer module provides an API for configuring and managing Kafka producers, allowing scripts to create topics, send messages, and close the producer connection. It abstracts the complexities of Kafka producer configuration and message sending, enabling developers to easily integrate Kafka message production into their applications.
+ *
+ * ### Key Features:
+ * - **Topic Configuration**: The `Producer.topic` method allows developers to create a topic configuration wrapper with specified destination and properties.
+ * - **Message Sending**: The `send` method on the Topic class enables sending messages with optional keys to the configured Kafka topic.
+ * - **Connection Management**: The `close` method allows developers to close the Kafka producer connection pool, ensuring proper resource cleanup.
+ *
+ * ### Use Cases:
+ * - **Event Production**: Developers can use this module to produce messages to Kafka topics in real-time, enabling use cases such as event-driven architectures and microservices communication.
+ * - **Integration with Other Systems**: By sending Kafka messages, applications can integrate with other systems that consume messages from Kafka, facilitating data flow across different components of an ecosystem.
+ *
+ * ### Example Usage:
+ * ```ts
+ * import { Producer } from "@aerokit/sdk/kafka";
+ *
+ * // Create a producer for the "orders" topic with specific configuration
+ * const ordersProducer = Producer.topic("orders", { "bootstrap.servers": "localhost:9092" });
+ *
+ * // Send a message with a key to the "orders" topic
+ * ordersProducer.send("order123", "New order placed");
+ *
+ * // Later, close the producer connection
+ * Producer.close({ "bootstrap.servers": "localhost:9092" });
+ * ```
+ */
 /**
  * The Producer class serves as the main entry point for creating and configuring
  * Kafka topic producers.

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

@@ -1,2 +1,12 @@
+/**
+ * @module log/index
+ * @package @aerokit/sdk/log
+ * @overview
+ *
+ * This module provides functionalities for logging within the Aerokit SDK. It includes classes and methods for managing loggers, configuring logging settings, and writing log messages at various levels (e.g., info, warning, error).
+ *
+ * The main components of this module are:
+ * - Logging: Represents a logging utility that provides methods to create loggers and write log messages.
+ */
 export { Logging as logging } from "./logging";
 export * from "./logging";

package/dist/dts/log/logging.d.ts

@@ -1,3 +1,35 @@
+/**
+ * @module log/logging
+ * @package @aerokit/sdk/log
+ * @name Logging
+ * @overview
+ *
+ * The Logging module provides a structured and flexible logging API for applications, allowing developers to create named loggers and emit log messages at various levels (e.g., DEBUG, INFO, WARN, ERROR). The module abstracts the underlying logging implementation, providing a consistent interface for logging across the application. It supports message formatting with variable arguments and can handle error objects to include stack traces in log outputs.
+ *
+ * ### Key Features:
+ * - **Named Loggers**: Create loggers with specific names to categorize log messages (e.g., 'com.app.service').
+ * - **Leveled Logging**: Emit log messages at different levels (DEBUG, INFO, WARN, ERROR) with the ability to set logging thresholds.
+ * - **Message Formatting**: Support for message templates with variable arguments for dynamic log content.
+ * - **Error Handling**: Ability to include Error objects in log messages to capture stack traces and error details.
+ *
+ * ### Use Cases:
+ * - **Application Logging**: Use the Logging module to emit log messages throughout your application for debugging, monitoring, and auditing purposes.
+ * - **Error Tracking**: Log errors with stack traces to facilitate troubleshooting and issue resolution.
+ * - **Performance Monitoring**: Emit log messages at different levels to monitor application performance and behavior under various conditions.
+ *
+ * ### Example Usage:
+ * ```ts
+ * import { Logging } from "@aerokit/sdk/log";
+ *
+ * const logger = Logging.getLogger("com.app.service");
+ * logger.setLevel("DEBUG");
+ *
+ * logger.debug("Debugging value: {0}", someVariable);
+ * logger.info("Service started successfully");
+ * logger.warn("Low disk space warning");
+ * logger.error("An error occurred while processing request", new Error("Database connection failed"));
+ * ```
+ */
 /**
  * The main entry point for the logging API. Use this class to obtain a named
  * logger instance.

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

@@ -1,3 +1,30 @@
+/**
+ * @module mail/client
+ * @package @aerokit/sdk/mail
+ * @name MailClient
+ * @overview
+ *
+ * The MailClient provides a client for sending emails, supporting both simple text/HTML messages and complex multipart messages with attachments or inline content. It abstracts the underlying Java MailFacade, allowing developers to send emails using a straightforward API while handling recipient processing and content formatting internally.
+ *
+ * ### Key Features:
+ * - **Simple Email Sending**: The `send` method allows sending basic emails with a single text or HTML body.
+ * - **Multipart Email Support**: The `sendMultipart` method enables sending complex emails composed of multiple parts, including attachments and inline content.
+ * - **Recipient Handling**: Supports flexible recipient specifications, allowing for 'to', 'cc', and 'bcc' fields to be provided as either strings or arrays.
+ * - **Configuration Options**: The constructor accepts an optional configuration object for customizing the mail client (e.g., SMTP settings).
+ *
+ * ### Use Cases:
+ * - **Notification Emails**: Use the MailClient to send notifications, alerts, or updates to users via email.
+ * - **Transactional Emails**: Send transactional emails such as order confirmations, password resets, or account activations.
+ * - **Rich Content Emails**: Leverage multipart email capabilities to include attachments, inline images, or mixed content in emails.
+ *
+ * ### Example Usage:
+ * ```ts
+ * import { MailClient } from "@aerokit/sdk/mail";
+ *
+ * // Send a simple HTML email
+ * MailClient.send("user@example.com", "Subject", "<p>Hello, World!</p>", "html");
+ * ```
+ */
 /**
  * Defines the structure for specifying email recipients.
  * Recipients can be provided as a single email string or an array of strings.

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

@@ -1,2 +1,12 @@
+/**
+ * @module mail/index
+ * @package @aerokit/sdk/mail
+ * @overview
+ *
+ * This module provides functionalities for email handling within the Aerokit SDK. It includes classes and methods for sending emails, managing email templates, and configuring email settings.
+ *
+ * The main components of this module are:
+ * - MailClient: Represents a client for sending emails and provides methods to configure email settings and send email messages.
+ */
 export * from "./client";
 export { MailClient as client } from "./client";

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

@@ -1,6 +1,33 @@
 /**
- * Provides an API for consuming messages from JMS-style destinations,
- * supporting both Queues (point-to-point) and Topics (publish/subscribe).
+ * @module messaging/consumer
+ * @package @aerokit/sdk/messaging
+ * @name Consumer
+ * @overview
+ *
+ * The Consumer module provides an API for consuming messages from JMS-style destinations, supporting both Queues (point-to-point) and Topics (publish/subscribe). It abstracts the complexities of message consumption, allowing developers to easily receive messages from configured destinations with optional timeout handling.
+ *
+ * ### Key Features:
+ * - **Queue and Topic Support**: The module supports both Queue and Topic consumers, enabling different messaging patterns (point-to-point and publish/subscribe).
+ * - **Synchronous Message Reception**: The `receive` method allows for synchronous message retrieval with an optional timeout parameter.
+ *
+ * ### Use Cases:
+ * - **Message-Driven Applications**: Developers can use this module to build applications that react to messages received from queues or topics, enabling event-driven architectures.
+ * - **Integration with Messaging Systems**: By consuming messages from JMS-style destinations, applications can integrate with various messaging systems that support these patterns.
+ *
+ * ### Example Usage:
+ * ```ts
+ * import { Consumer } from "@aerokit/sdk/messaging";
+ *
+ * // Create a Queue consumer for 'orders.queue'
+ * const queueConsumer = Consumer.queue("orders.queue");
+ * const messageFromQueue = queueConsumer.receive(5000); // Wait up to 5 seconds for a message
+ * console.log("Received from queue:", messageFromQueue);
+ *
+ * // Create a Topic consumer for 'market.updates.topic'
+ * const topicConsumer = Consumer.topic("market.updates.topic");
+ * const messageFromTopic = topicConsumer.receive(5000); // Wait up to 5 seconds for a message
+ * console.log("Received from topic:", messageFromTopic);
+ * ```
  */
 /**
  * The entry point for creating messaging consumers.

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

@@ -1,3 +1,35 @@
+/**
+ * @module messaging/decorators
+ * @package @aerokit/sdk/messaging
+ * @name Decorators
+ * @overview
+ *
+ * This module provides a set of decorators for defining messaging consumers in a declarative manner. The decorators allow developers to annotate classes to specify that they should act as consumers for specific messaging destinations, such as queues or topics. This makes it easier to create and manage message-driven components within the application.
+ *
+ * ### Key Features:
+ * - **Listener Decorator**: The `@Listener` decorator is used to mark a class as a messaging consumer, specifying the destination name and type (e.g., Queue or Topic).
+ *
+ * ### Use Cases:
+ * - **Message-Driven Applications**: These decorators are primarily used for defining components that react to messages received from queues or topics, enabling event-driven architectures.
+ * - **Integration with Messaging Systems**: By using these decorators, developers can easily integrate their applications with various messaging systems that support JMS-style patterns.
+ *
+ * ### Example Usage:
+ * ```ts
+ * import { Listener } from "@aerokit/sdk/messaging";
+ *
+ * @Listener({ name: "orders.queue", kind: "Queue" })
+ * class OrderConsumer {
+ *     // Logic to consume messages from 'orders.queue'
+ * }
+ *
+ * @Listener({ name: "market.updates.topic", kind: "Topic" })
+ * class MarketUpdatesConsumer {
+ *     // Logic to consume messages from 'market.updates.topic'
+ * }
+ *
+ * // The consumers will be automatically registered based on the provided metadata.
+ * ```
+ */
 export interface ListenerOptions {
     name: string;
     kind: string;

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

@@ -1,3 +1,15 @@
+/**
+ * @module messaging/index
+ * @package @aerokit/sdk/messaging
+ * @overview
+ *
+ * This module provides functionalities for messaging within the Aerokit SDK. It includes classes and methods for producing and consuming messages from various messaging systems, as well as managing messaging configurations and connections.
+ *
+ * The main components of this module are:
+ * - Consumer: Represents a message consumer that can subscribe to topics and consume messages.
+ * - Producer: Represents a message producer that can send messages to topics.
+ * - Decorators: Provides decorators for defining message handlers and producers in a modular architecture.
+ */
 export { Consumer as consumer } from "./consumer";
 export * from "./consumer";
 export { Producer as producer } from "./producer";