native-fn 1.3.0 → 1.3.2

package/dist/plugin/notification/index.mjs

@@ -90,6 +90,8 @@ var PermissionType;
     PermissionType["ClipboardRead"] = "clipboard-read";
     PermissionType["Microphone"] = "microphone";
     PermissionType["MIDI"] = "midi";
+    PermissionType["DeviceOrientation"] = "device-orientation";
+    PermissionType["DeviceMotion"] = "device-motion";
 })(PermissionType || (PermissionType = {}));
 var PermissionState;
 (function (PermissionState) {
@@ -121,6 +123,212 @@ var GET_USER_MEDIA = (function () {
     }
 })();
 
+var IE_WRAPPER_STORE = [];
+var MEDIA_QUERY_LIST_WRAPPER_STORE = [];
+function isEventListenerCallback(callback) {
+    return (typeof callback === 'function' ||
+        (typeof callback === 'object' && callback !== null && typeof callback.handleEvent === 'function'));
+}
+function isMediaQueryListTarget(target) {
+    return typeof target.media === 'string' && typeof target.matches === 'boolean';
+}
+function findIEWrapper(target, type, callback) {
+    for (var i = 0; i < IE_WRAPPER_STORE.length; i++) {
+        var wrapper = IE_WRAPPER_STORE[i];
+        if (wrapper.target === target && wrapper.type === type && wrapper.callback === callback)
+            return wrapper.wrapper;
+    }
+    return undefined;
+}
+function setIEWrapper(target, type, callback, wrapper) {
+    IE_WRAPPER_STORE.push({ target: target, type: type, callback: callback, wrapper: wrapper });
+}
+function removeIEWrapper(target, type, callback) {
+    for (var i = 0; i < IE_WRAPPER_STORE.length; i++) {
+        var wrapper = IE_WRAPPER_STORE[i];
+        if (wrapper.target === target && wrapper.type === type && wrapper.callback === callback) {
+            IE_WRAPPER_STORE.splice(i, 1);
+            return wrapper.wrapper;
+        }
+    }
+    return undefined;
+}
+function findMediaQueryListWrapper(target, type, callback) {
+    for (var i = 0; i < MEDIA_QUERY_LIST_WRAPPER_STORE.length; i++) {
+        var wrapper = MEDIA_QUERY_LIST_WRAPPER_STORE[i];
+        if (wrapper.target === target && wrapper.type === type && wrapper.callback === callback)
+            return wrapper.wrapper;
+    }
+    return undefined;
+}
+function setMediaQueryListWrapper(target, type, callback, wrapper) {
+    MEDIA_QUERY_LIST_WRAPPER_STORE.push({ target: target, type: type, callback: callback, wrapper: wrapper });
+}
+function removeMediaQueryListWrapper(target, type, callback) {
+    for (var i = 0; i < MEDIA_QUERY_LIST_WRAPPER_STORE.length; i++) {
+        var wrapper = MEDIA_QUERY_LIST_WRAPPER_STORE[i];
+        if (wrapper.target === target && wrapper.type === type && wrapper.callback === callback) {
+            MEDIA_QUERY_LIST_WRAPPER_STORE.splice(i, 1);
+            return wrapper.wrapper;
+        }
+    }
+    return undefined;
+}
+function createMediaQueryListWrapper(callback) {
+    return function (event) {
+        if (typeof callback === 'function') {
+            callback.call(this, event);
+        }
+        else if (callback && typeof callback.handleEvent === 'function') {
+            callback.handleEvent(event);
+        }
+    };
+}
+function capitalize(_) {
+    var groups = [];
+    for (var _i = 1; _i < arguments.length; _i++) {
+        groups[_i - 1] = arguments[_i];
+    }
+    var result = '';
+    for (var i = 0; i < groups.length - 2; i++) {
+        var arg = groups[i];
+        if (typeof arg !== 'undefined')
+            result = result + arg.charAt(0).toUpperCase() + arg.slice(1);
+    }
+    return result;
+}
+function withVendor(target, type) {
+    if (target === globalThis.document && ['deviceready', 'pause', 'resume', 'backbutton', 'menubutton', 'searchbutton', 'startcallbutton', 'endcallbutton', 'volumedownbutton', 'volumeupbutton', 'activated', 'cordovacallbackerror'].indexOf(type) > -1)
+        return type;
+    if (typeof target.webkitEnterFullscreen === 'function' && ['webkitbeginfullscreen', 'webkitendfullscreen', 'webkitpresentationmodechanged'].indexOf(type) > -1)
+        return type;
+    var types;
+    if (typeof LEGACY_TYPE_MAP[type] !== 'undefined')
+        types = LEGACY_TYPE_MAP[type];
+    else if (EVENT_TYPE_REGEXP.test(type))
+        types = [type, type.replace(EVENT_TYPE_REGEXP, capitalize)];
+    else
+        types = [type];
+    for (var i = 0; i < VENDORS.length; i++) {
+        for (var j = 0; j < types.length; j++) {
+            var name_1 = VENDORS[i] + types[j];
+            if (typeof target['on' + name_1] !== 'undefined')
+                return name_1;
+        }
+    }
+    return type;
+}
+function preventDefaultPolyfill() {
+    this.returnValue = false;
+}
+function stopPropagationPolyfill() {
+    this.cancelBubble = true;
+}
+var EVENT_TYPE_REGEXP = /(animation)(start|iteration|end|cancel)|(transition)(start|run|end|cancel)|(fullscreen)(change|error)|(lost|got)(pointer)(capture)|(pointer)(lock)(change|error)|(pointer)(cancel|down|enter|leave|move|out|over|up)/i;
+var VENDORS = ['', 'webkit', 'moz', 'ms', 'MS', 'o', 'O'];
+var LEGACY_TYPE_MAP = {
+    'wheel': ['wheel', 'mousewheel', 'DOMMouseScroll'],
+    'focus': ['focus', 'focusin'],
+    'blur': ['blur', 'focusout'],
+    'beforeinput': ['beforeinput', 'textInput'],
+};
+var EventListener = {
+    useStd: typeof globalThis.document.addEventListener === 'function',
+    add: function (target, eventListenerOptions) {
+        if (typeof eventListenerOptions.type === 'undefined')
+            return;
+        if (typeof target === 'undefined')
+            return;
+        var callback = eventListenerOptions.callback;
+        var type = withVendor(target, eventListenerOptions.type);
+        var options = eventListenerOptions.options;
+        if (isMediaQueryListTarget(target)) {
+            if (typeof target.addListener === 'function') {
+                try {
+                    var wrapper = findMediaQueryListWrapper(target, type, callback);
+                    if (typeof wrapper === 'undefined') {
+                        setMediaQueryListWrapper(target, type, callback, wrapper = createMediaQueryListWrapper(callback));
+                    }
+                    return target.addListener(wrapper);
+                }
+                catch (_) {
+                }
+            }
+        }
+        if (typeof target.addEventListener === 'function') {
+            try {
+                if (isEventListenerCallback(callback)) {
+                    return target.addEventListener(type, callback, options);
+                }
+            }
+            catch (_) {
+            }
+        }
+        if (typeof target.attachEvent === 'function') {
+            var existing = findIEWrapper(target, type, callback);
+            if (typeof existing === 'function')
+                return;
+            var wrapper = function (event) {
+                if (typeof event === 'undefined')
+                    event = globalThis.event;
+                if (typeof event === 'undefined')
+                    return;
+                try {
+                    Object.defineProperty(event, 'currentTarget', { value: target, configurable: true });
+                }
+                catch (_) {
+                }
+                if (typeof event.preventDefault !== 'function')
+                    event.preventDefault = preventDefaultPolyfill.bind(event);
+                if (typeof event.stopPropagation !== 'function')
+                    event.stopPropagation = stopPropagationPolyfill.bind(event);
+                if (typeof callback === 'function')
+                    callback.call(target, event);
+                else if (callback && typeof callback.handleEvent === 'function')
+                    callback.handleEvent(event);
+            };
+            setIEWrapper(target, type, callback, wrapper);
+            return target.attachEvent('on' + type, wrapper);
+        }
+    },
+    remove: function (target, eventListenerOptions) {
+        if (typeof eventListenerOptions.type === 'undefined')
+            return;
+        if (typeof target === 'undefined')
+            return;
+        var callback = eventListenerOptions.callback;
+        var type = withVendor(target, eventListenerOptions.type);
+        var options = eventListenerOptions.options;
+        if (isMediaQueryListTarget(target)) {
+            if (typeof target.removeListener === 'function') {
+                try {
+                    var wrapper = removeMediaQueryListWrapper(target, type, callback);
+                    if (typeof wrapper === 'function')
+                        return target.removeListener(wrapper);
+                }
+                catch (_) {
+                }
+            }
+            return;
+        }
+        if (typeof target.removeEventListener === 'function') {
+            try {
+                if (isEventListenerCallback(callback)) {
+                    return target.removeEventListener(type, callback, options);
+                }
+            }
+            catch (_) {
+            }
+        }
+        if (typeof target.detachEvent === 'function') {
+            var wrapper = removeIEWrapper(target, type, callback);
+            if (typeof wrapper === 'function')
+                target.detachEvent('on' + type, wrapper);
+            return;
+        }
+    },
+};
+
 var Permission = {
     get supported() {
         return supported$1();
@@ -131,14 +339,45 @@ var Permission = {
         PermissionType: PermissionType,
         PermissionState: PermissionState,
     },
-    Errors: {},
+    Errors: {
+        NotSupportedError: NotSupportedError,
+    },
 };
+function toPermissionState(permission) {
+    switch (permission) {
+        case 'granted':
+            return PermissionState.Grant;
+        case 'denied':
+            return PermissionState.Denied;
+        case 'prompt':
+        case 'default':
+            return PermissionState.Prompt;
+        default:
+            return PermissionState.Unsupported;
+    }
+}
+function toSafariSensorEventMap(type) {
+    switch (type) {
+        case PermissionType.DeviceOrientation:
+            return {
+                event: globalThis.DeviceOrientationEvent,
+                type: 'deviceorientation',
+            };
+        case PermissionType.DeviceMotion:
+            return {
+                event: globalThis.DeviceMotionEvent,
+                type: 'devicemotion',
+            };
+        default:
+            return undefined;
+    }
+}
 function supported$1() {
     return typeof globalThis.navigator.permissions !== 'undefined';
 }
 function request(type) {
     var instance = this;
-    return new Promise(function (resolve) {
+    return new Promise(function (resolve, reject) {
         function resolveAfterCheck() {
             instance.check(type).then(resolve);
         }
@@ -150,17 +389,8 @@ function request(type) {
                 case PermissionType.Notification:
                     if (typeof globalThis.Notification === 'undefined')
                         return resolve(PermissionState.Unsupported);
-                    globalThis.Notification.requestPermission().then(function (value) {
-                        switch (value) {
-                            case 'default':
-                                return resolve(PermissionState.Prompt);
-                            case 'granted':
-                                return resolve(PermissionState.Grant);
-                            case 'denied':
-                                return resolve(PermissionState.Denied);
-                            default:
-                                resolveAfterCheck();
-                        }
+                    globalThis.Notification.requestPermission().then(function (permission) {
+                        resolve(toPermissionState(permission));
                     });
                     break;
                 case PermissionType.Geolocation:
@@ -198,6 +428,23 @@ function request(type) {
                         .then(resolveAfterCheck)
                         .catch(resolveAfterCheck);
                     break;
+                case PermissionType.DeviceOrientation:
+                case PermissionType.DeviceMotion:
+                    var sensorEventMap = toSafariSensorEventMap(type);
+                    if (typeof sensorEventMap === 'undefined' || typeof sensorEventMap.event === 'undefined')
+                        return resolve(PermissionState.Unsupported);
+                    if (typeof sensorEventMap.event.requestPermission !== 'function')
+                        return resolve(PermissionState.Grant);
+                    try {
+                        sensorEventMap.event.requestPermission()
+                            .then(function (permission) {
+                            resolve(toPermissionState(permission));
+                        });
+                    }
+                    catch (_) {
+                        return reject(new NotSupportedError('\'DeviceOrientationEvent.requestPermission()\' must be called within a user gesture context.'));
+                    }
+                    break;
                 default:
                     return resolve(PermissionState.Unsupported);
             }
@@ -205,6 +452,34 @@ function request(type) {
     });
 }
 function check(type) {
+    if (type === PermissionType.DeviceOrientation || type === PermissionType.DeviceMotion) {
+        return new Promise(function (resolve) {
+            var sensorEventMap = toSafariSensorEventMap(type);
+            if (typeof sensorEventMap === 'undefined' || typeof sensorEventMap.event === 'undefined')
+                return resolve(PermissionState.Unsupported);
+            if (typeof sensorEventMap.event.requestPermission !== 'function')
+                return resolve(PermissionState.Grant);
+            var granted = false;
+            EventListener.add(globalThis, {
+                type: sensorEventMap.type,
+                callback: function () {
+                    granted = true;
+                },
+                options: { once: true }
+            });
+            setTimeout(function () {
+                if (granted)
+                    return resolve(PermissionState.Grant);
+                sensorEventMap.event.requestPermission()
+                    .then(function (permission) {
+                    resolve(toPermissionState(permission));
+                })
+                    .catch(function () {
+                    resolve(PermissionState.Prompt);
+                });
+            }, 50);
+        });
+    }
     return new Promise(function (resolve) {
         if (typeof globalThis.navigator.permissions === 'undefined')
             return resolve(PermissionState.Unsupported);

package/dist/plugin/notification/src/plugin/appearance/types/appearance.d.ts

@@ -2,8 +2,8 @@ import { Appearances } from "../constants";
 export declare interface AppearanceInstance {
     get value(): Appearances;
     onChange(listener: (appearance: Appearances) => void, options?: AddEventListenerOptions): () => void;
-    Constants: {
-        Appearances: typeof Appearances;
+    readonly Constants: {
+        readonly Appearances: typeof Appearances;
     };
-    Errors: {};
+    readonly Errors: {};
 }

package/dist/plugin/notification/src/plugin/badge/types/badge.d.ts

@@ -3,8 +3,8 @@ export declare interface BadgeInstance {
     get supported(): boolean;
     set(contents: number): Promise<void>;
     clear(): Promise<void>;
-    Constants: {};
-    Errors: {
-        NotSupportedError: typeof NotSupportedError;
+    readonly Constants: {};
+    readonly Errors: {
+        readonly NotSupportedError: typeof NotSupportedError;
     };
 }

package/dist/plugin/notification/src/plugin/battery/types/battery.d.ts

@@ -19,8 +19,8 @@ export declare interface BatteryInstance {
     get supported(): boolean;
     get value(): Promise<BatteryManager>;
     onChange(listener: (battery: BatteryManager) => void, options?: AddEventListenerOptions): () => void;
-    Constants: {};
-    Errors: {
-        NotSupportedError: typeof NotSupportedError;
+    readonly Constants: {};
+    readonly Errors: {
+        readonly NotSupportedError: typeof NotSupportedError;
     };
 }

package/dist/plugin/notification/src/plugin/clipboard/types/clipboard.d.ts

@@ -1,6 +1,6 @@
 export declare interface ClipboardInstance {
     copy(item: any): Promise<boolean>;
     paste(): Promise<string>;
-    Constants: {};
-    Errors: {};
+    readonly Constants: {};
+    readonly Errors: {};
 }

package/dist/plugin/notification/src/plugin/dimension/constants/index.d.ts

@@ -1,7 +1,12 @@
 export declare enum Orientation {
-    Portrait = "portrait",
-    Landscape = "landscape",
-    Unknown = "unknown"
+    PortraitPrimary = "portrait-primary",
+    PortraitSecondary = "portrait-secondary",
+    LandscapePrimary = "landscape-primary",
+    LandscapeSecondary = "landscape-secondary"
+}
+export declare namespace Orientation {
+    function isLandscape(orientation: Orientation): boolean;
+    function isPortrait(orientation: Orientation): boolean;
 }
 export declare const ENV_PRESETS: {
     readonly 'safe-area-inset': {

package/dist/plugin/notification/src/plugin/dimension/types/dimensions.d.ts

@@ -1,15 +1,17 @@
 import { ENV_PRESETS, Orientation } from "../constants";
+import { NotSupportedError } from "../../../errors/not-supported-error";
+import { PermissionNotGrantedError } from "../../../errors/permission-not-granted-error";
 export type EnvironmentPresetKey = keyof typeof ENV_PRESETS;
 export type EnvironmentPresetAttribute<K extends EnvironmentPresetKey> = keyof typeof ENV_PRESETS[K];
 export type EnvironmentPresetValues<K extends EnvironmentPresetKey> = {
     [P in EnvironmentPresetAttribute<K>]: number;
 };
 export declare interface Environment {
-    safeAreaInset: EnvironmentObserver<'safe-area-inset'>;
-    safeAreaMaxInset: EnvironmentObserver<'safe-area-max-inset'>;
-    keyboardInset: EnvironmentObserver<'keyboard-inset'>;
-    titlebarArea: EnvironmentObserver<'titlebar-area'>;
-    viewportSegment: EnvironmentObserver<'viewport-segment'>;
+    readonly safeAreaInset: EnvironmentObserver<'safe-area-inset'>;
+    readonly safeAreaMaxInset: EnvironmentObserver<'safe-area-max-inset'>;
+    readonly keyboardInset: EnvironmentObserver<'keyboard-inset'>;
+    readonly titlebarArea: EnvironmentObserver<'titlebar-area'>;
+    readonly viewportSegment: EnvironmentObserver<'viewport-segment'>;
 }
 export declare interface SegmentsObserver {
     get value(): EnvironmentPresetValues<'viewport-segment'>[];
@@ -22,19 +24,39 @@ export declare type EnvironmentObserver<K extends EnvironmentPresetKey> = K exte
     useCssVariable(prefix: string): () => void;
 };
 export declare interface Dimensions {
-    outerWidth: number;
-    outerHeight: number;
-    innerWidth: number;
-    innerHeight: number;
-    scale: number;
-    orientation: Orientation;
+    readonly outerWidth: number;
+    readonly outerHeight: number;
+    readonly innerWidth: number;
+    readonly innerHeight: number;
+    readonly scale: number;
+}
+export declare interface DeviceOrientationValue {
+    readonly alpha: number | null;
+    readonly beta: number | null;
+    readonly gamma: number | null;
+    readonly absolute: boolean;
+}
+export declare interface DeviceOrientationInstance {
+    get supported(): boolean;
+    readonly value: Promise<DeviceOrientationValue>;
+    onChange(listener: (value: DeviceOrientationValue) => void, options?: AddEventListenerOptions): () => void;
+}
+export declare interface ScreenOrientationInstance {
+    get supported(): boolean;
+    readonly value: Orientation;
+    onChange(listener: (value: Orientation) => void, options?: AddEventListenerOptions): () => void;
 }
 export declare interface DimensionInstance {
     get value(): Dimensions;
-    environment: Environment;
+    readonly environment: Environment;
+    readonly screenOrientation: ScreenOrientationInstance;
+    readonly deviceOrientation: DeviceOrientationInstance;
     onChange(listener: (dimension: Dimensions) => void, options?: AddEventListenerOptions): () => void;
-    Constants: {
-        Orientation: typeof Orientation;
+    readonly Constants: {
+        readonly Orientation: typeof Orientation;
+    };
+    readonly Errors: {
+        readonly NotSupportedError: typeof NotSupportedError;
+        readonly PermissionNotGrantedError: typeof PermissionNotGrantedError;
     };
-    Errors: {};
 }

package/dist/plugin/notification/src/plugin/fullscreen/types/fullscreen.d.ts

@@ -11,14 +11,14 @@ export declare interface FullscreenInstance {
     onChange(target: Element, listener: (payload: FullscreenEventPayload) => void, options?: AddEventListenerOptions): () => void;
     onError(listener: (payload: FullscreenEventPayload) => void, options?: AddEventListenerOptions): () => void;
     onChange(target: Element, listener: (payload: FullscreenEventPayload) => void, options?: AddEventListenerOptions): () => void;
-    Constants: {};
-    Errors: {
-        NotSupportedError: typeof NotSupportedError;
-        InvalidStateError: typeof InvalidStateError;
+    readonly Constants: {};
+    readonly Errors: {
+        readonly NotSupportedError: typeof NotSupportedError;
+        readonly InvalidStateError: typeof InvalidStateError;
     };
 }
 export declare interface FullscreenEventPayload {
-    nativeEvent: Event;
-    element: Element;
-    isActive: boolean;
+    readonly nativeEvent: Event;
+    readonly element: Element;
+    readonly isActive: boolean;
 }

package/dist/plugin/notification/src/plugin/geolocation/types/geolocation.d.ts

@@ -4,9 +4,9 @@ export declare interface GeolocationInstance {
     get supported(): boolean;
     get value(): Promise<GeolocationCoordinates>;
     onChange(listener: (coordinates: GeolocationCoordinates) => void, options?: AddEventListenerOptions): () => void;
-    Constants: {};
-    Errors: {
-        NotSupportedError: typeof NotSupportedError;
-        PermissionNotGrantedError: typeof PermissionNotGrantedError;
+    readonly Constants: {};
+    readonly Errors: {
+        readonly NotSupportedError: typeof NotSupportedError;
+        readonly PermissionNotGrantedError: typeof PermissionNotGrantedError;
     };
 }

package/dist/plugin/notification/src/plugin/notification/types/notification.d.ts

@@ -19,9 +19,9 @@ export interface NotificationOptions {
 export declare interface NotificationInstance {
     send(options: NotificationOptions): Promise<Notification>;
     get supported(): boolean;
-    Constants: {};
-    Errors: {
-        NotSupportedError: typeof NotSupportedError;
-        PermissionNotGrantedError: typeof PermissionNotGrantedError;
+    readonly Constants: {};
+    readonly Errors: {
+        readonly NotSupportedError: typeof NotSupportedError;
+        readonly PermissionNotGrantedError: typeof PermissionNotGrantedError;
     };
 }

package/dist/plugin/notification/src/plugin/open/types/open.d.ts

@@ -82,8 +82,8 @@ export interface DirectoryOptions {
     startIn?: ExplorerStartIn;
 }
 export interface FileWithPath {
-    file: File;
-    relativePath: string;
+    readonly file: File;
+    readonly relativePath: string;
 }
 export interface CameraOptions {
     type?: CameraType;
@@ -175,7 +175,7 @@ export declare interface OpenInstance {
     contact(options?: ContactOptions): Promise<Contact[]>;
     share(options: ShareData): Promise<void>;
     calendar(options: CalendarOptions): void;
-    supported: {
+    readonly supported: {
         get intent(): boolean;
         get universal(): boolean;
         get setting(): boolean;
@@ -185,15 +185,15 @@ export declare interface OpenInstance {
         get share(): boolean;
         get calendar(): boolean;
     };
-    Constants: {
-        AppOpenState: typeof AppOpenState;
-        SettingType: typeof SettingType;
-        CameraType: typeof CameraType;
-        CaptureType: typeof CaptureType;
+    readonly Constants: {
+        readonly AppOpenState: typeof AppOpenState;
+        readonly SettingType: typeof SettingType;
+        readonly CameraType: typeof CameraType;
+        readonly CaptureType: typeof CaptureType;
     };
-    Errors: {
-        URLOpenError: typeof URLOpenError;
-        NotSupportedError: typeof NotSupportedError;
-        UserCancelledError: typeof UserCancelledError;
+    readonly Errors: {
+        readonly URLOpenError: typeof URLOpenError;
+        readonly NotSupportedError: typeof NotSupportedError;
+        readonly UserCancelledError: typeof UserCancelledError;
     };
 }

package/dist/plugin/notification/src/plugin/permission/constants/index.d.ts

@@ -12,7 +12,9 @@ export declare enum PermissionType {
     Camera = "camera",
     ClipboardRead = "clipboard-read",
     Microphone = "microphone",
-    MIDI = "midi"
+    MIDI = "midi",
+    DeviceOrientation = "device-orientation",
+    DeviceMotion = "device-motion"
 }
 export declare enum PermissionState {
     Grant = "grant",

package/dist/plugin/notification/src/plugin/permission/types/permission.d.ts

@@ -1,11 +1,14 @@
 import { PermissionState, PermissionType } from "../constants";
+import { NotSupportedError } from "../../../errors/not-supported-error";
 export declare interface PermissionInstance {
     get supported(): boolean;
     request(type: PermissionType): Promise<PermissionState>;
     check(type: PermissionType): Promise<PermissionState>;
-    Constants: {
-        PermissionType: typeof PermissionType;
-        PermissionState: typeof PermissionState;
+    readonly Constants: {
+        readonly PermissionType: typeof PermissionType;
+        readonly PermissionState: typeof PermissionState;
+    };
+    readonly Errors: {
+        readonly NotSupportedError: typeof NotSupportedError;
     };
-    Errors: {};
 }

package/dist/plugin/notification/src/plugin/pip/types/pip.d.ts

@@ -11,14 +11,14 @@ export declare interface PipInstance {
     onChange(target: HTMLVideoElement, listener: (payload: PipEventPayload) => void, options?: AddEventListenerOptions): () => void;
     onError(listener: (payload: PipEventPayload) => void, options?: AddEventListenerOptions): () => void;
     onError(target: HTMLVideoElement, listener: (payload: PipEventPayload) => void, options?: AddEventListenerOptions): () => void;
-    Constants: {};
-    Errors: {
-        NotSupportedError: typeof NotSupportedError;
-        InvalidStateError: typeof InvalidStateError;
+    readonly Constants: {};
+    readonly Errors: {
+        readonly NotSupportedError: typeof NotSupportedError;
+        readonly InvalidStateError: typeof InvalidStateError;
     };
 }
 export declare interface PipEventPayload {
-    nativeEvent: Event;
-    element: HTMLVideoElement;
-    isActive: boolean;
+    readonly nativeEvent: Event;
+    readonly element: HTMLVideoElement;
+    readonly isActive: boolean;
 }