@aerokit/sdk 12.80.0 → 12.82.0

package/dist/dts/http/client-async.d.ts

@@ -1,6 +1,34 @@
 /**
- * Provides a JavaScript/TypeScript wrapper (Facade) for making asynchronous HTTP requests.
+ * @module http/client-async
+ * @package @aerokit/sdk/http
+ * @name HttpAsyncClient
+ * @overview
  *
+ * The HttpAsyncClient class provides a JavaScript/TypeScript wrapper (Facade) for making asynchronous HTTP requests using the underlying Java HTTP client. It allows developers to perform non-blocking HTTP operations by defining success, error, and cancel callbacks as strings of executable JavaScript code. The class supports all standard HTTP methods (GET, POST, PUT, PATCH, DELETE, HEAD, TRACE) and accepts a comprehensive set of request options that mirror the capabilities of the Java client.
+ *
+ * ### Key Features:
+ * - **Asynchronous Execution**: All HTTP methods return immediately, with callbacks executed upon completion.
+ * - **Comprehensive Request Options**: Supports a wide range of configuration options for fine-tuning HTTP requests.
+ * - **Callback Flexibility**: Callbacks are defined as strings of JavaScript code, allowing for dynamic execution in the JVM environment.
+ *
+ * ### Use Cases:
+ * - **Non-blocking API Calls**: Ideal for scenarios where you want to perform HTTP requests without blocking the main execution thread.
+ * - **Complex Request Configurations**: Suitable for advanced use cases that require detailed request configurations and handling.
+ *
+ * ### Example Usage:
+ * ```ts
+ * import { HttpAsyncClient } from "@aerokit/sdk/http";
+ *
+ * const client = HttpAsyncClient.getInstance();
+ *
+ * client.getAsync("https://api.example.com/data", {
+ *   success: "function(response) { console.log('Success:', response); }",
+ *   error: "function(error) { console.error('Error:', error); }"
+ * }, {
+ *   headers: [{ name: 'Authorization', value: 'Bearer token' }],
+ *   params: [{ name: 'query', value: 'search term' }]
+ * });
+ * ```
  */
 /** Defines a single HTTP header, used for both request and response. */
 export interface HttpClientHeader {

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

@@ -1,6 +1,34 @@
 /**
- * Provides a JavaScript/TypeScript wrapper (Facade) for making synchronous HTTP requests.
+ * @module http/client
+ * @package @aerokit/sdk/http
+ * @name HttpClient
+ * @overview
  *
+ * The HttpClient class provides a JavaScript/TypeScript wrapper (Facade) for making synchronous HTTP requests. It abstracts the underlying Java implementation and exposes a simple API for performing HTTP operations such as GET, POST, PUT, PATCH, DELETE, HEAD, and TRACE. The class allows developers to configure various aspects of the HTTP request, including headers, query parameters, request body content, timeouts, and more.
+ *
+ * ### Key Features:
+ * - **Synchronous Requests**: All methods execute synchronously, blocking until a response is received.
+ * - **Comprehensive Configuration**: Supports a wide range of options for customizing the HTTP request.
+ * - **Structured Response**: Returns a structured response object containing status, headers, and body content.
+ *
+ * ### Use Cases:
+ * - **API Consumption**: Ideal for scenarios where you need to consume external APIs and require a simple interface for making HTTP requests.
+ * - **Testing and Scripting**: Useful in testing scenarios or scripts where synchronous execution is acceptable and simplicity is desired.
+ *
+ * ### Example Usage:
+ * ```ts
+ * import { HttpClient } from "@aerokit/sdk/http";
+ *
+ * const response = HttpClient.get("https://api.example.com/data", {
+ *   headers: [{ name: "Authorization", value: "Bearer token" }],
+ *   params: [{ name: "query", value: "search term" }],
+ *   timeout: 5000
+ * });
+ *
+ * console.log(response.statusCode); // e.g., 200
+ * console.log(response.text); // Response body as text
+ * console.log(response.headers); // Array of response headers
+ * ```
  */
 /**
  * Defines a single HTTP header, used for both request and response.

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

@@ -1,3 +1,41 @@
+/**
+ * @module http/decorators
+ * @package @aerokit/sdk/http
+ * @name Decorators
+ * @overview
+ *
+ * This module provides a set of decorators for defining HTTP controllers and their associated routes in a declarative manner. The decorators allow developers to annotate classes and methods to specify how they should handle HTTP requests, making it easier to create RESTful APIs with clear and concise code.
+ *
+ * ### Key Features:
+ * - **Controller Decorator**: The `@Controller` decorator is used to mark a class as an HTTP controller, which can contain multiple route handlers.
+ * - **HTTP Method Decorators**: Decorators such as `@Get`, `@Post`, `@Put`, `@Patch`, `@Delete`, `@Head`, and `@Options` are used to define the HTTP method and path for each route handler method within the controller.
+ * - **Documentation Decorator**: The `@Documentation` decorator allows developers to add documentation to their controllers or methods, which can be useful for generating API documentation.
+ *
+ * ### Use Cases:
+ * - **API Development**: These decorators are primarily used in the development of RESTful APIs, allowing developers to define their endpoints and handlers in a clear and structured way.
+ * - **Code Organization**: By using decorators, developers can keep their code organized and maintainable, separating the routing logic from the business logic within their controllers.
+ *
+ * ### Example Usage:
+ * ```ts
+ * import { Controller, Get, Post, Documentation } from "@aerokit/sdk/http";
+ *
+ * @Controller
+ * @Documentation("UserController handles user-related operations.")
+ * class UserController {
+ *     @Get("/users/{id}")
+ *     @Documentation("Retrieves a user by ID.")
+ *     getUserById(id: string) {
+ *         // Logic to retrieve user by ID
+ *     }
+ *
+ *     @Post("/users")
+ *     @Documentation("Creates a new user.")
+ *     createUser(userData: any) {
+ *         // Logic to create a new user
+ *     }
+ * }
+ * ```
+ */
 export declare function Controller(ctr: {
     new (): any;
 }, _context?: ClassDecoratorContext): void;

package/dist/dts/http/errors/ForbiddenError.d.ts

@@ -1,6 +1,10 @@
 /**
- * Custom error class representing a 403 Forbidden status, indicating
- * that the user does not have permission to access the requested resource.
+ * @module http/errors/ForbiddenError
+ * @package @aerokit/sdk/http
+ * @name ForbiddenError
+ * @overview
+ *
+ * This module defines the `ForbiddenError` class, a custom error type that represents a 403 Forbidden HTTP status. This error is typically thrown when a user attempts to access a resource or perform an action for which they do not have the necessary permissions. The `ForbiddenError` class extends the built-in `Error` class and provides a default error message, while also allowing for custom messages to be specified when instantiated.
  */
 export declare class ForbiddenError extends Error {
     /**

package/dist/dts/http/errors/ValidationError.d.ts

@@ -1,6 +1,10 @@
 /**
- * Custom error class used for representing failures due to invalid input
- * or data that violates domain-specific validation rules.
+ * @module http/errors/ValidationError
+ * @package @aerokit/sdk/http
+ * @name ValidationError
+ * @overview
+ *
+ * This module defines the `ValidationError` class, a custom error type that represents failures due to invalid input or data that violates domain-specific validation rules. The `ValidationError` class extends the built-in `Error` class and provides a default error message, while also allowing for custom messages to be specified when instantiated. This error is typically thrown when user input fails to meet certain criteria or when data does not conform to expected formats, helping developers to handle validation issues in a consistent manner across their applications.
  */
 export declare class ValidationError extends Error {
     /**

package/dist/dts/http/errors.d.ts

@@ -1,2 +1,16 @@
+/**
+ * @module http/errors
+ * @package @aerokit/sdk/http
+ * @name Errors
+ * @overview
+ *
+ * This module provides HTTP-specific error classes for the Aerokit SDK.
+ * It includes custom error types for handling common HTTP response scenarios
+ * like forbidden access and validation failures.
+ *
+ * The main components of this module are:
+ * - ForbiddenError: Represents a 403 Forbidden HTTP error.
+ * - ValidationError: Represents validation-related errors in HTTP requests.
+ */
 export { ForbiddenError } from "./errors/ForbiddenError";
 export { ValidationError } from "./errors/ValidationError";

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

@@ -1,3 +1,21 @@
+/**
+ * @module http/index
+ * @package @aerokit/sdk/http
+ * @overview
+ *
+ * This module provides functionalities for making HTTP requests within the Aerokit SDK. It includes classes and methods for sending HTTP requests, handling responses, managing sessions, and configuring HTTP clients.
+ *
+ * The main components of this module are:
+ * - HttpClient: Represents an HTTP client for sending requests and receiving responses.
+ * - Request: Represents an HTTP request with methods for setting headers, body, and other parameters.
+ * - Response: Represents an HTTP response with methods for accessing status, headers, and body content.
+ * - Session: Provides session management for maintaining state across multiple HTTP requests.
+ * - Upload: Provides functionalities for handling file uploads in HTTP requests.
+ * - Errors: Contains classes for handling various HTTP-related errors and exceptions.
+ * - Utils: Provides utility functions for working with HTTP requests and responses.
+ * - AsyncClient: Represents an asynchronous HTTP client for sending requests and receiving responses in a non-blocking manner.
+ * - Decorators: Provides decorators for defining HTTP endpoints and their properties in a declarative manner.
+ */
 export * as asyncClient from "./client-async";
 export * from "./client";
 export { HttpClient as client } from "./client";

package/dist/dts/http/request.d.ts

@@ -1,8 +1,35 @@
 /**
- * The Request API under the HTTP module is responsible for
- * managing standard HTTP request parameters, headers, cookies,
- * and request metadata provided to server-side scripting services.
+ * @module http/request
+ * @package @aerokit/sdk/http
+ * @name Request
+ * @overview
  *
+ * The Request class provides a comprehensive API for accessing HTTP request data and metadata within server-side scripting services. It abstracts the underlying HTTP request details and exposes a rich set of static methods to retrieve information such as headers, query parameters, cookies, authentication details, and the request body in various formats (text, JSON, binary).
+ *
+ * ### Key Features:
+ * - **Comprehensive Request Data Access**: Provides methods to access all aspects of the HTTP request, including headers, parameters, cookies, and body content.
+ * - **Convenient Body Parsing**: Offers built-in methods to retrieve the request body as text or parse it as JSON, simplifying common use cases.
+ * - **Security Information**: Allows checking user roles and authentication types directly from the request context.
+ *
+ * ### Use Cases:
+ * - **API Development**: Used in RESTful API endpoints to access incoming request data and make decisions based on headers, parameters, or authentication status.
+ * - **Middleware Logic**: Can be used in middleware functions to inspect requests before they reach the main handler logic.
+ *
+ * ### Example Usage:
+ * ```ts
+ * import { Request } from "@aerokit/sdk/http";
+ *
+ * function handleRequest() {
+ *     if (Request.isValid()) {
+ *         const method = Request.getMethod();
+ *         const user = Request.getRemoteUser();
+ *         const body = Request.json();
+ *         // Process the request based on method, user, and body content
+ *     } else {
+ *         // Handle invalid request context
+ *     }
+ * }
+ * ```
  */
 import { InputStream } from "@aerokit/sdk/io/streams";
 import { Cookie } from "./response";

package/dist/dts/http/response.d.ts

@@ -1,7 +1,44 @@
 /**
- * Provides a static façade (`Response` class) for managing the HTTP response.
- * This class wraps a native Java HTTP response object, offering methods for setting
- * status codes, headers, cookies, and writing content (text, JSON, or binary).
+ * @module http/response
+ * @package @aerokit/sdk/http
+ * @name Response
+ * @overview
+ *
+ * The `Response` class provides a static façade for managing the HTTP response in a server context. It wraps a native Java HTTP response object, offering methods for setting status codes, headers, cookies, and writing content (text, JSON, or binary) to the response body. The class also includes constants for standard HTTP status codes and a mapping of these codes to their reason phrases as defined in RFC 7231.
+ *
+ * ### Key Features:
+ * - **HTTP Status Codes**: Provides constants for all standard HTTP status codes, making it easier to set response statuses without memorizing numeric values.
+ * - **Content Writing**: Methods for writing text, JSON, or binary data to the response body, with proper handling of character encoding.
+ * - **Header Management**: Methods for setting and adding headers, as well as checking for existing headers.
+ * - **Cookie Management**: A method for adding cookies to the response, with support for cookie attributes.
+ * - **Response Control**: Methods for flushing and closing the response output stream, sending redirects and errors, and resetting the response.
+ *
+ * ### Use Cases:
+ * - **API Development**: Used in HTTP controllers to construct responses to client requests in a structured and consistent manner.
+ * - **Web Application Development**: Useful in any server-side code that needs to send HTTP responses, such as rendering HTML pages or serving files.
+ *
+ * ### Example Usage:
+ * ```ts
+ * import { Response } from "@aerokit/sdk/http";
+ *
+ * // Sending a JSON response with a 200 OK status
+ * Response.setStatus(Response.OK);
+ * Response.json({ message: "Hello, world!" });
+ *
+ * // Sending a plain text response with a custom header
+ * Response.setHeader("X-Custom-Header", "CustomValue");
+ * Response.print("This is a plain text response.");
+ *
+ * // Adding a cookie to the response
+ * Response.addCookie({
+ *     name: "sessionId",
+ *     value: "abc123",
+ *     attributes: {
+ *         maxAge: "3600",
+ *         path: "/"
+ *     }
+ * });
+ * ```
  */
 import { OutputStream } from "@aerokit/sdk/io/streams";
 /**

package/dist/dts/http/rs/resource-mappings.d.ts

@@ -1,3 +1,33 @@
+/**
+ * @module http/rs/mappings
+ * @package @aerokit/sdk/http
+ * @name ResourceMappings
+ * @overview
+ *
+ * The ResourceMappings class is a core component of the HTTP controller module, responsible for managing the mappings between URL path templates and their corresponding resource handler specifications. It serves as the configuration store for the HttpController, allowing developers to define and manage their API resources in a structured manner.
+ *
+ * ### Key Features:
+ * - **Resource Management**: Allows defining resources with specific URL path templates and their associated handlers.
+ *
+ * ### Use Cases:
+ * - **API Configuration**: Developers can use ResourceMappings to configure their API endpoints, specifying the paths and the logic that should handle requests to those paths.
+ *
+ * ### Example Usage:
+ * ```ts
+ * import { ResourceMappings } from "@aerokit/sdk/http";
+ *
+ * const resourceMappings = new ResourceMappings({
+ *  "users/{id}": {
+ *   get: (req, res) => { ... },
+ *   post: (req, res) => { ... }
+ * },
+ * "products/{id}": {
+ *  get: (req, res) => { ... },
+ *  post: (req, res) => { ... }
+ * }
+ * });
+ * ```
+ */
 import { Resource } from "./resource";
 /**
  * The ResourceMappings class abstracts the mappings between resource URL path templates

package/dist/dts/http/rs.d.ts

@@ -1,3 +1,41 @@
+/**
+ * @module http/rs
+ * @package @aerokit/sdk/http
+ * @name RestService
+ * @overview
+ *
+ * This module provides REST service utilities for the Aerokit SDK.
+ * It includes decorators and classes for building HTTP controllers,
+ * defining resource methods, and managing RESTful endpoints.
+ *
+ * The main components of this module are:
+ * - service: Service decorator for HTTP services.
+ * - HttpController: Base class for HTTP controllers.
+ * - ResourceMethod: Enum or decorator for HTTP methods (GET, POST, etc.).
+ * - ResourceMappings: Utilities for mapping resources to endpoints.
+ * - Resource: Decorator for defining REST resources.
+ *
+ * ### Example Usage:
+ * ```ts
+ * import { Controller, Get, Post, Documentation } from "@aerokit/sdk/http";
+ *
+ * @Controller
+ * @Documentation("UserController handles user-related operations.")
+ * class UserController {
+ *     @Get("/users/{id}")
+ *     @Documentation("Retrieves a user by ID.")
+ *     getUserById(id: string) {
+ *         // Logic to retrieve user by ID
+ *     }
+ *
+ *     @Post("/users")
+ *     @Documentation("Creates a new user.")
+ *     createUser(userData: any) {
+ *         // Logic to create a new user
+ *     }
+ * }
+ * ```
+ */
 export { service, HttpController } from "./rs/resource-http-controller";
 export { ResourceMethod } from "./rs/resource-method";
 export { ResourceMappings } from "./rs/resource-mappings";

package/dist/dts/http/session.d.ts

@@ -1,7 +1,38 @@
 /**
- * Provides a static façade (`Session` class) for accessing and manipulating
- * the HTTP session associated with the current request. This module is often used
- * to store user-specific data during their interaction with the application.
+ * @module http/session
+ * @package @aerokit/sdk/http
+ * @name Session
+ * @overview
+ *
+ * The Session module provides a static façade (`Session` class) for accessing and manipulating the HTTP session associated with the current request. This module is often used to store user-specific data during their interaction with the application, such as authentication status, user preferences, or temporary data that should persist across multiple requests within the same session.
+ *
+ * ### Key Features:
+ * - **Session Management**: Provides methods to check session validity, retrieve and set attributes, manage session lifetime, and invalidate sessions.
+ * - **Attribute Handling**: Allows storing and retrieving named attributes in the session, which can be used to maintain user state across requests.
+ * - **Session Metadata**: Offers access to session metadata such as creation time, last accessed time, and session ID.
+ *
+ * ### Use Cases:
+ * - **User Authentication**: Storing user authentication status or tokens in the session to maintain login state across requests.
+ * - **User Preferences**: Keeping user-specific settings or preferences that should persist during the session.
+ * - **Temporary Data Storage**: Holding temporary data that is relevant for the duration of the user's interaction with the application but does not need to be stored permanently.
+ *
+ * ### Example Usage:
+ * ```ts
+ * import { Session } from "@aerokit/sdk/http";
+ *
+ * // Check if the session is valid
+ * if (Session.isValid()) {
+ *     // Set a user attribute in the session
+ *     Session.setAttribute("userId", "12345");
+ *     // Retrieve the user attribute from the session
+ *     const userId = Session.getAttribute("userId");
+ *     // Get session metadata
+ *     const creationTime = Session.getCreationTime();
+ *     const lastAccessedTime = Session.getLastAccessedTime();
+ *     // Invalidate the session when done
+ *     Session.invalidate();
+ * }
+ * ```
  */
 /**
  * The static Session class provides methods to interact with the current user session

package/dist/dts/http/upload.d.ts

@@ -1,6 +1,31 @@
 /**
- * Provides a static façade (`Upload` class) for checking and parsing
- * multipart/form-data HTTP requests, typically used for file uploads.
+ * @module http/upload
+ * @package @aerokit/sdk/http
+ * @name Upload
+ * @overview
+ *
+ * The Upload module provides a static façade (`Upload` class) for checking and parsing multipart/form-data HTTP requests, which are commonly used for file uploads. This module allows developers to easily determine if an incoming request contains multipart content and to parse that content into manageable file items, abstracting away the complexities of handling multipart requests directly.
+ *
+ * ### Key Features:
+ * - **Multipart Detection**: The `isMultipartContent` method allows developers to quickly check if the incoming request is of the multipart/form-data type.
+ * - **Request Parsing**: The `parseRequest` method processes the multipart content and provides a structured representation of the uploaded files and form fields through the `FileItems` class.
+ *
+ * ### Use Cases:
+ * - **File Upload Handling**: This module is essential for handling file uploads in web applications, allowing developers to access uploaded files and their metadata easily.
+ * - **Form Data Processing**: In addition to file uploads, this module can also handle regular form fields that are part of a multipart request, making it versatile for various form processing scenarios.
+ *
+ * ### Example Usage:
+ * ```ts
+ * import { Upload } from "@aerokit/sdk/http";
+ *
+ * if (Upload.isMultipartContent()) {
+ *     const fileItems = Upload.parseRequest();
+ *     for (let i = 0; i < fileItems.size(); i++) {
+ *         const fileItem = fileItems.get(i);
+ *         console.log(`Uploaded file: ${fileItem.getName()}, size: ${fileItem.getSize()} bytes`);
+ *     }
+ * }
+ * ```
  */
 import { InputStream } from "@aerokit/sdk/io/streams";
 /**

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

@@ -1,3 +1,45 @@
+/**
+ * @module http/utils
+ * @package @aerokit/sdk/http
+ * @name HttpUtils
+ * @overview
+ *
+ * The HttpUtils class provides a collection of static utility methods for sending standardized HTTP responses in a consistent format. These methods abstract away the details of setting response status codes, content types, and formatting response bodies as JSON, allowing developers to easily send common success and error responses with minimal code.
+ *
+ * ### Key Features:
+ * - **Standardized Responses**: Provides methods for sending common HTTP responses such as 200 OK, 201 Created, 204 No Content, 400 Bad Request, 403 Forbidden, 404 Not Found, and 500 Internal Server Error.
+ * - **JSON Formatting**: Automatically formats response bodies as JSON, ensuring a consistent response structure across the application.
+ *
+ * ### Use Cases:
+ * - **API Development**: These utilities are essential for API development, allowing developers to quickly send appropriate responses based on the outcome of request processing.
+ * - **Error Handling**: Simplifies error handling by providing methods to send standardized error responses with descriptive messages.
+ *
+ * ### Example Usage:
+ * ```ts
+ * import { HttpUtils } from "@aerokit/sdk/http";
+ *
+ * // Sending a successful response with data
+ * HttpUtils.sendResponseOk({ id: "123", name: "Example" });
+ *
+ * // Sending a created response after creating a resource
+ * HttpUtils.sendResponseCreated({ id: "123", name: "New Resource" });
+ *
+ * // Sending a no content response after deleting a resource
+ * HttpUtils.sendResponseNoContent();
+ *
+ * // Sending a bad request error response
+ * HttpUtils.sendResponseBadRequest("Invalid input data");
+ *
+ * // Sending a forbidden error response
+ * HttpUtils.sendForbiddenRequest("You do not have permission to access this resource");
+ *
+ * // Sending a not found error response
+ * HttpUtils.sendResponseNotFound("Resource not found");
+ *
+ * // Sending an internal server error response
+ * HttpUtils.sendInternalServerError("An unexpected error occurred");
+ * ```
+ */
 /**
  * Provides convenient static methods for sending standard HTTP responses.
  * All responses are automatically formatted as 'application/json'.

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

@@ -1,3 +1,14 @@
+/**
+ * @module indexing/index
+ * @package @aerokit/sdk/indexing
+ * @overview
+ *
+ * This module provides functionalities for indexing and search within the Aerokit SDK. It includes classes and methods for creating and managing search indexes, performing search queries, and writing data to indexes.
+ *
+ * The main components of this module are:
+ * - Searcher: Represents a searcher for performing search queries on an index and retrieving results.
+ * - Writer: Represents a writer for adding, updating, and deleting documents in an index.
+ */
 export * from "./searcher";
 export { Searcher as searcher } from "./searcher";
 export * from "./writer";

package/dist/dts/indexing/searcher.d.ts

@@ -1,6 +1,39 @@
 /**
- * Provides a static façade (`Searcher` class) for performing
- * term-based and time-based queries against a native indexing service.
+ * @module indexing/searcher
+ * @package @aerokit/sdk/indexing
+ * @name Searcher
+ * @overview
+ *
+ * The Searcher class provides a static façade for performing term-based and time-based queries against a native indexing service. It allows developers to execute keyword searches and filter indexed entries based on their indexing timestamps, facilitating efficient retrieval of relevant data from the index.
+ *
+ * ### Key Features:
+ * - **Keyword Search**: The `search` method enables searching for entries in a specified index using keywords or search phrases.
+ * - **Time-Based Queries**: The `before`, `after`, and `between` methods allow filtering indexed entries based on their indexing timestamps, enabling retrieval of entries indexed before, after, or within a specific date range.
+ *
+ * ### Use Cases:
+ * - **Data Retrieval**: Developers can use the Searcher class to retrieve relevant data from an index based on keywords or time criteria, which is essential for applications that rely on indexed data for search functionality.
+ * - **Index Management**: The time-based query methods can be useful for managing and maintaining the index by identifying entries that may need to be updated or removed based on their age.
+ *
+ * ### Example Usage:
+ * ```ts
+ * import { Searcher } from "@aerokit/sdk/indexing";
+ *
+ * // Perform a keyword search in the 'documents' index
+ * const results = Searcher.search('documents', 'example search term');
+ * console.log(results);
+ *
+ * // Find entries indexed before a specific date
+ * const oldEntries = Searcher.before('documents', new Date('2023-01-01'));
+ * console.log(oldEntries);
+ *
+ * // Find entries indexed after a specific date
+ * const recentEntries = Searcher.after('documents', new Date('2023-06-01'));
+ * console.log(recentEntries);
+ *
+ * // Find entries indexed between two dates
+ * const entriesInRange = Searcher.between('documents', new Date('2023-01-01'), new Date('2023-06-01'));
+ * console.log(entriesInRange);
+ * ```
  */
 /**
  * The Searcher class provides methods for querying a specific index

package/dist/dts/indexing/writer.d.ts

@@ -1,6 +1,27 @@
 /**
- * Provides a static façade (`Writer` class) for adding new documents
- * or content to the native indexing service.
+ * @module indexing/writer
+ * @package @aerokit/sdk/indexing
+ * @name Writer
+ * @overview
+ *
+ * The Writer class provides a static façade for adding new documents or content to the native indexing service. It allows developers to index documents with full-text content, a last modification timestamp, and optional metadata, facilitating efficient organization and retrieval of indexed data.
+ *
+ * ### Key Features:
+ * - **Document Indexing**: The `add` method enables adding new documents to a specified index with relevant content and metadata.
+ * - **Metadata Support**: Allows associating additional key-value metadata with indexed documents, which can be useful for filtering and searching.
+ * - **Timestamp Management**: Supports specifying the last modification time of the document, which can be used for time-based queries and index maintenance.
+ *
+ * ### Use Cases:
+ * - **Content Management**: Developers can use the Writer class to index various types of content (e.g., articles, products, user profiles) to make them searchable within the application.
+ * - **Search Optimization**: By providing rich metadata and accurate timestamps, developers can enhance the search experience and relevance of results retrieved from the index.
+ *
+ * ### Example Usage:
+ * ```ts
+ * import { Writer } from "@aerokit/sdk/indexing";
+ *
+ * // Index a new document with metadata
+ * Writer.add('documents', '/path/to/document.txt', 'This is the full text content of the document.', new Date(), { author: 'John Doe', category: 'example' });
+ * ```
  */
 /**
  * The Writer class provides a static method for indexing documents, allowing

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

@@ -1,2 +1,12 @@
+/**
+ * @module integrations/index
+ * @package @aerokit/sdk/integrations
+ * @overview
+ *
+ * This module provides functionalities for integrations within the Aerokit SDK. It includes classes and methods for managing integrations with external systems, such as databases, messaging systems, and third-party APIs.
+ *
+ * The main components of this module are:
+ * - Integrations: Represents a registry for managing integrations and provides methods to register and retrieve integrations.
+ */
 export * from "./integrations";
 export { Integrations as integrations } from "./integrations";

package/dist/dts/integrations/integrations.d.ts

@@ -1,7 +1,31 @@
 /**
- * Provides a static façade for interacting with Apache Camel routes
- * within the execution environment. This allows JavaScript code to synchronously
- * invoke integration routes and access the current message context.
+ * @module integrations/integrations
+ * @package @aerokit/sdk/integrations
+ * @name Integrations
+ * @overview
+ *
+ * The Integrations class provides utility methods for triggering and interacting with predefined Apache Camel integration routes. It allows JavaScript code to synchronously invoke Camel routes by their unique identifiers, passing in a payload, headers, and exchange properties. Additionally, it provides access to the current message being processed within the integration context, enabling developers to read and modify message content and metadata during route execution.
+ *
+ * ### Key Features:
+ * - **Route Invocation**: The `invokeRoute` method allows developers to execute a specific Camel route by its ID, providing the necessary input data and context for the route to process.
+ * - **Message Access**: The `getInvokingRouteMessage` method provides access to the current message being processed in the integration context, allowing for dynamic interaction with the message's body, headers, and exchange properties.
+ *
+ * ### Use Cases:
+ * - **Integration Testing**: Developers can use the `invokeRoute` method to test individual Camel routes in isolation by providing controlled inputs and examining the outputs.
+ * - **Dynamic Message Manipulation**: By accessing the current message through `getInvokingRouteMessage`, developers can implement dynamic logic within their routes, such as modifying headers or altering the message body based on certain conditions.
+ *
+ * ### Example Usage:
+ * ```ts
+ * import { Integrations } from "@aerokit/sdk/integrations";
+ *
+ * // Invoke a Camel route with specific payload, headers, and exchange properties
+ * const result = Integrations.invokeRoute('myRouteId', { key: 'value' }, { header1: 'value1' }, { property1: 'value1' });
+ * console.log(result);
+ *
+ * // Access the current message within a route endpoint
+ * const currentMessage = Integrations.getInvokingRouteMessage();
+ * console.log(currentMessage.getBody());
+ * ```
  */
 declare const CamelMessage: any;
 /**