@arbitro/client 0.2.0

package/dist/index.d.ts

@@ -0,0 +1,602 @@
+import { ZodRawShape, ZodObject, output } from 'zod';
+
+type LogFn = {
+    (msg: string): void;
+    (obj: object, msg: string): void;
+};
+interface Logger {
+    trace: LogFn;
+    debug: LogFn;
+    info: LogFn;
+    warn: LogFn;
+    error: LogFn;
+    child(bindings: Record<string, unknown>): Logger;
+}
+
+declare enum DeliverPolicy {
+    All = "All",
+    Last = "Last",
+    New = "New",
+    BySeq = "ByStartSeq",
+    ByTime = "ByStartTime"
+}
+declare enum JournalType {
+    Memory = "Memory",
+    Tolerant = "Tolerant",
+    Strict = "Strict"
+}
+declare enum AckPolicy {
+    Explicit = "explicit",
+    None = "none"
+}
+interface FlushConfig {
+    intervalMs?: number;
+    maxMessages?: number;
+    maxBytes?: number;
+}
+type JournalConfig = {
+    type: JournalType.Memory;
+} | {
+    type: JournalType.Tolerant;
+} | {
+    type: JournalType.Strict;
+    flush?: FlushConfig;
+};
+interface StreamConfig {
+    subjectFilter: string;
+    journal?: JournalConfig;
+    maxMsgs?: number;
+    maxBytes?: number;
+    maxAgeMs?: number;
+    /**
+     * Per-stream broker-side dedup window in milliseconds.
+     *
+     * - `0` or undefined (default): no dedup. Every publish is stored;
+     *   `msgId` is ignored.
+     * - `>0`: any publish that carries a `msgId` matching one the
+     *   broker has stored for THIS stream within the last
+     *   `idempotencyWindowMs` is rejected with the `IdempotencyDuplicate`
+     *   wire error. Useful for safe retries — the first publish wins.
+     *
+     * The broker clamps requested windows above 5 minutes (300 000 ms)
+     * down to that ceiling, matching JetStream behaviour.
+     */
+    idempotencyWindowMs?: number;
+}
+interface DeleteStreamOpts {
+    deleteData?: boolean;
+}
+interface StreamInfo {
+    name: string;
+    config: StreamConfig;
+    lastSeq: number;
+}
+/**
+ * Per-subject inflight cap. Each entry caps the number of in-flight
+ * (delivered, unacked) messages on subjects matching `pattern`. Patterns
+ * may use NATS-style wildcards (`*`, `>`).
+ *
+ * Only enforced when the owning consumer's `ackPolicy` is `Explicit`;
+ * silently dropped server-side for fire-and-forget consumers (because
+ * fire-and-forget bindings skip inflight tracking entirely).
+ */
+interface SubjectInflightLimit {
+    pattern: string;
+    limit: number;
+}
+interface ConsumerConfig {
+    name?: string;
+    filter?: string;
+    fanout?: boolean;
+    /** Consumer-side ACK policy. None = fire-and-forget delivery, Explicit = consumer must ACK. */
+    ackPolicy?: AckPolicy;
+    deliverPolicy?: DeliverPolicy;
+    startSeq?: bigint;
+    startTime?: bigint;
+    maxAckPending?: number;
+    ackWaitMs?: number;
+    maxDeliver?: number;
+    removeUnusedAfterMs?: number;
+    /**
+     * Per-subject max inflight (list of pattern → limit pairs).
+     * Only effective with `ackPolicy: Explicit`.
+     */
+    maxSubjectInflights?: SubjectInflightLimit[];
+}
+interface ConsumerInfo {
+    group: string;
+    stream: string;
+    config: ConsumerConfig;
+}
+interface SubscribeOptions {
+    fetchTimeoutMs?: number;
+}
+interface ReconnectConfig {
+    enabled?: boolean;
+    maxAttempts?: number;
+    intervalMs?: number;
+    jitter?: boolean;
+}
+interface TlsConfig {
+    enabled?: boolean;
+    ca?: Buffer | string;
+    cert?: Buffer | string;
+    key?: Buffer | string;
+}
+interface ClientConfig {
+    servers: string[];
+    prefix?: string;
+    timeout?: number;
+    reconnect?: ReconnectConfig;
+    tls?: TlsConfig;
+    logger?: Logger;
+}
+
+declare class ArbitroError extends Error {
+    readonly code: 'connect' | 'timeout' | 'protocol' | 'server' | 'closed';
+    readonly brokerName?: string | undefined;
+    readonly brokerDetails?: unknown | undefined;
+    /**
+     * Numeric wire error code from the broker's `RepError` frame. Only
+     * populated when `code === 'server'`. Use the `ErrorCode` enum to
+     * compare (e.g. `err.wireCode === ErrorCode.IdempotencyDuplicate`).
+     */
+    readonly wireCode?: number | undefined;
+    constructor(message: string, code: 'connect' | 'timeout' | 'protocol' | 'server' | 'closed', brokerName?: string | undefined, brokerDetails?: unknown | undefined, 
+    /**
+     * Numeric wire error code from the broker's `RepError` frame. Only
+     * populated when `code === 'server'`. Use the `ErrorCode` enum to
+     * compare (e.g. `err.wireCode === ErrorCode.IdempotencyDuplicate`).
+     */
+    wireCode?: number | undefined);
+}
+/**
+ * Wire-level error codes. Mirrors the `ErrorCode` enum in
+ * `arbitro-proto`. New codes added to the broker MUST be appended here
+ * with the matching numeric value.
+ */
+declare const ErrorCode: {
+    readonly UnknownAction: 1;
+    readonly BufferTooShort: 2;
+    readonly InvalidLength: 3;
+    readonly InvalidEntryCount: 4;
+    readonly AuthRequired: 257;
+    readonly AuthFailed: 258;
+    readonly StreamNotFound: 513;
+    readonly StreamAlreadyExists: 514;
+    readonly StreamFull: 515;
+    readonly StreamFilterOverlap: 516;
+    readonly SubjectNotFound: 517;
+    /** Publish carried a `msgId` already seen for this stream within
+     * `idempotencyWindowMs`. Original write stands; safe to treat as
+     * a successful publish at the application level. */
+    readonly IdempotencyDuplicate: 518;
+    readonly ConsumerNotFound: 769;
+    readonly ConsumerAlreadyExists: 770;
+    readonly ConsumerFilterOverlap: 771;
+    readonly InvalidSequence: 1025;
+    readonly MaxInflightReached: 1026;
+    readonly AckTimeout: 1027;
+    readonly ServerShuttingDown: 1281;
+    readonly InternalError: 1282;
+};
+type ErrorCodeValue = (typeof ErrorCode)[keyof typeof ErrorCode];
+
+interface ClientMetricsSnapshot {
+    /** Calls to `publish` / `publishAck` / `publishBatch` entries. */
+    publishesSent: number;
+    /** Total entries inside `publishBatch` calls (summed across batches). */
+    publishBatchEntries: number;
+    /** `Deliver` frames received from the broker (one per message). */
+    deliveriesReceived: number;
+    /** Currently-open subscriptions (gauge — inc at subscribe, dec at close). */
+    activeSubscriptions: number;
+    /** `Ack` frames sent to the broker. */
+    acksSent: number;
+    /** `Nack` frames sent to the broker. */
+    nacksSent: number;
+    /** Successful reconnections after a session drop. */
+    reconnects: number;
+    /** Outstanding pending request-reply slots (gauge). */
+    pendingReplies: number;
+}
+/**
+ * Live atomic-ish counters. JavaScript is single-threaded per worker so
+ * plain `++` is sufficient — no `Atomics` needed.
+ *
+ * Held on `ArbitroClient` and shared with `Connection` so the demux loop
+ * can bump `deliveriesReceived` directly. Public `snapshot()` returns a
+ * frozen copy for logging or external scraping.
+ */
+declare class ClientMetrics {
+    publishesSent: number;
+    publishBatchEntries: number;
+    deliveriesReceived: number;
+    activeSubscriptions: number;
+    acksSent: number;
+    nacksSent: number;
+    reconnects: number;
+    pendingReplies: number;
+    snapshot(): ClientMetricsSnapshot;
+}
+
+type DeliveryHandler = (frame: Buffer) => void;
+declare class Connection {
+    private readonly reconnectAddr?;
+    private readonly reconnectCfg?;
+    private seq;
+    private connId;
+    private framer;
+    private routes;
+    private pending;
+    private socket;
+    private closing;
+    private readonly log;
+    private activeSubs;
+    private metrics?;
+    private constructor();
+    private attachSocket;
+    static connect(addr: string, timeoutMs?: number, tlsCfg?: TlsConfig, reconnectCfg?: ReconnectConfig, logger?: Logger): Promise<Connection>;
+    nextSeq(): bigint;
+    /**
+     * Attach a metrics sink. Called by `ArbitroClient` after `connect()`.
+     * The connection bumps `deliveriesReceived` on every Deliver/RepBatch
+     * entry and `reconnects` on successful reconnections. Unset = no-op.
+     */
+    setMetrics(m: ClientMetrics): void;
+    private resolvePending;
+    private rejectPending;
+    private onFrame;
+    private handleBatchDeliver;
+    sendSubscribeV2(consumerId: number, filter: Buffer, handler: DeliveryHandler, onRenew?: (newConsumerId: number) => void): Promise<number>;
+    cancelSubscription(consumerId: number): void;
+    private resubscribeAll;
+    registerRoute(consumerId: number, handler: DeliveryHandler): void;
+    unregisterRoute(consumerId: number): void;
+    send(frame: Buffer): void;
+    /** Send frame and wait for RepOk. Returns the ref_seq from body. */
+    sendExpectReply(frame: Buffer, timeoutMs?: number): Promise<bigint>;
+    /** Send frame and wait for full reply frame buffer. */
+    sendExpectReplyRaw(frame: Buffer, timeoutMs?: number): Promise<Buffer>;
+    close(): Promise<void>;
+    private drain;
+    private handleClose;
+    private tryReconnect;
+}
+
+/**
+ * One entry of a `publishBatch` call.
+ *
+ * `msgId` (optional) is an opaque byte string the broker uses for
+ * per-stream deduplication when the target stream was created with
+ * `idempotencyWindowMs > 0`. Leaving it empty/undefined disables
+ * dedup for this entry (mixing dedup + non-dedup entries in a single
+ * batch is allowed).
+ */
+interface BatchPublishEntry {
+    subject: string;
+    payload: Buffer;
+    msgId?: Buffer;
+}
+
+/**
+ * Optional per-publish options.
+ *
+ * `msgId` is an opaque byte string the broker uses for dedup when the
+ * target stream was created with `idempotencyWindowMs > 0`. Empty or
+ * undefined means "no dedup for this publish" — safe to omit on
+ * non-idempotent streams.
+ */
+interface PublishOpts {
+    msgId?: Buffer | string;
+}
+
+declare function encodeString(s: string): Buffer;
+declare function decodeString(buf: Buffer): string;
+
+declare function encodeJson(value: unknown): Buffer;
+declare function decodeJson<T = unknown>(buf: Buffer): T;
+
+/** Core encode/decode contract. `fields` is required only for schema-based codecs
+ *  that power LazyMessage<T> getters — other encodings may omit it. */
+interface Encoding<T> {
+    encode(value: T): Buffer;
+    decode(buf: Buffer): T;
+    readonly fields?: string[];
+}
+/** Maps a FieldType string literal to its corresponding TypeScript type. */
+type FieldTypeMap = {
+    string: string;
+    number: number;
+    boolean: boolean;
+    bigint: bigint;
+    buffer: Buffer;
+    unknown: unknown;
+};
+/** Infers the TypeScript record type from a schema definition.
+ *  Eliminates the need to define both an interface and a Schema<T>. */
+type InferSchema<S extends Record<string, FieldType>> = {
+    [K in keyof S]: FieldTypeMap[S[K]];
+};
+declare abstract class TextEncoding implements Encoding<string> {
+    abstract readonly encoding: BufferEncoding;
+    encode(value: string): Buffer;
+    decode(buf: Buffer): string;
+}
+declare class StringCodec extends TextEncoding {
+    readonly encoding: BufferEncoding;
+    constructor(encoding?: BufferEncoding);
+}
+declare class JsonCodec<T> implements Encoding<T> {
+    private readonly text;
+    constructor(encoding?: BufferEncoding);
+    encode(value: T): Buffer;
+    decode(buf: Buffer): T;
+}
+type FieldType = 'string' | 'number' | 'boolean' | 'bigint' | 'buffer' | 'unknown';
+type Schema<T> = {
+    [K in keyof Required<T>]: FieldType;
+};
+declare class Codec<T extends Record<string, unknown>> implements Encoding<T> {
+    readonly fields: (keyof T & string)[];
+    private readonly packr;
+    private readonly unpackr;
+    constructor(schema: Schema<T>);
+    encode(value: T): Buffer;
+    decode(buf: Buffer): T;
+}
+/** Creates a msgpack Codec with the TypeScript type inferred from the schema definition. */
+declare function schema<S extends Record<string, FieldType>>(def: S): Codec<InferSchema<S>>;
+
+type SendFn = (frame: Buffer) => void;
+declare class Message {
+    private readonly frame;
+    private readonly send;
+    private readonly seqFn;
+    private _subjectLen;
+    constructor(frame: Buffer, send: SendFn, seqFn: () => bigint);
+    /** Delivery sequence — used to ack/nack this message. */
+    seq(): bigint;
+    /** Consumer ID that received this delivery. */
+    consumerId(): number;
+    /** Subject hash — echoed back in ack for O(1) credit release. */
+    subjectHash(): number;
+    private subjLen;
+    /** Zero-copy view of the subject bytes. */
+    subject(): Buffer;
+    /** Zero-copy view of the payload bytes. */
+    data(): Buffer;
+    /** Acknowledge — fire-and-forget to broker. */
+    ack(): void;
+    /** Negative acknowledge — immediate requeue. */
+    nack(): void;
+    /** Negative acknowledge with redelivery delay (ms). */
+    nackDelay(ms: number): void;
+}
+
+type MsgCallback$1 = (msg: Message) => void;
+declare class Subscription {
+    private consumerId;
+    private readonly conn;
+    private readonly streamName;
+    private readonly fetchTimeoutMs;
+    private callback;
+    private fetchQueue;
+    private msgBuf;
+    private closed;
+    constructor(consumerId: number, conn: Connection, streamName: string, fetchTimeoutMs: number);
+    /** Consumer ID assigned by the server. */
+    id(): number;
+    deliver(frame: Buffer): void;
+    onMessage(cb: MsgCallback$1): void;
+    fetch(count: number, timeoutMs?: number): Promise<Message[]>;
+    close(): void;
+}
+
+type LazyMessage<T> = T & {
+    readonly _raw: Buffer;
+    decode(): T;
+    ack(): void;
+    nack(): void;
+    nackDelay(delayMs: number): void;
+};
+declare function makeLazyMessage<T extends Record<string, unknown>>(raw: Buffer, codec: Encoding<T>, fields: string[], onAck: () => void, onNack: () => void, onNackDelay?: (ms: number) => void): LazyMessage<T>;
+
+type RawCallback = (msg: Message) => void;
+declare class Consumer {
+    private readonly client;
+    readonly streamName: string;
+    readonly config: ConsumerConfig;
+    private _consumerId?;
+    constructor(client: ArbitroClient, streamName: string, config: ConsumerConfig, _consumerId?: number | undefined);
+    get name(): string;
+    get consumerId(): number | undefined;
+    /**
+     * Publish through this consumer's stream. Returns `Promise<void>` that
+     * resolves on broker `RepOk`. Await to wait, or ignore for
+     * fire-and-forget semantics — the caller's choice, on the same call.
+     */
+    publish(subject: string, data: Buffer): Promise<void>;
+    create(): Promise<this>;
+    upsert(): Promise<this>;
+    delete(): Promise<void>;
+    exists(): Promise<boolean>;
+    /**
+     * Live pending-ack count for this consumer (delivered, not yet acked).
+     * Uses the cached consumer ID when available; otherwise looks it up
+     * from `streamName + name`. Equivalent of NATS `num_ack_pending`.
+     */
+    getPendings(): Promise<number>;
+    subscribe(cb?: RawCallback, opts?: SubscribeOptions): Promise<Subscription>;
+    subscribe<T extends Record<string, unknown>>(codec: Encoding<T>, cb: (msg: LazyMessage<T>) => void, opts?: SubscribeOptions): Promise<Subscription>;
+}
+
+type MsgCallback = (msg: Message) => void;
+declare class ArbitroClient {
+    private conn;
+    private readonly cfg;
+    private readonly tls;
+    private readonly logger;
+    private readonly sidCache;
+    private readonly _metrics;
+    constructor(config: ClientConfig);
+    connect(): Promise<this>;
+    /**
+     * Point-in-time snapshot of client counters: publishes sent, deliveries
+     * received, acks/nacks, active subscriptions, reconnects. Cheap — just
+     * reads plain integer fields. Call on a timer to chart throughput.
+     */
+    metrics(): ClientMetricsSnapshot;
+    /** Internal connection accessor for Stream/Consumer publish methods. */
+    _conn(): Connection;
+    /** Default timeout from config. */
+    get timeout(): number;
+    /** Apply prefix to subject if configured. */
+    private prefixed;
+    /**
+     * Publish a message. Returns a `Promise<void>` that resolves once the
+     * broker confirms receipt (`RepOk`). The TS idiom is "everything async,
+     * the caller chooses to await":
+     *
+     *   await client.publish(s, subj, data)               // wait for ack
+     *   client.publish(s, subj, data)                     // fire-and-forget
+     *   client.publish(s, subj, data).catch(handleError)  // async error path
+     *
+     * The broker always emits `RepOk` regardless of whether the caller
+     * awaits — that's what enables the same call site to support both
+     * semantics. A "no-reply" path doesn't save wire bytes, so it isn't
+     * exposed.
+     */
+    publish(streamName: string, subject: string, data: Buffer, opts?: PublishOpts): Promise<void>;
+    /**
+     * @deprecated alias for {@link publish}. The default `publish` already
+     * waits for `RepOk` and returns a Promise, so this method is identical.
+     */
+    publishAck(streamName: string, subject: string, data: Buffer, opts?: PublishOpts): Promise<void>;
+    /** Batch publish — single V2 BatchPubFrame, ONE round-trip. Resolves
+     * to `first_seq` (sequence of the first message in the batch; the N
+     * messages occupy `[first_seq, first_seq + N - 1]`).
+     *
+     * Mirrors `publish`: the call always exchanges request/response with
+     * the broker. The caller decides whether to actually wait:
+     *
+     *   await client.publishBatch(stream, msgs)   // barrier
+     *   client.publishBatch(stream, msgs)         // fire-and-forget (promise dropped)
+     *   client.publishBatch(stream, msgs)         //   (suppress unhandled rejection)
+     *     .catch(() => {})
+     *
+     * Each entry may carry an optional `msgId` for broker-side dedup on
+     * streams created with `idempotencyWindowMs > 0`. If any entry
+     * collides with a previously-stored id (or another entry in the
+     * SAME batch), the whole batch is rejected — `publishBatch` is
+     * atomic.
+     */
+    publishBatch(streamName: string, messages: BatchPublishEntry[]): Promise<bigint>;
+    /** Request-reply. */
+    request(streamName: string, subject: string, data: Buffer, timeoutMs?: number): Promise<Buffer>;
+    /** Subscribe with explicit consumer config. */
+    subscribe(streamName: string, config: ConsumerConfig, callback?: MsgCallback, opts?: SubscribeOptions): Promise<Subscription>;
+    /** Subscribe by consumer name only (consumer must already exist). */
+    subscribe(streamName: string, callback: MsgCallback): Promise<Subscription>;
+    createStream(name: string, config: StreamConfig): Promise<Stream>;
+    upsertStream(name: string, config: StreamConfig): Promise<Stream>;
+    deleteStream(name: string, _opts?: DeleteStreamOpts): Promise<void>;
+    getStreamInfo(name: string): Promise<StreamInfo | null>;
+    listStreams(): Promise<StreamInfo[]>;
+    streamExists(name: string): Promise<boolean>;
+    purgeStream(name: string): Promise<number>;
+    drainSubject(streamName: string, subject: string): Promise<number>;
+    createConsumer(streamName: string, config: ConsumerConfig): Promise<Consumer>;
+    private createConsumerRaw;
+    upsertConsumer(streamName: string, config: ConsumerConfig): Promise<Consumer>;
+    /** Delete consumer by server-assigned ID. */
+    deleteConsumer(consumerId: number): Promise<void>;
+    /** Delete consumer by stream + name (lookup ID first). */
+    deleteConsumer(streamName: string, name: string): Promise<void>;
+    getConsumerId(streamName: string, name: string): Promise<number | null>;
+    consumerExists(streamName: string, name: string): Promise<boolean>;
+    /**
+     * Live pending-ack count for one consumer — the number of messages the
+     * consumer has been delivered but not yet acked. Equivalent of NATS
+     * JetStream's `num_ack_pending`. Single broker round-trip; engine cost
+     * is one O(1) Vec read per shard.
+     */
+    getPending(consumerId: number): Promise<number>;
+    getPending(streamName: string, name: string): Promise<number>;
+    getConsumerInfo(streamName: string, name: string): Promise<ConsumerInfo | null>;
+    listConsumers(streamName?: string): Promise<ConsumerInfo[]>;
+    /** Resolve stream name → server wire_hash_32. Caches the result. */
+    private resolveStreamId;
+    /** Get cached stream_id or throw (for sync fire-and-forget paths). */
+    private cachedSid;
+    private ensureConsumer;
+    /** Pre-resolve stream_id from server (GetStream). Required before sync publish(). */
+    resolveStream(name: string): Promise<void>;
+    stream(name: string, config?: StreamConfig): Stream;
+    close(): Promise<void>;
+}
+
+declare class Stream {
+    private readonly client;
+    readonly name: string;
+    private _config;
+    constructor(client: ArbitroClient, name: string, config?: StreamConfig);
+    get config(): StreamConfig | undefined;
+    create(config?: StreamConfig): Promise<this>;
+    upsert(config?: StreamConfig): Promise<this>;
+    delete(opts?: DeleteStreamOpts): Promise<void>;
+    exists(): Promise<boolean>;
+    info(): Promise<StreamInfo | null>;
+    /**
+     * Publish to this stream. Returns a `Promise<void>` that resolves on
+     * broker `RepOk`. Await it to wait for confirmation, or ignore the
+     * returned promise for fire-and-forget semantics.
+     *
+     * Pass `opts.msgId` to opt this publish into broker-side dedup on
+     * streams created with `idempotencyWindowMs > 0`. Duplicate ids
+     * within the window are rejected with a `ClientError` carrying the
+     * `IdempotencyDuplicate` code.
+     */
+    publish(subject: string, data: Buffer, opts?: PublishOpts): Promise<void>;
+    /** @deprecated alias for {@link publish}. */
+    publishAck(subject: string, data: Buffer, opts?: PublishOpts): Promise<void>;
+    /** Batch publish — single V2 BatchPubFrame, ONE round-trip.
+     *  Resolves with `first_seq` (the N messages occupy
+     *  `[first_seq, first_seq + N - 1]`).
+     *
+     *  Like {@link publish}, the call always exchanges request/response
+     *  with the broker; the caller decides whether to wait via `await`. */
+    publishBatch(messages: BatchPublishEntry[]): Promise<bigint>;
+    request(subject: string, data: Buffer, timeoutMs?: number): Promise<Buffer>;
+    consumer(overrides?: Partial<ConsumerConfig>): Consumer;
+    topic<T extends Record<string, unknown>>(subject: string, codec: Encoding<T>): Topic<T>;
+}
+
+declare class Topic<T extends Record<string, unknown>> {
+    private readonly stream;
+    private readonly subject;
+    private readonly codec;
+    private readonly fields;
+    constructor(stream: Stream, subject: string, codec: Encoding<T>);
+    publish(value: T): void;
+    publishAck(value: T): Promise<void>;
+    publishBatch(values: T[]): void;
+    subscribe(group: string, cb: (msg: LazyMessage<T>) => void): Promise<Subscription>;
+}
+
+declare function streamId(name: Buffer | string): number;
+
+/** Wraps a ZodObject schema as an Encoding<T>.
+ *
+ *  - encode: msgpack (no Zod overhead — bytes out)
+ *  - decode: msgpack unpack → schema.parse() (validates on inbound data)
+ *  - fields: Object.keys(schema.shape) — powers LazyMessage<T> getters
+ *
+ *  Validation cost on decode is intentional and acceptable on the management
+ *  path. Do NOT use zodCodec on a hot publish loop.
+ */
+declare function zodCodec<S extends ZodRawShape>(zodSchema: ZodObject<S>): Encoding<output<ZodObject<S>>> & {
+    readonly fields: string[];
+};
+
+export { AckPolicy, ArbitroClient, ArbitroError, type BatchPublishEntry, type ClientConfig, type ClientMetricsSnapshot, Codec, Consumer, type ConsumerConfig, type ConsumerInfo, type DeleteStreamOpts, DeliverPolicy, type Encoding, ErrorCode, type ErrorCodeValue, type FieldType, type FieldTypeMap, type FlushConfig, type InferSchema, type JournalConfig, JournalType, JsonCodec, type LazyMessage, type LogFn, type Logger, Message, type PublishOpts, type ReconnectConfig, type Schema, Stream, type StreamConfig, type StreamInfo, StringCodec, type SubjectInflightLimit, type SubscribeOptions, Subscription, type TlsConfig, Topic, decodeJson, decodeString, encodeJson, encodeString, makeLazyMessage, schema, streamId, zodCodec };