import { h as MeshConnectionCounters, E as MeshServiceType, D as MeshServiceStrategy, q as MeshInstanceRecord, P as NormalizedMeshConfig } from '../types-C9VYURdP.js';
import { c as MeshLockRecord } from '../types-BZGet48R.js';
import { a as MeshLeaderRecord } from '../types-CYIf5CLM.js';

interface MeshRouterServiceStats {
    readonly service: string;
    readonly requests: number;
    readonly upgrades: number;
    readonly errors: number;
    readonly active: MeshConnectionCounters;
}
interface MeshRouterMetricsSnapshot {
    readonly router: {
        readonly startedAt: string;
        readonly uptimeMs: number;
        readonly draining: boolean;
    };
    readonly requests: {
        readonly total: number;
        readonly proxied: number;
        readonly noTarget: number;
        readonly errors: number;
        readonly upgrades: number;
    };
    readonly active: MeshConnectionCounters;
    readonly services: readonly MeshRouterServiceStats[];
}
interface MeshDashboardServiceSummary {
    readonly service: string;
    readonly type: MeshServiceType;
    readonly strategy: MeshServiceStrategy;
    readonly configuredInstances: number;
    readonly running: number;
    readonly draining: number;
    readonly expired: number;
    readonly failed: number;
    readonly routes: readonly string[];
}
interface MeshDashboardRouteSummary {
    readonly service: string;
    readonly route: string;
    readonly source: 'config' | 'hsm:canonical' | 'hsm:backend';
    readonly stateId?: string;
}
interface MeshDashboardLogEntry {
    readonly instanceId: string;
    readonly service: string;
    readonly logFile: string;
    readonly text: string;
}
interface MeshDashboardCoordinationSnapshot {
    readonly enabled: boolean;
    readonly backend: string;
    readonly locks: readonly MeshLockRecord[];
    readonly leaders: readonly MeshLeaderRecord[];
    readonly errors?: readonly string[];
}
interface MeshDashboardSnapshot {
    readonly app: string;
    readonly generatedAt: string;
    readonly projectRoot: string;
    readonly router: {
        readonly enabled: boolean;
        readonly url: string;
        readonly metricsPath: string;
        readonly metrics?: MeshRouterMetricsSnapshot;
        readonly metricsError?: string;
    };
    readonly registry: {
        readonly type: string;
        readonly ttlMs: number;
        readonly heartbeatIntervalMs: number;
    };
    readonly streaming: {
        readonly enabled: boolean;
        readonly transport: string;
        readonly logs: boolean;
        readonly events: boolean;
        readonly keyPrefix: string;
    };
    readonly services: readonly MeshDashboardServiceSummary[];
    readonly instances: readonly MeshInstanceRecord[];
    readonly routes: readonly MeshDashboardRouteSummary[];
    readonly coordination: MeshDashboardCoordinationSnapshot;
    readonly hsm: {
        readonly enabled: boolean;
        readonly routeCount: number;
        readonly schemaId?: string;
        readonly schemaVersion?: string;
    };
    readonly logs?: readonly MeshDashboardLogEntry[];
}
interface MeshDashboardBuildOptions {
    readonly includeLogs?: boolean;
    readonly logLines?: number;
}
interface MeshDashboardRenderOptions {
    readonly colors?: boolean;
    readonly compact?: boolean;
}
interface MeshDashboardCommandOptions extends MeshDashboardBuildOptions, MeshDashboardRenderOptions {
    readonly json?: boolean;
    readonly once?: boolean;
    readonly intervalMs?: number;
}

declare class RouterMetrics {
    private readonly startedAt;
    private requestsTotal;
    private proxiedTotal;
    private noTargetTotal;
    private errorsTotal;
    private upgradesTotal;
    private readonly services;
    recordProxy(service: string): void;
    recordUpgrade(service: string): void;
    recordNoTarget(): void;
    recordError(service?: string): void;
    snapshot(active: MeshConnectionCounters, serviceActive: ReadonlyMap<string, MeshConnectionCounters>, draining: boolean): MeshRouterMetricsSnapshot;
    private service;
}

declare class ObservabilitySnapshotBuilder {
    private readonly config;
    private readonly registry;
    private readonly logs;
    constructor(config: NormalizedMeshConfig);
    build(options?: MeshDashboardBuildOptions): Promise<MeshDashboardSnapshot>;
    private serviceSummaries;
    private routeSummaries;
    private readCoordination;
    private readLogs;
    private readRouterMetrics;
}

declare class DashboardRenderer {
    render(snapshot: MeshDashboardSnapshot, options?: MeshDashboardRenderOptions): string;
    private table;
    private duration;
    private age;
}

declare class DashboardCommand {
    private readonly config;
    private readonly builder;
    private readonly renderer;
    constructor(config: NormalizedMeshConfig);
    renderOnce(options?: MeshDashboardCommandOptions): Promise<string>;
    watch(options?: MeshDashboardCommandOptions): Promise<void>;
}

export { DashboardCommand, DashboardRenderer, type MeshDashboardBuildOptions, type MeshDashboardCommandOptions, type MeshDashboardLogEntry, type MeshDashboardRenderOptions, type MeshDashboardRouteSummary, type MeshDashboardServiceSummary, type MeshDashboardSnapshot, type MeshRouterMetricsSnapshot, type MeshRouterServiceStats, ObservabilitySnapshotBuilder, RouterMetrics };