@aerokit/sdk 12.44.0

package/dist/dts/bpm/values.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Values
+ * * Utility class for serializing (stringify) and deserializing (parse) complex variable values (like objects and arrays)
+ * to and from JSON strings for storage or transfer across the API boundary.
+ */
+export declare class Values {
+    /**
+     * Attempts to parse a value as a JSON string.
+     * If the value is a valid JSON string (representing an object or array), it is parsed and returned as an object.
+     * If parsing fails (e.g., the value is a primitive or an invalid JSON string), the original value is returned.
+     * @param value The value to parse, typically a string read from the API.
+     * @returns The parsed object, or the original value if parsing fails.
+     */
+    static parseValue(value: any): any;
+    /**
+     * Iterates over the values of a Map and applies {@link #parseValue(any)} to each value.
+     * This is typically used to deserialize all variables returned from an API call.
+     * @param variables The Map of variable names to their values (which may be JSON strings).
+     * @returns The Map with all values deserialized where possible.
+     */
+    static parseValuesMap(variables: Map<string, any>): Map<string, any>;
+    /**
+     * Serializes a value for persistence or API transfer.
+     * Arrays and objects are converted into their respective JSON string representations.
+     * Note: Arrays are additionally converted into a `java.util.List` of stringified elements for Java API compatibility.
+     * Primitive types are returned as is.
+     * @param value The value to serialize.
+     * @returns The JSON string representation, a Java List (for arrays), or the original primitive value.
+     */
+    static stringifyValue(value: any): any;
+    /**
+     * Iterates over the values of a Map and applies {@link #stringifyValue(any)} to each value.
+     * This is typically used to serialize a map of variables before sending them to an API call.
+     * @param variables The Map of variable names to their values.
+     * @returns The Map with all values serialized.
+     */
+    static stringifyValuesMap(variables: Map<string, any>): Map<string, any>;
+}

package/dist/dts/cache/cache.d.ts

@@ -0,0 +1,30 @@
+export declare class Cache {
+    /**
+     * Checks if the cache contains a value for the specified key.
+     * @param key The key to check.
+     * @returns True if the key exists in the cache, false otherwise.
+     */
+    static contains(key: string): boolean;
+    /**
+     * Retrieves the value associated with the specified key from the cache.
+     * @param key The key to retrieve.
+     * @returns The cached value, or `undefined` if the key is not found.
+     */
+    static get(key: any): any | undefined;
+    /**
+     * Stores a value in the cache under the specified key.
+     * Note: The duration/time-to-live (TTL) is typically configured server-side.
+     * @param key The key to store the data under.
+     * @param data The data to store.
+     */
+    static set(key: string, data: any): void;
+    /**
+     * Removes the key and its associated value from the cache.
+     * @param key The key to delete.
+     */
+    static delete(key: string): void;
+    /**
+     * Clears all entries from the cache.
+     */
+    static clear(): void;
+}

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

@@ -0,0 +1,2 @@
+export { Cache as caches } from "./cache";
+export * from "./cache";

package/dist/dts/cms/cmis.d.ts

