@aerokit/sdk 12.44.0

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

@@ -0,0 +1,126 @@
+import { ResourceMethod } from "./resource-method";
+/**
+ * Constructs a new Resource instance, initialized with the supplied path parameter and optionally with the second, configuration object parameter.
+ */
+export declare class Resource {
+    /** The URL path for this resource. */
+    sPath: string;
+    /** The resource configuration mapping methods to handler specifications. */
+    cfg: any;
+    /** The optional controller instance. */
+    controller: any;
+    /** Bound execute function from the controller. */
+    execute: Function | undefined;
+    /** Additional mappings object. */
+    mappings: any;
+    /**
+     * @param sPath The base URL path for the resource.
+     * @param oConfiguration Optional configuration object (map of method handlers).
+     * @param controller Optional controller instance containing an execute method.
+     * @param mappings Optional object for resource mappings.
+     */
+    constructor(sPath: string, oConfiguration?: any, controller?: any, mappings?: any);
+    /**
+     * Sets the URL path for this resource, overriding the one specified upon its construction,
+     * if a path string is provided as argument ot the method (i.e. acts as setter),
+     * or returns the path set for this resource, if the method is invoked without arguments (i.e. acts as getter).
+     *
+     * @param sPath The path property to be set for this resource.
+     * @returns The resource instance for method chaining (setter mode), or the path set for this resource (getter mode).
+     */
+    path(sPath?: string): Resource | string;
+    /**
+     * Creates a new HTTP method handling specification.
+     *
+     * @param sHttpMethod The HTTP method (method) (e.g., "GET").
+     * @param oConfiguration The handler specification(s) for this HTTP method. Can be a single object or array.
+     * @returns The ResourceMethod instance, or an array of ResourceMethod instances.
+     */
+    method(sHttpMethod: string, oConfiguration?: any | any[]): ResourceMethod | ResourceMethod[];
+    /**
+     * Internal utility method to handle the logic for HTTP verb shortcut methods (get, post, etc.).
+     *
+     * @param sMethodName The HTTP method name (e.g., 'get').
+     * @param args The arguments passed to the shortcut method.
+     * @returns The ResourceMethod instance or an array of instances.
+     */
+    private buildMethod;
+    /**
+     * Creates a handling specification for the HTTP method "GET".
+     * @param fServeCb|oConfiguration Serve function callback or configuration object to initialize the method.
+     * @returns The ResourceMethod instance or array.
+     */
+    get(fServeCb: Function): ResourceMethod;
+    get(oConfiguration: any): ResourceMethod | ResourceMethod[];
+    get(): ResourceMethod;
+    /**
+     * Creates a handling specification for the HTTP method "POST".
+     * @param fServeCb|oConfiguration Serve function callback or configuration object to initialize the method.
+     * @returns The ResourceMethod instance or array.
+     */
+    post(fServeCb: Function): ResourceMethod;
+    post(oConfiguration: any): ResourceMethod | ResourceMethod[];
+    post(): ResourceMethod;
+    /**
+     * Creates a handling specification for the HTTP method "PUT".
+     * @param fServeCb|oConfiguration Serve function callback or configuration object to initialize the method.
+     * @returns The ResourceMethod instance or array.
+     */
+    put(fServeCb: Function): ResourceMethod;
+    put(oConfiguration: any): ResourceMethod | ResourceMethod[];
+    put(): ResourceMethod;
+    /**
+     * Creates a handling specification for the HTTP method "DELETE".
+     * @param fServeCb|oConfiguration Serve function callback or configuration object to initialize the method.
+     * @returns The ResourceMethod instance or array.
+     */
+    delete(fServeCb: Function): ResourceMethod;
+    delete(oConfiguration: any): ResourceMethod | ResourceMethod[];
+    delete(): ResourceMethod;
+    /**
+     * Creates a handling specification for the HTTP method "DELETE" (alias for delete()).
+     * @param fServeCb|oConfiguration Serve function callback or configuration object to initialize the method.
+     * @returns The ResourceMethod instance or array.
+     */
+    remove(fServeCb: Function): ResourceMethod;
+    remove(oConfiguration: any): ResourceMethod | ResourceMethod[];
+    remove(): ResourceMethod;
+    /**
+     * Finds a ResourceMethod with the given constraints.
+     *
+     * @param sVerb The name of the method property of the ResourceMethod in search (e.g., "GET").
+     * @param arrConsumesMimeTypeStrings The consumes constraint property of the ResourceMethod in search.
+     * @param arrProducesMimeTypeStrings The produces constraint property of the ResourceMethod in search.
+     * @returns The found ResourceMethod instance, or undefined if not found.
+     */
+    find(sVerb: string, arrConsumesMimeTypeStrings?: string[], arrProducesMimeTypeStrings?: string[]): ResourceMethod | undefined;
+    /**
+     * Returns the configuration of this resource.
+     *
+     * @returns The resource configuration object.
+     */
+    configuration(): any;
+    /**
+     * Instructs redirection of the request base don the parameter. If it is a stirng representing URI, the request will be
+     * redirected to this URI for any method. If it's a function it will be invoked and epxected to return a URI string to redirect to.
+     *
+     * @param fRedirector The function or string URI to redirect to.
+     * @returns The resource instance for method chaining.
+     */
+    redirect(fRedirector: string | Function): Resource;
+    /**
+     * Disables the ResourceMethods that match the given constraints
+     *
+     * @param sVerb The HTTP verb (e.g., "GET").
+     * @param arrConsumesTypeStrings The consumes constraint property of the ResourceMethod in search.
+     * @param arrProducesTypeStrings The produces constraint property of the ResourceMethod in search.
+     * @returns The resource instance for method chaining.
+     */
+    disable(sVerb?: string, arrConsumesTypeStrings?: string[], arrProducesTypeStrings?: string[]): Resource;
+    /**
+     * Disables all but 'read' HTTP methods in this resource (GET, HEAD, TRACE).
+     *
+     * @returns The resource instance for method chaining.
+     */
+    readonly(): Resource;
+}

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

