@equinor/fusion-framework-module-signalr 10.0.1 → 11.0.0

package/dist/types/SignalRModule.d.ts

@@ -1,11 +1,36 @@
 import type { Module } from '@equinor/fusion-framework-module';
 import { type ISignalRConfigurator } from './SignalRModuleConfigurator';
 import { type ISignalRProvider } from './SignalRModuleProvider';
+/** String literal key used to register the SignalR module in the Fusion Framework module system. */
 export type SignalRModuleKey = 'signalR';
+/** Module registration key for the SignalR module (`'signalR'`). */
 export declare const moduleKey: SignalRModuleKey;
+/**
+ * Module type definition for the SignalR module.
+ *
+ * Binds the module key, provider interface ({@link ISignalRProvider}), and
+ * configurator interface ({@link ISignalRConfigurator}) together for the
+ * Fusion Framework module system.
+ */
 export type SignalRModule = Module<SignalRModuleKey, ISignalRProvider, ISignalRConfigurator>;
+/**
+ * SignalR module instance that can be registered with a Fusion Framework configurator.
+ *
+ * During the `configure` phase, a {@link SignalRConfigurator} is created.
+ * During the `initialize` phase, the configurator builds its {@link SignalRConfig}
+ * and produces a {@link SignalRModuleProvider}.
+ *
+ * @example
+ * ```ts
+ * import { ModuleConfigurator } from '@equinor/fusion-framework-module';
+ * import signalR from '@equinor/fusion-framework-module-signalr';
+ *
+ * configurator.addConfig({ module: signalR });
+ * ```
+ */
 export declare const module: SignalRModule;
 export default module;
