ocpp-ws-io 1.0.0-alpha

package/dist/index.d.ts

@@ -0,0 +1,268 @@
+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 { Duplex } from 'node:stream';
+import 'node:https';
+import 'node:tls';
+import 'ajv';
+
+/**
+ * OCPPClient — A typed WebSocket RPC client for OCPP communication.
+ *
+ * Supports all 3 OCPP Security Profiles:
+ * - Profile 1: Basic Auth over unsecured WS
+ * - Profile 2: TLS + Basic Auth
+ * - Profile 3: Mutual TLS (client certificates)
+ */
+declare class OCPPClient extends EventEmitter {
+    static readonly CONNECTING: 0;
+    static readonly OPEN: 1;
+    static readonly CLOSING: 2;
+    static readonly CLOSED: 3;
+    protected _options: Required<Pick<ClientOptions, "identity" | "endpoint" | "callTimeoutMs" | "pingIntervalMs" | "deferPingsOnActivity" | "callConcurrency" | "maxBadMessages" | "respondWithDetailedErrors" | "reconnect" | "maxReconnects" | "backoffMin" | "backoffMax">> & ClientOptions;
+    protected _state: ConnectionState;
+    protected _ws: WebSocket | null;
+    protected _protocol: string | undefined;
+    protected _identity: string;
+    private _handlers;
+    private _wildcardHandler;
+    private _pendingCalls;
+    private _pendingResponses;
+    private _callQueue;
+    private _pingTimer;
+    private _closePromise;
+    private _reconnectAttempt;
+    private _reconnectTimer;
+    private _badMessageCount;
+    private _lastActivity;
+    private _validators;
+    private _strictProtocols;
+    protected _handshake: unknown;
+    constructor(options: ClientOptions);
+    get identity(): string;
+    get protocol(): string | undefined;
+    get state(): ConnectionState;
+    get securityProfile(): SecurityProfile;
+    connect(): Promise<{
+        response: node_http.IncomingMessage;
+    }>;
+    private _connectInternal;
+    close(options?: CloseOptions): Promise<{
+        code: number;
+        reason: string;
+    }>;
+    private _closeInternal;
+    handle<TParams = unknown, TResult = unknown>(methodOrHandler: string | WildcardHandler, handler?: CallHandler<TParams, TResult>): void;
+    removeHandler(method?: string): void;
+    removeAllHandlers(): void;
+    call<TResult = unknown>(method: string, params?: unknown, options?: CallOptions): Promise<TResult>;
+    private _sendCall;
+    /**
+     * Send a raw string message over the WebSocket (use with caution).
+     */
+    sendRaw(message: string): void;
+    reconfigure(options: Partial<ClientOptions>): void;
+    protected _attachWebsocket(ws: WebSocket): void;
+    private _onMessage;
+    private _handleIncomingCall;
+    private _handleCallResult;
+    private _handleCallError;
+    private _onBadMessage;
+    private _onClose;
+    private _scheduleReconnect;
+    private _startPing;
+    private _stopPing;
+    private _recordActivity;
+    private _setupValidators;
+    private _validateOutbound;
+    private _validateInbound;
+    private _findValidator;
+    private _buildEndpoint;
+    private _buildWsOptions;
+    private _cleanup;
+}
+
+/**
+ * OCPPServerClient — A server-side client representation.
+ *
+ * Created by OCPPServer when a charging station connects.
+ * Extends OCPPClient but is pre-connected (cannot call connect()).
+ */
+declare class OCPPServerClient extends OCPPClient {
+    private _serverSession;
+    private _serverHandshake;
+    constructor(options: ClientOptions, context: {
+        ws: WebSocket$1;
+        handshake: HandshakeInfo;
+        session: Record<string, unknown>;
+    });
+    /**
+     * Session data associated with this client connection.
+     */
+    get session(): Record<string, unknown>;
+    /**
+     * Handshake information from the initial connection.
+     */
+    get handshake(): HandshakeInfo;
+    /**
+     * Server clients cannot initiate connections.
+     * @throws Always throws — use OCPPClient for outbound connections.
+     */
+    connect(): Promise<never>;
+}
+
+/**
+ * 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 EventEmitter {
+    private _options;
+    private _authCallback;
+    private _clients;
+    private _httpServers;
+    private _wss;
+    private _adapter;
+    private _httpServerAbortControllers;
+    constructor(options?: ServerOptions);
+    get clients(): ReadonlySet<OCPPServerClient>;
+    auth(callback: AuthCallback): void;
+    listen(port?: number, host?: string, options?: ListenOptions): Promise<Server>;
+    get handleUpgrade(): (req: IncomingMessage, socket: Duplex, head: Buffer) => Promise<void>;
+    private _handleUpgrade;
+    close(options?: CloseOptions): Promise<void>;
+    reconfigure(options: Partial<ServerOptions>): void;
+    setAdapter(adapter: EventAdapterInterface): void;
+    publish(channel: string, data: unknown): Promise<void>;
+}
+
+/**
+ * Pre-built validators for all supported OCPP protocol versions.
+ * These are automatically registered when strict mode is enabled.
+ */
+declare const standardValidators: Validator[];
+
+declare class TimeoutError extends Error {
+    constructor(message?: string);
+}
+declare class UnexpectedHttpResponse extends Error {
+    readonly statusCode: number;
+    readonly headers: Record<string, string | string[] | undefined>;
+    constructor(message: string, statusCode: number, headers?: Record<string, string | string[] | undefined>);
+}
+declare class WebsocketUpgradeError extends Error {
+    constructor(message?: string);
+}
+interface RPCError extends Error {
+    readonly rpcErrorCode: string;
+    readonly rpcErrorMessage: string;
+    readonly details: Record<string, unknown>;
+}
+declare class RPCGenericError extends Error implements RPCError {
+    readonly rpcErrorCode: string;
+    readonly rpcErrorMessage: string;
+    readonly details: Record<string, unknown>;
+    constructor(message?: string, details?: Record<string, unknown>);
+}
+declare class RPCNotImplementedError extends RPCGenericError {
+    readonly rpcErrorCode = "NotImplemented";
+    readonly rpcErrorMessage = "Requested method is not known";
+    constructor(message?: string, details?: Record<string, unknown>);
+}
+declare class RPCNotSupportedError extends RPCGenericError {
+    readonly rpcErrorCode = "NotSupported";
+    readonly rpcErrorMessage = "Requested method is recognised but not supported";
+    constructor(message?: string, details?: Record<string, unknown>);
+}
+declare class RPCInternalError extends RPCGenericError {
+    readonly rpcErrorCode = "InternalError";
+    readonly rpcErrorMessage = "An internal error occurred and the receiver was not able to process the requested action successfully";
+    constructor(message?: string, details?: Record<string, unknown>);
+}
+declare class RPCProtocolError extends RPCGenericError {
+    readonly rpcErrorCode = "ProtocolError";
+    readonly rpcErrorMessage = "Payload for action is incomplete";
+    constructor(message?: string, details?: Record<string, unknown>);
+}
+declare class RPCSecurityError extends RPCGenericError {
+    readonly rpcErrorCode = "SecurityError";
+    readonly rpcErrorMessage = "During the processing of action a security issue occurred preventing receiver from completing the action successfully";
+    constructor(message?: string, details?: Record<string, unknown>);
+}
+declare class RPCFormationViolationError extends RPCGenericError {
+    readonly rpcErrorCode = "FormationViolation";
+    readonly rpcErrorMessage = "Payload for action is syntactically incorrect or not conform the PDU structure for action";
+    constructor(message?: string, details?: Record<string, unknown>);
+}
+declare class RPCFormatViolationError extends RPCGenericError {
+    readonly rpcErrorCode = "FormatViolation";
+    readonly rpcErrorMessage = "Payload is syntactically correct but at least one field contains an invalid value";
+    constructor(message?: string, details?: Record<string, unknown>);
+}
+declare class RPCPropertyConstraintViolationError extends RPCGenericError {
+    readonly rpcErrorCode = "PropertyConstraintViolation";
+    readonly rpcErrorMessage = "Payload is syntactically correct but at least one of the fields violates data type constraints";
+    constructor(message?: string, details?: Record<string, unknown>);
+}
+declare class RPCOccurrenceConstraintViolationError extends RPCGenericError {
+    readonly rpcErrorCode = "OccurrenceConstraintViolation";
+    readonly rpcErrorMessage = "Payload for action is syntactically correct but at least one of the fields violates occurrence constraints";
+    constructor(message?: string, details?: Record<string, unknown>);
+}
+declare class RPCTypeConstraintViolationError extends RPCGenericError {
+    readonly rpcErrorCode = "TypeConstraintViolation";
+    readonly rpcErrorMessage = "Payload for action is syntactically correct but at least one of the fields violates type constraints";
+    constructor(message?: string, details?: Record<string, unknown>);
+}
+declare class RPCMessageTypeNotSupportedError extends RPCGenericError {
+    readonly rpcErrorCode = "MessageTypeNotSupported";
+    readonly rpcErrorMessage = "A message with a Message Type Number received that is not supported by this implementation";
+    constructor(message?: string, details?: Record<string, unknown>);
+}
+declare class RPCFrameworkError extends RPCGenericError {
+    readonly rpcErrorCode = "RpcFrameworkError";
+    readonly rpcErrorMessage = "Content of the call is not a valid RPC request";
+    constructor(message?: string, details?: Record<string, unknown>);
+}
+
+/**
+ * Instantiate a typed RPCError from a string error code.
+ * Returns an RPCGenericError if the code is not recognized.
+ */
+declare function createRPCError(code: string, message?: string, details?: Record<string, unknown>): RPCError;
+/**
+ * Convert an Error (or subclass) into a plain, JSON-safe object.
+ *
+ * Extracts well-known properties explicitly rather than relying on
+ * Object.getOwnPropertyNames to avoid exposing internal fields and
+ * to guarantee a stable output shape.
+ *
+ * If a property holds a non-serializable value (functions, symbols,
+ * circular references), it is silently skipped.
+ */
+declare function getErrorPlainObject(err: Error): Record<string, unknown>;
+/**
+ * Get the package identifier string used in HTTP headers and logging.
+ * Format: `ocpp-ws-io/1.0.0`
+ */
+declare function getPackageIdent(): string;
+
+/**
+ * In-memory event adapter for single-process use.
+ * Events are dispatched synchronously within the same process.
+ */
+declare class InMemoryAdapter implements EventAdapterInterface {
+    private _channels;
+    publish(channel: string, data: unknown): Promise<void>;
+    subscribe(channel: string, handler: (data: unknown) => void): Promise<void>;
+    unsubscribe(channel: string): Promise<void>;
+    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 };