@decaf-ts/logging 0.15.0 → 0.17.0

package/lib/types/logging.d.mts

@@ -0,0 +1,373 @@
+import { LoggerFactory, LoggingConfig, LoggingContext, LoggingFilter, LogMeta, StringLike, Theme, Logger } from "./types.js";
+import { LogLevel } from "./constants.js";
+import { LogParameterDescriptor } from "./logParameters.js";
+import { LoggedEnvironment } from "./environment.js";
+export declare const ROOT_CONTEXT_SYMBOL: unique symbol;
+/**
+ * @description A minimal logger implementation.
+ * @summary MiniLogger is a lightweight logging class that implements the Logger interface. It provides basic logging functionality with support for different log levels, verbosity, context-aware logging, and customizable formatting.
+ * @param {string} [context] - The context (typically class name) this logger is associated with.
+ * @param {Partial<LoggingConfig>} [conf] - Optional configuration to override global settings.
+ * @param {string[]} [baseContext=[]] - The base context for the logger.
+ * @class MiniLogger
+ * @example
+ * // Create a new logger for a class
+ * const logger = new MiniLogger('MyClass');
+ *
+ * // Log messages at different levels
+ * logger.info('This is an info message');
+ * logger.debug('This is a debug message');
+ * logger.error('Something went wrong');
+ *
+ * // Create a child logger for a specific method
+ * const methodLogger = logger.for('myMethod');
+ * methodLogger.verbose('Detailed information', 2);
+ *
+ * // Log with custom configuration
+ * logger.for('specialMethod', { style: true }).info('Styled message');
+ */
+export declare class MiniLogger implements Logger {
+    protected conf?: Partial<LoggingConfig> | undefined;
+    protected context: string[];
+    protected baseContext: string[];
+    constructor(context?: string, conf?: Partial<LoggingConfig> | undefined, baseContext?: string[]);
+    protected config<K extends keyof LoggingConfig>(key: K): LoggingConfig[K];
+    for(config: Partial<LoggingConfig>): this;
+    for(method: string | ((...args: any[]) => any) | {
+        new (...args: any[]): any;
+    } | object): this;
+    for(method: string | ((...args: any[]) => any) | {
+        new (...args: any[]): any;
+    } | object | Partial<LoggingConfig>, config: Partial<LoggingConfig>, ...args: any[]): this;
+    protected getConfigSnapshot(): LoggingConfig;
+    protected getContextSegments(): string[];
+    protected resolveFilters(config: LoggingConfig): LoggingFilter[];
+    protected applyFilters(message: string, context: string[], config: LoggingConfig): string;
+    /**
+     * @description Creates a formatted log string.
+     * @summary Generates a log string with timestamp, colored log level, context, and message.
+     * @param {LogLevel} level - The log level for this message.
+     * @param {StringLike | Error} message - The message to log or an Error object.
+     * @param {Error} [error] - Optional error to extract stack trace to include in the log.
+     * @return {string} A formatted log string with all components.
+     */
+    protected createLog(level: LogLevel, message: StringLike | Error, error?: Error, meta?: LogMeta): string;
+    private formatMeta;
+    protected normalizePatternSpacing(value: string): string;
+    /**
+     * @description Logs a message with the specified log level.
+     * @summary Checks if the message should be logged based on the current log level, then uses the appropriate console method to output the formatted log.
+     * @param {LogLevel} level - The log level of the message.
+     * @param {StringLike | Error} msg - The message to be logged or an Error object.
+     * @param {Error} [error] - Optional stack trace to include in the log.
+     * @return {void}
+     */
+    protected log(level: LogLevel, msg: StringLike | Error, error?: Error, meta?: LogMeta): void;
+    /**
+     * @description Logs a message at the benchmark level.
+     * @summary Logs a message at the benchmark level if the current verbosity setting allows it.
+     * @param {StringLike} msg - The message to be logged.
+     * @param {object} [meta] - Optional metadata to include with the entry.
+     * @return {void}
+     */
+    benchmark(msg: StringLike, meta?: LogMeta): void;
+    /**
+     * @description Logs a message at the silly level.
+     * @summary Logs a message at the silly level if the current verbosity setting allows it.
+     * @param {StringLike} msg - The message to be logged.
+     * @param {number} [verbosity=0] - The verbosity level of the message.
+     * @param {object} [meta] - Optional metadata to include with the entry.
+     * @return {void}
+     */
+    silly(msg: StringLike, verbosityOrMeta?: number | LogMeta, meta?: LogMeta): void;
+    /**
+     * @description Logs a message at the verbose level.
+     * @summary Logs a message at the verbose level if the current verbosity setting allows it.
+     * @param {StringLike} msg - The message to be logged.
+     * @param {number} [verbosity=0] - The verbosity level of the message.
+     * @param {object} [meta] - Optional metadata to include with the entry.
+     * @return {void}
+     */
+    verbose(msg: StringLike, verbosityOrMeta?: number | LogMeta, meta?: LogMeta): void;
+    /**
+     * @description Logs a message at the info level.
+     * @summary Logs a message at the info level for general application information.
+     * @param {StringLike} msg - The message to be logged.
+     * @param {object} [meta] - Optional metadata to include with the entry.
+     * @return {void}
+     */
+    info(msg: StringLike, meta?: LogMeta): void;
+    /**
+     * @description Logs a message at the debug level.
+     * @summary Logs a message at the debug level for detailed troubleshooting information.
+     * @param {StringLike} msg - The message to be logged.
+     * @param {object} [meta] - Optional metadata to include with the entry.
+     * @return {void}
+     */
+    debug(msg: StringLike, meta?: LogMeta): void;
+    /**
+     * @description Logs a message at the error level.
+     * @summary Logs a message at the error level for errors and exceptions.
+     * @param {StringLike | Error} msg - The message to be logged or an Error object.
+     * @param {Error|object} [e] - Optional error or metadata to include in the log.
+     * @param {object} [meta] - Optional metadata to include with the entry when an error is supplied.
+     * @return {void}
+     */
+    error(msg: StringLike | Error, e?: Error | LogMeta, meta?: LogMeta): void;
+    /**
+     * @description Logs a message at the warning level.
+     * @summary Logs a message at the warning level for potential issues.
+     * @param {StringLike} msg - The message to be logged.
+     * @param {object} [meta] - Optional metadata to include with the entry.
+     * @return {void}
+     */
+    warn(msg: StringLike, meta?: LogMeta): void;
+    /**
+     * @description Logs a message at the trace level.
+     * @summary Logs a message at the trace level for tracing code execution.
+     * @param {StringLike} msg - The message to be logged.
+     * @param {object} [meta] - Optional metadata to include with the entry.
+     * @return {void}
+     */
+    trace(msg: StringLike, meta?: LogMeta): void;
+    /**
+     * @description Updates the logger configuration.
+     * @summary Merges the provided configuration with the existing configuration.
+     * @param {Partial<LoggingConfig>} config - The configuration options to apply.
+     * @return {void}
+     */
+    setConfig(config: Partial<LoggingConfig>): void;
+    get root(): string[];
+    /**
+     * @description Clears any contextual overrides applied by `for`.
+     * @summary Returns the same logger instance so more contexts can be chained afterwards.
+     * @return {this} The same logger instance.
+     */
+    clear(): this;
+}
+/**
+ * @description A static class for managing logging operations.
+ * @summary The Logging class provides a centralized logging mechanism with support for different log levels, verbosity, and styling. It uses a singleton pattern to maintain a global logger instance and allows creating specific loggers for different classes and methods.
+ * @class Logging
+ * @example
+ * // Set global configuration
+ * Logging.setConfig({ level: LogLevel.debug, style: true });
+ *
+ * // Get a logger for a specific class
+ * const logger = Logging.for('MyClass');
+ *
+ * // Log messages at different levels
+ * logger.info('Application started');
+ * logger.debug('Processing data...');
+ *
+ * // Log with context
+ * const methodLogger = Logging.for('MyClass.myMethod');
+ * methodLogger.verbose('Detailed operation information', 1);
+ *
+ * // Log errors
+ * try {
+ *   // some operation
+ * } catch (error) {
+ *   logger.error(error);
+ * }
+ * @mermaid
+ * classDiagram
+ *   class Logger {
+ *     <<interface>>
+ *     +for(method, config, ...args)
+ *     +silly(msg, verbosity)
+ *     +verbose(msg, verbosity)
+ *     +info(msg)
+ *     +debug(msg)
+ *     +error(msg)
+ *     +setConfig(config)
+ *   }
+ *
+ *   class Logging {
+ *     -global: Logger
+ *     -_factory: LoggerFactory
+ *     -_config: LoggingConfig
+ *     +setFactory(factory)
+ *     +setConfig(config)
+ *     +getConfig()
+ *     +get()
+ *     +verbose(msg, verbosity)
+ *     +info(msg)
+ *     +debug(msg)
+ *     +silly(msg)
+ *     +error(msg)
+ *     +for(object, config, ...args)
+ *     +because(reason, id)
+ *     +theme(text, type, loggerLevel, template)
+ *   }
+ *
+ *   class MiniLogger {
+ *     +constructor(context, conf?)
+ *   }
+ *
+ *   Logging ..> Logger : creates
+ *   Logging ..> MiniLogger : creates by default
+ */
+export declare class Logging {
+    /**
+     * @description The global logger instance.
+     * @summary A singleton instance of Logger used for global logging.
+     */
+    private static global?;
+    /**
+     * @description Factory function for creating logger instances.
+     * @summary A function that creates new Logger instances. By default, it creates a MiniLogger.
+     */
+    private static _factory;
+    private static _config;
+    private constructor();
+    /**
+     * @description Sets the factory function for creating logger instances.
+     * @summary Allows customizing how logger instances are created.
+     * @param {LoggerFactory} factory - The factory function to use for creating loggers.
+     * @return {void}
+     */
+    static setFactory(factory: LoggerFactory): void;
+    /**
+     * @description Updates the global logging configuration.
+     * @summary Allows updating the global logging configuration with new settings.
+     * @param {Partial<LoggingConfig>} config - The configuration options to apply.
+     * @return {void}
+     */
+    static setConfig(config: Partial<LoggingConfig>): void;
+    /**
+     * @description Gets a copy of the current global logging configuration.
+     * @summary Returns a copy of the current global logging configuration.
+     * @return {LoggingConfig} A copy of the current configuration.
+     */
+    static getConfig(): typeof LoggedEnvironment;
+    /**
+     * @description Retrieves or creates the global logger instance.
+     * @summary Returns the existing global logger or creates a new one if it doesn't exist.
+     * @return {Logger} The global Logger instance.
+     */
+    static get(): Logger;
+    /**
+     * @description Logs a verbose message.
+     * @summary Delegates the verbose logging to the global logger instance.
+     * @param {StringLike} msg - The message to be logged.
+     * @param {number|object} [verbosity] - The verbosity level or metadata object.
+     * @param {object} [meta] - Optional metadata applied when a verbosity level is provided.
+     * @return {void}
+     */
+    static verbose(msg: StringLike, verbosityOrMeta?: number | LogMeta, meta?: LogMeta): void;
+    /**
+     * @description Logs an info message.
+     * @summary Delegates the info logging to the global logger instance.
+     * @param {StringLike} msg - The message to be logged.
+     * @param {object} [meta] - Optional metadata to include with the entry.
+     * @return {void}
+     */
+    static info(msg: StringLike, meta?: LogMeta): void;
+    /**
+     * @description Logs a trace message.
+     * @summary Delegates the trace logging to the global logger instance.
+     * @param {StringLike} msg - The message to be logged.
+     * @param {object} [meta] - Optional metadata to include with the entry.
+     * @return {void}
+     */
+    static trace(msg: StringLike, meta?: LogMeta): void;
+    /**
+     * @description Logs a debug message.
+     * @summary Delegates the debug logging to the global logger instance.
+     * @param {StringLike} msg - The message to be logged.
+     * @param {object} [meta] - Optional metadata to include with the entry.
+     * @return {void}
+     */
+    static debug(msg: StringLike, meta?: LogMeta): void;
+    /**
+     * @description Logs a benchmark message.
+     * @summary Delegates the benchmark logging to the global logger instance.
+     * @param {StringLike} msg - The message to be logged.
+     * @param {object} [meta] - Optional metadata to include with the entry.
+     * @return {void}
+     */
+    static benchmark(msg: StringLike, meta?: LogMeta): void;
+    /**
+     * @description Logs a silly message.
+     * @summary Delegates the silly logging to the global logger instance.
+     * @param {StringLike} msg - The message to be logged.
+     * @param {number|object} [verbosity] - The verbosity level or metadata object.
+     * @param {object} [meta] - Optional metadata applied when a verbosity level is provided.
+     * @return {void}
+     */
+    static silly(msg: StringLike, verbosityOrMeta?: number | LogMeta, meta?: LogMeta): void;
+    /**
+     * @description Logs a warning message.
+     * @summary Delegates the warning logging to the global logger instance.
+     * @param {StringLike} msg - The message to be logged.
+     * @param {object} [meta] - Optional metadata to include with the entry.
+     * @return {void}
+     */
+    static warn(msg: StringLike, meta?: LogMeta): void;
+    /**
+     * @description Logs an error message.
+     * @summary Delegates the error logging to the global logger instance.
+     * @param {StringLike | Error} msg - The message to be logged.
+     * @param {Error|object} [e] - Optional error or metadata to include in the log.
+     * @param {object} [meta] - Optional metadata to include with the entry when an error is supplied.
+     * @return {void}
+     */
+    static error(msg: StringLike | Error, e?: Error | LogMeta, meta?: LogMeta): void;
+    /**
+     * @description Creates a logger for a specific object or context.
+     * @summary Creates a new logger instance for the given object or context using the factory function.
+     * @param {LoggingContext} object - The object, class, or context to create a logger for.
+     * @param {Partial<LoggingConfig>} [config] - Optional configuration to override global settings.
+     * @param {...any} args - Additional arguments to pass to the logger factory.
+     * @return {Logger} A new logger instance for the specified object or context.
+     */
+    static for(object: LoggingContext, config?: Partial<LoggingConfig>, ...args: any[]): Logger;
+    /**
+     * @description Creates a logger for a specific reason or correlation context.
+     * @summary Utility to quickly create a logger labeled with a free-form reason and optional identifier so that ad-hoc operations can be traced without tying the logger to a class or method name.
+     * @param {string} reason - A textual reason or context label for this logger instance.
+     * @param {string} [id] - Optional identifier to help correlate related log entries.
+     * @return {Logger} A new logger instance labeled with the provided reason and id.
+     */
+    static because(reason: string, id?: string): Logger;
+    private static baseContext;
+    private static attachRootContext;
+    private static ensureRoot;
+    /**
+     * @description Applies theme styling to text.
+     * @summary Applies styling (colors, formatting) to text based on the theme configuration.
+     * @param {string} text - The text to style.
+     * @param type - The type of element to style (e.g., "class", "message", "logLevel").
+     * @param {LogLevel} loggerLevel - The log level to use for styling.
+     * @param {Theme} [template=DefaultTheme] - The theme to use for styling.
+     * @return {string} The styled text.
+     * @mermaid
+     * sequenceDiagram
+     *   participant Caller
+     *   participant Theme as Logging.theme
+     *   participant Apply as apply function
+     *   participant Style as styled-string-builder
+     *
+     *   Caller->>Theme: theme(text, type, loggerLevel)
+     *   Theme->>Theme: Check if styling is enabled
+     *   alt styling disabled
+     *     Theme-->>Caller: return original text
+     *   else styling enabled
+     *     Theme->>Theme: Get theme for type
+     *     alt theme not found
+     *       Theme-->>Caller: return original text
+     *     else theme found
+     *       Theme->>Theme: Determine actual theme based on log level
+     *       Theme->>Apply: Apply each style property
+     *       Apply->>Style: Apply colors and formatting
+     *       Style-->>Apply: Return styled text
+     *       Apply-->>Theme: Return styled text
+     *       Theme-->>Caller: Return final styled text
+     *     end
+     *   end
+     */
+    static theme(text: string, type: keyof Theme | keyof LogLevel, loggerLevel: LogLevel, template?: Theme): string;
+    static register(descriptor: LogParameterDescriptor): import("./logParameters.js").LogParameterRegistry;
+    static unregister(key: string): import("./logParameters.js").LogParameterRegistry;
+}

