const monitor = new ClientMonitor(config?: ClientMonitorConfig);

monitor.setInboundTrackContext(trackId, {
    contentType: 'screenshare',     // no frame-rate penalties on static content
    motionType: 'lowmotion',
    videoTag: videoElement,         // presented size, re-measured every tick
    presentedResolution: { width: 1280, height: 720 },   // or declare it directly
    linkedVideoTrackId: videoTrackId,                    // enables AVDesyncPlayoutDetector
    paused: true,
    remoteOutboundTrackPaused: true,
});

monitor.setOutboundTrackContext(trackId, { contentType: 'camera', paused: false });

type ClientMonitorEvents = {
    // Collection & sampling
    'stats-collected': [{
        clientMonitor: ClientMonitor;
        startedAt: number;
        durationOfCollectingStatsInMs: number;
        collectedStats: [string, RtcStats[]][];
    }];
    'sample-created': [{ clientMonitor: ClientMonitor; sample: ClientSample }];

    // Scoring
    'score': [{ clientMonitor: ClientMonitor; clientScore: number; currentReasons: Record<string, number> }];

    // Issue lifecycle
    'issue':          [ClientIssue];
    'issue-updated':  [RaisedClientIssue];
    'issue-resolved': [ResolvedClientIssue];

    // Application records
    'client-event': [ClientEvent];

    // One entry per detector event — see Events & issues for the full list
    'uplink-congestion':   [UplinkCongestionEventPayload];
    'downlink-congestion': [DownlinkCongestionEventPayload];
    'video-flow-disrupted':[VideoFlowEventPayload];
    // …

    'close': [];
};

interface Detector {
    readonly name: string;
    disabled?: boolean;
    includeIssueInSample?: boolean;
    update(): void;
}

pcMonitor.detectors.getByName<TransportDelayDetector>('transport-delay-detector')?.inputsUnavailable;

detectors.size;  detectors.listOfNames;
detectors.has(name);  detectors.getByName<T>(name);
detectors.find(pred);  detectors.filter(pred);
detectors.add(detector);  detectors.remove(detector);  detectors.clear();
detectors.disable(name);  detectors.enable(name);  detectors.isEnabled(name);
detectors.disableAll();   detectors.enableAll();
for (const d of detectors) { /* … */ }

monitorIssues.hasType(type);
monitorIssues.getByType(type);
monitorIssues.getFirstPayloadByType(type);
monitorIssues.size;

interface ScoreCalculator {
    update(): void;
}

interface StatsAdapter {
    readonly name: string;
    preAdapt?(stats: RtcStats[]): RtcStats[];    // before the built-ins
    postAdapt?(stats: RtcStats[]): RtcStats[];   // after them
}

type ExtensionStatProvider = () =>
    | { type: string; id?: string; payload?: Record<string, unknown> }
    | Promise<{ type: string; id?: string; payload?: Record<string, unknown> }>;

interface Logger {
    trace(...args: unknown[]): void;
    debug(...args: unknown[]): void;
    info(...args: unknown[]): void;
    warn(...args: unknown[]): void;
    error(...args: unknown[]): void;
}

import {
    ClientMonitor,

    // unions and guards
    ClientMonitorIssue,
    ClientMonitorResolvedIssue,
    ClientMonitorIssueType,
    isClientMonitorIssue,
    isClientMonitorResolvedIssue,

    // a detector, its config type and its payload type
    StuckDecoderDetector,
    StuckDecoderIssuePayload,
} from '@observertc/client-monitor-js';

import type { StuckDecoderDetectorConfig } from '@observertc/client-monitor-js';

"dependencies": { "@observertc/client-monitor-js": "next" }