@@ -0,0 +1,413 @@
+/**
+ * API CMIS
+ * * Note: This module is supported only with the Mozilla Rhino engine
+ * * Provides static access to the CMIS (Content Management Interoperability Services) repository session and utility constants.
+ */
+import * as streams from "@aerokit/sdk/io/streams";
+export declare class Cmis {
+    /**
+     * CMIS method constant for read operations.
+     */
+    static readonly METHOD_READ = "READ";
+    /**
+     * CMIS method constant for write operations.
+     */
+    static readonly METHOD_WRITE = "WRITE";
+    /** CMIS property: Object name. */
+    static readonly NAME = "cmis:name";
+    /** CMIS property: Unique object identifier. */
+    static readonly OBJECT_ID = "cmis:objectId";
+    /** CMIS property: Object type identifier. */
+    static readonly OBJECT_TYPE_ID = "cmis:objectTypeId";
+    /** CMIS property: Base object type identifier. */
+    static readonly BASE_TYPE_ID = "cmis:baseTypeId";
+    /** CMIS property: User who created the object. */
+    static readonly CREATED_BY = "cmis:createdBy";
+    /** CMIS property: Timestamp of object creation. */
+    static readonly CREATION_DATE = "cmis:creationDate";
+    /** CMIS property: User who last modified the object. */
+    static readonly LAST_MODIFIED_BY = "cmis:lastModifiedBy";
+    /** CMIS property: Timestamp of last modification. */
+    static readonly LAST_MODIFICATION_DATE = "cmis:lastModificationDate";
+    /** CMIS property: Change token for object change tracking. */
+    static readonly CHANGE_TOKEN = "cmis:changeToken";
+    /** CMIS property: Indicates if the document is immutable. */
+    static readonly IS_IMMUTABLE = "cmis:isImmutable";
+    /** CMIS property: Indicates if the document is the latest version in the version series. */
+    static readonly IS_LATEST_VERSION = "cmis:isLatestVersion";
+    /** CMIS property: Indicates if the document is a major version. */
+    static readonly IS_MAJOR_VERSION = "cmis:isMajorVersion";
+    /** CMIS property: Indicates if the document is the latest major version. */
+    static readonly IS_LATEST_MAJOR_VERSION = "cmis:isLatestMajorVersion";
+    /** CMIS property: Label of the document version. */
+    static readonly VERSION_LABEL = "cmis:versionLabel";
+    /** CMIS property: ID of the version series. */
+    static readonly VERSION_SERIES_ID = "cmis:versionSeriesId";
+    /** CMIS property: Indicates if the version series is checked out. */
+    static readonly IS_VERSION_SERIES_CHECKED_OUT = "cmis:isVersionSeriesCheckedOut";
+    /** CMIS property: User who checked out the version series. */
+    static readonly VERSION_SERIES_CHECKED_OUT_BY = "cmis:versionSeriesCheckedOutBy";
+    /** CMIS property: ID of the checked-out document object. */
+    static readonly VERSION_SERIES_CHECKED_OUT_ID = "cmis:versionSeriesCheckedOutId";
+    /** CMIS property: Comment associated with the check-in operation. */
+    static readonly CHECKIN_COMMENT = "cmis:checkinComment";
+    /** CMIS property: Length of the content stream in bytes. */
+    static readonly CONTENT_STREAM_LENGTH = "cmis:contentStreamLength";
+    /** CMIS property: MIME type of the content stream. */
+    static readonly CONTENT_STREAM_MIME_TYPE = "cmis:contentStreamMimeType";
+    /** CMIS property: Original file name of the content stream. */
+    static readonly CONTENT_STREAM_FILE_NAME = "cmis:contentStreamFileName";
+    /** CMIS property: ID of the content stream. */
+    static readonly CONTENT_STREAM_ID = "cmis:contentStreamId";
+    /** CMIS property: Object ID of the parent folder. */
+    static readonly PARENT_ID = "cmis:parentId";
+    /** CMIS property: List of allowed object type IDs for children. */
+    static readonly ALLOWED_CHILD_OBJECT_TYPE_IDS = "cmis:allowedChildObjectTypeIds";
+    /** CMIS property: Path of the folder in the repository. */
+    static readonly PATH = "cmis:path";
+    /** CMIS property: Object ID of the relationship source. */
+    static readonly SOURCE_ID = "cmis:sourceId";
+    /** CMIS property: Object ID of the relationship target. */
+    static readonly TARGET_ID = "cmis:targetId";
+    /** CMIS property: Text content of the policy. */
+    static readonly POLICY_TEXT = "cmis:policyText";
+    /** CMIS Versioning State: No versioning. */
+    static readonly VERSIONING_STATE_NONE = "none";
+    /** CMIS Versioning State: Create a new major version. */
+    static readonly VERSIONING_STATE_MAJOR = "major";
+    /** CMIS Versioning State: Create a new minor version. */
+    static readonly VERSIONING_STATE_MINOR = "minor";
+    /** CMIS Versioning State: Document is checked out. */
+    static readonly VERSIONING_STATE_CHECKEDOUT = "checkedout";
+    /** CMIS Object Type ID: Document. */
+    static readonly OBJECT_TYPE_DOCUMENT = "cmis:document";
+    /** CMIS Object Type ID: Folder. */
+    static readonly OBJECT_TYPE_FOLDER = "cmis:folder";
+    /** CMIS Object Type ID: Relationship. */
+    static readonly OBJECT_TYPE_RELATIONSHIP = "cmis:relationship";
+    /** CMIS Object Type ID: Policy. */
+    static readonly OBJECT_TYPE_POLICY = "cmis:policy";
+    /** CMIS Object Type ID: Item. */
+    static readonly OBJECT_TYPE_ITEM = "cmis:item";
+    /** CMIS Object Type ID: Secondary. */
+    static readonly OBJECT_TYPE_SECONDARY = "cmis:secondary";
+    /**
+     * Gets a new CMIS session instance to interact with the repository.
+     * @returns A new {@link Session} instance.
+     */
+    static getSession(): Session;
+    /**
+     * Retrieves access control definitions for a specific path and method.
+     * @param path The path of the CMIS object.
+     * @param method The operation method (e.g., {@link Cmis.METHOD_READ}, {@link Cmis.METHOD_WRITE}).
+     * @returns A list of access definitions.
+     */
+    static getAccessDefinitions(path: string, method: string): AccessDefinition[];
+}
+/**
+ * Represents an access control entry (ACE) for a CMIS object, detailing
+ * who has what permissions on a path.
+ */
+interface AccessDefinition {
+    /** Gets the unique identifier for the access definition. */
+    getId(): string;
+    /** Gets the scope of the definition (e.g., 'user', 'group'). */
+    getScope(): string;
+    /** Gets the path of the CMIS object this definition applies to. */
+    getPath(): string;
+    /** Gets the method/operation this definition applies to (e.g., 'READ', 'WRITE'). */
+    getMethod(): string;
+    /** Gets the security role (e.g., 'Administrator', 'Viewer'). */
+    getRole(): string;
+}
+/**
+ * Session object
+ * * Represents an active connection to a CMIS repository, used as the main entry point for CMIS operations.
+ */
+declare class Session {
+    private readonly native;
+    constructor(native: any);
+    /**
+     * Gets information about the repository this session is connected to.
+     * @returns Repository metadata.
+     */
+    getRepositoryInfo(): RepositoryInfo;
+    /**
+     * Gets the root folder of the repository.
+     * @returns The root {@link Folder} object.
+     */
+    getRootFolder(): Folder;
+    /**
+     * Gets the object factory for creating new CMIS objects like ContentStream.
+     * @returns An {@link ObjectFactory} instance.
+     */
+    getObjectFactory(): ObjectFactory;
+    /**
+     * Retrieves a CMIS object (Document or Folder) by its unique ID.
+     * @param objectId The unique ID of the object.
+     * @returns A {@link Document} or {@link Folder} instance.
+     * @throws Error if the object type is unsupported.
+     */
+    getObject(objectId: string): Folder | Document;
+    /**
+     * Retrieves a CMIS object (Document or Folder) by its path.
+     * @param path The path of the object in the repository (e.g., "/path/to/object").
+     * @returns A {@link Document} or {@link Folder} instance.
+     * @throws Error if read access is not allowed or the object type is unsupported.
+     */
+    getObjectByPath(path: string): Folder | Document;
+    /**
+     * Creates a folder structure recursively based on a path. This is a convenience method that
+     * creates all non-existent parent folders.
+     * Example: `createFolder("/new/path/structure")`
+     * @param location The path of the folder to create.
+     * @returns The newly created (or existing) innermost {@link Folder} object.
+     */
+    createFolder(location: string): Folder;
+    /**
+     * Creates a new document at the specified location. This method ensures the parent folder structure exists.
+     * @param location The path of the parent folder (e.g., "/path/to/folder").
+     * @param properties A map of CMIS properties for the new document (must include {@link Cmis.NAME}).
+     * @param contentStream The content stream containing the document's binary data.
+     * @param versioningState The versioning state (e.g., {@link Cmis.VERSIONING_STATE_MAJOR}).
+     * @returns The newly created {@link Document} object.
+     */
+    createDocument(location: string, properties: {
+        [key: string]: any;
+    }, contentStream: ContentStream, versioningState: string): Document;
+}
+/**
+ * RepositoryInfo object
+ * * Provides basic information about the connected CMIS repository.
+ */
+declare class RepositoryInfo {
+    private readonly native;
+    constructor(native: any);
+    /**
+     * Gets the unique identifier of the repository.
+     * @returns The repository ID.
+     */
+    getId(): string;
+    /**
+     * Gets the name of the repository.
+     * @returns The repository name.
+     */
+    getName(): string;
+}
+/**
+ * Folder object
+ * * Represents a CMIS folder object, allowing operations like creating children, deleting, and renaming.
+ */
+export declare class Folder {
+    private readonly native;
+    private path;
+    constructor(native: any, path: any);
+    /**
+     * Gets the unique identifier of the folder.
+     * @returns The folder ID.
+     */
+    getId(): string;
+    /**
+     * Gets the name of the folder.
+     * @returns The folder name.
+     */
+    getName(): string;
+    /**
+     * Creates a new folder within this folder.
+     * @param properties A map of CMIS properties for the new folder (must include {@link Cmis.NAME}).
+     * @returns The newly created {@link Folder} object.
+     * @throws Error if write access is not allowed.
+     */
+    createFolder(properties: {
+        [key: string]: any;
+    }): Folder;
+    /**
+     * Creates a new document within this folder.
+     * @param properties A map of CMIS properties for the new document (must include {@link Cmis.NAME}).
+     * @param contentStream The content stream containing the document's binary data.
+     * @param versioningState The versioning state (e.g., {@link Cmis.VERSIONING_STATE_MAJOR}).
+     * @returns The newly created {@link Document} object.
+     * @throws Error if write access is not allowed.
+     */
+    createDocument(properties: {
+        [key: string]: any;
+    }, contentStream: ContentStream, versioningState: string): Document;
+    /**
+     * Retrieves the children of this folder.
+     * @returns A list of generic {@link CmisObject} wrappers for the children.
+     * @throws Error if read access is not allowed.
+     */
+    getChildren(): CmisObject[];
+    /**
+     * Gets the path of the folder.
+     * @returns The folder path.
+     */
+    getPath(): string;
+    /**
+     * Checks if this folder is the root folder of the repository.
+     * @returns True if it is the root folder, false otherwise.
+     */
+    isRootFolder(): boolean;
+    /**
+     * Gets the parent folder of this folder.
+     * @returns The parent {@link Folder} object.
+     */
+    getFolderParent(): Folder;
+    /**
+     * Deletes this folder (must be empty to succeed).
+     * @throws Error if write access is not allowed.
+     */
+    delete(): void;
+    /**
+     * Renames this folder.
+     * @param newName The new name for the folder.
+     * @throws Error if write access is not allowed.
+     */
+    rename(newName: string): void;
+    /**
+     * Deletes this folder and all its contents recursively.
+     * @throws Error if write access is not allowed.
+     */
+    deleteTree(): void;
+    /**
+     * Gets the type definition of the folder.
+     * @returns The folder's {@link TypeDefinition}.
+     */
+    getType(): TypeDefinition;
+}
+/**
+ * CmisObject object
+ * * A generic wrapper for CMIS objects, used primarily for children lists.
+ */
+declare class CmisObject {
+    private readonly native;
+    constructor(native: any);
+    /**
+     * Gets the unique identifier of the object.
+     * @returns The object ID.
+     */
+    getId(): string;
+    /**
+     * Gets the name of the object.
+     * @returns The object name.
+     */
+    getName(): string;
+    /**
+     * Gets the path of the CMIS object. Handles differences in native CMIS implementations.
+     * @returns The object path.
+     * @throws Error if the path cannot be determined.
+     */
+    getPath(): string;
+    /**
+     * Gets the type definition of the object.
+     * @returns The object's {@link TypeDefinition}.
+     */
+    getType(): TypeDefinition;
+    /**
+     * Deletes the CMIS object.
+     */
+    delete(): void;
+    /**
+     * Renames the CMIS object.
+     * @param newName The new name for the object.
+     */
+    rename(newName: string): void;
+}
+/**
+ * ObjectFactory object
+ * * Provides methods to create content streams.
+ */
+declare class ObjectFactory {
+    private readonly native;
+    constructor(native: any);
+    /**
+     * Creates a new content stream instance that can be used to create or update document content.
+     * @param filename The name of the file.
+     * @param length The size of the content stream in bytes.
+     * @param mimetype The MIME type of the content.
+     * @param inputStream The input stream containing the data.
+     * @returns A new {@link ContentStream} object.
+     */
+    createContentStream(filename: string, length: number, mimetype: string, inputStream: streams.InputStream): ContentStream;
+}
+/**
+ * ContentStream object
+ * * Represents the binary content stream of a CMIS Document.
+ */
+declare class ContentStream {
+    private readonly native;
+    constructor(native: any);
+    /**
+     * Gets the Java-backed input stream for reading the content.
+     * @returns An {@link streams.InputStream} wrapper.
+     */
+    getStream(): streams.InputStream;
+    /**
+     * Gets the MIME type of the content stream.
+     * @returns The MIME type string.
+     */
+    getMimeType(): string;
+}
+/**
+ * Document object
+ * * Represents a CMIS document object, allowing operations like reading content, deleting, and renaming.
+ */
+export declare class Document {
+    private readonly native;
+    private path;
+    constructor(native: any, path: string);
+    /**
+     * Gets the unique identifier of the document.
+     * @returns The document ID.
+     */
+    getId(): string;
+    /**
+     * Gets the name of the document.
+     * @returns The document name.
+     */
+    getName(): string;
+    /**
+     * Gets the type definition of the document.
+     * @returns The document's {@link TypeDefinition}.
+     */
+    getType(): TypeDefinition;
+    /**
+     * Gets the path of the document.
+     * @returns The document path.
+     */
+    getPath(): string;
+    /**
+     * Deletes this document.
+     * @throws Error if write access is not allowed.
+     */
+    delete(): void;
+    /**
+     * Gets the binary content stream of the document.
+     * @returns The {@link ContentStream} object, or `null` if the document has no content.
+     */
+    getContentStream(): ContentStream | null;
+    /**
+     * Gets the size of the document's content stream in bytes.
+     * @returns The size in bytes.
+     */
+    getSize(): number;
+    /**
+     * Renames this document.
+     * @param newName The new name for the document.
+     * @throws Error if write access is not allowed.
+     */
+    rename(newName: string): void;
+}
+/**
+ * Represents the definition of a CMIS object type (e.g., cmis:document, cmis:folder).
+ */
+declare class TypeDefinition {
+    private readonly native;
+    constructor(native: any);
+    /**
+     * Gets the unique ID of the object type (e.g., 'cmis:document').
+     * @returns The type ID.
+     */
+    getId(): string;
+}
+export {};

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

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

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

