@angular-helpers/browser-web-apis 21.1.0 → 21.3.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, EnvironmentProviders } from '@angular/core';
+import { DestroyRef, ElementRef, Signal, 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' | 'mutationObserver' | 'performanceObserver' | 'idleDetector' | 'eyeDropper' | 'barcodeDetector' | 'webAudio' | 'gamepad' | 'webBluetooth' | 'webUsb' | 'webNfc' | 'paymentRequest' | 'credentialManagement';
 declare class BrowserCapabilityService {
     getCapabilities(): readonly [{
         readonly id: "permissions";
@@ -176,12 +176,112 @@ 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;
+    }, {
+        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";
-        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" | "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;
@@ -256,6 +356,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;
@@ -387,6 +492,632 @@ 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 MutationObserverOptions {
+    childList?: boolean;
+    attributes?: boolean;
+    characterData?: boolean;
+    subtree?: boolean;
+    attributeOldValue?: boolean;
+    characterDataOldValue?: boolean;
+    attributeFilter?: string[];
+}
+
+declare class MutationObserverService {
+    private readonly platformId;
+    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 {
+    private readonly platformId;
+    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 {
+    private readonly platformId;
+    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 {
+    private readonly platformId;
+    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 {
+    private readonly platformId;
+    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 {
+    private readonly platformId;
+    private readonly destroyRef;
+    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 {
+    private readonly platformId;
+    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 {
+    private readonly platformId;
+    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 {
+    private readonly platformId;
+    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 {
+    private readonly platformId;
+    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 {
+    private readonly platformId;
+    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 {
+    private readonly platformId;
+    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;
@@ -476,6 +1207,83 @@ 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: ElementInput, options?: ResizeObserverOptions): ResizeRef;
+
+interface IntersectionRef {
+    readonly isIntersecting: Signal<boolean>;
+    readonly isVisible: Signal<boolean>;
+}
+declare function injectIntersectionObserver(elementOrRef: ElementInput, 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;
+
+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[];
@@ -512,6 +1320,31 @@ 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;
+    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;
@@ -530,8 +1363,33 @@ 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 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, 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 { BarcodeDetectorService, BatteryService, BroadcastChannelService, BrowserApiBaseService, BrowserCapabilityService, BrowserSupportUtil, CameraService, ClipboardService, CredentialManagementService, EyeDropperService, FileSystemAccessService, FullscreenService, GamepadService, GeolocationService, IdleDetectorService, IntersectionObserverService, MediaDevicesService, MediaRecorderService, MutationObserverService, NetworkInformationService, NotificationService, PageVisibilityService, PaymentRequestService, PerformanceObserverService, 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 };