@hotmeshio/hotmesh 0.0.54 → 0.0.56

package/build/types/job.d.ts

@@ -6,81 +6,36 @@ type ActivityData = {
     metadata?: Record<string, unknown>;
 };
 type JobMetadata = {
-    /** job_key */
     key?: string;
-    /** system assigned guid that corresponds to the transition message guid that spawned reentry */
     guid?: string;
-    /** system assigned guid; ensured created/deleted/created jobs are unique */
     gid: string;
-    /** job_id (jid+dad+aid) is composite key for activity */
     jid: string;
-    /** dimensional address for the activity (,0,0,1) */
     dad: string;
-    /** activity_id as in the YAML file */
     aid: string;
-    /** parent_job_id (pj+pd+pa) is composite key for parent activity */
     pj?: string;
-    /** parent_generational_id (system assigned at trigger inception); pg is the parent job's gid (just in case user created/deleted/created a job with same jid) */
     pg?: string;
-    /** parent_dimensional_address */
     pd?: string;
-    /** parent_activity_id */
     pa?: string;
-    /** sever the dependency chain if true (startChild/vs/execChild) */
     px?: boolean;
-    /** engine guid (one time subscriptions) */
     ngn?: string;
-    /** app_id */
     app: string;
-    /** app version */
     vrs: string;
-    /** subscription topic */
     tpc: string;
-    /** 201203120005 (slice of time) //time series */
     ts: string;
-    /** GMT created //job_created */
     jc: string;
-    /** GMT updated //job_updated */
     ju: string;
     js: JobStatus;
-    /** activity_type */
     atp: string;
-    /** activity_subtype */
     stp: string;
-    /** open telemetry span context */
     spn: string;
-    /** open telemetry trace context */
     trc: string;
-    /** stringified job error json: {message: string, code: number, error?} */
     err?: string;
-    /** process data expire policy */
     expire?: number;
 };
-/**
- * User-defined (extended) types for job data. Users may interleave
- * data into the job hash safely by using the `ExtensionType` interface.
- * The data will be prefixed as necessary using an underscore or
- * dash to ensure it is not confused with system process data.
- */
 type ExtensionType = {
-    /**
-     * Custom search data field (name/value pairs) to seed the Hash.
-     * Every field will be prefixed with an underscore before being
-     * stored with the initial Hash data set along side system
-     * process data.
-     */
     search?: StringStringType;
-    /**
-     * Custom marker data field used for adding a searchable marker to the job.
-     * markers always begin with a dash (-). Any field that does not
-     * begin with a dash will be removed and will not be inserted with
-     * the initial data set.
-     */
     marker?: StringStringType;
 };
-/**
- * job_status semaphore
- */
 type JobStatus = number;
 type JobState = {
     metadata: JobMetadata;
@@ -94,65 +49,25 @@ type JobState = {
     };
 };
 type JobInterruptOptions = {
-    /**
-     * optional Reason; will be used as the error `message` when thrown
-     * @default 'Job Interrupted'
-     */
     reason?: string;
-    /**
-     * throw JobInterrupted error upon interrupting
-     * @default true
-     */
     throw?: boolean;
-    /**
-     * interrupt child/descendant jobs
-     * @default false
-     */
     descend?: boolean;
-    /**
-     * if true, errors related to inactivation (like overage...already inactive) are suppressed/ignored
-     * @default false
-     */
     suppress?: boolean;
-    /**
-     * how long to wait in seconds before fully expiring/removing the hash from Redis;
-     * the job is inactive, but can remain in the cache indefinitely;
-     * @default 1 second.
-     */
     expire?: number;
-    /**
-     * Optional Error Code; will be used as the error `code` when thrown
-     * @default 410
-     */
     code?: number;
-    /**
-     * Optional stack trace
-     */
     stack?: string;
 };
-/**
- * format when publishing job meta/data on the wire when it completes
- */
 type JobOutput = {
     metadata: JobMetadata;
     data: JobData;
 };
-/**
- * jid+dad+aid is a composite guid; signal in and restore the full job context
- */
 type PartialJobState = {
     metadata: JobMetadata | Pick<JobMetadata, 'jid' | 'dad' | 'aid'>;
     data: JobData;
 };
 type JobCompletionOptions = {
-    /** default false */
     emit?: boolean;
-    /** default undefined */
     interrupt?: boolean;
-    /**
-     * in seconds to wait before deleting/expiring job hash
-     * @default 1 second
-     */
     expire?: number;
 };
