@aerokit/sdk 12.44.0

package/dist/dts/security/user.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Provides static access to the currently authenticated user's security and session context.
+ * This class acts as a facade for the underlying UserFacade component.
+ */
+export declare class User {
+    /**
+     * Retrieves the principal name (username or ID) of the currently authenticated user.
+     *
+     * @returns The user's name or identifier as a string.
+     */
+    static getName(): string;
+    /**
+     * Checks if the currently authenticated user is assigned to a specific security role.
+     *
+     * @param role The name of the role to check (e.g., 'Administrator', 'User').
+     * @returns True if the user is in the specified role, false otherwise.
+     */
+    static isInRole(role: string): boolean;
+    /**
+     * Retrieves the remaining session timeout for the current user session in seconds.
+     *
+     * @returns The session timeout duration in seconds.
+     */
+    static getTimeout(): number;
+    /**
+     * Retrieves the authentication mechanism used for the current session (e.g., 'BASIC', 'FORM').
+     *
+     * @returns The type of authentication used.
+     */
+    static getAuthType(): string;
+    /**
+     * Retrieves the security token associated with the current user session.
+     * This might be a session ID or an access token.
+     *
+     * @returns The security token as a string.
+     */
+    static getSecurityToken(): string;
+    /**
+     * Retrieves the number of requests (invocations) made by the current user
+     * during the lifecycle of the current session.
+     *
+     * @returns The total invocation count.
+     */
+    static getInvocationCount(): number;
+    /**
+     * Retrieves the preferred language setting (e.g., 'en', 'de', 'es') for the current user.
+     *
+     * @returns The user's preferred language code.
+     */
+    static getLanguage(): string;
+}

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

@@ -0,0 +1,98 @@
+/**
+ * An internal wrapper class that adapts a native template engine implementation.
+ * It manages the engine instance and optional custom start/end markers.
+ */
+declare class TemplateEngine {
+    private engine;
+    /** The start marker string (e.g., '{{' for Mustache). */
+    private sm;
+    /** The end marker string (e.g., '}}' for Mustache). */
+    private em;
+    /**
+     * Creates an instance of TemplateEngine.
+     *
+     * @param engine The native template engine object from the Facade.
+     * @param type The type of the engine ('mustache', 'velocity', 'javascript').
+     */
+    constructor(engine: any, type: string);
+    /**
+     * Generates the final output by executing the template with the provided parameters.
+     * Note: Parameters are internally serialized to JSON before being passed to the native engine.
+     *
+     * @param location A string identifying the template (used for error reporting/caching, often a file path).
+     * @param template The raw template string content to process.
+     * @param parameters An object containing the context data to be used in the template.
+     * @returns The processed output string.
+     */
+    generate(location: string, template: string, parameters: {
+        [key: string]: any;
+    }): string;
+    /**
+     * Sets a custom start marker for the template engine. This is primarily useful for Mustache.
+     *
+     * @param sm The new start marker string.
+     */
+    setSm(sm: any): void;
+    /**
+     * Sets a custom end marker for the template engine. This is primarily useful for Mustache.
+     *
+     * @param em The new end marker string.
+     */
+    setEm(em: any): void;
+}
+/**
+ * Provides access to various server-side template engines (Velocity, Mustache, JavaScript).
+ * It offers utility methods for generating content from templates directly or from files
+ * stored in the registry.
+ */
+export declare class TemplateEngines {
+    /**
+     * Retrieves the default template engine, which is currently the Velocity engine.
+     *
+     * @returns The default template engine instance.
+     */
+    static getDefaultEngine(): TemplateEngine;
+    /**
+     * Retrieves the Mustache template engine instance.
+     * Mustache is often used for logic-less templating and uses '{{' and '}}' as default markers.
+     *
+     * @returns The Mustache template engine instance.
+     */
+    static getMustacheEngine(): TemplateEngine;
+    /**
+     * Retrieves the Velocity template engine instance.
+     * Velocity is often used for complex templating with directives (e.g., #set, #foreach).
+     *
+     * @returns The Velocity template engine instance.
+     */
+    static getVelocityEngine(): TemplateEngine;
+    /**
+     * Retrieves the JavaScript template engine instance (usually used for server-side evaluation).
+     *
+     * @returns The JavaScript template engine instance.
+     */
+    static getJavascriptEngine(): TemplateEngine;
+    /**
+     * Generates output by processing a raw template string using the **default template engine (Velocity)**.
+     *
+     * @param location A string identifying the template (used for error reporting/caching, often a file path).
+     * @param template The raw template string content to process.
+     * @param parameters An object containing key-value pairs to be used as context variables in the template.
+     * @returns The processed output string.
+     */
+    static generate(location: string, template: string, parameters: {
+        [key: string]: any;
+    }): string;
+    /**
+     * Loads a template from the public registry, selects an appropriate engine, and generates output.
+     * It uses the **Mustache engine** if the file extension is `.mustache`, otherwise it uses the **default (Velocity)**.
+     *
+     * @param location The path to the template file within the `/registry/public/` directory (e.g., 'templates/email.mustache').
+     * @param parameters An object containing key-value pairs to be used as context variables in the template.
+     * @returns The processed output string, or `undefined` if the resource does not exist.
+     */
+    static generateFromFile(location: string, parameters: {
+        [key: string]: any;
+    }): string | undefined;
+}
+export {};

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

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

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

