ocpp-ws-io 2.1.7 → 2.1.8

package/dist/{index-BRblF1XV.d.ts → types-BZXEmDQ1.d.ts}

@@ -2,7 +2,7 @@ import * as WebSocket from 'ws';
 import WebSocket__default, { WebSocket as WebSocket$1 } from 'ws';
 import * as node_https from 'node:https';
 import * as node_http from 'node:http';
-import { IncomingMessage } from 'node:http';
+import { Server, IncomingMessage } from 'node:http';
 import { EventEmitter } from 'node:events';
 import { Duplex } from 'node:stream';
 import { TLSSocket } from 'node:tls';
@@ -4431,6 +4431,100 @@ type OCPPResponseType<P extends keyof OCPPMethodMap, M extends string> = P exten
     response: infer R;
 } ? R : never : never : never;
 
+/**
+ * Compiled regex pattern for RegExp-based route fallback.
+ * Only used when a user registers a RegExp pattern (not string patterns).
+ * @internal
+ */
+interface CompiledRegexPattern {
+    regex: RegExp;
+    paramNames: string[];
+}
+declare const OCPPRouter_base: new () => TypedEventEmitter<ServerEvents>;
+/**
+ * OCPPRouter — An Express-like Connection dispatcher.
+ * Isolated handler for a specific set of matching URL route patterns.
+ *
+ * String patterns are matched via radix trie (O(k) lookup, managed by OCPPServer).
+ * RegExp patterns fall back to linear matching.
+ */
+declare class OCPPRouter extends OCPPRouter_base {
+    /** Raw registered patterns (strings and/or RegExp) for reference. */
+    patterns: Array<string | RegExp>;
+    /** Connection middlewares attached to this router. */
+    middlewares: ConnectionMiddleware[];
+    /** Auth callback for this route endpoint. */
+    authCallback: AuthCallback<unknown> | null;
+    /** Route-level CORS options. */
+    _routeCORS?: CORSOptions;
+    /** Route-level config overrides. */
+    _routeConfig?: RouterConfig;
+    /**
+     * Compiled RegExp patterns for fallback linear matching.
+     * Only populated when RegExp patterns are registered.
+     * @internal
+     */
+    _regexPatterns: CompiledRegexPattern[];
+    constructor(patterns?: Array<string | RegExp>, middlewares?: ConnectionMiddleware[]);
+    /**
+     * Appends URL paths or regular expressions to this router's match condition.
+     * String patterns are stored for trie insertion by OCPPServer.
+     * RegExp patterns are compiled for linear fallback matching.
+     */
+    route(...patterns: Array<string | RegExp>): this;
+    /**
+     * Appends connection middlewares to this router's execution chain.
+     */
+    use(...middlewares: ConnectionMiddleware[]): this;
+    /**
+     * Applies specific CORS rules to connections matching this router's paths.
+     */
+    cors(options: CORSOptions): this;
+    /**
+     * Overrides global connection settings (e.g. timeouts, protocols) for this router.
+     */
+    config(options: RouterConfig): this;
+    /**
+     * Registers an authentication and protocol-negotiation callback for this route endpoint.
+     */
+    auth<TSession = Record<string, unknown>>(callback: AuthCallback<TSession>): this;
+    /**
+     * Binds a version-specific OCPP message handler directly to all clients that match this route.
+     *
+     * @throws {Error} AT RUNTIME when a client connects, if a handler for this version and method is already registered for that client.
+     */
+    handle<V extends OCPPProtocol, M extends AllMethodNames<V>>(version: V, method: M, handler: (context: RouterHandlerContext<OCPPRequestType<V, M>>) => OCPPResponseType<V, M> | Promise<OCPPResponseType<V, M>>): this;
+    /**
+     * Binds a custom/extension message handler directly to all clients that match this route.
+     *
+     * @throws {Error} AT RUNTIME when a client connects, if a handler for this protocol and method is already registered for that client.
+     */
+    handle<S extends string>(version: S extends OCPPProtocol ? never : S, method: string, handler: (context: RouterHandlerContext<Record<string, any>>) => any): this;
+    /**
+     * Binds a message handler directly to all clients that match this route using the default protocol.
+     *
+     * @throws {Error} AT RUNTIME when a client connects, if a handler for this method is already registered for that client.
+     */
+    handle<M extends AllMethodNames<OCPPProtocol>>(method: M, handler: (context: RouterHandlerContext<OCPPRequestType<OCPPProtocol, M>>) => OCPPResponseType<OCPPProtocol, M> | Promise<OCPPResponseType<OCPPProtocol, M>>): this;
+    /**
+     * Binds a custom/extension method not in the typed map.
+     *
+     * @throws {Error} AT RUNTIME when a client connects, if a handler for this method is already registered for that client.
+     */
+    handle(method: string, handler: (context: RouterHandlerContext<Record<string, any>>) => any): this;
+    /**
+     * Binds a wildcard handler to all clients that match this route.
+     *
+     * @throws {Error} AT RUNTIME when a client connects, if a wildcard handler is already registered for that client.
+     */
+    handle(handler: RouterWildcardHandler): this;
+}
+/**
+ * Creates a standalone, modular `OCPPRouter` instance that can be attached
+ * to an `OCPPServer` later via `server.attachRouters()`.
+ */
+declare function createRouter(...patterns: Array<string | RegExp>): OCPPRouter;
+
 /**
  * Middleware handling for intercepting and modifying OCPP operations.
  *
@@ -4641,7 +4735,7 @@ declare class OCPPClient<P extends OCPPProtocol = OCPPProtocol> extends OCPPClie
     sendRaw(message: string): void;
     reconfigure(options: Partial<ClientOptions>): void;
     protected _attachWebsocket(ws: WebSocket__default): void;
-    private _onMessage;
+    protected _onMessage(rawData: WebSocket__default.RawData, preParsed?: unknown): void;
     private _handleIncomingCall;
     private _handleCallResult;
     private _handleCallError;
@@ -4686,6 +4780,43 @@ declare class OCPPClient<P extends OCPPProtocol = OCPPProtocol> extends OCPPClie
     private _cleanup;
 }
 
+interface WorkerPoolOptions {
+    /** Number of worker threads (default: Math.max(2, cpus - 2)) */
+    poolSize?: number;
+    /** Max pending parse jobs before rejecting (default: 10000) */
+    maxQueueSize?: number;
+}
+interface ParseResult {
+    message: unknown;
+    validationError?: {
+        schemaId: string;
+        errors: string;
+    };
+}
+declare class WorkerPool {
+    private _workers;
+    private _nextWorker;
+    private _taskId;
+    private _pending;
+    private _maxQueueSize;
+    private _terminated;
+    constructor(options?: WorkerPoolOptions);
+    /** Number of worker threads in the pool */
+    get size(): number;
+    /** Number of pending (unresolved) parse tasks */
+    get pendingTasks(): number;
+    /**
+     * Send raw data to a worker for JSON parsing + optional validation.
+     * Uses round-robin worker selection.
+     */
+    parse(data: Buffer | string, schemaInfo?: {
+        protocol: string;
+        schemas: Record<string, unknown>;
+    }): Promise<ParseResult>;
+    /** Gracefully terminate all workers */
+    shutdown(): Promise<void>;
+}
+
 /**
  * OCPPServerClient — A server-side client representation.
  *
@@ -4700,8 +4831,14 @@ declare class OCPPServerClient extends OCPPClient {
         handshake: HandshakeInfo;
         session: Record<string, any>;
         protocol?: string;
+        /** Optional adaptive rate multiplier getter (from OCPPServer.AdaptiveLimiter) */
+        adaptiveMultiplier?: () => number;
+        /** Optional worker pool for off-thread JSON parsing */
+        workerPool?: WorkerPool;
     });
     private _rateLimits;
