native-fn 1.2.2 → 1.3.1

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

@@ -1,34 +1,62 @@
 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 EnvironmentPresetAttr<K extends EnvironmentPresetKey> = keyof typeof ENV_PRESETS[K];
+export type EnvironmentPresetAttribute<K extends EnvironmentPresetKey> = keyof typeof ENV_PRESETS[K];
 export type EnvironmentPresetValues<K extends EnvironmentPresetKey> = {
-    [P in EnvironmentPresetAttr<K>]: number;
+    [P in EnvironmentPresetAttribute<K>]: number;
 };
-export declare interface DimensionInstance {
-    get value(): Dimensions;
-    environment: Environment;
-    onChange(listener: (dimension: Dimensions) => void, options?: AddEventListenerOptions): () => void;
-    Constants: {
-        Orientation: typeof Orientation;
-    };
-    Errors: {};
+export declare interface Environment {
+    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 Dimensions {
-    outerWidth: number;
-    outerHeight: number;
-    innerWidth: number;
-    innerHeight: number;
-    scale: number;
-    orientation: Orientation;
+export declare interface SegmentsObserver {
+    get value(): EnvironmentPresetValues<'viewport-segment'>[];
+    onChange(listener: (value: EnvironmentPresetValues<'viewport-segment'>[]) => void, options?: AddEventListenerOptions): () => void;
+    useCssVariable(prefix: string): () => void;
 }
-export declare interface EnvironmentPreset<K extends EnvironmentPresetKey> {
+export declare type EnvironmentObserver<K extends EnvironmentPresetKey> = K extends 'viewport-segment' ? SegmentsObserver : {
     get value(): EnvironmentPresetValues<K>;
     onChange(listener: (value: EnvironmentPresetValues<K>) => void, options?: AddEventListenerOptions): () => void;
+    useCssVariable(prefix: string): () => void;
+};
+export declare interface Dimensions {
+    readonly outerWidth: number;
+    readonly outerHeight: number;
+    readonly innerWidth: number;
+    readonly innerHeight: number;
+    readonly scale: number;
 }
-export declare interface Environment {
-    safeAreaInset: EnvironmentPreset<'safe-area-inset'>;
-    safeAreaMaxInset: EnvironmentPreset<'safe-area-max-inset'>;
-    keyboardInset: EnvironmentPreset<'keyboard-inset'>;
-    titlebarArea: EnvironmentPreset<'titlebar-area'>;
-    viewportSegment: EnvironmentPreset<'viewport-segment'>;
+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;
+    readonly environment: Environment;
+    readonly screenOrientation: ScreenOrientationInstance;
+    readonly deviceOrientation: DeviceOrientationInstance;
+    onChange(listener: (dimension: Dimensions) => void, options?: AddEventListenerOptions): () => void;
+    readonly Constants: {
+        readonly Orientation: typeof Orientation;
+    };
+    readonly Errors: {
+        readonly NotSupportedError: typeof NotSupportedError;
+        readonly PermissionNotGrantedError: typeof PermissionNotGrantedError;
+    };
 }

package/dist/plugin/appearance/src/plugin/dimension/utils/create-env-observer.d.ts

@@ -1,10 +1,15 @@
-import { EnvironmentPresetKey, EnvironmentPresetValues } from "../types";
+import { EnvironmentObserver, EnvironmentPresetKey } from "../types";
 declare global {
     interface Navigator {
         readonly virtualKeyboard?: VirtualKeyboard;
+        readonly devicePosture?: DevicePosture;
     }
+    var viewport: BrowsingContextViewport | undefined;
+}
+interface DevicePosture extends EventTarget {
+    readonly type: 'continuous' | 'folded';
+    onchange: ((this: DevicePosture, ev: Event) => any) | null;
 }
-type ChangeCallback<K extends EnvironmentPresetKey> = (values: EnvironmentPresetValues<K>) => void;
 interface VirtualKeyboardEventMap {
     geometrychange: Event;
 }
@@ -16,9 +21,13 @@ interface VirtualKeyboard extends EventTarget {
     addEventListener<K extends keyof VirtualKeyboardEventMap>(type: K, listener: (this: VirtualKeyboard, ev: VirtualKeyboardEventMap[K]) => any, options?: AddEventListenerOptions): void;
     removeEventListener<K extends keyof VirtualKeyboardEventMap>(type: K, listener: (this: VirtualKeyboard, ev: VirtualKeyboardEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
 }
-export type EnvObserver<K extends EnvironmentPresetKey> = {
-    get(): EnvironmentPresetValues<K>;
-    onChange(callback: ChangeCallback<K>, options?: AddEventListenerOptions): () => void;
-};
-export default function createEnvObserver<K extends EnvironmentPresetKey>(preset: K): EnvObserver<K>;
+interface BrowsingContextViewportEventMap {
+    change: Event;
+}
+interface BrowsingContextViewport extends EventTarget {
+    readonly segments: ReadonlyArray<DOMRectReadOnly> | null;
+    addEventListener<K extends keyof BrowsingContextViewportEventMap>(type: K, listener: (this: BrowsingContextViewport, ev: BrowsingContextViewportEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener<K extends keyof BrowsingContextViewportEventMap>(type: K, listener: (this: BrowsingContextViewport, ev: BrowsingContextViewportEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+}
+export default function createEnvObserver<K extends EnvironmentPresetKey>(preset: K): EnvironmentObserver<K>;
 export {};

package/dist/plugin/appearance/src/plugin/dimension/utils/create-environment-observer.d.ts

@@ -0,0 +1,33 @@
+import { EnvironmentObserver, EnvironmentPresetKey } from "../types";
+declare global {
+    interface Navigator {
+        readonly virtualKeyboard?: VirtualKeyboard;
+        readonly devicePosture?: DevicePosture;
+    }
+    var viewport: BrowsingContextViewport | undefined;
+}
+interface DevicePosture extends EventTarget {
+    readonly type: 'continuous' | 'folded';
+    onchange: ((this: DevicePosture, ev: Event) => any) | null;
+}
+interface VirtualKeyboardEventMap {
+    geometrychange: Event;
+}
+interface VirtualKeyboard extends EventTarget {
+    readonly boundingRect: DOMRect;
+    overlaysContent: boolean;
+    show(): void;
+    hide(): void;
+    addEventListener<K extends keyof VirtualKeyboardEventMap>(type: K, listener: (this: VirtualKeyboard, ev: VirtualKeyboardEventMap[K]) => any, options?: AddEventListenerOptions): void;
+    removeEventListener<K extends keyof VirtualKeyboardEventMap>(type: K, listener: (this: VirtualKeyboard, ev: VirtualKeyboardEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+}
+interface BrowsingContextViewportEventMap {
+    change: Event;
+}
+interface BrowsingContextViewport extends EventTarget {
+    readonly segments: ReadonlyArray<DOMRectReadOnly> | null;
+    addEventListener<K extends keyof BrowsingContextViewportEventMap>(type: K, listener: (this: BrowsingContextViewport, ev: BrowsingContextViewportEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener<K extends keyof BrowsingContextViewportEventMap>(type: K, listener: (this: BrowsingContextViewport, ev: BrowsingContextViewportEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+}
+export default function createEnvironmentObserver<K extends EnvironmentPresetKey>(preset: K): EnvironmentObserver<K>;
+export {};

package/dist/plugin/appearance/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/appearance/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/appearance/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/appearance/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/appearance/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/appearance/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/appearance/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;
 }

package/dist/plugin/appearance/src/plugin/platform/constants/index.d.ts

@@ -34,7 +34,7 @@ export declare enum Browsers {
     IE = "IE",
     SamsungInternet = "SamsungInternet"
 }
-export declare const USER_AGENT: string;
+export declare let USER_AGENT: string;
 export declare const HIGH_ENTROPY_BRAND_NAME_MAP: Record<string, string>;
 export declare const RTL_LANGUAGES: string[];
 export declare const OS_RESOLVER_MAP: [RegExp, OS, VersionResolver?][];

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

@@ -14,24 +14,24 @@ export declare interface PlatformInstance {
     get isNode(): boolean;
     get isStandalone(): boolean;
     get isWebview(): boolean;
-    Constants: {
-        OS: typeof OS;
-        Engines: typeof Engines;
-        Browsers: typeof Browsers;
-        Devices: typeof Devices;
+    readonly Constants: {
+        readonly OS: typeof OS;
+        readonly Engines: typeof Engines;
+        readonly Browsers: typeof Browsers;
+        readonly Devices: typeof Devices;
     };
-    Errors: {};
+    readonly Errors: {};
 }
 export declare interface NameVersionPair<T> {
-    name: T;
-    version: string;
+    readonly name: T;
+    readonly version: string;
 }
 export declare interface Locale {
-    language: string | null;
-    languages: string[];
-    timezone: string | null;
-    offset: number;
-    isRTL: boolean;
+    readonly language: string | null;
+    readonly languages: readonly string[];
+    readonly timezone: string | null;
+    readonly offset: number;
+    readonly isRTL: boolean;
 }
 export interface GPUAdapterInfo {
     readonly vendor?: string;

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

@@ -1,6 +1,6 @@
 export declare interface ThemeInstance {
     get value(): string | undefined;
     set value(color: string | undefined);
-    Constants: {};
-    Errors: {};
+    readonly Constants: {};
+    readonly Errors: {};
 }

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

@@ -3,8 +3,8 @@ export declare interface VibrationInstance {
     get supported(): boolean;
     run(pattern: number | number[]): boolean;
     stop(): boolean;
-    Constants: {};
-    Errors: {
-        NotSupportedError: typeof NotSupportedError;
+    readonly Constants: {};
+    readonly Errors: {
+        readonly NotSupportedError: typeof NotSupportedError;
     };
 }

package/dist/plugin/appearance/src/types/subscription-manager.d.ts

@@ -1,4 +1,4 @@
-export declare interface SubscriptionManager<T, U> {
-    emit: (value: U) => void;
-    subscribe: (listener: (value: U) => void, options?: AddEventListenerOptions) => () => void;
+export declare interface SubscriptionManager<T> {
+    emit: (value: T) => void;
+    subscribe: (listener: (value: T) => void, options?: AddEventListenerOptions) => () => void;
 }

package/dist/plugin/appearance/src/utils/create-subscription-manager.d.ts

@@ -1,2 +1,2 @@
 import { SubscriptionManager } from "../types/subscription-manager";
-export default function createSubscriptionManager<T, U>(attach: () => void, detach: () => void): SubscriptionManager<T, U>;
+export default function createSubscriptionManager<T>(attach: () => void, detach: () => void): SubscriptionManager<T>;

package/dist/plugin/appearance/src/utils/insert-sort.d.ts

@@ -0,0 +1 @@
+export default function insertionSort(arr: number[]): void;

package/dist/plugin/badge/index.d.ts

@@ -4,9 +4,9 @@ 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/badge/src/plugin/appearance/constants/index.d.ts

@@ -3,6 +3,6 @@ export declare enum Appearances {
     Light = "light",
     Dark = "dark"
 }
-export declare let MEDIA_QUERY_LIST: MediaQueryList;
+export declare let PREFERS_COLOR_SCHEME_MEDIA_QUERY_LIST: MediaQueryList;
 export declare const CONTEXT: CanvasRenderingContext2D | null;
 export declare const SVG_PIXEL_DATA_URL: string;

package/dist/plugin/badge/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/badge/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/badge/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/badge/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/badge/src/plugin/dimension/constants/index.d.ts

@@ -1,8 +1,12 @@
-import { Dimensions } from "../types";
 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': {
@@ -40,5 +44,5 @@ export declare const ENV_PRESETS: {
         readonly left: "viewport-segment-left";
     };
 };
-export declare const FALLBACK_DIMENSION: Dimensions;
-export declare let MEDIA_QUERY_LIST: MediaQueryList;
+export declare let ORIENTATION_MEDIA_QUERY_LIST: MediaQueryList;
+export declare let DEVICE_POSTURE_MEDIA_QUERY_LIST: MediaQueryList;

package/dist/plugin/badge/src/plugin/dimension/cores/index.d.ts

@@ -1,3 +1,18 @@
 import { DimensionInstance } from "../types";
+declare global {
+    interface DOMRectReadOnly {
+        readonly x: number;
+        readonly y: number;
+        readonly width: number;
+        readonly height: number;
+        readonly top: number;
+        readonly right: number;
+        readonly bottom: number;
+        readonly left: number;
+    }
+    interface VisualViewport {
+        readonly segments?: DOMRectReadOnly[];
+    }
+}
 declare const Dimension: DimensionInstance;
 export default Dimension;

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

@@ -1,34 +1,62 @@
 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 EnvironmentPresetAttr<K extends EnvironmentPresetKey> = keyof typeof ENV_PRESETS[K];
+export type EnvironmentPresetAttribute<K extends EnvironmentPresetKey> = keyof typeof ENV_PRESETS[K];
 export type EnvironmentPresetValues<K extends EnvironmentPresetKey> = {
-    [P in EnvironmentPresetAttr<K>]: number;
+    [P in EnvironmentPresetAttribute<K>]: number;
 };
-export declare interface DimensionInstance {
-    get value(): Dimensions;
-    environment: Environment;
-    onChange(listener: (dimension: Dimensions) => void, options?: AddEventListenerOptions): () => void;
-    Constants: {
-        Orientation: typeof Orientation;
-    };
-    Errors: {};
+export declare interface Environment {
+    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 Dimensions {
-    outerWidth: number;
-    outerHeight: number;
-    innerWidth: number;
-    innerHeight: number;
-    scale: number;
-    orientation: Orientation;
+export declare interface SegmentsObserver {
+    get value(): EnvironmentPresetValues<'viewport-segment'>[];
+    onChange(listener: (value: EnvironmentPresetValues<'viewport-segment'>[]) => void, options?: AddEventListenerOptions): () => void;
+    useCssVariable(prefix: string): () => void;
 }
-export declare interface EnvironmentPreset<K extends EnvironmentPresetKey> {
+export declare type EnvironmentObserver<K extends EnvironmentPresetKey> = K extends 'viewport-segment' ? SegmentsObserver : {
     get value(): EnvironmentPresetValues<K>;
     onChange(listener: (value: EnvironmentPresetValues<K>) => void, options?: AddEventListenerOptions): () => void;
+    useCssVariable(prefix: string): () => void;
+};
+export declare interface Dimensions {
+    readonly outerWidth: number;
+    readonly outerHeight: number;
+    readonly innerWidth: number;
+    readonly innerHeight: number;
+    readonly scale: number;
 }
-export declare interface Environment {
-    safeAreaInset: EnvironmentPreset<'safe-area-inset'>;
-    safeAreaMaxInset: EnvironmentPreset<'safe-area-max-inset'>;
-    keyboardInset: EnvironmentPreset<'keyboard-inset'>;
-    titlebarArea: EnvironmentPreset<'titlebar-area'>;
-    viewportSegment: EnvironmentPreset<'viewport-segment'>;
+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;
+    readonly environment: Environment;
+    readonly screenOrientation: ScreenOrientationInstance;
+    readonly deviceOrientation: DeviceOrientationInstance;
+    onChange(listener: (dimension: Dimensions) => void, options?: AddEventListenerOptions): () => void;
+    readonly Constants: {
+        readonly Orientation: typeof Orientation;
+    };
+    readonly Errors: {
+        readonly NotSupportedError: typeof NotSupportedError;
+        readonly PermissionNotGrantedError: typeof PermissionNotGrantedError;
+    };
 }