import { type PackagerFormat } from '../../packager/media_packager.js';
import type { WireDropConfig, WireHoldConfig } from '../../moq/network_simulator.js';
import { type MediaDumpConfig } from '../../utils/media_dumper.js';
export interface TrackData {
    namespace: string[];
    name: string;
    authInfo?: string;
    maxInFlightRequests?: number;
    maxOpenStreams?: number;
    isHipri?: boolean;
    moqMapping?: string;
    newSubgroupEvery?: number;
    dropConfig?: WireDropConfig;
    holdConfig?: WireHoldConfig;
}
export interface MuxerSenderConfig {
    urlHostPort: string;
    backupUrlHostPort: string;
    isSendingStats: boolean;
    moqTracks: Record<string, TrackData>;
    keepAlivesEveryMs: number;
    certificateHash: any;
    usePublishNamespace: boolean;
    packagerFormat: PackagerFormat;
    mediaDump: MediaDumpConfig;
    verbose: boolean;
}
interface ChunkMessage {
    mediaType: string;
    chunk: any;
    seqId?: number;
    compensatedTs?: number;
    metadata?: any;
    timebase?: number;
    codec?: string;
    moqMapping?: string;
    codedWidth?: number;
    codedHeight?: number;
}
/**
 * MoQ publisher Web Worker. Packages encoded media with the configured packager
 * (LOC or CMAF, see src/packager/media_packager.ts) and assigns the MoQ
 * (group, object) ids once, then hands every object to each relay connection
 * (main and, optionally, backup; see RelayConnection). All MoQ protocol work
 * (session, control loop, subscriptions, object scheduling) lives in the
 * `Moq`/`Track` classes.
 */
export declare class MoqSender {
    private config;
    private verbose;
    private connections;
    private packagers;
    private dumper;
    private sequences;
    /** Entry point for the worker shell: routes one message to one handler. */
    onMessage(e: MessageEvent): Promise<void>;
    private parseSenderConfig;
    private checkTrackData;
    /**
     * Open one session per relay (main and optional backup) and publish the
     * tracks on each. The connections start concurrently and independently: one
     * that hangs or fails never holds back the other.
     */
    handleInit(data: any): Promise<void>;
    private priorityForMediaType;
    /** Package one encoded media chunk and hand it to every relay connection. */
    handleChunk(data: ChunkMessage): void;
    private emitBlocked;
    private nextObjectIds;
    private normalizeChunk;
    private packagerFor;
    private packetizeChunk;
    /** Force-drop the next burst of wire units for one media type, on one relay. */
    private handleForceDropBurst;
    /** Force-hold (stall then clump) the next burst for one media type, on one relay. */
    private handleForceHoldBurst;
    private connectionFor;
    private startConfiguredDump;
    /**
     * Start capturing packaged object payloads for one media type. Capture only
     * begins on the next group boundary, so what is captured is decodable on its
     * own (for CMAF it starts with a CMAF Header).
     */
    private handleArmMediaDump;
    /** Hand the captured bytes back to the main thread and disarm the capture. */
    private handleDumpMedia;
    /** Stop publishing and close every relay session. */
    handleStop(): void;
}
export {};
//# sourceMappingURL=moq_sender_internals.d.ts.map