@gravito/ripple 3.1.0 → 4.0.1

package/dist/ripple/src/drivers/NATSDriver.d.ts

@@ -0,0 +1,87 @@
+/**
+ * @fileoverview NATS driver for @gravito/ripple
+ *
+ * @module @gravito/ripple/drivers
+ */
+import type { ConnectionOptions } from 'nats';
+import type { RippleLogger } from '../logging/Logger';
+import type { DriverStatus, PresenceUserInfo, RippleDriver } from '../types';
+/**
+ * Configuration for the NATSDriver.
+ */
+export interface NATSDriverConfig {
+    /** NATS server URL (default: 'nats://localhost:4222') */
+    servers?: string | string[];
+    /** Credentials for authentication */
+    user?: string;
+    password?: string;
+    token?: string;
+    /** Prefix for Ripple NATS subjects (default: 'ripple.') */
+    subjectPrefix?: string;
+    /** Custom logger instance */
+    logger?: RippleLogger;
+    /** Optional NATS connection options */
+    connectionOptions?: ConnectionOptions;
+}
+/**
+ * NATS driver for Ripple, offering high-performance distributed broadcasting.
+ *
+ * @example
+ * ```typescript
+ * import { RippleServer, NATSDriver } from '@gravito/ripple'
+ *
+ * const server = new RippleServer({
+ *   driver: 'nats',
+ *   nats: {
+ *     servers: 'nats://localhost:4222'
+ *   }
+ * })
+ * ```
+ */
+export declare class NATSDriver implements RippleDriver {
+    private config;
+    readonly name = "nats";
+    private nats?;
+    private subjectPrefix;
+    private subscriptions;
+    private callbacks;
+    private _initialized;
+    private _connected;
+    private _lastError?;
+    private logger;
+    constructor(config?: NATSDriverConfig);
+    get isInitialized(): boolean;
+    init(): Promise<void>;
+    publish(channel: string, event: string, data: unknown): Promise<void>;
+    subscribe(channel: string, callback: (event: string, data: unknown) => void): Promise<void>;
+    unsubscribe(channel: string): Promise<void>;
+    shutdown(): Promise<void>;
+    getStatus(): DriverStatus;
+    /**
+     * Track presence member using NATS KV Store.
+     *
+     * Creates or updates a bucket for the channel and stores user info with TTL.
+     *
+     * @param channel - Presence channel name
+     * @param userInfo - User information to store
+     * @since 4.0.0-alpha
+     */
+    trackPresence(channel: string, userInfo: PresenceUserInfo): Promise<void>;
+    /**
+     * Remove presence member from NATS KV Store.
+     *
+     * @param channel - Presence channel name
+     * @param userId - User ID to remove
+     * @since 4.0.0-alpha
+     */
+    untrackPresence(channel: string, userId: string | number): Promise<void>;
+    /**
+     * Get all presence members from NATS KV Store.
+     *
+     * @param channel - Presence channel name
+     * @returns Array of presence user information
+     * @since 4.0.0-alpha
+     */
+    getPresenceMembers(channel: string): Promise<PresenceUserInfo[]>;
+    private handleError;
+}

package/dist/ripple/src/drivers/RedisDriver.d.ts

@@ -4,7 +4,7 @@
  * @module @gravito/ripple/drivers
  */
 import type { RippleLogger } from '../logging/Logger';
-import type { DriverStatus, RippleDriver } from '../types';
+import type { DriverStatus, PresenceUserInfo, RippleDriver } from '../types';
 /**
  * Configuration for the RedisDriver.
  */
