@defai.digital/contracts 13.0.3

package/dist/ml-lifecycle/v1/schema.d.ts

@@ -0,0 +1,1207 @@
+/**
+ * ML Lifecycle Contract V1 - Schema Definitions
+ *
+ * Defines schemas for machine learning lifecycle management:
+ * - Experiment tracking
+ * - Model registration
+ * - Model monitoring
+ * - Drift detection
+ * - A/B testing
+ */
+import { z } from 'zod';
+/**
+ * ML experiment status
+ */
+export declare const ExperimentStatusSchema: z.ZodEnum<["running", "completed", "failed", "promoted", "rejected", "archived"]>;
+/**
+ * Experiment hyperparameter value
+ */
+export declare const HyperparameterValueSchema: z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodNumber]>, "many">]>;
+/**
+ * ML experiment definition
+ */
+export declare const MLExperimentSchema: z.ZodObject<{
+    experimentId: z.ZodString;
+    experimentName: z.ZodString;
+    hypothesis: z.ZodString;
+    modelType: z.ZodString;
+    hyperparameters: z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodNumber]>, "many">]>>;
+    datasetVersion: z.ZodString;
+    baselineModel: z.ZodOptional<z.ZodString>;
+    successCriteria: z.ZodString;
+    status: z.ZodEnum<["running", "completed", "failed", "promoted", "rejected", "archived"]>;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodOptional<z.ZodString>;
+    createdBy: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    status: "completed" | "failed" | "running" | "promoted" | "rejected" | "archived";
+    createdAt: string;
+    experimentId: string;
+    experimentName: string;
+    hypothesis: string;
+    modelType: string;
+    hyperparameters: Record<string, string | number | boolean | (string | number)[]>;
+    datasetVersion: string;
+    successCriteria: string;
+    createdBy: string;
+    updatedAt?: string | undefined;
+    baselineModel?: string | undefined;
+}, {
+    status: "completed" | "failed" | "running" | "promoted" | "rejected" | "archived";
+    createdAt: string;
+    experimentId: string;
+    experimentName: string;
+    hypothesis: string;
+    modelType: string;
+    hyperparameters: Record<string, string | number | boolean | (string | number)[]>;
+    datasetVersion: string;
+    successCriteria: string;
+    createdBy: string;
+    updatedAt?: string | undefined;
+    baselineModel?: string | undefined;
+}>;
+/**
+ * Experiment metric log entry
+ */
+export declare const ExperimentMetricSchema: z.ZodObject<{
+    experimentId: z.ZodString;
+    metricName: z.ZodString;
+    metricValue: z.ZodNumber;
+    step: z.ZodOptional<z.ZodNumber>;
+    epoch: z.ZodOptional<z.ZodNumber>;
+    timestamp: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    timestamp: string;
+    metricName: string;
+    experimentId: string;
+    metricValue: number;
+    step?: number | undefined;
+    epoch?: number | undefined;
+}, {
+    timestamp: string;
+    metricName: string;
+    experimentId: string;
+    metricValue: number;
+    step?: number | undefined;
+    epoch?: number | undefined;
+}>;
+/**
+ * Experiment comparison result
+ */
+export declare const ExperimentComparisonSchema: z.ZodObject<{
+    experimentIds: z.ZodArray<z.ZodString, "many">;
+    metrics: z.ZodArray<z.ZodString, "many">;
+    results: z.ZodArray<z.ZodObject<{
+        experimentId: z.ZodString;
+        experimentName: z.ZodString;
+        metricsValues: z.ZodRecord<z.ZodString, z.ZodNumber>;
+        rank: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        experimentId: string;
+        experimentName: string;
+        metricsValues: Record<string, number>;
+        rank: number;
+    }, {
+        experimentId: string;
+        experimentName: string;
+        metricsValues: Record<string, number>;
+        rank: number;
+    }>, "many">;
+    recommendation: z.ZodObject<{
+        bestExperiment: z.ZodString;
+        reason: z.ZodString;
+        confidence: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        reason: string;
+        confidence: number;
+        bestExperiment: string;
+    }, {
+        reason: string;
+        confidence: number;
+        bestExperiment: string;
+    }>;
+    comparedAt: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    results: {
+        experimentId: string;
+        experimentName: string;
+        metricsValues: Record<string, number>;
+        rank: number;
+    }[];
+    metrics: string[];
+    experimentIds: string[];
+    recommendation: {
+        reason: string;
+        confidence: number;
+        bestExperiment: string;
+    };
+    comparedAt: string;
+}, {
+    results: {
+        experimentId: string;
+        experimentName: string;
+        metricsValues: Record<string, number>;
+        rank: number;
+    }[];
+    metrics: string[];
+    experimentIds: string[];
+    recommendation: {
+        reason: string;
+        confidence: number;
+        bestExperiment: string;
+    };
+    comparedAt: string;
+}>;
+/**
+ * ML model lifecycle status
+ */
+export declare const ModelStatusSchema: z.ZodEnum<["staged", "canary", "production", "archived", "deprecated"]>;
+/**
+ * Model artifact information
+ */
+export declare const ModelArtifactSchema: z.ZodObject<{
+    path: z.ZodString;
+    checksum: z.ZodString;
+    sizeBytes: z.ZodNumber;
+    format: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    path: string;
+    sizeBytes: number;
+    checksum: string;
+    format?: string | undefined;
+}, {
+    path: string;
+    sizeBytes: number;
+    checksum: string;
+    format?: string | undefined;
+}>;
+/**
+ * Model lineage information
+ */
+export declare const ModelLineageSchema: z.ZodObject<{
+    experimentId: z.ZodString;
+    trainingDataset: z.ZodString;
+    parentModel: z.ZodOptional<z.ZodString>;
+    trainingConfig: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "strip", z.ZodTypeAny, {
+    experimentId: string;
+    trainingDataset: string;
+    parentModel?: string | undefined;
+    trainingConfig?: Record<string, unknown> | undefined;
+}, {
+    experimentId: string;
+    trainingDataset: string;
+    parentModel?: string | undefined;
+    trainingConfig?: Record<string, unknown> | undefined;
+}>;
+/**
+ * Model schemas for input/output
+ */
+export declare const ModelIOSchemaSchema: z.ZodObject<{
+    inputSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    outputSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    featureNames: z.ZodArray<z.ZodString, "many">;
+}, "strip", z.ZodTypeAny, {
+    inputSchema: Record<string, unknown>;
+    outputSchema: Record<string, unknown>;
+    featureNames: string[];
+}, {
+    inputSchema: Record<string, unknown>;
+    outputSchema: Record<string, unknown>;
+    featureNames: string[];
+}>;
+/**
+ * Model dependencies
+ */
+export declare const ModelDependenciesSchema: z.ZodObject<{
+    framework: z.ZodString;
+    frameworkVersion: z.ZodString;
+    packages: z.ZodArray<z.ZodString, "many">;
+}, "strip", z.ZodTypeAny, {
+    framework: string;
+    frameworkVersion: string;
+    packages: string[];
+}, {
+    framework: string;
+    frameworkVersion: string;
+    packages: string[];
+}>;
+/**
+ * ML model registration
+ */
+export declare const MLModelSchema: z.ZodObject<{
+    modelName: z.ZodString;
+    version: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    lineage: z.ZodObject<{
+        experimentId: z.ZodString;
+        trainingDataset: z.ZodString;
+        parentModel: z.ZodOptional<z.ZodString>;
+        trainingConfig: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, "strip", z.ZodTypeAny, {
+        experimentId: string;
+        trainingDataset: string;
+        parentModel?: string | undefined;
+        trainingConfig?: Record<string, unknown> | undefined;
+    }, {
+        experimentId: string;
+        trainingDataset: string;
+        parentModel?: string | undefined;
+        trainingConfig?: Record<string, unknown> | undefined;
+    }>;
+    artifact: z.ZodObject<{
+        path: z.ZodString;
+        checksum: z.ZodString;
+        sizeBytes: z.ZodNumber;
+        format: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        path: string;
+        sizeBytes: number;
+        checksum: string;
+        format?: string | undefined;
+    }, {
+        path: string;
+        sizeBytes: number;
+        checksum: string;
+        format?: string | undefined;
+    }>;
+    schemas: z.ZodObject<{
+        inputSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        outputSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        featureNames: z.ZodArray<z.ZodString, "many">;
+    }, "strip", z.ZodTypeAny, {
+        inputSchema: Record<string, unknown>;
+        outputSchema: Record<string, unknown>;
+        featureNames: string[];
+    }, {
+        inputSchema: Record<string, unknown>;
+        outputSchema: Record<string, unknown>;
+        featureNames: string[];
+    }>;
+    metrics: z.ZodRecord<z.ZodString, z.ZodNumber>;
+    dependencies: z.ZodObject<{
+        framework: z.ZodString;
+        frameworkVersion: z.ZodString;
+        packages: z.ZodArray<z.ZodString, "many">;
+    }, "strip", z.ZodTypeAny, {
+        framework: string;
+        frameworkVersion: string;
+        packages: string[];
+    }, {
+        framework: string;
+        frameworkVersion: string;
+        packages: string[];
+    }>;
+    status: z.ZodEnum<["staged", "canary", "production", "archived", "deprecated"]>;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodOptional<z.ZodString>;
+    createdBy: z.ZodString;
+    tags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    status: "deprecated" | "archived" | "staged" | "canary" | "production";
+    version: string;
+    createdAt: string;
+    metrics: Record<string, number>;
+    dependencies: {
+        framework: string;
+        frameworkVersion: string;
+        packages: string[];
+    };
+    createdBy: string;
+    modelName: string;
+    lineage: {
+        experimentId: string;
+        trainingDataset: string;
+        parentModel?: string | undefined;
+        trainingConfig?: Record<string, unknown> | undefined;
+    };
+    artifact: {
+        path: string;
+        sizeBytes: number;
+        checksum: string;
+        format?: string | undefined;
+    };
+    schemas: {
+        inputSchema: Record<string, unknown>;
+        outputSchema: Record<string, unknown>;
+        featureNames: string[];
+    };
+    description?: string | undefined;
+    tags?: string[] | undefined;
+    updatedAt?: string | undefined;
+}, {
+    status: "deprecated" | "archived" | "staged" | "canary" | "production";
+    version: string;
+    createdAt: string;
+    metrics: Record<string, number>;
+    dependencies: {
+        framework: string;
+        frameworkVersion: string;
+        packages: string[];
+    };
+    createdBy: string;
+    modelName: string;
+    lineage: {
+        experimentId: string;
+        trainingDataset: string;
+        parentModel?: string | undefined;
+        trainingConfig?: Record<string, unknown> | undefined;
+    };
+    artifact: {
+        path: string;
+        sizeBytes: number;
+        checksum: string;
+        format?: string | undefined;
+    };
+    schemas: {
+        inputSchema: Record<string, unknown>;
+        outputSchema: Record<string, unknown>;
+        featureNames: string[];
+    };
+    description?: string | undefined;
+    tags?: string[] | undefined;
+    updatedAt?: string | undefined;
+}>;
+/**
+ * Model promotion request
+ */
+export declare const ModelPromotionRequestSchema: z.ZodObject<{
+    modelName: z.ZodString;
+    fromVersion: z.ZodString;
+    toStatus: z.ZodEnum<["canary", "production"]>;
+    reason: z.ZodString;
+    approver: z.ZodOptional<z.ZodString>;
+    canaryConfig: z.ZodOptional<z.ZodObject<{
+        trafficPercentage: z.ZodNumber;
+        durationMinutes: z.ZodNumber;
+        successThreshold: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        successThreshold: number;
+        trafficPercentage: number;
+        durationMinutes: number;
+    }, {
+        successThreshold: number;
+        trafficPercentage: number;
+        durationMinutes: number;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    reason: string;
+    fromVersion: string;
+    modelName: string;
+    toStatus: "canary" | "production";
+    approver?: string | undefined;
+    canaryConfig?: {
+        successThreshold: number;
+        trafficPercentage: number;
+        durationMinutes: number;
+    } | undefined;
+}, {
+    reason: string;
+    fromVersion: string;
+    modelName: string;
+    toStatus: "canary" | "production";
+    approver?: string | undefined;
+    canaryConfig?: {
+        successThreshold: number;
+        trafficPercentage: number;
+        durationMinutes: number;
+    } | undefined;
+}>;
+/**
+ * Model promotion result
+ */
+export declare const ModelPromotionResultSchema: z.ZodObject<{
+    modelName: z.ZodString;
+    version: z.ZodString;
+    previousStatus: z.ZodEnum<["staged", "canary", "production", "archived", "deprecated"]>;
+    newStatus: z.ZodEnum<["staged", "canary", "production", "archived", "deprecated"]>;
+    promotedAt: z.ZodString;
+    promotedBy: z.ZodString;
+    previousProductionVersion: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    version: string;
+    modelName: string;
+    previousStatus: "deprecated" | "archived" | "staged" | "canary" | "production";
+    newStatus: "deprecated" | "archived" | "staged" | "canary" | "production";
+    promotedAt: string;
+    promotedBy: string;
+    previousProductionVersion?: string | undefined;
+}, {
+    version: string;
+    modelName: string;
+    previousStatus: "deprecated" | "archived" | "staged" | "canary" | "production";
+    newStatus: "deprecated" | "archived" | "staged" | "canary" | "production";
+    promotedAt: string;
+    promotedBy: string;
+    previousProductionVersion?: string | undefined;
+}>;
+/**
+ * Drift severity levels
+ */
+export declare const DriftSeveritySchema: z.ZodEnum<["none", "moderate", "significant", "critical"]>;
+/**
+ * Drift detection result for a single feature
+ */
+export declare const FeatureDriftResultSchema: z.ZodObject<{
+    featureName: z.ZodString;
+    driftScore: z.ZodNumber;
+    severity: z.ZodEnum<["none", "moderate", "significant", "critical"]>;
+    baselineStats: z.ZodObject<{
+        mean: z.ZodOptional<z.ZodNumber>;
+        std: z.ZodOptional<z.ZodNumber>;
+        min: z.ZodOptional<z.ZodNumber>;
+        max: z.ZodOptional<z.ZodNumber>;
+        distribution: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+    }, "strip", z.ZodTypeAny, {
+        min?: number | undefined;
+        max?: number | undefined;
+        mean?: number | undefined;
+        std?: number | undefined;
+        distribution?: Record<string, number> | undefined;
+    }, {
+        min?: number | undefined;
+        max?: number | undefined;
+        mean?: number | undefined;
+        std?: number | undefined;
+        distribution?: Record<string, number> | undefined;
+    }>;
+    currentStats: z.ZodObject<{
+        mean: z.ZodOptional<z.ZodNumber>;
+        std: z.ZodOptional<z.ZodNumber>;
+        min: z.ZodOptional<z.ZodNumber>;
+        max: z.ZodOptional<z.ZodNumber>;
+        distribution: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+    }, "strip", z.ZodTypeAny, {
+        min?: number | undefined;
+        max?: number | undefined;
+        mean?: number | undefined;
+        std?: number | undefined;
+        distribution?: Record<string, number> | undefined;
+    }, {
+        min?: number | undefined;
+        max?: number | undefined;
+        mean?: number | undefined;
+        std?: number | undefined;
+        distribution?: Record<string, number> | undefined;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    severity: "critical" | "none" | "moderate" | "significant";
+    featureName: string;
+    driftScore: number;
+    baselineStats: {
+        min?: number | undefined;
+        max?: number | undefined;
+        mean?: number | undefined;
+        std?: number | undefined;
+        distribution?: Record<string, number> | undefined;
+    };
+    currentStats: {
+        min?: number | undefined;
+        max?: number | undefined;
+        mean?: number | undefined;
+        std?: number | undefined;
+        distribution?: Record<string, number> | undefined;
+    };
+}, {
+    severity: "critical" | "none" | "moderate" | "significant";
+    featureName: string;
+    driftScore: number;
+    baselineStats: {
+        min?: number | undefined;
+        max?: number | undefined;
+        mean?: number | undefined;
+        std?: number | undefined;
+        distribution?: Record<string, number> | undefined;
+    };
+    currentStats: {
+        min?: number | undefined;
+        max?: number | undefined;
+        mean?: number | undefined;
+        std?: number | undefined;
+        distribution?: Record<string, number> | undefined;
+    };
+}>;
+/**
+ * Data drift detection result
+ */
+export declare const DataDriftResultSchema: z.ZodObject<{
+    modelName: z.ZodString;
+    modelVersion: z.ZodString;
+    overallDriftLevel: z.ZodEnum<["none", "moderate", "significant", "critical"]>;
+    featureResults: z.ZodArray<z.ZodObject<{
+        featureName: z.ZodString;
+        driftScore: z.ZodNumber;
+        severity: z.ZodEnum<["none", "moderate", "significant", "critical"]>;
+        baselineStats: z.ZodObject<{
+            mean: z.ZodOptional<z.ZodNumber>;
+            std: z.ZodOptional<z.ZodNumber>;
+            min: z.ZodOptional<z.ZodNumber>;
+            max: z.ZodOptional<z.ZodNumber>;
+            distribution: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+        }, "strip", z.ZodTypeAny, {
+            min?: number | undefined;
+            max?: number | undefined;
+            mean?: number | undefined;
+            std?: number | undefined;
+            distribution?: Record<string, number> | undefined;
+        }, {
+            min?: number | undefined;
+            max?: number | undefined;
+            mean?: number | undefined;
+            std?: number | undefined;
+            distribution?: Record<string, number> | undefined;
+        }>;
+        currentStats: z.ZodObject<{
+            mean: z.ZodOptional<z.ZodNumber>;
+            std: z.ZodOptional<z.ZodNumber>;
+            min: z.ZodOptional<z.ZodNumber>;
+            max: z.ZodOptional<z.ZodNumber>;
+            distribution: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+        }, "strip", z.ZodTypeAny, {
+            min?: number | undefined;
+            max?: number | undefined;
+            mean?: number | undefined;
+            std?: number | undefined;
+            distribution?: Record<string, number> | undefined;
+        }, {
+            min?: number | undefined;
+            max?: number | undefined;
+            mean?: number | undefined;
+            std?: number | undefined;
+            distribution?: Record<string, number> | undefined;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        severity: "critical" | "none" | "moderate" | "significant";
+        featureName: string;
+        driftScore: number;
+        baselineStats: {
+            min?: number | undefined;
+            max?: number | undefined;
+            mean?: number | undefined;
+            std?: number | undefined;
+            distribution?: Record<string, number> | undefined;
+        };
+        currentStats: {
+            min?: number | undefined;
+            max?: number | undefined;
+            mean?: number | undefined;
+            std?: number | undefined;
+            distribution?: Record<string, number> | undefined;
+        };
+    }, {
+        severity: "critical" | "none" | "moderate" | "significant";
+        featureName: string;
+        driftScore: number;
+        baselineStats: {
+            min?: number | undefined;
+            max?: number | undefined;
+            mean?: number | undefined;
+            std?: number | undefined;
+            distribution?: Record<string, number> | undefined;
+        };
+        currentStats: {
+            min?: number | undefined;
+            max?: number | undefined;
+            mean?: number | undefined;
+            std?: number | undefined;
+            distribution?: Record<string, number> | undefined;
+        };
+    }>, "many">;
+    topDriftedFeatures: z.ZodArray<z.ZodString, "many">;
+    detectedAt: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    modelName: string;
+    modelVersion: string;
+    overallDriftLevel: "critical" | "none" | "moderate" | "significant";
+    featureResults: {
+        severity: "critical" | "none" | "moderate" | "significant";
+        featureName: string;
+        driftScore: number;
+        baselineStats: {
+            min?: number | undefined;
+            max?: number | undefined;
+            mean?: number | undefined;
+            std?: number | undefined;
+            distribution?: Record<string, number> | undefined;
+        };
+        currentStats: {
+            min?: number | undefined;
+            max?: number | undefined;
+            mean?: number | undefined;
+            std?: number | undefined;
+            distribution?: Record<string, number> | undefined;
+        };
+    }[];
+    topDriftedFeatures: string[];
+    detectedAt: string;
+}, {
+    modelName: string;
+    modelVersion: string;
+    overallDriftLevel: "critical" | "none" | "moderate" | "significant";
+    featureResults: {
+        severity: "critical" | "none" | "moderate" | "significant";
+        featureName: string;
+        driftScore: number;
+        baselineStats: {
+            min?: number | undefined;
+            max?: number | undefined;
+            mean?: number | undefined;
+            std?: number | undefined;
+            distribution?: Record<string, number> | undefined;
+        };
+        currentStats: {
+            min?: number | undefined;
+            max?: number | undefined;
+            mean?: number | undefined;
+            std?: number | undefined;
+            distribution?: Record<string, number> | undefined;
+        };
+    }[];
+    topDriftedFeatures: string[];
+    detectedAt: string;
+}>;
+/**
+ * Prediction drift detection result
+ */
+export declare const PredictionDriftResultSchema: z.ZodObject<{
+    modelName: z.ZodString;
+    modelVersion: z.ZodString;
+    driftLevel: z.ZodEnum<["none", "moderate", "significant", "critical"]>;
+    driftScore: z.ZodNumber;
+    baselineDistribution: z.ZodRecord<z.ZodString, z.ZodNumber>;
+    currentDistribution: z.ZodRecord<z.ZodString, z.ZodNumber>;
+    detectedAt: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    modelName: string;
+    driftScore: number;
+    modelVersion: string;
+    detectedAt: string;
+    driftLevel: "critical" | "none" | "moderate" | "significant";
+    baselineDistribution: Record<string, number>;
+    currentDistribution: Record<string, number>;
+}, {
+    modelName: string;
+    driftScore: number;
+    modelVersion: string;
+    detectedAt: string;
+    driftLevel: "critical" | "none" | "moderate" | "significant";
+    baselineDistribution: Record<string, number>;
+    currentDistribution: Record<string, number>;
+}>;
+/**
+ * Performance degradation result
+ */
+export declare const PerformanceDegradationResultSchema: z.ZodObject<{
+    modelName: z.ZodString;
+    modelVersion: z.ZodString;
+    degradationDetected: z.ZodBoolean;
+    metricsComparison: z.ZodArray<z.ZodObject<{
+        metricName: z.ZodString;
+        baselineValue: z.ZodNumber;
+        currentValue: z.ZodNumber;
+        degradationPercent: z.ZodNumber;
+        threshold: z.ZodNumber;
+        breached: z.ZodBoolean;
+    }, "strip", z.ZodTypeAny, {
+        metricName: string;
+        baselineValue: number;
+        currentValue: number;
+        degradationPercent: number;
+        threshold: number;
+        breached: boolean;
+    }, {
+        metricName: string;
+        baselineValue: number;
+        currentValue: number;
+        degradationPercent: number;
+        threshold: number;
+        breached: boolean;
+    }>, "many">;
+    detectedAt: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    modelName: string;
+    modelVersion: string;
+    detectedAt: string;
+    degradationDetected: boolean;
+    metricsComparison: {
+        metricName: string;
+        baselineValue: number;
+        currentValue: number;
+        degradationPercent: number;
+        threshold: number;
+        breached: boolean;
+    }[];
+}, {
+    modelName: string;
+    modelVersion: string;
+    detectedAt: string;
+    degradationDetected: boolean;
+    metricsComparison: {
+        metricName: string;
+        baselineValue: number;
+        currentValue: number;
+        degradationPercent: number;
+        threshold: number;
+        breached: boolean;
+    }[];
+}>;
+/**
+ * Retraining recommendation
+ */
+export declare const RetrainingRecommendationSchema: z.ZodEnum<["no_action", "monitor", "investigate", "retrain", "retrain_urgent"]>;
+/**
+ * Model monitoring alert
+ */
+export declare const MonitoringAlertSchema: z.ZodObject<{
+    alertId: z.ZodString;
+    modelName: z.ZodString;
+    modelVersion: z.ZodString;
+    severity: z.ZodEnum<["info", "warning", "critical"]>;
+    alertType: z.ZodEnum<["data_drift", "prediction_drift", "performance_degradation", "error_rate"]>;
+    driftSummary: z.ZodOptional<z.ZodObject<{
+        dataDriftLevel: z.ZodEnum<["none", "moderate", "significant", "critical"]>;
+        predictionDriftLevel: z.ZodEnum<["none", "moderate", "significant", "critical"]>;
+        topDriftedFeatures: z.ZodArray<z.ZodString, "many">;
+    }, "strip", z.ZodTypeAny, {
+        topDriftedFeatures: string[];
+        dataDriftLevel: "critical" | "none" | "moderate" | "significant";
+        predictionDriftLevel: "critical" | "none" | "moderate" | "significant";
+    }, {
+        topDriftedFeatures: string[];
+        dataDriftLevel: "critical" | "none" | "moderate" | "significant";
+        predictionDriftLevel: "critical" | "none" | "moderate" | "significant";
+    }>>;
+    performanceSummary: z.ZodOptional<z.ZodObject<{
+        degradationDetected: z.ZodBoolean;
+        metricsAffected: z.ZodArray<z.ZodString, "many">;
+    }, "strip", z.ZodTypeAny, {
+        degradationDetected: boolean;
+        metricsAffected: string[];
+    }, {
+        degradationDetected: boolean;
+        metricsAffected: string[];
+    }>>;
+    recommendation: z.ZodEnum<["no_action", "monitor", "investigate", "retrain", "retrain_urgent"]>;
+    createdAt: z.ZodString;
+    acknowledged: z.ZodBoolean;
+    acknowledgedAt: z.ZodOptional<z.ZodString>;
+    acknowledgedBy: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    createdAt: string;
+    severity: "critical" | "info" | "warning";
+    recommendation: "no_action" | "monitor" | "investigate" | "retrain" | "retrain_urgent";
+    modelName: string;
+    modelVersion: string;
+    alertId: string;
+    alertType: "data_drift" | "prediction_drift" | "performance_degradation" | "error_rate";
+    acknowledged: boolean;
+    driftSummary?: {
+        topDriftedFeatures: string[];
+        dataDriftLevel: "critical" | "none" | "moderate" | "significant";
+        predictionDriftLevel: "critical" | "none" | "moderate" | "significant";
+    } | undefined;
+    performanceSummary?: {
+        degradationDetected: boolean;
+        metricsAffected: string[];
+    } | undefined;
+    acknowledgedAt?: string | undefined;
+    acknowledgedBy?: string | undefined;
+}, {
+    createdAt: string;
+    severity: "critical" | "info" | "warning";
+    recommendation: "no_action" | "monitor" | "investigate" | "retrain" | "retrain_urgent";
+    modelName: string;
+    modelVersion: string;
+    alertId: string;
+    alertType: "data_drift" | "prediction_drift" | "performance_degradation" | "error_rate";
+    acknowledged: boolean;
+    driftSummary?: {
+        topDriftedFeatures: string[];
+        dataDriftLevel: "critical" | "none" | "moderate" | "significant";
+        predictionDriftLevel: "critical" | "none" | "moderate" | "significant";
+    } | undefined;
+    performanceSummary?: {
+        degradationDetected: boolean;
+        metricsAffected: string[];
+    } | undefined;
+    acknowledgedAt?: string | undefined;
+    acknowledgedBy?: string | undefined;
+}>;
+/**
+ * A/B test status
+ */
+export declare const ABTestStatusSchema: z.ZodEnum<["draft", "running", "paused", "completed", "cancelled"]>;
+/**
+ * A/B test variant
+ */
+export declare const ABTestVariantSchema: z.ZodObject<{
+    variantId: z.ZodString;
+    variantName: z.ZodString;
+    modelVersion: z.ZodString;
+    trafficAllocation: z.ZodNumber;
+    isControl: z.ZodBoolean;
+}, "strip", z.ZodTypeAny, {
+    modelVersion: string;
+    variantId: string;
+    variantName: string;
+    trafficAllocation: number;
+    isControl: boolean;
+}, {
+    modelVersion: string;
+    variantId: string;
+    variantName: string;
+    trafficAllocation: number;
+    isControl: boolean;
+}>;
+/**
+ * A/B test configuration
+ */
+export declare const ABTestConfigSchema: z.ZodObject<{
+    testId: z.ZodString;
+    testName: z.ZodString;
+    modelName: z.ZodString;
+    hypothesis: z.ZodString;
+    variants: z.ZodArray<z.ZodObject<{
+        variantId: z.ZodString;
+        variantName: z.ZodString;
+        modelVersion: z.ZodString;
+        trafficAllocation: z.ZodNumber;
+        isControl: z.ZodBoolean;
+    }, "strip", z.ZodTypeAny, {
+        modelVersion: string;
+        variantId: string;
+        variantName: string;
+        trafficAllocation: number;
+        isControl: boolean;
+    }, {
+        modelVersion: string;
+        variantId: string;
+        variantName: string;
+        trafficAllocation: number;
+        isControl: boolean;
+    }>, "many">;
+    primaryMetric: z.ZodString;
+    secondaryMetrics: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    minimumSampleSize: z.ZodNumber;
+    confidenceLevel: z.ZodDefault<z.ZodNumber>;
+    durationDays: z.ZodNumber;
+    status: z.ZodEnum<["draft", "running", "paused", "completed", "cancelled"]>;
+    createdAt: z.ZodString;
+    startedAt: z.ZodOptional<z.ZodString>;
+    endedAt: z.ZodOptional<z.ZodString>;
+    createdBy: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    status: "completed" | "running" | "draft" | "cancelled" | "paused";
+    createdAt: string;
+    hypothesis: string;
+    createdBy: string;
+    modelName: string;
+    testId: string;
+    testName: string;
+    variants: {
+        modelVersion: string;
+        variantId: string;
+        variantName: string;
+        trafficAllocation: number;
+        isControl: boolean;
+    }[];
+    primaryMetric: string;
+    minimumSampleSize: number;
+    confidenceLevel: number;
+    durationDays: number;
+    startedAt?: string | undefined;
+    secondaryMetrics?: string[] | undefined;
+    endedAt?: string | undefined;
+}, {
+    status: "completed" | "running" | "draft" | "cancelled" | "paused";
+    createdAt: string;
+    hypothesis: string;
+    createdBy: string;
+    modelName: string;
+    testId: string;
+    testName: string;
+    variants: {
+        modelVersion: string;
+        variantId: string;
+        variantName: string;
+        trafficAllocation: number;
+        isControl: boolean;
+    }[];
+    primaryMetric: string;
+    minimumSampleSize: number;
+    durationDays: number;
+    startedAt?: string | undefined;
+    secondaryMetrics?: string[] | undefined;
+    confidenceLevel?: number | undefined;
+    endedAt?: string | undefined;
+}>;
+/**
+ * A/B test results
+ */
+export declare const ABTestResultsSchema: z.ZodObject<{
+    testId: z.ZodString;
+    status: z.ZodEnum<["inconclusive", "control_wins", "variant_wins"]>;
+    variantResults: z.ZodArray<z.ZodObject<{
+        variantId: z.ZodString;
+        sampleSize: z.ZodNumber;
+        primaryMetricValue: z.ZodNumber;
+        secondaryMetricValues: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+        conversionRate: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        variantId: string;
+        sampleSize: number;
+        primaryMetricValue: number;
+        secondaryMetricValues?: Record<string, number> | undefined;
+        conversionRate?: number | undefined;
+    }, {
+        variantId: string;
+        sampleSize: number;
+        primaryMetricValue: number;
+        secondaryMetricValues?: Record<string, number> | undefined;
+        conversionRate?: number | undefined;
+    }>, "many">;
+    statisticalSignificance: z.ZodNumber;
+    pValue: z.ZodNumber;
+    winningVariant: z.ZodOptional<z.ZodString>;
+    uplift: z.ZodOptional<z.ZodNumber>;
+    recommendation: z.ZodString;
+    analyzedAt: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    status: "inconclusive" | "control_wins" | "variant_wins";
+    recommendation: string;
+    testId: string;
+    variantResults: {
+        variantId: string;
+        sampleSize: number;
+        primaryMetricValue: number;
+        secondaryMetricValues?: Record<string, number> | undefined;
+        conversionRate?: number | undefined;
+    }[];
+    statisticalSignificance: number;
+    pValue: number;
+    analyzedAt: string;
+    winningVariant?: string | undefined;
+    uplift?: number | undefined;
+}, {
+    status: "inconclusive" | "control_wins" | "variant_wins";
+    recommendation: string;
+    testId: string;
+    variantResults: {
+        variantId: string;
+        sampleSize: number;
+        primaryMetricValue: number;
+        secondaryMetricValues?: Record<string, number> | undefined;
+        conversionRate?: number | undefined;
+    }[];
+    statisticalSignificance: number;
+    pValue: number;
+    analyzedAt: string;
+    winningVariant?: string | undefined;
+    uplift?: number | undefined;
+}>;
+/**
+ * Feature definition
+ */
+export declare const FeatureDefinitionSchema: z.ZodObject<{
+    featureId: z.ZodString;
+    featureName: z.ZodString;
+    description: z.ZodString;
+    dataType: z.ZodEnum<["numeric", "categorical", "boolean", "datetime", "text", "embedding"]>;
+    transformations: z.ZodArray<z.ZodString, "many">;
+    sourceColumns: z.ZodArray<z.ZodString, "many">;
+    validationRules: z.ZodOptional<z.ZodObject<{
+        notNull: z.ZodOptional<z.ZodBoolean>;
+        minValue: z.ZodOptional<z.ZodNumber>;
+        maxValue: z.ZodOptional<z.ZodNumber>;
+        allowedValues: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        regex: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        regex?: string | undefined;
+        minValue?: number | undefined;
+        maxValue?: number | undefined;
+        notNull?: boolean | undefined;
+        allowedValues?: string[] | undefined;
+    }, {
+        regex?: string | undefined;
+        minValue?: number | undefined;
+        maxValue?: number | undefined;
+        notNull?: boolean | undefined;
+        allowedValues?: string[] | undefined;
+    }>>;
+    statistics: z.ZodOptional<z.ZodObject<{
+        nullRate: z.ZodOptional<z.ZodNumber>;
+        uniqueCount: z.ZodOptional<z.ZodNumber>;
+        mean: z.ZodOptional<z.ZodNumber>;
+        std: z.ZodOptional<z.ZodNumber>;
+        importance: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        mean?: number | undefined;
+        std?: number | undefined;
+        nullRate?: number | undefined;
+        uniqueCount?: number | undefined;
+        importance?: number | undefined;
+    }, {
+        mean?: number | undefined;
+        std?: number | undefined;
+        nullRate?: number | undefined;
+        uniqueCount?: number | undefined;
+        importance?: number | undefined;
+    }>>;
+    version: z.ZodString;
+    createdAt: z.ZodString;
+    createdBy: z.ZodString;
+    tags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    version: string;
+    description: string;
+    createdAt: string;
+    dataType: "boolean" | "datetime" | "text" | "numeric" | "categorical" | "embedding";
+    createdBy: string;
+    featureName: string;
+    featureId: string;
+    transformations: string[];
+    sourceColumns: string[];
+    tags?: string[] | undefined;
+    validationRules?: {
+        regex?: string | undefined;
+        minValue?: number | undefined;
+        maxValue?: number | undefined;
+        notNull?: boolean | undefined;
+        allowedValues?: string[] | undefined;
+    } | undefined;
+    statistics?: {
+        mean?: number | undefined;
+        std?: number | undefined;
+        nullRate?: number | undefined;
+        uniqueCount?: number | undefined;
+        importance?: number | undefined;
+    } | undefined;
+}, {
+    version: string;
+    description: string;
+    createdAt: string;
+    dataType: "boolean" | "datetime" | "text" | "numeric" | "categorical" | "embedding";
+    createdBy: string;
+    featureName: string;
+    featureId: string;
+    transformations: string[];
+    sourceColumns: string[];
+    tags?: string[] | undefined;
+    validationRules?: {
+        regex?: string | undefined;
+        minValue?: number | undefined;
+        maxValue?: number | undefined;
+        notNull?: boolean | undefined;
+        allowedValues?: string[] | undefined;
+    } | undefined;
+    statistics?: {
+        mean?: number | undefined;
+        std?: number | undefined;
+        nullRate?: number | undefined;
+        uniqueCount?: number | undefined;
+        importance?: number | undefined;
+    } | undefined;
+}>;
+/**
+ * Feature set definition
+ */
+export declare const FeatureSetSchema: z.ZodObject<{
+    featureSetId: z.ZodString;
+    featureSetName: z.ZodString;
+    description: z.ZodString;
+    features: z.ZodArray<z.ZodString, "many">;
+    targetVariable: z.ZodOptional<z.ZodString>;
+    version: z.ZodString;
+    createdAt: z.ZodString;
+    createdBy: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    version: string;
+    description: string;
+    createdAt: string;
+    features: string[];
+    createdBy: string;
+    featureSetId: string;
+    featureSetName: string;
+    targetVariable?: string | undefined;
+}, {
+    version: string;
+    description: string;
+    createdAt: string;
+    features: string[];
+    createdBy: string;
+    featureSetId: string;
+    featureSetName: string;
+    targetVariable?: string | undefined;
+}>;
+export type ExperimentStatus = z.infer<typeof ExperimentStatusSchema>;
+export type HyperparameterValue = z.infer<typeof HyperparameterValueSchema>;
+export type MLExperiment = z.infer<typeof MLExperimentSchema>;
+export type ExperimentMetric = z.infer<typeof ExperimentMetricSchema>;
+export type ExperimentComparison = z.infer<typeof ExperimentComparisonSchema>;
+export type ModelStatus = z.infer<typeof ModelStatusSchema>;
+export type ModelArtifact = z.infer<typeof ModelArtifactSchema>;
+export type ModelLineage = z.infer<typeof ModelLineageSchema>;
+export type ModelIOSchema = z.infer<typeof ModelIOSchemaSchema>;
+export type ModelDependencies = z.infer<typeof ModelDependenciesSchema>;
+export type MLModel = z.infer<typeof MLModelSchema>;
+export type ModelPromotionRequest = z.infer<typeof ModelPromotionRequestSchema>;
+export type ModelPromotionResult = z.infer<typeof ModelPromotionResultSchema>;
+export type DriftSeverity = z.infer<typeof DriftSeveritySchema>;
+export type FeatureDriftResult = z.infer<typeof FeatureDriftResultSchema>;
+export type DataDriftResult = z.infer<typeof DataDriftResultSchema>;
+export type PredictionDriftResult = z.infer<typeof PredictionDriftResultSchema>;
+export type PerformanceDegradationResult = z.infer<typeof PerformanceDegradationResultSchema>;
+export type RetrainingRecommendation = z.infer<typeof RetrainingRecommendationSchema>;
+export type MonitoringAlert = z.infer<typeof MonitoringAlertSchema>;
+export type ABTestStatus = z.infer<typeof ABTestStatusSchema>;
+export type ABTestVariant = z.infer<typeof ABTestVariantSchema>;
+export type ABTestConfig = z.infer<typeof ABTestConfigSchema>;
+export type ABTestResults = z.infer<typeof ABTestResultsSchema>;
+export type FeatureDefinition = z.infer<typeof FeatureDefinitionSchema>;
+export type FeatureSet = z.infer<typeof FeatureSetSchema>;
+export declare const validateMLExperiment: (data: unknown) => MLExperiment;
+export declare const safeValidateMLExperiment: (data: unknown) => {
+    success: true;
+    data: MLExperiment;
+} | {
+    success: false;
+    error: z.ZodError;
+};
+export declare const validateMLModel: (data: unknown) => MLModel;
+export declare const safeValidateMLModel: (data: unknown) => {
+    success: true;
+    data: MLModel;
+} | {
+    success: false;
+    error: z.ZodError;
+};
+export declare const validateMonitoringAlert: (data: unknown) => MonitoringAlert;
+export declare const validateABTestConfig: (data: unknown) => ABTestConfig;
+export declare const createMLExperiment: (params: Omit<MLExperiment, "experimentId" | "createdAt" | "status">) => MLExperiment;
+export declare const createMLModel: (params: Omit<MLModel, "createdAt" | "status">) => MLModel;
+export declare const createMonitoringAlert: (params: Omit<MonitoringAlert, "alertId" | "createdAt" | "acknowledged">) => MonitoringAlert;
+export declare const MLLifecycleErrorCodes: {
+    readonly EXPERIMENT_NOT_FOUND: "ML_EXPERIMENT_NOT_FOUND";
+    readonly EXPERIMENT_ALREADY_EXISTS: "ML_EXPERIMENT_ALREADY_EXISTS";
+    readonly EXPERIMENT_IMMUTABLE: "ML_EXPERIMENT_IMMUTABLE";
+    readonly INVALID_EXPERIMENT_STATUS: "ML_INVALID_EXPERIMENT_STATUS";
+    readonly MODEL_NOT_FOUND: "ML_MODEL_NOT_FOUND";
+    readonly MODEL_VERSION_EXISTS: "ML_MODEL_VERSION_EXISTS";
+    readonly MODEL_VERSION_INVALID: "ML_MODEL_VERSION_INVALID";
+    readonly MODEL_ARTIFACT_INVALID: "ML_MODEL_ARTIFACT_INVALID";
+    readonly MODEL_LINEAGE_INCOMPLETE: "ML_MODEL_LINEAGE_INCOMPLETE";
+    readonly PROMOTION_NOT_ALLOWED: "ML_PROMOTION_NOT_ALLOWED";
+    readonly PRODUCTION_MODEL_EXISTS: "ML_PRODUCTION_MODEL_EXISTS";
+    readonly BASELINE_NOT_FOUND: "ML_BASELINE_NOT_FOUND";
+    readonly DRIFT_CALCULATION_FAILED: "ML_DRIFT_CALCULATION_FAILED";
+    readonly ALERT_NOT_FOUND: "ML_ALERT_NOT_FOUND";
+    readonly ABTEST_NOT_FOUND: "ML_ABTEST_NOT_FOUND";
+    readonly ABTEST_INVALID_CONFIG: "ML_ABTEST_INVALID_CONFIG";
+    readonly ABTEST_ALREADY_RUNNING: "ML_ABTEST_ALREADY_RUNNING";
+    readonly ABTEST_INSUFFICIENT_DATA: "ML_ABTEST_INSUFFICIENT_DATA";
+    readonly FEATURE_NOT_FOUND: "ML_FEATURE_NOT_FOUND";
+    readonly FEATURE_VALIDATION_FAILED: "ML_FEATURE_VALIDATION_FAILED";
+    readonly FEATURE_SET_NOT_FOUND: "ML_FEATURE_SET_NOT_FOUND";
+};
+export type MLLifecycleErrorCode = (typeof MLLifecycleErrorCodes)[keyof typeof MLLifecycleErrorCodes];
+//# sourceMappingURL=schema.d.ts.map