@@ -0,0 +1,39 @@
+/**
+ * Transforms a string to an alphanumeric sequence, stripping non-conformant characters for it.
+ * @param string {String} the string to transform
+ */
+export declare class Alphanumeric {
+    static toAlphanumeric(string: string): string;
+    /**
+     * Generates a random alphanumeric sequence with the specified length
+     * @param length {Integer} Defaults to 4
+     */
+    static randomString(length: number, charset: string): string;
+    /**
+     * Generates a random alphanumeric sequence with the specified length
+     * @param length {Integer} Defaults to 4
+     * @param lowercase {Boolean} Defaults to true
+     */
+    static alphanumeric(length: number, lowercase: boolean): string;
+    /**
+     * Generates a random ASCII sequence with the specified length
+     * @param length {Integer} Defaults to 4
+     * @param lowercase {Boolean} Defaults to true
+     */
+    static alpha(length: number, lowercase: boolean): string;
+    /**
+     * Generates a random numeric value
+     * @param length {Integer} Defaults to 4
+     */
+    static numeric(length: number): string;
+    /**
+     * Tests is the provided `str` argument is a valid numeric sequence.
+     * @param str {String} the string to test
+     */
+    static isNumeric(str: string): boolean;
+    /**
+     * Tests is the provided `str` argument is a valid alphanumeric sequence.
+     * @param str {String} the string to test
+     */
+    static isAlphanumeric(str: string): boolean;
+}

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

@@ -0,0 +1,48 @@
+/**
+ * Utility class for performing **Base64 encoding and decoding** of data.
+ * It handles conversion between JavaScript strings, JavaScript byte arrays (any[]),
+ * and the native Java byte arrays required by the underlying Base64Facade.
+ */
+export declare class Base64 {
+    /**
+     * Base64 encoding: Converts the input data (text or byte array) into a
+     * standard **Base64 encoded string representation**.
+     *
+     * @param input The data to encode, either as a string or a JavaScript byte array (any[]).
+     * @returns The resulting Base64 encoded string.
+     */
+    static encode(input: string | any[]): string;
+    /**
+     * Base64 encoding: Converts the input data (text or byte array) into a
+     * **JavaScript byte array (any[])** containing the Base64 encoded representation.
+     *
+     * @param input The data to encode, either as a string or a JavaScript byte array (any[]).
+     * @returns The resulting byte array containing the Base64 encoded data.
+     */
+    static encodeAsBytes(input: string | any[]): any[];
+    /**
+     * Base64 encoding: Converts the input data (text or byte array) into a
+     * **native Java byte array** containing the Base64 encoded representation.
+     * This method is generally for internal use.
+     *
+     * @param input The data to encode, either as a string or a JavaScript byte array (any[]).
+     * @returns The resulting native Java byte array containing the Base64 data.
+     */
+    static encodeAsNativeBytes(input: string | any[]): any[];
+    /**
+     * Base64 decoding: Converts a Base64 input (text or byte array) back into
+     * the original **raw byte array (JavaScript any[])**.
+     *
+     * @param input The Base64 data to decode, either as a string or a JavaScript byte array (any[]).
+     * @returns The decoded raw byte array (any[]). Returns null if decoding fails or input is null.
+     */
+    static decode(input: string | any[]): any[];
+    /**
+     * Base64 decoding: Converts a Base64 input (text or byte array) back into
+     * the original **native Java raw byte array**. This method is generally for internal use.
+     *
+     * @param input The Base64 data to decode, either as a string or a JavaScript byte array (any[]).
+     * @returns The decoded native Java byte array.
+     */
+    static decodeAsNativeBytes(input: string | any[]): any[];
+}

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

