directix 1.8.0 → 1.10.0

package/dist/index.d.ts

@@ -1,7 +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';
 
 /**
@@ -14,6 +17,145 @@ 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
+ */
+declare function assert_2(condition: boolean, message: string, directive?: string): asserts condition;
+export { assert_2 as assert }
+
+/**
+ * Assert a number is positive
+ */
+export declare function assertPositive(value: number, directive: string, param: string): void;
+
+/**
+ * Assert a number is within range
+ */
+export declare function assertRange(value: number, min: number, max: number, directive: string, param: string): void;
+
+/**
+ * Assert a parameter type
+ */
+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
+ */
+export declare function calculateStats(metrics: PerformanceMetric[]): PerformanceStats;
+
 /**
  * Calculate remaining time
  */
@@ -32,6 +174,26 @@ 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
+ */
+export declare function clearDevtoolsState(): void;
+
+/**
+ * Clear all performance metrics
+ */
+export declare function clearPerformanceMetrics(): void;
+
 /**
  * Click delay handler
  */
@@ -78,6 +240,26 @@ 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
+ */
+export declare function configurePerformance(config: Partial<PerformanceConfig>): void;
+
 /**
  * Configure permission directive
  */
@@ -168,6 +350,55 @@ export declare function createCapitalizer(options?: {
  */
 export declare function createDelayedClick(handler: ClickDelayHandler, delay?: number): (event: MouseEvent | TouchEvent) => void;
 
+/**
+ * Create a directive from a template
+ *
+ * @example
+ * ```ts
+ * const vMyDirective = createDirectiveTemplate({
+ *   name: 'my-directive',
+ *   onMount(el, options) {
+ *     el.style.color = options.color
+ *   },
+ *   onUpdate(el, options) {
+ *     el.style.color = options.color
+ *   },
+ *   onUnmount(el) {
+ *     el.style.color = ''
+ *   },
+ * })
+ * ```
+ */
+export declare function createDirectiveTemplate<T = any, B extends Element = Element>(template: DirectiveTemplateOptions<T, B>): Directive;
+
+/**
+ * Create a simple event-based directive template
+ *
+ * @example
+ * ```ts
+ * const vTrack = createEventDirective({
+ *   name: 'track',
+ *   eventName: 'click',
+ *   handler(el, binding, event) {
+ *     analytics.track(binding.value, { element: el.tagName })
+ *   },
+ * })
+ * ```
+ */
+export declare function createEventDirective(options: {
+    name: string;
+    eventName: string;
+    handler: (el: HTMLElement, binding: any, event: Event) => void;
+    /** Options for addEventListener */
+    listenerOptions?: boolean | AddEventListenerOptions;
+    ssr?: boolean;
+}): Directive;
+
+/**
+ * Create i18n instance
+ */
+export declare function createI18n(options: I18nOptions): I18nInstance;
+
 /**
  * Create a lowercase transformation function
  *
@@ -258,6 +489,34 @@ 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
+ *
+ * @example
+ * ```ts
+ * const vOpacity = createStyleDirective({
+ *   name: 'opacity',
+ *   cssProperty: 'opacity',
+ *   defaultUnit: '',
+ * })
+ * ```
+ */
+export declare function createStyleDirective(options: {
+    name: string;
+    /** CSS property name */
+    cssProperty: string;
+    /** Default unit (e.g., 'px', '%') */
+    defaultUnit?: string;
+    /** Validate value */
+    validate?: (value: any) => boolean;
+    ssr?: boolean;
+}): Directive;
+
 /**
  * Create a trim function with preset options
  *
@@ -337,6 +596,38 @@ 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
+ */
+export declare interface DateFormatOptions {
+    /** Date format pattern */
+    datePattern: string;
+    /** Time format pattern */
+    timePattern: string;
+    /** 12/24 hour format */
+    hourCycle: 'h12' | 'h23' | 'h24';
+    /** First day of week (0=Sunday, 1=Monday) */
+    firstDayOfWeek: number;
+    /** Date separator */
+    dateSeparator: string;
+    /** Time separator */
+    timeSeparator: string;
+}
+
 /**
  * Simple debounce function wrapper
  *
@@ -363,6 +654,11 @@ export declare function debounceFn<T extends (...args: any[]) => any>(fn: T, wai
     trailing?: boolean;
 }): ComposableDebouncedFunction<T>;
 
+/**
+ * Show a debug message (only in development)
+ */
+export declare function debug(message: string, params?: Record<string, any>): void;
+
 /**
  * Deep clone an object
  */
@@ -389,6 +685,46 @@ export declare function defineDirectiveGroup(name: string, directives: Record<st
     install: (app: any) => void;
 };
 
+/**
+ * Define a Directix plugin
+ */
+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
+ */
+export declare function detectLocaleInfo(): LocaleInfo;
+
+/**
+ * DevTools event
+ */
+export declare interface DevtoolsEvent {
+    type: 'directive:mounted' | 'directive:updated' | 'directive:unmounted' | 'plugin:install' | 'plugin:uninstall';
+    name: string;
+    timestamp: number;
+    data?: any;
+}
+
 /**
  * Unified directive binding object
  */
@@ -419,6 +755,23 @@ export declare interface DirectiveDefinition<T = any, B extends Element = Elemen
     defaults?: Partial<T>;
 }
 
+/**
+ * Directive-specific error helper
+ */
+export declare function directiveError(directive: string, message: string, params?: Record<string, any>): void;
+
+/**
+ * Directive extension hook
+ */
+export declare interface DirectiveExtension {
+    /** Target directive name */
+    target: string;
+    /** Hook to extend */
+    hook: 'mounted' | 'updated' | 'unmounted' | 'beforeMount' | 'afterMount';
+    /** Extension handler */
+    handler: (el: any, binding: any, vnode: any, prevVnode?: any) => void | Promise<void>;
+}
+
 /**
  * Unified directive hooks
  */
@@ -448,6 +801,23 @@ export declare interface DirectiveHooks<T = any, B extends Element = Element> {
     unmounted?: (el: B, binding: DirectiveBinding<T>, vnode: VNode) => void;
 }
 
+/**
+ * Vue DevTools Integration
+ *
+ * Provides debugging capabilities for Directix through Vue DevTools.
+ * Shows registered directives, plugins, and performance metrics.
+ */
+/**
+ * Directive info for DevTools
+ */
+export declare interface DirectiveInfo {
+    name: string;
+    element?: string;
+    bindings: number;
+    lastUpdated: number;
+    options?: Record<string, any>;
+}
+
 /**
  * Directive installation options
  */
@@ -460,21 +830,225 @@ 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
+ */
+declare interface DirectiveMessages {
+    description: string;
+    params?: Record<string, string>;
+    errors?: Record<string, string>;
+    warnings?: Record<string, string>;
+}
+
+/**
+ * Directive performance metrics
+ */
+export declare interface DirectivePerformance {
+    /** Directive name */
+    name: string;
+    /** Mount stats */
+    mount: PerformanceStats;
+    /** Update stats */
+    update: PerformanceStats;
+    /** Unmount stats */
+    unmount: PerformanceStats;
+    /** Total time spent */
+    totalTime: number;
+    /** Call count */
+    callCount: number;
+}
+
+/**
+ * Directive template options
+ */
+export declare interface DirectiveTemplateOptions<T = any, B extends Element = Element> {
+    /** Directive name */
+    name: string;
+    /** SSR safe */
+    ssr?: boolean;
+    /** Default options */
+    defaults?: Partial<T>;
+    /** Called when directive is mounted */
+    onMount: (el: B, options: T, binding: any) => void;
+    /** Called when directive is updated */
+    onUpdate?: (el: B, options: T, binding: any) => void;
+    /** Called when directive is unmounted */
+    onUnmount: (el: B, state: Record<string, any>) => void;
+    /** Validate options */
+    validate?: (options: T) => string | null;
+    /** Normalize binding value to options */
+    normalize?: (binding: any) => T;
+}
+
+/**
+ * Directive-specific warning helper
+ */
+export declare function directiveWarn(directive: string, message: string, params?: Record<string, any>): void;
+
 /**
  * Directix plugin
  */
 export declare const Directix: Plugin_2;
 
+/**
+ * Plugin definition
+ */
+export declare interface DirectixPlugin {
+    /** Plugin metadata */
+    meta: PluginMeta;
+    /** Install function - called when plugin is registered */
+    install: (ctx: PluginContext) => void | Promise<void>;
+    /** Uninstall function - called when plugin is removed */
+    uninstall?: (ctx: PluginContext) => void | Promise<void>;
+    /** Plugin dependencies */
+    dependencies?: string[];
+}
+
+/**
+ * Disable DevTools integration
+ */
+export declare function disableDevtools(): void;
+
+/**
+ * Disable performance monitoring
+ */
+export declare function disablePerformance(): void;
+
 /**
  * Draggable axis
  */
 export declare type DraggableAxis = 'x' | 'y' | 'both';
 
+/**
+ * Enable DevTools integration
+ */
+export declare function enableDevtools(): void;
+
+/**
+ * Enable performance monitoring
+ */
+export declare function enablePerformance(): void;
+
+/**
+ * End a performance measurement
+ */
+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;
+
+/**
+ * Show an error message
+ */
+export declare function error(options: WarningOptions): void;
+
+export declare function error(message: string, params?: Record<string, any>): void;
+
+/**
+ * Global error messages
+ */
+declare interface ErrorMessages {
+    invalid_param: string;
+    missing_required: string;
+    type_error: string;
+    value_out_of_range: string;
+    not_supported: string;
+    ssr_not_supported: string;
+}
+
+/**
+ * Escape HTML entities
+ */
+export declare function escapeHtml(str: string): string;
+
 /**
  * Export format type
  */
 export declare type ExportFormat = 'csv' | 'json' | 'txt' | 'html';
 
+/**
+ * Export performance metrics as JSON
+ */
+export declare function exportPerformanceData(): {
+    config: PerformanceConfig;
+    metrics: PerformanceMetric[];
+    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
+ */
+export declare function formatCurrencyLocale(value: number, options?: Partial<NumberFormatOptions>): string;
+
+/**
+ * Format date with locale-specific pattern
+ */
+export declare function formatDateLocale(date: Date | string | number, options?: Partial<DateFormatOptions>): string;
+
 /**
  * Format number to money string
  */
@@ -497,11 +1071,21 @@ export declare function formatNumber(value: number, options?: {
     suffix?: string;
 }): string;
 
+/**
+ * Format number with locale-specific separators
+ */
+export declare function formatNumberLocale(value: number, decimals?: number, options?: Partial<NumberFormatOptions>): string;
+
 /**
  * Format time to string
  */
 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
  */
@@ -512,11 +1096,101 @@ 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)
+ */
+export declare function getDevtoolsState(): {
+    enabled: boolean;
+    directiveCount: number;
+    pluginCount: number;
+    eventCount: number;
+};
+
+/**
+ * Get performance metrics for a specific directive
+ */
+export declare function getDirectiveMetrics(directive: string): PerformanceMetric[];
+
+/**
+ * Get current locale
+ */
+export declare function getLocale(): string;
+
+/**
+ * Get locale display name
+ */
+export declare function getLocaleDisplayName(locale: string, displayLocale?: string): string;
+
+/**
+ * Get most frequently called directives
+ */
+export declare function getMostFrequentDirectives(limit?: number): DirectivePerformance[];
+
+/**
+ * Get region-specific number format
+ */
+export declare function getNumberFormat(region?: string): NumberFormatOptions;
+
+/**
+ * Get all performance metrics
+ */
+export declare function getPerformanceMetrics(): PerformanceMetric[];
+
+/**
+ * Get performance report for all directives
+ */
+export declare function getPerformanceReport(): DirectivePerformance[];
+
 /**
  * Get current configuration
  */
 export declare function getPermissionConfig(): PermissionConfig | null;
 
+/**
+ * Get or create the global plugin manager
+ */
+export declare function getPluginManager(config?: PluginConfig): PluginManager;
+
+/**
+ * Get or create the global plugin registry
+ */
+export declare function getPluginRegistry(registryUrl?: string): PluginRegistry;
+
+/**
+ * Get slowest directives
+ */
+export declare function getSlowestDirectives(limit?: number): DirectivePerformance[];
+
+/**
+ * Get all supported regions
+ */
+export declare function getSupportedRegions(): string[];
+
+/**
+ * Get timezone info
+ */
+export declare function getTimezoneInfo(): TimezoneInfo;
+
 /**
  * Get current Vue version
  */
@@ -556,6 +1230,54 @@ export declare interface HotkeyDefinition {
     disabled?: boolean | Ref<boolean>;
 }
 
+/**
+ * i18n instance type
+ */
+export declare interface I18nInstance {
+    locale: string;
+    fallbackLocale: string;
+    messages: I18nMessages;
+    setLocale: (locale: string) => void;
+    t: (key: string, params?: Record<string, any>) => string;
+}
+
+/**
+ * i18n type definitions
+ */
+/**
+ * Locale messages structure
+ */
+export declare interface I18nMessages {
+    directives: Record<string, DirectiveMessages>;
+    errors: ErrorMessages;
+    warnings: WarningMessages;
+    help: Record<string, string>;
+}
+
+/**
+ * i18n options
+ */
+export declare interface I18nOptions {
+    locale?: string;
+    fallbackLocale?: string;
+    messages: Record<string, I18nMessages>;
+}
+
+/**
+ * Show an info message
+ */
+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
  */
@@ -576,6 +1298,11 @@ export declare function isBoolean(value: unknown): value is boolean;
  */
 export declare const isBrowser: () => boolean;
 
+/**
+ * Check if DevTools is available
+ */
+export declare function isDevtoolsAvailable(): boolean;
+
 /**
  * Check if value is empty
  */
@@ -586,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
  */
@@ -596,6 +1328,11 @@ export declare function isNumber(value: unknown): value is number;
  */
 export declare function isObject(value: unknown): value is Record<string, any>;
 
+/**
+ * Check if performance monitoring is enabled
+ */
+export declare function isPerformanceEnabled(): boolean;
+
 /**
  * Check if value is a Promise
  */
@@ -611,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)
  */
