@aerokit/sdk 12.44.0

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

@@ -0,0 +1,250 @@
+/**
+ * Provides the API for managing scheduled jobs and tasks within the platform,
+ * allowing users to retrieve, enable, disable, and trigger jobs, as well as log output.
+ */
+/**
+ * The Scheduler class provides static methods for interacting with the job scheduler,
+ * offering global control over the system's defined jobs.
+ */
+export declare class Scheduler {
+    /**
+     * Retrieves all job definitions currently configured in the system.
+     *
+     * @returns An array of {@link Job} objects.
+     */
+    static getJobs(): Job[];
+    /**
+     * Retrieves a specific job definition by its unique name.
+     *
+     * @param name The name of the job.
+     * @returns A {@link Job} object corresponding to the provided name.
+     */
+    static getJob(name: string): Job;
+    /**
+     * Enables a job, allowing it to be executed according to its schedule (cron expression).
+     *
+     * @param name The name of the job to enable.
+     */
+    static enable(name: string): void;
+    /**
+     * Disables a job, preventing it from executing on its schedule.
+     *
+     * @param name The name of the job to disable.
+     */
+    static disable(name: string): void;
+    /**
+     * Triggers the immediate execution of a job.
+     *
+     * @param name The name of the job to trigger.
+     * @param parameters Optional key-value object of parameters to pass to the job execution.
+     */
+    static trigger(name: string, parameters?: {
+        [key: string]: string;
+    }): void;
+    /**
+     * Logs a message at the standard log level for a specific job instance.
+     * This is useful when the log context needs to be associated with a running job.
+     *
+     * @param name The name of the job to associate the log with.
+     * @param message The log message content.
+     */
+    static log(name: string, message: string): void;
+    /**
+     * Logs an error message for a specific job instance.
+     *
+     * @param name The name of the job.
+     * @param message The error message content.
+     */
+    static error(name: string, message: string): void;
+    /**
+     * Logs a warning message for a specific job instance.
+     *
+     * @param name The name of the job.
+     * @param message The warning message content.
+     */
+    static warn(name: string, message: string): void;
+    /**
+     * Logs an informational message for a specific job instance.
+     *
+     * @param name The name of the job.
+     * @param message The information message content.
+     */
+    static info(name: string, message: string): void;
+}
+/**
+ * Represents a single scheduled job definition.
+ */
+declare class Job {
+    private data;
+    /**
+     * @param data The raw data object containing job properties.
+     */
+    constructor(data: any);
+    /**
+     * Gets the unique name of the job.
+     * @returns The job name.
+     */
+    getName(): string;
+    /**
+     * Gets the logical grouping for the job.
+     * @returns The job group name.
+     */
+    getGroup(): string;
+    /**
+     * Gets the Java class name (for Java-based jobs) or script file name (for script-based jobs).
+     * @returns The job implementation class/file name.
+     */
+    getClazz(): string;
+    /**
+     * Gets the description of the job's purpose.
+     * @returns The job description.
+     */
+    getDescription(): string;
+    /**
+     * Gets the cron expression defining the job's schedule.
+     * @returns The cron expression string.
+     */
+    getExpression(): string;
+    /**
+     * Gets the handler file path or resource name for script-based jobs.
+     * @returns The handler path.
+     */
+    getHandler(): string;
+    /**
+     * Gets the execution engine type (e.g., 'JavaScript', 'Java').
+     * @returns The engine type.
+     */
+    getEngine(): string;
+    /**
+     * Checks if the job is configured as a singleton (only one instance runs at a time).
+     * @returns True if the job is a singleton.
+     */
+    getSingleton(): boolean;
+    /**
+     * Checks if the job is currently enabled for scheduled execution.
+     * @returns True if the job is enabled.
+     */
+    getEnabled(): boolean;
+    /**
+     * Gets the user ID who created the job definition.
+     * @returns The creator's user ID.
+     */
+    getCreatedBy(): string;
+    /**
+     * Gets the timestamp when the job definition was created.
+     * @returns The creation time as a numerical timestamp.
+     */
+    getCreatedAt(): number;
+    /**
+     * Gets the parameters associated with this job definition.
+     * @returns A {@link JobParameters} object containing all parameters.
+     */
+    getParameters(): JobParameters;
+    /**
+     * Retrieves the value for a specific parameter of this job.
+     * It checks for an overriding value in the global configurations first,
+     * and falls back to the defined default value if the configuration is not set.
+     *
+     * @param name The name of the parameter to retrieve.
+     * @returns The parameter's configured or default value, or null if not found.
+     */
+    getParameter(name: string): string;
+    /**
+     * Enables this specific job instance.
+     */
+    enable(): void;
+    /**
+     * Disables this specific job instance.
+     */
+    disable(): void;
+    /**
+     * Triggers the immediate execution of this job instance.
+     *
+     * @param parameters Optional key-value object of parameters to pass to the job execution.
+     */
+    trigger(parameters?: {
+        [key: string]: string;
+    }): void;
+    /**
+     * Logs a message at the standard log level for this job instance.
+     *
+     * @param message The log message content.
+     */
+    log(message: string): void;
+    /**
+     * Logs an error message for this job instance.
+     *
+     * @param message The error message content.
+     */
+    error(message: string): void;
+    /**
+     * Logs a warning message for this job instance.
+     *
+     * @param message The warning message content.
+     */
+    warn(message: string): void;
+    /**
+     * Logs an informational message for this job instance.
+     *
+     * @param message The information message content.
+     */
+    info(message: string): void;
+}
+/**
+ * A container object representing the collection of parameters for a {@link Job}.
+ */
+declare class JobParameters {
+    private data;
+    /**
+     * @param data The array of raw job parameter objects.
+     */
+    constructor(data: any[]);
+    /**
+     * Retrieves a specific job parameter by its index.
+     *
+     * @param i The index of the parameter in the array.
+     * @returns A {@link JobParameter} object.
+     */
+    get(i: number): JobParameter;
+    /**
+     * Gets the total number of parameters defined for the job.
+     * @returns The count of parameters.
+     */
+    count(): number;
+}
+/**
+ * Represents a single parameter definition for a job.
+ */
+declare class JobParameter {
+    private data;
+    /**
+     * @param data The raw data object containing parameter properties.
+     */
+    constructor(data: any);
+    /**
+     * Gets the name of the parameter.
+     * @returns The parameter name.
+     */
+    getName(): string;
+    /**
+     * Gets the description of the parameter.
+     * @returns The parameter description.
+     */
+    getDescription(): string;
+    /**
+     * Gets the expected data type of the parameter (e.g., 'String', 'Integer', 'Boolean').
+     * @returns The parameter type.
+     */
+    getType(): string;
+    /**
+     * Gets the default value for the parameter.
+     * @returns The default value string.
+     */
+    getDefaultValue(): string;
+    /**
+     * Gets a list of predefined choices for the parameter, if applicable.
+     * @returns An array of choice strings.
+     */
+    getChoices(): string[];
+}
+export {};

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