package/lib/types/pino/index.d.cts

@@ -0,0 +1,7 @@
+/**
+ * @module Pino
+ * @description This module provides an adapter for the Pino logger.
+ * @summary This module exports the {@link PinoLogger} class.
+ * @memberOf module:Logging
+ */
+export * from "./pino.cjs";

package/lib/types/pino/index.d.mts

@@ -0,0 +1,7 @@
+/**
+ * @module Pino
+ * @description This module provides an adapter for the Pino logger.
+ * @summary This module exports the {@link PinoLogger} class.
+ * @memberOf module:Logging
+ */
+export * from "./pino.js";

package/lib/types/pino/pino.d.cts

@@ -0,0 +1,29 @@
+import { Logger as PinoBaseLogger } from "pino";
+import { MiniLogger } from "../logging.cjs";
+import { Logger, LoggerFactory, LogMeta, LoggingConfig, StringLike } from "../types.cjs";
+import { LogLevel } from "../constants.cjs";
+/**
+ * @description A logger that is powered by the Pino logging library.
+ * @summary This class extends {@link MiniLogger} and uses Pino as its underlying logging engine.
+ * @param {string} [context] - The context (typically the class name) that this logger is associated with.
+ * @param {Partial<LoggingConfig>} [conf] - Optional configuration to override global settings.
+ * @param {PinoBaseLogger} [driver] - An optional, pre-existing Pino logger instance to use.
+ * @class PinoLogger
+ */
+export declare class PinoLogger extends MiniLogger implements Logger {
+    protected pino: PinoBaseLogger;
+    constructor(context?: string, conf?: Partial<LoggingConfig>, driver?: PinoBaseLogger);
+    protected log(level: LogLevel, msg: StringLike | Error, error?: Error, meta?: LogMeta): void;
+    fatal(msg: StringLike | Error, error?: Error, meta?: LogMeta): void;
+    child(bindings?: Record<string, unknown>, options?: Record<string, unknown>): PinoLogger;
+    flush(): void | Promise<void>;
+    get level(): string | undefined;
+    set level(value: string | undefined);
+}
+/**
+ * @description A factory for creating {@link PinoLogger} instances.
+ * @summary This factory function creates a new {@link PinoLogger} instance, and can optionally accept a pre-existing Pino logger instance.
+ * @const {LoggerFactory} PinoFactory
+ * @memberOf module:Logging
+ */
+export declare const PinoFactory: LoggerFactory;

