@objectstack/spec 0.9.2 → 1.0.0

package/dist/hub/plugin-security.zod.d.ts

@@ -16,103 +16,294 @@ import { z } from 'zod';
 /**
  * Vulnerability Severity
  */
-export declare const VulnerabilitySeverity: z.ZodEnum<{
-    info: "info";
-    medium: "medium";
-    critical: "critical";
-    high: "high";
-    low: "low";
-}>;
+export declare const VulnerabilitySeverity: z.ZodEnum<["critical", "high", "medium", "low", "info"]>;
 export type VulnerabilitySeverity = z.infer<typeof VulnerabilitySeverity>;
 /**
  * Security Vulnerability
  */
 export declare const SecurityVulnerabilitySchema: z.ZodObject<{
+    /**
+     * CVE identifier (if applicable)
+     */
     cve: z.ZodOptional<z.ZodString>;
+    /**
+     * Vulnerability identifier (GHSA, SNYK, etc.)
+     */
     id: z.ZodString;
+    /**
+     * Title
+     */
     title: z.ZodString;
+    /**
+     * Description
+     */
     description: z.ZodString;
-    severity: z.ZodEnum<{
-        info: "info";
-        medium: "medium";
-        critical: "critical";
-        high: "high";
-        low: "low";
-    }>;
+    /**
+     * Severity
+     */
+    severity: z.ZodEnum<["critical", "high", "medium", "low", "info"]>;
+    /**
+     * CVSS score (0-10)
+     */
     cvss: z.ZodOptional<z.ZodNumber>;
+    /**
+     * Affected package
+     */
     package: z.ZodObject<{
         name: z.ZodString;
         version: z.ZodString;
         ecosystem: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        version: string;
+        ecosystem?: string | undefined;
+    }, {
+        name: string;
+        version: string;
+        ecosystem?: string | undefined;
+    }>;
+    /**
+     * Vulnerable version range
+     */
     vulnerableVersions: z.ZodString;
+    /**
+     * Patched versions
+     */
     patchedVersions: z.ZodOptional<z.ZodString>;
+    /**
+     * References
+     */
     references: z.ZodDefault<z.ZodArray<z.ZodObject<{
-        type: z.ZodEnum<{
-            advisory: "advisory";
-            article: "article";
-            report: "report";
-            web: "web";
-        }>;
+        type: z.ZodEnum<["advisory", "article", "report", "web"]>;
         url: z.ZodString;
-    }, z.core.$strip>>>;
-    cwe: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    }, "strip", z.ZodTypeAny, {
+        type: "advisory" | "article" | "report" | "web";
+        url: string;
+    }, {
+        type: "advisory" | "article" | "report" | "web";
+        url: string;
+    }>, "many">>;
+    /**
+     * CWE (Common Weakness Enumeration)
+     */
+    cwe: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    /**
+     * Published date
+     */
     publishedAt: z.ZodOptional<z.ZodString>;
+    /**
+     * Mitigation advice
+     */
     mitigation: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
+}, "strip", z.ZodTypeAny, {
+    description: string;
+    severity: "info" | "medium" | "critical" | "high" | "low";
+    id: string;
+    title: string;
+    package: {
+        name: string;
+        version: string;
+        ecosystem?: string | undefined;
+    };
+    references: {
+        type: "advisory" | "article" | "report" | "web";
+        url: string;
+    }[];
+    vulnerableVersions: string;
+    cwe: string[];
+    cve?: string | undefined;
+    publishedAt?: string | undefined;
+    cvss?: number | undefined;
+    patchedVersions?: string | undefined;
+    mitigation?: string | undefined;
+}, {
+    description: string;
+    severity: "info" | "medium" | "critical" | "high" | "low";
+    id: string;
+    title: string;
+    package: {
+        name: string;
+        version: string;
+        ecosystem?: string | undefined;
+    };
+    vulnerableVersions: string;
+    cve?: string | undefined;
+    references?: {
+        type: "advisory" | "article" | "report" | "web";
+        url: string;
+    }[] | undefined;
+    publishedAt?: string | undefined;
+    cvss?: number | undefined;
+    patchedVersions?: string | undefined;
+    cwe?: string[] | undefined;
+    mitigation?: string | undefined;
+}>;
 export type SecurityVulnerability = z.infer<typeof SecurityVulnerabilitySchema>;
 /**
  * Security Scan Result
  */
 export declare const SecurityScanResultSchema: z.ZodObject<{
+    /**
+     * Scan identifier
+     */
     scanId: z.ZodString;
+    /**
+     * Plugin being scanned
+     */
     plugin: z.ZodObject<{
         id: z.ZodString;
         version: z.ZodString;
-    }, z.core.$strip>;
+    }, "strip", z.ZodTypeAny, {
+        version: string;
+        id: string;
+    }, {
+        version: string;
+        id: string;
+    }>;
+    /**
+     * Scan timestamp
+     */
     scannedAt: z.ZodString;
+    /**
+     * Scanner information
+     */
     scanner: z.ZodObject<{
         name: z.ZodString;
         version: z.ZodString;
-    }, z.core.$strip>;
-    status: z.ZodEnum<{
-        warning: "warning";
-        failed: "failed";
-        passed: "passed";
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        version: string;
+    }, {
+        name: string;
+        version: string;
     }>;
+    /**
+     * Scan status
+     */
+    status: z.ZodEnum<["passed", "failed", "warning"]>;
+    /**
+     * Vulnerabilities found
+     */
     vulnerabilities: z.ZodArray<z.ZodObject<{
+        /**
+         * CVE identifier (if applicable)
+         */
         cve: z.ZodOptional<z.ZodString>;
+        /**
+         * Vulnerability identifier (GHSA, SNYK, etc.)
+         */
         id: z.ZodString;
+        /**
+         * Title
+         */
         title: z.ZodString;
+        /**
+         * Description
+         */
         description: z.ZodString;
-        severity: z.ZodEnum<{
-            info: "info";
-            medium: "medium";
-            critical: "critical";
-            high: "high";
-            low: "low";
-        }>;
+        /**
+         * Severity
+         */
+        severity: z.ZodEnum<["critical", "high", "medium", "low", "info"]>;
+        /**
+         * CVSS score (0-10)
+         */
         cvss: z.ZodOptional<z.ZodNumber>;
+        /**
+         * Affected package
+         */
         package: z.ZodObject<{
             name: z.ZodString;
             version: z.ZodString;
             ecosystem: z.ZodOptional<z.ZodString>;
-        }, z.core.$strip>;
+        }, "strip", z.ZodTypeAny, {
+            name: string;
+            version: string;
+            ecosystem?: string | undefined;
+        }, {
+            name: string;
+            version: string;
+            ecosystem?: string | undefined;
+        }>;
+        /**
+         * Vulnerable version range
+         */
         vulnerableVersions: z.ZodString;
+        /**
+         * Patched versions
+         */
         patchedVersions: z.ZodOptional<z.ZodString>;
+        /**
+         * References
+         */
         references: z.ZodDefault<z.ZodArray<z.ZodObject<{
-            type: z.ZodEnum<{
-                advisory: "advisory";
-                article: "article";
-                report: "report";
-                web: "web";
-            }>;
+            type: z.ZodEnum<["advisory", "article", "report", "web"]>;
             url: z.ZodString;
-        }, z.core.$strip>>>;
-        cwe: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        }, "strip", z.ZodTypeAny, {
+            type: "advisory" | "article" | "report" | "web";
+            url: string;
+        }, {
+            type: "advisory" | "article" | "report" | "web";
+            url: string;
+        }>, "many">>;
+        /**
+         * CWE (Common Weakness Enumeration)
+         */
+        cwe: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        /**
+         * Published date
+         */
         publishedAt: z.ZodOptional<z.ZodString>;
+        /**
+         * Mitigation advice
+         */
         mitigation: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>>;
+    }, "strip", z.ZodTypeAny, {
+        description: string;
+        severity: "info" | "medium" | "critical" | "high" | "low";
+        id: string;
+        title: string;
+        package: {
+            name: string;
+            version: string;
+            ecosystem?: string | undefined;
+        };
+        references: {
+            type: "advisory" | "article" | "report" | "web";
+            url: string;
+        }[];
+        vulnerableVersions: string;
+        cwe: string[];
+        cve?: string | undefined;
+        publishedAt?: string | undefined;
+        cvss?: number | undefined;
+        patchedVersions?: string | undefined;
+        mitigation?: string | undefined;
+    }, {
+        description: string;
+        severity: "info" | "medium" | "critical" | "high" | "low";
+        id: string;
+        title: string;
+        package: {
+            name: string;
+            version: string;
+            ecosystem?: string | undefined;
+        };
+        vulnerableVersions: string;
+        cve?: string | undefined;
+        references?: {
+            type: "advisory" | "article" | "report" | "web";
+            url: string;
+        }[] | undefined;
+        publishedAt?: string | undefined;
+        cvss?: number | undefined;
+        patchedVersions?: string | undefined;
+        cwe?: string[] | undefined;
+        mitigation?: string | undefined;
+    }>, "many">;
+    /**
+     * Vulnerability summary
+     */
     summary: z.ZodObject<{
         critical: z.ZodDefault<z.ZodNumber>;
         high: z.ZodDefault<z.ZodNumber>;
@@ -120,521 +311,2143 @@ export declare const SecurityScanResultSchema: z.ZodObject<{
         low: z.ZodDefault<z.ZodNumber>;
         info: z.ZodDefault<z.ZodNumber>;
         total: z.ZodDefault<z.ZodNumber>;
-    }, z.core.$strip>;
+    }, "strip", z.ZodTypeAny, {
+        info: number;
+        total: number;
+        medium: number;
+        critical: number;
+        high: number;
+        low: number;
+    }, {
+        info?: number | undefined;
+        total?: number | undefined;
+        medium?: number | undefined;
+        critical?: number | undefined;
+        high?: number | undefined;
+        low?: number | undefined;
+    }>;
+    /**
+     * License compliance issues
+     */
     licenseIssues: z.ZodDefault<z.ZodArray<z.ZodObject<{
         package: z.ZodString;
         license: z.ZodString;
         reason: z.ZodString;
-        severity: z.ZodEnum<{
-            error: "error";
-            warning: "warning";
-            info: "info";
-        }>;
-    }, z.core.$strip>>>;
+        severity: z.ZodEnum<["error", "warning", "info"]>;
+    }, "strip", z.ZodTypeAny, {
+        severity: "error" | "warning" | "info";
+        license: string;
+        package: string;
+        reason: string;
+    }, {
+        severity: "error" | "warning" | "info";
+        license: string;
+        package: string;
+        reason: string;
+    }>, "many">>;
+    /**
+     * Code quality issues
+     */
     codeQuality: z.ZodOptional<z.ZodObject<{
         score: z.ZodOptional<z.ZodNumber>;
         issues: z.ZodDefault<z.ZodArray<z.ZodObject<{
-            type: z.ZodEnum<{
-                style: "style";
-                security: "security";
-                quality: "quality";
-            }>;
-            severity: z.ZodEnum<{
-                error: "error";
-                warning: "warning";
-                info: "info";
-            }>;
+            type: z.ZodEnum<["security", "quality", "style"]>;
+            severity: z.ZodEnum<["error", "warning", "info"]>;
             message: z.ZodString;
             file: z.ZodOptional<z.ZodString>;
             line: z.ZodOptional<z.ZodNumber>;
-        }, z.core.$strip>>>;
-    }, z.core.$strip>>;
+        }, "strip", z.ZodTypeAny, {
+            message: string;
+            type: "style" | "security" | "quality";
+            severity: "error" | "warning" | "info";
+            file?: string | undefined;
+            line?: number | undefined;
+        }, {
+            message: string;
+            type: "style" | "security" | "quality";
+            severity: "error" | "warning" | "info";
+            file?: string | undefined;
+            line?: number | undefined;
+        }>, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        issues: {
+            message: string;
+            type: "style" | "security" | "quality";
+            severity: "error" | "warning" | "info";
+            file?: string | undefined;
+            line?: number | undefined;
+        }[];
+        score?: number | undefined;
+    }, {
+        issues?: {
+            message: string;
+            type: "style" | "security" | "quality";
+            severity: "error" | "warning" | "info";
+            file?: string | undefined;
+            line?: number | undefined;
+        }[] | undefined;
+        score?: number | undefined;
+    }>>;
+    /**
+     * Next scan scheduled
+     */
     nextScanAt: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
