@hotmeshio/hotmesh/build/services/router/consumption/index.d.ts

Permanent-Memory Workflows & AI Agents

import { ILogger } from '../../logger';
import { StreamService } from '../../stream';
import { ThrottleManager } from '../throttling';
import { ErrorHandler } from '../error-handling';
import { LifecycleManager } from '../lifecycle';
import { StreamData, StreamDataResponse } from '../../../types/stream';
import { ProviderClient, ProviderTransaction } from '../../../types/provider';
export declare class ConsumptionManager<S extends StreamService<ProviderClient, ProviderTransaction>> {
    private stream;
    private logger;
    private throttleManager;
    private errorHandler;
    private lifecycleManager;
    private reclaimDelay;
    private reclaimCount;
    private appId;
    private role;
    private errorCount;
    private counts;
    private hasReachedMaxBackoff;
    private router;
    private retryPolicy;
    constructor(stream: S, logger: ILogger, throttleManager: ThrottleManager, errorHandler: ErrorHandler, lifecycleManager: LifecycleManager<S>, reclaimDelay: number, reclaimCount: number, appId: string, role: any, router: any, retryPolicy?: import('../../../types/stream').RetryPolicy);
    createGroup(stream: string, group: string): Promise<void>;
    publishMessage(topic: string, streamData: StreamData | StreamDataResponse, transaction?: ProviderTransaction): Promise<string | ProviderTransaction>;
    consumeMessages(stream: string, group: string, consumer: string, callback: (streamData: StreamData) => Promise<StreamDataResponse | void>): Promise<void>;
    private consumeWithNotifications;
    private consumeWithPolling;
    consumeOne(stream: string, group: string, id: string, input: StreamData, callback: (streamData: StreamData) => Promise<StreamDataResponse | void>): Promise<void>;
    execStreamLeg(input: StreamData, stream: string, id: string, callback: (streamData: StreamData) => Promise<StreamDataResponse | void>): Promise<StreamDataResponse>;
    ackAndDelete(stream: string, group: string, id: string): Promise<void>;
    ackAndDeleteBatch(stream: string, group: string, ids: string[]): Promise<void>;
    publishResponse(input: StreamData, output: StreamDataResponse | void): Promise<string>;
    isStreamMessage(result: any): boolean;
}