@@ -0,0 +1,4 @@
+export { service, HttpController } from "./rs/resource-http-controller";
+export { ResourceMethod } from "./rs/resource-method";
+export { ResourceMappings } from "./rs/resource-mappings";
+export { Resource } from "./rs/resource";

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

@@ -0,0 +1,81 @@
+/**
+ * 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.
+ */
+/**
+ * The static Session class provides methods to interact with the current user session
+ * (e.g., storing attributes, checking status, managing lifetime).
+ */
+export declare class Session {
+    /**
+     * Checks if a session is currently valid and active for the request context.
+     * @returns True if the session is valid, false otherwise (e.g., if it has been invalidated or timed out).
+     */
+    static isValid(): boolean;
+    /**
+     * Retrieves the value of a named attribute stored in the session.
+     * Note: The underlying Java facade typically stores strings, but the value may represent
+     * serialized data that should be parsed if complex.
+     * @param name The name of the attribute.
+     * @returns The attribute value as a string, or null/undefined if not found.
+     */
+    static getAttribute(name: string): string;
+    /**
+     * Retrieves an array of all attribute names currently stored in the session.
+     * The names are retrieved as a JSON string from the facade and then parsed.
+     * @returns An array of attribute names (strings), or an empty array if no attributes are present.
+     */
+    static getAttributeNames(): string[];
+    /**
+     * Returns the time at which this session was created, converted to a JavaScript Date object.
+     * @returns A Date object representing the session's creation time.
+     */
+    static getCreationTime(): Date;
+    /**
+     * Returns the unique identifier assigned to this session.
+     * @returns The session ID string.
+     */
+    static getId(): string;
+    /**
+     * Returns the last time the client accessed this session, converted to a JavaScript Date object.
+     * Access includes requests that retrieve or set session attributes.
+     * @returns A Date object representing the last access time.
+     */
+    static getLastAccessedTime(): Date;
+    /**
+     * Returns the maximum time interval, in seconds, that the server should keep this session open
+     * between client requests. After this interval, the session will be invalidated.
+     * @returns The maximum inactive interval in seconds.
+     */
+    static getMaxInactiveInterval(): number;
+    /**
+     * Invalidates this session, unbinding any objects bound to it.
+     * After this call, the session is no longer valid.
+     */
+    static invalidate(): void;
+    /**
+     * Checks if the client does not yet know about the session, typically meaning
+     * the server has not yet returned the session ID via a cookie or encoded URL.
+     * @returns True if the session is new (not yet used in a response), false otherwise.
+     */
+    static isNew(): boolean;
+    /**
+     * Binds an object to this session, using the specified name.
+     * This is the primary way to store data in the user's session.
+     * @param name The name to bind the object under.
+     * @param value The value/object to store in the session.
+     */
+    static setAttribute(name: string, value: any): void;
+    /**
+     * Removes the attribute with the given name from the session.
+     * @param name The name of the attribute to remove.
+     */
+    static removeAttribute(name: string): void;
+    /**
+     * Specifies the maximum time interval, in seconds, that the server should keep this session open
+     * between client requests before automatically invalidating it.
+     * @param interval The new interval in seconds.
+     */
+    static setMaxInactiveInterval(interval: number): void;
+}

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