@@ -0,0 +1,44 @@
+/**
+ * Utility class for converting and normalizing common data types (Date, Boolean)
+ * within an object structure, typically for persistence or API consumption.
+ */
+export declare class Converter {
+    /**
+     * Converts a date property value within an object into a Unix timestamp (milliseconds since epoch).
+     *
+     * @param obj The object containing the property to be converted.
+     * @param property The string name of the date property (e.g., 'dateCreated').
+     * @example
+     * // Before: { date: "2024-01-01T10:00:00Z" }
+     * Converter.setDate(obj, 'date');
+     * // After: { date: 1704096000000 }
+     */
+    static setDate(obj: any, property: string): void;
+    /**
+     * Converts a date property value into an ISO 8601 string, adjusted to represent
+     * the start of that day (local midnight) to handle timezone offsets consistently.
+     * This is typically used for fields that should represent a date *only*, without time of day ambiguity.
+     *
+     * @param obj The object containing the property to be converted.
+     * @param property The string name of the date property (e.g., 'birthday').
+     * @example
+     * // If local timezone is EST (UTC-5):
+     * // Before: { date: "2024-01-01" }
+     * Converter.setLocalDate(obj, 'date');
+     * // After: { date: "2024-01-01T05:00:00.000Z" } (start of day UTC)
+     */
+    static setLocalDate(obj: any, property: string): void;
+    /**
+     * Explicitly coerces a property value to a strict boolean type (`true` or `false`).
+     * This handles truthy/falsy values like `1`, `0`, `null`, and empty strings.
+     *
+     * @param obj The object containing the property to be converted.
+     * @param property The string name of the boolean property (e.g., 'isActive').
+     * @example
+     * // Before: { flag: 1, other: null }
+     * Converter.setBoolean(obj, 'flag');
+     * Converter.setBoolean(obj, 'other');
+     * // After: { flag: true, other: false }
+     */
+    static setBoolean(obj: any, property: string): void;
+}

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

@@ -0,0 +1,50 @@
+export declare class Digest {
+    /**
+     * Calculate MD5 digest from input (text or byte array) and return result as byte array
+     */
+    static md5(input: string | any[]): any[];
+    /**
+     * Calculate MD5 digest from input (text or byte array) and return result as 16 elements java native byte array
+     */
+    static md5AsNativeBytes(input: string | any[]): any[];
+    /**
+     * Calculate MD5 digest from input (text or byte array) and return result as 32 character hex string
+     */
+    static md5Hex(input: string | any[]): string;
+    /**
+     * Calculate SHA1 digest from input (text or byte array) and return result as 20 elements byte array
+     */
+    static sha1(input: string | any[]): any[];
+    /**
+     * Calculate SHA1 digest from input (text or byte array) and return result as 20 elements java native byte array
+     */
+    static sha1AsNativeBytes(input: string | any[]): any[];
+    /**
+     * Calculate SHA256 digest from input (text or byte array) and return result as 32 elements byte array
+     */
+    static sha256(input: string | any[]): any[];
+    /**
+     * Calculate SHA256 digest from input (text or byte array) and return result as 32 elements java native byte array
+     */
+    static sha256AsNativeBytes(input: string | any[]): any[];
+    /**
+     * Calculate SHA384 digest from input (text or byte array) and return result as 48 elements byte array
+     */
+    static sha384(input: string | any[]): any[];
+    /**
+     * Calculate SHA384 digest from input (text or byte array) and return result as 48 elements java native byte array
+     */
+    static sha384AsNativeBytes(input: string | any[]): any[];
+    /**
+     * Calculate SHA512 digest from input (text or byte array) and return result as 64 elements byte array
+     */
+    static sha512(input: string | any[]): any[];
+    /**
+     * Calculate SHA512 digest from input (text or byte array) and return result as 64 elements java native byte array
+     */
+    static sha512AsNativeBytes(input: string | any[]): any;
+    /**
+     * Calculate SHA1 digest from input (text or byte array) and return result as 40 character hex string
+     */
+    static sha1Hex(input: string | any[]): string;
+}

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