@@ -0,0 +1 @@
+export * from "./junit";

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

@@ -0,0 +1,50 @@
+/**
+ * Defines a test case.
+ *
+ * @param name The name of the test case.
+ * @param testFn The function containing the test logic and assertions.
+ */
+export declare function test(name: string, testFn: () => void): void;
+/**
+ * Asserts that two objects or primitive values are equal.
+ *
+ * @template T The type of the values being compared.
+ * @param expected The expected value.
+ * @param actual The actual value.
+ * @param message Optional message to display if the assertion fails.
+ */
+export declare function assertEquals<T>(expected: T, actual: T): void;
+export declare function assertEquals<T>(message: string, expected: T, actual: T): void;
+/**
+ * Asserts that two objects or primitive values are not equal.
+ *
+ * @template T The type of the values being compared.
+ * @param unexpected The unexpected value.
+ * @param actual The actual value.
+ * @param message Optional message to display if the assertion fails.
+ */
+export declare function assertNotEquals<T>(unexpected: T, actual: T): void;
+export declare function assertNotEquals<T>(message: string, unexpected: T, actual: T): void;
+/**
+ * Asserts that a condition is true.
+ *
+ * @param condition The condition to test.
+ * @param message Optional message to display if the assertion fails.
+ */
+export declare function assertTrue(condition: boolean): void;
+export declare function assertTrue(message: string, condition: boolean): void;
+/**
+ * Asserts that a condition is false.
+ *
+ * @param condition The condition to test.
+ * @param message Optional message to display if the assertion fails.
+ */
+export declare function assertFalse(condition: boolean): void;
+export declare function assertFalse(message: string, condition: boolean): void;
+/**
+ * Fails a test immediately.
+ *
+ * @param message Optional message to display indicating the reason for the failure.
+ */
+export declare function fail(): void;
+export declare function fail(message: string): void;

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

