@decaf-ts/utils 0.1.6 → 0.2.0

package/lib/utils/accumulator.d.ts

@@ -0,0 +1,105 @@
+/**
+ * @class ObjectAccumulator
+ * @template T - The type of the accumulated object, extends object
+ * @description A class that accumulates objects and provides type-safe access to their properties.
+ * It allows for dynamic addition of properties while maintaining type information.
+ * @summary Accumulates objects and maintains type information for accumulated properties
+ * @memberOf utils
+ */
+export declare class ObjectAccumulator<T extends object> {
+    /**
+     * @private
+     * @description The size of the accumulated object
+     * @type {number}
+     */
+    private __size;
+    constructor();
+    /**
+     * @protected
+     * @description Expands the accumulator with properties from a new object
+     * @summary Adds new properties to the accumulator
+     * @template V - The type of the object being expanded
+     * @param {V} value - The object to expand with
+     * @returns {void}
+     */
+    protected expand<V extends object>(value: V): void;
+    /**
+     * @description Accumulates a new object into the accumulator
+     * @summary Adds properties from a new object to the accumulator, maintaining type information
+     * @template V - The type of the object being accumulated
+     * @param {V} value - The object to accumulate
+     * @returns A new ObjectAccumulator instance with updated type information
+     * @mermaid
+     * sequenceDiagram
+     *   participant A as Accumulator
+     *   participant O as Object
+     *   A->>O: Get entries
+     *   loop For each entry
+     *     A->>A: Define property
+     *   end
+     *   A->>A: Update size
+     *   A->>A: Return updated accumulator
+     */
+    accumulate<V extends object>(value: V): T & V & ObjectAccumulator<T & V>;
+    /**
+     * @description Retrieves a value from the accumulator by its key
+     * @summary Gets a value from the accumulated object using a type-safe key
+     * @template K - The key type, must be a key of this
+     * @param {K} key - The key of the value to retrieve
+     * @returns {any | undefined} The value associated with the key, or undefined if not found
+     */
+    get<K extends keyof this>(key: K): this[K] | undefined;
+    /**
+     * @description Checks if a key exists in the accumulator
+     * @summary Determines whether the accumulator contains a specific key
+     * @param {string} key - The key to check for existence
+     * @returns {boolean} True if the key exists, false otherwise
+     */
+    has(key: string): boolean;
+    /**
+     * @description Removes a key-value pair from the accumulator
+     * @summary Deletes a property from the accumulated object
+     * @param {string} key - The key of the property to remove
+     * @returns {} The accumulator instance with the specified property removed
+     */
+    remove(key: keyof this | string): (Omit<this, typeof key> & ObjectAccumulator<Omit<this, typeof key>>) | this;
+    /**
+     * @description Retrieves all keys from the accumulator
+     * @summary Gets an array of all accumulated property keys
+     * @returns {string[]} An array of keys as strings
+     */
+    keys(): string[];
+    /**
+     * @description Retrieves all values from the accumulator
+     * @summary Gets an array of all accumulated property values
+     * @returns An array of values
+     */
+    values(): T[keyof T][];
+    /**
+     * @description Gets the number of key-value pairs in the accumulator
+     * @summary Returns the count of accumulated properties
+     * @returns {number} The number of key-value pairs
+     */
+    size(): number;
+    /**
+     * @description Clears all accumulated key-value pairs
+     * @summary Removes all properties from the accumulator and returns a new empty instance
+     * @returns {ObjectAccumulator<never>} A new empty ObjectAccumulator instance
+     */
+    clear(): ObjectAccumulator<never>;
+    /**
+     * @description Executes a callback for each key-value pair in the accumulator
+     * @summary Iterates over all accumulated properties, calling a function for each
+     * @param {function(any, string, number): void} callback - The function to execute for each entry
+     * @returns {void}
+     */
+    forEach(callback: (value: this[keyof this], key: keyof this, i: number) => void): void;
+    /**
+     * @description Creates a new array with the results of calling a provided function on every element in the accumulator
+     * @summary Maps each accumulated property to a new value using a callback function
+     * @template R - The type of the mapped values
+     * @param {function(any, string,number): R} callback - Function that produces an element of the new array
+     * @returns {R[]} A new array with each element being the result of the callback function
+     */
+    map<R>(callback: (value: this[keyof this], key: keyof this, i: number) => R): R[];
+}

package/lib/utils/constants.cjs

@@ -175,5 +175,4 @@ exports.DefaultLoggingConfig = {
     theme: exports.DefaultTheme,
 };
 exports.AbortCode = "Aborted";