@@ -122,6 +122,35 @@ export declare class RedisDriver implements RippleDriver {
      * Get the current status of the Redis driver.
      */
     getStatus(): DriverStatus;
+    /**
+     * Track a presence member in a channel.
+     *
+     * Stores presence information in Redis Hash for cross-node sharing.
+     * Sets TTL on the hash to prevent stale data.
+     *
+     * @param channel - Presence channel name
+     * @param userInfo - User information to track
+     * @since 3.6.0
+     */
+    trackPresence(channel: string, userInfo: PresenceUserInfo): Promise<void>;
+    /**
+     * Remove a presence member from a channel.
+     *
+     * @param channel - Presence channel name
+     * @param userId - User ID to remove
+     * @since 3.6.0
+     */
+    untrackPresence(channel: string, userId: string | number): Promise<void>;
+    /**
+     * Get all presence members for a channel.
+     *
+     * Retrieves all members from the Redis Hash.
+     *
+     * @param channel - Presence channel name
+     * @returns Array of presence user information
+     * @since 3.6.0
+     */
+    getPresenceMembers(channel: string): Promise<PresenceUserInfo[]>;
     /**
      * Handle an incoming message from Redis Pub/Sub.
      *

package/dist/ripple/src/drivers/index.d.ts

@@ -1,2 +1,3 @@
 export * from './LocalDriver';
+export * from './NATSDriver';
 export * from './RedisDriver';

package/dist/ripple/src/engines/BunEngine.d.ts

@@ -0,0 +1,98 @@
+/**
+ * @fileoverview Bun native WebSocket engine implementation
+ *
+ * Wraps Bun's native WebSocket API to implement the IRippleEngine interface.
+ * This is the default and highest-performance engine for Ripple.
+ *
+ * @module @gravito/ripple/engines
+ * @since 5.0.0
+ */
+import type { Server, ServerWebSocket } from 'bun';
+import type { ClientData } from '../types';
+import type { IRippleEngine, RippleSocket } from './IRippleEngine';
+/**
+ * Wrapper around Bun's ServerWebSocket to implement RippleSocket interface.
+ *
+ * This is a zero-overhead wrapper that delegates all operations to the native
+ * Bun WebSocket object. No proxies or additional allocations.
+ */
+export declare class BunRippleSocket implements RippleSocket {
+    private ws;
+    constructor(ws: ServerWebSocket<ClientData>);
+    get id(): string;
+    get data(): ClientData;
+    send(data: string | Uint8Array, compress?: boolean): void;
+    close(code?: number, reason?: string): void;
+    getBufferedAmount(): number;
+    subscribe(topic: string): void;
+    unsubscribe(topic: string): void;
+    publish(topic: string, data: string | Uint8Array): void;
+    get raw(): ServerWebSocket<ClientData>;
+}
+/**
+ * Configuration for BunEngine.
+ */
+export interface BunEngineConfig {
+    /** Port to listen on */
+    port?: number;
+    /** Hostname to bind to */
+    hostname?: string;
+    /** TLS configuration */
+    tls?: {
+        cert: string;
+        key: string;
+    };
+    /** Development mode (enables verbose logging) */
+    development?: boolean;
+}
+/**
+ * Bun native WebSocket engine.
+ *
+ * Leverages Bun's high-performance WebSocket implementation with native pub/sub support.
+ * This engine provides the best performance and is the default choice for Bun runtime.
+ *
+ * @example
+ * ```typescript
+ * const engine = new BunEngine({ port: 3000 })
+ *
+ * engine.onConnection((socket) => {
+ *   console.log('Client connected:', socket.id)
+ * })
+ *
+ * await engine.listen(3000)
+ * ```
+ */
+export declare class BunEngine implements IRippleEngine {
+    private config;
+    readonly name = "bun";
+    private server?;
+    private connectionHandler?;
+    private disconnectionHandler?;
+    private messageHandler?;
+    private sockets;
+    constructor(config?: BunEngineConfig);
+    onConnection(handler: (socket: RippleSocket) => void): void;
+    onDisconnection(handler: (socket: RippleSocket, code: number, reason: string) => void): void;
+    onMessage(handler: (socket: RippleSocket, message: string | Uint8Array) => void): void;
+    listen(port: number): Promise<void>;
+    close(): Promise<void>;
+    broadcast(topic: string, data: string | Uint8Array, excludeSocketId?: string): void;
+    /**
+     * Upgrade an HTTP request to a WebSocket connection.
+     *
+     * This method is called by RippleServer to handle WebSocket upgrade requests.
+     *
+     * @param req - HTTP request
+     * @param options - Upgrade options (userId, reconnectionToken)
+     * @returns true if upgrade succeeded, false otherwise
+     */
+    upgrade(req: Request, options?: {
+        userId?: string;
+        reconnectionToken?: string;
+    }): boolean;
+    /**
+     * Get the underlying Bun server instance.
+     * Useful for advanced use cases.
+     */
+    getServer(): Server<ClientData> | undefined;
+}

package/dist/ripple/src/engines/IRippleEngine.d.ts

@@ -0,0 +1,205 @@
+/**
+ * @fileoverview Core abstraction layer for Ripple WebSocket engines
+ *
+ * Defines the interface that all WebSocket engines must implement to work with Ripple.
+ * This abstraction allows Ripple to run on different runtimes (Bun, Node.js with uWS, Node.js with ws).
+ *
+ * @module @gravito/ripple/engines
+ * @since 5.0.0
+ */
+import type { ClientData } from '../types';
+/**
+ * Runtime-agnostic WebSocket connection interface.
+ *
+ * Provides a unified API across different WebSocket implementations (Bun, uWS, ws).
+ * Each engine wraps its native WebSocket type to implement this interface.
+ *
+ * @example
+ * ```typescript
+ * // Engine implementations wrap their native WebSocket
+ * class BunRippleSocket implements RippleSocket {
+ *   constructor(private ws: ServerWebSocket<ClientData>) {}
+ *
+ *   send(data: string | Uint8Array) {
+ *     this.ws.send(data)
+ *   }
+ *
+ *   get data() {
+ *     return this.ws.data
+ *   }
+ * }
+ * ```
+ */
+export interface RippleSocket {
+    /** Unique socket identifier */
+    id: string;
+    /** Client session data */
+    data: ClientData;
+    /**
+     * Send data to the client.
+     *
+     * @param data - Message payload (string or binary)
+     * @param compress - Whether to compress the message (optional, engine-dependent)
+     */
+    send(data: string | Uint8Array, compress?: boolean): void;
+    /**
+     * Close the WebSocket connection.
+     *
+     * @param code - WebSocket close code (default: 1000)
+     * @param reason - Human-readable close reason
+     */
+    close(code?: number, reason?: string): void;
+    /**
+     * Get the number of bytes buffered for sending.
+     * Used for backpressure management.
+     *
+     * @returns Buffered bytes count
+     */
+    getBufferedAmount(): number;
+    /**
+     * Subscribe to a pub/sub topic.
+     *
+     * For engines with native pub/sub (Bun, uWS), this uses the native API.
+     * For engines without (ws), this is tracked in-memory by the engine.
+     *
+     * @param topic - Topic name to subscribe to
+     */
+    subscribe(topic: string): void;
+    /**
+     * Unsubscribe from a pub/sub topic.
+     *
+     * @param topic - Topic name to unsubscribe from
+     */
+    unsubscribe(topic: string): void;
+    /**
+     * Publish a message to a topic.
+     *
+     * For engines with native pub/sub, this broadcasts at the C++ layer.
+     * For engines without, this is handled by the engine's broadcast logic.
+     *
+     * @param topic - Topic name
+     * @param data - Message payload
+     */
+    publish(topic: string, data: string | Uint8Array): void;
+    /**
+     * Access to the underlying native WebSocket object.
+     *
+     * This is an escape hatch for engine-specific features not covered by the interface.
+     * Use with caution as it breaks runtime portability.
+     *
+     * @example
+     * ```typescript
+     * // Access Bun-specific features
+     * if (socket.raw && 'remoteAddress' in socket.raw) {
+     *   console.log('Client IP:', socket.raw.remoteAddress)
+     * }
+     * ```
+     */
+    raw?: any;
+}
+/**
+ * WebSocket engine interface for Ripple.
+ *
+ * Engines handle the low-level WebSocket I/O and lifecycle management.
+ * RippleServer delegates all runtime-specific operations to the engine.
+ *
+ * @example
+ * ```typescript
+ * // Example: Custom engine implementation
+ * class MyCustomEngine implements IRippleEngine {
+ *   private server?: any
+ *   private connectionHandler?: (socket: RippleSocket) => void
+ *
+ *   async listen(port: number): Promise<void> {
+ *     this.server = createServer(port)
+ *     this.server.on('connection', (ws) => {
+ *       const socket = new MyRippleSocket(ws)
+ *       this.connectionHandler?.(socket)
+ *     })
+ *   }
+ *
+ *   onConnection(handler: (socket: RippleSocket) => void): void {
+ *     this.connectionHandler = handler
+ *   }
+ *
+ *   // ... implement other methods
+ * }
+ * ```
+ */
+export interface IRippleEngine {
+    /** Engine name for logging and debugging */
+    readonly name: string;
+    /**
+     * Start the WebSocket server.
+     *
+     * @param port - Port number to listen on
+     * @throws If the port is already in use or binding fails
+     */
+    listen(port: number): Promise<void>;
+    /**
+     * Stop the WebSocket server and close all connections.
+     */
+    close(): Promise<void>;
+    /**
+     * Register handler for new WebSocket connections.
+     *
+     * Called by RippleServer to hook into the connection lifecycle.
+     * The engine should call this handler whenever a new WebSocket connection is established.
+     *
+     * @param handler - Callback invoked when a client connects
+     */
+    onConnection(handler: (socket: RippleSocket) => void): void;
+    /**
+     * Register handler for WebSocket disconnections.
+     *
+     * Called by RippleServer to hook into the disconnection lifecycle.
+     * The engine should call this handler whenever a WebSocket connection closes.
+     *
+     * @param handler - Callback invoked when a client disconnects
+     */
+    onDisconnection(handler: (socket: RippleSocket, code: number, reason: string) => void): void;
+    /**
+     * Register handler for incoming WebSocket messages.
+     *
+     * Called by RippleServer to hook into the message lifecycle.
+     * The engine should call this handler whenever a message is received.
+     *
+     * @param handler - Callback invoked when a message is received
+     */
+    onMessage(handler: (socket: RippleSocket, message: string | Uint8Array) => void): void;
+    /**
+     * Broadcast a message to all subscribers of a topic.
+     *
+     * For engines with native pub/sub (Bun, uWS), this should use the native broadcast API
+     * for maximum performance (C++ layer broadcast, no JS callback overhead).
+     *
+     * For engines without native pub/sub (ws), this should iterate over subscribers
+     * and send the message to each.
+     *
+     * @param topic - Topic/channel name
+     * @param data - Message payload
+     * @param excludeSocketId - Optional socket ID to exclude from broadcast
+     */
+    broadcast(topic: string, data: string | Uint8Array, excludeSocketId?: string): void;
+    /**
+     * Upgrade an HTTP request to a WebSocket connection.
+     *
+     * This is optional and only needed for engines that integrate with HTTP servers
+     * (Bun, uWS). For standalone WebSocket servers, this can be omitted.
+     *
+     * @param req - HTTP request object
+     * @param options - Upgrade options (e.g., user ID for authentication)
+     * @returns true if upgrade was successful, false otherwise
+     */
+    upgrade?(req: Request, options?: {
+        userId?: string;
+        reconnectionToken?: string;
+    }): boolean;
+}
+/**
+ * Factory function type for creating engine instances.
+ *
+ * @param config - Engine-specific configuration
+ * @returns Engine instance
+ */
+export type EngineFactory = (config: any) => IRippleEngine;

package/dist/ripple/src/engines/UWebSocketsEngine.d.ts

@@ -0,0 +1,97 @@
+/**
+ * @fileoverview uWebSockets.js engine implementation for Node.js
+ *
+ * Wraps uWebSockets.js API to implement the IRippleEngine interface.
+ * This engine provides high performance on Node.js, close to Bun's native performance.
+ *
+ * @module @gravito/ripple/engines
+ * @since 5.0.0
+ */
+import type { ClientData } from '../types';
+import type { IRippleEngine, RippleSocket } from './IRippleEngine';
+interface WebSocket {
+    send(message: string | ArrayBuffer, isBinary?: boolean, compress?: boolean): number;
+    close(): void;
+    getBufferedAmount(): number;
+    subscribe(topic: string): void;
+    unsubscribe(topic: string): void;
+    publish(topic: string, message: string | ArrayBuffer, isBinary?: boolean, compress?: boolean): boolean;
+    getUserData(): ClientData;
+}
+/**
+ * Wrapper around uWebSockets.js WebSocket to implement RippleSocket interface.
+ *
+ * This is a zero-overhead wrapper that delegates all operations to the uWebSockets.js
+ * WebSocket object.
+ */
+export declare class UWebSocketsRippleSocket implements RippleSocket {
+    private ws;
+    constructor(ws: WebSocket);
+    get id(): string;
+    get data(): ClientData;
+    send(data: string | Uint8Array, compress?: boolean): void;
+    close(_code?: number, _reason?: string): void;
+    getBufferedAmount(): number;
+    subscribe(topic: string): void;
+    unsubscribe(topic: string): void;
+    publish(topic: string, data: string | Uint8Array): void;
+    get raw(): WebSocket;
+}
+/**
+ * Configuration for uWebSocketsEngine.
+ */
+export interface UWebSocketsEngineConfig {
+    /** Port to listen on */
+    port?: number;
+    /** Hostname to bind to */
+    hostname?: string;
+    /** TLS configuration */
+    tls?: {
+        cert: string;
+        key: string;
+    };
+    /** Compression mode (0 = disabled, 1 = shared, 3 = dedicated 3KB) */
+    compression?: number;
+    /** Maximum payload length in bytes (default: 16MB) */
+    maxPayloadLength?: number;
+    /** Idle timeout in seconds (default: 120) */
+    idleTimeout?: number;
+    /** Maximum backpressure in bytes (default: 1MB) */
+    maxBackpressure?: number;
+    /** Development mode (enables verbose logging) */
+    development?: boolean;
+}
+/**
+ * uWebSockets.js engine for Node.js.
+ *
+ * Leverages uWebSockets.js high-performance WebSocket implementation with native pub/sub support.
+ * This engine provides excellent performance on Node.js (~90% of Bun's performance).
+ */
+export declare class UWebSocketsEngine implements IRippleEngine {
+    private config;
+    readonly name = "node-uws";
+    private app?;
+    private uws?;
+    private connectionHandler?;
+    private disconnectionHandler?;
+    private messageHandler?;
+    private sockets;
+    private listenSocket?;
+    constructor(config?: UWebSocketsEngineConfig);
+    onConnection(handler: (socket: RippleSocket) => void): void;
+    onDisconnection(handler: (socket: RippleSocket, code: number, reason: string) => void): void;
+    onMessage(handler: (socket: RippleSocket, message: string | Uint8Array) => void): void;
+    listen(port: number): Promise<void>;
+    close(): Promise<void>;
+    broadcast(topic: string, data: string | Uint8Array, excludeSocketId?: string): void;
+    getConnectedSockets(): RippleSocket[];
+    getSocket(id: string): RippleSocket | undefined;
+    /**
+     * Upgrade an HTTP request to WebSocket.
+     *
+     * Note: This method is not used in the engine-based architecture.
+     * uWebSockets.js handles upgrades internally via the ws() route.
+     */
+    upgrade(_req: Request, _data?: Record<string, unknown>): boolean;
+}
+export {};

package/dist/ripple/src/engines/WsEngine.d.ts

@@ -0,0 +1,69 @@
+/**
+ * @fileoverview Node.js ws engine implementation
+ *
+ * Wraps the 'ws' library to implement the IRippleEngine interface.
+ * Implements in-memory pub/sub since the ws library does not support it natively.
+ *
+ * @module @gravito/ripple/engines
+ * @since 5.0.0
+ */
+import { type WebSocket } from 'ws';
+import type { ClientData } from '../types';
+import type { IRippleEngine, RippleSocket } from './IRippleEngine';
+/**
+ * Wrapper around 'ws' WebSocket to implement RippleSocket interface.
+ */
+export declare class WsRippleSocket implements RippleSocket {
+    private ws;
+    private clientData;
+    private engine;
+    constructor(ws: WebSocket, clientData: ClientData, engine: WsEngine);
+    get id(): string;
+    get data(): ClientData;
+    send(data: string | Uint8Array, compress?: boolean): void;
+    close(code?: number, reason?: string): void;
+    getBufferedAmount(): number;
+    subscribe(topic: string): void;
+    unsubscribe(topic: string): void;
+    publish(topic: string, data: string | Uint8Array): void;
+    get raw(): WebSocket;
+}
+/**
+ * Configuration for WsEngine.
+ */
+export interface WsEngineConfig {
+    /** Port to listen on */
+    port?: number;
+    /** Hostname to bind to */
+    hostname?: string;
+    /** Development mode */
+    development?: boolean;
+    /** WebSocket path */
+    path?: string;
+}
+/**
+ * Node.js ws engine.
+ *
+ * Uses the popular 'ws' library. Provides standard compatibility but
+ * uses application-layer pub/sub.
+ */
+export declare class WsEngine implements IRippleEngine {
+    private config;
+    readonly name = "node-ws";
+    private wss?;
+    private connectionHandler?;
+    private disconnectionHandler?;
+    private messageHandler?;
+    private sockets;
+    private subscriptions;
+    constructor(config?: WsEngineConfig);
+    onConnection(handler: (socket: RippleSocket) => void): void;
+    onDisconnection(handler: (socket: RippleSocket, code: number, reason: string) => void): void;
+    onMessage(handler: (socket: RippleSocket, message: string | Uint8Array) => void): void;
+    listen(port: number): Promise<void>;
+    close(): Promise<void>;
+    subscribe(socketId: string, topic: string): void;
+    unsubscribe(socketId: string, topic: string): void;
+    private cleanupSocket;
+    broadcast(topic: string, data: string | Uint8Array, excludeSocketId?: string): void;
+}

package/dist/ripple/src/engines/index.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @fileoverview Ripple WebSocket Engine exports
+ *
+ * Provides runtime-agnostic WebSocket engine implementations for Ripple.
+ *
+ * @module @gravito/ripple/engines
+ * @since 5.0.0
+ */
+export type { BunEngineConfig } from './BunEngine';
+export { BunEngine, BunRippleSocket } from './BunEngine';
+export type { EngineFactory, IRippleEngine, RippleSocket } from './IRippleEngine';
+export type { UWebSocketsEngineConfig } from './UWebSocketsEngine';
+export { UWebSocketsEngine, UWebSocketsRippleSocket } from './UWebSocketsEngine';
+export type { WsEngineConfig } from './WsEngine';
+export { WsEngine, WsRippleSocket } from './WsEngine';

package/dist/ripple/src/index.d.ts

@@ -53,7 +53,9 @@ export { HealthChecker } from './health/HealthChecker';
 export type { LogContext, LogLevel, RippleLogger } from './logging/Logger';
 export { ConsoleLogger, createLogger } from './logging/Logger';
 export { OrbitRipple } from './OrbitRipple';
+export { RippleMetrics } from './observability/RippleMetrics';
 export { RippleServer } from './RippleServer';
+export { AckManager } from './reliability/AckManager';
 export type { ConnectionEvent, ConnectionTracker } from './tracking/ConnectionTracker';
 export { DefaultConnectionTracker } from './tracking/ConnectionTracker';
 export type { BroadcastEventInterface, Channel, ChannelAuthorizer, ChannelType, ClientData, ClientMessage, DriverStatus, ErrorServerMessage, PresenceUserInfo, RippleBunServer, RippleConfig, RippleDriver, RippleErrorCode, RippleWebSocket, ServerMessage, WebSocketHandlerConfig, } from './types';

package/dist/ripple/src/middleware/InterceptorManager.d.ts

@@ -0,0 +1,21 @@
+import type { RippleContext, RippleInterceptor } from '../types';
+/**
+ * Manages the execution of message interceptors in an onion model.
+ *
+ * @since 4.0.0
+ */
+export declare class InterceptorManager {
+    private interceptors;
+    constructor(interceptors?: RippleInterceptor[]);
+    /**
+     * Execute the interceptor pipeline for a given context.
+     *
+     * @param ctx - The ripple message context
+     * @param finalHandler - The final handler to run after all interceptors
+     */
+    execute(ctx: RippleContext, finalHandler: () => Promise<void> | void): Promise<void>;
+    /**
+     * Add a new interceptor to the end of the pipeline.
+     */
+    use(interceptor: RippleInterceptor): void;
+}

package/dist/ripple/src/observability/RippleMetrics.d.ts

@@ -0,0 +1,24 @@
+import type { AckManager } from '../reliability/AckManager';
+import type { ConnectionTracker } from '../tracking/ConnectionTracker';
+/**
+ * Prometheus metrics exporter for Ripple.
+ *
+ * @since 3.7.0
+ */
+export declare class RippleMetrics {
+    private prefix;
+    private tracker;
+    private ackManager?;
+    private slowClients;
+    constructor(tracker: ConnectionTracker, prefix?: string, ackManager?: AckManager);
+    /**
+     * Increment the counter for slow clients isolated or disconnected.
+     */
+    incrementSlowClients(): void;
+    /**
+     * Export metrics in Prometheus text format.
+     *
+     * @returns String containing Prometheus metrics
+     */
+    export(): string;
+}