@pexip/media 16.7.1

package/dist/index.d.ts

@@ -0,0 +1,739 @@
+import * as _pexip_media_control from '@pexip/media-control';
+import { MediaDeviceRequest, MediaDeviceInfoLike, InputConstraintSet } 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;
+}
+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;
+        video?: InputConstraintSet;
+    };
+}
+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;
+};
+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;
+}
+
+/**
+ * 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>;
+
+/**
+ * Create a Audio Mixing Processor and will own the stream passed-in
+ */
+declare const createAudioMixingProcess: (getCurrrentMedia: () => MediaStream | undefined, scope?: string) => Process<Promise<Media>>;
+
+export { AudioDetectionSignals, AudioSignalDetectionOptions, CreatePreviewStreamController, DeniedDevices, DenoiseParams, ExtendedMediaTrackSettings, ExtendedMediaTrackSettingsKey, 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, VideoRenderParams, VideoStreamTrackProcessorAPIs, VoiceActivityDetectionOptions, areBothGranted, createAudioMixingProcess, createAudioStreamProcess, 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 };