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

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

@@ -1,7 +1,7 @@
-import * as i0 from '@angular/core';
-import { DestroyRef } from '@angular/core';
 import { Observable } from 'rxjs';
-import { CanActivate, Router, ActivatedRouteSnapshot } from '@angular/router';
+import * as i0 from '@angular/core';
+import { DestroyRef, Signal, ElementRef, EnvironmentProviders } from '@angular/core';
+import { CanActivateFn } from '@angular/router';
 
 type PermissionNameExt = PermissionName | 'clipboard-read' | 'clipboard-write';
 interface PermissionRequest {
@@ -50,13 +50,16 @@ declare abstract class BrowserApiBaseService {
      * Request a permission
      */
     protected requestPermission(permission: PermissionNameExt): Promise<boolean>;
+    /**
+     * Create an error with proper cause chaining
+     */
+    protected createError(message: string, cause?: unknown): Error;
     static ɵfac: i0.ɵɵFactoryDeclaration<BrowserApiBaseService, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<BrowserApiBaseService>;
 }
 
 declare class CameraService extends BrowserApiBaseService {
     private currentStream;
-    private createError;
     protected getApiName(): string;
     private ensureCameraSupport;
     startCamera(constraints?: MediaStreamConstraints): Promise<MediaStream>;
@@ -87,7 +90,6 @@ interface DisplayMediaConstraints {
     audio?: boolean | MediaTrackConstraints;
 }
 declare class MediaDevicesService extends BrowserApiBaseService {
-    private createError;
     protected getApiName(): string;
     private ensureMediaDevicesSupport;
     getDevices(): Promise<MediaDeviceInfo[]>;
@@ -106,6 +108,9 @@ declare class MediaDevicesService extends BrowserApiBaseService {
 
 declare class NotificationService extends BrowserApiBaseService {
     protected getApiName(): string;
+    get permission(): NotificationPermission;
+    isSupported(): boolean;
+    requestNotificationPermission(): Promise<NotificationPermission>;
     showNotification(title: string, options?: NotificationOptions): Promise<Notification>;
     static ɵfac: i0.ɵɵFactoryDeclaration<NotificationService, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<NotificationService>;
@@ -121,7 +126,7 @@ declare class ClipboardService extends BrowserApiBaseService {
     static ɵprov: i0.ɵɵInjectableDeclaration<ClipboardService>;
 }
 
-type BrowserCapabilityId = 'permissions' | 'geolocation' | 'clipboard' | 'notification' | 'mediaDevices' | 'camera' | 'webWorker' | 'regexSecurity' | 'webStorage' | 'webShare' | 'battery' | 'webSocket';
+type BrowserCapabilityId = 'permissions' | 'geolocation' | 'clipboard' | 'notification' | 'mediaDevices' | 'camera' | 'webWorker' | 'regexSecurity' | 'webStorage' | 'webShare' | 'battery' | 'webSocket' | 'intersectionObserver' | 'resizeObserver' | 'pageVisibility' | 'broadcastChannel' | 'networkInformation' | 'screenWakeLock' | 'screenOrientation' | 'fullscreen' | 'fileSystemAccess' | 'mediaRecorder' | 'serverSentEvents' | 'vibration' | 'speechSynthesis';
 declare class BrowserCapabilityService {
     getCapabilities(): readonly [{
         readonly id: "permissions";
@@ -171,12 +176,64 @@ declare class BrowserCapabilityService {
         readonly id: "webSocket";
         readonly label: "WebSocket API";
         readonly requiresSecureContext: false;
+    }, {
+        readonly id: "intersectionObserver";
+        readonly label: "Intersection Observer";
+        readonly requiresSecureContext: false;
+    }, {
+        readonly id: "resizeObserver";
+        readonly label: "Resize Observer";
+        readonly requiresSecureContext: false;
+    }, {
+        readonly id: "pageVisibility";
+        readonly label: "Page Visibility API";
+        readonly requiresSecureContext: false;
+    }, {
+        readonly id: "broadcastChannel";
+        readonly label: "Broadcast Channel API";
+        readonly requiresSecureContext: false;
+    }, {
+        readonly id: "networkInformation";
+        readonly label: "Network Information API";
+        readonly requiresSecureContext: false;
+    }, {
+        readonly id: "screenWakeLock";
+        readonly label: "Screen Wake Lock API";
+        readonly requiresSecureContext: true;
+    }, {
+        readonly id: "screenOrientation";
+        readonly label: "Screen Orientation API";
+        readonly requiresSecureContext: false;
+    }, {
+        readonly id: "fullscreen";
+        readonly label: "Fullscreen API";
+        readonly requiresSecureContext: false;
+    }, {
+        readonly id: "fileSystemAccess";
+        readonly label: "File System Access API";
+        readonly requiresSecureContext: true;
+    }, {
+        readonly id: "mediaRecorder";
+        readonly label: "MediaRecorder API";
+        readonly requiresSecureContext: true;
+    }, {
+        readonly id: "serverSentEvents";
+        readonly label: "Server-Sent Events";
+        readonly requiresSecureContext: false;
+    }, {
+        readonly id: "vibration";
+        readonly label: "Vibration API";
+        readonly requiresSecureContext: false;
+    }, {
+        readonly id: "speechSynthesis";
+        readonly label: "Speech Synthesis API";
+        readonly requiresSecureContext: false;
     }];
     isSecureContext(): boolean;
     isSupported(capability: BrowserCapabilityId): boolean;
     getAllStatuses(): {
-        id: "camera" | "geolocation" | "permissions" | "mediaDevices" | "clipboard" | "notification" | "webWorker" | "regexSecurity" | "webStorage" | "webShare" | "battery" | "webSocket";
-        label: "Permissions API" | "Geolocation API" | "Clipboard API" | "Notification API" | "MediaDevices API" | "Camera API" | "Web Worker API" | "Regex Security" | "Web Storage" | "Web Share" | "Battery API" | "WebSocket API";
+        id: "camera" | "geolocation" | "permissions" | "mediaDevices" | "clipboard" | "notification" | "webWorker" | "regexSecurity" | "webStorage" | "webShare" | "battery" | "webSocket" | "intersectionObserver" | "resizeObserver" | "pageVisibility" | "broadcastChannel" | "networkInformation" | "screenWakeLock" | "screenOrientation" | "fullscreen" | "fileSystemAccess" | "mediaRecorder" | "serverSentEvents" | "vibration" | "speechSynthesis";
+        label: "Permissions API" | "Geolocation API" | "Clipboard API" | "Notification API" | "MediaDevices API" | "Camera API" | "Web Worker API" | "Regex Security" | "Web Storage" | "Web Share" | "Battery API" | "WebSocket API" | "Intersection Observer" | "Resize Observer" | "Page Visibility API" | "Broadcast Channel API" | "Network Information API" | "Screen Wake Lock API" | "Screen Orientation API" | "Fullscreen API" | "File System Access API" | "MediaRecorder API" | "Server-Sent Events" | "Vibration API" | "Speech Synthesis API";
         supported: boolean;
         secureContext: boolean;
         requiresSecureContext: boolean;
@@ -186,6 +243,474 @@ declare class BrowserCapabilityService {
     static ɵprov: i0.ɵɵInjectableDeclaration<BrowserCapabilityService>;
 }
 
+interface BatteryInfo {
+    charging: boolean;
+    chargingTime: number;
+    dischargingTime: number;
+    level: number;
+}
+interface BatteryManager extends EventTarget {
+    readonly charging: boolean;
+    readonly chargingTime: number;
+    readonly dischargingTime: number;
+    readonly level: number;
+    addEventListener(type: 'chargingchange', listener: (this: BatteryManager, ev: Event) => void, options?: boolean | AddEventListenerOptions): void;
+    addEventListener(type: 'levelchange', listener: (this: BatteryManager, ev: Event) => void, options?: boolean | AddEventListenerOptions): void;
+    addEventListener(type: 'chargingtimechange', listener: (this: BatteryManager, ev: Event) => void, options?: boolean | AddEventListenerOptions): void;
+    addEventListener(type: 'dischargingtimechange', listener: (this: BatteryManager, ev: Event) => void, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener(type: 'chargingchange', listener: (this: BatteryManager, ev: Event) => void, options?: boolean | EventListenerOptions): void;
+    removeEventListener(type: 'levelchange', listener: (this: BatteryManager, ev: Event) => void, options?: boolean | EventListenerOptions): void;
+    removeEventListener(type: 'chargingtimechange', listener: (this: BatteryManager, ev: Event) => void, options?: boolean | EventListenerOptions): void;
+    removeEventListener(type: 'dischargingtimechange', listener: (this: BatteryManager, ev: Event) => void, options?: boolean | EventListenerOptions): void;
+}
+declare global {
+    interface Navigator {
+        getBattery?: () => Promise<BatteryManager>;
+    }
+}
+
+declare class BatteryService extends BrowserApiBaseService {
+    private batteryManager;
+    protected getApiName(): string;
+    private ensureBatterySupport;
+    initialize(): Promise<BatteryInfo>;
+    getBatteryInfo(): BatteryInfo;
+    watchBatteryInfo(): Observable<BatteryInfo>;
+    private setupEventListeners;
+    getNativeBatteryManager(): BatteryManager;
+    isCharging(): boolean;
+    getLevel(): number;
+    getChargingTime(): number;
+    getDischargingTime(): number;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BatteryService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<BatteryService>;
+}
+
+interface ShareResult {
+    shared: boolean;
+    error?: string;
+}
+declare class WebShareService extends BrowserApiBaseService {
+    protected getApiName(): string;
+    private ensureWebShareSupport;
+    share(data: ShareData): Promise<ShareResult>;
+    canShare(): boolean;
+    canShareFiles(): boolean;
+    getNativeShare(): typeof navigator.share;
+    static ɵfac: i0.ɵɵFactoryDeclaration<WebShareService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<WebShareService>;
+}
+
+type BrowserError = Error & {
+    name?: string;
+    message?: string;
+};
+type EventHandler<T = Event> = (event: T) => void;
+type StorageValue = string | number | boolean | object | null;
+type ErrorCallback = (error: BrowserError) => void;
+
+interface StorageOptions {
+    prefix?: string;
+    serialize?: (value: StorageValue) => string;
+    deserialize?: (value: string) => StorageValue;
+}
+interface StorageEvent {
+    key: string;
+    newValue: StorageValue | null;
+    oldValue: StorageValue | null;
+    storageArea: 'localStorage' | 'sessionStorage';
+}
+declare class WebStorageService extends BrowserApiBaseService {
+    private storageEvents;
+    protected destroyRef: DestroyRef;
+    constructor();
+    protected getApiName(): string;
+    private ensureStorageSupport;
+    private setupEventListeners;
+    private serializeValue;
+    private deserializeValue;
+    private getKey;
+    setLocalStorage<T extends StorageValue>(key: string, value: T, options?: StorageOptions): boolean;
+    getLocalStorage<T extends StorageValue>(key: string, defaultValue?: T | null, options?: StorageOptions): T | null;
+    removeLocalStorage(key: string, options?: StorageOptions): boolean;
+    clearLocalStorage(options?: StorageOptions): boolean;
+    setSessionStorage<T extends StorageValue>(key: string, value: T, options?: StorageOptions): boolean;
+    getSessionStorage<T extends StorageValue>(key: string, defaultValue?: T | null, options?: StorageOptions): T | null;
+    removeSessionStorage(key: string, options?: StorageOptions): boolean;
+    clearSessionStorage(options?: StorageOptions): boolean;
+    getLocalStorageSize(options?: StorageOptions): number;
+    getSessionStorageSize(options?: StorageOptions): number;
+    getStorageEvents(): Observable<StorageEvent>;
+    watchLocalStorage<T extends StorageValue>(key: string, options?: StorageOptions): Observable<T | null>;
+    watchSessionStorage<T extends StorageValue>(key: string, options?: StorageOptions): Observable<T | null>;
+    getNativeLocalStorage(): Storage;
+    getNativeSessionStorage(): Storage;
+    static ɵfac: i0.ɵɵFactoryDeclaration<WebStorageService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<WebStorageService>;
+}
+
+interface WebSocketConfig {
+    url: string;
+    protocols?: string | string[];
+    reconnectInterval?: number;
+    maxReconnectAttempts?: number;
+    heartbeatInterval?: number;
+    heartbeatMessage?: unknown;
+}
+interface WebSocketMessage<T = unknown> {
+    type: string;
+    data: T;
+    timestamp?: number;
+}
+interface WebSocketStatus {
+    connected: boolean;
+    connecting: boolean;
+    reconnecting: boolean;
+    error?: string;
+    reconnectAttempts: number;
+}
+declare class WebSocketService extends BrowserApiBaseService {
+    private webSocket;
+    private statusSubject;
+    private messageSubject;
+    private reconnectAttempts;
+    private reconnectTimer;
+    private heartbeatTimer;
+    protected getApiName(): string;
+    private ensureWebSocketSupport;
+    connect(config: WebSocketConfig): Observable<WebSocketStatus>;
+    disconnect(): void;
+    send<T>(message: WebSocketMessage<T>): void;
+    sendRaw(data: string): void;
+    getStatus(): Observable<WebSocketStatus>;
+    getMessages<T = unknown>(): Observable<WebSocketMessage<T>>;
+    private setupWebSocketHandlers;
+    private startHeartbeat;
+    private attemptReconnect;
+    private updateStatus;
+    private getCurrentStatus;
+    getNativeWebSocket(): WebSocket | null;
+    isConnected(): boolean;
+    getReadyState(): number;
+    static ɵfac: i0.ɵɵFactoryDeclaration<WebSocketService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<WebSocketService>;
+}
+
+interface WorkerMessage<T = unknown> {
+    id: string;
+    type: string;
+    data: T;
+    timestamp: number;
+}
+interface WorkerStatus {
+    initialized: boolean;
+    running: boolean;
+    error?: string;
+    messageCount: number;
+}
+interface WorkerTask<T = unknown> {
+    id: string;
+    type: string;
+    data: T;
+    transferable?: Transferable[];
+}
+declare class WebWorkerService extends BrowserApiBaseService {
+    protected destroyRef: DestroyRef;
+    private workers;
+    private workerStatuses;
+    private workerMessages;
+    private currentWorkerStatuses;
+    protected getApiName(): string;
+    private ensureWorkerSupport;
+    createWorker(name: string, scriptUrl: string): Observable<WorkerStatus>;
+    terminateWorker(name: string): void;
+    terminateAllWorkers(): void;
+    postMessage(workerName: string, task: WorkerTask): void;
+    getMessages(workerName: string): Observable<WorkerMessage>;
+    getStatus(workerName: string): Observable<WorkerStatus>;
+    getCurrentStatus(workerName: string): WorkerStatus | undefined;
+    getAllStatuses(): Map<string, WorkerStatus>;
+    isWorkerRunning(workerName: string): boolean;
+    private setupWorker;
+    private updateWorkerStatus;
+    getNativeWorker(name: string): Worker | undefined;
+    getAllWorkers(): Map<string, Worker>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<WebWorkerService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<WebWorkerService>;
+}
+
+interface IntersectionObserverOptions {
+    root?: Element | Document | null;
+    rootMargin?: string;
+    threshold?: number | number[];
+}
+declare class IntersectionObserverService {
+    private readonly platformId;
+    isSupported(): boolean;
+    observe(element: Element, options?: IntersectionObserverOptions): Observable<IntersectionObserverEntry[]>;
+    observeVisibility(element: Element, options?: IntersectionObserverOptions): Observable<boolean>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IntersectionObserverService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<IntersectionObserverService>;
+}
+
+interface ResizeObserverOptions {
+    box?: ResizeObserverBoxOptions;
+}
+interface ElementSize {
+    width: number;
+    height: number;
+    inlineSize: number;
+    blockSize: number;
+}
+declare class ResizeObserverService {
+    private readonly platformId;
+    isSupported(): boolean;
+    observe(element: Element, options?: ResizeObserverOptions): Observable<ResizeObserverEntry[]>;
+    observeSize(element: Element, options?: ResizeObserverOptions): Observable<ElementSize>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ResizeObserverService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ResizeObserverService>;
+}
+
+type VisibilityState = 'visible' | 'hidden' | 'prerender';
+declare class PageVisibilityService {
+    private readonly platformId;
+    isSupported(): boolean;
+    get isHidden(): boolean;
+    get visibilityState(): VisibilityState;
+    watch(): Observable<VisibilityState>;
+    watchVisibility(): Observable<boolean>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PageVisibilityService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<PageVisibilityService>;
+}
+
+declare class BroadcastChannelService {
+    private readonly destroyRef;
+    private readonly platformId;
+    private channels;
+    isSupported(): boolean;
+    private ensureSupport;
+    open<T = unknown>(name: string): Observable<T>;
+    post<T = unknown>(name: string, data: T): void;
+    close(name: string): void;
+    closeAll(): void;
+    getOpenChannels(): string[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<BroadcastChannelService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<BroadcastChannelService>;
+}
+
+type ConnectionType = 'bluetooth' | 'cellular' | 'ethernet' | 'none' | 'wifi' | 'wimax' | 'other' | 'unknown';
+type EffectiveConnectionType = 'slow-2g' | '2g' | '3g' | '4g';
+interface NetworkInformation {
+    type?: ConnectionType;
+    effectiveType?: EffectiveConnectionType;
+    downlink?: number;
+    downlinkMax?: number;
+    rtt?: number;
+    saveData?: boolean;
+    online: boolean;
+}
+declare class NetworkInformationService {
+    private readonly platformId;
+    isSupported(): boolean;
+    getSnapshot(): NetworkInformation;
+    watch(): Observable<NetworkInformation>;
+    get isOnline(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NetworkInformationService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NetworkInformationService>;
+}
+
+type WakeLockType = 'screen';
+interface WakeLockStatus {
+    active: boolean;
+    type?: WakeLockType;
+    released?: boolean;
+}
+declare class ScreenWakeLockService extends BrowserApiBaseService {
+    private sentinel;
+    protected getApiName(): string;
+    isSupported(): boolean;
+    get isActive(): boolean;
+    request(type?: WakeLockType): Promise<WakeLockStatus>;
+    release(): Promise<void>;
+    watchStatus(): Observable<WakeLockStatus>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ScreenWakeLockService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ScreenWakeLockService>;
+}
+
+type OrientationType = 'portrait-primary' | 'portrait-secondary' | 'landscape-primary' | 'landscape-secondary';
+type OrientationLockType = 'any' | 'natural' | 'landscape' | 'portrait' | 'portrait-primary' | 'portrait-secondary' | 'landscape-primary' | 'landscape-secondary';
+interface OrientationInfo {
+    type: OrientationType;
+    angle: number;
+}
+declare class ScreenOrientationService {
+    private readonly platformId;
+    isSupported(): boolean;
+    getSnapshot(): OrientationInfo;
+    get isPortrait(): boolean;
+    get isLandscape(): boolean;
+    watch(): Observable<OrientationInfo>;
+    lock(orientation: OrientationLockType): Promise<void>;
+    unlock(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ScreenOrientationService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ScreenOrientationService>;
+}
+
+declare class FullscreenService {
+    private readonly destroyRef;
+    private readonly platformId;
+    isSupported(): boolean;
+    get isFullscreen(): boolean;
+    get fullscreenElement(): Element | null;
+    request(element?: Element): Promise<void>;
+    exit(): Promise<void>;
+    toggle(element?: Element): Promise<void>;
+    watch(): Observable<boolean>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FullscreenService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<FullscreenService>;
+}
+
+interface FileOpenOptions {
+    multiple?: boolean;
+    excludeAcceptAllOption?: boolean;
+    types?: Array<{
+        description?: string;
+        accept: Record<string, string[]>;
+    }>;
+}
+interface FileSaveOptions {
+    suggestedName?: string;
+    excludeAcceptAllOption?: boolean;
+    types?: Array<{
+        description?: string;
+        accept: Record<string, string[]>;
+    }>;
+}
+declare class FileSystemAccessService extends BrowserApiBaseService {
+    protected getApiName(): string;
+    isSupported(): boolean;
+    private get win();
+    private ensureSupport;
+    openFile(options?: FileOpenOptions): Promise<File[]>;
+    saveFile(content: string | Blob, options?: FileSaveOptions): Promise<void>;
+    openDirectory(options?: {
+        id?: string;
+        mode?: 'read' | 'readwrite';
+        startIn?: string;
+    }): Promise<FileSystemDirectoryHandle | null>;
+    readFileAsText(file: File): Promise<string>;
+    readFileAsArrayBuffer(file: File): Promise<ArrayBuffer>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FileSystemAccessService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<FileSystemAccessService>;
+}
+
+type RecordingState = 'inactive' | 'recording' | 'paused';
+interface RecordingOptions {
+    mimeType?: string;
+    audioBitsPerSecond?: number;
+    videoBitsPerSecond?: number;
+    bitsPerSecond?: number;
+    timeslice?: number;
+}
+interface RecordingResult {
+    blob: Blob;
+    url: string;
+    mimeType: string;
+    duration: number;
+}
+declare class MediaRecorderService extends BrowserApiBaseService {
+    private recorder;
+    private chunks;
+    private startTime;
+    private readonly dataSubject;
+    private readonly stateSubject;
+    protected getApiName(): string;
+    isSupported(): boolean;
+    get state(): RecordingState;
+    static isTypeSupported(mimeType: string): boolean;
+    watchState(): Observable<RecordingState>;
+    watchData(): Observable<Blob>;
+    start(stream: MediaStream, options?: RecordingOptions): Promise<void>;
+    pause(): void;
+    resume(): void;
+    stop(): RecordingResult | null;
+    getResult(): RecordingResult | null;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MediaRecorderService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<MediaRecorderService>;
+}
+
+type SSEConnectionState = 'connecting' | 'open' | 'closed';
+interface SSEMessage<T = unknown> {
+    data: T;
+    type: string;
+    lastEventId: string;
+    origin: string;
+}
+interface SSEConfig {
+    withCredentials?: boolean;
+    eventTypes?: string[];
+}
+declare class ServerSentEventsService {
+    private readonly destroyRef;
+    private readonly platformId;
+    private sources;
+    isSupported(): boolean;
+    private ensureSupport;
+    connect<T = unknown>(url: string, config?: SSEConfig): Observable<SSEMessage<T>>;
+    disconnect(url: string): void;
+    disconnectAll(): void;
+    getState(url: string): SSEConnectionState;
+    getActiveConnections(): string[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<ServerSentEventsService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ServerSentEventsService>;
+}
+
+type VibrationPattern = number | number[];
+interface VibrationPreset {
+    success: VibrationPattern;
+    error: VibrationPattern;
+    notification: VibrationPattern;
+    doubleTap: VibrationPattern;
+}
+declare class VibrationService {
+    private readonly platformId;
+    readonly presets: VibrationPreset;
+    isSupported(): boolean;
+    vibrate(pattern?: VibrationPattern): boolean;
+    success(): boolean;
+    error(): boolean;
+    notification(): boolean;
+    doubleTap(): boolean;
+    stop(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<VibrationService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<VibrationService>;
+}
+
+type SpeechState = 'idle' | 'speaking' | 'paused';
+interface SpeechOptions {
+    lang?: string;
+    voice?: SpeechSynthesisVoice;
+    volume?: number;
+    rate?: number;
+    pitch?: number;
+}
+declare class SpeechSynthesisService {
+    private readonly destroyRef;
+    private readonly platformId;
+    isSupported(): boolean;
+    private ensureSupport;
+    get state(): SpeechState;
+    get isPending(): boolean;
+    getVoices(): SpeechSynthesisVoice[];
+    watchVoices(): Observable<SpeechSynthesisVoice[]>;
+    speak(text: string, options?: SpeechOptions): Observable<SpeechState>;
+    pause(): void;
+    resume(): void;
+    cancel(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SpeechSynthesisService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SpeechSynthesisService>;
+}
+
 interface MediaDevice {
     deviceId: string;
     groupId: string;
@@ -275,6 +800,50 @@ interface GeolocationWatchOptions extends GeolocationOptions {
     maximumAge?: number;
 }
 
+interface PageVisibilityRef {
+    readonly state: Signal<VisibilityState>;
+    readonly isVisible: Signal<boolean>;
+    readonly isHidden: Signal<boolean>;
+}
+declare function injectPageVisibility(): PageVisibilityRef;
+
+interface ResizeRef {
+    readonly size: Signal<ElementSize | null>;
+    readonly width: Signal<number>;
+    readonly height: Signal<number>;
+    readonly inlineSize: Signal<number>;
+    readonly blockSize: Signal<number>;
+}
+declare function injectResizeObserver(elementOrRef: Element | ElementRef<Element>, options?: ResizeObserverOptions): ResizeRef;
+
+interface IntersectionRef {
+    readonly isIntersecting: Signal<boolean>;
+    readonly isVisible: Signal<boolean>;
+}
+declare function injectIntersectionObserver(elementOrRef: Element | ElementRef<Element>, options?: IntersectionObserverOptions): IntersectionRef;
+
+interface NetworkInformationRef {
+    readonly snapshot: Signal<NetworkInformation>;
+    readonly online: Signal<boolean>;
+    readonly effectiveType: Signal<EffectiveConnectionType | undefined>;
+    readonly downlink: Signal<number | undefined>;
+    readonly rtt: Signal<number | undefined>;
+    readonly type: Signal<ConnectionType | undefined>;
+    readonly saveData: Signal<boolean | undefined>;
+}
+declare function injectNetworkInformation(): NetworkInformationRef;
+
+interface ScreenOrientationRef {
+    readonly orientation: Signal<OrientationInfo>;
+    readonly type: Signal<OrientationType>;
+    readonly angle: Signal<number>;
+    readonly isPortrait: Signal<boolean>;
+    readonly isLandscape: Signal<boolean>;
+    lock(orientation: OrientationLockType): Promise<void>;
+    unlock(): void;
+}
+declare function injectScreenOrientation(): ScreenOrientationRef;
+
 declare class BrowserSupportUtil {
     static isSupported(feature: string): boolean;
     static getUnsupportedFeatures(): string[];
@@ -294,21 +863,69 @@ declare class BrowserSupportUtil {
     private static getBrowserVersion;
 }
 
-declare class PermissionGuard implements CanActivate {
-    private permissionsService;
-    private router;
-    constructor(permissionsService: PermissionsService, router: Router);
-    canActivate(route: ActivatedRouteSnapshot): Promise<boolean>;
-    private checkPermission;
+/**
+ * Functional guard that checks if the user has the required permission.
+ * Usage in routes: { canActivate: [permissionGuard('camera')] }
+ */
+declare const permissionGuard: (permission: PermissionNameExt) => CanActivateFn;
+
+interface BrowserWebApisConfig {
+    enableCamera?: boolean;
+    enableGeolocation?: boolean;
+    enableNotifications?: boolean;
+    enableClipboard?: boolean;
+    enableMediaDevices?: boolean;
+    enableBattery?: boolean;
+    enableWebShare?: boolean;
+    enableWebStorage?: boolean;
+    enableWebSocket?: boolean;
+    enableWebWorker?: boolean;
+    enableIntersectionObserver?: boolean;
+    enableResizeObserver?: boolean;
+    enablePageVisibility?: boolean;
+    enableBroadcastChannel?: boolean;
+    enableNetworkInformation?: boolean;
+    enableScreenWakeLock?: boolean;
+    enableScreenOrientation?: boolean;
+    enableFullscreen?: boolean;
+    enableFileSystemAccess?: boolean;
+    enableMediaRecorder?: boolean;
+    enableServerSentEvents?: boolean;
+    enableVibration?: boolean;
+    enableSpeechSynthesis?: boolean;
 }
-declare function createPermissionGuard(permission: PermissionNameExt): {
-    canActivate: (typeof PermissionGuard)[];
-    data: {
-        permission: PermissionNameExt;
-    };
-};
+declare const defaultBrowserWebApisConfig: BrowserWebApisConfig;
+declare function provideBrowserWebApis(config?: BrowserWebApisConfig): EnvironmentProviders;
+declare function provideCamera(): EnvironmentProviders;
+declare function provideGeolocation(): EnvironmentProviders;
+declare function provideNotifications(): EnvironmentProviders;
+declare function provideClipboard(): EnvironmentProviders;
+declare function provideMediaDevices(): EnvironmentProviders;
+declare function provideBattery(): EnvironmentProviders;
+declare function provideWebShare(): EnvironmentProviders;
+declare function provideWebStorage(): EnvironmentProviders;
+declare function provideWebSocket(): EnvironmentProviders;
+declare function provideWebWorker(): EnvironmentProviders;
+declare function providePermissions(): EnvironmentProviders;
+declare function provideMediaApis(): EnvironmentProviders;
+declare function provideLocationApis(): EnvironmentProviders;
+declare function provideStorageApis(): EnvironmentProviders;
+declare function provideCommunicationApis(): EnvironmentProviders;
+declare function provideIntersectionObserver(): EnvironmentProviders;
+declare function provideResizeObserver(): EnvironmentProviders;
+declare function providePageVisibility(): EnvironmentProviders;
+declare function provideBroadcastChannel(): EnvironmentProviders;
+declare function provideNetworkInformation(): EnvironmentProviders;
+declare function provideScreenWakeLock(): EnvironmentProviders;
+declare function provideScreenOrientation(): EnvironmentProviders;
+declare function provideFullscreen(): EnvironmentProviders;
+declare function provideFileSystemAccess(): EnvironmentProviders;
+declare function provideMediaRecorder(): EnvironmentProviders;
+declare function provideServerSentEvents(): EnvironmentProviders;
+declare function provideVibration(): EnvironmentProviders;
+declare function provideSpeechSynthesis(): EnvironmentProviders;
 
 declare const version = "0.1.0";
 
-export { BrowserCapabilityService, BrowserSupportUtil, CameraService, ClipboardService, GeolocationService, MediaDevicesService, NotificationService, PermissionGuard, PermissionsService, createPermissionGuard, version };
-export type { BrowserCapabilityId, BrowserPermissions, CameraCapabilities, CameraInfo, GeolocationCoordinates, GeolocationError, GeolocationOptions, GeolocationPosition$1 as GeolocationPosition, GeolocationWatchOptions, MediaDevice, MediaDeviceKind, MediaDevicesInfo, MediaStreamConstraints$1 as MediaStreamConstraints, MediaTrackConstraints$1 as MediaTrackConstraints, PermissionNameExt, PermissionRequest };
+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 };