package/lib/types/pino/pino.d.mts

@@ -0,0 +1,29 @@
+import { Logger as PinoBaseLogger } from "pino";
+import { MiniLogger } from "../logging.js";
+import { Logger, LoggerFactory, LogMeta, LoggingConfig, StringLike } from "../types.js";
+import { LogLevel } from "../constants.js";
+/**
+ * @description A logger that is powered by the Pino logging library.
+ * @summary This class extends {@link MiniLogger} and uses Pino as its underlying logging engine.
+ * @param {string} [context] - The context (typically the class name) that this logger is associated with.
+ * @param {Partial<LoggingConfig>} [conf] - Optional configuration to override global settings.
+ * @param {PinoBaseLogger} [driver] - An optional, pre-existing Pino logger instance to use.
+ * @class PinoLogger
+ */
+export declare class PinoLogger extends MiniLogger implements Logger {
+    protected pino: PinoBaseLogger;
+    constructor(context?: string, conf?: Partial<LoggingConfig>, driver?: PinoBaseLogger);
+    protected log(level: LogLevel, msg: StringLike | Error, error?: Error, meta?: LogMeta): void;
+    fatal(msg: StringLike | Error, error?: Error, meta?: LogMeta): void;
+    child(bindings?: Record<string, unknown>, options?: Record<string, unknown>): PinoLogger;
+    flush(): void | Promise<void>;
+    get level(): string | undefined;
+    set level(value: string | undefined);
+}
+/**
+ * @description A factory for creating {@link PinoLogger} instances.
+ * @summary This factory function creates a new {@link PinoLogger} instance, and can optionally accept a pre-existing Pino logger instance.
+ * @const {LoggerFactory} PinoFactory
+ * @memberOf module:Logging
+ */
+export declare const PinoFactory: LoggerFactory;