@@ -0,0 +1,100 @@
+/**
+ * Provides a static façade (`Upload` class) for checking and parsing
+ * multipart/form-data HTTP requests, typically used for file uploads.
+ */
+import { InputStream } from "@aerokit/sdk/io/streams";
+/**
+ * The static Upload class provides methods to determine if a request contains
+ * multipart content and to parse that content into file items.
+ */
+export declare class Upload {
+    /**
+     * Checks if the current incoming HTTP request contains multipart content
+     * (e.g., from an HTML form with `enctype="multipart/form-data"`).
+     * @returns True if the request is multipart, false otherwise.
+     */
+    static isMultipartContent(): boolean;
+    /**
+     * Parses the incoming multipart request content into a collection of file items.
+     * This operation typically consumes the request body.
+     * @returns A FileItems object representing all parts (files and form fields) of the request.
+     */
+    static parseRequest(): FileItems;
+}
+/**
+ * Represents a collection of uploaded file and form field items parsed from a multipart request.
+ */
+export declare class FileItems {
+    private readonly native;
+    /**
+     * @param native The native Java collection object holding the file items.
+     */
+    constructor(native: any);
+    /**
+     * Retrieves a specific item (file or form field) by its index in the collection.
+     * @param index The zero-based index of the item.
+     * @returns A FileItem object representing the item at the specified index.
+     */
+    get(index: number): FileItem;
+    /**
+     * Returns the total number of items (files and form fields) in the collection.
+     * @returns The size of the collection.
+     */
+    size(): number;
+}
+/**
+ * Represents a single item (either an uploaded file or a regular form field)
+ * within a multipart request.
+ */
+export declare class FileItem {
+    private readonly native;
+    /**
+     * @param native The native Java object representing the file item.
+     */
+    constructor(native: any);
+    /**
+     * For a file upload, returns the original filename as reported by the client.
+     * For a regular form field, this is typically null or undefined.
+     * @returns The original filename string.
+     */
+    getName(): string;
+    /**
+     * Returns the MIME type of the uploaded file or content part.
+     * @returns The content type string (e.g., 'image/png', 'text/plain').
+     */
+    getContentType(): string;
+    /**
+     * Checks if the uploaded item is empty (e.g., a file upload with zero bytes).
+     * @returns True if the item is empty, false otherwise.
+     */
+    isEmpty(): boolean;
+    /**
+     * Returns the size of the uploaded item in bytes.
+     * @returns The size as a number.
+     */
+    getSize(): number;
+    /**
+     * Retrieves the content of the file item as a JavaScript array of bytes.
+     * This uses a utility (`Bytes.toJavaScriptBytes`) to convert the native Java byte array.
+     * @returns An array of bytes (`any[]`).
+     */
+    getBytes(): any[];
+    /**
+     * Retrieves the content of the file item as the native Java byte array.
+     * @returns The native byte array (`any[]`).
+     */
+    getBytesNative(): any[];
+    /**
+     * Retrieves the content of the file item as a string.
+     * Note: This assumes the content is text and may not handle all encodings correctly.
+     * It relies on JavaScript's `String.fromCharCode.apply` for conversion.
+     * @returns The content as a string.
+     */
+    getText(): string;
+    /**
+     * Gets an input stream for reading the content of the file item.
+     * This is useful for handling large files without loading the entire content into memory.
+     * @returns An InputStream object wrapping the native input stream.
+     */
+    getInputStream(): InputStream;
+}

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