-
-//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["src/utils/constants.ts"],"names":[],"mappings":";;;AAEA;;;;;GAKG;AACU,QAAA,QAAQ,GAAG,OAAO,CAAC;AAEhC;;;;;GAKG;AACU,QAAA,eAAe,GAC1B,4DAA4D,CAAC;AAE/D;;;;;GAKG;AACH,IAAY,UAOX;AAPD,WAAY,UAAU;IACpB,wDAAwD;IACxD,6BAAe,CAAA;IACf,2DAA2D;IAC3D,6BAAe,CAAA;IACf,oEAAoE;IACpE,6BAAe,CAAA;AACjB,CAAC,EAPW,UAAU,0BAAV,UAAU,QAOrB;AAED;;;;;GAKG;AACU,QAAA,QAAQ,GAAG,QAAQ,CAAC;AAEjC;;;;;GAKG;AACU,QAAA,cAAc,GAAG,aAAa,CAAC;AAE5C;;;;;GAKG;AACH,IAAY,MASX;AATD,WAAY,MAAM;IAChB,0CAA0C;IAC1C,wBAAc,CAAA;IACd,0CAA0C;IAC1C,2BAAiB,CAAA;IACjB,6CAA6C;IAC7C,iCAAuB,CAAA;IACvB,iDAAiD;IACjD,0CAAgC,CAAA;AAClC,CAAC,EATW,MAAM,sBAAN,MAAM,QASjB;AAED;;;;;GAKG;AACH,IAAY,QAWX;AAXD,WAAY,QAAQ;IAClB,sDAAsD;IACtD,2BAAe,CAAA;IACf,kEAAkE;IAClE,yBAAa,CAAA;IACb,uCAAuC;IACvC,+BAAmB,CAAA;IACnB,kCAAkC;IAClC,2BAAe,CAAA;IACf,4CAA4C;IAC5C,2BAAe,CAAA;AACjB,CAAC,EAXW,QAAQ,wBAAR,QAAQ,QAWnB;AAED;;;;;;;;;;GAUG;AACU,QAAA,gBAAgB,GAAG;IAC9B,KAAK,EAAE,CAAC;IACR,IAAI,EAAE,CAAC;IACP,OAAO,EAAE,CAAC;IACV,KAAK,EAAE,CAAC;IACR,KAAK,EAAE,CAAC;CACT,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACU,QAAA,YAAY,GAAU;IACjC,KAAK,EAAE;QACL,EAAE,EAAE,EAAE;KACP;IACD,EAAE,EAAE;QACF,EAAE,EAAE,EAAE;KACP;IACD,KAAK,EAAE,EAAE;IACT,SAAS,EAAE,EAAE;IACb,OAAO,EAAE;QACP,KAAK,EAAE;YACL,EAAE,EAAE,EAAE;SACP;KACF;IACD,MAAM,EAAE,EAAE;IACV,QAAQ,EAAE;QACR,KAAK,EAAE;YACL,EAAE,EAAE,EAAE;YACN,KAAK,EAAE,CAAC,MAAM,CAAC;SAChB;QACD,IAAI,EAAE,EAAE;QACR,OAAO,EAAE,EAAE;QACX,KAAK,EAAE;YACL,EAAE,EAAE,EAAE;SACP;KACF;CACF,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACU,QAAA,oBAAoB,GAAkB;IACjD,OAAO,EAAE,CAAC;IACV,KAAK,EAAE,QAAQ,CAAC,IAAI;IACpB,QAAQ,EAAE,IAAI;IACd,KAAK,EAAE,KAAK;IACZ,SAAS,EAAE,KAAK;IAChB,SAAS,EAAE,IAAI;IACf,eAAe,EAAE,cAAc;IAC/B,OAAO,EAAE,IAAI;IACb,KAAK,EAAE,oBAAY;CACpB,CAAC;AAEW,QAAA,SAAS,GAAG,SAAS,CAAC","file":"utils/constants.js","sourcesContent":["import { LoggingConfig, Theme } from \"../output/types\";\n\n/**\n * @description Default encoding for text operations.\n * @summary The standard UTF-8 encoding used for text processing.\n * @const {string} Encoding\n * @memberOf @decaf-ts/utils\n */\nexport const Encoding = \"utf-8\";\n\n/**\n * @description Regular expression for semantic versioning.\n * @summary A regex pattern to match and parse semantic version strings.\n * @const {RegExp} SemVersionRegex\n * @memberOf @decaf-ts/utils\n */\nexport const SemVersionRegex =\n  /^(\\d+)\\.(\\d+)\\.(\\d+)(?:-([0-9A-Za-z-]+(?:\\.[0-9A-Za-z])))/g;\n\n/**\n * @description Enum for semantic version components.\n * @summary Defines the three levels of semantic versioning: PATCH, MINOR, and MAJOR.\n * @enum {string}\n * @memberOf @decaf-ts/utils\n */\nexport enum SemVersion {\n  /** Patch version for backwards-compatible bug fixes. */\n  PATCH = \"patch\",\n  /** Minor version for backwards-compatible new features. */\n  MINOR = \"minor\",\n  /** Major version for changes that break backwards compatibility. */\n  MAJOR = \"major\",\n}\n\n/**\n * @description Flag to indicate non-CI environment.\n * @summary Used to specify that a command should run outside of a Continuous Integration environment.\n * @const {string} NoCIFLag\n * @memberOf @decaf-ts/utils\n */\nexport const NoCIFLag = \"-no-ci\";\n\n/**\n * @description Key for the setup script in package.json.\n * @summary Identifies the script that runs after package installation.\n * @const {string} SetupScriptKey\n * @memberOf @decaf-ts/utils\n */\nexport const SetupScriptKey = \"postinstall\";\n\n/**\n * @description Enum for various authentication tokens.\n * @summary Defines the file names for storing different types of authentication tokens.\n * @enum {string}\n * @memberOf @decaf-ts/utils\n */\nexport enum Tokens {\n  /** Git authentication token file name. */\n  GIT = \".token\",\n  /** NPM authentication token file name. */\n  NPM = \".npmtoken\",\n  /** Docker authentication token file name. */\n  DOCKER = \".dockertoken\",\n  /** Confluence authentication token file name. */\n  CONFLUENCE = \".confluence-token\",\n}\n\n/**\n * @description Enum for log levels.\n * @summary Defines different levels of logging for the application.\n * @enum {string}\n * @memberOf @decaf-ts/utils\n */\nexport enum LogLevel {\n  /** Error events that are likely to cause problems. */\n  error = \"error\",\n  /** Routine information, such as ongoing status or performance. */\n  info = \"info\",\n  /** Additional relevant information. */\n  verbose = \"verbose\",\n  /** Debug or trace information. */\n  debug = \"debug\",\n  /** way too verbose or silly information. */\n  silly = \"silly\",\n}\n\n/**\n * @description Numeric values associated with log levels.\n * @summary Provides a numeric representation of log levels for comparison and filtering.\n * @const {Object} NumericLogLevels\n * @property {number} error - Numeric value for error level (0).\n * @property {number} info - Numeric value for info level (2).\n * @property {number} verbose - Numeric value for verbose level (4).\n * @property {number} debug - Numeric value for debug level (5).\n * @property {number} silly - Numeric value for silly level (8).\n * @memberOf @decaf-ts/utils\n */\nexport const NumericLogLevels = {\n  error: 2,\n  info: 4,\n  verbose: 6,\n  debug: 7,\n  silly: 9,\n};\n\n/**\n * @description Default theme for styling log output.\n * @summary Defines the default color and style settings for various components of log messages.\n * @const DefaultTheme\n * @typedef {Theme} DefaultTheme\n * @property {Object} class - Styling for class names.\n * @property {number} class.fg - Foreground color code for class names (4).\n * @property {Object} id - Styling for identifiers.\n * @property {number} id.fg - Foreground color code for identifiers (36).\n * @property {Object} stack - Styling for stack traces (empty object).\n * @property {Object} timestamp - Styling for timestamps (empty object).\n * @property {Object} message - Styling for different types of messages.\n * @property {Object} message.error - Styling for error messages.\n * @property {number} message.error.fg - Foreground color code for error messages (34).\n * @property {Object} method - Styling for method names (empty object).\n * @property {Object} logLevel - Styling for different log levels.\n * @property {Object} logLevel.error - Styling for error level logs.\n * @property {number} logLevel.error.fg - Foreground color code for error level logs (6).\n * @property {Object} logLevel.info - Styling for info level logs (empty object).\n * @property {Object} logLevel.verbose - Styling for verbose level logs (empty object).\n * @property {Object} logLevel.debug - Styling for debug level logs.\n * @property {number} logLevel.debug.fg - Foreground color code for debug level logs (7).\n * @memberOf @decaf-ts/utils\n */\nexport const DefaultTheme: Theme = {\n  class: {\n    fg: 34,\n  },\n  id: {\n    fg: 36,\n  },\n  stack: {},\n  timestamp: {},\n  message: {\n    error: {\n      fg: 31,\n    },\n  },\n  method: {},\n  logLevel: {\n    error: {\n      fg: 31,\n      style: [\"bold\"],\n    },\n    info: {},\n    verbose: {},\n    debug: {\n      fg: 33,\n    },\n  },\n};\n\n/**\n * @description Default configuration for logging.\n * @summary Defines the default settings for the logging system, including verbosity, log level, styling, and timestamp format.\n * @const DefaultLoggingConfig\n * @typedef {LoggingConfig} DefaultLoggingConfig\n * @property {number} verbose - Verbosity level (0).\n * @property {LogLevel} level - Default log level (LogLevel.info).\n * @property {boolean} style - Whether to apply styling to log output (false).\n * @property {boolean} timestamp - Whether to include timestamps in log messages (true).\n * @property {string} timestampFormat - Format for timestamps (\"HH:mm:ss.SSS\").\n * @property {boolean} context - Whether to include context information in log messages (true).\n * @property {Theme} theme - The theme to use for styling log messages (DefaultTheme).\n * @memberOf @decaf-ts/utils\n */\nexport const DefaultLoggingConfig: LoggingConfig = {\n  verbose: 0,\n  level: LogLevel.info,\n  logLevel: true,\n  style: false,\n  separator: \" - \",\n  timestamp: true,\n  timestampFormat: \"HH:mm:ss.SSS\",\n  context: true,\n  theme: DefaultTheme,\n};\n\nexport const AbortCode = \"Aborted\";\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"constants.js","sourceRoot":"","sources":["../../src/utils/constants.ts"],"names":[],"mappings":";;;AAEA;;;;;GAKG;AACU,QAAA,QAAQ,GAAG,OAAO,CAAC;AAEhC;;;;;GAKG;AACU,QAAA,eAAe,GAC1B,4DAA4D,CAAC;AAE/D;;;;;GAKG;AACH,IAAY,UAOX;AAPD,WAAY,UAAU;IACpB,wDAAwD;IACxD,6BAAe,CAAA;IACf,2DAA2D;IAC3D,6BAAe,CAAA;IACf,oEAAoE;IACpE,6BAAe,CAAA;AACjB,CAAC,EAPW,UAAU,0BAAV,UAAU,QAOrB;AAED;;;;;GAKG;AACU,QAAA,QAAQ,GAAG,QAAQ,CAAC;AAEjC;;;;;GAKG;AACU,QAAA,cAAc,GAAG,aAAa,CAAC;AAE5C;;;;;GAKG;AACH,IAAY,MASX;AATD,WAAY,MAAM;IAChB,0CAA0C;IAC1C,wBAAc,CAAA;IACd,0CAA0C;IAC1C,2BAAiB,CAAA;IACjB,6CAA6C;IAC7C,iCAAuB,CAAA;IACvB,iDAAiD;IACjD,0CAAgC,CAAA;AAClC,CAAC,EATW,MAAM,sBAAN,MAAM,QASjB;AAED;;;;;GAKG;AACH,IAAY,QAWX;AAXD,WAAY,QAAQ;IAClB,sDAAsD;IACtD,2BAAe,CAAA;IACf,kEAAkE;IAClE,yBAAa,CAAA;IACb,uCAAuC;IACvC,+BAAmB,CAAA;IACnB,kCAAkC;IAClC,2BAAe,CAAA;IACf,4CAA4C;IAC5C,2BAAe,CAAA;AACjB,CAAC,EAXW,QAAQ,wBAAR,QAAQ,QAWnB;AAED;;;;;;;;;;GAUG;AACU,QAAA,gBAAgB,GAAG;IAC9B,KAAK,EAAE,CAAC;IACR,IAAI,EAAE,CAAC;IACP,OAAO,EAAE,CAAC;IACV,KAAK,EAAE,CAAC;IACR,KAAK,EAAE,CAAC;CACT,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACU,QAAA,YAAY,GAAU;IACjC,KAAK,EAAE;QACL,EAAE,EAAE,EAAE;KACP;IACD,EAAE,EAAE;QACF,EAAE,EAAE,EAAE;KACP;IACD,KAAK,EAAE,EAAE;IACT,SAAS,EAAE,EAAE;IACb,OAAO,EAAE;QACP,KAAK,EAAE;YACL,EAAE,EAAE,EAAE;SACP;KACF;IACD,MAAM,EAAE,EAAE;IACV,QAAQ,EAAE;QACR,KAAK,EAAE;YACL,EAAE,EAAE,EAAE;YACN,KAAK,EAAE,CAAC,MAAM,CAAC;SAChB;QACD,IAAI,EAAE,EAAE;QACR,OAAO,EAAE,EAAE;QACX,KAAK,EAAE;YACL,EAAE,EAAE,EAAE;SACP;KACF;CACF,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACU,QAAA,oBAAoB,GAAkB;IACjD,OAAO,EAAE,CAAC;IACV,KAAK,EAAE,QAAQ,CAAC,IAAI;IACpB,QAAQ,EAAE,IAAI;IACd,KAAK,EAAE,KAAK;IACZ,SAAS,EAAE,KAAK;IAChB,SAAS,EAAE,IAAI;IACf,eAAe,EAAE,cAAc;IAC/B,OAAO,EAAE,IAAI;IACb,KAAK,EAAE,oBAAY;CACpB,CAAC;AAEW,QAAA,SAAS,GAAG,SAAS,CAAC","sourcesContent":["import { LoggingConfig, Theme } from \"../output/types\";\n\n/**\n * @description Default encoding for text operations.\n * @summary The standard UTF-8 encoding used for text processing.\n * @const {string} Encoding\n * @memberOf @decaf-ts/utils\n */\nexport const Encoding = \"utf-8\";\n\n/**\n * @description Regular expression for semantic versioning.\n * @summary A regex pattern to match and parse semantic version strings.\n * @const {RegExp} SemVersionRegex\n * @memberOf @decaf-ts/utils\n */\nexport const SemVersionRegex =\n  /^(\\d+)\\.(\\d+)\\.(\\d+)(?:-([0-9A-Za-z-]+(?:\\.[0-9A-Za-z])))/g;\n\n/**\n * @description Enum for semantic version components.\n * @summary Defines the three levels of semantic versioning: PATCH, MINOR, and MAJOR.\n * @enum {string}\n * @memberOf @decaf-ts/utils\n */\nexport enum SemVersion {\n  /** Patch version for backwards-compatible bug fixes. */\n  PATCH = \"patch\",\n  /** Minor version for backwards-compatible new features. */\n  MINOR = \"minor\",\n  /** Major version for changes that break backwards compatibility. */\n  MAJOR = \"major\",\n}\n\n/**\n * @description Flag to indicate non-CI environment.\n * @summary Used to specify that a command should run outside of a Continuous Integration environment.\n * @const {string} NoCIFLag\n * @memberOf @decaf-ts/utils\n */\nexport const NoCIFLag = \"-no-ci\";\n\n/**\n * @description Key for the setup script in package.json.\n * @summary Identifies the script that runs after package installation.\n * @const {string} SetupScriptKey\n * @memberOf @decaf-ts/utils\n */\nexport const SetupScriptKey = \"postinstall\";\n\n/**\n * @description Enum for various authentication tokens.\n * @summary Defines the file names for storing different types of authentication tokens.\n * @enum {string}\n * @memberOf @decaf-ts/utils\n */\nexport enum Tokens {\n  /** Git authentication token file name. */\n  GIT = \".token\",\n  /** NPM authentication token file name. */\n  NPM = \".npmtoken\",\n  /** Docker authentication token file name. */\n  DOCKER = \".dockertoken\",\n  /** Confluence authentication token file name. */\n  CONFLUENCE = \".confluence-token\",\n}\n\n/**\n * @description Enum for log levels.\n * @summary Defines different levels of logging for the application.\n * @enum {string}\n * @memberOf @decaf-ts/utils\n */\nexport enum LogLevel {\n  /** Error events that are likely to cause problems. */\n  error = \"error\",\n  /** Routine information, such as ongoing status or performance. */\n  info = \"info\",\n  /** Additional relevant information. */\n  verbose = \"verbose\",\n  /** Debug or trace information. */\n  debug = \"debug\",\n  /** way too verbose or silly information. */\n  silly = \"silly\",\n}\n\n/**\n * @description Numeric values associated with log levels.\n * @summary Provides a numeric representation of log levels for comparison and filtering.\n * @const {Object} NumericLogLevels\n * @property {number} error - Numeric value for error level (0).\n * @property {number} info - Numeric value for info level (2).\n * @property {number} verbose - Numeric value for verbose level (4).\n * @property {number} debug - Numeric value for debug level (5).\n * @property {number} silly - Numeric value for silly level (8).\n * @memberOf @decaf-ts/utils\n */\nexport const NumericLogLevels = {\n  error: 2,\n  info: 4,\n  verbose: 6,\n  debug: 7,\n  silly: 9,\n};\n\n/**\n * @description Default theme for styling log output.\n * @summary Defines the default color and style settings for various components of log messages.\n * @const DefaultTheme\n * @typedef {Theme} DefaultTheme\n * @property {Object} class - Styling for class names.\n * @property {number} class.fg - Foreground color code for class names (4).\n * @property {Object} id - Styling for identifiers.\n * @property {number} id.fg - Foreground color code for identifiers (36).\n * @property {Object} stack - Styling for stack traces (empty object).\n * @property {Object} timestamp - Styling for timestamps (empty object).\n * @property {Object} message - Styling for different types of messages.\n * @property {Object} message.error - Styling for error messages.\n * @property {number} message.error.fg - Foreground color code for error messages (34).\n * @property {Object} method - Styling for method names (empty object).\n * @property {Object} logLevel - Styling for different log levels.\n * @property {Object} logLevel.error - Styling for error level logs.\n * @property {number} logLevel.error.fg - Foreground color code for error level logs (6).\n * @property {Object} logLevel.info - Styling for info level logs (empty object).\n * @property {Object} logLevel.verbose - Styling for verbose level logs (empty object).\n * @property {Object} logLevel.debug - Styling for debug level logs.\n * @property {number} logLevel.debug.fg - Foreground color code for debug level logs (7).\n * @memberOf @decaf-ts/utils\n */\nexport const DefaultTheme: Theme = {\n  class: {\n    fg: 34,\n  },\n  id: {\n    fg: 36,\n  },\n  stack: {},\n  timestamp: {},\n  message: {\n    error: {\n      fg: 31,\n    },\n  },\n  method: {},\n  logLevel: {\n    error: {\n      fg: 31,\n      style: [\"bold\"],\n    },\n    info: {},\n    verbose: {},\n    debug: {\n      fg: 33,\n    },\n  },\n};\n\n/**\n * @description Default configuration for logging.\n * @summary Defines the default settings for the logging system, including verbosity, log level, styling, and timestamp format.\n * @const DefaultLoggingConfig\n * @typedef {LoggingConfig} DefaultLoggingConfig\n * @property {number} verbose - Verbosity level (0).\n * @property {LogLevel} level - Default log level (LogLevel.info).\n * @property {boolean} style - Whether to apply styling to log output (false).\n * @property {boolean} timestamp - Whether to include timestamps in log messages (true).\n * @property {string} timestampFormat - Format for timestamps (\"HH:mm:ss.SSS\").\n * @property {boolean} context - Whether to include context information in log messages (true).\n * @property {Theme} theme - The theme to use for styling log messages (DefaultTheme).\n * @memberOf @decaf-ts/utils\n */\nexport const DefaultLoggingConfig: LoggingConfig = {\n  verbose: 0,\n  level: LogLevel.info,\n  logLevel: true,\n  style: false,\n  separator: \" - \",\n  timestamp: true,\n  timestampFormat: \"HH:mm:ss.SSS\",\n  context: true,\n  theme: DefaultTheme,\n};\n\nexport const AbortCode = \"Aborted\";\n"]}

