@aerokit/sdk 12.44.0

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

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

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

@@ -0,0 +1,72 @@
+/**
+ * Interface defining the structured data required to generate a table in a PDF.
+ */
+export interface PDFTableData {
+    title: string;
+    description: string;
+    columns: {
+        name: string;
+        key: string;
+    }[];
+    rows: {
+        [key: string]: any;
+    }[];
+}
+/**
+ * Interface defining optional configuration for PDF document layout.
+ */
+export interface PDFTableConfig {
+    /** Document width in mm. Overrides size if present. */
+    pageWidth?: number;
+    /** Document height in mm. Overrides size if present. */
+    pageHeight?: number;
+    /** Whether to apply column alignment (based on template default). */
+    alignColumns?: boolean;
+    /** Whether to apply row alignment (based on template default). */
+    alignRows?: boolean;
+    /** Standard ISO 216 paper size (A0-A10). Sets standard dimensions if custom width/height are not provided. */
+    size?: "a0" | "a1" | "a2" | "a3" | "a4" | "a5" | "a6" | "a7" | "a8" | "a9" | "a10";
+}
+/**
+ * @class PDF
+ * @description Utility class for generating PDF documents using a template engine and the PDFFacade.
+ */
+export declare class PDF {
+    /**
+     * Generates a PDF document containing a styled table based on the standard table template.
+     *
+     * @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>).
+     */
+    static generateTable(data: PDFTableData, config?: PDFTableConfig): any[];
+    /**
+     * Generates a PDF document using a custom template path and data payload.
+     *
+     * @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>).
+     */
+    static generate(templatePath: string, data: PDFTableData): any[];
+    /**
+     * Internal method to set template parameters based on optional configuration.
+     *
+     * @param {TemplateParameters} templateParameters The object containing parameters to be modified.
+     * @param {PDFTableConfig} [config] The optional configuration object.
+     */
+    private static setTemplateParameters;
+    /**
+     * Internal method to set column and row alignment parameters.
+     *
+     * @param {TemplateParameters} templateParameters The object containing parameters to be modified.
+     * @param {PDFTableConfig} [config] The optional configuration object.
+     */
+    private static setDocumentAlign;
+    /**
+     * Internal method to set the document size (width and height in mm) based on a standard 'size' or custom dimensions.
+     *
+     * @param {TemplateParameters} templateParameters The object containing parameters to be modified.
+     * @param {PDFTableConfig} [config] The optional configuration object.
+     */
+    private static setDocumentSize;
+}

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

@@ -0,0 +1,41 @@
+/**
+ * Defines the configuration options for the command execution process.
+ */
+interface CommandOptions {
+    /** The directory in which the command will be executed. */
+    workingDirectory: string;
+}
+/**
+ * Defines key-value pairs for environment variables to add during execution.
+ */
+interface EnvironmentVariables {
+    [key: string]: string;
+}
+/**
+ * Defines the structured output returned after command execution.
+ */
+interface CommandOutput {
+    /** The exit code returned by the executed process (0 usually means success). */
+    exitCode: number;
+    /** The standard output stream content. */
+    standardOutput: string;
+    /** The standard error stream content. */
+    errorOutput: string;
+}
+/**
+ * @class Command
+ * @description Static utility class for executing system commands.
+ */
+export declare class Command {
+    /**
+     * Executes a system command with specified configuration, environment variables, and exclusions.
+     *
+     * @param {string} command The command string to execute (e.g., "ls -l").
+     * @param {CommandOptions} [options] Optional configuration for the execution environment.
+     * @param {EnvironmentVariables} [add] Optional environment variables to add to the process.
+     * @param {string[]} [remove] Optional list of environment variable keys to remove from the process.
+     * @returns {CommandOutput} A structured object containing the exit code and output streams.
+     */
+    static execute(command: string, options?: CommandOptions, add?: EnvironmentVariables, remove?: string[]): CommandOutput;
+}
+export {};

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

@@ -0,0 +1,35 @@
+/**
+ * Interface defining the execution parameters expected by the Engine class.
+ */
+export interface ExecutionParameters {
+    [key: string]: any;
+}
+/**
+ * @class Engine
+ * @description Represents a specific execution engine type (e.g., JavaScript, Groovy)
+ * and provides methods to interact with the platform's execution facade.
+ */
+export declare class Engine {
+    private type;
+    /**
+     * Creates an instance of Engine.
+     * @param {string} type The type of the execution engine (e.g., "javascript").
+     */
+    constructor(type: string);
+    /**
+     * Retrieves the list of available engine types from the platform.
+     * @returns {string[]} An array of supported engine type names.
+     */
+    static getTypes(): string[];
+    /**
+     * Executes a project script or process using the configured engine type.
+     *
+     * @param {string} projectName The name of the project.
+     * @param {string} projectFilePath The relative path to the main file to execute within the project (e.g., "lib/script.js").
+     * @param {string} projectFilePathParam A secondary file path parameter (often unused or context-specific).
+     * @param {ExecutionParameters} parameters An object containing key/value parameters to pass to the script context.
+     * @param {boolean} [debug=false] Whether to execute in debug mode.
+     * @returns {any} The result returned by the executed script.
+     */
+    execute(projectName: string, projectFilePath: string, projectFilePathParam: string, parameters: ExecutionParameters, debug?: boolean): any;
+}

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

