import { P as NormalizedMeshConfig, X as NormalizedMeshStreamingConfig } from '../types-C9VYURdP.js';
import { g as MeshStreamPublisher, i as MeshStreamSubscriber, d as MeshStreamEnvelope, a as MeshLogPublishInput, c as MeshLogStreamPayload, e as MeshStreamHandler, h as MeshStreamSubscribeOptions } from '../types-CijKzcAX.js';
export { M as MeshLifecycleStreamPayload, b as MeshLogStreamName, f as MeshStreamKind } from '../types-CijKzcAX.js';

declare class MeshStreamFactory {
    createPublisher(config: NormalizedMeshConfig): MeshStreamPublisher | null;
    createSubscriber(config: NormalizedMeshConfig): MeshStreamSubscriber | null;
}

declare class MeshStreamChannels {
    private readonly config;
    constructor(config: NormalizedMeshStreamingConfig);
    logs(): string;
    events(): string;
    all(): readonly string[];
}

declare class MeshStreamSerializer {
    create<TPayload>(app: string, input: Omit<MeshStreamEnvelope<TPayload>, 'id' | 'emittedAt' | 'app'> & {
        readonly app?: string;
    }): MeshStreamEnvelope<TPayload>;
    encode(event: MeshStreamEnvelope): string;
    decode(value: string): MeshStreamEnvelope | null;
}

declare class MemoryMeshStream implements MeshStreamPublisher, MeshStreamSubscriber {
    private readonly config;
    private readonly serializer;
    private readonly hub;
    private logSequence;
    constructor(config: NormalizedMeshConfig);
    publish<TPayload>(input: Omit<MeshStreamEnvelope<TPayload>, 'id' | 'emittedAt' | 'app'> & {
        readonly app?: string;
    }): Promise<MeshStreamEnvelope<TPayload>>;
    publishLog(input: MeshLogPublishInput): Promise<MeshStreamEnvelope<MeshLogStreamPayload> | null>;
    subscribe(types: readonly string[], handler: MeshStreamHandler): Promise<() => void>;
}

interface MeshStreamCommandOptions extends MeshStreamSubscribeOptions {
    readonly json?: boolean;
    readonly raw?: boolean;
}
declare class StreamCommand {
    private readonly config;
    constructor(config: NormalizedMeshConfig);
    run(options?: MeshStreamCommandOptions): Promise<void>;
    private resolveFilters;
    private matches;
    private format;
}

declare class RedisMeshStream implements MeshStreamPublisher, MeshStreamSubscriber {
    private readonly config;
    private readonly client;
    private readonly channels;
    private readonly serializer;
    private logSequence;
    constructor(config: NormalizedMeshConfig);
    publish<TPayload>(input: Omit<MeshStreamEnvelope<TPayload>, 'id' | 'emittedAt' | 'app'> & {
        readonly app?: string;
    }): Promise<MeshStreamEnvelope<TPayload>>;
    publishLog(input: MeshLogPublishInput): Promise<MeshStreamEnvelope<MeshLogStreamPayload> | null>;
    subscribe(types: readonly string[], handler: MeshStreamHandler): Promise<() => Promise<void>>;
}

interface RedisPubSubConnectionOptions {
    readonly url: string;
    readonly connectTimeoutMs?: number;
}
declare class RedisPubSubConnection {
    private readonly options;
    private socket;
    private reader;
    private closed;
    constructor(options: RedisPubSubConnectionOptions);
    subscribe(channels: readonly string[], onMessage: (channel: string, message: string) => void): Promise<() => Promise<void>>;
    private readLoop;
    private connect;
}

export { MemoryMeshStream, MeshLogPublishInput, MeshLogStreamPayload, MeshStreamChannels, MeshStreamEnvelope, MeshStreamFactory, MeshStreamHandler, MeshStreamPublisher, MeshStreamSerializer, MeshStreamSubscribeOptions, MeshStreamSubscriber, RedisMeshStream, RedisPubSubConnection, StreamCommand };