@@ -0,0 +1,52 @@
+/**
+ * API DI (Dependency Injection) Decorators
+ * * Provides a hybrid implementation of decorators for Dependency Injection (DI)
+ * that supports both legacy JavaScript environments (like Mozilla Rhino or older GraalJS)
+ * using the `(target, propertyKey)` signature, and modern JavaScript environments
+ * using the decorator metadata and `context.addInitializer`.
+ */
+/**
+ * Extends a standard constructor function to include properties used for internal metadata storage.
+ */
+export interface ComponentConstructor extends Function {
+    new (...args: any[]): any;
+    /** Internal storage for the component's registered name. */
+    __component_name?: string;
+    /** Internal storage for the component's injection map. */
+    __injections_map?: Map<string | symbol, string | undefined>;
+}
+/**
+ * Class decorator that marks a class as a Dependency Injection component.
+ * It registers the component's metadata and wraps the constructor to ensure
+ * dependencies are injected upon instance creation.
+ *
+ * Can be used as `@Component` (uses class name) or `@Component('customName')`.
+ *
+ * @param nameOrConstructor The optional custom component name (string) or the class constructor (Function) when used without parentheses.
+ * @returns A class decorator function or the decorated class itself.
+ */
+export declare function Component(nameOrConstructor?: string | Function): Function;
+/**
+ * An alias for the {@link Component} decorator, used for semantic clarity
+ * in contexts where the class is explicitly intended to be injected elsewhere.
+ * Its functionality is identical to {@link Component}.
+ *
+ * @param nameOrConstructor The optional custom component name (string) or the class constructor (Function).
+ * @returns A class decorator function or the decorated class itself.
+ */
+export declare function Injected(nameOrConstructor?: string | Function): Function;
+/**
+ * Property decorator used to mark an instance property as an injection point.
+ * The runtime will look up a dependency based on the property name or the optional
+ * name provided.
+ *
+ * It supports both modern (`context.addInitializer`) and legacy decorator APIs.
+ *
+ * Usage:
+ * - `@Inject` propertyKey: Injects a component with the same name as `propertyKey`.
+ * - `@Inject('myService')` propertyKey: Injects the component registered as 'myService'.
+ *
+ * @param name The optional name of the component to inject.
+ * @returns A property decorator function.
+ */
+export declare function Inject(name?: string): (...args: any[]) => void;

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