-export { JobCompletionOptions, JobInterruptOptions, JobData, JobsData, JobMetadata, JobOutput, JobState, JobStatus, PartialJobState, ExtensionType, };
+export { JobCompletionOptions, JobData, JobsData, JobInterruptOptions, JobMetadata, JobOutput, JobState, JobStatus, PartialJobState, ExtensionType, };

package/build/types/pipe.d.ts

@@ -1,82 +1,17 @@
-/**
- * Represents a single cell value in a pipeline row
- * If the value is a string, the value will be a literal OR mapping expression
- */
 type PipeItem = string | boolean | number | null | object;
-/**
- * Array of `PipeItem` types.
- */
 type PipeItems = PipeItem[];
-/**
- * Represents a new nested context in the pipeline.
- * As the structure is recursive, the nested pipe may contain an
- * array of `PipeItem[]`, `PipeObject`, OR `ReduceObject` items.
- */
 type PipeObject = {
     '@pipe': Array<PipeItem[] | PipeObject | ReduceObject>;
 };
-/**
- * Reduce is similar to Pipe in that it represents a new context
- * and may include an array of `PipeItem[]`, `PipeObject`, or `ReduceObject`.
- * But it also iterates and produces output. The context variables,
- * `$input`, `$output`, `$item`, `$key`, and `$index` are available.
- * @example
- *
- * // Example of a reduce expression. The optional object is empty and
- * // serves as the $output during iteration. The last step in the iteration
- * // sets $output. if ther are no more iterations, the $output is returned
- * // and provided to the next step in the pipeline.
- *
- * // If data is:
- * // { response: ['a', 'b', 'c'] }
- *
- * // The reduced/transformed expression will be:
- * // { 'a': 0, 'b': 1, 'c': 2 }
- *
- * // Arrays and objects may be iterated over and transformed.
- *
- * //YAML
- * '@pipe':
- *   - ['{data.response}', {}]
- *   - '@reduce':
- *       - '@pipe':
- *           - ['{$output}']
- *       - '@pipe':
- *           - ['{$item}']
- *       - '@pipe':
- *           - ['{$index}']
- *       - ['{@object.set}']
- */
 type ReduceObject = {
     '@reduce': Array<PipeItem[] | PipeObject | ReduceObject>;
 };
-/**
- * Represents a sequence in the pipeline that can include arrays of `PipeItem`, `PipeObject`, or `ReduceObject`.
- */
 type Pipe = (PipeItem[] | PipeObject | ReduceObject)[];
-/**
- * Defines the context of a pipeline operation.
- */
 type PipeContext = {
-    /**
-     * Input of the current iteration.
-     */
     $input: unknown[];
-    /**
-     * Output of the current iteration and the final output for the reducer.
-     */
     $output: unknown;
-    /**
-     * Target item in the iterator.
-     */
     $item: unknown;
-    /**
-     * Array index as string or object key.
-     */
     $key: string;
-    /**
-     * Numeric index of the iterator.
-     */
     $index: number;
 };
 export { Pipe, PipeContext, PipeItem, PipeItems, PipeObject, ReduceObject };

package/build/types/quorum.d.ts

@@ -15,7 +15,6 @@ interface NetworkStat {
     tx_sec: number;
     ms: number;
 }