@@ -0,0 +1,54 @@
+/**
+ * Provides convenient static methods for sending standard HTTP responses.
+ * All responses are automatically formatted as 'application/json'.
+ */
+export declare class HttpUtils {
+    /**
+     * Sends a successful response with HTTP status 200 (OK).
+     * The provided entity is serialized as the JSON response body.
+     * @param entity The data entity to return in the response body.
+     */
+    static sendResponseOk(entity: any): void;
+    /**
+     * Sends a successful response with HTTP status 201 (Created).
+     * Typically used after a resource has been successfully created.
+     * @param entity The data entity of the newly created resource.
+     */
+    static sendResponseCreated(entity: any): void;
+    /**
+     * Sends a successful response with HTTP status 204 (No Content).
+     * Typically used for successful DELETE requests or updates that do not return a body.
+     */
+    static sendResponseNoContent(): void;
+    /**
+     * Sends an error response with HTTP status 400 (Bad Request).
+     * Used when the request could not be understood or processed due to client-side errors (e.g., validation failure).
+     * @param message A descriptive error message explaining why the request was invalid.
+     */
+    static sendResponseBadRequest(message: string): void;
+    /**
+     * Sends an error response with HTTP status 403 (Forbidden).
+     * Used when the client is authenticated but does not have the necessary permissions to access the resource.
+     * @param message A descriptive error message.
+     */
+    static sendForbiddenRequest(message: string): void;
+    /**
+     * Sends an error response with HTTP status 404 (Not Found).
+     * Used when the requested resource could not be found.
+     * @param message A descriptive error message.
+     */
+    static sendResponseNotFound(message: string): void;
+    /**
+     * Sends an error response with HTTP status 500 (Internal Server Error).
+     * Used for unexpected server-side conditions encountered during processing.
+     * @param message A descriptive error message (should mask internal details in production).
+     */
+    static sendInternalServerError(message: string): void;
+    /**
+     * Generic private method to set the response status, content type, and body.
+     * If a body is provided, it is stringified into JSON and written to the response.
+     * @param status The HTTP status code to set (e.g., 200, 404, 500).
+     * @param body The JavaScript object or string to be serialized as the response body (optional).
+     */
+    private static sendResponse;
+}

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

@@ -0,0 +1,4 @@
+export * from "./searcher";
+export { Searcher as searcher } from "./searcher";
+export * from "./writer";
+export { Writer as writer } from "./writer";

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

@@ -0,0 +1,47 @@
+/**
+ * Provides a static façade (`Searcher` class) for performing
+ * term-based and time-based queries against a native indexing service.
+ */
+/**
+ * The Searcher class provides methods for querying a specific index
+ * using keywords or date ranges.
+ */
+export declare class Searcher {
+    /**
+     * Executes a keyword search against a specified index.
+     * @param index The name or identifier of the index to search (e.g., 'documents', 'products').
+     * @param term The keyword or search phrase to look for.
+     * @returns An array of result objects, parsed from the native JSON string output.
+     */
+    static search(index: string, term: string): {
+        [key: string]: string;
+    }[];
+    /**
+     * Finds all entries in the index that were indexed before the specified date.
+     * @param index The name or identifier of the index.
+     * @param date The Date object representing the upper bound (exclusive) of the time range.
+     * @returns An array of result objects, parsed from the native JSON string output.
+     */
+    static before(index: string, date: Date): {
+        [key: string]: string;
+    }[];
+    /**
+     * Finds all entries in the index that were indexed after the specified date.
+     * @param index The name or identifier of the index.
+     * @param date The Date object representing the lower bound (exclusive) of the time range.
+     * @returns An array of result objects, parsed from the native JSON string output.
+     */
+    static after(index: string, date: Date): {
+        [key: string]: string;
+    }[];
+    /**
+     * Finds all entries in the index that were indexed within the specified date range.
+     * @param index The name or identifier of the index.
+     * @param lower The Date object for the lower bound (exclusive).
+     * @param upper The Date object for the upper bound (exclusive).
+     * @returns An array of result objects, parsed from the native JSON string output.
+     */
+    static between(index: string, lower: Date, upper: Date): {
+        [key: string]: string;
+    }[];
+}

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

