@bsb/base 9.0.0

package/lib/interfaces/observable.d.ts

@@ -0,0 +1,297 @@
+/**
+ * BSB (Better-Service-Base) is an event-bus based microservice framework.
+ * Copyright (C) 2016 - 2025 BetterCorp (PTY) Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published
+ * by the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Alternatively, you may obtain a commercial license for this program.
+ * The commercial license allows you to use the Program in a closed-source manner,
+ * including the right to create derivative works that are not subject to the terms
+ * of the AGPL.
+ *
+ * To obtain a commercial license, please contact the copyright holders at
+ * https://www.bettercorp.dev. The terms and conditions of the commercial license
+ * will be provided upon request.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+import { DTrace } from './metrics';
+import { SmartLogMeta } from './logging';
+import { Counter, Gauge, Histogram, Timer } from './metrics';
+import { ResourceContext } from '../base/ResourceContext';
+import { z } from 'zod';
+/**
+ * Observable context for unified observability across logging, metrics, and tracing.
+ *
+ * Observable replaces DTrace in the public API and provides a unified interface for:
+ * - Structured logging with automatic trace context
+ * - Metrics creation with resource context
+ * - Distributed tracing with W3C trace context
+ * - Attribute propagation to child spans
+ *
+ * @group Observability
+ * @category Core
+ * @see {@link https://bsbcode.dev/languages/nodejs/types/interfaces/Observable.html | API: Observable}
+ *
+ * @example
+ * ```typescript
+ * // In a service plugin
+ * public async run(obs: Observable) {
+ *   // Logging
+ *   obs.log.info("Starting service");
+ *
+ *   // Set attributes for all child operations
+ *   const withUser = obs.setAttribute("user.id", "123");
+ *
+ *   // Create child span
+ *   const childObs = withUser.startSpan("database-query");
+ *   childObs.log.debug("Querying database");
+ *   // ... do work ...
+ *   childObs.end();
+ * }
+ * ```
+ */
+export interface Observable<TAttributeSchema extends z.ZodSchema = z.ZodAny> {
+    /**
+     * Core trace information (W3C compatible)
+     * @readonly
+     */
+    readonly trace: DTrace;
+    /**
+     * Trace ID (unique identifier for the entire trace)
+     * @readonly
+     */
+    readonly traceId: string;
+    /**
+     * Span ID (unique identifier for this specific span)
+     * @readonly
+     */
+    readonly spanId: string;
+    /**
+     * Resource context (service name, version, instance ID, environment, region)
+     * Automatically populated from plugin configuration
+     * @readonly
+     */
+    readonly resource: ResourceContext;
+    /**
+     * Custom attributes attached to this observable
+     * Attributes are immutable - use setAttribute() to create new observable with additional attributes
+     * @readonly
+     */
+    readonly attributes: Record<string, string | number | boolean>;
+    /**
+     * Logging methods with automatic trace context
+     *
+     * All log methods automatically include trace context (trace ID, span ID) in the output.
+     * Logs support placeholder syntax for structured logging.
+     *
+     * @example
+     * ```typescript
+     * obs.log.debug("Processing {count} items", { count: 10 });
+     * obs.log.info("Request started");
+     * obs.log.warn("Rate limit approaching");
+     * obs.log.error("Failed to connect to database");
+     * ```
+     */
+    log: {
+        /**
+         * Log a debug message
+         * @param message - The message to log with optional {placeholder} syntax
+         * @param meta - Metadata to replace placeholders and add to log
+         */
+        debug<T extends string>(message: T, ...meta: SmartLogMeta<T>): void;
+        /**
+         * Log an info message
+         * @param message - The message to log with optional {placeholder} syntax
+         * @param meta - Metadata to replace placeholders and add to log
+         */
+        info<T extends string>(message: T, ...meta: SmartLogMeta<T>): void;
+        /**
+         * Log a warning message
+         * @param message - The message to log with optional {placeholder} syntax
+         * @param meta - Metadata to replace placeholders and add to log
+         */
+        warn<T extends string>(message: T, ...meta: SmartLogMeta<T>): void;
+        /**
+         * Log an error message or BSBError
+         * @param messageOrError - Either a message string or BSBError instance
+         * @param meta - Metadata (only used if first arg is a message)
+         */
+        error<T extends string>(messageOrError: T | Error, ...meta: SmartLogMeta<T>): void;
+    };
+    /**
+     * Metrics methods for creating counters, gauges, histograms, and timers
+     *
+     * @example
+     * ```typescript
+     * // Counter for tracking requests
+     * const requests = obs.metrics.counter(
+     *   "requests_total",
+     *   "Total requests",
+     *   "Count of all incoming requests",
+     *   ["method", "status"]
+     * );
+     * requests.increment(1, { method: "GET", status: "200" });
+     *
+     * // Timer for measuring duration
+     * const timer = obs.metrics.timer();
+     * await processRequest();
+     * const duration = timer.stop();
+     * obs.log.info("Request took {ms}ms", { ms: duration });
+     * ```
+     */
+    metrics: {
+        /**
+         * Create a counter metric
+         * @param name - Metric name
+         * @param description - Short description
+         * @param help - Detailed help text
+         * @param labels - Optional label names
+         */
+        counter<LABELS extends string | undefined>(name: string, description: string, help: string, labels?: LABELS[]): Counter<LABELS>;
+        /**
+         * Create a gauge metric
+         * @param name - Metric name
+         * @param description - Short description
+         * @param help - Detailed help text
+         * @param labels - Optional label names
+         */
+        gauge<LABELS extends string | undefined>(name: string, description: string, help: string, labels?: LABELS[]): Gauge<LABELS>;
+        /**
+         * Create a histogram metric
+         * @param name - Metric name
+         * @param description - Short description
+         * @param help - Detailed help text
+         * @param boundaries - Optional histogram boundaries
+         * @param labels - Optional label names
+         */
+        histogram<LABELS extends string | undefined>(name: string, description: string, help: string, boundaries?: number[], labels?: LABELS[]): Histogram<LABELS>;
+        /**
+         * Create a timer to measure elapsed time
+         */
+        timer(): Timer;
+    };
+    /**
+     * Create a child span with inherited attributes
+     *
+     * Child spans inherit all attributes from the parent and form a parent-child
+     * relationship in the distributed trace. Always call end() when done.
+     *
+     * @param name - Name of the span
+     * @param attributes - Additional attributes for this span
+     * @returns New Observable representing the child span
+     *
+     * @example
+     * ```typescript
+     * public async fetchUser(obs: Observable, userId: string) {
+     *   const span = obs.startSpan("fetch-user", { "user.id": userId });
+     *   try {
+     *     const user = await this.db.query("SELECT * FROM users WHERE id = ?", [userId]);
+     *     span.end({ "user.found": true });
+     *     return user;
+     *   } catch (error) {
+     *     span.error(error as Error);
+     *     span.end({ "user.found": false });
+     *     throw error;
+     *   }
+     * }
+     * ```
+     */
+    startSpan(name: string, attributes?: Record<string, string | number | boolean>): Observable<TAttributeSchema>;
+    /**
+     * Create a new Observable with an additional attribute
+     *
+     * Observables are immutable - this returns a new instance.
+     * Attributes are propagated to all child operations (logs, spans, metrics).
+     *
+     * @param key - Attribute key
+     * @param value - Attribute value
+     * @returns New Observable with the added attribute
+     *
+     * @example
+     * ```typescript
+     * public async handleRequest(obs: Observable, req: Request) {
+     *   // Add request ID to all subsequent operations
+     *   const withRequestId = obs.setAttribute("request.id", req.id);
+     *   withRequestId.log.info("Handling request");
+     *
+     *   // Chain multiple attributes
+     *   const withUser = withRequestId.setAttribute("user.id", req.userId);
+     *   const span = withUser.startSpan("process-request");
+     * }
+     * ```
+     */
+    setAttribute<K extends string, V extends string | number | boolean>(key: K, value: V): Observable<TAttributeSchema>;
+    /**
+     * Create a new Observable with multiple attributes
+     *
+     * Observables are immutable - this returns a new instance.
+     * More efficient than calling setAttribute multiple times.
+     *
+     * @param attrs - Attributes to add
+     * @returns New Observable with the added attributes
+     *
+     * @example
+     * ```typescript
+     * public async handleRequest(obs: Observable, req: Request) {
+     *   const withContext = obs.setAttributes({
+     *     "request.id": req.id,
+     *     "user.id": req.userId,
+     *     "request.method": req.method,
+     *     "request.path": req.path
+     *   });
+     *   withContext.log.info("Processing request");
+     * }
+     * ```
+     */
+    setAttributes(attrs: Record<string, string | number | boolean>): Observable<TAttributeSchema>;
+    /**
+     * Record an error to both logs and traces
+     *
+     * Automatically records the error to both the logging system and the active span.
+     * This ensures errors are captured in both systems for complete observability.
+     *
+     * @param error - Error or BSBError to record
+     * @param attributes - Additional attributes to attach
+     *
+     * @example
+     * ```typescript
+     * const span = obs.startSpan("risky-operation");
+     * try {
+     *   await this.doSomethingRisky();
+     *   span.end({ "status": "success" });
+     * } catch (error) {
+     *   span.error(error as Error, { "status": "failed", "retry": true });
+     *   span.end();
+     *   throw error;
+     * }
+     * ```
+     */
+    error(error: Error, attributes?: Record<string, string | number | boolean>): void;
+    /**
+     * End the span (only applies if this Observable was created via span())
+     *
+     * Completes the span and records the final state. If this Observable was not
+     * created via span(), this method does nothing.
+     *
+     * @param attributes - Final attributes to attach before ending
+     *
+     * @example
+     * ```typescript
+     * const span = obs.startSpan("process-batch");
+     * const items = await this.fetchItems();
+     * await this.processItems(items);
+     * span.end({ "items.processed": items.length, "status": "complete" });
+     * ```
+     */
+    end(attributes?: Record<string, string | number | boolean>): void;
+}