@@ -0,0 +1,16 @@
+export * from "./command";
+export { Command as command } from "./command";
+export * from "./engines";
+export { Engine as engines } from "./engines";
+export * from "./lifecycle";
+export { Lifecycle as lifecycle } from "./lifecycle";
+export * from "./os";
+export { OS as os } from "./os";
+export * from "./problems";
+export { Problems as problems } from "./problems";
+export * from "./registry";
+export { Registry as registry } from "./registry";
+export * from "./repository";
+export { Repository as repository } from "./repository";
+export * from "./workspace";
+export { Workspace as workspace } from "./workspace";

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

@@ -0,0 +1,22 @@
+/**
+ * @class Lifecycle
+ * @description Static utility class to publish and unpublish projects on the platform.
+ */
+export declare class Lifecycle {
+    /**
+     * Publishes a project for a specific user and workspace.
+     *
+     * @param {string} user The username of the owner of the workspace.
+     * @param {string} workspace The name of the workspace to publish from.
+     * @param {string} [project="*"] The specific project name to publish. Use "*" to publish all projects in the workspace.
+     * @returns {boolean} True if the publish operation was successful, false otherwise.
+     */
+    static publish(user: string, workspace: string, project?: string): boolean;
+    /**
+     * Unpublishes a currently deployed project.
+     *
+     * @param {string} [project="*"] The specific project name to unpublish. Use "*" to unpublish all currently deployed projects.
+     * @returns {boolean} True if the unpublish operation was successful, false otherwise.
+     */
+    static unpublish(project?: string): boolean;
+}

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

@@ -0,0 +1,23 @@
+/**
+ * @class OS
+ * @description Provides static methods and constants related to the operating system
+ * the underlying Java platform is running on.
+ */
+export declare class OS {
+    /**
+     * The full name of the operating system (e.g., "Windows 10", "Linux").
+     * This value is read directly from the Java system property 'os.name'.
+     * @type {string}
+     */
+    static readonly OS_NAME: string;
+    /**
+     * Checks if the operating system is a variant of Windows.
+     * @returns {boolean} True if the OS is Windows, false otherwise.
+     */
+    static isWindows(): boolean;
+    /**
+     * Checks if the operating system is a variant of Unix (including Linux, macOS, and BSD).
+     * @returns {boolean} True if the OS is Unix-like, false otherwise.
+     */
+    static isUnix(): boolean;
+}

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