package/lib/utils/constants.d.ts

@@ -0,0 +1,136 @@
+import { LoggingConfig, Theme } from "../output/types";
+/**
+ * @description Default encoding for text operations.
+ * @summary The standard UTF-8 encoding used for text processing.
+ * @const {string} Encoding
+ * @memberOf @decaf-ts/utils
+ */
+export declare const Encoding = "utf-8";
+/**
+ * @description Regular expression for semantic versioning.
+ * @summary A regex pattern to match and parse semantic version strings.
+ * @const {RegExp} SemVersionRegex
+ * @memberOf @decaf-ts/utils
+ */
+export declare const SemVersionRegex: RegExp;
+/**
+ * @description Enum for semantic version components.
+ * @summary Defines the three levels of semantic versioning: PATCH, MINOR, and MAJOR.
+ * @enum {string}
+ * @memberOf @decaf-ts/utils
+ */
+export declare enum SemVersion {
+    /** Patch version for backwards-compatible bug fixes. */
+    PATCH = "patch",
+    /** Minor version for backwards-compatible new features. */
+    MINOR = "minor",
+    /** Major version for changes that break backwards compatibility. */
+    MAJOR = "major"
+}
+/**
+ * @description Flag to indicate non-CI environment.
+ * @summary Used to specify that a command should run outside of a Continuous Integration environment.
+ * @const {string} NoCIFLag
+ * @memberOf @decaf-ts/utils
+ */
+export declare const NoCIFLag = "-no-ci";
+/**
+ * @description Key for the setup script in package.json.
+ * @summary Identifies the script that runs after package installation.
+ * @const {string} SetupScriptKey
+ * @memberOf @decaf-ts/utils
+ */
+export declare const SetupScriptKey = "postinstall";
+/**
+ * @description Enum for various authentication tokens.
+ * @summary Defines the file names for storing different types of authentication tokens.
+ * @enum {string}
+ * @memberOf @decaf-ts/utils
+ */
+export declare enum Tokens {
+    /** Git authentication token file name. */
+    GIT = ".token",
+    /** NPM authentication token file name. */
+    NPM = ".npmtoken",
+    /** Docker authentication token file name. */
+    DOCKER = ".dockertoken",
+    /** Confluence authentication token file name. */
+    CONFLUENCE = ".confluence-token"
+}
+/**
+ * @description Enum for log levels.
+ * @summary Defines different levels of logging for the application.
+ * @enum {string}
+ * @memberOf @decaf-ts/utils
+ */
+export declare enum LogLevel {
+    /** Error events that are likely to cause problems. */
+    error = "error",
+    /** Routine information, such as ongoing status or performance. */
+    info = "info",
+    /** Additional relevant information. */
+    verbose = "verbose",
+    /** Debug or trace information. */
+    debug = "debug",
+    /** way too verbose or silly information. */
+    silly = "silly"
+}
+/**
+ * @description Numeric values associated with log levels.
+ * @summary Provides a numeric representation of log levels for comparison and filtering.
+ * @const {Object} NumericLogLevels
+ * @property {number} error - Numeric value for error level (0).
+ * @property {number} info - Numeric value for info level (2).
+ * @property {number} verbose - Numeric value for verbose level (4).
+ * @property {number} debug - Numeric value for debug level (5).
+ * @property {number} silly - Numeric value for silly level (8).
+ * @memberOf @decaf-ts/utils
+ */
+export declare const NumericLogLevels: {
+    error: number;
+    info: number;
+    verbose: number;
+    debug: number;
+    silly: number;
+};
+/**
+ * @description Default theme for styling log output.
+ * @summary Defines the default color and style settings for various components of log messages.
+ * @const DefaultTheme
+ * @typedef {Theme} DefaultTheme
+ * @property {Object} class - Styling for class names.
+ * @property {number} class.fg - Foreground color code for class names (4).
+ * @property {Object} id - Styling for identifiers.
+ * @property {number} id.fg - Foreground color code for identifiers (36).
+ * @property {Object} stack - Styling for stack traces (empty object).
+ * @property {Object} timestamp - Styling for timestamps (empty object).
+ * @property {Object} message - Styling for different types of messages.
+ * @property {Object} message.error - Styling for error messages.
+ * @property {number} message.error.fg - Foreground color code for error messages (34).
+ * @property {Object} method - Styling for method names (empty object).
+ * @property {Object} logLevel - Styling for different log levels.
+ * @property {Object} logLevel.error - Styling for error level logs.
+ * @property {number} logLevel.error.fg - Foreground color code for error level logs (6).
+ * @property {Object} logLevel.info - Styling for info level logs (empty object).
+ * @property {Object} logLevel.verbose - Styling for verbose level logs (empty object).
+ * @property {Object} logLevel.debug - Styling for debug level logs.
+ * @property {number} logLevel.debug.fg - Foreground color code for debug level logs (7).
+ * @memberOf @decaf-ts/utils
+ */
+export declare const DefaultTheme: Theme;
+/**
+ * @description Default configuration for logging.
+ * @summary Defines the default settings for the logging system, including verbosity, log level, styling, and timestamp format.
+ * @const DefaultLoggingConfig
+ * @typedef {LoggingConfig} DefaultLoggingConfig
+ * @property {number} verbose - Verbosity level (0).
+ * @property {LogLevel} level - Default log level (LogLevel.info).
+ * @property {boolean} style - Whether to apply styling to log output (false).
+ * @property {boolean} timestamp - Whether to include timestamps in log messages (true).
+ * @property {string} timestampFormat - Format for timestamps ("HH:mm:ss.SSS").
+ * @property {boolean} context - Whether to include context information in log messages (true).
+ * @property {Theme} theme - The theme to use for styling log messages (DefaultTheme).
+ * @memberOf @decaf-ts/utils
+ */
+export declare const DefaultLoggingConfig: LoggingConfig;
+export declare const AbortCode = "Aborted";