package/lib/interfaces/observable.js

@@ -0,0 +1,29 @@
+"use strict";
+/**
+ * BSB (Better-Service-Base) is an event-bus based microservice framework.
+ * Copyright (C) 2016 - 2025 BetterCorp (PTY) Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published
+ * by the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Alternatively, you may obtain a commercial license for this program.
+ * The commercial license allows you to use the Program in a closed-source manner,
+ * including the right to create derivative works that are not subject to the terms
+ * of the AGPL.
+ *
+ * To obtain a commercial license, please contact the copyright holders at
+ * https://www.bettercorp.dev. The terms and conditions of the commercial license
+ * will be provided upon request.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=observable.js.map

package/lib/interfaces/observable.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"observable.js","sourceRoot":"","sources":["../../src/interfaces/observable.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG"}

package/lib/interfaces/options.d.ts

@@ -0,0 +1,164 @@
+/**
+ * BSB (Better-Service-Base) is an event-bus based microservice framework.
+ * Copyright (C) 2016 - 2025 BetterCorp (PTY) Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published
+ * by the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Alternatively, you may obtain a commercial license for this program.
+ * The commercial license allows you to use the Program in a closed-source manner,
+ * including the right to create derivative works that are not subject to the terms
+ * of the AGPL.
+ *
+ * To obtain a commercial license, please contact the copyright holders at
+ * https://www.bettercorp.dev. The terms and conditions of the commercial license
+ * will be provided upon request.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+import type { DEBUG_MODE } from "./logging";
+import type { SBConfig } from "../serviceBase/config";
+import type { SBPlugins } from "../serviceBase/plugins";
+import type { SBObservable } from "../serviceBase/observable";
+import type { SBEvents } from "../serviceBase/events";
+import type { SBServices } from "../serviceBase/services";
+/**
+ * Configuration options for ServiceBase constructor
+ *
+ * @group Main
+ * @category Configuration
+ * @see {@link https://bsbcode.dev/languages/nodejs/types/interfaces/BSBOptions.html | API: BSBOptions}
+ */
+export interface BSBOptions {
+    /**
+     * Enable debug logging
+     * @default true
+     */
+    debug?: boolean;
+    /**
+     * Disable development mode (affects plugin loading)
+     * @default false
+     */
+    live?: boolean;
+    /**
+     * Current working directory
+     * @default process.cwd()
+     */
+    cwd?: string;
+    /**
+     * Custom application ID (overrides auto-generated ID)
+     * @default undefined (auto-generated from hostname + UUID)
+     */
+    appId?: string;
+    /**
+     * Deployment region for resource context
+     * @default undefined (resolved from BSB_REGION env var)
+     */
+    region?: string;
+    /**
+     * Override default configuration handler
+     * @default SBConfig
+     */
+    config?: typeof SBConfig;
+    /**
+     * Override default plugins handler
+     * @default SBPlugins
+     */
+    plugins?: typeof SBPlugins;
+    /**
+     * Override default observable handler (unified logging, metrics, tracing)
+     * @default SBObservable
+     */
+    observable?: typeof SBObservable;
+    /**
+     * Override default events handler
+     * @default SBEvents
+     */
+    events?: typeof SBEvents;
+    /**
+     * Override default services handler
+     * @default SBServices
+     */
+    services?: typeof SBServices;
+}
+/**
+ * Resolved options with all defaults applied
+ *
+ * @group Main
+ * @category Configuration
+ * @see {@link https://bsbcode.dev/languages/nodejs/types/interfaces/ResolvedBSBOptions.html | API: ResolvedBSBOptions}
+ */
+export interface ResolvedBSBOptions {
+    debug: boolean;
+    live: boolean;
+    cwd: string;
+    appId: string;
+    region?: string;
+    mode: DEBUG_MODE;
+    config: typeof SBConfig;
+    plugins: typeof SBPlugins;
+    observable: typeof SBObservable;
+    events: typeof SBEvents;
+    services: typeof SBServices;
+}
+/**
+ * Simple configuration for common use cases
+ *
+ * @group Main
+ * @category Configuration
+ * @see {@link https://bsbcode.dev/languages/nodejs/types/interfaces/SimpleBSBOptions.html | API: SimpleBSBOptions}
+ */
+export interface SimpleBSBOptions {
+    /**
+     * Working directory
+     * @default process.cwd()
+     */
+    cwd?: string;
+    /**
+     * Configuration file path or object
+     */
+    config?: string | object;
+    /**
+     * List of plugins to enable
+     * @default ['observable-default', 'events-default']
+     */
+    plugins?: string[];
+    /**
+     * Debug mode
+     * @default true in development, false in production
+     */
+    debug?: boolean;
+}
+/**
+ * Factory preset configurations
+ *
+ * @group Main
+ * @category Configuration
+ * @see {@link https://bsbcode.dev/languages/nodejs/types/interfaces/BSBPreset.html | API: BSBPreset}
+ */
+export declare enum BSBPreset {
+    /**
+     * Minimal setup with basic plugins
+     */
+    MINIMAL = "minimal",
+    /**
+     * Development setup with debug logging
+     */
+    DEVELOPMENT = "development",
+    /**
+     * Production setup with optimized settings
+     */
+    PRODUCTION = "production",
+    /**
+     * Testing setup with mocked components
+     */
+    TESTING = "testing"
+}