+}, "strip", z.ZodTypeAny, {
+    status: "warning" | "failed" | "passed";
+    summary: {
+        info: number;
+        total: number;
+        medium: number;
+        critical: number;
+        high: number;
+        low: number;
+    };
+    plugin: {
+        version: string;
+        id: string;
+    };
+    scanner: {
+        name: string;
+        version: string;
+    };
+    vulnerabilities: {
+        description: string;
+        severity: "info" | "medium" | "critical" | "high" | "low";
+        id: string;
+        title: string;
+        package: {
+            name: string;
+            version: string;
+            ecosystem?: string | undefined;
+        };
+        references: {
+            type: "advisory" | "article" | "report" | "web";
+            url: string;
+        }[];
+        vulnerableVersions: string;
+        cwe: string[];
+        cve?: string | undefined;
+        publishedAt?: string | undefined;
+        cvss?: number | undefined;
+        patchedVersions?: string | undefined;
+        mitigation?: string | undefined;
+    }[];
+    scanId: string;
+    scannedAt: string;
+    licenseIssues: {
+        severity: "error" | "warning" | "info";
+        license: string;
+        package: string;
+        reason: string;
+    }[];
+    codeQuality?: {
+        issues: {
+            message: string;
+            type: "style" | "security" | "quality";
+            severity: "error" | "warning" | "info";
+            file?: string | undefined;
+            line?: number | undefined;
+        }[];
+        score?: number | undefined;
+    } | undefined;
+    nextScanAt?: string | undefined;
+}, {
+    status: "warning" | "failed" | "passed";
+    summary: {
+        info?: number | undefined;
+        total?: number | undefined;
+        medium?: number | undefined;
+        critical?: number | undefined;
+        high?: number | undefined;
+        low?: number | undefined;
+    };
+    plugin: {
+        version: string;
+        id: string;
+    };
+    scanner: {
+        name: string;
+        version: string;
+    };
+    vulnerabilities: {
+        description: string;
+        severity: "info" | "medium" | "critical" | "high" | "low";
+        id: string;
+        title: string;
+        package: {
+            name: string;
+            version: string;
+            ecosystem?: string | undefined;
+        };
+        vulnerableVersions: string;
+        cve?: string | undefined;
+        references?: {
+            type: "advisory" | "article" | "report" | "web";
+            url: string;
+        }[] | undefined;
+        publishedAt?: string | undefined;
+        cvss?: number | undefined;
+        patchedVersions?: string | undefined;
+        cwe?: string[] | undefined;
+        mitigation?: string | undefined;
+    }[];
+    scanId: string;
+    scannedAt: string;
+    codeQuality?: {
+        issues?: {
+            message: string;
+            type: "style" | "security" | "quality";
+            severity: "error" | "warning" | "info";
+            file?: string | undefined;
+            line?: number | undefined;
+        }[] | undefined;
+        score?: number | undefined;
+    } | undefined;
+    licenseIssues?: {
+        severity: "error" | "warning" | "info";
+        license: string;
+        package: string;
+        reason: string;
+    }[] | undefined;
+    nextScanAt?: string | undefined;
+}>;
 export type SecurityScanResult = z.infer<typeof SecurityScanResultSchema>;
 /**
  * Security Policy
  */
 export declare const SecurityPolicySchema: z.ZodObject<{
+    /**
+     * Policy identifier
+     */
     id: z.ZodString;
+    /**
+     * Policy name
+     */
     name: z.ZodString;
+    /**
+     * Automatic scanning
+     */
     autoScan: z.ZodObject<{
         enabled: z.ZodDefault<z.ZodBoolean>;
-        frequency: z.ZodDefault<z.ZodEnum<{
-            daily: "daily";
-            weekly: "weekly";
-            monthly: "monthly";
-            "on-publish": "on-publish";
-        }>>;
-    }, z.core.$strip>;
+        frequency: z.ZodDefault<z.ZodEnum<["on-publish", "daily", "weekly", "monthly"]>>;
+    }, "strip", z.ZodTypeAny, {
+        enabled: boolean;
+        frequency: "daily" | "weekly" | "monthly" | "on-publish";
+    }, {
+        enabled?: boolean | undefined;
+        frequency?: "daily" | "weekly" | "monthly" | "on-publish" | undefined;
+    }>;
+    /**
+     * Vulnerability thresholds
+     */
     thresholds: z.ZodObject<{
+        /**
+         * Block plugin if critical vulnerabilities exceed this
+         */
         maxCritical: z.ZodDefault<z.ZodNumber>;
+        /**
+         * Block plugin if high vulnerabilities exceed this
+         */
         maxHigh: z.ZodDefault<z.ZodNumber>;
+        /**
+         * Warn if medium vulnerabilities exceed this
+         */
         maxMedium: z.ZodDefault<z.ZodNumber>;
-    }, z.core.$strip>;
-    allowedLicenses: z.ZodDefault<z.ZodArray<z.ZodString>>;
-    prohibitedLicenses: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    }, "strip", z.ZodTypeAny, {
+        maxCritical: number;
+        maxHigh: number;
+        maxMedium: number;
+    }, {
+        maxCritical?: number | undefined;
+        maxHigh?: number | undefined;
+        maxMedium?: number | undefined;
+    }>;
+    /**
+     * Allowed licenses
+     */
+    allowedLicenses: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    /**
+     * Prohibited licenses
+     */
+    prohibitedLicenses: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    /**
+     * Code signing requirements
+     */
     codeSigning: z.ZodOptional<z.ZodObject<{
         required: z.ZodDefault<z.ZodBoolean>;
-        allowedSigners: z.ZodDefault<z.ZodArray<z.ZodString>>;
-    }, z.core.$strip>>;
+        allowedSigners: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        required: boolean;
+        allowedSigners: string[];
+    }, {
+        required?: boolean | undefined;
+        allowedSigners?: string[] | undefined;
+    }>>;
+    /**
+     * Sandbox restrictions
+     */
     sandbox: z.ZodOptional<z.ZodObject<{
-        networkAccess: z.ZodDefault<z.ZodEnum<{
-            none: "none";
-            all: "all";
-            localhost: "localhost";
-            allowlist: "allowlist";
-        }>>;
-        allowedDestinations: z.ZodDefault<z.ZodArray<z.ZodString>>;
-        filesystemAccess: z.ZodDefault<z.ZodEnum<{
-            full: "full";
-            none: "none";
-            "read-only": "read-only";
-            "temp-only": "temp-only";
-        }>>;
+        /**
+         * Restrict network access
+         */
+        networkAccess: z.ZodDefault<z.ZodEnum<["none", "localhost", "allowlist", "all"]>>;
+        /**
+         * Allowed network destinations (if allowlist)
+         */
+        allowedDestinations: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        /**
+         * File system access
+         */
+        filesystemAccess: z.ZodDefault<z.ZodEnum<["none", "read-only", "temp-only", "full"]>>;
+        /**
+         * Maximum memory (MB)
+         */
         maxMemoryMB: z.ZodOptional<z.ZodNumber>;
+        /**
+         * Maximum CPU time (seconds)
+         */
         maxCPUSeconds: z.ZodOptional<z.ZodNumber>;
-    }, z.core.$strip>>;
-}, z.core.$strip>;
+    }, "strip", z.ZodTypeAny, {
+        networkAccess: "none" | "all" | "localhost" | "allowlist";
+        allowedDestinations: string[];
+        filesystemAccess: "full" | "none" | "read-only" | "temp-only";
+        maxMemoryMB?: number | undefined;
+        maxCPUSeconds?: number | undefined;
+    }, {
+        maxMemoryMB?: number | undefined;
+        networkAccess?: "none" | "all" | "localhost" | "allowlist" | undefined;
+        allowedDestinations?: string[] | undefined;
+        filesystemAccess?: "full" | "none" | "read-only" | "temp-only" | undefined;
+        maxCPUSeconds?: number | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    id: string;
+    autoScan: {
+        enabled: boolean;
+        frequency: "daily" | "weekly" | "monthly" | "on-publish";
+    };
+    thresholds: {
+        maxCritical: number;
+        maxHigh: number;
+        maxMedium: number;
+    };
+    allowedLicenses: string[];
+    prohibitedLicenses: string[];
+    sandbox?: {
+        networkAccess: "none" | "all" | "localhost" | "allowlist";
+        allowedDestinations: string[];
+        filesystemAccess: "full" | "none" | "read-only" | "temp-only";
+        maxMemoryMB?: number | undefined;
+        maxCPUSeconds?: number | undefined;
+    } | undefined;
+    codeSigning?: {
+        required: boolean;
+        allowedSigners: string[];
+    } | undefined;
+}, {
+    name: string;
+    id: string;
+    autoScan: {
+        enabled?: boolean | undefined;
+        frequency?: "daily" | "weekly" | "monthly" | "on-publish" | undefined;
+    };
+    thresholds: {
+        maxCritical?: number | undefined;
+        maxHigh?: number | undefined;
+        maxMedium?: number | undefined;
+    };
+    sandbox?: {
+        maxMemoryMB?: number | undefined;
+        networkAccess?: "none" | "all" | "localhost" | "allowlist" | undefined;
+        allowedDestinations?: string[] | undefined;
+        filesystemAccess?: "full" | "none" | "read-only" | "temp-only" | undefined;
+        maxCPUSeconds?: number | undefined;
+    } | undefined;
+    codeSigning?: {
+        required?: boolean | undefined;
+        allowedSigners?: string[] | undefined;
+    } | undefined;
+    allowedLicenses?: string[] | undefined;
+    prohibitedLicenses?: string[] | undefined;
+}>;
 export type SecurityPolicy = z.infer<typeof SecurityPolicySchema>;
 /**
  * Package Dependency
  */
 export declare const PackageDependencySchema: z.ZodObject<{
+    /**
+     * Package name/ID
+     */
     name: z.ZodString;
+    /**
+     * Version constraint (semver range)
+     */
     versionConstraint: z.ZodString;
-    type: z.ZodDefault<z.ZodEnum<{
-        optional: "optional";
-        required: "required";
-        dev: "dev";
-        peer: "peer";
-    }>>;
+    /**
+     * Dependency type
+     */
+    type: z.ZodDefault<z.ZodEnum<["required", "optional", "peer", "dev"]>>;
+    /**
+     * Resolved version (filled during resolution)
+     */
     resolvedVersion: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
+}, "strip", z.ZodTypeAny, {
+    type: "required" | "dev" | "optional" | "peer";
+    name: string;
+    versionConstraint: string;
+    resolvedVersion?: string | undefined;
+}, {
+    name: string;
+    versionConstraint: string;
+    type?: "required" | "dev" | "optional" | "peer" | undefined;
+    resolvedVersion?: string | undefined;
+}>;
 export type PackageDependency = z.infer<typeof PackageDependencySchema>;
 /**
  * Dependency Graph Node
  */
 export declare const DependencyGraphNodeSchema: z.ZodObject<{
+    /**
+     * Package identifier
+     */
     id: z.ZodString;
+    /**
+     * Package version
+     */
     version: z.ZodString;
+    /**
+     * Dependencies of this package
+     */
     dependencies: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        /**
+         * Package name/ID
+         */
         name: z.ZodString;
+        /**
+         * Version constraint (semver range)
+         */
         versionConstraint: z.ZodString;
-        type: z.ZodDefault<z.ZodEnum<{
-            optional: "optional";
-            required: "required";
-            dev: "dev";
-            peer: "peer";
-        }>>;
+        /**
+         * Dependency type
+         */
+        type: z.ZodDefault<z.ZodEnum<["required", "optional", "peer", "dev"]>>;
+        /**
+         * Resolved version (filled during resolution)
+         */
         resolvedVersion: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>>>;
+    }, "strip", z.ZodTypeAny, {
+        type: "required" | "dev" | "optional" | "peer";
+        name: string;
+        versionConstraint: string;
+        resolvedVersion?: string | undefined;
+    }, {
+        name: string;
+        versionConstraint: string;
+        type?: "required" | "dev" | "optional" | "peer" | undefined;
+        resolvedVersion?: string | undefined;
+    }>, "many">>;
+    /**
+     * Depth in dependency tree
+     */
     depth: z.ZodNumber;
+    /**
+     * Whether this is a direct dependency
+     */
     isDirect: z.ZodBoolean;
+    /**
+     * Package metadata
+     */
     metadata: z.ZodOptional<z.ZodObject<{
         name: z.ZodString;
         description: z.ZodOptional<z.ZodString>;
         license: z.ZodOptional<z.ZodString>;
         homepage: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>>;
-}, z.core.$strip>;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        description?: string | undefined;
+        license?: string | undefined;
+        homepage?: string | undefined;
+    }, {
+        name: string;
+        description?: string | undefined;
+        license?: string | undefined;
+        homepage?: string | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    dependencies: {
+        type: "required" | "dev" | "optional" | "peer";
+        name: string;
+        versionConstraint: string;
+        resolvedVersion?: string | undefined;
+    }[];
+    version: string;
+    id: string;
+    depth: number;
+    isDirect: boolean;
+    metadata?: {
+        name: string;
+        description?: string | undefined;
+        license?: string | undefined;
+        homepage?: string | undefined;
+    } | undefined;
+}, {
+    version: string;
+    id: string;
+    depth: number;
+    isDirect: boolean;
+    dependencies?: {
+        name: string;
+        versionConstraint: string;
+        type?: "required" | "dev" | "optional" | "peer" | undefined;
+        resolvedVersion?: string | undefined;
+    }[] | undefined;
+    metadata?: {
+        name: string;
+        description?: string | undefined;
+        license?: string | undefined;
+        homepage?: string | undefined;
+    } | undefined;
+}>;
 export type DependencyGraphNode = z.infer<typeof DependencyGraphNodeSchema>;
 /**
  * Dependency Graph
  */
 export declare const DependencyGraphSchema: z.ZodObject<{
+    /**
+     * Root package
+     */
     root: z.ZodObject<{
         id: z.ZodString;
         version: z.ZodString;
-    }, z.core.$strip>;
+    }, "strip", z.ZodTypeAny, {
+        version: string;
+        id: string;
+    }, {
+        version: string;
+        id: string;
+    }>;
+    /**
+     * All nodes in the graph
+     */
     nodes: z.ZodArray<z.ZodObject<{
+        /**
+         * Package identifier
+         */
         id: z.ZodString;
+        /**
+         * Package version
+         */
         version: z.ZodString;
+        /**
+         * Dependencies of this package
+         */
         dependencies: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            /**
+             * Package name/ID
+             */
             name: z.ZodString;
+            /**
+             * Version constraint (semver range)
+             */
             versionConstraint: z.ZodString;
-            type: z.ZodDefault<z.ZodEnum<{
-                optional: "optional";
-                required: "required";
-                dev: "dev";
-                peer: "peer";
-            }>>;
+            /**
+             * Dependency type
+             */
+            type: z.ZodDefault<z.ZodEnum<["required", "optional", "peer", "dev"]>>;
+            /**
+             * Resolved version (filled during resolution)
+             */
             resolvedVersion: z.ZodOptional<z.ZodString>;
-        }, z.core.$strip>>>;
+        }, "strip", z.ZodTypeAny, {
+            type: "required" | "dev" | "optional" | "peer";
+            name: string;
+            versionConstraint: string;
+            resolvedVersion?: string | undefined;
+        }, {
+            name: string;
+            versionConstraint: string;
+            type?: "required" | "dev" | "optional" | "peer" | undefined;
+            resolvedVersion?: string | undefined;
+        }>, "many">>;
+        /**
+         * Depth in dependency tree
+         */
         depth: z.ZodNumber;
+        /**
+         * Whether this is a direct dependency
+         */
         isDirect: z.ZodBoolean;
+        /**
+         * Package metadata
+         */
         metadata: z.ZodOptional<z.ZodObject<{
             name: z.ZodString;
             description: z.ZodOptional<z.ZodString>;
             license: z.ZodOptional<z.ZodString>;
             homepage: z.ZodOptional<z.ZodString>;
-        }, z.core.$strip>>;
-    }, z.core.$strip>>;
+        }, "strip", z.ZodTypeAny, {
+            name: string;
+            description?: string | undefined;
+            license?: string | undefined;
+            homepage?: string | undefined;
+        }, {
+            name: string;
+            description?: string | undefined;
+            license?: string | undefined;
+            homepage?: string | undefined;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        dependencies: {
+            type: "required" | "dev" | "optional" | "peer";
+            name: string;
+            versionConstraint: string;
+            resolvedVersion?: string | undefined;
+        }[];
+        version: string;
+        id: string;
+        depth: number;
+        isDirect: boolean;
+        metadata?: {
+            name: string;
+            description?: string | undefined;
+            license?: string | undefined;
+            homepage?: string | undefined;
+        } | undefined;
+    }, {
+        version: string;
+        id: string;
+        depth: number;
+        isDirect: boolean;
+        dependencies?: {
+            name: string;
+            versionConstraint: string;
+            type?: "required" | "dev" | "optional" | "peer" | undefined;
+            resolvedVersion?: string | undefined;
+        }[] | undefined;
+        metadata?: {
+            name: string;
+            description?: string | undefined;
+            license?: string | undefined;
+            homepage?: string | undefined;
+        } | undefined;
+    }>, "many">;
+    /**
+     * Edges (dependency relationships)
+     */
     edges: z.ZodArray<z.ZodObject<{
         from: z.ZodString;
         to: z.ZodString;
         constraint: z.ZodString;
-    }, z.core.$strip>>;
+    }, "strip", z.ZodTypeAny, {
+        from: string;
+        to: string;
+        constraint: string;
+    }, {
+        from: string;
+        to: string;
+        constraint: string;
+    }>, "many">;
+    /**
+     * Resolution statistics
+     */
     stats: z.ZodObject<{
         totalDependencies: z.ZodNumber;
         directDependencies: z.ZodNumber;
         maxDepth: z.ZodNumber;
-    }, z.core.$strip>;
-}, z.core.$strip>;
+    }, "strip", z.ZodTypeAny, {
+        totalDependencies: number;
+        directDependencies: number;
+        maxDepth: number;
+    }, {
+        totalDependencies: number;
+        directDependencies: number;
+        maxDepth: number;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    root: {
+        version: string;
+        id: string;
+    };
+    stats: {
+        totalDependencies: number;
+        directDependencies: number;
+        maxDepth: number;
+    };
+    nodes: {
+        dependencies: {
+            type: "required" | "dev" | "optional" | "peer";
+            name: string;
+            versionConstraint: string;
+            resolvedVersion?: string | undefined;
+        }[];
+        version: string;
+        id: string;
+        depth: number;
+        isDirect: boolean;
+        metadata?: {
+            name: string;
+            description?: string | undefined;
+            license?: string | undefined;
+            homepage?: string | undefined;
+        } | undefined;
+    }[];
+    edges: {
+        from: string;
+        to: string;
+        constraint: string;
+    }[];
+}, {
+    root: {
+        version: string;
+        id: string;
+    };
+    stats: {
+        totalDependencies: number;
+        directDependencies: number;
+        maxDepth: number;
+    };
+    nodes: {
+        version: string;
+        id: string;
+        depth: number;
+        isDirect: boolean;
+        dependencies?: {
+            name: string;
+            versionConstraint: string;
+            type?: "required" | "dev" | "optional" | "peer" | undefined;
+            resolvedVersion?: string | undefined;
+        }[] | undefined;
+        metadata?: {
+            name: string;
+            description?: string | undefined;
+            license?: string | undefined;
+            homepage?: string | undefined;
+        } | undefined;
+    }[];
+    edges: {
+        from: string;
+        to: string;
+        constraint: string;
+    }[];
+}>;
 export type DependencyGraph = z.infer<typeof DependencyGraphSchema>;
 /**
  * Dependency Conflict
  */
 export declare const DependencyConflictSchema: z.ZodObject<{
+    /**
+     * Package with conflict
+     */
     package: z.ZodString;
+    /**
+     * Conflicting versions
+     */
     conflicts: z.ZodArray<z.ZodObject<{
         version: z.ZodString;
-        requestedBy: z.ZodArray<z.ZodString>;
+        requestedBy: z.ZodArray<z.ZodString, "many">;
         constraint: z.ZodString;
-    }, z.core.$strip>>;
+    }, "strip", z.ZodTypeAny, {
+        version: string;
+        requestedBy: string[];
+        constraint: string;
+    }, {
+        version: string;
+        requestedBy: string[];
+        constraint: string;
+    }>, "many">;
+    /**
+     * Suggested resolution
+     */
     resolution: z.ZodOptional<z.ZodObject<{
-        strategy: z.ZodEnum<{
-            manual: "manual";
-            "pick-highest": "pick-highest";
-            "pick-lowest": "pick-lowest";
-        }>;
+        strategy: z.ZodEnum<["pick-highest", "pick-lowest", "manual"]>;
         version: z.ZodOptional<z.ZodString>;
         reason: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>>;
-    severity: z.ZodEnum<{
-        error: "error";
-        warning: "warning";
-        info: "info";
-    }>;
-}, z.core.$strip>;
+    }, "strip", z.ZodTypeAny, {
+        strategy: "manual" | "pick-highest" | "pick-lowest";
+        version?: string | undefined;
+        reason?: string | undefined;
+    }, {
+        strategy: "manual" | "pick-highest" | "pick-lowest";
+        version?: string | undefined;
+        reason?: string | undefined;
+    }>>;
+    /**
+     * Severity
+     */
+    severity: z.ZodEnum<["error", "warning", "info"]>;
+}, "strip", z.ZodTypeAny, {
+    severity: "error" | "warning" | "info";
+    package: string;
+    conflicts: {
+        version: string;
+        requestedBy: string[];
+        constraint: string;
+    }[];
+    resolution?: {
+        strategy: "manual" | "pick-highest" | "pick-lowest";
+        version?: string | undefined;
+        reason?: string | undefined;
+    } | undefined;
+}, {
+    severity: "error" | "warning" | "info";
+    package: string;
+    conflicts: {
+        version: string;
+        requestedBy: string[];
+        constraint: string;
+    }[];
+    resolution?: {
+        strategy: "manual" | "pick-highest" | "pick-lowest";
+        version?: string | undefined;
+        reason?: string | undefined;
+    } | undefined;
+}>;
 export type DependencyConflict = z.infer<typeof DependencyConflictSchema>;
 /**
  * Dependency Resolution Result
  */
 export declare const DependencyResolutionResultSchema: z.ZodObject<{
-    status: z.ZodEnum<{
-        error: "error";
-        success: "success";
-        conflict: "conflict";
-    }>;
+    /**
+     * Resolution status
+     */
+    status: z.ZodEnum<["success", "conflict", "error"]>;
+    /**
+     * Resolved dependency graph
+     */
     graph: z.ZodOptional<z.ZodObject<{
+        /**
+         * Root package
+         */
         root: z.ZodObject<{
             id: z.ZodString;
             version: z.ZodString;
-        }, z.core.$strip>;
+        }, "strip", z.ZodTypeAny, {
+            version: string;
+            id: string;
+        }, {
+            version: string;
+            id: string;
+        }>;
+        /**
+         * All nodes in the graph
+         */
         nodes: z.ZodArray<z.ZodObject<{
+            /**
+             * Package identifier
+             */
             id: z.ZodString;
+            /**
+             * Package version
+             */
             version: z.ZodString;
+            /**
+             * Dependencies of this package
+             */
             dependencies: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                /**
+                 * Package name/ID
+                 */
                 name: z.ZodString;
+                /**
+                 * Version constraint (semver range)
+                 */
                 versionConstraint: z.ZodString;
-                type: z.ZodDefault<z.ZodEnum<{
-                    optional: "optional";
-                    required: "required";
-                    dev: "dev";
-                    peer: "peer";
-                }>>;
+                /**
+                 * Dependency type
+                 */
+                type: z.ZodDefault<z.ZodEnum<["required", "optional", "peer", "dev"]>>;
+                /**
+                 * Resolved version (filled during resolution)
+                 */
                 resolvedVersion: z.ZodOptional<z.ZodString>;
-            }, z.core.$strip>>>;
+            }, "strip", z.ZodTypeAny, {
+                type: "required" | "dev" | "optional" | "peer";
+                name: string;
+                versionConstraint: string;
+                resolvedVersion?: string | undefined;
+            }, {
+                name: string;
+                versionConstraint: string;
+                type?: "required" | "dev" | "optional" | "peer" | undefined;
+                resolvedVersion?: string | undefined;
+            }>, "many">>;
+            /**
+             * Depth in dependency tree
+             */
             depth: z.ZodNumber;
