nats.do 0.1.0

package/dist/types.d.cts

@@ -0,0 +1,444 @@
+export { E as Env } from './env-Ds3wIkQg.cjs';
+
+/**
+ * Core NATS Types
+ *
+ * Implements types compatible with the nats.js library.
+ */
+interface ConnectionOptions {
+    servers: string | string[];
+    name?: string;
+    token?: string;
+    user?: string;
+    pass?: string;
+    timeout?: number;
+    reconnect?: boolean;
+    maxReconnectAttempts?: number;
+    reconnectTimeWait?: number;
+}
+interface MsgHdrs {
+    get(key: string): string | undefined;
+    set(key: string, value: string): void;
+    append(key: string, value: string): void;
+    has(key: string): boolean;
+    delete(key: string): void;
+    keys(): IterableIterator<string>;
+    values(key: string): string[];
+    code?: number;
+    description?: string;
+}
+declare function createHeaders(): MsgHdrs;
+interface Msg {
+    subject: string;
+    data: Uint8Array;
+    sid: number;
+    reply?: string;
+    headers?: MsgHdrs;
+    respond(data?: Uint8Array, opts?: PublishOptions): boolean;
+    string(): string;
+    json<T = unknown>(): T;
+}
+interface PublishOptions {
+    reply?: string;
+    headers?: MsgHdrs;
+}
+interface SubscriptionOptions {
+    queue?: string;
+    max?: number;
+    callback?: (err: Error | null, msg: Msg) => void;
+    timeout?: number;
+}
+interface RequestOptions {
+    timeout?: number;
+    headers?: MsgHdrs;
+    noMux?: boolean;
+}
+interface Subscription extends AsyncIterable<Msg> {
+    getSubject(): string;
+    unsubscribe(max?: number): void;
+    drain(): Promise<void>;
+    isClosed(): boolean;
+    getReceived(): number;
+    getMax(): number | undefined;
+}
+interface QueuedIterator<T> extends AsyncIterator<T> {
+    [Symbol.asyncIterator](): AsyncIterator<T>;
+    stop(): void;
+}
+type StatusType = 'disconnect' | 'reconnecting' | 'reconnect' | 'update' | 'ldm' | 'error';
+interface Status {
+    type: StatusType;
+    data?: string | Error | {
+        added?: string[];
+        deleted?: string[];
+    };
+}
+interface ServerInfo {
+    server_id: string;
+    server_name: string;
+    version: string;
+    proto: number;
+    host: string;
+    port: number;
+    max_payload: number;
+    jetstream?: boolean;
+    client_id?: number;
+    client_ip?: string;
+}
+interface NatsConnection {
+    publish(subject: string, data?: Uint8Array, opts?: PublishOptions): void;
+    subscribe(subject: string, opts?: SubscriptionOptions): Subscription;
+    request(subject: string, data?: Uint8Array, opts?: RequestOptions): Promise<Msg>;
+    flush(): Promise<void>;
+    drain(): Promise<void>;
+    close(): Promise<void>;
+    closed(): Promise<void | Error>;
+    status(): AsyncIterable<Status>;
+    isClosed(): boolean;
+    isDraining(): boolean;
+    getServer(): string;
+    info?: ServerInfo;
+}
+interface Codec<T> {
+    encode(data: T): Uint8Array;
+    decode(data: Uint8Array): T;
+}
+declare function StringCodec(): Codec<string>;
+declare function JSONCodec<T = unknown>(): Codec<T>;
+declare const Empty: Uint8Array;
+
+/**
+ * JetStream Types
+ *
+ * Implements types compatible with @nats-io/jetstream library.
+ */
+type RetentionPolicy = 'limits' | 'interest' | 'workqueue';
+type StorageType = 'file' | 'memory';
+type DiscardPolicy = 'old' | 'new';
+type AckPolicy = 'none' | 'all' | 'explicit';
+type DeliverPolicy = 'all' | 'last' | 'new' | 'by_start_sequence' | 'by_start_time' | 'last_per_subject';
+type ReplayPolicy = 'instant' | 'original';
+interface StreamConfig {
+    name: string;
+    subjects: string[];
+    description?: string;
+    retention?: RetentionPolicy;
+    storage?: StorageType;
+    max_msgs?: number;
+    max_bytes?: number;
+    max_age?: number;
+    max_msg_size?: number;
+    max_msgs_per_subject?: number;
+    max_consumers?: number;
+    discard?: DiscardPolicy;
+    discard_new_per_subject?: boolean;
+    duplicate_window?: number;
+    num_replicas?: number;
+    deny_delete?: boolean;
+    deny_purge?: boolean;
+    allow_rollup_hdrs?: boolean;
+    allow_direct?: boolean;
+    mirror_direct?: boolean;
+    sealed?: boolean;
+    placement?: {
+        cluster?: string;
+        tags?: string[];
+    };
+    mirror?: {
+        name: string;
+        opt_start_seq?: number;
+        opt_start_time?: string;
+        filter_subject?: string;
+    };
+    sources?: Array<{
+        name: string;
+        opt_start_seq?: number;
+        opt_start_time?: string;
+        filter_subject?: string;
+    }>;
+    republish?: {
+        src: string;
+        dest: string;
+        headers_only?: boolean;
+    };
+    subject_transform?: {
+        src: string;
+        dest: string;
+    };
+}
+declare function defaultStreamConfig(name: string): StreamConfig;
+interface StreamState {
+    messages: number;
+    bytes: number;
+    first_seq: number;
+    first_ts?: string;
+    last_seq: number;
+    last_ts?: string;
+    consumer_count: number;
+    num_deleted?: number;
+    num_subjects?: number;
+    subjects?: Record<string, number>;
+}
+interface StreamInfo {
+    config: StreamConfig;
+    state: StreamState;
+    created: string;
+    cluster?: {
+        name?: string;
+        leader?: string;
+        replicas?: Array<{
+            name: string;
+            current: boolean;
+            active: number;
+            lag: number;
+        }>;
+    };
+    mirror?: {
+        name: string;
+        lag: number;
+        active: number;
+    };
+    sources?: Array<{
+        name: string;
+        lag: number;
+        active: number;
+    }>;
+}
+interface ConsumerConfig {
+    name?: string;
+    durable_name?: string;
+    description?: string;
+    deliver_policy?: DeliverPolicy;
+    opt_start_seq?: number;
+    opt_start_time?: string;
+    ack_policy: AckPolicy;
+    ack_wait?: number;
+    max_deliver?: number;
+    filter_subject?: string;
+    filter_subjects?: string[];
+    replay_policy?: ReplayPolicy;
+    rate_limit_bps?: number;
+    sample_freq?: string;
+    max_waiting?: number;
+    max_ack_pending?: number;
+    headers_only?: boolean;
+    max_batch?: number;
+    max_expires?: number;
+    max_bytes?: number;
+    inactive_threshold?: number;
+    backoff?: number[];
+    num_replicas?: number;
+    mem_storage?: boolean;
+    metadata?: Record<string, string>;
+}
+declare function defaultConsumerConfig(): ConsumerConfig;
+interface SequencePair {
+    consumer_seq: number;
+    stream_seq: number;
+}
+interface ConsumerInfo {
+    stream_name: string;
+    name: string;
+    config: ConsumerConfig;
+    created: string;
+    delivered: SequencePair;
+    ack_floor: SequencePair;
+    num_ack_pending: number;
+    num_redelivered: number;
+    num_waiting: number;
+    num_pending: number;
+    cluster?: {
+        name?: string;
+        leader?: string;
+    };
+    push_bound?: boolean;
+}
+interface PubAck {
+    stream: string;
+    seq: number;
+    duplicate?: boolean;
+    domain?: string;
+}
+interface JsMsgInfo {
+    stream: string;
+    consumer: string;
+    delivered: number;
+    streamSequence: number;
+    consumerSequence: number;
+    timestampNanos: bigint;
+    pending: number;
+    redelivered: boolean;
+    redeliveryCount?: number;
+}
+interface JsMsg {
+    subject: string;
+    data: Uint8Array;
+    headers?: MsgHdrs;
+    seq: number;
+    info: JsMsgInfo;
+    ack(): void;
+    nak(delay?: number): void;
+    working(): void;
+    term(reason?: string): void;
+    ackAck(): Promise<boolean>;
+    string?(): string;
+    json?<T = unknown>(): T;
+}
+interface PullOptions {
+    max_messages?: number;
+    max_bytes?: number;
+    expires?: number;
+    idle_heartbeat?: number;
+    batch?: number;
+    no_wait?: boolean;
+}
+interface ConsumeOptions {
+    max_messages?: number;
+    max_bytes?: number;
+    expires?: number;
+    idle_heartbeat?: number;
+    callback?: (msg: JsMsg) => void | Promise<void>;
+}
+interface ConsumerMessages extends AsyncIterable<JsMsg> {
+    close(): Promise<void>;
+    stop(): Promise<void>;
+}
+interface Stream {
+    info(cached?: boolean): Promise<StreamInfo>;
+    getMessage(query: {
+        seq?: number;
+        last_by_subj?: string;
+        next_by_subj?: string;
+    }): Promise<StoredMsg | null>;
+    deleteMessage(seq: number, erase?: boolean): Promise<boolean>;
+}
+interface StoredMsg {
+    subject: string;
+    data: Uint8Array;
+    headers?: MsgHdrs;
+    seq: number;
+    time: string;
+}
+interface Consumer {
+    info(cached?: boolean): Promise<ConsumerInfo>;
+    consume(opts?: ConsumeOptions): Promise<ConsumerMessages>;
+    fetch(opts?: PullOptions): Promise<ConsumerMessages>;
+    delete(): Promise<boolean>;
+}
+interface PurgeResponse {
+    success: boolean;
+    purged: number;
+}
+interface StreamsAPI {
+    add(config: StreamConfig): Promise<StreamInfo>;
+    update(config: StreamConfig): Promise<StreamInfo>;
+    delete(stream: string): Promise<boolean>;
+    get(stream: string): Promise<Stream>;
+    list(): AsyncIterable<StreamInfo>;
+    info(stream: string): Promise<StreamInfo>;
+    names(): AsyncIterable<string>;
+    purge(stream: string, opts?: {
+        filter?: string;
+        seq?: number;
+        keep?: number;
+    }): Promise<PurgeResponse>;
+}
+interface ConsumersAPI {
+    add(stream: string, config: ConsumerConfig): Promise<ConsumerInfo>;
+    update(stream: string, config: ConsumerConfig): Promise<ConsumerInfo>;
+    delete(stream: string, consumer: string): Promise<boolean>;
+    list(stream: string): AsyncIterable<ConsumerInfo>;
+    info(stream: string, consumer: string): Promise<ConsumerInfo>;
+}
+interface JetStreamManager {
+    streams: StreamsAPI;
+    consumers: ConsumersAPI;
+}
+interface ConsumersAccessor {
+    get(stream: string, consumer: string): Promise<Consumer>;
+}
+interface StreamsAccessor {
+    get(stream: string): Promise<Stream>;
+}
+interface JetStreamPublishOptions {
+    msgID?: string;
+    expect?: {
+        lastMsgID?: string;
+        lastSequence?: number;
+        lastSubjectSequence?: number;
+        streamName?: string;
+    };
+    headers?: MsgHdrs;
+    timeout?: number;
+}
+interface JetStreamClient {
+    publish(subject: string, data?: Uint8Array, opts?: JetStreamPublishOptions): Promise<PubAck>;
+    consumers: ConsumersAccessor;
+    streams: StreamsAccessor;
+}
+
+/**
+ * RPC Types
+ *
+ * JSON-RPC 2.0 types for NatDO communication.
+ */
+type RpcId = string | number;
+interface RpcRequest {
+    jsonrpc: '2.0';
+    method: string;
+    params?: Record<string, unknown> | unknown[];
+    id: RpcId;
+}
+interface RpcNotification {
+    jsonrpc: '2.0';
+    method: string;
+    params?: Record<string, unknown> | unknown[];
+}
+interface RpcError {
+    code: number;
+    message: string;
+    data?: unknown;
+}
+interface RpcResponse {
+    jsonrpc: '2.0';
+    result?: unknown;
+    error?: RpcError;
+    id: RpcId | null;
+}
+type RpcBatchRequest = Array<RpcRequest | RpcNotification>;
+type RpcBatchResponse = RpcResponse[];
+declare const RPC_ERROR_CODES: {
+    readonly PARSE_ERROR: -32700;
+    readonly INVALID_REQUEST: -32600;
+    readonly METHOD_NOT_FOUND: -32601;
+    readonly INVALID_PARAMS: -32602;
+    readonly INTERNAL_ERROR: -32603;
+    readonly STREAM_NOT_FOUND: -32001;
+    readonly CONSUMER_NOT_FOUND: -32002;
+    readonly NO_RESPONDERS: -32003;
+    readonly TIMEOUT: -32004;
+    readonly MESSAGE_NOT_FOUND: -32005;
+    readonly STREAM_EXISTS: -32006;
+    readonly CONSUMER_EXISTS: -32007;
+    readonly INVALID_SUBJECT: -32008;
+    readonly PERMISSION_DENIED: -32009;
+    readonly MAX_PAYLOAD_EXCEEDED: -32010;
+    readonly DUPLICATE_MESSAGE: -32011;
+    readonly STREAM_SEALED: -32012;
+    readonly CONSUMER_DELETED: -32013;
+};
+declare function isRpcError(response: RpcResponse): response is RpcResponse & {
+    error: RpcError;
+};
+declare function isRpcSuccess(response: RpcResponse): response is RpcResponse & {
+    result: unknown;
+};
+declare function createRpcRequest(method: string, opts?: {
+    params?: Record<string, unknown> | unknown[];
+    id?: RpcId;
+}): RpcRequest;
+declare function createRpcError(code: number, message: string, id?: RpcId | null, data?: unknown): RpcResponse;
+declare function createRpcSuccess(result: unknown, id: RpcId): RpcResponse;
+declare function resetRequestIdCounter(): void;
+
+export { type AckPolicy, type Codec, type ConnectionOptions, type ConsumeOptions, type Consumer, type ConsumerConfig, type ConsumerInfo, type ConsumerMessages, type ConsumersAPI, type ConsumersAccessor, type DeliverPolicy, type DiscardPolicy, Empty, JSONCodec, type JetStreamClient, type JetStreamManager, type JetStreamPublishOptions, type JsMsg, type JsMsgInfo, type Msg, type MsgHdrs, type NatsConnection, type PubAck, type PublishOptions, type PullOptions, type PurgeResponse, type QueuedIterator, RPC_ERROR_CODES, type ReplayPolicy, type RequestOptions, type RetentionPolicy, type RpcBatchRequest, type RpcBatchResponse, type RpcError, type RpcId, type RpcNotification, type RpcRequest, type RpcResponse, type SequencePair, type ServerInfo, type Status, type StatusType, type StorageType, type StoredMsg, type Stream, type StreamConfig, type StreamInfo, type StreamState, type StreamsAPI, type StreamsAccessor, StringCodec, type Subscription, type SubscriptionOptions, createHeaders, createRpcError, createRpcRequest, createRpcSuccess, defaultConsumerConfig, defaultStreamConfig, isRpcError, isRpcSuccess, resetRequestIdCounter };