@loglayer/mixin-datadog-http-metrics 1.0.0

package/dist/index.d.mts

@@ -0,0 +1,1735 @@
+import metrics, { BufferedMetricsLogger as BufferedMetricsLogger$1, BufferedMetricsLoggerOptions, BufferedMetricsLoggerOptions as BufferedMetricsLoggerOptions$1 } from "datadog-metrics";
+
+//#region ../../core/shared/dist/index.d.ts
+//#region src/common.types.d.ts
+declare enum LogLevel {
+  info = "info",
+  warn = "warn",
+  error = "error",
+  debug = "debug",
+  trace = "trace",
+  fatal = "fatal"
+}
+/**
+ * Combination of the LogLevel enum and its string representations.
+ */
+type LogLevelType = LogLevel | `${LogLevel}`;
+/**
+ * Mapping of log levels to their numeric values.
+ */
+type MessageDataType = string | number | boolean | null | undefined;
+/**
+ * Options for the `errorOnly` method.
+ * @see {@link https://loglayer.dev/logging-api/error-handling.html#error-only-logging | Error Only Logging Doc}
+ */
+interface ErrorOnlyOpts {
+  /**
+   * Sets the log level of the error
+   */
+  logLevel?: LogLevel;
+  /**
+   * If `true`, copies the `error.message` if available to the transport library's
+   * message property.
+   *
+   * If the config option `error.copyMsgOnOnlyError` is enabled, this property
+   * can be set to `true` to disable the behavior for this specific log entry.
+   */
+  copyMsg?: boolean;
+}
+/**
+ * Defines the structure for context data that persists across multiple log entries
+ * within the same context scope. This is set using log.withContext().
+ */
+interface LogLayerContext extends Record<string, any> {}
+/**
+ * Defines the structure for metadata that can be attached to individual log entries.
+ * This is set using log.withMetadata() or log.metadataOnly().
+ */
+interface LogLayerMetadata extends Record<string, any> {}
+/**
+ * Used internally by LogLayer when assembling the final data object (metadata / context / error) sent to transports.
+ */
+interface LogLayerData extends Record<string, any> {}
+interface LogLayerCommonDataParams {
+  /**
+   * Combined object data containing the metadata, context, and / or error data in a
+   * structured format configured by the user.
+   */
+  data?: LogLayerData;
+  /**
+   * Individual metadata object passed to the log message method.
+   */
+  metadata?: LogLayerMetadata;
+  /**
+   * Error passed to the log message method.
+   */
+  error?: any;
+  /**
+   * Context data that is included with each log entry.
+   */
+  context?: LogLayerContext;
+} //#endregion
+//#region src/plugin.types.d.ts
+/**
+ * Input for the `onBeforeDataOut` plugin lifecycle method.
+ * @see {@link https://loglayer.dev/plugins/creating-plugins.html#onbeforedataout | Creating Plugins}
+ */
+interface PluginBeforeDataOutParams extends LogLayerCommonDataParams {
+  /**
+   * Log level of the data
+   */
+  logLevel: LogLevelType;
+}
+/**
+ * Input for the `transformLogLevel` plugin lifecycle method.
+ * @see {@link https://loglayer.dev/plugins/creating-plugins.html#transformloglevel | Creating Plugins}
+ */
+interface PluginTransformLogLevelParams extends LogLayerCommonDataParams {
+  /**
+   * Log level of the data
+   */
+  logLevel: LogLevelType;
+  /**
+   * Message data that is copied from the original.
+   */
+  messages: any[];
+}
+/**
+ * Input for the `shouldSendToLogger` plugin lifecycle method.
+ * @see {@link https://loglayer.dev/plugins/creating-plugins.html#shouldsendtologger | Creating Plugins}
+ */
+interface PluginShouldSendToLoggerParams extends LogLayerCommonDataParams {
+  /**
+   * Unique identifier for the transport. Can be used to not send to a specific transport.
+   */
+  transportId?: string;
+  /**
+   * Message data that is copied from the original.
+   */
+  messages: any[];
+  /**
+   * Log level of the message
+   */
+  logLevel: LogLevelType;
+}
+/**
+ * Input for the `onBeforeMessageOut` plugin lifecycle method.
+ * @see {@link https://loglayer.dev/plugins/creating-plugins.html#onbeforemessageout | Creating Plugins}
+ */
+interface PluginBeforeMessageOutParams {
+  /**
+   * Log level of the message
+   */
+  logLevel: LogLevelType;
+  /**
+   * Message data that is copied from the original.
+   */
+  messages: any[];
+}
+/**
+ * Parameters for creating a LogLayer plugin.
+ * @see {@link https://loglayer.dev/plugins/creating-plugins.html | Creating Plugins}
+ */
+interface LogLayerPluginParams {
+  /**
+   * Unique identifier for the plugin. Used for selectively disabling / enabling
+   * and removing the plugin. If not defined, a randomly generated ID will be used.
+   */
+  id?: string;
+  /**
+   * If true, the plugin will skip execution
+   */
+  disabled?: boolean;
+}
+/**
+ * Interface for implementing a LogLayer plugin.
+ * @see {@link https://loglayer.dev/plugins/creating-plugins.html | Creating Plugins}
+ */
+interface LogLayerPlugin extends LogLayerPluginParams {
+  /**
+   * Called after `onBeforeDataOut` and `onBeforeMessageOut` but before `shouldSendToLogger` to transform the log level.
+   * This allows you to change the log level based on the processed log data, metadata, context, error, or messages.
+   *
+   * - The shape of `data` varies depending on your `fieldName` configuration
+   * for metadata / context / error. The metadata / context / error data is a *shallow* clone.
+   * - If data was not found for assembly, `undefined` is used as the `data` input.
+   * - The `data` parameter will contain any modifications made by `onBeforeDataOut` plugins.
+   * - The `messages` parameter will contain any modifications made by `onBeforeMessageOut` plugins.
+   * - If multiple plugins define `transformLogLevel`, the last one that returns a valid log level wins.
+   *
+   * @returns [LogLevelType] The log level to use for the log. Returning null, undefined, or false
+   * will use the log level originally specified.
+   *
+   * @see {@link https://loglayer.dev/plugins/creating-plugins.html#transformloglevel | Creating Plugins}
+   */
+  transformLogLevel?(params: PluginTransformLogLevelParams, loglayer: ILogLayer): LogLevelType | null | undefined | false;
+  /**
+   * Called after the assembly of the data object that contains
+   * the metadata / context / error data before being sent to the destination logging
+   * library.
+   *
+   * - The shape of `data` varies depending on your `fieldName` configuration
+   * for metadata / context / error. The metadata / context / error data is a *shallow* clone.
+   * - If data was not found for assembly, `undefined` is used as the `data` input.
+   * - You can also create your own object and return it to be sent to the logging library.
+   *
+   * @returns [Object] The object to be sent to the destination logging
+   * library or null / undefined to not pass an object through.
+   *
+   * @see {@link https://loglayer.dev/plugins/creating-plugins.html#onbeforedataout | Creating Plugins}
+   */
+  onBeforeDataOut?(params: PluginBeforeDataOutParams, loglayer: ILogLayer): LogLayerData | null | undefined;
+  /**
+   * Called after `onBeforeDataOut` and before `shouldSendToLogger`.
+   * This allows you to modify the message data before it is sent to the destination logging library.
+   *
+   * @returns [Array] The message data to be sent to the destination logging library.
+   *
+   * @see {@link https://loglayer.dev/plugins/creating-plugins.html#onbeforemessageout | Creating Plugins}
+   */
+  onBeforeMessageOut?(params: PluginBeforeMessageOutParams, loglayer: ILogLayer): any[];
+  /**
+   * Called before the data is sent to the transport. Return false to omit sending
+   * to the transport. Useful for isolating specific log messages for debugging /
+   * troubleshooting.
+   *
+   * If there are multiple plugins with shouldSendToLogger defined, the
+   * first plugin to return false will stop the data from being sent to the
+   * transport.
+   *
+   * @returns boolean If true, sends data to the transport, if false does not.
+   *
+   * @see {@link https://loglayer.dev/plugins/creating-plugins.html#shouldsendtologger | Creating Plugins}
+   */
+  shouldSendToLogger?(params: PluginShouldSendToLoggerParams, loglayer: ILogLayer): boolean;
+  /**
+   * Called when withMetadata() or metadataOnly() is called. This allows you to modify the metadata before it is sent to the destination logging library.
+   *
+   * The metadata is a *shallow* clone of the metadata input.
+   *
+   * If null is returned, then no metadata will be sent to the destination logging library.
+   *
+   * In multiple plugins, the modified metadata will be passed through each plugin in the order they are added.
+   *
+   * @returns [Object] The metadata object to be sent to the destination logging library.
+   *
+   * @see {@link https://loglayer.dev/plugins/creating-plugins.html#onmetadatacalled | Creating Plugins}
+   */
+  onMetadataCalled?: (metadata: LogLayerMetadata, loglayer: ILogLayer) => LogLayerMetadata | null | undefined;
+  /**
+   * Called when withContext() is called. This allows you to modify the context before it is used.
+   *
+   * The context is a *shallow* clone of the context input.
+   *
+   * If null is returned, then no context will be used.
+   *
+   * In multiple plugins, the modified context will be passed through each plugin in the order they are added.
+   *
+   * @returns [Object] The context object to be used.
+   *
+   * @see {@link https://loglayer.dev/plugins/creating-plugins.html#oncontextcalled | Creating Plugins}
+   */
+  onContextCalled?: (context: LogLayerContext, loglayer: ILogLayer) => LogLayerContext | null | undefined;
+} //#endregion
+//#region src/loglayer.types.d.ts
+/**
+ * Interface for raw log entries that allows complete control over all aspects of a log entry.
+ *
+ * @see {@link https://loglayer.dev/logging-api/basic-logging.html#raw-logging | Raw Logging Documentation}
+ */
+interface RawLogEntry {
+  /**
+   * Context data to include with the log entry.
+   *
+   * - When provided, this context data will be used instead of the context manager.
+   * - If not provided, the context manager data will be used instead
+   * - An empty object will result in no context data being used at all
+   */
+  context?: LogLayerContext;
+  /**
+   * Metadata to include with the log entry.
+   */
+  metadata?: LogLayerMetadata;
+  /**
+   * Error object to include with the log entry.
+   */
+  error?: any;
+  /**
+   * The log level for this entry.
+   */
+  logLevel: LogLevelType;
+  /**
+   * Array of message parameters to log.
+   *
+   * These are the actual log messages and can include strings, numbers,
+   * booleans, null, or undefined values. The first string message will
+   * have any configured prefix applied to it.
+   */
+  messages?: MessageDataType[];
+}
+/**
+ * Context Manager callback function for when a child logger is created.
+ * @see {@link https://loglayer.dev/context-managers/creating-context-managers.html | Creating Context Managers Docs}
+ */
+interface OnChildLoggerCreatedParams {
+  /**
+   * The parent logger instance
+   */
+  parentLogger: ILogLayer<any>;
+  /**
+   * The child logger instance
+   */
+  childLogger: ILogLayer<any>;
+  /**
+   * The parent logger's context manager
+   */
+  parentContextManager: IContextManager;
+  /**
+   * The child logger's context manager
+   */
+  childContextManager: IContextManager;
+}
+/**
+ * Interface for implementing a context manager instance.
+ *
+ * If your context manager needs to clean up resources (like file handles, memory, or external connections),
+ * you can optionally implement the {@link https://www.typescriptlang.org/docs/handbook/release-notes/typescript-5-2.html#using-declarations-and-explicit-resource-management | Disposable} interface.
+ * LogLayer will automatically call the dispose method when the context manager is replaced using `withContextManager()`.
+ *
+ * @see {@link https://loglayer.dev/context-managers/creating-context-managers.html | Creating Context Managers Docs}
+ */
+interface IContextManager {
+  /**
+   * Sets the context data to be included with every log entry. Set to `undefined` to clear the context data.
+   */
+  setContext(context?: LogLayerContext): void;
+  /**
+   * Appends context data to the existing context data.
+   */
+  appendContext(context: Partial<LogLayerContext>): void;
+  /**
+   * Returns the context data to be included with every log entry.
+   */
+  getContext(): LogLayerContext;
+  /**
+   * Returns true if context data is present.
+   */
+  hasContextData(): boolean;
+  /**
+   * Clears the context data. If keys are provided, only those keys will be removed.
+   * If no keys are provided, all context data will be cleared.
+   */
+  clearContext(keys?: string | string[]): void;
+  /**
+   * Called when a child logger is created. Use to manipulate context data between parent and child.
+   */
+  onChildLoggerCreated(params: OnChildLoggerCreatedParams): void;
+  /**
+   * Creates a new instance of the context manager with the same context data.
+   */
+  clone(): IContextManager;
+}
+/**
+ * Log Level Manager callback function for when a child logger is created.
+ */
+interface OnChildLogLevelManagerCreatedParams {
+  /**
+   * The parent logger instance
+   */
+  parentLogger: ILogLayer<any>;
+  /**
+   * The child logger instance
+   */
+  childLogger: ILogLayer<any>;
+  /**
+   * The parent logger's log level manager
+   */
+  parentLogLevelManager: ILogLevelManager;
+  /**
+   * The child logger's log level manager
+   */
+  childLogLevelManager: ILogLevelManager;
+}
+/**
+ * Interface for implementing a log level manager instance.
+ *
+ * Log level managers are responsible for managing log level settings across logger instances.
+ * They control how log levels are inherited and propagated between parent and child loggers.
+ *
+ * If your log level manager needs to clean up resources (like parent-child references, memory, or external connections),
+ * you can optionally implement the {@link https://www.typescriptlang.org/docs/handbook/release-notes/typescript-5-2.html#using-declarations-and-explicit-resource-management | Disposable} interface.
+ * LogLayer will automatically call the dispose method when the log level manager is replaced using `withLogLevelManager()`.
+ *
+ * @see {@link https://loglayer.dev/log-level-managers/creating-log-level-managers.html | Creating Log Level Managers Docs}
+ */
+interface ILogLevelManager {
+  /**
+   * Sets the minimum log level to be used by the logger. Only messages with
+   * this level or higher severity will be logged.
+   *
+   * **When triggered:** Called when `logger.setLevel()` is invoked on a LogLayer instance.
+   */
+  setLevel(logLevel: LogLevelType): void;
+  /**
+   * Enables a specific log level.
+   *
+   * **When triggered:** Called when `logger.enableIndividualLevel()` is invoked on a LogLayer instance.
+   */
+  enableIndividualLevel(logLevel: LogLevelType): void;
+  /**
+   * Disables a specific log level.
+   *
+   * **When triggered:** Called when `logger.disableIndividualLevel()` is invoked on a LogLayer instance.
+   */
+  disableIndividualLevel(logLevel: LogLevelType): void;
+  /**
+   * Checks if a specific log level is enabled.
+   *
+   * **When triggered:** Called before every log method execution (e.g., `info()`, `warn()`, `error()`, `debug()`, `trace()`, `fatal()`, `raw()`, `metadataOnly()`, `errorOnly()`) to determine if the log should be processed. Also called when `logger.isLevelEnabled()` is invoked directly.
+   */
+  isLevelEnabled(logLevel: LogLevelType): boolean;
+  /**
+   * Enable sending logs to the logging library.
+   *
+   * **When triggered:** Called when `logger.enableLogging()` is invoked on a LogLayer instance.
+   */
+  enableLogging(): void;
+  /**
+   * All logging inputs are dropped and stops sending logs to the logging library.
+   *
+   * **When triggered:** Called when `logger.disableLogging()` is invoked on a LogLayer instance, or when a LogLayer instance is created with `enabled: false` in the configuration.
+   */
+  disableLogging(): void;
+  /**
+   * Called when a child logger is created. Use to manipulate log level settings between parent and child.
+   *
+   * **When triggered:** Called automatically when `logger.child()` is invoked, after the child logger is created and the parent's log level manager has been cloned. This allows the manager to establish relationships between parent and child loggers.
+   */
+  onChildLoggerCreated(params: OnChildLogLevelManagerCreatedParams): void;
+  /**
+   * Creates a new instance of the log level manager with the same log level settings.
+   *
+   * **When triggered:** Called automatically when `logger.child()` is invoked to create a new log level manager instance for the child logger. The cloned instance should have the same initial log level state as the parent, but can be modified independently (unless the manager implements shared state behavior).
+   */
+  clone(): ILogLevelManager;
+}
+/**
+ * Input to the LogLayer transport shipToLogger() method.
+ * @see {@link https://loglayer.dev/transports/creating-transports.html | Creating Transports Docs}
+ */
+interface LogLayerTransportParams extends LogLayerCommonDataParams {
+  /**
+   * The log level of the message
+   */
+  logLevel: LogLevelType;
+  /**
+   * The parameters that were passed to the log message method (eg: info / warn / debug / error)
+   */
+  messages: any[];
+  /**
+   * If true, the data object is included in the message parameters
+   */
+  hasData?: boolean;
+}
+/**
+ * Interface for implementing a LogLayer transport instance.
+ * @see {@link https://loglayer.dev/transports/creating-transports.html | Creating Transports Docs}
+ */
+interface LogLayerTransport<LogLibrary = any> {
+  /**
+   * A user-defined identifier for the transport
+   **/
+  id?: string;
+  /**
+   * If false, the transport will not send logs to the logger.
+   * Default is true.
+   */
+  enabled?: boolean;
+  /**
+   * Sends the log data to the logger for transport
+   */
+  shipToLogger(params: LogLayerTransportParams): any[];
+  /**
+   * Internal use only. Do not implement.
+   * @param params
+   */
+  _sendToLogger(params: LogLayerTransportParams): void;
+  /**
+   * Returns the logger instance attached to the transport
+   */
+  getLoggerInstance(): LogLibrary;
+}
+/**
+ * Interface for implementing a LogLayer builder instance.
+ * @see {@link https://loglayer.dev | LogLayer Documentation}
+ */
+interface ILogBuilder<This = ILogBuilder<any>> {
+  /**
+   * Sends a log message to the logging library under an info log level.
+   */
+  info(...messages: MessageDataType[]): void;
+  /**
+   * Sends a log message to the logging library under the warn log level
+   */
+  warn(...messages: MessageDataType[]): void;
+  /**
+   * Sends a log message to the logging library under the error log level
+   */
+  error(...messages: MessageDataType[]): void;
+  /**
+   * Sends a log message to the logging library under the debug log level
+   */
+  debug(...messages: MessageDataType[]): void;
+  /**
+   * Sends a log message to the logging library under the trace log level
+   */
+  trace(...messages: MessageDataType[]): void;
+  /**
+   * Sends a log message to the logging library under the fatal log level
+   */
+  fatal(...messages: MessageDataType[]): void;
+  /**
+   * Specifies metadata to include with the log message
+   *
+   * @see {@link https://loglayer.dev/logging-api/metadata.html | Metadata Docs}
+   */
+  withMetadata(metadata?: LogLayerMetadata): This;
+  /**
+   * Specifies an Error to include with the log message
+   *
+   * @see {@link https://loglayer.dev/logging-api/error-handling.html | Error Handling Docs}
+   */
+  withError(error: any): This;
+  /**
+   * Enable sending logs to the logging library.
+   *
+   * @see {@link https://loglayer.dev/logging-api/basic-logging.html#enabling-disabling-logging | Enabling/Disabling Logging Docs}
+   */
+  enableLogging(): This;
+  /**
+   * All logging inputs are dropped and stops sending logs to the logging library.
+   *
+   * @see {@link https://loglayer.dev/logging-api/basic-logging.html#enabling-disabling-logging | Enabling/Disabling Logging Docs}
+   */
+  disableLogging(): This;
+}
+/**
+ * Interface for implementing a LogLayer logger instance.
+ * @see {@link https://loglayer.dev | LogLayer Documentation}
+ */
+interface ILogLayer<This = ILogLayer<any>> {
+  /**
+   * Sends a log message to the logging library under an info log level.
+   */
+  info(...messages: MessageDataType[]): void;
+  /**
+   * Sends a log message to the logging library under the warn log level
+   */
+  warn(...messages: MessageDataType[]): void;
+  /**
+   * Sends a log message to the logging library under the error log level
+   */
+  error(...messages: MessageDataType[]): void;
+  /**
+   * Sends a log message to the logging library under the debug log level
+   */
+  debug(...messages: MessageDataType[]): void;
+  /**
+   * Sends a log message to the logging library under the trace log level
+   */
+  trace(...messages: MessageDataType[]): void;
+  /**
+   * Sends a log message to the logging library under the fatal log level
+   */
+  fatal(...messages: MessageDataType[]): void;
+  /**
+   * Specifies metadata to include with the log message
+   *
+   * @see {@link https://loglayer.dev/logging-api/metadata.html | Metadata Docs}
+   */
+  withMetadata(metadata?: LogLayerMetadata): ILogBuilder<any>;
+  /**
+   * Specifies an Error to include with the log message
+   *
+   * @see {@link https://loglayer.dev/logging-api/error-handling.html | Error Handling Docs}
+   */
+  withError(error: any): ILogBuilder<any>;
+  /**
+   * Enable sending logs to the logging library.
+   *
+   * @see {@link https://loglayer.dev/logging-api/basic-logging.html#enabling-disabling-logging | Enabling/Disabling Logging Docs}
+   */
+  enableLogging(): This;
+  /**
+   * All logging inputs are dropped and stops sending logs to the logging library.
+   *
+   * @see {@link https://loglayer.dev/logging-api/basic-logging.html#enabling-disabling-logging | Enabling/Disabling Logging Docs}
+   */
+  disableLogging(): This;
+  /**
+   * Calls child() and sets the prefix to be included with every log message.
+   *
+   * @see {@link https://loglayer.dev/logging-api/basic-logging.html#message-prefixing | Message Prefixing Docs}
+   */
+  withPrefix(string: string): This;
+  /**
+   * Appends context data which will be included with
+   * every log entry.
+   *
+   * Passing in an empty value / object will *not* clear the context.
+   *
+   * To clear the context, use {@link clearContext}.
+   *
+   * @see {@link https://loglayer.dev/logging-api/context.html | Context Docs}
+   */
+  withContext(context?: LogLayerContext): This;
+  /**
+   * Clears the context data. If keys are provided, only those keys will be removed.
+   * If no keys are provided, all context data will be cleared.
+   *
+   * @see {@link https://loglayer.dev/logging-api/context.html | Context Docs}
+   */
+  clearContext(keys?: string | string[]): This;
+  /**
+   * Logs only the error object without a log message
+   *
+   * @see {@link https://loglayer.dev/logging-api/error-handling.html | Error Handling Docs}
+   */
+  errorOnly(error: any, opts?: ErrorOnlyOpts): void;
+  /**
+   * Logs only metadata without a log message
+   *
+   * @see {@link https://loglayer.dev/logging-api/metadata.html | Metadata Docs}
+   */
+  metadataOnly(metadata?: LogLayerMetadata, logLevel?: LogLevelType): void;
+  /**
+   * Returns the context used
+   *
+   * @see {@link https://loglayer.dev/logging-api/context.html | Context Docs}
+   */
+  getContext(): LogLayerContext;
+  /**
+   * Creates a new instance of LogLayer but with the initialization
+   * configuration and context data copied over.
+   *
+   * The copied context data is a *shallow copy*.
+   *
+   * @see {@link https://loglayer.dev/logging-api/child-loggers.html | Child Logging Docs}
+   */
+  child(): This;
+  /**
+   * Disables inclusion of context data in the print
+   *
+   * @see {@link https://loglayer.dev/logging-api/context.html#managing-context | Managing Context Docs}
+   */
+  muteContext(): This;
+  /**
+   * Enables inclusion of context data in the print
+   *
+   * @see {@link https://loglayer.dev/logging-api/context.html#managing-context | Managing Context Docs}
+   */
+  unMuteContext(): This;
+  /**
+   * Disables inclusion of metadata data in the print
+   *
+   * @see {@link https://loglayer.dev/logging-api/metadata.html#controlling-metadata-output | Controlling Metadata Output Docs}
+   */
+  muteMetadata(): This;
+  /**
+   * Enables inclusion of metadata data in the print
+   *
+   * @see {@link https://loglayer.dev/logging-api/metadata.html#controlling-metadata-output | Controlling Metadata Output Docs}
+   */
+  unMuteMetadata(): This;
+  /**
+   * Enables a specific log level
+   *
+   * @see {@link https://loglayer.dev/logging-api/basic-logging.html#enabling-disabling-logging | Enabling/Disabling Logging Docs}
+   */
+  enableIndividualLevel(logLevel: LogLevelType): This;
+  /**
+   * Disables a specific log level
+   *
+   * @see {@link https://loglayer.dev/logging-api/basic-logging.html#enabling-disabling-logging | Enabling/Disabling Logging Docs}
+   */
+  disableIndividualLevel(logLevel: LogLevelType): This;
+  /**
+   * Sets the minimum log level to be used by the logger. Only messages with
+   * this level or higher severity will be logged.
+   *
+   * For example, if you setLevel(LogLevel.warn), this will:
+   * Enable:
+   * - warn
+   * - error
+   * - fatal
+   * Disable:
+   * - info
+   * - debug
+   * - trace
+   *
+   * @see {@link https://loglayer.dev/logging-api/basic-logging.html#enabling-disabling-logging | Enabling/Disabling Logging Docs}
+   */
+  setLevel(logLevel: LogLevelType): This;
+  /**
+   * Checks if a specific log level is enabled
+   *
+   * @see {@link https://loglayer.dev/logging-api/basic-logging.html#checking-if-a-log-level-is-enabled | Checking if a Log Level is Enabled Docs}
+   */
+  isLevelEnabled(logLevel: LogLevelType): boolean;
+  /**
+   * Enable sending logs to the logging library.
+   *
+   * @see {@link https://loglayer.dev/logging-api/basic-logging.html#enabling-disabling-logging | Enabling/Disabling Logging Docs}
+   */
+  enableLogging(): This;
+  /**
+   * All logging inputs are dropped and stops sending logs to the logging library.
+   *
+   * @see {@link https://loglayer.dev/logging-api/basic-logging.html#enabling-disabling-logging | Enabling/Disabling Logging Docs}
+   */
+  disableLogging(): This;
+  /**
+   * Returns a logger instance for a specific transport
+   *
+   * @see {@link https://loglayer.dev/logging-api/transport-management.html | Transport Management Docs}
+   */
+  getLoggerInstance<Library>(id: string): Library | undefined;
+  /**
+   * Replaces all existing transports with new ones while preserving other logger configuration.
+   *
+   * Transport changes only affect the current logger instance. Child loggers
+   * created before the change will retain their original transports, and
+   * parent loggers are not affected when a child modifies its transports.
+   *
+   * @see {@link https://loglayer.dev/logging-api/transport-management.html | Transport Management Docs}
+   */
+  withFreshTransports(transports: LogLayerTransport | Array<LogLayerTransport>): This;
+  /**
+   * Adds one or more transports to the existing transports.
+   * If a transport with the same ID already exists, it will be replaced.
+   *
+   * Transport changes only affect the current logger instance. Child loggers
+   * created before the change will retain their original transports, and
+   * parent loggers are not affected when a child modifies its transports.
+   *
+   * @see {@link https://loglayer.dev/logging-api/transport-management.html | Transport Management Docs}
+   */
+  addTransport(transports: LogLayerTransport | Array<LogLayerTransport>): This;
+  /**
+   * Removes a transport by its ID.
+   *
+   * Transport changes only affect the current logger instance. Child loggers
+   * created before the change will retain their original transports, and
+   * parent loggers are not affected when a child modifies its transports.
+   *
+   * @returns true if the transport was found and removed, false otherwise.
+   *
+   * @see {@link https://loglayer.dev/logging-api/transport-management.html | Transport Management Docs}
+   */
+  removeTransport(id: string): boolean;
+  /**
+   * Replaces all existing plugins with new ones.
+   *
+   * When used with child loggers, it only affects the current logger instance
+   * and does not modify the parent's plugins.
+   *
+   * @see {@link https://loglayer.dev/plugins/ | Plugins Docs}
+   */
+  withFreshPlugins(plugins: Array<LogLayerPlugin>): This;
+  /**
+   * Sets the context manager to use for managing context data.
+   */
+  withContextManager(manager: IContextManager): This;
+  /**
+   * Gets the context manager used by the logger.
+   */
+  getContextManager<M extends IContextManager = IContextManager>(): M;
+  /**
+   * Sets the log level manager to use for managing log levels.
+   */
+  withLogLevelManager(manager: ILogLevelManager): This;
+  /**
+   * Gets the log level manager used by the logger.
+   */
+  getLogLevelManager<M extends ILogLevelManager = ILogLevelManager>(): M;
+  /**
+   * Returns the configuration object used to initialize the logger.
+   */
+  getConfig(): {
+    prefix?: string;
+    enabled?: boolean;
+    consoleDebug?: boolean;
+    transport: LogLayerTransport | Array<LogLayerTransport>;
+    plugins?: Array<LogLayerPlugin>;
+    errorSerializer?: (err: any) => Record<string, any> | string;
+    errorFieldName?: string;
+    copyMsgOnOnlyError?: boolean;
+    errorFieldInMetadata?: boolean;
+    contextFieldName?: string;
+    metadataFieldName?: string;
+    muteContext?: boolean;
+    muteMetadata?: boolean;
+  };
+  /**
+   * Logs a raw log entry with complete control over all log parameters.
+   *
+   * This method allows you to bypass the normal LogLayer API and directly specify
+   * all aspects of a log entry including log level, messages, metadata, and error.
+   * It's useful for scenarios where you need to log structured data that doesn't
+   * fit the standard LogLayer patterns, or when integrating with external logging
+   * systems that provide pre-formatted log entries.
+   *
+   * The raw entry will still go through all LogLayer processing.
+   *
+   * @see {@link https://loglayer.dev/logging-api/basic-logging.html | Basic Logging Docs}
+   */
+  raw(rawEntry: RawLogEntry): void;
+} //#endregion
+//#endregion
+//#region ../../core/plugin/dist/index.d.ts
+/**
+ * List of plugin callbacks that can be called by the plugin manager.
+ *
+ * @see {@link https://loglayer.dev/plugins/creating-plugins.html#transformloglevel | transformLogLevel Docs}
+ * @see {@link https://loglayer.dev/plugins/creating-plugins.html#onbeforedataout | onBeforeDataOut Docs}
+ * @see {@link https://loglayer.dev/plugins/creating-plugins.html#shouldsendtologger | shouldSendToLogger Docs}
+ * @see {@link https://loglayer.dev/plugins/creating-plugins.html#onmetadatacalled | onMetadataCalled Docs}
+ * @see {@link https://loglayer.dev/plugins/creating-plugins.html#onbeforemessageout | onBeforeMessageOut Docs}
+ * @see {@link https://loglayer.dev/plugins/creating-plugins.html#oncontextcalled | onContextCalled Docs}
+ */
+declare enum PluginCallbackType {
+  transformLogLevel = "transformLogLevel",
+  onBeforeDataOut = "onBeforeDataOut",
+  shouldSendToLogger = "shouldSendToLogger",
+  onMetadataCalled = "onMetadataCalled",
+  onBeforeMessageOut = "onBeforeMessageOut",
+  onContextCalled = "onContextCalled"
+} //#endregion
+//#endregion
+//#region ../../core/loglayer/dist/index.d.ts
+//#region src/PluginManager.d.ts
+/**
+ * A class that manages plugins and runs their callbacks.
+ * Used by LogLayer to run plugins at various stages of the logging process.
+ */
+declare class PluginManager {
+  private idToPlugin;
+  private transformLogLevel;
+  private onBeforeDataOut;
+  private shouldSendToLogger;
+  private onMetadataCalled;
+  private onBeforeMessageOut;
+  private onContextCalled;
+  constructor(plugins: Array<LogLayerPlugin>);
+  private mapPlugins;
+  private indexPlugins;
+  hasPlugins(callbackType: PluginCallbackType): boolean;
+  countPlugins(callbackType?: PluginCallbackType): number;
+  addPlugins(plugins: Array<LogLayerPlugin>): void;
+  enablePlugin(id: string): void;
+  disablePlugin(id: string): void;
+  removePlugin(id: string): void;
+  /**
+   * Runs plugins that define transformLogLevel. Returns the transformed log level or the original if no transformation is applied.
+   * If multiple plugins transform the log level, the last one wins.
+   */
+  runTransformLogLevel(params: PluginTransformLogLevelParams, loglayer: ILogLayer): LogLevelType;
+  /**
+   * Runs plugins that defines onBeforeDataOut.
+   */
+  runOnBeforeDataOut(params: PluginBeforeDataOutParams, loglayer: ILogLayer): LogLayerData | undefined;
+  /**
+   * Runs plugins that define shouldSendToLogger. Any plugin that returns false will prevent the message from being sent to the transport.
+   */
+  runShouldSendToLogger(params: PluginShouldSendToLoggerParams, loglayer: ILogLayer): boolean;
+  /**
+   * Runs plugins that define onMetadataCalled.
+   */
+  runOnMetadataCalled(metadata: LogLayerMetadata, loglayer: ILogLayer): LogLayerMetadata | null;
+  runOnBeforeMessageOut(params: PluginBeforeMessageOutParams, loglayer: ILogLayer): MessageDataType[];
+  /**
+   * Runs plugins that define onContextCalled.
+   */
+  runOnContextCalled(context: Record<string, any>, loglayer: ILogLayer): Record<string, any> | null;
+} //#endregion
+//#region src/MockLogBuilder.d.ts
+/**
+ * A mock implementation of the ILogBuilder interface that does nothing.
+ * Useful for writing unit tests.
+ */
+declare class MockLogBuilder implements ILogBuilder<MockLogBuilder> {
+  debug(..._messages: MessageDataType[]): void;
+  error(..._messages: MessageDataType[]): void;
+  info(..._messages: MessageDataType[]): void;
+  trace(..._messages: MessageDataType[]): void;
+  warn(..._messages: MessageDataType[]): void;
+  fatal(..._messages: MessageDataType[]): void;
+  enableLogging(): this;
+  disableLogging(): this;
+  withMetadata(_metadata?: Record<string, any>): this;
+  withError(_error: any): this;
+} //#endregion
+//#region src/MockLogLayer.d.ts
+/**
+ * A mock implementation of the ILogLayer interface that does nothing.
+ * Useful for writing unit tests.
+ * MockLogLayer implements both ILogLayer and ILogBuilder for simplicity in testing.
+ */
+declare class MockLogLayer$1 implements ILogLayer<MockLogLayer$1>, ILogBuilder<MockLogLayer$1> {
+  private mockLogBuilder;
+  private mockContextManager;
+  private mockLogLevelManager;
+  info(..._messages: MessageDataType[]): void;
+  warn(..._messages: MessageDataType[]): void;
+  error(..._messages: MessageDataType[]): void;
+  debug(..._messages: MessageDataType[]): void;
+  trace(..._messages: MessageDataType[]): void;
+  fatal(..._messages: MessageDataType[]): void;
+  raw(_rawEntry: RawLogEntry): void;
+  getLoggerInstance<_T extends LogLayerTransport>(_id: string): any;
+  errorOnly(_error: any, _opts?: ErrorOnlyOpts): void;
+  metadataOnly(_metadata?: Record<string, any>, _logLevel?: LogLevel): void;
+  addPlugins(_plugins: Array<LogLayerPlugin>): void;
+  removePlugin(_id: string): void;
+  enablePlugin(_id: string): void;
+  disablePlugin(_id: string): void;
+  withPrefix(_prefix: string): this;
+  withContext(_context?: Record<string, any>): this;
+  withError(_error: any): any;
+  withMetadata(_metadata?: Record<string, any>): any;
+  getContext(): Record<string, any>;
+  clearContext(_keys?: string | string[]): this;
+  enableLogging(): this;
+  disableLogging(): this;
+  child(): this;
+  muteContext(): this;
+  unMuteContext(): this;
+  muteMetadata(): this;
+  unMuteMetadata(): this;
+  withFreshTransports(_transports: LogLayerTransport | Array<LogLayerTransport>): this;
+  addTransport(_transports: LogLayerTransport | Array<LogLayerTransport>): this;
+  removeTransport(_id: string): boolean;
+  withFreshPlugins(_plugins: Array<LogLayerPlugin>): this;
+  withContextManager(_contextManager: any): this;
+  getContextManager<M extends IContextManager = IContextManager>(): M;
+  withLogLevelManager(_logLevelManager: ILogLevelManager): this;
+  getLogLevelManager<M extends ILogLevelManager = ILogLevelManager>(): M;
+  getConfig(): any;
+  /**
+   * Sets the mock log builder to use for testing.
+   */
+  setMockLogBuilder(mockLogBuilder: ILogBuilder): void;
+  enableIndividualLevel(_logLevel: LogLevelType): this;
+  disableIndividualLevel(_logLevel: LogLevelType): this;
+  setLevel(_logLevel: LogLevelType): this;
+  isLevelEnabled(_logLevel: LogLevelType): boolean;
+  /**
+   * Returns the mock log builder used for testing.
+   */
+  getMockLogBuilder(): ILogBuilder<ILogBuilder<any>>;
+  /**
+   * Resets the mock log builder to a new instance of MockLogBuilder.
+   */
+  resetMockLogBuilder(): void;
+} //#endregion
+//#region src/types/mixin.types.d.ts
+/**
+ * The class that the mixin extends
+ */
+declare enum LogLayerMixinAugmentType {
+  /**
+   * Mixin extends the LogBuilder prototype
+   */
+  LogBuilder = "LogBuilder",
+  /**
+   * Mixin extends the LogLayer prototype
+   */
+  LogLayer = "LogLayer"
+}
+/**
+ * Interface for mixins to add custom functionality to the LogBuilder prototype.
+ */
+interface LogBuilderMixin {
+  /**
+   * Specifies that this mixin augments the main LogBuilder class.
+   * This type discrimination allows TypeScript to properly type-check mixin usage.
+   */
+  augmentationType: LogLayerMixinAugmentType.LogBuilder;
+  /**
+   * Called at the end of the LogBuilder construct() method.
+   * The LogBuilder instance is passed as the first parameter.
+   */
+  onConstruct?: (instance: LogBuilder, logger: LogLayer$1) => void;
+  /**
+   * Function that performs the augmentation of the LogBuilder prototype.
+   *
+   * @param prototype - The LogBuilder class prototype being augmented
+   */
+  augment: (prototype: typeof LogBuilder.prototype) => void;
+  /**
+   * Function that performs the augmentation of the MockLogBuilder prototype.
+   * This is called to ensure the mock class has the same functionality as the real class.
+   *
+   * @param prototype - The MockLogBuilder class prototype being augmented
+   */
+  augmentMock: (prototype: typeof MockLogBuilder.prototype) => void;
+}
+/**
+ * Interface for mixins to add custom functionality to the LogLayer prototype.
+ */
+interface LogLayerMixin {
+  /**
+   * Specifies that this mixin augments the main LogLayer class.
+   * This type discrimination allows TypeScript to properly type-check mixin usage.
+   */
+  augmentationType: LogLayerMixinAugmentType.LogLayer;
+  /**
+   * Called at the end of the LogLayer construct() method.
+   * The LogLayer instance is passed as the first parameter.
+   */
+  onConstruct?: (instance: LogLayer$1, config: LogLayerConfig) => void;
+  /**
+   * Function that performs the augmentation of the LogLayer prototype.
+   *
+   * @param prototype - The LogLayer class prototype being augmented
+   */
+  augment: (prototype: typeof LogLayer$1.prototype) => void;
+  /**
+   * Function that performs the augmentation of the MockLogLayer prototype.
+   * This is called to ensure the mock class has the same functionality as the real class.
+   *
+   * @param prototype - The MockLogLayer class prototype being augmented
+   */
+  augmentMock: (prototype: typeof MockLogLayer$1.prototype) => void;
+}
+type LogLayerMixinType = LogBuilderMixin | LogLayerMixin;
+/**
+ * Interface for registering mixins to LogLayer.
+ */
+interface LogLayerMixinRegistration {
+  /**
+   * Array of mixins to add to LogLayer.
+   */
+  mixinsToAdd: LogLayerMixinType[];
+  /**
+   * Array of plugins to add to LogLayer.
+   */
+  pluginsToAdd?: LogLayerPlugin[];
+} //#endregion
+//#region src/types/index.d.ts
+type ErrorSerializerType = (err: any) => Record<string, any> | string;
+/**
+ * Configuration options for LogLayer
+ * @see {@link https://loglayer.dev/configuration.html | LogLayer Configuration Docs}
+ */
+interface LogLayerConfig {
+  /**
+   * The prefix to prepend to all log messages
+   */
+  prefix?: string;
+  /**
+   * Set false to drop all log input and stop sending to the logging
+   * library.
+   *
+   * Can be re-enabled with `enableLogging()`.
+   *
+   * Default is `true`.
+   */
+  enabled?: boolean;
+  /**
+   * If set to true, will also output messages via console logging before
+   * sending to the logging library.
+   *
+   * Useful for troubleshooting a logging library / transports
+   * to ensure logs are still being created when the underlying
+   * does not print anything.
+   */
+  consoleDebug?: boolean;
+  /**
+   * The transport(s) that implements a logging library to send logs to.
+   * Can be a single transport or an array of transports.
+   */
+  transport: LogLayerTransport | Array<LogLayerTransport>;
+  /**
+   * Plugins to use.
+   */
+  plugins?: Array<LogLayerPlugin>;
+  /**
+   * A function that takes in an incoming Error type and transforms it into an object.
+   * Used in the event that the logging library does not natively support serialization of errors.
+   */
+  errorSerializer?: ErrorSerializerType;
+  /**
+   * Logging libraries may require a specific field name for errors so it knows
+   * how to parse them.
+   *
+   * Default is 'err'.
+   */
+  errorFieldName?: string;
+  /**
+   * If true, always copy error.message if available as a log message along
+   * with providing the error data to the logging library.
+   *
+   * Can be overridden individually by setting `copyMsg: false` in the `onlyError()`
+   * call.
+   *
+   * Default is false.
+   */
+  copyMsgOnOnlyError?: boolean;
+  /**
+   * If set to true, the error will be included as part of metadata instead
+   * of the root of the log data.
+   *
+   * metadataFieldName must be set to true for this to work.
+   *
+   * Default is false.
+   */
+  errorFieldInMetadata?: boolean;
+  /**
+   * If specified, will set the context object to a specific field
+   * instead of flattening the data alongside the error and message.
+   *
+   * Default is context data will be flattened.
+   */
+  contextFieldName?: string;
+  /**
+   * If specified, will set the metadata object to a specific field
+   * instead of flattening the data alongside the error and message.
+   *
+   * Default is metadata will be flattened.
+   */
+  metadataFieldName?: string;
+  /**
+   * If set to true, will not include context data in the log message.
+   */
+  muteContext?: boolean;
+  /**
+   * If set to true, will not include metadata data in the log message.
+   */
+  muteMetadata?: boolean;
+} //#endregion
+//#region src/LogLayer.d.ts
+interface FormatLogParams {
+  logLevel: LogLevelType;
+  params?: any[];
+  metadata?: LogLayerMetadata | null;
+  err?: any;
+  context?: LogLayerContext | null;
+}
+/**
+ * Wraps around a logging framework to provide convenience methods that allow
+ * developers to programmatically specify their errors and metadata along with
+ * a message in a consistent fashion.
+ */
+declare class LogLayer$1 implements ILogLayer<LogLayer$1> {
+  private pluginManager;
+  private idToTransport;
+  private hasMultipleTransports;
+  private singleTransport;
+  private contextManager;
+  private logLevelManager;
+  /**
+   * The configuration object used to initialize the logger.
+   * This is for internal use only and should not be modified directly.
+   */
+  _config: LogLayerConfig;
+  constructor(config: LogLayerConfig);
+  /**
+   * Sets the context manager to use for managing context data.
+   */
+  withContextManager(contextManager: IContextManager): LogLayer$1;
+  /**
+   * Returns the context manager instance being used.
+   */
+  getContextManager<M extends IContextManager = IContextManager>(): M;
+  /**
+   * Sets the log level manager to use for managing log levels.
+   */
+  withLogLevelManager(logLevelManager: ILogLevelManager): LogLayer$1;
+  /**
+   * Returns the log level manager instance being used.
+   */
+  getLogLevelManager<M extends ILogLevelManager = ILogLevelManager>(): M;
+  /**
+   * Returns the configuration object used to initialize the logger.
+   */
+  getConfig(): LogLayerConfig;
+  private _initializeTransports;
+  /**
+   * Calls child() and sets the prefix to be included with every log message.
+   *
+   * @see {@link https://loglayer.dev/logging-api/basic-logging.html#message-prefixing | Message Prefixing Docs}
+   */
+  withPrefix(prefix: string): LogLayer$1;
+  /**
+   * Appends context data which will be included with
+   * every log entry.
+   *
+   * Passing in an empty value / object will *not* clear the context.
+   *
+   * To clear the context, use {@link https://loglayer.dev/logging-api/context.html#clearing-context | clearContext()}.
+   *
+   * @see {@link https://loglayer.dev/logging-api/context.html | Context Docs}
+   */
+  withContext(context?: LogLayerContext): LogLayer$1;
+  /**
+   * Clears the context data. If keys are provided, only those keys will be removed.
+   * If no keys are provided, all context data will be cleared.
+   */
+  clearContext(keys?: string | string[]): this;
+  getContext(): LogLayerContext;
+  /**
+   * Add additional plugins.
+   *
+   * @see {@link https://loglayer.dev/plugins/ | Plugins Docs}
+   */
+  addPlugins(plugins: Array<LogLayerPlugin>): void;
+  /**
+   * Enables a plugin by id.
+   *
+   * @see {@link https://loglayer.dev/plugins/ | Plugins Docs}
+   */
+  enablePlugin(id: string): void;
+  /**
+   * Disables a plugin by id.
+   *
+   * @see {@link https://loglayer.dev/plugins/ | Plugins Docs}
+   */
+  disablePlugin(id: string): void;
+  /**
+   * Removes a plugin by id.
+   *
+   * @see {@link https://loglayer.dev/plugins/ | Plugins Docs}
+   */
+  removePlugin(id: string): void;
+  /**
+   * Specifies metadata to include with the log message
+   *
+   * @see {@link https://loglayer.dev/logging-api/metadata.html | Metadata Docs}
+   */
+  withMetadata(metadata?: LogLayerMetadata): LogBuilder;
+  /**
+   * Specifies an Error to include with the log message
+   *
+   * @see {@link https://loglayer.dev/logging-api/error-handling.html | Error Handling Docs}
+   */
+  withError(error: any): LogBuilder;
+  /**
+   * Creates a new instance of LogLayer but with the initialization
+   * configuration and context copied over.
+   *
+   * @see {@link https://loglayer.dev/logging-api/child-loggers.html | Child Logging Docs}
+   */
+  child(): LogLayer$1;
+  /**
+   * Replaces all existing transports with new ones.
+   *
+   * Transport changes only affect the current logger instance. Child loggers
+   * created before the change will retain their original transports, and
+   * parent loggers are not affected when a child modifies its transports.
+   *
+   * @see {@link https://loglayer.dev/logging-api/transport-management.html | Transport Management Docs}
+   */
+  withFreshTransports(transports: LogLayerTransport | Array<LogLayerTransport>): LogLayer$1;
+  /**
+   * Adds one or more transports to the existing transports.
+   * If a transport with the same ID already exists, it will be replaced.
+   *
+   * Transport changes only affect the current logger instance. Child loggers
+   * created before the change will retain their original transports, and
+   * parent loggers are not affected when a child modifies its transports.
+   *
+   * @see {@link https://loglayer.dev/logging-api/transport-management.html | Transport Management Docs}
+   */
+  addTransport(transports: LogLayerTransport | Array<LogLayerTransport>): LogLayer$1;
+  /**
+   * Removes a transport by its ID.
+   *
+   * Transport changes only affect the current logger instance. Child loggers
+   * created before the change will retain their original transports, and
+   * parent loggers are not affected when a child modifies its transports.
+   *
+   * @returns true if the transport was found and removed, false otherwise.
+   *
+   * @see {@link https://loglayer.dev/logging-api/transport-management.html | Transport Management Docs}
+   */
+  removeTransport(id: string): boolean;
+  /**
+   * Replaces all existing plugins with new ones.
+   *
+   * When used with child loggers, it only affects the current logger instance
+   * and does not modify the parent's plugins.
+   *
+   * @see {@link https://loglayer.dev/plugins/ | Plugins Docs}
+   */
+  withFreshPlugins(plugins: Array<LogLayerPlugin>): LogLayer$1;
+  protected withPluginManager(pluginManager: PluginManager): this;
+  /**
+   * Logs only the error object without a log message
+   *
+   * @see {@link https://loglayer.dev/logging-api/error-handling.html | Error Handling Docs}
+   */
+  errorOnly(error: any, opts?: ErrorOnlyOpts): void;
+  /**
+   * Logs only metadata without a log message
+   *
+   * @see {@link https://loglayer.dev/logging-api/metadata.html | Metadata Docs}
+   */
+  metadataOnly(metadata?: LogLayerMetadata, logLevel?: LogLevelType): void;
+  /**
+   * Sends a log message to the logging library under an info log level.
+   *
+   * The logging library may or may not support multiple message parameters and only
+   * the first parameter would be used.
+   *
+   * @see {@link https://loglayer.dev/logging-api/basic-logging.html | Basic Logging Docs}
+   */
+  info(...messages: MessageDataType[]): void;
+  /**
+   * Sends a log message to the logging library under the warn log level
+   *
+   * @see {@link https://loglayer.dev/logging-api/basic-logging.html | Basic Logging Docs}
+   */
+  warn(...messages: MessageDataType[]): void;
+  /**
+   * Sends a log message to the logging library under the error log level
+   *
+   * @see {@link https://loglayer.dev/logging-api/basic-logging.html | Basic Logging Docs}
+   */
+  error(...messages: MessageDataType[]): void;
+  /**
+   * Sends a log message to the logging library under the debug log level
+   *
+   * @see {@link https://loglayer.dev/logging-api/basic-logging.html | Basic Logging Docs}
+   */
+  debug(...messages: MessageDataType[]): void;
+  /**
+   * Sends a log message to the logging library under the trace log level
+   *
+   * @see {@link https://loglayer.dev/logging-api/basic-logging.html | Basic Logging Docs}
+   */
+  trace(...messages: MessageDataType[]): void;
+  /**
+   * Sends a log message to the logging library under the fatal log level
+   *
+   * @see {@link https://loglayer.dev/logging-api/basic-logging.html | Basic Logging Docs}
+   */
+  fatal(...messages: MessageDataType[]): void;
+  /**
+   * Logs a raw log entry with complete control over all log parameters.
+   *
+   * This method allows you to bypass the normal LogLayer API and directly specify
+   * all aspects of a log entry including log level, messages, metadata, and error.
+   * It's useful for scenarios where you need to log structured data that doesn't
+   * fit the standard LogLayer patterns, or when integrating with external logging
+   * systems that provide pre-formatted log entries.
+   *
+   * The raw entry will still go through all LogLayer processing.
+   *
+   * @see {@link https://loglayer.dev/logging-api/basic-logging.html | Basic Logging Docs}
+   */
+  raw(logEntry: RawLogEntry): void;
+  /**
+   * All logging inputs are dropped and stops sending logs to the logging library.
+   *
+   * @see {@link https://loglayer.dev/logging-api/basic-logging.html#enabling-disabling-logging | Enabling/Disabling Logging Docs}
+   */
+  disableLogging(): this;
+  /**
+   * Enable sending logs to the logging library.
+   *
+   * @see {@link https://loglayer.dev/logging-api/basic-logging.html#enabling-disabling-logging | Enabling/Disabling Logging Docs}
+   */
+  enableLogging(): this;
+  /**
+   * Disables inclusion of context data in the print
+   *
+   * @see {@link https://loglayer.dev/logging-api/context.html#managing-context | Managing Context Docs}
+   */
+  muteContext(): this;
+  /**
+   * Enables inclusion of context data in the print
+   *
+   * @see {@link https://loglayer.dev/logging-api/context.html#managing-context | Managing Context Docs}
+   */
+  unMuteContext(): this;
+  /**
+   * Disables inclusion of metadata in the print
+   *
+   * @see {@link https://loglayer.dev/logging-api/metadata.html#controlling-metadata-output | Controlling Metadata Output Docs}
+   */
+  muteMetadata(): this;
+  /**
+   * Enables inclusion of metadata in the print
+   *
+   * @see {@link https://loglayer.dev/logging-api/metadata.html#controlling-metadata-output | Controlling Metadata Output Docs}
+   */
+  unMuteMetadata(): this;
+  /**
+   * Enables a specific log level
+   *
+   * @see {@link https://loglayer.dev/logging-api/basic-logging.html#enabling-disabling-logging | Enabling/Disabling Logging Docs}
+   */
+  enableIndividualLevel(logLevel: LogLevelType): this;
+  /**
+   * Disables a specific log level
+   *
+   * @see {@link https://loglayer.dev/logging-api/basic-logging.html#enabling-disabling-logging | Enabling/Disabling Logging Docs}
+   */
+  disableIndividualLevel(logLevel: LogLevelType): this;
+  /**
+   * Sets the minimum log level to be used by the logger. Only messages with
+   * this level or higher severity will be logged.
+   *
+   * For example, if you setLevel(LogLevel.warn), this will:
+   * Enable:
+   * - warn
+   * - error
+   * - fatal
+   * Disable:
+   * - info
+   * - debug
+   * - trace
+   *
+   * @see {@link https://loglayer.dev/logging-api/basic-logging.html#enabling-disabling-logging | Enabling/Disabling Logging Docs}
+   */
+  setLevel(logLevel: LogLevelType): this;
+  /**
+   * Checks if a specific log level is enabled
+   *
+   * @see {@link https://loglayer.dev/logging-api/basic-logging.html#checking-if-a-log-level-is-enabled | Checking if a Log Level is Enabled Docs}
+   */
+  isLevelEnabled(logLevel: LogLevelType): boolean;
+  private formatContext;
+  private formatMetadata;
+  /**
+   * Returns a logger instance for a specific transport
+   *
+   * @see {@link https://loglayer.dev/logging-api/transport-management.html | Transport Management Docs}
+   */
+  getLoggerInstance<Logger>(id: string): Logger | undefined;
+  _formatMessage(messages?: MessageDataType[]): void;
+  _formatLog({
+    logLevel,
+    params,
+    metadata,
+    err,
+    context
+  }: FormatLogParams): void;
+} //#endregion
+//#region src/LogBuilder.d.ts
+/**
+ * A class that contains methods to specify log metadata and an error and assembles
+ * it to form a data object that can be passed into the transport.
+ */
+declare class LogBuilder implements ILogBuilder<LogBuilder> {
+  private err;
+  private metadata;
+  private structuredLogger;
+  private hasMetadata;
+  private pluginManager;
+  constructor(structuredLogger: LogLayer$1);
+  /**
+   * Specifies metadata to include with the log message
+   *
+   * @see {@link https://loglayer.dev/logging-api/metadata.html | Metadata Docs}
+   */
+  withMetadata(metadata?: LogLayerMetadata): this;
+  /**
+   * Specifies an Error to include with the log message
+   *
+   * @see {@link https://loglayer.dev/logging-api/error-handling.html | Error Handling Docs}
+   */
+  withError(error: any): this;
+  /**
+   * Sends a log message to the logging library under an info log level.
+   */
+  info(...messages: MessageDataType[]): void;
+  /**
+   * Sends a log message to the logging library under the warn log level
+   */
+  warn(...messages: MessageDataType[]): void;
+  /**
+   * Sends a log message to the logging library under the error log level
+   */
+  error(...messages: MessageDataType[]): void;
+  /**
+   * Sends a log message to the logging library under the debug log level
+   *
+   * The logging library may or may not support multiple message parameters and only
+   * the first parameter would be used.
+   */
+  debug(...messages: MessageDataType[]): void;
+  /**
+   * Sends a log message to the logging library under the trace log level
+   *
+   * The logging library may or may not support multiple message parameters and only
+   * the first parameter would be used.
+   */
+  trace(...messages: MessageDataType[]): void;
+  /**
+   * Sends a log message to the logging library under the fatal log level
+   *
+   * The logging library may or may not support multiple message parameters and only
+   * the first parameter would be used.
+   */
+  fatal(...messages: MessageDataType[]): void;
+  /**
+   * All logging inputs are dropped and stops sending logs to the logging library.
+   */
+  disableLogging(): this;
+  /**
+   * Enable sending logs to the logging library.
+   */
+  enableLogging(): this;
+  private formatLog;
+} //#endregion
+//#region src/mixins.d.ts
+/**
+ * Adds one or more mixins to LogLayer.
+ * @param mixin - The mixin(s) to register. Can be a single mixin registration or an array of mixin registrations.
+ */
+//#endregion
+//#region src/types.d.ts
+/**
+ * Options for creating a BufferedMetricsLogger instance.
+ * Re-exported from the datadog-metrics library for convenience.
+ */
+type DatadogMetricsOptions = BufferedMetricsLoggerOptions$1;
+/**
+ * Histogram aggregation and percentile options
+ */
+interface HistogramOptions {
+  /** Aggregation types: 'max', 'min', 'sum', 'avg', 'count', 'median' */
+  aggregates?: string[];
+  /** Percentile values between 0 and 1, e.g. [0.95, 0.99] */
+  percentiles?: number[];
+}
+/**
+ * Builder interface for chaining metric configurations
+ */
+interface IMetricsBuilder {
+  /**
+   * Add tags to the metric
+   */
+  withTags(tags: string[]): IMetricsBuilder;
+  /**
+   * Set the timestamp for the metric in milliseconds since epoch
+   */
+  withTimestamp(timestamp: number): IMetricsBuilder;
+  /**
+   * Send the metric with the configured options
+   */
+  send(): void;
+}
+/**
+ * Builder interface for increment method with withValue support
+ */
+interface IIncrementBuilder extends IMetricsBuilder {
+  /**
+   * Set the increment value (defaults to 1)
+   */
+  withValue(value: number): IIncrementBuilder;
+  withTags(tags: string[]): IIncrementBuilder;
+  withTimestamp(timestamp: number): IIncrementBuilder;
+}
+/**
+ * Builder interface for histogram method with histogram options support
+ */
+interface IHistogramBuilder extends IMetricsBuilder {
+  /**
+   * Set histogram-specific options (aggregates and percentiles)
+   */
+  withHistogramOptions(options: HistogramOptions): IHistogramBuilder;
+  withTags(tags: string[]): IHistogramBuilder;
+  withTimestamp(timestamp: number): IHistogramBuilder;
+}
+/**
+ * Metrics API interface containing all datadog-metrics methods
+ */
+interface IMetricsAPI {
+  /**
+   * Increment a counter metric
+   */
+  increment(key: string): IIncrementBuilder;
+  /**
+   * Set a gauge metric to a specific value
+   */
+  gauge(key: string, value: number): IMetricsBuilder;
+  /**
+   * Record a histogram value
+   */
+  histogram(key: string, value: number): IHistogramBuilder;
+  /**
+   * Record a distribution value (server-side calculated)
+   */
+  distribution(key: string, value: number): IMetricsBuilder;
+  /**
+   * Flush all buffered metrics to Datadog immediately
+   */
+  flush(): Promise<void>;
+  /**
+   * Start auto-flushing metrics at the configured interval
+   */
+  start(): void;
+  /**
+   * Stop auto-flushing and optionally flush remaining metrics
+   */
+  stop(options?: {
+    flush?: boolean;
+  }): Promise<void>;
+  /**
+   * Get the underlying BufferedMetricsLogger instance
+   */
+  getClient(): BufferedMetricsLogger$1;
+}
+/**
+ * Generic mixin interface for Datadog HTTP metrics methods.
+ * T is the instance type (LogLayer or MockLogLayer).
+ */
+interface IDatadogMetricsMixin<_T> {
+  /**
+   * Access to Datadog HTTP metrics API
+   */
+  ddStats: IMetricsAPI;
+}
+declare module "loglayer" {
+  interface LogLayer extends IDatadogMetricsMixin<LogLayer> {}
+  interface MockLogLayer extends IDatadogMetricsMixin<MockLogLayer> {}
+  interface ILogLayer<This> extends IDatadogMetricsMixin<This> {}
+}
+//#endregion
+//#region src/MetricsAPI.d.ts
+/**
+ * Metrics API implementation that wraps datadog-metrics BufferedMetricsLogger.
+ * Provides a fluent interface for sending metrics to Datadog via HTTP.
+ */
+declare class MetricsAPI implements IMetricsAPI {
+  private readonly client;
+  /**
+   * Creates a new MetricsAPI instance.
+   *
+   * @param client - The datadog-metrics BufferedMetricsLogger instance
+   */
+  constructor(client: BufferedMetricsLogger$1);
+  /**
+   * Increment a counter metric.
+   * Returns a builder that supports chaining with withValue(), withTags(), and withTimestamp().
+   *
+   * @param key - The metric key to increment
+   * @returns A builder instance for chaining additional options
+   */
+  increment(key: string): IIncrementBuilder;
+  /**
+   * Set a gauge metric to a specific value.
+   * Returns a builder that supports chaining with withTags() and withTimestamp().
+   *
+   * @param key - The metric key to set
+   * @param value - The value to set the gauge to
+   * @returns A builder instance for chaining additional options
+   */
+  gauge(key: string, value: number): IMetricsBuilder;
+  /**
+   * Record a histogram value.
+   * Returns a builder that supports chaining with withTags(), withTimestamp(), and withHistogramOptions().
+   *
+   * @param key - The metric key to record
+   * @param value - The histogram value to record
+   * @returns A builder instance for chaining additional options
+   */
+  histogram(key: string, value: number): IHistogramBuilder;
+  /**
+   * Record a distribution value (server-side calculated).
+   * Returns a builder that supports chaining with withTags() and withTimestamp().
+   *
+   * @param key - The metric key to record
+   * @param value - The distribution value to record
+   * @returns A builder instance for chaining additional options
+   */
+  distribution(key: string, value: number): IMetricsBuilder;
+  /**
+   * Flush all buffered metrics to Datadog immediately.
+   *
+   * @returns A promise that resolves when the flush completes
+   */
+  flush(): Promise<void>;
+  /**
+   * Start auto-flushing metrics at the configured interval.
+   */
+  start(): void;
+  /**
+   * Stop auto-flushing and optionally flush remaining metrics.
+   *
+   * @param options - Options for stopping. `flush` defaults to true.
+   * @returns A promise that resolves when stopping completes
+   */
+  stop(options?: {
+    flush?: boolean;
+  }): Promise<void>;
+  /**
+   * Get the underlying BufferedMetricsLogger instance.
+   *
+   * @returns The BufferedMetricsLogger instance
+   */
+  getClient(): BufferedMetricsLogger$1;
+}
+//#endregion
+//#region src/MockMetricsAPI.d.ts
+/**
+ * No-op implementation of IMetricsAPI.
+ * All methods return mock builder instances that do nothing when send() is called.
+ * This is used when datadogMetricsMixin(null) is called, allowing the metrics API
+ * to be used without actually sending any metrics.
+ */
+declare class MockMetricsAPI implements IMetricsAPI {
+  increment(key: string): IIncrementBuilder;
+  gauge(key: string, value: number): IMetricsBuilder;
+  histogram(key: string, value: number): IHistogramBuilder;
+  distribution(key: string, value: number): IMetricsBuilder;
+  flush(): Promise<void>;
+  start(): void;
+  stop(_options?: {
+    flush?: boolean;
+  }): Promise<void>;
+  getClient(): BufferedMetricsLogger$1;
+}
+//#endregion
+//#region src/index.d.ts
+declare const BufferedMetricsLogger: typeof metrics.BufferedMetricsLogger;
+/**
+ * A reporter that discards all metrics. Useful for testing or temporarily
+ * disabling metric submission without using the `enabled` flag.
+ * Re-exported from the `datadog-metrics` library.
+ */
+declare const NullReporter: typeof metrics.reporters.NullReporter;
+/**
+ * The default reporter that sends metrics to Datadog's HTTP API with automatic retries.
+ * Re-exported from the `datadog-metrics` library.
+ */
+declare const DatadogReporter: typeof metrics.reporters.DatadogReporter;
+/**
+ * Register the datadog-metrics mixin with LogLayer.
+ * This adds a `ddStats` property to LogLayer instances,
+ * providing a fluent API for sending metrics to Datadog via HTTP.
+ *
+ * @param options - The BufferedMetricsLogger configuration options, or null for no-op mode.
+ *   Set `enabled: false` to use no-op mode while still passing options.
+ * @returns A LogLayer mixin registration object
+ *
+ * @example
+ * ```typescript
+ * import { useLogLayerMixin } from 'loglayer';
+ * import { datadogMetricsMixin } from '@loglayer/mixin-datadog-http-metrics';
+ *
+ * useLogLayerMixin(datadogMetricsMixin({
+ *   apiKey: 'your-api-key',
+ *   prefix: 'myapp.',
+ *   enabled: process.env.NODE_ENV === 'production',
+ * }));
+ * ```
+ */
+declare function datadogMetricsMixin(options: (DatadogMetricsOptions & {
+  enabled?: boolean;
+}) | null): LogLayerMixinRegistration;
+//#endregion
+export { BufferedMetricsLogger, type BufferedMetricsLoggerOptions, type DatadogMetricsOptions, DatadogReporter, type HistogramOptions, type IDatadogMetricsMixin, type IHistogramBuilder, type IIncrementBuilder, type IMetricsAPI, type IMetricsBuilder, MetricsAPI, MockMetricsAPI, NullReporter, datadogMetricsMixin };