@angular-helpers/browser-web-apis 21.1.0 → 21.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@angular-helpers/browser-web-apis",
-  "version": "21.1.0",
+  "version": "21.2.0",
   "description": "Sistema de servicios Angular para acceso formalizado a Browser Web APIs (cámara, permisos, geolocalización, etc.)",
   "keywords": [
     "angular",

package/types/angular-helpers-browser-web-apis.d.ts

@@ -1,6 +1,6 @@
 import { Observable } from 'rxjs';
 import * as i0 from '@angular/core';
-import { DestroyRef, EnvironmentProviders } from '@angular/core';
+import { DestroyRef, Signal, ElementRef, EnvironmentProviders } from '@angular/core';
 import { CanActivateFn } from '@angular/router';
 
 type PermissionNameExt = PermissionName | 'clipboard-read' | 'clipboard-write';
@@ -126,7 +126,7 @@ declare class ClipboardService extends BrowserApiBaseService {
     static ɵprov: i0.ɵɵInjectableDeclaration<ClipboardService>;
 }
 
-type BrowserCapabilityId = 'permissions' | 'geolocation' | 'clipboard' | 'notification' | 'mediaDevices' | 'camera' | 'webWorker' | 'regexSecurity' | 'webStorage' | 'webShare' | 'battery' | 'webSocket';
+type BrowserCapabilityId = 'permissions' | 'geolocation' | 'clipboard' | 'notification' | 'mediaDevices' | 'camera' | 'webWorker' | 'regexSecurity' | 'webStorage' | 'webShare' | 'battery' | 'webSocket' | 'intersectionObserver' | 'resizeObserver' | 'pageVisibility' | 'broadcastChannel' | 'networkInformation' | 'screenWakeLock' | 'screenOrientation' | 'fullscreen' | 'fileSystemAccess' | 'mediaRecorder' | 'serverSentEvents' | 'vibration' | 'speechSynthesis';
 declare class BrowserCapabilityService {
     getCapabilities(): readonly [{
         readonly id: "permissions";
@@ -176,12 +176,64 @@ declare class BrowserCapabilityService {
         readonly id: "webSocket";
         readonly label: "WebSocket API";
         readonly requiresSecureContext: false;
+    }, {
+        readonly id: "intersectionObserver";
+        readonly label: "Intersection Observer";
+        readonly requiresSecureContext: false;
+    }, {
+        readonly id: "resizeObserver";
+        readonly label: "Resize Observer";
+        readonly requiresSecureContext: false;
+    }, {
+        readonly id: "pageVisibility";
+        readonly label: "Page Visibility API";
+        readonly requiresSecureContext: false;
+    }, {
+        readonly id: "broadcastChannel";
+        readonly label: "Broadcast Channel API";
+        readonly requiresSecureContext: false;
+    }, {
+        readonly id: "networkInformation";
+        readonly label: "Network Information API";
+        readonly requiresSecureContext: false;
+    }, {
+        readonly id: "screenWakeLock";
+        readonly label: "Screen Wake Lock API";
+        readonly requiresSecureContext: true;
+    }, {
+        readonly id: "screenOrientation";
+        readonly label: "Screen Orientation API";
+        readonly requiresSecureContext: false;
+    }, {
+        readonly id: "fullscreen";
+        readonly label: "Fullscreen API";
+        readonly requiresSecureContext: false;
+    }, {
+        readonly id: "fileSystemAccess";
+        readonly label: "File System Access API";
+        readonly requiresSecureContext: true;
+    }, {
+        readonly id: "mediaRecorder";
+        readonly label: "MediaRecorder API";
+        readonly requiresSecureContext: true;
+    }, {
+        readonly id: "serverSentEvents";
+        readonly label: "Server-Sent Events";
+        readonly requiresSecureContext: false;
+    }, {
+        readonly id: "vibration";
+        readonly label: "Vibration API";
+        readonly requiresSecureContext: false;
+    }, {
+        readonly id: "speechSynthesis";
+        readonly label: "Speech Synthesis API";
+        readonly requiresSecureContext: false;
     }];
     isSecureContext(): boolean;
     isSupported(capability: BrowserCapabilityId): boolean;
     getAllStatuses(): {
-        id: "camera" | "geolocation" | "permissions" | "mediaDevices" | "clipboard" | "notification" | "webWorker" | "regexSecurity" | "webStorage" | "webShare" | "battery" | "webSocket";
-        label: "Permissions API" | "Geolocation API" | "Clipboard API" | "Notification API" | "MediaDevices API" | "Camera API" | "Web Worker API" | "Regex Security" | "Web Storage" | "Web Share" | "Battery API" | "WebSocket API";
+        id: "camera" | "geolocation" | "permissions" | "mediaDevices" | "clipboard" | "notification" | "webWorker" | "regexSecurity" | "webStorage" | "webShare" | "battery" | "webSocket" | "intersectionObserver" | "resizeObserver" | "pageVisibility" | "broadcastChannel" | "networkInformation" | "screenWakeLock" | "screenOrientation" | "fullscreen" | "fileSystemAccess" | "mediaRecorder" | "serverSentEvents" | "vibration" | "speechSynthesis";
+        label: "Permissions API" | "Geolocation API" | "Clipboard API" | "Notification API" | "MediaDevices API" | "Camera API" | "Web Worker API" | "Regex Security" | "Web Storage" | "Web Share" | "Battery API" | "WebSocket API" | "Intersection Observer" | "Resize Observer" | "Page Visibility API" | "Broadcast Channel API" | "Network Information API" | "Screen Wake Lock API" | "Screen Orientation API" | "Fullscreen API" | "File System Access API" | "MediaRecorder API" | "Server-Sent Events" | "Vibration API" | "Speech Synthesis API";
         supported: boolean;
         secureContext: boolean;
         requiresSecureContext: boolean;
@@ -387,6 +439,278 @@ declare class WebWorkerService extends BrowserApiBaseService {
     static ɵprov: i0.ɵɵInjectableDeclaration<WebWorkerService>;
 }
 
+interface IntersectionObserverOptions {
+    root?: Element | Document | null;
+    rootMargin?: string;
+    threshold?: number | number[];
+}
+declare class IntersectionObserverService {
+    private readonly platformId;
+    isSupported(): boolean;
+    observe(element: Element, options?: IntersectionObserverOptions): Observable<IntersectionObserverEntry[]>;
+    observeVisibility(element: Element, options?: IntersectionObserverOptions): Observable<boolean>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IntersectionObserverService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<IntersectionObserverService>;
+}
+
+interface ResizeObserverOptions {
+    box?: ResizeObserverBoxOptions;
+}
+interface ElementSize {
+    width: number;
+    height: number;
+    inlineSize: number;
+    blockSize: number;
+}
+declare class ResizeObserverService {
+    private readonly platformId;
+    isSupported(): boolean;
+    observe(element: Element, options?: ResizeObserverOptions): Observable<ResizeObserverEntry[]>;
+    observeSize(element: Element, options?: ResizeObserverOptions): Observable<ElementSize>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ResizeObserverService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ResizeObserverService>;
+}
+
+type VisibilityState = 'visible' | 'hidden' | 'prerender';
+declare class PageVisibilityService {
+    private readonly platformId;
+    isSupported(): boolean;
+    get isHidden(): boolean;
+    get visibilityState(): VisibilityState;
+    watch(): Observable<VisibilityState>;
+    watchVisibility(): Observable<boolean>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PageVisibilityService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<PageVisibilityService>;
+}
+
+declare class BroadcastChannelService {
+    private readonly destroyRef;
+    private readonly platformId;
+    private channels;
+    isSupported(): boolean;
+    private ensureSupport;
+    open<T = unknown>(name: string): Observable<T>;
+    post<T = unknown>(name: string, data: T): void;
+    close(name: string): void;
+    closeAll(): void;
+    getOpenChannels(): string[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<BroadcastChannelService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<BroadcastChannelService>;
+}
+
+type ConnectionType = 'bluetooth' | 'cellular' | 'ethernet' | 'none' | 'wifi' | 'wimax' | 'other' | 'unknown';
+type EffectiveConnectionType = 'slow-2g' | '2g' | '3g' | '4g';
+interface NetworkInformation {
+    type?: ConnectionType;
+    effectiveType?: EffectiveConnectionType;
+    downlink?: number;
+    downlinkMax?: number;
+    rtt?: number;
+    saveData?: boolean;
+    online: boolean;
+}
+declare class NetworkInformationService {
+    private readonly platformId;
+    isSupported(): boolean;
+    getSnapshot(): NetworkInformation;
+    watch(): Observable<NetworkInformation>;
+    get isOnline(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NetworkInformationService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NetworkInformationService>;
+}
+
+type WakeLockType = 'screen';
+interface WakeLockStatus {
+    active: boolean;
+    type?: WakeLockType;
+    released?: boolean;
+}
+declare class ScreenWakeLockService extends BrowserApiBaseService {
+    private sentinel;
+    protected getApiName(): string;
+    isSupported(): boolean;
+    get isActive(): boolean;
+    request(type?: WakeLockType): Promise<WakeLockStatus>;
+    release(): Promise<void>;
+    watchStatus(): Observable<WakeLockStatus>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ScreenWakeLockService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ScreenWakeLockService>;
+}
+
+type OrientationType = 'portrait-primary' | 'portrait-secondary' | 'landscape-primary' | 'landscape-secondary';
+type OrientationLockType = 'any' | 'natural' | 'landscape' | 'portrait' | 'portrait-primary' | 'portrait-secondary' | 'landscape-primary' | 'landscape-secondary';
+interface OrientationInfo {
+    type: OrientationType;
+    angle: number;
+}
+declare class ScreenOrientationService {
+    private readonly platformId;
+    isSupported(): boolean;
+    getSnapshot(): OrientationInfo;
+    get isPortrait(): boolean;
+    get isLandscape(): boolean;
+    watch(): Observable<OrientationInfo>;
+    lock(orientation: OrientationLockType): Promise<void>;
+    unlock(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ScreenOrientationService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ScreenOrientationService>;
+}
+
+declare class FullscreenService {
+    private readonly destroyRef;
+    private readonly platformId;
+    isSupported(): boolean;
+    get isFullscreen(): boolean;
+    get fullscreenElement(): Element | null;
+    request(element?: Element): Promise<void>;
+    exit(): Promise<void>;
+    toggle(element?: Element): Promise<void>;
+    watch(): Observable<boolean>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FullscreenService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<FullscreenService>;
+}
+
+interface FileOpenOptions {
+    multiple?: boolean;
+    excludeAcceptAllOption?: boolean;
+    types?: Array<{
+        description?: string;
+        accept: Record<string, string[]>;
+    }>;
+}
+interface FileSaveOptions {
+    suggestedName?: string;
+    excludeAcceptAllOption?: boolean;
+    types?: Array<{
+        description?: string;
+        accept: Record<string, string[]>;
+    }>;
+}
+declare class FileSystemAccessService extends BrowserApiBaseService {
+    protected getApiName(): string;
+    isSupported(): boolean;
+    private get win();
+    private ensureSupport;
+    openFile(options?: FileOpenOptions): Promise<File[]>;
+    saveFile(content: string | Blob, options?: FileSaveOptions): Promise<void>;
+    openDirectory(options?: {
+        id?: string;
+        mode?: 'read' | 'readwrite';
+        startIn?: string;
+    }): Promise<FileSystemDirectoryHandle | null>;
+    readFileAsText(file: File): Promise<string>;
+    readFileAsArrayBuffer(file: File): Promise<ArrayBuffer>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FileSystemAccessService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<FileSystemAccessService>;
+}
+
+type RecordingState = 'inactive' | 'recording' | 'paused';
+interface RecordingOptions {
+    mimeType?: string;
+    audioBitsPerSecond?: number;
+    videoBitsPerSecond?: number;
+    bitsPerSecond?: number;
+    timeslice?: number;
+}
+interface RecordingResult {
+    blob: Blob;
+    url: string;
+    mimeType: string;
+    duration: number;
+}
+declare class MediaRecorderService extends BrowserApiBaseService {
+    private recorder;
+    private chunks;
+    private startTime;
+    private readonly dataSubject;
+    private readonly stateSubject;
+    protected getApiName(): string;
+    isSupported(): boolean;
+    get state(): RecordingState;
+    static isTypeSupported(mimeType: string): boolean;
+    watchState(): Observable<RecordingState>;
+    watchData(): Observable<Blob>;
+    start(stream: MediaStream, options?: RecordingOptions): Promise<void>;
+    pause(): void;
+    resume(): void;
+    stop(): RecordingResult | null;
+    getResult(): RecordingResult | null;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MediaRecorderService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<MediaRecorderService>;
+}
+
+type SSEConnectionState = 'connecting' | 'open' | 'closed';
+interface SSEMessage<T = unknown> {
+    data: T;
+    type: string;
+    lastEventId: string;
+    origin: string;
+}
+interface SSEConfig {
+    withCredentials?: boolean;
+    eventTypes?: string[];
+}
+declare class ServerSentEventsService {
+    private readonly destroyRef;
+    private readonly platformId;
+    private sources;
+    isSupported(): boolean;
+    private ensureSupport;
+    connect<T = unknown>(url: string, config?: SSEConfig): Observable<SSEMessage<T>>;
+    disconnect(url: string): void;
+    disconnectAll(): void;
+    getState(url: string): SSEConnectionState;
+    getActiveConnections(): string[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<ServerSentEventsService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ServerSentEventsService>;
+}
+
+type VibrationPattern = number | number[];
+interface VibrationPreset {
+    success: VibrationPattern;
+    error: VibrationPattern;
+    notification: VibrationPattern;
+    doubleTap: VibrationPattern;
+}
+declare class VibrationService {
+    private readonly platformId;
+    readonly presets: VibrationPreset;
+    isSupported(): boolean;
+    vibrate(pattern?: VibrationPattern): boolean;
+    success(): boolean;
+    error(): boolean;
+    notification(): boolean;
+    doubleTap(): boolean;
+    stop(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<VibrationService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<VibrationService>;
+}
+
+type SpeechState = 'idle' | 'speaking' | 'paused';
+interface SpeechOptions {
+    lang?: string;
+    voice?: SpeechSynthesisVoice;
+    volume?: number;
+    rate?: number;
+    pitch?: number;
+}
+declare class SpeechSynthesisService {
+    private readonly destroyRef;
+    private readonly platformId;
+    isSupported(): boolean;
+    private ensureSupport;
+    get state(): SpeechState;
+    get isPending(): boolean;
+    getVoices(): SpeechSynthesisVoice[];
+    watchVoices(): Observable<SpeechSynthesisVoice[]>;
+    speak(text: string, options?: SpeechOptions): Observable<SpeechState>;
+    pause(): void;
+    resume(): void;
+    cancel(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SpeechSynthesisService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SpeechSynthesisService>;
+}
+
 interface MediaDevice {
     deviceId: string;
     groupId: string;
@@ -476,6 +800,50 @@ interface GeolocationWatchOptions extends GeolocationOptions {
     maximumAge?: number;
 }
 
+interface PageVisibilityRef {
+    readonly state: Signal<VisibilityState>;
+    readonly isVisible: Signal<boolean>;
+    readonly isHidden: Signal<boolean>;
+}
+declare function injectPageVisibility(): PageVisibilityRef;
+
+interface ResizeRef {
+    readonly size: Signal<ElementSize | null>;
+    readonly width: Signal<number>;
+    readonly height: Signal<number>;
+    readonly inlineSize: Signal<number>;
+    readonly blockSize: Signal<number>;
+}
+declare function injectResizeObserver(elementOrRef: Element | ElementRef<Element>, options?: ResizeObserverOptions): ResizeRef;
+
+interface IntersectionRef {
+    readonly isIntersecting: Signal<boolean>;
+    readonly isVisible: Signal<boolean>;
+}
+declare function injectIntersectionObserver(elementOrRef: Element | ElementRef<Element>, options?: IntersectionObserverOptions): IntersectionRef;
+
+interface NetworkInformationRef {
+    readonly snapshot: Signal<NetworkInformation>;
+    readonly online: Signal<boolean>;
+    readonly effectiveType: Signal<EffectiveConnectionType | undefined>;
+    readonly downlink: Signal<number | undefined>;
+    readonly rtt: Signal<number | undefined>;
+    readonly type: Signal<ConnectionType | undefined>;
+    readonly saveData: Signal<boolean | undefined>;
+}
+declare function injectNetworkInformation(): NetworkInformationRef;
+
+interface ScreenOrientationRef {
+    readonly orientation: Signal<OrientationInfo>;
+    readonly type: Signal<OrientationType>;
+    readonly angle: Signal<number>;
+    readonly isPortrait: Signal<boolean>;
+    readonly isLandscape: Signal<boolean>;
+    lock(orientation: OrientationLockType): Promise<void>;
+    unlock(): void;
+}
+declare function injectScreenOrientation(): ScreenOrientationRef;
+
 declare class BrowserSupportUtil {
     static isSupported(feature: string): boolean;
     static getUnsupportedFeatures(): string[];
@@ -512,6 +880,19 @@ interface BrowserWebApisConfig {
     enableWebStorage?: boolean;
     enableWebSocket?: boolean;
     enableWebWorker?: boolean;
+    enableIntersectionObserver?: boolean;
+    enableResizeObserver?: boolean;
+    enablePageVisibility?: boolean;
+    enableBroadcastChannel?: boolean;
+    enableNetworkInformation?: boolean;
+    enableScreenWakeLock?: boolean;
+    enableScreenOrientation?: boolean;
+    enableFullscreen?: boolean;
+    enableFileSystemAccess?: boolean;
+    enableMediaRecorder?: boolean;
+    enableServerSentEvents?: boolean;
+    enableVibration?: boolean;
+    enableSpeechSynthesis?: boolean;
 }
 declare const defaultBrowserWebApisConfig: BrowserWebApisConfig;
 declare function provideBrowserWebApis(config?: BrowserWebApisConfig): EnvironmentProviders;
@@ -530,8 +911,21 @@ declare function provideMediaApis(): EnvironmentProviders;
 declare function provideLocationApis(): EnvironmentProviders;
 declare function provideStorageApis(): EnvironmentProviders;
 declare function provideCommunicationApis(): EnvironmentProviders;
+declare function provideIntersectionObserver(): EnvironmentProviders;
+declare function provideResizeObserver(): EnvironmentProviders;
+declare function providePageVisibility(): EnvironmentProviders;
+declare function provideBroadcastChannel(): EnvironmentProviders;
+declare function provideNetworkInformation(): EnvironmentProviders;
+declare function provideScreenWakeLock(): EnvironmentProviders;
+declare function provideScreenOrientation(): EnvironmentProviders;
+declare function provideFullscreen(): EnvironmentProviders;
+declare function provideFileSystemAccess(): EnvironmentProviders;
+declare function provideMediaRecorder(): EnvironmentProviders;
+declare function provideServerSentEvents(): EnvironmentProviders;
+declare function provideVibration(): EnvironmentProviders;
+declare function provideSpeechSynthesis(): EnvironmentProviders;
 
 declare const version = "0.1.0";
 
-export { BatteryService, BrowserApiBaseService, BrowserCapabilityService, BrowserSupportUtil, CameraService, ClipboardService, GeolocationService, MediaDevicesService, NotificationService, PermissionsService, WebShareService, WebSocketService, WebStorageService, WebWorkerService, permissionGuard as createPermissionGuard, defaultBrowserWebApisConfig, permissionGuard, provideBattery, provideBrowserWebApis, provideCamera, provideClipboard, provideCommunicationApis, provideGeolocation, provideLocationApis, provideMediaApis, provideMediaDevices, provideNotifications, providePermissions, provideStorageApis, provideWebShare, provideWebSocket, provideWebStorage, provideWebWorker, version };
-export type { BatteryInfo, BatteryManager, BrowserCapabilityId, BrowserError, BrowserPermissions, BrowserWebApisConfig, CameraCapabilities, CameraInfo, ErrorCallback, EventHandler, GeolocationCoordinates, GeolocationError, GeolocationOptions, GeolocationPosition$1 as GeolocationPosition, GeolocationWatchOptions, MediaDevice, MediaDeviceKind, MediaDevicesInfo, MediaStreamConstraints$1 as MediaStreamConstraints, MediaTrackConstraints$1 as MediaTrackConstraints, PermissionNameExt, PermissionRequest, StorageEvent, StorageOptions, StorageValue, WebSocketConfig, WebSocketMessage, WebSocketStatus, WorkerMessage, WorkerStatus, WorkerTask };
+export { BatteryService, BroadcastChannelService, BrowserApiBaseService, BrowserCapabilityService, BrowserSupportUtil, CameraService, ClipboardService, FileSystemAccessService, FullscreenService, GeolocationService, IntersectionObserverService, MediaDevicesService, MediaRecorderService, NetworkInformationService, NotificationService, PageVisibilityService, PermissionsService, ResizeObserverService, ScreenOrientationService, ScreenWakeLockService, ServerSentEventsService, SpeechSynthesisService, VibrationService, WebShareService, WebSocketService, WebStorageService, WebWorkerService, permissionGuard as createPermissionGuard, defaultBrowserWebApisConfig, injectIntersectionObserver, injectNetworkInformation, injectPageVisibility, injectResizeObserver, injectScreenOrientation, permissionGuard, provideBattery, provideBroadcastChannel, provideBrowserWebApis, provideCamera, provideClipboard, provideCommunicationApis, provideFileSystemAccess, provideFullscreen, provideGeolocation, provideIntersectionObserver, provideLocationApis, provideMediaApis, provideMediaDevices, provideMediaRecorder, provideNetworkInformation, provideNotifications, providePageVisibility, providePermissions, provideResizeObserver, provideScreenOrientation, provideScreenWakeLock, provideServerSentEvents, provideSpeechSynthesis, provideStorageApis, provideVibration, provideWebShare, provideWebSocket, provideWebStorage, provideWebWorker, version };
+export type { BatteryInfo, BatteryManager, BrowserCapabilityId, BrowserError, BrowserPermissions, BrowserWebApisConfig, CameraCapabilities, CameraInfo, ConnectionType, EffectiveConnectionType, ElementSize, ErrorCallback, EventHandler, FileOpenOptions, FileSaveOptions, GeolocationCoordinates, GeolocationError, GeolocationOptions, GeolocationPosition$1 as GeolocationPosition, GeolocationWatchOptions, IntersectionObserverOptions, IntersectionRef, MediaDevice, MediaDeviceKind, MediaDevicesInfo, MediaStreamConstraints$1 as MediaStreamConstraints, MediaTrackConstraints$1 as MediaTrackConstraints, NetworkInformation, NetworkInformationRef, OrientationInfo, OrientationLockType, OrientationType, PageVisibilityRef, PermissionNameExt, PermissionRequest, RecordingOptions, RecordingResult, RecordingState, ResizeObserverOptions, ResizeRef, SSEConfig, SSEConnectionState, SSEMessage, ScreenOrientationRef, SpeechOptions, SpeechState, StorageEvent, StorageOptions, StorageValue, VibrationPattern, VibrationPreset, VisibilityState, WakeLockStatus, WakeLockType, WebSocketConfig, WebSocketMessage, WebSocketStatus, WorkerMessage, WorkerStatus, WorkerTask };