@@ -0,0 +1,110 @@
+/**
+ * Utility class for performing context-aware string escaping and unescaping operations,
+ * delegating to a native Java EscapeFacade. These methods are essential for security
+ * (preventing injection attacks) and ensuring correct data serialization across different formats.
+ */
+export declare class Escape {
+    /**
+     * Escapes special characters in a string to make it safe for use as a value within a CSV file.
+     * Typically handles double quotes, commas, and newlines.
+     *
+     * @param input The string to be escaped.
+     * @returns The CSV-safe escaped string.
+     */
+    static escapeCsv(input: string): string;
+    /**
+     * Escapes characters in a string to create a valid JavaScript string literal.
+     * This makes it safe for embedding string values within JavaScript code blocks.
+     *
+     * @param input The string to be escaped.
+     * @returns The JavaScript-safe escaped string.
+     */
+    static escapeJavascript(input: string): string;
+    /**
+     * Escapes characters in a string using HTML 3.2 entity references.
+     *
+     * @param input The string to be escaped.
+     * @returns The HTML 3.2 escaped string.
+     */
+    static escapeHtml3(input: string): string;
+    /**
+     * Escapes characters in a string using HTML 4.0 entity references.
+     * This is the common standard for escaping characters like <, >, &, and ".
+     *
+     * @param input The string to be escaped.
+     * @returns The HTML 4.0 escaped string.
+     */
+    static escapeHtml4(input: string): string;
+    /**
+     * Escapes characters in a string to create a valid Java string literal.
+     *
+     * @param input The string to be escaped.
+     * @returns The Java-safe escaped string.
+     */
+    static escapeJava(input: string): string;
+    /**
+     * Escapes characters (like quotes, backslashes, and control characters) in a string
+     * to make it safe for embedding as a value within a JSON document.
+     *
+     * @param input The string to be escaped.
+     * @returns The JSON-safe escaped string.
+     */
+    static escapeJson(input: string): string;
+    /**
+     * Escapes characters in a string to make it valid for use within an XML document.
+     * Typically handles characters like <, >, &, ", and '.
+     *
+     * @param input The string to be escaped.
+     * @returns The XML-safe escaped string.
+     */
+    static escapeXml(input: string): string;
+    /**
+     * The inverse of `escapeCsv`: unescapes CSV-specific escape sequences back to their original form.
+     *
+     * @param input The CSV-escaped string.
+     * @returns The unescaped string.
+     */
+    static unescapeCsv(input: string): string;
+    /**
+     * The inverse of `escapeJavascript`: unescapes JavaScript string literals.
+     *
+     * @param input The JavaScript-escaped string.
+     * @returns The unescaped string.
+     */
+    static unescapeJavascript(input: string): string;
+    /**
+     * The inverse of `escapeHtml3`: unescapes HTML 3.2 entity references.
+     *
+     * @param input The HTML 3.2 escaped string.
+     * @returns The unescaped string.
+     */
+    static unescapeHtml3(input: string): string;
+    /**
+     * The inverse of `escapeHtml4`: unescapes HTML 4.0 entity references.
+     *
+     * @param input The HTML 4.0 escaped string.
+     * @returns The unescaped string.
+     */
+    static unescapeHtml4(input: string): string;
+    /**
+     * The inverse of `escapeJava`: unescapes Java string literals.
+     *
+     * @param input The Java-escaped string.
+     * @returns The unescaped string.
+     */
+    static unescapeJava(input: string): string;
+    /**
+     * The inverse of `escapeJson`: unescapes JSON string escape sequences.
+     *
+     * @param input The JSON-escaped string.
+     * @returns The unescaped string.
+     */
+    static unescapeJson(input: string): string;
+    /**
+     * The inverse of `escapeXml`: unescapes XML entity references.
+     *
+     * @param input The XML-escaped string.
+     * @returns The unescaped string.
+     */
+    static unescapeXml(input: string): string;
+}

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