package/lib/interfaces/options.js

@@ -0,0 +1,56 @@
+"use strict";
+/**
+ * BSB (Better-Service-Base) is an event-bus based microservice framework.
+ * Copyright (C) 2016 - 2025 BetterCorp (PTY) Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published
+ * by the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Alternatively, you may obtain a commercial license for this program.
+ * The commercial license allows you to use the Program in a closed-source manner,
+ * including the right to create derivative works that are not subject to the terms
+ * of the AGPL.
+ *
+ * To obtain a commercial license, please contact the copyright holders at
+ * https://www.bettercorp.dev. The terms and conditions of the commercial license
+ * will be provided upon request.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BSBPreset = void 0;
+/**
+ * Factory preset configurations
+ *
+ * @group Main
+ * @category Configuration
+ * @see {@link https://bsbcode.dev/languages/nodejs/types/interfaces/BSBPreset.html | API: BSBPreset}
+ */
+var BSBPreset;
+(function (BSBPreset) {
+    /**
+     * Minimal setup with basic plugins
+     */
+    BSBPreset["MINIMAL"] = "minimal";
+    /**
+     * Development setup with debug logging
+     */
+    BSBPreset["DEVELOPMENT"] = "development";
+    /**
+     * Production setup with optimized settings
+     */
+    BSBPreset["PRODUCTION"] = "production";
+    /**
+     * Testing setup with mocked components
+     */
+    BSBPreset["TESTING"] = "testing";
+})(BSBPreset || (exports.BSBPreset = BSBPreset = {}));
+//# sourceMappingURL=options.js.map

