directix 1.9.0 → 1.10.0

package/dist/index.d.ts

@@ -1,8 +1,10 @@
 import { App } from 'vue';
 import { ComponentPublicInstance } from 'vue';
+import { ComputedRef } from 'vue';
 import { Directive } from 'vue';
 import { Plugin as Plugin_2 } from 'vue';
 import { Ref } from 'vue';
+import { ShallowRef } from 'vue';
 import { VNode } from 'vue';
 
 /**
@@ -15,6 +17,102 @@ export declare function addCleanupVue2(el: Element, fn: () => void): void;
  */
 export declare function addCleanupVue3(el: Element, fn: () => void): void;
 
+/**
+ * Add non-passive event listener (for events that need preventDefault)
+ */
+export declare function addNonPassiveListener(element: EventTarget, event: string, handler: EventListener, options?: AddEventListenerOptions): () => void;
+
+/**
+ * Add passive event listener
+ */
+export declare function addPassiveListener(element: EventTarget, event: string, handler: EventListener, options?: AddEventListenerOptions): () => void;
+
+/**
+ * Announce a message to screen readers
+ */
+export declare function announce(message: string, options?: AnnounceOptions): void;
+
+/**
+ * Announce message to screen readers
+ */
+export declare interface AnnounceOptions {
+    /** Priority level */
+    priority?: ARIALivePriority;
+    /** Time before clearing message */
+    timeout?: number;
+    /** Whether to clear queue */
+    clear?: boolean;
+}
+
+/**
+ * Apply ARIA attributes to an element
+ */
+export declare function applyAriaAttributes(el: HTMLElement, config: ARIAConfig): void;
+
+/**
+ * ARIA attribute configuration
+ */
+export declare interface ARIAConfig {
+    /** Role */
+    role?: ARIARole;
+    /** State attributes */
+    ariaExpanded?: boolean;
+    ariaSelected?: boolean;
+    ariaChecked?: boolean;
+    ariaDisabled?: boolean;
+    ariaHidden?: boolean;
+    ariaBusy?: boolean;
+    ariaPressed?: boolean;
+    ariaCurrent?: 'page' | 'step' | 'location' | 'date' | 'time' | boolean;
+    /** Property attributes */
+    ariaLabel?: string;
+    ariaLabelledBy?: string;
+    ariaDescribedBy?: string;
+    ariaControls?: string;
+    ariaOwns?: string;
+    ariaHasPopup?: ARIAPopupType | boolean;
+    ariaAutoComplete?: 'inline' | 'list' | 'both' | 'none';
+    /** Live region attributes */
+    ariaLive?: ARIALivePriority;
+    ariaAtomic?: boolean;
+    ariaRelevant?: 'additions' | 'removals' | 'text' | 'all';
+    /** Other attributes */
+    ariaValueNow?: number;
+    ariaValueMin?: number;
+    ariaValueMax?: number;
+    ariaValueText?: string;
+    ariaPlaceholder?: string;
+    ariaRequired?: boolean;
+    ariaReadonly?: boolean;
+    ariaModal?: boolean;
+    /** Tab index */
+    tabIndex?: number;
+}
+
+/**
+ * ARIA live region priority
+ */
+export declare type ARIALivePriority = 'off' | 'polite' | 'assertive';
+
+/**
+ * ARIA popup type
+ */
+export declare type ARIAPopupType = 'menu' | 'listbox' | 'tree' | 'grid' | 'dialog' | 'tooltip';
+
+/**
+ * A11y (Accessibility) Utilities for Directix
+ *
+ * Provides comprehensive accessibility support including:
+ * - ARIA attribute management
+ * - Keyboard navigation
+ * - Screen reader announcements
+ * - Focus management
+ */
+/**
+ * ARIA role types
+ */
+export declare type ARIARole = 'alert' | 'alertdialog' | 'application' | 'article' | 'banner' | 'button' | 'cell' | 'checkbox' | 'columnheader' | 'combobox' | 'complementary' | 'contentinfo' | 'definition' | 'dialog' | 'directory' | 'document' | 'feed' | 'figure' | 'form' | 'grid' | 'gridcell' | 'group' | 'heading' | 'img' | 'link' | 'list' | 'listbox' | 'listitem' | 'log' | 'main' | 'marquee' | 'math' | 'menu' | 'menubar' | 'menuitem' | 'menuitemcheckbox' | 'menuitemradio' | 'navigation' | 'none' | 'note' | 'option' | 'presentation' | 'progressbar' | 'radio' | 'radiogroup' | 'region' | 'row' | 'rowgroup' | 'rowheader' | 'scrollbar' | 'search' | 'searchbox' | 'separator' | 'slider' | 'spinbutton' | 'status' | 'switch' | 'tab' | 'table' | 'tablist' | 'tabpanel' | 'term' | 'textbox' | 'timer' | 'toolbar' | 'tooltip' | 'tree' | 'treegrid' | 'treeitem';
+
 /**
  * Assert a condition and throw an error if false
  */