+            /**
+             * Whether this is a direct dependency
+             */
             isDirect: z.ZodBoolean;
+            /**
+             * Package metadata
+             */
             metadata: z.ZodOptional<z.ZodObject<{
                 name: z.ZodString;
                 description: z.ZodOptional<z.ZodString>;
                 license: z.ZodOptional<z.ZodString>;
                 homepage: z.ZodOptional<z.ZodString>;
-            }, z.core.$strip>>;
-        }, z.core.$strip>>;
+            }, "strip", z.ZodTypeAny, {
+                name: string;
+                description?: string | undefined;
+                license?: string | undefined;
+                homepage?: string | undefined;
+            }, {
+                name: string;
+                description?: string | undefined;
+                license?: string | undefined;
+                homepage?: string | undefined;
+            }>>;
+        }, "strip", z.ZodTypeAny, {
+            dependencies: {
+                type: "required" | "dev" | "optional" | "peer";
+                name: string;
+                versionConstraint: string;
+                resolvedVersion?: string | undefined;
+            }[];
+            version: string;
+            id: string;
+            depth: number;
+            isDirect: boolean;
+            metadata?: {
+                name: string;
+                description?: string | undefined;
+                license?: string | undefined;
+                homepage?: string | undefined;
+            } | undefined;
+        }, {
+            version: string;
+            id: string;
+            depth: number;
+            isDirect: boolean;
+            dependencies?: {
+                name: string;
+                versionConstraint: string;
+                type?: "required" | "dev" | "optional" | "peer" | undefined;
+                resolvedVersion?: string | undefined;
+            }[] | undefined;
+            metadata?: {
+                name: string;
+                description?: string | undefined;
+                license?: string | undefined;
+                homepage?: string | undefined;
+            } | undefined;
+        }>, "many">;
+        /**
+         * Edges (dependency relationships)
+         */
         edges: z.ZodArray<z.ZodObject<{
             from: z.ZodString;
             to: z.ZodString;
             constraint: z.ZodString;
-        }, z.core.$strip>>;
+        }, "strip", z.ZodTypeAny, {
+            from: string;
+            to: string;
+            constraint: string;
+        }, {
+            from: string;
+            to: string;
+            constraint: string;
+        }>, "many">;
+        /**
+         * Resolution statistics
+         */
         stats: z.ZodObject<{
             totalDependencies: z.ZodNumber;
             directDependencies: z.ZodNumber;
             maxDepth: z.ZodNumber;
-        }, z.core.$strip>;
-    }, z.core.$strip>>;
+        }, "strip", z.ZodTypeAny, {
+            totalDependencies: number;
+            directDependencies: number;
+            maxDepth: number;
+        }, {
+            totalDependencies: number;
+            directDependencies: number;
+            maxDepth: number;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        root: {
+            version: string;
+            id: string;
+        };
+        stats: {
+            totalDependencies: number;
+            directDependencies: number;
+            maxDepth: number;
+        };
+        nodes: {
+            dependencies: {
+                type: "required" | "dev" | "optional" | "peer";
+                name: string;
+                versionConstraint: string;
+                resolvedVersion?: string | undefined;
+            }[];
+            version: string;
+            id: string;
+            depth: number;
+            isDirect: boolean;
+            metadata?: {
+                name: string;
+                description?: string | undefined;
+                license?: string | undefined;
+                homepage?: string | undefined;
+            } | undefined;
+        }[];
+        edges: {
+            from: string;
+            to: string;
+            constraint: string;
+        }[];
+    }, {
+        root: {
+            version: string;
+            id: string;
+        };
+        stats: {
+            totalDependencies: number;
+            directDependencies: number;
+            maxDepth: number;
+        };
+        nodes: {
+            version: string;
+            id: string;
+            depth: number;
+            isDirect: boolean;
+            dependencies?: {
+                name: string;
+                versionConstraint: string;
+                type?: "required" | "dev" | "optional" | "peer" | undefined;
+                resolvedVersion?: string | undefined;
+            }[] | undefined;
+            metadata?: {
+                name: string;
+                description?: string | undefined;
+                license?: string | undefined;
+                homepage?: string | undefined;
+            } | undefined;
+        }[];
+        edges: {
+            from: string;
+            to: string;
+            constraint: string;
+        }[];
+    }>>;
+    /**
+     * Conflicts detected
+     */
     conflicts: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        /**
+         * Package with conflict
+         */
         package: z.ZodString;
+        /**
+         * Conflicting versions
+         */
         conflicts: z.ZodArray<z.ZodObject<{
             version: z.ZodString;
-            requestedBy: z.ZodArray<z.ZodString>;
+            requestedBy: z.ZodArray<z.ZodString, "many">;
             constraint: z.ZodString;
-        }, z.core.$strip>>;
+        }, "strip", z.ZodTypeAny, {
+            version: string;
+            requestedBy: string[];
+            constraint: string;
+        }, {
+            version: string;
+            requestedBy: string[];
+            constraint: string;
+        }>, "many">;
+        /**
+         * Suggested resolution
+         */
         resolution: z.ZodOptional<z.ZodObject<{
-            strategy: z.ZodEnum<{
-                manual: "manual";
-                "pick-highest": "pick-highest";
-                "pick-lowest": "pick-lowest";
-            }>;
+            strategy: z.ZodEnum<["pick-highest", "pick-lowest", "manual"]>;
             version: z.ZodOptional<z.ZodString>;
             reason: z.ZodOptional<z.ZodString>;
-        }, z.core.$strip>>;
-        severity: z.ZodEnum<{
-            error: "error";
-            warning: "warning";
-            info: "info";
-        }>;
-    }, z.core.$strip>>>;
+        }, "strip", z.ZodTypeAny, {
+            strategy: "manual" | "pick-highest" | "pick-lowest";
+            version?: string | undefined;
+            reason?: string | undefined;
+        }, {
+            strategy: "manual" | "pick-highest" | "pick-lowest";
+            version?: string | undefined;
+            reason?: string | undefined;
+        }>>;
+        /**
+         * Severity
+         */
+        severity: z.ZodEnum<["error", "warning", "info"]>;
+    }, "strip", z.ZodTypeAny, {
+        severity: "error" | "warning" | "info";
+        package: string;
+        conflicts: {
+            version: string;
+            requestedBy: string[];
+            constraint: string;
+        }[];
+        resolution?: {
+            strategy: "manual" | "pick-highest" | "pick-lowest";
+            version?: string | undefined;
+            reason?: string | undefined;
+        } | undefined;
+    }, {
+        severity: "error" | "warning" | "info";
+        package: string;
+        conflicts: {
+            version: string;
+            requestedBy: string[];
+            constraint: string;
+        }[];
+        resolution?: {
+            strategy: "manual" | "pick-highest" | "pick-lowest";
+            version?: string | undefined;
+            reason?: string | undefined;
+        } | undefined;
+    }>, "many">>;
+    /**
+     * Errors encountered
+     */
     errors: z.ZodDefault<z.ZodArray<z.ZodObject<{
         package: z.ZodString;
         error: z.ZodString;
-    }, z.core.$strip>>>;
-    installOrder: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    }, "strip", z.ZodTypeAny, {
+        error: string;
+        package: string;
+    }, {
+        error: string;
+        package: string;
+    }>, "many">>;
+    /**
+     * Installation order (topological sort)
+     */
+    installOrder: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    /**
+     * Resolution time (ms)
+     */
     resolvedIn: z.ZodOptional<z.ZodNumber>;
-}, z.core.$strip>;
+}, "strip", z.ZodTypeAny, {
+    status: "error" | "success" | "conflict";
+    errors: {
+        error: string;
+        package: string;
+    }[];
+    conflicts: {
+        severity: "error" | "warning" | "info";
+        package: string;
+        conflicts: {
+            version: string;
+            requestedBy: string[];
+            constraint: string;
+        }[];
+        resolution?: {
+            strategy: "manual" | "pick-highest" | "pick-lowest";
+            version?: string | undefined;
+            reason?: string | undefined;
+        } | undefined;
+    }[];
+    installOrder: string[];
+    graph?: {
+        root: {
+            version: string;
+            id: string;
+        };
+        stats: {
+            totalDependencies: number;
+            directDependencies: number;
+            maxDepth: number;
+        };
+        nodes: {
+            dependencies: {
+                type: "required" | "dev" | "optional" | "peer";
+                name: string;
+                versionConstraint: string;
+                resolvedVersion?: string | undefined;
+            }[];
+            version: string;
+            id: string;
+            depth: number;
+            isDirect: boolean;
+            metadata?: {
+                name: string;
+                description?: string | undefined;
+                license?: string | undefined;
+                homepage?: string | undefined;
+            } | undefined;
+        }[];
+        edges: {
+            from: string;
+            to: string;
+            constraint: string;
+        }[];
+    } | undefined;
+    resolvedIn?: number | undefined;
+}, {
+    status: "error" | "success" | "conflict";
+    graph?: {
+        root: {
+            version: string;
+            id: string;
+        };
+        stats: {
+            totalDependencies: number;
+            directDependencies: number;
+            maxDepth: number;
+        };
+        nodes: {
+            version: string;
+            id: string;
+            depth: number;
+            isDirect: boolean;
+            dependencies?: {
+                name: string;
+                versionConstraint: string;
+                type?: "required" | "dev" | "optional" | "peer" | undefined;
+                resolvedVersion?: string | undefined;
+            }[] | undefined;
+            metadata?: {
+                name: string;
+                description?: string | undefined;
+                license?: string | undefined;
+                homepage?: string | undefined;
+            } | undefined;
+        }[];
+        edges: {
+            from: string;
+            to: string;
+            constraint: string;
+        }[];
+    } | undefined;
+    errors?: {
+        error: string;
+        package: string;
+    }[] | undefined;
+    conflicts?: {
+        severity: "error" | "warning" | "info";
+        package: string;
+        conflicts: {
+            version: string;
+            requestedBy: string[];
+            constraint: string;
+        }[];
+        resolution?: {
+            strategy: "manual" | "pick-highest" | "pick-lowest";
+            version?: string | undefined;
+            reason?: string | undefined;
+        } | undefined;
+    }[] | undefined;
+    installOrder?: string[] | undefined;
+    resolvedIn?: number | undefined;
+}>;
 export type DependencyResolutionResult = z.infer<typeof DependencyResolutionResultSchema>;
 /**
  * SBOM (Software Bill of Materials) Entry
  */
 export declare const SBOMEntrySchema: z.ZodObject<{
+    /**
+     * Component name
+     */
     name: z.ZodString;
+    /**
+     * Component version
+     */
     version: z.ZodString;
+    /**
+     * Package URL (purl)
+     */
     purl: z.ZodOptional<z.ZodString>;
+    /**
+     * License
+     */
     license: z.ZodOptional<z.ZodString>;
+    /**
+     * Hashes
+     */
     hashes: z.ZodOptional<z.ZodObject<{
         sha256: z.ZodOptional<z.ZodString>;
         sha512: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>>;
+    }, "strip", z.ZodTypeAny, {
+        sha256?: string | undefined;
+        sha512?: string | undefined;
+    }, {
+        sha256?: string | undefined;
+        sha512?: string | undefined;
+    }>>;
+    /**
+     * Supplier
+     */
     supplier: z.ZodOptional<z.ZodObject<{
         name: z.ZodString;
         url: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>>;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        url?: string | undefined;
+    }, {
+        name: string;
+        url?: string | undefined;
+    }>>;
+    /**
+     * External references
+     */
     externalRefs: z.ZodDefault<z.ZodArray<z.ZodObject<{
-        type: z.ZodEnum<{
-            documentation: "documentation";
-            repository: "repository";
-            website: "website";
-            "issue-tracker": "issue-tracker";
-        }>;
+        type: z.ZodEnum<["website", "repository", "documentation", "issue-tracker"]>;
         url: z.ZodString;
-    }, z.core.$strip>>>;
-}, z.core.$strip>;
+    }, "strip", z.ZodTypeAny, {
+        type: "documentation" | "website" | "repository" | "issue-tracker";
+        url: string;
+    }, {
+        type: "documentation" | "website" | "repository" | "issue-tracker";
+        url: string;
+    }>, "many">>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    version: string;
+    externalRefs: {
+        type: "documentation" | "website" | "repository" | "issue-tracker";
+        url: string;
+    }[];
+    license?: string | undefined;
+    purl?: string | undefined;
+    hashes?: {
+        sha256?: string | undefined;
+        sha512?: string | undefined;
+    } | undefined;
+    supplier?: {
+        name: string;
+        url?: string | undefined;
+    } | undefined;
+}, {
+    name: string;
+    version: string;
+    license?: string | undefined;
+    purl?: string | undefined;
+    hashes?: {
+        sha256?: string | undefined;
+        sha512?: string | undefined;
+    } | undefined;
+    supplier?: {
+        name: string;
+        url?: string | undefined;
+    } | undefined;
+    externalRefs?: {
+        type: "documentation" | "website" | "repository" | "issue-tracker";
+        url: string;
+    }[] | undefined;
+}>;
 export type SBOMEntry = z.infer<typeof SBOMEntrySchema>;
 /**
  * Software Bill of Materials (SBOM)
  */
 export declare const SBOMSchema: z.ZodObject<{
-    format: z.ZodDefault<z.ZodEnum<{
-        spdx: "spdx";
-        cyclonedx: "cyclonedx";
-    }>>;
+    /**
+     * SBOM format
+     */
+    format: z.ZodDefault<z.ZodEnum<["spdx", "cyclonedx"]>>;
+    /**
+     * SBOM version
+     */
     version: z.ZodString;
+    /**
+     * Plugin metadata
+     */
     plugin: z.ZodObject<{
         id: z.ZodString;
         version: z.ZodString;
         name: z.ZodString;
-    }, z.core.$strip>;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        version: string;
+        id: string;
+    }, {
+        name: string;
+        version: string;
+        id: string;
+    }>;
+    /**
+     * Components (dependencies)
+     */
     components: z.ZodArray<z.ZodObject<{
+        /**
+         * Component name
+         */
         name: z.ZodString;
+        /**
+         * Component version
+         */
         version: z.ZodString;
+        /**
+         * Package URL (purl)
+         */
         purl: z.ZodOptional<z.ZodString>;
+        /**
+         * License
+         */
         license: z.ZodOptional<z.ZodString>;
+        /**
+         * Hashes
+         */
         hashes: z.ZodOptional<z.ZodObject<{
             sha256: z.ZodOptional<z.ZodString>;
             sha512: z.ZodOptional<z.ZodString>;
-        }, z.core.$strip>>;
+        }, "strip", z.ZodTypeAny, {
+            sha256?: string | undefined;
+            sha512?: string | undefined;
+        }, {
+            sha256?: string | undefined;
+            sha512?: string | undefined;
+        }>>;
+        /**
+         * Supplier
+         */
         supplier: z.ZodOptional<z.ZodObject<{
             name: z.ZodString;
             url: z.ZodOptional<z.ZodString>;
-        }, z.core.$strip>>;
+        }, "strip", z.ZodTypeAny, {
+            name: string;
+            url?: string | undefined;
+        }, {
+            name: string;
+            url?: string | undefined;
+        }>>;
+        /**
+         * External references
+         */
         externalRefs: z.ZodDefault<z.ZodArray<z.ZodObject<{
-            type: z.ZodEnum<{
-                documentation: "documentation";
-                repository: "repository";
-                website: "website";
-                "issue-tracker": "issue-tracker";
-            }>;
+            type: z.ZodEnum<["website", "repository", "documentation", "issue-tracker"]>;
             url: z.ZodString;
-        }, z.core.$strip>>>;
-    }, z.core.$strip>>;
+        }, "strip", z.ZodTypeAny, {
+            type: "documentation" | "website" | "repository" | "issue-tracker";
+            url: string;
+        }, {
+            type: "documentation" | "website" | "repository" | "issue-tracker";
+            url: string;
+        }>, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        version: string;
+        externalRefs: {
+            type: "documentation" | "website" | "repository" | "issue-tracker";
+            url: string;
+        }[];
+        license?: string | undefined;
+        purl?: string | undefined;
+        hashes?: {
+            sha256?: string | undefined;
+            sha512?: string | undefined;
+        } | undefined;
+        supplier?: {
+            name: string;
+            url?: string | undefined;
+        } | undefined;
+    }, {
+        name: string;
+        version: string;
+        license?: string | undefined;
+        purl?: string | undefined;
+        hashes?: {
+            sha256?: string | undefined;
+            sha512?: string | undefined;
+        } | undefined;
+        supplier?: {
+            name: string;
+            url?: string | undefined;
+        } | undefined;
+        externalRefs?: {
+            type: "documentation" | "website" | "repository" | "issue-tracker";
+            url: string;
+        }[] | undefined;
+    }>, "many">;
+    /**
+     * Generation timestamp
+     */
     generatedAt: z.ZodString;