@@ -0,0 +1,22 @@
+/**
+ * Provides a static façade (`Writer` class) for adding new documents
+ * or content to the native indexing service.
+ */
+/**
+ * The Writer class provides a static method for indexing documents, allowing
+ * for full-text content, a last modification timestamp, and optional metadata.
+ */
+export declare class Writer {
+    /**
+     * Adds a new document entry to the specified index.
+     *
+     * @param index The name or identifier of the index (e.g., 'documents', 'users').
+     * @param location A unique identifier or path for the indexed document (e.g., a file path or URL).
+     * @param contents The full-text content of the document to be indexed and made searchable.
+     * @param lastModified The Date object representing the last modification time of the document. Defaults to the current date/time if omitted.
+     * @param parameters Optional key-value map of additional metadata to associate with the document.
+     */
+    static add(index: string, location: string, contents: string, lastModified?: Date, parameters?: {
+        [key: string]: string;
+    }): void;
+}

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

@@ -0,0 +1,2 @@
+export * from "./integrations";
+export { Integrations as integrations } from "./integrations";

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

@@ -0,0 +1,118 @@
+/**
+ * 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.
+ */
+declare const CamelMessage: any;
+/**
+ * Defines the structure for Camel Message Headers, typically used for
+ * standard communication metadata. Keys are strings, and values can be
+ * a single string or an array of strings.
+ */
+export interface HeadersMap {
+    [key: string]: string | string[];
+}
+/**
+ * Defines the structure for Camel Exchange Properties, which are context-specific
+ * variables used for processing within a single route execution. Keys are strings,
+ * and values can be a single string or an array of strings.
+ */
+export interface ExchangeProperties {
+    [key: string]: string | string[];
+}
+/**
+ * Represents the Camel message currently being processed. This interface mirrors
+ * key functionality of the underlying Apache Camel Message and Exchange objects.
+ */
+export interface IntegrationMessage {
+    /**
+     * Constructs an IntegrationMessage wrapper around a native message object.
+     * @param message The native message object (usually a Camel Message or Exchange).
+     */
+    constructor(message: any): any;
+    /**
+     * Retrieves the body of the message.
+     * @returns The message body (can be any type, e.g., string, object, stream).
+     */
+    getBody(): any;
+    /**
+     * Retrieves a specific property from the current Exchange context.
+     * @param propertyName The name of the exchange property.
+     * @returns The value of the exchange property.
+     */
+    getExchangeProperty(propertyName: string): any;
+    /**
+     * Sets a specific property on the current Exchange context.
+     * @param propertyName The name of the exchange property.
+     * @param propertyValue The value to set.
+     */
+    setExchangeProperty(propertyName: string, propertyValue: any): void;
+    /**
+     * Retrieves all properties from the current Exchange context.
+     * @returns A map of all exchange properties.
+     */
+    getExchangeProperties(): Record<string, any>;
+    /**
+     * Retrieves the body of the message as a string.
+     * @returns The message body converted to a string.
+     */
+    getBodyAsString(): string;
+    /**
+     * Sets the body of the message.
+     * @param body The new body content.
+     */
+    setBody(body: any): void;
+    /**
+     * Retrieves all headers associated with the message.
+     * @returns A map of headers.
+     */
+    getHeaders(): HeadersMap;
+    /**
+     * Retrieves a specific header value.
+     * @param key The header key.
+     * @returns The header value(s).
+     */
+    getHeader(key: string): string | string[];
+    /**
+     * Sets multiple headers on the message.
+     * @param headers The map of headers to set.
+     */
+    setHeaders(headers: HeadersMap): void;
+    /**
+     * Sets a single header on the message.
+     * @param key The header key.
+     * @param value The header value.
+     */
+    setHeader(key: string, value: string | string[]): void;
+    /**
+     * Retrieves the underlying native Camel Message object.
+     * @returns The raw Camel Message instance.
+     */
+    getCamelMessage(): typeof CamelMessage;
+}
+/**
+ * The Integrations class provides utility methods for triggering and interacting
+ * with predefined Apache Camel integration routes.
+ */
+export declare class Integrations {
+    /**
+     * Synchronously invokes a specified Camel route.
+     *
+     * @param routeId The unique identifier of the Camel route to be executed.
+     * @param payload The initial message body/payload for the route.
+     * @param headers A map of headers to set on the initial Camel Message.
+     * @param exchangeProperties A map of properties to set on the Camel Exchange context.
+     * @returns The final result (the body of the resulting Camel Message) after the route has completed execution.
+     */
+    static invokeRoute(routeId: string, payload: any, headers: HeadersMap, exchangeProperties: ExchangeProperties): any;
+    /**
+     * Retrieves the current message being processed by the underlying integration
+     * engine's context. This is typically used within a route endpoint (e.g., a script component)
+     * to access or modify the message.
+     *
+     * Note: '__context' is assumed to be a global or context-injected variable.
+     * @returns The current IntegrationMessage wrapper.
+     */
+    static getInvokingRouteMessage(): IntegrationMessage;
+}
+export {};

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

