@rstmdb/client 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,888 @@
+import { EventEmitter } from 'events';
+
+/**
+ * A stream event from a watch subscription.
+ */
+interface StreamEvent {
+    /** Subscription ID */
+    subscriptionId: string;
+    /** Instance ID */
+    instanceId: string;
+    /** Machine name */
+    machine: string;
+    /** Machine version */
+    version: number;
+    /** WAL offset */
+    walOffset: bigint;
+    /** Source state */
+    fromState: string;
+    /** Target state */
+    toState: string;
+    /** Event name */
+    event: string;
+    /** Event payload */
+    payload?: Record<string, unknown>;
+    /** Instance context */
+    ctx?: Record<string, unknown>;
+}
+/**
+ * Options for WATCH_INSTANCE operation.
+ */
+interface WatchOptions {
+    /** Include context in events. Default: true */
+    includeCtx?: boolean;
+    /** Replay events from this offset */
+    fromOffset?: bigint;
+}
+/**
+ * Options for WATCH_ALL operation.
+ */
+interface WatchAllOptions extends WatchOptions {
+    /** Filter by machine names */
+    machines?: string[];
+    /** Filter by source states */
+    fromStates?: string[];
+    /** Filter by target states */
+    toStates?: string[];
+    /** Filter by event names */
+    events?: string[];
+}
+/**
+ * A subscription to watch events.
+ */
+interface Subscription {
+    /** Subscription ID */
+    readonly subscriptionId: string;
+    /** AsyncIterator for for-await-of loops */
+    [Symbol.asyncIterator](): AsyncIterator<StreamEvent>;
+    /** Register event listener */
+    on(event: 'event', listener: (event: StreamEvent) => void): this;
+    on(event: 'error', listener: (error: Error) => void): this;
+    on(event: 'end', listener: () => void): this;
+    /** Remove event listener */
+    off(event: 'event', listener: (event: StreamEvent) => void): this;
+    off(event: 'error', listener: (error: Error) => void): this;
+    off(event: 'end', listener: () => void): this;
+    /** Cancel the subscription */
+    unsubscribe(): Promise<void>;
+}
+
+/**
+ * TLS configuration options for secure connections.
+ */
+interface TlsConfig {
+    /** CA certificate(s) for server verification */
+    ca?: string | Buffer | string[];
+    /** Whether to reject unauthorized certificates. Default: true */
+    rejectUnauthorized?: boolean;
+    /** Client certificate for mTLS */
+    cert?: string | Buffer;
+    /** Client private key for mTLS */
+    key?: string | Buffer;
+    /** Server name for SNI */
+    servername?: string;
+}
+/**
+ * Client configuration options.
+ */
+interface ClientConfig {
+    /** Server hostname */
+    host: string;
+    /** Server port. Default: 7401 */
+    port?: number;
+    /** Connection timeout in milliseconds. Default: 10000 */
+    connectTimeout?: number;
+    /** Request timeout in milliseconds. Default: 30000 */
+    requestTimeout?: number;
+    /** Bearer token for authentication */
+    authToken?: string;
+    /** TLS configuration. true = use TLS with system CA */
+    tls?: TlsConfig | boolean;
+    /** Enable automatic reconnection. Default: true */
+    reconnect?: boolean;
+    /** Reconnection interval in milliseconds. Default: 1000 */
+    reconnectInterval?: number;
+    /** Maximum reconnection attempts. Default: 10 */
+    reconnectMaxAttempts?: number;
+    /** Client name sent in HELLO */
+    clientName?: string;
+}
+/**
+ * Resolved configuration with all defaults applied.
+ */
+interface ResolvedConfig {
+    host: string;
+    port: number;
+    connectTimeout: number;
+    requestTimeout: number;
+    authToken?: string;
+    tls?: TlsConfig;
+    reconnect: boolean;
+    reconnectInterval: number;
+    reconnectMaxAttempts: number;
+    clientName?: string;
+}
+/**
+ * Default configuration values.
+ */
+declare const DEFAULT_CONFIG: {
+    readonly port: 7401;
+    readonly connectTimeout: 10000;
+    readonly requestTimeout: 30000;
+    readonly reconnect: true;
+    readonly reconnectInterval: 1000;
+    readonly reconnectMaxAttempts: 10;
+};
+/**
+ * Builder for creating client configurations with a fluent API.
+ *
+ * @example
+ * ```typescript
+ * const config = ClientOptions.create('localhost')
+ *   .port(7401)
+ *   .auth('my-token')
+ *   .tls({ rejectUnauthorized: true })
+ *   .timeout({ connect: 5000, request: 15000 })
+ *   .reconnect({ enabled: true, maxAttempts: 5 })
+ *   .build();
+ *
+ * const client = new Client(config);
+ * ```
+ */
+declare class ClientOptions {
+    private config;
+    private constructor();
+    /**
+     * Create a new options builder with the given host.
+     */
+    static create(host: string): ClientOptions;
+    /**
+     * Set the server port.
+     * @default 7401
+     */
+    port(port: number): this;
+    /**
+     * Set the authentication token.
+     */
+    auth(token: string): this;
+    /**
+     * Configure TLS settings.
+     *
+     * @param config - TLS configuration, or `true` to enable with system CA
+     *
+     * @example
+     * ```typescript
+     * // Enable TLS with system CA
+     * options.tls(true)
+     *
+     * // Custom CA certificate
+     * options.tls({ ca: fs.readFileSync('ca.pem') })
+     *
+     * // mTLS with client certificate
+     * options.tls({
+     *   ca: fs.readFileSync('ca.pem'),
+     *   cert: fs.readFileSync('client.pem'),
+     *   key: fs.readFileSync('client-key.pem'),
+     * })
+     * ```
+     */
+    tls(config: TlsConfig | boolean): this;
+    /**
+     * Set timeout values.
+     */
+    timeout(options: {
+        connect?: number;
+        request?: number;
+    }): this;
+    /**
+     * Configure reconnection behavior.
+     */
+    reconnect(options: {
+        enabled?: boolean;
+        interval?: number;
+        maxAttempts?: number;
+    }): this;
+    /**
+     * Set the client name (sent in HELLO handshake).
+     */
+    clientName(name: string): this;
+    /**
+     * Build the configuration object.
+     */
+    build(): ClientConfig;
+}
+
+/**
+ * A state machine transition definition.
+ */
+interface Transition {
+    /** Source state(s) */
+    from: string | string[];
+    /** Event that triggers the transition */
+    event: string;
+    /** Target state */
+    to: string;
+    /** Optional guard expression */
+    guard?: string;
+}
+/**
+ * A state machine definition.
+ */
+interface MachineDefinition {
+    /** List of valid states */
+    states: string[];
+    /** Initial state for new instances */
+    initial: string;
+    /** Transition definitions */
+    transitions: Transition[];
+    /** Optional metadata */
+    meta?: Record<string, unknown>;
+}
+/**
+ * Result of PUT_MACHINE operation.
+ */
+interface PutMachineResult {
+    /** Machine name */
+    machine: string;
+    /** Machine version */
+    version: number;
+    /** Checksum of stored definition */
+    storedChecksum: string;
+    /** Whether the machine was newly created */
+    created: boolean;
+}
+/**
+ * Result of GET_MACHINE operation.
+ */
+interface GetMachineResult {
+    /** Machine definition */
+    definition: MachineDefinition;
+    /** Definition checksum */
+    checksum: string;
+}
+/**
+ * A machine entry in LIST_MACHINES result.
+ */
+interface MachineListItem {
+    /** Machine name */
+    machine: string;
+    /** Available versions */
+    versions: number[];
+}
+/**
+ * Options for LIST_MACHINES operation.
+ */
+interface ListMachinesOptions {
+    /** Pagination cursor */
+    cursor?: string;
+    /** Maximum items to return */
+    limit?: number;
+}
+/**
+ * Result of LIST_MACHINES operation.
+ */
+interface ListMachinesResult {
+    /** List of machines */
+    items: MachineListItem[];
+    /** Cursor for next page, if more results exist */
+    nextCursor?: string;
+}
+
+/**
+ * Options for CREATE_INSTANCE operation.
+ */
+interface CreateInstanceOptions {
+    /** Custom instance ID (server generates if omitted) */
+    instanceId?: string;
+    /** Initial context data */
+    initialCtx?: Record<string, unknown>;
+    /** Idempotency key for deduplication */
+    idempotencyKey?: string;
+}
+/**
+ * Result of CREATE_INSTANCE operation.
+ */
+interface CreateInstanceResult {
+    /** Generated or provided instance ID */
+    instanceId: string;
+    /** Initial state */
+    state: string;
+    /** WAL offset of the creation */
+    walOffset: bigint;
+}
+/**
+ * Result of GET_INSTANCE operation.
+ */
+interface GetInstanceResult {
+    /** Machine name */
+    machine: string;
+    /** Machine version */
+    version: number;
+    /** Current state */
+    state: string;
+    /** Current context */
+    ctx: Record<string, unknown>;
+    /** Last applied event ID */
+    lastEventId?: string;
+    /** Last WAL offset */
+    lastWalOffset: bigint;
+}
+/**
+ * Options for DELETE_INSTANCE operation.
+ */
+interface DeleteInstanceOptions {
+    /** Idempotency key for deduplication */
+    idempotencyKey?: string;
+}
+
+/**
+ * Error codes used by the rstmdb client.
+ */
+declare enum ErrorCode {
+    UNSUPPORTED_PROTOCOL = "UNSUPPORTED_PROTOCOL",
+    BAD_REQUEST = "BAD_REQUEST",
+    UNAUTHORIZED = "UNAUTHORIZED",
+    AUTH_FAILED = "AUTH_FAILED",
+    NOT_FOUND = "NOT_FOUND",
+    MACHINE_NOT_FOUND = "MACHINE_NOT_FOUND",
+    MACHINE_VERSION_EXISTS = "MACHINE_VERSION_EXISTS",
+    INSTANCE_NOT_FOUND = "INSTANCE_NOT_FOUND",
+    INSTANCE_EXISTS = "INSTANCE_EXISTS",
+    INVALID_TRANSITION = "INVALID_TRANSITION",
+    GUARD_FAILED = "GUARD_FAILED",
+    CONFLICT = "CONFLICT",
+    WAL_IO_ERROR = "WAL_IO_ERROR",
+    INTERNAL_ERROR = "INTERNAL_ERROR",
+    RATE_LIMITED = "RATE_LIMITED",
+    CONNECTION_FAILED = "CONNECTION_FAILED",
+    CONNECTION_CLOSED = "CONNECTION_CLOSED",
+    TIMEOUT = "TIMEOUT"
+}
+
+/**
+ * Base error class for all rstmdb errors.
+ */
+declare class RstmdbError extends Error {
+    /** Error code */
+    readonly code: ErrorCode;
+    /** Whether the operation can be retried */
+    readonly retryable: boolean;
+    /** Additional error details */
+    readonly details?: Record<string, unknown>;
+    constructor(message: string, code: ErrorCode, options?: {
+        retryable?: boolean;
+        details?: Record<string, unknown>;
+        cause?: Error;
+    });
+    /**
+     * Create an error from a server response.
+     */
+    static fromResponse(response: {
+        code: string;
+        message: string;
+        details?: Record<string, unknown>;
+    }): RstmdbError;
+}
+
+/**
+ * Options for APPLY_EVENT operation.
+ */
+interface ApplyEventOptions {
+    /** Event payload data */
+    payload?: Record<string, unknown>;
+    /** Expected current state (optimistic concurrency) */
+    expectedState?: string;
+    /** Expected WAL offset (stronger concurrency check) */
+    expectedWalOffset?: bigint;
+    /** Custom event ID */
+    eventId?: string;
+    /** Idempotency key for deduplication */
+    idempotencyKey?: string;
+}
+/**
+ * Result of APPLY_EVENT operation.
+ */
+interface ApplyEventResult {
+    /** State before transition */
+    fromState: string;
+    /** State after transition */
+    toState: string;
+    /** Updated context (if changed) */
+    ctx?: Record<string, unknown>;
+    /** WAL offset of the event */
+    walOffset: bigint;
+    /** Whether the event was applied */
+    applied: boolean;
+    /** Event ID */
+    eventId?: string;
+}
+/**
+ * A batch operation definition.
+ */
+interface BatchOperation {
+    /** Operation type */
+    op: 'CREATE_INSTANCE' | 'APPLY_EVENT' | 'DELETE_INSTANCE';
+    /** Operation parameters */
+    params: Record<string, unknown>;
+}
+/**
+ * Options for BATCH operation.
+ */
+interface BatchOptions {
+    /** Execution mode */
+    mode: 'atomic' | 'best_effort';
+}
+/**
+ * A single result within a batch.
+ */
+interface BatchResultItem {
+    /** Result status */
+    status: 'ok' | 'error';
+    /** Operation result (if successful) */
+    result?: unknown;
+    /** Error (if failed) */
+    error?: RstmdbError;
+}
+/**
+ * Result of BATCH operation.
+ */
+interface BatchResult {
+    /** Individual operation results */
+    results: BatchResultItem[];
+    /** WAL offset (for atomic batches) */
+    walOffset?: bigint;
+}
+/**
+ * Server information from INFO operation.
+ */
+interface ServerInfo {
+    /** Server name */
+    serverName: string;
+    /** Server version */
+    serverVersion: string;
+    /** Protocol version */
+    protocolVersion: number;
+    /** Maximum payload size in bytes */
+    maxPayloadBytes?: number;
+    /** Maximum batch operations */
+    maxBatchOps?: number;
+    /** WAL segment size */
+    walSegmentSize?: number;
+    /** Whether authentication is required */
+    authRequired?: boolean;
+    /** Server features */
+    features?: string[];
+}
+/**
+ * Options for WAL_READ operation.
+ */
+interface WalReadOptions {
+    /** Maximum entries to read */
+    limit?: number;
+}
+/**
+ * A WAL entry.
+ */
+interface WalEntry {
+    /** WAL offset */
+    offset: bigint;
+    /** Entry type */
+    type: string;
+    /** Entry data */
+    data: Record<string, unknown>;
+    /** Timestamp */
+    timestamp: number;
+}
+/**
+ * Result of WAL_READ operation.
+ */
+interface WalReadResult {
+    /** WAL entries */
+    entries: WalEntry[];
+    /** Whether more entries exist */
+    hasMore: boolean;
+    /** Next offset for pagination */
+    nextOffset?: bigint;
+}
+/**
+ * Result of SNAPSHOT_INSTANCE operation.
+ */
+interface SnapshotResult {
+    /** Instance ID */
+    instanceId: string;
+    /** WAL offset of snapshot */
+    walOffset: bigint;
+    /** Snapshot size in bytes */
+    sizeBytes: number;
+}
+/**
+ * Options for COMPACT operation.
+ */
+interface CompactOptions {
+    /** Force compaction even if not needed */
+    force?: boolean;
+}
+/**
+ * Result of COMPACT operation.
+ */
+interface CompactResult {
+    /** Number of snapshots created */
+    snapshotsCreated: number;
+    /** Number of WAL segments deleted */
+    segmentsDeleted: number;
+    /** Bytes reclaimed */
+    bytesReclaimed: bigint;
+}
+
+/**
+ * Client events.
+ */
+interface ClientEvents {
+    connect: () => void;
+    disconnect: (error?: Error) => void;
+    error: (error: Error) => void;
+    reconnect: (attempt: number) => void;
+}
+/**
+ * The rstmdb client.
+ *
+ * @example
+ * ```typescript
+ * // Simple configuration
+ * const client = Client.connect('localhost', 7401);
+ *
+ * // With authentication
+ * const client = Client.connect('localhost', 7401, { auth: 'my-token' });
+ *
+ * // With full configuration object
+ * const client = new Client({
+ *   host: 'localhost',
+ *   port: 7401,
+ *   authToken: 'my-token',
+ *   tls: true,
+ * });
+ *
+ * // With builder pattern
+ * const client = new Client(
+ *   ClientOptions.create('localhost')
+ *     .port(7401)
+ *     .auth('my-token')
+ *     .tls(true)
+ *     .timeout({ connect: 5000, request: 15000 })
+ *     .build()
+ * );
+ * ```
+ */
+declare class Client extends EventEmitter {
+    private readonly connection;
+    private readonly subscriptions;
+    private readonly config;
+    constructor(config: ClientConfig);
+    /**
+     * Create a client and connect to the server.
+     *
+     * @param host - Server hostname
+     * @param port - Server port (default: 7401)
+     * @param options - Additional options
+     * @returns Connected client instance
+     *
+     * @example
+     * ```typescript
+     * const client = await Client.connect('localhost');
+     * const client = await Client.connect('localhost', 7401);
+     * const client = await Client.connect('localhost', 7401, { auth: 'token' });
+     * ```
+     */
+    static connect(host: string, port?: number, options?: {
+        auth?: string;
+        tls?: TlsConfig | boolean;
+        clientName?: string;
+    }): Promise<Client>;
+    /**
+     * Get the current configuration.
+     */
+    getConfig(): Readonly<ClientConfig>;
+    /**
+     * Connect to the server.
+     */
+    connect(): Promise<void>;
+    /**
+     * Close the connection.
+     */
+    close(): Promise<void>;
+    /**
+     * Check if connected to the server.
+     */
+    isConnected(): boolean;
+    /**
+     * Ping the server.
+     */
+    ping(): Promise<void>;
+    /**
+     * Get server information.
+     */
+    info(): Promise<ServerInfo>;
+    /**
+     * Create or update a state machine definition.
+     */
+    putMachine(machine: string, version: number, definition: MachineDefinition): Promise<PutMachineResult>;
+    /**
+     * Get a state machine definition.
+     */
+    getMachine(machine: string, version: number): Promise<GetMachineResult>;
+    /**
+     * List all state machines.
+     */
+    listMachines(options?: ListMachinesOptions): Promise<ListMachinesResult>;
+    /**
+     * Create a new state machine instance.
+     */
+    createInstance(machine: string, version: number, options?: CreateInstanceOptions): Promise<CreateInstanceResult>;
+    /**
+     * Get instance state and context.
+     */
+    getInstance(instanceId: string): Promise<GetInstanceResult>;
+    /**
+     * Delete an instance.
+     */
+    deleteInstance(instanceId: string, options?: DeleteInstanceOptions): Promise<void>;
+    /**
+     * Apply an event to an instance.
+     */
+    applyEvent(instanceId: string, event: string, options?: ApplyEventOptions): Promise<ApplyEventResult>;
+    /**
+     * Execute multiple operations in a batch.
+     */
+    batch(operations: BatchOperation[], options?: BatchOptions): Promise<BatchResult>;
+    /**
+     * Read entries from the write-ahead log.
+     */
+    walRead(fromOffset: bigint, options?: WalReadOptions): Promise<WalReadResult>;
+    /**
+     * Create a snapshot of an instance.
+     */
+    snapshotInstance(instanceId: string): Promise<SnapshotResult>;
+    /**
+     * Trigger WAL compaction.
+     */
+    compact(options?: CompactOptions): Promise<CompactResult>;
+    /**
+     * Watch a specific instance for state changes.
+     */
+    watchInstance(instanceId: string, options?: WatchOptions): Promise<Subscription>;
+    /**
+     * Watch all instances matching the filter.
+     */
+    watchAll(options?: WatchAllOptions): Promise<Subscription>;
+    /**
+     * Cancel a watch subscription.
+     */
+    unwatch(subscriptionId: string): Promise<void>;
+    on(event: 'connect', listener: () => void): this;
+    on(event: 'disconnect', listener: (error?: Error) => void): this;
+    on(event: 'error', listener: (error: Error) => void): this;
+    on(event: 'reconnect', listener: (attempt: number) => void): this;
+    once(event: 'connect', listener: () => void): this;
+    once(event: 'disconnect', listener: (error?: Error) => void): this;
+    once(event: 'error', listener: (error: Error) => void): this;
+    once(event: 'reconnect', listener: (attempt: number) => void): this;
+    off(event: 'connect', listener: () => void): this;
+    off(event: 'disconnect', listener: (error?: Error) => void): this;
+    off(event: 'error', listener: (error: Error) => void): this;
+    off(event: 'reconnect', listener: (attempt: number) => void): this;
+}
+
+/**
+ * Connection-related errors.
+ */
+declare class ConnectionError extends RstmdbError {
+    constructor(message: string, options?: {
+        cause?: Error;
+        details?: Record<string, unknown>;
+    });
+}
+/**
+ * Timeout errors.
+ */
+declare class TimeoutError extends RstmdbError {
+    constructor(message: string, options?: {
+        cause?: Error;
+        details?: Record<string, unknown>;
+    });
+}
+/**
+ * Protocol-level errors.
+ */
+declare class ProtocolError extends RstmdbError {
+    constructor(message: string, code?: ErrorCode, options?: {
+        cause?: Error;
+        details?: Record<string, unknown>;
+    });
+}
+/**
+ * Server-returned errors.
+ */
+declare class ServerError extends RstmdbError {
+    constructor(message: string, code: ErrorCode, options?: {
+        retryable?: boolean;
+        details?: Record<string, unknown>;
+        cause?: Error;
+    });
+    /**
+     * Create a ServerError from a server response.
+     */
+    static fromResponse(response: {
+        code: string;
+        message: string;
+        details?: Record<string, unknown>;
+    }): ServerError;
+}
+/**
+ * Resource not found errors.
+ */
+declare class NotFoundError extends ServerError {
+    constructor(message: string, code?: ErrorCode, options?: {
+        details?: Record<string, unknown>;
+        cause?: Error;
+    });
+}
+/**
+ * Conflict errors (resource already exists, version mismatch, etc.).
+ */
+declare class ConflictError extends ServerError {
+    constructor(message: string, code?: ErrorCode, options?: {
+        details?: Record<string, unknown>;
+        cause?: Error;
+    });
+}
+/**
+ * Authentication errors.
+ */
+declare class AuthenticationError extends ServerError {
+    constructor(message: string, code?: ErrorCode, options?: {
+        details?: Record<string, unknown>;
+        cause?: Error;
+    });
+}
+/**
+ * Invalid state transition errors.
+ */
+declare class InvalidTransitionError extends ServerError {
+    constructor(message: string, options?: {
+        details?: Record<string, unknown>;
+        cause?: Error;
+    });
+}
+/**
+ * Guard condition failed errors.
+ */
+declare class GuardFailedError extends ServerError {
+    constructor(message: string, options?: {
+        details?: Record<string, unknown>;
+        cause?: Error;
+    });
+}
+
+/**
+ * RCP frame magic bytes: "RCPX"
+ */
+declare const FRAME_MAGIC = 1380143192;
+/**
+ * Protocol version.
+ */
+declare const PROTOCOL_VERSION = 1;
+/**
+ * Frame header size in bytes (4 magic + 2 version + 2 flags + 2 header_len + 4 payload_len + 4 crc).
+ */
+declare const HEADER_SIZE = 18;
+/**
+ * Frame flags.
+ */
+declare enum FrameFlags {
+    NONE = 0,
+    CRC_PRESENT = 1,
+    COMPRESSED = 2,
+    STREAM = 4,
+    END_STREAM = 8
+}
+/**
+ * A decoded RCP frame.
+ */
+interface Frame {
+    flags: number;
+    payload: Buffer;
+}
+/**
+ * Encodes a payload into an RCP frame.
+ */
+declare class FrameEncoder {
+    private readonly useCrc;
+    constructor(options?: {
+        useCrc?: boolean;
+    });
+    /**
+     * Encode an object into an RCP frame.
+     */
+    encode(payload: object): Buffer;
+    /**
+     * Encode a stream frame.
+     */
+    encodeStream(payload: object, endStream?: boolean): Buffer;
+    /**
+     * Encode raw payload with specified flags.
+     */
+    private encodeRaw;
+}
+/**
+ * Decodes RCP frames from a byte stream.
+ */
+declare class FrameDecoder {
+    private buffer;
+    private readonly verifyCrc;
+    constructor(options?: {
+        verifyCrc?: boolean;
+    });
+    /**
+     * Append data to the internal buffer.
+     */
+    append(data: Buffer): void;
+    /**
+     * Try to decode a frame from the buffer.
+     * Returns null if not enough data is available.
+     */
+    decode(): Frame | null;
+    /**
+     * Reset the decoder state.
+     */
+    reset(): void;
+    /**
+     * Get the current buffer length.
+     */
+    get bufferedLength(): number;
+}
+
+/**
+ * RCP operation types.
+ */
+declare enum Operation {
+    HELLO = "HELLO",
+    AUTH = "AUTH",
+    PING = "PING",
+    INFO = "INFO",
+    PUT_MACHINE = "PUT_MACHINE",
+    GET_MACHINE = "GET_MACHINE",
+    LIST_MACHINES = "LIST_MACHINES",
+    CREATE_INSTANCE = "CREATE_INSTANCE",
+    GET_INSTANCE = "GET_INSTANCE",
+    DELETE_INSTANCE = "DELETE_INSTANCE",
+    APPLY_EVENT = "APPLY_EVENT",
+    BATCH = "BATCH",
+    WAL_READ = "WAL_READ",
+    SNAPSHOT_INSTANCE = "SNAPSHOT_INSTANCE",
+    COMPACT = "COMPACT",
+    WATCH_INSTANCE = "WATCH_INSTANCE",
+    WATCH_ALL = "WATCH_ALL",
+    UNWATCH = "UNWATCH"
+}
+
+export { type ApplyEventOptions, type ApplyEventResult, AuthenticationError, type BatchOperation, type BatchOptions, type BatchResult, type BatchResultItem, Client, type ClientConfig, type ClientEvents, ClientOptions, type CompactOptions, type CompactResult, ConflictError, ConnectionError, type CreateInstanceOptions, type CreateInstanceResult, DEFAULT_CONFIG, type DeleteInstanceOptions, ErrorCode, FRAME_MAGIC, type Frame, FrameDecoder, FrameEncoder, FrameFlags, type GetInstanceResult, type GetMachineResult, GuardFailedError, HEADER_SIZE, InvalidTransitionError, type ListMachinesOptions, type ListMachinesResult, type MachineDefinition, type MachineListItem, NotFoundError, Operation, PROTOCOL_VERSION, ProtocolError, type PutMachineResult, type ResolvedConfig, RstmdbError, ServerError, type ServerInfo, type SnapshotResult, type StreamEvent, type Subscription, TimeoutError, type TlsConfig, type Transition, type WalEntry, type WalReadOptions, type WalReadResult, type WatchAllOptions, type WatchOptions };