package/lib/utils/environment.cjs

@@ -91,5 +91,4 @@ class Environment extends accumulator_1.ObjectAccumulator {
     }
 }
 exports.Environment = Environment;
-
-//# sourceMappingURL=data:application/json;charset=utf8;base64,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
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZW52aXJvbm1lbnQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdXRpbHMvZW52aXJvbm1lbnQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBQUEsaUNBQXFDO0FBQ3JDLCtDQUFrRDtBQUVsRCwrQkFBa0M7QUFFbEM7Ozs7Ozs7R0FPRztBQUNILE1BQWEsV0FBOEIsU0FBUSwrQkFBb0I7SUFDckU7Ozs7OztPQU1HO2FBQ2MsWUFBTyxHQUN0QixHQUFxQixFQUFFLENBQUMsSUFBSSxXQUFXLEVBQUUsQ0FBQztJQVU1QztRQUNFLEtBQUssRUFBRSxDQUFDO0lBQ1YsQ0FBQztJQUVTLE9BQU8sQ0FBQyxDQUFTO1FBQ3pCLElBQUksR0FBNEIsQ0FBQztRQUNqQyxJQUFJLElBQUEsZUFBUyxHQUFFLEVBQUUsQ0FBQztZQUNoQixHQUFHLEdBQUksVUFBK0QsQ0FDcEUsS0FBSyxDQUNOLENBQUM7UUFDSixDQUFDO2FBQU0sQ0FBQztZQUNOLEdBQUcsR0FBRyxVQUFVLENBQUMsT0FBTyxDQUFDLEdBQUcsQ0FBQztZQUM3QixDQUFDLEdBQUcsSUFBQSxrQkFBVyxFQUFDLENBQUMsQ0FBQyxDQUFDO1FBQ3JCLENBQUM7UUFDRCxPQUFPLEdBQUcsQ0FBQyxDQUFDLENBQUMsQ0FBQztJQUNoQixDQUFDO0lBRVMsTUFBTSxDQUFtQixLQUFRO1FBQ3pDLE1BQU0sQ0FBQyxPQUFPLENBQUMsS0FBSyxDQUFDLENBQUMsT0FBTyxDQUFDLENBQUMsQ0FBQyxDQUFDLEVBQUUsQ0FBQyxDQUFDLEVBQUUsRUFBRTtZQUN2QyxNQUFNLENBQUMsY0FBYyxDQUFDLElBQUksRUFBRSxDQUFDLEVBQUU7Z0JBQzdCLEdBQUcsRUFBRSxHQUFHLEVBQUU7b0JBQ1IsTUFBTSxPQUFPLEdBQUcsSUFBSSxDQUFDLE9BQU8sQ0FBQyxDQUFDLENBQUMsQ0FBQztvQkFDaEMsT0FBTyxPQUFPLE9BQU8sS0FBSyxXQUFXLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUMsT0FBTyxDQUFDO2dCQUN0RCxDQUFDO2dCQUNELEdBQUcsRUFBRSxDQUFDLEdBQWUsRUFBRSxFQUFFO29CQUN2QixDQUFDLEdBQUcsR0FBRyxDQUFDO2dCQUNWLENBQUM7Z0JBQ0QsWUFBWSxFQUFFLElBQUk7Z0JBQ2xCLFVBQVUsRUFBRSxJQUFJO2FBQ2pCLENBQUMsQ0FBQztRQUNMLENBQUMsQ0FBQyxDQUFDO0lBQ0wsQ0FBQztJQUVEOzs7Ozs7OztPQVFHO0lBQ08sTUFBTSxDQUFDLFFBQVEsQ0FBNkIsR0FBRyxJQUFlO1FBQ3RFLFdBQVcsQ0FBQyxTQUFTLEdBQUcsQ0FBQyxXQUFXLENBQUMsU0FBUztZQUM1QyxDQUFDLENBQUMsV0FBVyxDQUFDLE9BQU8sQ0FBQyxHQUFHLElBQUksQ0FBQztZQUM5QixDQUFDLENBQUMsV0FBVyxDQUFDLFNBQVMsQ0FBQztRQUMxQixPQUFPLFdBQVcsQ0FBQyxTQUFjLENBQUM7SUFDcEMsQ0FBQztJQUVEOzs7Ozs7O09BT0c7SUFDSCxNQUFNLENBQUMsVUFBVSxDQUNmLEtBQVE7UUFJUixNQUFNLFFBQVEsR0FBRyxXQUFXLENBQUMsUUFBUSxFQUFFLENBQUM7UUFDeEMsT0FBTyxRQUFRLENBQUMsVUFBVSxDQUFDLEtBQUssQ0FBQyxDQUFDO0lBQ3BDLENBQUM7SUFFRDs7Ozs7O09BTUc7SUFDSCxNQUFNLENBQUMsSUFBSSxDQUFDLFFBQWlCLElBQUk7UUFDL0IsT0FBTyxXQUFXLENBQUMsUUFBUSxFQUFFO2FBQzFCLElBQUksRUFBRTthQUNOLEdBQUcsQ0FBQyxDQUFDLENBQUMsRUFBRSxFQUFFLENBQUMsQ0FBQyxLQUFLLENBQUMsQ0FBQyxDQUFDLElBQUEsa0JBQVcsRUFBQyxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQztJQUM5QyxDQUFDOztBQWhHSCxrQ0FpR0MiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyB0b0VOVkZvcm1hdCB9IGZyb20gXCIuL3RleHRcIjtcbmltcG9ydCB7IE9iamVjdEFjY3VtdWxhdG9yIH0gZnJvbSBcIi4vYWNjdW11bGF0b3JcIjtcbmltcG9ydCB7IEVudmlyb25tZW50RmFjdG9yeSB9IGZyb20gXCIuL3R5cGVzXCI7XG5pbXBvcnQgeyBpc0Jyb3dzZXIgfSBmcm9tIFwiLi93ZWJcIjtcblxuLyoqXG4gKiBAY2xhc3MgRW52aXJvbm1lbnRcbiAqIEBleHRlbmRzIHtPYmplY3RBY2N1bXVsYXRvcjxUPn1cbiAqIEB0ZW1wbGF0ZSBUXG4gKiBAZGVzY3JpcHRpb24gQSBjbGFzcyByZXByZXNlbnRpbmcgYW4gZW52aXJvbm1lbnQgd2l0aCBhY2N1bXVsYXRpb24gY2FwYWJpbGl0aWVzLlxuICogQHN1bW1hcnkgTWFuYWdlcyBlbnZpcm9ubWVudC1yZWxhdGVkIGRhdGEgYW5kIHByb3ZpZGVzIG1ldGhvZHMgZm9yIGFjY3VtdWxhdGlvbiBhbmQga2V5IHJldHJpZXZhbC5cbiAqIEBwYXJhbSB7VH0gW2luaXRpYWxEYXRhXSAtIFRoZSBpbml0aWFsIGRhdGEgdG8gcG9wdWxhdGUgdGhlIGVudmlyb25tZW50IHdpdGguXG4gKi9cbmV4cG9ydCBjbGFzcyBFbnZpcm9ubWVudDxUIGV4dGVuZHMgb2JqZWN0PiBleHRlbmRzIE9iamVjdEFjY3VtdWxhdG9yPFQ+IHtcbiAgLyoqXG4gICAqIEBzdGF0aWNcbiAgICogQHByb3RlY3RlZFxuICAgKiBAZGVzY3JpcHRpb24gQSBmYWN0b3J5IGZ1bmN0aW9uIGZvciBjcmVhdGluZyBFbnZpcm9ubWVudCBpbnN0YW5jZXMuXG4gICAqIEBzdW1tYXJ5IERlZmluZXMgaG93IG5ldyBpbnN0YW5jZXMgb2YgdGhlIEVudmlyb25tZW50IGNsYXNzIHNob3VsZCBiZSBjcmVhdGVkLlxuICAgKiBAcmV0dXJuIHtFbnZpcm9ubWVudDxhbnk+fSBBIG5ldyBpbnN0YW5jZSBvZiB0aGUgRW52aXJvbm1lbnQgY2xhc3MuXG4gICAqL1xuICBwcm90ZWN0ZWQgc3RhdGljIGZhY3Rvcnk6IEVudmlyb25tZW50RmFjdG9yeTxhbnksIGFueT4gPVxuICAgICgpOiBFbnZpcm9ubWVudDxhbnk+ID0+IG5ldyBFbnZpcm9ubWVudCgpO1xuXG4gIC8qKlxuICAgKiBAc3RhdGljXG4gICAqIEBwcml2YXRlXG4gICAqIEBkZXNjcmlwdGlvbiBUaGUgc2luZ2xldG9uIGluc3RhbmNlIG9mIHRoZSBFbnZpcm9ubWVudCBjbGFzcy5cbiAgICogQHR5cGUge0Vudmlyb25tZW50PGFueT59XG4gICAqL1xuICBwcml2YXRlIHN0YXRpYyBfaW5zdGFuY2U6IEVudmlyb25tZW50PGFueT47XG5cbiAgcHJvdGVjdGVkIGNvbnN0cnVjdG9yKCkge1xuICAgIHN1cGVyKCk7XG4gIH1cblxuICBwcm90ZWN0ZWQgZnJvbUVudihrOiBzdHJpbmcpIHtcbiAgICBsZXQgZW52OiBSZWNvcmQ8c3RyaW5nLCB1bmtub3duPjtcbiAgICBpZiAoaXNCcm93c2VyKCkpIHtcbiAgICAgIGVudiA9IChnbG9iYWxUaGlzIGFzIHR5cGVvZiBnbG9iYWxUaGlzICYgeyBFTlY6IFJlY29yZDxzdHJpbmcsIGFueT4gfSlbXG4gICAgICAgIFwiRU5WXCJcbiAgICAgIF07XG4gICAgfSBlbHNlIHtcbiAgICAgIGVudiA9IGdsb2JhbFRoaXMucHJvY2Vzcy5lbnY7XG4gICAgICBrID0gdG9FTlZGb3JtYXQoayk7XG4gICAgfVxuICAgIHJldHVybiBlbnZba107XG4gIH1cblxuICBwcm90ZWN0ZWQgZXhwYW5kPFYgZXh0ZW5kcyBvYmplY3Q+KHZhbHVlOiBWKTogdm9pZCB7XG4gICAgT2JqZWN0LmVudHJpZXModmFsdWUpLmZvckVhY2goKFtrLCB2XSkgPT4ge1xuICAgICAgT2JqZWN0LmRlZmluZVByb3BlcnR5KHRoaXMsIGssIHtcbiAgICAgICAgZ2V0OiAoKSA9PiB7XG4gICAgICAgICAgY29uc3QgZnJvbUVudiA9IHRoaXMuZnJvbUVudihrKTtcbiAgICAgICAgICByZXR1cm4gdHlwZW9mIGZyb21FbnYgPT09IFwidW5kZWZpbmVkXCIgPyB2IDogZnJvbUVudjtcbiAgICAgICAgfSxcbiAgICAgICAgc2V0OiAodmFsOiBWW2tleW9mIFZdKSA9PiB7XG4gICAgICAgICAgdiA9IHZhbDtcbiAgICAgICAgfSxcbiAgICAgICAgY29uZmlndXJhYmxlOiB0cnVlLFxuICAgICAgICBlbnVtZXJhYmxlOiB0cnVlLFxuICAgICAgfSk7XG4gICAgfSk7XG4gIH1cblxuICAvKipcbiAgICogQHByb3RlY3RlZFxuICAgKiBAc3RhdGljXG4gICAqIEBkZXNjcmlwdGlvbiBSZXRyaWV2ZXMgb3IgY3JlYXRlcyB0aGUgc2luZ2xldG9uIGluc3RhbmNlIG9mIHRoZSBFbnZpcm9ubWVudCBjbGFzcy5cbiAgICogQHN1bW1hcnkgRW5zdXJlcyBvbmx5IG9uZSBpbnN0YW5jZSBvZiB0aGUgRW52aXJvbm1lbnQgY2xhc3MgZXhpc3RzLlxuICAgKiBAdGVtcGxhdGUgRVxuICAgKiBAcGFyYW0gey4uLnVua25vd25bXX0gYXJncyAtIEFyZ3VtZW50cyB0byBwYXNzIHRvIHRoZSBmYWN0b3J5IGZ1bmN0aW9uIGlmIGEgbmV3IGluc3RhbmNlIGlzIGNyZWF0ZWQuXG4gICAqIEByZXR1cm4ge0V9IFRoZSBzaW5nbGV0b24gaW5zdGFuY2Ugb2YgdGhlIEVudmlyb25tZW50IGNsYXNzLlxuICAgKi9cbiAgcHJvdGVjdGVkIHN0YXRpYyBpbnN0YW5jZTxFIGV4dGVuZHMgRW52aXJvbm1lbnQ8YW55Pj4oLi4uYXJnczogdW5rbm93bltdKTogRSB7XG4gICAgRW52aXJvbm1lbnQuX2luc3RhbmNlID0gIUVudmlyb25tZW50Ll9pbnN0YW5jZVxuICAgICAgPyBFbnZpcm9ubWVudC5mYWN0b3J5KC4uLmFyZ3MpXG4gICAgICA6IEVudmlyb25tZW50Ll9pbnN0YW5jZTtcbiAgICByZXR1cm4gRW52aXJvbm1lbnQuX2luc3RhbmNlIGFzIEU7XG4gIH1cblxuICAvKipcbiAgICogQHN0YXRpY1xuICAgKiBAZGVzY3JpcHRpb24gQWNjdW11bGF0ZXMgdGhlIGdpdmVuIHZhbHVlIGludG8gdGhlIGVudmlyb25tZW50LlxuICAgKiBAc3VtbWFyeSBBZGRzIG5ldyBwcm9wZXJ0aWVzIHRvIHRoZSBlbnZpcm9ubWVudCBmcm9tIHRoZSBwcm92aWRlZCBvYmplY3QuXG4gICAqIEB0ZW1wbGF0ZSBWXG4gICAqIEBwYXJhbSB7Vn0gdmFsdWUgLSBUaGUgb2JqZWN0IHRvIGFjY3VtdWxhdGUgaW50byB0aGUgZW52aXJvbm1lbnQuXG4gICAqIEByZXR1cm4ge1Z9IFRoZSB1cGRhdGVkIGVudmlyb25tZW50IGluc3RhbmNlLlxuICAgKi9cbiAgc3RhdGljIGFjY3VtdWxhdGU8ViBleHRlbmRzIG9iamVjdD4oXG4gICAgdmFsdWU6IFZcbiAgKTogdHlwZW9mIEVudmlyb25tZW50Ll9pbnN0YW5jZSAmXG4gICAgViAmXG4gICAgT2JqZWN0QWNjdW11bGF0b3I8dHlwZW9mIEVudmlyb25tZW50Ll9pbnN0YW5jZSAmIFY+IHtcbiAgICBjb25zdCBpbnN0YW5jZSA9IEVudmlyb25tZW50Lmluc3RhbmNlKCk7XG4gICAgcmV0dXJuIGluc3RhbmNlLmFjY3VtdWxhdGUodmFsdWUpO1xuICB9XG5cbiAgLyoqXG4gICAqIEBzdGF0aWNcbiAgICogQGRlc2NyaXB0aW9uIFJldHJpZXZlcyB0aGUga2V5cyBvZiB0aGUgZW52aXJvbm1lbnQsIG9wdGlvbmFsbHkgY29udmVydGluZyB0aGVtIHRvIEVOViBmb3JtYXQuXG4gICAqIEBzdW1tYXJ5IEdldHMgYWxsIGtleXMgaW4gdGhlIGVudmlyb25tZW50LCB3aXRoIGFuIG9wdGlvbiB0byBmb3JtYXQgdGhlbSBmb3IgZW52aXJvbm1lbnQgdmFyaWFibGVzLlxuICAgKiBAcGFyYW0ge2Jvb2xlYW59IFt0b0Vudj10cnVlXSAtIFdoZXRoZXIgdG8gY29udmVydCB0aGUga2V5cyB0byBFTlYgZm9ybWF0LlxuICAgKiBAcmV0dXJuIHtzdHJpbmdbXX0gQW4gYXJyYXkgb2Yga2V5cyBmcm9tIHRoZSBlbnZpcm9ubWVudC5cbiAgICovXG4gIHN0YXRpYyBrZXlzKHRvRW52OiBib29sZWFuID0gdHJ1ZSk6IHN0cmluZ1tdIHtcbiAgICByZXR1cm4gRW52aXJvbm1lbnQuaW5zdGFuY2UoKVxuICAgICAgLmtleXMoKVxuICAgICAgLm1hcCgoaykgPT4gKHRvRW52ID8gdG9FTlZGb3JtYXQoaykgOiBrKSk7XG4gIH1cbn1cbiJdfQ==