@@ -0,0 +1,56 @@
+/**
+ * Provides utilities for converting and manipulating byte arrays,
+ * facilitating conversions between JavaScript arrays, Java arrays, text, and integers.
+ */
+/**
+ * The Bytes class provides static methods for byte array operations, primarily
+ * used to bridge data types between the JavaScript environment and native Java components.
+ */
+export declare class Bytes {
+    /**
+     * Converts a native JavaScript byte array (an array of numbers) to a Java byte array.
+     * This is used internally by the API layer to pass data to Java methods.
+     *
+     * @param bytes The JavaScript array of bytes (e.g., [104, 101, 108, 108, 111]).
+     * @returns A native Java byte array (internal representation).
+     */
+    static toJavaBytes(bytes: any[]): any[];
+    /**
+     * Converts a native Java byte array back to a JavaScript array of numbers.
+     * This is used internally by the API layer to retrieve data from Java methods.
+     *
+     * @param internalBytes The native Java byte array.
+     * @returns A JavaScript array containing the byte values (numbers).
+     */
+    static toJavaScriptBytes(internalBytes: any[]): any[];
+    /**
+     * Converts a standard text string into a byte array using the default platform encoding.
+     *
+     * @param text The input text string.
+     * @returns A JavaScript array representing the bytes of the text.
+     */
+    static textToByteArray(text: string): any[];
+    /**
+     * Converts a byte array back into a text string.
+     *
+     * @param data The JavaScript array of bytes.
+     * @returns The reconstructed text string.
+     */
+    static byteArrayToText(data: any[]): string;
+    /**
+     * Converts a 32-bit integer value into a byte array, respecting the specified byte order.
+     *
+     * @param value The integer value to convert.
+     * @param byteOrder Specifies the byte ordering: "BIG_ENDIAN" (most significant byte first) or "LITTLE_ENDIAN" (least significant byte first).
+     * @returns A JavaScript array representing the 4-byte integer.
+     */
+    static intToByteArray(value: number, byteOrder: "BIG_ENDIAN" | "LITTLE_ENDIAN"): any[];
+    /**
+     * Converts a 4-byte array back into a 32-bit integer value, respecting the specified byte order.
+     *
+     * @param data The 4-byte array (JavaScript array of numbers).
+     * @param byteOrder Specifies the byte ordering used during conversion.
+     * @returns The reconstructed integer value.
+     */
+    static byteArrayToInt(data: any[], byteOrder: "BIG_ENDIAN" | "LITTLE_ENDIAN"): number;
+}