@@ -0,0 +1,48 @@
+/**
+ * The Consumer class acts as the main entry point for creating and configuring
+ * Kafka topic consumers.
+ */
+export declare class Consumer {
+    /**
+     * Creates a new topic configuration wrapper that can be used to start or
+     * stop listening for messages on a Kafka topic.
+     *
+     * @param destination The name of the Kafka topic to consume messages from.
+     * @param configuration Optional key-value object containing Kafka consumer properties
+     * (e.g., 'group.id', 'auto.offset.reset').
+     * @returns A {@link Topic} instance configured for the specified destination and properties.
+     */
+    static topic(destination: string, configuration?: {
+        [key: string]: string;
+    }): Topic;
+}
+/**
+ * Represents a configured Kafka topic consumer capable of starting and stopping
+ * background message listening.
+ */
+declare class Topic {
+    private destination;
+    private configuration;
+    /**
+     * @param destination The name of the Kafka topic.
+     * @param configuration Optional key-value object for consumer properties.
+     */
+    constructor(destination: string, configuration?: {
+        [key: string]: string;
+    });
+    /**
+     * Starts listening to the configured topic in a background process.
+     *
+     * @param handler The path to the script or function name that will handle the incoming Kafka messages.
+     * This function should accept two arguments: `message` (string) and `headers` (object).
+     * @param timeout The maximum amount of time (in milliseconds) the consumer should wait for messages.
+     */
+    startListening(handler: string, timeout: number): void;
+    /**
+     * Stops the background process that is listening to the configured topic.
+     * Note: Stopping is based on matching the topic and configuration, so the same
+     * configuration object used in `startListening` should be used here.
+     */
+    stopListening(): void;
+}
+export {};

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

@@ -0,0 +1,4 @@
+export { Consumer as consumer } from "./consumer";
+export * from "./consumer";
+export { Producer as producer } from "./producer";
+export * from "./producer";

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

@@ -0,0 +1,50 @@
+/**
+ * The Producer class serves as the main entry point for creating and configuring
+ * Kafka topic producers.
+ */
+export declare class Producer {
+    /**
+     * Creates a new topic configuration wrapper that can be used to send messages
+     * to a specific Kafka topic.
+     *
+     * @param destination The name of the Kafka topic to send messages to.
+     * @param configuration Optional key-value object containing Kafka producer properties
+     * (e.g., 'bootstrap.servers', 'acks').
+     * @returns A {@link Topic} instance configured for the specified destination and properties.
+     */
+    static topic(destination: string, configuration?: {
+        [key: string]: string;
+    }): Topic;
+    /**
+     * Closes the Kafka producer connection pool, releasing associated resources.
+     * This should be called when message sending is complete to ensure proper cleanup.
+     *
+     * @param configuration Optional key-value object containing the configuration
+     * used to initialize the producer to be closed.
+     */
+    static close(configuration?: {
+        [key: string]: string;
+    }): void;
+}
+/**
+ * Represents a configured Kafka topic that can be used to send messages.
+ */
+declare class Topic {
+    private destination;
+    private configuration;
+    /**
+     * @param destination The name of the Kafka topic.
+     * @param configuration Key-value object for producer properties.
+     */
+    constructor(destination: string, configuration: {
+        [key: string]: string;
+    });
+    /**
+     * Sends a message with an optional key to the configured Kafka topic.
+     *
+     * @param key The key of the message. Messages with the same key go to the same partition.
+     * @param value The content of the message to be sent.
+     */
+    send(key: string, value: string): void;
+}
+export {};

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

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

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

