@pexip/media 17.2.0 → 17.4.0

package/dist/index.d.ts

@@ -1,837 +1,11 @@
-import * as _pexip_media_control from '@pexip/media-control';
-import { MediaDeviceRequest, MediaDeviceInfoLike, InputConstraintSet, DisplayMediaOptions } from '@pexip/media-control';
-import { RenderEffects, SegmentationModel, RenderParams, Segmenter, ThrottleOptions, AudioGraphOptions, AudioNodeInit, VideoProcessor, SegmentationTransform } from '@pexip/media-processor';
-import { Signal, SignalVariant } from '@pexip/signal';
-import { AsyncQueueOptions } from '@pexip/utils';
-
-type Unsubscribe = () => void;
-interface ExtendedMediaTrackSettings extends MediaTrackSettings {
-    mixWithAdditionalMedia?: boolean;
-    channelCount?: number;
-    denoise?: boolean;
-    vad?: boolean;
-    asd?: boolean;
-    backgroundBlurAmount?: number;
-    bgImageUrl?: string;
-    edgeBlurAmount?: number;
-    flipHorizontal?: boolean;
-    foregroundThreshold?: number;
-    videoSegmentation?: RenderEffects;
-    videoSegmentationModel?: SegmentationModel;
-    pan?: boolean;
-    tilt?: boolean;
-    zoom?: boolean;
-    contentHint?: AudioContentHint | VideoContentHint;
-}
-type ExtendedMediaTrackSettingsKey = keyof ExtendedMediaTrackSettings;
-interface MediaSettings {
-    audio: ExtendedMediaTrackSettings[];
-    video: ExtendedMediaTrackSettings[];
-}
-/**
- * URL links needed for creating a denoise node for audio processing
- */
-interface DenoiseParams {
-    /**
-     * wasm URL to get the denoise wasm
-     */
-    wasmURL: string;
-    /**
-     * AudioWorklet module URL to get the worklet, @see AudioContext['audioWorklet']['addModule']
-     */
-    workletModule: string;
-    /**
-     * AudioWorklet options to pass @see AudioContext['audioWorklet']['addModule']
-     */
-    workletOptions?: WorkletOptions;
-}
-interface MediaAttributes {
-    /**
-     * The constraints used to request the media
-     */
-    constraints?: MediaDeviceRequest;
-    /**
-     * The devices used for the media
-     */
-    devices: MediaDeviceInfoLike[];
-    /**
-     * Media stream for the media
-     */
-    stream?: MediaStream;
-    /**
-     * The raw stream obtained from the `getUserMedia` API
-     */
-    rawStream?: MediaStream;
-    /**
-     * Audio input device is used for the audio track from the current stream
-     */
-    audioInput?: MediaDeviceInfoLike;
-    /**
-     * Video input device is used for the video track from the current stream
-     */
-    videoInput?: MediaDeviceInfoLike;
-    /**
-     * The audio input device which is expected to be used for the current
-     * stream based on the provided constraints
-     */
-    expectedAudioInput?: MediaDeviceInfoLike;
-    /**
-     * The video input device which is expected to be used for the current
-     * stream based on the provided constraints
-     */
-    expectedVideoInput?: MediaDeviceInfoLike;
-    /**
-     * The status of the media
-     */
-    status: UserMediaStatus;
-    /**
-     * Current mute state of audio track
-     * `undefined` means there is no such track from the stream
-     */
-    audioMuted: boolean | undefined;
-    /**
-     * Current mute state of video track
-     * `undefined` means there is no such track from the stream
-     */
-    videoMuted: boolean | undefined;
-}
-interface Media extends MediaAttributes {
-    /**
-     * mute/unmute the audio track
-     */
-    muteAudio(mute: boolean): void;
-    /**
-     * mute/unmute the video track
-     */
-    muteVideo(mute: boolean): void;
-    /**
-     * Apply the constraints to the current media
-     */
-    applyConstraints(constraints: MediaDeviceRequest): Promise<void>;
-    /**
-     * Release the media resources, e.g. camera/microphone
-     */
-    release(): Promise<void>;
-    getSettings(): MediaSettings;
-    toJSON?: () => unknown;
-}
-type Process<T> = (a: T) => Promise<Media>;
-type MediaProcessor = Process<Promise<Media>>;
-/**
- * A media pipeline to get and process media
- */
-type Pipeline<T = MediaDeviceRequest> = [
-    Process<T>,
-    ...MediaProcessor[]
-];
-type ProcessMedia = (media: Media) => undefined | Media;
-/**
- * Use which processor API to process the stream track
- * `stream` - Use MediaStreamTrackProcessor, when available
- * `canvas` - Use Canvas
- */
-type VideoStreamTrackProcessorAPIs = 'stream' | 'canvas';
-declare enum UserMediaStatus {
-    /**
-     * The initial status
-     */
-    Initial = "initial",
-    /**
-     * When we know the permissions were already granted from permission API
-     */
-    InitialPermissionsGranted = "initial-permissions-granted",
-    /**
-     * When we do not know the permissions from permission API
-     */
-    InitialPermissionsNotGranted = "initial-permissions-not-granted",
-    /**
-     * When video input permissions are initially denied in the browser and audio input permissions are unknown
-     */
-    InitialPermissionsVideoInputDenied = "initial-permissions-videoinput-denied",
-    /**
-     * When audio input permissions are initially denied in the browser and video input permissions are unknown
-     */
-    InitialPermissionsAudioInputDenied = "initial-permissions-audioinput-denied",
-    /**
-     * When video input permissions are granted in the browser and audio input permissions are unknown
-     */
-    InitialPermissionsVideoInputGranted = "initial-permissions-videoinput-granted",
-    /**
-     * When audio input permissions are granted in the browser and video input permissions are unknown
-     */
-    InitialPermissionsAudioInputGranted = "initial-permissions-audioinput-granted",
-    /**
-     * When audio input permissions are granted but video input permissions are initially denied
-     */
-    InitialPermissionsGrantedVideoInputDenied = "initial-permissions-audioinput-granted-videoinput-denied",
-    /**
-     * When video input permissions are granted but audio input permissions are initially denied
-     */
-    InitialPermissionsGrantedAudioInputDenied = "initial-permissions-videoinput-granted-audioinput-denied",
-    /**
-     * When there is no any kind of input devices
-     */
-    NoDevicesFound = "no-devices-found",
-    /**
-     * When there is no any video input devices
-     */
-    NoVideoDevicesFound = "no-video-devices-found",
-    /**
-     * When there is no any audio input devices
-     */
-    NoAudioDevicesFound = "no-audio-devices-found",
-    /**
-     * Derived from `MediaDeviceFailure.AudioInputDeviceNotFoundError`
-     */
-    AudioDeviceNotFound = "audio-device-not-found",
-    /**
-     * Derived from `MediaDeviceFailure.VideoInputDeviceNotFoundError`
-     */
-    VideoDeviceNotFound = "video-device-not-found",
-    /**
-     * Derived from `MediaDeviceFailure.AudioAndVideoDeviceNotFoundError`
-     */
-    AudioVideoDevicesNotFound = "audio-video-devices-not-found",
-    /**
-     * When Permission is granted by user for both video and audio, and both
-     * devices are exactly matched with the request constraints
-     */
-    PermissionsGranted = "permissions-granted",
-    /**
-     * When Permission is granted by user for both video and audio, and both
-     * devices are NOT exactly matched with the request constraints
-     */
-    PermissionsGrantedFallback = "permissions-granted-fallback-devices",
-    /**
-     * When Permission is granted by user for both video and audio, and audio
-     * input is NOT exactly matched with the request constraints
-     */
-    PermissionsGrantedFallbackAudioinput = "permissions-granted-fallback-audioinput",
-    /**
-     * When Permission is granted by user for both video and audio, and video
-     * input is NOT exactly matched with the request constraints
-     */
-    PermissionsGrantedFallbackVideoinput = "permissions-granted-fallback-videoinput",
-    /**
-     * When Permission for using both audio and video devices are rejected by the user
-     * from `PermissionDeniedError`
-     */
-    PermissionsRejected = "permissions-rejected",
-    /**
-     * When Permission for using the audio device is rejected by the user
-     * from `PermissionDeniedError`
-     */
-    PermissionsRejectedAudioInput = "permissions-rejected-audioinput",
-    /**
-     * When Permission for using the video device is rejected by the user
-     * from `PermissionDeniedError`
-     */
-    PermissionsRejectedVideoInput = "permissions-rejected-videoinput",
-    /**
-     * When only request and return exact audio input device
-     */
-    PermissionsOnlyAudioinput = "permissions-only-audioinput",
-    /**
-     * When only request audio input device because of no video devices
-     * available and returned exact audio input device
-     */
-    PermissionsOnlyAudioinputNoVideoDevices = "permissions-only-audioinput-no-video-devices",
-    /**
-     * When only request and returned NOT exact audio input device
-     */
-    PermissionsOnlyAudioinputFallback = "permissions-only-fallback-audioinput",
-    /**
-     * When only request audio input device because of no video devices
-     * available and returned NOT exact audio input device
-     */
-    PermissionsOnlyAudioinputFallbackNoVideoDevices = "permissions-only-fallback-audioinput-no-video-devices",
-    /**
-     * When only request and return exact video input device
-     */
-    PermissionsOnlyVideoinput = "permissions-only-videoinput",
-    /**
-     * When only request video input device because of no audio devices
-     * available and returned exact video input device
-     */
-    PermissionsOnlyVideoinputNoAudioDevices = "permissions-only-videoinput-no-audio-devices",
-    /**
-     * When only request and returned NOT exact video input device
-     */
-    PermissionsOnlyVideoinputFallback = "permissions-only-fallback-videoinput",
-    /**
-     * When only request video input device because of no video devices
-     * available and returned NOT exact video input device
-     */
-    PermissionsOnlyVideoinputFallbackNoAudioDevices = "permissions-only-fallback-videoinput-no-audio-devices",
-    /**
-     * When requesting the audio device is used by other application
-     */
-    AudioDeviceInUse = "audio-device-in-use",
-    /**
-     * When requesting the video device is used by other application
-     */
-    VideoDeviceInUse = "video-device-in-use",
-    /**
-     * When requesting both audio and video devices are used by other application
-     */
-    DevicesInUse = "devices-in-use",
-    /**
-     * When requesting both audio and video with over-constrained
-     */
-    Overconstrained = "overconstrained",
-    /**
-     * When requesting video with over-constrained
-     */
-    VideoOverconstrained = "video-overconstrained",
-    /**
-     * When requesting audio with over-constrained
-     */
-    AudioOverconstrained = "audio-overconstrained",
-    /**
-     * When requesting both audio and video with invalid constraints
-     */
-    InvalidConstraints = "invalid-constraints",
-    /**
-     * When requesting video with invalid constraints
-     */
-    InvalidVideoConstraints = "invalid-video-constraints",
-    /**
-     * When requesting audio with invalid constraints
-     */
-    InvalidAudioConstraints = "invalid-audio-constraints",
-    /**
-     * When requesting both audio and video with NotSupportedError
-     */
-    NotSupportedError = "not-supported-error",
-    /**
-     * When requesting video with NotSupportedError
-     */
-    NotSupportedErrorOnlyVideoInput = "not-supported-error-only-video",
-    /**
-     * When requesting audio with NotSupportedError
-     */
-    NotSupportedErrorOnlyAudioInput = "not-supported-error-only-audio",
-    /**
-     * Unknown error from both video and audio
-     */
-    UnknownError = "unknown-error",
-    /**
-     * Unknown error from audio device
-     */
-    UnknownErrorOnlyAudioinput = "unknown-error-only-audioinput",
-    /**
-     * Unknown error from video device
-     */
-    UnknownErrorOnlyVideoinput = "unknown-error-only-videoinput"
-}
-interface AudioSignalDetectionOptions {
-    /**
-     * Audio Signal Detection Duration in second
-     */
-    audioSignalDetectionDuration?: number;
-    /**
-     * Whether or not to detect audio signal for malfunctioning device
-     */
-    shouldDetectAudio: () => boolean;
-}
-interface VoiceActivityDetectionOptions {
-    /**
-     * Voice Activity Detection in millisecond
-     */
-    vadThrottleMS?: number;
-    /**
-     * Whether or not to detect voice activity
-     */
-    shouldDetectVoiceActivity: () => boolean;
-}
-interface DeviceMuteState {
-    /**
-     * Indicating whether audio is muted
-     */
-    audio: boolean;
-    /**
-     * Indicating whether video is muted
-     */
-    video: boolean;
-}
-interface MediaOptions {
-    /**
-     * Media signals to be used for the module
-     *
-     * @see MediaSignals
-     */
-    signals: MediaSignals;
-    /**
-     * Media Processors
-     */
-    mediaProcessors: MediaProcessor[];
-    /**
-     * A function to get the devices' mute state
-     */
-    getMuteState: () => DeviceMuteState;
-    /**
-     * Pass default constraints to use with get media wrappers
-     */
-    getDefaultConstraints?: () => {
-        audio?: InputConstraintSet | false;
-        video?: InputConstraintSet | false;
-    };
-}
-interface MediaProps {
-    /**
-     * Current media
-     */
-    media: Media;
-    /**
-     * Current device
-     */
-    devices: MediaDeviceInfoLike[];
-    /**
-     * When should we discard the requested MediaStream
-     */
-    discardMedia: boolean;
-}
-interface MediaController {
-    /**
-     * Current Media
-     */
-    media: Media;
-    /**
-     * Current device list
-     */
-    devices: MediaDeviceInfoLike[];
-    /**
-     * Execute the media pipeline immediately with provided constraints
-     *
-     * @param constraints - @see MediaDeviceRequest
-     */
-    getUserMedia: (constraints: MediaDeviceRequest) => void;
-    /**
-     * Execute the media pipeline immediately with provided constraints. An
-     * explicit version of `getUserMedia` to make it possible to chain other
-     * async actions
-     *
-     * @param constraints - @see MediaDeviceRequest
-     */
-    getUserMediaAsync: (constraints: MediaDeviceRequest) => Promise<void>;
-    /**
-     * Cross-check PermissionState and available devices before requesting user
-     * media, the request will be skipped if there is no granted device.
-     */
-    tryAndGetUserMedia: (constraints: MediaDeviceRequest) => void;
-}
-type VideoRenderParams = Omit<RenderParams, 'backgroundImage' | 'effects'> & {
-    /**
-     * Target frame rate for the video segmentation
-     */
-    frameRate: number;
-    /**
-     * Default background image URL for overlay effects
-     */
-    bgImageUrl: string;
-    /**
-     * Render Effects
-     */
-    videoSegmentation: RenderEffects;
-    pan?: boolean;
-    tilt?: boolean;
-    zoom?: boolean;
-};
-interface StreamTrackSignals {
-    /**
-     * MediaStreamTrack events: mute
-     * https://developer.mozilla.org/en-US/docs/Web/API/MediaStreamTrack#events
-     */
-    onStreamTrackMuted: Signal<MediaStreamTrack>;
-    /**
-     * MediaStreamTrack events: unmute
-     * https://developer.mozilla.org/en-US/docs/Web/API/MediaStreamTrack#events
-     */
-    onStreamTrackUnmuted: Signal<MediaStreamTrack>;
-    /**
-     * MediaStreamTrack events: ended
-     * https://developer.mozilla.org/en-US/docs/Web/API/MediaStreamTrack#events
-     */
-    onStreamTrackEnded: Signal<MediaStreamTrack>;
-    /**
-     * Emit `MediaStreamTrack` whenever a call to `Media['muteAudio']` or
-     * `Media['muteVideo']`
-     */
-    onStreamTrackEnabled: Signal<MediaStreamTrack>;
-}
-interface MediaChangesSignals {
-    onDevicesChanged: Signal<MediaDeviceInfoLike[]>;
-    onStatusChanged: Signal<UserMediaStatus>;
-    onMediaChanged: Signal<Media>;
-}
-interface AudioDetectionSignals {
-    onVAD: Signal<undefined>;
-    onSilentDetected: Signal<boolean>;
-}
-type MediaSignalsOptional = Pick<Partial<MediaChangesSignals>, 'onDevicesChanged' | 'onStatusChanged'> & Partial<StreamTrackSignals>;
-type MediaSignalsRequired = Pick<MediaChangesSignals, 'onMediaChanged'> & AudioDetectionSignals;
-type MediaSignals = MediaSignalsRequired & MediaSignalsOptional;
-declare enum DeniedDevices {
-    Microphone = "microphone",
-    Camera = "camera",
-    Both = "microphone-and-camera"
-}
-interface Segmenters {
-    mediapipeSelfie: Segmenter;
-}
-/**
- * Audio content hints are only applicable when the MediaStreamTrack contains an
- * audio track
- *
- * {@link https://www.w3.org/TR/mst-content-hint/#audio-content-hints}
- */
-declare const AUDIO_CONTENT_HINTS: {
-    /**
-     * No hint has been provided, the implementation should make its
-     * best-informed guess on how to handle contained audio data. This may be
-     * inferred from how the track was opened or by doing content analysis
-     */
-    readonly NoHint: "";
-    /**
-     * The track should be treated as if it contains speech data. Consuming this
-     * signal it may be appropriate to apply noise suppression or boost
-     * intelligibility of the incoming signal.
-     */
-    readonly Speech: "speech";
-    /**
-     * The track should be treated as if it contains data for the purpose of
-     * speech recognition by a machine. Consuming this signal it may be
-     * appropriate to boost intelligibility of the incoming signal for
-     * transcription and turn off audio-processing components that are used for
-     * human consumption.
-     */
-    readonly SpeechRecognition: "speech-recognition";
-    /**
-     * The track should be treated as if it contains music data. Generally this
-     * might imply tuning or turning off audio-processing components that are
-     * used to process speech data to prevent the audio from being distorted.
-     */
-    readonly Music: "music";
-};
-type AudioContentHint = (typeof AUDIO_CONTENT_HINTS)[keyof typeof AUDIO_CONTENT_HINTS];
-/**
- * Video content hints are only applicable when the MediaStreamTrack contains a
- * video track.
- *
- * {@link https://www.w3.org/TR/mst-content-hint/#video-content-hints}
- */
-declare const VIDEO_CONTENT_HINTS: {
-    /**
-     * No hint has been provided, the implementation should make its
-     * best-informed guess on how contained video content should be treated.
-     * This can for example be inferred from how the track was opened or by
-     * doing content analysis.
-     */
-    readonly NoHint: "";
-    /**
-     * The track should be treated as if it contains video where motion is
-     * important. This is normally webcam video, movies or video games.
-     * Quantization artefacts and downscaling are acceptable in order to
-     * preserve motion as well as possible while still retaining target
-     * bitrates. During low bitrates when compromises have to be made, more
-     * effort is spent on preserving frame rate than edge quality and details.
-     */
-    readonly Motion: "motion";
-    /**
-     * The track should be treated as if video details are extra important.
-     * This is generally applicable to presentations or web pages with text
-     * content, painting or line art. This setting would normally optimize for
-     * detail in the resulting individual frames rather than smooth playback.
-     * Artefacts from quantization or downscaling that make small text or line
-     * art unintelligible should be avoided.
-     */
-    readonly Detail: "detail";
-    /**
-     * The track should be treated as if video details are extra important, and
-     * that significant sharp edges and areas of consistent color can occur
-     * frequently. This is generally applicable to presentations or web pages
-     * with text content. This setting would normally optimize for detail in the
-     * resulting individual frames rather than smooth playback, and may take
-     * advantage of encoder tools that optimize for text rendering. Artefacts
-     * from quantization or downscaling that make small text or line art
-     * unintelligible should be avoided.
-     */
-    readonly Text: "text";
-};
-type VideoContentHint = (typeof VIDEO_CONTENT_HINTS)[keyof typeof VIDEO_CONTENT_HINTS];
-
-/**
- * Create an object to interact with the media scream, which is usually used for
- * our main stream.
- *
- * @param options - @see MediaOptions
- */
-declare const createMedia: ({ getMuteState, signals, mediaProcessors, getDefaultConstraints, }: MediaOptions) => MediaController;
-
-type AudioNodeInits = AudioNodeInit[];
-/**
- * A function to be called to create the AudioNodes needed for the graph
- * creation
- *
- * @param media - Media to be used for the AudioGraph creation
- */
-type CreateNodes = (media: Media) => AudioNodeInits;
-interface AudioProcessOptions {
-    /**
-     * An option is being passed to AnalyserNode creation when used
-     * @see https://developer.mozilla.org/en-US/docs/Web/API/AnalyserNode/fftSize
-     *
-     * @defaultValue 2048
-     */
-    fftSize?: number;
-    /**
-     * Params needed for setting up noise suppression WebAssembly and
-     * AudioWorklet
-     */
-    denoiseParams?: DenoiseParams;
-    /**
-     * Update frequency for analyzer per second
-     *
-     * @defaultValue 0.5
-     */
-    analyzerUpdateFrequency?: number;
-    /**
-     * Audio Signal Detection duration in second
-     *
-     * @defaultValue 4.0
-     */
-    audioSignalDetectionDuration?: number;
-    /**
-     * Callback when Voice Activity detected
-     */
-    onVoiceActivityDetected?: () => void;
-    /**
-     * Callback when Audio Signal detected
-     */
-    onAudioSignalDetected?: (silent: boolean) => void;
-    /**
-     * @see AudioGraphOptions
-     */
-    audioGraphOptions?: AudioGraphOptions;
-    /**
-     * Whether or to enable this processor
-     */
-    shouldEnable: () => boolean;
-    /**
-     * Insert additional nodes between the source and destination
-     */
-    createNodes?: CreateNodes;
-    /**
-     * Silent threshold, how large the value of the sample is considered as
-     * silent in FFTed time domain
-     */
-    silentThreshold?: number;
-    scope?: string;
-}
-/**
- * Create a Audio Stream Processor and will own the stream passed-in
- */
-declare const createAudioStreamProcess: ({ analyzerUpdateFrequency, audioGraphOptions, audioSignalDetectionDuration, clock, createNodes, denoiseParams, fftSize, onAudioSignalDetected, onVoiceActivityDetected, shouldEnable, silentThreshold, throttleMs, scope, }: AudioProcessOptions & ThrottleOptions) => Process<Promise<Media>>;
-
-interface ProcessorDeps {
-    videoProcessor?: VideoProcessor;
-    transformer?: SegmentationTransform;
-    segmenters: Segmenters;
-    videoSegmentationModel?: SegmentationModel;
-}
-interface VideoStreamProcessOptions extends Partial<VideoRenderParams>, Omit<ProcessorDeps, 'videoProcessor'> {
-    /**
-     * What API to use for processing the MediaStreamTrack
-     * `stream` - Use MediaStreamTrackProcessor, when available
-     * `canvas` - Use Canvas
-     */
-    trackProcessorAPI?: VideoStreamTrackProcessorAPIs;
-    /**
-     * Whether or to enable this processor
-     */
-    shouldEnable: () => boolean;
-    /**
-     * Callback when error occurs
-     */
-    onError?: (error: Error) => void;
-    processingWidth: number;
-    processingHeight: number;
-    hasInitializedDeps?: boolean;
-    width?: number;
-    height?: number;
-    scope?: string;
-}
-declare const createVideoStreamProcess: ({ trackProcessorAPI, processingWidth, processingHeight, shouldEnable, frameRate, videoSegmentation, foregroundThreshold, bgImageUrl, flipHorizontal, edgeBlurAmount, scope, ...options }: VideoStreamProcessOptions) => Process<Promise<Media>>;
-
-/**
- * Log meta and message with respective log level
- */
-type LogMethod = (meta: unknown, message?: string) => void;
-declare enum LogLevels {
-    trace = 10,
-    debug = 20,
-    info = 30,
-    warn = 40,
-    error = 50,
-    fatal = 60,
-    silent
-}
-type LogLevelsString = keyof typeof LogLevels;
-type LogMethods = {
-    [key in LogLevelsString]: LogMethod;
-};
-/**
- * Log Level from high to low, "fatal" | "error" | "warn" | "info" | "debug" | "trace"
- * Typically, debug and trace logs are only valid for development, and not needed in production
- */
-interface Logger extends LogMethods {
-    /**
-     * Adds a value to the redaction set, which makes it replaced by [REDACTED] when logged to file.
-     *
-     * @remarks
-     * The redaction set is applied globally, and only applies to the log file, not console logs.
-     *
-     * @param value - the string to redact
-     */
-    redact(value: string): void;
-}
-
-declare function setLogger(newLogger: Logger): void;
-
-type EventCallback<T> = (event: T) => void;
-type EventErrorCallback = (error: Error) => void;
-type PreviewInput = MediaDeviceInfoLike | undefined;
-interface PreviewEventHandler {
-    audioInput?: EventCallback<PreviewInput>;
-    videoInput?: EventCallback<PreviewInput>;
-    media?: EventCallback<Media>;
-    videoInputError?: EventErrorCallback;
-    audioInputError?: EventErrorCallback;
-    applyChangesError?: EventErrorCallback;
-    revertChangesError?: EventErrorCallback;
-    updatingPreview?: EventCallback<boolean>;
-    updatingMain?: EventCallback<boolean>;
-    unsubscribeMain?: Unsubscribe;
-}
-interface PreviewStreamParams {
-    getCurrentDevices: () => MediaDeviceInfoLike[];
-    getCurrentMedia: () => Media | undefined;
-    updateMainStream: (request: MediaDeviceRequest) => Promise<void>;
-    mediaSignal: MediaSignals['onMediaChanged'];
-    onEnded?: () => void;
-    fftSize?: number;
-    queueOptions?: Partial<AsyncQueueOptions>;
-    processors: MediaProcessor[];
-}
-interface PreviewControllerProps {
-    media: Media;
-    audioInput?: MediaDeviceInfoLike;
-    videoInput?: MediaDeviceInfoLike;
-    updatingPreview: boolean;
-    updatingMain: boolean;
-    originalMainAudioInput?: MediaDeviceInfoLike;
-    discardMedia: boolean;
-    initialized: boolean;
-}
-interface PreviewStreamController {
-    media: Media;
-    audioInputChanged: boolean;
-    videoInputChanged: boolean;
-    inputChanged: boolean;
-    audioInput: PreviewInput;
-    videoInput: PreviewInput;
-    updatingPreview: boolean;
-    updatingMain: boolean;
-    updateAudioInput(input: PreviewInput): void;
-    updateVideoInput(input: PreviewInput): void;
-    applyChanges(): Promise<void>;
-    revertChanges(): Promise<void>;
-    onMediaChanged(callback: EventCallback<Media>): Unsubscribe;
-    onAudioInputChanged(callback: EventCallback<PreviewInput>): Unsubscribe;
-    onVideoInputChanged(callback: EventCallback<PreviewInput>): Unsubscribe;
-    onUpdatingPreview(callback: EventCallback<boolean>): Unsubscribe;
-    onUpdatingMain(callback: EventCallback<boolean>): Unsubscribe;
-    onAudioInputError(callback: EventErrorCallback): Unsubscribe;
-    onVideoInputError(callback: EventErrorCallback): Unsubscribe;
-    onApplyChangesError(callback: EventErrorCallback): Unsubscribe;
-    onRevertChangesError(callback: EventErrorCallback): Unsubscribe;
-}
-declare const createPreviewStreamController: ({ getCurrentDevices, getCurrentMedia, updateMainStream, onEnded, mediaSignal, queueOptions, processors, }: PreviewStreamParams) => PreviewStreamController;
-type CreatePreviewStreamController = typeof createPreviewStreamController;
-
-type UserMediaValidator = (status: UserMediaStatus) => boolean;
-declare const isFallbackVideo: UserMediaValidator;
-declare const isFallbackAudio: UserMediaValidator;
-declare const isFallback: UserMediaValidator;
-declare const hasNoDevice: UserMediaValidator;
-declare const hasNoAudioDevices: UserMediaValidator;
-declare const hasNoVideoDevices: UserMediaValidator;
-declare const isGrantedOnlyVideoNoAudioDevices: UserMediaValidator;
-declare const isPromptAudio: UserMediaValidator;
-declare const isGrantedOnlyVideo: UserMediaValidator;
-declare const isGrantedOnlyAudioNoVideoDevices: UserMediaValidator;
-declare const isPromptVideo: UserMediaValidator;
-declare const isGrantedOnlyAudio: UserMediaValidator;
-declare const areBothGranted: UserMediaValidator;
-declare const isGrantedVideo: UserMediaValidator;
-declare const isGrantedAudio: UserMediaValidator;
-declare const isGranted: UserMediaValidator;
-declare const isOnlyAudioError: UserMediaValidator;
-declare const isOnlyVideoError: UserMediaValidator;
-declare const isRejected: UserMediaValidator;
-declare const isRejectedOnlyAudio: UserMediaValidator;
-declare const isRejectedOnlyVideo: UserMediaValidator;
-declare const isOverConstrained: UserMediaValidator;
-declare const isUnknownError: UserMediaValidator;
-declare const isInitial: UserMediaValidator;
-declare const isInitialPermissions: UserMediaValidator;
-declare const isInitialPermissionsNotGranted: UserMediaValidator;
-declare const isInitialPermissionsGranted: UserMediaValidator;
-declare const isAudioDeviceInUse: UserMediaValidator;
-declare const isDeviceInUse: UserMediaValidator;
-declare const isVideoDeviceInUse: UserMediaValidator;
-declare const toDeniedDevices: (status?: UserMediaStatus) => DeniedDevices | undefined;
-declare const getPermissionStatus: (getPermissionState?: (anyActiveStream?: boolean | undefined) => Promise<_pexip_media_control.InputDevicePermission>) => Promise<UserMediaStatus.Initial | UserMediaStatus.InitialPermissionsGranted | UserMediaStatus.InitialPermissionsNotGranted | UserMediaStatus.InitialPermissionsVideoInputDenied | UserMediaStatus.InitialPermissionsAudioInputDenied | UserMediaStatus.InitialPermissionsVideoInputGranted | UserMediaStatus.InitialPermissionsAudioInputGranted | UserMediaStatus.InitialPermissionsGrantedVideoInputDenied | UserMediaStatus.InitialPermissionsGrantedAudioInputDenied | UserMediaStatus.PermissionsRejected>;
-declare const deriveInitialPermissionStatus: (prevStatus: UserMediaStatus, getPermissionState?: (anyActiveStream?: boolean | undefined) => Promise<_pexip_media_control.InputDevicePermission>) => Promise<UserMediaStatus>;
-
-/**
- * Create a general signal with consistent scoped name
- *
- * @param name - Signal name
- * @param crucial - Signify if the signal is unmissable. @defaultValue true
- * @param variant - The variant of the signal @see Signal @defaultValue 'generic'
- */
-declare const createMediaSignal: <T = undefined>(name: string, crucial?: boolean, variant?: SignalVariant) => Signal<T>;
-declare const REQUIRED_SIGNAL_KEYS: readonly ["onMediaChanged", "onVAD", "onSilentDetected"];
-/**
- * Create and return all required and optional (if specified with `more`),
- * signals for media to work
- *
- * @param more - Keys from `MediaSignalsOptional`, @see MediaSignalsOptional
- * @param scope - any scope prefix for the generated signal name, @see Signal
- *
- * The following signals created by default
- * - 'onMediaChanged',
- * - 'onVAD',
- *
- * @see REQUIRED_SIGNAL_KEYS
- */
-declare const createMediaSignals: <K extends "onDevicesChanged" | "onStatusChanged" | keyof StreamTrackSignals>(more: K[], scope?: string) => Pick<Required<MediaSignals>, "onMediaChanged" | "onVAD" | "onSilentDetected" | K>;
-
-/**
- * Apply the content hint to the track
- *
- * @param hint - Content hint
- * @param track - The track to be applied
- */
-declare const applyContentHint: <T extends "" | "speech" | "speech-recognition" | "music" | "motion" | "detail" | "text">(hint?: T | undefined) => (track: MediaStreamTrack) => void;
-
-/**
- * Create a Audio Mixing Processor and will own the stream passed-in
- */
-declare const createAudioMixingProcess: (getCurrrentMedia: () => MediaStream | undefined, scope?: string) => Process<Promise<Media>>;
-
-declare const createGetDisplayMedia: (getDefaultConstraints: () => DisplayMediaOptions, getDisplayMedia?: MediaDevices['getDisplayMedia']) => (constraints?: DisplayMediaOptions) => Promise<MediaStream | undefined>;
-type GetDisplayMedia = ReturnType<typeof createGetDisplayMedia>;
-
-export { AUDIO_CONTENT_HINTS, AudioContentHint, AudioDetectionSignals, AudioSignalDetectionOptions, CreatePreviewStreamController, DeniedDevices, DenoiseParams, ExtendedMediaTrackSettings, ExtendedMediaTrackSettingsKey, GetDisplayMedia, Media, MediaAttributes, MediaChangesSignals, MediaController, MediaOptions, MediaProcessor, MediaProps, MediaSettings, MediaSignals, MediaSignalsOptional, MediaSignalsRequired, Pipeline, PreviewControllerProps, PreviewEventHandler, PreviewInput, PreviewStreamController, PreviewStreamParams, Process, ProcessMedia, REQUIRED_SIGNAL_KEYS, Segmenters, StreamTrackSignals, Unsubscribe, UserMediaStatus, UserMediaValidator, VIDEO_CONTENT_HINTS, VideoContentHint, VideoRenderParams, VideoStreamTrackProcessorAPIs, VoiceActivityDetectionOptions, applyContentHint, areBothGranted, createAudioMixingProcess, createAudioStreamProcess, createGetDisplayMedia, createMedia, createMediaSignal, createMediaSignals, createPreviewStreamController, createVideoStreamProcess, deriveInitialPermissionStatus, getPermissionStatus, hasNoAudioDevices, hasNoDevice, hasNoVideoDevices, isAudioDeviceInUse, isDeviceInUse, isFallback, isFallbackAudio, isFallbackVideo, isGranted, isGrantedAudio, isGrantedOnlyAudio, isGrantedOnlyAudioNoVideoDevices, isGrantedOnlyVideo, isGrantedOnlyVideoNoAudioDevices, isGrantedVideo, isInitial, isInitialPermissions, isInitialPermissionsGranted, isInitialPermissionsNotGranted, isOnlyAudioError, isOnlyVideoError, isOverConstrained, isPromptAudio, isPromptVideo, isRejected, isRejectedOnlyAudio, isRejectedOnlyVideo, isUnknownError, isVideoDeviceInUse, setLogger, toDeniedDevices };
+export { createMedia } from './media';
+export { createAudioStreamProcess } from './audioProcessor';
+export { createVideoStreamProcess } from './videoProcessor';
+export * from './types';
+export { setLogger } from './logger';
+export * from './previewController';
+export * from './status';
+export * from './signals';
+export { applyContentHint } from './utils';
+export { createAudioMixingProcess } from './audioMixingProcessor';
+export * from './displayMedia';