@objectstack/spec 0.9.2 → 1.0.1

package/dist/kernel/plugin-loading.zod.d.ts

@@ -0,0 +1,1774 @@
+import { z } from 'zod';
+/**
+ * # Plugin Loading Protocol
+ *
+ * Defines the enhanced plugin loading mechanism for the microkernel architecture.
+ * Inspired by industry best practices from:
+ * - Kubernetes CRDs and Operators
+ * - OSGi Dynamic Module System
+ * - Eclipse Plugin Framework
+ * - Webpack Module Federation
+ *
+ * This protocol enables:
+ * - Lazy loading and code splitting
+ * - Dynamic imports and parallel initialization
+ * - Capability-based discovery
+ * - Hot reload in development
+ * - Advanced caching strategies
+ */
+/**
+ * Plugin Loading Strategy
+ * Determines how and when a plugin is loaded into memory
+ */
+export declare const PluginLoadingStrategySchema: z.ZodEnum<["eager", "lazy", "parallel", "deferred", "on-demand"]>;
+/**
+ * Plugin Preloading Configuration
+ * Configures preloading behavior for faster activation
+ */
+export declare const PluginPreloadConfigSchema: z.ZodObject<{
+    /**
+     * Enable preloading for this plugin
+     */
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    /**
+     * Preload priority (lower = higher priority)
+     */
+    priority: z.ZodDefault<z.ZodNumber>;
+    /**
+     * Resources to preload
+     */
+    resources: z.ZodOptional<z.ZodArray<z.ZodEnum<["metadata", "dependencies", "assets", "code", "services"]>, "many">>;
+    /**
+     * Conditions for preloading
+     */
+    conditions: z.ZodOptional<z.ZodObject<{
+        /**
+         * Preload only on specific routes
+         */
+        routes: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        /**
+         * Preload only for specific user roles
+         */
+        roles: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        /**
+         * Preload based on device type
+         */
+        deviceType: z.ZodOptional<z.ZodArray<z.ZodEnum<["desktop", "mobile", "tablet"]>, "many">>;
+        /**
+         * Network connection quality threshold
+         */
+        minNetworkSpeed: z.ZodOptional<z.ZodEnum<["slow-2g", "2g", "3g", "4g"]>>;
+    }, "strip", z.ZodTypeAny, {
+        roles?: string[] | undefined;
+        routes?: string[] | undefined;
+        deviceType?: ("desktop" | "mobile" | "tablet")[] | undefined;
+        minNetworkSpeed?: "slow-2g" | "2g" | "3g" | "4g" | undefined;
+    }, {
+        roles?: string[] | undefined;
+        routes?: string[] | undefined;
+        deviceType?: ("desktop" | "mobile" | "tablet")[] | undefined;
+        minNetworkSpeed?: "slow-2g" | "2g" | "3g" | "4g" | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    enabled: boolean;
+    priority: number;
+    conditions?: {
+        roles?: string[] | undefined;
+        routes?: string[] | undefined;
+        deviceType?: ("desktop" | "mobile" | "tablet")[] | undefined;
+        minNetworkSpeed?: "slow-2g" | "2g" | "3g" | "4g" | undefined;
+    } | undefined;
+    resources?: ("code" | "dependencies" | "metadata" | "assets" | "services")[] | undefined;
+}, {
+    enabled?: boolean | undefined;
+    priority?: number | undefined;
+    conditions?: {
+        roles?: string[] | undefined;
+        routes?: string[] | undefined;
+        deviceType?: ("desktop" | "mobile" | "tablet")[] | undefined;
+        minNetworkSpeed?: "slow-2g" | "2g" | "3g" | "4g" | undefined;
+    } | undefined;
+    resources?: ("code" | "dependencies" | "metadata" | "assets" | "services")[] | undefined;
+}>;
+/**
+ * Plugin Code Splitting Configuration
+ * Configures how plugin code is split for optimal loading
+ */
+export declare const PluginCodeSplittingSchema: z.ZodObject<{
+    /**
+     * Enable code splitting for this plugin
+     */
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    /**
+     * Split strategy
+     */
+    strategy: z.ZodDefault<z.ZodEnum<["route", "feature", "size", "custom"]>>;
+    /**
+     * Chunk naming strategy
+     */
+    chunkNaming: z.ZodDefault<z.ZodEnum<["hashed", "named", "sequential"]>>;
+    /**
+     * Maximum chunk size in KB
+     */
+    maxChunkSize: z.ZodOptional<z.ZodNumber>;
+    /**
+     * Shared dependencies optimization
+     */
+    sharedDependencies: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        /**
+         * Minimum times a module must be shared before extraction
+         */
+        minChunks: z.ZodDefault<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        enabled: boolean;
+        minChunks: number;
+    }, {
+        enabled?: boolean | undefined;
+        minChunks?: number | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    enabled: boolean;
+    strategy: "custom" | "size" | "route" | "feature";
+    chunkNaming: "hashed" | "named" | "sequential";
+    maxChunkSize?: number | undefined;
+    sharedDependencies?: {
+        enabled: boolean;
+        minChunks: number;
+    } | undefined;
+}, {
+    enabled?: boolean | undefined;
+    strategy?: "custom" | "size" | "route" | "feature" | undefined;
+    chunkNaming?: "hashed" | "named" | "sequential" | undefined;
+    maxChunkSize?: number | undefined;
+    sharedDependencies?: {
+        enabled?: boolean | undefined;
+        minChunks?: number | undefined;
+    } | undefined;
+}>;
+/**
+ * Plugin Dynamic Import Configuration
+ * Configures dynamic import behavior for runtime module loading
+ */
+export declare const PluginDynamicImportSchema: z.ZodObject<{
+    /**
+     * Enable dynamic imports
+     */
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    /**
+     * Import mode
+     */
+    mode: z.ZodDefault<z.ZodEnum<["async", "sync", "eager", "lazy"]>>;
+    /**
+     * Prefetch strategy
+     */
+    prefetch: z.ZodDefault<z.ZodBoolean>;
+    /**
+     * Preload strategy
+     */
+    preload: z.ZodDefault<z.ZodBoolean>;
+    /**
+     * Webpack magic comments support
+     */
+    webpackChunkName: z.ZodOptional<z.ZodString>;
+    /**
+     * Import timeout in milliseconds
+     */
+    timeout: z.ZodDefault<z.ZodNumber>;
+    /**
+     * Retry configuration on import failure
+     */
+    retry: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        maxAttempts: z.ZodDefault<z.ZodNumber>;
+        backoffMs: z.ZodDefault<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        enabled: boolean;
+        maxAttempts: number;
+        backoffMs: number;
+    }, {
+        enabled?: boolean | undefined;
+        maxAttempts?: number | undefined;
+        backoffMs?: number | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    enabled: boolean;
+    timeout: number;
+    mode: "async" | "eager" | "lazy" | "sync";
+    prefetch: boolean;
+    preload: boolean;
+    retry?: {
+        enabled: boolean;
+        maxAttempts: number;
+        backoffMs: number;
+    } | undefined;
+    webpackChunkName?: string | undefined;
+}, {
+    enabled?: boolean | undefined;
+    timeout?: number | undefined;
+    mode?: "async" | "eager" | "lazy" | "sync" | undefined;
+    retry?: {
+        enabled?: boolean | undefined;
+        maxAttempts?: number | undefined;
+        backoffMs?: number | undefined;
+    } | undefined;
+    prefetch?: boolean | undefined;
+    preload?: boolean | undefined;
+    webpackChunkName?: string | undefined;
+}>;
+/**
+ * Plugin Initialization Configuration
+ * Configures how plugin initialization is executed
+ */
+export declare const PluginInitializationSchema: z.ZodObject<{
+    /**
+     * Initialization mode
+     */
+    mode: z.ZodDefault<z.ZodEnum<["sync", "async", "parallel", "sequential"]>>;
+    /**
+     * Initialization timeout in milliseconds
+     */
+    timeout: z.ZodDefault<z.ZodNumber>;
+    /**
+     * Startup priority (lower = higher priority, earlier initialization)
+     */
+    priority: z.ZodDefault<z.ZodNumber>;
+    /**
+     * Whether to continue bootstrap if this plugin fails
+     */
+    critical: z.ZodDefault<z.ZodBoolean>;
+    /**
+     * Retry configuration on initialization failure
+     */
+    retry: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        maxAttempts: z.ZodDefault<z.ZodNumber>;
+        backoffMs: z.ZodDefault<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        enabled: boolean;
+        maxAttempts: number;
+        backoffMs: number;
+    }, {
+        enabled?: boolean | undefined;
+        maxAttempts?: number | undefined;
+        backoffMs?: number | undefined;
+    }>>;
+    /**
+     * Health check interval for monitoring
+     */
+    healthCheckInterval: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    timeout: number;
+    priority: number;
+    mode: "async" | "parallel" | "sequential" | "sync";
+    critical: boolean;
+    retry?: {
+        enabled: boolean;
+        maxAttempts: number;
+        backoffMs: number;
+    } | undefined;
+    healthCheckInterval?: number | undefined;
+}, {
+    timeout?: number | undefined;
+    priority?: number | undefined;
+    mode?: "async" | "parallel" | "sequential" | "sync" | undefined;
+    retry?: {
+        enabled?: boolean | undefined;
+        maxAttempts?: number | undefined;
+        backoffMs?: number | undefined;
+    } | undefined;
+    critical?: boolean | undefined;
+    healthCheckInterval?: number | undefined;
+}>;
+/**
+ * Plugin Dependency Resolution Configuration
+ * Advanced dependency resolution using semantic versioning
+ */
+export declare const PluginDependencyResolutionSchema: z.ZodObject<{
+    /**
+     * Dependency resolution strategy
+     */
+    strategy: z.ZodDefault<z.ZodEnum<["strict", "compatible", "latest", "pinned"]>>;
+    /**
+     * Peer dependency handling
+     */
+    peerDependencies: z.ZodOptional<z.ZodObject<{
+        /**
+         * Whether to resolve peer dependencies
+         */
+        resolve: z.ZodDefault<z.ZodBoolean>;
+        /**
+         * Action on missing peer dependency
+         */
+        onMissing: z.ZodDefault<z.ZodEnum<["error", "warn", "ignore"]>>;
+        /**
+         * Action on peer version mismatch
+         */
+        onMismatch: z.ZodDefault<z.ZodEnum<["error", "warn", "ignore"]>>;
+    }, "strip", z.ZodTypeAny, {
+        resolve: boolean;
+        onMissing: "error" | "warn" | "ignore";
+        onMismatch: "error" | "warn" | "ignore";
+    }, {
+        resolve?: boolean | undefined;
+        onMissing?: "error" | "warn" | "ignore" | undefined;
+        onMismatch?: "error" | "warn" | "ignore" | undefined;
+    }>>;
+    /**
+     * Optional dependency handling
+     */
+    optionalDependencies: z.ZodOptional<z.ZodObject<{
+        /**
+         * Whether to attempt loading optional dependencies
+         */
+        load: z.ZodDefault<z.ZodBoolean>;
+        /**
+         * Action on optional dependency load failure
+         */
+        onFailure: z.ZodDefault<z.ZodEnum<["warn", "ignore"]>>;
+    }, "strip", z.ZodTypeAny, {
+        load: boolean;
+        onFailure: "warn" | "ignore";
+    }, {
+        load?: boolean | undefined;
+        onFailure?: "warn" | "ignore" | undefined;
+    }>>;
+    /**
+     * Conflict resolution
+     */
+    conflictResolution: z.ZodDefault<z.ZodEnum<["fail", "latest", "oldest", "manual"]>>;
+    /**
+     * Circular dependency handling
+     */
+    circularDependencies: z.ZodDefault<z.ZodEnum<["error", "warn", "allow"]>>;
+}, "strip", z.ZodTypeAny, {
+    strategy: "strict" | "latest" | "compatible" | "pinned";
+    conflictResolution: "latest" | "manual" | "fail" | "oldest";
+    circularDependencies: "error" | "warn" | "allow";
+    peerDependencies?: {
+        resolve: boolean;
+        onMissing: "error" | "warn" | "ignore";
+        onMismatch: "error" | "warn" | "ignore";
+    } | undefined;
+    optionalDependencies?: {
+        load: boolean;
+        onFailure: "warn" | "ignore";
+    } | undefined;
+}, {
+    strategy?: "strict" | "latest" | "compatible" | "pinned" | undefined;
+    conflictResolution?: "latest" | "manual" | "fail" | "oldest" | undefined;
+    peerDependencies?: {
+        resolve?: boolean | undefined;
+        onMissing?: "error" | "warn" | "ignore" | undefined;
+        onMismatch?: "error" | "warn" | "ignore" | undefined;
+    } | undefined;
+    optionalDependencies?: {
+        load?: boolean | undefined;
+        onFailure?: "warn" | "ignore" | undefined;
+    } | undefined;
+    circularDependencies?: "error" | "warn" | "allow" | undefined;
+}>;
+/**
+ * Plugin Hot Reload Configuration
+ * Enables hot module replacement for development
+ */
+export declare const PluginHotReloadSchema: z.ZodObject<{
+    /**
+     * Enable hot reload
+     */
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    /**
+     * Hot reload strategy
+     */
+    strategy: z.ZodDefault<z.ZodEnum<["full", "partial", "state-preserve"]>>;
+    /**
+     * Files to watch for changes
+     */
+    watchPatterns: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    /**
+     * Files to ignore
+     */
+    ignorePatterns: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    /**
+     * Debounce delay in milliseconds
+     */
+    debounceMs: z.ZodDefault<z.ZodNumber>;
+    /**
+     * Whether to preserve state during reload
+     */
+    preserveState: z.ZodDefault<z.ZodBoolean>;
+    /**
+     * State serialization
+     */
+    stateSerialization: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        /**
+         * Path to state serialization handler
+         */
+        handler: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        enabled: boolean;
+        handler?: string | undefined;
+    }, {
+        enabled?: boolean | undefined;
+        handler?: string | undefined;
+    }>>;
+    /**
+     * Hooks for hot reload lifecycle
+     */
+    hooks: z.ZodOptional<z.ZodObject<{
+        beforeReload: z.ZodOptional<z.ZodString>;
+        afterReload: z.ZodOptional<z.ZodString>;
+        onError: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        onError?: string | undefined;
+        beforeReload?: string | undefined;
+        afterReload?: string | undefined;
+    }, {
+        onError?: string | undefined;
+        beforeReload?: string | undefined;
+        afterReload?: string | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    enabled: boolean;
+    strategy: "partial" | "full" | "state-preserve";
+    debounceMs: number;
+    preserveState: boolean;
+    watchPatterns?: string[] | undefined;
+    ignorePatterns?: string[] | undefined;
+    stateSerialization?: {
+        enabled: boolean;
+        handler?: string | undefined;
+    } | undefined;
+    hooks?: {
+        onError?: string | undefined;
+        beforeReload?: string | undefined;
+        afterReload?: string | undefined;
+    } | undefined;
+}, {
+    enabled?: boolean | undefined;
+    strategy?: "partial" | "full" | "state-preserve" | undefined;
+    watchPatterns?: string[] | undefined;
+    ignorePatterns?: string[] | undefined;
+    debounceMs?: number | undefined;
+    preserveState?: boolean | undefined;
+    stateSerialization?: {
+        enabled?: boolean | undefined;
+        handler?: string | undefined;
+    } | undefined;
+    hooks?: {
+        onError?: string | undefined;
+        beforeReload?: string | undefined;
+        afterReload?: string | undefined;
+    } | undefined;
+}>;
+/**
+ * Plugin Caching Configuration
+ * Configures caching strategy for faster subsequent loads
+ */
+export declare const PluginCachingSchema: z.ZodObject<{
+    /**
+     * Enable caching
+     */
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    /**
+     * Cache storage type
+     */
+    storage: z.ZodDefault<z.ZodEnum<["memory", "disk", "indexeddb", "hybrid"]>>;
+    /**
+     * Cache key strategy
+     */
+    keyStrategy: z.ZodDefault<z.ZodEnum<["version", "hash", "timestamp"]>>;
+    /**
+     * Cache TTL in seconds
+     */
+    ttl: z.ZodOptional<z.ZodNumber>;
+    /**
+     * Maximum cache size in MB
+     */
+    maxSize: z.ZodOptional<z.ZodNumber>;
+    /**
+     * Cache invalidation triggers
+     */
+    invalidateOn: z.ZodOptional<z.ZodArray<z.ZodEnum<["version-change", "dependency-change", "manual", "error"]>, "many">>;
+    /**
+     * Compression
+     */
+    compression: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        algorithm: z.ZodDefault<z.ZodEnum<["gzip", "brotli", "deflate"]>>;
+    }, "strip", z.ZodTypeAny, {
+        enabled: boolean;
+        algorithm: "gzip" | "brotli" | "deflate";
+    }, {
+        enabled?: boolean | undefined;
+        algorithm?: "gzip" | "brotli" | "deflate" | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    enabled: boolean;
+    storage: "hybrid" | "memory" | "disk" | "indexeddb";
+    keyStrategy: "hash" | "version" | "timestamp";
+    maxSize?: number | undefined;
+    ttl?: number | undefined;
+    invalidateOn?: ("error" | "manual" | "version-change" | "dependency-change")[] | undefined;
+    compression?: {
+        enabled: boolean;
+        algorithm: "gzip" | "brotli" | "deflate";
+    } | undefined;
+}, {
+    enabled?: boolean | undefined;
+    maxSize?: number | undefined;
+    ttl?: number | undefined;
+    invalidateOn?: ("error" | "manual" | "version-change" | "dependency-change")[] | undefined;
+    compression?: {
+        enabled?: boolean | undefined;
+        algorithm?: "gzip" | "brotli" | "deflate" | undefined;
+    } | undefined;
+    storage?: "hybrid" | "memory" | "disk" | "indexeddb" | undefined;
+    keyStrategy?: "hash" | "version" | "timestamp" | undefined;
+}>;
+/**
+ * Plugin Sandboxing Configuration
+ * Security isolation for untrusted plugins
+ */
+export declare const PluginSandboxingSchema: z.ZodObject<{
+    /**
+     * Enable sandboxing
+     */
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    /**
+     * Sandbox isolation level
+     */
+    isolationLevel: z.ZodDefault<z.ZodEnum<["none", "process", "vm", "iframe", "web-worker"]>>;
+    /**
+     * Allowed capabilities
+     */
+    allowedCapabilities: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    /**
+     * Resource quotas
+     */
+    resourceQuotas: z.ZodOptional<z.ZodObject<{
+        /**
+         * Maximum memory usage in MB
+         */
+        maxMemoryMB: z.ZodOptional<z.ZodNumber>;
+        /**
+         * Maximum CPU time in milliseconds
+         */
+        maxCpuTimeMs: z.ZodOptional<z.ZodNumber>;
+        /**
+         * Maximum number of file descriptors
+         */
+        maxFileDescriptors: z.ZodOptional<z.ZodNumber>;
+        /**
+         * Maximum network bandwidth in KB/s
+         */
+        maxNetworkKBps: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        maxMemoryMB?: number | undefined;
+        maxCpuTimeMs?: number | undefined;
+        maxFileDescriptors?: number | undefined;
+        maxNetworkKBps?: number | undefined;
+    }, {
+        maxMemoryMB?: number | undefined;
+        maxCpuTimeMs?: number | undefined;
+        maxFileDescriptors?: number | undefined;
+        maxNetworkKBps?: number | undefined;
+    }>>;
+    /**
+     * Permissions
+     */
+    permissions: z.ZodOptional<z.ZodObject<{
+        /**
+         * Allowed API access
+         */
+        allowedAPIs: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        /**
+         * Allowed file system paths
+         */
+        allowedPaths: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        /**
+         * Allowed network endpoints
+         */
+        allowedEndpoints: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        /**
+         * Allowed environment variables
+         */
+        allowedEnvVars: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        allowedAPIs?: string[] | undefined;
+        allowedPaths?: string[] | undefined;
+        allowedEndpoints?: string[] | undefined;
+        allowedEnvVars?: string[] | undefined;
+    }, {
+        allowedAPIs?: string[] | undefined;
+        allowedPaths?: string[] | undefined;
+        allowedEndpoints?: string[] | undefined;
+        allowedEnvVars?: string[] | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    enabled: boolean;
+    isolationLevel: "none" | "process" | "vm" | "iframe" | "web-worker";
+    permissions?: {
+        allowedAPIs?: string[] | undefined;
+        allowedPaths?: string[] | undefined;
+        allowedEndpoints?: string[] | undefined;
+        allowedEnvVars?: string[] | undefined;
+    } | undefined;
+    allowedCapabilities?: string[] | undefined;
+    resourceQuotas?: {
+        maxMemoryMB?: number | undefined;
+        maxCpuTimeMs?: number | undefined;
+        maxFileDescriptors?: number | undefined;
+        maxNetworkKBps?: number | undefined;
+    } | undefined;
+}, {
+    enabled?: boolean | undefined;
+    isolationLevel?: "none" | "process" | "vm" | "iframe" | "web-worker" | undefined;
+    permissions?: {
+        allowedAPIs?: string[] | undefined;
+        allowedPaths?: string[] | undefined;
+        allowedEndpoints?: string[] | undefined;
+        allowedEnvVars?: string[] | undefined;
+    } | undefined;
+    allowedCapabilities?: string[] | undefined;
+    resourceQuotas?: {
+        maxMemoryMB?: number | undefined;
+        maxCpuTimeMs?: number | undefined;
+        maxFileDescriptors?: number | undefined;
+        maxNetworkKBps?: number | undefined;
+    } | undefined;
+}>;
+/**
+ * Plugin Performance Monitoring Configuration
+ * Telemetry and performance tracking
+ */
+export declare const PluginPerformanceMonitoringSchema: z.ZodObject<{
+    /**
+     * Enable performance monitoring
+     */
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    /**
+     * Metrics to collect
+     */
+    metrics: z.ZodOptional<z.ZodArray<z.ZodEnum<["load-time", "init-time", "memory-usage", "cpu-usage", "api-calls", "error-rate", "cache-hit-rate"]>, "many">>;
+    /**
+     * Sampling rate (0-1, where 1 = 100%)
+     */
+    samplingRate: z.ZodDefault<z.ZodNumber>;
+    /**
+     * Reporting interval in seconds
+     */
+    reportingInterval: z.ZodDefault<z.ZodNumber>;
+    /**
+     * Performance budget thresholds
+     */
+    budgets: z.ZodOptional<z.ZodObject<{
+        /**
+         * Maximum load time in milliseconds
+         */
+        maxLoadTimeMs: z.ZodOptional<z.ZodNumber>;
+        /**
+         * Maximum init time in milliseconds
+         */
+        maxInitTimeMs: z.ZodOptional<z.ZodNumber>;
+        /**
+         * Maximum memory usage in MB
+         */
+        maxMemoryMB: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        maxMemoryMB?: number | undefined;
+        maxLoadTimeMs?: number | undefined;
+        maxInitTimeMs?: number | undefined;
+    }, {
+        maxMemoryMB?: number | undefined;
+        maxLoadTimeMs?: number | undefined;
+        maxInitTimeMs?: number | undefined;
+    }>>;
+    /**
+     * Action on budget violation
+     */
+    onBudgetViolation: z.ZodDefault<z.ZodEnum<["warn", "error", "ignore"]>>;
+}, "strip", z.ZodTypeAny, {
+    enabled: boolean;
+    samplingRate: number;
+    reportingInterval: number;
+    onBudgetViolation: "error" | "warn" | "ignore";
+    metrics?: ("load-time" | "init-time" | "memory-usage" | "cpu-usage" | "api-calls" | "error-rate" | "cache-hit-rate")[] | undefined;
+    budgets?: {
+        maxMemoryMB?: number | undefined;
+        maxLoadTimeMs?: number | undefined;
+        maxInitTimeMs?: number | undefined;
+    } | undefined;
+}, {
+    enabled?: boolean | undefined;
+    metrics?: ("load-time" | "init-time" | "memory-usage" | "cpu-usage" | "api-calls" | "error-rate" | "cache-hit-rate")[] | undefined;
+    samplingRate?: number | undefined;
+    reportingInterval?: number | undefined;
+    budgets?: {
+        maxMemoryMB?: number | undefined;
+        maxLoadTimeMs?: number | undefined;
+        maxInitTimeMs?: number | undefined;
+    } | undefined;
+    onBudgetViolation?: "error" | "warn" | "ignore" | undefined;
+}>;
+/**
+ * Complete Plugin Loading Configuration
+ * Combines all loading-related configurations
+ */
+export declare const PluginLoadingConfigSchema: z.ZodObject<{
+    /**
+     * Loading strategy
+     */
+    strategy: z.ZodDefault<z.ZodEnum<["eager", "lazy", "parallel", "deferred", "on-demand"]>>;
+    /**
+     * Preloading configuration
+     */
+    preload: z.ZodOptional<z.ZodObject<{
+        /**
+         * Enable preloading for this plugin
+         */
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        /**
+         * Preload priority (lower = higher priority)
+         */
+        priority: z.ZodDefault<z.ZodNumber>;
+        /**
+         * Resources to preload
+         */
+        resources: z.ZodOptional<z.ZodArray<z.ZodEnum<["metadata", "dependencies", "assets", "code", "services"]>, "many">>;
+        /**
+         * Conditions for preloading
+         */
+        conditions: z.ZodOptional<z.ZodObject<{
+            /**
+             * Preload only on specific routes
+             */
+            routes: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            /**
+             * Preload only for specific user roles
+             */
+            roles: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            /**
+             * Preload based on device type
+             */
+            deviceType: z.ZodOptional<z.ZodArray<z.ZodEnum<["desktop", "mobile", "tablet"]>, "many">>;
+            /**
+             * Network connection quality threshold
+             */
+            minNetworkSpeed: z.ZodOptional<z.ZodEnum<["slow-2g", "2g", "3g", "4g"]>>;
+        }, "strip", z.ZodTypeAny, {
+            roles?: string[] | undefined;
+            routes?: string[] | undefined;
+            deviceType?: ("desktop" | "mobile" | "tablet")[] | undefined;
+            minNetworkSpeed?: "slow-2g" | "2g" | "3g" | "4g" | undefined;
+        }, {
+            roles?: string[] | undefined;
+            routes?: string[] | undefined;
+            deviceType?: ("desktop" | "mobile" | "tablet")[] | undefined;
+            minNetworkSpeed?: "slow-2g" | "2g" | "3g" | "4g" | undefined;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        enabled: boolean;
+        priority: number;
+        conditions?: {
+            roles?: string[] | undefined;
+            routes?: string[] | undefined;
+            deviceType?: ("desktop" | "mobile" | "tablet")[] | undefined;
+            minNetworkSpeed?: "slow-2g" | "2g" | "3g" | "4g" | undefined;
+        } | undefined;
+        resources?: ("code" | "dependencies" | "metadata" | "assets" | "services")[] | undefined;
+    }, {
+        enabled?: boolean | undefined;
+        priority?: number | undefined;
+        conditions?: {
+            roles?: string[] | undefined;
+            routes?: string[] | undefined;
+            deviceType?: ("desktop" | "mobile" | "tablet")[] | undefined;
+            minNetworkSpeed?: "slow-2g" | "2g" | "3g" | "4g" | undefined;
+        } | undefined;
+        resources?: ("code" | "dependencies" | "metadata" | "assets" | "services")[] | undefined;
+    }>>;
+    /**
+     * Code splitting configuration
+     */
+    codeSplitting: z.ZodOptional<z.ZodObject<{
+        /**
+         * Enable code splitting for this plugin
+         */
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        /**
+         * Split strategy
+         */
+        strategy: z.ZodDefault<z.ZodEnum<["route", "feature", "size", "custom"]>>;
+        /**
+         * Chunk naming strategy
+         */
+        chunkNaming: z.ZodDefault<z.ZodEnum<["hashed", "named", "sequential"]>>;
+        /**
+         * Maximum chunk size in KB
+         */
+        maxChunkSize: z.ZodOptional<z.ZodNumber>;
+        /**
+         * Shared dependencies optimization
+         */
+        sharedDependencies: z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            /**
+             * Minimum times a module must be shared before extraction
+             */
+            minChunks: z.ZodDefault<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            enabled: boolean;
+            minChunks: number;
+        }, {
+            enabled?: boolean | undefined;
+            minChunks?: number | undefined;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        enabled: boolean;
+        strategy: "custom" | "size" | "route" | "feature";
+        chunkNaming: "hashed" | "named" | "sequential";
+        maxChunkSize?: number | undefined;
+        sharedDependencies?: {
+            enabled: boolean;
+            minChunks: number;
+        } | undefined;
+    }, {
+        enabled?: boolean | undefined;
+        strategy?: "custom" | "size" | "route" | "feature" | undefined;
+        chunkNaming?: "hashed" | "named" | "sequential" | undefined;
+        maxChunkSize?: number | undefined;
+        sharedDependencies?: {
+            enabled?: boolean | undefined;
+            minChunks?: number | undefined;
+        } | undefined;
+    }>>;
+    /**
+     * Dynamic import configuration
+     */
+    dynamicImport: z.ZodOptional<z.ZodObject<{
+        /**
+         * Enable dynamic imports
+         */
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        /**
+         * Import mode
+         */
+        mode: z.ZodDefault<z.ZodEnum<["async", "sync", "eager", "lazy"]>>;
+        /**
+         * Prefetch strategy
+         */
+        prefetch: z.ZodDefault<z.ZodBoolean>;
+        /**
+         * Preload strategy
+         */
+        preload: z.ZodDefault<z.ZodBoolean>;
+        /**
+         * Webpack magic comments support
+         */
+        webpackChunkName: z.ZodOptional<z.ZodString>;
+        /**
+         * Import timeout in milliseconds
+         */
+        timeout: z.ZodDefault<z.ZodNumber>;
+        /**
+         * Retry configuration on import failure
+         */
+        retry: z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            maxAttempts: z.ZodDefault<z.ZodNumber>;
+            backoffMs: z.ZodDefault<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            enabled: boolean;
+            maxAttempts: number;
+            backoffMs: number;
+        }, {
+            enabled?: boolean | undefined;
+            maxAttempts?: number | undefined;
+            backoffMs?: number | undefined;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        enabled: boolean;
+        timeout: number;
+        mode: "async" | "eager" | "lazy" | "sync";
+        prefetch: boolean;
+        preload: boolean;
+        retry?: {
+            enabled: boolean;
+            maxAttempts: number;
+            backoffMs: number;
+        } | undefined;
+        webpackChunkName?: string | undefined;
+    }, {
+        enabled?: boolean | undefined;
+        timeout?: number | undefined;
+        mode?: "async" | "eager" | "lazy" | "sync" | undefined;
+        retry?: {
+            enabled?: boolean | undefined;
+            maxAttempts?: number | undefined;
+            backoffMs?: number | undefined;
+        } | undefined;
+        prefetch?: boolean | undefined;
+        preload?: boolean | undefined;
+        webpackChunkName?: string | undefined;
+    }>>;
+    /**
+     * Initialization configuration
+     */
+    initialization: z.ZodOptional<z.ZodObject<{
+        /**
+         * Initialization mode
+         */
+        mode: z.ZodDefault<z.ZodEnum<["sync", "async", "parallel", "sequential"]>>;
+        /**
+         * Initialization timeout in milliseconds
+         */
+        timeout: z.ZodDefault<z.ZodNumber>;
+        /**
+         * Startup priority (lower = higher priority, earlier initialization)
+         */
+        priority: z.ZodDefault<z.ZodNumber>;
+        /**
+         * Whether to continue bootstrap if this plugin fails
+         */
+        critical: z.ZodDefault<z.ZodBoolean>;
+        /**
+         * Retry configuration on initialization failure
+         */
+        retry: z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            maxAttempts: z.ZodDefault<z.ZodNumber>;
+            backoffMs: z.ZodDefault<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            enabled: boolean;
+            maxAttempts: number;
+            backoffMs: number;
+        }, {
+            enabled?: boolean | undefined;
+            maxAttempts?: number | undefined;
+            backoffMs?: number | undefined;
+        }>>;
+        /**
+         * Health check interval for monitoring
+         */
+        healthCheckInterval: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        timeout: number;
+        priority: number;
+        mode: "async" | "parallel" | "sequential" | "sync";
+        critical: boolean;
+        retry?: {
+            enabled: boolean;
+            maxAttempts: number;
+            backoffMs: number;
+        } | undefined;
+        healthCheckInterval?: number | undefined;
+    }, {
+        timeout?: number | undefined;
+        priority?: number | undefined;
+        mode?: "async" | "parallel" | "sequential" | "sync" | undefined;
+        retry?: {
+            enabled?: boolean | undefined;
+            maxAttempts?: number | undefined;
+            backoffMs?: number | undefined;
+        } | undefined;
+        critical?: boolean | undefined;
+        healthCheckInterval?: number | undefined;
+    }>>;
+    /**
+     * Dependency resolution configuration
+     */
+    dependencyResolution: z.ZodOptional<z.ZodObject<{
+        /**
+         * Dependency resolution strategy
+         */
+        strategy: z.ZodDefault<z.ZodEnum<["strict", "compatible", "latest", "pinned"]>>;
+        /**
+         * Peer dependency handling
+         */
+        peerDependencies: z.ZodOptional<z.ZodObject<{
+            /**
+             * Whether to resolve peer dependencies
+             */
+            resolve: z.ZodDefault<z.ZodBoolean>;
+            /**
+             * Action on missing peer dependency
+             */
+            onMissing: z.ZodDefault<z.ZodEnum<["error", "warn", "ignore"]>>;
+            /**
+             * Action on peer version mismatch
+             */
+            onMismatch: z.ZodDefault<z.ZodEnum<["error", "warn", "ignore"]>>;
+        }, "strip", z.ZodTypeAny, {
+            resolve: boolean;
+            onMissing: "error" | "warn" | "ignore";
+            onMismatch: "error" | "warn" | "ignore";
+        }, {
+            resolve?: boolean | undefined;
+            onMissing?: "error" | "warn" | "ignore" | undefined;
+            onMismatch?: "error" | "warn" | "ignore" | undefined;
+        }>>;
+        /**
+         * Optional dependency handling
+         */
+        optionalDependencies: z.ZodOptional<z.ZodObject<{
+            /**
+             * Whether to attempt loading optional dependencies
+             */
+            load: z.ZodDefault<z.ZodBoolean>;
+            /**
+             * Action on optional dependency load failure
+             */
+            onFailure: z.ZodDefault<z.ZodEnum<["warn", "ignore"]>>;
+        }, "strip", z.ZodTypeAny, {
+            load: boolean;
+            onFailure: "warn" | "ignore";
+        }, {
+            load?: boolean | undefined;
+            onFailure?: "warn" | "ignore" | undefined;
+        }>>;
+        /**
+         * Conflict resolution
+         */
+        conflictResolution: z.ZodDefault<z.ZodEnum<["fail", "latest", "oldest", "manual"]>>;
+        /**
+         * Circular dependency handling
+         */
+        circularDependencies: z.ZodDefault<z.ZodEnum<["error", "warn", "allow"]>>;
+    }, "strip", z.ZodTypeAny, {
+        strategy: "strict" | "latest" | "compatible" | "pinned";
+        conflictResolution: "latest" | "manual" | "fail" | "oldest";
+        circularDependencies: "error" | "warn" | "allow";
+        peerDependencies?: {
+            resolve: boolean;
+            onMissing: "error" | "warn" | "ignore";
+            onMismatch: "error" | "warn" | "ignore";
+        } | undefined;
+        optionalDependencies?: {
+            load: boolean;
+            onFailure: "warn" | "ignore";
+        } | undefined;
+    }, {
+        strategy?: "strict" | "latest" | "compatible" | "pinned" | undefined;
+        conflictResolution?: "latest" | "manual" | "fail" | "oldest" | undefined;
+        peerDependencies?: {
+            resolve?: boolean | undefined;
+            onMissing?: "error" | "warn" | "ignore" | undefined;
+            onMismatch?: "error" | "warn" | "ignore" | undefined;
+        } | undefined;
+        optionalDependencies?: {
+            load?: boolean | undefined;
+            onFailure?: "warn" | "ignore" | undefined;
+        } | undefined;
+        circularDependencies?: "error" | "warn" | "allow" | undefined;
+    }>>;
+    /**
+     * Hot reload configuration (development only)
+     */
+    hotReload: z.ZodOptional<z.ZodObject<{
+        /**
+         * Enable hot reload
+         */
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        /**
+         * Hot reload strategy
+         */
+        strategy: z.ZodDefault<z.ZodEnum<["full", "partial", "state-preserve"]>>;
+        /**
+         * Files to watch for changes
+         */
+        watchPatterns: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        /**
+         * Files to ignore
+         */
+        ignorePatterns: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        /**
+         * Debounce delay in milliseconds
+         */
+        debounceMs: z.ZodDefault<z.ZodNumber>;
+        /**
+         * Whether to preserve state during reload
+         */
+        preserveState: z.ZodDefault<z.ZodBoolean>;
+        /**
+         * State serialization
+         */
+        stateSerialization: z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            /**
+             * Path to state serialization handler
+             */
+            handler: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            enabled: boolean;
+            handler?: string | undefined;
+        }, {
+            enabled?: boolean | undefined;
+            handler?: string | undefined;
+        }>>;
+        /**
+         * Hooks for hot reload lifecycle
+         */
+        hooks: z.ZodOptional<z.ZodObject<{
+            beforeReload: z.ZodOptional<z.ZodString>;
+            afterReload: z.ZodOptional<z.ZodString>;
+            onError: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            onError?: string | undefined;
+            beforeReload?: string | undefined;
+            afterReload?: string | undefined;
+        }, {
+            onError?: string | undefined;
+            beforeReload?: string | undefined;
+            afterReload?: string | undefined;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        enabled: boolean;
+        strategy: "partial" | "full" | "state-preserve";
+        debounceMs: number;
+        preserveState: boolean;
+        watchPatterns?: string[] | undefined;
+        ignorePatterns?: string[] | undefined;
+        stateSerialization?: {
+            enabled: boolean;
+            handler?: string | undefined;
+        } | undefined;
+        hooks?: {
+            onError?: string | undefined;
+            beforeReload?: string | undefined;
+            afterReload?: string | undefined;
+        } | undefined;
+    }, {
+        enabled?: boolean | undefined;
+        strategy?: "partial" | "full" | "state-preserve" | undefined;
+        watchPatterns?: string[] | undefined;
+        ignorePatterns?: string[] | undefined;
+        debounceMs?: number | undefined;
+        preserveState?: boolean | undefined;
+        stateSerialization?: {
+            enabled?: boolean | undefined;
+            handler?: string | undefined;
+        } | undefined;
+        hooks?: {
+            onError?: string | undefined;
+            beforeReload?: string | undefined;
+            afterReload?: string | undefined;
+        } | undefined;
+    }>>;
+    /**
+     * Caching configuration
+     */
+    caching: z.ZodOptional<z.ZodObject<{
+        /**
+         * Enable caching
+         */
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        /**
+         * Cache storage type
+         */
+        storage: z.ZodDefault<z.ZodEnum<["memory", "disk", "indexeddb", "hybrid"]>>;
+        /**
+         * Cache key strategy
+         */
+        keyStrategy: z.ZodDefault<z.ZodEnum<["version", "hash", "timestamp"]>>;
+        /**
+         * Cache TTL in seconds
+         */
+        ttl: z.ZodOptional<z.ZodNumber>;
+        /**
+         * Maximum cache size in MB
+         */
+        maxSize: z.ZodOptional<z.ZodNumber>;
+        /**
+         * Cache invalidation triggers
+         */
+        invalidateOn: z.ZodOptional<z.ZodArray<z.ZodEnum<["version-change", "dependency-change", "manual", "error"]>, "many">>;
+        /**
+         * Compression
+         */
+        compression: z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            algorithm: z.ZodDefault<z.ZodEnum<["gzip", "brotli", "deflate"]>>;
+        }, "strip", z.ZodTypeAny, {
+            enabled: boolean;
+            algorithm: "gzip" | "brotli" | "deflate";
+        }, {
+            enabled?: boolean | undefined;
+            algorithm?: "gzip" | "brotli" | "deflate" | undefined;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        enabled: boolean;
+        storage: "hybrid" | "memory" | "disk" | "indexeddb";
+        keyStrategy: "hash" | "version" | "timestamp";
+        maxSize?: number | undefined;
+        ttl?: number | undefined;
+        invalidateOn?: ("error" | "manual" | "version-change" | "dependency-change")[] | undefined;
+        compression?: {
+            enabled: boolean;
+            algorithm: "gzip" | "brotli" | "deflate";
+        } | undefined;
+    }, {
+        enabled?: boolean | undefined;
+        maxSize?: number | undefined;
+        ttl?: number | undefined;
+        invalidateOn?: ("error" | "manual" | "version-change" | "dependency-change")[] | undefined;
+        compression?: {
+            enabled?: boolean | undefined;
+            algorithm?: "gzip" | "brotli" | "deflate" | undefined;
+        } | undefined;
+        storage?: "hybrid" | "memory" | "disk" | "indexeddb" | undefined;
+        keyStrategy?: "hash" | "version" | "timestamp" | undefined;
+    }>>;
+    /**
+     * Sandboxing configuration
+     */
+    sandboxing: z.ZodOptional<z.ZodObject<{
+        /**
+         * Enable sandboxing
+         */
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        /**
+         * Sandbox isolation level
+         */
+        isolationLevel: z.ZodDefault<z.ZodEnum<["none", "process", "vm", "iframe", "web-worker"]>>;
+        /**
+         * Allowed capabilities
+         */
+        allowedCapabilities: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        /**
+         * Resource quotas
+         */
+        resourceQuotas: z.ZodOptional<z.ZodObject<{
+            /**
+             * Maximum memory usage in MB
+             */
+            maxMemoryMB: z.ZodOptional<z.ZodNumber>;
+            /**
+             * Maximum CPU time in milliseconds
+             */
+            maxCpuTimeMs: z.ZodOptional<z.ZodNumber>;
+            /**
+             * Maximum number of file descriptors
+             */
+            maxFileDescriptors: z.ZodOptional<z.ZodNumber>;
+            /**
+             * Maximum network bandwidth in KB/s
+             */
+            maxNetworkKBps: z.ZodOptional<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            maxMemoryMB?: number | undefined;
+            maxCpuTimeMs?: number | undefined;
+            maxFileDescriptors?: number | undefined;
+            maxNetworkKBps?: number | undefined;
+        }, {
+            maxMemoryMB?: number | undefined;
+            maxCpuTimeMs?: number | undefined;
+            maxFileDescriptors?: number | undefined;
+            maxNetworkKBps?: number | undefined;
+        }>>;
+        /**
+         * Permissions
+         */
+        permissions: z.ZodOptional<z.ZodObject<{
+            /**
+             * Allowed API access
+             */
+            allowedAPIs: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            /**
+             * Allowed file system paths
+             */
+            allowedPaths: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            /**
+             * Allowed network endpoints
+             */
+            allowedEndpoints: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            /**
+             * Allowed environment variables
+             */
+            allowedEnvVars: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        }, "strip", z.ZodTypeAny, {
+            allowedAPIs?: string[] | undefined;
+            allowedPaths?: string[] | undefined;
+            allowedEndpoints?: string[] | undefined;
+            allowedEnvVars?: string[] | undefined;
+        }, {
+            allowedAPIs?: string[] | undefined;
+            allowedPaths?: string[] | undefined;
+            allowedEndpoints?: string[] | undefined;
+            allowedEnvVars?: string[] | undefined;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        enabled: boolean;
+        isolationLevel: "none" | "process" | "vm" | "iframe" | "web-worker";
+        permissions?: {
+            allowedAPIs?: string[] | undefined;
+            allowedPaths?: string[] | undefined;
+            allowedEndpoints?: string[] | undefined;
+            allowedEnvVars?: string[] | undefined;
+        } | undefined;
+        allowedCapabilities?: string[] | undefined;
+        resourceQuotas?: {
+            maxMemoryMB?: number | undefined;
+            maxCpuTimeMs?: number | undefined;
+            maxFileDescriptors?: number | undefined;
+            maxNetworkKBps?: number | undefined;
+        } | undefined;
+    }, {
+        enabled?: boolean | undefined;
+        isolationLevel?: "none" | "process" | "vm" | "iframe" | "web-worker" | undefined;
+        permissions?: {
+            allowedAPIs?: string[] | undefined;
+            allowedPaths?: string[] | undefined;
+            allowedEndpoints?: string[] | undefined;
+            allowedEnvVars?: string[] | undefined;
+        } | undefined;
+        allowedCapabilities?: string[] | undefined;
+        resourceQuotas?: {
+            maxMemoryMB?: number | undefined;
+            maxCpuTimeMs?: number | undefined;
+            maxFileDescriptors?: number | undefined;
+            maxNetworkKBps?: number | undefined;
+        } | undefined;
+    }>>;
+    /**
+     * Performance monitoring
+     */
+    monitoring: z.ZodOptional<z.ZodObject<{
+        /**
+         * Enable performance monitoring
+         */
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        /**
+         * Metrics to collect
+         */
+        metrics: z.ZodOptional<z.ZodArray<z.ZodEnum<["load-time", "init-time", "memory-usage", "cpu-usage", "api-calls", "error-rate", "cache-hit-rate"]>, "many">>;
+        /**
+         * Sampling rate (0-1, where 1 = 100%)
+         */
+        samplingRate: z.ZodDefault<z.ZodNumber>;
+        /**
+         * Reporting interval in seconds
+         */
+        reportingInterval: z.ZodDefault<z.ZodNumber>;
+        /**
+         * Performance budget thresholds
+         */
+        budgets: z.ZodOptional<z.ZodObject<{
+            /**
+             * Maximum load time in milliseconds
+             */
+            maxLoadTimeMs: z.ZodOptional<z.ZodNumber>;
+            /**
+             * Maximum init time in milliseconds
+             */
+            maxInitTimeMs: z.ZodOptional<z.ZodNumber>;
+            /**
+             * Maximum memory usage in MB
+             */
+            maxMemoryMB: z.ZodOptional<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            maxMemoryMB?: number | undefined;
+            maxLoadTimeMs?: number | undefined;
+            maxInitTimeMs?: number | undefined;
+        }, {
+            maxMemoryMB?: number | undefined;
+            maxLoadTimeMs?: number | undefined;
+            maxInitTimeMs?: number | undefined;
+        }>>;
+        /**
+         * Action on budget violation
+         */
+        onBudgetViolation: z.ZodDefault<z.ZodEnum<["warn", "error", "ignore"]>>;
+    }, "strip", z.ZodTypeAny, {
+        enabled: boolean;
+        samplingRate: number;
+        reportingInterval: number;
+        onBudgetViolation: "error" | "warn" | "ignore";
+        metrics?: ("load-time" | "init-time" | "memory-usage" | "cpu-usage" | "api-calls" | "error-rate" | "cache-hit-rate")[] | undefined;
+        budgets?: {
+            maxMemoryMB?: number | undefined;
+            maxLoadTimeMs?: number | undefined;
+            maxInitTimeMs?: number | undefined;
+        } | undefined;
+    }, {
+        enabled?: boolean | undefined;
+        metrics?: ("load-time" | "init-time" | "memory-usage" | "cpu-usage" | "api-calls" | "error-rate" | "cache-hit-rate")[] | undefined;
+        samplingRate?: number | undefined;
+        reportingInterval?: number | undefined;
+        budgets?: {
+            maxMemoryMB?: number | undefined;
+            maxLoadTimeMs?: number | undefined;
+            maxInitTimeMs?: number | undefined;
+        } | undefined;
+        onBudgetViolation?: "error" | "warn" | "ignore" | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    strategy: "parallel" | "eager" | "lazy" | "deferred" | "on-demand";
+    caching?: {
+        enabled: boolean;
+        storage: "hybrid" | "memory" | "disk" | "indexeddb";
+        keyStrategy: "hash" | "version" | "timestamp";
+        maxSize?: number | undefined;
+        ttl?: number | undefined;
+        invalidateOn?: ("error" | "manual" | "version-change" | "dependency-change")[] | undefined;
+        compression?: {
+            enabled: boolean;
+            algorithm: "gzip" | "brotli" | "deflate";
+        } | undefined;
+    } | undefined;
+    preload?: {
+        enabled: boolean;
+        priority: number;
+        conditions?: {
+            roles?: string[] | undefined;
+            routes?: string[] | undefined;
+            deviceType?: ("desktop" | "mobile" | "tablet")[] | undefined;
+            minNetworkSpeed?: "slow-2g" | "2g" | "3g" | "4g" | undefined;
+        } | undefined;
+        resources?: ("code" | "dependencies" | "metadata" | "assets" | "services")[] | undefined;
+    } | undefined;
+    codeSplitting?: {
+        enabled: boolean;
+        strategy: "custom" | "size" | "route" | "feature";
+        chunkNaming: "hashed" | "named" | "sequential";
+        maxChunkSize?: number | undefined;
+        sharedDependencies?: {
+            enabled: boolean;
+            minChunks: number;
+        } | undefined;
+    } | undefined;
+    dynamicImport?: {
+        enabled: boolean;
+        timeout: number;
+        mode: "async" | "eager" | "lazy" | "sync";
+        prefetch: boolean;
+        preload: boolean;
+        retry?: {
+            enabled: boolean;
+            maxAttempts: number;
+            backoffMs: number;
+        } | undefined;
+        webpackChunkName?: string | undefined;
+    } | undefined;
+    initialization?: {
+        timeout: number;
+        priority: number;
+        mode: "async" | "parallel" | "sequential" | "sync";
+        critical: boolean;
+        retry?: {
+            enabled: boolean;
+            maxAttempts: number;
+            backoffMs: number;
+        } | undefined;
+        healthCheckInterval?: number | undefined;
+    } | undefined;
+    dependencyResolution?: {
+        strategy: "strict" | "latest" | "compatible" | "pinned";
+        conflictResolution: "latest" | "manual" | "fail" | "oldest";
+        circularDependencies: "error" | "warn" | "allow";
+        peerDependencies?: {
+            resolve: boolean;
+            onMissing: "error" | "warn" | "ignore";
+            onMismatch: "error" | "warn" | "ignore";
+        } | undefined;
+        optionalDependencies?: {
+            load: boolean;
+            onFailure: "warn" | "ignore";
+        } | undefined;
+    } | undefined;
+    hotReload?: {
+        enabled: boolean;
+        strategy: "partial" | "full" | "state-preserve";
+        debounceMs: number;
+        preserveState: boolean;
+        watchPatterns?: string[] | undefined;
+        ignorePatterns?: string[] | undefined;
+        stateSerialization?: {
+            enabled: boolean;
+            handler?: string | undefined;
+        } | undefined;
+        hooks?: {
+            onError?: string | undefined;
+            beforeReload?: string | undefined;
+            afterReload?: string | undefined;
+        } | undefined;
+    } | undefined;
+    sandboxing?: {
+        enabled: boolean;
+        isolationLevel: "none" | "process" | "vm" | "iframe" | "web-worker";
+        permissions?: {
+            allowedAPIs?: string[] | undefined;
+            allowedPaths?: string[] | undefined;
+            allowedEndpoints?: string[] | undefined;
+            allowedEnvVars?: string[] | undefined;
+        } | undefined;
+        allowedCapabilities?: string[] | undefined;
+        resourceQuotas?: {
+            maxMemoryMB?: number | undefined;
+            maxCpuTimeMs?: number | undefined;
+            maxFileDescriptors?: number | undefined;
+            maxNetworkKBps?: number | undefined;
+        } | undefined;
+    } | undefined;
+    monitoring?: {
+        enabled: boolean;
+        samplingRate: number;
+        reportingInterval: number;
+        onBudgetViolation: "error" | "warn" | "ignore";
+        metrics?: ("load-time" | "init-time" | "memory-usage" | "cpu-usage" | "api-calls" | "error-rate" | "cache-hit-rate")[] | undefined;
+        budgets?: {
+            maxMemoryMB?: number | undefined;
+            maxLoadTimeMs?: number | undefined;
+            maxInitTimeMs?: number | undefined;
+        } | undefined;
+    } | undefined;
+}, {
+    strategy?: "parallel" | "eager" | "lazy" | "deferred" | "on-demand" | undefined;
+    caching?: {
+        enabled?: boolean | undefined;
+        maxSize?: number | undefined;
+        ttl?: number | undefined;
+        invalidateOn?: ("error" | "manual" | "version-change" | "dependency-change")[] | undefined;
+        compression?: {
+            enabled?: boolean | undefined;
+            algorithm?: "gzip" | "brotli" | "deflate" | undefined;
+        } | undefined;
+        storage?: "hybrid" | "memory" | "disk" | "indexeddb" | undefined;
+        keyStrategy?: "hash" | "version" | "timestamp" | undefined;
+    } | undefined;
+    preload?: {
+        enabled?: boolean | undefined;
+        priority?: number | undefined;
+        conditions?: {
+            roles?: string[] | undefined;
+            routes?: string[] | undefined;
+            deviceType?: ("desktop" | "mobile" | "tablet")[] | undefined;
+            minNetworkSpeed?: "slow-2g" | "2g" | "3g" | "4g" | undefined;
+        } | undefined;
+        resources?: ("code" | "dependencies" | "metadata" | "assets" | "services")[] | undefined;
+    } | undefined;
+    codeSplitting?: {
+        enabled?: boolean | undefined;
+        strategy?: "custom" | "size" | "route" | "feature" | undefined;
+        chunkNaming?: "hashed" | "named" | "sequential" | undefined;
+        maxChunkSize?: number | undefined;
+        sharedDependencies?: {
+            enabled?: boolean | undefined;
+            minChunks?: number | undefined;
+        } | undefined;
+    } | undefined;
+    dynamicImport?: {
+        enabled?: boolean | undefined;
+        timeout?: number | undefined;
+        mode?: "async" | "eager" | "lazy" | "sync" | undefined;
+        retry?: {
+            enabled?: boolean | undefined;
+            maxAttempts?: number | undefined;
+            backoffMs?: number | undefined;
+        } | undefined;
+        prefetch?: boolean | undefined;
+        preload?: boolean | undefined;
+        webpackChunkName?: string | undefined;
+    } | undefined;
+    initialization?: {
+        timeout?: number | undefined;
+        priority?: number | undefined;
+        mode?: "async" | "parallel" | "sequential" | "sync" | undefined;
+        retry?: {
+            enabled?: boolean | undefined;
+            maxAttempts?: number | undefined;
+            backoffMs?: number | undefined;
+        } | undefined;
+        critical?: boolean | undefined;
+        healthCheckInterval?: number | undefined;
+    } | undefined;
+    dependencyResolution?: {
+        strategy?: "strict" | "latest" | "compatible" | "pinned" | undefined;
+        conflictResolution?: "latest" | "manual" | "fail" | "oldest" | undefined;
+        peerDependencies?: {
+            resolve?: boolean | undefined;
+            onMissing?: "error" | "warn" | "ignore" | undefined;
+            onMismatch?: "error" | "warn" | "ignore" | undefined;
+        } | undefined;
+        optionalDependencies?: {
+            load?: boolean | undefined;
+            onFailure?: "warn" | "ignore" | undefined;
+        } | undefined;
+        circularDependencies?: "error" | "warn" | "allow" | undefined;
+    } | undefined;
+    hotReload?: {
+        enabled?: boolean | undefined;
+        strategy?: "partial" | "full" | "state-preserve" | undefined;
+        watchPatterns?: string[] | undefined;
+        ignorePatterns?: string[] | undefined;
+        debounceMs?: number | undefined;
+        preserveState?: boolean | undefined;
+        stateSerialization?: {
+            enabled?: boolean | undefined;
+            handler?: string | undefined;
+        } | undefined;
+        hooks?: {
+            onError?: string | undefined;
+            beforeReload?: string | undefined;
+            afterReload?: string | undefined;
+        } | undefined;
+    } | undefined;
+    sandboxing?: {
+        enabled?: boolean | undefined;
+        isolationLevel?: "none" | "process" | "vm" | "iframe" | "web-worker" | undefined;
+        permissions?: {
+            allowedAPIs?: string[] | undefined;
+            allowedPaths?: string[] | undefined;
+            allowedEndpoints?: string[] | undefined;
+            allowedEnvVars?: string[] | undefined;
+        } | undefined;
+        allowedCapabilities?: string[] | undefined;
+        resourceQuotas?: {
+            maxMemoryMB?: number | undefined;
+            maxCpuTimeMs?: number | undefined;
+            maxFileDescriptors?: number | undefined;
+            maxNetworkKBps?: number | undefined;
+        } | undefined;
+    } | undefined;
+    monitoring?: {
+        enabled?: boolean | undefined;
+        metrics?: ("load-time" | "init-time" | "memory-usage" | "cpu-usage" | "api-calls" | "error-rate" | "cache-hit-rate")[] | undefined;
+        samplingRate?: number | undefined;
+        reportingInterval?: number | undefined;
+        budgets?: {
+            maxMemoryMB?: number | undefined;
+            maxLoadTimeMs?: number | undefined;
+            maxInitTimeMs?: number | undefined;
+        } | undefined;
+        onBudgetViolation?: "error" | "warn" | "ignore" | undefined;
+    } | undefined;
+}>;
+/**
+ * Plugin Loading Event
+ * Emitted during plugin loading lifecycle
+ */
+export declare const PluginLoadingEventSchema: z.ZodObject<{
+    /**
+     * Event type
+     */
+    type: z.ZodEnum<["load-started", "load-completed", "load-failed", "init-started", "init-completed", "init-failed", "preload-started", "preload-completed", "cache-hit", "cache-miss", "hot-reload"]>;
+    /**
+     * Plugin identifier
+     */
+    pluginId: z.ZodString;
+    /**
+     * Timestamp
+     */
+    timestamp: z.ZodNumber;
+    /**
+     * Duration in milliseconds
+     */
+    durationMs: z.ZodOptional<z.ZodNumber>;
+    /**
+     * Additional metadata
+     */
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    /**
+     * Error if event represents a failure
+     */
+    error: z.ZodOptional<z.ZodObject<{
+        message: z.ZodString;
+        code: z.ZodOptional<z.ZodString>;
+        stack: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        message: string;
+        code?: string | undefined;
+        stack?: string | undefined;
+    }, {
+        message: string;
+        code?: string | undefined;
+        stack?: string | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    type: "load-started" | "load-completed" | "load-failed" | "init-started" | "init-completed" | "init-failed" | "preload-started" | "preload-completed" | "cache-hit" | "cache-miss" | "hot-reload";
+    timestamp: number;
+    pluginId: string;
+    error?: {
+        message: string;
+        code?: string | undefined;
+        stack?: string | undefined;
+    } | undefined;
+    metadata?: Record<string, any> | undefined;
+    durationMs?: number | undefined;
+}, {
+    type: "load-started" | "load-completed" | "load-failed" | "init-started" | "init-completed" | "init-failed" | "preload-started" | "preload-completed" | "cache-hit" | "cache-miss" | "hot-reload";
+    timestamp: number;
+    pluginId: string;
+    error?: {
+        message: string;
+        code?: string | undefined;
+        stack?: string | undefined;
+    } | undefined;
+    metadata?: Record<string, any> | undefined;
+    durationMs?: number | undefined;
+}>;
+/**
+ * Plugin Loading State
+ * Tracks the current loading state of a plugin
+ */
+export declare const PluginLoadingStateSchema: z.ZodObject<{
+    /**
+     * Plugin identifier
+     */
+    pluginId: z.ZodString;
+    /**
+     * Current state
+     */
+    state: z.ZodEnum<["pending", "loading", "loaded", "initializing", "ready", "failed", "reloading"]>;
+    /**
+     * Load progress (0-100)
+     */
+    progress: z.ZodDefault<z.ZodNumber>;
+    /**
+     * Loading start time
+     */
+    startedAt: z.ZodOptional<z.ZodNumber>;
+    /**
+     * Loading completion time
+     */
+    completedAt: z.ZodOptional<z.ZodNumber>;
+    /**
+     * Last error
+     */
+    lastError: z.ZodOptional<z.ZodString>;
+    /**
+     * Retry count
+     */
+    retryCount: z.ZodDefault<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    progress: number;
+    state: "failed" | "pending" | "initializing" | "loading" | "loaded" | "ready" | "reloading";
+    pluginId: string;
+    retryCount: number;
+    startedAt?: number | undefined;
+    completedAt?: number | undefined;
+    lastError?: string | undefined;
+}, {
+    state: "failed" | "pending" | "initializing" | "loading" | "loaded" | "ready" | "reloading";
+    pluginId: string;
+    progress?: number | undefined;
+    startedAt?: number | undefined;
+    completedAt?: number | undefined;
+    lastError?: string | undefined;
+    retryCount?: number | undefined;
+}>;
+export type PluginLoadingStrategy = z.infer<typeof PluginLoadingStrategySchema>;
+export type PluginPreloadConfig = z.infer<typeof PluginPreloadConfigSchema>;
+export type PluginCodeSplitting = z.infer<typeof PluginCodeSplittingSchema>;
+export type PluginDynamicImport = z.infer<typeof PluginDynamicImportSchema>;
+export type PluginInitialization = z.infer<typeof PluginInitializationSchema>;
+export type PluginDependencyResolution = z.infer<typeof PluginDependencyResolutionSchema>;
+export type PluginHotReload = z.infer<typeof PluginHotReloadSchema>;
+export type PluginCaching = z.infer<typeof PluginCachingSchema>;
+export type PluginSandboxing = z.infer<typeof PluginSandboxingSchema>;
+export type PluginPerformanceMonitoring = z.infer<typeof PluginPerformanceMonitoringSchema>;
+export type PluginLoadingConfig = z.infer<typeof PluginLoadingConfigSchema>;
+export type PluginLoadingEvent = z.infer<typeof PluginLoadingEventSchema>;
+export type PluginLoadingState = z.infer<typeof PluginLoadingStateSchema>;
+//# sourceMappingURL=plugin-loading.zod.d.ts.map