@@ -37,6 +135,22 @@ export declare function assertRange(value: number, min: number, max: number, dir
 declare function assertType_2<T>(value: unknown, type: 'string' | 'number' | 'boolean' | 'object' | 'function' | 'symbol' | 'bigint' | 'undefined', directive: string, param: string): asserts value is T;
 export { assertType_2 as assertType }
 
+/**
+ * Auto-generate ARIA attributes based on directive type
+ */
+export declare interface AutoAriaOptions {
+    /** Directive type */
+    type: 'tooltip' | 'menu' | 'dialog' | 'popover' | 'dropdown' | 'modal' | 'alert' | 'region';
+    /** Label for the element */
+    label?: string;
+    /** Whether element is expanded */
+    expanded?: boolean;
+    /** Whether element is disabled */
+    disabled?: boolean;
+    /** Related element ID */
+    relatedId?: string;
+}
+
 /**
  * Calculate statistics from metrics
  */
@@ -60,6 +174,16 @@ export declare function capitalizeText(text: string, options?: {
  */
 export declare function capitalizeWord(word: string): string;
 
+/**
+ * Clear the announcer
+ */
+export declare function clearAnnouncer(): void;
+
+/**
+ * Clear all ARIA attributes from an element
+ */
+export declare function clearAriaAttributes(el: HTMLElement): void;
+
 /**
  * Clear DevTools state
  */
@@ -116,6 +240,21 @@ export declare interface ComposableThrottledFunction<T extends (...args: any[])
     cancel: () => void;
 }
 
+/**
+ * Computed ref with automatic cleanup
+ */
+export declare function computedWithCleanup<T>(options: ComputedWithCleanupOptions<T>): ComputedRef<T>;
+
+/**
+ * Options for computed with cleanup
+ */
+export declare interface ComputedWithCleanupOptions<T> {
+    /** Getter function */
+    get: () => T;
+    /** Cleanup function called when dependencies change or on unmount */
+    cleanup?: (value: T) => void;
+}
+
 /**
  * Configure performance monitoring
  */
@@ -350,6 +489,11 @@ export declare function createPermissionChecker(config: {
     roleMap?: Record<string, string[]>;
 }): (value: string | string[], mode?: PermissionMode) => boolean;
 
+/**
+ * Create safe content handler
+ */
+export declare function createSafeContentHandler(config?: XSSProtectionConfig): SafeContentHandler;
+
 /**
  * Create a style-based directive template
  *
@@ -452,6 +596,20 @@ export declare function createWatermarkUrl(content: string | string[], options?:
  */
 export declare type CrossVersionDirective = Directive | Vue2DirectiveHooks | Vue3DirectiveHooks;
 
+/**
+ * CSP Configuration
+ */
+export declare interface CSPConfig {
+    /** Disable inline scripts */
+    noInlineScripts?: boolean;
+    /** Disable inline styles */
+    noInlineStyles?: boolean;
+    /** Disable eval */
+    noEval?: boolean;
+    /** Nonce for inline scripts/styles */
+    nonce?: string;
+}
+
 /**
  * Date format options per region
  */
@@ -532,6 +690,26 @@ export declare function defineDirectiveGroup(name: string, directives: Record<st
  */
 export declare function definePlugin(plugin: DirectixPlugin): DirectixPlugin;
 
+/**
+ * Dependency vulnerability info
+ */
+export declare interface DependencyVulnerability {
+    /** Package name */
+    name: string;
+    /** Installed version */
+    version: string;
+    /** Vulnerability ID (e.g., CVE, GHSA) */
+    id?: string;
+    /** Severity level */
+    severity: 'critical' | 'high' | 'medium' | 'low';
+    /** Vulnerability title */
+    title: string;
+    /** URL for more info */
+    url?: string;
+    /** Patched versions */
+    patchedVersions?: string;
+}
+
 /**
  * Detect user locale info
  */
@@ -652,6 +830,16 @@ export declare interface DirectiveInstallOptions {
     config?: Record<string, any>;
 }
 
+/**
+ * Options for directive instance with Vue 3 reactivity
+ */
+export declare interface DirectiveInstanceOptions<T = any> {
+    /** Initial state */
+    initialState?: T;
+    /** Whether to use shallow reactive (better for large objects) */
+    shallow?: boolean;
+}
+
 /**
  * Per-directive messages
  */
@@ -756,6 +944,11 @@ export declare function enablePerformance(): void;
  */
 export declare function endMeasure(markId: string, directive: string, phase: 'mount' | 'update' | 'unmount', metadata?: Record<string, any>): void;
 
+/**
+ * Create teleport target if not exists
+ */
+export declare function ensureTeleportTarget(target: string): HTMLElement | null;
+
 export declare const enUS: I18nMessages;
 
 /**
@@ -777,6 +970,11 @@ declare interface ErrorMessages {
     ssr_not_supported: string;
 }
 
+/**
+ * Escape HTML entities
+ */
+export declare function escapeHtml(str: string): string;
+
 /**
  * Export format type
  */
@@ -791,6 +989,56 @@ export declare function exportPerformanceData(): {
     report: DirectivePerformance[];
 };
 
+/**
+ * Extended touch gesture types
+ */
+export declare type ExtendedGestureType = 'tap' | 'doubleTap' | 'longPress' | 'swipe' | 'pan' | 'pinch' | 'pinchIn' | 'pinchOut' | 'rotate' | 'twoFingerTap' | 'threeFingerTap' | 'edgeSwipe';
+
+/**
+ * Extended touch gesture event
+ */
+export declare interface ExtendedTouchEvent {
+    /** Gesture type */
+    type: ExtendedGestureType;
+    /** Swipe direction (for swipe gesture) */
+    direction?: 'left' | 'right' | 'up' | 'down';
+    /** Distance in pixels */
+    distance?: number;
+    /** Velocity in px/s */
+    velocity?: number;
+    /** Angle in degrees */
+    angle?: number;
+    /** Scale factor (for pinch) */
+    scale?: number;
+    /** Rotation in degrees */
+    rotation?: number;
+    /** Center point */
+    center?: {
+        x: number;
+        y: number;
+    };
+    /** Original touch event */
+    event: TouchEvent;
+    /** Duration in ms */
+    duration?: number;
+}
+
+/**
+ * Focus trap options
+ */
+export declare interface FocusTrapOptions {
+    /** Initial focus element */
+    initialFocus?: HTMLElement | string | (() => HTMLElement | null);
+    /** Elements to allow focus escape */
+    allowOutsideClick?: boolean | ((event: MouseEvent | TouchEvent) => boolean);
+    /** Enable escape key */
+    escapeDeactivates?: boolean;
+    /** Callback on activate */
+    onActivate?: () => void;
+    /** Callback on deactivate */
+    onDeactivate?: () => void;
+}
+
 /**
  * Format currency with locale-specific format
  */
@@ -833,6 +1081,11 @@ export declare function formatNumberLocale(value: number, decimals?: number, opt
  */
 export declare function formatTime(time: CountdownTime, format: string | CountdownFormatFunction): string;
 
+/**
+ * Generate unique ID for ARIA references
+ */
+export declare function generateAriaId(prefix?: string): string;
+
 /**
  * Generate unique ID
  */
@@ -843,11 +1096,26 @@ export declare function generateId(prefix?: string): string;
  */
 export declare function get<T = any>(obj: Record<string, any>, path: string, defaultValue?: T): T;
 
+/**
+ * Get default ARIA config for directive type
+ */
+export declare function getAutoAriaConfig(options: AutoAriaOptions): ARIAConfig;
+
+/**
+ * Get CSP nonce from meta tag
+ */
+export declare function getCSPNonce(): string | null;
+
 /**
  * Get region-specific date format
  */
 export declare function getDateFormat(region?: string): DateFormatOptions;
 
+/**
+ * Get device pixel ratio
+ */
+export declare function getDevicePixelRatio(): number;
+
 /**
  * Get DevTools state (for external access)
  */
@@ -1000,6 +1268,16 @@ export declare interface I18nOptions {
  */
 export declare function info(message: string, params?: Record<string, any>): void;
 
+/**
+ * CSP-safe script injection
+ */
+export declare function injectScriptCSP(src: string, options?: CSPConfig): HTMLScriptElement | null;
+
+/**
+ * CSP-safe style injection
+ */
+export declare function injectStylesCSP(css: string, options?: CSPConfig): HTMLStyleElement | HTMLLinkElement | null;
+
 /**
  * Intersect event handler
  */
@@ -1035,6 +1313,11 @@ export declare function isEmpty(value: unknown): boolean;
  */
 export declare function isFunction(value: unknown): value is (...args: any[]) => any;
 
+/**
+ * Check if device is mobile
+ */
+export declare function isMobileDevice(): boolean;
+
 /**
  * Check if value is a number
  */
@@ -1065,6 +1348,16 @@ export declare const isSSR: () => boolean;
  */
 export declare function isString(value: unknown): value is string;
 
+/**
+ * Check if device supports touch
+ */
+export declare function isTouchDevice(): boolean;
+
+/**
+ * Check if URL is safe
+ */
+export declare function isUrlSafe(url: string, allowedProtocols?: string[]): boolean;
+
 /**
  * Check if Vue 2 (includes 2.7)
  */
@@ -1087,6 +1380,36 @@ export declare type ItemSizeFunction = (index: number) => number;
 
 export declare const jaJP: I18nMessages;
 
+/**
+ * Keyboard navigation configuration
+ */
+export declare interface KeyboardNavigationConfig {
+    /** Keys for next item */
+    nextKeys?: string[];
+    /** Keys for previous item */
+    prevKeys?: string[];
+    /** Keys for selection */
+    selectKeys?: string[];
+    /** Keys for closing */
+    closeKeys?: string[];
+    /** Keys for home */
+    homeKeys?: string[];
+    /** Keys for end */
+    endKeys?: string[];
+    /** Focus trap enabled */
+    focusTrap?: boolean;
+    /** Whether element should receive initial focus */
+    initialFocus?: string | HTMLElement | (() => HTMLElement | null);
+    /** Return focus on close */
+    returnFocus?: boolean;
+    /** Navigation mode */
+    mode?: 'linear' | 'grid' | 'tree';
+    /** Loop navigation */
+    loop?: boolean;
+    /** Roving tabindex enabled */
+    rovingTabindex?: boolean;
+}
+
 /**
  * Lazy loading state
  */
@@ -1163,6 +1486,55 @@ export declare interface NumberFormatOptions {
     currencyDecimals: number;
 }
 
+/**
+ * Object pool for reusing objects (memory optimization)
+ */
+export declare class ObjectPool<T> {
+    private pool;
+    private factory;
+    private reset;
+    private maxSize;
+    constructor(factory: () => T, reset: (item: T) => void, maxSize?: number);
+    acquire(): T;
+    release(item: T): void;
+    get size(): number;
+    clear(): void;
+}
+
+/**
+ * Vue 3 Optimization Utilities for Directix
+ *
+ * These utilities leverage Vue 3 specific APIs for better performance
+ * when running in Vue 3 environments.
+ */
+/**
+ * Options for optimized lazy loading
+ */
+export declare interface OptimizedLazyOptions {
+    /** Threshold for intersection observer */
+    threshold?: number | number[];
+    /** Root margin for intersection observer */
+    rootMargin?: string;
+    /** Whether to disconnect after first load */
+    once?: boolean;
+    /** Callback when element becomes visible */
+    onLoad?: (entry: IntersectionObserverEntry) => void;
+}
+
+/**
+ * State for optimized lazy loading
+ */
+export declare interface OptimizedLazyState {
+    /** Whether loading is in progress */
+    loading: boolean;
+    /** Whether resource is loaded */
+    loaded: boolean;
+    /** Error if loading failed */
+    error: Error | null;
+    /** Whether element is visible */
+    isVisible: boolean;
+}
+
 /**
  * Pan gesture event data
  */
@@ -1576,6 +1948,43 @@ export declare type PullRefreshHandler = () => Promise<void> | void;
  */
 export declare type PullRefreshState = 'idle' | 'pulling' | 'ready' | 'loading' | 'success' | 'error';
 
+/**
+ * PWA configuration
+ */
+export declare interface PWAConfig {
+    /** Service worker configuration */
+    serviceWorker?: {
+        /** Enable service worker */
+        enabled?: boolean;
+        /** Service worker scope */
+        scope?: string;
+        /** Update strategy */
+        updateStrategy?: 'auto' | 'manual';
+        /** Registration path */
+        path?: string;
+    };
+    /** Cache configuration */
+    cache?: {
+        /** Static resource strategy */
+        static?: 'cache-first' | 'network-first' | 'stale-while-revalidate';
+        /** Dynamic resource strategy */
+        dynamic?: 'network-first' | 'cache-first';
+        /** Maximum age in seconds */
+        maxAge?: number;
+        /** Maximum cache entries */
+        maxSize?: number;
+    };
+    /** Offline support */
+    offline?: {
+        /** Enable offline support */
+        enabled?: boolean;
+        /** Fallback page */
+        fallbackPage?: string;
+        /** Show offline indicator */
+        offlineIndicator?: boolean;
+    };
+}
+
 /**
  * Quick print function
  *
@@ -1637,6 +2046,40 @@ export declare interface RotateGestureEvent {
     isFinal: boolean;
 }
 
+/**
+ * Safe content handler for directives
+ */
+export declare class SafeContentHandler {
+    private config;
+    constructor(config?: XSSProtectionConfig);
+    /**
+     * Sanitize and set HTML content
+     */
+    setHtml(element: HTMLElement, content: string): void;
+    /**
+     * Sanitize and set text content
+     */
+    setText(element: HTMLElement, content: string): void;
+    /**
+     * Set attribute with URL validation
+     */
+    setAttribute(element: HTMLElement, name: string, value: string): void;
+    /**
+     * Get sanitized HTML
+     */
+    getSanitizedHtml(content: string): string;
+}
+
+/**
+ * Advanced HTML sanitizer
+ */
+export declare function sanitizeHtml(html: string, config?: XSSProtectionConfig): string;
+
+/**
+ * Sanitize URL
+ */
+export declare function sanitizeUrl(url: string, allowedProtocols?: string[]): string;
+
 /**
  * Scroll direction
  */
@@ -1664,6 +2107,68 @@ export declare interface ScrollInfo {
     directionY: ScrollDirection;
 }
 
+/**
+ * Security audit utilities
+ */
+export declare const SecurityAudit: {
+    /**
+     * Scan for potential security issues in HTML
+     */
+    scanHtml(html: string): SecurityVulnerability[];
+    /**
+     * Check CSP configuration
+     */
+    checkCSP(): {
+        policies: Record<string, string[]>;
+        warnings: string[];
+        recommendations: string[];
+    };
+    /**
+     * Check for known dependency vulnerabilities (Node.js environment only)
+     * Note: This is a client-side check that uses npm audit API when available.
+     * For production use, run `npm audit` or `pnpm audit` in CI/CD.
+     */
+    checkDependencies(): Promise<DependencyVulnerability[]>;
+    /**
+     * Generate security report
+     */
+    generateReport(html?: string): SecurityReport;
+    /**
+     * Format security report
+     */
+    formatReport(report: SecurityReport, format?: "text" | "json" | "html"): string;
+};
+
+/**
+ * Security scan result
+ */
+export declare interface SecurityReport {
+    /** Found vulnerabilities */
+    vulnerabilities: SecurityVulnerability[];
+    /** Warnings */
+    warnings: SecurityVulnerability[];
+    /** Recommendations */
+    recommendations: string[];
+    /** Scan timestamp */
+    timestamp: Date;
+}
+
+/**
+ * Security vulnerability
+ */
+export declare interface SecurityVulnerability {
+    /** Severity level */
+    severity: 'critical' | 'high' | 'medium' | 'low';
+    /** Issue type */
+    type: string;
+    /** Description */
+    description: string;
+    /** Location */
+    location?: string;
+    /** Remediation suggestion */
+    remediation?: string;
+}
+
 /**
  * Set nested property value by path
  */
@@ -1704,6 +2209,11 @@ export declare type SkeletonAnimation = 'wave' | 'pulse' | 'none';
  */
 export declare function startMeasure(directive: string, phase: 'mount' | 'update' | 'unmount'): string;
 
+/**
+ * Strip all HTML tags
+ */
+export declare function stripHtml(html: string): string;
+
 /**
  * Check if Clipboard API is supported
  */
@@ -1729,6 +2239,18 @@ export declare const supportsPassive: () => boolean;
  */
 export declare const supportsResizeObserver: () => boolean;
 
+/**
+ * Suspense-ready async directive state
+ */
+export declare interface SuspenseDirectiveState<T = any> {
+    /** Loading state */
+    loading: boolean;
+    /** Error state */
+    error: Error | null;
+    /** Data */
+    data: T | null;
+}
+
 /**
  * Swipe direction
  */
@@ -1746,6 +2268,21 @@ export declare type SwipeHandler = (direction: SwipeDirection, event: Event) =>
  */
 export declare function t(key: string, params?: Record<string, any>): string;
 
+/**
+ * Teleport content to target
+ */
+export declare function teleportContent(content: HTMLElement, options: TeleportEnhanceOptions): () => void;
+
+/**
+ * Teleport enhancement options
+ */
+export declare interface TeleportEnhanceOptions {
+    /** Target selector or element */
+    to: string | HTMLElement;
+    /** Whether to teleport content */
+    disabled?: boolean;
+}
+
 /**
  * Simple throttle function wrapper
  *
@@ -1803,6 +2340,20 @@ export declare type TooltipPlacement = 'top' | 'bottom' | 'left' | 'right';
  */
 export declare type TooltipTrigger = 'hover' | 'click' | 'focus' | 'manual';
 
+/**
+ * Touch feedback configuration
+ */
+export declare interface TouchFeedbackConfig {
+    /** Enable haptic feedback */
+    haptic?: boolean;
+    /** Enable visual feedback */
+    visual?: boolean;
+    /** Visual feedback class name */
+    visualClass?: string;
+    /** Visual feedback duration in ms */
+    visualDuration?: number;
+}
+
 /**
  * Touch gesture type
  */
@@ -1825,6 +2376,36 @@ export declare interface TouchGestureEvent {
     event: TouchEvent;
 }
 
+/**
+ * Mobile Optimization Utilities for Directix
+ *
+ * Provides mobile-specific enhancements including:
+ * - Touch gesture optimizations
+ * - Passive event listeners
+ * - Haptic feedback
+ * - Performance optimizations
+ * - PWA support utilities
+ */
+/**
+ * Touch gesture thresholds
+ */
+export declare interface TouchGestureThresholds {
+    /** Tap recognition threshold in pixels */
+    tap?: number;
+    /** Long press time threshold in ms */
+    longPress?: number;
+    /** Swipe distance threshold in pixels */
+    swipe?: number;
+    /** Pinch scale threshold */
+    pinch?: number;
+    /** Rotate angle threshold in degrees */
+    rotate?: number;
+    /** Double tap interval in ms */
+    doubleTap?: number;
+    /** Velocity threshold for swipe in px/s */
+    swipeVelocity?: number;
+}
+
 /**
  * Register a directive for DevTools tracking
  */
@@ -1835,6 +2416,11 @@ export declare function trackDirective(name: string, info?: Partial<DirectiveInf
  */
 export declare function trackPlugin(info: PluginInfo): void;
 
+/**
+ * Trigger haptic feedback
+ */
+export declare function triggerHaptic(type?: 'light' | 'medium' | 'heavy' | 'selection'): void;
+
 /**
  * Trim position
  */
@@ -1868,6 +2454,11 @@ export declare type TruncatePosition = 'start' | 'middle' | 'end';
  */
 export declare function truncateText(text: string, maxLength: number, ellipsis?: string): string;
 
+/**
+ * Unescape HTML entities
+ */
+export declare function unescapeHtml(str: string): string;
+
 /**
  * Unregister a directive from DevTools tracking
  */
@@ -2629,6 +3220,28 @@ export declare interface UseDebounceReturn<T extends (...args: any[]) => any> {
     pending: () => boolean;
 }
 
+/**
+ * Create a directive instance with Vue 3 optimizations
+ * Uses markRaw for DOM elements and reactive/shallowReactive for state
+ */
+export declare function useDirectiveInstance<T extends Record<string, any>>(options?: DirectiveInstanceOptions<T>): UseDirectiveInstanceReturn<T>;
+
+/**
+ * Return type for useDirectiveInstance
+ */
+export declare interface UseDirectiveInstanceReturn<T> {
+    /** The element (marked raw for performance) */
+    element: HTMLElement | null;
+    /** Reactive state */
+    state: Readonly<T>;
+    /** Set element and initialize */
+    setElement: (el: HTMLElement) => void;
+    /** Update state */
+    setState: (updater: (prev: T) => T) => void;
+    /** Reset state */
+    reset: () => void;
+}
+
 /**
  * Composable for making elements draggable
  *
@@ -2854,6 +3467,59 @@ export declare interface UseEmojiReturn {
     bind: (element: HTMLInputElement | HTMLTextAreaElement) => () => void;
 }
 
+/**
+ * Enhanced touch composable with full gesture support
+ */
+export declare function useEnhancedTouch(options?: UseEnhancedTouchOptions): UseEnhancedTouchReturn;
+
+/**
+ * Options for enhanced touch handling
+ */
+export declare interface UseEnhancedTouchOptions {
+    /** Gesture recognition thresholds */
+    thresholds?: TouchGestureThresholds;
+    /** Touch feedback configuration */
+    feedback?: TouchFeedbackConfig;
+    /** Gesture priority order */
+    priority?: ExtendedGestureType[];
+    /** Debounce time between gestures in ms */
+    debounce?: number;
+    /** Throttle time for continuous gestures in ms */
+    throttle?: number;
+    /** Enable passive listeners */
+    passive?: boolean;
+    /** Disable gesture */
+    disabled?: boolean | Ref<boolean>;
+    /** Gesture callbacks */
+    onTap?: (e: ExtendedTouchEvent) => void;
+    onDoubleTap?: (e: ExtendedTouchEvent) => void;
+    onLongPress?: (e: ExtendedTouchEvent) => void;
+    onSwipe?: (e: ExtendedTouchEvent) => void;
+    onSwipeLeft?: (e: ExtendedTouchEvent) => void;
+    onSwipeRight?: (e: ExtendedTouchEvent) => void;
+    onSwipeUp?: (e: ExtendedTouchEvent) => void;
+    onSwipeDown?: (e: ExtendedTouchEvent) => void;
+    onPan?: (e: ExtendedTouchEvent) => void;
+    onPinch?: (e: ExtendedTouchEvent) => void;
+    onPinchIn?: (e: ExtendedTouchEvent) => void;
+    onPinchOut?: (e: ExtendedTouchEvent) => void;
+    onRotate?: (e: ExtendedTouchEvent) => void;
+    onTwoFingerTap?: (e: ExtendedTouchEvent) => void;
+    onEdgeSwipe?: (e: ExtendedTouchEvent) => void;
+}
+
+/**
+ * Return type for useEnhancedTouch
+ */
+export declare interface UseEnhancedTouchReturn {
+    /** Current active gesture */
+    activeGesture: Readonly<Ref<ExtendedGestureType | null>>;
+    /** Bind touch events to element */
+    bind: (element: HTMLElement) => () => void;
+    /** Whether currently touching */
+    isTouching: Readonly<Ref<boolean>>;
+}
+
 /**
  * Composable for exporting data
  *
@@ -3049,6 +3715,23 @@ export declare interface UseFocusReturn {
     bind: (element: HTMLElement) => () => void;
 }
 
+/**
+ * Composable for focus trap
+ */
+export declare function useFocusTrap(container: Ref<HTMLElement | null>, options?: FocusTrapOptions): UseFocusTrapReturn;
+
+/**
+ * Return type for useFocusTrap
+ */
+export declare interface UseFocusTrapReturn {
+    /** Activate focus trap */
+    activate: () => void;
+    /** Deactivate focus trap */
+    deactivate: () => void;
+    /** Whether active */
+    isActive: Readonly<Ref<boolean>>;
+}
+
 /**
  * Composable for fullscreen functionality
  *
@@ -3585,6 +4268,31 @@ export declare interface UseIntersectReturn {
     stop: () => void;
 }
 
+/**
+ * Composable for keyboard navigation
+ */
+export declare function useKeyboardNavigation(options?: KeyboardNavigationConfig): UseKeyboardNavigationReturn;
+
+/**
+ * Return type for useKeyboardNavigation
+ */
+export declare interface UseKeyboardNavigationReturn {
+    /** Current focused index */
+    focusedIndex: Readonly<Ref<number>>;
+    /** Bind keyboard navigation to container */
+    bind: (container: HTMLElement, items: HTMLElement[]) => () => void;
+    /** Focus item at index */
+    focusIndex: (index: number) => void;
+    /** Focus next item */
+    focusNext: () => void;
+    /** Focus previous item */
+    focusPrev: () => void;
+    /** Focus first item */
+    focusFirst: () => void;
+    /** Focus last item */
+    focusLast: () => void;
+}
+
 /**
  * Composable for lazy loading images
  *
@@ -3613,6 +4321,26 @@ export declare interface UseIntersectReturn {
  */
 export declare function useLazy(options?: UseLazyOptions): UseLazyReturn;
 
+/**
+ * Optimized lazy loading using Vue 3's shallowRef for performance
+ * with large state objects
+ */
+export declare function useLazyOptimized(options?: OptimizedLazyOptions): UseLazyOptimizedReturn;
+
+/**
+ * Return type for useLazyOptimized
+ */
+export declare interface UseLazyOptimizedReturn {
+    /** Reactive state */
+    state: Readonly<ShallowRef<OptimizedLazyState>>;
+    /** Start observing element */
+    observe: (el: HTMLElement) => void;
+    /** Stop observing and cleanup */
+    disconnect: () => void;
+    /** Manually trigger load */
+    load: () => void;
+}
+
 /**
  * Options for useLazy composable
  */
@@ -4861,6 +5589,28 @@ export declare interface UsePullRefreshReturn {
     refresh: () => Promise<void>;
 }
 
+export declare function usePWA(config?: PWAConfig): UsePWAReturn;
+
+/**
+ * PWA utilities
+ */
+export declare interface UsePWAReturn {
+    /** Whether online */
+    isOnline: Readonly<Ref<boolean>>;
+    /** Whether registered */
+    isRegistered: Readonly<Ref<boolean>>;
+    /** Whether update available */
+    needsUpdate: Readonly<Ref<boolean>>;
+    /** Register service worker */
+    register: () => Promise<void>;
+    /** Update service worker */
+    update: () => Promise<void>;
+    /** Unregister service worker */
+    unregister: () => Promise<void>;
+    /** Initialize PWA */
+    init: () => () => void;
+}
+
 /**
  * Composable for tracking element resize
  *
@@ -5328,6 +6078,35 @@ export declare interface UseStickyReturn {
     stop: () => void;
 }
 
+/**
+ * Suspense-ready composable for async directives
+ */
+export declare function useSuspenseDirective<T>(options: UseSuspenseDirectiveOptions<T>): UseSuspenseDirectiveReturn<T>;
+
+/**
+ * Options for suspense directive
+ */
+declare interface UseSuspenseDirectiveOptions<T> {
+    /** Async loader function */
+    loader: () => Promise<T>;
+    /** On success callback */
+    onSuccess?: (data: T) => void;
+    /** On error callback */
+    onError?: (error: Error) => void;
+}
+
+/**
+ * Return type for suspense directive
+ */
+export declare interface UseSuspenseDirectiveReturn<T> {
+    /** Reactive state */
+    state: Readonly<ShallowRef<SuspenseDirectiveState<T>>>;
+    /** Trigger load */
+    load: () => Promise<void>;
+    /** Retry on error */
+    retry: () => Promise<void>;
+}
+
 /**
  * Composable for detecting swipe gestures
  *
@@ -7424,6 +8203,23 @@ export declare function warnNotSupported(feature: string): void;
  */
 export declare function warnSSRNotSupported(directive: string): void;
 
+/**
+ * watchEffect that tracks directive bindings
+ */
+export declare function watchEffectBinding(options: WatchEffectBindingOptions): () => void;
+
+/**
+ * Options for watchEffect with element binding
+ */
+export declare interface WatchEffectBindingOptions {
+    /** Binding value to watch */
+    binding: Ref<any>;
+    /** Effect callback */
+    effect: (value: any, oldValue: any, onCleanup: (fn: () => void) => void) => void;
+    /** Whether to run immediately */
+    immediate?: boolean;
+}
+
 /**
  * Create a performance monitor decorator for directives
  */
@@ -7439,6 +8235,39 @@ export declare function withPerformanceMonitoring<T extends Record<string, any>>
  */
 export declare function wouldTextTruncate(text: string, containerWidth: number, fontSize?: number): boolean;
 
+/**
+ * Security Utilities for Directix
+ *
+ * Provides comprehensive security features including:
+ * - XSS protection and sanitization
+ * - CSP (Content Security Policy) compatibility
+ * - Security audit tools
+ * - Safe HTML handling
+ */
+/**
+ * XSS Protection Configuration
+ */
+export declare interface XSSProtectionConfig {
+    /** Allowed HTML tags */
+    allowedTags?: string[];
+    /** Allowed attributes per tag or globally */
+    allowedAttributes?: Record<string, string[]> | string[];
+    /** Allowed URL protocols */
+    allowedProtocols?: string[];
+    /** Allow data URLs */
+    allowDataUrls?: boolean;
+    /** Allow inline styles */
+    allowInlineStyles?: boolean;
+    /** Allow class attribute */
+    allowClass?: boolean;
+    /** Allow id attribute */
+    allowId?: boolean;
+    /** Detect and remove dangerous patterns */
+    detectDangerousPatterns?: boolean;
+    /** Custom filter functions */
+    customFilters?: ((html: string) => string)[];
+}
+
 export declare const zhCN: I18nMessages;
 
 export { }