@aerokit/sdk 12.80.0 → 12.82.0

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

@@ -1,6 +1,31 @@
 /**
- * Provides an API for producing (sending) messages to JMS-style destinations,
- * supporting both Queues (point-to-point) and Topics (publish/subscribe).
+ * @module messaging/producer
+ * @package @aerokit/sdk/messaging
+ * @name Producer
+ * @overview
+ *
+ * The Producer module provides an API for configuring and managing messaging producers, allowing scripts to send messages to JMS-style destinations such as Queues and Topics. It abstracts the complexities of message production, enabling developers to easily integrate message sending capabilities into their applications.
+ *
+ * ### Key Features:
+ * - **Queue and Topic Support**: The module supports both Queue and Topic producers, enabling different messaging patterns (point-to-point and publish/subscribe).
+ * - **Message Sending**: The `send` method allows for sending messages to the configured destinations.
+ *
+ * ### Use Cases:
+ * - **Event Production**: Developers can use this module to produce messages to queues or topics, enabling use cases such as event-driven architectures and microservices communication.
+ * - **Integration with Messaging Systems**: By sending messages to JMS-style destinations, applications can integrate with various messaging systems that support these patterns.
+ *
+ * ### Example Usage:
+ * ```ts
+ * import { Producer } from "@aerokit/sdk/messaging";
+ *
+ * // Create a Queue producer for 'task.queue'
+ * const queueProducer = Producer.queue("task.queue");
+ * queueProducer.send("New task created");
+ *
+ * // Create a Topic producer for 'sensor.data.topic'
+ * const topicProducer = Producer.topic("sensor.data.topic");
+ * topicProducer.send("Temperature reading: 22°C");
+ * ```
  */
 /**
  * The entry point for creating messaging producers.

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

@@ -1,3 +1,40 @@
+/**
+ * @module mongodb/client
+ * @package @aerokit/sdk/mongodb
+ * @name Client
+ * @overview
+ *
+ * The Client module provides a high-level API for connecting to MongoDB databases and performing operations on collections. It abstracts the underlying MongoDB Java driver, allowing developers to interact with MongoDB using familiar JavaScript objects and methods. The module includes classes for managing database connections, accessing collections, and executing queries, making it easier to integrate MongoDB into applications built on the Dirigible platform.
+ *
+ * ### Key Features:
+ * - **MongoDB Connection Management**: The `Client` class allows for connecting to MongoDB using a connection URI and credentials.
+ * - **Database and Collection Access**: The `DB` and `DBCollection` classes provide methods for accessing databases and collections, as well as performing CRUD operations.
+ * - **Querying and Cursor Management**: The `DBCursor` class enables iterating over query results with support for sorting, limiting, and batch processing.
+ *
+ * ### Use Cases:
+ * - **Data Storage and Retrieval**: Developers can use this module to store and retrieve data in MongoDB, leveraging its flexible document model.
+ * - **Integration with MongoDB**: By providing a JavaScript-friendly API, this module facilitates integration with MongoDB in applications running on the Dirigible platform.
+ *
+ * ### Example Usage:
+ * ```ts
+ * import { Client } from "@aerokit/sdk/mongodb";
+ *
+ * // Create a MongoDB client and connect to the database
+ * const client = new Client("mongodb://localhost:27017", "username", "password");
+ * const db = client.getDB("myDatabase");
+ * const collection = db.getCollection("myCollection");
+ *
+ * // Insert a document into the collection
+ * collection.insert({ name: "Alice", age: 30 });
+ *
+ * // Find documents in the collection
+ * const cursor = collection.find({ age: { $gt: 25 } });
+ * while (cursor.hasNext()) {
+ *     const doc = cursor.next();
+ *     console.log(doc);
+ * }
+ * ```
+ */
 /**
  * Define a common type for input to functions that accept either a plain JavaScript object
  * (which will be implicitly converted to DBObject) or an existing DBObject wrapper instance.

package/dist/dts/mongodb/dao.d.ts

@@ -1,3 +1,56 @@
+/**
+ * @module mongodb/dao
+ * @package @aerokit/sdk/mongodb
+ * @name DAO
+ * @overview
+ *
+ * The DAO (Data Access Object) module provides a high-level abstraction for performing CRUD operations on MongoDB collections. It defines a DAO class that encapsulates the logic for interacting with MongoDB, including entity validation, transformation, and database operations. The module also includes a factory function for creating DAO instances based on ORM definitions.
+ *
+ * ### Key Features:
+ * - **Entity Validation**: The DAO class includes methods for validating entities against mandatory properties defined in the ORM.
+ * - **Entity Transformation**: The `createNoSQLEntity` method transforms JavaScript objects into a format suitable for MongoDB storage, applying any necessary transformations defined in the ORM.
+ * - **CRUD Operations**: The DAO class provides methods for inserting, updating, deleting, and querying entities in MongoDB collections.
+ * - **Logging**: The module integrates with the logging system to provide detailed logs of database operations and errors.
+ *
+ * ### Use Cases:
+ * - **Data Management**: Developers can use the DAO module to manage data stored in MongoDB collections, performing CRUD operations with ease.
+ * - **ORM Integration**: By defining ORM specifications, developers can leverage the DAO module to ensure consistent data handling and validation across their application.
+ *
+ * ### Example Usage:
+ * ```ts
+ * import { dao } from "@aerokit/sdk/mongodb";
+ *
+ * // Define an ORM specification for a "users" collection
+ * const userOrm = {
+ *   table: "users",
+ *   primaryKey: { name: "id" },
+ *   mandatoryProperties: [
+ *     { name: "name", type: "VARCHAR" },
+ *     { name: "email", type: "VARCHAR" }
+ *   ],
+ *   optionalProperties: [
+ *     { name: "age", type: "INTEGER" }
+ *   ]
+ * };
+ *
+ * // Create a DAO instance for the "users" collection
+ * const userDao = dao(userOrm);
+ *
+ * // Insert a new user entity
+ * const newUserId = userDao.insert({ name: "Alice", email: "alice@example.com" });
+ *
+ * // Find the inserted user entity
+ * const user = userDao.find(newUserId);
+ * console.log("User found:", user);
+ *
+ * // Update the user entity
+ * user.age = 30;
+ * userDao.update(user);
+ *
+ * // Delete the user entity
+ * userDao.remove(newUserId);
+ * ```
+ */
 export declare class DAO {
     private orm;
     $log: any;

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

@@ -1,2 +1,13 @@
+/**
+ * @module mongodb/index
+ * @package @aerokit/sdk/mongodb
+ * @overview
+ *
+ * This module provides functionalities for MongoDB integration within the Aerokit SDK. It includes classes and methods for connecting to MongoDB databases, performing CRUD operations, and managing MongoDB collections and documents.
+ *
+ * The main components of this module are:
+ * - Client: Represents a client for connecting to a MongoDB database and provides methods to perform operations on the database.
+ * - Dao: Represents a Data Access Object (DAO) for managing MongoDB collections and documents, providing methods for CRUD operations and query execution.
+ */
 export * as client from "./client";
 export * as dao from "./dao";

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

@@ -1,3 +1,30 @@
+/**
+ * @module net/decorators
+ * @package @aerokit/sdk/net
+ * @name Decorators
+ * @overview
+ *
+ * This module provides a set of decorators for defining WebSocket endpoints in a declarative manner. The decorators allow developers to annotate classes to specify that they should act as WebSocket handlers, defining the endpoint and associated metadata. This makes it easier to create and manage WebSocket-based communication within the application.
+ *
+ * ### Key Features:
+ * - **WebSocket Decorator**: The `@Websocket` decorator is used to mark a class as a WebSocket handler, specifying the endpoint and associated metadata.
+ *
+ * ### Use Cases:
+ * - **Real-Time Communication**: These decorators are primarily used for defining components that handle WebSocket connections, enabling real-time communication between clients and the server.
+ * - **Integration with WebSocket Systems**: By using these decorators, developers can easily integrate their applications with WebSocket-based systems and protocols.
+ *
+ * ### Example Usage:
+ * ```ts
+ * import { Websocket } from "@aerokit/sdk/net";
+ *
+ * @Websocket({ name: "MyWebsocket", endpoint: "my-ws" })
+ * class MyWebsocketHandler {
+ *     // Logic to handle WebSocket connections at the 'my-ws' endpoint
+ * }
+ *
+ * // The WebSocket handler will be automatically registered based on the provided metadata.
+ * ```
+ */
 export interface WebsocketOptions {
     name: string;
     endpoint: string;

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

@@ -1,3 +1,16 @@
+/**
+ * @module net/index
+ * @package @aerokit/sdk/net
+ * @overview
+ *
+ * This module provides functionalities for network communication within the Aerokit SDK. It includes classes and methods for handling various network protocols, such as HTTP, SOAP, WebSockets, and more. The module also provides decorators for defining network-related functionalities in a modular architecture.
+ *
+ * The main components of this module are:
+ * - HTTP: Represents an HTTP client for making HTTP requests and handling responses.
+ * - SOAP: Represents a SOAP client for interacting with SOAP-based web services.
+ * - WebSockets: Represents a WebSocket client for establishing and managing WebSocket connections.
+ * - Decorators: Provides decorators for defining network-related functionalities in a declarative manner.
+ */
 export * from "./soap";
 export { SOAP as soap } from "./soap";
 export * from "./websockets";

package/dist/dts/net/soap.d.ts

@@ -1,3 +1,37 @@
+/**
+ * @module net/soap
+ * @package @aerokit/sdk/net
+ * @name SOAP
+ * @overview
+ *
+ * The SOAP module provides a set of classes and methods for working with SOAP messages in JavaScript. It allows developers to create, parse, and send SOAP messages to SOAP endpoints, abstracting the complexities of the underlying Java SOAP API. This module is essential for integrating with SOAP-based web services and enables seamless communication using the SOAP protocol.
+ *
+ * ### Key Features:
+ * - **Message Creation**: The `SOAP` class provides methods to create new SOAP messages, including the ability to add namespaces, headers, and body elements.
+ * - **Message Parsing**: The module allows parsing of incoming SOAP messages from HTTP requests, enabling developers to handle SOAP requests in their applications.
+ * - **SOAP Calls**: The `call` method enables sending SOAP messages to specified endpoints and receiving responses, facilitating communication with SOAP-based web services.
+ *
+ * ### Use Cases:
+ * - **Integrating with SOAP Web Services**: Developers can use this module to interact with existing SOAP web services, sending requests and processing responses in a structured manner.
+ * - **Building SOAP Endpoints**: By parsing incoming SOAP messages, developers can create applications that act as SOAP endpoints, handling requests and providing appropriate responses.
+ *
+ * ### Example Usage:
+ * ```ts
+ * import { SOAP } from "@aerokit/sdk/net";
+ *
+ * // Create a new SOAP message
+ * const message = SOAP.createMessage();
+ * const envelope = message.getPart().getEnvelope();
+ * envelope.addNamespaceDeclaration("ns", "http://example.com/namespace");
+ * const body = envelope.getBody();
+ * const element = body.addChildElement("MyRequest", "ns");
+ * element.addTextNode("Request data");
+ *
+ * // Send the SOAP message to an endpoint
+ * const response = SOAP.call(message, "http://example.com/soap-endpoint");
+ * console.log(response.getText());
+ * ```
+ */
 import { InputStream } from "@aerokit/sdk/io/streams";
 /**
  * Utility class for creating, parsing, and calling SOAP messages.

package/dist/dts/net/websockets.d.ts

@@ -1,3 +1,37 @@
+/**
+ * @module net/websockets
+ * @package @aerokit/sdk/net
+ * @name Websockets
+ * @overview
+ *
+ * The Websockets module provides an API for managing WebSocket clients and handling lifecycle events within the application context. It abstracts the complexities of WebSocket communication, allowing developers to easily create and manage WebSocket connections, send messages, and handle events such as connection openings, messages, errors, and closures.
+ *
+ * ### Key Features:
+ * - **WebSocket Client Management**: Create and manage WebSocket clients with ease, including sending messages and closing connections.
+ * - **Event Handling**: Access event details such as messages and errors within the context of WebSocket event handlers.
+ *
+ * ### Use Cases:
+ * - **Real-Time Communication**: This module is ideal for applications that require real-time communication between clients and the server using WebSockets.
+ * - **Integration with WebSocket Systems**: By providing a high-level API for WebSocket management, developers can easily integrate their applications with WebSocket-based systems and protocols.
+ *
+ * ### Example Usage:
+ * ```ts
+ * import { Websockets } from "@aerokit/sdk/net";
+ *
+ * // Create a new WebSocket client connection
+ * const client = Websockets.createWebsocket("ws://example.com/socket", "myHandler");
+ * client.send("Hello, WebSocket!");
+ *
+ * // Access event details in an 'onmessage' handler
+ * if (Websockets.isOnMessage()) {
+ *     const message = Websockets.getMessage();
+ *     console.log("Received message:", message);
+ * }
+ *
+ * // Close the WebSocket connection when done
+ * client.close();
+ * ```
+ */
 /**
  * @class Websockets
  * @description Static utility class for accessing and managing WebSocket functionality.

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

@@ -1,2 +1,12 @@
+/**
+ * @module pdf/index
+ * @package @aerokit/sdk/pdf
+ * @overview
+ *
+ * This module provides functionalities for PDF generation and manipulation within the Aerokit SDK. It includes classes and methods for creating PDF documents, adding content to PDFs, and managing PDF configurations.
+ *
+ * The main components of this module are:
+ * - PDF: Represents a PDF document and provides methods to create and manipulate PDF content.
+ */
 export * from "./pdf";
 export { PDF as pdf } from "./pdf";

package/dist/dts/pdf/pdf.d.ts

@@ -1,3 +1,42 @@
+/**
+ * @module pdf/pdf
+ * @package @aerokit/sdk/pdf
+ * @name PDF
+ * @overview
+ *
+ * The PDF module provides utilities for generating PDF documents using predefined templates and structured data. It abstracts the complexities of PDF generation, allowing developers to create well-formatted PDF documents with ease. The module includes functionality for generating tables in PDFs based on a standard template, as well as the ability to use custom templates for more advanced use cases.
+ *
+ * ### Key Features:
+ * - **Table Generation**: The `generateTable` method allows for creating PDF documents containing styled tables based on a standard template, using structured data input.
+ * - **Custom Template Support**: The `generate` method enables the use of custom templates for PDF generation, providing flexibility for various document layouts and styles.
+ * - **Configurable Layout**: Optional configuration parameters allow for customizing page size and alignment of table content within the generated PDF.
+ *
+ * ### Use Cases:
+ * - **Reporting**: Generate PDF reports with tabular data, such as sales reports, inventory lists, or any structured data presentation.
+ * - **Document Generation**: Create custom PDF documents for invoices, certificates, or any scenario where a specific layout is required.
+ *
+ * ### Example Usage:
+ * ```ts
+ * import { PDF } from "@aerokit/sdk/pdf";
+ *
+ * const tableData = {
+ *   title: "Sales Report",
+ *   description: "Monthly sales data for Q1",
+ *   columns: [
+ *     { name: "Product", key: "product" },
+ *     { name: "Quantity", key: "quantity" },
+ *     { name: "Price", key: "price" }
+ *   ],
+ *   rows: [
+ *     { product: "Widget A", quantity: 100, price: "$10" },
+ *     { product: "Widget B", quantity: 50, price: "$20" }
+ *   ]
+ * };
+ *
+ * const pdfContent = PDF.generateTable(tableData, { size: "a4", alignColumns: true });
+ * // pdfContent is a byte array representing the generated PDF document
+ * ```
+ */
 /**
  * Interface defining the structured data required to generate a table in a PDF.
  */
@@ -37,7 +76,7 @@ export declare class PDF {
      *
      * @param {PDFTableData} data The structured data to populate the table.
      * @param {PDFTableConfig} [config] Optional configuration for page size and alignment.
-     * @returns {any[]} The generated PDF content as a byte array (Array<number>).
+     * @returns {any[]} The generated PDF content as a byte array (number[]).
      */
     static generateTable(data: PDFTableData, config?: PDFTableConfig): any[];
     /**
@@ -45,7 +84,7 @@ export declare class PDF {
      *
      * @param {string} templatePath The path to the custom template file (e.g., in the Registry).
      * @param {PDFTableData} data The data to be injected into the template.
-     * @returns {any[]} The generated PDF content as a byte array (Array<number>).
+     * @returns {any[]} The generated PDF content as a byte array (number[]).
      */
     static generate(templatePath: string, data: PDFTableData): any[];
     /**

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

@@ -1,3 +1,29 @@
+/**
+ * @module platform/command
+ * @package @aerokit/sdk/platform
+ * @name Command
+ * @overview
+ *
+ * The Command module provides a static utility class for executing system commands through the platform's CommandEngine. It allows developers to run shell commands with configurable options, including working directory and environment variable management. The module abstracts the complexities of process execution, providing a simple interface for integrating command execution into applications.
+ *
+ * ### Key Features:
+ * - **Command Execution**: The `execute` method allows for running system commands with specified options and environment variable configurations.
+ * - **Structured Output**: The method returns a structured output containing the exit code, standard output, and error output of the executed command.
+ *
+ * ### Use Cases:
+ * - **System Integration**: This module is ideal for applications that need to interact with the underlying operating system or execute external processes as part of their functionality.
+ * - **Automation and Scripting**: Developers can use this module to automate tasks by executing shell commands from within their applications.
+ *
+ * ### Example Usage:
+ * ```ts
+ * import { Command } from "@aerokit/sdk/platform";
+ *
+ * const result = Command.execute("ls -l", { workingDirectory: "/home/user" }, { "ENV_VAR": "value" }, ["OLD_ENV_VAR"]);
+ * console.log("Exit Code:", result.exitCode);
+ * console.log("Standard Output:", result.standardOutput);
+ * console.log("Error Output:", result.errorOutput);
+ * ```
+ */
 /**
  * Defines the configuration options for the command execution process.
  */

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

@@ -1,3 +1,41 @@
+/**
+ * @module platform/engines
+ * @package @aerokit/sdk/platform
+ * @name Engines
+ * @overview
+ *
+ * The Engines module provides a class for interacting with the platform's execution engines, such as JavaScript or Groovy. It allows developers to execute scripts or processes within the context of a project, passing parameters and optionally enabling debug mode. The module abstracts the complexities of engine execution, providing a simple interface for running code in various supported languages.
+ *
+ * ### Key Features:
+ * - **Engine Type Management**: Retrieve the list of available engine types supported by the platform.
+ * - **Script Execution**: Execute project scripts or processes using a specified engine type, with support for passing parameters and enabling debug mode.
+ *
+ * ### Use Cases:
+ * - **Multi-Language Support**: This module is ideal for applications that need to execute code in different languages supported by the platform, such as JavaScript or Groovy.
+ * - **Project-Based Execution**: Developers can use this module to run scripts within the context of a project, allowing for better organization and management of code.
+ *
+ * ### Example Usage:
+ * ```ts
+ * import { Engine } from "@aerokit/sdk/platform";
+ *
+ * // Get available engine types
+ * const engineTypes = Engine.getTypes();
+ * console.log("Available Engines:", engineTypes);
+ *
+ * // Create an instance of the Engine class for JavaScript
+ * const jsEngine = new Engine("javascript");
+ *
+ * // Execute a script within a project context
+ * const result = jsEngine.execute(
+ *     "MyProject",
+ *     "lib/script.js",
+ *     "",
+ *     { param1: "value1", param2: 42 },
+ *     false
+ * );
+ * console.log("Execution Result:", result);
+ * ```
+ */
 /**
  * Interface defining the execution parameters expected by the Engine class.
  */

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

@@ -1,3 +1,22 @@
+/**
+ * @module platform/index
+ * @package @aerokit/sdk/platform
+ * @overview
+ *
+ * This module provides platform-specific utilities and abstractions for the Aerokit SDK.
+ * It exposes command execution, engine management, lifecycle control, OS information,
+ * problem reporting, registry/repository handling, and workspace operations.
+ *
+ * The main components of this module are:
+ * - Command: Execution of platform commands and process interaction.
+ * - Engine: Management of pluggable execution engines.
+ * - Lifecycle: Application/service lifecycle helpers.
+ * - OS: Operating system information and utilities.
+ * - Problems: Unified problem reporting and diagnostics collection.
+ * - Registry: Package/extension registry interfaces.
+ * - Repository: Repository layout and access abstractions.
+ * - Workspace: Workspace path and file handling helpers.
+ */
 export * from "./command";
 export { Command as command } from "./command";
 export * from "./engines";

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

@@ -1,3 +1,32 @@
+/**
+ * @module platform/lifecycle
+ * @package @aerokit/sdk/platform
+ * @name Lifecycle
+ * @overview
+ *
+ * The Lifecycle module provides a static utility class for managing the lifecycle of projects on the platform, including publishing and unpublishing projects. It abstracts the complexities of project deployment, allowing developers to easily control the availability of their projects through simple method calls.
+ *
+ * ### Key Features:
+ * - **Project Publishing**: The `publish` method allows developers to publish a specific project or all projects within a workspace for a given user.
+ * - **Project Unpublishing**: The `unpublish` method enables developers to unpublish a specific project or all currently deployed projects, making them unavailable for use.
+ *
+ * ### Use Cases:
+ * - **Deployment Management**: This module is ideal for applications that need to manage the deployment status of projects on the platform, allowing for dynamic control over which projects are available at any given time.
+ * - **Automated Deployment**: Developers can use this module to automate the publishing and unpublishing of projects as part of their development and deployment workflows.
+ *
+ * ### Example Usage:
+ * ```ts
+ * import { Lifecycle } from "@aerokit/sdk/platform";
+ *
+ * // Publish a specific project
+ * const publishResult = Lifecycle.publish("john_doe", "my_workspace", "my_project");
+ * console.log("Publish Result:", publishResult);
+ *
+ * // Unpublish all currently deployed projects
+ * const unpublishResult = Lifecycle.unpublish();
+ * console.log("Unpublish Result:", unpublishResult);
+ * ```
+ */
 /**
  * @class Lifecycle
  * @description Static utility class to publish and unpublish projects on the platform.

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

@@ -1,3 +1,33 @@
+/**
+ * @module platform/os
+ * @package @aerokit/sdk/platform
+ * @name OS
+ * @overview
+ *
+ * The OS module provides a static utility class for retrieving operating system information and checking OS types. It leverages the platform's access to Java's SystemUtils for system properties, allowing developers to easily determine the operating system their application is running on. This can be particularly useful for applications that need to perform OS-specific operations or optimizations.
+ *
+ * ### Key Features:
+ * - **OS Name Retrieval**: Access the full name of the operating system through a static constant.
+ * - **OS Type Checking**: Static methods to check if the operating system is a variant of Windows or Unix (including Linux, macOS, and BSD).
+ *
+ * ### Use Cases:
+ * - **Cross-Platform Compatibility**: This module is ideal for applications that need to ensure compatibility across different operating systems by conditionally executing code based on the OS type.
+ * - **System Information**: Developers can use this module to gather information about the operating system for logging, debugging, or analytics purposes.
+ *
+ * ### Example Usage:
+ * ```ts
+ * import { OS } from "@aerokit/sdk/platform";
+ *
+ * console.log("Operating System:", OS.OS_NAME);
+ * if (OS.isWindows()) {
+ *     console.log("Running on Windows");
+ * } else if (OS.isUnix()) {
+ *     console.log("Running on a Unix-like OS");
+ * } else {
+ *     console.log("Running on an unknown OS");
+ * }
+ * ```
+ */
 /**
  * @class OS
  * @description Provides static methods and constants related to the operating system

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

@@ -1,3 +1,39 @@
+/**
+ * @module platform/problems
+ * @package @aerokit/sdk/platform
+ * @name Problems
+ * @overview
+ *
+ * The Problems module provides a static utility class for managing system problems and issues through the platform's ProblemsFacade. It allows developers to save new problems, fetch existing ones, update their status, and delete them as needed. This module abstracts the complexities of problem management, providing a simple interface for handling issues that arise during development or runtime.
+ *
+ * ### Key Features:
+ * - **Problem Recording**: Save detailed information about problems, including location, type, cause, and expected outcomes.
+ * - **Problem Retrieval**: Fetch individual problems by ID or retrieve all problems with optional filtering and batching.
+ * - **Status Management**: Update the status of problems to indicate whether they are active, solved, or ignored.
+ * - **Problem Deletion**: Remove specific problems or clear all problems based on their status.
+ *
+ * ### Use Cases:
+ * - **Issue Tracking**: This module is ideal for applications that need to track and manage issues that occur during development or runtime, providing a structured way to log and resolve problems.
+ * - **Automated Problem Handling**: Developers can use this module to automate the handling of known issues by updating their status or deleting them as part of maintenance routines.
+ *
+ * ### Example Usage:
+ * ```ts
+ * import { Problems } from "@aerokit/sdk/platform";
+ *
+ * // Save a new problem
+ * Problems.save("/path/to/file.js", "Syntax Error", "10", "15", "Unexpected token", "Expected ';'", "Syntax", "JavaScript", "const a = ;", "file.js");
+ *
+ * // Fetch all problems
+ * const allProblems = Problems.fetchAllProblems();
+ * console.log("All Problems:", allProblems);
+ *
+ * // Update the status of a problem
+ * Problems.updateStatus(1, Problems.SOLVED);
+ *
+ * // Delete a specific problem
+ * Problems.deleteProblem(1);
+ * ```
+ */
 /**
  * @interface Problem
  * @description Represents a single problem or issue recorded in the system.

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

@@ -1,3 +1,42 @@
+/**
+ * @module platform/registry
+ * @package @aerokit/sdk/platform
+ * @name Registry
+ * @overview
+ *
+ * The Registry module provides a set of utilities and data structures for interacting with the platform's Registry/Repository, which manages files and directories (Artefacts and Collections). It allows developers to retrieve content and metadata from the registry using simple JavaScript interfaces, abstracting the underlying complexities of the Java-based registry system. The module includes classes for representing both individual resources (Artefacts) and collections of resources (Directories), as well as a class for accessing detailed metadata about these resources.
+ *
+ * ### Key Features:
+ * - **Content Retrieval**: Methods to get the content of registry resources as byte arrays or text.
+ * - **Resource Navigation**: Classes to represent and navigate through directories and artefacts in the registry.
+ * - **Metadata Access**: Ability to access detailed information about resources, such as creation date, size, and permissions.
+ *
+ * ### Use Cases:
+ * - **File Management**: This module is ideal for applications that need to manage files and directories within the platform's registry, allowing for easy access and manipulation of stored resources.
+ * - **Metadata Analysis**: Developers can use this module to analyze resource metadata for auditing, reporting, or conditional logic based on resource attributes.
+ *
+ * ### Example Usage:
+ * ```ts
+ * import { Registry } from "@aerokit/sdk/platform";
+ *
+ * // Get the root directory of the public registry
+ * const rootDirectory = Registry.getRoot();
+ * console.log("Root Directory Path:", rootDirectory.getPath());
+ *
+ * // List all artefacts in the root directory
+ * const artefacts = rootDirectory.getArtefactsNames();
+ * console.log("Artefacts in Root Directory:", artefacts);
+ *
+ * // Get a specific artefact and its content
+ * const myFile = rootDirectory.getArtefact("myFile.txt");
+ * if (myFile.exists()) {
+ *     const content = myFile.getText();
+ *     console.log("Content of myFile.txt:", content);
+ * } else {
+ *     console.log("myFile.txt does not exist in the registry.");
+ * }
+ * ```
+ */
 /**
  * @class Registry
  * @description Static utility class providing high-level access to the RegistryFacade for

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

@@ -1,3 +1,43 @@
+/**
+ * @module platform/repository
+ * @package @aerokit/sdk/platform
+ * @name Repository
+ * @overview
+ *
+ * The Repository module provides a wrapper for the platform's RepositoryFacade, allowing developers to manage files (Resources) and folders (Collections) within the repository. It offers high-level methods for creating, retrieving, updating, and deleting resources and collections by their paths, as well as handling content in both string and byte array formats. The module abstracts the complexities of repository interactions, providing a simple interface for file management operations.
+ *
+ * ### Key Features:
+ * - **Resource Management**: Create, retrieve, update, and delete resources (files) with support for both text and binary content.
+ * - **Collection Management**: Create, retrieve, and delete collections (folders), as well as manage their contents.
+ * - **Metadata Access**: Retrieve detailed information about resources and collections, including permissions, size, and timestamps.
+ * - **Search Functionality**: Search for resources using glob patterns to find files matching specific criteria.
+ *
+ * ### Use Cases:
+ * - **File Storage**: This module is ideal for applications that need to store and manage files within the platform's repository, such as configuration files, data exports, or user-generated content.
+ * - **Content Management**: Developers can use this module to organize files into collections (folders) and manage their lifecycle effectively.
+ *
+ * ### Example Usage:
+ * ```ts
+ * import { Repository } from "@aerokit/sdk/platform";
+ *
+ * // Create a new resource with text content
+ * const resource = Repository.createResource("/myproject/data.txt", "Hello, Repository!", "text/plain");
+ * console.log("Resource created at path:", resource.getPath());
+ *
+ * // Update the resource content with binary data
+ * const binaryContent = [0x48, 0x65, 0x6C, 0x6C, 0x6F]; // "Hello" in bytes
+ * resource.setContent(binaryContent);
+ * console.log("Resource content updated with binary data.");
+ *
+ * // Create a new collection (folder)
+ * const collection = Repository.createCollection("/myproject/documents");
+ * console.log("Collection created at path:", collection.getPath());
+ *
+ * // Move the resource into the new collection
+ * resource.moveTo("/myproject/documents/data.txt");
+ * console.log("Resource moved to new path:", resource.getPath());
+ * ```
+ */
 /**
  * @class Repository
  * @description Static utility class providing high-level methods for interacting with the