import { M as MeshRegistry } from './types-Dkbb4iqE.js';
import { E as MeshServiceType, P as NormalizedMeshConfig, q as MeshInstanceRecord } from './types-C9VYURdP.js';
import { g as MeshStreamPublisher } from './types-CijKzcAX.js';

interface MeshNodeOptions {
    readonly app: string;
    readonly service: string;
    readonly serviceType?: MeshServiceType;
    readonly nodeId?: string;
    readonly internalUrl?: string;
    readonly port?: number;
    readonly host?: string;
    readonly registry?: MeshRegistry | {
        type: 'file';
        stateDir: string;
    } | {
        type: 'redis';
        url: string;
        secret?: string;
        keyPrefix?: string;
    };
    readonly secret?: string;
    readonly heartbeatIntervalMs?: number;
    readonly ttlMs?: number;
    readonly metadata?: Record<string, unknown>;
    readonly stream?: MeshStreamPublisher | NormalizedMeshConfig;
}
interface MeshNodeSignalHandlerOptions {
    readonly onDrain?: () => Promise<void> | void;
    readonly onStop?: () => Promise<void> | void;
    readonly exit?: boolean;
}
declare class MeshNode {
    private readonly options;
    private readonly registry;
    private readonly id;
    private heartbeat;
    private readonly streamPublisher;
    private record;
    private stopping;
    constructor(options: MeshNodeOptions);
    start(): Promise<MeshInstanceRecord>;
    drain(): Promise<void>;
    stop(): Promise<void>;
    emit<TPayload>(type: string, payload: TPayload): Promise<void>;
    log(stream: 'stdout' | 'stderr' | 'system', chunk: string | Buffer): Promise<void>;
    installSignalHandlers(options?: MeshNodeSignalHandlerOptions): void;
    private gracefulSignalStop;
    private buildRecord;
    private resolveStream;
    private resolveRegistry;
}
declare function createMeshNode(options: MeshNodeOptions): MeshNode;

export { MeshNode as M, type MeshNodeOptions as a, type MeshNodeSignalHandlerOptions as b, createMeshNode as c };