-/** reveals: memory, cpu, network */
 export interface SystemHealth {
     TotalMemoryGB: string;
     FreeMemoryGB: string;
@@ -24,17 +23,17 @@ export interface SystemHealth {
     NetworkStats: NetworkStat[];
 }
 export type ThrottleOptions = {
-    /** target an engine OR worker by GUID */
     guid?: string;
-    /** target a worker quorum */
     topic?: string;
-    /** in milliseconds; default is 0 */
+    entity?: string;
     throttle: number;
+    namespace?: string;
 };
 export interface QuorumProfile {
     namespace: string;
     app_id: string;
     engine_id: string;
+    entity?: string;
     worker_topic?: string;
     stream?: string;
     stream_depth?: number;
@@ -48,6 +47,7 @@ export interface QuorumProfile {
     signature?: string;
 }
 interface QuorumMessageBase {
+    entity?: string;
     guid?: string;
     topic?: string;
     type?: string;
@@ -69,6 +69,7 @@ export interface PongMessage extends QuorumMessageBase {
     type: 'pong';
     guid: string;
     originator: string;
+    entity?: string;
     profile?: QuorumProfile;
 }
 export interface ActivateMessage extends QuorumMessageBase {
@@ -78,18 +79,21 @@ export interface ActivateMessage extends QuorumMessageBase {
 }
 export interface JobMessage extends QuorumMessageBase {
     type: 'job';
+    entity?: string;
     topic: string;
     job: JobOutput;
 }
 export interface ThrottleMessage extends QuorumMessageBase {
     type: 'throttle';
     guid?: string;
+    entity?: string;
     topic?: string;
     throttle: number;
 }
 export interface RollCallMessage extends QuorumMessageBase {
     type: 'rollcall';
     guid?: string;
+    entity?: string;
     topic?: string | null;
     interval: number;
     max?: number;
@@ -104,11 +108,12 @@ export interface SubscriptionCallback {
 export interface QuorumMessageCallback {
     (topic: string, message: QuorumMessage): void;
 }
-/**
- * The types in this file are used to define those messages that are sent
- * to hotmesh client instances when a new version is about to be activated.
- * These messages serve to coordinate the cache invalidation and switch-over
- * to the new version without any downtime and a coordinating parent server.
- */
+export type RollCallOptions = {
+    delay?: number;
+    namespace?: string;
+};
+export type SubscriptionOptions = {
+    namespace?: string;
+};
 export type QuorumMessage = PingMessage | PongMessage | ActivateMessage | WorkMessage | JobMessage | ThrottleMessage | RollCallMessage | CronMessage;
 export {};

package/build/types/redis.d.ts

@@ -1,8 +1,226 @@
-import { RedisClassType, RedisClientType as RCT, RedisMultiType as RMT, RedisClientOptions as RCO } from './redisclient';
-import { RedisClassType as IORRedisClassType, RedisClientType as IORCT, RedisMultiType as IORMT, RedisClientOptions as IORCO } from './ioredisclient';
-type RedisClass = RedisClassType | IORRedisClassType;
-type RedisClient = RCT | IORCT;
-type RedisMulti = RMT | IORMT;
-type RedisOptions = RCO | IORCO;
+/// <reference types="node" />
+import { StringStringType } from './serializer';
+import { ReclaimedMessageType } from './stream';
 type MultiResponseFlags = (string | number)[];
-export { RedisClass, RedisClient, RedisMulti, RedisOptions, MultiResponseFlags, };
+interface ConnectionOptions {
+    host?: string;
+    port?: number;
+    path?: string;
+    socket?: any;
+    NPNProtocols?: string[] | Buffer[];
+    ALPNProtocols?: string[] | Buffer[];
+    servername?: string;
+    checkServerIdentity?: (servername: string, cert: Buffer) => Error | undefined;
+    session?: Buffer;
+    minDHSize?: number;
+    secureContext?: any;
+    secureProtocol?: string;
+    ciphers?: string;
+    honorCipherOrder?: boolean;
+    requestCert?: boolean;
+    rejectUnauthorized?: boolean;
+    maxVersion?: 'TLSv1.3' | 'TLSv1.2' | 'TLSv1.1' | 'TLSv1';
+    minVersion?: 'TLSv1.3' | 'TLSv1.2' | 'TLSv1.1' | 'TLSv1';
+}
+interface RedisRedisClientOptions {
+    url?: string;
+    socket?: {
+        host?: string;
+        port?: number;
+        tls?: boolean;
+        servername?: string;
+    };
+    username?: string;
+    password?: string;
+    database?: number;
+    name?: string;
+    readonly?: boolean;
+    legacyMode?: boolean;
+    commandsQueueMaxLength?: number;
+    disableOfflineQueue?: boolean;
+    connectTimeout?: number;
+    autoResubscribe?: boolean;
+    autoResendUnfulfilledCommands?: boolean;
+    lazyConnect?: boolean;
+    tls?: boolean | ConnectionOptions;
+    enableReadyCheck?: boolean;
+    keepAlive?: number;
+    family?: 'IPv4' | 'IPv6';
+    keyPrefix?: string;
+    retry?: {
+        maxReconnectionAttempts?: number;
+        initialReconnectionDelay?: number;
+        reconnectionBackoffFactor?: number;
+        totalReconnectionTimeout?: number;
+        maxRetryCount?: number;
+    };
+    stringNumbers?: boolean;
+}
+interface RedisRedisMultiType {
+    sendCommand(command: string, ...args: string[]): Promise<any>;
+    exec: () => Promise<unknown[]>;
+    XADD(key: string, id: string, fields: any): this;
+    XACK(key: string, group: string, id: string): this;
+    XDEL(key: string, id: string): this;
+    XLEN(key: string): this;
+    DEL(key: string): this;
+    EXISTS(key: string): this;
+    HDEL(key: string, itemId: string): this;
+    HGET(key: string, itemId: string): this;
+    HGETALL(key: string): this;
+    HINCRBYFLOAT(key: string, itemId: string, value: number): this;
+    HMGET(key: string, itemIds: string[]): Promise<string[]>;
+    HSET(key: string, values: Record<string, string>): this;
+    LPUSH(key: string, items: string[]): this;
+    LRANGE(key: string, start: number, end: number): this;
+    RPUSH(key: string, items: string[]): this;
+    SET(key: string, value: string): this;
+    ZADD(key: string, values: {
+        score: string;
+        value: string;
+    }, opts?: {
+        NX: boolean;
+    }): this;
+    ZRANGE_WITHSCORES(key: string, start: number, end: number): this;
+    ZRANK(key: string, member: string): this;
+    ZSCORE(key: string, value: string): this;
+}
+interface RedisRedisClientType {
+    multi(): Partial<RedisRedisMultiType>;
+    connect(): Promise<void>;
+    sendCommand(args: any[]): Promise<any>;
+    exec(): Promise<unknown[]>;
+    flushDb(): Promise<string>;
+    quit(): Promise<string>;
+    disconnect(): void;
+    duplicate(): RedisRedisClientType;
+    on(event: string, callback: (...args: any[]) => void): void;
+    publish(channel: string, message: string): Promise<number>;
+    pSubscribe(pattern: string, callback: (channel: string, message: string) => void): void;
+    pUnsubscribe(pattern: string): void;
+    subscribe(channel: string, callback: (channel: string, message: string) => void): void;
+    unsubscribe(channel: string): void;
+    punsubscribe(channel: string): void;
+    get(key: string): Promise<string | null>;
+    set(key: string, value: string): Promise<string>;
+    XADD(key: string, id: string, fields: any): Promise<string>;
+    XACK(key: string, group: string, id: string): Promise<number>;
+    XDEL(key: string, id: string): Promise<number>;
+    XLEN(key: string): Promise<number>;
+    DEL(key: string): Promise<number>;
+    EXISTS(key: string): Promise<number>;
+    HDEL(key: string, itemId: string): Promise<number>;
+    HGET(key: string, itemId: string): Promise<string | null>;
+    HGETALL(key: string): Promise<StringStringType>;
+    HINCRBYFLOAT(key: string, itemId: string, value: number): Promise<number>;
+    HMGET(key: string, itemIds: string[]): Promise<string[]>;
+    HSET(key: string, values: Record<string, string>): this;
+    LPUSH(key: string, items: string[]): Promise<number>;
+    LRANGE(key: string, start: number, end: number): Promise<string[]>;
+    RPUSH(key: string, items: string[]): Promise<number>;
+    SET(key: string, value: string): Promise<string>;
+    ZADD(key: string, values: {
+        score: string;
+        value: string;
+    }, opts?: {
+        NX: boolean;
+    }): Promise<number>;
+    ZRANGE_WITHSCORES(key: string, start: number, end: number): Promise<{
+        score: number;
+        value: string;
+    }>;
+    ZRANK(key: string, member: string): Promise<number>;
+    ZSCORE(key: string, value: string): Promise<number>;
+}
+interface RedisRedisClassType {
+    createClient(options: RedisRedisClientOptions): Partial<RedisRedisClientType>;
+}
+interface IORedisClientOptions {
+    port?: number;
+    host?: string;
+    family?: 'IPv4' | 'IPv6';
+    path?: string;
+    keepAlive?: number;
+    noDelay?: boolean;
+    connectionName?: string;
+    db?: number;
+    password?: string;
+    username?: string;
+    sentinels?: Array<{
+        host: string;
+        port: number;
+    }>;
+    name?: string;
+    readOnly?: boolean;
+    keyPrefix?: string;
+    reconnectOnError?: (err: Error) => boolean;
+}
+interface IORedisClient {
+    multi(): IORedisMultiType;
+    exec(): Promise<unknown[]>;
+    sendCommand(args: any[]): Promise<any>;
+    call(command: string, ...args: any[]): Promise<any>;
+    quit(): Promise<string>;
+    flushdb(): Promise<string>;
+    publish(channel: string, message: string): Promise<number>;
+    psubscribe(pattern: string, callback: (channel: string, message: string) => void): Promise<void>;
+    punsubscribe(pattern: string): void;
+    subscribe(channel: string, callback: (channel: string, message: string) => void): void;
+    unsubscribe(channel: string): void;
+    punsubscribe(channel: string): void;
+    xadd(key: string, id: string, fields: any, message?: string): Promise<string>;
+    xack(key: string, group: string, id: string): Promise<number>;
+    xdel(key: string, id: string): Promise<number>;
+    xlen(key: string): Promise<number>;
+    xpending(key: string, group: string, start?: string, end?: string, count?: number, consumer?: string): Promise<[string, string, number, [string, number][]][] | [string, string, number, number] | unknown[]>;
+    xclaim(key: string, group: string, consumer: string, minIdleTime: number, id: string, ...args: string[]): Promise<ReclaimedMessageType>;
+    xinfo(command: 'GROUPS' | string, key: string): Promise<unknown>;
+    xrange(key: string, start: string, end: string): Promise<string[][]>;
+    del(key: string): Promise<number>;
+    exists(key: string): Promise<number>;
+    get(key: string): Promise<string | null>;
+    hdel(key: string, itemId: string): Promise<number>;
+    hget(key: string, itemId: string): Promise<string | null>;
+    hgetall(key: string): Promise<StringStringType>;
+    hincrbyfloat(key: string, itemId: string, value: number): Promise<number>;
+    hmget(key: string, itemIds: string[]): Promise<string[]>;
+    hset(key: string, values: Record<string, string>): this;
+    lpush(key: string, ...args: string[]): Promise<number>;
+    lrange(key: string, start: number, end: number): Promise<string[]>;
+    on(event: string, callback: (...args: any[]) => void): void;
+    rpush(key: string, ...args: string[]): Promise<number>;
+    set(key: string, value: string): Promise<string>;
+    zadd(...args: Array<string | number>): Promise<number>;
+    zrange(key: string, start: number, end: number, withScores?: 'WITHSCORES'): Promise<string[]>;
+    zrank(key: string, member: string): Promise<number>;
+    zscore(key: string, value: string): Promise<number>;
+    xgroup(command: 'CREATE' | string, key: string, groupName: string, id: string, mkStream?: 'MKSTREAM'): Promise<string>;
+}
+type IORedisClassType = new (options: IORedisClientOptions, ...args: any[]) => IORedisClient;
+interface IORedisMultiType {
+    xadd(key: string, id: string, fields: any, message?: string): this;
+    xack(key: string, group: string, id: string): this;
+    xdel(key: string, id: string): this;
+    xlen(key: string): this;
+    xpending(key: string, group: string, start?: string, end?: string, count?: number, consumer?: string): this;
+    xclaim(key: string, group: string, consumer: string, minIdleTime: number, id: string, ...args: string[]): this;
+    hdel(key: string, itemId: string): this;
+    hget(key: string, itemId: string): this;
+    hgetall(key: string): this;
+    hincrbyfloat(key: string, itemId: string, value: number): this;
+    hmget(key: string, itemIds: string[]): this;
+    hset(key: string, values: Record<string, string>): this;
+    lrange(key: string, start: number, end: number): this;
+    rpush(key: string, value: string): this;
+    zadd(...args: Array<string | number>): this;
+    xgroup(command: 'CREATE', key: string, groupName: string, id: string, mkStream?: 'MKSTREAM'): this;
+    sendCommand(command: string[]): Promise<any>;
+    exec: () => Promise<unknown[]>;
+}
+type RedisClass = RedisRedisClassType | IORedisClassType;
+type RedisClient = RedisRedisClientType | IORedisClient;
+type RedisOptions = RedisRedisClientOptions | IORedisClientOptions;
+type RedisMulti = RedisRedisMultiType | IORedisMultiType;
+declare function isRedisClient(client: RedisClient): client is RedisRedisClientType;
+declare function isIORedisClient(client: RedisClient): client is IORedisClient;
+export { RedisClass, RedisRedisClientType, RedisRedisClientOptions, RedisRedisClassType, IORedisClient as IORedisClientType, RedisClient, RedisMulti, RedisRedisMultiType, IORedisClientOptions, IORedisClassType, IORedisMultiType, RedisOptions, MultiResponseFlags, isRedisClient, isIORedisClient, };

package/build/types/redis.js

@@ -1,2 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.isIORedisClient = exports.isRedisClient = void 0;
+function isRedisClient(client) {
+    return 'sendCommand' in client;
+}
+exports.isRedisClient = isRedisClient;
+function isIORedisClient(client) {
+    return 'pipeline' in client;
+}
+exports.isIORedisClient = isIORedisClient;

package/build/types/stream.d.ts

@@ -1,38 +1,19 @@
-/** Represents a policy for retrying stream operations based on error codes */
 export interface StreamRetryPolicy {
-    /**
-     * Key is error code, value is the retry profile.
-     * Tuple contains: [max retry count, retry type].
-     * 'x' denotes exponential backoff (default). Only 10, 100, 1000, 10000 are allowed retry intervals.
-     */
     [key: string]: [number, 'x'?];
 }
-/** A 3-digit status code representing the outcome of a stream operation */
 export type StreamCode = number;
-/** Describes the structure of a stream error */
 export type StreamError = {
-    /** Descriptive message of the error */
     message: string;
-    /** Numeric code corresponding to the type of error */
     code: number;
-    /** Optional job identifier, used when communicating errors externally */
     job_id?: string;
-    /** Stack trace of the error if unhandled */
     stack?: string;
-    /** Name of the error if unhandled */
     name?: string;
-    /** Custom user-defined error details */
     error?: Record<string, unknown>;
-    /** True if originating via a standard transition message with an `error` status */
     is_stream_error?: boolean;
 };
-/** Enumerated status values for stream operations */
 export declare enum StreamStatus {
-    /** Indicates successful completion of the stream operation */
     SUCCESS = "success",
-    /** Indicates an error occurred during the stream operation */
     ERROR = "error",
-    /** Indicates the stream operation is still pending */
     PENDING = "pending"
 }
 export declare enum StreamDataType {
@@ -46,51 +27,28 @@ export declare enum StreamDataType {
     SIGNAL = "signal",
     INTERRUPT = "interrupt"
 }
-/** Defines the structure of stream data used when passing stream messages (transitions) */
 export interface StreamData {
-    /** Metadata associated with the stream data */
     metadata: {
-        /** Globally unique identifier for the StreamData message to distinguish `retries` from new 'reentry/cycles' */
         guid: string;
-        /** Workflow/job topic */
         topic?: string;
-        /** Workflow/job ID */
         jid?: string;
-        /** Workflow Generational ID (internal GUID) */
         gid?: string;
-        /** Dimensional address indicating the message routing specifics */
         dad?: string;
-        /** Activity ID */
         aid: string;
-        /** OpenTelemetry Trace identifier */
         trc?: string;
-        /** OpenTelemetry Span identifier */
         spn?: string;
-        /** Current try count, used for retry logic */
         try?: number;
-        /**
-         * Indicates if the message should wait for a response.
-         * If explicitly false, the connection is severed immediately
-         * upon verifying (and returning) the Job ID.
-         */
         await?: boolean;
     };
-    /** Type of the data being streamed, optional */
     type?: StreamDataType;
-    /** Actual data being transmitted as a record of key-value pairs */
     data: Record<string, unknown>;
-    /** Policies related to retry logic, optional */
     policies?: {
         retry?: StreamRetryPolicy;
     };
-    /** Status of the stream, default assumed as 'success' */
     status?: StreamStatus;
-    /** HTTP-like status code for the stream, default assumed as 200 */
     code?: number;
-    /** Error stack trace */
     stack?: string;
 }
-/** Extends StreamData for responses, allowing for inheritance of the base properties */
 export interface StreamDataResponse extends StreamData {
 }
 export declare enum StreamRole {
@@ -98,35 +56,19 @@ export declare enum StreamRole {
     ENGINE = "engine",
     SYSTEM = "system"
 }
-/**
- * Represents a type for messages that have been reclaimed from a stream.
- * Each item is a tuple containing a messageId and its details.
- */
 export type ReclaimedMessageType = [
-    /** The stream ID, typically formatted as `<timestamp>-<count>` */
     messageId: string,
-    /** Details of the message, consisting of a key and its value */
     details: [
-        /** Key is always 'message' */
         key: string,
-        /** Value is a stringified representation of StreamData */
         value: string
     ]
 ][];
-/** Configuration parameters for a stream */
 export type StreamConfig = {
-    /** Namespace under which the stream operates */
     namespace: string;
-    /** Application identifier */
     appId: string;
-    /** Globally unique identifier for the stream */
     guid: string;
-    /** Role associated with the stream */
     role: StreamRole;
-    /** Optional topic for the stream */
     topic?: string;
-    /** Delay before a message can be reclaimed, defaults to 60,000 milliseconds */
     reclaimDelay?: number;
-    /** Maximum number of reclaims allowed, defaults to 3. Values greater throw an error */
     reclaimCount?: number;
 };