@pexip/media-control 16.7.1

package/dist/index.d.ts

@@ -0,0 +1,923 @@
+/**
+ * A striped version of MediaDeviceInfo
+ *
+ * @beta
+ */
+type MediaDeviceInfoLike = Omit<MediaDeviceInfo, 'toJSON'> & {
+    settings?: MediaTrackSettings;
+    toJSON?: MediaDeviceInfo['toJSON'];
+};
+type DeviceConstraint = MediaDeviceInfoLike | MediaDeviceInfoLike[];
+interface ConstraintDeviceParameters {
+    exact?: DeviceConstraint;
+    ideal?: DeviceConstraint;
+}
+interface InputConstraintSet extends MediaTrackConstraints {
+    /**
+     * Same purpose as `deviceId` but it gives more information about the device
+     * so that we can have extra tolerance on device selection
+     */
+    device?: DeviceConstraint | ConstraintDeviceParameters;
+    /**
+     * Whether or not using video segmentation, e.g. background
+     * blur/replacement, to specify the effects, intended to be applied to the
+     * segment. Available effects are `none`, `blur`, `overlay` or `remove`
+     */
+    videoSegmentation?: ConstrainDOMString;
+    /**
+     * Segmentation model to be used for video segmentation, currently only
+     * supports `mediapipeSelfie` and `personify`
+     */
+    videoSegmentationModel?: ConstrainDOMString;
+    /**
+     * Whether or not using our own noise suppression
+     */
+    denoise?: ConstrainBoolean;
+    /**
+     * Voice Activity Detection
+     */
+    vad?: ConstrainBoolean;
+    /**
+     * Audio Signal Detection for the purpose of checking if the audio input is
+     * hardware muted or unusable
+     */
+    asd?: ConstrainBoolean;
+    /**
+     * Audio Signal Detection for the purpose of checking if the audio input is
+     * hardware muted or unusable
+     */
+    mixWithAdditionalMedia?: ConstrainBoolean;
+    /**
+     * Flip the video horizontally
+     */
+    flipHorizontal?: ConstrainBoolean;
+    /**
+     * Blur size/level parameter when using video segmentation with `blur`
+     * effects
+     */
+    backgroundBlurAmount?: ConstrainULong;
+    /**
+     * Blur amount applied to the segmented person's edge
+     */
+    edgeBlurAmount?: ConstrainULong;
+    /**
+     * Erode level for edge smoothing when using video segmentation
+     */
+    foregroundThreshold?: ConstrainDouble;
+    /**
+     * Image Url that is being used for video overlay effects
+     */
+    bgImageUrl?: ConstrainDOMString;
+}
+type InputDeviceConstraint = DeviceConstraint | InputConstraintSet | boolean;
+/**
+ * The request constraints that applies to `getMediaStream`
+ *
+ * @beta
+ */
+interface MediaDeviceRequest {
+    /**
+     * Either a Boolean (which indicates whether or not an audio track is
+     * requested) or a {@link MediaDeviceInfoLike} object providing a hint for the
+     * audio track included in the returned MediaStream
+     */
+    audio?: InputDeviceConstraint;
+    /**
+     * Either a Boolean (which indicates whether or not an video track is
+     * requested) or a {@link MediaDeviceInfoLike} object providing a hint for the
+     * video track included in the returned MediaStream
+     */
+    video?: InputDeviceConstraint;
+}
+/**
+ * an enum of MediaDeviceKind which can be reused
+ *
+ * @beta
+ */
+declare enum MediaDeviceKinds {
+    /** audio input */
+    AUDIOINPUT = "audioinput",
+    /** audio output */
+    AUDIOOUTPUT = "audiooutput",
+    /** video input */
+    VIDEOINPUT = "videoinput"
+}
+/**
+ * MediaTrackConstraints.facingMode
+ * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/MediaTrackConstraints/facingMode}
+ */
+declare const FACING_MODE: readonly ["user", "environment", "left", "right"];
+type FacingMode = (typeof FACING_MODE)[number];
+/**
+ * An enum of failure events for media device
+ *
+ * @beta
+ */
+declare enum MediaDeviceFailure {
+    /**
+     * some problem (not user or permissions) occurred which prevented the device
+     * from being used.
+     */
+    AbortError = "AbortError",
+    /**
+     * Custom error for when selected audio and video device is not found
+     */
+    AudioAndVideoDeviceNotFoundError = "AudioAndVideoDeviceNotFoundError",
+    /**
+     * Custom error for selected audio device not found
+     */
+    AudioInputDeviceNotFoundError = "AudioInputDeviceNotFoundError",
+    /**
+     * Custom missing constraints error
+     */
+    MissingConstraintsError = "MissingConstraintsError",
+    /**
+     * user has blocked access
+     */
+    NotAllowedError = "NotAllowedError",
+    /**
+     * the media tracks doesn't match the constraints
+     */
+    NotFoundError = "NotFoundError",
+    /**
+     * hardware failure after user granted access
+     */
+    NotReadableError = "NotReadableError",
+    /**
+     * no devices met the criteria for the constraints
+     */
+    OverconstrainedError = "OverconstrainedError",
+    /**
+     * user has blocked access old chrome
+     */
+    PermissionDeniedError = "PermissionDeniedError",
+    /**
+     * User media support disabled by agent
+     */
+    SecurityError = "SecurityError",
+    /**
+     * when hardware in use old chrome win os
+     */
+    TrackStartError = "TrackStartError",
+    /**
+     * GetUserMedia invalid constraints error
+     */
+    TypeError = "TypeError",
+    /**
+     * Custom error for selected video device not found
+     */
+    VideoInputDeviceNotFoundError = "VideoInputDeviceNotFoundError",
+    /**
+     * action or function is not supported by the current platform
+     */
+    NotSupportedError = "NotSupportedError",
+    /**
+     * Canvas capture is not supported
+     */
+    StreamTrackNotFound = "StreamTrackNotFound"
+}
+/**
+ * Lesser strict type of `MediaStreamTrack`
+ *
+ * @beta
+ */
+type MediaStreamTrackLike = Pick<MediaStreamTrack, 'id' | 'kind' | 'label' | 'getSettings' | 'stop'>;
+/**
+ * Holds user media input devices
+ *
+ * @beta
+ */
+interface MediaInput {
+    audioInput?: MediaDeviceInfoLike;
+    videoInput?: MediaDeviceInfoLike;
+}
+type Unsubscribe = () => void;
+type TrackEventCallback = (track: MediaStreamTrack) => void;
+/**
+ * An object contains the event handlers
+ */
+interface StreamTrackEventHandlers {
+    ended?: TrackEventCallback;
+    mute?: TrackEventCallback;
+    unmute?: TrackEventCallback;
+}
+interface InputDevicePermission {
+    audio: PermissionState;
+    video: PermissionState;
+}
+
+/**
+ * DeviceChange Event
+ *
+ * ```
+ * devices (raw)
+ * |--- authorized
+ * |        |--- found
+ * |        |--- lost
+ * |--- unauthorized
+ * ```
+ *
+ * @beta
+ */
+type DeviceChangedChanges = {
+    authorized: MediaDeviceInfoLike[];
+    unauthorized: MediaDeviceInfoLike[];
+    found: MediaDeviceInfoLike[];
+    lost: MediaDeviceInfoLike[];
+    devices: MediaDeviceInfoLike[];
+};
+interface ToKeyOptions {
+    id: string;
+    kind: string;
+    label: string;
+}
+/**
+ * Convert provided info to key for Map
+ *
+ * @beta
+ */
+declare const toKey: ({ id, kind, label }: ToKeyOptions) => string;
+/**
+ * Future proofing: in case we want to alter the values or type returned
+ * by {@link https://developer.mozilla.org/en-US/docs/Web/API/MediaDevices/enumerateDevices | enumerateDevices}
+ *
+ * @returns
+ * a list of currently available {@link https://developer.mozilla.org/en-US/docs/Web/API/MediaDeviceInfo | devices}
+ *
+ * @example
+ * ```javascript
+ * import {getDevices} from "media-control";
+ *
+ * const devices = await getDevices();
+ * // return MediaDeviceInfo[]
+ * ```
+ *
+ * @beta
+ */
+declare const getDevices: () => Promise<MediaDeviceInfo[]>;
+declare const createTrackDevicesChanges: (prevDevices?: MediaDeviceInfoLike[]) => (devices: MediaDeviceInfoLike[]) => {
+    unauthorized: MediaDeviceInfoLike[];
+    authorized: MediaDeviceInfoLike[];
+    found: MediaDeviceInfoLike[];
+    lost: MediaDeviceInfoLike[];
+    devices: MediaDeviceInfoLike[];
+};
+/**
+ * Unified interface for subscribing {@link DeviceChangedChanges} Event
+ *
+ * @beta
+ */
+declare const deviceChanged: (fn: (event: DeviceChangedChanges) => void) => () => void;
+/**
+ * Convert `MediaStreamTrack` to `MediaDeviceInfoLike`
+ *
+ * @beta
+ */
+declare const toMediaDeviceInfoLike: (track: MediaStreamTrack) => MediaDeviceInfoLike | undefined;
+/**
+ * Find the MediaDeviceInfo from provided MediaDeviceInfo[] by comparing with
+ * provided MediaStreamTrack
+ *
+ * @param devices - A device list used for the searching
+ * @param track - A track for the searching criteria
+ *
+ * @returns `MediaDeviceInfo` if found, otherwise `undefined`
+ *
+ * @beta
+ */
+declare const findMediaInputFromMediaStreamTrack: (devices: MediaDeviceInfoLike[]) => (track?: MediaStreamTrack | undefined) => MediaDeviceInfoLike | undefined;
+/**
+ * Find media input from media stream
+ *
+ * @param devices - A list of media devices from
+ * `navigator.mediaDevices.enumerateDevices()`. Will be used for search target
+ * @param stream - A media stream used for the search criteria
+ *
+ * @returns A object may contains the devices
+ *
+ * @beta
+ */
+declare const findMediaInputFromStream: (devices: MediaDeviceInfoLike[]) => (stream: MediaStream | undefined) => MediaInput;
+declare const isRequestedResolution: (request: InputDeviceConstraint | undefined, response: MediaDeviceInfoLike | undefined) => boolean;
+declare const isRequestedInputDevice: (request: InputDeviceConstraint | undefined, response: MediaDeviceInfoLike | undefined) => boolean;
+/**
+ * Compare request and the input to see if the request has been fulfilled
+ */
+declare const isRequestedInputTrack: (request: InputDeviceConstraint | undefined, current: MediaStreamTrack | MediaDeviceInfoLike | undefined) => boolean;
+declare const hasRequestingDevice: (request: InputDeviceConstraint | undefined, kind: MediaDeviceKind, currentDevices: MediaDeviceInfoLike[]) => boolean;
+/**
+ * Decide if we should send a new gUM request based on the inputs
+ *
+ * @param request - Requesting input device constraint
+ * @param tracks - The current media stream tracks
+ * @param currentDevices - The current list of device of the same kind of the
+ * request
+ *
+ * @returns `true` means the request should be conducted, otherwise `false`.
+ */
+declare const shouldRequestDevice: (request: InputDeviceConstraint | undefined, tracks: MediaStreamTrack[], currentDevices: MediaDeviceInfoLike[]) => boolean;
+declare const isStreamingRequestedDevicesBase: (request: MediaDeviceRequest, tracksOrDevices: {
+    audio?: MediaDeviceInfoLike | MediaStreamTrack[];
+    video?: MediaDeviceInfoLike | MediaStreamTrack[];
+}, devices: MediaDeviceInfoLike[]) => {
+    audio: boolean;
+    video: boolean;
+};
+/**
+ * Check if provided request has already been fulfilled
+ *
+ * @param request - A media request constraints
+ * @param stream - Current media stream
+ *
+ * @returns
+ * audio - The stream is using the same device as requested if `true`
+ * video - The stream is using the same device as requested if `true`
+ */
+declare const isStreamingRequestedDevices: (request: MediaDeviceRequest, stream: MediaStream | undefined, devices: MediaDeviceInfoLike[]) => {
+    audio: boolean;
+    video: boolean;
+};
+/**
+ * Find in the list of devices which has permissions granted
+ *
+ * From MDN:
+ * For security reasons,the label field is always blank unless an active media stream
+ * exists or the user has granted persistent permission for media device access.
+ *
+ * @param devices - A list of media devices from
+ * `navigator.mediaDevices.enumerateDevices()`. Will be used for search target
+ *
+ * @returns List of devices that has permission granted
+ *
+ * @beta
+ */
+declare const findPermissionGrantedDevices: (devices: MediaDeviceInfoLike[]) => MediaDeviceInfoLike[];
+/**
+ * A wrapper for `navigator.permissions.query` with fallback to use
+ * `navigator.mediaDevices.enumerateDevices` to guess the `PermissionState`
+ *
+ * @param anyActiveStream - Has ever got an active stream to help the fallback to
+ * guess the state more accurately
+ */
+declare const getInputDevicePermissionState: (anyActiveStream?: boolean) => Promise<InputDevicePermission>;
+/**
+ * Find current audio output id to be used to set as sinkId
+ *
+ * If you set the stale deviceId to setSink it will throw exception.
+ * So we want to check if audio output id still exist.
+ *
+ * @param audioOutput - Audio output as `MediaDeviceInfo`
+ * @param devices - A list of media devices from
+ * `navigator.mediaDevices.enumerateDevices()`. Will be used for search target
+ *
+ * @returns Audio output id or empty string if couldn't find it.
+ *
+ * @beta
+ */
+declare const findCurrentAudioOutputId: (audioOutput?: MediaDeviceInfoLike, devices?: MediaDeviceInfoLike[]) => string;
+/**
+ * Find videoinput device id in the stream
+ *
+ * @param stream - Media stream to do the lookup
+ *
+ * @returns A object may contains the devices
+ *
+ * @beta
+ */
+declare const findCurrentVideoInputDeviceIdFromStream: (stream: MediaStream) => string | undefined;
+/**
+ * Finds device with given deviceId
+ *
+ * @param devices - A list of media devices from
+ * `navigator.mediaDevices.enumerateDevices()`. Will be used for search target
+ * @param deviceId - id that represents desired device
+ *
+ * @returns device with given deviceId
+ *
+ * @beta
+ */
+declare const findDeviceWithDeviceId: (devices: MediaDeviceInfoLike[], deviceId: string) => MediaDeviceInfoLike | undefined;
+/**
+ * Find in the list of devices with given MediaDeviceKind
+ *
+ * @param devices - A list of media devices from
+ * `navigator.mediaDevices.enumerateDevices()`. Will be used for search target
+ * @param kind - A list of media devices from
+ * `navigator.mediaDevices.enumerateDevices()`. Will be used for search target
+ *
+ * @returns List of devices that have required MediaDeviceKind
+ *
+ * @beta
+ */
+declare const findDevicesByKind: (kind: MediaDeviceKind) => (devices: MediaDeviceInfoLike[]) => MediaDeviceInfoLike[];
+/**
+ * Find in the list of devices only the audio input ones
+ *
+ * @param devices - A list of media devices from
+ * `navigator.mediaDevices.enumerateDevices()`. Will be used for search target
+ *
+ * @returns List of devices that are audio inputs
+ *
+ * @beta
+ */
+declare const findAudioInputDevices: (devices: MediaDeviceInfoLike[]) => MediaDeviceInfoLike[];
+/**
+ * Find in the list of devices only the video input ones
+ *
+ * @param devices - A list of media devices from
+ * `navigator.mediaDevices.enumerateDevices()`. Will be used for search target
+ *
+ * @returns List of devices that are video inputs
+ *
+ * @beta
+ */
+declare const findVideoInputDevices: (devices: MediaDeviceInfoLike[]) => MediaDeviceInfoLike[];
+/**
+ * Find in the list of devices only the audio output ones
+ *
+ * @param devices - A list of media devices from
+ * `navigator.mediaDevices.enumerateDevices()`. Will be used for search target
+ *
+ * @returns List of devices that are audio outputs
+ *
+ * @beta
+ */
+declare const findAudioOutputDevices: (devices: MediaDeviceInfoLike[]) => MediaDeviceInfoLike[];
+/**
+ * Set `MediaStreamTrack['enabled']` according to `mute` param for the provided `stream`
+ *
+ * @param stream - Media stream
+ * @param mute - disable or enable the audio stream
+ * @param mediaType - Can either be 'audio', 'video' or 'all'
+ * @defaultValue
+ * 'all'
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/MediaStreamTrack/enabled
+ *
+ * @beta
+ */
+declare const muteStreamTrack: (stream?: MediaStream) => (mute: boolean, mediaType?: 'audio' | 'video' | 'all') => void;
+/**
+ * Stops all tracks in the given stream
+ *
+ * Immediately after calling stop(), the readyState property is set to `ended`.
+ * Note that the `ended` event will not be fired in this situation
+ * https://developer.mozilla.org/en-US/docs/Web/API/MediaStreamTrack/stop#description
+ *
+ * @param stream - `MediaStream` which we mutate
+ * @param onStopped - callback to be called when the track is stopped
+ */
+declare const stopMediaStream: (stream: MediaStream | undefined, onStopped?: ((track: MediaStreamTrack) => void) | undefined) => void;
+/**
+ * Checks that tracks with a given type are enabled in the stream
+ *
+ * @param stream - `MediaStream` used for comparison
+ * @param type - `MediaInput` used for comparison
+ *
+ * @returns Return true when all the tracks are enabled false otherwise
+ *
+ * @beta
+ */
+declare const areTracksEnabled: (stream: MediaStream | undefined, type: 'audio' | 'video') => boolean;
+/**
+ * Check if list contains media inputs
+ *
+ * @param devices - A list of media devices from
+ * `navigator.mediaDevices.enumerateDevices()`. Will be used for search target
+ *
+ * @returns True when some media inputs false otherwise
+ *
+ * @beta
+ */
+declare const hasAudioOrVideoInputs: (devices: MediaDeviceInfoLike[]) => boolean;
+/**
+ * Check if list contains audio inputs
+ *
+ * @param devices - A list of media devices from
+ * `navigator.mediaDevices.enumerateDevices()`. Will be used for search target
+ *
+ * @returns True when some audio inputs false otherwise
+ *
+ * @beta
+ */
+declare const hasAudioInputs: (devices: MediaDeviceInfoLike[]) => boolean;
+/**
+ * Check if list contains video inputs
+ *
+ * @param devices - A list of media devices from
+ * `navigator.mediaDevices.enumerateDevices()`. Will be used for search target
+ *
+ * @returns True when some video inputs false otherwise
+ *
+ * @beta
+ */
+declare const hasVideoInputs: (devices: MediaDeviceInfoLike[]) => boolean;
+/**
+ * Check if provided devices have any granted input device
+ *
+ * @param devices - The devices to check
+ */
+declare const hasAnyGrantedInput: (devices: MediaDeviceInfoLike[]) => boolean;
+/**
+ * Check if provided devices have any video and audio inputs
+ *
+ * @param devices - The devices to lookup
+ * @param grantedOnly - When it is `true`, the device label is also taken into
+ * consideration
+ * @defaultValue `false`
+ *
+ * @returns A tuple of `[anyAudioInput, anyVideoInput]`, e.g. `[true, false]`
+ * means there is audio input but no video input
+ */
+declare const hasAnyInputs: (devices: MediaDeviceInfoLike[], grantedOnly?: boolean) => [boolean, boolean];
+/**
+ * An utility function to check the input device has been changed
+ *
+ * @param oldInput - The previous input device
+ * @param newInput - The current input device
+ */
+declare const hasChangedInput: (oldInput: MediaDeviceInfoLike | undefined, newInput: MediaDeviceInfoLike | undefined) => boolean;
+/**
+ * An utility function to check if facing mode is supported by interpreting the
+ * device label and the API `getSupportedConstraints`
+ *
+ * @remarks
+ * Only support snooping the label for English
+ *
+ * @param currentDevices - Current list of devices available
+ * @param getSupportedConstraints - A function to get supported constraints,
+ * i.e. `navigator.mediaDevices.getSupportedConstraints()`
+ * @param tracks - Current video input track
+ */
+declare const areMultipleFacingModeSupportted: (currentDevices: MediaDeviceInfoLike[], getSupportedConstraints?: () => MediaTrackSupportedConstraints) => boolean;
+/**
+ * Interpret the current facing mode from the provided track, and try to get the
+ * mode from settings, or use the label to guess the facing mode when facingMode
+ * is not supported from settings
+ *
+ * @param currentTrack - The current video input track
+ */
+declare const interpretCurrentFacingMode: (currentTrack: MediaStreamTrack | undefined) => FacingMode | undefined;
+
+declare const isAudioInput: (device: MediaDeviceInfoLike) => boolean;
+declare const isVideoInput: (device: MediaDeviceInfoLike) => boolean;
+declare const isAudioOutput: (device: MediaDeviceInfoLike) => boolean;
+/**
+ * Check if provided device is a permission-granted device by inspecting the
+ * device label
+ *
+ * @param device - The device to check
+ *
+ * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/MediaDeviceInfo/label#value}
+ **/
+declare const isDeviceGranted: (device: MediaDeviceInfoLike) => boolean;
+/**
+ * Compare 2 devices to see if they are the same by `deviceId` or `label` as
+ * a fallback
+ *
+ * @beta
+ */
+declare const compareDevices: (deviceInfo: MediaDeviceInfoLike, key?: Exclude<keyof MediaDeviceInfoLike, 'kind' | 'settings'>) => (anotherDeviceInfo: MediaDeviceInfoLike) => boolean;
+/**
+ * Lookup the the `device` from `devices` list
+ *
+ * @remarks
+ * When we cannot find the device by `deviceId`, we compare the label as last
+ * resort, and return the first one.
+ *
+ * @param deviceToFind - Provide a device info to be used for the searching
+ * @param useFallback - Whether to use `label` as a fallback when there is no
+ * match from using `deviceId`
+ *
+ * @beta
+ */
+declare const findDevice: (deviceToFind: MediaDeviceInfoLike, useFallback?: boolean) => (devices: readonly MediaDeviceInfoLike[]) => MediaDeviceInfoLike | undefined;
+
+/**
+ * Reference https://w3c.github.io/mediacapture-main/#dom-mediatrackconstraintset
+ */
+declare const CONSTRAIN_STRING_KEYS: readonly ["facingMode", "resizeMode", "deviceId", "groupId"];
+declare const EXTENDED_CONSTRAIN_STRING_KEYS: readonly ["videoSegmentation", "videoSegmentationModel", "bgImageUrl"];
+type ExtendedConstrainStringKeys = (typeof EXTENDED_CONSTRAIN_STRING_KEYS)[number];
+type ConstrainStringKeys = (typeof CONSTRAIN_STRING_KEYS)[number];
+declare const CONSTRAIN_U_LONG_KEYS: readonly ["width", "height", "sampleRate", "sampleSize", "channelCount"];
+declare const EXTENDED_CONSTRAIN_U_LONG_KEYS: readonly ["backgroundBlurAmount", "edgeBlurAmount"];
+type ExtendedConstrainULongKeys = (typeof EXTENDED_CONSTRAIN_U_LONG_KEYS)[number];
+type ConstrainULongKeys = (typeof CONSTRAIN_U_LONG_KEYS)[number];
+declare const CONSTRAIN_DOUBLE_KEYS: readonly ["aspectRatio", "frameRate", "latency"];
+declare const EXTENDED_CONSTRAIN_DOUBLE_KEYS: readonly ["foregroundThreshold"];
+type ExtendedConstrainDoubleKeys = (typeof EXTENDED_CONSTRAIN_DOUBLE_KEYS)[number];
+type ConstrainDoubleKeys = (typeof CONSTRAIN_DOUBLE_KEYS)[number];
+declare const CONSTRAIN_BOOLEAN_KEYS: readonly ["echoCancellation", "autoGainControl", "noiseSuppression"];
+/**
+ * Extends boolean constraint keys for our own implementation of the media
+ * feature
+ */
+declare const EXTENDED_CONSTRAIN_BOOLEAN_KEYS: readonly ["vad", "asd", "mixWithAdditionalMedia", "denoise", "flipHorizontal"];
+type ExtendedConstrainBooleanKeys = (typeof EXTENDED_CONSTRAIN_BOOLEAN_KEYS)[number];
+type ConstrainBooleanKeys = (typeof CONSTRAIN_BOOLEAN_KEYS)[number];
+/**
+ * Check if provided is `MediaDeviceInfo`
+ *
+ * @beta
+ */
+declare const isMediaDeviceInfo: (t: unknown) => t is MediaDeviceInfo;
+declare const isMediaDeviceInfoArray: (t: unknown) => t is MediaDeviceInfo[];
+declare const CONSTRAIN_PARAM_KEYS: readonly ["exact", "ideal"];
+type ConstrainParamKeys = (typeof CONSTRAIN_PARAM_KEYS)[number];
+declare const CONSTRAIN_RANGE_KEYS: readonly ["min", "max"];
+type ConstrainRangeKeys = (typeof CONSTRAIN_RANGE_KEYS)[number];
+type ConstrainRangeParamKeys = ConstrainParamKeys | ConstrainRangeKeys;
+/**
+ * Check if provided is `MediaStreamTrack`
+ *
+ * @beta
+ */
+declare const isMediaStreamTrack: (m: unknown) => m is MediaStreamTrack;
+declare const isFacingMode: (s: unknown) => s is "user" | "environment" | "left" | "right";
+
+/**
+ * Check if provided constraint is an `exact` device constraint
+ */
+declare const isExactDeviceConstraint: (constraint: InputDeviceConstraint | undefined) => boolean;
+/**
+ * Merge base constraints with provided base constraints and another constraints
+ */
+declare const mergeConstraints: (baseConstraints: InputConstraintSet | boolean | undefined) => (constraints: InputDeviceConstraint | undefined) => InputConstraintSet | boolean;
+type ConstrainNoneTuple = [undefined, 'ideal'];
+type ConstrainStringTuple = [string[], ConstrainParamKeys];
+type ConstrainBooleanTuple = [boolean, ConstrainParamKeys];
+type ConstrainNumber = number | Partial<Record<ConstrainRangeParamKeys, number>>;
+type ConstrainNumberTuple = [
+    ConstrainNumber,
+    ConstrainParamKeys | 'min-max'
+];
+type ConstrainDeviceTuple = [MediaDeviceInfoLike[], ConstrainParamKeys];
+declare const getValueFromConstrainNumber: (constraint: ConstrainNumber) => number;
+declare const getFacingModeFromConstraintString: (constraint: string) => FacingMode | undefined;
+/**
+ * Call applyConstraints foreach track accordingly
+ *
+ * @param tracks - Tracks to be applied
+ * @param constraints - constraints to be applied
+ */
+declare const applyConstraints: (tracks: MediaStreamTrack[] | undefined, constraints: MediaDeviceRequest) => Promise<void>;
+type ConstrainNumberKeys = ConstrainULongKeys | ConstrainDoubleKeys | ExtendedConstrainDoubleKeys | ExtendedConstrainULongKeys;
+type ConstrainStrings = Record<ConstrainStringKeys | ExtendedConstrainStringKeys, ConstrainStringTuple | ConstrainNoneTuple>;
+type ConstrainNumbers = Record<ConstrainNumberKeys, ConstrainNumberTuple | ConstrainNoneTuple>;
+type ConstrainBooleans = Record<ConstrainBooleanKeys | ExtendedConstrainBooleanKeys, ConstrainBooleanTuple | ConstrainNoneTuple>;
+type ConstrainDevices = Record<'device', ConstrainDeviceTuple | ConstrainNoneTuple>;
+type Constraints = ConstrainStrings & ConstrainNumbers & ConstrainBooleans & ConstrainDevices;
+/**
+ * Extract the constraints with provided keys
+ *
+ * @param keys - The keys to be used for the extraction
+ * @param constraints - The constraints to be used for the extraction
+ *
+ * @returns an object with the provided key and the value-param tuple
+ *
+ * @example
+ *
+ * ```typescript
+ * const device = {deviceId: 'xxxx', label: 'abc', kind: 'audioinput'};
+ * const constraints = { device, noiseSuppression: true };
+ * const extract = extractConstraintsWithKeys(['device', 'noiseSuppression']);
+ * const {
+ *   device: [devices, deviceParam],
+ *   noiseSuppression: [noiseSuppression, noiseSuppressionParam],
+ * } = extract(constraints);
+ * expect(devices).toEqual([device]);
+ * expect(deviceParam).toEqual('ideal');
+ * expect(noiseSuppression).toEqual(true);
+ * expect(noiseSuppressionParam).toEqual('ideal');
+ * ```
+ */
+declare const extractConstraintsWithKeys: <T extends "deviceId" | "groupId" | "facingMode" | "resizeMode" | "videoSegmentation" | "videoSegmentationModel" | "bgImageUrl" | ConstrainNumberKeys | "echoCancellation" | "autoGainControl" | "noiseSuppression" | "vad" | "asd" | "mixWithAdditionalMedia" | "denoise" | "flipHorizontal" | "device">(keys: T[]) => (constraints: InputDeviceConstraint | undefined) => Pick<Constraints, T>;
+/**
+ * Find device from the device list with provided constraints
+ *
+ * @param constraints - The constraints to be used for the lookup
+ * @param devices - The devices to be used for the lookup
+ *
+ * @returns `true` means it can be any devices, `undefined` means not found,
+ * otherwise, the matched device will be returned
+ */
+declare const findDeviceFromConstraints: (constraints: InputDeviceConstraint | undefined, devices: MediaDeviceInfoLike[]) => boolean | MediaDeviceInfoLike | undefined;
+/**
+ * Relax input constraints to enable looking up the device by `deviceId` as well
+ * as `label` as a fallback as a best effort to get a similar device when
+ * possible.
+ *
+ * @param input - The input constraints to be relaxed
+ * @param devices - The current device list
+ */
+declare const relaxInputConstraint: (input: InputDeviceConstraint | undefined, devices: MediaDeviceInfoLike[]) => InputDeviceConstraint | undefined;
+
+/**
+ * MediaStreamTrack Events
+ *
+ * @remarks
+ * See MDN {@link https://developer.mozilla.org/en-US/docs/Web/API/MediaStreamTrack#Events | Events}
+ *
+ * @beta
+ */
+declare enum MediaEventType {
+    /**
+     * Sent to the MediaStreamTrack when the value of the muted property is
+     * changed to true, indicating that the track is unable to provide data
+     * temporarily (such as when the network is experiencing a service
+     * malfunction).
+     */
+    Mute = "mute",
+    /**
+     * Sent to the track when data becomes available again, ending the muted state.
+     */
+    Unmute = "unmute",
+    /**
+     * Sent when playback of the track ends (when the value readyState changes to
+     * ended).
+     */
+    Ended = "ended",
+    /**
+     * Fired when a media input or output device is attached to or removed from
+     * the user's computer.
+     *
+     * @remarks
+     * See MDN {@link https://developer.mozilla.org/en-US/docs/Web/API/MediaDevices#Events | Events}
+     */
+    DevicesChanged = "devices:changed",
+    /**
+     * Found new devices from authorized device list
+     */
+    DevicesFound = "devices:found",
+    /**
+     * Lost devices from authorized device list
+     */
+    DevicesLost = "devices:lost",
+    /**
+     * Lost device from authorized device list
+     */
+    DeviceLost = "device:lost",
+    /**
+     * Unauthorized devices
+     */
+    DevicesUnauthorized = "devices:unauthorized",
+    /**
+     * No Input Devices, and no further device events will be emitted
+     */
+    NoInputDevices = "devices:noinput",
+    /**
+     * Other errors
+     */
+    Error = "error",
+    /**
+     * When stream
+     */
+    Stream = "stream"
+}
+/**
+ * Event object by MediaEventType
+ *
+ * @beta
+ */
+type Events = {
+    id: string;
+    type: MediaEventType.Mute;
+} | {
+    id: string;
+    type: MediaEventType.Unmute;
+} | {
+    id: string;
+    type: MediaEventType.Ended;
+} | {
+    devices: MediaDeviceInfoLike[];
+    type: MediaEventType.DevicesChanged;
+} | {
+    devices: MediaDeviceInfoLike[];
+    authorizedDevices: MediaDeviceInfoLike[];
+    unauthorizedDevices: MediaDeviceInfoLike[];
+    type: MediaEventType.DevicesFound;
+} | {
+    devices: MediaDeviceInfoLike[];
+    authorizedDevices: MediaDeviceInfoLike[];
+    unauthorizedDevices: MediaDeviceInfoLike[];
+    type: MediaEventType.DevicesLost;
+} | {
+    devices: MediaDeviceInfoLike[];
+    authorizedDevices: MediaDeviceInfoLike[];
+    type: MediaEventType.DevicesUnauthorized;
+} | {
+    devices: MediaDeviceInfoLike[];
+    type: MediaEventType.NoInputDevices;
+} | {
+    device: MediaDeviceInfoLike;
+    type: MediaEventType.DeviceLost;
+} | {
+    error: Error;
+    type: MediaEventType.Error;
+} | {
+    facingMode: boolean;
+    stream: MediaStream;
+    type: MediaEventType.Stream;
+    video: boolean;
+};
+/**
+ * Custom Media Event
+ * @beta
+ */
+type MediaEvent = CustomEvent<Events>;
+
+/**
+ * Create a MediaStreamTrack's native events subscription
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/MediaStreamTrack#events
+ *
+ * @param track - The track used for the subscription
+ * @param handlers - An object contains the event handlers
+ */
+declare const createStreamTrackEventSubscriptions: (track: MediaStreamTrack, handlers: StreamTrackEventHandlers) => Unsubscribe;
+
+/**
+ * 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;
+
+/**
+ * media-control is meant to extend the mediaDevices api methods such as
+ * `getUserMedia`, `enumerateDevices` and events on media streams and tracks.
+ * The final goal is to have a library that gives a stable and robust way to use
+ * these methods while guaranteeing that the developer has better control over
+ * which devices are delivered, fail, or exist.
+ *
+ * @packageDocumentation
+ */
+
+declare const 
+/**
+ * Get MediaStream with provided {@link MediaDeviceRequest | input constraints}
+ */
+getUserMedia: ({ audio, video, }: MediaDeviceRequest) => Promise<MediaStream>;
+declare const /**
+ * Set default media stream constraints
+ *
+ * A {@link
+ * https://developer.mozilla.org/en-US/docs/Web/API/MediaStreamConstraints |
+ * MediaStreamConstraints} object specifying the types of media to request, along with any requirements for each type.
+ */
+setDefaultConstraints: (newConstraints: MediaStreamConstraints) => void;
+declare const /**
+ * Subscribe media events
+ */
+subscribe: (listener: (event: MediaEvent) => void) => () => void;
+
+/**
+ * MediaControl Interface
+ *
+ * @beta
+ */
+interface MediaControl {
+    /** {@inheritDoc deviceChanged} */
+    deviceChanged: typeof deviceChanged;
+    /** {@inheritDoc getDevices} */
+    getDevices: typeof getDevices;
+    /** {@inheritDoc MediaEventType} */
+    MediaEventType: typeof MediaEventType;
+    /** {@inheritDoc getUserMedia} */
+    getUserMedia: typeof getUserMedia;
+    /** {@inheritDoc setDefaultConstraints} */
+    setDefaultConstraints: typeof setDefaultConstraints;
+    /** {@inheritDoc subscribe} */
+    subscribe: typeof subscribe;
+}
+
+export { DeviceChangedChanges, Events, FacingMode, InputConstraintSet, InputDevicePermission, MediaControl, MediaDeviceFailure, MediaDeviceInfoLike, MediaDeviceKinds, MediaDeviceRequest, MediaEvent, MediaEventType, MediaInput, MediaStreamTrackLike, StreamTrackEventHandlers, Unsubscribe, applyConstraints, areMultipleFacingModeSupportted, areTracksEnabled, compareDevices, createStreamTrackEventSubscriptions, createTrackDevicesChanges, deviceChanged, extractConstraintsWithKeys, findAudioInputDevices, findAudioOutputDevices, findCurrentAudioOutputId, findCurrentVideoInputDeviceIdFromStream, findDevice, findDeviceFromConstraints, findDeviceWithDeviceId, findDevicesByKind, findMediaInputFromMediaStreamTrack, findMediaInputFromStream, findPermissionGrantedDevices, findVideoInputDevices, getDevices, getFacingModeFromConstraintString, getInputDevicePermissionState, getUserMedia, getValueFromConstrainNumber, hasAnyGrantedInput, hasAnyInputs, hasAudioInputs, hasAudioOrVideoInputs, hasChangedInput, hasRequestingDevice, hasVideoInputs, interpretCurrentFacingMode, isAudioInput, isAudioOutput, isDeviceGranted, isExactDeviceConstraint, isFacingMode, isMediaDeviceInfo, isMediaDeviceInfoArray, isMediaStreamTrack, isRequestedInputDevice, isRequestedInputTrack, isRequestedResolution, isStreamingRequestedDevices, isStreamingRequestedDevicesBase, isVideoInput, mergeConstraints, muteStreamTrack, relaxInputConstraint, setDefaultConstraints, setLogger, shouldRequestDevice, stopMediaStream, subscribe, toKey, toMediaDeviceInfoLike };