ocpp-ws-io 1.0.0-alpha → 1.0.0

package/.github/workflows/publish.yml

@@ -46,6 +46,11 @@ jobs:
           fi
           echo "Publishing $VERSION with tag: $(cat $GITHUB_OUTPUT | grep tag | cut -d= -f2)"
 
+      - name: Sync version from git tag to package.json
+        run: |
+          VERSION="${GITHUB_REF#refs/tags/v}"
+          npm version "$VERSION" --no-git-tag-version --allow-same-version
+
       - name: Publish to npm
         run: npm publish --provenance --access public --tag ${{ steps.dist-tag.outputs.tag }}
         env:

package/README.md

@@ -12,7 +12,8 @@ Built with TypeScript from the ground up — supports OCPP 1.6, 2.0.1, and 2.1 w
 - 🔁 **Auto-Reconnect** — Exponential backoff with configurable limits
 - 🧩 **Framework Agnostic** — Use standalone, or attach to Express, Fastify, NestJS, etc.
 - 📡 **Clustering** — Optional Redis adapter for multi-instance deployments
-- 🎯 **Type-Safe** — Full TypeScript types for events, handlers, options, and messages
+- 🎯 **Type-Safe** — Auto-generated types for all OCPP 1.6, 2.0.1 & 2.1 methods with full request/response inference
+- 🔀 **Version-Aware Handlers** — Register handlers per OCPP version with typed params, or use generic handlers with protocol context
 
 ## Installation
 
@@ -34,21 +35,21 @@ const client = new OCPPClient({
   securityProfile: SecurityProfile.NONE,
 });
 