+/** Augments the global `Modules` interface so that `'signalR'` is a known module key. */
 declare module '@equinor/fusion-framework-module' {
     interface Modules {
         signalR: SignalRModule;

package/dist/types/SignalRModuleConfigurator.d.ts

@@ -1,53 +1,129 @@
 import { type AnyModule, ModuleConfigBuilder, type ModuleInitializerArgs } from '@equinor/fusion-framework-module';
 import type { ServiceDiscoveryModule } from '@equinor/fusion-framework-module-service-discovery';
 import type { IHttpConnectionOptions, LogLevel } from '@microsoft/signalr';
+/**
+ * Public configuration interface for the SignalR module.
+ *
+ * Consumers use this interface to register hub connections and configuration
+ * callbacks during the module `configure` phase.
+ */
 export interface ISignalRConfigurator {
-    /** add configuration for hub connection */
+    /**
+     * Register a named SignalR hub connection.
+     *
+     * @param name - Unique identifier for the hub (used later with {@link ISignalRProvider.connect})
+     * @param config - Hub connection configuration or a promise that resolves to one
+     */
     addHub(name: string, config: SignalRHubConfig | Promise<SignalRHubConfig>): void;
-    /** add callback for building config on init */
+    /**
+     * Register a callback that will run during the module initialization phase
+     * to build configuration using a {@link SignalRModuleConfigBuilder}.
+     *
+     * Use this when hub configuration depends on resolved module dependencies
+     * such as service-discovery or authentication.
+     *
+     * @param cb - Callback that receives a {@link SignalRModuleConfigBuilder}
+     */
     onCreateConfig(cb: SignalRModuleConfigBuilderCallback): void;
 }
-/** configuration callback */
+/**
+ * Callback invoked during module initialization to configure SignalR hubs.
+ *
+ * Receives a {@link SignalRModuleConfigBuilder} that provides access to
+ * resolved module dependencies, allowing dynamic hub registration.
+ *
+ * @template TDeps - Tuple of module dependencies available through the builder
+ */
 export type SignalRModuleConfigBuilderCallback<TDeps = unknown> = (builder: SignalRModuleConfigBuilder<TDeps>) => void | Promise<void>;
 /**
- * Configuration for hub connection
+ * Configuration for a single SignalR hub connection.
+ *
+ * Defines the endpoint URL, transport options, reconnection behavior,
+ * and logging level for a `@microsoft/signalr` `HubConnection`.
  */
 export type SignalRHubConfig = {
-    /** connection endpoint */
+    /** Absolute URL of the SignalR hub endpoint. */
     url: string;
-    /** connection options */
+    /**
+     * Transport and authentication options forwarded to the underlying
+     * `HubConnectionBuilder.withUrl()` call.
+     *
+     * The `httpClient` option is excluded because the module manages the
+     * HTTP client internally.
+     */
     options: Omit<IHttpConnectionOptions, 'httpClient'>;
-    /** reconnect when connection lost */
+    /**
+     * When `true`, the connection will automatically attempt to reconnect
+     * after an unintentional disconnection.
+     *
+     * @defaultValue `undefined` (no automatic reconnect)
+     */
     automaticReconnect?: boolean;
+    /**
+     * Minimum log level for the SignalR connection logger.
+     *
+     * @defaultValue `LogLevel.Critical` (5) when omitted
+     */
     logLevel?: LogLevel;
 };
 /**
- * Configuration for creating SignalR provider
+ * Resolved configuration used to create a {@link SignalRModuleProvider}.
+ *
+ * Contains all registered hub configurations keyed by hub name.
  */
 export type SignalRConfig = {
+    /** Map of hub name to its {@link SignalRHubConfig}. */
     hubs: Record<string, SignalRHubConfig>;
 };
 /**
- * builder utility class for generating configuration
+ * Builder utility for registering SignalR hub configurations during
+ * module initialization.
+ *
+ * Extends {@link ModuleConfigBuilder} to provide access to resolved
+ * module dependencies (e.g., service-discovery, authentication) so that
+ * hub URLs and access-token factories can be built dynamically.
+ *
+ * @template TDeps - Tuple of module dependencies available through the builder
  */
 export declare class SignalRModuleConfigBuilder<TDeps extends AnyModule[] | unknown = unknown> extends ModuleConfigBuilder<TDeps, ISignalRConfigurator> {
+    /**
+     * Register a named hub connection through the underlying configurator.
+     *
+     * @param name - Unique hub identifier
+     * @param config - Hub connection configuration
+     */
     addHub(name: string, config: SignalRHubConfig): Promise<void>;
 }
+/**
+ * Default {@link ISignalRConfigurator} implementation.
+ *
+ * Collects hub registrations and builder callbacks, then produces a
+ * {@link SignalRConfig} during the module initialization phase.
+ */
 export declare class SignalRConfigurator implements ISignalRConfigurator {
     #private;
     /**
-     * register SignalR hub configuration.
+     * Register a named SignalR hub connection.
+     *
+     * @param name - Unique identifier for the hub
+     * @param config - Hub connection configuration
      */
     addHub(name: string, config: SignalRHubConfig): void;
     /**
-     * add callback for building config on when configurator is creating config.
-     * {@link SignalRConfigurator.createConfig}
+     * Register a configuration builder callback that will run during
+     * {@link SignalRConfigurator.createConfig}.
+     *
+     * @param cb - Callback receiving a {@link SignalRModuleConfigBuilder}
      */
     onCreateConfig<T>(cb: SignalRModuleConfigBuilderCallback<T>): void;
     /**
-     * normally executed in `init` phase of module, which creates configuration to the module provider.
-     * cycles threw all registered configuration builders.
-     * await all registered hub configurations.
+     * Build the final {@link SignalRConfig} by executing all registered
+     * builder callbacks and collecting hub configurations.
+     *
+     * Normally called during the module `initialize` phase.
+     *
+     * @param init - Module initializer arguments providing access to resolved dependencies
+     * @returns Resolved configuration containing all registered hubs
      */
     createConfig(init: ModuleInitializerArgs<ISignalRConfigurator, [ServiceDiscoveryModule]>): Promise<SignalRConfig>;
 }

package/dist/types/SignalRModuleProvider.d.ts

@@ -2,17 +2,70 @@ import { type HubConnection } from '@microsoft/signalr';
 import { Observable } from 'rxjs';
 import type { SignalRConfig } from './SignalRModuleConfigurator';
 import { Topic } from './lib/Topic';
+/**
+ * Public interface for the SignalR module provider.
+ *
+ * Use {@link ISignalRProvider.connect} to subscribe to a named hub method
+ * through an RxJS-based {@link Topic}. Connections are reference-counted
+ * and automatically torn down when all subscribers unsubscribe.
+ */
 export interface ISignalRProvider {
     /**
-     * connect to SignalR hub
-     * re-use existing connections and close connection when nobody is listening
+     * Connect to a SignalR hub method and return an observable {@link Topic}.
+     *
+     * Existing hub connections are reused (shared via `shareReplay` with
+     * `refCount`). When the last subscriber unsubscribes, the underlying
+     * `HubConnection` is stopped automatically.
+     *
+     * @template T - Type of messages received from the hub method
+     * @param hubId - Name of the hub as registered in the configurator
+     * @param methodName - Server-side method name to listen on
+     * @returns A {@link Topic} observable that emits messages from the hub method
+     *
+     * @example
+     * ```ts
+     * const provider = modules.signalR;
+     * const topic = provider.connect<MyMessage>('notifications', 'OnNewMessage');
+     * topic.subscribe((msg) => console.log('Received:', msg));
+     * ```
      */
-    connect<T>(ubId: string, methodName: string): Topic<T>;
+    connect<T>(hubId: string, methodName: string): Topic<T>;
 }
+/**
+ * Default {@link ISignalRProvider} implementation.
+ *
+ * Creates and manages `@microsoft/signalr` `HubConnection` instances based on
+ * the resolved {@link SignalRConfig}. Hub connections are lazily created on
+ * first subscription and shared across all callers via `shareReplay`.
+ */
 export declare class SignalRModuleProvider implements ISignalRProvider {
     #private;
+    /**
+     * @param config - Resolved SignalR configuration containing all registered hubs
+     */
     constructor(config: SignalRConfig);
+    /**
+     * Connect to a named hub method and return an observable {@link Topic}.
+     *
+     * @template T - Type of messages received from the hub method
+     * @param hubId - Name of the hub as registered in the configurator
+     * @param methodName - Server-side method name to listen on
+     * @returns A {@link Topic} observable emitting hub messages
+     * @throws {Error} When no hub configuration exists for `hubId`
+     */
     connect<T>(hubId: string, methodName: string): Topic<T>;
+    /**
+     * Create or retrieve a shared `HubConnection` observable for the given hub.
+     *
+     * The connection is lazily built using `HubConnectionBuilder` and shared
+     * with `shareReplay({ bufferSize: 1, refCount: true })` so that:
+     * - New subscribers immediately receive the current connection.
+     * - The connection is stopped when the last subscriber unsubscribes.
+     *
+     * @param hubId - Name of the hub as registered in the configurator
+     * @returns Observable that emits the active `HubConnection`
+     * @throws {Error} When no hub configuration exists for `hubId`
+     */
     protected _createHubConnection(hubId: string): Observable<HubConnection>;
 }
 export default SignalRModuleProvider;

package/dist/types/index.d.ts

@@ -1,3 +1,16 @@
+/**
+ * @packageDocumentation
+ *
+ * Fusion Framework module for real-time communication via
+ * [SignalR](https://learn.microsoft.com/aspnet/core/signalr/introduction).
+ *
+ * Provides an RxJS-based API for connecting to SignalR hubs, subscribing to
+ * server-side methods, and sending messages. Hub connections are reference-counted
+ * and automatically stopped when no subscribers remain.
+ *
+ * @see {@link enableSignalR} for the quickest way to register the module.
+ * @see {@link ISignalRProvider.connect} for subscribing to hub methods at runtime.
+ */
 export { ISignalRConfigurator, SignalRConfigurator, SignalRConfig, SignalRHubConfig, SignalRModuleConfigBuilder, SignalRModuleConfigBuilderCallback, } from './SignalRModuleConfigurator';
 export { ISignalRProvider, SignalRModuleProvider } from './SignalRModuleProvider';
 export { Topic } from './lib/Topic';

package/dist/types/lib/Topic.d.ts

@@ -1,10 +1,50 @@
 import type { HubConnection } from '@microsoft/signalr';
 import { Observable } from 'rxjs';
+/**
+ * RxJS Observable wrapper around a SignalR hub method.
+ *
+ * A `Topic` subscribes to a named method on a `HubConnection` and emits
+ * incoming messages as observable values. It also exposes {@link Topic.send}
+ * and {@link Topic.invoke} for sending messages back to the server.
+ *
+ * Created by {@link SignalRModuleProvider.connect} — consumers typically
+ * do not instantiate `Topic` directly.
+ *
+ * @template T - Type of messages received from the hub method
+ *
+ * @example
+ * ```ts
+ * const topic = provider.connect<ChatMessage>('chat', 'ReceiveMessage');
+ * topic.subscribe((msg) => console.log(msg.text));
+ *
+ * // Send a message to the server on the same method
+ * topic.send('Hello, world!');
+ * ```
+ */
 export declare class Topic<T> extends Observable<T> {
     topic: string;
     hubConnection: Observable<HubConnection>;
+    /** The active hub connection, set once the connection observable emits. */
     connection: HubConnection | undefined;
+    /**
+     * @param topic - Server-side method name to listen on and send to
+     * @param hubConnection - Observable that emits the active `HubConnection`
+     */
     constructor(topic: string, hubConnection: Observable<HubConnection>);
+    /**
+     * Send a fire-and-forget message to the server on this topic.
+     *
+     * @param args - Arguments forwarded to `HubConnection.send()`
+     * @throws {Error} When the hub connection has not been established yet
+     */
     send(...args: any[]): void;
+    /**
+     * Invoke a server method on this topic and wait for a response.
+     *
+     * @template T - Expected return type from the server method
+     * @param args - Arguments forwarded to `HubConnection.invoke()`
+     * @returns Promise resolving with the server's response
+     * @throws {Error} When the hub connection has not been established yet
+     */
     invoke<T>(...args: any[]): Promise<T>;
 }

package/dist/types/lib/utils/configure-from-framework.d.ts

@@ -1,8 +1 @@
-import type { MsalModule } from '@equinor/fusion-framework-module-msal';
-import type { ServiceDiscoveryModule } from '@equinor/fusion-framework-module-service-discovery';
-import type { SignalRModuleConfigBuilder } from '../../SignalRModuleConfigurator';
-export declare const configureFromFramework: (args: {
-    name: string;
-    service: string;
-    path: string;
-}, builder: SignalRModuleConfigBuilder<[MsalModule, ServiceDiscoveryModule]>) => Promise<void>;
+export {};

package/dist/types/lib/utils/enable-signalr.d.ts

@@ -1,38 +1,60 @@
 import type { IModulesConfigurator } from '@equinor/fusion-framework-module';
 import type { SignalRModuleConfigBuilderCallback } from '../../SignalRModuleConfigurator';
+/**
+ * Call-signature overloads for {@link enableSignalR}.
+ */
 export interface enableSignalR {
+    /**
+     * Enable SignalR with a custom configuration builder callback.
+     *
+     * @param configurator - The module configurator instance
+     * @param name - Hub name identifier
+     * @param cb - Builder callback for manual hub configuration
+     */
     (configurator: IModulesConfigurator<any, any>, name: string, cb: SignalRModuleConfigBuilderCallback): void;
+    /**
+     * Enable SignalR using service-discovery to resolve the hub URL automatically.
+     *
+     * @param configurator - The module configurator instance
+     * @param name - Hub name identifier
+     * @param options - Service name and path used to resolve the hub endpoint
+     */
     (configurator: IModulesConfigurator<any, any>, name: string, options: {
         service: string;
         path: string;
     }): void;
 }
 /**
+ * Register the SignalR module on a Fusion Framework configurator and add hub
+ * configuration in a single call.
+ *
+ * Accepts either a manual builder callback or a service-discovery shorthand.
+ * When the shorthand form is used, the hub URL and authentication token are
+ * resolved automatically via the service-discovery and MSAL modules.
+ *
+ * @param configurator - The module configurator to register the SignalR module on
+ * @param name - Hub name identifier (used as key in the hub registry)
+ * @param optionsOrCallback - A builder callback for custom configuration, or
+ *   `{ service, path }` to resolve the hub endpoint through service-discovery
+ *
  * @example
- ```ts
- import {
-    enableSignalR,
-    configurePortalHub,
-    configureNotificationHub
- } from '@equinor/fusion-framework-module-signalr';
-
- export const configure = (configurator) => {
-    enableSignalR(configurator, {
-        name: 'portal',
-        service: 'portal',
-        path: '/signalr/hubs/service-message'
-    });
-    enableSignalR(configurator, 'notifications');
-    // custom
-    enableSignalR(configurator, builder => {
-        builder.addHub('myHub', {
-            uri: 'https://foo.bar',
-            path: '/my_messages'
-            accessTokenFactory: () => makeToken(),
-        })
-    });
- }
- ```
+ * ```ts
+ * import { enableSignalR } from '@equinor/fusion-framework-module-signalr';
+ *
+ * // Using service-discovery shorthand
+ * enableSignalR(configurator, 'portal', {
+ *   service: 'portal',
+ *   path: '/signalr/hubs/service-message',
+ * });
+ *
+ * // Using a custom builder callback
+ * enableSignalR(configurator, 'custom', (builder) => {
+ *   builder.addHub('custom', {
+ *     url: 'https://my-service.example.com/hub',
+ *     options: { accessTokenFactory: () => getToken() },
+ *   });
+ * });
+ * ```
  */
 export declare function enableSignalR(configurator: IModulesConfigurator<any, any>, name: string, optionsOrCallback: SignalRModuleConfigBuilderCallback | {
     service: string;

package/dist/types/version.d.ts

@@ -1 +1 @@
-export declare const version = "10.0.1";
+export declare const version = "11.0.0";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@equinor/fusion-framework-module-signalr",
-  "version": "10.0.1",
+  "version": "11.0.0",
   "description": "",
   "sideEffects": false,
   "main": "dist/esm/index.js",
@@ -27,14 +27,15 @@
     "rxjs": "^7.8.1"
   },
   "devDependencies": {
-    "typescript": "^5.8.2",
-    "@equinor/fusion-framework-module-msal": "^7.3.1",
-    "@equinor/fusion-framework-module": "^5.0.6"
+    "typescript": "^5.9.3",
+    "@equinor/fusion-framework-module-msal": "^8.0.0",
+    "@equinor/fusion-framework-module": "^6.0.0",
+    "@equinor/fusion-framework-module-service-discovery": "^10.0.0"
   },
   "peerDependencies": {
-    "@equinor/fusion-framework-module": "^5.0.6",
-    "@equinor/fusion-framework-module-msal": "^7.3.1",
-    "@equinor/fusion-framework-module-service-discovery": "^9.1.1"
+    "@equinor/fusion-framework-module": "^6.0.0",
+    "@equinor/fusion-framework-module-msal": "^8.0.0",
+    "@equinor/fusion-framework-module-service-discovery": "^10.0.0"
   },
   "peerDependenciesMeta": {
     "@equinor/fusion-framework-module-service-discovery": {

package/src/SignalRModule.ts

@@ -3,12 +3,36 @@ import { type ISignalRConfigurator, SignalRConfigurator } from './SignalRModuleC
 
 import { type ISignalRProvider, SignalRModuleProvider } from './SignalRModuleProvider';
 
+/** String literal key used to register the SignalR module in the Fusion Framework module system. */
 export type SignalRModuleKey = 'signalR';
 
+/** Module registration key for the SignalR module (`'signalR'`). */
 export const moduleKey: SignalRModuleKey = 'signalR';
 
+/**
+ * Module type definition for the SignalR module.
+ *
+ * Binds the module key, provider interface ({@link ISignalRProvider}), and
+ * configurator interface ({@link ISignalRConfigurator}) together for the
+ * Fusion Framework module system.
+ */
 export type SignalRModule = Module<SignalRModuleKey, ISignalRProvider, ISignalRConfigurator>;
 
+/**
+ * SignalR module instance that can be registered with a Fusion Framework configurator.
+ *
+ * During the `configure` phase, a {@link SignalRConfigurator} is created.
+ * During the `initialize` phase, the configurator builds its {@link SignalRConfig}
+ * and produces a {@link SignalRModuleProvider}.
+ *
+ * @example
+ * ```ts
+ * import { ModuleConfigurator } from '@equinor/fusion-framework-module';
+ * import signalR from '@equinor/fusion-framework-module-signalr';
+ *
+ * configurator.addConfig({ module: signalR });
+ * ```
+ */
 export const module: SignalRModule = {
   name: moduleKey,
   configure: () => new SignalRConfigurator(),
@@ -20,6 +44,7 @@ export const module: SignalRModule = {
 
 export default module;
 
+/** Augments the global `Modules` interface so that `'signalR'` is a known module key. */
 declare module '@equinor/fusion-framework-module' {
   interface Modules {
     signalR: SignalRModule;

package/src/SignalRModuleConfigurator.ts

@@ -7,77 +7,154 @@ import {
 import type { ServiceDiscoveryModule } from '@equinor/fusion-framework-module-service-discovery';
 import type { IHttpConnectionOptions, LogLevel } from '@microsoft/signalr';
 
+/**
+ * Public configuration interface for the SignalR module.
+ *
+ * Consumers use this interface to register hub connections and configuration
+ * callbacks during the module `configure` phase.
+ */
 export interface ISignalRConfigurator {
-  /** add configuration for hub connection */
+  /**
+   * Register a named SignalR hub connection.
+   *
+   * @param name - Unique identifier for the hub (used later with {@link ISignalRProvider.connect})
+   * @param config - Hub connection configuration or a promise that resolves to one
+   */
   addHub(name: string, config: SignalRHubConfig | Promise<SignalRHubConfig>): void;
 
-  /** add callback for building config on init */
+  /**
+   * Register a callback that will run during the module initialization phase
+   * to build configuration using a {@link SignalRModuleConfigBuilder}.
+   *
+   * Use this when hub configuration depends on resolved module dependencies
+   * such as service-discovery or authentication.
+   *
+   * @param cb - Callback that receives a {@link SignalRModuleConfigBuilder}
+   */
   onCreateConfig(cb: SignalRModuleConfigBuilderCallback): void;
 }
 
-/** configuration callback */
+/**
+ * Callback invoked during module initialization to configure SignalR hubs.
+ *
+ * Receives a {@link SignalRModuleConfigBuilder} that provides access to
+ * resolved module dependencies, allowing dynamic hub registration.
+ *
+ * @template TDeps - Tuple of module dependencies available through the builder
+ */
 export type SignalRModuleConfigBuilderCallback<TDeps = unknown> = (
   builder: SignalRModuleConfigBuilder<TDeps>,
 ) => void | Promise<void>;
 
 /**
- * Configuration for hub connection
+ * Configuration for a single SignalR hub connection.
+ *
+ * Defines the endpoint URL, transport options, reconnection behavior,
+ * and logging level for a `@microsoft/signalr` `HubConnection`.
  */
 export type SignalRHubConfig = {
-  /** connection endpoint */
+  /** Absolute URL of the SignalR hub endpoint. */
   url: string;
 
-  /** connection options */
+  /**
+   * Transport and authentication options forwarded to the underlying
+   * `HubConnectionBuilder.withUrl()` call.
+   *
+   * The `httpClient` option is excluded because the module manages the
+   * HTTP client internally.
+   */
   options: Omit<IHttpConnectionOptions, 'httpClient'>;
 
-  /** reconnect when connection lost */
+  /**
+   * When `true`, the connection will automatically attempt to reconnect
+   * after an unintentional disconnection.
+   *
+   * @defaultValue `undefined` (no automatic reconnect)
+   */
   automaticReconnect?: boolean;
+
+  /**
+   * Minimum log level for the SignalR connection logger.
+   *
+   * @defaultValue `LogLevel.Critical` (5) when omitted
+   */
   logLevel?: LogLevel;
 };
 
 /**
- * Configuration for creating SignalR provider
+ * Resolved configuration used to create a {@link SignalRModuleProvider}.
+ *
+ * Contains all registered hub configurations keyed by hub name.
  */
 export type SignalRConfig = {
+  /** Map of hub name to its {@link SignalRHubConfig}. */
   hubs: Record<string, SignalRHubConfig>;
 };
 
 /**
- * builder utility class for generating configuration
+ * Builder utility for registering SignalR hub configurations during
+ * module initialization.
+ *
+ * Extends {@link ModuleConfigBuilder} to provide access to resolved
+ * module dependencies (e.g., service-discovery, authentication) so that
+ * hub URLs and access-token factories can be built dynamically.
+ *
+ * @template TDeps - Tuple of module dependencies available through the builder
  */
 export class SignalRModuleConfigBuilder<
   TDeps extends AnyModule[] | unknown = unknown,
   // TODO - use BaseConfigBuilder
 > extends ModuleConfigBuilder<TDeps, ISignalRConfigurator> {
+  /**
+   * Register a named hub connection through the underlying configurator.
+   *
+   * @param name - Unique hub identifier
+   * @param config - Hub connection configuration
+   */
   async addHub(name: string, config: SignalRHubConfig) {
     this._config.addHub(name, config);
   }
 }
 
+/**
+ * Default {@link ISignalRConfigurator} implementation.
+ *
+ * Collects hub registrations and builder callbacks, then produces a
+ * {@link SignalRConfig} during the module initialization phase.
+ */
 export class SignalRConfigurator implements ISignalRConfigurator {
   #builderCallbacks: Array<SignalRModuleConfigBuilderCallback> = [];
 
   #hubs: Record<string, SignalRHubConfig> = {};
 
   /**
-   * register SignalR hub configuration.
+   * Register a named SignalR hub connection.
+   *
+   * @param name - Unique identifier for the hub
+   * @param config - Hub connection configuration
    */
   public addHub(name: string, config: SignalRHubConfig) {
     this.#hubs[name] = config;
   }
 
   /**
-   * add callback for building config on when configurator is creating config.
-   * {@link SignalRConfigurator.createConfig}
+   * Register a configuration builder callback that will run during
+   * {@link SignalRConfigurator.createConfig}.
+   *
+   * @param cb - Callback receiving a {@link SignalRModuleConfigBuilder}
    */
   public onCreateConfig<T>(cb: SignalRModuleConfigBuilderCallback<T>): void {
     this.#builderCallbacks.push(cb);
   }
 
   /**
-   * normally executed in `init` phase of module, which creates configuration to the module provider.
-   * cycles threw all registered configuration builders.
-   * await all registered hub configurations.
+   * Build the final {@link SignalRConfig} by executing all registered
+   * builder callbacks and collecting hub configurations.
+   *
+   * Normally called during the module `initialize` phase.
+   *
+   * @param init - Module initializer arguments providing access to resolved dependencies
+   * @returns Resolved configuration containing all registered hubs
    */
   public async createConfig(
     init: ModuleInitializerArgs<ISignalRConfigurator, [ServiceDiscoveryModule]>,