import type TypedEmitter from 'typed-emitter';
import type { Throws } from '../../../utils/throws';
import { Future } from '../../utils';
import { type EncryptionProvider } from '../e2ee';
import { DataTrackHandle } from '../handle';
import { type DataTrackInfo, LocalDataTrack } from '../track';
import { DataTrackPublishError, DataTrackPublishErrorReason, DataTrackPushFrameError, DataTrackPushFrameErrorReason } from './errors';
import DataTrackOutgoingPipeline from './pipeline';
import { type DataTrackOptions, type OutputEventPacketsAvailable, type OutputEventSfuPublishRequest, type OutputEventSfuUnpublishRequest, type SfuPublishResponseResult } from './types';
export type PendingDescriptor = {
    type: 'pending';
    completionFuture: Future<LocalDataTrack, DataTrackPublishError<DataTrackPublishErrorReason.NotAllowed> | DataTrackPublishError<DataTrackPublishErrorReason.DuplicateName> | DataTrackPublishError<DataTrackPublishErrorReason.Timeout> | DataTrackPublishError<DataTrackPublishErrorReason.LimitReached> | DataTrackPublishError<DataTrackPublishErrorReason.Disconnected> | DataTrackPublishError<DataTrackPublishErrorReason.Cancelled>>;
};
export type ActiveDescriptor = {
    type: 'active';
    info: DataTrackInfo;
    pipeline: DataTrackOutgoingPipeline;
    /** Resolves when the descriptor is unpublished. */
    unpublishingFuture: Future<void, never>;
};
export type Descriptor = PendingDescriptor | ActiveDescriptor;
export declare const Descriptor: {
    pending(): PendingDescriptor;
    active(info: DataTrackInfo, encryptionProvider: EncryptionProvider | null): ActiveDescriptor;
};
export type DataTrackOutgoingManagerCallbacks = {
    /** Request sent to the SFU to publish a track. */
    sfuPublishRequest: (event: OutputEventSfuPublishRequest) => void;
    /** Request sent to the SFU to unpublish a track. */
    sfuUnpublishRequest: (event: OutputEventSfuUnpublishRequest) => void;
    /** Serialized packets are ready to be sent over the transport. */
    packetsAvailable: (event: OutputEventPacketsAvailable) => void;
};
type DataTrackLocalManagerOptions = {
    /**
     * Provider to use for encrypting outgoing frame payloads.
     *
     * If none, end-to-end encryption will be disabled for all published tracks.
     */
    encryptionProvider?: EncryptionProvider;
};
declare const OutgoingDataTrackManager_base: new () => TypedEmitter<DataTrackOutgoingManagerCallbacks>;
export default class OutgoingDataTrackManager extends OutgoingDataTrackManager_base {
    private encryptionProvider;
    private handleAllocator;
    private descriptors;
    constructor(options?: DataTrackLocalManagerOptions);
    static withDescriptors(descriptors: Map<DataTrackHandle, Descriptor>): OutgoingDataTrackManager;
    /**
     * Used by attached {@link LocalDataTrack} instances to query their associated descriptor info.
     * @internal
     */
    getDescriptor(handle: DataTrackHandle): Descriptor | null;
    createLocalDataTrack(handle: DataTrackHandle): LocalDataTrack | null;
    /** Used by attached {@link LocalDataTrack} instances to broadcast data track packets to other
     * subscribers.
     * @internal
     */
    tryProcessAndSend(handle: DataTrackHandle, payload: Uint8Array): Throws<void, DataTrackPushFrameError<DataTrackPushFrameErrorReason.Dropped> | DataTrackPushFrameError<DataTrackPushFrameErrorReason.TrackUnpublished>>;
    /** Client requested to publish a track. */
    publishRequest(options: DataTrackOptions, signal?: AbortSignal): Promise<LocalDataTrack & {
        readonly __throws?: DataTrackPublishError<DataTrackPublishErrorReason.NotAllowed> | DataTrackPublishError<DataTrackPublishErrorReason.DuplicateName> | DataTrackPublishError<DataTrackPublishErrorReason.Timeout> | DataTrackPublishError<DataTrackPublishErrorReason.LimitReached> | DataTrackPublishError<DataTrackPublishErrorReason.Disconnected> | DataTrackPublishError<DataTrackPublishErrorReason.Cancelled> | undefined;
    }>;
    /** Get information about all currently published tracks. */
    queryPublished(): Promise<DataTrackInfo[]>;
    /** Client request to unpublish a track. */
    unpublishRequest(handle: DataTrackHandle): Promise<void>;
    /** SFU responded to a request to publish a data track. */
    receivedSfuPublishResponse(handle: DataTrackHandle, result: SfuPublishResponseResult): void;
    /** SFU notification that a track has been unpublished. */
    receivedSfuUnpublishResponse(handle: DataTrackHandle): void;
    /** Shuts down the manager and all associated tracks. */
    shutdown(): Promise<void>;
}
export {};
//# sourceMappingURL=OutgoingDataTrackManager.d.ts.map