+    /**
+     * Generator tool
+     */
     generator: z.ZodOptional<z.ZodObject<{
         name: z.ZodString;
         version: z.ZodString;
-    }, z.core.$strip>>;
-}, z.core.$strip>;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        version: string;
+    }, {
+        name: string;
+        version: string;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    format: "spdx" | "cyclonedx";
+    version: string;
+    components: {
+        name: string;
+        version: string;
+        externalRefs: {
+            type: "documentation" | "website" | "repository" | "issue-tracker";
+            url: string;
+        }[];
+        license?: string | undefined;
+        purl?: string | undefined;
+        hashes?: {
+            sha256?: string | undefined;
+            sha512?: string | undefined;
+        } | undefined;
+        supplier?: {
+            name: string;
+            url?: string | undefined;
+        } | undefined;
+    }[];
+    plugin: {
+        name: string;
+        version: string;
+        id: string;
+    };
+    generatedAt: string;
+    generator?: {
+        name: string;
+        version: string;
+    } | undefined;
+}, {
+    version: string;
+    components: {
+        name: string;
+        version: string;
+        license?: string | undefined;
+        purl?: string | undefined;
+        hashes?: {
+            sha256?: string | undefined;
+            sha512?: string | undefined;
+        } | undefined;
+        supplier?: {
+            name: string;
+            url?: string | undefined;
+        } | undefined;
+        externalRefs?: {
+            type: "documentation" | "website" | "repository" | "issue-tracker";
+            url: string;
+        }[] | undefined;
+    }[];
+    plugin: {
+        name: string;
+        version: string;
+        id: string;
+    };
+    generatedAt: string;
+    format?: "spdx" | "cyclonedx" | undefined;
+    generator?: {
+        name: string;
+        version: string;
+    } | undefined;
+}>;
 export type SBOM = z.infer<typeof SBOMSchema>;
 /**
  * Plugin Provenance
  * Verifiable chain of custody for plugin artifacts
  */
 export declare const PluginProvenanceSchema: z.ZodObject<{
+    /**
+     * Plugin identifier
+     */
     pluginId: z.ZodString;
+    /**
+     * Plugin version
+     */
     version: z.ZodString;
+    /**
+     * Build information
+     */
     build: z.ZodObject<{
+        /**
+         * Build timestamp
+         */
         timestamp: z.ZodString;
+        /**
+         * Build environment
+         */
         environment: z.ZodOptional<z.ZodObject<{
             os: z.ZodString;
             arch: z.ZodString;
             nodeVersion: z.ZodString;
-        }, z.core.$strip>>;
+        }, "strip", z.ZodTypeAny, {
+            os: string;
+            nodeVersion: string;
+            arch: string;
+        }, {
+            os: string;
+            nodeVersion: string;
+            arch: string;
+        }>>;
+        /**
+         * Source repository
+         */
         source: z.ZodOptional<z.ZodObject<{
             repository: z.ZodString;
             commit: z.ZodString;
             branch: z.ZodOptional<z.ZodString>;
             tag: z.ZodOptional<z.ZodString>;
-        }, z.core.$strip>>;
+        }, "strip", z.ZodTypeAny, {
+            commit: string;
+            repository: string;
+            tag?: string | undefined;
+            branch?: string | undefined;
+        }, {
+            commit: string;
+            repository: string;
+            tag?: string | undefined;
+            branch?: string | undefined;
+        }>>;
+        /**
+         * Builder identity
+         */
         builder: z.ZodOptional<z.ZodObject<{
             name: z.ZodString;
             email: z.ZodOptional<z.ZodString>;
-        }, z.core.$strip>>;
-    }, z.core.$strip>;
+        }, "strip", z.ZodTypeAny, {
+            name: string;
+            email?: string | undefined;
+        }, {
+            name: string;
+            email?: string | undefined;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        timestamp: string;
+        source?: {
+            commit: string;
+            repository: string;
+            tag?: string | undefined;
+            branch?: string | undefined;
+        } | undefined;
+        environment?: {
+            os: string;
+            nodeVersion: string;
+            arch: string;
+        } | undefined;
+        builder?: {
+            name: string;
+            email?: string | undefined;
+        } | undefined;
+    }, {
+        timestamp: string;
+        source?: {
+            commit: string;
+            repository: string;
+            tag?: string | undefined;
+            branch?: string | undefined;
+        } | undefined;
+        environment?: {
+            os: string;
+            nodeVersion: string;
+            arch: string;
+        } | undefined;
+        builder?: {
+            name: string;
+            email?: string | undefined;
+        } | undefined;
+    }>;
+    /**
+     * Artifact hashes
+     */
     artifacts: z.ZodArray<z.ZodObject<{
         filename: z.ZodString;
         sha256: z.ZodString;
         size: z.ZodNumber;
-    }, z.core.$strip>>;
+    }, "strip", z.ZodTypeAny, {
+        size: number;
+        sha256: string;
+        filename: string;
+    }, {
+        size: number;
+        sha256: string;
+        filename: string;
+    }>, "many">;
+    /**
+     * Signatures
+     */
     signatures: z.ZodDefault<z.ZodArray<z.ZodObject<{
-        algorithm: z.ZodEnum<{
-            rsa: "rsa";
-            ecdsa: "ecdsa";
-            ed25519: "ed25519";
-        }>;
+        algorithm: z.ZodEnum<["rsa", "ecdsa", "ed25519"]>;
         publicKey: z.ZodString;
         signature: z.ZodString;
         signedBy: z.ZodString;
         timestamp: z.ZodString;
-    }, z.core.$strip>>>;
+    }, "strip", z.ZodTypeAny, {
+        algorithm: "rsa" | "ecdsa" | "ed25519";
+        signature: string;
+        timestamp: string;
+        publicKey: string;
+        signedBy: string;
+    }, {
+        algorithm: "rsa" | "ecdsa" | "ed25519";
+        signature: string;
+        timestamp: string;
+        publicKey: string;
+        signedBy: string;
+    }>, "many">>;
+    /**
+     * Attestations
+     */
     attestations: z.ZodDefault<z.ZodArray<z.ZodObject<{
-        type: z.ZodEnum<{
-            "code-review": "code-review";
-            "security-scan": "security-scan";
-            "test-results": "test-results";
-            "ci-build": "ci-build";
-        }>;
-        status: z.ZodEnum<{
-            failed: "failed";
-            passed: "passed";
-        }>;
+        type: z.ZodEnum<["code-review", "security-scan", "test-results", "ci-build"]>;
+        status: z.ZodEnum<["passed", "failed"]>;
         url: z.ZodOptional<z.ZodString>;
         timestamp: z.ZodString;
-    }, z.core.$strip>>>;
-}, z.core.$strip>;
+    }, "strip", z.ZodTypeAny, {
+        type: "code-review" | "security-scan" | "test-results" | "ci-build";
+        status: "failed" | "passed";
+        timestamp: string;
+        url?: string | undefined;
+    }, {
+        type: "code-review" | "security-scan" | "test-results" | "ci-build";
+        status: "failed" | "passed";
+        timestamp: string;
+        url?: string | undefined;
+    }>, "many">>;
+}, "strip", z.ZodTypeAny, {
+    version: string;
+    pluginId: string;
+    build: {
+        timestamp: string;
+        source?: {
+            commit: string;
+            repository: string;
+            tag?: string | undefined;
+            branch?: string | undefined;
+        } | undefined;
+        environment?: {
+            os: string;
+            nodeVersion: string;
+            arch: string;
+        } | undefined;
+        builder?: {
+            name: string;
+            email?: string | undefined;
+        } | undefined;
+    };
+    artifacts: {
+        size: number;
+        sha256: string;
+        filename: string;
+    }[];
+    signatures: {
+        algorithm: "rsa" | "ecdsa" | "ed25519";
+        signature: string;
+        timestamp: string;
+        publicKey: string;
+        signedBy: string;
+    }[];
+    attestations: {
+        type: "code-review" | "security-scan" | "test-results" | "ci-build";
+        status: "failed" | "passed";
+        timestamp: string;
+        url?: string | undefined;
+    }[];
+}, {
+    version: string;
+    pluginId: string;
+    build: {
+        timestamp: string;
+        source?: {
+            commit: string;
+            repository: string;
+            tag?: string | undefined;
+            branch?: string | undefined;
+        } | undefined;
+        environment?: {
+            os: string;
+            nodeVersion: string;
+            arch: string;
+        } | undefined;
+        builder?: {
+            name: string;
+            email?: string | undefined;
+        } | undefined;
+    };
+    artifacts: {
+        size: number;
+        sha256: string;
+        filename: string;
+    }[];
+    signatures?: {
+        algorithm: "rsa" | "ecdsa" | "ed25519";
+        signature: string;
+        timestamp: string;
+        publicKey: string;
+        signedBy: string;
+    }[] | undefined;
+    attestations?: {
+        type: "code-review" | "security-scan" | "test-results" | "ci-build";
+        status: "failed" | "passed";
+        timestamp: string;
+        url?: string | undefined;
+    }[] | undefined;
+}>;
 export type PluginProvenance = z.infer<typeof PluginProvenanceSchema>;
 /**
  * Plugin Trust Score
  */
 export declare const PluginTrustScoreSchema: z.ZodObject<{
+    /**
+     * Plugin identifier
+     */
     pluginId: z.ZodString;
+    /**
+     * Overall trust score (0-100)
+     */
     score: z.ZodNumber;
+    /**
+     * Score components
+     */
     components: z.ZodObject<{
+        /**
+         * Vendor reputation (0-100)
+         */
         vendorReputation: z.ZodNumber;
+        /**
+         * Security scan results (0-100)
+         */
         securityScore: z.ZodNumber;
+        /**
+         * Code quality (0-100)
+         */
         codeQuality: z.ZodNumber;
+        /**
+         * Community engagement (0-100)
+         */
         communityScore: z.ZodNumber;
+        /**
+         * Update frequency (0-100)
+         */
         maintenanceScore: z.ZodNumber;
-    }, z.core.$strip>;
-    level: z.ZodEnum<{
-        verified: "verified";
-        trusted: "trusted";
-        untrusted: "untrusted";
-        blocked: "blocked";
-        neutral: "neutral";
+    }, "strip", z.ZodTypeAny, {
+        codeQuality: number;
+        vendorReputation: number;
+        securityScore: number;
+        communityScore: number;
+        maintenanceScore: number;
+    }, {
+        codeQuality: number;
+        vendorReputation: number;
+        securityScore: number;
+        communityScore: number;
+        maintenanceScore: number;
     }>;
-    badges: z.ZodDefault<z.ZodArray<z.ZodEnum<{
-        "open-source": "open-source";
-        official: "official";
-        "verified-vendor": "verified-vendor";
-        "security-scanned": "security-scanned";
-        "code-signed": "code-signed";
-        popular: "popular";
-    }>>>;
+    /**
+     * Trust level
+     */
+    level: z.ZodEnum<["verified", "trusted", "neutral", "untrusted", "blocked"]>;
+    /**
+     * Verification badges
+     */
+    badges: z.ZodDefault<z.ZodArray<z.ZodEnum<["official", "verified-vendor", "security-scanned", "code-signed", "open-source", "popular"]>, "many">>;
+    /**
+     * Last updated
+     */
     updatedAt: z.ZodString;
-}, z.core.$strip>;
+}, "strip", z.ZodTypeAny, {
+    components: {
+        codeQuality: number;
+        vendorReputation: number;
+        securityScore: number;
+        communityScore: number;
+        maintenanceScore: number;
+    };
+    level: "verified" | "trusted" | "untrusted" | "blocked" | "neutral";
+    updatedAt: string;
+    pluginId: string;
+    score: number;
+    badges: ("official" | "verified-vendor" | "security-scanned" | "code-signed" | "open-source" | "popular")[];
+}, {
+    components: {
+        codeQuality: number;
+        vendorReputation: number;
+        securityScore: number;
+        communityScore: number;
+        maintenanceScore: number;
+    };
+    level: "verified" | "trusted" | "untrusted" | "blocked" | "neutral";
+    updatedAt: string;
+    pluginId: string;
+    score: number;
+    badges?: ("official" | "verified-vendor" | "security-scanned" | "code-signed" | "open-source" | "popular")[] | undefined;
+}>;
 export type PluginTrustScore = z.infer<typeof PluginTrustScoreSchema>;
 export declare const PluginSecurityProtocol: {
-    readonly VulnerabilitySeverity: z.ZodEnum<{
-        info: "info";
-        medium: "medium";
-        critical: "critical";
-        high: "high";
-        low: "low";
-    }>;
+    readonly VulnerabilitySeverity: z.ZodEnum<["critical", "high", "medium", "low", "info"]>;
     readonly SecurityVulnerability: z.ZodObject<{
+        /**
+         * CVE identifier (if applicable)
+         */
         cve: z.ZodOptional<z.ZodString>;
+        /**
+         * Vulnerability identifier (GHSA, SNYK, etc.)
+         */
         id: z.ZodString;
+        /**
+         * Title
+         */
         title: z.ZodString;
+        /**
+         * Description
+         */
         description: z.ZodString;
-        severity: z.ZodEnum<{
-            info: "info";
-            medium: "medium";
-            critical: "critical";
-            high: "high";
-            low: "low";
-        }>;
+        /**
+         * Severity
+         */
+        severity: z.ZodEnum<["critical", "high", "medium", "low", "info"]>;
+        /**
+         * CVSS score (0-10)
+         */
         cvss: z.ZodOptional<z.ZodNumber>;
+        /**
+         * Affected package
+         */
         package: z.ZodObject<{
             name: z.ZodString;
             version: z.ZodString;
             ecosystem: z.ZodOptional<z.ZodString>;
-        }, z.core.$strip>;
+        }, "strip", z.ZodTypeAny, {
+            name: string;
+            version: string;
+            ecosystem?: string | undefined;
+        }, {
+            name: string;
+            version: string;
+            ecosystem?: string | undefined;
+        }>;
+        /**
+         * Vulnerable version range
+         */
         vulnerableVersions: z.ZodString;
+        /**
+         * Patched versions
+         */
         patchedVersions: z.ZodOptional<z.ZodString>;
+        /**
+         * References
+         */
         references: z.ZodDefault<z.ZodArray<z.ZodObject<{
-            type: z.ZodEnum<{
-                advisory: "advisory";
-                article: "article";
-                report: "report";
-                web: "web";
-            }>;
+            type: z.ZodEnum<["advisory", "article", "report", "web"]>;
             url: z.ZodString;
-        }, z.core.$strip>>>;
-        cwe: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        }, "strip", z.ZodTypeAny, {
+            type: "advisory" | "article" | "report" | "web";
+            url: string;
+        }, {
+            type: "advisory" | "article" | "report" | "web";
+            url: string;
+        }>, "many">>;
+        /**
+         * CWE (Common Weakness Enumeration)
+         */
+        cwe: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        /**
+         * Published date
+         */
         publishedAt: z.ZodOptional<z.ZodString>;
