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

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, Signal, ElementRef, EnvironmentProviders } from '@angular/core';
+import { DestroyRef, ElementRef, Signal, EnvironmentProviders } from '@angular/core';
 import { CanActivateFn } from '@angular/router';
 
 type PermissionNameExt = PermissionName | 'clipboard-read' | 'clipboard-write';
@@ -21,44 +21,74 @@ declare class PermissionsService implements BrowserPermissions {
 }
 
 /**
- * Base class for all Browser Web API services
+ * Base class for all Browser Web API services.
  * Provides common functionality for:
- * - Support checking
- * - Permission management
- * - Error handling
+ * - Platform detection (browser vs server)
+ * - Support assertion via Template Method
+ * - Error creation with cause chaining
+ * - Structured logging
  * - Lifecycle management with destroyRef
- * - Logging
+ *
+ * Services that also need permission querying should extend
+ * `PermissionAwareBrowserApiBaseService` instead.
  */
 declare abstract class BrowserApiBaseService {
-    protected permissionsService: PermissionsService;
     protected destroyRef: DestroyRef;
     protected platformId: Object;
     /**
-     * Abstract method that must be implemented by child services
-     * Returns the API name for support checking
+     * Abstract method that must be implemented by child services.
+     * Returns the API name used in log messages and error strings.
      */
     protected abstract getApiName(): string;
     /**
-     * Check if running in browser environment using Angular's platform detection
+     * Check if running in browser environment using Angular's platform detection.
      */
     protected isBrowserEnvironment(): boolean;
     /**
-     * Check if running in server environment using Angular's platform detection
+     * Check if running in server environment using Angular's platform detection.
      */
     protected isServerEnvironment(): boolean;
     /**
-     * Request a permission
+     * Template Method: throws a standard error when the API is not available.
+     * Uses getApiName() to produce consistent error messages.
      */
-    protected requestPermission(permission: PermissionNameExt): Promise<boolean>;
+    protected ensureSupported(): void;
     /**
-     * Create an error with proper cause chaining
+     * Create an error with proper cause chaining.
      */
     protected createError(message: string, cause?: unknown): Error;
+    /**
+     * Log an error with the service name as prefix.
+     */
+    protected logError(message: string, error?: unknown): void;
+    /**
+     * Log an informational message with the service name as prefix.
+     */
+    protected logInfo(message: string): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<BrowserApiBaseService, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<BrowserApiBaseService>;
 }
 