-// Register a handler for incoming calls from the server
-client.handle("Reset", ({ params }) => {
-  console.log("Reset requested:", params);
+// Register a handler — params are auto-typed for OCPP 1.6 Reset
+client.handle("Reset", ({ params, protocol }) => {
+  console.log(`Reset requested (${protocol}):`, params.type);
   return { status: "Accepted" };
 });
 
-// Connect and send a BootNotification
+// Connect and send a BootNotification — version-aware, fully typed
 await client.connect();
 
-const response = await client.call("BootNotification", {
+const response = await client.call("ocpp1.6", "BootNotification", {
   chargePointVendor: "VendorX",
   chargePointModel: "ModelY",
 });
 
-console.log("BootNotification response:", response);
+console.log("Status:", response.status); // typed: "Accepted" | "Pending" | "Rejected"
 ```
 
 ### Server (Central System)
@@ -77,9 +78,9 @@ server.auth((accept, reject, handshake) => {
 server.on("client", (client) => {
   console.log(`${client.identity} connected (protocol: ${client.protocol})`);
 
-  // Handle BootNotification from this client
-  client.handle("BootNotification", ({ params }) => {
-    console.log("BootNotification:", params);
+  // Version-aware handlers — params typed per OCPP version
+  client.handle("ocpp1.6", "BootNotification", ({ params }) => {
+    console.log("OCPP 1.6 Boot:", params.chargePointVendor);
     return {
       status: "Accepted",
       currentTime: new Date().toISOString(),
@@ -87,11 +88,20 @@ server.on("client", (client) => {
     };
   });
 
-  // Send a call TO the client
-  client
-    .call("GetConfiguration", { key: ["HeartbeatInterval"] })
-    .then((result) => console.log("GetConfiguration result:", result))
-    .catch((err) => console.error("GetConfiguration failed:", err));
+  client.handle("ocpp2.0.1", "BootNotification", ({ params }) => {
+    console.log("OCPP 2.0.1 Boot:", params.chargingStation.vendorName);
+    return {
+      status: "Accepted",
+      currentTime: new Date().toISOString(),
+      interval: 300,
+    };
+  });
+
+  // Version-aware call from server to client
+  const config = await client.call("ocpp1.6", "GetConfiguration", {
+    key: ["HeartbeatInterval"],
+  });
+  console.log("Config:", config.configurationKey);
 
   client.on("close", () => {
     console.log(`${client.identity} disconnected`);
@@ -289,6 +299,122 @@ httpServer.listen(3000);
 
 ---
 
+## Type-Safe API
+
+`ocpp-ws-io` includes auto-generated TypeScript types for **all** OCPP methods across 1.6, 2.0.1, and 2.1. When you call `handle()` or `call()` with a known method name, both request params and response types are inferred automatically. Custom/vendor-specific methods are also supported — they use `Record<string, any>` params.
+
+### Version-Aware `handle()` and `call()`
+
+Both `handle()` and `call()` support **version-specific overloads** — params and response types are inferred from the OCPP version you specify:
+
+```typescript
+// ✅ Version-aware handle — params typed per version
+client.handle("ocpp1.6", "BootNotification", ({ params }) => {
+  params.chargePointVendor; // ✅ string (OCPP 1.6 shape)
+  return { status: "Accepted", currentTime: "...", interval: 300 };
+});
+
+client.handle("ocpp2.0.1", "BootNotification", ({ params }) => {
+  params.chargingStation; // ✅ { model, vendorName } (OCPP 2.0.1 shape)
+  return { status: "Accepted", currentTime: "...", interval: 300 };
+});
+
+// ✅ Version-aware call — params and response typed per version
+const res16 = await client.call("ocpp1.6", "BootNotification", {
+  chargePointVendor: "VendorX",
+  chargePointModel: "ModelY",
+});
+res16.status; // typed: "Accepted" | "Pending" | "Rejected"
+
+const res201 = await client.call("ocpp2.0.1", "BootNotification", {
+  chargingStation: { model: "ModelX", vendorName: "VendorY" },
+  reason: "PowerUp",
+});
+res201.status; // typed for 2.0.1
+```
+
+### Default Protocol and Untyped Calls
+
+```typescript
+// Default protocol — uses the client's type parameter P
+const res = await client.call("BootNotification", {
+  chargePointVendor: "VendorX",
+  chargePointModel: "ModelY",
+});
+
+// Custom/extension methods — loose typing
+client.handle("VendorCustomAction", ({ params }) => {
+  params; // Record<string, any>
+  return { result: "ok" };
+});
+
+const custom = await client.call<{ result: string }>("VendorCustomAction", {
+  data: "hello",
+});
+custom.result; // string
+```
+
+````
+
+**Dispatch priority**: When a call arrives, the runtime looks up handlers in this order:
+
+1. **Version-specific** handler (e.g., `"ocpp1.6:BootNotification"`)
+2. **Generic** handler (e.g., `"BootNotification"`)
+3. **Wildcard** handler
+
+### Handler Context
+
+Every handler receives a `HandlerContext` with:
+
+```typescript
+client.handle("Reset", ({ params, protocol, method, messageId, signal }) => {
+  params; // typed request body
+  protocol; // "ocpp1.6" | "ocpp2.0.1" | "ocpp2.1" | undefined
+  method; // "Reset"
+  messageId; // unique call ID
+  signal; // AbortSignal
+  return { status: "Accepted" };
+});
+````
+
+### `removeHandler` with Version Support
+
+```typescript
+// Remove a generic handler
+client.removeHandler("Reset");
+
+// Remove a version-specific handler
+client.removeHandler("ocpp1.6", "Reset");
+
+// Remove wildcard handler
+client.removeHandler();
+
+// Remove all handlers
+client.removeAllHandlers();
+```
+
+### Available Generated Type Utilities
+
+```typescript
+import type {
+  OCPPProtocol, // "ocpp1.6" | "ocpp2.0.1" | "ocpp2.1"
+  AllMethodNames, // All method names for a given protocol
+  OCPPRequestType, // Request type for a method, e.g. OCPPRequestType<"ocpp1.6", "Reset">
+  OCPPResponseType, // Response type for a method
+  OCPPMethodMap, // Full method map for a protocol
+} from "ocpp-ws-io";
+
+// Example: Get all method names for OCPP 1.6
+type OCPP16Methods = AllMethodNames<"ocpp1.6">;
+// "Authorize" | "BootNotification" | "ChangeAvailability" | ...
+
+// Example: Get request params type
+type BootReq = OCPPRequestType<"ocpp1.6", "BootNotification">;
+// { chargePointVendor: string; chargePointModel: string; ... }
+```
+
+---
+
 ## Strict Mode (Schema Validation)
 
 Enable strict mode to validate all inbound and outbound messages against the OCPP JSON schemas:
@@ -429,18 +555,45 @@ const client = new OCPPClient(options: ClientOptions);
 // Connect to the OCPP server
 await client.connect();
 
-// Make an RPC call
-const result = await client.call('BootNotification', { ... });
+// Version-aware call — fully typed params and response
+const result = await client.call("ocpp1.6", "BootNotification", {
+  chargePointVendor: "VendorX",
+  chargePointModel: "ModelY",
+});
+
+// OCPP 2.0.1 — different shape, still fully typed
+const result201 = await client.call("ocpp2.0.1", "BootNotification", {
+  chargingStation: { model: "ModelX", vendorName: "VendorY" },
+  reason: "PowerUp",
+});
+
+// Default protocol call (uses the client's type parameter P)
+const res = await client.call("Heartbeat", {});
+
+// Explicit response type (for custom/vendor methods)
+const custom = await client.call<{ result: string }>("VendorAction", {
+  data: "hello",
+});
 
-// Make a call with options
-const result = await client.call('RemoteStartTransaction', params, {
+// Call with options
+const res2 = await client.call("ocpp1.6", "RemoteStartTransaction", params, {
   timeoutMs: 5000,
-  signal: abortController.signal,
 });
 
-// Register a handler for a specific method
-client.handle('Reset', ({ params, method, messageId, signal }) => {
-  return { status: 'Accepted' };
+// Register a typed handler for a specific method
+client.handle("Reset", ({ params, protocol, method, messageId, signal }) => {
+  return { status: "Accepted" };
+});
+
+// Register a version-specific handler
+client.handle("ocpp1.6", "BootNotification", ({ params }) => {
+  params.chargePointVendor; // typed for OCPP 1.6 only
+  return { status: "Accepted", currentTime: "...", interval: 300 };
+});
+
+// Register a handler for a custom/vendor method
+client.handle("VendorCustomAction", ({ params }) => {
+  return { result: "ok" };
 });
 
 // Register a wildcard handler (handles all unmatched methods)
@@ -449,21 +602,23 @@ client.handle((method, { params }) => {
   throw new RPCNotImplementedError();
 });
 
-// Remove a handler
-client.removeHandler('Reset');
-client.removeAllHandlers();
+// Remove handlers
+client.removeHandler("Reset"); // remove generic
+client.removeHandler("ocpp1.6", "Reset"); // remove version-specific
+client.removeHandler(); // remove wildcard
+client.removeAllHandlers(); // remove all
 
 // Close the connection
 await client.close();
-await client.close({ code: 1000, reason: 'Normal closure' });
+await client.close({ code: 1000, reason: "Normal closure" });
 await client.close({ awaitPending: true }); // wait for in-flight calls
-await client.close({ force: true });        // immediate termination
+await client.close({ force: true }); // immediate termination
 
 // Reconfigure at runtime
 client.reconfigure({ callTimeoutMs: 10000 });
 
 // Send a raw message (advanced — use with caution)
-client.sendRaw(JSON.stringify([2, 'uuid', 'Heartbeat', {}]));
+client.sendRaw(JSON.stringify([2, "uuid", "Heartbeat", {}]));
 ```
 
 #### Events
@@ -604,9 +759,11 @@ server.on("client", (client) => {
   client.session; // Record<string, unknown> — session data from auth
   client.handshake; // HandshakeInfo — connection handshake details
 
-  // All OCPPClient methods available:
-  client.handle("Heartbeat", () => ({ currentTime: new Date().toISOString() }));
-  const result = await client.call("GetConfiguration", { key: [] });
+  // All OCPPClient methods available — version-aware:
+  client.handle("ocpp1.6", "Heartbeat", () => ({
+    currentTime: new Date().toISOString(),
+  }));
+  const result = await client.call("ocpp1.6", "GetConfiguration", { key: [] });
   await client.close();
 });
 ```
@@ -727,6 +884,13 @@ All types are exported for use in your application:
 
 ```typescript
 import type {
+  // OCPP protocol types (auto-generated)
+  OCPPProtocol, // "ocpp1.6" | "ocpp2.0.1" | "ocpp2.1"
+  AllMethodNames, // Union of method names for a protocol
+  OCPPRequestType, // Request type for a method + protocol
+  OCPPResponseType, // Response type for a method + protocol
+  OCPPMethodMap, // Full method map for a protocol
+
   // OCPP message types
   OCPPCall,
   OCPPCallResult,
@@ -755,6 +919,10 @@ import type {
   // Event types
   ClientEvents,
   ServerEvents,
+  TypedEventEmitter,
+
+  // Server client interface
+  ServerClientInstance,
 
   // Adapter interface (for custom adapters)
   EventAdapterInterface,
@@ -768,6 +936,10 @@ import type {
 - **Node.js** ≥ 18.0.0
 - **TypeScript** ≥ 5.0 (optional, but recommended)
 
+## Inspired By
+
+This project is inspired by [ocpp-rpc](https://github.com/mikuso/ocpp-rpc) — a well-crafted OCPP-J RPC library for Node.js. `ocpp-ws-io` builds on similar ideas while adding full TypeScript type safety, version-aware APIs, built-in schema validation, and clustering support.
+
 ## License
 
 [MIT](LICENSE)

package/dist/adapters/redis.d.mts

@@ -1,8 +1,9 @@
-import { E as EventAdapterInterface } from '../types-6LVUoXof.mjs';
+import { E as EventAdapterInterface } from '../types-CpxyZ6AL.mjs';
 import 'node:https';
 import 'node:http';
 import 'node:tls';
 import 'node:stream';
+import 'node:events';
 import 'ajv';
 
 /**

package/dist/adapters/redis.d.ts

@@ -1,8 +1,9 @@
-import { E as EventAdapterInterface } from '../types-6LVUoXof.js';
+import { E as EventAdapterInterface } from '../types-CpxyZ6AL.js';
 import 'node:https';
 import 'node:http';
 import 'node:tls';
 import 'node:stream';
+import 'node:events';
 import 'ajv';
 
 /**

package/dist/index.d.mts

@@ -1,14 +1,15 @@
 import * as node_http from 'node:http';
 import { Server, IncomingMessage } from 'node:http';
-import { EventEmitter } from 'node:events';
 import WebSocket, { WebSocket as WebSocket$1 } from 'ws';
-import { C as ClientOptions, a as ConnectionState, S as SecurityProfile, b as CloseOptions, W as WildcardHandler, c as CallHandler, d as CallOptions, H as HandshakeInfo, e as ServerOptions, A as AuthCallback, L as ListenOptions, E as EventAdapterInterface, V as Validator } from './types-6LVUoXof.mjs';
-export { f as AuthAccept, g as ClientEvents, h as HandlerContext, M as MessageType, N as NOREPLY, O as OCPPCall, i as OCPPCallError, j as OCPPCallResult, k as OCPPMessage, l as OCPPProtocol, m as ServerEvents, n as SessionData, T as TLSOptions, o as createValidator } from './types-6LVUoXof.mjs';
+import { O as OCPPProtocol, T as TypedEventEmitter, C as ClientEvents, a as ClientOptions, b as ConnectionState, S as SecurityProfile, c as CloseOptions, A as AllMethodNames, H as HandlerContext, d as OCPPRequestType, e as OCPPResponseType, W as WildcardHandler, f as CallOptions, g as HandshakeInfo, h as ServerEvents, i as ServerOptions, j as AuthCallback, L as ListenOptions, E as EventAdapterInterface, V as Validator } from './types-CpxyZ6AL.mjs';
+export { k as AuthAccept, l as CallHandler, M as MessageType, N as NOREPLY, m as OCPP16Methods, n as OCPP201Methods, o as OCPP21Methods, p as OCPPCall, q as OCPPCallError, r as OCPPCallResult, s as OCPPMessage, t as OCPPMethodMap, u as SessionData, v as TLSOptions, w as createValidator } from './types-CpxyZ6AL.mjs';
 import { Duplex } from 'node:stream';
 import 'node:https';
 import 'node:tls';
+import 'node:events';
 import 'ajv';
 
+declare const OCPPClient_base: new () => TypedEventEmitter<ClientEvents>;
 /**
  * OCPPClient — A typed WebSocket RPC client for OCPP communication.
  *
@@ -17,7 +18,7 @@ import 'ajv';
  * - Profile 2: TLS + Basic Auth
  * - Profile 3: Mutual TLS (client certificates)
  */
-declare class OCPPClient extends EventEmitter {
+declare class OCPPClient<P extends OCPPProtocol = OCPPProtocol> extends OCPPClient_base {
     static readonly CONNECTING: 0;
     static readonly OPEN: 1;
     static readonly CLOSING: 2;
@@ -55,10 +56,32 @@ declare class OCPPClient extends EventEmitter {
         reason: string;
     }>;
     private _closeInternal;
-    handle<TParams = unknown, TResult = unknown>(methodOrHandler: string | WildcardHandler, handler?: CallHandler<TParams, TResult>): void;
+    /**
+     * Register a version-specific handler — `handle("ocpp1.6", "BootNotification", handler)`.
+     * This handler is only invoked when the active protocol matches the given version.
+     */
+    handle<V extends OCPPProtocol, M extends AllMethodNames<V>>(version: V, method: M, handler: (context: HandlerContext<OCPPRequestType<V, M>>) => OCPPResponseType<V, M> | Promise<OCPPResponseType<V, M>>): void;
+    /**
+     * Register a handler for the client's default protocol — `handle("BootNotification", handler)`.
+     * Uses the default protocol type parameter `P`.
+     */
+    handle<M extends AllMethodNames<P>>(method: M, handler: (context: HandlerContext<OCPPRequestType<P, M>>) => OCPPResponseType<P, M> | Promise<OCPPResponseType<P, M>>): void;
+    /** Register a handler for a custom/extension method not in the typed OCPP method maps. */
+    handle(method: string, handler: (context: HandlerContext<Record<string, any>>) => any): void;
+    /** Register a wildcard handler for all unhandled methods. */
+    handle(handler: WildcardHandler): void;
     removeHandler(method?: string): void;
+    removeHandler(version: OCPPProtocol, method: string): void;
     removeAllHandlers(): void;
-    call<TResult = unknown>(method: string, params?: unknown, options?: CallOptions): Promise<TResult>;
+    /**
+     * Call a version-specific typed method — `call("ocpp1.6", "BootNotification", {...})`.
+     * Provides full type inference for params and response based on the OCPP version.
+     */
+    call<V extends OCPPProtocol, M extends AllMethodNames<V>>(version: V, method: M, params: OCPPRequestType<V, M>, options?: CallOptions): Promise<OCPPResponseType<V, M>>;
+    /** Call a known typed method using the client's default protocol. */
+    call<M extends AllMethodNames<P>>(method: M, params: OCPPRequestType<P, M>, options?: CallOptions): Promise<OCPPResponseType<P, M>>;
+    /** Call a known typed method with explicit response type. */
+    call<TResult = unknown>(method: string, params?: Record<string, unknown>, options?: CallOptions): Promise<TResult>;
     private _sendCall;
     /**
      * Send a raw string message over the WebSocket (use with caution).
@@ -98,6 +121,7 @@ declare class OCPPServerClient extends OCPPClient {
         ws: WebSocket$1;
         handshake: HandshakeInfo;
         session: Record<string, unknown>;
+        protocol?: string;
     });
     /**
      * Session data associated with this client connection.
@@ -114,6 +138,7 @@ declare class OCPPServerClient extends OCPPClient {
     connect(): Promise<never>;
 }
 
+declare const OCPPServer_base: new () => TypedEventEmitter<ServerEvents>;
 /**
  * OCPPServer — A typed WebSocket RPC server for OCPP communication.
  *
@@ -122,7 +147,7 @@ declare class OCPPServerClient extends OCPPClient {
  * - Profile 2: TLS + Basic Auth (HTTPS server)
  * - Profile 3: Mutual TLS (HTTPS server with requestCert)
  */
-declare class OCPPServer extends EventEmitter {
+declare class OCPPServer extends OCPPServer_base {
     private _options;
     private _authCallback;
     private _clients;
@@ -265,4 +290,4 @@ declare class InMemoryAdapter implements EventAdapterInterface {
     disconnect(): Promise<void>;
 }
 
-export { AuthCallback, CallHandler, CallOptions, ClientOptions, CloseOptions, ConnectionState, EventAdapterInterface, HandshakeInfo, InMemoryAdapter, ListenOptions, OCPPClient, OCPPServer, OCPPServerClient, type RPCError, RPCFormatViolationError, RPCFormationViolationError, RPCFrameworkError, RPCGenericError, RPCInternalError, RPCMessageTypeNotSupportedError, RPCNotImplementedError, RPCNotSupportedError, RPCOccurrenceConstraintViolationError, RPCPropertyConstraintViolationError, RPCProtocolError, RPCSecurityError, RPCTypeConstraintViolationError, SecurityProfile, ServerOptions, TimeoutError, UnexpectedHttpResponse, Validator, WebsocketUpgradeError, WildcardHandler, createRPCError, getErrorPlainObject, getPackageIdent, standardValidators };
+export { AllMethodNames, AuthCallback, CallOptions, ClientEvents, ClientOptions, CloseOptions, ConnectionState, EventAdapterInterface, HandlerContext, HandshakeInfo, InMemoryAdapter, ListenOptions, OCPPClient, OCPPProtocol, OCPPRequestType, OCPPResponseType, OCPPServer, OCPPServerClient, type RPCError, RPCFormatViolationError, RPCFormationViolationError, RPCFrameworkError, RPCGenericError, RPCInternalError, RPCMessageTypeNotSupportedError, RPCNotImplementedError, RPCNotSupportedError, RPCOccurrenceConstraintViolationError, RPCPropertyConstraintViolationError, RPCProtocolError, RPCSecurityError, RPCTypeConstraintViolationError, SecurityProfile, ServerEvents, ServerOptions, TimeoutError, TypedEventEmitter, UnexpectedHttpResponse, Validator, WebsocketUpgradeError, WildcardHandler, createRPCError, getErrorPlainObject, getPackageIdent, standardValidators };

package/dist/index.d.ts

@@ -1,14 +1,15 @@
 import * as node_http from 'node:http';
 import { Server, IncomingMessage } from 'node:http';
-import { EventEmitter } from 'node:events';
 import WebSocket, { WebSocket as WebSocket$1 } from 'ws';
-import { C as ClientOptions, a as ConnectionState, S as SecurityProfile, b as CloseOptions, W as WildcardHandler, c as CallHandler, d as CallOptions, H as HandshakeInfo, e as ServerOptions, A as AuthCallback, L as ListenOptions, E as EventAdapterInterface, V as Validator } from './types-6LVUoXof.js';
-export { f as AuthAccept, g as ClientEvents, h as HandlerContext, M as MessageType, N as NOREPLY, O as OCPPCall, i as OCPPCallError, j as OCPPCallResult, k as OCPPMessage, l as OCPPProtocol, m as ServerEvents, n as SessionData, T as TLSOptions, o as createValidator } from './types-6LVUoXof.js';
+import { O as OCPPProtocol, T as TypedEventEmitter, C as ClientEvents, a as ClientOptions, b as ConnectionState, S as SecurityProfile, c as CloseOptions, A as AllMethodNames, H as HandlerContext, d as OCPPRequestType, e as OCPPResponseType, W as WildcardHandler, f as CallOptions, g as HandshakeInfo, h as ServerEvents, i as ServerOptions, j as AuthCallback, L as ListenOptions, E as EventAdapterInterface, V as Validator } from './types-CpxyZ6AL.js';
+export { k as AuthAccept, l as CallHandler, M as MessageType, N as NOREPLY, m as OCPP16Methods, n as OCPP201Methods, o as OCPP21Methods, p as OCPPCall, q as OCPPCallError, r as OCPPCallResult, s as OCPPMessage, t as OCPPMethodMap, u as SessionData, v as TLSOptions, w as createValidator } from './types-CpxyZ6AL.js';
 import { Duplex } from 'node:stream';
 import 'node:https';
 import 'node:tls';
+import 'node:events';
 import 'ajv';
 
+declare const OCPPClient_base: new () => TypedEventEmitter<ClientEvents>;
 /**
  * OCPPClient — A typed WebSocket RPC client for OCPP communication.
  *
@@ -17,7 +18,7 @@ import 'ajv';
  * - Profile 2: TLS + Basic Auth
  * - Profile 3: Mutual TLS (client certificates)
  */
-declare class OCPPClient extends EventEmitter {
+declare class OCPPClient<P extends OCPPProtocol = OCPPProtocol> extends OCPPClient_base {
     static readonly CONNECTING: 0;
     static readonly OPEN: 1;
     static readonly CLOSING: 2;
@@ -55,10 +56,32 @@ declare class OCPPClient extends EventEmitter {
         reason: string;
     }>;
     private _closeInternal;
-    handle<TParams = unknown, TResult = unknown>(methodOrHandler: string | WildcardHandler, handler?: CallHandler<TParams, TResult>): void;
+    /**
+     * Register a version-specific handler — `handle("ocpp1.6", "BootNotification", handler)`.
+     * This handler is only invoked when the active protocol matches the given version.
+     */
+    handle<V extends OCPPProtocol, M extends AllMethodNames<V>>(version: V, method: M, handler: (context: HandlerContext<OCPPRequestType<V, M>>) => OCPPResponseType<V, M> | Promise<OCPPResponseType<V, M>>): void;
+    /**
+     * Register a handler for the client's default protocol — `handle("BootNotification", handler)`.
+     * Uses the default protocol type parameter `P`.
+     */
+    handle<M extends AllMethodNames<P>>(method: M, handler: (context: HandlerContext<OCPPRequestType<P, M>>) => OCPPResponseType<P, M> | Promise<OCPPResponseType<P, M>>): void;
+    /** Register a handler for a custom/extension method not in the typed OCPP method maps. */
+    handle(method: string, handler: (context: HandlerContext<Record<string, any>>) => any): void;
+    /** Register a wildcard handler for all unhandled methods. */
+    handle(handler: WildcardHandler): void;
     removeHandler(method?: string): void;
+    removeHandler(version: OCPPProtocol, method: string): void;
     removeAllHandlers(): void;
-    call<TResult = unknown>(method: string, params?: unknown, options?: CallOptions): Promise<TResult>;
+    /**
+     * Call a version-specific typed method — `call("ocpp1.6", "BootNotification", {...})`.
+     * Provides full type inference for params and response based on the OCPP version.
+     */
+    call<V extends OCPPProtocol, M extends AllMethodNames<V>>(version: V, method: M, params: OCPPRequestType<V, M>, options?: CallOptions): Promise<OCPPResponseType<V, M>>;
+    /** Call a known typed method using the client's default protocol. */
+    call<M extends AllMethodNames<P>>(method: M, params: OCPPRequestType<P, M>, options?: CallOptions): Promise<OCPPResponseType<P, M>>;
+    /** Call a known typed method with explicit response type. */
+    call<TResult = unknown>(method: string, params?: Record<string, unknown>, options?: CallOptions): Promise<TResult>;
     private _sendCall;
     /**
      * Send a raw string message over the WebSocket (use with caution).
@@ -98,6 +121,7 @@ declare class OCPPServerClient extends OCPPClient {
         ws: WebSocket$1;
         handshake: HandshakeInfo;
         session: Record<string, unknown>;
+        protocol?: string;
     });
     /**
      * Session data associated with this client connection.
@@ -114,6 +138,7 @@ declare class OCPPServerClient extends OCPPClient {
     connect(): Promise<never>;
 }
 
+declare const OCPPServer_base: new () => TypedEventEmitter<ServerEvents>;
 /**
  * OCPPServer — A typed WebSocket RPC server for OCPP communication.
  *
@@ -122,7 +147,7 @@ declare class OCPPServerClient extends OCPPClient {
  * - Profile 2: TLS + Basic Auth (HTTPS server)
  * - Profile 3: Mutual TLS (HTTPS server with requestCert)
  */
-declare class OCPPServer extends EventEmitter {
+declare class OCPPServer extends OCPPServer_base {
     private _options;
     private _authCallback;
     private _clients;
@@ -265,4 +290,4 @@ declare class InMemoryAdapter implements EventAdapterInterface {
     disconnect(): Promise<void>;
 }
 
-export { AuthCallback, CallHandler, CallOptions, ClientOptions, CloseOptions, ConnectionState, EventAdapterInterface, HandshakeInfo, InMemoryAdapter, ListenOptions, OCPPClient, OCPPServer, OCPPServerClient, type RPCError, RPCFormatViolationError, RPCFormationViolationError, RPCFrameworkError, RPCGenericError, RPCInternalError, RPCMessageTypeNotSupportedError, RPCNotImplementedError, RPCNotSupportedError, RPCOccurrenceConstraintViolationError, RPCPropertyConstraintViolationError, RPCProtocolError, RPCSecurityError, RPCTypeConstraintViolationError, SecurityProfile, ServerOptions, TimeoutError, UnexpectedHttpResponse, Validator, WebsocketUpgradeError, WildcardHandler, createRPCError, getErrorPlainObject, getPackageIdent, standardValidators };
+export { AllMethodNames, AuthCallback, CallOptions, ClientEvents, ClientOptions, CloseOptions, ConnectionState, EventAdapterInterface, HandlerContext, HandshakeInfo, InMemoryAdapter, ListenOptions, OCPPClient, OCPPProtocol, OCPPRequestType, OCPPResponseType, OCPPServer, OCPPServerClient, type RPCError, RPCFormatViolationError, RPCFormationViolationError, RPCFrameworkError, RPCGenericError, RPCInternalError, RPCMessageTypeNotSupportedError, RPCNotImplementedError, RPCNotSupportedError, RPCOccurrenceConstraintViolationError, RPCPropertyConstraintViolationError, RPCProtocolError, RPCSecurityError, RPCTypeConstraintViolationError, SecurityProfile, ServerEvents, ServerOptions, TimeoutError, TypedEventEmitter, UnexpectedHttpResponse, Validator, WebsocketUpgradeError, WildcardHandler, createRPCError, getErrorPlainObject, getPackageIdent, standardValidators };