+        /**
+         * Mitigation advice
+         */
         mitigation: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>;
+    }, "strip", z.ZodTypeAny, {
+        description: string;
+        severity: "info" | "medium" | "critical" | "high" | "low";
+        id: string;
+        title: string;
+        package: {
+            name: string;
+            version: string;
+            ecosystem?: string | undefined;
+        };
+        references: {
+            type: "advisory" | "article" | "report" | "web";
+            url: string;
+        }[];
+        vulnerableVersions: string;
+        cwe: string[];
+        cve?: string | undefined;
+        publishedAt?: string | undefined;
+        cvss?: number | undefined;
+        patchedVersions?: string | undefined;
+        mitigation?: string | undefined;
+    }, {
+        description: string;
+        severity: "info" | "medium" | "critical" | "high" | "low";
+        id: string;
+        title: string;
+        package: {
+            name: string;
+            version: string;
+            ecosystem?: string | undefined;
+        };
+        vulnerableVersions: string;
+        cve?: string | undefined;
+        references?: {
+            type: "advisory" | "article" | "report" | "web";
+            url: string;
+        }[] | undefined;
+        publishedAt?: string | undefined;
+        cvss?: number | undefined;
+        patchedVersions?: string | undefined;
+        cwe?: string[] | undefined;
+        mitigation?: string | undefined;
+    }>;
     readonly SecurityScanResult: z.ZodObject<{
+        /**
+         * Scan identifier
+         */
         scanId: z.ZodString;
+        /**
+         * Plugin being scanned
+         */
         plugin: z.ZodObject<{
             id: z.ZodString;
             version: z.ZodString;
-        }, z.core.$strip>;
+        }, "strip", z.ZodTypeAny, {
+            version: string;
+            id: string;
+        }, {
+            version: string;
+            id: string;
+        }>;
+        /**
+         * Scan timestamp
+         */
         scannedAt: z.ZodString;
+        /**
+         * Scanner information
+         */
         scanner: z.ZodObject<{
             name: z.ZodString;
             version: z.ZodString;
-        }, z.core.$strip>;
-        status: z.ZodEnum<{
-            warning: "warning";
-            failed: "failed";
-            passed: "passed";
+        }, "strip", z.ZodTypeAny, {
+            name: string;
+            version: string;
+        }, {
+            name: string;
+            version: string;
         }>;
+        /**
+         * Scan status
+         */
+        status: z.ZodEnum<["passed", "failed", "warning"]>;
+        /**
+         * Vulnerabilities found
+         */
         vulnerabilities: z.ZodArray<z.ZodObject<{
+            /**
+             * CVE identifier (if applicable)
+             */
             cve: z.ZodOptional<z.ZodString>;
+            /**
+             * Vulnerability identifier (GHSA, SNYK, etc.)
+             */
             id: z.ZodString;
+            /**
+             * Title
+             */
             title: z.ZodString;
+            /**
+             * Description
+             */
             description: z.ZodString;
-            severity: z.ZodEnum<{
-                info: "info";
-                medium: "medium";
-                critical: "critical";
-                high: "high";
-                low: "low";
-            }>;
+            /**
+             * Severity
+             */
+            severity: z.ZodEnum<["critical", "high", "medium", "low", "info"]>;
+            /**
+             * CVSS score (0-10)
+             */
             cvss: z.ZodOptional<z.ZodNumber>;
+            /**
+             * Affected package
+             */
             package: z.ZodObject<{
                 name: z.ZodString;
                 version: z.ZodString;
                 ecosystem: z.ZodOptional<z.ZodString>;
-            }, z.core.$strip>;
+            }, "strip", z.ZodTypeAny, {
+                name: string;
+                version: string;
+                ecosystem?: string | undefined;
+            }, {
+                name: string;
+                version: string;
+                ecosystem?: string | undefined;
+            }>;
+            /**
+             * Vulnerable version range
+             */
             vulnerableVersions: z.ZodString;
+            /**
+             * Patched versions
+             */
             patchedVersions: z.ZodOptional<z.ZodString>;
+            /**
+             * References
+             */
             references: z.ZodDefault<z.ZodArray<z.ZodObject<{
-                type: z.ZodEnum<{
-                    advisory: "advisory";
-                    article: "article";
-                    report: "report";
-                    web: "web";
-                }>;
+                type: z.ZodEnum<["advisory", "article", "report", "web"]>;
                 url: z.ZodString;
-            }, z.core.$strip>>>;
-            cwe: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            }, "strip", z.ZodTypeAny, {
+                type: "advisory" | "article" | "report" | "web";
+                url: string;
+            }, {
+                type: "advisory" | "article" | "report" | "web";
+                url: string;
+            }>, "many">>;
+            /**
+             * CWE (Common Weakness Enumeration)
+             */
+            cwe: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+            /**
+             * Published date
+             */
             publishedAt: z.ZodOptional<z.ZodString>;
+            /**
+             * Mitigation advice
+             */
             mitigation: z.ZodOptional<z.ZodString>;
-        }, z.core.$strip>>;
+        }, "strip", z.ZodTypeAny, {
+            description: string;
+            severity: "info" | "medium" | "critical" | "high" | "low";
+            id: string;
+            title: string;
+            package: {
+                name: string;
+                version: string;
+                ecosystem?: string | undefined;
+            };
+            references: {
+                type: "advisory" | "article" | "report" | "web";
+                url: string;
+            }[];
+            vulnerableVersions: string;
+            cwe: string[];
+            cve?: string | undefined;
+            publishedAt?: string | undefined;
+            cvss?: number | undefined;
+            patchedVersions?: string | undefined;
+            mitigation?: string | undefined;
+        }, {
+            description: string;
+            severity: "info" | "medium" | "critical" | "high" | "low";
+            id: string;
+            title: string;
+            package: {
+                name: string;
+                version: string;
+                ecosystem?: string | undefined;
+            };
+            vulnerableVersions: string;
+            cve?: string | undefined;
+            references?: {
+                type: "advisory" | "article" | "report" | "web";
+                url: string;
+            }[] | undefined;
+            publishedAt?: string | undefined;
+            cvss?: number | undefined;
+            patchedVersions?: string | undefined;
+            cwe?: string[] | undefined;
+            mitigation?: string | undefined;
+        }>, "many">;
+        /**
+         * Vulnerability summary
+         */
         summary: z.ZodObject<{
             critical: z.ZodDefault<z.ZodNumber>;
             high: z.ZodDefault<z.ZodNumber>;
@@ -642,388 +2455,1819 @@ export declare const PluginSecurityProtocol: {
             low: z.ZodDefault<z.ZodNumber>;
             info: z.ZodDefault<z.ZodNumber>;
             total: z.ZodDefault<z.ZodNumber>;
-        }, z.core.$strip>;
+        }, "strip", z.ZodTypeAny, {
+            info: number;
+            total: number;
+            medium: number;
+            critical: number;
+            high: number;
+            low: number;
+        }, {
+            info?: number | undefined;
+            total?: number | undefined;
+            medium?: number | undefined;
+            critical?: number | undefined;
+            high?: number | undefined;
+            low?: number | undefined;
+        }>;
+        /**
+         * License compliance issues
+         */
         licenseIssues: z.ZodDefault<z.ZodArray<z.ZodObject<{
             package: z.ZodString;
             license: z.ZodString;
             reason: z.ZodString;
-            severity: z.ZodEnum<{
-                error: "error";
-                warning: "warning";
-                info: "info";
-            }>;
-        }, z.core.$strip>>>;
+            severity: z.ZodEnum<["error", "warning", "info"]>;
+        }, "strip", z.ZodTypeAny, {
+            severity: "error" | "warning" | "info";
+            license: string;
+            package: string;
+            reason: string;
+        }, {
+            severity: "error" | "warning" | "info";
+            license: string;
+            package: string;
+            reason: string;
+        }>, "many">>;
+        /**
+         * Code quality issues
+         */
         codeQuality: z.ZodOptional<z.ZodObject<{
             score: z.ZodOptional<z.ZodNumber>;
             issues: z.ZodDefault<z.ZodArray<z.ZodObject<{
-                type: z.ZodEnum<{
-                    style: "style";
-                    security: "security";
-                    quality: "quality";
-                }>;
-                severity: z.ZodEnum<{
-                    error: "error";
-                    warning: "warning";
-                    info: "info";
-                }>;
+                type: z.ZodEnum<["security", "quality", "style"]>;
+                severity: z.ZodEnum<["error", "warning", "info"]>;
                 message: z.ZodString;
                 file: z.ZodOptional<z.ZodString>;
                 line: z.ZodOptional<z.ZodNumber>;
-            }, z.core.$strip>>>;
-        }, z.core.$strip>>;
+            }, "strip", z.ZodTypeAny, {
+                message: string;
+                type: "style" | "security" | "quality";
+                severity: "error" | "warning" | "info";
+                file?: string | undefined;
+                line?: number | undefined;
+            }, {
+                message: string;
+                type: "style" | "security" | "quality";
+                severity: "error" | "warning" | "info";
+                file?: string | undefined;
+                line?: number | undefined;
+            }>, "many">>;
+        }, "strip", z.ZodTypeAny, {
+            issues: {
+                message: string;
+                type: "style" | "security" | "quality";
+                severity: "error" | "warning" | "info";
+                file?: string | undefined;
+                line?: number | undefined;
+            }[];
+            score?: number | undefined;
+        }, {
+            issues?: {
+                message: string;
+                type: "style" | "security" | "quality";
+                severity: "error" | "warning" | "info";
+                file?: string | undefined;
+                line?: number | undefined;
+            }[] | undefined;
+            score?: number | undefined;
+        }>>;
+        /**
+         * Next scan scheduled
+         */
         nextScanAt: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>;