+    private _adaptiveMultiplier;
+    private _workerPool;
     private _checkRateLimit;
     private _attachServerWebsocket;
     private _handleRateLimitExceeded;
@@ -4732,6 +4869,240 @@ declare class OCPPServerClient extends OCPPClient {
     }>;
 }
 
+declare const OCPPServer_base: new () => TypedEventEmitter<ServerEvents>;
+/**
+ * OCPPServer — A typed WebSocket RPC server for OCPP communication.
+ *
+ * Supports all 3 OCPP Security Profiles:
+ * - Profile 1: Basic Auth over unsecured WS
+ * - Profile 2: TLS + Basic Auth (HTTPS server)
+ * - Profile 3: Mutual TLS (HTTPS server with requestCert)
+ */
+declare class OCPPServer extends OCPPServer_base {
+    private _options;
+    /** Radix trie for O(k) route matching (string patterns). */
+    private _trie;
+    /** Global middleware routers (server.use() with no patterns — catch-all). */
+    private _globalMiddlewareRouters;
+    /** Routers with RegExp patterns (fallback linear scan). */
+    private _regexRouters;
+    private _clients;
+    private _clientsByIdentity;
+    private _httpServers;
+    private _wss;
+    private _state;
+    private _adapter;
+    private _httpServerAbortControllers;
+    private _logger;
+    private _globalCORS?;
+    private _connectionBuckets;
+    private _adaptiveLimiter;
+    private _plugins;
+    private _workerPool;
+    private readonly _nodeId;
+    private _sessions;
+    private _gcInterval;
+    private readonly _sessionTimeoutMs;
+    constructor(options?: ServerOptions);
+    get log(): LoggerLikeNotOptional;
+    /**
+     * Returns a readonly set of all currently connected OCPPServerClient instances.
+     */
+    get clients(): ReadonlySet<OCPPServerClient>;
+    /**
+     * Returns the current server state (OPEN, CLOSING, CLOSED).
+     */
+    get state(): "OPEN" | "CLOSING" | "CLOSED";
+    /**
+     * Returns current node observability statistics
+     * (e.g. connected socket count, tracked memory sessions, and process CPU/Memory usage).
+     * Fully compatible with Loki/Prometheus node metric ingestion.
+     */
+    stats(): OCPPServerStats;
+    /**
+     * Returns observability statistics from the active Event Adapter (e.g. Redis).
+     * Useful for tracking consumer backlog and enabling Horizontal Pod Autoscaling.
+     */
+    adapterMetrics(): Promise<Record<string, unknown> | null>;
+    /**
+     * Synchronously returns the OCPPServerClient instance if the specific identity
+     * is connected to THIS local server node.
+     * Note: In a clustered environment, clients connected to other nodes will NOT be returned here.
+     *
+     * @param identity The client identity (username/station ID)
+     */
+    getLocalClient(identity: string): OCPPServerClient | undefined;
+    /**
+     * Synchronously checks if the specific identity is connected to THIS local server node.
+     * Note: In a clustered environment, this will return false if the client is connected to another node.
+     *
+     * @param identity The client identity (username/station ID)
+     */
+    hasLocalClient(identity: string): boolean;
+    /**
+     * Asynchronously checks if the specific identity is connected to the server.
+     * In a single-node setup, this checks the local connections.
+     * In a clustered setup (with a pub/sub adapter), this will also check the global presence registry
+     * to see if the client is connected to ANY node in the cluster.
+     *
+     * @param identity The client identity (username/station ID)
+     */
+    isClientConnected(identity: string): Promise<boolean>;
+    /**
+     * Applies global CORS rules to all incoming connections before routing.
+     */
+    cors(options: CORSOptions): this;
+    /**
+     * Registers a new routing dispatcher for multiplexing connections.
+     * `server.route("/api/:tenant").use(middleware).auth(cb).on("client", ...)`
+     */
+    route(...patterns: Array<string | RegExp>): OCPPRouter;
+    /**
+     * Attaches one or more standalone modular routers created via `createRouter()`.
+     * This is useful for separating route definitions across different files.
+     */
+    attachRouters(...routers: OCPPRouter[]): this;
+    /**
+     * Registers one or more plugins for server lifecycle hooks.
+     * Plugins are called in registration order for all lifecycle events.
+     *
+     * @example Single plugin
+     * ```ts
+     * server.plugin(metricsPlugin);
+     * ```
+     *
+     * @example Multiple plugins
+     * ```ts
+     * server.plugin(metricsPlugin, loggingPlugin, otelPlugin);
+     * ```
+     */
+    plugin(...plugins: OCPPPlugin[]): this;
+    /**
+     * Registers middleware chain(s) as a wildcard/catch-all router.
+     *
+     * @example
+     * ```ts
+     * server.use(myMiddleware).route("/api").on("client", ...);
+     * ```
+     */
+    use(...middlewares: ConnectionMiddleware[]): OCPPRouter;
+    /**
+     * Registers a top-level auth handler, returning a router to attach `.on()` or `.use()`.
+     */
+    auth<TSession = Record<string, unknown>>(callback: AuthCallback<TSession>): OCPPRouter;
+    /**
+     * Routes a router into the appropriate internal structure:
+     * - String patterns → radix trie (O(k) lookup)
+     * - RegExp patterns → linear fallback array
+     * - No patterns → global middleware (catch-all)
+     * @internal
+     */
+    private _registerRouter;
+    listen(port?: number, host?: string, options?: ListenOptions): Promise<Server>;
+    /**
+     * Hot-reloads the TLS certificate on all active HTTPS servers without
+     * dropping any existing WebSocket connections.
+     *
+     * **When to use:** Call this whenever your TLS certificate is renewed —
+     * for example, after a Let's Encrypt auto-renewal (every ~90 days).
+     * Without this, you would need to restart the Node.js process to pick up
+     * the new certificate, disconnecting all connected charging stations.
+     *
+     * **How to use:**
+     * ```ts
+     * server.updateTLS({ cert: newCert, key: newKey });
+     * ```
+     *
+     * **Optional:** Only relevant if you are terminating TLS directly in Node.js
+     * (i.e. `SecurityProfile.TLS_BASIC_AUTH` or `TLS_CLIENT_CERT`). If you are
+     * running behind a reverse proxy (Nginx, AWS ALB, etc.) that handles TLS,
+     * you do not need this method — just rotate the cert on the proxy.
+     *
+     * @throws If the server is not using a TLS Security Profile.
+     */
+    updateTLS(tlsOpts: TLSOptions): void;
+    get handleUpgrade(): (req: IncomingMessage, socket: Duplex, head: Buffer) => Promise<void>;
+    /**
+     * Core upgrade handler. Follows a strict pipeline:
+     *
+     * 1. Validate socket readyState & upgrade header
+     * 2. Parse URL → identity + endpoint
+     * 3. Enable TCP Keep-Alive
+     * 4. Parse & negotiate subprotocols
+     * 5. Parse Basic Auth (via modular parseBasicAuth)
+     * 6. Extract TLS client certificate (Profile 3)
+     * 7. Build HandshakeInfo
+     * 8. Run auth callback with AbortController + handshake timeout
+     * 9. Complete WebSocket upgrade
+     * 10. Create OCPPServerClient
+     */
+    private _handleUpgrade;
+    private _updateSessionActivity;
+    close(options?: CloseOptions): Promise<void>;
+    reconfigure(options: Partial<ServerOptions>): void;
+    /**
+     * Send a request to a specific client (local or remote).
+     *
+     * 1. Checks local clients.
+     * 2. Checks Presence Registry -> Unicast.
+     * 3. Fallback: Broadcast.
+     */
+    /**
+     * Send a request to a specific client (local or remote).
+     *
+     * 1. Checks local clients.
+     * 2. Checks Presence Registry -> Unicast.
+     * 3. Fallback: Error (Client not found).
+     */
+    sendToClient<V extends OCPPProtocol, M extends AllMethodNames<V>>(identity: string, version: V, method: M, params: OCPPRequestType<V, M>, options?: CallOptions): Promise<OCPPResponseType<V, M> | undefined>;
+    sendToClient<M extends AllMethodNames<any>>(identity: string, method: M, params: OCPPRequestType<any, M>, options?: CallOptions): Promise<OCPPResponseType<any, M> | undefined>;
+    sendToClient<_T = any>(identity: string, method: string, params: Record<string, any>, options?: CallOptions): Promise<any | undefined>;
+    safeSendToClient<V extends OCPPProtocol, M extends AllMethodNames<V>>(identity: string, version: V, method: M, params: OCPPRequestType<V, M>, options?: CallOptions): Promise<OCPPResponseType<V, M> | undefined>;
+    safeSendToClient<M extends AllMethodNames<any>>(identity: string, method: M, params: OCPPRequestType<any, M>, options?: CallOptions): Promise<OCPPResponseType<any, M> | undefined>;
+    safeSendToClient<_T = any>(identity: string, method: string, params: Record<string, any>, options?: CallOptions): Promise<any | undefined>;
+    /**
+     * Pipeline multiple calls to a single client into a concurrent batch.
+     * Useful for reconnection warm-up (e.g. GetConfiguration, ChangeAvailability, etc.)
+     * where sequential calls would add unnecessary round-trip latency.
+     *
+     * @param identity The client identity to send calls to
+     * @param calls Array of { method, params, options? } to execute concurrently
+     * @returns Array of results in the same order as the calls array.
+     *          Each element is the call result, or `undefined` if that individual call failed.
+     *
+     * @example
+     * ```ts
+     * const results = await server.sendBatch('CP-101', [
+     *   { method: 'GetConfiguration', params: { key: ['MeterInterval'] } },
+     *   { method: 'ChangeAvailability', params: { type: 'Operative' } },
+     *   { method: 'TriggerMessage', params: { requestedMessage: 'StatusNotification' } },
+     * ]);
+     * ```
+     */
+    sendBatch(identity: string, calls: Array<{
+        method: string;
+        params: Record<string, unknown>;
+        options?: CallOptions;
+    }>): Promise<Array<unknown | undefined>>;
+    setAdapter(adapter: EventAdapterInterface): Promise<void>;
+    private _onBroadcast;
+    private _onUnicast;
+    publish(channel: string, data: unknown): Promise<void>;
+    broadcast<V extends AllMethodNames<any>>(method: V, params: OCPPRequestType<any, V>): Promise<void>;
+    /**
+     * Send a specific method & params to a list of specific clients efficiently.
+     * This leverages adapter pipelining (e.g. Redis .pipeline()) to minimize network overhead
+     * when communicating with thousands of nodes simultaneously.
+     *
+     * @param identities Array of target client identities
+     * @param method The OCPP method to send
+     * @param params The request parameters
+     * @param options Call options
+     */
+    broadcastBatch<V extends AllMethodNames<any>>(identities: string[], method: V, params: OCPPRequestType<any, V>, options?: CallOptions): Promise<void>;
+    private _buildCompressionConfig;
+}
+
 interface ValidatorSchema {
     $schema?: string;
     $id?: string;
@@ -5068,6 +5439,26 @@ interface ClientOptions {
      * Oldest messages are dropped when exceeded. (default: 100)
      */
     offlineQueueMaxSize?: number;
+    /**
+     * Enable WebSocket `permessage-deflate` compression.
+     * Reduces bandwidth by ~80% for JSON payloads at the cost of ~0.2ms CPU per message.
+     * - `true` → sensible defaults (threshold: 1024, level: 6)
+     * - `object` → fine-tuned configuration
+     * (default: false)
+     */
+    compression?: boolean | CompressionOptions;
+}
+interface CompressionOptions {
+    /** Minimum payload size in bytes to compress (default: 1024) */
+    threshold?: number;
+    /** zlib compression level 1 (fastest) to 9 (smallest) (default: 6) */
+    level?: number;
+    /** zlib memory level 1–9 (default: 8) */
+    memLevel?: number;
+    /** Server does not retain deflate context between messages (default: true — saves ~120KB/conn) */
+    serverNoContextTakeover?: boolean;
+    /** Client does not retain deflate context between messages (default: true) */
+    clientNoContextTakeover?: boolean;
 }
 interface RateLimitOptions {
     /** Maximum number of messages allowed within the window */
@@ -5090,6 +5481,27 @@ interface RateLimitOptions {
         limit: number;
         windowMs: number;
     }>;
+    /**
+     * Enable adaptive rate limiting based on CPU/memory pressure.
+     * When enabled, the token refill rate is automatically reduced under
+     * high load and restored after a cooldown period. (default: false)
+     */
+    adaptive?: boolean;
+    /**
+     * CPU usage percent threshold to begin throttling.
+     * Applies only when `adaptive` is true. (default: 80)
+     */
+    cpuThresholdPercent?: number;
+    /**
+     * Heap usage percent threshold to begin throttling.
+     * Applies only when `adaptive` is true. (default: 85)
+     */
+    memThresholdPercent?: number;
+    /**
+     * Time (ms) both CPU and memory must stay below their thresholds
+     * before restoring the original rate. (default: 5000)
+     */
+    cooldownMs?: number;
 }
 interface RouterConfig {
     /** Accepted OCPP subprotocols (e.g. ["ocpp1.6"]) */
@@ -5189,6 +5601,26 @@ interface ServerOptionsBase {
      * (default: 65536 / 64KB — sufficient for any standard OCPP message)
      */
     maxPayloadBytes?: number;
+    /**
+     * Enable worker thread pool for JSON parsing (+ optional AJV validation).
+     * Offloads CPU-heavy work to worker threads, keeping the main event loop free.
+     * Recommended for 10k+ concurrent connections. (default: false)
+     *
+     * - `true` → uses default pool size: `Math.max(2, os.cpus() - 2)`
+     * - `{ poolSize, maxQueueSize }` → fine-tuned pool configuration
+     */
+    workerThreads?: boolean | {
+        poolSize?: number;
+        maxQueueSize?: number;
+    };
+    /**
+     * Enable WebSocket `permessage-deflate` compression.
+     * Reduces bandwidth by ~80% for JSON payloads at the cost of ~0.2ms CPU per message.
+     * - `true` → sensible defaults (threshold: 1024, level: 6)
+     * - `object` → fine-tuned configuration
+     * (default: false)
+     */
+    compression?: boolean | CompressionOptions;
 }
 /** When strictMode is enabled, protocols MUST be specified */
 interface StrictServerOptions extends ServerOptionsBase {
@@ -5339,6 +5771,39 @@ interface EventAdapterInterface {
     }[]): Promise<void>;
     metrics?(): Promise<Record<string, unknown>>;
 }
+/**
+ * Plugin interface for extending OCPPServer functionality.
+ *
+ * Plugins provide a unified way to hook into server lifecycle events
+ * without modifying core internals. Useful for:
+ * - Observability (OpenTelemetry, Prometheus)
+ * - Custom adapters and integrations
+ * - Auditing and compliance
+ *
+ * @example
+ * ```ts
+ * const myPlugin: OCPPPlugin = {
+ *   name: 'my-plugin',
+ *   onInit(server) { console.log('Plugin initialized'); },
+ *   onConnection(client) { console.log(`${client.identity} connected`); },
+ *   onDisconnect(client) { console.log(`${client.identity} disconnected`); },
+ *   onClose() { console.log('Server shutting down'); },
+ * };
+ * server.plugin(myPlugin);
+ * ```
+ */
+interface OCPPPlugin {
+    /** Unique plugin name (used for logging and deduplication) */
+    name: string;
+    /** Called when the plugin is registered via server.plugin(plugin) */
+    onInit?(server: OCPPServer): void | Promise<void>;
+    /** Called for each new client connection after auth succeeds */
+    onConnection?(client: OCPPServerClient): void | Promise<void>;
+    /** Called when a client disconnects */
+    onDisconnect?(client: OCPPServerClient, code: number, reason: string): void;
+    /** Called during server.close() for plugin cleanup */
+    onClose?(): void | Promise<void>;
+}
 declare const NOREPLY: unique symbol;
 type MiddlewareContext = {
     type: "incoming_call";
@@ -5384,90 +5849,4 @@ interface AuthContext<TSession = Record<string, unknown>> extends BaseConnection
 }
 type ConnectionMiddleware = (ctx: ConnectionContext) => Promise<void> | void;
 
-interface RedisLikeClient {
-    publish(channel: string, message: string): Promise<number | unknown | undefined>;
-    subscribe(channel: string, ...args: unknown[]): Promise<unknown | undefined>;
-    unsubscribe(channel: string, ...args: unknown[]): Promise<unknown | undefined>;
-    on?(event: "message", callback: (channel: string, message: string) => void): unknown;
-    disconnect?(): Promise<void> | void;
-    quit?(): Promise<unknown> | undefined;
-    isOpen?: boolean;
-}
-
-interface RedisAdapterOptions {
-    /** Redis client for publishing */
-    pubClient: RedisLikeClient;
-    /** Redis client for subscribing (must be a separate connection) */
-    subClient: RedisLikeClient;
-    /** Redis client for blocking stream operations (recommended for reliability) */
-    blockingClient?: RedisLikeClient;
-    /** Optional key prefix for channels (default: 'ocpp-ws-io:') */
-    prefix?: string;
-    /** StreamMaxLen for trimming (default: 1000) */
-    streamMaxLen?: number;
-    /**
-     * TTL in seconds for ephemeral stream keys (default: 300).
-     * Prevents abandoned channel keys from leaking memory in Redis.
-     */
-    streamTtlSeconds?: number;
-    /**
-     * Presence TTL in seconds (default: 300).
-     * Used for batch presence heartbeat pipeline.
-     */
-    presenceTtlSeconds?: number;
-}
-/**
- * Redis adapter for cross-process event distribution.
- *
- * Supports `ioredis` and `node-redis` (v4+).
- * Uses Redis Streams for reliable unicast (node-to-node) and Pub/Sub for broadcast.
- */
-declare class RedisAdapter implements EventAdapterInterface {
-    private _driver;
-    private _prefix;
-    private _streamMaxLen;
-    private _streamTtlSeconds;
-    private _presenceTtlSeconds;
-    private _handlers;
-    private _streamOffsets;
-    private _streams;
-    private _polling;
-    private _closed;
-    private _sequenceCounters;
-    private _unsubError?;
-    private _unsubReconnect?;
-    private _presenceCache;
-    constructor(options: RedisAdapterOptions);
-    publish(channel: string, data: unknown): Promise<void>;
-    publishBatch(messages: {
-        channel: string;
-        data: unknown;
-    }[]): Promise<void>;
-    subscribe(channel: string, handler: (data: unknown) => void): Promise<void>;
-    unsubscribe(channel: string): Promise<void>;
-    disconnect(): Promise<void>;
-    private _handleMessage;
-    private _ensurePolling;
-    private _pollLoop;
-    setPresence(identity: string, nodeId: string, ttl: number): Promise<void>;
-    getPresence(identity: string): Promise<string | null>;
-    getPresenceBatch(identities: string[]): Promise<(string | null)[]>;
-    removePresence(identity: string): Promise<void>;
-    metrics(): Promise<Record<string, unknown>>;
-    /**
-     * Set multiple presence entries in a single Redis pipeline.
-     * Reduces N network round-trips to 1 for bulk presence updates.
-     */
-    setPresenceBatch(entries: {
-        identity: string;
-        nodeId: string;
-        ttl?: number;
-    }[]): Promise<void>;
-    /**
-     * Re-syncs all cached presence entries to Redis after a reconnection.
-     * Called automatically when the Redis client reconnects.
-     */
-    private _rehydratePresence;
-}
-
-export { createValidator as $, type AuthCallback as A, MiddlewareStack as B, type ConnectionMiddleware as C, type OCPP16Methods as D, type EventAdapterInterface as E, type OCPP201Methods as F, type OCPP21Methods as G, type HandlerContext as H, type OCPPCall as I, type OCPPCallError as J, type OCPPCallResult as K, type LoggerLike as L, type MiddlewareFunction as M, NOREPLY as N, type OCPPProtocol as O, OCPPClient as P, type OCPPMessage as Q, type RouterConfig as R, type ServerEvents as S, type TypedEventEmitter as T, type OCPPMethodMap as U, Validator as V, type OCPPProtocolKey as W, RedisAdapter as X, SecurityProfile as Y, type SessionData as Z, type WildcardHandler as _, type LoggingConfig as a, type RedisAdapterOptions as a0, type MiddlewareContext as b, type CORSOptions as c, type AllMethodNames as d, type RouterHandlerContext as e, type OCPPRequestType as f, type OCPPResponseType as g, type RouterWildcardHandler as h, type ServerOptions as i, type LoggerLikeNotOptional as j, OCPPServerClient as k, type OCPPServerStats as l, type ListenOptions as m, type TLSOptions as n, type CloseOptions as o, type CallOptions as p, type AnyOCPPProtocol as q, type AuthAccept as r, type CallHandler as s, type ClientEvents as t, type ClientOptions as u, type ConnectionContext as v, ConnectionState as w, type HandshakeInfo as x, MessageType as y, type MiddlewareNext as z };
+export { createRouter as $, type AuthCallback as A, type OCPPMessage as B, type ConnectionMiddleware as C, type OCPPMethodMap as D, type EventAdapterInterface as E, type OCPPProtocol as F, type OCPPProtocolKey as G, type HandlerContext as H, type OCPPRequestType as I, type OCPPResponseType as J, OCPPRouter as K, type LoggerLike as L, type MiddlewareFunction as M, NOREPLY as N, type OCPPPlugin as O, OCPPServer as P, OCPPServerClient as Q, type RateLimitOptions as R, type RouterConfig as S, SecurityProfile as T, type ServerEvents as U, Validator as V, type ServerOptions as W, type SessionData as X, type TLSOptions as Y, type TypedEventEmitter as Z, type WildcardHandler as _, type LoggingConfig as a, createValidator as a0, type MiddlewareContext as b, type AllMethodNames as c, type AnyOCPPProtocol as d, type AuthAccept as e, type CORSOptions as f, type CallHandler as g, type CallOptions as h, type ClientEvents as i, type ClientOptions as j, type CloseOptions as k, type CompressionOptions as l, type ConnectionContext as m, ConnectionState as n, type HandshakeInfo as o, type ListenOptions as p, MessageType as q, type MiddlewareNext as r, MiddlewareStack as s, type OCPP16Methods as t, type OCPP201Methods as u, type OCPP21Methods as v, type OCPPCall as w, type OCPPCallError as x, type OCPPCallResult as y, OCPPClient as z };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ocpp-ws-io",
-  "version": "2.1.7",
+  "version": "2.1.8",
   "description": "Type-safe OCPP 1.6 & 2.0.1 WebSocket RPC client & server. Build EV charging CSMS platforms with Redis clustering, strict validation, and DDoS protection.",
   "repository": {
     "type": "git",
@@ -29,6 +29,11 @@
       "types": "./dist/logger.d.ts",
       "import": "./dist/logger.mjs",
       "require": "./dist/logger.js"
+    },
+    "./plugins": {
+      "types": "./dist/plugins.d.ts",
+      "import": "./dist/plugins.mjs",
+      "require": "./dist/plugins.js"
     }
   },
   "scripts": {
@@ -79,8 +84,7 @@
     "url": "https://github.com/rohittiwari-dev/ocpp-ws-io/issues"
   },
   "files": [
-    "dist",
-    "assets"
+    "dist"
   ],
   "license": "MIT",
   "dependencies": {