@objectstack/spec 0.9.2 → 1.0.0

package/dist/kernel/plugin-lifecycle-advanced.zod.d.ts

@@ -0,0 +1,1458 @@
+import { z } from 'zod';
+/**
+ * # Advanced Plugin Lifecycle Protocol
+ *
+ * Defines advanced lifecycle management capabilities including:
+ * - Hot reload and live updates
+ * - Graceful degradation and fallback mechanisms
+ * - Health monitoring and auto-recovery
+ * - State preservation during updates
+ *
+ * This protocol extends the basic plugin lifecycle with enterprise-grade
+ * features for production environments.
+ */
+/**
+ * Plugin Health Status
+ * Represents the current operational state of a plugin
+ */
+export declare const PluginHealthStatusSchema: z.ZodEnum<["healthy", "degraded", "unhealthy", "failed", "recovering", "unknown"]>;
+/**
+ * Plugin Health Check Configuration
+ * Defines how to check plugin health
+ */
+export declare const PluginHealthCheckSchema: z.ZodObject<{
+    /**
+     * Health check interval in milliseconds
+     */
+    interval: z.ZodDefault<z.ZodNumber>;
+    /**
+     * Timeout for health check in milliseconds
+     */
+    timeout: z.ZodDefault<z.ZodNumber>;
+    /**
+     * Number of consecutive failures before marking as unhealthy
+     */
+    failureThreshold: z.ZodDefault<z.ZodNumber>;
+    /**
+     * Number of consecutive successes to recover from unhealthy state
+     */
+    successThreshold: z.ZodDefault<z.ZodNumber>;
+    /**
+     * Custom health check function name or endpoint
+     */
+    checkMethod: z.ZodOptional<z.ZodString>;
+    /**
+     * Enable automatic restart on failure
+     */
+    autoRestart: z.ZodDefault<z.ZodBoolean>;
+    /**
+     * Maximum number of restart attempts
+     */
+    maxRestartAttempts: z.ZodDefault<z.ZodNumber>;
+    /**
+     * Backoff strategy for restarts
+     */
+    restartBackoff: z.ZodDefault<z.ZodEnum<["fixed", "linear", "exponential"]>>;
+}, "strip", z.ZodTypeAny, {
+    timeout: number;
+    interval: number;
+    failureThreshold: number;
+    successThreshold: number;
+    autoRestart: boolean;
+    maxRestartAttempts: number;
+    restartBackoff: "fixed" | "linear" | "exponential";
+    checkMethod?: string | undefined;
+}, {
+    timeout?: number | undefined;
+    interval?: number | undefined;
+    failureThreshold?: number | undefined;
+    successThreshold?: number | undefined;
+    checkMethod?: string | undefined;
+    autoRestart?: boolean | undefined;
+    maxRestartAttempts?: number | undefined;
+    restartBackoff?: "fixed" | "linear" | "exponential" | undefined;
+}>;
+/**
+ * Plugin Health Report
+ * Detailed health information from a plugin
+ */
+export declare const PluginHealthReportSchema: z.ZodObject<{
+    /**
+     * Overall health status
+     */
+    status: z.ZodEnum<["healthy", "degraded", "unhealthy", "failed", "recovering", "unknown"]>;
+    /**
+     * Timestamp of the health check
+     */
+    timestamp: z.ZodString;
+    /**
+     * Human-readable message about health status
+     */
+    message: z.ZodOptional<z.ZodString>;
+    /**
+     * Detailed metrics
+     */
+    metrics: z.ZodOptional<z.ZodObject<{
+        uptime: z.ZodOptional<z.ZodNumber>;
+        memoryUsage: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
+        cpuUsage: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
+        activeConnections: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
+        errorRate: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
+        responseTime: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
+    }, "strip", z.ZodTypeAny, {
+        uptime?: number | undefined;
+        memoryUsage?: number | undefined;
+        cpuUsage?: number | undefined;
+        activeConnections?: number | undefined;
+        errorRate?: number | undefined;
+        responseTime?: number | undefined;
+    }, {
+        uptime?: number | undefined;
+        memoryUsage?: number | undefined;
+        cpuUsage?: number | undefined;
+        activeConnections?: number | undefined;
+        errorRate?: number | undefined;
+        responseTime?: number | undefined;
+    }>>;
+    /**
+     * List of checks performed
+     */
+    checks: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        status: z.ZodEnum<["passed", "failed", "warning"]>;
+        message: z.ZodOptional<z.ZodString>;
+        data: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    }, "strip", z.ZodTypeAny, {
+        status: "warning" | "failed" | "passed";
+        name: string;
+        message?: string | undefined;
+        data?: Record<string, any> | undefined;
+    }, {
+        status: "warning" | "failed" | "passed";
+        name: string;
+        message?: string | undefined;
+        data?: Record<string, any> | undefined;
+    }>, "many">>;
+    /**
+     * Dependencies health
+     */
+    dependencies: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        pluginId: z.ZodString;
+        status: z.ZodEnum<["healthy", "degraded", "unhealthy", "failed", "recovering", "unknown"]>;
+        message: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        status: "unknown" | "failed" | "degraded" | "healthy" | "unhealthy" | "recovering";
+        pluginId: string;
+        message?: string | undefined;
+    }, {
+        status: "unknown" | "failed" | "degraded" | "healthy" | "unhealthy" | "recovering";
+        pluginId: string;
+        message?: string | undefined;
+    }>, "many">>;
+}, "strip", z.ZodTypeAny, {
+    status: "unknown" | "failed" | "degraded" | "healthy" | "unhealthy" | "recovering";
+    timestamp: string;
+    message?: string | undefined;
+    dependencies?: {
+        status: "unknown" | "failed" | "degraded" | "healthy" | "unhealthy" | "recovering";
+        pluginId: string;
+        message?: string | undefined;
+    }[] | undefined;
+    metrics?: {
+        uptime?: number | undefined;
+        memoryUsage?: number | undefined;
+        cpuUsage?: number | undefined;
+        activeConnections?: number | undefined;
+        errorRate?: number | undefined;
+        responseTime?: number | undefined;
+    } | undefined;
+    checks?: {
+        status: "warning" | "failed" | "passed";
+        name: string;
+        message?: string | undefined;
+        data?: Record<string, any> | undefined;
+    }[] | undefined;
+}, {
+    status: "unknown" | "failed" | "degraded" | "healthy" | "unhealthy" | "recovering";
+    timestamp: string;
+    message?: string | undefined;
+    dependencies?: {
+        status: "unknown" | "failed" | "degraded" | "healthy" | "unhealthy" | "recovering";
+        pluginId: string;
+        message?: string | undefined;
+    }[] | undefined;
+    metrics?: {
+        uptime?: number | undefined;
+        memoryUsage?: number | undefined;
+        cpuUsage?: number | undefined;
+        activeConnections?: number | undefined;
+        errorRate?: number | undefined;
+        responseTime?: number | undefined;
+    } | undefined;
+    checks?: {
+        status: "warning" | "failed" | "passed";
+        name: string;
+        message?: string | undefined;
+        data?: Record<string, any> | undefined;
+    }[] | undefined;
+}>;
+/**
+ * Distributed State Configuration
+ * Configuration for distributed state management in cluster environments
+ */
+export declare const DistributedStateConfigSchema: z.ZodObject<{
+    /**
+     * Distributed cache provider
+     */
+    provider: z.ZodEnum<["redis", "etcd", "custom"]>;
+    /**
+     * Connection URL or endpoints
+     */
+    endpoints: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    /**
+     * Key prefix for namespacing
+     */
+    keyPrefix: z.ZodOptional<z.ZodString>;
+    /**
+     * Time to live in seconds
+     */
+    ttl: z.ZodOptional<z.ZodNumber>;
+    /**
+     * Authentication configuration
+     */
+    auth: z.ZodOptional<z.ZodObject<{
+        username: z.ZodOptional<z.ZodString>;
+        password: z.ZodOptional<z.ZodString>;
+        token: z.ZodOptional<z.ZodString>;
+        certificate: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        password?: string | undefined;
+        username?: string | undefined;
+        token?: string | undefined;
+        certificate?: string | undefined;
+    }, {
+        password?: string | undefined;
+        username?: string | undefined;
+        token?: string | undefined;
+        certificate?: string | undefined;
+    }>>;
+    /**
+     * Replication settings
+     */
+    replication: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        minReplicas: z.ZodDefault<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        enabled: boolean;
+        minReplicas: number;
+    }, {
+        enabled?: boolean | undefined;
+        minReplicas?: number | undefined;
+    }>>;
+    /**
+     * Custom provider configuration
+     */
+    customConfig: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+}, "strip", z.ZodTypeAny, {
+    provider: "custom" | "redis" | "etcd";
+    ttl?: number | undefined;
+    replication?: {
+        enabled: boolean;
+        minReplicas: number;
+    } | undefined;
+    auth?: {
+        password?: string | undefined;
+        username?: string | undefined;
+        token?: string | undefined;
+        certificate?: string | undefined;
+    } | undefined;
+    endpoints?: string[] | undefined;
+    keyPrefix?: string | undefined;
+    customConfig?: Record<string, any> | undefined;
+}, {
+    provider: "custom" | "redis" | "etcd";
+    ttl?: number | undefined;
+    replication?: {
+        enabled?: boolean | undefined;
+        minReplicas?: number | undefined;
+    } | undefined;
+    auth?: {
+        password?: string | undefined;
+        username?: string | undefined;
+        token?: string | undefined;
+        certificate?: string | undefined;
+    } | undefined;
+    endpoints?: string[] | undefined;
+    keyPrefix?: string | undefined;
+    customConfig?: Record<string, any> | undefined;
+}>;
+/**
+ * Hot Reload Configuration
+ * Controls how plugins handle live updates
+ */
+export declare const HotReloadConfigSchema: z.ZodObject<{
+    /**
+     * Enable hot reload capability
+     */
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    /**
+     * Watch file patterns for auto-reload
+     */
+    watchPatterns: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    /**
+     * Debounce delay before reloading (milliseconds)
+     */
+    debounceDelay: z.ZodDefault<z.ZodNumber>;
+    /**
+     * Preserve plugin state during reload
+     */
+    preserveState: z.ZodDefault<z.ZodBoolean>;
+    /**
+     * State serialization strategy
+     */
+    stateStrategy: z.ZodDefault<z.ZodEnum<["memory", "disk", "distributed", "none"]>>;
+    /**
+     * Distributed state configuration (required when stateStrategy is "distributed")
+     */
+    distributedConfig: z.ZodOptional<z.ZodObject<{
+        /**
+         * Distributed cache provider
+         */
+        provider: z.ZodEnum<["redis", "etcd", "custom"]>;
+        /**
+         * Connection URL or endpoints
+         */
+        endpoints: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        /**
+         * Key prefix for namespacing
+         */
+        keyPrefix: z.ZodOptional<z.ZodString>;
+        /**
+         * Time to live in seconds
+         */
+        ttl: z.ZodOptional<z.ZodNumber>;
+        /**
+         * Authentication configuration
+         */
+        auth: z.ZodOptional<z.ZodObject<{
+            username: z.ZodOptional<z.ZodString>;
+            password: z.ZodOptional<z.ZodString>;
+            token: z.ZodOptional<z.ZodString>;
+            certificate: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            password?: string | undefined;
+            username?: string | undefined;
+            token?: string | undefined;
+            certificate?: string | undefined;
+        }, {
+            password?: string | undefined;
+            username?: string | undefined;
+            token?: string | undefined;
+            certificate?: string | undefined;
+        }>>;
+        /**
+         * Replication settings
+         */
+        replication: z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            minReplicas: z.ZodDefault<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            enabled: boolean;
+            minReplicas: number;
+        }, {
+            enabled?: boolean | undefined;
+            minReplicas?: number | undefined;
+        }>>;
+        /**
+         * Custom provider configuration
+         */
+        customConfig: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    }, "strip", z.ZodTypeAny, {
+        provider: "custom" | "redis" | "etcd";
+        ttl?: number | undefined;
+        replication?: {
+            enabled: boolean;
+            minReplicas: number;
+        } | undefined;
+        auth?: {
+            password?: string | undefined;
+            username?: string | undefined;
+            token?: string | undefined;
+            certificate?: string | undefined;
+        } | undefined;
+        endpoints?: string[] | undefined;
+        keyPrefix?: string | undefined;
+        customConfig?: Record<string, any> | undefined;
+    }, {
+        provider: "custom" | "redis" | "etcd";
+        ttl?: number | undefined;
+        replication?: {
+            enabled?: boolean | undefined;
+            minReplicas?: number | undefined;
+        } | undefined;
+        auth?: {
+            password?: string | undefined;
+            username?: string | undefined;
+            token?: string | undefined;
+            certificate?: string | undefined;
+        } | undefined;
+        endpoints?: string[] | undefined;
+        keyPrefix?: string | undefined;
+        customConfig?: Record<string, any> | undefined;
+    }>>;
+    /**
+     * Graceful shutdown timeout
+     */
+    shutdownTimeout: z.ZodDefault<z.ZodNumber>;
+    /**
+     * Pre-reload hooks
+     */
+    beforeReload: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    /**
+     * Post-reload hooks
+     */
+    afterReload: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    enabled: boolean;
+    preserveState: boolean;
+    debounceDelay: number;
+    stateStrategy: "none" | "memory" | "disk" | "distributed";
+    shutdownTimeout: number;
+    watchPatterns?: string[] | undefined;
+    beforeReload?: string[] | undefined;
+    afterReload?: string[] | undefined;
+    distributedConfig?: {
+        provider: "custom" | "redis" | "etcd";
+        ttl?: number | undefined;
+        replication?: {
+            enabled: boolean;
+            minReplicas: number;
+        } | undefined;
+        auth?: {
+            password?: string | undefined;
+            username?: string | undefined;
+            token?: string | undefined;
+            certificate?: string | undefined;
+        } | undefined;
+        endpoints?: string[] | undefined;
+        keyPrefix?: string | undefined;
+        customConfig?: Record<string, any> | undefined;
+    } | undefined;
+}, {
+    enabled?: boolean | undefined;
+    watchPatterns?: string[] | undefined;
+    preserveState?: boolean | undefined;
+    beforeReload?: string[] | undefined;
+    afterReload?: string[] | undefined;
+    debounceDelay?: number | undefined;
+    stateStrategy?: "none" | "memory" | "disk" | "distributed" | undefined;
+    distributedConfig?: {
+        provider: "custom" | "redis" | "etcd";
+        ttl?: number | undefined;
+        replication?: {
+            enabled?: boolean | undefined;
+            minReplicas?: number | undefined;
+        } | undefined;
+        auth?: {
+            password?: string | undefined;
+            username?: string | undefined;
+            token?: string | undefined;
+            certificate?: string | undefined;
+        } | undefined;
+        endpoints?: string[] | undefined;
+        keyPrefix?: string | undefined;
+        customConfig?: Record<string, any> | undefined;
+    } | undefined;
+    shutdownTimeout?: number | undefined;
+}>;
+/**
+ * Graceful Degradation Configuration
+ * Defines how plugin degrades when dependencies fail
+ */
+export declare const GracefulDegradationSchema: z.ZodObject<{
+    /**
+     * Enable graceful degradation
+     */
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    /**
+     * Fallback mode when dependencies fail
+     */
+    fallbackMode: z.ZodDefault<z.ZodEnum<["minimal", "cached", "readonly", "offline", "disabled"]>>;
+    /**
+     * Critical dependencies that must be available
+     */
+    criticalDependencies: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    /**
+     * Optional dependencies that can fail
+     */
+    optionalDependencies: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    /**
+     * Feature flags for degraded mode
+     */
+    degradedFeatures: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        feature: z.ZodString;
+        enabled: z.ZodBoolean;
+        reason: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        enabled: boolean;
+        feature: string;
+        reason?: string | undefined;
+    }, {
+        enabled: boolean;
+        feature: string;
+        reason?: string | undefined;
+    }>, "many">>;
+    /**
+     * Automatic recovery attempts
+     */
+    autoRecovery: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        retryInterval: z.ZodDefault<z.ZodNumber>;
+        maxAttempts: z.ZodDefault<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        enabled: boolean;
+        maxAttempts: number;
+        retryInterval: number;
+    }, {
+        enabled?: boolean | undefined;
+        maxAttempts?: number | undefined;
+        retryInterval?: number | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    enabled: boolean;
+    fallbackMode: "cached" | "readonly" | "disabled" | "minimal" | "offline";
+    optionalDependencies?: string[] | undefined;
+    criticalDependencies?: string[] | undefined;
+    degradedFeatures?: {
+        enabled: boolean;
+        feature: string;
+        reason?: string | undefined;
+    }[] | undefined;
+    autoRecovery?: {
+        enabled: boolean;
+        maxAttempts: number;
+        retryInterval: number;
+    } | undefined;
+}, {
+    enabled?: boolean | undefined;
+    optionalDependencies?: string[] | undefined;
+    fallbackMode?: "cached" | "readonly" | "disabled" | "minimal" | "offline" | undefined;
+    criticalDependencies?: string[] | undefined;
+    degradedFeatures?: {
+        enabled: boolean;
+        feature: string;
+        reason?: string | undefined;
+    }[] | undefined;
+    autoRecovery?: {
+        enabled?: boolean | undefined;
+        maxAttempts?: number | undefined;
+        retryInterval?: number | undefined;
+    } | undefined;
+}>;
+/**
+ * Plugin Update Strategy
+ * Defines how plugin handles version updates
+ */
+export declare const PluginUpdateStrategySchema: z.ZodObject<{
+    /**
+     * Update mode
+     */
+    mode: z.ZodDefault<z.ZodEnum<["manual", "automatic", "scheduled", "rolling"]>>;
+    /**
+     * Version constraints for automatic updates
+     */
+    autoUpdateConstraints: z.ZodOptional<z.ZodObject<{
+        major: z.ZodDefault<z.ZodBoolean>;
+        minor: z.ZodDefault<z.ZodBoolean>;
+        patch: z.ZodDefault<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        major: boolean;
+        minor: boolean;
+        patch: boolean;
+    }, {
+        major?: boolean | undefined;
+        minor?: boolean | undefined;
+        patch?: boolean | undefined;
+    }>>;
+    /**
+     * Update schedule (for scheduled mode)
+     */
+    schedule: z.ZodOptional<z.ZodObject<{
+        /**
+         * Cron expression for update window
+         */
+        cron: z.ZodOptional<z.ZodString>;
+        /**
+         * Timezone for schedule
+         */
+        timezone: z.ZodDefault<z.ZodString>;
+        /**
+         * Maintenance window duration in minutes
+         */
+        maintenanceWindow: z.ZodDefault<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        timezone: string;
+        maintenanceWindow: number;
+        cron?: string | undefined;
+    }, {
+        timezone?: string | undefined;
+        cron?: string | undefined;
+        maintenanceWindow?: number | undefined;
+    }>>;
+    /**
+     * Rollback configuration
+     */
+    rollback: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        /**
+         * Automatic rollback on failure
+         */
+        automatic: z.ZodDefault<z.ZodBoolean>;
+        /**
+         * Keep N previous versions for rollback
+         */
+        keepVersions: z.ZodDefault<z.ZodNumber>;
+        /**
+         * Rollback timeout in milliseconds
+         */
+        timeout: z.ZodDefault<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        enabled: boolean;
+        timeout: number;
+        automatic: boolean;
+        keepVersions: number;
+    }, {
+        enabled?: boolean | undefined;
+        timeout?: number | undefined;
+        automatic?: boolean | undefined;
+        keepVersions?: number | undefined;
+    }>>;
+    /**
+     * Pre-update validation
+     */
+    validation: z.ZodOptional<z.ZodObject<{
+        /**
+         * Run compatibility checks before update
+         */
+        checkCompatibility: z.ZodDefault<z.ZodBoolean>;
+        /**
+         * Run tests before applying update
+         */
+        runTests: z.ZodDefault<z.ZodBoolean>;
+        /**
+         * Test suite to run
+         */
+        testSuite: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        checkCompatibility: boolean;
+        runTests: boolean;
+        testSuite?: string | undefined;
+    }, {
+        checkCompatibility?: boolean | undefined;
+        runTests?: boolean | undefined;
+        testSuite?: string | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    mode: "manual" | "rolling" | "scheduled" | "automatic";
+    validation?: {
+        checkCompatibility: boolean;
+        runTests: boolean;
+        testSuite?: string | undefined;
+    } | undefined;
+    rollback?: {
+        enabled: boolean;
+        timeout: number;
+        automatic: boolean;
+        keepVersions: number;
+    } | undefined;
+    schedule?: {
+        timezone: string;
+        maintenanceWindow: number;
+        cron?: string | undefined;
+    } | undefined;
+    autoUpdateConstraints?: {
+        major: boolean;
+        minor: boolean;
+        patch: boolean;
+    } | undefined;
+}, {
+    validation?: {
+        checkCompatibility?: boolean | undefined;
+        runTests?: boolean | undefined;
+        testSuite?: string | undefined;
+    } | undefined;
+    mode?: "manual" | "rolling" | "scheduled" | "automatic" | undefined;
+    rollback?: {
+        enabled?: boolean | undefined;
+        timeout?: number | undefined;
+        automatic?: boolean | undefined;
+        keepVersions?: number | undefined;
+    } | undefined;
+    schedule?: {
+        timezone?: string | undefined;
+        cron?: string | undefined;
+        maintenanceWindow?: number | undefined;
+    } | undefined;
+    autoUpdateConstraints?: {
+        major?: boolean | undefined;
+        minor?: boolean | undefined;
+        patch?: boolean | undefined;
+    } | undefined;
+}>;
+/**
+ * Plugin State Snapshot
+ * Captures plugin state for preservation during updates/reloads
+ */
+export declare const PluginStateSnapshotSchema: z.ZodObject<{
+    /**
+     * Plugin identifier
+     */
+    pluginId: z.ZodString;
+    /**
+     * Version at time of snapshot
+     */
+    version: z.ZodString;
+    /**
+     * Snapshot timestamp
+     */
+    timestamp: z.ZodString;
+    /**
+     * Serialized state data
+     */
+    state: z.ZodRecord<z.ZodString, z.ZodAny>;
+    /**
+     * State metadata
+     */
+    metadata: z.ZodOptional<z.ZodObject<{
+        checksum: z.ZodOptional<z.ZodString>;
+        compressed: z.ZodDefault<z.ZodBoolean>;
+        encryption: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        compressed: boolean;
+        encryption?: string | undefined;
+        checksum?: string | undefined;
+    }, {
+        encryption?: string | undefined;
+        checksum?: string | undefined;
+        compressed?: boolean | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    state: Record<string, any>;
+    version: string;
+    timestamp: string;
+    pluginId: string;
+    metadata?: {
+        compressed: boolean;
+        encryption?: string | undefined;
+        checksum?: string | undefined;
+    } | undefined;
+}, {
+    state: Record<string, any>;
+    version: string;
+    timestamp: string;
+    pluginId: string;
+    metadata?: {
+        encryption?: string | undefined;
+        checksum?: string | undefined;
+        compressed?: boolean | undefined;
+    } | undefined;
+}>;
+/**
+ * Advanced Plugin Lifecycle Configuration
+ * Complete configuration for advanced lifecycle management
+ */
+export declare const AdvancedPluginLifecycleConfigSchema: z.ZodObject<{
+    /**
+     * Health monitoring configuration
+     */
+    health: z.ZodOptional<z.ZodObject<{
+        /**
+         * Health check interval in milliseconds
+         */
+        interval: z.ZodDefault<z.ZodNumber>;
+        /**
+         * Timeout for health check in milliseconds
+         */
+        timeout: z.ZodDefault<z.ZodNumber>;
+        /**
+         * Number of consecutive failures before marking as unhealthy
+         */
+        failureThreshold: z.ZodDefault<z.ZodNumber>;
+        /**
+         * Number of consecutive successes to recover from unhealthy state
+         */
+        successThreshold: z.ZodDefault<z.ZodNumber>;
+        /**
+         * Custom health check function name or endpoint
+         */
+        checkMethod: z.ZodOptional<z.ZodString>;
+        /**
+         * Enable automatic restart on failure
+         */
+        autoRestart: z.ZodDefault<z.ZodBoolean>;
+        /**
+         * Maximum number of restart attempts
+         */
+        maxRestartAttempts: z.ZodDefault<z.ZodNumber>;
+        /**
+         * Backoff strategy for restarts
+         */
+        restartBackoff: z.ZodDefault<z.ZodEnum<["fixed", "linear", "exponential"]>>;
+    }, "strip", z.ZodTypeAny, {
+        timeout: number;
+        interval: number;
+        failureThreshold: number;
+        successThreshold: number;
+        autoRestart: boolean;
+        maxRestartAttempts: number;
+        restartBackoff: "fixed" | "linear" | "exponential";
+        checkMethod?: string | undefined;
+    }, {
+        timeout?: number | undefined;
+        interval?: number | undefined;
+        failureThreshold?: number | undefined;
+        successThreshold?: number | undefined;
+        checkMethod?: string | undefined;
+        autoRestart?: boolean | undefined;
+        maxRestartAttempts?: number | undefined;
+        restartBackoff?: "fixed" | "linear" | "exponential" | undefined;
+    }>>;
+    /**
+     * Hot reload configuration
+     */
+    hotReload: z.ZodOptional<z.ZodObject<{
+        /**
+         * Enable hot reload capability
+         */
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        /**
+         * Watch file patterns for auto-reload
+         */
+        watchPatterns: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        /**
+         * Debounce delay before reloading (milliseconds)
+         */
+        debounceDelay: z.ZodDefault<z.ZodNumber>;
+        /**
+         * Preserve plugin state during reload
+         */
+        preserveState: z.ZodDefault<z.ZodBoolean>;
+        /**
+         * State serialization strategy
+         */
+        stateStrategy: z.ZodDefault<z.ZodEnum<["memory", "disk", "distributed", "none"]>>;
+        /**
+         * Distributed state configuration (required when stateStrategy is "distributed")
+         */
+        distributedConfig: z.ZodOptional<z.ZodObject<{
+            /**
+             * Distributed cache provider
+             */
+            provider: z.ZodEnum<["redis", "etcd", "custom"]>;
+            /**
+             * Connection URL or endpoints
+             */
+            endpoints: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            /**
+             * Key prefix for namespacing
+             */
+            keyPrefix: z.ZodOptional<z.ZodString>;
+            /**
+             * Time to live in seconds
+             */
+            ttl: z.ZodOptional<z.ZodNumber>;
+            /**
+             * Authentication configuration
+             */
+            auth: z.ZodOptional<z.ZodObject<{
+                username: z.ZodOptional<z.ZodString>;
+                password: z.ZodOptional<z.ZodString>;
+                token: z.ZodOptional<z.ZodString>;
+                certificate: z.ZodOptional<z.ZodString>;
+            }, "strip", z.ZodTypeAny, {
+                password?: string | undefined;
+                username?: string | undefined;
+                token?: string | undefined;
+                certificate?: string | undefined;
+            }, {
+                password?: string | undefined;
+                username?: string | undefined;
+                token?: string | undefined;
+                certificate?: string | undefined;
+            }>>;
+            /**
+             * Replication settings
+             */
+            replication: z.ZodOptional<z.ZodObject<{
+                enabled: z.ZodDefault<z.ZodBoolean>;
+                minReplicas: z.ZodDefault<z.ZodNumber>;
+            }, "strip", z.ZodTypeAny, {
+                enabled: boolean;
+                minReplicas: number;
+            }, {
+                enabled?: boolean | undefined;
+                minReplicas?: number | undefined;
+            }>>;
+            /**
+             * Custom provider configuration
+             */
+            customConfig: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+        }, "strip", z.ZodTypeAny, {
+            provider: "custom" | "redis" | "etcd";
+            ttl?: number | undefined;
+            replication?: {
+                enabled: boolean;
+                minReplicas: number;
+            } | undefined;
+            auth?: {
+                password?: string | undefined;
+                username?: string | undefined;
+                token?: string | undefined;
+                certificate?: string | undefined;
+            } | undefined;
+            endpoints?: string[] | undefined;
+            keyPrefix?: string | undefined;
+            customConfig?: Record<string, any> | undefined;
+        }, {
+            provider: "custom" | "redis" | "etcd";
+            ttl?: number | undefined;
+            replication?: {
+                enabled?: boolean | undefined;
+                minReplicas?: number | undefined;
+            } | undefined;
+            auth?: {
+                password?: string | undefined;
+                username?: string | undefined;
+                token?: string | undefined;
+                certificate?: string | undefined;
+            } | undefined;
+            endpoints?: string[] | undefined;
+            keyPrefix?: string | undefined;
+            customConfig?: Record<string, any> | undefined;
+        }>>;
+        /**
+         * Graceful shutdown timeout
+         */
+        shutdownTimeout: z.ZodDefault<z.ZodNumber>;
+        /**
+         * Pre-reload hooks
+         */
+        beforeReload: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        /**
+         * Post-reload hooks
+         */
+        afterReload: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        enabled: boolean;
+        preserveState: boolean;
+        debounceDelay: number;
+        stateStrategy: "none" | "memory" | "disk" | "distributed";
+        shutdownTimeout: number;
+        watchPatterns?: string[] | undefined;
+        beforeReload?: string[] | undefined;
+        afterReload?: string[] | undefined;
+        distributedConfig?: {
+            provider: "custom" | "redis" | "etcd";
+            ttl?: number | undefined;
+            replication?: {
+                enabled: boolean;
+                minReplicas: number;
+            } | undefined;
+            auth?: {
+                password?: string | undefined;
+                username?: string | undefined;
+                token?: string | undefined;
+                certificate?: string | undefined;
+            } | undefined;
+            endpoints?: string[] | undefined;
+            keyPrefix?: string | undefined;
+            customConfig?: Record<string, any> | undefined;
+        } | undefined;
+    }, {
+        enabled?: boolean | undefined;
+        watchPatterns?: string[] | undefined;
+        preserveState?: boolean | undefined;
+        beforeReload?: string[] | undefined;
+        afterReload?: string[] | undefined;
+        debounceDelay?: number | undefined;
+        stateStrategy?: "none" | "memory" | "disk" | "distributed" | undefined;
+        distributedConfig?: {
+            provider: "custom" | "redis" | "etcd";
+            ttl?: number | undefined;
+            replication?: {
+                enabled?: boolean | undefined;
+                minReplicas?: number | undefined;
+            } | undefined;
+            auth?: {
+                password?: string | undefined;
+                username?: string | undefined;
+                token?: string | undefined;
+                certificate?: string | undefined;
+            } | undefined;
+            endpoints?: string[] | undefined;
+            keyPrefix?: string | undefined;
+            customConfig?: Record<string, any> | undefined;
+        } | undefined;
+        shutdownTimeout?: number | undefined;
+    }>>;
+    /**
+     * Graceful degradation configuration
+     */
+    degradation: z.ZodOptional<z.ZodObject<{
+        /**
+         * Enable graceful degradation
+         */
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        /**
+         * Fallback mode when dependencies fail
+         */
+        fallbackMode: z.ZodDefault<z.ZodEnum<["minimal", "cached", "readonly", "offline", "disabled"]>>;
+        /**
+         * Critical dependencies that must be available
+         */
+        criticalDependencies: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        /**
+         * Optional dependencies that can fail
+         */
+        optionalDependencies: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        /**
+         * Feature flags for degraded mode
+         */
+        degradedFeatures: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            feature: z.ZodString;
+            enabled: z.ZodBoolean;
+            reason: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            enabled: boolean;
+            feature: string;
+            reason?: string | undefined;
+        }, {
+            enabled: boolean;
+            feature: string;
+            reason?: string | undefined;
+        }>, "many">>;
+        /**
+         * Automatic recovery attempts
+         */
+        autoRecovery: z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            retryInterval: z.ZodDefault<z.ZodNumber>;
+            maxAttempts: z.ZodDefault<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            enabled: boolean;
+            maxAttempts: number;
+            retryInterval: number;
+        }, {
+            enabled?: boolean | undefined;
+            maxAttempts?: number | undefined;
+            retryInterval?: number | undefined;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        enabled: boolean;
+        fallbackMode: "cached" | "readonly" | "disabled" | "minimal" | "offline";
+        optionalDependencies?: string[] | undefined;
+        criticalDependencies?: string[] | undefined;
+        degradedFeatures?: {
+            enabled: boolean;
+            feature: string;
+            reason?: string | undefined;
+        }[] | undefined;
+        autoRecovery?: {
+            enabled: boolean;
+            maxAttempts: number;
+            retryInterval: number;
+        } | undefined;
+    }, {
+        enabled?: boolean | undefined;
+        optionalDependencies?: string[] | undefined;
+        fallbackMode?: "cached" | "readonly" | "disabled" | "minimal" | "offline" | undefined;
+        criticalDependencies?: string[] | undefined;
+        degradedFeatures?: {
+            enabled: boolean;
+            feature: string;
+            reason?: string | undefined;
+        }[] | undefined;
+        autoRecovery?: {
+            enabled?: boolean | undefined;
+            maxAttempts?: number | undefined;
+            retryInterval?: number | undefined;
+        } | undefined;
+    }>>;
+    /**
+     * Update strategy
+     */
+    updates: z.ZodOptional<z.ZodObject<{
+        /**
+         * Update mode
+         */
+        mode: z.ZodDefault<z.ZodEnum<["manual", "automatic", "scheduled", "rolling"]>>;
+        /**
+         * Version constraints for automatic updates
+         */
+        autoUpdateConstraints: z.ZodOptional<z.ZodObject<{
+            major: z.ZodDefault<z.ZodBoolean>;
+            minor: z.ZodDefault<z.ZodBoolean>;
+            patch: z.ZodDefault<z.ZodBoolean>;
+        }, "strip", z.ZodTypeAny, {
+            major: boolean;
+            minor: boolean;
+            patch: boolean;
+        }, {
+            major?: boolean | undefined;
+            minor?: boolean | undefined;
+            patch?: boolean | undefined;
+        }>>;
+        /**
+         * Update schedule (for scheduled mode)
+         */
+        schedule: z.ZodOptional<z.ZodObject<{
+            /**
+             * Cron expression for update window
+             */
+            cron: z.ZodOptional<z.ZodString>;
+            /**
+             * Timezone for schedule
+             */
+            timezone: z.ZodDefault<z.ZodString>;
+            /**
+             * Maintenance window duration in minutes
+             */
+            maintenanceWindow: z.ZodDefault<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            timezone: string;
+            maintenanceWindow: number;
+            cron?: string | undefined;
+        }, {
+            timezone?: string | undefined;
+            cron?: string | undefined;
+            maintenanceWindow?: number | undefined;
+        }>>;
+        /**
+         * Rollback configuration
+         */
+        rollback: z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            /**
+             * Automatic rollback on failure
+             */
+            automatic: z.ZodDefault<z.ZodBoolean>;
+            /**
+             * Keep N previous versions for rollback
+             */
+            keepVersions: z.ZodDefault<z.ZodNumber>;
+            /**
+             * Rollback timeout in milliseconds
+             */
+            timeout: z.ZodDefault<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            enabled: boolean;
+            timeout: number;
+            automatic: boolean;
+            keepVersions: number;
+        }, {
+            enabled?: boolean | undefined;
+            timeout?: number | undefined;
+            automatic?: boolean | undefined;
+            keepVersions?: number | undefined;
+        }>>;
+        /**
+         * Pre-update validation
+         */
+        validation: z.ZodOptional<z.ZodObject<{
+            /**
+             * Run compatibility checks before update
+             */
+            checkCompatibility: z.ZodDefault<z.ZodBoolean>;
+            /**
+             * Run tests before applying update
+             */
+            runTests: z.ZodDefault<z.ZodBoolean>;
+            /**
+             * Test suite to run
+             */
+            testSuite: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            checkCompatibility: boolean;
+            runTests: boolean;
+            testSuite?: string | undefined;
+        }, {
+            checkCompatibility?: boolean | undefined;
+            runTests?: boolean | undefined;
+            testSuite?: string | undefined;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        mode: "manual" | "rolling" | "scheduled" | "automatic";
+        validation?: {
+            checkCompatibility: boolean;
+            runTests: boolean;
+            testSuite?: string | undefined;
+        } | undefined;
+        rollback?: {
+            enabled: boolean;
+            timeout: number;
+            automatic: boolean;
+            keepVersions: number;
+        } | undefined;
+        schedule?: {
+            timezone: string;
+            maintenanceWindow: number;
+            cron?: string | undefined;
+        } | undefined;
+        autoUpdateConstraints?: {
+            major: boolean;
+            minor: boolean;
+            patch: boolean;
+        } | undefined;
+    }, {
+        validation?: {
+            checkCompatibility?: boolean | undefined;
+            runTests?: boolean | undefined;
+            testSuite?: string | undefined;
+        } | undefined;
+        mode?: "manual" | "rolling" | "scheduled" | "automatic" | undefined;
+        rollback?: {
+            enabled?: boolean | undefined;
+            timeout?: number | undefined;
+            automatic?: boolean | undefined;
+            keepVersions?: number | undefined;
+        } | undefined;
+        schedule?: {
+            timezone?: string | undefined;
+            cron?: string | undefined;
+            maintenanceWindow?: number | undefined;
+        } | undefined;
+        autoUpdateConstraints?: {
+            major?: boolean | undefined;
+            minor?: boolean | undefined;
+            patch?: boolean | undefined;
+        } | undefined;
+    }>>;
+    /**
+     * Resource limits
+     */
+    resources: z.ZodOptional<z.ZodObject<{
+        maxMemory: z.ZodOptional<z.ZodNumber>;
+        maxCpu: z.ZodOptional<z.ZodNumber>;
+        maxConnections: z.ZodOptional<z.ZodNumber>;
+        timeout: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        timeout?: number | undefined;
+        maxMemory?: number | undefined;
+        maxCpu?: number | undefined;
+        maxConnections?: number | undefined;
+    }, {
+        timeout?: number | undefined;
+        maxMemory?: number | undefined;
+        maxCpu?: number | undefined;
+        maxConnections?: number | undefined;
+    }>>;
+    /**
+     * Monitoring and observability
+     */
+    observability: z.ZodOptional<z.ZodObject<{
+        enableMetrics: z.ZodDefault<z.ZodBoolean>;
+        enableTracing: z.ZodDefault<z.ZodBoolean>;
+        enableProfiling: z.ZodDefault<z.ZodBoolean>;
+        metricsInterval: z.ZodDefault<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        enableMetrics: boolean;
+        enableTracing: boolean;
+        enableProfiling: boolean;
+        metricsInterval: number;
+    }, {
+        enableMetrics?: boolean | undefined;
+        enableTracing?: boolean | undefined;
+        enableProfiling?: boolean | undefined;
+        metricsInterval?: number | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    resources?: {
+        timeout?: number | undefined;
+        maxMemory?: number | undefined;
+        maxCpu?: number | undefined;
+        maxConnections?: number | undefined;
+    } | undefined;
+    hotReload?: {
+        enabled: boolean;
+        preserveState: boolean;
+        debounceDelay: number;
+        stateStrategy: "none" | "memory" | "disk" | "distributed";
+        shutdownTimeout: number;
+        watchPatterns?: string[] | undefined;
+        beforeReload?: string[] | undefined;
+        afterReload?: string[] | undefined;
+        distributedConfig?: {
+            provider: "custom" | "redis" | "etcd";
+            ttl?: number | undefined;
+            replication?: {
+                enabled: boolean;
+                minReplicas: number;
+            } | undefined;
+            auth?: {
+                password?: string | undefined;
+                username?: string | undefined;
+                token?: string | undefined;
+                certificate?: string | undefined;
+            } | undefined;
+            endpoints?: string[] | undefined;
+            keyPrefix?: string | undefined;
+            customConfig?: Record<string, any> | undefined;
+        } | undefined;
+    } | undefined;
+    health?: {
+        timeout: number;
+        interval: number;
+        failureThreshold: number;
+        successThreshold: number;
+        autoRestart: boolean;
+        maxRestartAttempts: number;
+        restartBackoff: "fixed" | "linear" | "exponential";
+        checkMethod?: string | undefined;
+    } | undefined;
+    degradation?: {
+        enabled: boolean;
+        fallbackMode: "cached" | "readonly" | "disabled" | "minimal" | "offline";
+        optionalDependencies?: string[] | undefined;
+        criticalDependencies?: string[] | undefined;
+        degradedFeatures?: {
+            enabled: boolean;
+            feature: string;
+            reason?: string | undefined;
+        }[] | undefined;
+        autoRecovery?: {
+            enabled: boolean;
+            maxAttempts: number;
+            retryInterval: number;
+        } | undefined;
+    } | undefined;
+    updates?: {
+        mode: "manual" | "rolling" | "scheduled" | "automatic";
+        validation?: {
+            checkCompatibility: boolean;
+            runTests: boolean;
+            testSuite?: string | undefined;
+        } | undefined;
+        rollback?: {
+            enabled: boolean;
+            timeout: number;
+            automatic: boolean;
+            keepVersions: number;
+        } | undefined;
+        schedule?: {
+            timezone: string;
+            maintenanceWindow: number;
+            cron?: string | undefined;
+        } | undefined;
+        autoUpdateConstraints?: {
+            major: boolean;
+            minor: boolean;
+            patch: boolean;
+        } | undefined;
+    } | undefined;
+    observability?: {
+        enableMetrics: boolean;
+        enableTracing: boolean;
+        enableProfiling: boolean;
+        metricsInterval: number;
+    } | undefined;
+}, {
+    resources?: {
+        timeout?: number | undefined;
+        maxMemory?: number | undefined;
+        maxCpu?: number | undefined;
+        maxConnections?: number | undefined;
+    } | undefined;
+    hotReload?: {
+        enabled?: boolean | undefined;
+        watchPatterns?: string[] | undefined;
+        preserveState?: boolean | undefined;
+        beforeReload?: string[] | undefined;
+        afterReload?: string[] | undefined;
+        debounceDelay?: number | undefined;
+        stateStrategy?: "none" | "memory" | "disk" | "distributed" | undefined;
+        distributedConfig?: {
+            provider: "custom" | "redis" | "etcd";
+            ttl?: number | undefined;
+            replication?: {
+                enabled?: boolean | undefined;
+                minReplicas?: number | undefined;
+            } | undefined;
+            auth?: {
+                password?: string | undefined;
+                username?: string | undefined;
+                token?: string | undefined;
+                certificate?: string | undefined;
+            } | undefined;
+            endpoints?: string[] | undefined;
+            keyPrefix?: string | undefined;
+            customConfig?: Record<string, any> | undefined;
+        } | undefined;
+        shutdownTimeout?: number | undefined;
+    } | undefined;
+    health?: {
+        timeout?: number | undefined;
+        interval?: number | undefined;
+        failureThreshold?: number | undefined;
+        successThreshold?: number | undefined;
+        checkMethod?: string | undefined;
+        autoRestart?: boolean | undefined;
+        maxRestartAttempts?: number | undefined;
+        restartBackoff?: "fixed" | "linear" | "exponential" | undefined;
+    } | undefined;
+    degradation?: {
+        enabled?: boolean | undefined;
+        optionalDependencies?: string[] | undefined;
+        fallbackMode?: "cached" | "readonly" | "disabled" | "minimal" | "offline" | undefined;
+        criticalDependencies?: string[] | undefined;
+        degradedFeatures?: {
+            enabled: boolean;
+            feature: string;
+            reason?: string | undefined;
+        }[] | undefined;
+        autoRecovery?: {
+            enabled?: boolean | undefined;
+            maxAttempts?: number | undefined;
+            retryInterval?: number | undefined;
+        } | undefined;
+    } | undefined;
+    updates?: {
+        validation?: {
+            checkCompatibility?: boolean | undefined;
+            runTests?: boolean | undefined;
+            testSuite?: string | undefined;
+        } | undefined;
+        mode?: "manual" | "rolling" | "scheduled" | "automatic" | undefined;
+        rollback?: {
+            enabled?: boolean | undefined;
+            timeout?: number | undefined;
+            automatic?: boolean | undefined;
+            keepVersions?: number | undefined;
+        } | undefined;
+        schedule?: {
+            timezone?: string | undefined;
+            cron?: string | undefined;
+            maintenanceWindow?: number | undefined;
+        } | undefined;
+        autoUpdateConstraints?: {
+            major?: boolean | undefined;
+            minor?: boolean | undefined;
+            patch?: boolean | undefined;
+        } | undefined;
+    } | undefined;
+    observability?: {
+        enableMetrics?: boolean | undefined;
+        enableTracing?: boolean | undefined;
+        enableProfiling?: boolean | undefined;
+        metricsInterval?: number | undefined;
+    } | undefined;
+}>;
+export type PluginHealthStatus = z.infer<typeof PluginHealthStatusSchema>;
+export type PluginHealthCheck = z.infer<typeof PluginHealthCheckSchema>;
+export type PluginHealthReport = z.infer<typeof PluginHealthReportSchema>;
+export type DistributedStateConfig = z.infer<typeof DistributedStateConfigSchema>;
+export type HotReloadConfig = z.infer<typeof HotReloadConfigSchema>;
+export type GracefulDegradation = z.infer<typeof GracefulDegradationSchema>;
+export type PluginUpdateStrategy = z.infer<typeof PluginUpdateStrategySchema>;
+export type PluginStateSnapshot = z.infer<typeof PluginStateSnapshotSchema>;
+export type AdvancedPluginLifecycleConfig = z.infer<typeof AdvancedPluginLifecycleConfigSchema>;
+//# sourceMappingURL=plugin-lifecycle-advanced.zod.d.ts.map