directix 1.7.0 → 1.9.0

package/dist/index.d.ts

@@ -1,3 +1,4 @@
+import { App } from 'vue';
 import { ComponentPublicInstance } from 'vue';
 import { Directive } from 'vue';
 import { Plugin as Plugin_2 } from 'vue';
@@ -14,6 +15,33 @@ export declare function addCleanupVue2(el: Element, fn: () => void): void;
  */
 export declare function addCleanupVue3(el: Element, fn: () => void): void;
 
+/**
+ * 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 }
+
+/**
+ * Calculate statistics from metrics
+ */
+export declare function calculateStats(metrics: PerformanceMetric[]): PerformanceStats;
+
 /**
  * Calculate remaining time
  */
@@ -32,6 +60,16 @@ export declare function capitalizeText(text: string, options?: {
  */
 export declare function capitalizeWord(word: string): string;
 
+/**
+ * Clear DevTools state
+ */
+export declare function clearDevtoolsState(): void;
+
+/**
+ * Clear all performance metrics
+ */
+export declare function clearPerformanceMetrics(): void;
+
 /**
  * Click delay handler
  */
@@ -78,6 +116,11 @@ export declare interface ComposableThrottledFunction<T extends (...args: any[])
     cancel: () => void;
 }
 
+/**
+ * Configure performance monitoring
+ */
+export declare function configurePerformance(config: Partial<PerformanceConfig>): void;
+
 /**
  * Configure permission directive
  */
@@ -168,6 +211,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 +350,29 @@ export declare function createPermissionChecker(config: {
     roleMap?: Record<string, string[]>;
 }): (value: string | string[], mode?: PermissionMode) => boolean;
 
+/**
+ * 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 +452,24 @@ export declare function createWatermarkUrl(content: string | string[], options?:
  */
 export declare type CrossVersionDirective = Directive | Vue2DirectiveHooks | Vue3DirectiveHooks;
 
+/**
+ * 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 +496,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 +527,26 @@ export declare function defineDirectiveGroup(name: string, directives: Record<st
     install: (app: any) => void;
 };
 
+/**
+ * Define a Directix plugin
+ */
+export declare function definePlugin(plugin: DirectixPlugin): DirectixPlugin;
+
+/**
+ * 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 +577,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 +623,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 +652,155 @@ export declare interface DirectiveInstallOptions {
     config?: Record<string, any>;
 }
 
+/**
+ * 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;
+
+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;
+}
+
 /**
  * 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[];
+};
+
+/**
+ * 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,6 +823,11 @@ 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
  */
@@ -512,11 +843,86 @@ export declare function generateId(prefix?: string): string;
  */
 export declare function get<T = any>(obj: Record<string, any>, path: string, defaultValue?: T): T;
 
+/**
+ * Get region-specific date format
+ */
+export declare function getDateFormat(region?: string): DateFormatOptions;
+
+/**
+ * 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 +962,44 @@ 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;
+
 /**
  * Intersect event handler
  */
@@ -576,6 +1020,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
  */
@@ -596,6 +1045,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
  */
@@ -631,11 +1085,42 @@ export declare function isVue3(): boolean;
  */
 export declare type ItemSizeFunction = (index: number) => number;
 
+export declare const jaJP: I18nMessages;
+
 /**
  * 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 +1131,38 @@ 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;
+}
+
 /**
  * Pan gesture event data
  */
@@ -669,6 +1181,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 +1218,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
  */
@@ -728,6 +1304,250 @@ export declare interface PinchEvent {
     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 interface PluginRegistryData {
+    /** Registry version */
+    version: number;
+    /** Last updated date */
+    updated: string;
+    /** Plugin list */
+    plugins: PluginRegistryEntry[];
+}
+
+/**
+ * Plugin registry entry
+ */
+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;
+}
+
 /**
  * Position type
  */
@@ -776,6 +1596,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)
  */
@@ -839,16 +1669,41 @@ export declare interface ScrollInfo {
  */
 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;
+
 /**
  * Check if Clipboard API is supported
  */
@@ -884,6 +1739,13 @@ 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;
+
 /**
  * Simple throttle function wrapper
  *
@@ -910,6 +1772,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
  */
@@ -942,6 +1825,16 @@ export declare interface TouchGestureEvent {
     event: TouchEvent;
 }
 
+/**
+ * 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;
+
 /**
  * Trim position
  */
@@ -975,6 +1868,16 @@ export declare type TruncatePosition = 'start' | 'middle' | 'end';
  */
 export declare function truncateText(text: string, maxLength: number, ellipsis?: 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
  */
@@ -6466,6 +7369,66 @@ 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;
+
+/**
+ * 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 +7439,6 @@ export declare const vWatermark: Directive;
  */
 export declare function wouldTextTruncate(text: string, containerWidth: number, fontSize?: number): boolean;
 
+export declare const zhCN: I18nMessages;
+
 export { }