package/lib/utils/environment.d.ts

@@ -0,0 +1,57 @@
+import { ObjectAccumulator } from "./accumulator";
+import { EnvironmentFactory } from "./types";
+/**
+ * @class Environment
+ * @extends {ObjectAccumulator<T>}
+ * @template T
+ * @description A class representing an environment with accumulation capabilities.
+ * @summary Manages environment-related data and provides methods for accumulation and key retrieval.
+ * @param {T} [initialData] - The initial data to populate the environment with.
+ */
+export declare class Environment<T extends object> extends ObjectAccumulator<T> {
+    /**
+     * @static
+     * @protected
+     * @description A factory function for creating Environment instances.
+     * @summary Defines how new instances of the Environment class should be created.
+     * @return {Environment<any>} A new instance of the Environment class.
+     */
+    protected static factory: EnvironmentFactory<any, any>;
+    /**
+     * @static
+     * @private
+     * @description The singleton instance of the Environment class.
+     * @type {Environment<any>}
+     */
+    private static _instance;
+    protected constructor();
+    protected fromEnv(k: string): unknown;
+    protected expand<V extends object>(value: V): void;
+    /**
+     * @protected
+     * @static
+     * @description Retrieves or creates the singleton instance of the Environment class.
+     * @summary Ensures only one instance of the Environment class exists.
+     * @template E
+     * @param {...unknown[]} args - Arguments to pass to the factory function if a new instance is created.
+     * @return {E} The singleton instance of the Environment class.
+     */
+    protected static instance<E extends Environment<any>>(...args: unknown[]): E;
+    /**
+     * @static
+     * @description Accumulates the given value into the environment.
+     * @summary Adds new properties to the environment from the provided object.
+     * @template V
+     * @param {V} value - The object to accumulate into the environment.
+     * @return {V} The updated environment instance.
+     */
+    static accumulate<V extends object>(value: V): typeof Environment._instance & V & ObjectAccumulator<typeof Environment._instance & V>;
+    /**
+     * @static
+     * @description Retrieves the keys of the environment, optionally converting them to ENV format.
+     * @summary Gets all keys in the environment, with an option to format them for environment variables.
+     * @param {boolean} [toEnv=true] - Whether to convert the keys to ENV format.
+     * @return {string[]} An array of keys from the environment.
+     */
+    static keys(toEnv?: boolean): string[];
+}