package/lib/interfaces/options.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"options.js","sourceRoot":"","sources":["../../src/interfaces/options.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;;;AAmIH;;;;;;GAMG;AACH,IAAY,SAoBX;AApBD,WAAY,SAAS;IACnB;;OAEG;IACH,gCAAmB,CAAA;IAEnB;;OAEG;IACH,wCAA2B,CAAA;IAE3B;;OAEG;IACH,sCAAyB,CAAA;IAEzB;;OAEG;IACH,gCAAmB,CAAA;AACrB,CAAC,EApBW,SAAS,yBAAT,SAAS,QAoBpB"}

package/lib/interfaces/plugins.d.ts

@@ -0,0 +1,143 @@
+/**
+ * BSB (Better-Service-Base) is an event-bus based microservice framework.
+ * Copyright (C) 2016 - 2025 BetterCorp (PTY) Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published
+ * by the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Alternatively, you may obtain a commercial license for this program.
+ * The commercial license allows you to use the Program in a closed-source manner,
+ * including the right to create derivative works that are not subject to the terms
+ * of the AGPL.
+ *
+ * To obtain a commercial license, please contact the copyright holders at
+ * https://www.bettercorp.dev. The terms and conditions of the commercial license
+ * will be provided upon request.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+import { BSBConfig, BSBConfigRef, BSBEvents, BSBEventsRef, BSBObservable, BSBObservableRef, BSBPluginConfig, BSBService, BSBServiceRef } from "../base";
+import { EventsEventTypes } from "./events";
+/**
+ * @hidden
+ */
+/**
+ * @see {@link https://bsbcode.dev/languages/nodejs/types/modules.html#module-interfaces_plugins | API: interfaces/plugins}
+ */
+export declare const PluginTypes: {
+    readonly config: "config";
+    readonly events: "events";
+    readonly observable: "observable";
+    readonly service: "service";
+};
+/**
+ * @hidden
+ */
+export type PluginType = (typeof PluginTypes)[keyof typeof PluginTypes];
+/**
+ * Marks all properties of an object read only and all nested objects read only
+ * @hidden
+ */
+export type DeepReadonly<T> = {
+    readonly [P in keyof T]: T[P] extends (infer R)[] ? DeepReadonlyArray<R> : T[P] extends Function ? T[P] : T[P] extends object ? DeepReadonly<T[P]> : T[P];
+};
+/**
+ * Marks all properties of an array read only and all nested objects read only
+ * @hidden
+ */
+export interface DeepReadonlyArray<T> extends ReadonlyArray<DeepReadonly<T>> {
+}
+/**
+ * @hidden
+ */
+export interface IPluginDefinition {
+    package?: string | null;
+    plugin: string;
+    name: string;
+    version: string;
+}
+/**
+ * @hidden
+ */
+export interface IPluginBuilder {
+    name: string;
+    pluginName: string;
+    version: string;
+    pluginFile: string;
+    pluginDir: string;
+    installerFile: string | null;
+}
+/**
+ * @hidden
+ */
+export type PluginTypeDefinition<T extends PluginType> = T extends typeof PluginTypes.service ? BSBService : T extends typeof PluginTypes.observable ? BSBObservable<any> : T extends typeof PluginTypes.config ? BSBConfig : T extends typeof PluginTypes.events ? BSBEvents : never;
+/**
+ * @hidden
+ */
+export type PluginTypeDefinitionRef<T extends PluginType> = T extends typeof PluginTypes.service ? typeof BSBServiceRef : T extends typeof PluginTypes.observable ? typeof BSBObservableRef : T extends typeof PluginTypes.config ? typeof BSBConfigRef : T extends typeof PluginTypes.events ? typeof BSBEventsRef : never;
+/**
+ * @hidden
+ */
+export interface IPluginBuilt<T extends PluginType> extends IPluginBuilder {
+    config: any;
+    plugin: PluginTypeDefinition<T>;
+}
+/**
+ * @hidden
+ */
+export interface PluginDefinition {
+    package?: string | null;
+    version: string | null;
+    plugin: string;
+    enabled: boolean;
+}
+/**
+ * @hidden
+ */
+export type FilterDetailed<T extends string | number | symbol = any> = Record<T, {
+    plugins: Array<string>;
+    enabled: boolean;
+}>;
+/**
+ * @hidden
+ */
+export type EventsFilterDetailed = FilterDetailed<EventsEventTypes>;
+/**
+ * @hidden
+ */
+export type EventsFilter = EventsFilterDetailed | Record<EventsEventTypes, boolean> | Record<EventsEventTypes, Array<string>> | Array<EventsEventTypes>;
+/**
+ * @hidden
+ */
+export interface EventsConfig extends PluginDefinition {
+    filter?: EventsFilter;
+}
+/**
+ * @hidden
+ */
+export type FilterOnType = // see EventsFilter and LoggingFilter for more details
+"all" | "events" | "eventsState" | "eventsPlugins" | "eventsDetailed";
+/**
+ * @hidden
+ */
+export interface LoadedPlugin<NamedType extends PluginType, ClassType extends PluginTypeDefinitionRef<NamedType> = PluginTypeDefinitionRef<NamedType>> {
+    name: string;
+    ref: string;
+    version: string;
+    serviceConfig: BSBPluginConfig<any> | null;
+    plugin: ClassType;
+    packageCwd: string;
+    pluginCwd: string;
+    pluginPath: string;
+}
+/**
+ * @see {@link https://bsbcode.dev/languages/nodejs/types/modules.html#module-interfaces_plugins | API: interfaces/plugins}
+ */