@@ -631,11 +1378,72 @@ export declare function isVue3(): boolean;
  */
 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
  */
 export declare type LazyState = 'pending' | 'loading' | 'loaded' | 'error';
 
+/**
+ * Locale info
+ */
+export declare interface LocaleInfo {
+    /** Locale code (e.g., 'zh-CN') */
+    locale: string;
+    /** Language code (e.g., 'zh') */
+    language: string;
+    /** Region/country code (e.g., 'CN') */
+    region: string | null;
+    /** Script code (e.g., 'Hant') */
+    script: string | null;
+    /** Browser detected locale */
+    browserLocale: string;
+    /** System timezone */
+    timezone: string;
+}
+
+/**
+ * Unified warning/error system for Directix directives
+ *
+ * Provides structured, localized error messages with:
+ * - Directive name context
+ * - Parameter validation messages
+ * - Stack trace in development mode
+ * - Warning levels (debug, info, warn, error)
+ */
+declare type LogLevel = 'debug' | 'info' | 'warn' | 'error';
+
 /**
  * Lottie animation state
  */
@@ -646,11 +1454,87 @@ export declare type LottieAnimationState = 'playing' | 'paused' | 'stopped';
  */
 export declare function lowercaseText(text: string, firstOnly?: boolean): string;
 
