@hotmeshio/hotmesh/build/services/stream/providers/redis/redis.d.ts

Permanent-Memory Workflows & AI Agents

import { ILogger } from '../../../logger';
import { StreamService } from '../../index';
import { RedisRedisClientType, RedisRedisMultiType } from '../../../../types/redis';
import { PublishMessageConfig, StreamConfig, StreamMessage, StreamStats } from '../../../../types/stream';
import { KeyStoreParams, StringAnyType } from '../../../../types';
import { KeyType } from '../../../../modules/key';
import { ProviderTransaction } from '../../../../types/provider';
declare class RedisStreamService extends StreamService<RedisRedisClientType, RedisRedisMultiType> {
    constructor(streamClient: RedisRedisClientType, storeClient: RedisRedisClientType, config?: StreamConfig);
    init(namespace: string, appId: string, logger: ILogger): Promise<void>;
    mintKey(type: KeyType, params: KeyStoreParams): string;
    transact(): ProviderTransaction;
    createStream(streamName: string): Promise<boolean>;
    deleteStream(streamName: string): Promise<boolean>;
    createConsumerGroup(streamName: string, groupName: string): Promise<boolean>;
    deleteConsumerGroup(streamName: string, groupName: string): Promise<boolean>;
    publishMessages(streamName: string, messages: string[], options?: PublishMessageConfig): Promise<string[]>;
    consumeMessages(streamName: string, groupName: string, consumerName: string, options?: {
        batchSize?: number;
        blockTimeout?: number;
    }): Promise<StreamMessage[]>;
    ackAndDelete(stream: string, group: string, ids: string[]): Promise<number>;
    acknowledgeMessages(stream: string, group: string, ids: string[], options?: StringAnyType): Promise<number | RedisRedisMultiType>;
    deleteMessages(stream: string, group: string, ids: string[], options?: StringAnyType): Promise<number | RedisRedisMultiType>;
    getPendingMessages(stream: string, group: string, count?: number, consumer?: string): Promise<[string, string, number, [string, number][]][] | [string, string, number, number]>;
    retryMessages(streamName: string, groupName: string, options?: {
        consumerName?: string;
        minIdleTime?: number;
        messageIds?: string[];
        delay?: number;
        maxRetries?: number;
        limit?: number;
    }): Promise<StreamMessage[]>;
    claimMessage(stream: string, group: string, consumer: string, minIdleTime: number, id: string, ...args: string[]): Promise<StreamMessage>;
    getStreamStats(streamName: string): Promise<StreamStats>;
    getStreamDepth(streamName: string, options?: {
        multi: RedisRedisMultiType;
    }): Promise<number>;
    getStreamDepths(streamNames: {
        stream: string;
    }[]): Promise<{
        stream: string;
        depth: number;
    }[]>;
    trimStream(streamName: string, options: {
        maxLen?: number;
        maxAge?: number;
        exactLimit?: boolean;
    }): Promise<number>;
    getProviderSpecificFeatures(): {
        supportsBatching: boolean;
        supportsDeadLetterQueue: boolean;
        supportsOrdering: boolean;
        supportsTrimming: boolean;
        supportsRetry: boolean;
        supportsNotifications: boolean;
        maxMessageSize: number;
        maxBatchSize: number;
    };
}
export { RedisStreamService };