@@ -0,0 +1,102 @@
+/**
+ * The main entry point for the logging API. Use this class to obtain a named
+ * logger instance.
+ */
+export declare class Logging {
+    /**
+     * Retrieves or creates a Logger instance associated with a specific name.
+     * The logger name is typically used to categorize log messages (e.g., 'com.app.service').
+     *
+     * @param loggerName The name of the logger.
+     * @returns A {@link Logger} instance.
+     */
+    static getLogger(loggerName: string): Logger;
+}
+/**
+ * Represents a named logger instance used for emitting log messages at various levels.
+ */
+declare class Logger {
+    private loggerName;
+    /**
+     * @param loggerName The name of the logger.
+     */
+    constructor(loggerName: string);
+    /**
+     * Sets the logging level for this specific logger instance.
+     * Messages below this threshold will be ignored.
+     *
+     * @param level The desired logging level (e.g., 'TRACE', 'DEBUG', 'INFO', 'WARN', 'ERROR').
+     * @returns The Logger instance for method chaining.
+     */
+    setLevel(level: string): Logger;
+    /**
+     * Checks if the DEBUG level is currently enabled for this logger.
+     * @returns True if DEBUG logging is enabled, false otherwise.
+     */
+    isDebugEnabled(): boolean;
+    /**
+     * Checks if the ERROR level is currently enabled for this logger.
+     * @returns True if ERROR logging is enabled, false otherwise.
+     */
+    isErrorEnabled(): boolean;
+    /**
+     * Checks if the WARN level is currently enabled for this logger.
+     * @returns True if WARN logging is enabled, false otherwise.
+     */
+    isWarnEnabled(): boolean;
+    /**
+     * Checks if the INFO level is currently enabled for this logger.
+     * @returns True if INFO logging is enabled, false otherwise.
+     */
+    isInfoEnabled(): boolean;
+    /**
+     * Checks if the TRACE level is currently enabled for this logger.
+     * @returns True if TRACE logging is enabled, false otherwise.
+     */
+    isTraceEnabled(): boolean;
+    /**
+     * The core logging method. Logs a message at the specified level, optionally
+     * supporting parameters for message formatting and a final Error object for stack trace logging.
+     *
+     * @param msg The log message template (e.g., "User {0} failed to connect: {1}").
+     * @param level The logging level (e.g., 'DEBUG', 'ERROR').
+     * @param [args] Optional arguments for message formatting. The last argument can be an Error object.
+     */
+    log(msg: string, level: string): void;
+    /**
+     * Logs a message at the DEBUG level.
+     *
+     * @param msg The log message template.
+     * @param [args] Optional arguments for message formatting. The last argument can be an Error object.
+     */
+    debug(msg: string, ..._: any[]): void;
+    /**
+     * Logs a message at the INFO level.
+     *
+     * @param msg The log message template.
+     * @param [args] Optional arguments for message formatting. The last argument can be an Error object.
+     */
+    info(msg: string, ..._: any[]): void;
+    /**
+     * Logs a message at the TRACE level.
+     *
+     * @param msg The log message template.
+     * @param [args] Optional arguments for message formatting. The last argument can be an Error object.
+     */
+    trace(msg: string, ..._: any[]): void;
+    /**
+     * Logs a message at the WARN level.
+     *
+     * @param msg The log message template.
+     * @param [args] Optional arguments for message formatting. The last argument can be an Error object.
+     */
+    warn(msg: string, ..._: any[]): void;
+    /**
+     * Logs a message at the ERROR level.
+     *
+     * @param msg The log message template.
+     * @param [args] Optional arguments for message formatting. The last argument can be an Error object.
+     */
+    error(msg: string, ..._: any[]): void;
+}
+export {};

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

@@ -0,0 +1,90 @@
+/**
+ * Defines the structure for specifying email recipients.
+ * Recipients can be provided as a single email string or an array of strings.
+ */
+export interface MailRecipients {
+    /** The primary recipients of the email. */
+    to?: string | string[];
+    /** Carbon Copy recipients. */
+    cc?: string | string[];
+    /** Blind Carbon Copy recipients. */
+    bcc?: string | string[];
+}
+/**
+ * Defines a single part of a multipart email message.
+ * This is used for bodies, attachments, and inline images.
+ */
+export interface MailMultipart {
+    /** The nature of the part: 'text' (body), 'inline' (e.g., image displayed in HTML), or 'attachment'. */
+    type: "text" | "inline" | "attachment";
+    /** The MIME content type of the part (e.g., 'text/plain', 'text/html', 'image/png'). */
+    contentType: string;
+    /** The text content for 'text' parts. */
+    text?: string;
+    /** Required for 'inline' parts; used in the HTML body to reference the content (e.g., `<img src="cid:...">`). */
+    contentId?: string;
+    /** The name of the file for 'attachment' and 'inline' parts. */
+    fileName?: string;
+    /** The base64-encoded data content for 'attachment' and 'inline' parts. */
+    data?: string;
+}
+/**
+ * Defines the content type for simple emails sent via {@link MailClient.send}.
+ */
+type MailContentType = "html" | "plain";
+/**
+ * The MailClient provides methods for sending emails, handling recipient processing
+ * and interfacing with the underlying MailFacade.
+ */
+export declare class MailClient {
+    private readonly native;
+    /**
+     * A static convenience method to send a multipart email without instantiating a client.
+     * This is suitable for emails that require attachments, inline images, or mixed content.
+     *
+     * @param from The sender's email address.
+     * @param recipients The recipient(s) structure (string for 'to', or {@link MailRecipients} object).
+     * @param subject The subject line of the email.
+     * @param parts An array of {@link MailMultipart} objects defining the email content.
+     */
+    static sendMultipart(from: string, recipients: string | MailRecipients, subject: string, parts: MailMultipart[]): void;
+    /**
+     * A static convenience method to send a simple email with only a single text or HTML body.
+     *
+     * @param from The sender's email address.
+     * @param recipients The recipient(s) structure (string for 'to', or {@link MailRecipients} object).
+     * @param subject The subject line of the email.
+     * @param text The body content of the email.
+     * @param contentType Specifies the body format: 'html' or 'plain'.
+     */
+    static send(from: string, recipients: string | MailRecipients, subject: string, text: string, contentType: MailContentType): void;
+    /**
+     * Creates a new instance of the MailClient, optionally configuring the underlying
+     * native mail facade.
+     *
+     * @param options Optional key-value object containing configuration properties for the mail client (e.g., SMTP settings).
+     */
+    constructor(options?: object);
+    /**
+     * Sends a simple email with a single body part (text or HTML).
+     *
+     * @param from The sender's email address.
+     * @param _recipients The recipient(s) structure (string for 'to', or {@link MailRecipients} object).
+     * @param subject The subject line of the email.
+     * @param text The body content of the email.
+     * @param contentType Specifies the body format: 'html' or 'plain'.
+     * @throws {Error} Throws an error if the recipient format is invalid or the native call fails.
+     */
+    send(from: string, _recipients: string | MailRecipients, subject: string, text: string, contentType: MailContentType): void;
+    /**
+     * Sends a complex email composed of multiple parts (text bodies, HTML, attachments, inline content).
+     *
+     * @param from The sender's email address.
+     * @param _recipients The recipient(s) structure (string for 'to', or {@link MailRecipients} object).
+     * @param subject The subject line of the email.
+     * @param parts An array of {@link MailMultipart} objects defining the email content.
+     * @throws {Error} Throws an error if the recipient format is invalid or the native call fails.
+     */
+    sendMultipart(from: string, _recipients: string | MailRecipients, subject: string, parts: MailMultipart[]): void;
+}
+export {};

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

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

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