package/lib/types/text.d.cts

@@ -0,0 +1,118 @@
+/**
+ * @description Pads the end of a string with a specified character.
+ * @summary This function extends the input string to a specified length by adding a padding character to the end. If the input string is already longer than the specified length, it is returned unchanged.
+ * @param {string} str - The input string to be padded.
+ * @param {number} length - The desired total length of the resulting string.
+ * @param {string} [char=" "] - The character to use for padding.
+ * @return {string} The padded string.
+ * @throws {Error} If the padding character is not exactly one character long.
+ * @function padEnd
+ * @memberOf module:Logging
+ */
+export declare function padEnd(str: string, length: number, char?: string): string;
+/**
+ * @description Replaces placeholders in a string with the provided values.
+ * @summary This function interpolates a string by replacing placeholders of the form `${variableName}` with the corresponding values from the provided object. If a placeholder does not have a corresponding value, it is left unchanged in the string.
+ * @param {string} input - The input string containing the placeholders to be replaced.
+ * @param {Record<string, (number|string)>} values - An object containing key-value pairs for the replacement.
+ * @param {string} [prefix="${"] - The prefix for the placeholders.
+ * @param {string} [suffix="}"] - The suffix for the placeholders.
+ * @param {string} [flags="g"] - The regular expression flags to use.
+ * @return {string} The interpolated string with the placeholders replaced by their corresponding values.
+ * @function patchPlaceholders
+ * @mermaid
+ * sequenceDiagram
+ *   participant Caller
+ *   participant patchString
+ *   participant String.replace
+ *   Caller->>patchString: Call with input and values
+ *   patchString->>String.replace: Call with regex and replacement function
+ *   String.replace->>patchString: Return replaced string
+ *   patchString-->>Caller: Return patched string
+ * @memberOf module:Logging
+ */
+export declare function patchPlaceholders(input: string, values: Record<string, number | string>, prefix?: string, suffix?: string, flags?: string): string;
+/**
+ * @description Replaces occurrences of keys with their corresponding values in a string.
+ * @summary This function iterates through a set of key-value pairs and replaces all occurrences of each key in the input string with its corresponding value. It supports regular expression flags for customized replacement.
+ * @param {string} input - The input string in which the replacements will be made.
+ * @param {Record<string, (number|string)>} values - An object containing key-value pairs for the replacement.
+ * @param {string} [flags="g"] - The regular expression flags to control the replacement behavior.
+ * @return {string} The string with all the specified replacements applied.
+ * @function patchString
+ * @memberOf module:Logging
+ */
+export declare function patchString(input: string, values: Record<string, number | string>, flags?: string): string;
+/**
+ * @description Converts a string to camelCase.
+ * @summary This function transforms the input string into camelCase format, where words are joined without spaces and each word after the first starts with a capital letter.
+ * @param {string} text - The input string to be converted.
+ * @return {string} The input string converted to camelCase.
+ * @function toCamelCase
+ * @memberOf module:Logging
+ */
+export declare function toCamelCase(text: string): string;
+/**
+ * @description Converts a string to ENVIRONMENT_VARIABLE format.
+ * @summary This function transforms the input string into uppercase with words separated by underscores, which is a format that is typically used for environment variable names.
+ * @param {string} text - The input string to be converted.
+ * @return {string} The input string converted to ENVIRONMENT_VARIABLE format.
+ * @function toENVFormat
+ * @memberOf module:Logging
+ */
+export declare function toENVFormat(text: string): string;
+/**
+ * @description Converts a string to snake_case.
+ * @summary This function transforms the input string into lowercase with words separated by underscores.
+ * @param {string} text - The input string to be converted.
+ * @return {string} The input string converted to snake_case.
+ * @function toSnakeCase
+ * @memberOf module:Logging
+ */
+export declare function toSnakeCase(text: string): string;
+/**
+ * @description Converts a string to kebab-case.
+ * @summary This function transforms the input string into lowercase with words separated by hyphens.
+ * @param {string} text - The input string to be converted.
+ * @return {string} The input string converted to kebab-case.
+ * @function toKebabCase
+ * @memberOf module:Logging
+ */
+export declare function toKebabCase(text: string): string;
+/**
+ * @description Converts a string to PascalCase.
+ * @summary This function transforms the input string into PascalCase format, where words are joined without spaces and each word starts with a capital letter.
+ * @param {string} text - The input string to be converted.
+ * @return {string} The input string converted to PascalCase.
+ * @function toPascalCase
+ * @memberOf module:Logging
+ */
+export declare function toPascalCase(text: string): string;
+/**
+ * @description Escapes special characters in a string for use in a regular expression.
+ * @summary This function adds backslashes before characters that have a special meaning in regular expressions, which allows the string to be used as a literal match in a RegExp.
+ * @param {string} string - The string to escape for regular expression use.
+ * @return {string} The escaped string that is safe for use in regular expressions.
+ * @function escapeRegExp
+ * @memberOf module:Logging
+ */
+export declare function escapeRegExp(string: string): string;
+/**
+ * @description A utility function that provides string formatting functionality that is similar to C#'s string.format.
+ * @summary This function replaces placeholders in a string with the provided arguments.
+ * @param {string} string - The string to format.
+ * @param {...(string|number|Record<string, any>)} args - The arguments to use for formatting.
+ * @return {string} The formatted string.
+ * @function sf
+ * @memberOf module:Logging
+ */
+export declare function sf(string: string, ...args: (string | number | Record<string, any>)[]): string;
+/**
+ * @description A utility function that provides string formatting functionality that is similar to C#'s string.format.
+ * @summary This function is deprecated. Use {@link sf} instead.
+ * @see sf
+ * @deprecated
+ * @function stringFormat
+ * @memberOf module:Logging
+ */
+export declare const stringFormat: typeof sf;