@@ -0,0 +1,114 @@
+/**
+ * @interface Problem
+ * @description Represents a single problem or issue recorded in the system.
+ */
+export interface Problem {
+    /** The unique identifier of the problem. */
+    id: number;
+    /** The resource path or file location where the problem was detected. */
+    location: string;
+    /** The severity or nature of the problem (e.g., "Error", "Warning"). */
+    type: string;
+    /** The line number in the source where the problem occurred. */
+    line: string;
+    /** The column number in the source where the problem occurred. */
+    column: string;
+    /** A brief description of the cause of the problem. */
+    cause: string;
+    /** A description of the expected state or value. */
+    expected: string;
+    /** The timestamp when the problem was created. */
+    createdAt: Date;
+    /** The user who created or triggered the problem record. */
+    createdBy: string;
+    /** The category of the problem (e.g., "Syntax", "Deployment"). */
+    category: string;
+    /** The module or component where the problem was found. */
+    module: string;
+    /** The original source code or content related to the problem. */
+    source: string;
+    /** The program or file name associated with the problem. */
+    program: string;
+    /** The current status of the problem (e.g., ACTIVE, SOLVED, IGNORED). */
+    status: string;
+}
+/**
+ * @class Problems
+ * @description Static utility class for managing system problems via the ProblemsFacade.
+ */
+export declare class Problems {
+    /** Status indicating a newly reported or unresolved problem. */
+    static readonly ACTIVE = "ACTIVE";
+    /** Status indicating a problem that has been fixed or is no longer relevant. */
+    static readonly SOLVED = "SOLVED";
+    /** Status indicating a problem that is known but deliberately being disregarded. */
+    static readonly IGNORED = "IGNORED";
+    /**
+     * Saves a new problem entry to the system's problem log.
+     *
+     * @param {string} location The resource path or file location.
+     * @param {string} type The severity or nature of the problem.
+     * @param {string} line The line number.
+     * @param {string} column The column number.
+     * @param {string} cause The cause description.
+     * @param {string} expected The expected state/value description.
+     * @param {string} category The problem category.
+     * @param {string} module The module/component name.
+     * @param {string} source The original source content.
+     * @param {string} program The program or file name.
+     */
+    static save(location: string, type: string, line: string, column: string, cause: string, expected: string, category: string, module: string, source: string, program: string): void;
+    /**
+     * Finds a specific problem by its unique ID.
+     * Note: The underlying facade returns a JSON string which is parsed here.
+     *
+     * @param {number} id The unique problem ID.
+     * @returns {Problem} The found Problem object.
+     */
+    static findProblem(id: number): Problem;
+    /**
+     * Fetches all recorded problems in the system.
+     * Note: The underlying facade returns a JSON string which is parsed here.
+     *
+     * @returns {Problem[]} An array of all Problem objects.
+     */
+    static fetchAllProblems(): Problem[];
+    /**
+     * Fetches a batch of problems based on a custom condition and limit.
+     *
+     * @param {string} condition A SQL-like condition string (e.g., "CATEGORY='Syntax'").
+     * @param {number} limit The maximum number of problems to retrieve.
+     * @returns {Problem[]} An array of Problem objects matching the condition.
+     */
+    static fetchProblemsBatch(condition: string, limit: number): Problem[];
+    /**
+     * Deletes a problem record by its unique ID.
+     *
+     * @param {number} id The unique problem ID to delete.
+     */
+    static deleteProblem(id: number): void;
+    /**
+     * Deletes all problem records that currently have the specified status.
+     *
+     * @param {string} status The status (e.g., Problems.SOLVED or Problems.IGNORED).
+     */
+    static deleteAllByStatus(status: string): void;
+    /**
+     * Clears (deletes) all problem records in the system, regardless of status.
+     */
+    static clearAllProblems(): void;
+    /**
+     * Updates the status of a single problem by its ID.
+     *
+     * @param {number} id The unique problem ID.
+     * @param {string} status The new status (e.g., Problems.SOLVED).
+     */
+    static updateStatus(id: number, status: string): void;
+    /**
+     * Updates the status of multiple problems identified by an array of IDs.
+     *
+     * @param {number[]} ids An array of unique problem IDs.
+     * @param {string} status The new status to apply to all problems.
+     */
+    static updateStatusMultiple(ids: number[], status: string): void;
+}

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