@@ -0,0 +1,61 @@
+/**
+ * Provides an API for consuming messages from JMS-style destinations,
+ * supporting both Queues (point-to-point) and Topics (publish/subscribe).
+ */
+/**
+ * The entry point for creating messaging consumers.
+ * Use this class to obtain instances of Queue or Topic consumers.
+ */
+export declare class Consumer {
+    /**
+     * Creates a Queue consumer instance for point-to-point messaging.
+     * Messages sent to this destination are consumed by only one receiver.
+     *
+     * @param destination The name of the queue destination (e.g., 'orders.queue').
+     * @returns A {@link Queue} instance.
+     */
+    static queue(destination: string): Queue;
+    /**
+     * Creates a Topic consumer instance for publish/subscribe messaging.
+     * Messages sent to this destination can be consumed by multiple subscribers.
+     *
+     * @param destination The name of the topic destination (e.g., 'market.updates.topic').
+     * @returns A {@link Topic} instance.
+     */
+    static topic(destination: string): Topic;
+}
+/**
+ * Represents a consumer for a Queue destination (point-to-point).
+ */
+declare class Queue {
+    private destination;
+    /**
+     * @param destination The name of the queue destination.
+     */
+    constructor(destination: string);
+    /**
+     * Attempts to synchronously receive a message from the queue.
+     *
+     * @param timeout The maximum time (in milliseconds) to wait for a message. Defaults to 1000ms.
+     * @returns The received message content (usually a string or object), or null if the timeout is reached.
+     */
+    receive(timeout?: number): any;
+}
+/**
+ * Represents a consumer for a Topic destination (publish/subscribe).
+ */
+declare class Topic {
+    private destination;
+    /**
+     * @param destination The name of the topic destination.
+     */
+    constructor(destination: string);
+    /**
+     * Attempts to synchronously receive a message from the topic.
+     *
+     * @param timeout The maximum time (in milliseconds) to wait for a message. Defaults to 1000ms.
+     * @returns The received message content (usually a string or object), or null if the timeout is reached.
+     */
+    receive(timeout?: number): any;
+}
+export {};

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

@@ -0,0 +1,11 @@
+export interface ListenerOptions {
+    name: string;
+    kind: string;
+}
+/**
+ * @Listener decorator
+ * Marks an entire class as a listener
+ *
+ * introduced in TypeScript 5.0, which expects a ClassDecoratorContext object.
+ */
+export declare function Listener(options: ListenerOptions): <T extends abstract new (...args: any) => any>(target: T, context: ClassDecoratorContext<T>) => void;