@@ -0,0 +1,48 @@
+/**
+ * Utility class for performing **Hexadecimal encoding and decoding** of data.
+ * It handles conversion between JavaScript strings, JavaScript byte arrays (any[]),
+ * and the native Java byte arrays required by the underlying HexFacade.
+ */
+export declare class Hex {
+    /**
+     * Hexadecimal encoding: Converts the input data (text or byte array) into a
+     * standard **hexadecimal string representation**.
+     *
+     * @param input The data to encode, either as a string or a JavaScript byte array (any[]).
+     * @returns The resulting hexadecimal string.
+     */
+    static encode(input: string | any[]): string;
+    /**
+     * Hexadecimal encoding: Converts the input data (text or byte array) into a
+     * **JavaScript byte array (any[])** containing the hexadecimal representation.
+     *
+     * @param input The data to encode, either as a string or a JavaScript byte array (any[]).
+     * @returns The resulting byte array containing the hexadecimal data.
+     */
+    static encodeAsBytes(input: string | any[]): any[];
+    /**
+     * Hexadecimal encoding: Converts the input data (text or byte array) into a
+     * **native Java byte array** containing the hexadecimal representation.
+     * This method is generally for internal use.
+     *
+     * @param input The data to encode, either as a string or a JavaScript byte array (any[]).
+     * @returns The resulting native Java byte array.
+     */
+    static encodeAsNativeBytes(input: string | any[]): any[];
+    /**
+     * Hexadecimal decoding: Converts a hexadecimal input (text or byte array) back into
+     * the original **raw byte array (JavaScript any[])**.
+     *
+     * @param input The hexadecimal data to decode, either as a string or a JavaScript byte array (any[]).
+     * @returns The decoded raw byte array (any[]). Returns null if decoding fails or input is null.
+     */
+    static decode(input: string | any[]): any[];
+    /**
+     * Hexadecimal decoding: Converts a hexadecimal input (text or byte array) back into
+     * the original **native Java raw byte array**. This method is generally for internal use.
+     *
+     * @param input The hexadecimal data to decode, either as a string or a JavaScript byte array (any[]).
+     * @returns The decoded native Java byte array.
+     */
+    static decodeAsNativeBytes(input: string | any[]): any;
+}

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

@@ -0,0 +1,23 @@
+export * from "./alphanumeric";
+export { Alphanumeric as alphanumeric } from "./alphanumeric";
+export * from "./base64";
+export { Base64 as base64 } from "./base64";
+export * from "./digest";
+export { Digest as digest } from "./digest";
+export * from "./escape";
+export { Escape as escape } from "./escape";
+export * from "./hex";
+export { Hex as hex } from "./hex";
+export * as jsonpath from "./jsonpath";
+export * from "./qrcode";
+export { QRCode as qrcode } from "./qrcode";
+export * from "./url";
+export { URL as url } from "./url";
+export * from "./utf8";
+export { UTF8 as utf8 } from "./utf8";
+export * from "./uuid";
+export { UUID as uuid } from "./uuid";
+export * from "./xml";
+export { XML as xml } from "./xml";
+export * from "./converter";
+export { Converter as converter } from "./converter";

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

@@ -0,0 +1,22 @@
+/**
+ * @param {Object} [opts] If present, must be an object
+ * @param {string} expr JSON path to evaluate
+ * @param {JSON} obj JSON object to evaluate against
+ * @param {Function} callback Passed 3 arguments: 1) desired payload per `resultType`,
+ *     2) `"value"|"property"`, 3) Full returned object with all payloads
+ * @param {Function} otherTypeCallback If `@other()` is at the end of one's query, this
+ *  will be invoked with the value of the item, its path, its parent, and its parent's
+ *  property name, and it should return a boolean indicating whether the supplied value
+ *  belongs to the "other" type or not (or it may handle transformations and return `false`).
+ * @returns {JSONPath}
+ * @class
+ */
+export declare function JSONPath(opts: any, expr: any, obj: any, callback: any, otherTypeCallback: any): void;
+export declare namespace JSONPath {
+    var prototype: any;
+    var cache: {};
+    var toPathString: (pathArr: any) => string;
+    var toPointer: (pointer: any) => string;
+    var toPathArray: (expr: any) => any;
+}
+export default JSONPath;

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

@@ -0,0 +1,16 @@
+/**
+ * Utility class for generating QR codes.
+ * It uses the underlying native Java QRCodeFacade to convert text into
+ * a QR code image represented as a raw byte array.
+ */
+export declare class QRCode {
+    /**
+     * Generates a QR code image byte array from the given text.
+     * The returned byte array represents the image data (e.g., PNG or JPEG format,
+     * depending on the native implementation's default output).
+     *
+     * @param text The string content to be encoded in the QR code.
+     * @returns A **JavaScript byte array (any[])** containing the raw QR code image data.
+     */
+    static generateQRCode(text: string): any[];
+}

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