@@ -0,0 +1,227 @@
+/**
+ * @class Registry
+ * @description Static utility class providing high-level access to the RegistryFacade for
+ * retrieving content and metadata by path.
+ */
+export declare class Registry {
+    /**
+     * Retrieves the content of a registry resource at the given path, converting it into a
+     * JavaScript-friendly byte array format.
+     *
+     * @param {string} path The absolute path to the resource (e.g., "/registry/public/myFile.txt").
+     * @returns {any[]} The resource content as a JavaScript byte array.
+     */
+    static getContent(path: string): any[];
+    /**
+     * Retrieves the content of a registry resource at the given path in its native Java byte array format.
+     *
+     * @param {string} path The absolute path to the resource.
+     * @returns {any[]} The resource content as a native Java byte array.
+     */
+    static getContentNative(path: string): any[];
+    /**
+     * Retrieves the content of a registry resource at the given path as a string.
+     *
+     * @param {string} path The absolute path to the resource.
+     * @returns {string} The resource content as plain text.
+     */
+    static getText(path: string): string;
+    /**
+     * Searches the registry starting from a given path for resources matching a glob pattern.
+     *
+     * @param {string} path The starting path for the search.
+     * @param {string} pattern The glob pattern to match resource names against (e.g., "*.js").
+     * @returns {string[]} An array of registry paths (strings) that match the search criteria.
+     */
+    static find(path: string, pattern: string): string[];
+    /**
+     * Gets the root directory object for the public registry space.
+     *
+     * @returns {Directory} A Directory instance representing the root public collection.
+     */
+    static getRoot(): Directory;
+}
+/**
+ * @class Artefact
+ * @description Represents a file or resource (non-collection) within the Registry.
+ */
+export declare class Artefact {
+    private readonly native;
+    /**
+     * @constructor
+     * @param {any} native The native Java object instance representing the repository resource.
+     */
+    constructor(native: any);
+    /**
+     * Gets the name of the artefact (file name).
+     * @returns {string} The name.
+     */
+    getName(): string;
+    /**
+     * Gets the full registry path of the artefact.
+     * @returns {string} The registry path.
+     */
+    getPath(): string;
+    /**
+     * Gets the parent directory of this artefact.
+     * @returns {Directory} The parent Directory instance.
+     */
+    getParent(): Directory;
+    /**
+     * Gets detailed metadata about the artefact.
+     * @returns {ArtefactInformation} The metadata object.
+     */
+    getInformation(): ArtefactInformation;
+    /**
+     * Checks if the artefact currently exists in the registry.
+     * @returns {boolean} True if the artefact exists, false otherwise.
+     */
+    exists(): boolean;
+    /**
+     * Checks if the artefact (file) is empty (has zero size).
+     * @returns {boolean} True if the content is empty, false otherwise.
+     */
+    isEmpty(): boolean;
+    /**
+     * Gets the content of the artefact as a text string.
+     * @returns {string} The text content.
+     */
+    getText(): string;
+    /**
+     * Gets the content of the artefact as a JavaScript-friendly byte array.
+     * @returns {any[]} The content bytes.
+     */
+    getContent(): any[];
+    /**
+     * Gets the content of the artefact as its native Java byte array representation.
+     * @returns {any[]} The content bytes.
+     */
+    getContentNative(): any[];
+    /**
+     * Checks if the artefact content is determined to be binary.
+     * @returns {boolean} True if binary, false if text.
+     */
+    isBinary(): boolean;
+    /**
+     * Gets the content type (MIME type) of the artefact.
+     * @returns {string} The content type string.
+     */
+    getContentType(): string;
+}
+/**
+ * @class Directory
+ * @description Represents a collection or folder within the Registry.
+ */
+export declare class Directory {
+    private readonly native;
+    /**
+     * @constructor
+     * @param {any} native The native Java object instance representing the repository collection.
+     */
+    constructor(native: any);
+    /**
+     * Gets the name of the directory (folder name).
+     * @returns {string} The name.
+     */
+    getName(): string;
+    /**
+     * Gets the full registry path of the directory.
+     * @returns {string} The registry path.
+     */
+    getPath(): string;
+    /**
+     * Gets the parent directory.
+     * @returns {Directory} The parent Directory instance.
+     */
+    getParent(): Directory;
+    /**
+     * Gets detailed metadata about the directory.
+     * @returns {ArtefactInformation} The metadata object.
+     */
+    getInformation(): ArtefactInformation;
+    /**
+     * Checks if the directory currently exists in the registry.
+     * @returns {boolean} True if the directory exists, false otherwise.
+     */
+    exists(): boolean;
+    /**
+     * Checks if the directory is empty (contains no files or sub-directories).
+     * @returns {boolean} True if empty, false otherwise.
+     */
+    isEmpty(): boolean;
+    /**
+     * Gets the names of all sub-directories within this directory.
+     * @returns {string[]} An array of sub-directory names.
+     */
+    getDirectoriesNames(): string[];
+    /**
+     * Gets a specific sub-directory by name.
+     * @param {string} name The name of the sub-directory.
+     * @returns {Directory} The child Directory instance.
+     */
+    getDirectory(name: string): Directory;
+    /**
+     * Gets the names of all files (artefacts) within this directory.
+     * @returns {string[]} An array of artefact names.
+     */
+    getArtefactsNames(): string[];
+    /**
+     * Gets a specific file (artefact) by name.
+     * @param {string} name The name of the artefact.
+     * @returns {Artefact} The child Artefact instance.
+     */
+    getArtefact(name: string): Artefact;
+}
+/**
+ * @class ArtefactInformation
+ * @description Represents detailed metadata (creation date, size, permissions, etc.) for a
+ * Directory or Artefact.
+ */
+export declare class ArtefactInformation {
+    private readonly native;
+    /**
+     * @constructor
+     * @param {any} native The native Java object instance holding the artefact information.
+     */
+    constructor(native: any);
+    /**
+     * Gets the name of the resource.
+     * @returns {string} The name.
+     */
+    getName(): string;
+    /**
+     * Gets the full registry path of the resource.
+     * @returns {string} The registry path.
+     */
+    getPath(): string;
+    /**
+     * Gets the access permissions for the resource (typically an integer bitmask).
+     * @returns {number} The permissions value.
+     */
+    getPermissions(): number;
+    /**
+     * Gets the size of the resource content in bytes.
+     * @returns {number} The size in bytes.
+     */
+    getSize(): number;
+    /**
+     * Gets the user who created the resource.
+     * @returns {string} The creator's name.
+     */
+    getCreatedBy(): string;
+    /**
+     * Gets the creation timestamp.
+     * @returns {Date} The creation date and time.
+     */
+    getCreatedAt(): Date;
+    /**
+     * Gets the user who last modified the resource.
+     * @returns {string} The modifier's name.
+     */
+    getModifiedBy(): string;
+    /**
+     * Gets the last modification timestamp.
+     * @returns {Date} The modification date and time.
+     */
+    getModifiedAt(): Date;
+}