+/**
+ * Performance measurement helper
+ * Use this to wrap directive lifecycle methods
+ */
+export declare function measurePerformance<T>(directive: string, phase: 'mount' | 'update' | 'unmount', fn: () => T, metadata?: Record<string, any>): T;
+
+/**
+ * Async performance measurement helper
+ */
+export declare function measurePerformanceAsync<T>(directive: string, phase: 'mount' | 'update' | 'unmount', fn: () => Promise<T>, metadata?: Record<string, any>): Promise<T>;
+
 /**
  * Mutation change handler
  */
 export declare type MutationHandler = (mutations: MutationRecord[], observer: MutationObserver) => void;
 
+/**
+ * Number format options per region
+ */
+export declare interface NumberFormatOptions {
+    /** Decimal separator */
+    decimalSeparator: string;
+    /** Thousands separator */
+    thousandsSeparator: string;
+    /** Currency symbol */
+    currencySymbol: string;
+    /** Currency position ('before' or 'after') */
+    currencyPosition: 'before' | 'after';
+    /** Decimal places for currency */
+    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
  */
@@ -669,6 +1553,15 @@ export declare interface PanEvent {
     velocity: number;
 }
 
+/**
+ * Parse locale string into components
+ */
+export declare function parseLocale(locale: string): {
+    language: string;
+    region: string | null;
+    script: string | null;
+};
+
 /**
  * Parse formatted money string to number
  */
@@ -697,6 +1590,61 @@ export declare function parseTargetTime(target: Date | number | string): number;
  */
 export declare function parseTime(arg?: string): number | null;
 
+/**
+ * Performance configuration
+ */
+export declare interface PerformanceConfig {
+    /** Enable performance monitoring */
+    enabled: boolean;
+    /** Maximum metrics to store */
+    maxMetrics: number;
+    /** Sample rate (0-1) */
+    sampleRate: number;
+    /** Warn threshold in ms */
+    warnThreshold: number;
+}
+
+/**
+ * Performance Monitoring
+ *
+ * Provides performance metrics and monitoring for Directix directives.
+ */
+/**
+ * Performance metric types
+ */
+export declare interface PerformanceMetric {
+    /** Metric name */
+    name: string;
+    /** Directive name */
+    directive: string;
+    /** Duration in milliseconds */
+    duration: number;
+    /** Timestamp */
+    timestamp: number;
+    /** Additional metadata */
+    metadata?: Record<string, any>;
+}
+
+/**
+ * Performance statistics
+ */
+export declare interface PerformanceStats {
+    /** Total calls */
+    totalCalls: number;
+    /** Average duration */
+    averageDuration: number;
+    /** Min duration */
+    minDuration: number;
+    /** Max duration */
+    maxDuration: number;
+    /** P50 (median) */
+    p50: number;
+    /** P95 */
+    p95: number;
+    /** P99 */
+    p99: number;
+}
+
 /**
  * Permission configuration
  */
@@ -710,22 +1658,266 @@ declare interface PermissionConfig {
 }
 
 /**
- * Permission check mode
+ * Permission check mode
+ */
+export declare type PermissionMode = 'some' | 'every';
+
+/**
+ * Pinch gesture event data
+ */
+export declare interface PinchEvent {
+    scale: number;
+    distance: number;
+    initialDistance: number;
+    centerX: number;
+    centerY: number;
+    isPinching: boolean;
+    isFirst: boolean;
+    isFinal: boolean;
+}
+
+/**
+ * Plugin category
+ */
+export declare type PluginCategory = 'event' | 'visibility' | 'scroll' | 'form' | 'ui' | 'security' | 'observer' | 'gesture' | 'other';
+
+/**
+ * Plugin configuration
+ */
+export declare interface PluginConfig {
+    /** Enable debug mode */
+    debug?: boolean;
+    /** Plugin registry URL */
+    registryUrl?: string;
+    /** Auto-load official plugins */
+    autoLoadOfficial?: boolean;
+}
+
+/**
+ * Plugin context - provides utilities for plugins
+ */
+export declare interface PluginContext {
+    /** Vue app instance */
+    app: App;
+    /** Register a directive */
+    registerDirective: (name: string, directive: Directive) => void;
+    /** Register a composable */
+    registerComposable: (name: string, composable: any) => void;
+    /** Get an existing directive */
+    getDirective: (name: string) => Directive | undefined;
+    /** Show a warning */
+    warn: (message: string) => void;
+    /** Show an error */
+    error: (message: string) => void;
+    /** Plugin metadata */
+    meta: PluginMeta;
+}
+
+/**
+ * Plugin hook types
+ */
+export declare type PluginHook = 'beforeInstall' | 'afterInstall' | 'beforeUninstall' | 'afterUninstall';
+
+/**
+ * Plugin hook callback
+ */
+export declare type PluginHookCallback = (plugin: DirectixPlugin, ctx: PluginContext) => void | Promise<void>;
+
+/**
+ * Plugin info for DevTools
+ */
+export declare interface PluginInfo {
+    name: string;
+    version: string;
+    description?: string;
+    enabled: boolean;
+    registeredAt: number;
+}
+
+/**
+ * Plugin manager class
+ */
+export declare class PluginManager {
+    private plugins;
+    private hooks;
+    private directives;
+    private composables;
+    private extensions;
+    private app;
+    private config;
+    constructor(config?: PluginConfig);
+    /**
+     * Get the plugin registry instance
+     */
+    getRegistry(): PluginRegistry;
+    /**
+     * Set the Vue app instance
+     */
+    setApp(app: App): void;
+    /**
+     * Register a plugin
+     */
+    register(plugin: DirectixPlugin): Promise<void>;
+    /**
+     * Unregister a plugin
+     */
+    unregister(name: string): Promise<void>;
+    /**
+     * Check if a plugin is registered
+     */
+    has(name: string): boolean;
+    /**
+     * Get a registered plugin
+     */
+    get(name: string): DirectixPlugin | undefined;
+    /**
+     * Get all registered plugins
+     */
+    getAll(): DirectixPlugin[];
+    /**
+     * Register a hook
+     */
+    onHook(hook: PluginHook, callback: PluginHookCallback): void;
+    /**
+     * Remove a hook
+     */
+    offHook(hook: PluginHook, callback: PluginHookCallback): void;
+    /**
+     * Register a directive extension
+     */
+    extendDirective(extension: DirectiveExtension): void;
+    /**
+     * Get extensions for a directive
+     */
+    getExtensions(directiveName: string): DirectiveExtension[];
+    /**
+     * Get a registered directive
+     */
+    getDirective(name: string): Directive | undefined;
+    /**
+     * Get a registered composable
+     */
+    getComposable(name: string): any;
+    /**
+     * Create plugin context
+     */
+    private createContext;
+    /**
+     * Fire hooks
+     */
+    private fireHooks;
+}
+
+/**
+ * Plugin metadata
+ */
+export declare interface PluginMeta {
+    /** Plugin name */
+    name: string;
+    /** Plugin version */
+    version: string;
+    /** Plugin description */
+    description?: string;
+    /** Author name */
+    author?: string;
+    /** License */
+    license?: string;
+    /** Repository URL */
+    repository?: string;
+    /** Keywords for discovery */
+    keywords?: string[];
+}
+
+/**
+ * Plugin registry class
+ */
+export declare class PluginRegistry {
+    private registryUrl;
+    private cache;
+    private cacheTime;
+    private cacheTTL;
+    constructor(registryUrl?: string);
+    /**
+     * Fetch plugin registry data
+     */
+    private fetchData;
+    /**
+     * Set registry data directly (useful for testing or local development)
+     */
+    setData(data: PluginRegistryData): void;
+    /**
+     * Get all plugins from the registry
+     */
+    getAll(): Promise<PluginRegistryEntry[]>;
+    /**
+     * Get a plugin by name
+     */
+    getByName(name: string): Promise<PluginRegistryEntry | undefined>;
+    /**
+     * Search plugins by query
+     */
+    search(query: string): Promise<PluginRegistryEntry[]>;
+    /**
+     * Get plugins by category
+     */
+    getByCategory(category: PluginCategory): Promise<PluginRegistryEntry[]>;
+    /**
+     * Get registry metadata
+     */
+    getMeta(): Promise<{
+        version: number;
+        updated: string;
+        count: number;
+    }>;
+    /**
+     * Install a plugin from the registry
+     *
+     * Note: This is a helper for programmatic installation.
+     * For production use, install the package with your package manager first.
+     */
+    install(name: string, manager: PluginManager): Promise<void>;
+}
+
+/**
+ * Plugin registry data structure
  */
-export declare type PermissionMode = 'some' | 'every';
+export declare interface PluginRegistryData {
+    /** Registry version */
+    version: number;
+    /** Last updated date */
+    updated: string;
+    /** Plugin list */
+    plugins: PluginRegistryEntry[];
+}
 
 /**
- * Pinch gesture event data
+ * Plugin registry entry
  */
-export declare interface PinchEvent {
-    scale: number;
-    distance: number;
-    initialDistance: number;
-    centerX: number;
-    centerY: number;
-    isPinching: boolean;
-    isFirst: boolean;
-    isFinal: boolean;
+export declare interface PluginRegistryEntry {
+    /** Plugin name */
+    name: string;
+    /** Plugin version */
+    version: string;
+    /** Plugin description */
+    description: string;
+    /** NPM package name */
+    package: string;
+    /** Author */
+    author: string;
+    /** Keywords */
+    keywords: string[];
+    /** Category */
+    category?: PluginCategory;
+    /** Download count */
+    downloads?: number;
+    /** GitHub stars */
+    stars?: number;
+    /** Repository URL */
+    repository?: string;
+    /** Homepage URL */
+    homepage?: string;
+    /** License */
+    license?: string;
 }
 
 /**
@@ -756,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
  *
@@ -776,6 +2005,16 @@ export declare type PullRefreshState = 'idle' | 'pulling' | 'ready' | 'loading'
  */
 export declare function quickPrint(target: string | HTMLElement, options?: UsePrintOptions): Promise<void>;
 
+/**
+ * Reset the global plugin manager
+ */
+export declare function resetPluginManager(): void;
+
+/**
+ * Reset the global plugin registry
+ */
+export declare function resetPluginRegistry(): void;
+
 /**
  * Reset Vue version (useful for testing)
  */
@@ -807,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
  */
@@ -834,21 +2107,113 @@ 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
  */
 export declare function set(obj: Record<string, any>, path: string, value: any): void;
 
+/**
+ * Set current locale
+ */
+export declare function setLocale(locale: string): void;
+
 /**
  * Set Vue version explicitly (for cases where auto-detection fails)
  */
 export declare function setVueVersion(version: VueVersion): void;
 
+/**
+ * Set development mode
+ */
+export declare function setWarningDevMode(dev: boolean): void;
+
+/**
+ * Set i18n translation function
+ */
+export declare function setWarningI18n(t: (key: string, params?: Record<string, any>) => string): void;
+
+/**
+ * Set global log level
+ */
+export declare function setWarningLevel(level: LogLevel): void;
+
 /**
  * Skeleton animation type
  */
 export declare type SkeletonAnimation = 'wave' | 'pulse' | 'none';
 
+/**
+ * Start a performance measurement
+ */
+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
  */
@@ -874,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
  */
@@ -884,6 +2261,28 @@ export declare type SwipeDirection = 'left' | 'right' | 'up' | 'down';
  */
 export declare type SwipeHandler = (direction: SwipeDirection, event: Event) => void;
 
+/**
+ * Translate a message key
+ * @param key - Dot-notation key like 'directives.debounce.invalid_wait'
+ * @param params - Interpolation parameters
+ */
+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
  *
@@ -910,6 +2309,27 @@ export declare function throttleFn<T extends (...args: any[]) => any>(fn: T, wai
     trailing?: boolean;
 }): ComposableThrottledFunction<T>;
 
+/**
+ * Timezone and locale utilities
+ *
+ * Provides timezone-aware formatting and locale detection for Directix.
+ */
+/**
+ * Timezone info
+ */
+export declare interface TimezoneInfo {
+    /** Timezone identifier (e.g., 'Asia/Shanghai') */
+    id: string;
+    /** UTC offset in hours */
+    offset: number;
+    /** Offset string (e.g., '+08:00') */
+    offsetString: string;
+    /** Whether DST is active */
+    isDST: boolean;
+    /** Locale timezone name */
+    name: string;
+}
+
 /**
  * Tooltip placement
  */
@@ -920,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
  */
@@ -942,6 +2376,51 @@ 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
+ */
+export declare function trackDirective(name: string, info?: Partial<DirectiveInfo>): void;
+
+/**
+ * Register a plugin for DevTools tracking
+ */
+export declare function trackPlugin(info: PluginInfo): void;
+
+/**
+ * Trigger haptic feedback
+ */
+export declare function triggerHaptic(type?: 'light' | 'medium' | 'heavy' | 'selection'): void;
+
 /**
  * Trim position
  */
@@ -975,6 +2454,21 @@ 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
+ */
+export declare function untrackDirective(name: string): void;
+
+/**
+ * Unregister a plugin from DevTools tracking
+ */
+export declare function untrackPlugin(name: string): void;
+
 /**
  * Transform text to uppercase
  */
@@ -1726,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
  *
@@ -1951,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
  *
@@ -2146,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
  *
@@ -2682,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
  *
@@ -2710,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
  */
@@ -3958,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
  *
@@ -4425,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
  *
@@ -6466,6 +8148,83 @@ export declare const vVisible: Directive;
  */
 export declare const vWatermark: Directive;
 
+/**
+ * Show a warning message
+ */
+export declare function warn(options: WarningOptions): void;
+
+export declare function warn(message: string, params?: Record<string, any>): void;
+
+/**
+ * Deprecation warning
+ */
+export declare function warnDeprecated(feature: string, alternative: string): void;
+
+/**
+ * Global warning messages
+ */
+declare interface WarningMessages {
+    deprecated: string;
+    experimental: string;
+    performance: string;
+    fallback: string;
+}
+
+declare interface WarningOptions {
+    /** Directive name */
+    directive?: string;
+    /** Message key or raw message */
+    message: string;
+    /** Additional context parameters */
+    params?: Record<string, any>;
+    /** Log level */
+    level?: LogLevel;
+    /** Stack trace (only in development) */
+    stack?: boolean;
+}
+
+/**
+ * Parameter validation warning
+ */
+export declare function warnInvalidParam(directive: string, param: string, value: any, expected: string): void;
+
+/**
+ * Missing parameter warning
+ */
+export declare function warnMissingParam(directive: string, param: string): void;
+
+/**
+ * Feature not supported warning
+ */
+export declare function warnNotSupported(feature: string): void;
+
+/**
+ * SSR not supported warning
+ */
+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
+ */
+export declare function withPerformanceMonitoring<T extends Record<string, any>>(directiveName: string, directive: T): T;
+
 /**
  * Utility function to check if text would be truncated in a container
  *
@@ -6476,4 +8235,39 @@ export declare const vWatermark: Directive;
  */
 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 { }