@@ -0,0 +1,50 @@
+/**
+ * Utility class for performing various forms of URL encoding and decoding.
+ * It wraps native Java URL utility methods for handling query parameters,
+ * path segments, and form data.
+ */
+export declare class URL {
+    /**
+     * URL-encodes the input string, typically used for encoding query parameter values.
+     *
+     * @param input The string to be encoded.
+     * @param charset The character set (e.g., 'UTF-8', 'ISO-8859-1') to use for encoding. Defaults to the system's preferred encoding if omitted.
+     * @returns The URL-encoded string.
+     */
+    static encode(input: string, charset?: string): string;
+    /**
+     * URL-decodes the input string, typically used for decoding query parameter values.
+     *
+     * @param input The string to be decoded.
+     * @param charset The character set (e.g., 'UTF-8', 'ISO-8859-1') that was used for encoding. Defaults to the system's preferred encoding if omitted.
+     * @returns The URL-decoded string.
+     */
+    static decode(input: string, charset?: string): string;
+    /**
+     * Escapes the input string using general URL escaping rules.
+     * This is typically equivalent to `encodeURIComponent` and is suitable for
+     * encoding query parameter *values*.
+     *
+     * @param input The string to escape.
+     * @returns The escaped string.
+     */
+    static escape(input: string): string;
+    /**
+     * Escapes the input string specifically for use as a **URL path segment**.
+     * It typically preserves path delimiters like `/` that might otherwise be escaped
+     * in standard URL encoding.
+     *
+     * @param input The path string to escape.
+     * @returns The escaped path string.
+     */
+    static escapePath(input: string): string;
+    /**
+     * Escapes the input string according to the rules for **HTML Form Data**
+     * (application/x-www-form-urlencoded). This typically replaces spaces with `+`
+     * instead of `%20`.
+     *
+     * @param input The form data string to escape.
+     * @returns The escaped form data string.
+     */
+    static escapeForm(input: string): string;
+}

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

@@ -0,0 +1,33 @@
+/**
+ * Utility class for performing UTF-8 encoding and decoding operations.
+ * It provides methods to handle conversions between standard JavaScript strings and
+ * raw UTF-8 byte representations.
+ */
+export declare class UTF8 {
+    /**
+     * Encodes the input (either a standard JavaScript string or a raw byte array)
+     * into a UTF-8 encoded string representation.
+     *
+     * @param input The text string to be encoded, or a byte array to convert to its string representation.
+     * @returns The resulting UTF-8 encoded string.
+     */
+    static encode(input: string | any[]): string;
+    /**
+     * Decodes the input (either a UTF-8 encoded string or a raw byte array)
+     * back into a standard JavaScript string.
+     *
+     * @param input The UTF-8 encoded string or byte array to be decoded.
+     * @returns The resulting standard decoded string.
+     */
+    static decode(input: string | any[]): string;
+    /**
+     * Decodes a specific segment of a raw byte array into a standard string
+     * using UTF-8 encoding.
+     *
+     * @param bytes The raw byte array containing the UTF-8 data.
+     * @param offset The starting index (inclusive) from which to begin decoding.
+     * @param length The number of bytes to decode starting from the offset.
+     * @returns The decoded string segment.
+     */
+    static bytesToString(bytes: any[], offset: number, length: number): string;
+}

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

@@ -0,0 +1,21 @@
+/**
+ * Utility class for generating and validating Universally Unique Identifiers (UUIDs).
+ * It typically provides access to Type 4 (randomly generated) UUIDs.
+ */
+export declare class UUID {
+    /**
+     * Generates a new random UUID (Type 4).
+     * The generated string is typically in the format: xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx.
+     *
+     * @returns A string representing the newly generated UUID.
+     */
+    static random(): string;
+    /**
+     * Validates if the provided string conforms to the standard UUID format
+     * (e.g., a valid 36-character string including hyphens).
+     *
+     * @param input The string to validate.
+     * @returns true if the input string is a valid UUID, false otherwise.
+     */
+    static validate(input: string): boolean;
+}