logixia 1.13.3 → 2.0.4

package/dist/nestjs-extras-OkC796py.d.mts

@@ -1,725 +0,0 @@
-import { E as TraceIdConfig, b as LoggerWithLevels, f as ILogger, h as LogEntry, p as ILoggerDefault, v as LogLevelString, x as NamespaceLevels, y as LoggerConfig } from "./index-BPwEisy4.mjs";
-import * as _nestjs_common0 from "@nestjs/common";
-import { ArgumentsHost, CallHandler, ExceptionFilter, ExecutionContext, InjectionToken, LoggerService, MiddlewareConsumer, ModuleMetadata, NestInterceptor, NestModule, OptionalFactoryDependency, Type } from "@nestjs/common";
-import { Observable } from "rxjs";
-
-//#region src/plugin.d.ts
-
-interface LogixiaPlugin {
-  /**
-   * Unique plugin name.
-   * logixia uses this to prevent duplicate registration of the same plugin
-   * on the same logger instance.
-   */
-  name: string;
-  /**
-   * Called once immediately after `logger.use(plugin)` is called.
-   * Use for one-time setup (open connections, allocate buffers, etc.).
-   * Async `onInit` errors are silently swallowed to avoid blocking the logger.
-   */
-  onInit?(): void | Promise<void>;
-  /**
-   * Called for every log entry **after** PII redaction and **before** transport
-   * dispatch. Plugins run in registration order; each receives the (possibly
-   * modified) output of the previous plugin.
-   *
-   * - Return the entry (modified or unchanged) to continue processing.
-   * - Return `null` to **drop** the entry — no transport will receive it.
-   *
-   * Errors thrown inside `onLog` are swallowed so a buggy plugin cannot crash
-   * logging; the chain continues with the previous (un-transformed) entry.
-   */
-  onLog?(entry: LogEntry): LogEntry | null | Promise<LogEntry | null>;
-  /**
-   * Called when a transport write fails (after any configured retries).
-   * Useful for routing transport errors to an alerting or metrics system.
-   * Errors thrown inside `onError` are silently swallowed.
-   */
-  onError?(error: Error, entry?: LogEntry): void | Promise<void>;
-  /**
-   * Called when the logger is closed via `logger.close()` or the process
-   * receives a shutdown signal (when `gracefulShutdown` is enabled).
-   * Errors thrown inside `onShutdown` are silently swallowed.
-   */
-  onShutdown?(): void | Promise<void>;
-}
-/**
- * Holds an ordered list of `LogixiaPlugin` instances and dispatches lifecycle
- * events to them. One registry is created per logger instance; a global
- * singleton is also exported for process-wide registration.
- */
-declare class PluginRegistry {
-  private readonly _plugins;
-  /**
-   * Register a plugin. Silently skips if a plugin with the same `name` is
-   * already registered on this registry.
-   */
-  register(plugin: LogixiaPlugin): void;
-  /** Remove a previously registered plugin by name. No-op if not found. */
-  unregister(name: string): void;
-  /** Returns `true` if a plugin with the given name is registered. */
-  has(name: string): boolean;
-  /** Number of currently registered plugins. */
-  get size(): number;
-  /**
-   * Run all `onLog` hooks in order.
-   * Returns `null` if any plugin cancels the entry; otherwise returns the
-   * (possibly transformed) entry.
-   */
-  runOnLog(entry: LogEntry): Promise<LogEntry | null>;
-  /**
-   * Notify all `onError` hooks.
-   * Errors thrown inside hooks are swallowed to prevent error cascades.
-   */
-  runOnError(error: Error, entry?: LogEntry): Promise<void>;
-  /** Run all `onShutdown` hooks concurrently. Hook errors are swallowed. */
-  runOnShutdown(): Promise<void>;
-}
-/**
- * Module-level singleton registry.
- *
- * Plugins registered here are automatically copied into every **new** logger
- * instance created after the registration. Already-created loggers are not
- * retroactively affected — use `logger.use(plugin)` for per-instance control.
- */
-declare const globalPluginRegistry: PluginRegistry;
-/**
- * Register a plugin in the global registry so it applies to every future
- * logger instance.
- *
- * @example
- * ```ts
- * import { usePlugin } from 'logixia';
- *
- * usePlugin({
- *   name: 'audit-sink',
- *   onLog(entry) {
- *     if (entry.level === 'error') auditQueue.push(entry);
- *     return entry;
- *   },
- * });
- * ```
- */
-declare function usePlugin(plugin: LogixiaPlugin): void;
-//#endregion
-//#region src/core/logitron-logger.d.ts
-declare class LogixiaLogger<TConfig extends LoggerConfig<Record<string, number>> = LoggerConfig> implements ILoggerDefault {
-  [K: string]: any;
-  private config;
-  private context?;
-  private timers;
-  private contextData;
-  private transportManager;
-  private fieldState;
-  /** Stable fallback trace ID generated ONCE per logger instance. */
-  private readonly fallbackTraceId;
-  /** Numeric value for each known log level — built once, read on every log call. */
-  private _levelValues;
-  /** Numeric threshold for the currently active log level. */
-  private _minLevelValue;
-  /** `source=value` pairs already reported as unknown levels — warn once per logger. */
-  private readonly _warnedInvalidLevels;
-  /** Pre-built ANSI color codes to avoid recreating the object in colorize(). */
-  private _colorMap;
-  /** Pre-computed field-enabled booleans so isFieldEnabled() isn't called per log. */
-  private _fieldCache;
-  /** True when contextData is non-empty — avoids Object.keys() check on hot path. */
-  private _hasContextData;
-  /**
-   * Pre-computed `[INFO] `, `[WARN] ` etc. strings — avoids a colorize() call per log.
-   * Key: lowercase level name. Value: formatted bracket string ready to concatenate.
-   */
-  private _formattedLevels;
-  /** Pre-computed `[appName] ` string — avoids template literal allocation per log. */
-  private _formattedAppName;
-  /** True when a redact config is present — short-circuits applyRedaction when false. */
-  private _hasRedact;
-  /** Sampling engine — only created when sampling config is present. */
-  private _sampler;
-  /** Per-instance plugin registry — also inherits from the global registry at creation time. */
-  private readonly _pluginRegistry;
-  /** Set on loggers created by child(); they borrow the root's transports, sampler and plugins. */
-  private readonly _parent;
-  constructor(config: TConfig, context?: string, parent?: LogixiaLogger<TConfig>);
-  private setupGracefulShutdown;
-  private createCustomLevelMethods;
-  /**
-   * Rebuild all hot-path caches after any config mutation or level change.
-   * Keeps the actual log() call free of allocations in the common case.
-   */
-  private _buildPerfCaches;
-  error(messageOrError: string | Error, data?: Record<string, unknown>): Promise<void>;
-  warn(message: string, data?: Record<string, unknown>): Promise<void>;
-  info(message: string, data?: Record<string, unknown>): Promise<void>;
-  debug(message: string, data?: Record<string, unknown>): Promise<void>;
-  trace(message: string, data?: Record<string, unknown>): Promise<void>;
-  verbose(message: string, data?: Record<string, unknown>): Promise<void>;
-  logLevel(level: string, message: string, data?: Record<string, unknown>): Promise<void>;
-  time(label: string): void;
-  timeEnd(label: string): Promise<number | undefined>;
-  timeAsync<T>(label: string, fn: () => Promise<T>): Promise<T>;
-  setLevel(level: LogLevelString): void;
-  getLevel(): LogLevelString;
-  private _validLevelList;
-  /**
-   * Canonicalise a level from config/ENV. Unknown values return undefined so the
-   * caller falls through to the next source, and warn once per logger per source.
-   */
-  private _validLevel;
-  /**
-   * Replace the per-namespace level map at runtime — no restart needed.
-   *
-   * This is the runtime counterpart to the `namespaceLevels` config option and
-   * the most-requested logging feature across the Winston/Pino issue trackers
-   * (flip a module's verbosity live to chase a bug without raising global
-   * volume). The new map fully replaces the previous one.
-   *
-   * @example
-   * ```ts
-   * // Turn on debug for the DB layer only, live:
-   * logger.setNamespaceLevels({ 'db.*': 'debug', '*': 'info' });
-   * ```
-   */
-  setNamespaceLevels(levels: NamespaceLevels): void;
-  /** Merge entries into the existing per-namespace level map at runtime. */
-  patchNamespaceLevels(levels: NamespaceLevels): void;
-  /** Return a copy of the current per-namespace level map. */
-  getNamespaceLevels(): NamespaceLevels;
-  setContext(context: string): void;
-  getContext(): string | undefined;
-  enableField(fieldName: string): void;
-  disableField(fieldName: string): void;
-  isFieldEnabled(fieldName: string): boolean;
-  getFieldState(): Record<string, boolean>;
-  resetFieldState(): void;
-  /** @deprecated No-op. Library code never prompts on stdin; use setTransportLevels(). */
-  enableTransportLevelPrompting(): void;
-  /** @deprecated No-op. */
-  disableTransportLevelPrompting(): void;
-  setTransportLevels(transportId: string, levels: string[]): void;
-  getTransportLevels(transportId: string): string[] | undefined;
-  clearTransportLevelPreferences(): void;
-  getAvailableTransports(): string[];
-  child(context: string, data?: Record<string, unknown>): ILogger;
-  /**
-   * Register a plugin on this logger instance.
-   *
-   * @example
-   * ```ts
-   * logger.use({
-   *   name: 'audit',
-   *   onLog(entry) { auditQueue.push(entry); return entry; },
-   * });
-   * ```
-   */
-  use(plugin: LogixiaPlugin): this;
-  /**
-   * Remove a previously registered plugin by name.
-   * No-op if the plugin is not registered on this instance.
-   */
-  unuse(pluginName: string): this;
-  flush(): Promise<void>;
-  healthCheck(): Promise<{
-    healthy: boolean;
-    details: Record<string, unknown>;
-  }>;
-  close(): Promise<void>;
-  private log;
-  /**
-   * Hot-path level check: a single Map lookup + integer compare.
-   * The level map and threshold are pre-built in _buildPerfCaches().
-   */
-  private shouldLog;
-  /**
-   * Feature 3: Resolve the effective log level for this logger instance.
-   *
-   * Priority:
-   *  1. ENV `LOGIXIA_LEVEL_<NS_UPPER>` (e.g. LOGIXIA_LEVEL_DB for ns "db" or "db.queries")
-   *  2. Matching `namespaceLevels` config entry (longer pattern = more specific, wins)
-   *  3. Global `LOGIXIA_LEVEL` ENV override
-   *  4. `levelOptions.level` (resolved via Feature 5 in constructor)
-   */
-  private resolveEffectiveLevel;
-  private formatLog;
-  private colorize;
-  /**
-   * Dispatch the entry to transports (each formats itself). Returns `void` when
-   * the write completes synchronously (console-only hot path) and a Promise only
-   * when a transport is genuinely async — so the caller awaits only when needed.
-   * Formatting for the no-transport fallback is done lazily, never on the
-   * transport path.
-   */
-  private output;
-  /** Shared transport-failure handler: log internally, notify plugins, then fall
-   * back to a direct stdout/stderr write so the entry is never lost. */
-  private _handleOutputError;
-}
-declare function createLogger<T extends LoggerConfig<Record<string, number>>>(config: T, context?: string): LoggerWithLevels<T>;
-//#endregion
-//#region src/core/logitron-nestjs.service.d.ts
-/**
- * Level names that already have proper typed implementations on LogixiaLoggerService.
- * These are excluded from the auto-generated method type so we don't produce
- * duplicate / conflicting signatures.
- */
-type _ServiceBuiltinLevels = 'error' | 'warn' | 'info' | 'debug' | 'verbose' | 'trace' | 'log' | 'logLevel';
-/**
- * Mapped type that adds one method per *custom* level (i.e. every key in TLevels
- * that is not already a built-in method on LogixiaLoggerService).
- *
- * @example
- * ServiceCustomLevelMethods<{ kafka: 3; mysql: 4; payment: 5 }>
- * // → { kafka(msg, data?): Promise<void>; mysql(...): …; payment(...): … }
- */
-type ServiceCustomLevelMethods<TLevels extends Record<string, number>> = { readonly [K in keyof TLevels as K extends _ServiceBuiltinLevels ? never : K & string]: (message: string, data?: Record<string, unknown>) => Promise<void> };
-/**
- * The return type of `LogixiaLoggerService.create<T>(config)`.
- *
- * When `T` carries `levelOptions.levels`, this type intersects
- * `LogixiaLoggerService` with a method for every *custom* level so the IDE
- * suggests `service.kafka(...)`, `service.payment(...)`, etc.
- */
-type LogixiaServiceWithLevels<T extends LoggerConfig<Record<string, number>>> = T['levelOptions'] extends {
-  levels: infer L;
-} ? L extends Record<string, number> ? LogixiaLoggerService & ServiceCustomLevelMethods<L> : LogixiaLoggerService : LogixiaLoggerService;
-/**
- * Helper — extracts custom level names from a config object's `levelOptions.levels`.
- */
-type _ExtractCustomLevelNames<T> = T extends {
-  levelOptions?: {
-    levels?: infer L;
-  };
-} ? L extends Record<string, number> ? Exclude<keyof L & string, _ServiceBuiltinLevels> : never : never;
-/**
- * Typed `LogixiaLoggerService` with autocomplete for custom levels.
- *
- * Accepts either:
- *   - **string union** of custom level names: `LogixiaServiceWith<'kafka' | 'payment'>`
- *   - **config object type** (via `typeof`): `LogixiaServiceWith<typeof logixiaConfig>`
- *
- * Define your config with `as const` once, derive the type everywhere:
- *
- * @example
- * ```ts
- * // logger.config.ts — define once
- * export const logixiaConfig = {
- *   levelOptions: {
- *     levels: { error: 0, warn: 1, info: 2, debug: 3, verbose: 4, kafka: 5, payment: 6 },
- *   },
- * } as const;
- * export type AppLogger = LogixiaServiceWith<typeof logixiaConfig>;
- *
- * // any.controller.ts — use everywhere, no casting
- * constructor(private readonly logger: AppLogger) {}
- * // this.logger.kafka('msg')  ← fully typed
- * // this.logger.payment('msg') ← fully typed
- * ```
- *
- * @example
- * ```ts
- * // Or use string union directly:
- * type AppLogger = LogixiaServiceWith<'kafka' | 'payment'>;
- * ```
- */
-type LogixiaServiceWith<T extends string | Record<string, unknown>> = LogixiaLoggerService & { readonly [K in T extends string ? Exclude<T, _ServiceBuiltinLevels> : _ExtractCustomLevelNames<T>]: (message: string, data?: Record<string, unknown>) => Promise<void> };
-declare class LogixiaLoggerService implements LoggerService {
-  [K: string]: any;
-  private logger;
-  private context?;
-  private _mergedConfig;
-  constructor(config?: LoggerConfig);
-  private _createCustomLevelMethods;
-  /**
-   * NestJS `LoggerService.log` — void, string context.
-   * Maps internally to `info`.
-   *
-   * @example `logger.log('User signed up', 'AuthService')`
-   */
-  log(message: unknown, context?: string): void;
-  /**
-   * Native async `info` — structured data, returns `Promise<void>`.
-   *
-   * @example `await logger.info('User signed up', { userId: 'u_abc' })`
-   */
-  info(message: string, data?: Record<string, unknown>): Promise<void>;
-  /**
-   * Native async overload — structured metadata, returns `Promise<void>`.
-   *
-   * @example `await logger.error(new Error('DB timeout'), { requestId: 'req_abc' })`
-   * @example `await logger.error('Login failed', { userId: 'u_abc' })`
-   */
-  error(message: string | Error, data: Record<string, unknown>): Promise<void>;
-  /**
-   * NestJS compat overload — string trace + optional context, returns `void`.
-   *
-   * @example `logger.error('Something failed', err.stack, 'AuthService')`
-   */
-  error(message: unknown, trace?: string, context?: string): void;
-  /**
-   * Native async overload — structured metadata, returns `Promise<void>`.
-   *
-   * @example `await logger.warn('Rate limit approaching', { userId: 'u_abc', count: 90 })`
-   */
-  warn(message: string, data: Record<string, unknown>): Promise<void>;
-  /**
-   * NestJS compat overload — optional context string, returns `void`.
-   *
-   * @example `logger.warn('Deprecated API used', 'PaymentService')`
-   */
-  warn(message: unknown, context?: string): void;
-  /**
-   * Native async overload — structured metadata, returns `Promise<void>`.
-   *
-   * @example `await logger.debug('Cache miss', { key: 'user:abc', ttl: 300 })`
-   */
-  debug(message: string, data: Record<string, unknown>): Promise<void>;
-  /**
-   * NestJS compat overload — optional context string, returns `void`.
-   *
-   * @example `logger.debug('Processing request', 'OrderService')`
-   */
-  debug(message: unknown, context?: string): void;
-  /**
-   * Native async overload — structured metadata, returns `Promise<void>`.
-   * Maps to `trace` level internally.
-   *
-   * @example `await logger.verbose('Socket message received', { event: 'ping', size: 42 })`
-   */
-  verbose(message: string, data: Record<string, unknown>): Promise<void>;
-  /**
-   * NestJS compat overload — optional context string, returns `void`.
-   *
-   * @example `logger.verbose('Connection established', 'WebSocketGateway')`
-   */
-  verbose(message: unknown, context?: string): void;
-  /**
-   * Native async `trace` — lowest verbosity level, structured data.
-   */
-  trace(message: string, data?: Record<string, unknown>): Promise<void>;
-  /**
-   * Log at any named level with structured data.
-   */
-  logLevel(level: string, message: string, data?: Record<string, unknown>): Promise<void>;
-  time(label: string): void;
-  timeEnd(label: string): Promise<number | undefined>;
-  timeAsync<T>(label: string, fn: () => Promise<T>): Promise<T>;
-  setContext(context: string): void;
-  getContext(): string | undefined;
-  setLevel(level: LogLevelString): void;
-  getLevel(): LogLevelString;
-  child(context: string, data?: Record<string, unknown>): LogixiaLoggerService;
-  getCurrentTraceId(): string | undefined;
-  /** Returns the AsyncLocalStorage key currently used to store the trace ID. */
-  get traceContextKey(): string;
-  close(): Promise<void>;
-  static create<T extends LoggerConfig<Record<string, number>>>(config?: T): LogixiaServiceWithLevels<T>;
-  getLogger(): LogixiaLogger;
-  private setContextIfProvided;
-  private formatMessage;
-}
-//#endregion
-//#region src/core/kafka-trace.interceptor.d.ts
-/**
- * Observable counters exposed for monitoring Kafka consumer trace hygiene.
- *
- * Usage:
- *   import { KafkaTraceInterceptor } from 'logixia/nest';
- *   setInterval(() => {
- *     myMetrics.gauge('kafka.trace.dropped', KafkaTraceInterceptor.metrics.dropped);
- *   }, 10_000);
- */
-interface KafkaTraceMetrics {
-  /** Messages processed where a traceId was successfully resolved (body/header/ALS). */
-  accepted: number;
-  /** Messages handled without any traceId — `requireTraceId: false`. */
-  acceptedWithoutTrace: number;
-  /** Messages dropped because `requireTraceId: true` and no traceId was found. */
-  dropped: number;
-}
-declare class KafkaTraceInterceptor implements NestInterceptor {
-  private readonly config?;
-  private readonly requireTraceId;
-  /**
-   * Process-wide counters. Readable from anywhere — scrape into your metrics
-   * system (Prometheus, Datadog, CloudWatch) on an interval.
-   */
-  static readonly metrics: KafkaTraceMetrics;
-  /** Reset counters (tests). */
-  static resetMetrics(): void;
-  private readonly ctx;
-  /**
-   * @param config        - TraceIdConfig options (extractor keys, contextKey, etc.)
-   * @param requireTraceId - When true, messages with no traceId are silently skipped
-   *                         (EMPTY Observable — message is ack'd, consumer stays alive).
-   *                         A WARN is logged AND `KafkaTraceInterceptor.metrics.dropped`
-   *                         increments so the missing traceId is observable end-to-end.
-   *                         Default: false (handler runs without trace context).
-   */
-  constructor(config?: TraceIdConfig | undefined, requireTraceId?: boolean);
-  intercept(context: ExecutionContext, next: CallHandler): Observable<any>;
-}
-//#endregion
-//#region src/core/websocket-trace.interceptor.d.ts
-declare class WebSocketTraceInterceptor implements NestInterceptor {
-  private readonly config?;
-  private readonly ctx;
-  constructor(config?: TraceIdConfig | undefined);
-  intercept(context: ExecutionContext, next: CallHandler): Observable<any>;
-}
-//#endregion
-//#region src/core/logitron-logger.module.d.ts
-declare const LOGIXIA_LOGGER_CONFIG = "LOGIXIA_LOGGER_CONFIG";
-declare const LOGIXIA_TRACE_CONFIG = "TRACE_CONFIG";
-declare const LOGIXIA_LOGGER_PREFIX = "LOGIXIA_LOGGER_";
-interface LogixiaAsyncOptions extends Pick<ModuleMetadata, 'imports'> {
-  useExisting?: Type<LogixiaOptionsFactory>;
-  useClass?: Type<LogixiaOptionsFactory>;
-  useFactory?: (...args: unknown[]) => Promise<Partial<LoggerConfig>> | Partial<LoggerConfig>;
-  inject?: Array<InjectionToken | OptionalFactoryDependency>;
-}
-interface LogixiaOptionsFactory {
-  createLogixiaOptions(): Promise<Partial<LoggerConfig>> | Partial<LoggerConfig>;
-}
-/**
- * Logixia Logger Module for NestJS dependency injection
- */
-declare class LogixiaLoggerModule implements NestModule {
-  private config;
-  private static loggerConfig;
-  /**
-   * @internal Backing field for the global logger. Do not read or write
-   * directly — use {@link getGlobalLogger} / {@link _setGlobalLogger} which
-   * enforce single-init semantics.
-   */
-  static _globalLogger: LogixiaLoggerService | null;
-  /**
-   * @internal Set the global logger exactly once.
-   *
-   * Called from the module's forRoot / forRootAsync factory. If the module is
-   * initialised more than once in the same process (nested DI context, test
-   * harness creating multiple apps, hot reload, etc.) a warning is written to
-   * stderr and the first logger wins — silently overwriting would allow the
-   * newer instance's transport config to replace the live one while the old
-   * one is still being used by registered shutdown hooks, decorators, etc.
-   *
-   * Use {@link _resetGlobalLogger} in tests to reset between runs.
-   */
-  static _setGlobalLogger(service: LogixiaLoggerService): void;
-  /** @internal Clear the global logger. Tests only. */
-  static _resetGlobalLogger(): void;
-  /**
-   * Returns the global LogixiaLoggerService instance that was created when the
-   * module booted. Useful for logging outside of NestJS DI — utility functions,
-   * plain scripts, decorators — without injecting the service everywhere.
-   *
-   * Returns `null` if called before `LogixiaLoggerModule.forRoot[Async]()` has
-   * been initialised (i.e. before the NestJS app has started).
-   *
-   * @example
-   * ```ts
-   * // some-util.ts
-   * import { LogixiaLoggerModule } from 'logixia/nest';
-   *
-   * export function doSomething() {
-   *   LogixiaLoggerModule.getGlobalLogger()?.info('doing something');
-   * }
-   * ```
-   */
-  static getGlobalLogger(): LogixiaLoggerService | null;
-  configure(consumer: MiddlewareConsumer): void;
-  /**
-   * Configure the module with synchronous options
-   */
-  static forRoot(config?: Partial<LoggerConfig>): {
-    module: typeof LogixiaLoggerModule;
-    providers: ({
-      provide: string;
-      useValue: Partial<LoggerConfig<Record<string, number>>>;
-      useFactory?: never;
-      inject?: never;
-    } | {
-      provide: string;
-      useValue: TraceIdConfig;
-      useFactory?: never;
-      inject?: never;
-    } | {
-      provide: typeof LogixiaLoggerService;
-      useFactory: (loggerConfig: Partial<LoggerConfig>) => LogixiaLoggerService;
-      inject: string[];
-      useValue?: never;
-    } | {
-      provide: typeof KafkaTraceInterceptor;
-      useFactory: (traceConfig: TraceIdConfig | undefined) => KafkaTraceInterceptor;
-      inject: string[];
-      useValue?: never;
-    } | {
-      provide: typeof WebSocketTraceInterceptor;
-      useFactory: (traceConfig: TraceIdConfig | undefined) => WebSocketTraceInterceptor;
-      inject: string[];
-      useValue?: never;
-    })[];
-    exports: (string | typeof WebSocketTraceInterceptor | typeof LogixiaLoggerService | typeof KafkaTraceInterceptor)[];
-    global: boolean;
-  };
-  /**
-   * Configure the module with asynchronous options
-   */
-  static forRootAsync(options: LogixiaAsyncOptions): {
-    module: typeof LogixiaLoggerModule;
-    imports: (Type<any> | _nestjs_common0.DynamicModule | Promise<_nestjs_common0.DynamicModule> | _nestjs_common0.ForwardReference<any>)[];
-    providers: ({
-      provide: string;
-      useFactory: (...args: unknown[]) => Promise<Partial<LoggerConfig>> | Partial<LoggerConfig>;
-      inject: (InjectionToken | OptionalFactoryDependency)[];
-    } | {
-      provide: string;
-      useFactory: (optionsFactory: LogixiaOptionsFactory) => Promise<Partial<LoggerConfig<Record<string, number>>>>;
-      inject: Type<LogixiaOptionsFactory>[];
-    } | {
-      provide: Type<LogixiaOptionsFactory>;
-      useClass: Type<LogixiaOptionsFactory>;
-    } | {
-      provide: string;
-      useFactory: (loggerConfig: Partial<LoggerConfig>) => TraceIdConfig;
-      inject: string[];
-    } | {
-      provide: typeof LogixiaLoggerService;
-      useFactory: (loggerConfig: Partial<LoggerConfig>) => LogixiaLoggerService;
-      inject: string[];
-    } | {
-      provide: typeof KafkaTraceInterceptor;
-      useFactory: (traceConfig: TraceIdConfig | undefined) => KafkaTraceInterceptor;
-      inject: string[];
-    } | {
-      provide: typeof WebSocketTraceInterceptor;
-      useFactory: (traceConfig: TraceIdConfig | undefined) => WebSocketTraceInterceptor;
-      inject: string[];
-    })[];
-    exports: (string | typeof WebSocketTraceInterceptor | typeof LogixiaLoggerService | typeof KafkaTraceInterceptor)[];
-    global: boolean;
-  };
-  /**
-   * Create feature-specific logger instances
-   */
-  static forFeature(context: string): {
-    module: typeof LogixiaLoggerModule;
-    providers: {
-      provide: string;
-      useFactory: (baseLogger: LogixiaLoggerService) => LogixiaLoggerService;
-      inject: (typeof LogixiaLoggerService)[];
-    }[];
-    exports: string[];
-  };
-  private static createAsyncProviders;
-  private static createAsyncOptionsProvider;
-}
-//#endregion
-//#region src/core/nestjs-extras.d.ts
-/**
- * Inject the Logixia logger registered in the current NestJS DI container.
- *
- * Equivalent to `@Inject(LOGIXIA_LOGGER_TOKEN)` but without needing to import
- * the internal token constant yourself.
- *
- * @example
- * ```ts
- * constructor(@InjectLogger() private readonly logger: LogixiaLoggerService) {}
- * ```
- */
-declare const InjectLogger: () => ParameterDecorator;
-interface LogMethodOptions {
-  /**
-   * Log level to use for entry / exit messages.
-   * @default 'debug'
-   */
-  level?: LogLevelString;
-  /**
-   * Whether to log the arguments passed to the method.
-   * Disable for high-throughput hot paths.
-   * @default true
-   */
-  logArgs?: boolean;
-  /**
-   * Whether to log the return value of the method.
-   * @default false
-   */
-  logResult?: boolean;
-  /**
-   * Whether to log error stack traces for thrown errors.
-   * @default true
-   */
-  logErrors?: boolean;
-  /**
-   * Custom label used in log messages instead of the auto-detected class.method name.
-   */
-  label?: string;
-}
-/**
- * Method decorator that auto-logs entry, exit, duration, and errors.
- *
- * Preserves the original method's sync/async contract: a synchronous method
- * stays synchronous (returns its value directly, with logs emitted
- * fire-and-forget), and an async method is awaited so exit/error logs reflect
- * the resolved result. Attaches to the logger found on the class instance via a
- * `logger` property (the conventional NestJS name).
- *
- * @example
- * ```ts
- * @LogMethod({ level: 'info', logArgs: true })
- * async processPayment(orderId: string): Promise<void> { … }
- * ```
- */
-declare function LogMethod(options?: LogMethodOptions): MethodDecorator;
-/**
- * Global NestJS exception filter that converts any exception into the standard
- * `LogixiaErrorResponse` wire format and logs it with full request context.
- *
- * Handles three exception types in priority order:
- *  1. `LogixiaException`     — typed fields used directly
- *  2. NestJS `HttpException` — status + message extracted
- *  3. Unknown / plain Error  — falls back to 500 `server_error`
- *
- * **Debug block (off by default):**
- * Responses never include the `debug` block (stack trace, service, duration)
- * unless `exposeDebug: true` is passed in the filter options. The underlying
- * `cause` is only added when `exposeCause: true` is also set. Enable explicitly
- * for local development only, e.g.
- * `new LogixiaExceptionFilter(logger, undefined, { exposeDebug: process.env.NODE_ENV === 'development' })`.
- *
- * **Trace ID headers:**
- * `X-Trace-ID` and `X-Request-ID` are echoed back on every error response so
- * clients can correlate with server logs.
- *
- * **Retry-After header:**
- * Automatically added for `429` responses (`Retry-After: 60`).
- *
- * Register in `main.ts`:
- * ```ts
- * const logger = app.get(LogixiaLoggerService);
- * app.useGlobalFilters(new LogixiaExceptionFilter(logger));
- * ```
- */
-interface LogixiaExceptionFilterOptions {
-  /**
-   * Include the `debug` block (stack trace, service, duration) in error responses.
-   * @default false
-   */
-  exposeDebug?: boolean;
-  /**
-   * Include `debug.cause` as well. Requires `exposeDebug`.
-   * @default false
-   */
-  exposeCause?: boolean;
-}
-/** Injection token for {@link LogixiaExceptionFilterOptions}. */
-declare const LOGIXIA_EXCEPTION_FILTER_OPTIONS = "LOGIXIA_EXCEPTION_FILTER_OPTIONS";
-declare class LogixiaExceptionFilter implements ExceptionFilter {
-  private readonly _logger;
-  private readonly _traceConfig;
-  private readonly _options;
-  constructor(logger?: LogixiaLoggerService, loggerConfig?: Partial<LoggerConfig>, options?: LogixiaExceptionFilterOptions);
-  catch(exception: unknown, host: ArgumentsHost): void;
-}
-//#endregion
-export { usePlugin as C, globalPluginRegistry as S, LogixiaServiceWithLevels as _, LogixiaExceptionFilter as a, LogixiaPlugin as b, LOGIXIA_LOGGER_PREFIX as c, LogixiaLoggerModule as d, LogixiaOptionsFactory as f, LogixiaServiceWith as g, LogixiaLoggerService as h, LogMethodOptions as i, LOGIXIA_TRACE_CONFIG as l, KafkaTraceInterceptor as m, LOGIXIA_EXCEPTION_FILTER_OPTIONS as n, LogixiaExceptionFilterOptions as o, WebSocketTraceInterceptor as p, LogMethod as r, LOGIXIA_LOGGER_CONFIG as s, InjectLogger as t, LogixiaAsyncOptions as u, LogixiaLogger as v, PluginRegistry as x, createLogger as y };
-//# sourceMappingURL=nestjs-extras-OkC796py.d.mts.map