directix 1.10.0 → 2.0.0

package/dist/index.d.ts

@@ -7,6 +7,11 @@ import { Ref } from 'vue';
 import { ShallowRef } from 'vue';
 import { VNode } from 'vue';
 
+/**
+ * Acknowledge alert
+ */
+export declare function acknowledgeAlert(alertId: string, acknowledgedBy: string): boolean;
+
 /**
  * Add cleanup function to element
  */
@@ -17,6 +22,11 @@ export declare function addCleanupVue2(el: Element, fn: () => void): void;
  */
 export declare function addCleanupVue3(el: Element, fn: () => void): void;
 
+/**
+ * Add health check
+ */
+export declare function addHealthCheck(check: HealthCheck): void;
+
 /**
  * Add non-passive event listener (for events that need preventDefault)
  */
@@ -27,6 +37,49 @@ export declare function addNonPassiveListener(element: EventTarget, event: strin
  */
 export declare function addPassiveListener(element: EventTarget, event: string, handler: EventListener, options?: AddEventListenerOptions): () => void;
 
+export declare interface Alert {
+    id: string;
+    ruleId: string;
+    name: string;
+    severity: AlertSeverity;
+    status: AlertStatus;
+    message: string;
+    labels: Record<string, string>;
+    value: number;
+    threshold: number;
+    startedAt: number;
+    resolvedAt?: number;
+    acknowledgedAt?: number;
+    acknowledgedBy?: string;
+}
+
+export declare interface AlertChannel {
+    type: 'webhook' | 'email' | 'slack' | 'pagerduty' | 'custom';
+    name: string;
+    config: Record<string, any>;
+    severity: AlertSeverity[];
+}
+
+export declare interface AlertRule {
+    id: string;
+    name: string;
+    description: string;
+    condition: string;
+    severity: AlertSeverity;
+    duration: number;
+    labels: Record<string, string>;
+    annotations: Record<string, string>;
+    enabled: boolean;
+}
+
+/**
+ * Monitoring and Alerting Integration Module for Directix
+ * Provides real-time monitoring, metrics collection, and alerting capabilities
+ */
+export declare type AlertSeverity = 'info' | 'warning' | 'error' | 'critical';
+
+export declare type AlertStatus = 'active' | 'resolved' | 'acknowledged';
+
 /**
  * Announce a message to screen readers
  */
@@ -49,6 +102,23 @@ export declare interface AnnounceOptions {
  */
 export declare function applyAriaAttributes(el: HTMLElement, config: ARIAConfig): void;
 
+/**
+ * Apply a Vue directive to a custom element
+ *
+ * @example
+ * ```ts
+ * import { vLazy } from 'directix'
+ * import { applyDirectiveToCustomElement } from 'directix/web-components'
+ *
+ * const myElement = document.querySelector('my-component')
+ * applyDirectiveToCustomElement(myElement, vLazy, { threshold: 0.5 })
+ * ```
+ */
+export declare function applyDirectiveToCustomElement<T = any>(el: Element, directive: Directive, value?: T, options?: {
+    arg?: string;
+    modifiers?: Record<string, boolean>;
+}): () => void;
+
 /**
  * ARIA attribute configuration
  */
@@ -135,6 +205,105 @@ 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 }
 
+/**
+ * Convenience logging methods
+ */
+export declare const audit: {
+    debug: (type: AuditEventType, message: string, details?: Record<string, unknown>, context?: Partial<AuditContext>) => AuditLogEntry | null;
+    info: (type: AuditEventType, message: string, details?: Record<string, unknown>, context?: Partial<AuditContext>) => AuditLogEntry | null;
+    warn: (type: AuditEventType, message: string, details?: Record<string, unknown>, context?: Partial<AuditContext>) => AuditLogEntry | null;
+    error: (type: AuditEventType, message: string, details?: Record<string, unknown>, context?: Partial<AuditContext>) => AuditLogEntry | null;
+    critical: (type: AuditEventType, message: string, details?: Record<string, unknown>, context?: Partial<AuditContext>) => AuditLogEntry | null;
+};
+
+export declare interface AuditContext {
+    directive?: string;
+    component?: string;
+    file?: string;
+    line?: number;
+    userAgent?: string;
+    url?: string;
+    sessionId?: string;
+    userId?: string;
+    environment?: string;
+    version?: string;
+    [key: string]: unknown;
+}
+
+export declare type AuditEventType = 'directive.mount' | 'directive.update' | 'directive.unmount' | 'permission.check' | 'permission.grant' | 'permission.deny' | 'security.violation' | 'performance.slow' | 'compatibility.warning' | 'migration.detected' | 'config.change' | 'error.caught' | 'user.action';
+
+export declare interface AuditLogConfig {
+    enabled: boolean;
+    level: AuditLogLevel;
+    maxEntries: number;
+    persistToStorage: boolean;
+    storageKey: string;
+    consoleOutput: boolean;
+    consoleLevel: AuditLogLevel;
+    includeStackTrace: boolean;
+    sampleRate: number;
+    filters: {
+        excludeTypes?: AuditEventType[];
+        excludeLevels?: AuditLogLevel[];
+        minDuration?: number;
+    };
+    handlers: {
+        onLog?: (entry: AuditLogEntry) => void;
+        onError?: (entry: AuditLogEntry) => void;
+        onCritical?: (entry: AuditLogEntry) => void;
+    };
+    sensitiveFields: string[];
+    maskSensitive: boolean;
+}
+
+export declare interface AuditLogEntry {
+    id: string;
+    timestamp: number;
+    level: AuditLogLevel;
+    type: AuditEventType;
+    message: string;
+    details: Record<string, unknown>;
+    context: AuditContext;
+    duration?: number;
+    stackTrace?: string;
+}
+
+export declare interface AuditLogExportOptions {
+    format: 'json' | 'csv' | 'markdown' | 'html';
+    includeDetails: boolean;
+    includeContext: boolean;
+    dateFormat: 'iso' | 'unix' | 'locale';
+}
+
+export declare interface AuditLogFilter {
+    level?: AuditLogLevel | AuditLogLevel[];
+    type?: AuditEventType | AuditEventType[];
+    since?: number;
+    until?: number;
+    directive?: string | string[];
+    component?: string | string[];
+    limit?: number;
+    offset?: number;
+}
+
+/**
+ * Comprehensive Audit Logging System for Directix
+ * Provides detailed logging for directive operations, permission checks, and security events
+ */
+export declare type AuditLogLevel = 'debug' | 'info' | 'warn' | 'error' | 'critical';
+
+export declare interface AuditLogStats {
+    totalEntries: number;
+    byLevel: Record<AuditLogLevel, number>;
+    byType: Record<AuditEventType, number>;
+    byDirective: Record<string, number>;
+    avgDuration: number;
+    errorRate: number;
+    criticalCount: number;
+    last24Hours: number;
+    lastHour: number;
+}
+
 /**
  * Auto-generate ARIA attributes based on directive type
  */
@@ -151,6 +320,214 @@ export declare interface AutoAriaOptions {
     relatedId?: string;
 }
 
+/**
+ * Simple benchmark decorator
+ */
+export declare function benchmark(name?: string): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
+
+export declare interface BenchmarkComparison {
+    baseline: BenchmarkResult;
+    current: BenchmarkResult;
+    improvement: number;
+    significant: boolean;
+    regression: boolean;
+}
+
+/**
+ * Performance Benchmark Module for Directix
+ * Provides utilities for measuring and comparing directive performance
+ */
+export declare interface BenchmarkConfig {
+    iterations: number;
+    warmupIterations: number;
+    samples: number;
+    timeout: number;
+    gc: boolean;
+    verbose: boolean;
+}
+
+export declare type BenchmarkFunction = () => void | Promise<void>;
+
+export declare interface BenchmarkResult {
+    name: string;
+    iterations: number;
+    samples: number;
+    mean: number;
+    median: number;
+    min: number;
+    max: number;
+    stdDev: number;
+    percentiles: {
+        p50: number;
+        p75: number;
+        p90: number;
+        p95: number;
+        p99: number;
+    };
+    opsPerSecond: number;
+    marginOfError: number;
+    timestamp: number;
+}
+
+export declare interface BenchmarkSuite {
+    name: string;
+    benchmarks: BenchmarkResult[];
+    summary: {
+        totalTime: number;
+        averageTime: number;
+        fastest: string;
+        slowest: string;
+    };
+    timestamp: number;
+}
+
+export declare const BREAKING_CHANGES_REGISTRY: BreakingChangeDefinition[];
+
+/**
+ * Breaking change information
+ */
+export declare interface BreakingChange {
+    type: 'api' | 'behavior' | 'signature' | 'option';
+    name: string;
+    location: string;
+    line: number;
+    description: string;
+    migration: string;
+}
+
+export declare type BreakingChangeCategory = 'api' | 'behavior' | 'config' | 'type' | 'directive';
+
+export declare interface BreakingChangeDefinition {
+    id: string;
+    version: string;
+    description: string;
+    severity: ChangeSeverity;
+    status: ChangeStatus;
+    category: BreakingChangeCategory;
+    affectedAPIs: string[];
+    migrationGuide: string;
+    detectionPattern?: RegExp;
+    autoFixable: boolean;
+    deprecatedIn?: string;
+    removedIn?: string;
+    alternatives?: string[];
+    examples?: {
+        before: string;
+        after: string;
+    };
+}
+
+export declare interface BreakingChangeDetection {
+    changeId: string;
+    location: {
+        file?: string;
+        line?: number;
+        column?: number;
+        snippet?: string;
+    };
+    matchedPattern: string;
+    severity: ChangeSeverity;
+    suggestion: string;
+}
+
+export declare interface BreakingChangesConfig {
+    enabled: boolean;
+    targetVersion: string;
+    warnLevel: 'none' | 'low' | 'medium' | 'high' | 'all';
+    consoleOutput: boolean;
+    throwOnCritical: boolean;
+    customHandlers: {
+        onDetected?: (detection: BreakingChangeDetection) => void;
+        onWarning?: (change: BreakingChangeDefinition) => void;
+        onCritical?: (change: BreakingChangeDefinition) => void;
+    };
+}
+
+export declare interface BreakingChangesReport {
+    targetVersion: string;
+    generatedAt: number;
+    totalChanges: number;
+    bySeverity: Record<ChangeSeverity, number>;
+    byCategory: Record<BreakingChangeCategory, number>;
+    byStatus: Record<ChangeStatus, number>;
+    changes: BreakingChangeDefinition[];
+    detections: BreakingChangeDetection[];
+    readyForMigration: boolean;
+    migrationEffort: 'low' | 'medium' | 'high' | 'critical';
+    recommendations: string[];
+}
+
+export declare const BROWSER_TARGETS: MatrixBrowserTarget[];
+
+/**
+ * Compatibility configuration
+ */
+export declare interface BrowserCompatibilityConfig {
+    targets: BrowserTarget;
+    fallback: FallbackConfig;
+    polyfill: PolyfillStrategy;
+    warnOnUnsupported: boolean;
+    strictMode: boolean;
+}
+
+/**
+ * Browser feature support status
+ */
+export declare interface BrowserFeatures {
+    passive: boolean;
+    intersectionObserver: boolean;
+    resizeObserver: boolean;
+    mutationObserver: boolean;
+    clipboard: boolean;
+    clipboardItem: boolean;
+    clipboardWrite: boolean;
+    clipboardRead: boolean;
+    pointerEvents: boolean;
+    touchEvents: boolean;
+    webAnimations: boolean;
+    customElements: boolean;
+    shadowDom: boolean;
+    cssVariables: boolean;
+    cssGrid: boolean;
+    cssFlexbox: boolean;
+    es2020: boolean;
+    es2021: boolean;
+    es2022: boolean;
+}
+
+/**
+ * Browser version info
+ */
+export declare interface BrowserInfo {
+    type: BrowserType;
+    version: string;
+    major: number;
+    platform: PlatformType;
+    os: string;
+    supportLevel: SupportLevel;
+    features: BrowserFeatures;
+}
+
+/**
+ * Browser target configuration
+ */
+export declare interface BrowserTarget {
+    chrome?: string;
+    firefox?: string;
+    safari?: string;
+    edge?: string;
+    samsung?: string;
+}
+
+/**
+ * Browser compatibility module for Directix
+ * Provides browser detection, polyfill management, and fallback strategies
+ */
+/**
+ * Browser type
+ */
+declare type BrowserType = 'chrome' | 'firefox' | 'safari' | 'edge' | 'opera' | 'samsung' | 'uc' | 'wechat' | 'unknown';
+
 /**
  * Calculate statistics from metrics
  */
@@ -161,6 +538,17 @@ export declare function calculateStats(metrics: PerformanceMetric[]): Performanc
  */
 export declare function calculateTime(remaining: number): CountdownTime;
 
+/**
+ * Calculate Time to Interactive estimate
+ */
+export declare function calculateTTI(): number | undefined;
+
+/**
+ * Cancel idle callback
+ */
+declare function cancelIdleCallback_2(id: number): void;
+export { cancelIdleCallback_2 as cancelIdleCallback }
+
 /**
  * Capitalize text based on options
  */
@@ -174,6 +562,34 @@ export declare function capitalizeText(text: string, options?: {
  */
 export declare function capitalizeWord(word: string): string;
 
+/**
+ * Breaking Changes Warning System for Directix
+ * Provides early warning for upcoming breaking changes in future versions
+ */
+export declare type ChangeSeverity = 'low' | 'medium' | 'high' | 'critical';
+
+export declare type ChangeStatus = 'planned' | 'deprecated' | 'removed';
+
+/**
+ * Check API usage and warn if affected
+ */
+export declare function checkAPIUsage(apiName: string): void;
+
+/**
+ * Check dependency availability
+ */
+export declare function checkDependency(name: string, globalPath?: string): boolean;
+
+/**
+ * Cleanup
+ */
+export declare function cleanupFirstScreenOptimizer(): void;
+
+/**
+ * Clear alerts
+ */
+export declare function clearAlerts(): void;
+
 /**
  * Clear the announcer
  */
@@ -184,16 +600,41 @@ export declare function clearAnnouncer(): void;
  */
 export declare function clearAriaAttributes(el: HTMLElement): void;
 
+/**
+ * Clear audit logs
+ */
+export declare function clearAuditLogs(): void;
+
+/**
+ * Clear stored results
+ */
+export declare function clearBenchmarkResults(): void;
+
 /**
  * Clear DevTools state
  */
 export declare function clearDevtoolsState(): void;
 
+/**
+ * Clear warnings
+ */
+export declare function clearEdgeCaseWarnings(): void;
+
 /**
  * Clear all performance metrics
  */
 export declare function clearPerformanceMetrics(): void;
 
+/**
+ * Clear warned changes cache
+ */
+export declare function clearWarnedChanges(): void;
+
+/**
+ * Clear warned features cache
+ */
+export declare function clearWarnedFeatures(): void;
+
 /**
  * Click delay handler
  */
@@ -204,6 +645,56 @@ export declare type ClickDelayHandler = (event: MouseEvent | TouchEvent) => void
  */
 export declare type ClickOutsideHandler = (event: MouseEvent | TouchEvent) => void;
 
+/**
+ * Code change information
+ */
+export declare interface CodeChange {
+    type: 'replace' | 'insert' | 'delete';
+    location: string;
+    line: number;
+    original: string;
+    new: string;
+    description: string;
+}
+
+/**
+ * Compare two benchmark results
+ */
+export declare function compareBenchmarks(baseline: BenchmarkResult, current: BenchmarkResult, threshold?: number): BenchmarkComparison;
+
+/**
+ * Compare performance snapshots
+ */
+export declare function compareSnapshots(before: PerformanceSnapshot, after: PerformanceSnapshot): {
+    memoryDiff?: {
+        usedJSHeapSize: number;
+        totalJSHeapSize: number;
+    };
+    timeDiff: number;
+};
+
+/**
+ * Version comparison utility
+ */
+export declare function compareVersions(a: string, b: string): -1 | 0 | 1;
+
+export declare interface CompatibilityMatrix {
+    browsers: MatrixBrowserTarget[];
+    features: Record<string, FeatureMatrix>;
+    mobileDevices: MobileDevice[];
+}
+
+/**
+ * Compatibility report
+ */
+export declare interface CompatibilityReport {
+    browser: BrowserInfo;
+    config: BrowserCompatibilityConfig;
+    unsupportedFeatures: (keyof BrowserFeatures)[];
+    warnings: string[];
+    recommendations: string[];
+}
+
 /**
  * Debounced function type for composables
  */
@@ -240,6 +731,37 @@ export declare interface ComposableThrottledFunction<T extends (...args: any[])
     cancel: () => void;
 }
 
+/**
+ * Cache for computed results with dependency tracking
+ */
+export declare class ComputedCache<K, V> {
+    private cache;
+    private maxSize;
+    private computeFunction;
+    private ttl;
+    constructor(computeFunction: (key: K, ...deps: any[]) => V, maxSize?: number, ttl?: number);
+    /**
+     * Get or compute cached value
+     */
+    get(key: K, dependencies: any[]): V;
+    /**
+     * Compare dependencies
+     */
+    private compareDependencies;
+    /**
+     * Invalidate specific key
+     */
+    invalidate(key: K): void;
+    /**
+     * Clear all cache
+     */
+    clear(): void;
+    /**
+     * Get cache size
+     */
+    size(): number;
+}
+
 /**
  * Computed ref with automatic cleanup
  */
@@ -255,60 +777,193 @@ export declare interface ComputedWithCleanupOptions<T> {
     cleanup?: (value: T) => void;
 }
 
+export declare interface ConfigCenterConfig {
+    sources: ConfigSource[];
+    mergeStrategy: 'override' | 'merge' | 'deepMerge';
+    cache: {
+        enabled: boolean;
+        ttl: number;
+        key: string;
+    };
+    sync: {
+        enabled: boolean;
+        broadcastChannel?: string;
+        onUpdate?: (key: string, value: any) => void;
+    };
+    validation: {
+        enabled: boolean;
+        schema?: Record<string, ConfigSchema>;
+    };
+    encryption: {
+        enabled: boolean;
+        algorithm: 'AES' | 'none';
+        key?: string;
+    };
+}
+
+export declare interface ConfigChangeEvent {
+    key: string;
+    oldValue: any;
+    newValue: any;
+    source: string;
+    timestamp: number;
+}
+
+export declare interface ConfigSchema {
+    type: 'string' | 'number' | 'boolean' | 'object' | 'array';
+    required?: boolean;
+    default?: any;
+    enum?: any[];
+    min?: number;
+    max?: number;
+    pattern?: string;
+    validator?: (value: any) => boolean;
+}
+
+export declare interface ConfigSnapshot {
+    version: string;
+    config: Record<string, any>;
+    timestamp: number;
+    source: string;
+    hash: string;
+}
+
+export declare interface ConfigSource {
+    type: ConfigSourceType;
+    priority: number;
+    api?: {
+        url: string;
+        method: 'GET' | 'POST';
+        headers?: Record<string, string>;
+        refreshInterval?: number;
+        timeout?: number;
+    };
+    storage?: {
+        key: string;
+        encrypt?: boolean;
+    };
+    static?: Record<string, any>;
+}
+
 /**
- * Configure performance monitoring
+ * Configuration Center Integration Module for Directix
+ * Provides centralized configuration management with remote sync support
  */
-export declare function configurePerformance(config: Partial<PerformanceConfig>): void;
+export declare type ConfigSourceType = 'static' | 'api' | 'localStorage' | 'sessionStorage' | 'remote';
 
 /**
- * Configure permission directive
+ * Configure audit logging
  */
-export declare function configurePermission(config: PermissionConfig): void;
+export declare function configureAuditLog(config: Partial<AuditLogConfig>): void;
 
 /**
- * Context menu item
+ * Configure benchmark
  */
-export declare interface ContextMenuItem {
-    label: string;
-    handler?: () => void;
-    disabled?: boolean;
-    divider?: boolean;
-    icon?: string;
-    class?: string;
-}
+export declare function configureBenchmark(config: Partial<BenchmarkConfig>): void;
 
 /**
- * Countdown complete callback
+ * Configure breaking changes warning system
  */
-export declare type CountdownCompleteCallback = () => void;
+export declare function configureBreakingChanges(config: Partial<BreakingChangesConfig>): void;
 
 /**
- * Countdown format function
+ * Configure browser compatibility settings
  */
-export declare type CountdownFormatFunction = (time: CountdownTime) => string;
+export declare function configureCompatibility(config: Partial<BrowserCompatibilityConfig>): void;
 
 /**
- * Countdown tick callback
+ * Configure configuration center
  */
-export declare type CountdownTickCallback = (time: CountdownTime) => void;
+export declare function configureConfigCenter(config: Partial<ConfigCenterConfig>): void;
 
 /**
- * Countdown time object
+ * Configure edge case handler
  */
-export declare interface CountdownTime {
-    days: number;
-    hours: number;
-    minutes: number;
-    seconds: number;
-    milliseconds: number;
-    total: number;
-}
+export declare function configureEdgeCase(config: Partial<EdgeCaseConfig>): void;
+
+/**
+ * Configure global permission manager
+ */
+export declare function configureEnterprisePermission(config: Partial<EnterprisePermissionConfig>): EnterprisePermissionManager;
+
+/**
+ * Configure first screen optimization
+ */
+export declare function configureFirstScreen(config: Partial<FirstScreenConfig>): void;
+
+/**
+ * Configure monitoring
+ */
+export declare function configureMonitoring(config: Partial<MonitoringConfig>): void;
+
+/**
+ * Configure performance monitoring
+ */
+export declare function configurePerformance(config: Partial<PerformanceConfig>): void;
+
+/**
+ * Configure performance optimization
+ */
+export declare function configurePerformanceOptimization(config: Partial<PerformanceOptimizationConfig>): void;
+
+/**
+ * Configure permission directive
+ */
+export declare function configurePermission(config: PermissionConfig): void;
+
+/**
+ * Context menu item
+ */
+export declare interface ContextMenuItem {
+    label: string;
+    handler?: () => void;
+    disabled?: boolean;
+    divider?: boolean;
+    icon?: string;
+    class?: string;
+}
+
+/**
+ * Countdown complete callback
+ */
+export declare type CountdownCompleteCallback = () => void;
+
+/**
+ * Countdown format function
+ */
+export declare type CountdownFormatFunction = (time: CountdownTime) => string;
+
+/**
+ * Countdown tick callback
+ */
+export declare type CountdownTickCallback = (time: CountdownTime) => void;
+
+/**
+ * Countdown time object
+ */
+export declare interface CountdownTime {
+    days: number;
+    hours: number;
+    minutes: number;
+    seconds: number;
+    milliseconds: number;
+    total: number;
+}
 
 /**
  * Easing type
  */
 export declare type CounterEasing = 'linear' | 'easeOut' | 'easeInOut' | 'easeOutQuart' | 'easeOutExpo';
 
+/**
+ * Create audit log middleware for directives
+ */
+export declare function createAuditLogMiddleware(directiveName: string): {
+    onMount: (_el: HTMLElement, binding: any, vnode: any) => void;
+    onUpdate: (_el: HTMLElement, binding: any, vnode: any, oldBinding: any) => void;
+    onUnmount: (_el: HTMLElement, _binding: any, vnode: any) => void;
+};
+
 /**
  * Create a capitalizing function with preset options
  *
@@ -331,6 +986,11 @@ export declare function createCapitalizer(options?: {
     keepLower?: string[];
 }): (text: string) => string;
 
+/**
+ * Debounce resize handler
+ */
+export declare function createDebouncedResizeHandler(handler: () => void, delay?: number): () => void;
+
 /**
  * Create a debounced click handler
  *
@@ -350,6 +1010,34 @@ export declare function createCapitalizer(options?: {
  */
 export declare function createDelayedClick(handler: ClickDelayHandler, delay?: number): (event: MouseEvent | TouchEvent) => void;
 
+/**
+ * Create a deprecation warning helper
+ */
+export declare function createDeprecationWarning(changeId: string, deprecatedAPI: string, alternative: string): () => void;
+
+/**
+ * Create benchmark for directive
+ */
+export declare function createDirectiveBenchmark(directiveName: string, setup: () => HTMLElement, teardown?: (el: HTMLElement) => void): {
+    measureMount: () => Promise<BenchmarkResult>;
+    measureUpdate: (newValue: any) => Promise<BenchmarkResult>;
+    measureUnmount: () => Promise<BenchmarkResult>;
+    measureFullCycle: () => Promise<BenchmarkResult>;
+};
+
+/**
+ * Create a directive element wrapper
+ *
+ * @example
+ * ```ts
+ * import { createDirectiveElement, vLazy } from 'directix'
+ *
+ * const LazyImage = createDirectiveElement('lazy-image', vLazy)
+ * customElements.define('lazy-image', LazyImage)
+ * ```
+ */
+export declare function createDirectiveElement(_name: string, directive: Directive, options?: Omit<CustomElementDirectiveOptions, 'name' | 'directive'>): CustomElementConstructor;
+
 /**
  * Create a directive from a template
  *
@@ -399,6 +1087,19 @@ export declare function createEventDirective(options: {
  */
 export declare function createI18n(options: I18nOptions): I18nInstance;
 
+/**
+ * Create lazy loader for directives
+ */
+export declare function createLazyLoader(options?: {
+    rootMargin?: string;
+    threshold?: number;
+    onVisible?: (element: Element) => void;
+}): {
+    observe: (element: Element) => void;
+    unobserve: (element: Element) => void;
+    disconnect: () => void;
+};
+
 /**
  * Create a lowercase transformation function
  *
@@ -462,6 +1163,28 @@ export declare function createNumberFormatter(options?: {
     suffix?: string;
 }): (value: number) => string;
 
+/**
+ * Create performance budget checker
+ */
+export declare function createPerformanceBudget(budget: {
+    fcp?: number;
+    lcp?: number;
+    tti?: number;
+    cls?: number;
+    tbt?: number;
+}): {
+    check: () => {
+        passed: boolean;
+        violations: string[];
+    };
+    report: () => string;
+};
+
+/**
+ * Create permission directive helper
+ */
+export declare function createPermissionCheck(permission: string | string[], mode?: 'any' | 'all'): (context?: Record<string, any>) => Promise<boolean>;
+
 /**
  * Create a permission checker with shared configuration
  *
@@ -494,6 +1217,14 @@ export declare function createPermissionChecker(config: {
  */
 export declare function createSafeContentHandler(config?: XSSProtectionConfig): SafeContentHandler;
 
+/**
+ * Create safe directive wrapper
+ */
+export declare function createSafeDirectiveWrapper<T>(directiveName: string, operation: (el: HTMLElement, binding: any, vnode: any) => T | Promise<T>, options?: {
+    requireDOM?: boolean;
+    validateBinding?: (binding: any) => boolean;
+}): (el: HTMLElement, binding: any, vnode: any) => Promise<T | undefined>;
+
 /**
  * Create a style-based directive template
  *
@@ -563,8 +1294,9 @@ export declare function createUppercaser(first?: boolean): (text: string) => str
 export declare function createVue2Directive<T, B extends Element>(hooks: DirectiveHooks<T, B>): Record<string, any>;
 
 /**
- * Vue 3 directive adapter
- * @returns Vue 3 directive object with created/mounted/updated/unmounted hooks
+ * Create Vue 3 directive with optimizations
+ * Uses markRaw for DOM elements and shallowReactive for state
+ * @returns Vue 3 directive object
  */
 export declare function createVue3Directive<T, B extends Element>(hooks: DirectiveHooks<T, B>): Record<string, any>;
 
@@ -610,6 +1342,35 @@ export declare interface CSPConfig {
     nonce?: string;
 }
 
+/**
+ * Options for creating a custom element directive
+ */
+export declare interface CustomElementDirectiveOptions {
+    /** The element name (must contain a hyphen) */
+    name: string;
+    /** The Vue directive to apply */
+    directive: Directive;
+    /** Default binding value */
+    defaultValue?: any;
+    /** Whether to use shadow DOM */
+    shadow?: boolean;
+    /** Shadow DOM mode */
+    shadowMode?: 'open' | 'closed';
+}
+
+declare interface CustomIntegration {
+    enabled: boolean;
+    pushMetrics: (metrics: Metric[]) => Promise<void>;
+    pushAlert: (alert: Alert) => Promise<void>;
+}
+
+declare interface DatadogConfig {
+    enabled: boolean;
+    apiKey: string;
+    appKey?: string;
+    host?: string;
+}
+
 /**
  * Date format options per region
  */
@@ -669,6 +1430,58 @@ export declare function deepClone<T>(obj: T): T;
  */
 export declare function deepMerge<T extends Record<string, any>>(target: T, ...sources: Partial<T>[]): T;
 
+export declare const DEFAULT_AUDIT_LOG_CONFIG: AuditLogConfig;
+
+export declare const DEFAULT_BENCHMARK_CONFIG: BenchmarkConfig;
+
+export declare const DEFAULT_BREAKING_CHANGES_CONFIG: BreakingChangesConfig;
+
+export declare const DEFAULT_CONFIG_CENTER_CONFIG: ConfigCenterConfig;
+
+export declare const DEFAULT_EDGE_CASE_CONFIG: EdgeCaseConfig;
+
+export declare const DEFAULT_ENTERPRISE_PERMISSION_CONFIG: EnterprisePermissionConfig;
+
+export declare const DEFAULT_FIRST_SCREEN_CONFIG: FirstScreenConfig;
+
+export declare const DEFAULT_MONITORING_CONFIG: MonitoringConfig;
+
+export declare const DEFAULT_PERFORMANCE_CONFIG: PerformanceOptimizationConfig;
+
+/**
+ * Defer non-critical directive
+ */
+export declare function deferNonCriticalDirective(_directiveName: string, setup: () => void | Promise<void>, isCritical?: boolean): void;
+
+export declare interface DeferredTask {
+    id: string;
+    priority: 'critical' | 'high' | 'medium' | 'low';
+    execute: () => void | Promise<void>;
+    executed: boolean;
+}
+
+/**
+ * Defer task execution
+ */
+export declare function deferTask(id: string, execute: () => void | Promise<void>, priority?: 'critical' | 'high' | 'medium' | 'low'): void;
+
+/**
+ * Define a custom element that wraps a Vue directive
+ *
+ * @example
+ * ```ts
+ * import { vClickOutside, defineCustomElementDirective } from 'directix'
+ *
+ * defineCustomElementDirective({
+ *   name: 'click-outside',
+ *   directive: vClickOutside,
+ * })
+ *
+ * // Now you can use: <click-outside></click-outside>
+ * ```
+ */
+export declare function defineCustomElementDirective(options: CustomElementDirectiveOptions): void;
+
 /**
  * Define a cross-version compatible directive
  * @param definition The directive definition
@@ -690,6 +1503,11 @@ export declare function defineDirectiveGroup(name: string, directives: Record<st
  */
 export declare function definePlugin(plugin: DirectixPlugin): DirectixPlugin;
 
+/**
+ * Delete configuration value
+ */
+export declare function deleteConfig(key: string): void;
+
 /**
  * Dependency vulnerability info
  */
@@ -710,11 +1528,46 @@ export declare interface DependencyVulnerability {
     patchedVersions?: string;
 }
 
+/**
+ * Deprecated API information
+ */
+export declare interface DeprecatedAPI {
+    name: string;
+    location: string;
+    line: number;
+    deprecatedIn: string;
+    removedIn: string;
+    replacement: string;
+    migrationCode?: string;
+}
+
+/**
+ * Detect breaking changes in code
+ */
+export declare function detectBreakingChangesInCode(code: string, options?: {
+    file?: string;
+}): BreakingChangeDetection[];
+
+/**
+ * Detect legacy usage in code
+ */
+export declare function detectLegacyUsage(code: string, source?: MigrationSource): LegacyUsageReport;
+
 /**
  * Detect user locale info
  */
 export declare function detectLocaleInfo(): LocaleInfo;
 
+/**
+ * Detect resize loop
+ */
+export declare function detectResizeLoop(_entries: ResizeObserverEntry[], threshold?: number): boolean;
+
+/**
+ * Detect scroll jank
+ */
+export declare function detectScrollJank(frameTime: number, threshold?: number): boolean;
+
 /**
  * DevTools event
  */
@@ -924,11 +1777,87 @@ export declare function disableDevtools(): void;
  */
 export declare function disablePerformance(): void;
 
+/**
+ * Cache for DOM queries to reduce repeated queries
+ */
+export declare class DOMQueryCache {
+    private queryCache;
+    private styleCache;
+    /**
+     * Query selector with caching
+     */
+    querySelector(element: Element, selector: string): Element | null;
+    /**
+     * Query selector all with caching
+     */
+    querySelectorAll(element: Element, selector: string): Element[];
+    /**
+     * Get computed style with caching
+     */
+    getComputedStyle(element: Element): CSSStyleDeclaration;
+    /**
+     * Invalidate cache for element
+     */
+    invalidate(element: Element): void;
+}
+
 /**
  * Draggable axis
  */
 export declare type DraggableAxis = 'x' | 'y' | 'both';
 
+/**
+ * Edge Case Handler Module for Directix
+ * Provides robust handling for edge cases and error scenarios
+ */
+export declare interface EdgeCaseConfig {
+    ssr: {
+        enabled: boolean;
+        warnOnUnsupported: boolean;
+        fallbackBehavior: 'skip' | 'mock' | 'throw';
+    };
+    domReady: {
+        waitForReady: boolean;
+        timeout: number;
+        retryCount: number;
+    };
+    memory: {
+        maxObservers: number;
+        cleanupInterval: number;
+        warnThreshold: number;
+    };
+    errorRecovery: {
+        enabled: boolean;
+        maxRetries: number;
+        retryDelay: number;
+        fallbackValue?: any;
+    };
+    mobile: {
+        touchDelay: number;
+        debounceResize: number;
+        preventDefaultOnTouch: boolean;
+    };
+}
+
+export declare interface EdgeCaseResult<T> {
+    success: boolean;
+    value?: T;
+    error?: Error;
+    recovered: boolean;
+    retryCount: number;
+}
+
+export declare type EdgeCaseType = 'ssr-unsupported' | 'dom-not-ready' | 'element-not-found' | 'observer-limit' | 'memory-leak' | 'touch-conflict' | 'resize-loop' | 'scroll-jank' | 'invalid-binding' | 'missing-dependency';
+
+export declare interface EdgeCaseWarning {
+    type: EdgeCaseType;
+    message: string;
+    element?: Element;
+    directive?: string;
+    timestamp: number;
+    handled: boolean;
+}
+
 /**
  * Enable DevTools integration
  */
@@ -949,6 +1878,139 @@ export declare function endMeasure(markId: string, directive: string, phase: 'mo
  */
 export declare function ensureTeleportTarget(target: string): HTMLElement | null;
 
+/**
+ * Permission configuration
+ */
+export declare interface EnterprisePermissionConfig {
+    sources: PermissionSourceConfig[];
+    roles: Record<string, RoleDefinition>;
+    cache: {
+        enabled: boolean;
+        ttl: number;
+        key: string;
+    };
+    audit: {
+        enabled: boolean;
+        onCheck?: (result: PermissionCheckResult) => void;
+        onGrant?: (result: PermissionCheckResult) => void;
+        onDeny?: (result: PermissionCheckResult) => void;
+        logToConsole?: boolean;
+    };
+    defaultBehavior: 'allow' | 'deny';
+    customCheck?: (permission: string, context?: any) => boolean | Promise<boolean>;
+}
+
+/**
+ * Enterprise Permission Manager
+ */
+export declare class EnterprisePermissionManager {
+    private config;
+    private permissions;
+    private resolvedRoles;
+    private auditLogs;
+    private cacheTimestamp;
+    private refreshTimer;
+    private initialized;
+    constructor(config?: Partial<EnterprisePermissionConfig>);
+    /**
+     * Initialize permission manager
+     */
+    initialize(): Promise<void>;
+    /**
+     * Load permissions from all configured sources
+     */
+    private loadPermissions;
+    /**
+     * Load permissions from a single source
+     */
+    private loadFromSource;
+    /**
+     * Load permissions from API
+     */
+    private loadFromApi;
+    /**
+     * Load permissions from storage
+     */
+    private loadFromStorage;
+    /**
+     * Resolve all role inheritances
+     */
+    private resolveAllRoles;
+    /**
+     * Resolve a single role with inheritance
+     */
+    private resolveRole;
+    /**
+     * Set up automatic refresh timer
+     */
+    private setupRefreshTimer;
+    /**
+     * Check if permission is granted
+     */
+    check(permission: string, context?: Record<string, any>): Promise<PermissionCheckResult>;
+    /**
+     * Check permission synchronously (without API refresh)
+     */
+    checkSync(permission: string, context?: Record<string, any>): PermissionCheckResult;
+    /**
+     * Check multiple permissions
+     */
+    checkAll(permissions: string[], context?: Record<string, any>): Promise<Record<string, boolean>>;
+    /**
+     * Check if any of the permissions is granted
+     */
+    checkAny(permissions: string[], context?: Record<string, any>): Promise<boolean>;
+    /**
+     * Log audit entry
+     */
+    private logAudit;
+    /**
+     * Get audit logs
+     */
+    getAuditLogs(filter?: {
+        permission?: string;
+        result?: 'granted' | 'denied';
+        since?: number;
+        limit?: number;
+    }): PermissionAuditLogEntry[];
+    /**
+     * Clear audit logs
+     */
+    clearAuditLogs(): void;
+    /**
+     * Add permission dynamically
+     */
+    addPermission(permission: string): void;
+    /**
+     * Remove permission dynamically
+     */
+    removePermission(permission: string): void;
+    /**
+     * Get all current permissions
+     */
+    getPermissions(): string[];
+    /**
+     * Add role dynamically
+     */
+    addRole(role: RoleDefinition): void;
+    /**
+     * Remove role dynamically
+     */
+    removeRole(roleName: string): void;
+    /**
+     * Get resolved permissions for a role
+     */
+    getRolePermissions(roleName: string): string[];
+    /**
+     * Export audit logs
+     */
+    exportAuditLogs(format?: 'json' | 'csv'): string;
+    /**
+     * Destroy and cleanup
+     */
+    destroy(): void;
+}
+
 export declare const enUS: I18nMessages;
 
 /**
@@ -975,6 +2037,58 @@ declare interface ErrorMessages {
  */
 export declare function escapeHtml(str: string): string;
 
+/**
+ * Estimate migration effort
+ */
+export declare function estimateMigrationEffort(report: LegacyUsageReport): {
+    estimatedTime: string;
+    difficulty: 'easy' | 'medium' | 'hard';
+    autoFixablePercentage: number;
+};
+
+/**
+ * Batch processor for events to reduce DOM operations
+ */
+export declare class EventBatchProcessor {
+    private queue;
+    private processing;
+    private batchSize;
+    private scheduled;
+    constructor(batchSize?: number);
+    /**
+     * Add event to batch queue
+     */
+    add(target: HTMLElement, event: string, handler: EventListener): void;
+    /**
+     * Process batched events
+     */
+    private processBatch;
+    /**
+     * Clear the queue
+     */
+    clear(): void;
+}
+
+/**
+ * Execute deferred tasks
+ */
+export declare function executeDeferredTasks(): Promise<void>;
+
+/**
+ * Export audit logs
+ */
+export declare function exportAuditLogs(options?: AuditLogExportOptions): string;
+
+/**
+ * Export results as JSON
+ */
+export declare function exportBenchmarkResults(format?: 'json' | 'csv'): string;
+
+/**
+ * Export configuration
+ */
+export declare function exportConfig(format?: 'json' | 'yaml' | 'env'): string;
+
 /**
  * Export format type
  */
@@ -989,6 +2103,11 @@ export declare function exportPerformanceData(): {
     report: DirectivePerformance[];
 };
 
+/**
+ * Export metrics in Prometheus format
+ */
+export declare function exportPrometheusMetrics(): string;
+
 /**
  * Extended touch gesture types
  */
@@ -1023,6 +2142,87 @@ export declare interface ExtendedTouchEvent {
     duration?: number;
 }
 
+/**
+ * Get Critical CSS
+ */
+export declare function extractCriticalCSS(): string;
+
+/**
+ * Fallback strategy configuration
+ */
+export declare interface FallbackConfig {
+    intersectionObserver: boolean;
+    resizeObserver: boolean;
+    clipboard: boolean;
+    mutationObserver: boolean;
+    pointerEvents: boolean;
+    touchEvents: boolean;
+}
+
+export declare const FEATURE_MATRIX: Record<string, FeatureMatrix>;
+
+export declare interface FeatureMatrix {
+    name: string;
+    description: string;
+    browserSupport: Record<string, {
+        minVersion: number;
+        notes?: string;
+    }>;
+    fallbackAvailable: boolean;
+}
+
+export declare interface FeatureSupport {
+    name: string;
+    supported: boolean;
+    polyfillAvailable: boolean;
+    notes?: string;
+}
+
+/**
+ * First Screen Loading Optimization Module for Directix
+ * Provides utilities for optimizing initial page load performance
+ */
+export declare interface FirstScreenConfig {
+    lazyLoading: {
+        enabled: boolean;
+        rootMargin: string;
+        threshold: number;
+        deferNonCritical: boolean;
+    };
+    codeSplitting: {
+        enabled: boolean;
+        preloadAfter: number;
+        prefetchVisible: boolean;
+    };
+    resourceHints: {
+        preconnect: string[];
+        preload: string[];
+        prefetch: string[];
+        dnsPrefetch: string[];
+    };
+    deferredExecution: {
+        enabled: boolean;
+        deferDelay: number;
+        priorityQueue: boolean;
+    };
+    criticalCSS: {
+        extract: boolean;
+        inline: boolean;
+        inlineThreshold: number;
+    };
+}
+
+export declare interface FirstScreenMetrics {
+    domContentLoaded: number;
+    load: number;
+    firstPaint: number;
+    firstContentfulPaint: number;
+    largestContentfulPaint: number;
+    timeToInteractive: number;
+    totalBlockingTime: number;
+    cumulativeLayoutShift: number;
+}
+
 /**
  * Focus trap options
  */
@@ -1072,74 +2272,369 @@ export declare function formatNumber(value: number, options?: {
 }): string;
 
 /**
- * Format number with locale-specific separators
+ * 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 benchmark report
+ */
+export declare function generateBenchmarkReport(): string;
+
+/**
+ * Generate comprehensive breaking changes report
+ */
+export declare function generateBreakingChangesReport(targetVersion?: string): BreakingChangesReport;
+
+/**
+ * Generate browserslist configuration
+ */
+export declare function generateBrowserslistConfig(): string[];
+
+/**
+ * Generate compatibility report
+ */
+export declare function generateCompatibilityReport(): CompatibilityReport;
+
+/**
+ * Generate unique ID
+ */
+export declare function generateId(prefix?: string): string;
+
+/**
+ * Generate migration report
+ */
+export declare function generateMigrationReport(report: LegacyUsageReport, format: 'text' | 'json' | 'markdown'): string;
+
+/**
+ * Get nested property value by path
+ */
+export declare function get<T = any>(obj: Record<string, any>, path: string, defaultValue?: T): T;
+
+/**
+ * Get alerts
+ */
+export declare function getAlerts(filter?: {
+    status?: AlertStatus;
+    severity?: AlertSeverity;
+    ruleId?: string;
+    since?: number;
+}): Alert[];
+
+/**
+ * Get all stored results
+ */
+export declare function getAllBenchmarkResults(): Map<string, BenchmarkResult>;
+
+/**
+ * Get all breaking changes
+ */
+export declare function getAllBreakingChanges(): BreakingChangeDefinition[];
+
+/**
+ * Get all configuration values
+ */
+export declare function getAllConfig(): Record<string, any>;
+
+/**
+ * Get audit log by ID
+ */
+export declare function getAuditLogById(id: string): AuditLogEntry | undefined;
+
+/**
+ * Get current configuration
+ */
+export declare function getAuditLogConfig(): AuditLogConfig;
+
+/**
+ * Get audit logs with filtering
+ */
+export declare function getAuditLogs(filter?: AuditLogFilter): AuditLogEntry[];
+
+/**
+ * Get audit log statistics
+ */
+export declare function getAuditLogStats(): AuditLogStats;
+
+/**
+ * Get default ARIA config for directive type
+ */
+export declare function getAutoAriaConfig(options: AutoAriaOptions): ARIAConfig;
+
+/**
+ * Get current configuration
+ */
+export declare function getBenchmarkConfig(): BenchmarkConfig;
+
+/**
+ * Get stored benchmark result
+ */
+export declare function getBenchmarkResult(name: string): BenchmarkResult | undefined;
+
+/**
+ * Get breaking changes by category
+ */
+export declare function getBreakingChangesByCategory(category: BreakingChangeCategory): BreakingChangeDefinition[];
+
+/**
+ * Get breaking changes by severity
+ */
+export declare function getBreakingChangesBySeverity(severity: ChangeSeverity): BreakingChangeDefinition[];
+
+/**
+ * Get current configuration
+ */
+export declare function getBreakingChangesConfig(): BreakingChangesConfig;
+
+/**
+ * Get breaking changes affecting a specific API
+ */
+export declare function getBreakingChangesForAPI(apiName: string): BreakingChangeDefinition[];
+
+/**
+ * Get breaking changes for a specific version
+ */
+export declare function getBreakingChangesForVersion(version: string): BreakingChangeDefinition[];
+
+/**
+ * Get compatibility report for a browser
+ */
+export declare function getBrowserCompatibilityReport(browserName: string, version: number): {
+    supported: boolean;
+    features: FeatureSupport[];
+    recommendations: string[];
+};
+
+/**
+ * Get browser information
+ */
+export declare function getBrowserInfo(): BrowserInfo;
+
+/**
+ * Get all supported browsers for a feature
+ */
+export declare function getBrowsersSupportingFeature(featureName: string): MatrixBrowserTarget[];
+
+/**
+ * Get current compatibility configuration
+ */
+export declare function getCompatibilityConfig(): BrowserCompatibilityConfig;
+
+/**
+ * Get full compatibility matrix
+ */
+export declare function getCompatibilityMatrix(): CompatibilityMatrix;
+
+/**
+ * Get configuration value
+ */
+export declare function getConfig<T = any>(key: string, defaultValue?: T): T;
+
+/**
+ * Get current configuration
+ */
+export declare function getConfigCenterConfig(): ConfigCenterConfig;
+
+/**
+ * Get snapshots
+ */
+export declare function getConfigSnapshots(): ConfigSnapshot[];
+
+/**
+ * Get config statistics
+ */
+export declare function getConfigStats(): {
+    totalKeys: number;
+    snapshotCount: number;
+    listenerCount: number;
+    cacheEnabled: boolean;
+    syncEnabled: boolean;
+};
+
+/**
+ * Get counter value
+ */
+export declare function getCounterValue(name: string, labels?: Record<string, string>): number;
+
+/**
+ * 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 DOM query cache
+ */
+export declare function getDOMQueryCache(): DOMQueryCache | null;
+
+/**
+ * Get current configuration
+ */
+export declare function getEdgeCaseConfig(): EdgeCaseConfig;
+
+/**
+ * Get warnings
+ */
+export declare function getEdgeCaseWarnings(filter?: {
+    type?: EdgeCaseType;
+    directive?: string;
+    since?: number;
+}): EdgeCaseWarning[];
+
+/**
+ * Get element with edge case handling
+ */
+export declare function getElementWithFallback(selector: string, fallbackSelectors?: string[]): Element | null;
+
+/**
+ * Get event batch processor
+ */
+export declare function getEventBatchProcessor(): EventBatchProcessor | null;
+
+/**
+ * Get feature support for a browser
+ */
+export declare function getFeatureSupport(browserName: string, featureName: string): FeatureSupport | undefined;
+
+/**
+ * Get current configuration
+ */
+export declare function getFirstScreenConfig(): FirstScreenConfig;
+
+/**
+ * Get first screen metrics
+ */
+export declare function getFirstScreenMetrics(): Partial<FirstScreenMetrics>;
+
+/**
+ * Get gauge value
  */
-export declare function formatNumberLocale(value: number, decimals?: number, options?: Partial<NumberFormatOptions>): string;
+export declare function getGaugeValue(name: string, labels?: Record<string, string>): number | undefined;
 
 /**
- * Format time to string
+ * Get health status
  */
-export declare function formatTime(time: CountdownTime, format: string | CountdownFormatFunction): string;
+export declare function getHealthStatus(): {
+    healthy: boolean;
+    checks: HealthStatus[];
+    timestamp: number;
+};
 
 /**
- * Generate unique ID for ARIA references
+ * Get histogram statistics
  */
-export declare function generateAriaId(prefix?: string): string;
+export declare function getHistogramStats(name: string, labels?: Record<string, string>): {
+    count: number;
+    min: number;
+    max: number;
+    mean: number;
+    p50: number;
+    p95: number;
+    p99: number;
+} | undefined;
 
 /**
- * Generate unique ID
+ * Get current locale
  */
-export declare function generateId(prefix?: string): string;
+export declare function getLocale(): string;
 
 /**
- * Get nested property value by path
+ * Get locale display name
  */
-export declare function get<T = any>(obj: Record<string, any>, path: string, defaultValue?: T): T;
+export declare function getLocaleDisplayName(locale: string, displayLocale?: string): string;
 
 /**
- * Get default ARIA config for directive type
+ * Get memory cleanup manager
  */
-export declare function getAutoAriaConfig(options: AutoAriaOptions): ARIAConfig;
+export declare function getMemoryCleanupManager(): MemoryCleanupManager | null;
 
 /**
- * Get CSP nonce from meta tag
+ * Get memory statistics
  */
-export declare function getCSPNonce(): string | null;
+export declare function getMemoryStats(): {
+    observerCount: number;
+    maxObservers: number;
+    warningCount: number;
+    usedPercentage: number;
+};
 
 /**
- * Get region-specific date format
+ * Get metrics
  */
-export declare function getDateFormat(region?: string): DateFormatOptions;
+export declare function getMetrics(filter?: {
+    name?: string;
+    type?: MetricType;
+    since?: number;
+}): Metric[];
 
 /**
- * Get device pixel ratio
+ * Get migration rules for a specific source
  */
-export declare function getDevicePixelRatio(): number;
+export declare function getMigrationRules(source: MigrationSource): MigrationRule[];
 
 /**
- * Get DevTools state (for external access)
+ * Get migration timeline
  */
-export declare function getDevtoolsState(): {
-    enabled: boolean;
-    directiveCount: number;
-    pluginCount: number;
-    eventCount: number;
-};
+export declare function getMigrationTimeline(): Array<{
+    version: string;
+    changes: BreakingChangeDefinition[];
+    milestone: 'deprecated' | 'removed';
+}>;
 
 /**
- * Get performance metrics for a specific directive
+ * Get required polyfills that are not loaded
  */
-export declare function getDirectiveMetrics(directive: string): PerformanceMetric[];
+export declare function getMissingPolyfills(): string[];
 
 /**
- * Get current locale
+ * Get current configuration
  */
-export declare function getLocale(): string;
+export declare function getMonitoringConfig(): MonitoringConfig;
 
 /**
- * Get locale display name
+ * Get monitoring statistics
  */
-export declare function getLocaleDisplayName(locale: string, displayLocale?: string): string;
+export declare function getMonitoringStats(): {
+    metricsCount: number;
+    alertsCount: number;
+    activeAlerts: number;
+    healthChecksCount: number;
+    healthyChecks: number;
+};
 
 /**
  * Get most frequently called directives
@@ -1151,11 +2646,21 @@ export declare function getMostFrequentDirectives(limit?: number): DirectivePerf
  */
 export declare function getNumberFormat(region?: string): NumberFormatOptions;
 
+/**
+ * Get observer count
+ */
+export declare function getObserverCount(): number;
+
 /**
  * Get all performance metrics
  */
 export declare function getPerformanceMetrics(): PerformanceMetric[];
 
+/**
+ * Get current performance config
+ */
+export declare function getPerformanceOptimizationConfig(): PerformanceOptimizationConfig;
+
 /**
  * Get performance report for all directives
  */
@@ -1166,6 +2671,11 @@ export declare function getPerformanceReport(): DirectivePerformance[];
  */
 export declare function getPermissionConfig(): PermissionConfig | null;
 
+/**
+ * Get global permission manager
+ */
+export declare function getPermissionManager(): EnterprisePermissionManager | null;
+
 /**
  * Get or create the global plugin manager
  */
@@ -1176,6 +2686,14 @@ export declare function getPluginManager(config?: PluginConfig): PluginManager;
  */
 export declare function getPluginRegistry(registryUrl?: string): PluginRegistry;
 
+/**
+ * Get polyfill status
+ */
+export declare function getPolyfillStatus(): Record<string, {
+    loaded: boolean;
+    required: boolean;
+}>;
+
 /**
  * Get slowest directives
  */
@@ -1191,11 +2709,57 @@ export declare function getSupportedRegions(): string[];
  */
 export declare function getTimezoneInfo(): TimezoneInfo;
 
+/**
+ * Get unsupported features list
+ */
+export declare function getUnsupportedFeatures(): (keyof BrowserFeatures)[];
+
 /**
  * Get current Vue version
  */
 export declare function getVueVersion(): VueVersion;
 
+/**
+ * Get warned changes
+ */
+export declare function getWarnedChanges(): string[];
+
+/**
+ * Handle SSR unsupported operation
+ */
+export declare function handleSSRUnsupported(operation: string, directive?: string): EdgeCaseResult<undefined>;
+
+/**
+ * Handle touch conflict (for mobile)
+ */
+export declare function handleTouchConflict(element: Element, event: TouchEvent, directive?: string): boolean;
+
+/**
+ * Check permission using global manager
+ */
+export declare function hasPermission(permission: string, context?: Record<string, any>): Promise<boolean>;
+
+/**
+ * Check permission synchronously
+ */
+export declare function hasPermissionSync(permission: string, context?: Record<string, any>): boolean;
+
+export declare interface HealthCheck {
+    name: string;
+    check: () => Promise<boolean> | boolean;
+    interval: number;
+    timeout: number;
+    enabled: boolean;
+}
+
+export declare interface HealthStatus {
+    name: string;
+    healthy: boolean;
+    lastCheck: number;
+    error?: string;
+    latency: number;
+}
+
 /**
  * Hotkey definition
  */
@@ -1263,11 +2827,31 @@ export declare interface I18nOptions {
     messages: Record<string, I18nMessages>;
 }
 
+/**
+ * Import configuration
+ */
+export declare function importConfig(data: string, format?: 'json' | 'yaml' | 'env', merge?: boolean): Promise<void>;
+
+/**
+ * Increment counter
+ */
+export declare function incrementCounter(name: string, labels?: Record<string, string>, value?: number): void;
+
 /**
  * Show an info message
  */
 export declare function info(message: string, params?: Record<string, any>): void;
 
+/**
+ * Initialize configuration center
+ */
+export declare function initConfigCenter(): Promise<void>;
+
+/**
+ * Initialize first screen optimizer
+ */
+export declare function initFirstScreenOptimizer(): void;
+
 /**
  * CSP-safe script injection
  */
@@ -1278,11 +2862,21 @@ export declare function injectScriptCSP(src: string, options?: CSPConfig): HTMLS
  */
 export declare function injectStylesCSP(css: string, options?: CSPConfig): HTMLStyleElement | HTMLLinkElement | null;
 
+/**
+ * Inline critical CSS
+ */
+export declare function inlineCriticalCSS(css: string): void;
+
 /**
  * Intersect event handler
  */
 export declare type IntersectHandler = (entry: IntersectionObserverEntry, observer: IntersectionObserver) => void;
 
+/**
+ * Check if an API is affected by breaking changes
+ */
+export declare function isAPIAffected(apiName: string, version?: string): boolean;
+
 /**
  * Check if value is an array
  */
@@ -1298,21 +2892,51 @@ export declare function isBoolean(value: unknown): value is boolean;
  */
 export declare const isBrowser: () => boolean;
 
+/**
+ * Check if a browser version is supported
+ */
+export declare function isBrowserSupported(browserName: string, version: number): boolean;
+
+/**
+ * Check if an element is a custom element
+ */
+export declare function isCustomElement(el: Element): boolean;
+
 /**
  * Check if DevTools is available
  */
 export declare function isDevtoolsAvailable(): boolean;
 
+/**
+ * Check if DOM is ready
+ */
+export declare function isDOMReady(): boolean;
+
 /**
  * Check if value is empty
  */
 export declare function isEmpty(value: unknown): boolean;
 
+/**
+ * Check if a feature is supported
+ */
+export declare function isFeatureSupported(feature: keyof BrowserFeatures): boolean;
+
+/**
+ * Check if current browser is fully supported
+ */
+export declare function isFullySupported(): boolean;
+
 /**
  * Check if value is a function
  */
 export declare function isFunction(value: unknown): value is (...args: any[]) => any;
 
+/**
+ * Check if element is in viewport (with fallback)
+ */
+export declare function isInViewport(element: Element): boolean;
+
 /**
  * Check if device is mobile
  */
@@ -1328,11 +2952,21 @@ export declare function isNumber(value: unknown): value is number;
  */
 export declare function isObject(value: unknown): value is Record<string, any>;
 
+/**
+ * Check if page is loaded
+ */
+export declare function isPageLoaded(): boolean;
+
 /**
  * Check if performance monitoring is enabled
  */
 export declare function isPerformanceEnabled(): boolean;
 
+/**
+ * Check if a polyfill is loaded
+ */
+export declare function isPolyfillLoaded(name: string): boolean;
+
 /**
  * Check if value is a Promise
  */
@@ -1343,6 +2977,11 @@ export declare function isPromise<T = any>(value: unknown): value is Promise<T>;
  */
 export declare const isSSR: () => boolean;
 
+/**
+ * Check if running in SSR environment
+ */
+export declare function isSSREnvironment(): boolean;
+
 /**
  * Check if value is a string
  */
@@ -1353,11 +2992,21 @@ export declare function isString(value: unknown): value is string;
  */
 export declare function isTouchDevice(): boolean;
 
+/**
+ * Check if running in a known unsupported browser
+ */
+export declare function isUnsupportedBrowser(): boolean;
+
 /**
  * Check if URL is safe
  */
 export declare function isUrlSafe(url: string, allowedProtocols?: string[]): boolean;
 
+/**
+ * Check if a version is affected by any breaking changes
+ */
+export declare function isVersionAffected(version: string): boolean;
+
 /**
  * Check if Vue 2 (includes 2.7)
  */
@@ -1410,66 +3059,329 @@ export declare interface KeyboardNavigationConfig {
     rovingTabindex?: boolean;
 }
 
+/**
+ * Lazy initialization helper to defer expensive operations
+ */
+export declare class LazyInitializer<T> {
+    private value;
+    private initFunction;
+    private initialized;
+    private pendingPromise;
+    constructor(initFunction: () => T | Promise<T>);
+    /**
+     * Get value, initializing if needed
+     */
+    get(): T;
+    /**
+     * Get value asynchronously
+     */
+    getAsync(): Promise<T>;
+    /**
+     * Check if initialized
+     */
+    isInitialized(): boolean;
+    /**
+     * Reset and clear value
+     */
+    reset(): void;
+}
+
 /**
  * Lazy loading state
  */
 export declare type LazyState = 'pending' | 'loading' | 'loaded' | 'error';
 
 /**
- * Locale info
+ * Legacy API detection result
+ */
+export declare interface LegacyUsageReport {
+    deprecatedAPIs: DeprecatedAPI[];
+    breakingChanges: BreakingChange[];
+    warnings: MigrationWarning[];
+    suggestions: MigrationSuggestion[];
+    totalIssues: number;
+    severity: 'low' | 'medium' | 'high';
+}
+
+export declare interface LoadPriority {
+    critical: string[];
+    high: string[];
+    medium: string[];
+    low: string[];
+}
+
+/**
+ * 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;
+}
+
+/**
+ * Core logging function
+ */
+export declare function logAudit(level: AuditLogLevel, type: AuditEventType, message: string, details?: Record<string, unknown>, context?: Partial<AuditContext>, duration?: number): AuditLogEntry | null;
+
+/**
+ * Log directive operation
+ */
+export declare function logDirectiveOperation(operation: 'mount' | 'update' | 'unmount', directive: string, details?: Record<string, unknown>, context?: Partial<AuditContext>, duration?: number): void;
+
+/**
+ * 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';
+
+/**
+ * Log performance issue
+ */
+export declare function logPerformanceIssue(operation: string, duration: number, threshold: number, context?: Partial<AuditContext>): void;
+
+/**
+ * Log permission check
+ */
+export declare function logPermissionCheck(permission: string, granted: boolean, source: string, context?: Partial<AuditContext>): void;
+
+/**
+ * Log security violation
+ */
+export declare function logSecurityViolation(violation: string, details: Record<string, unknown>, context?: Partial<AuditContext>): void;
+
+/**
+ * Lottie animation state
+ */
+export declare type LottieAnimationState = 'playing' | 'paused' | 'stopped';
+
+/**
+ * Transform text to lowercase
+ */
+export declare function lowercaseText(text: string, firstOnly?: boolean): string;
+
+/**
+ * Mark a polyfill as loaded
+ */
+export declare function markPolyfillLoaded(name: string): void;
+
+/**
+ * Browser Compatibility Test Matrix for Directix
+ * Defines supported browsers, versions, and test configurations
+ */
+export declare interface MatrixBrowserTarget {
+    name: string;
+    minVersion: number;
+    currentVersion: number;
+    engine: 'blink' | 'gecko' | 'webkit';
+    features: FeatureSupport[];
+}
+
+/**
+ * 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>;
+
+/**
+ * Check if current browser meets minimum requirements
+ */
+export declare function meetsMinimumRequirements(): boolean;
+
+/**
+ * Manager for periodic memory cleanup
+ */
+export declare class MemoryCleanupManager {
+    private cleanupCallbacks;
+    private intervalId;
+    private cleanupInterval;
+    constructor(cleanupInterval?: number);
+    /**
+     * Register cleanup callback
+     */
+    register(callback: () => void): void;
+    /**
+     * Unregister cleanup callback
+     */
+    unregister(callback: () => void): void;
+    /**
+     * Start periodic cleanup
+     */
+    start(): void;
+    /**
+     * Stop periodic cleanup
+     */
+    stop(): void;
+    /**
+     * Run cleanup manually
+     */
+    runCleanup(): void;
+    /**
+     * Get registered callbacks count
+     */
+    size(): number;
+}
+
+export declare interface Metric {
+    name: string;
+    type: MetricType;
+    value: number;
+    labels: Record<string, string>;
+    timestamp: number;
+}
+
+export declare type MetricType = 'counter' | 'gauge' | 'histogram' | 'summary';
+
+/**
+ * Apply migration rules to code
+ */
+export declare function migrate(code: string, options: MigrationOptions): MigrationResult;
+
+/**
+ * Migration options
+ */
+export declare interface MigrationOptions {
+    source: MigrationSource;
+    rules: MigrationRule[];
+    dryRun: boolean;
+    verbose: boolean;
+    preserveComments: boolean;
+    formatOutput: boolean;
+}
+
+/**
+ * Migration result
  */
-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;
+export declare interface MigrationResult {
+    code: string;
+    changes: CodeChange[];
+    warnings: string[];
+    stats: MigrationStats;
 }
 
 /**
- * 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)
+ * Migration rule
  */
-declare type LogLevel = 'debug' | 'info' | 'warn' | 'error';
+export declare interface MigrationRule {
+    pattern: RegExp | string;
+    replacement: string;
+    description: string;
+    autoFixable: boolean;
+}
 
 /**
- * Lottie animation state
+ * Migration helper module for Directix
+ * Provides tools for detecting and migrating from older versions or other libraries
  */
-export declare type LottieAnimationState = 'playing' | 'paused' | 'stopped';
+/**
+ * Migration source type
+ */
+export declare type MigrationSource = 'directix-v1' | 'vueuse' | 'v-directives' | 'custom';
 
 /**
- * Transform text to lowercase
+ * Migration statistics
  */
-export declare function lowercaseText(text: string, firstOnly?: boolean): string;
+export declare interface MigrationStats {
+    filesProcessed: number;
+    filesChanged: number;
+    totalChanges: number;
+    autoFixes: number;
+    manualFixes: number;
+    warnings: number;
+    errors: number;
+}
 
 /**
- * Performance measurement helper
- * Use this to wrap directive lifecycle methods
+ * Migration suggestion
  */
-export declare function measurePerformance<T>(directive: string, phase: 'mount' | 'update' | 'unmount', fn: () => T, metadata?: Record<string, any>): T;
+export declare interface MigrationSuggestion {
+    original: string;
+    suggested: string;
+    location: string;
+    line: number;
+    autoFixable: boolean;
+}
 
 /**
- * Async performance measurement helper
+ * Migration warning
  */
-export declare function measurePerformanceAsync<T>(directive: string, phase: 'mount' | 'update' | 'unmount', fn: () => Promise<T>, metadata?: Record<string, any>): Promise<T>;
+export declare interface MigrationWarning {
+    message: string;
+    location: string;
+    line: number;
+    severity: 'info' | 'warning' | 'error';
+}
+
+export declare const MOBILE_DEVICES: MobileDevice[];
+
+export declare interface MobileDevice {
+    name: string;
+    os: string;
+    osMinVersion: string;
+    browser: string;
+    browserMinVersion: string;
+}
+
+export declare interface MonitoringConfig {
+    enabled: boolean;
+    metrics: {
+        enabled: boolean;
+        prefix: string;
+        labels: Record<string, string>;
+        flushInterval: number;
+        maxBatchSize: number;
+    };
+    alerts: {
+        enabled: boolean;
+        channels: AlertChannel[];
+        rules: AlertRule[];
+        cooldown: number;
+        aggregation: boolean;
+        aggregationWindow: number;
+    };
+    health: {
+        enabled: boolean;
+        endpoint: string;
+        checks: HealthCheck[];
+        interval: number;
+    };
+    integrations: {
+        prometheus?: PrometheusConfig;
+        datadog?: DatadogConfig;
+        sentry?: SentryConfig;
+        custom?: CustomIntegration;
+    };
+}
 
 /**
  * Mutation change handler
  */
 export declare type MutationHandler = (mutations: MutationRecord[], observer: MutationObserver) => void;
 
+/**
+ * Check if code needs migration
+ */
+export declare function needsMigration(code: string, source?: MigrationSource): boolean;
+
 /**
  * Number format options per region
  */
@@ -1501,6 +3413,23 @@ export declare class ObjectPool<T> {
     clear(): void;
 }
 
+export declare interface ObjectPoolOptions {
+    initialSize: number;
+    maxSize: number;
+    resetFunction?: (obj: any) => void;
+    createFunction: () => any;
+}
+
+/**
+ * Execute on DOM ready
+ */
+export declare function onDOMReady(callback: () => void): void;
+
+/**
+ * Execute on page load
+ */
+export declare function onPageLoad(callback: () => void): void;
+
 /**
  * Vue 3 Optimization Utilities for Directix
  *
@@ -1625,6 +3554,61 @@ export declare interface PerformanceMetric {
     metadata?: Record<string, any>;
 }
 
+/**
+ * Runtime Performance Optimization Module for Directix
+ * Provides utilities for optimizing runtime performance
+ */
+export declare interface PerformanceOptimizationConfig {
+    eventDelegation: {
+        enabled: boolean;
+        globalListeners: boolean;
+        batchProcessing: boolean;
+        batchSize: number;
+    };
+    virtualization: {
+        enabled: boolean;
+        scrollThreshold: number;
+        listItemHeight: number | 'auto';
+        bufferSize: number;
+    };
+    caching: {
+        computedResults: boolean;
+        domQueries: boolean;
+        styleCalculations: boolean;
+        maxCacheSize: number;
+    };
+    lazyInit: {
+        directives: boolean;
+        events: boolean;
+        observers: boolean;
+        debounceMs: number;
+    };
+    memory: {
+        objectPool: boolean;
+        weakReferences: boolean;
+        cleanupOnUnmount: boolean;
+        periodicCleanup: number | false;
+    };
+}
+
+/**
+ * Performance snapshot
+ */
+export declare interface PerformanceSnapshot {
+    memory?: {
+        usedJSHeapSize: number;
+        totalJSHeapSize: number;
+        jsHeapSizeLimit: number;
+    };
+    timing: {
+        domContentLoaded: number;
+        loadComplete: number;
+        domInteractive: number;
+    };
+    entries: PerformanceEntry[];
+    timestamp: number;
+}
+
 /**
  * Performance statistics
  */
@@ -1645,6 +3629,33 @@ export declare interface PerformanceStats {
     p99: number;
 }
 
+/**
+ * Permission audit log entry
+ */
+export declare interface PermissionAuditLogEntry {
+    id: string;
+    timestamp: number;
+    permission: string;
+    result: 'granted' | 'denied';
+    source: string;
+    context?: Record<string, any>;
+    reason?: string;
+    userAgent?: string;
+    url?: string;
+}
+
+/**
+ * Permission check result
+ */
+export declare interface PermissionCheckResult {
+    granted: boolean;
+    permission: string;
+    source: string;
+    timestamp: number;
+    context?: Record<string, any>;
+    reason?: string;
+}
+
 /**
  * Permission configuration
  */
@@ -1662,6 +3673,35 @@ declare interface PermissionConfig {
  */
 export declare type PermissionMode = 'some' | 'every';
 
+/**
+ * Permission source configuration
+ */
+export declare interface PermissionSourceConfig {
+    type: PermissionSourceType;
+    permissions?: string[];
+    api?: {
+        url: string;
+        method: 'GET' | 'POST';
+        headers?: Record<string, string>;
+        transform?: (response: any) => string[];
+        refreshInterval?: number;
+    };
+    storage?: {
+        key: string;
+        parse?: (value: string) => string[];
+    };
+    custom?: () => string[] | Promise<string[]>;
+}
+
+/**
+ * Enterprise Permission Management Module for Directix
+ * Provides advanced permission management with multi-source support, role inheritance, and audit logging
+ */
+/**
+ * Permission source type
+ */
+export declare type PermissionSourceType = 'static' | 'api' | 'localStorage' | 'sessionStorage' | 'custom';
+
 /**
  * Pinch gesture event data
  */
@@ -1676,6 +3716,11 @@ export declare interface PinchEvent {
     isFinal: boolean;
 }
 
+/**
+ * Platform type
+ */
+export declare type PlatformType = 'desktop' | 'mobile' | 'tablet';
+
 /**
  * Plugin category
  */
@@ -1920,6 +3965,11 @@ export declare interface PluginRegistryEntry {
     license?: string;
 }
 
+/**
+ * Polyfill strategy
+ */
+export declare type PolyfillStrategy = 'auto' | 'manual' | 'none';
+
 /**
  * Position type
  */
@@ -1928,6 +3978,23 @@ export declare interface Position {
     y: number;
 }
 
+/**
+ * Prefetch module
+ */
+export declare function prefetchModule(url: string): void;
+
+/**
+ * Prefetch visible elements
+ */
+export declare function prefetchVisibleElements(selector: string, getUrl: (element: Element) => string, options?: {
+    rootMargin?: string;
+}): void;
+
+/**
+ * Preload module
+ */
+export declare function preloadModule(url: string): void;
+
 /**
  * Print before callback
  */
@@ -1938,6 +4005,11 @@ export declare type PrintBeforeCallback = () => boolean | void;
  */
 export declare type PrintCompleteCallback = () => void;
 
+declare interface PrometheusConfig {
+    enabled: boolean;
+    endpoint: string;
+}
+
 /**
  * Pull refresh handler
  */
@@ -2005,6 +4077,62 @@ export declare interface PWAConfig {
  */
 export declare function quickPrint(target: string | HTMLElement, options?: UsePrintOptions): Promise<void>;
 
+/**
+ * Record histogram value
+ */
+export declare function recordHistogram(name: string, value: number, labels?: Record<string, string>): void;
+
+/**
+ * Register multiple directives as custom elements
+ *
+ * @example
+ * ```ts
+ * import { registerDirectiveElements, vLazy, vClickOutside } from 'directix'
+ *
+ * registerDirectiveElements({
+ *   'lazy-img': vLazy,
+ *   'click-outside': vClickOutside,
+ * })
+ * ```
+ */
+export declare function registerDirectiveElements(elements: Record<string, Directive>): void;
+
+/**
+ * Register a polyfill
+ */
+export declare function registerPolyfill(name: string, required?: boolean): void;
+
+/**
+ * Remove health check
+ */
+export declare function removeHealthCheck(name: string): void;
+
+/**
+ * Request idle callback with fallback
+ */
+declare function requestIdleCallback_2(callback: IdleRequestCallback, options?: IdleRequestOptions): number;
+export { requestIdleCallback_2 as requestIdleCallback }
+
+/**
+ * Reset browser info cache (useful for testing)
+ */
+export declare function resetBrowserInfo(): void;
+
+/**
+ * Reset configuration center
+ */
+export declare function resetConfigCenter(): void;
+
+/**
+ * Reset monitoring
+ */
+export declare function resetMonitoring(): void;
+
+/**
+ * Reset performance optimizer
+ */
+export declare function resetPerformanceOptimizer(): void;
+
 /**
  * Reset the global plugin manager
  */
@@ -2032,6 +4160,27 @@ export declare interface ResizeInfo {
     contentRect: DOMRectReadOnly;
 }
 
+/**
+ * Resolve alert
+ */
+export declare function resolveAlert(alertId: string): boolean;
+
+/**
+ * Role definition
+ */
+export declare interface RoleDefinition {
+    name: string;
+    permissions: string[];
+    inherits?: string[];
+    description?: string;
+    metadata?: Record<string, any>;
+}
+
+/**
+ * Rollback to snapshot
+ */
+export declare function rollbackConfig(version: string): boolean;
+
 /**
  * Rotate gesture event data
  */
@@ -2046,6 +4195,24 @@ export declare interface RotateGestureEvent {
     isFinal: boolean;
 }
 
+/**
+ * Run a single benchmark
+ */
+export declare function runBenchmark(name: string, fn: BenchmarkFunction, config?: Partial<BenchmarkConfig>): Promise<BenchmarkResult>;
+
+/**
+ * Run benchmark suite
+ */
+export declare function runBenchmarkSuite(suiteName: string, benchmarks: Array<{
+    name: string;
+    fn: BenchmarkFunction;
+}>, config?: Partial<BenchmarkConfig>): Promise<BenchmarkSuite>;
+
+/**
+ * Run manual cleanup
+ */
+export declare function runMemoryCleanup(): void;
+
 /**
  * Safe content handler for directives
  */
@@ -2070,6 +4237,15 @@ export declare class SafeContentHandler {
     getSanitizedHtml(content: string): string;
 }
 
+/**
+ * Safely query element with retry
+ */
+export declare function safeQueryElement(selector: string, options?: {
+    retryCount?: number;
+    retryDelay?: number;
+    parent?: Element | Document;
+}): Promise<Element | null>;
+
 /**
  * Advanced HTML sanitizer
  */
@@ -2169,16 +4345,38 @@ export declare interface SecurityVulnerability {
     remediation?: string;
 }
 
+declare interface SentryConfig {
+    enabled: boolean;
+    dsn: string;
+    environment?: string;
+    release?: string;
+}
+
 /**
  * Set nested property value by path
  */
 export declare function set(obj: Record<string, any>, path: string, value: any): void;
 
+/**
+ * Set configuration value
+ */
+export declare function setConfig(key: string, value: any, source?: string): void;
+
+/**
+ * Set gauge
+ */
+export declare function setGauge(name: string, value: number, labels?: Record<string, string>): void;
+
 /**
  * Set current locale
  */
 export declare function setLocale(locale: string): void;
 
+/**
+ * Cleanup on page unload
+ */
+export declare function setupCleanupOnUnload(cleanupFn: () => void): void;
+
 /**
  * Set Vue version explicitly (for cases where auto-detection fails)
  */
@@ -2209,11 +4407,21 @@ export declare type SkeletonAnimation = 'wave' | 'pulse' | 'none';
  */
 export declare function startMeasure(directive: string, phase: 'mount' | 'update' | 'unmount'): string;
 
+/**
+ * Stop cleanup timer
+ */
+export declare function stopCleanupTimer(): void;
+
 /**
  * Strip all HTML tags
  */
 export declare function stripHtml(html: string): string;
 
+/**
+ * Support level
+ */
+export declare type SupportLevel = 'full' | 'partial' | 'none';
+
 /**
  * Check if Clipboard API is supported
  */
@@ -2261,6 +4469,14 @@ export declare type SwipeDirection = 'left' | 'right' | 'up' | 'down';
  */
 export declare type SwipeHandler = (direction: SwipeDirection, event: Event) => void;
 
+/**
+ * Sync configuration to remote
+ */
+export declare function syncConfigToRemote(url: string, options?: {
+    method?: 'POST' | 'PUT';
+    headers?: Record<string, string>;
+}): Promise<boolean>;
+
 /**
  * Translate a message key
  * @param key - Dot-notation key like 'directives.debounce.invalid_wait'
@@ -2268,6 +4484,11 @@ export declare type SwipeHandler = (direction: SwipeDirection, event: Event) =>
  */
 export declare function t(key: string, params?: Record<string, any>): string;
 
+/**
+ * Take performance snapshot
+ */
+export declare function takePerformanceSnapshot(): PerformanceSnapshot;
+
 /**
  * Teleport content to target
  */
@@ -2309,6 +4530,11 @@ export declare function throttleFn<T extends (...args: any[]) => any>(fn: T, wai
     trailing?: boolean;
 }): ComposableThrottledFunction<T>;
 
+/**
+ * Time an operation
+ */
+export declare function timeOperation<T>(name: string, fn: () => T | Promise<T>, labels?: Record<string, string>): Promise<T>;
+
 /**
  * Timezone and locale utilities
  *
@@ -2411,11 +4637,21 @@ export declare interface TouchGestureThresholds {
  */
 export declare function trackDirective(name: string, info?: Partial<DirectiveInfo>): void;
 
+/**
+ * Track observer count
+ */
+export declare function trackObserver(): boolean;
+
 /**
  * Register a plugin for DevTools tracking
  */
 export declare function trackPlugin(info: PluginInfo): void;
 
+/**
+ * Trigger alert
+ */
+export declare function triggerAlert(ruleId: string, message: string, value: number, threshold: number, labels?: Record<string, string>): Alert | null;
+
 /**
  * Trigger haptic feedback
  */
@@ -2464,6 +4700,11 @@ export declare function unescapeHtml(str: string): string;
  */
 export declare function untrackDirective(name: string): void;
 
+/**
+ * Untrack observer
+ */
+export declare function untrackObserver(): void;
+
 /**
  * Unregister a plugin from DevTools tracking
  */
@@ -7055,6 +9296,15 @@ export declare interface UseWatermarkReturn {
     disable: () => void;
 }
 
+/**
+ * Validate binding value
+ */
+export declare function validateBinding(binding: any, schema: {
+    type?: string | string[];
+    required?: boolean;
+    validator?: (value: any) => boolean;
+}, directive?: string): EdgeCaseResult<any>;
+
 /**
  * v-blur directive
  * Background blur overlay effect
@@ -8148,6 +10398,11 @@ export declare const vVisible: Directive;
  */
 export declare const vWatermark: Directive;
 
+/**
+ * Wait for DOM ready
+ */
+export declare function waitForDOMReady(): Promise<void>;
+
 /**
  * Show a warning message
  */
@@ -8155,6 +10410,11 @@ export declare function warn(options: WarningOptions): void;
 
 export declare function warn(message: string, params?: Record<string, any>): void;
 
+/**
+ * Warn about a breaking change (once)
+ */
+export declare function warnBreakingChange(changeId: string): void;
+
 /**
  * Deprecation warning
  */
@@ -8203,6 +10463,21 @@ export declare function warnNotSupported(feature: string): void;
  */
 export declare function warnSSRNotSupported(directive: string): void;
 
+/**
+ * Warn once about a specific feature
+ */
+export declare function warnUnsupportedFeatureOnce(feature: string, fallback?: string): void;
+
+/**
+ * Warn about unsupported features
+ */
+export declare function warnUnsupportedFeatures(): void;
+
+/**
+ * Watch configuration changes
+ */
+export declare function watchConfig(key: string | '*', callback: (event: ConfigChangeEvent) => void): () => void;
+
 /**
  * watchEffect that tracks directive bindings
  */
@@ -8220,6 +10495,55 @@ export declare interface WatchEffectBindingOptions {
     immediate?: boolean;
 }
 
+/**
+ * Cache using WeakMap for automatic cleanup when references are removed
+ */
+export declare class WeakCache<K extends object, V> {
+    private cache;
+    private strongCache;
+    private maxStrongSize;
+    constructor(maxStrongSize?: number);
+    /**
+     * Get cached value
+     */
+    get(key: K): V | undefined;
+    /**
+     * Set cached value
+     */
+    set(key: K, value: V): void;
+    /**
+     * Check if key exists
+     */
+    has(key: K): boolean;
+    /**
+     * Delete cached value
+     */
+    delete(key: K): boolean;
+    /**
+     * Clear strong cache (weak cache auto-clears)
+     */
+    clearStrong(): void;
+    /**
+     * Get cache size
+     */
+    size(): number;
+}
+
+/**
+ * Measure and log performance
+ */
+export declare function withAuditLog<T>(type: AuditEventType, message: string, fn: () => T | Promise<T>, details?: Record<string, unknown>, context?: Partial<AuditContext>): Promise<T>;
+
+/**
+ * Execute with error recovery
+ */
+export declare function withErrorRecovery<T>(operation: () => T | Promise<T>, options?: {
+    maxRetries?: number;
+    retryDelay?: number;
+    fallbackValue?: T;
+    onError?: (error: Error, attempt: number) => void;
+}): Promise<EdgeCaseResult<T>>;
+
 /**
  * Create a performance monitor decorator for directives
  */