-declare class CameraService extends BrowserApiBaseService {
+/**
+ * Extension of `BrowserApiBaseService` for services that need to query
+ * browser permissions via the Permissions API.
+ *
+ * Only services that actively call `requestPermission()` should extend this
+ * class. All other services should extend `BrowserApiBaseService` directly
+ * to avoid carrying an unnecessary PermissionsService dependency.
+ */
+declare abstract class PermissionAwareBrowserApiBaseService extends BrowserApiBaseService {
+    protected permissionsService: PermissionsService;
+    /**
+     * Query the Permissions API for the given permission name.
+     * Returns `true` if the permission state is `'granted'`.
+     */
+    protected requestPermission(permission: PermissionNameExt): Promise<boolean>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PermissionAwareBrowserApiBaseService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<PermissionAwareBrowserApiBaseService>;
+}
+
+declare class CameraService extends PermissionAwareBrowserApiBaseService {
     private currentStream;
     protected getApiName(): string;
     private ensureCameraSupport;
@@ -116,17 +146,16 @@ declare class NotificationService extends BrowserApiBaseService {
     static ɵprov: i0.ɵɵInjectableDeclaration<NotificationService>;
 }
 
-declare class ClipboardService extends BrowserApiBaseService {
+declare class ClipboardService extends PermissionAwareBrowserApiBaseService {
     protected getApiName(): string;
     private ensureClipboardPermission;
     writeText(text: string): Promise<void>;
     readText(): Promise<string>;
-    writeTextSecure(text: string): Promise<void>;
     static ɵfac: i0.ɵɵFactoryDeclaration<ClipboardService, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<ClipboardService>;
 }
 
-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';
+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' | 'mutationObserver' | 'performanceObserver' | 'idleDetector' | 'eyeDropper' | 'barcodeDetector' | 'webAudio' | 'gamepad' | 'webBluetooth' | 'webUsb' | 'webNfc' | 'paymentRequest' | 'credentialManagement';
 declare class BrowserCapabilityService {
     getCapabilities(): readonly [{
         readonly id: "permissions";
@@ -228,12 +257,60 @@ declare class BrowserCapabilityService {
         readonly id: "speechSynthesis";
         readonly label: "Speech Synthesis API";
         readonly requiresSecureContext: false;
+    }, {
+        readonly id: "mutationObserver";
+        readonly label: "Mutation Observer";
+        readonly requiresSecureContext: false;
+    }, {
+        readonly id: "performanceObserver";
+        readonly label: "Performance Observer";
+        readonly requiresSecureContext: false;
+    }, {
+        readonly id: "idleDetector";
+        readonly label: "Idle Detection API";
+        readonly requiresSecureContext: true;
+    }, {
+        readonly id: "eyeDropper";
+        readonly label: "EyeDropper API";
+        readonly requiresSecureContext: true;
+    }, {
+        readonly id: "barcodeDetector";
+        readonly label: "Barcode Detection API";
+        readonly requiresSecureContext: true;
+    }, {
+        readonly id: "webAudio";
+        readonly label: "Web Audio API";
+        readonly requiresSecureContext: false;
+    }, {
+        readonly id: "gamepad";
+        readonly label: "Gamepad API";
+        readonly requiresSecureContext: true;
+    }, {
+        readonly id: "webBluetooth";
+        readonly label: "Web Bluetooth API";
+        readonly requiresSecureContext: true;
+    }, {
+        readonly id: "webUsb";
+        readonly label: "WebUSB API";
+        readonly requiresSecureContext: true;
+    }, {
+        readonly id: "webNfc";
+        readonly label: "Web NFC API";
+        readonly requiresSecureContext: true;
+    }, {
+        readonly id: "paymentRequest";
+        readonly label: "Payment Request API";
+        readonly requiresSecureContext: true;
+    }, {
+        readonly id: "credentialManagement";
+        readonly label: "Credential Management API";
+        readonly requiresSecureContext: true;
     }];
     isSecureContext(): boolean;
     isSupported(capability: BrowserCapabilityId): boolean;
     getAllStatuses(): {
-        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";
+        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" | "mutationObserver" | "performanceObserver" | "idleDetector" | "eyeDropper" | "barcodeDetector" | "webAudio" | "gamepad" | "webBluetooth" | "webUsb" | "webNfc" | "paymentRequest" | "credentialManagement";
+        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" | "Mutation Observer" | "Performance Observer" | "Idle Detection API" | "EyeDropper API" | "Barcode Detection API" | "Web Audio API" | "Gamepad API" | "Web Bluetooth API" | "WebUSB API" | "Web NFC API" | "Payment Request API" | "Credential Management API";
         supported: boolean;
         secureContext: boolean;
         requiresSecureContext: boolean;
@@ -276,7 +353,6 @@ declare class BatteryService extends BrowserApiBaseService {
     initialize(): Promise<BatteryInfo>;
     getBatteryInfo(): BatteryInfo;
     watchBatteryInfo(): Observable<BatteryInfo>;
-    private setupEventListeners;
     getNativeBatteryManager(): BatteryManager;
     isCharging(): boolean;
     getLevel(): number;
@@ -308,6 +384,11 @@ type BrowserError = Error & {
 type EventHandler<T = Event> = (event: T) => void;
 type StorageValue = string | number | boolean | object | null;
 type ErrorCallback = (error: BrowserError) => void;
+/**
+ * Accepted element input for inject functions.
+ * Supports static elements, ElementRef, or deferred signals (e.g. from viewChild).
+ */
+type ElementInput = Element | ElementRef<Element> | Signal<Element | ElementRef<Element> | undefined>;
 
 interface StorageOptions {
     prefix?: string;
@@ -444,8 +525,8 @@ interface IntersectionObserverOptions {
     rootMargin?: string;
     threshold?: number | number[];
 }
-declare class IntersectionObserverService {
-    private readonly platformId;
+declare class IntersectionObserverService extends BrowserApiBaseService {
+    protected getApiName(): string;
     isSupported(): boolean;
     observe(element: Element, options?: IntersectionObserverOptions): Observable<IntersectionObserverEntry[]>;
     observeVisibility(element: Element, options?: IntersectionObserverOptions): Observable<boolean>;
@@ -462,8 +543,8 @@ interface ElementSize {
     inlineSize: number;
     blockSize: number;
 }
-declare class ResizeObserverService {
-    private readonly platformId;
+declare class ResizeObserverService extends BrowserApiBaseService {
+    protected getApiName(): string;
     isSupported(): boolean;
     observe(element: Element, options?: ResizeObserverOptions): Observable<ResizeObserverEntry[]>;
     observeSize(element: Element, options?: ResizeObserverOptions): Observable<ElementSize>;
@@ -472,8 +553,8 @@ declare class ResizeObserverService {
 }
 
 type VisibilityState = 'visible' | 'hidden' | 'prerender';
-declare class PageVisibilityService {
-    private readonly platformId;
+declare class PageVisibilityService extends BrowserApiBaseService {
+    protected getApiName(): string;
     isSupported(): boolean;
     get isHidden(): boolean;
     get visibilityState(): VisibilityState;
@@ -483,12 +564,46 @@ declare class PageVisibilityService {
     static ɵprov: i0.ɵɵInjectableDeclaration<PageVisibilityService>;
 }
 
-declare class BroadcastChannelService {
-    private readonly destroyRef;
-    private readonly platformId;
-    private channels;
+/**
+ * Base class for services that manage a named registry of persistent
+ * connections (e.g. BroadcastChannel, EventSource, WebSocket pools).
+ *
+ * Implements the Template Method pattern: subclasses define how a single
+ * native connection is closed via `closeNativeConnection()`, while this
+ * class handles the Map lifecycle (remove, closeAll, getActiveKeys).
+ *
+ * Public-facing method names (`close`, `disconnect`, `getOpenChannels`, etc.)
+ * remain the responsibility of the concrete service to preserve the public API.
+ */
+declare abstract class ConnectionRegistryBaseService<T> extends BrowserApiBaseService {
+    protected readonly connections: Map<string, T>;
+    /**
+     * Template Method: close a single native connection.
+     * Implemented by each concrete service.
+     */
+    protected abstract closeNativeConnection(connection: T): void;
+    /**
+     * Remove and close the connection registered under `key`.
+     * Safe to call even if the key does not exist.
+     */
+    protected removeConnection(key: string): void;
+    /**
+     * Close all registered connections and clear the registry.
+     */
+    protected closeAllConnections(): void;
+    /**
+     * Return the keys of all currently open connections.
+     */
+    protected getConnectionKeys(): string[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<ConnectionRegistryBaseService<any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ConnectionRegistryBaseService<any>>;
+}
+
+declare class BroadcastChannelService extends ConnectionRegistryBaseService<BroadcastChannel> {
+    protected getApiName(): string;
+    protected closeNativeConnection(channel: BroadcastChannel): void;
     isSupported(): boolean;
-    private ensureSupport;
+    private ensureBroadcastChannelSupported;
     open<T = unknown>(name: string): Observable<T>;
     post<T = unknown>(name: string, data: T): void;
     close(name: string): void;
@@ -509,8 +624,8 @@ interface NetworkInformation {
     saveData?: boolean;
     online: boolean;
 }
-declare class NetworkInformationService {
-    private readonly platformId;
+declare class NetworkInformationService extends BrowserApiBaseService {
+    protected getApiName(): string;
     isSupported(): boolean;
     getSnapshot(): NetworkInformation;
     watch(): Observable<NetworkInformation>;
@@ -543,8 +658,8 @@ interface OrientationInfo {
     type: OrientationType;
     angle: number;
 }
-declare class ScreenOrientationService {
-    private readonly platformId;
+declare class ScreenOrientationService extends BrowserApiBaseService {
+    protected getApiName(): string;
     isSupported(): boolean;
     getSnapshot(): OrientationInfo;
     get isPortrait(): boolean;
@@ -556,9 +671,8 @@ declare class ScreenOrientationService {
     static ɵprov: i0.ɵɵInjectableDeclaration<ScreenOrientationService>;
 }
 
-declare class FullscreenService {
-    private readonly destroyRef;
-    private readonly platformId;
+declare class FullscreenService extends BrowserApiBaseService {
+    protected getApiName(): string;
     isSupported(): boolean;
     get isFullscreen(): boolean;
     get fullscreenElement(): Element | null;
@@ -650,12 +764,11 @@ interface SSEConfig {
     withCredentials?: boolean;
     eventTypes?: string[];
 }
-declare class ServerSentEventsService {
-    private readonly destroyRef;
-    private readonly platformId;
-    private sources;
+declare class ServerSentEventsService extends ConnectionRegistryBaseService<EventSource> {
+    protected getApiName(): string;
+    protected closeNativeConnection(source: EventSource): void;
     isSupported(): boolean;
-    private ensureSupport;
+    private ensureSSESupported;
     connect<T = unknown>(url: string, config?: SSEConfig): Observable<SSEMessage<T>>;
     disconnect(url: string): void;
     disconnectAll(): void;
@@ -672,8 +785,8 @@ interface VibrationPreset {
     notification: VibrationPattern;
     doubleTap: VibrationPattern;
 }
-declare class VibrationService {
-    private readonly platformId;
+declare class VibrationService extends BrowserApiBaseService {
+    protected getApiName(): string;
     readonly presets: VibrationPreset;
     isSupported(): boolean;
     vibrate(pattern?: VibrationPattern): boolean;
@@ -694,11 +807,10 @@ interface SpeechOptions {
     rate?: number;
     pitch?: number;
 }
-declare class SpeechSynthesisService {
-    private readonly destroyRef;
-    private readonly platformId;
+declare class SpeechSynthesisService extends BrowserApiBaseService {
+    protected getApiName(): string;
     isSupported(): boolean;
-    private ensureSupport;
+    private ensureSpeechSynthesisSupported;
     get state(): SpeechState;
     get isPending(): boolean;
     getVoices(): SpeechSynthesisVoice[];
@@ -711,6 +823,359 @@ declare class SpeechSynthesisService {
     static ɵprov: i0.ɵɵInjectableDeclaration<SpeechSynthesisService>;
 }
 
+interface MutationObserverOptions {
+    childList?: boolean;
+    attributes?: boolean;
+    characterData?: boolean;
+    subtree?: boolean;
+    attributeOldValue?: boolean;
+    characterDataOldValue?: boolean;
+    attributeFilter?: string[];
+}
+
+declare class MutationObserverService extends BrowserApiBaseService {
+    protected getApiName(): string;
+    isSupported(): boolean;
+    observe(target: Node, options?: MutationObserverOptions): Observable<MutationRecord[]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MutationObserverService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<MutationObserverService>;
+}
+
+type PerformanceEntryType = 'element' | 'event' | 'first-input' | 'largest-contentful-paint' | 'layout-shift' | 'longtask' | 'mark' | 'measure' | 'navigation' | 'paint' | 'resource' | 'visibility-state';
+interface PerformanceObserverConfig {
+    entryTypes?: PerformanceEntryType[];
+    type?: PerformanceEntryType;
+    buffered?: boolean;
+}
+
+declare class PerformanceObserverService extends BrowserApiBaseService {
+    protected getApiName(): string;
+    isSupported(): boolean;
+    observe(config: PerformanceObserverConfig): Observable<PerformanceEntryList>;
+    observeByType(type: PerformanceEntryType, buffered?: boolean): Observable<PerformanceEntryList>;
+    getSupportedEntryTypes(): PerformanceEntryType[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<PerformanceObserverService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<PerformanceObserverService>;
+}
+
+type UserIdleState = 'active' | 'idle';
+type ScreenIdleState = 'locked' | 'unlocked';
+interface IdleState {
+    user: UserIdleState;
+    screen: ScreenIdleState;
+}
+interface IdleDetectorOptions {
+    threshold?: number;
+}
+declare class IdleDetectorService extends BrowserApiBaseService {
+    protected getApiName(): string;
+    isSupported(): boolean;
+    requestPermission(): Promise<PermissionState>;
+    watch(options?: IdleDetectorOptions): Observable<IdleState>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IdleDetectorService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<IdleDetectorService>;
+}
+
+interface ColorSelectionResult {
+    sRGBHex: string;
+}
+declare class EyeDropperService extends BrowserApiBaseService {
+    protected getApiName(): string;
+    isSupported(): boolean;
+    open(signal?: AbortSignal): Promise<ColorSelectionResult>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EyeDropperService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<EyeDropperService>;
+}
+
+type BarcodeFormat = 'aztec' | 'code_128' | 'code_39' | 'code_93' | 'codabar' | 'data_matrix' | 'ean_13' | 'ean_8' | 'itf' | 'pdf417' | 'qr_code' | 'upc_a' | 'upc_e' | 'unknown';
+interface DetectedBarcode {
+    boundingBox: DOMRectReadOnly;
+    cornerPoints: ReadonlyArray<{
+        x: number;
+        y: number;
+    }>;
+    format: BarcodeFormat;
+    rawValue: string;
+}
+declare class BarcodeDetectorService extends BrowserApiBaseService {
+    protected getApiName(): string;
+    isSupported(): boolean;
+    getSupportedFormats(): Promise<BarcodeFormat[]>;
+    detect(image: ImageBitmapSource, formats?: BarcodeFormat[]): Promise<DetectedBarcode[]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BarcodeDetectorService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<BarcodeDetectorService>;
+}
+
+type AudioContextState = 'suspended' | 'running' | 'closed';
+interface AudioAnalyserData {
+    frequencyData: Uint8Array;
+    timeDomainData: Uint8Array;
+}
+declare class WebAudioService extends BrowserApiBaseService {
+    protected getApiName(): string;
+    private context;
+    isSupported(): boolean;
+    getContext(): AudioContext;
+    resume(): Promise<void>;
+    close(): Promise<void>;
+    getState(): AudioContextState;
+    createOscillator(type?: OscillatorType, frequency?: number): OscillatorNode;
+    createGain(value?: number): GainNode;
+    createAnalyser(fftSize?: number): AnalyserNode;
+    watchAnalyser(analyser: AnalyserNode, intervalMs?: number): Observable<AudioAnalyserData>;
+    decodeAudioData(arrayBuffer: ArrayBuffer): Promise<AudioBuffer>;
+    playBuffer(buffer: AudioBuffer, loop?: boolean): AudioBufferSourceNode;
+    static ɵfac: i0.ɵɵFactoryDeclaration<WebAudioService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<WebAudioService>;
+}
+
+interface GamepadState {
+    id: string;
+    index: number;
+    connected: boolean;
+    buttons: ReadonlyArray<{
+        pressed: boolean;
+        value: number;
+    }>;
+    axes: readonly number[];
+    timestamp: number;
+}
+
+declare class GamepadService extends BrowserApiBaseService {
+    protected getApiName(): string;
+    isSupported(): boolean;
+    getSnapshot(index: number): GamepadState | null;
+    getConnectedGamepads(): GamepadState[];
+    watchConnections(): Observable<{
+        gamepad: GamepadState;
+        type: 'connected' | 'disconnected';
+    }>;
+    poll(index: number, intervalMs?: number): Observable<GamepadState>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GamepadService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<GamepadService>;
+}
+
+interface BluetoothRequestDeviceOptions {
+    filters?: Array<{
+        services?: string[];
+        name?: string;
+        namePrefix?: string;
+    }>;
+    optionalServices?: string[];
+    acceptAllDevices?: boolean;
+}
+interface BluetoothRemoteGATTServer {
+    readonly connected: boolean;
+    readonly device: BluetoothDeviceRef;
+    connect(): Promise<BluetoothRemoteGATTServer>;
+    disconnect(): void;
+    getPrimaryService(service: string): Promise<BluetoothRemoteGATTService>;
+}
+interface BluetoothRemoteGATTService {
+    getCharacteristic(characteristic: string): Promise<BluetoothRemoteGATTCharacteristic>;
+}
+interface BluetoothRemoteGATTCharacteristic extends EventTarget {
+    readonly value: DataView | null;
+    readValue(): Promise<DataView>;
+    writeValue(value: BufferSource): Promise<void>;
+    startNotifications(): Promise<BluetoothRemoteGATTCharacteristic>;
+    stopNotifications(): Promise<BluetoothRemoteGATTCharacteristic>;
+}
+interface BluetoothDeviceRef extends EventTarget {
+    readonly id: string;
+    readonly name: string | undefined;
+    readonly gatt: BluetoothRemoteGATTServer | undefined;
+}
+interface UsbDeviceRef {
+    readonly vendorId: number;
+    readonly productId: number;
+    readonly productName: string | undefined;
+    readonly manufacturerName: string | undefined;
+    readonly serialNumber: string | undefined;
+    readonly opened: boolean;
+    open(): Promise<void>;
+    close(): Promise<void>;
+    selectConfiguration(configurationValue: number): Promise<void>;
+    claimInterface(interfaceNumber: number): Promise<void>;
+    releaseInterface(interfaceNumber: number): Promise<void>;
+    transferIn(endpointNumber: number, length: number): Promise<UsbTransferResult>;
+    transferOut(endpointNumber: number, data: BufferSource): Promise<UsbTransferResult>;
+}
+interface UsbTransferResult {
+    readonly data: DataView | undefined;
+    readonly status: 'ok' | 'stall' | 'babble';
+}
+interface UsbDeviceFilterDef {
+    vendorId?: number;
+    productId?: number;
+    classCode?: number;
+    subclassCode?: number;
+    protocolCode?: number;
+    serialNumber?: string;
+}
+interface NdefMessage {
+    records: NdefRecord[];
+}
+interface NdefRecord {
+    recordType: string;
+    mediaType?: string;
+    id?: string;
+    data?: DataView;
+    encoding?: string;
+    lang?: string;
+}
+interface NdefReadingEvent {
+    serialNumber: string;
+    message: NdefMessage;
+}
+interface NdefWriteOptions {
+    overwrite?: boolean;
+    signal?: AbortSignal;
+}
+
+interface BluetoothDeviceInfo {
+    id: string;
+    name: string | undefined;
+    connected: boolean;
+}
+declare class WebBluetoothService extends BrowserApiBaseService {
+    protected getApiName(): string;
+    isSupported(): boolean;
+    requestDevice(options?: BluetoothRequestDeviceOptions): Promise<BluetoothDeviceRef>;
+    connect(device: BluetoothDeviceRef): Promise<BluetoothRemoteGATTServer>;
+    disconnect(device: BluetoothDeviceRef): void;
+    watchDisconnection(device: BluetoothDeviceRef): Observable<void>;
+    readCharacteristic(server: BluetoothRemoteGATTServer, serviceUuid: string, characteristicUuid: string): Promise<DataView>;
+    writeCharacteristic(server: BluetoothRemoteGATTServer, serviceUuid: string, characteristicUuid: string, value: BufferSource): Promise<void>;
+    watchCharacteristic(server: BluetoothRemoteGATTServer, serviceUuid: string, characteristicUuid: string): Observable<DataView>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<WebBluetoothService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<WebBluetoothService>;
+}
+
+interface UsbDeviceInfo {
+    vendorId: number;
+    productId: number;
+    productName: string | undefined;
+    manufacturerName: string | undefined;
+    serialNumber: string | undefined;
+    opened: boolean;
+}
+declare class WebUsbService extends BrowserApiBaseService {
+    protected getApiName(): string;
+    isSupported(): boolean;
+    requestDevice(filters?: UsbDeviceFilterDef[]): Promise<UsbDeviceRef>;
+    getDevices(): Promise<UsbDeviceRef[]>;
+    open(device: UsbDeviceRef): Promise<void>;
+    close(device: UsbDeviceRef): Promise<void>;
+    selectConfiguration(device: UsbDeviceRef, configurationValue: number): Promise<void>;
+    claimInterface(device: UsbDeviceRef, interfaceNumber: number): Promise<void>;
+    releaseInterface(device: UsbDeviceRef, interfaceNumber: number): Promise<void>;
+    transferIn(device: UsbDeviceRef, endpointNumber: number, length: number): Promise<UsbTransferResult>;
+    transferOut(device: UsbDeviceRef, endpointNumber: number, data: BufferSource): Promise<UsbTransferResult>;
+    watchConnection(): Observable<{
+        device: UsbDeviceRef;
+        type: 'connect' | 'disconnect';
+    }>;
+    getDeviceInfo(device: UsbDeviceRef): UsbDeviceInfo;
+    static ɵfac: i0.ɵɵFactoryDeclaration<WebUsbService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<WebUsbService>;
+}
+
+declare class WebNfcService extends BrowserApiBaseService {
+    protected getApiName(): string;
+    isSupported(): boolean;
+    scan(): Observable<NdefReadingEvent>;
+    write(message: NdefMessage | string, options?: NdefWriteOptions): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<WebNfcService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<WebNfcService>;
+}
+
+interface PaymentMethodConfig {
+    supportedMethods: string;
+    data?: Record<string, unknown>;
+}
+interface PaymentDetailsInit {
+    total: {
+        label: string;
+        amount: {
+            currency: string;
+            value: string;
+        };
+    };
+    displayItems?: Array<{
+        label: string;
+        amount: {
+            currency: string;
+            value: string;
+        };
+    }>;
+}
+interface PaymentOptionsConfig {
+    requestPayerName?: boolean;
+    requestPayerEmail?: boolean;
+    requestPayerPhone?: boolean;
+    requestShipping?: boolean;
+}
+interface PaymentResult {
+    methodName: string;
+    details: Record<string, unknown>;
+    payerName: string | null;
+    payerEmail: string | null;
+    payerPhone: string | null;
+}
+declare class PaymentRequestService extends BrowserApiBaseService {
+    protected getApiName(): string;
+    isSupported(): boolean;
+    canMakePayment(methods: PaymentMethodConfig[], details: PaymentDetailsInit): Promise<boolean>;
+    show(methods: PaymentMethodConfig[], details: PaymentDetailsInit, options?: PaymentOptionsConfig): Promise<PaymentResult>;
+    abort(methods: PaymentMethodConfig[], details: PaymentDetailsInit): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PaymentRequestService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<PaymentRequestService>;
+}
+
+interface PasswordCredentialData {
+    id: string;
+    password: string;
+    name?: string;
+    iconURL?: string;
+}
+interface PublicKeyCredentialOptions {
+    challenge: BufferSource;
+    rp: {
+        name: string;
+        id?: string;
+    };
+    user: {
+        id: BufferSource;
+        name: string;
+        displayName: string;
+    };
+    pubKeyCredParams: Array<{
+        type: 'public-key';
+        alg: number;
+    }>;
+    timeout?: number;
+    attestation?: AttestationConveyancePreference;
+    authenticatorSelection?: AuthenticatorSelectionCriteria;
+}
+interface CredentialResult {
+    id: string;
+    type: string;
+}
+declare class CredentialManagementService extends BrowserApiBaseService {
+    protected getApiName(): string;
+    isSupported(): boolean;
+    isPublicKeySupported(): boolean;
+    get(options?: CredentialRequestOptions): Promise<Credential | null>;
+    store(credential: Credential): Promise<void>;
+    createPasswordCredential(data: PasswordCredentialData): Promise<Credential>;
+    createPublicKeyCredential(options: PublicKeyCredentialOptions): Promise<Credential | null>;
+    preventSilentAccess(): Promise<void>;
+    isConditionalMediationAvailable(): Promise<boolean>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CredentialManagementService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CredentialManagementService>;
+}
+
 interface MediaDevice {
     deviceId: string;
     groupId: string;
@@ -814,13 +1279,13 @@ interface ResizeRef {
     readonly inlineSize: Signal<number>;
     readonly blockSize: Signal<number>;
 }
-declare function injectResizeObserver(elementOrRef: Element | ElementRef<Element>, options?: ResizeObserverOptions): ResizeRef;
+declare function injectResizeObserver(elementOrRef: ElementInput, options?: ResizeObserverOptions): ResizeRef;
 
 interface IntersectionRef {
     readonly isIntersecting: Signal<boolean>;
     readonly isVisible: Signal<boolean>;
 }
-declare function injectIntersectionObserver(elementOrRef: Element | ElementRef<Element>, options?: IntersectionObserverOptions): IntersectionRef;
+declare function injectIntersectionObserver(elementOrRef: ElementInput, options?: IntersectionObserverOptions): IntersectionRef;
 
 interface NetworkInformationRef {
     readonly snapshot: Signal<NetworkInformation>;
@@ -844,6 +1309,39 @@ interface ScreenOrientationRef {
 }
 declare function injectScreenOrientation(): ScreenOrientationRef;
 
+interface MutationRef {
+    readonly mutations: Signal<MutationRecord[]>;
+    readonly mutationCount: Signal<number>;
+}
+declare function injectMutationObserver(elementOrRef: ElementInput, options?: MutationObserverOptions): MutationRef;
+
+interface PerformanceObserverRef {
+    readonly entries: Signal<PerformanceEntryList>;
+    readonly entryCount: Signal<number>;
+    readonly latestEntry: Signal<PerformanceEntry | undefined>;
+}
+declare function injectPerformanceObserver(config: PerformanceObserverConfig): PerformanceObserverRef;
+
+interface IdleDetectorRef {
+    readonly state: Signal<IdleState>;
+    readonly userState: Signal<UserIdleState>;
+    readonly screenState: Signal<ScreenIdleState>;
+    readonly isUserIdle: Signal<boolean>;
+    readonly isScreenLocked: Signal<boolean>;
+}
+declare function injectIdleDetector(options?: IdleDetectorOptions): IdleDetectorRef;
+
+interface GamepadRef {
+    readonly state: Signal<GamepadState | null>;
+    readonly connected: Signal<boolean>;
+    readonly buttons: Signal<ReadonlyArray<{
+        pressed: boolean;
+        value: number;
+    }>>;
+    readonly axes: Signal<readonly number[]>;
+}
+declare function injectGamepad(index: number, intervalMs?: number): GamepadRef;
+
 declare class BrowserSupportUtil {
     static isSupported(feature: string): boolean;
     static getUnsupportedFeatures(): string[];
@@ -893,6 +1391,18 @@ interface BrowserWebApisConfig {
     enableServerSentEvents?: boolean;
     enableVibration?: boolean;
     enableSpeechSynthesis?: boolean;
+    enableMutationObserver?: boolean;
+    enablePerformanceObserver?: boolean;
+    enableIdleDetector?: boolean;
+    enableEyeDropper?: boolean;
+    enableBarcodeDetector?: boolean;
+    enableWebAudio?: boolean;
+    enableGamepad?: boolean;
+    enableWebBluetooth?: boolean;
+    enableWebUsb?: boolean;
+    enableWebNfc?: boolean;
+    enablePaymentRequest?: boolean;
+    enableCredentialManagement?: boolean;
 }
 declare const defaultBrowserWebApisConfig: BrowserWebApisConfig;
 declare function provideBrowserWebApis(config?: BrowserWebApisConfig): EnvironmentProviders;
@@ -924,8 +1434,20 @@ declare function provideMediaRecorder(): EnvironmentProviders;
 declare function provideServerSentEvents(): EnvironmentProviders;
 declare function provideVibration(): EnvironmentProviders;
 declare function provideSpeechSynthesis(): EnvironmentProviders;
+declare function provideMutationObserver(): EnvironmentProviders;
+declare function providePerformanceObserver(): EnvironmentProviders;
+declare function provideIdleDetector(): EnvironmentProviders;
+declare function provideEyeDropper(): EnvironmentProviders;
+declare function provideBarcodeDetector(): EnvironmentProviders;
+declare function provideWebAudio(): EnvironmentProviders;
+declare function provideGamepad(): EnvironmentProviders;
+declare function provideWebBluetooth(): EnvironmentProviders;
+declare function provideWebUsb(): EnvironmentProviders;
+declare function provideWebNfc(): EnvironmentProviders;
+declare function providePaymentRequest(): EnvironmentProviders;
+declare function provideCredentialManagement(): EnvironmentProviders;
 
 declare const version = "0.1.0";
 
-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 };
+export { BarcodeDetectorService, BatteryService, BroadcastChannelService, BrowserApiBaseService, BrowserCapabilityService, BrowserSupportUtil, CameraService, ClipboardService, ConnectionRegistryBaseService, CredentialManagementService, EyeDropperService, FileSystemAccessService, FullscreenService, GamepadService, GeolocationService, IdleDetectorService, IntersectionObserverService, MediaDevicesService, MediaRecorderService, MutationObserverService, NetworkInformationService, NotificationService, PageVisibilityService, PaymentRequestService, PerformanceObserverService, PermissionAwareBrowserApiBaseService, PermissionsService, ResizeObserverService, ScreenOrientationService, ScreenWakeLockService, ServerSentEventsService, SpeechSynthesisService, VibrationService, WebAudioService, WebBluetoothService, WebNfcService, WebShareService, WebSocketService, WebStorageService, WebUsbService, WebWorkerService, permissionGuard as createPermissionGuard, defaultBrowserWebApisConfig, injectGamepad, injectIdleDetector, injectIntersectionObserver, injectMutationObserver, injectNetworkInformation, injectPageVisibility, injectPerformanceObserver, injectResizeObserver, injectScreenOrientation, permissionGuard, provideBarcodeDetector, provideBattery, provideBroadcastChannel, provideBrowserWebApis, provideCamera, provideClipboard, provideCommunicationApis, provideCredentialManagement, provideEyeDropper, provideFileSystemAccess, provideFullscreen, provideGamepad, provideGeolocation, provideIdleDetector, provideIntersectionObserver, provideLocationApis, provideMediaApis, provideMediaDevices, provideMediaRecorder, provideMutationObserver, provideNetworkInformation, provideNotifications, providePageVisibility, providePaymentRequest, providePerformanceObserver, providePermissions, provideResizeObserver, provideScreenOrientation, provideScreenWakeLock, provideServerSentEvents, provideSpeechSynthesis, provideStorageApis, provideVibration, provideWebAudio, provideWebBluetooth, provideWebNfc, provideWebShare, provideWebSocket, provideWebStorage, provideWebUsb, provideWebWorker, version };
+export type { AudioAnalyserData, AudioContextState, BarcodeFormat, BatteryInfo, BatteryManager, BluetoothDeviceInfo, BluetoothDeviceRef, BluetoothRequestDeviceOptions, BrowserCapabilityId, BrowserError, BrowserPermissions, BrowserWebApisConfig, CameraCapabilities, CameraInfo, ColorSelectionResult, ConnectionType, CredentialResult, DetectedBarcode, EffectiveConnectionType, ElementInput, ElementSize, ErrorCallback, EventHandler, FileOpenOptions, FileSaveOptions, GamepadRef, GamepadState, GeolocationCoordinates, GeolocationError, GeolocationOptions, GeolocationPosition$1 as GeolocationPosition, GeolocationWatchOptions, IdleDetectorOptions, IdleDetectorRef, IdleState, IntersectionObserverOptions, IntersectionRef, MediaDevice, MediaDeviceKind, MediaDevicesInfo, MediaStreamConstraints$1 as MediaStreamConstraints, MediaTrackConstraints$1 as MediaTrackConstraints, MutationObserverOptions, MutationRef, NdefMessage, NdefReadingEvent, NdefWriteOptions, NetworkInformation, NetworkInformationRef, OrientationInfo, OrientationLockType, OrientationType, PageVisibilityRef, PasswordCredentialData, PaymentDetailsInit, PaymentMethodConfig, PaymentOptionsConfig, PaymentResult, PerformanceEntryType, PerformanceObserverConfig, PerformanceObserverRef, PermissionNameExt, PermissionRequest, PublicKeyCredentialOptions, RecordingOptions, RecordingResult, RecordingState, ResizeObserverOptions, ResizeRef, SSEConfig, SSEConnectionState, SSEMessage, ScreenIdleState, ScreenOrientationRef, SpeechOptions, SpeechState, StorageEvent, StorageOptions, StorageValue, UsbDeviceFilterDef, UsbDeviceInfo, UsbDeviceRef, UserIdleState, VibrationPattern, VibrationPreset, VisibilityState, WakeLockStatus, WakeLockType, WebSocketConfig, WebSocketMessage, WebSocketStatus, WorkerMessage, WorkerStatus, WorkerTask };