+    }, "strip", z.ZodTypeAny, {
+        status: "warning" | "failed" | "passed";
+        summary: {
+            info: number;
+            total: number;
+            medium: number;
+            critical: number;
+            high: number;
+            low: number;
+        };
+        plugin: {
+            version: string;
+            id: string;
+        };
+        scanner: {
+            name: string;
+            version: string;
+        };
+        vulnerabilities: {
+            description: string;
+            severity: "info" | "medium" | "critical" | "high" | "low";
+            id: string;
+            title: string;
+            package: {
+                name: string;
+                version: string;
+                ecosystem?: string | undefined;
+            };
+            references: {
+                type: "advisory" | "article" | "report" | "web";
+                url: string;
+            }[];
+            vulnerableVersions: string;
+            cwe: string[];
+            cve?: string | undefined;
+            publishedAt?: string | undefined;
+            cvss?: number | undefined;
+            patchedVersions?: string | undefined;
+            mitigation?: string | undefined;
+        }[];
+        scanId: string;
+        scannedAt: string;
+        licenseIssues: {
+            severity: "error" | "warning" | "info";
+            license: string;
+            package: string;
+            reason: string;
+        }[];
+        codeQuality?: {
+            issues: {
+                message: string;
+                type: "style" | "security" | "quality";
+                severity: "error" | "warning" | "info";
+                file?: string | undefined;
+                line?: number | undefined;
+            }[];
+            score?: number | undefined;
+        } | undefined;
+        nextScanAt?: string | undefined;
+    }, {
+        status: "warning" | "failed" | "passed";
+        summary: {
+            info?: number | undefined;
+            total?: number | undefined;
+            medium?: number | undefined;
+            critical?: number | undefined;
+            high?: number | undefined;
+            low?: number | undefined;
+        };
+        plugin: {
+            version: string;
+            id: string;
+        };
+        scanner: {
+            name: string;
+            version: string;
+        };
+        vulnerabilities: {
+            description: string;
+            severity: "info" | "medium" | "critical" | "high" | "low";
+            id: string;
+            title: string;
+            package: {
+                name: string;
+                version: string;
+                ecosystem?: string | undefined;
+            };
+            vulnerableVersions: string;
+            cve?: string | undefined;
+            references?: {
+                type: "advisory" | "article" | "report" | "web";
+                url: string;
+            }[] | undefined;
+            publishedAt?: string | undefined;
+            cvss?: number | undefined;
+            patchedVersions?: string | undefined;
+            cwe?: string[] | undefined;
+            mitigation?: string | undefined;
+        }[];
+        scanId: string;
+        scannedAt: string;
+        codeQuality?: {
+            issues?: {
+                message: string;
+                type: "style" | "security" | "quality";
+                severity: "error" | "warning" | "info";
+                file?: string | undefined;
+                line?: number | undefined;
+            }[] | undefined;
+            score?: number | undefined;
+        } | undefined;
+        licenseIssues?: {
+            severity: "error" | "warning" | "info";
+            license: string;
+            package: string;
+            reason: string;
+        }[] | undefined;
+        nextScanAt?: string | undefined;
+    }>;
     readonly SecurityPolicy: z.ZodObject<{
+        /**
+         * Policy identifier
+         */
         id: z.ZodString;
+        /**
+         * Policy name
+         */
         name: z.ZodString;
+        /**
+         * Automatic scanning
+         */
         autoScan: z.ZodObject<{
             enabled: z.ZodDefault<z.ZodBoolean>;
-            frequency: z.ZodDefault<z.ZodEnum<{
-                daily: "daily";
-                weekly: "weekly";
-                monthly: "monthly";
-                "on-publish": "on-publish";
-            }>>;
-        }, z.core.$strip>;
+            frequency: z.ZodDefault<z.ZodEnum<["on-publish", "daily", "weekly", "monthly"]>>;
+        }, "strip", z.ZodTypeAny, {
+            enabled: boolean;
+            frequency: "daily" | "weekly" | "monthly" | "on-publish";
+        }, {
+            enabled?: boolean | undefined;
+            frequency?: "daily" | "weekly" | "monthly" | "on-publish" | undefined;
+        }>;
+        /**
+         * Vulnerability thresholds
+         */
         thresholds: z.ZodObject<{
+            /**
+             * Block plugin if critical vulnerabilities exceed this
+             */
             maxCritical: z.ZodDefault<z.ZodNumber>;
+            /**
+             * Block plugin if high vulnerabilities exceed this
+             */
             maxHigh: z.ZodDefault<z.ZodNumber>;
+            /**
+             * Warn if medium vulnerabilities exceed this
+             */
             maxMedium: z.ZodDefault<z.ZodNumber>;
-        }, z.core.$strip>;
-        allowedLicenses: z.ZodDefault<z.ZodArray<z.ZodString>>;
-        prohibitedLicenses: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        }, "strip", z.ZodTypeAny, {
+            maxCritical: number;
+            maxHigh: number;
+            maxMedium: number;
+        }, {
+            maxCritical?: number | undefined;
+            maxHigh?: number | undefined;
+            maxMedium?: number | undefined;
+        }>;
+        /**
+         * Allowed licenses
+         */
+        allowedLicenses: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        /**
+         * Prohibited licenses
+         */
+        prohibitedLicenses: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        /**
+         * Code signing requirements
+         */
         codeSigning: z.ZodOptional<z.ZodObject<{
             required: z.ZodDefault<z.ZodBoolean>;
-            allowedSigners: z.ZodDefault<z.ZodArray<z.ZodString>>;
-        }, z.core.$strip>>;
+            allowedSigners: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        }, "strip", z.ZodTypeAny, {
+            required: boolean;
+            allowedSigners: string[];
+        }, {
+            required?: boolean | undefined;
+            allowedSigners?: string[] | undefined;
+        }>>;
+        /**
+         * Sandbox restrictions
+         */
         sandbox: z.ZodOptional<z.ZodObject<{
-            networkAccess: z.ZodDefault<z.ZodEnum<{
-                none: "none";
-                all: "all";
-                localhost: "localhost";
-                allowlist: "allowlist";
-            }>>;
-            allowedDestinations: z.ZodDefault<z.ZodArray<z.ZodString>>;
-            filesystemAccess: z.ZodDefault<z.ZodEnum<{
-                full: "full";
-                none: "none";
-                "read-only": "read-only";
-                "temp-only": "temp-only";
-            }>>;
+            /**
+             * Restrict network access
+             */
+            networkAccess: z.ZodDefault<z.ZodEnum<["none", "localhost", "allowlist", "all"]>>;
+            /**
+             * Allowed network destinations (if allowlist)
+             */
+            allowedDestinations: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+            /**
+             * File system access
+             */
+            filesystemAccess: z.ZodDefault<z.ZodEnum<["none", "read-only", "temp-only", "full"]>>;
+            /**
+             * Maximum memory (MB)
+             */
             maxMemoryMB: z.ZodOptional<z.ZodNumber>;
+            /**
+             * Maximum CPU time (seconds)
+             */
             maxCPUSeconds: z.ZodOptional<z.ZodNumber>;
-        }, z.core.$strip>>;
-    }, z.core.$strip>;
+        }, "strip", z.ZodTypeAny, {
+            networkAccess: "none" | "all" | "localhost" | "allowlist";
+            allowedDestinations: string[];
+            filesystemAccess: "full" | "none" | "read-only" | "temp-only";
+            maxMemoryMB?: number | undefined;
+            maxCPUSeconds?: number | undefined;
+        }, {
+            maxMemoryMB?: number | undefined;
+            networkAccess?: "none" | "all" | "localhost" | "allowlist" | undefined;
+            allowedDestinations?: string[] | undefined;
+            filesystemAccess?: "full" | "none" | "read-only" | "temp-only" | undefined;
+            maxCPUSeconds?: number | undefined;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        id: string;
+        autoScan: {
+            enabled: boolean;
+            frequency: "daily" | "weekly" | "monthly" | "on-publish";
+        };
+        thresholds: {
+            maxCritical: number;
+            maxHigh: number;
+            maxMedium: number;
+        };
+        allowedLicenses: string[];
+        prohibitedLicenses: string[];
+        sandbox?: {
+            networkAccess: "none" | "all" | "localhost" | "allowlist";
+            allowedDestinations: string[];
+            filesystemAccess: "full" | "none" | "read-only" | "temp-only";
+            maxMemoryMB?: number | undefined;
+            maxCPUSeconds?: number | undefined;
+        } | undefined;
+        codeSigning?: {
+            required: boolean;
+            allowedSigners: string[];
+        } | undefined;
+    }, {
+        name: string;
+        id: string;
+        autoScan: {
+            enabled?: boolean | undefined;
+            frequency?: "daily" | "weekly" | "monthly" | "on-publish" | undefined;
+        };
+        thresholds: {
+            maxCritical?: number | undefined;
+            maxHigh?: number | undefined;
+            maxMedium?: number | undefined;
+        };
+        sandbox?: {
+            maxMemoryMB?: number | undefined;
+            networkAccess?: "none" | "all" | "localhost" | "allowlist" | undefined;
+            allowedDestinations?: string[] | undefined;
+            filesystemAccess?: "full" | "none" | "read-only" | "temp-only" | undefined;
+            maxCPUSeconds?: number | undefined;
+        } | undefined;
+        codeSigning?: {
+            required?: boolean | undefined;
+            allowedSigners?: string[] | undefined;
+        } | undefined;
+        allowedLicenses?: string[] | undefined;
+        prohibitedLicenses?: string[] | undefined;
+    }>;
     readonly PackageDependency: z.ZodObject<{
+        /**
+         * Package name/ID
+         */
         name: z.ZodString;
+        /**
+         * Version constraint (semver range)
+         */
         versionConstraint: z.ZodString;
-        type: z.ZodDefault<z.ZodEnum<{
-            optional: "optional";
-            required: "required";
-            dev: "dev";
-            peer: "peer";
-        }>>;
+        /**
+         * Dependency type
+         */
+        type: z.ZodDefault<z.ZodEnum<["required", "optional", "peer", "dev"]>>;
+        /**
+         * Resolved version (filled during resolution)
+         */
         resolvedVersion: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>;
+    }, "strip", z.ZodTypeAny, {
+        type: "required" | "dev" | "optional" | "peer";
+        name: string;
+        versionConstraint: string;
+        resolvedVersion?: string | undefined;
+    }, {
+        name: string;
+        versionConstraint: string;
+        type?: "required" | "dev" | "optional" | "peer" | undefined;
+        resolvedVersion?: string | undefined;
+    }>;
     readonly DependencyGraphNode: z.ZodObject<{
+        /**
+         * Package identifier
+         */
         id: z.ZodString;
+        /**
+         * Package version
+         */
         version: z.ZodString;
+        /**
+         * Dependencies of this package
+         */
         dependencies: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            /**
+             * Package name/ID
+             */
             name: z.ZodString;
+            /**
+             * Version constraint (semver range)
+             */
             versionConstraint: z.ZodString;
-            type: z.ZodDefault<z.ZodEnum<{
-                optional: "optional";
-                required: "required";
-                dev: "dev";
-                peer: "peer";
-            }>>;
+            /**
+             * Dependency type
+             */
+            type: z.ZodDefault<z.ZodEnum<["required", "optional", "peer", "dev"]>>;
+            /**
+             * Resolved version (filled during resolution)
+             */
             resolvedVersion: z.ZodOptional<z.ZodString>;
-        }, z.core.$strip>>>;
+        }, "strip", z.ZodTypeAny, {
+            type: "required" | "dev" | "optional" | "peer";
+            name: string;
+            versionConstraint: string;
+            resolvedVersion?: string | undefined;
+        }, {
+            name: string;
+            versionConstraint: string;
+            type?: "required" | "dev" | "optional" | "peer" | undefined;
+            resolvedVersion?: string | undefined;
+        }>, "many">>;
+        /**
+         * Depth in dependency tree
+         */
         depth: z.ZodNumber;
+        /**
+         * Whether this is a direct dependency
+         */
         isDirect: z.ZodBoolean;
+        /**
+         * Package metadata
+         */
         metadata: z.ZodOptional<z.ZodObject<{
             name: z.ZodString;
             description: z.ZodOptional<z.ZodString>;
             license: z.ZodOptional<z.ZodString>;
             homepage: z.ZodOptional<z.ZodString>;
-        }, z.core.$strip>>;
-    }, z.core.$strip>;
+        }, "strip", z.ZodTypeAny, {
+            name: string;
+            description?: string | undefined;
+            license?: string | undefined;
+            homepage?: string | undefined;
+        }, {
+            name: string;
+            description?: string | undefined;
+            license?: string | undefined;
+            homepage?: string | undefined;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        dependencies: {
+            type: "required" | "dev" | "optional" | "peer";
+            name: string;
+            versionConstraint: string;
+            resolvedVersion?: string | undefined;
+        }[];
+        version: string;
+        id: string;
+        depth: number;
+        isDirect: boolean;
+        metadata?: {
+            name: string;
+            description?: string | undefined;
+            license?: string | undefined;
+            homepage?: string | undefined;
+        } | undefined;
+    }, {
+        version: string;
+        id: string;
+        depth: number;
+        isDirect: boolean;
+        dependencies?: {
+            name: string;
+            versionConstraint: string;
+            type?: "required" | "dev" | "optional" | "peer" | undefined;
+            resolvedVersion?: string | undefined;
+        }[] | undefined;
+        metadata?: {
+            name: string;
+            description?: string | undefined;
+            license?: string | undefined;
+            homepage?: string | undefined;
+        } | undefined;
+    }>;
     readonly DependencyGraph: z.ZodObject<{
+        /**
+         * Root package
+         */
         root: z.ZodObject<{
             id: z.ZodString;
             version: z.ZodString;
-        }, z.core.$strip>;
+        }, "strip", z.ZodTypeAny, {
+            version: string;
+            id: string;
+        }, {
+            version: string;
+            id: string;
+        }>;
+        /**
+         * All nodes in the graph
+         */
         nodes: z.ZodArray<z.ZodObject<{
+            /**
+             * Package identifier
+             */
             id: z.ZodString;
+            /**
+             * Package version
+             */
             version: z.ZodString;
+            /**
+             * Dependencies of this package
+             */
             dependencies: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                /**
+                 * Package name/ID
+                 */
                 name: z.ZodString;
+                /**
+                 * Version constraint (semver range)
+                 */
                 versionConstraint: z.ZodString;
-                type: z.ZodDefault<z.ZodEnum<{
-                    optional: "optional";
-                    required: "required";
-                    dev: "dev";
-                    peer: "peer";
-                }>>;
+                /**
+                 * Dependency type
+                 */
+                type: z.ZodDefault<z.ZodEnum<["required", "optional", "peer", "dev"]>>;
+                /**
+                 * Resolved version (filled during resolution)
+                 */
                 resolvedVersion: z.ZodOptional<z.ZodString>;
-            }, z.core.$strip>>>;
+            }, "strip", z.ZodTypeAny, {
+                type: "required" | "dev" | "optional" | "peer";
+                name: string;
+                versionConstraint: string;
+                resolvedVersion?: string | undefined;
+            }, {
+                name: string;
+                versionConstraint: string;
+                type?: "required" | "dev" | "optional" | "peer" | undefined;
+                resolvedVersion?: string | undefined;
+            }>, "many">>;
+            /**
+             * Depth in dependency tree
+             */
             depth: z.ZodNumber;
+            /**
+             * Whether this is a direct dependency
+             */
             isDirect: z.ZodBoolean;
+            /**
+             * Package metadata
+             */
             metadata: z.ZodOptional<z.ZodObject<{
                 name: z.ZodString;
                 description: z.ZodOptional<z.ZodString>;
                 license: z.ZodOptional<z.ZodString>;
                 homepage: z.ZodOptional<z.ZodString>;
-            }, z.core.$strip>>;
-        }, z.core.$strip>>;
+            }, "strip", z.ZodTypeAny, {
+                name: string;
+                description?: string | undefined;
+                license?: string | undefined;
+                homepage?: string | undefined;
+            }, {
+                name: string;
+                description?: string | undefined;
+                license?: string | undefined;
+                homepage?: string | undefined;
+            }>>;
+        }, "strip", z.ZodTypeAny, {
+            dependencies: {
+                type: "required" | "dev" | "optional" | "peer";
+                name: string;
+                versionConstraint: string;
+                resolvedVersion?: string | undefined;
+            }[];
+            version: string;
+            id: string;
+            depth: number;
+            isDirect: boolean;
+            metadata?: {
+                name: string;
+                description?: string | undefined;
+                license?: string | undefined;
+                homepage?: string | undefined;
+            } | undefined;
+        }, {
+            version: string;
+            id: string;
+            depth: number;
+            isDirect: boolean;
+            dependencies?: {
+                name: string;
+                versionConstraint: string;
+                type?: "required" | "dev" | "optional" | "peer" | undefined;
+                resolvedVersion?: string | undefined;
+            }[] | undefined;
+            metadata?: {
+                name: string;
+                description?: string | undefined;
+                license?: string | undefined;
+                homepage?: string | undefined;
+            } | undefined;
+        }>, "many">;
+        /**
+         * Edges (dependency relationships)
+         */
         edges: z.ZodArray<z.ZodObject<{
             from: z.ZodString;
             to: z.ZodString;
             constraint: z.ZodString;
-        }, z.core.$strip>>;
+        }, "strip", z.ZodTypeAny, {
+            from: string;
+            to: string;
+            constraint: string;
+        }, {
+            from: string;
+            to: string;
+            constraint: string;
+        }>, "many">;
+        /**
+         * Resolution statistics
+         */
         stats: z.ZodObject<{
             totalDependencies: z.ZodNumber;
             directDependencies: z.ZodNumber;
             maxDepth: z.ZodNumber;
-        }, z.core.$strip>;
-    }, z.core.$strip>;
+        }, "strip", z.ZodTypeAny, {
+            totalDependencies: number;
+            directDependencies: number;
+            maxDepth: number;
+        }, {
+            totalDependencies: number;
+            directDependencies: number;
+            maxDepth: number;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        root: {
+            version: string;
+            id: string;
+        };
+        stats: {
+            totalDependencies: number;
+            directDependencies: number;
+            maxDepth: number;
+        };
+        nodes: {
+            dependencies: {
+                type: "required" | "dev" | "optional" | "peer";
+                name: string;
+                versionConstraint: string;
+                resolvedVersion?: string | undefined;
+            }[];
+            version: string;
+            id: string;
+            depth: number;
+            isDirect: boolean;
+            metadata?: {
+                name: string;
+                description?: string | undefined;
+                license?: string | undefined;
+                homepage?: string | undefined;
+            } | undefined;
+        }[];
+        edges: {
+            from: string;
+            to: string;
+            constraint: string;
+        }[];
+    }, {
+        root: {
+            version: string;
+            id: string;
+        };
+        stats: {
+            totalDependencies: number;
+            directDependencies: number;
+            maxDepth: number;
+        };
+        nodes: {
+            version: string;
+            id: string;
+            depth: number;
+            isDirect: boolean;
+            dependencies?: {
+                name: string;
+                versionConstraint: string;
+                type?: "required" | "dev" | "optional" | "peer" | undefined;
+                resolvedVersion?: string | undefined;
+            }[] | undefined;
+            metadata?: {
+                name: string;
+                description?: string | undefined;
+                license?: string | undefined;
+                homepage?: string | undefined;
+            } | undefined;
+        }[];
+        edges: {
+            from: string;
+            to: string;
+            constraint: string;
+        }[];
+    }>;
     readonly DependencyConflict: z.ZodObject<{
+        /**
+         * Package with conflict
+         */
         package: z.ZodString;
+        /**
+         * Conflicting versions
+         */
         conflicts: z.ZodArray<z.ZodObject<{
             version: z.ZodString;
-            requestedBy: z.ZodArray<z.ZodString>;
+            requestedBy: z.ZodArray<z.ZodString, "many">;
             constraint: z.ZodString;
-        }, z.core.$strip>>;
+        }, "strip", z.ZodTypeAny, {
+            version: string;
+            requestedBy: string[];
+            constraint: string;
+        }, {
+            version: string;
+            requestedBy: string[];
+            constraint: string;
+        }>, "many">;
+        /**
+         * Suggested resolution
+         */
         resolution: z.ZodOptional<z.ZodObject<{
-            strategy: z.ZodEnum<{
-                manual: "manual";
-                "pick-highest": "pick-highest";
-                "pick-lowest": "pick-lowest";
-            }>;
+            strategy: z.ZodEnum<["pick-highest", "pick-lowest", "manual"]>;
             version: z.ZodOptional<z.ZodString>;
             reason: z.ZodOptional<z.ZodString>;
-        }, z.core.$strip>>;
-        severity: z.ZodEnum<{
-            error: "error";
-            warning: "warning";
-            info: "info";
-        }>;
-    }, z.core.$strip>;
+        }, "strip", z.ZodTypeAny, {
+            strategy: "manual" | "pick-highest" | "pick-lowest";
+            version?: string | undefined;
+            reason?: string | undefined;
+        }, {
+            strategy: "manual" | "pick-highest" | "pick-lowest";
+            version?: string | undefined;
+            reason?: string | undefined;
+        }>>;
+        /**
+         * Severity
+         */
+        severity: z.ZodEnum<["error", "warning", "info"]>;
+    }, "strip", z.ZodTypeAny, {
+        severity: "error" | "warning" | "info";
+        package: string;
+        conflicts: {
+            version: string;
+            requestedBy: string[];
+            constraint: string;
+        }[];
+        resolution?: {
+            strategy: "manual" | "pick-highest" | "pick-lowest";
+            version?: string | undefined;
+            reason?: string | undefined;
+        } | undefined;
+    }, {
+        severity: "error" | "warning" | "info";
+        package: string;
+        conflicts: {
+            version: string;
+            requestedBy: string[];
+            constraint: string;
+        }[];
+        resolution?: {
+            strategy: "manual" | "pick-highest" | "pick-lowest";
+            version?: string | undefined;
+            reason?: string | undefined;
+        } | undefined;
+    }>;
     readonly DependencyResolutionResult: z.ZodObject<{
-        status: z.ZodEnum<{
-            error: "error";
-            success: "success";
-            conflict: "conflict";
-        }>;
+        /**
+         * Resolution status
+         */
+        status: z.ZodEnum<["success", "conflict", "error"]>;
+        /**
+         * Resolved dependency graph
+         */
         graph: z.ZodOptional<z.ZodObject<{
+            /**
+             * Root package
+             */
             root: z.ZodObject<{
                 id: z.ZodString;
                 version: z.ZodString;
-            }, z.core.$strip>;
+            }, "strip", z.ZodTypeAny, {
+                version: string;
+                id: string;
+            }, {
+                version: string;
+                id: string;
+            }>;
+            /**
+             * All nodes in the graph
+             */
             nodes: z.ZodArray<z.ZodObject<{
+                /**
+                 * Package identifier
+                 */
                 id: z.ZodString;
+                /**
+                 * Package version
+                 */
                 version: z.ZodString;
+                /**
+                 * Dependencies of this package
+                 */
                 dependencies: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                    /**
+                     * Package name/ID
+                     */
                     name: z.ZodString;
+                    /**
+                     * Version constraint (semver range)
+                     */
                     versionConstraint: z.ZodString;
-                    type: z.ZodDefault<z.ZodEnum<{
-                        optional: "optional";
-                        required: "required";
-                        dev: "dev";
-                        peer: "peer";
-                    }>>;
+                    /**
+                     * Dependency type
+                     */
+                    type: z.ZodDefault<z.ZodEnum<["required", "optional", "peer", "dev"]>>;
+                    /**
+                     * Resolved version (filled during resolution)
+                     */
                     resolvedVersion: z.ZodOptional<z.ZodString>;
-                }, z.core.$strip>>>;
+                }, "strip", z.ZodTypeAny, {
+                    type: "required" | "dev" | "optional" | "peer";
+                    name: string;
+                    versionConstraint: string;
+                    resolvedVersion?: string | undefined;
+                }, {
+                    name: string;
+                    versionConstraint: string;
+                    type?: "required" | "dev" | "optional" | "peer" | undefined;
+                    resolvedVersion?: string | undefined;
+                }>, "many">>;
+                /**
+                 * Depth in dependency tree
+                 */
                 depth: z.ZodNumber;