@@ -0,0 +1,2 @@
+export * from "./decorators";
+export * as decorators from "./decorators";

package/dist/dts/core/configurations.d.ts

@@ -0,0 +1,65 @@
+/**
+ * API Configurations
+ * * Provides a static interface for accessing and manipulating configuration properties,
+ * and checking the operating system type.
+ */
+export declare class Configurations {
+    /**
+     * Retrieves the configuration value associated with the given key.
+     * @param key The configuration key.
+     * @param defaultValue The optional default value to return if the key is not found.
+     * @returns The configuration value as a string, or `undefined` if the key is not found and no default is provided.
+     */
+    static get(key: string, defaultValue?: string): string | undefined;
+    /**
+     * Sets the configuration value for the given key.
+     * If the key already exists, its value is overwritten.
+     * @param key The configuration key.
+     * @param value The configuration value to set.
+     */
+    static set(key: string, value: string): void;
+    /**
+     * Removes the configuration property associated with the given key.
+     * @param key The configuration key to remove.
+     */
+    static remove(key: string): void;
+    /**
+     * Retrieves a list of all current configuration keys.
+     * @returns An array of configuration keys (strings).
+     */
+    static getKeys(): string[];
+    /**
+     * Loads configuration properties from a file at the specified path, overriding existing ones.
+     * @param path The file path to load configurations from.
+     */
+    static load(path: string): void;
+    /**
+     * Reloads or updates the current configuration settings from their source (e.g., persistence layer).
+     */
+    static update(): void;
+    /**
+     * Retrieves the name of the current Operating System.
+     * @returns The OS name as a string (e.g., "Windows", "Linux", "Mac OS X").
+     */
+    static getOS(): string;
+    /**
+     * Checks if the current Operating System is Windows.
+     * @returns True if the OS is Windows, false otherwise.
+     */
+    static isOSWindows(): boolean;
+    /**
+     * Checks if the current Operating System is Mac OS (or Mac OS X).
+     * @returns True if the OS is Mac, false otherwise.
+     */
+    static isOSMac(): boolean;
+    /**
+     * Checks if the current Operating System is a UNIX-like system (e.g., Linux, macOS, or others).
+     * @returns True if the OS is a UNIX variant, false otherwise.
+     */
+    static isOSUNIX(): boolean;
+    /**
+     * Checks if the current Operating System is Solaris.
+     * @returns True if the OS is Solaris, false otherwise.
+     */
+    static isOSSolaris(): boolean;
+}

