@objectstack/spec 3.0.8 → 3.0.9

package/dist/package-upgrade.zod-CDgftw9z.d.mts

@@ -0,0 +1,2686 @@
+import { z } from 'zod';
+
+/**
+ * # Dependency Resolution Protocol
+ *
+ * Defines schemas for runtime dependency resolution when installing,
+ * upgrading, or managing packages. Provides a standardized way to
+ * express dependency conflicts, resolution results, and installation order.
+ *
+ * ## Architecture Alignment
+ * - **npm**: Dependency tree resolution with conflict detection
+ * - **Helm**: Dependency management with version constraints
+ * - **Salesforce**: Package dependency validation at install time
+ *
+ * ## Resolution Flow
+ * ```
+ * 1. Parse manifest.dependencies (SemVer ranges)
+ * 2. Check installed packages registry
+ * 3. Resolve each dependency → satisfied | needs_install | needs_upgrade | conflict
+ * 4. Detect circular dependencies
+ * 5. Compute topological install order
+ * 6. Return resolution result with required actions
+ * ```
+ */
+/**
+ * Resolution status for a single dependency.
+ */
+declare const DependencyStatusEnum: z.ZodEnum<{
+    satisfied: "satisfied";
+    needs_install: "needs_install";
+    needs_upgrade: "needs_upgrade";
+    conflict: "conflict";
+}>;
+type DependencyStatus = z.infer<typeof DependencyStatusEnum>;
+/**
+ * Single dependency resolution result.
+ * Describes the state of one dependency after resolution.
+ */
+declare const ResolvedDependencySchema: z.ZodObject<{
+    packageId: z.ZodString;
+    requiredRange: z.ZodString;
+    resolvedVersion: z.ZodOptional<z.ZodString>;
+    installedVersion: z.ZodOptional<z.ZodString>;
+    status: z.ZodEnum<{
+        satisfied: "satisfied";
+        needs_install: "needs_install";
+        needs_upgrade: "needs_upgrade";
+        conflict: "conflict";
+    }>;
+    conflictReason: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type ResolvedDependency = z.infer<typeof ResolvedDependencySchema>;
+/**
+ * An action required before installation can proceed.
+ */
+declare const RequiredActionSchema: z.ZodObject<{
+    type: z.ZodEnum<{
+        install: "install";
+        upgrade: "upgrade";
+        confirm_conflict: "confirm_conflict";
+    }>;
+    packageId: z.ZodString;
+    description: z.ZodString;
+}, z.core.$strip>;
+type RequiredAction = z.infer<typeof RequiredActionSchema>;
+/**
+ * Complete dependency resolution result.
+ * Aggregates all dependency statuses and computes installation feasibility.
+ */
+declare const DependencyResolutionResultSchema: z.ZodObject<{
+    dependencies: z.ZodArray<z.ZodObject<{
+        packageId: z.ZodString;
+        requiredRange: z.ZodString;
+        resolvedVersion: z.ZodOptional<z.ZodString>;
+        installedVersion: z.ZodOptional<z.ZodString>;
+        status: z.ZodEnum<{
+            satisfied: "satisfied";
+            needs_install: "needs_install";
+            needs_upgrade: "needs_upgrade";
+            conflict: "conflict";
+        }>;
+        conflictReason: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    canProceed: z.ZodBoolean;
+    requiredActions: z.ZodArray<z.ZodObject<{
+        type: z.ZodEnum<{
+            install: "install";
+            upgrade: "upgrade";
+            confirm_conflict: "confirm_conflict";
+        }>;
+        packageId: z.ZodString;
+        description: z.ZodString;
+    }, z.core.$strip>>;
+    installOrder: z.ZodArray<z.ZodString>;
+    circularDependencies: z.ZodOptional<z.ZodArray<z.ZodArray<z.ZodString>>>;
+}, z.core.$strip>;
+type DependencyResolutionResult = z.infer<typeof DependencyResolutionResultSchema>;
+
+/**
+ * Schema for the ObjectStack Manifest.
+ * This defines the structure of a package configuration in the ObjectStack ecosystem.
+ * All packages (apps, plugins, drivers, modules) must conform to this schema.
+ *
+ * @example App Package
+ * ```yaml
+ * id: com.acme.crm
+ * version: 1.0.0
+ * type: app
+ * name: Acme CRM
+ * description: Customer Relationship Management system
+ * permissions:
+ *   - system.user.read
+ *   - system.object.create
+ * objects:
+ *   - "./src/objects/*.object.yml"
+ * ```
+ */
+declare const ManifestSchema: z.ZodObject<{
+    id: z.ZodString;
+    namespace: z.ZodOptional<z.ZodString>;
+    version: z.ZodString;
+    type: z.ZodEnum<{
+        theme: "theme";
+        driver: "driver";
+        app: "app";
+        server: "server";
+        ui: "ui";
+        module: "module";
+        agent: "agent";
+        objectql: "objectql";
+        plugin: "plugin";
+        gateway: "gateway";
+        adapter: "adapter";
+    }>;
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    permissions: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    objects: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    datasources: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    dependencies: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    configuration: z.ZodOptional<z.ZodObject<{
+        title: z.ZodOptional<z.ZodString>;
+        properties: z.ZodRecord<z.ZodString, z.ZodObject<{
+            type: z.ZodEnum<{
+                string: "string";
+                number: "number";
+                boolean: "boolean";
+                object: "object";
+                array: "array";
+            }>;
+            default: z.ZodOptional<z.ZodUnknown>;
+            description: z.ZodOptional<z.ZodString>;
+            required: z.ZodOptional<z.ZodBoolean>;
+            secret: z.ZodOptional<z.ZodBoolean>;
+            enum: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    contributes: z.ZodOptional<z.ZodObject<{
+        kinds: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            globs: z.ZodArray<z.ZodString>;
+            description: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>>;
+        events: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        menus: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            label: z.ZodString;
+            command: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>>>;
+        themes: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            label: z.ZodString;
+            path: z.ZodString;
+        }, z.core.$strip>>>;
+        translations: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            locale: z.ZodString;
+            path: z.ZodString;
+        }, z.core.$strip>>>;
+        actions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            label: z.ZodOptional<z.ZodString>;
+            description: z.ZodOptional<z.ZodString>;
+            input: z.ZodOptional<z.ZodUnknown>;
+            output: z.ZodOptional<z.ZodUnknown>;
+        }, z.core.$strip>>>;
+        drivers: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            label: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>>;
+        fieldTypes: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            label: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>>;
+        functions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+            args: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            returnType: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>>;
+        routes: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            prefix: z.ZodString;
+            service: z.ZodString;
+            methods: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>>>;
+        commands: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+            module: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>;
+    data: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        object: z.ZodString;
+        externalId: z.ZodDefault<z.ZodString>;
+        mode: z.ZodDefault<z.ZodEnum<{
+            insert: "insert";
+            update: "update";
+            upsert: "upsert";
+            replace: "replace";
+            ignore: "ignore";
+        }>>;
+        env: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+            prod: "prod";
+            dev: "dev";
+            test: "test";
+        }>>>;
+        records: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>>>;
+    capabilities: z.ZodOptional<z.ZodObject<{
+        implements: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            protocol: z.ZodObject<{
+                id: z.ZodString;
+                label: z.ZodString;
+                version: z.ZodObject<{
+                    major: z.ZodNumber;
+                    minor: z.ZodNumber;
+                    patch: z.ZodNumber;
+                }, z.core.$strip>;
+                specification: z.ZodOptional<z.ZodString>;
+                description: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>;
+            conformance: z.ZodDefault<z.ZodEnum<{
+                partial: "partial";
+                deprecated: "deprecated";
+                full: "full";
+                experimental: "experimental";
+            }>>;
+            implementedFeatures: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            features: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                enabled: z.ZodDefault<z.ZodBoolean>;
+                description: z.ZodOptional<z.ZodString>;
+                sinceVersion: z.ZodOptional<z.ZodString>;
+                deprecatedSince: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>>;
+            metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            certified: z.ZodDefault<z.ZodBoolean>;
+            certificationDate: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>>;
+        provides: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            name: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+            version: z.ZodObject<{
+                major: z.ZodNumber;
+                minor: z.ZodNumber;
+                patch: z.ZodNumber;
+            }, z.core.$strip>;
+            methods: z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                description: z.ZodOptional<z.ZodString>;
+                parameters: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    name: z.ZodString;
+                    type: z.ZodString;
+                    required: z.ZodDefault<z.ZodBoolean>;
+                    description: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>>>;
+                returnType: z.ZodOptional<z.ZodString>;
+                async: z.ZodDefault<z.ZodBoolean>;
+            }, z.core.$strip>>;
+            events: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                description: z.ZodOptional<z.ZodString>;
+                payload: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>>;
+            stability: z.ZodDefault<z.ZodEnum<{
+                alpha: "alpha";
+                experimental: "experimental";
+                stable: "stable";
+                beta: "beta";
+            }>>;
+        }, z.core.$strip>>>;
+        requires: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            pluginId: z.ZodString;
+            version: z.ZodString;
+            optional: z.ZodDefault<z.ZodBoolean>;
+            reason: z.ZodOptional<z.ZodString>;
+            requiredCapabilities: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>>>;
+        extensionPoints: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            name: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+            type: z.ZodEnum<{
+                provider: "provider";
+                action: "action";
+                widget: "widget";
+                hook: "hook";
+                transformer: "transformer";
+                validator: "validator";
+                decorator: "decorator";
+            }>;
+            contract: z.ZodOptional<z.ZodObject<{
+                input: z.ZodOptional<z.ZodString>;
+                output: z.ZodOptional<z.ZodString>;
+                signature: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>;
+            cardinality: z.ZodDefault<z.ZodEnum<{
+                multiple: "multiple";
+                single: "single";
+            }>>;
+        }, z.core.$strip>>>;
+        extensions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            targetPluginId: z.ZodString;
+            extensionPointId: z.ZodString;
+            implementation: z.ZodString;
+            priority: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>;
+    extensions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    loading: z.ZodOptional<z.ZodObject<{
+        strategy: z.ZodDefault<z.ZodEnum<{
+            lazy: "lazy";
+            parallel: "parallel";
+            eager: "eager";
+            deferred: "deferred";
+            "on-demand": "on-demand";
+        }>>;
+        preload: z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            priority: z.ZodDefault<z.ZodNumber>;
+            resources: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+                code: "code";
+                dependencies: "dependencies";
+                metadata: "metadata";
+                assets: "assets";
+                services: "services";
+            }>>>;
+            conditions: z.ZodOptional<z.ZodObject<{
+                routes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                roles: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                deviceType: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+                    desktop: "desktop";
+                    mobile: "mobile";
+                    tablet: "tablet";
+                }>>>;
+                minNetworkSpeed: z.ZodOptional<z.ZodEnum<{
+                    "slow-2g": "slow-2g";
+                    "2g": "2g";
+                    "3g": "3g";
+                    "4g": "4g";
+                }>>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+        codeSplitting: z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            strategy: z.ZodDefault<z.ZodEnum<{
+                custom: "custom";
+                size: "size";
+                route: "route";
+                feature: "feature";
+            }>>;
+            chunkNaming: z.ZodDefault<z.ZodEnum<{
+                hashed: "hashed";
+                sequential: "sequential";
+                named: "named";
+            }>>;
+            maxChunkSize: z.ZodOptional<z.ZodNumber>;
+            sharedDependencies: z.ZodOptional<z.ZodObject<{
+                enabled: z.ZodDefault<z.ZodBoolean>;
+                minChunks: z.ZodDefault<z.ZodNumber>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+        dynamicImport: z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            mode: z.ZodDefault<z.ZodEnum<{
+                lazy: "lazy";
+                async: "async";
+                sync: "sync";
+                eager: "eager";
+            }>>;
+            prefetch: z.ZodDefault<z.ZodBoolean>;
+            preload: z.ZodDefault<z.ZodBoolean>;
+            webpackChunkName: z.ZodOptional<z.ZodString>;
+            timeout: z.ZodDefault<z.ZodNumber>;
+            retry: z.ZodOptional<z.ZodObject<{
+                enabled: z.ZodDefault<z.ZodBoolean>;
+                maxAttempts: z.ZodDefault<z.ZodNumber>;
+                backoffMs: z.ZodDefault<z.ZodNumber>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+        initialization: z.ZodOptional<z.ZodObject<{
+            mode: z.ZodDefault<z.ZodEnum<{
+                async: "async";
+                parallel: "parallel";
+                sequential: "sequential";
+                sync: "sync";
+            }>>;
+            timeout: z.ZodDefault<z.ZodNumber>;
+            priority: z.ZodDefault<z.ZodNumber>;
+            critical: z.ZodDefault<z.ZodBoolean>;
+            retry: z.ZodOptional<z.ZodObject<{
+                enabled: z.ZodDefault<z.ZodBoolean>;
+                maxAttempts: z.ZodDefault<z.ZodNumber>;
+                backoffMs: z.ZodDefault<z.ZodNumber>;
+            }, z.core.$strip>>;
+            healthCheckInterval: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+        dependencyResolution: z.ZodOptional<z.ZodObject<{
+            strategy: z.ZodDefault<z.ZodEnum<{
+                strict: "strict";
+                pinned: "pinned";
+                latest: "latest";
+                compatible: "compatible";
+            }>>;
+            peerDependencies: z.ZodOptional<z.ZodObject<{
+                resolve: z.ZodDefault<z.ZodBoolean>;
+                onMissing: z.ZodDefault<z.ZodEnum<{
+                    error: "error";
+                    warn: "warn";
+                    ignore: "ignore";
+                }>>;
+                onMismatch: z.ZodDefault<z.ZodEnum<{
+                    error: "error";
+                    warn: "warn";
+                    ignore: "ignore";
+                }>>;
+            }, z.core.$strip>>;
+            optionalDependencies: z.ZodOptional<z.ZodObject<{
+                load: z.ZodDefault<z.ZodBoolean>;
+                onFailure: z.ZodDefault<z.ZodEnum<{
+                    warn: "warn";
+                    ignore: "ignore";
+                }>>;
+            }, z.core.$strip>>;
+            conflictResolution: z.ZodDefault<z.ZodEnum<{
+                latest: "latest";
+                manual: "manual";
+                fail: "fail";
+                oldest: "oldest";
+            }>>;
+            circularDependencies: z.ZodDefault<z.ZodEnum<{
+                error: "error";
+                warn: "warn";
+                allow: "allow";
+            }>>;
+        }, z.core.$strip>>;
+        hotReload: z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            environment: z.ZodDefault<z.ZodEnum<{
+                development: "development";
+                production: "production";
+                staging: "staging";
+            }>>;
+            strategy: z.ZodDefault<z.ZodEnum<{
+                partial: "partial";
+                full: "full";
+                "state-preserve": "state-preserve";
+            }>>;
+            watchPatterns: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            ignorePatterns: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            debounceMs: z.ZodDefault<z.ZodNumber>;
+            preserveState: z.ZodDefault<z.ZodBoolean>;
+            stateSerialization: z.ZodOptional<z.ZodObject<{
+                enabled: z.ZodDefault<z.ZodBoolean>;
+                handler: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>;
+            hooks: z.ZodOptional<z.ZodObject<{
+                beforeReload: z.ZodOptional<z.ZodString>;
+                afterReload: z.ZodOptional<z.ZodString>;
+                onError: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>;
+            productionSafety: z.ZodOptional<z.ZodObject<{
+                healthValidation: z.ZodDefault<z.ZodBoolean>;
+                rollbackOnFailure: z.ZodDefault<z.ZodBoolean>;
+                healthTimeout: z.ZodDefault<z.ZodNumber>;
+                drainConnections: z.ZodDefault<z.ZodBoolean>;
+                drainTimeout: z.ZodDefault<z.ZodNumber>;
+                maxConcurrentReloads: z.ZodDefault<z.ZodNumber>;
+                minReloadInterval: z.ZodDefault<z.ZodNumber>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+        caching: z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            storage: z.ZodDefault<z.ZodEnum<{
+                hybrid: "hybrid";
+                indexeddb: "indexeddb";
+                memory: "memory";
+                disk: "disk";
+            }>>;
+            keyStrategy: z.ZodDefault<z.ZodEnum<{
+                hash: "hash";
+                timestamp: "timestamp";
+                version: "version";
+            }>>;
+            ttl: z.ZodOptional<z.ZodNumber>;
+            maxSize: z.ZodOptional<z.ZodNumber>;
+            invalidateOn: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+                error: "error";
+                manual: "manual";
+                "version-change": "version-change";
+                "dependency-change": "dependency-change";
+            }>>>;
+            compression: z.ZodOptional<z.ZodObject<{
+                enabled: z.ZodDefault<z.ZodBoolean>;
+                algorithm: z.ZodDefault<z.ZodEnum<{
+                    gzip: "gzip";
+                    brotli: "brotli";
+                    deflate: "deflate";
+                }>>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+        sandboxing: z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            scope: z.ZodDefault<z.ZodEnum<{
+                "automation-only": "automation-only";
+                "untrusted-only": "untrusted-only";
+                "all-plugins": "all-plugins";
+            }>>;
+            isolationLevel: z.ZodDefault<z.ZodEnum<{
+                none: "none";
+                process: "process";
+                vm: "vm";
+                iframe: "iframe";
+                "web-worker": "web-worker";
+            }>>;
+            allowedCapabilities: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            resourceQuotas: z.ZodOptional<z.ZodObject<{
+                maxMemoryMB: z.ZodOptional<z.ZodNumber>;
+                maxCpuTimeMs: z.ZodOptional<z.ZodNumber>;
+                maxFileDescriptors: z.ZodOptional<z.ZodNumber>;
+                maxNetworkKBps: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>>;
+            permissions: z.ZodOptional<z.ZodObject<{
+                allowedAPIs: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                allowedPaths: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                allowedEndpoints: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                allowedEnvVars: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            }, z.core.$strip>>;
+            ipc: z.ZodOptional<z.ZodObject<{
+                enabled: z.ZodDefault<z.ZodBoolean>;
+                transport: z.ZodDefault<z.ZodEnum<{
+                    memory: "memory";
+                    "message-port": "message-port";
+                    "unix-socket": "unix-socket";
+                    tcp: "tcp";
+                }>>;
+                maxMessageSize: z.ZodDefault<z.ZodNumber>;
+                timeout: z.ZodDefault<z.ZodNumber>;
+                allowedServices: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+        monitoring: z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            metrics: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+                "load-time": "load-time";
+                "init-time": "init-time";
+                "memory-usage": "memory-usage";
+                "cpu-usage": "cpu-usage";
+                "api-calls": "api-calls";
+                "error-rate": "error-rate";
+                "cache-hit-rate": "cache-hit-rate";
+            }>>>;
+            samplingRate: z.ZodDefault<z.ZodNumber>;
+            reportingInterval: z.ZodDefault<z.ZodNumber>;
+            budgets: z.ZodOptional<z.ZodObject<{
+                maxLoadTimeMs: z.ZodOptional<z.ZodNumber>;
+                maxInitTimeMs: z.ZodOptional<z.ZodNumber>;
+                maxMemoryMB: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>>;
+            onBudgetViolation: z.ZodDefault<z.ZodEnum<{
+                error: "error";
+                warn: "warn";
+                ignore: "ignore";
+            }>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    engine: z.ZodOptional<z.ZodObject<{
+        objectstack: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+/**
+ * TypeScript type inferred from the ManifestSchema.
+ * Use this type for type-safe manifest handling in TypeScript code.
+ */
+type ObjectStackManifest = z.infer<typeof ManifestSchema>;
+type ObjectStackManifestInput = z.input<typeof ManifestSchema>;
+
+/**
+ * # Metadata Customization Layer Protocol
+ *
+ * Defines the overlay system for managing user customizations on top of
+ * package-delivered metadata. This protocol solves the critical challenge
+ * of separating "vendor-managed" metadata from "customer-customized" metadata,
+ * enabling safe package upgrades without losing user changes.
+ *
+ * ## Architecture Alignment
+ * - **Salesforce**: Managed vs Unmanaged metadata components
+ * - **ServiceNow**: Update Sets with collision detection
+ * - **WordPress**: Parent/child theme overlay model
+ * - **Kubernetes**: Strategic merge patch for resource customization
+ *
+ * ## Three-Layer Model
+ * ```
+ * ┌─────────────────────────────────┐
+ * │  User Layer (scope: user)       │  ← Personal overrides (per-user)
+ * ├─────────────────────────────────┤
+ * │  Platform Layer (scope: platform)│  ← Admin customizations (per-tenant)
+ * ├─────────────────────────────────┤
+ * │  System Layer (scope: system)   │  ← Package-delivered metadata (read-only)
+ * └─────────────────────────────────┘
+ * ```
+ *
+ * ## Merge Resolution Order
+ * Effective metadata = System ← merge(Platform) ← merge(User)
+ * Each layer only stores the delta (changed fields), not the full definition.
+ */
+/**
+ * Customization Origin
+ * Identifies who created the customization.
+ */
+declare const CustomizationOriginSchema: z.ZodEnum<{
+    api: "api";
+    user: "user";
+    package: "package";
+    migration: "migration";
+    admin: "admin";
+}>;
+/**
+ * Field-Level Change Tracking
+ * Records exactly which fields were modified by the customer.
+ */
+declare const FieldChangeSchema: z.ZodObject<{
+    path: z.ZodString;
+    originalValue: z.ZodOptional<z.ZodUnknown>;
+    currentValue: z.ZodUnknown;
+    changedBy: z.ZodOptional<z.ZodString>;
+    changedAt: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/**
+ * Metadata Overlay Schema
+ *
+ * Represents a customization layer on top of package-delivered metadata.
+ * Each overlay stores only the delta (changed fields) relative to the base definition.
+ *
+ * During package upgrades, the system performs a 3-way merge:
+ * 1. Old package version (base)
+ * 2. New package version (theirs)
+ * 3. Customer customizations (ours)
+ *
+ * @example
+ * ```yaml
+ * # Package delivers: object "crm__account" with field "status" label "Status"
+ * # Admin changes label to "Account Status"
+ * # Overlay record:
+ * baseType: object
+ * baseName: crm__account
+ * packageId: com.acme.crm
+ * packageVersion: "1.0.0"
+ * changes:
+ *   - path: "fields.status.label"
+ *     originalValue: "Status"
+ *     currentValue: "Account Status"
+ * ```
+ */
+declare const MetadataOverlaySchema: z.ZodObject<{
+    id: z.ZodString;
+    baseType: z.ZodString;
+    baseName: z.ZodString;
+    packageId: z.ZodOptional<z.ZodString>;
+    packageVersion: z.ZodOptional<z.ZodString>;
+    scope: z.ZodDefault<z.ZodEnum<{
+        user: "user";
+        platform: "platform";
+    }>>;
+    tenantId: z.ZodOptional<z.ZodString>;
+    owner: z.ZodOptional<z.ZodString>;
+    patch: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    changes: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        originalValue: z.ZodOptional<z.ZodUnknown>;
+        currentValue: z.ZodUnknown;
+        changedBy: z.ZodOptional<z.ZodString>;
+        changedAt: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    active: z.ZodDefault<z.ZodBoolean>;
+    createdAt: z.ZodOptional<z.ZodString>;
+    createdBy: z.ZodOptional<z.ZodString>;
+    updatedAt: z.ZodOptional<z.ZodString>;
+    updatedBy: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/**
+ * Merge Conflict
+ * Represents a conflict between package update and customer customization.
+ */
+declare const MergeConflictSchema: z.ZodObject<{
+    path: z.ZodString;
+    baseValue: z.ZodUnknown;
+    incomingValue: z.ZodUnknown;
+    customValue: z.ZodUnknown;
+    suggestedResolution: z.ZodEnum<{
+        manual: "manual";
+        "keep-custom": "keep-custom";
+        "accept-incoming": "accept-incoming";
+    }>;
+    reason: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/**
+ * Merge Strategy Configuration
+ * Controls how metadata merging behaves during package upgrades.
+ */
+declare const MergeStrategyConfigSchema: z.ZodObject<{
+    defaultStrategy: z.ZodDefault<z.ZodEnum<{
+        "keep-custom": "keep-custom";
+        "accept-incoming": "accept-incoming";
+        "three-way-merge": "three-way-merge";
+    }>>;
+    alwaysAcceptIncoming: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    alwaysKeepCustom: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    autoResolveNonConflicting: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>;
+/**
+ * Merge Result
+ * Result of a 3-way merge operation during package upgrade.
+ */
+declare const MergeResultSchema: z.ZodObject<{
+    success: z.ZodBoolean;
+    mergedMetadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    updatedOverlay: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    conflicts: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        baseValue: z.ZodUnknown;
+        incomingValue: z.ZodUnknown;
+        customValue: z.ZodUnknown;
+        suggestedResolution: z.ZodEnum<{
+            manual: "manual";
+            "keep-custom": "keep-custom";
+            "accept-incoming": "accept-incoming";
+        }>;
+        reason: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    autoResolved: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        resolution: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    stats: z.ZodOptional<z.ZodObject<{
+        totalFields: z.ZodNumber;
+        unchanged: z.ZodNumber;
+        autoResolved: z.ZodNumber;
+        conflicts: z.ZodNumber;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+/**
+ * Customizable Metadata Policy
+ * Defines what parts of a metadata item can be customized by admins/users.
+ * Package vendors use this to control customization boundaries.
+ */
+declare const CustomizationPolicySchema: z.ZodObject<{
+    metadataType: z.ZodString;
+    allowCustomization: z.ZodDefault<z.ZodBoolean>;
+    lockedFields: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    customizableFields: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    allowAddFields: z.ZodDefault<z.ZodBoolean>;
+    allowDeleteFields: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>;
+type CustomizationOrigin = z.infer<typeof CustomizationOriginSchema>;
+type FieldChange = z.infer<typeof FieldChangeSchema>;
+type MetadataOverlay = z.infer<typeof MetadataOverlaySchema>;
+type MergeConflict = z.infer<typeof MergeConflictSchema>;
+type MergeStrategyConfig = z.infer<typeof MergeStrategyConfigSchema>;
+type MergeResult = z.infer<typeof MergeResultSchema>;
+type CustomizationPolicy = z.infer<typeof CustomizationPolicySchema>;
+
+/**
+ * # Metadata Plugin Protocol
+ *
+ * Defines the specification for the **Metadata Plugin** — the central authority
+ * responsible for managing ALL metadata across the ObjectStack platform.
+ *
+ * ## Architecture
+ * The Metadata Plugin consolidates all scattered metadata operations into a single,
+ * cohesive plugin that "takes over" the entire platform's metadata management:
+ *
+ * ```
+ * ┌──────────────────────────────────────────────────────────────────┐
+ * │                     Metadata Plugin                             │
+ * │                                                                  │
+ * │  ┌──────────────┐  ┌──────────────┐  ┌──────────────────────┐  │
+ * │  │ Type Registry │  │  Loader      │  │ Customization Layer  │  │
+ * │  │ (all types)   │  │  (file/db/s3)│  │ (overlay / merge)    │  │
+ * │  └──────────────┘  └──────────────┘  └──────────────────────┘  │
+ * │                                                                  │
+ * │  ┌──────────────┐  ┌──────────────┐  ┌──────────────────────┐  │
+ * │  │ Persistence  │  │  Query       │  │ Lifecycle            │  │
+ * │  │ (db records) │  │  (search)    │  │ (validate/deploy)    │  │
+ * │  └──────────────┘  └──────────────┘  └──────────────────────┘  │
+ * └──────────────────────────────────────────────────────────────────┘
+ * ```
+ *
+ * ## Alignment
+ * - **Salesforce**: Metadata API (deploy, retrieve, describe)
+ * - **ServiceNow**: System Dictionary + Metadata API
+ * - **Kubernetes**: API Server + CRD Registry
+ *
+ * ## References
+ * - kernel/metadata-loader.zod.ts — Storage backend protocol
+ * - kernel/metadata-customization.zod.ts — Overlay/merge protocol
+ * - system/metadata-persistence.zod.ts — Database record format
+ * - contracts/metadata-service.ts — Service interface
+ */
+/**
+ * Platform Metadata Type Enum
+ *
+ * The canonical list of all metadata types managed by the platform.
+ * Each type maps to a specific Zod schema (e.g., ObjectSchema, ViewSchema).
+ * Plugins can extend this registry via `contributes.kinds` in the manifest.
+ */
+declare const MetadataTypeSchema: z.ZodEnum<{
+    object: "object";
+    function: "function";
+    field: "field";
+    datasource: "datasource";
+    profile: "profile";
+    role: "role";
+    page: "page";
+    approval: "approval";
+    service: "service";
+    dashboard: "dashboard";
+    report: "report";
+    action: "action";
+    view: "view";
+    flow: "flow";
+    app: "app";
+    validation: "validation";
+    trigger: "trigger";
+    workflow: "workflow";
+    hook: "hook";
+    router: "router";
+    agent: "agent";
+    translation: "translation";
+    permission: "permission";
+}>;
+type MetadataType = z.infer<typeof MetadataTypeSchema>;
+/**
+ * Metadata Type Registry Entry
+ *
+ * Describes a registered metadata type, including its validation schema,
+ * file patterns, and capabilities. Used by the metadata plugin to:
+ * 1. Discover metadata files on disk
+ * 2. Validate metadata payloads
+ * 3. Determine storage behavior
+ */
+declare const MetadataTypeRegistryEntrySchema: z.ZodObject<{
+    type: z.ZodEnum<{
+        object: "object";
+        function: "function";
+        field: "field";
+        datasource: "datasource";
+        profile: "profile";
+        role: "role";
+        page: "page";
+        approval: "approval";
+        service: "service";
+        dashboard: "dashboard";
+        report: "report";
+        action: "action";
+        view: "view";
+        flow: "flow";
+        app: "app";
+        validation: "validation";
+        trigger: "trigger";
+        workflow: "workflow";
+        hook: "hook";
+        router: "router";
+        agent: "agent";
+        translation: "translation";
+        permission: "permission";
+    }>;
+    label: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    filePatterns: z.ZodArray<z.ZodString>;
+    supportsOverlay: z.ZodDefault<z.ZodBoolean>;
+    allowRuntimeCreate: z.ZodDefault<z.ZodBoolean>;
+    supportsVersioning: z.ZodDefault<z.ZodBoolean>;
+    loadOrder: z.ZodDefault<z.ZodNumber>;
+    domain: z.ZodEnum<{
+        data: "data";
+        system: "system";
+        automation: "automation";
+        security: "security";
+        ai: "ai";
+        ui: "ui";
+    }>;
+}, z.core.$strip>;
+type MetadataTypeRegistryEntry = z.infer<typeof MetadataTypeRegistryEntrySchema>;
+/**
+ * Metadata Query Schema
+ *
+ * Standard protocol for searching and filtering metadata items.
+ * Used by the metadata service to support advanced metadata discovery.
+ */
+declare const MetadataQuerySchema: z.ZodObject<{
+    types: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        object: "object";
+        function: "function";
+        field: "field";
+        datasource: "datasource";
+        profile: "profile";
+        role: "role";
+        page: "page";
+        approval: "approval";
+        service: "service";
+        dashboard: "dashboard";
+        report: "report";
+        action: "action";
+        view: "view";
+        flow: "flow";
+        app: "app";
+        validation: "validation";
+        trigger: "trigger";
+        workflow: "workflow";
+        hook: "hook";
+        router: "router";
+        agent: "agent";
+        translation: "translation";
+        permission: "permission";
+    }>>>;
+    namespaces: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    packageId: z.ZodOptional<z.ZodString>;
+    search: z.ZodOptional<z.ZodString>;
+    scope: z.ZodOptional<z.ZodEnum<{
+        user: "user";
+        system: "system";
+        platform: "platform";
+    }>>;
+    state: z.ZodOptional<z.ZodEnum<{
+        deprecated: "deprecated";
+        active: "active";
+        archived: "archived";
+        draft: "draft";
+    }>>;
+    tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    sortBy: z.ZodDefault<z.ZodEnum<{
+        type: "type";
+        name: "name";
+        createdAt: "createdAt";
+        updatedAt: "updatedAt";
+    }>>;
+    sortOrder: z.ZodDefault<z.ZodEnum<{
+        asc: "asc";
+        desc: "desc";
+    }>>;
+    page: z.ZodDefault<z.ZodNumber>;
+    pageSize: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+type MetadataQuery = z.input<typeof MetadataQuerySchema>;
+/**
+ * Metadata Query Result
+ */
+declare const MetadataQueryResultSchema: z.ZodObject<{
+    items: z.ZodArray<z.ZodObject<{
+        type: z.ZodString;
+        name: z.ZodString;
+        namespace: z.ZodOptional<z.ZodString>;
+        label: z.ZodOptional<z.ZodString>;
+        scope: z.ZodOptional<z.ZodEnum<{
+            user: "user";
+            system: "system";
+            platform: "platform";
+        }>>;
+        state: z.ZodOptional<z.ZodEnum<{
+            deprecated: "deprecated";
+            active: "active";
+            archived: "archived";
+            draft: "draft";
+        }>>;
+        packageId: z.ZodOptional<z.ZodString>;
+        updatedAt: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    total: z.ZodNumber;
+    page: z.ZodNumber;
+    pageSize: z.ZodNumber;
+}, z.core.$strip>;
+type MetadataQueryResult = z.infer<typeof MetadataQueryResultSchema>;
+/**
+ * Metadata Event Schema
+ *
+ * Events emitted by the metadata plugin when metadata changes.
+ * Enables reactive patterns across the platform (cache invalidation,
+ * UI refresh, dependency tracking, etc.).
+ */
+declare const MetadataEventSchema: z.ZodObject<{
+    event: z.ZodEnum<{
+        "metadata.registered": "metadata.registered";
+        "metadata.updated": "metadata.updated";
+        "metadata.unregistered": "metadata.unregistered";
+        "metadata.validated": "metadata.validated";
+        "metadata.deployed": "metadata.deployed";
+        "metadata.overlay.applied": "metadata.overlay.applied";
+        "metadata.overlay.removed": "metadata.overlay.removed";
+        "metadata.imported": "metadata.imported";
+        "metadata.exported": "metadata.exported";
+    }>;
+    metadataType: z.ZodEnum<{
+        object: "object";
+        function: "function";
+        field: "field";
+        datasource: "datasource";
+        profile: "profile";
+        role: "role";
+        page: "page";
+        approval: "approval";
+        service: "service";
+        dashboard: "dashboard";
+        report: "report";
+        action: "action";
+        view: "view";
+        flow: "flow";
+        app: "app";
+        validation: "validation";
+        trigger: "trigger";
+        workflow: "workflow";
+        hook: "hook";
+        router: "router";
+        agent: "agent";
+        translation: "translation";
+        permission: "permission";
+    }>;
+    name: z.ZodString;
+    namespace: z.ZodOptional<z.ZodString>;
+    packageId: z.ZodOptional<z.ZodString>;
+    timestamp: z.ZodString;
+    actor: z.ZodOptional<z.ZodString>;
+    payload: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+type MetadataEvent = z.infer<typeof MetadataEventSchema>;
+/**
+ * Metadata Validation Result
+ */
+declare const MetadataValidationResultSchema: z.ZodObject<{
+    valid: z.ZodBoolean;
+    errors: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        message: z.ZodString;
+        code: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    warnings: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        message: z.ZodString;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+type MetadataValidationResult = z.infer<typeof MetadataValidationResultSchema>;
+/**
+ * Metadata Plugin Configuration
+ *
+ * The unified configuration for the metadata plugin, combining
+ * storage, caching, customization, and type registry settings.
+ */
+declare const MetadataPluginConfigSchema: z.ZodObject<{
+    storage: z.ZodObject<{
+        datasource: z.ZodOptional<z.ZodString>;
+        tableName: z.ZodDefault<z.ZodString>;
+        fallback: z.ZodDefault<z.ZodEnum<{
+            none: "none";
+            memory: "memory";
+            filesystem: "filesystem";
+        }>>;
+        rootDir: z.ZodOptional<z.ZodString>;
+        formats: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+            javascript: "javascript";
+            yaml: "yaml";
+            json: "json";
+            typescript: "typescript";
+        }>>>;
+        cache: z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            ttl: z.ZodDefault<z.ZodNumber>;
+            maxSize: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+        watch: z.ZodDefault<z.ZodBoolean>;
+        watchOptions: z.ZodOptional<z.ZodObject<{
+            ignored: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            persistent: z.ZodDefault<z.ZodBoolean>;
+            ignoreInitial: z.ZodDefault<z.ZodBoolean>;
+        }, z.core.$strip>>;
+        validation: z.ZodOptional<z.ZodObject<{
+            strict: z.ZodDefault<z.ZodBoolean>;
+            throwOnError: z.ZodDefault<z.ZodBoolean>;
+        }, z.core.$strip>>;
+        loaderOptions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>;
+    customizationPolicies: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        metadataType: z.ZodString;
+        allowCustomization: z.ZodDefault<z.ZodBoolean>;
+        lockedFields: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        customizableFields: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        allowAddFields: z.ZodDefault<z.ZodBoolean>;
+        allowDeleteFields: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strip>>>;
+    mergeStrategy: z.ZodOptional<z.ZodObject<{
+        defaultStrategy: z.ZodDefault<z.ZodEnum<{
+            "keep-custom": "keep-custom";
+            "accept-incoming": "accept-incoming";
+            "three-way-merge": "three-way-merge";
+        }>>;
+        alwaysAcceptIncoming: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        alwaysKeepCustom: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        autoResolveNonConflicting: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    additionalTypes: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        label: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        filePatterns: z.ZodArray<z.ZodString>;
+        supportsOverlay: z.ZodDefault<z.ZodBoolean>;
+        allowRuntimeCreate: z.ZodDefault<z.ZodBoolean>;
+        supportsVersioning: z.ZodDefault<z.ZodBoolean>;
+        loadOrder: z.ZodDefault<z.ZodNumber>;
+        domain: z.ZodEnum<{
+            data: "data";
+            system: "system";
+            automation: "automation";
+            security: "security";
+            ai: "ai";
+            ui: "ui";
+        }>;
+        type: z.ZodString;
+    }, z.core.$strip>>>;
+    enableEvents: z.ZodDefault<z.ZodBoolean>;
+    validateOnWrite: z.ZodDefault<z.ZodBoolean>;
+    enableVersioning: z.ZodDefault<z.ZodBoolean>;
+    cacheMaxItems: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+type MetadataPluginConfig = z.input<typeof MetadataPluginConfigSchema>;
+/**
+ * Metadata Plugin Manifest
+ *
+ * The complete manifest for the Metadata Plugin, declaring its identity,
+ * capabilities, and configuration. This is the "contract" between the
+ * metadata plugin and the kernel.
+ */
+declare const MetadataPluginManifestSchema: z.ZodObject<{
+    id: z.ZodLiteral<"com.objectstack.metadata">;
+    name: z.ZodLiteral<"ObjectStack Metadata Service">;
+    version: z.ZodString;
+    type: z.ZodLiteral<"standard">;
+    description: z.ZodDefault<z.ZodString>;
+    capabilities: z.ZodObject<{
+        crud: z.ZodDefault<z.ZodBoolean>;
+        query: z.ZodDefault<z.ZodBoolean>;
+        overlay: z.ZodDefault<z.ZodBoolean>;
+        watch: z.ZodDefault<z.ZodBoolean>;
+        importExport: z.ZodDefault<z.ZodBoolean>;
+        validation: z.ZodDefault<z.ZodBoolean>;
+        versioning: z.ZodDefault<z.ZodBoolean>;
+        events: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strip>;
+    config: z.ZodOptional<z.ZodObject<{
+        storage: z.ZodObject<{
+            datasource: z.ZodOptional<z.ZodString>;
+            tableName: z.ZodDefault<z.ZodString>;
+            fallback: z.ZodDefault<z.ZodEnum<{
+                none: "none";
+                memory: "memory";
+                filesystem: "filesystem";
+            }>>;
+            rootDir: z.ZodOptional<z.ZodString>;
+            formats: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+                javascript: "javascript";
+                yaml: "yaml";
+                json: "json";
+                typescript: "typescript";
+            }>>>;
+            cache: z.ZodOptional<z.ZodObject<{
+                enabled: z.ZodDefault<z.ZodBoolean>;
+                ttl: z.ZodDefault<z.ZodNumber>;
+                maxSize: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>>;
+            watch: z.ZodDefault<z.ZodBoolean>;
+            watchOptions: z.ZodOptional<z.ZodObject<{
+                ignored: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                persistent: z.ZodDefault<z.ZodBoolean>;
+                ignoreInitial: z.ZodDefault<z.ZodBoolean>;
+            }, z.core.$strip>>;
+            validation: z.ZodOptional<z.ZodObject<{
+                strict: z.ZodDefault<z.ZodBoolean>;
+                throwOnError: z.ZodDefault<z.ZodBoolean>;
+            }, z.core.$strip>>;
+            loaderOptions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, z.core.$strip>;
+        customizationPolicies: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            metadataType: z.ZodString;
+            allowCustomization: z.ZodDefault<z.ZodBoolean>;
+            lockedFields: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            customizableFields: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            allowAddFields: z.ZodDefault<z.ZodBoolean>;
+            allowDeleteFields: z.ZodDefault<z.ZodBoolean>;
+        }, z.core.$strip>>>;
+        mergeStrategy: z.ZodOptional<z.ZodObject<{
+            defaultStrategy: z.ZodDefault<z.ZodEnum<{
+                "keep-custom": "keep-custom";
+                "accept-incoming": "accept-incoming";
+                "three-way-merge": "three-way-merge";
+            }>>;
+            alwaysAcceptIncoming: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            alwaysKeepCustom: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            autoResolveNonConflicting: z.ZodDefault<z.ZodBoolean>;
+        }, z.core.$strip>>;
+        additionalTypes: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            label: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+            filePatterns: z.ZodArray<z.ZodString>;
+            supportsOverlay: z.ZodDefault<z.ZodBoolean>;
+            allowRuntimeCreate: z.ZodDefault<z.ZodBoolean>;
+            supportsVersioning: z.ZodDefault<z.ZodBoolean>;
+            loadOrder: z.ZodDefault<z.ZodNumber>;
+            domain: z.ZodEnum<{
+                data: "data";
+                system: "system";
+                automation: "automation";
+                security: "security";
+                ai: "ai";
+                ui: "ui";
+            }>;
+            type: z.ZodString;
+        }, z.core.$strip>>>;
+        enableEvents: z.ZodDefault<z.ZodBoolean>;
+        validateOnWrite: z.ZodDefault<z.ZodBoolean>;
+        enableVersioning: z.ZodDefault<z.ZodBoolean>;
+        cacheMaxItems: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+type MetadataPluginManifest = z.input<typeof MetadataPluginManifestSchema>;
+/**
+ * Default Type Registry
+ *
+ * The built-in metadata type registry with default configurations.
+ * Plugins extend this via `contributes.kinds` in the manifest.
+ */
+declare const DEFAULT_METADATA_TYPE_REGISTRY: MetadataTypeRegistryEntry[];
+/**
+ * Bulk Register Request
+ */
+declare const MetadataBulkRegisterRequestSchema: z.ZodObject<{
+    items: z.ZodArray<z.ZodObject<{
+        type: z.ZodString;
+        name: z.ZodString;
+        data: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        namespace: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    continueOnError: z.ZodDefault<z.ZodBoolean>;
+    validate: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>;
+type MetadataBulkRegisterRequest = z.input<typeof MetadataBulkRegisterRequestSchema>;
+/**
+ * Bulk Operation Result
+ */
+declare const MetadataBulkResultSchema: z.ZodObject<{
+    total: z.ZodNumber;
+    succeeded: z.ZodNumber;
+    failed: z.ZodNumber;
+    errors: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        type: z.ZodString;
+        name: z.ZodString;
+        error: z.ZodString;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+type MetadataBulkResult = z.infer<typeof MetadataBulkResultSchema>;
+/**
+ * Metadata Dependency Schema
+ *
+ * Tracks dependencies between metadata items.
+ * Used for impact analysis and safe deletion checks.
+ */
+declare const MetadataDependencySchema: z.ZodObject<{
+    sourceType: z.ZodString;
+    sourceName: z.ZodString;
+    targetType: z.ZodString;
+    targetName: z.ZodString;
+    kind: z.ZodEnum<{
+        reference: "reference";
+        includes: "includes";
+        triggers: "triggers";
+        extends: "extends";
+    }>;
+}, z.core.$strip>;
+type MetadataDependency = z.infer<typeof MetadataDependencySchema>;
+
+/**
+ * # Package Artifact Format Protocol
+ *
+ * Defines the standard structure of a package artifact (.tgz) produced by
+ * `os plugin build`. The marketplace uses these schemas to validate, store,
+ * and distribute package artifacts.
+ *
+ * ## Artifact Internal Structure
+ * ```
+ * ├── manifest.json          ← ManifestSchema serialized
+ * ├── metadata/              ← 30+ metadata types (JSON)
+ * │   ├── objects/            ← *.object.json
+ * │   ├── views/              ← *.view.json
+ * │   ├── pages/              ← *.page.json
+ * │   ├── flows/              ← *.flow.json
+ * │   ├── dashboards/         ← *.dashboard.json
+ * │   ├── permissions/        ← *.permission.json
+ * │   ├── agents/             ← *.agent.json
+ * │   └── ...                 ← Other metadata types
+ * ├── assets/                ← Static resources
+ * │   ├── icon.svg
+ * │   └── screenshots/
+ * ├── data/                  ← Seed data (DatasetSchema serialized)
+ * ├── locales/               ← i18n translation files
+ * ├── checksums.json         ← SHA256 checksum per file
+ * └── signature.sig          ← RSA-SHA256 package signature
+ * ```
+ *
+ * ## Architecture Alignment
+ * - **Salesforce**: Managed Package .zip with metadata components
+ * - **npm**: .tgz with package.json + contents
+ * - **Helm**: Chart .tgz with Chart.yaml + templates
+ * - **VS Code**: .vsix (zip) with extension manifest + assets
+ */
+/**
+ * Supported metadata categories within an artifact.
+ * Each category maps to a subdirectory under `metadata/`.
+ */
+declare const MetadataCategoryEnum: z.ZodEnum<{
+    objects: "objects";
+    pages: "pages";
+    dashboards: "dashboards";
+    reports: "reports";
+    actions: "actions";
+    themes: "themes";
+    workflows: "workflows";
+    flows: "flows";
+    permissions: "permissions";
+    apis: "apis";
+    agents: "agents";
+    triggers: "triggers";
+    views: "views";
+    translations: "translations";
+    datasets: "datasets";
+}>;
+type MetadataCategory = z.infer<typeof MetadataCategoryEnum>;
+/**
+ * A single file entry within the artifact.
+ */
+declare const ArtifactFileEntrySchema: z.ZodObject<{
+    path: z.ZodString;
+    size: z.ZodNumber;
+    category: z.ZodOptional<z.ZodEnum<{
+        objects: "objects";
+        pages: "pages";
+        dashboards: "dashboards";
+        reports: "reports";
+        actions: "actions";
+        themes: "themes";
+        workflows: "workflows";
+        flows: "flows";
+        permissions: "permissions";
+        apis: "apis";
+        agents: "agents";
+        triggers: "triggers";
+        views: "views";
+        translations: "translations";
+        datasets: "datasets";
+    }>>;
+}, z.core.$strip>;
+type ArtifactFileEntry = z.infer<typeof ArtifactFileEntrySchema>;
+/**
+ * Checksum map for artifact integrity verification.
+ * Maps relative file paths to their SHA256 hash values.
+ *
+ * @example
+ * {
+ *   "manifest.json": "a1b2c3...",
+ *   "metadata/objects/account.object.json": "d4e5f6..."
+ * }
+ */
+declare const ArtifactChecksumSchema: z.ZodObject<{
+    algorithm: z.ZodDefault<z.ZodEnum<{
+        sha256: "sha256";
+        sha384: "sha384";
+        sha512: "sha512";
+    }>>;
+    files: z.ZodRecord<z.ZodString, z.ZodString>;
+}, z.core.$strip>;
+type ArtifactChecksum = z.infer<typeof ArtifactChecksumSchema>;
+/**
+ * Digital signature for artifact authenticity verification.
+ * Ensures the artifact was produced by a trusted publisher and has not been tampered with.
+ */
+declare const ArtifactSignatureSchema: z.ZodObject<{
+    algorithm: z.ZodDefault<z.ZodEnum<{
+        "RSA-SHA256": "RSA-SHA256";
+        "RSA-SHA384": "RSA-SHA384";
+        "RSA-SHA512": "RSA-SHA512";
+        "ECDSA-SHA256": "ECDSA-SHA256";
+    }>>;
+    publicKeyRef: z.ZodString;
+    signature: z.ZodString;
+    signedAt: z.ZodOptional<z.ZodString>;
+    signedBy: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type ArtifactSignature = z.infer<typeof ArtifactSignatureSchema>;
+/**
+ * Package Artifact Schema
+ *
+ * Describes the complete structure and metadata of a built package artifact.
+ * This schema is used to validate artifacts before upload to the marketplace.
+ */
+declare const PackageArtifactSchema: z.ZodObject<{
+    formatVersion: z.ZodDefault<z.ZodString>;
+    packageId: z.ZodString;
+    version: z.ZodString;
+    format: z.ZodDefault<z.ZodEnum<{
+        tgz: "tgz";
+        zip: "zip";
+    }>>;
+    size: z.ZodOptional<z.ZodNumber>;
+    builtAt: z.ZodString;
+    builtWith: z.ZodOptional<z.ZodString>;
+    files: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        size: z.ZodNumber;
+        category: z.ZodOptional<z.ZodEnum<{
+            objects: "objects";
+            pages: "pages";
+            dashboards: "dashboards";
+            reports: "reports";
+            actions: "actions";
+            themes: "themes";
+            workflows: "workflows";
+            flows: "flows";
+            permissions: "permissions";
+            apis: "apis";
+            agents: "agents";
+            triggers: "triggers";
+            views: "views";
+            translations: "translations";
+            datasets: "datasets";
+        }>>;
+    }, z.core.$strip>>>;
+    metadataCategories: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        objects: "objects";
+        pages: "pages";
+        dashboards: "dashboards";
+        reports: "reports";
+        actions: "actions";
+        themes: "themes";
+        workflows: "workflows";
+        flows: "flows";
+        permissions: "permissions";
+        apis: "apis";
+        agents: "agents";
+        triggers: "triggers";
+        views: "views";
+        translations: "translations";
+        datasets: "datasets";
+    }>>>;
+    checksums: z.ZodOptional<z.ZodObject<{
+        algorithm: z.ZodDefault<z.ZodEnum<{
+            sha256: "sha256";
+            sha384: "sha384";
+            sha512: "sha512";
+        }>>;
+        files: z.ZodRecord<z.ZodString, z.ZodString>;
+    }, z.core.$strip>>;
+    signature: z.ZodOptional<z.ZodObject<{
+        algorithm: z.ZodDefault<z.ZodEnum<{
+            "RSA-SHA256": "RSA-SHA256";
+            "RSA-SHA384": "RSA-SHA384";
+            "RSA-SHA512": "RSA-SHA512";
+            "ECDSA-SHA256": "ECDSA-SHA256";
+        }>>;
+        publicKeyRef: z.ZodString;
+        signature: z.ZodString;
+        signedAt: z.ZodOptional<z.ZodString>;
+        signedBy: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+type PackageArtifact = z.infer<typeof PackageArtifactSchema>;
+type PackageArtifactInput = z.input<typeof PackageArtifactSchema>;
+
+/**
+ * # Package Upgrade Protocol
+ *
+ * Defines the complete lifecycle for upgrading installed packages,
+ * including pre-upgrade analysis, snapshot/backup, execution, validation,
+ * and rollback capabilities.
+ *
+ * ## Architecture Alignment
+ * - **Salesforce**: Managed Package upgrade with push upgrades and subscriber control
+ * - **ServiceNow**: Update Sets with preview, commit, and back-out support
+ * - **Helm**: Helm upgrade with rollback to previous release
+ * - **Kubernetes**: Rolling update with readiness probes and automatic rollback
+ *
+ * ## Upgrade Flow
+ * ```
+ * 1. PreCheck    → Validate compatibility, check dependencies
+ * 2. Plan        → Generate upgrade plan with metadata diff
+ * 3. Snapshot    → Backup current state (metadata + customizations)
+ * 4. Execute     → Apply new package metadata with 3-way merge
+ * 5. Validate    → Run post-upgrade health checks
+ * 6. Commit      → Finalize upgrade (or Rollback on failure)
+ * ```
+ */
+/**
+ * Metadata Change Type
+ * Type of change detected between package versions.
+ */
+declare const MetadataChangeTypeSchema: z.ZodEnum<{
+    removed: "removed";
+    added: "added";
+    modified: "modified";
+    renamed: "renamed";
+}>;
+/**
+ * Metadata Diff Item
+ * Describes a single metadata change between two package versions.
+ */
+declare const MetadataDiffItemSchema: z.ZodObject<{
+    type: z.ZodString;
+    name: z.ZodString;
+    changeType: z.ZodEnum<{
+        removed: "removed";
+        added: "added";
+        modified: "modified";
+        renamed: "renamed";
+    }>;
+    hasConflict: z.ZodDefault<z.ZodBoolean>;
+    summary: z.ZodOptional<z.ZodString>;
+    previousName: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/**
+ * Upgrade Impact Level
+ * Indicates the severity of impact the upgrade will have.
+ */
+declare const UpgradeImpactLevelSchema: z.ZodEnum<{
+    none: "none";
+    medium: "medium";
+    critical: "critical";
+    high: "high";
+    low: "low";
+}>;
+/**
+ * Upgrade Plan Schema
+ * The analysis result before executing an upgrade.
+ * Generated by comparing old version metadata with new version metadata.
+ */
+declare const UpgradePlanSchema: z.ZodObject<{
+    packageId: z.ZodString;
+    fromVersion: z.ZodString;
+    toVersion: z.ZodString;
+    impactLevel: z.ZodEnum<{
+        none: "none";
+        medium: "medium";
+        critical: "critical";
+        high: "high";
+        low: "low";
+    }>;
+    changes: z.ZodArray<z.ZodObject<{
+        type: z.ZodString;
+        name: z.ZodString;
+        changeType: z.ZodEnum<{
+            removed: "removed";
+            added: "added";
+            modified: "modified";
+            renamed: "renamed";
+        }>;
+        hasConflict: z.ZodDefault<z.ZodBoolean>;
+        summary: z.ZodOptional<z.ZodString>;
+        previousName: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    affectedCustomizations: z.ZodDefault<z.ZodNumber>;
+    requiresMigration: z.ZodDefault<z.ZodBoolean>;
+    migrationScripts: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    dependencyUpgrades: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        packageId: z.ZodString;
+        fromVersion: z.ZodString;
+        toVersion: z.ZodString;
+    }, z.core.$strip>>>;
+    estimatedDuration: z.ZodOptional<z.ZodNumber>;
+    summary: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/**
+ * Upgrade Snapshot Schema
+ * Captures the complete state before an upgrade for rollback capability.
+ */
+declare const UpgradeSnapshotSchema: z.ZodObject<{
+    id: z.ZodString;
+    packageId: z.ZodString;
+    fromVersion: z.ZodString;
+    toVersion: z.ZodString;
+    tenantId: z.ZodOptional<z.ZodString>;
+    previousManifest: z.ZodObject<{
+        id: z.ZodString;
+        namespace: z.ZodOptional<z.ZodString>;
+        version: z.ZodString;
+        type: z.ZodEnum<{
+            theme: "theme";
+            driver: "driver";
+            app: "app";
+            server: "server";
+            ui: "ui";
+            module: "module";
+            agent: "agent";
+            objectql: "objectql";
+            plugin: "plugin";
+            gateway: "gateway";
+            adapter: "adapter";
+        }>;
+        name: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        permissions: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        objects: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        datasources: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        dependencies: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        configuration: z.ZodOptional<z.ZodObject<{
+            title: z.ZodOptional<z.ZodString>;
+            properties: z.ZodRecord<z.ZodString, z.ZodObject<{
+                type: z.ZodEnum<{
+                    string: "string";
+                    number: "number";
+                    boolean: "boolean";
+                    object: "object";
+                    array: "array";
+                }>;
+                default: z.ZodOptional<z.ZodUnknown>;
+                description: z.ZodOptional<z.ZodString>;
+                required: z.ZodOptional<z.ZodBoolean>;
+                secret: z.ZodOptional<z.ZodBoolean>;
+                enum: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+        contributes: z.ZodOptional<z.ZodObject<{
+            kinds: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                globs: z.ZodArray<z.ZodString>;
+                description: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>>;
+            events: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            menus: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                label: z.ZodString;
+                command: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>>>;
+            themes: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                label: z.ZodString;
+                path: z.ZodString;
+            }, z.core.$strip>>>;
+            translations: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                locale: z.ZodString;
+                path: z.ZodString;
+            }, z.core.$strip>>>;
+            actions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                label: z.ZodOptional<z.ZodString>;
+                description: z.ZodOptional<z.ZodString>;
+                input: z.ZodOptional<z.ZodUnknown>;
+                output: z.ZodOptional<z.ZodUnknown>;
+            }, z.core.$strip>>>;
+            drivers: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                label: z.ZodString;
+                description: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>>;
+            fieldTypes: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                label: z.ZodString;
+                description: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>>;
+            functions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                description: z.ZodOptional<z.ZodString>;
+                args: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                returnType: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>>;
+            routes: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                prefix: z.ZodString;
+                service: z.ZodString;
+                methods: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            }, z.core.$strip>>>;
+            commands: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                description: z.ZodOptional<z.ZodString>;
+                module: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>>;
+        data: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            object: z.ZodString;
+            externalId: z.ZodDefault<z.ZodString>;
+            mode: z.ZodDefault<z.ZodEnum<{
+                insert: "insert";
+                update: "update";
+                upsert: "upsert";
+                replace: "replace";
+                ignore: "ignore";
+            }>>;
+            env: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+                prod: "prod";
+                dev: "dev";
+                test: "test";
+            }>>>;
+            records: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, z.core.$strip>>>;
+        capabilities: z.ZodOptional<z.ZodObject<{
+            implements: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                protocol: z.ZodObject<{
+                    id: z.ZodString;
+                    label: z.ZodString;
+                    version: z.ZodObject<{
+                        major: z.ZodNumber;
+                        minor: z.ZodNumber;
+                        patch: z.ZodNumber;
+                    }, z.core.$strip>;
+                    specification: z.ZodOptional<z.ZodString>;
+                    description: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>;
+                conformance: z.ZodDefault<z.ZodEnum<{
+                    partial: "partial";
+                    deprecated: "deprecated";
+                    full: "full";
+                    experimental: "experimental";
+                }>>;
+                implementedFeatures: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                features: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    name: z.ZodString;
+                    enabled: z.ZodDefault<z.ZodBoolean>;
+                    description: z.ZodOptional<z.ZodString>;
+                    sinceVersion: z.ZodOptional<z.ZodString>;
+                    deprecatedSince: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>>>;
+                metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                certified: z.ZodDefault<z.ZodBoolean>;
+                certificationDate: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>>;
+            provides: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                name: z.ZodString;
+                description: z.ZodOptional<z.ZodString>;
+                version: z.ZodObject<{
+                    major: z.ZodNumber;
+                    minor: z.ZodNumber;
+                    patch: z.ZodNumber;
+                }, z.core.$strip>;
+                methods: z.ZodArray<z.ZodObject<{
+                    name: z.ZodString;
+                    description: z.ZodOptional<z.ZodString>;
+                    parameters: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                        name: z.ZodString;
+                        type: z.ZodString;
+                        required: z.ZodDefault<z.ZodBoolean>;
+                        description: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strip>>>;
+                    returnType: z.ZodOptional<z.ZodString>;
+                    async: z.ZodDefault<z.ZodBoolean>;
+                }, z.core.$strip>>;
+                events: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    name: z.ZodString;
+                    description: z.ZodOptional<z.ZodString>;
+                    payload: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>>>;
+                stability: z.ZodDefault<z.ZodEnum<{
+                    alpha: "alpha";
+                    experimental: "experimental";
+                    stable: "stable";
+                    beta: "beta";
+                }>>;
+            }, z.core.$strip>>>;
+            requires: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                pluginId: z.ZodString;
+                version: z.ZodString;
+                optional: z.ZodDefault<z.ZodBoolean>;
+                reason: z.ZodOptional<z.ZodString>;
+                requiredCapabilities: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            }, z.core.$strip>>>;
+            extensionPoints: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                name: z.ZodString;
+                description: z.ZodOptional<z.ZodString>;
+                type: z.ZodEnum<{
+                    provider: "provider";
+                    action: "action";
+                    widget: "widget";
+                    hook: "hook";
+                    transformer: "transformer";
+                    validator: "validator";
+                    decorator: "decorator";
+                }>;
+                contract: z.ZodOptional<z.ZodObject<{
+                    input: z.ZodOptional<z.ZodString>;
+                    output: z.ZodOptional<z.ZodString>;
+                    signature: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>>;
+                cardinality: z.ZodDefault<z.ZodEnum<{
+                    multiple: "multiple";
+                    single: "single";
+                }>>;
+            }, z.core.$strip>>>;
+            extensions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                targetPluginId: z.ZodString;
+                extensionPointId: z.ZodString;
+                implementation: z.ZodString;
+                priority: z.ZodDefault<z.ZodNumber>;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>>;
+        extensions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        loading: z.ZodOptional<z.ZodObject<{
+            strategy: z.ZodDefault<z.ZodEnum<{
+                lazy: "lazy";
+                parallel: "parallel";
+                eager: "eager";
+                deferred: "deferred";
+                "on-demand": "on-demand";
+            }>>;
+            preload: z.ZodOptional<z.ZodObject<{
+                enabled: z.ZodDefault<z.ZodBoolean>;
+                priority: z.ZodDefault<z.ZodNumber>;
+                resources: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+                    code: "code";
+                    dependencies: "dependencies";
+                    metadata: "metadata";
+                    assets: "assets";
+                    services: "services";
+                }>>>;
+                conditions: z.ZodOptional<z.ZodObject<{
+                    routes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                    roles: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                    deviceType: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+                        desktop: "desktop";
+                        mobile: "mobile";
+                        tablet: "tablet";
+                    }>>>;
+                    minNetworkSpeed: z.ZodOptional<z.ZodEnum<{
+                        "slow-2g": "slow-2g";
+                        "2g": "2g";
+                        "3g": "3g";
+                        "4g": "4g";
+                    }>>;
+                }, z.core.$strip>>;
+            }, z.core.$strip>>;
+            codeSplitting: z.ZodOptional<z.ZodObject<{
+                enabled: z.ZodDefault<z.ZodBoolean>;
+                strategy: z.ZodDefault<z.ZodEnum<{
+                    custom: "custom";
+                    size: "size";
+                    route: "route";
+                    feature: "feature";
+                }>>;
+                chunkNaming: z.ZodDefault<z.ZodEnum<{
+                    hashed: "hashed";
+                    sequential: "sequential";
+                    named: "named";
+                }>>;
+                maxChunkSize: z.ZodOptional<z.ZodNumber>;
+                sharedDependencies: z.ZodOptional<z.ZodObject<{
+                    enabled: z.ZodDefault<z.ZodBoolean>;
+                    minChunks: z.ZodDefault<z.ZodNumber>;
+                }, z.core.$strip>>;
+            }, z.core.$strip>>;
+            dynamicImport: z.ZodOptional<z.ZodObject<{
+                enabled: z.ZodDefault<z.ZodBoolean>;
+                mode: z.ZodDefault<z.ZodEnum<{
+                    lazy: "lazy";
+                    async: "async";
+                    sync: "sync";
+                    eager: "eager";
+                }>>;
+                prefetch: z.ZodDefault<z.ZodBoolean>;
+                preload: z.ZodDefault<z.ZodBoolean>;
+                webpackChunkName: z.ZodOptional<z.ZodString>;
+                timeout: z.ZodDefault<z.ZodNumber>;
+                retry: z.ZodOptional<z.ZodObject<{
+                    enabled: z.ZodDefault<z.ZodBoolean>;
+                    maxAttempts: z.ZodDefault<z.ZodNumber>;
+                    backoffMs: z.ZodDefault<z.ZodNumber>;
+                }, z.core.$strip>>;
+            }, z.core.$strip>>;
+            initialization: z.ZodOptional<z.ZodObject<{
+                mode: z.ZodDefault<z.ZodEnum<{
+                    async: "async";
+                    parallel: "parallel";
+                    sequential: "sequential";
+                    sync: "sync";
+                }>>;
+                timeout: z.ZodDefault<z.ZodNumber>;
+                priority: z.ZodDefault<z.ZodNumber>;
+                critical: z.ZodDefault<z.ZodBoolean>;
+                retry: z.ZodOptional<z.ZodObject<{
+                    enabled: z.ZodDefault<z.ZodBoolean>;
+                    maxAttempts: z.ZodDefault<z.ZodNumber>;
+                    backoffMs: z.ZodDefault<z.ZodNumber>;
+                }, z.core.$strip>>;
+                healthCheckInterval: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>>;
+            dependencyResolution: z.ZodOptional<z.ZodObject<{
+                strategy: z.ZodDefault<z.ZodEnum<{
+                    strict: "strict";
+                    pinned: "pinned";
+                    latest: "latest";
+                    compatible: "compatible";
+                }>>;
+                peerDependencies: z.ZodOptional<z.ZodObject<{
+                    resolve: z.ZodDefault<z.ZodBoolean>;
+                    onMissing: z.ZodDefault<z.ZodEnum<{
+                        error: "error";
+                        warn: "warn";
+                        ignore: "ignore";
+                    }>>;
+                    onMismatch: z.ZodDefault<z.ZodEnum<{
+                        error: "error";
+                        warn: "warn";
+                        ignore: "ignore";
+                    }>>;
+                }, z.core.$strip>>;
+                optionalDependencies: z.ZodOptional<z.ZodObject<{
+                    load: z.ZodDefault<z.ZodBoolean>;
+                    onFailure: z.ZodDefault<z.ZodEnum<{
+                        warn: "warn";
+                        ignore: "ignore";
+                    }>>;
+                }, z.core.$strip>>;
+                conflictResolution: z.ZodDefault<z.ZodEnum<{
+                    latest: "latest";
+                    manual: "manual";
+                    fail: "fail";
+                    oldest: "oldest";
+                }>>;
+                circularDependencies: z.ZodDefault<z.ZodEnum<{
+                    error: "error";
+                    warn: "warn";
+                    allow: "allow";
+                }>>;
+            }, z.core.$strip>>;
+            hotReload: z.ZodOptional<z.ZodObject<{
+                enabled: z.ZodDefault<z.ZodBoolean>;
+                environment: z.ZodDefault<z.ZodEnum<{
+                    development: "development";
+                    production: "production";
+                    staging: "staging";
+                }>>;
+                strategy: z.ZodDefault<z.ZodEnum<{
+                    partial: "partial";
+                    full: "full";
+                    "state-preserve": "state-preserve";
+                }>>;
+                watchPatterns: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                ignorePatterns: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                debounceMs: z.ZodDefault<z.ZodNumber>;
+                preserveState: z.ZodDefault<z.ZodBoolean>;
+                stateSerialization: z.ZodOptional<z.ZodObject<{
+                    enabled: z.ZodDefault<z.ZodBoolean>;
+                    handler: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>>;
+                hooks: z.ZodOptional<z.ZodObject<{
+                    beforeReload: z.ZodOptional<z.ZodString>;
+                    afterReload: z.ZodOptional<z.ZodString>;
+                    onError: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>>;
+                productionSafety: z.ZodOptional<z.ZodObject<{
+                    healthValidation: z.ZodDefault<z.ZodBoolean>;
+                    rollbackOnFailure: z.ZodDefault<z.ZodBoolean>;
+                    healthTimeout: z.ZodDefault<z.ZodNumber>;
+                    drainConnections: z.ZodDefault<z.ZodBoolean>;
+                    drainTimeout: z.ZodDefault<z.ZodNumber>;
+                    maxConcurrentReloads: z.ZodDefault<z.ZodNumber>;
+                    minReloadInterval: z.ZodDefault<z.ZodNumber>;
+                }, z.core.$strip>>;
+            }, z.core.$strip>>;
+            caching: z.ZodOptional<z.ZodObject<{
+                enabled: z.ZodDefault<z.ZodBoolean>;
+                storage: z.ZodDefault<z.ZodEnum<{
+                    hybrid: "hybrid";
+                    indexeddb: "indexeddb";
+                    memory: "memory";
+                    disk: "disk";
+                }>>;
+                keyStrategy: z.ZodDefault<z.ZodEnum<{
+                    hash: "hash";
+                    timestamp: "timestamp";
+                    version: "version";
+                }>>;
+                ttl: z.ZodOptional<z.ZodNumber>;
+                maxSize: z.ZodOptional<z.ZodNumber>;
+                invalidateOn: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+                    error: "error";
+                    manual: "manual";
+                    "version-change": "version-change";
+                    "dependency-change": "dependency-change";
+                }>>>;
+                compression: z.ZodOptional<z.ZodObject<{
+                    enabled: z.ZodDefault<z.ZodBoolean>;
+                    algorithm: z.ZodDefault<z.ZodEnum<{
+                        gzip: "gzip";
+                        brotli: "brotli";
+                        deflate: "deflate";
+                    }>>;
+                }, z.core.$strip>>;
+            }, z.core.$strip>>;
+            sandboxing: z.ZodOptional<z.ZodObject<{
+                enabled: z.ZodDefault<z.ZodBoolean>;
+                scope: z.ZodDefault<z.ZodEnum<{
+                    "automation-only": "automation-only";
+                    "untrusted-only": "untrusted-only";
+                    "all-plugins": "all-plugins";
+                }>>;
+                isolationLevel: z.ZodDefault<z.ZodEnum<{
+                    none: "none";
+                    process: "process";
+                    vm: "vm";
+                    iframe: "iframe";
+                    "web-worker": "web-worker";
+                }>>;
+                allowedCapabilities: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                resourceQuotas: z.ZodOptional<z.ZodObject<{
+                    maxMemoryMB: z.ZodOptional<z.ZodNumber>;
+                    maxCpuTimeMs: z.ZodOptional<z.ZodNumber>;
+                    maxFileDescriptors: z.ZodOptional<z.ZodNumber>;
+                    maxNetworkKBps: z.ZodOptional<z.ZodNumber>;
+                }, z.core.$strip>>;
+                permissions: z.ZodOptional<z.ZodObject<{
+                    allowedAPIs: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                    allowedPaths: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                    allowedEndpoints: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                    allowedEnvVars: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                }, z.core.$strip>>;
+                ipc: z.ZodOptional<z.ZodObject<{
+                    enabled: z.ZodDefault<z.ZodBoolean>;
+                    transport: z.ZodDefault<z.ZodEnum<{
+                        memory: "memory";
+                        "message-port": "message-port";
+                        "unix-socket": "unix-socket";
+                        tcp: "tcp";
+                    }>>;
+                    maxMessageSize: z.ZodDefault<z.ZodNumber>;
+                    timeout: z.ZodDefault<z.ZodNumber>;
+                    allowedServices: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                }, z.core.$strip>>;
+            }, z.core.$strip>>;
+            monitoring: z.ZodOptional<z.ZodObject<{
+                enabled: z.ZodDefault<z.ZodBoolean>;
+                metrics: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+                    "load-time": "load-time";
+                    "init-time": "init-time";
+                    "memory-usage": "memory-usage";
+                    "cpu-usage": "cpu-usage";
+                    "api-calls": "api-calls";
+                    "error-rate": "error-rate";
+                    "cache-hit-rate": "cache-hit-rate";
+                }>>>;
+                samplingRate: z.ZodDefault<z.ZodNumber>;
+                reportingInterval: z.ZodDefault<z.ZodNumber>;
+                budgets: z.ZodOptional<z.ZodObject<{
+                    maxLoadTimeMs: z.ZodOptional<z.ZodNumber>;
+                    maxInitTimeMs: z.ZodOptional<z.ZodNumber>;
+                    maxMemoryMB: z.ZodOptional<z.ZodNumber>;
+                }, z.core.$strip>>;
+                onBudgetViolation: z.ZodDefault<z.ZodEnum<{
+                    error: "error";
+                    warn: "warn";
+                    ignore: "ignore";
+                }>>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+        engine: z.ZodOptional<z.ZodObject<{
+            objectstack: z.ZodString;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+    metadataSnapshot: z.ZodArray<z.ZodObject<{
+        type: z.ZodString;
+        name: z.ZodString;
+        metadata: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    }, z.core.$strip>>;
+    customizationSnapshot: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+    createdAt: z.ZodString;
+    expiresAt: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/**
+ * Upgrade Package Request
+ */
+declare const UpgradePackageRequestSchema: z.ZodObject<{
+    packageId: z.ZodString;
+    targetVersion: z.ZodOptional<z.ZodString>;
+    manifest: z.ZodOptional<z.ZodObject<{
+        id: z.ZodString;
+        namespace: z.ZodOptional<z.ZodString>;
+        version: z.ZodString;
+        type: z.ZodEnum<{
+            theme: "theme";
+            driver: "driver";
+            app: "app";
+            server: "server";
+            ui: "ui";
+            module: "module";
+            agent: "agent";
+            objectql: "objectql";
+            plugin: "plugin";
+            gateway: "gateway";
+            adapter: "adapter";
+        }>;
+        name: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        permissions: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        objects: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        datasources: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        dependencies: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        configuration: z.ZodOptional<z.ZodObject<{
+            title: z.ZodOptional<z.ZodString>;
+            properties: z.ZodRecord<z.ZodString, z.ZodObject<{
+                type: z.ZodEnum<{
+                    string: "string";
+                    number: "number";
+                    boolean: "boolean";
+                    object: "object";
+                    array: "array";
+                }>;
+                default: z.ZodOptional<z.ZodUnknown>;
+                description: z.ZodOptional<z.ZodString>;
+                required: z.ZodOptional<z.ZodBoolean>;
+                secret: z.ZodOptional<z.ZodBoolean>;
+                enum: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+        contributes: z.ZodOptional<z.ZodObject<{
+            kinds: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                globs: z.ZodArray<z.ZodString>;
+                description: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>>;
+            events: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            menus: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                label: z.ZodString;
+                command: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>>>;
+            themes: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                label: z.ZodString;
+                path: z.ZodString;
+            }, z.core.$strip>>>;
+            translations: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                locale: z.ZodString;
+                path: z.ZodString;
+            }, z.core.$strip>>>;
+            actions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                label: z.ZodOptional<z.ZodString>;
+                description: z.ZodOptional<z.ZodString>;
+                input: z.ZodOptional<z.ZodUnknown>;
+                output: z.ZodOptional<z.ZodUnknown>;
+            }, z.core.$strip>>>;
+            drivers: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                label: z.ZodString;
+                description: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>>;
+            fieldTypes: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                label: z.ZodString;
+                description: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>>;
+            functions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                description: z.ZodOptional<z.ZodString>;
+                args: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                returnType: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>>;
+            routes: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                prefix: z.ZodString;
+                service: z.ZodString;
+                methods: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            }, z.core.$strip>>>;
+            commands: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                description: z.ZodOptional<z.ZodString>;
+                module: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>>;
+        data: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            object: z.ZodString;
+            externalId: z.ZodDefault<z.ZodString>;
+            mode: z.ZodDefault<z.ZodEnum<{
+                insert: "insert";
+                update: "update";
+                upsert: "upsert";
+                replace: "replace";
+                ignore: "ignore";
+            }>>;
+            env: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+                prod: "prod";
+                dev: "dev";
+                test: "test";
+            }>>>;
+            records: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, z.core.$strip>>>;
+        capabilities: z.ZodOptional<z.ZodObject<{
+            implements: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                protocol: z.ZodObject<{
+                    id: z.ZodString;
+                    label: z.ZodString;
+                    version: z.ZodObject<{
+                        major: z.ZodNumber;
+                        minor: z.ZodNumber;
+                        patch: z.ZodNumber;
+                    }, z.core.$strip>;
+                    specification: z.ZodOptional<z.ZodString>;
+                    description: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>;
+                conformance: z.ZodDefault<z.ZodEnum<{
+                    partial: "partial";
+                    deprecated: "deprecated";
+                    full: "full";
+                    experimental: "experimental";
+                }>>;
+                implementedFeatures: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                features: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    name: z.ZodString;
+                    enabled: z.ZodDefault<z.ZodBoolean>;
+                    description: z.ZodOptional<z.ZodString>;
+                    sinceVersion: z.ZodOptional<z.ZodString>;
+                    deprecatedSince: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>>>;
+                metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                certified: z.ZodDefault<z.ZodBoolean>;
+                certificationDate: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>>;
+            provides: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                name: z.ZodString;
+                description: z.ZodOptional<z.ZodString>;
+                version: z.ZodObject<{
+                    major: z.ZodNumber;
+                    minor: z.ZodNumber;
+                    patch: z.ZodNumber;
+                }, z.core.$strip>;
+                methods: z.ZodArray<z.ZodObject<{
+                    name: z.ZodString;
+                    description: z.ZodOptional<z.ZodString>;
+                    parameters: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                        name: z.ZodString;
+                        type: z.ZodString;
+                        required: z.ZodDefault<z.ZodBoolean>;
+                        description: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strip>>>;
+                    returnType: z.ZodOptional<z.ZodString>;
+                    async: z.ZodDefault<z.ZodBoolean>;
+                }, z.core.$strip>>;
+                events: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    name: z.ZodString;
+                    description: z.ZodOptional<z.ZodString>;
+                    payload: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>>>;
+                stability: z.ZodDefault<z.ZodEnum<{
+                    alpha: "alpha";
+                    experimental: "experimental";
+                    stable: "stable";
+                    beta: "beta";
+                }>>;
+            }, z.core.$strip>>>;
+            requires: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                pluginId: z.ZodString;
+                version: z.ZodString;
+                optional: z.ZodDefault<z.ZodBoolean>;
+                reason: z.ZodOptional<z.ZodString>;
+                requiredCapabilities: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            }, z.core.$strip>>>;
+            extensionPoints: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                name: z.ZodString;
+                description: z.ZodOptional<z.ZodString>;
+                type: z.ZodEnum<{
+                    provider: "provider";
+                    action: "action";
+                    widget: "widget";
+                    hook: "hook";
+                    transformer: "transformer";
+                    validator: "validator";
+                    decorator: "decorator";
+                }>;
+                contract: z.ZodOptional<z.ZodObject<{
+                    input: z.ZodOptional<z.ZodString>;
+                    output: z.ZodOptional<z.ZodString>;
+                    signature: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>>;
+                cardinality: z.ZodDefault<z.ZodEnum<{
+                    multiple: "multiple";
+                    single: "single";
+                }>>;
+            }, z.core.$strip>>>;
+            extensions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                targetPluginId: z.ZodString;
+                extensionPointId: z.ZodString;
+                implementation: z.ZodString;
+                priority: z.ZodDefault<z.ZodNumber>;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>>;
+        extensions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        loading: z.ZodOptional<z.ZodObject<{
+            strategy: z.ZodDefault<z.ZodEnum<{
+                lazy: "lazy";
+                parallel: "parallel";
+                eager: "eager";
+                deferred: "deferred";
+                "on-demand": "on-demand";
+            }>>;
+            preload: z.ZodOptional<z.ZodObject<{
+                enabled: z.ZodDefault<z.ZodBoolean>;
+                priority: z.ZodDefault<z.ZodNumber>;
+                resources: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+                    code: "code";
+                    dependencies: "dependencies";
+                    metadata: "metadata";
+                    assets: "assets";
+                    services: "services";
+                }>>>;
+                conditions: z.ZodOptional<z.ZodObject<{
+                    routes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                    roles: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                    deviceType: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+                        desktop: "desktop";
+                        mobile: "mobile";
+                        tablet: "tablet";
+                    }>>>;
+                    minNetworkSpeed: z.ZodOptional<z.ZodEnum<{
+                        "slow-2g": "slow-2g";
+                        "2g": "2g";
+                        "3g": "3g";
+                        "4g": "4g";
+                    }>>;
+                }, z.core.$strip>>;
+            }, z.core.$strip>>;
+            codeSplitting: z.ZodOptional<z.ZodObject<{
+                enabled: z.ZodDefault<z.ZodBoolean>;
+                strategy: z.ZodDefault<z.ZodEnum<{
+                    custom: "custom";
+                    size: "size";
+                    route: "route";
+                    feature: "feature";
+                }>>;
+                chunkNaming: z.ZodDefault<z.ZodEnum<{
+                    hashed: "hashed";
+                    sequential: "sequential";
+                    named: "named";
+                }>>;
+                maxChunkSize: z.ZodOptional<z.ZodNumber>;
+                sharedDependencies: z.ZodOptional<z.ZodObject<{
+                    enabled: z.ZodDefault<z.ZodBoolean>;
+                    minChunks: z.ZodDefault<z.ZodNumber>;
+                }, z.core.$strip>>;
+            }, z.core.$strip>>;
+            dynamicImport: z.ZodOptional<z.ZodObject<{
+                enabled: z.ZodDefault<z.ZodBoolean>;
+                mode: z.ZodDefault<z.ZodEnum<{
+                    lazy: "lazy";
+                    async: "async";
+                    sync: "sync";
+                    eager: "eager";
+                }>>;
+                prefetch: z.ZodDefault<z.ZodBoolean>;
+                preload: z.ZodDefault<z.ZodBoolean>;
+                webpackChunkName: z.ZodOptional<z.ZodString>;
+                timeout: z.ZodDefault<z.ZodNumber>;
+                retry: z.ZodOptional<z.ZodObject<{
+                    enabled: z.ZodDefault<z.ZodBoolean>;
+                    maxAttempts: z.ZodDefault<z.ZodNumber>;
+                    backoffMs: z.ZodDefault<z.ZodNumber>;
+                }, z.core.$strip>>;
+            }, z.core.$strip>>;
+            initialization: z.ZodOptional<z.ZodObject<{
+                mode: z.ZodDefault<z.ZodEnum<{
+                    async: "async";
+                    parallel: "parallel";
+                    sequential: "sequential";
+                    sync: "sync";
+                }>>;
+                timeout: z.ZodDefault<z.ZodNumber>;
+                priority: z.ZodDefault<z.ZodNumber>;
+                critical: z.ZodDefault<z.ZodBoolean>;
+                retry: z.ZodOptional<z.ZodObject<{
+                    enabled: z.ZodDefault<z.ZodBoolean>;
+                    maxAttempts: z.ZodDefault<z.ZodNumber>;
+                    backoffMs: z.ZodDefault<z.ZodNumber>;
+                }, z.core.$strip>>;
+                healthCheckInterval: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>>;
+            dependencyResolution: z.ZodOptional<z.ZodObject<{
+                strategy: z.ZodDefault<z.ZodEnum<{
+                    strict: "strict";
+                    pinned: "pinned";
+                    latest: "latest";
+                    compatible: "compatible";
+                }>>;
+                peerDependencies: z.ZodOptional<z.ZodObject<{
+                    resolve: z.ZodDefault<z.ZodBoolean>;
+                    onMissing: z.ZodDefault<z.ZodEnum<{
+                        error: "error";
+                        warn: "warn";
+                        ignore: "ignore";
+                    }>>;
+                    onMismatch: z.ZodDefault<z.ZodEnum<{
+                        error: "error";
+                        warn: "warn";
+                        ignore: "ignore";
+                    }>>;
+                }, z.core.$strip>>;
+                optionalDependencies: z.ZodOptional<z.ZodObject<{
+                    load: z.ZodDefault<z.ZodBoolean>;
+                    onFailure: z.ZodDefault<z.ZodEnum<{
+                        warn: "warn";
+                        ignore: "ignore";
+                    }>>;
+                }, z.core.$strip>>;
+                conflictResolution: z.ZodDefault<z.ZodEnum<{
+                    latest: "latest";
+                    manual: "manual";
+                    fail: "fail";
+                    oldest: "oldest";
+                }>>;
+                circularDependencies: z.ZodDefault<z.ZodEnum<{
+                    error: "error";
+                    warn: "warn";
+                    allow: "allow";
+                }>>;
+            }, z.core.$strip>>;
+            hotReload: z.ZodOptional<z.ZodObject<{
+                enabled: z.ZodDefault<z.ZodBoolean>;
+                environment: z.ZodDefault<z.ZodEnum<{
+                    development: "development";
+                    production: "production";
+                    staging: "staging";
+                }>>;
+                strategy: z.ZodDefault<z.ZodEnum<{
+                    partial: "partial";
+                    full: "full";
+                    "state-preserve": "state-preserve";
+                }>>;
+                watchPatterns: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                ignorePatterns: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                debounceMs: z.ZodDefault<z.ZodNumber>;
+                preserveState: z.ZodDefault<z.ZodBoolean>;
+                stateSerialization: z.ZodOptional<z.ZodObject<{
+                    enabled: z.ZodDefault<z.ZodBoolean>;
+                    handler: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>>;
+                hooks: z.ZodOptional<z.ZodObject<{
+                    beforeReload: z.ZodOptional<z.ZodString>;
+                    afterReload: z.ZodOptional<z.ZodString>;
+                    onError: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>>;
+                productionSafety: z.ZodOptional<z.ZodObject<{
+                    healthValidation: z.ZodDefault<z.ZodBoolean>;
+                    rollbackOnFailure: z.ZodDefault<z.ZodBoolean>;
+                    healthTimeout: z.ZodDefault<z.ZodNumber>;
+                    drainConnections: z.ZodDefault<z.ZodBoolean>;
+                    drainTimeout: z.ZodDefault<z.ZodNumber>;
+                    maxConcurrentReloads: z.ZodDefault<z.ZodNumber>;
+                    minReloadInterval: z.ZodDefault<z.ZodNumber>;
+                }, z.core.$strip>>;
+            }, z.core.$strip>>;
+            caching: z.ZodOptional<z.ZodObject<{
+                enabled: z.ZodDefault<z.ZodBoolean>;
+                storage: z.ZodDefault<z.ZodEnum<{
+                    hybrid: "hybrid";
+                    indexeddb: "indexeddb";
+                    memory: "memory";
+                    disk: "disk";
+                }>>;
+                keyStrategy: z.ZodDefault<z.ZodEnum<{
+                    hash: "hash";
+                    timestamp: "timestamp";
+                    version: "version";
+                }>>;
+                ttl: z.ZodOptional<z.ZodNumber>;
+                maxSize: z.ZodOptional<z.ZodNumber>;
+                invalidateOn: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+                    error: "error";
+                    manual: "manual";
+                    "version-change": "version-change";
+                    "dependency-change": "dependency-change";
+                }>>>;
+                compression: z.ZodOptional<z.ZodObject<{
+                    enabled: z.ZodDefault<z.ZodBoolean>;
+                    algorithm: z.ZodDefault<z.ZodEnum<{
+                        gzip: "gzip";
+                        brotli: "brotli";
+                        deflate: "deflate";
+                    }>>;
+                }, z.core.$strip>>;
+            }, z.core.$strip>>;
+            sandboxing: z.ZodOptional<z.ZodObject<{
+                enabled: z.ZodDefault<z.ZodBoolean>;
+                scope: z.ZodDefault<z.ZodEnum<{
+                    "automation-only": "automation-only";
+                    "untrusted-only": "untrusted-only";
+                    "all-plugins": "all-plugins";
+                }>>;
+                isolationLevel: z.ZodDefault<z.ZodEnum<{
+                    none: "none";
+                    process: "process";
+                    vm: "vm";
+                    iframe: "iframe";
+                    "web-worker": "web-worker";
+                }>>;
+                allowedCapabilities: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                resourceQuotas: z.ZodOptional<z.ZodObject<{
+                    maxMemoryMB: z.ZodOptional<z.ZodNumber>;
+                    maxCpuTimeMs: z.ZodOptional<z.ZodNumber>;
+                    maxFileDescriptors: z.ZodOptional<z.ZodNumber>;
+                    maxNetworkKBps: z.ZodOptional<z.ZodNumber>;
+                }, z.core.$strip>>;
+                permissions: z.ZodOptional<z.ZodObject<{
+                    allowedAPIs: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                    allowedPaths: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                    allowedEndpoints: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                    allowedEnvVars: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                }, z.core.$strip>>;
+                ipc: z.ZodOptional<z.ZodObject<{
+                    enabled: z.ZodDefault<z.ZodBoolean>;
+                    transport: z.ZodDefault<z.ZodEnum<{
+                        memory: "memory";
+                        "message-port": "message-port";
+                        "unix-socket": "unix-socket";
+                        tcp: "tcp";
+                    }>>;
+                    maxMessageSize: z.ZodDefault<z.ZodNumber>;
+                    timeout: z.ZodDefault<z.ZodNumber>;
+                    allowedServices: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                }, z.core.$strip>>;
+            }, z.core.$strip>>;
+            monitoring: z.ZodOptional<z.ZodObject<{
+                enabled: z.ZodDefault<z.ZodBoolean>;
+                metrics: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+                    "load-time": "load-time";
+                    "init-time": "init-time";
+                    "memory-usage": "memory-usage";
+                    "cpu-usage": "cpu-usage";
+                    "api-calls": "api-calls";
+                    "error-rate": "error-rate";
+                    "cache-hit-rate": "cache-hit-rate";
+                }>>>;
+                samplingRate: z.ZodDefault<z.ZodNumber>;
+                reportingInterval: z.ZodDefault<z.ZodNumber>;
+                budgets: z.ZodOptional<z.ZodObject<{
+                    maxLoadTimeMs: z.ZodOptional<z.ZodNumber>;
+                    maxInitTimeMs: z.ZodOptional<z.ZodNumber>;
+                    maxMemoryMB: z.ZodOptional<z.ZodNumber>;
+                }, z.core.$strip>>;
+                onBudgetViolation: z.ZodDefault<z.ZodEnum<{
+                    error: "error";
+                    warn: "warn";
+                    ignore: "ignore";
+                }>>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+        engine: z.ZodOptional<z.ZodObject<{
+            objectstack: z.ZodString;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    createSnapshot: z.ZodDefault<z.ZodBoolean>;
+    mergeStrategy: z.ZodDefault<z.ZodEnum<{
+        "keep-custom": "keep-custom";
+        "accept-incoming": "accept-incoming";
+        "three-way-merge": "three-way-merge";
+    }>>;
+    dryRun: z.ZodDefault<z.ZodBoolean>;
+    skipValidation: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>;
+/**
+ * Upgrade Phase
+ * Current phase of the upgrade process.
+ */
+declare const UpgradePhaseSchema: z.ZodEnum<{
+    snapshot: "snapshot";
+    completed: "completed";
+    failed: "failed";
+    "rolled-back": "rolled-back";
+    pending: "pending";
+    analyzing: "analyzing";
+    executing: "executing";
+    migrating: "migrating";
+    validating: "validating";
+    "rolling-back": "rolling-back";
+}>;
+/**
+ * Upgrade Package Response
+ */
+declare const UpgradePackageResponseSchema: z.ZodObject<{
+    success: z.ZodBoolean;
+    phase: z.ZodEnum<{
+        snapshot: "snapshot";
+        completed: "completed";
+        failed: "failed";
+        "rolled-back": "rolled-back";
+        pending: "pending";
+        analyzing: "analyzing";
+        executing: "executing";
+        migrating: "migrating";
+        validating: "validating";
+        "rolling-back": "rolling-back";
+    }>;
+    plan: z.ZodOptional<z.ZodObject<{
+        packageId: z.ZodString;
+        fromVersion: z.ZodString;
+        toVersion: z.ZodString;
+        impactLevel: z.ZodEnum<{
+            none: "none";
+            medium: "medium";
+            critical: "critical";
+            high: "high";
+            low: "low";
+        }>;
+        changes: z.ZodArray<z.ZodObject<{
+            type: z.ZodString;
+            name: z.ZodString;
+            changeType: z.ZodEnum<{
+                removed: "removed";
+                added: "added";
+                modified: "modified";
+                renamed: "renamed";
+            }>;
+            hasConflict: z.ZodDefault<z.ZodBoolean>;
+            summary: z.ZodOptional<z.ZodString>;
+            previousName: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        affectedCustomizations: z.ZodDefault<z.ZodNumber>;
+        requiresMigration: z.ZodDefault<z.ZodBoolean>;
+        migrationScripts: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        dependencyUpgrades: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            packageId: z.ZodString;
+            fromVersion: z.ZodString;
+            toVersion: z.ZodString;
+        }, z.core.$strip>>>;
+        estimatedDuration: z.ZodOptional<z.ZodNumber>;
+        summary: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    snapshotId: z.ZodOptional<z.ZodString>;
+    conflicts: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        baseValue: z.ZodUnknown;
+        incomingValue: z.ZodUnknown;
+        customValue: z.ZodUnknown;
+    }, z.core.$strip>>>;
+    errorMessage: z.ZodOptional<z.ZodString>;
+    message: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/**
+ * Rollback Package Request
+ */
+declare const RollbackPackageRequestSchema: z.ZodObject<{
+    packageId: z.ZodString;
+    snapshotId: z.ZodString;
+    rollbackCustomizations: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>;
+/**
+ * Rollback Package Response
+ */
+declare const RollbackPackageResponseSchema: z.ZodObject<{
+    success: z.ZodBoolean;
+    restoredVersion: z.ZodOptional<z.ZodString>;
+    message: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type MetadataChangeType = z.infer<typeof MetadataChangeTypeSchema>;
+type MetadataDiffItem = z.infer<typeof MetadataDiffItemSchema>;
+type UpgradeImpactLevel = z.infer<typeof UpgradeImpactLevelSchema>;
+type UpgradePlan = z.infer<typeof UpgradePlanSchema>;
+type UpgradeSnapshot = z.infer<typeof UpgradeSnapshotSchema>;
+type UpgradePackageRequest = z.infer<typeof UpgradePackageRequestSchema>;
+type UpgradePhase = z.infer<typeof UpgradePhaseSchema>;
+type UpgradePackageResponse = z.infer<typeof UpgradePackageResponseSchema>;
+type RollbackPackageRequest = z.infer<typeof RollbackPackageRequestSchema>;
+type RollbackPackageResponse = z.infer<typeof RollbackPackageResponseSchema>;
+
+export { MetadataQueryResultSchema as $, type ArtifactChecksum as A, MergeStrategyConfigSchema as B, type CustomizationOrigin as C, type DependencyResolutionResult as D, type MetadataBulkRegisterRequest as E, type FieldChange as F, MetadataBulkRegisterRequestSchema as G, MetadataBulkResultSchema as H, type MetadataCategory as I, MetadataCategoryEnum as J, type MetadataChangeType as K, MetadataChangeTypeSchema as L, type MetadataQuery as M, MetadataDependencySchema as N, type ObjectStackManifest as O, type PackageArtifact as P, type MetadataDiffItem as Q, type RollbackPackageResponse as R, MetadataDiffItemSchema as S, type MetadataEvent as T, type UpgradePlan as U, MetadataEventSchema as V, MetadataOverlaySchema as W, type MetadataPluginConfig as X, MetadataPluginConfigSchema as Y, type MetadataPluginManifest as Z, MetadataPluginManifestSchema as _, type MetadataQueryResult as a, MetadataQuerySchema as a0, type MetadataType as a1, type MetadataTypeRegistryEntry as a2, MetadataTypeRegistryEntrySchema as a3, MetadataTypeSchema as a4, MetadataValidationResultSchema as a5, type ObjectStackManifestInput as a6, type PackageArtifactInput as a7, PackageArtifactSchema as a8, type RequiredAction as a9, RequiredActionSchema as aa, type ResolvedDependency as ab, ResolvedDependencySchema as ac, type RollbackPackageRequest as ad, RollbackPackageRequestSchema as ae, RollbackPackageResponseSchema as af, type UpgradeImpactLevel as ag, UpgradeImpactLevelSchema as ah, type UpgradePackageRequest as ai, UpgradePackageRequestSchema as aj, UpgradePackageResponseSchema as ak, type UpgradePhase as al, UpgradePhaseSchema as am, UpgradePlanSchema as an, UpgradeSnapshotSchema as ao, type MetadataBulkResult as b, type MetadataOverlay as c, type MetadataValidationResult as d, type MetadataDependency as e, type UpgradePackageResponse as f, type UpgradeSnapshot as g, ArtifactChecksumSchema as h, type ArtifactFileEntry as i, ArtifactFileEntrySchema as j, type ArtifactSignature as k, ArtifactSignatureSchema as l, CustomizationOriginSchema as m, type CustomizationPolicy as n, CustomizationPolicySchema as o, DEFAULT_METADATA_TYPE_REGISTRY as p, DependencyResolutionResultSchema as q, type DependencyStatus as r, DependencyStatusEnum as s, FieldChangeSchema as t, ManifestSchema as u, type MergeConflict as v, MergeConflictSchema as w, type MergeResult as x, MergeResultSchema as y, type MergeStrategyConfig as z };