+                /**
+                 * Whether this is a direct dependency
+                 */
                 isDirect: z.ZodBoolean;
+                /**
+                 * Package metadata
+                 */
                 metadata: z.ZodOptional<z.ZodObject<{
                     name: z.ZodString;
                     description: z.ZodOptional<z.ZodString>;
                     license: z.ZodOptional<z.ZodString>;
                     homepage: z.ZodOptional<z.ZodString>;
-                }, z.core.$strip>>;
-            }, z.core.$strip>>;
+                }, "strip", z.ZodTypeAny, {
+                    name: string;
+                    description?: string | undefined;
+                    license?: string | undefined;
+                    homepage?: string | undefined;
+                }, {
+                    name: string;
+                    description?: string | undefined;
+                    license?: string | undefined;
+                    homepage?: string | undefined;
+                }>>;
+            }, "strip", z.ZodTypeAny, {
+                dependencies: {
+                    type: "required" | "dev" | "optional" | "peer";
+                    name: string;
+                    versionConstraint: string;
+                    resolvedVersion?: string | undefined;
+                }[];
+                version: string;
+                id: string;
+                depth: number;
+                isDirect: boolean;
+                metadata?: {
+                    name: string;
+                    description?: string | undefined;
+                    license?: string | undefined;
+                    homepage?: string | undefined;
+                } | undefined;
+            }, {
+                version: string;
+                id: string;
+                depth: number;
+                isDirect: boolean;
+                dependencies?: {
+                    name: string;
+                    versionConstraint: string;
+                    type?: "required" | "dev" | "optional" | "peer" | undefined;
+                    resolvedVersion?: string | undefined;
+                }[] | undefined;
+                metadata?: {
+                    name: string;
+                    description?: string | undefined;
+                    license?: string | undefined;
+                    homepage?: string | undefined;
+                } | undefined;
+            }>, "many">;
+            /**
+             * Edges (dependency relationships)
+             */
             edges: z.ZodArray<z.ZodObject<{
                 from: z.ZodString;
                 to: z.ZodString;
                 constraint: z.ZodString;
-            }, z.core.$strip>>;
+            }, "strip", z.ZodTypeAny, {
+                from: string;
+                to: string;
+                constraint: string;
+            }, {
+                from: string;
+                to: string;
+                constraint: string;
+            }>, "many">;
+            /**
+             * Resolution statistics
+             */
             stats: z.ZodObject<{
                 totalDependencies: z.ZodNumber;
                 directDependencies: z.ZodNumber;
                 maxDepth: z.ZodNumber;
-            }, z.core.$strip>;
-        }, z.core.$strip>>;
+            }, "strip", z.ZodTypeAny, {
+                totalDependencies: number;
+                directDependencies: number;
+                maxDepth: number;
+            }, {
+                totalDependencies: number;
+                directDependencies: number;
+                maxDepth: number;
+            }>;
+        }, "strip", z.ZodTypeAny, {
+            root: {
+                version: string;
+                id: string;
+            };
+            stats: {
+                totalDependencies: number;
+                directDependencies: number;
+                maxDepth: number;
+            };
+            nodes: {
+                dependencies: {
+                    type: "required" | "dev" | "optional" | "peer";
+                    name: string;
+                    versionConstraint: string;
+                    resolvedVersion?: string | undefined;
+                }[];
+                version: string;
+                id: string;
+                depth: number;
+                isDirect: boolean;
+                metadata?: {
+                    name: string;
+                    description?: string | undefined;
+                    license?: string | undefined;
+                    homepage?: string | undefined;
+                } | undefined;
+            }[];
+            edges: {
+                from: string;
+                to: string;
+                constraint: string;
+            }[];
+        }, {
+            root: {
+                version: string;
+                id: string;
+            };
+            stats: {
+                totalDependencies: number;
+                directDependencies: number;
+                maxDepth: number;
+            };
+            nodes: {
+                version: string;
+                id: string;
+                depth: number;
+                isDirect: boolean;
+                dependencies?: {
+                    name: string;
+                    versionConstraint: string;
+                    type?: "required" | "dev" | "optional" | "peer" | undefined;
+                    resolvedVersion?: string | undefined;
+                }[] | undefined;
+                metadata?: {
+                    name: string;
+                    description?: string | undefined;
+                    license?: string | undefined;
+                    homepage?: string | undefined;
+                } | undefined;
+            }[];
+            edges: {
+                from: string;
+                to: string;
+                constraint: string;
+            }[];
+        }>>;
+        /**
+         * Conflicts detected
+         */
         conflicts: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            /**
+             * Package with conflict
+             */
             package: z.ZodString;
+            /**
+             * Conflicting versions
+             */
             conflicts: z.ZodArray<z.ZodObject<{
                 version: z.ZodString;
-                requestedBy: z.ZodArray<z.ZodString>;
+                requestedBy: z.ZodArray<z.ZodString, "many">;
                 constraint: z.ZodString;
-            }, z.core.$strip>>;
+            }, "strip", z.ZodTypeAny, {
+                version: string;
+                requestedBy: string[];
+                constraint: string;
+            }, {
+                version: string;
+                requestedBy: string[];
+                constraint: string;
+            }>, "many">;
+            /**
+             * Suggested resolution
+             */
             resolution: z.ZodOptional<z.ZodObject<{
-                strategy: z.ZodEnum<{
-                    manual: "manual";
-                    "pick-highest": "pick-highest";
-                    "pick-lowest": "pick-lowest";
-                }>;
+                strategy: z.ZodEnum<["pick-highest", "pick-lowest", "manual"]>;
                 version: z.ZodOptional<z.ZodString>;
                 reason: z.ZodOptional<z.ZodString>;
-            }, z.core.$strip>>;
-            severity: z.ZodEnum<{
-                error: "error";
-                warning: "warning";
-                info: "info";
-            }>;
-        }, z.core.$strip>>>;
+            }, "strip", z.ZodTypeAny, {
+                strategy: "manual" | "pick-highest" | "pick-lowest";
+                version?: string | undefined;
+                reason?: string | undefined;
+            }, {
+                strategy: "manual" | "pick-highest" | "pick-lowest";
+                version?: string | undefined;
+                reason?: string | undefined;
+            }>>;
+            /**
+             * Severity
+             */
+            severity: z.ZodEnum<["error", "warning", "info"]>;
+        }, "strip", z.ZodTypeAny, {
+            severity: "error" | "warning" | "info";
+            package: string;
+            conflicts: {
+                version: string;
+                requestedBy: string[];
+                constraint: string;
+            }[];
+            resolution?: {
+                strategy: "manual" | "pick-highest" | "pick-lowest";
+                version?: string | undefined;
+                reason?: string | undefined;
+            } | undefined;
+        }, {
+            severity: "error" | "warning" | "info";
+            package: string;
+            conflicts: {
+                version: string;
+                requestedBy: string[];
+                constraint: string;
+            }[];
+            resolution?: {
+                strategy: "manual" | "pick-highest" | "pick-lowest";
+                version?: string | undefined;
+                reason?: string | undefined;
+            } | undefined;
+        }>, "many">>;
+        /**
+         * Errors encountered
+         */
         errors: z.ZodDefault<z.ZodArray<z.ZodObject<{
             package: z.ZodString;
             error: z.ZodString;
-        }, z.core.$strip>>>;
-        installOrder: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        }, "strip", z.ZodTypeAny, {
+            error: string;
+            package: string;
+        }, {
+            error: string;
+            package: string;
+        }>, "many">>;
+        /**
+         * Installation order (topological sort)
+         */
+        installOrder: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        /**
+         * Resolution time (ms)
+         */
         resolvedIn: z.ZodOptional<z.ZodNumber>;
-    }, z.core.$strip>;
+    }, "strip", z.ZodTypeAny, {
+        status: "error" | "success" | "conflict";
+        errors: {
+            error: string;
+            package: string;
+        }[];
+        conflicts: {
+            severity: "error" | "warning" | "info";
+            package: string;
+            conflicts: {
+                version: string;
+                requestedBy: string[];
+                constraint: string;
+            }[];
+            resolution?: {
+                strategy: "manual" | "pick-highest" | "pick-lowest";
+                version?: string | undefined;
+                reason?: string | undefined;
+            } | undefined;
+        }[];
+        installOrder: string[];
+        graph?: {
+            root: {
+                version: string;
+                id: string;
+            };
+            stats: {
+                totalDependencies: number;
+                directDependencies: number;
+                maxDepth: number;
+            };
+            nodes: {
+                dependencies: {
+                    type: "required" | "dev" | "optional" | "peer";
+                    name: string;
+                    versionConstraint: string;
+                    resolvedVersion?: string | undefined;
+                }[];
+                version: string;
+                id: string;
+                depth: number;
+                isDirect: boolean;
+                metadata?: {
+                    name: string;
+                    description?: string | undefined;
+                    license?: string | undefined;
+                    homepage?: string | undefined;
+                } | undefined;
+            }[];
+            edges: {
+                from: string;
+                to: string;
+                constraint: string;
+            }[];
+        } | undefined;
+        resolvedIn?: number | undefined;
+    }, {
+        status: "error" | "success" | "conflict";
+        graph?: {
+            root: {
+                version: string;
+                id: string;
+            };
+            stats: {
+                totalDependencies: number;
+                directDependencies: number;
+                maxDepth: number;
+            };
+            nodes: {
+                version: string;
+                id: string;
+                depth: number;
+                isDirect: boolean;
+                dependencies?: {
+                    name: string;
+                    versionConstraint: string;
+                    type?: "required" | "dev" | "optional" | "peer" | undefined;
+                    resolvedVersion?: string | undefined;
+                }[] | undefined;
+                metadata?: {
+                    name: string;
+                    description?: string | undefined;
+                    license?: string | undefined;
+                    homepage?: string | undefined;
+                } | undefined;
+            }[];
+            edges: {
+                from: string;
+                to: string;
+                constraint: string;
+            }[];
+        } | undefined;
+        errors?: {
+            error: string;
+            package: string;
+        }[] | undefined;
+        conflicts?: {
+            severity: "error" | "warning" | "info";
+            package: string;
+            conflicts: {
+                version: string;
+                requestedBy: string[];
+                constraint: string;
+            }[];
+            resolution?: {
+                strategy: "manual" | "pick-highest" | "pick-lowest";
+                version?: string | undefined;
+                reason?: string | undefined;
+            } | undefined;
+        }[] | undefined;
+        installOrder?: string[] | undefined;
+        resolvedIn?: number | undefined;
+    }>;
     readonly SBOMEntry: z.ZodObject<{
+        /**
+         * Component name
+         */
         name: z.ZodString;
+        /**
+         * Component version
+         */
         version: z.ZodString;
+        /**
+         * Package URL (purl)
+         */
         purl: z.ZodOptional<z.ZodString>;
+        /**
+         * License
+         */
         license: z.ZodOptional<z.ZodString>;
+        /**
+         * Hashes
+         */
         hashes: z.ZodOptional<z.ZodObject<{
             sha256: z.ZodOptional<z.ZodString>;
             sha512: z.ZodOptional<z.ZodString>;
-        }, z.core.$strip>>;
+        }, "strip", z.ZodTypeAny, {
+            sha256?: string | undefined;
+            sha512?: string | undefined;
+        }, {
+            sha256?: string | undefined;
+            sha512?: string | undefined;
+        }>>;
+        /**
+         * Supplier
+         */
         supplier: z.ZodOptional<z.ZodObject<{
             name: z.ZodString;
             url: z.ZodOptional<z.ZodString>;
-        }, z.core.$strip>>;
+        }, "strip", z.ZodTypeAny, {
+            name: string;
+            url?: string | undefined;
+        }, {
+            name: string;
+            url?: string | undefined;
+        }>>;
+        /**
+         * External references
+         */
         externalRefs: z.ZodDefault<z.ZodArray<z.ZodObject<{
-            type: z.ZodEnum<{
-                documentation: "documentation";
-                repository: "repository";
-                website: "website";
-                "issue-tracker": "issue-tracker";
-            }>;
+            type: z.ZodEnum<["website", "repository", "documentation", "issue-tracker"]>;
             url: z.ZodString;
-        }, z.core.$strip>>>;
-    }, z.core.$strip>;
+        }, "strip", z.ZodTypeAny, {
+            type: "documentation" | "website" | "repository" | "issue-tracker";
+            url: string;
+        }, {
+            type: "documentation" | "website" | "repository" | "issue-tracker";
+            url: string;
+        }>, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        version: string;
+        externalRefs: {
+            type: "documentation" | "website" | "repository" | "issue-tracker";
+            url: string;
+        }[];
+        license?: string | undefined;
+        purl?: string | undefined;
+        hashes?: {
+            sha256?: string | undefined;
+            sha512?: string | undefined;
+        } | undefined;
+        supplier?: {
+            name: string;
+            url?: string | undefined;
+        } | undefined;
+    }, {
+        name: string;
+        version: string;
+        license?: string | undefined;
+        purl?: string | undefined;
+        hashes?: {
+            sha256?: string | undefined;
+            sha512?: string | undefined;
+        } | undefined;
+        supplier?: {
+            name: string;
+            url?: string | undefined;
+        } | undefined;
+        externalRefs?: {
+            type: "documentation" | "website" | "repository" | "issue-tracker";
+            url: string;
+        }[] | undefined;
+    }>;
     readonly SBOM: z.ZodObject<{
-        format: z.ZodDefault<z.ZodEnum<{
-            spdx: "spdx";
-            cyclonedx: "cyclonedx";
-        }>>;
+        /**
+         * SBOM format
+         */
+        format: z.ZodDefault<z.ZodEnum<["spdx", "cyclonedx"]>>;
+        /**
+         * SBOM version
+         */
         version: z.ZodString;
+        /**
+         * Plugin metadata
+         */
         plugin: z.ZodObject<{
             id: z.ZodString;
             version: z.ZodString;
             name: z.ZodString;
-        }, z.core.$strip>;
+        }, "strip", z.ZodTypeAny, {
+            name: string;
+            version: string;
+            id: string;
+        }, {
+            name: string;
+            version: string;
+            id: string;
+        }>;
+        /**
+         * Components (dependencies)
+         */
         components: z.ZodArray<z.ZodObject<{
+            /**
+             * Component name
+             */
             name: z.ZodString;
+            /**
+             * Component version
+             */
             version: z.ZodString;
+            /**
+             * Package URL (purl)
+             */
             purl: z.ZodOptional<z.ZodString>;
+            /**
+             * License
+             */
             license: z.ZodOptional<z.ZodString>;
+            /**
+             * Hashes
+             */
             hashes: z.ZodOptional<z.ZodObject<{
                 sha256: z.ZodOptional<z.ZodString>;
                 sha512: z.ZodOptional<z.ZodString>;
-            }, z.core.$strip>>;
+            }, "strip", z.ZodTypeAny, {
+                sha256?: string | undefined;
+                sha512?: string | undefined;
+            }, {
+                sha256?: string | undefined;
+                sha512?: string | undefined;
+            }>>;
+            /**
+             * Supplier
+             */
             supplier: z.ZodOptional<z.ZodObject<{
                 name: z.ZodString;
                 url: z.ZodOptional<z.ZodString>;
-            }, z.core.$strip>>;
+            }, "strip", z.ZodTypeAny, {
+                name: string;
+                url?: string | undefined;
+            }, {
+                name: string;
+                url?: string | undefined;
+            }>>;
+            /**
+             * External references
+             */
             externalRefs: z.ZodDefault<z.ZodArray<z.ZodObject<{
-                type: z.ZodEnum<{
-                    documentation: "documentation";
-                    repository: "repository";
-                    website: "website";
-                    "issue-tracker": "issue-tracker";
-                }>;
+                type: z.ZodEnum<["website", "repository", "documentation", "issue-tracker"]>;
                 url: z.ZodString;
-            }, z.core.$strip>>>;
-        }, z.core.$strip>>;
+            }, "strip", z.ZodTypeAny, {
+                type: "documentation" | "website" | "repository" | "issue-tracker";
+                url: string;
+            }, {
+                type: "documentation" | "website" | "repository" | "issue-tracker";
+                url: string;
+            }>, "many">>;
+        }, "strip", z.ZodTypeAny, {
+            name: string;
+            version: string;
+            externalRefs: {
+                type: "documentation" | "website" | "repository" | "issue-tracker";
+                url: string;
+            }[];
+            license?: string | undefined;
+            purl?: string | undefined;
+            hashes?: {
+                sha256?: string | undefined;
+                sha512?: string | undefined;
+            } | undefined;
+            supplier?: {
+                name: string;
+                url?: string | undefined;
+            } | undefined;
+        }, {
+            name: string;
+            version: string;
+            license?: string | undefined;
+            purl?: string | undefined;
+            hashes?: {
+                sha256?: string | undefined;
+                sha512?: string | undefined;
+            } | undefined;
+            supplier?: {
+                name: string;
+                url?: string | undefined;
+            } | undefined;
+            externalRefs?: {
+                type: "documentation" | "website" | "repository" | "issue-tracker";
+                url: string;
+            }[] | undefined;
+        }>, "many">;
+        /**
+         * Generation timestamp
+         */
         generatedAt: z.ZodString;