package/dist/dts/core/context.d.ts

@@ -0,0 +1,19 @@
+/**
+ * API Context
+ * * Provides a static interface for accessing and manipulating key-value pairs in a global, application-wide context.
+ */
+export declare class Context {
+    /**
+     * Retrieves the value associated with the specified name from the global context.
+     * @param name The name of the context variable.
+     * @returns The context value, or `undefined` if the name is not found or the value is null.
+     */
+    static get(name: string): any | undefined;
+    /**
+     * Stores a value in the global context under the specified name.
+     * If the name already exists, its value is overwritten.
+     * @param name The name of the context variable.
+     * @param value The value to store.
+     */
+    static set(name: string, value: any): void;
+}

package/dist/dts/core/env.d.ts

@@ -0,0 +1,23 @@
+/**
+ * API Env
+ * * Provides a static interface for accessing and listing environment variables exposed to the runtime.
+ */
+/**
+ * Interface representing a map of environment variable names to their string values.
+ */
+export interface EnvValues {
+    [key: string]: string;
+}
+export declare class Env {
+    /**
+     * Retrieves the value of the environment variable with the specified name.
+     * @param name The name of the environment variable.
+     * @returns The variable's value as a string, or `undefined` if the variable is not set.
+     */
+    static get(name: string): string | undefined;
+    /**
+     * Retrieves a map of all environment variables currently exposed to the application.
+     * @returns An {@link EnvValues} object containing all environment variables as key-value pairs.
+     */
+    static list(): EnvValues;
+}