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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@angular-helpers/browser-web-apis",
-  "version": "21.2.0",
+  "version": "21.3.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, 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';
@@ -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' | '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 +228,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;
@@ -308,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;
@@ -711,6 +764,360 @@ 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 {
+    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;
@@ -814,13 +1221,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 +1251,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 +1333,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 +1376,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, 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 };