+        /**
+         * Generator tool
+         */
         generator: z.ZodOptional<z.ZodObject<{
             name: z.ZodString;
             version: z.ZodString;
-        }, z.core.$strip>>;
-    }, z.core.$strip>;
+        }, "strip", z.ZodTypeAny, {
+            name: string;
+            version: string;
+        }, {
+            name: string;
+            version: string;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        format: "spdx" | "cyclonedx";
+        version: string;
+        components: {
+            name: string;
+            version: string;
+            externalRefs: {
+                type: "documentation" | "website" | "repository" | "issue-tracker";
+                url: string;
+            }[];
+            license?: string | undefined;
+            purl?: string | undefined;
+            hashes?: {
+                sha256?: string | undefined;
+                sha512?: string | undefined;
+            } | undefined;
+            supplier?: {
+                name: string;
+                url?: string | undefined;
+            } | undefined;
+        }[];
+        plugin: {
+            name: string;
+            version: string;
+            id: string;
+        };
+        generatedAt: string;
+        generator?: {
+            name: string;
+            version: string;
+        } | undefined;
+    }, {
+        version: string;
+        components: {
+            name: string;
+            version: string;
+            license?: string | undefined;
+            purl?: string | undefined;
+            hashes?: {
+                sha256?: string | undefined;
+                sha512?: string | undefined;
+            } | undefined;
+            supplier?: {
+                name: string;
+                url?: string | undefined;
+            } | undefined;
+            externalRefs?: {
+                type: "documentation" | "website" | "repository" | "issue-tracker";
+                url: string;
+            }[] | undefined;
+        }[];
+        plugin: {
+            name: string;
+            version: string;
+            id: string;
+        };
+        generatedAt: string;
+        format?: "spdx" | "cyclonedx" | undefined;
+        generator?: {
+            name: string;
+            version: string;
+        } | undefined;
+    }>;
     readonly PluginProvenance: z.ZodObject<{
+        /**
+         * Plugin identifier
+         */
         pluginId: z.ZodString;
+        /**
+         * Plugin version
+         */
         version: z.ZodString;
+        /**
+         * Build information
+         */
         build: z.ZodObject<{
+            /**
+             * Build timestamp
+             */
             timestamp: z.ZodString;
+            /**
+             * Build environment
+             */
             environment: z.ZodOptional<z.ZodObject<{
                 os: z.ZodString;
                 arch: z.ZodString;
                 nodeVersion: z.ZodString;
-            }, z.core.$strip>>;
+            }, "strip", z.ZodTypeAny, {
+                os: string;
+                nodeVersion: string;
+                arch: string;
+            }, {
+                os: string;
+                nodeVersion: string;
+                arch: string;
+            }>>;
+            /**
+             * Source repository
+             */
             source: z.ZodOptional<z.ZodObject<{
                 repository: z.ZodString;
                 commit: z.ZodString;
                 branch: z.ZodOptional<z.ZodString>;
                 tag: z.ZodOptional<z.ZodString>;
-            }, z.core.$strip>>;
+            }, "strip", z.ZodTypeAny, {
+                commit: string;
+                repository: string;
+                tag?: string | undefined;
+                branch?: string | undefined;
+            }, {
+                commit: string;
+                repository: string;
+                tag?: string | undefined;
+                branch?: string | undefined;
+            }>>;
+            /**
+             * Builder identity
+             */
             builder: z.ZodOptional<z.ZodObject<{
                 name: z.ZodString;
                 email: z.ZodOptional<z.ZodString>;
-            }, z.core.$strip>>;
-        }, z.core.$strip>;
+            }, "strip", z.ZodTypeAny, {
+                name: string;
+                email?: string | undefined;
+            }, {
+                name: string;
+                email?: string | undefined;
+            }>>;
+        }, "strip", z.ZodTypeAny, {
+            timestamp: string;
+            source?: {
+                commit: string;
+                repository: string;
+                tag?: string | undefined;
+                branch?: string | undefined;
+            } | undefined;
+            environment?: {
+                os: string;
+                nodeVersion: string;
+                arch: string;
+            } | undefined;
+            builder?: {
+                name: string;
+                email?: string | undefined;
+            } | undefined;
+        }, {
+            timestamp: string;
+            source?: {
+                commit: string;
+                repository: string;
+                tag?: string | undefined;
+                branch?: string | undefined;
+            } | undefined;
+            environment?: {
+                os: string;
+                nodeVersion: string;
+                arch: string;
+            } | undefined;
+            builder?: {
+                name: string;
+                email?: string | undefined;
+            } | undefined;
+        }>;
+        /**
+         * Artifact hashes
+         */
         artifacts: z.ZodArray<z.ZodObject<{
             filename: z.ZodString;
             sha256: z.ZodString;
             size: z.ZodNumber;
-        }, z.core.$strip>>;
+        }, "strip", z.ZodTypeAny, {
+            size: number;
+            sha256: string;
+            filename: string;
+        }, {
+            size: number;
+            sha256: string;
+            filename: string;
+        }>, "many">;
+        /**
+         * Signatures
+         */
         signatures: z.ZodDefault<z.ZodArray<z.ZodObject<{
-            algorithm: z.ZodEnum<{
-                rsa: "rsa";
-                ecdsa: "ecdsa";
-                ed25519: "ed25519";
-            }>;
+            algorithm: z.ZodEnum<["rsa", "ecdsa", "ed25519"]>;
             publicKey: z.ZodString;
             signature: z.ZodString;
             signedBy: z.ZodString;
             timestamp: z.ZodString;
-        }, z.core.$strip>>>;
+        }, "strip", z.ZodTypeAny, {
+            algorithm: "rsa" | "ecdsa" | "ed25519";
+            signature: string;
+            timestamp: string;
+            publicKey: string;
+            signedBy: string;
+        }, {
+            algorithm: "rsa" | "ecdsa" | "ed25519";
+            signature: string;
+            timestamp: string;
+            publicKey: string;
+            signedBy: string;
+        }>, "many">>;
+        /**
+         * Attestations
+         */
         attestations: z.ZodDefault<z.ZodArray<z.ZodObject<{
-            type: z.ZodEnum<{
-                "code-review": "code-review";
-                "security-scan": "security-scan";
-                "test-results": "test-results";
-                "ci-build": "ci-build";
-            }>;
-            status: z.ZodEnum<{
-                failed: "failed";
-                passed: "passed";
-            }>;
+            type: z.ZodEnum<["code-review", "security-scan", "test-results", "ci-build"]>;
+            status: z.ZodEnum<["passed", "failed"]>;
             url: z.ZodOptional<z.ZodString>;
             timestamp: z.ZodString;
-        }, z.core.$strip>>>;
-    }, z.core.$strip>;
+        }, "strip", z.ZodTypeAny, {
+            type: "code-review" | "security-scan" | "test-results" | "ci-build";
+            status: "failed" | "passed";
+            timestamp: string;
+            url?: string | undefined;
+        }, {
+            type: "code-review" | "security-scan" | "test-results" | "ci-build";
+            status: "failed" | "passed";
+            timestamp: string;
+            url?: string | undefined;
+        }>, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        version: string;
+        pluginId: string;
+        build: {
+            timestamp: string;
+            source?: {
+                commit: string;
+                repository: string;
+                tag?: string | undefined;
+                branch?: string | undefined;
+            } | undefined;
+            environment?: {
+                os: string;
+                nodeVersion: string;
+                arch: string;
+            } | undefined;
+            builder?: {
+                name: string;
+                email?: string | undefined;
+            } | undefined;
+        };
+        artifacts: {
+            size: number;
+            sha256: string;
+            filename: string;
+        }[];
+        signatures: {
+            algorithm: "rsa" | "ecdsa" | "ed25519";
+            signature: string;
+            timestamp: string;
+            publicKey: string;
+            signedBy: string;
+        }[];
+        attestations: {
+            type: "code-review" | "security-scan" | "test-results" | "ci-build";
+            status: "failed" | "passed";
+            timestamp: string;
+            url?: string | undefined;
+        }[];
+    }, {
+        version: string;
+        pluginId: string;
+        build: {
+            timestamp: string;
+            source?: {
+                commit: string;
+                repository: string;
+                tag?: string | undefined;
+                branch?: string | undefined;
+            } | undefined;
+            environment?: {
+                os: string;
+                nodeVersion: string;
+                arch: string;
+            } | undefined;
+            builder?: {
+                name: string;
+                email?: string | undefined;
+            } | undefined;
+        };
+        artifacts: {
+            size: number;
+            sha256: string;
+            filename: string;
+        }[];
+        signatures?: {
+            algorithm: "rsa" | "ecdsa" | "ed25519";
+            signature: string;
+            timestamp: string;
+            publicKey: string;
+            signedBy: string;
+        }[] | undefined;
+        attestations?: {
+            type: "code-review" | "security-scan" | "test-results" | "ci-build";
+            status: "failed" | "passed";
+            timestamp: string;
+            url?: string | undefined;
+        }[] | undefined;
+    }>;
     readonly PluginTrustScore: z.ZodObject<{
+        /**
+         * Plugin identifier
+         */
         pluginId: z.ZodString;
+        /**
+         * Overall trust score (0-100)
+         */
         score: z.ZodNumber;
+        /**
+         * Score components
+         */
         components: z.ZodObject<{
+            /**
+             * Vendor reputation (0-100)
+             */
             vendorReputation: z.ZodNumber;
+            /**
+             * Security scan results (0-100)
+             */
             securityScore: z.ZodNumber;
+            /**
+             * Code quality (0-100)
+             */
             codeQuality: z.ZodNumber;
+            /**
+             * Community engagement (0-100)
+             */
             communityScore: z.ZodNumber;
+            /**
+             * Update frequency (0-100)
+             */
             maintenanceScore: z.ZodNumber;
-        }, z.core.$strip>;
-        level: z.ZodEnum<{
-            verified: "verified";
-            trusted: "trusted";
-            untrusted: "untrusted";
-            blocked: "blocked";
-            neutral: "neutral";
+        }, "strip", z.ZodTypeAny, {
+            codeQuality: number;
+            vendorReputation: number;
+            securityScore: number;
+            communityScore: number;
+            maintenanceScore: number;
+        }, {
+            codeQuality: number;
+            vendorReputation: number;
+            securityScore: number;
+            communityScore: number;
+            maintenanceScore: number;
         }>;
-        badges: z.ZodDefault<z.ZodArray<z.ZodEnum<{
-            "open-source": "open-source";
-            official: "official";
-            "verified-vendor": "verified-vendor";
-            "security-scanned": "security-scanned";
-            "code-signed": "code-signed";
-            popular: "popular";
-        }>>>;
+        /**
+         * Trust level
+         */
+        level: z.ZodEnum<["verified", "trusted", "neutral", "untrusted", "blocked"]>;
+        /**
+         * Verification badges
+         */
+        badges: z.ZodDefault<z.ZodArray<z.ZodEnum<["official", "verified-vendor", "security-scanned", "code-signed", "open-source", "popular"]>, "many">>;
+        /**
+         * Last updated
+         */
         updatedAt: z.ZodString;
-    }, z.core.$strip>;
+    }, "strip", z.ZodTypeAny, {
+        components: {
+            codeQuality: number;
+            vendorReputation: number;
+            securityScore: number;
+            communityScore: number;
+            maintenanceScore: number;
+        };
+        level: "verified" | "trusted" | "untrusted" | "blocked" | "neutral";
+        updatedAt: string;
+        pluginId: string;
+        score: number;
+        badges: ("official" | "verified-vendor" | "security-scanned" | "code-signed" | "open-source" | "popular")[];
+    }, {
+        components: {
+            codeQuality: number;
+            vendorReputation: number;
+            securityScore: number;
+            communityScore: number;
+            maintenanceScore: number;
+        };
+        level: "verified" | "trusted" | "untrusted" | "blocked" | "neutral";
+        updatedAt: string;
+        pluginId: string;
+        score: number;
+        badges?: ("official" | "verified-vendor" | "security-scanned" | "code-signed" | "open-source" | "popular")[] | undefined;
+    }>;
 };
 //# sourceMappingURL=plugin-security.zod.d.ts.map