@stacknext/regression 0.0.0-stage → 0.6.0

package/dist/schema.d.ts

@@ -0,0 +1,1300 @@
+import { z } from 'zod';
+export declare const databaseNameSchema: z.ZodString;
+export declare const instrumentationSnapshotSchema: z.ZodObject<{
+    verbose: z.ZodBoolean;
+    verboseSource: z.ZodString;
+    captureFetch: z.ZodBoolean;
+    captureErrors: z.ZodBoolean;
+}, z.core.$strict>;
+export declare const environmentSnapshotSchema: z.ZodObject<{
+    nodeVersion: z.ZodString;
+    nextVersion: z.ZodNullable<z.ZodString>;
+    platform: z.ZodString;
+    arch: z.ZodString;
+    runtime: z.ZodLiteral<"nodejs">;
+    databases: z.ZodArray<z.ZodString>;
+    instrumentation: z.ZodObject<{
+        verbose: z.ZodBoolean;
+        verboseSource: z.ZodString;
+        captureFetch: z.ZodBoolean;
+        captureErrors: z.ZodBoolean;
+    }, z.core.$strict>;
+    sdkVersion: z.ZodString;
+    playwrightVersion: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export declare const scenarioIdentitySchema: z.ZodObject<{
+    id: z.ZodString;
+    source: z.ZodEnum<{
+        annotation: "annotation";
+        "test-id": "test-id";
+        title: "title";
+    }>;
+    title: z.ZodString;
+    file: z.ZodString;
+    project: z.ZodString;
+    tags: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+export declare const capturedSpanSchema: z.ZodObject<{
+    key: z.ZodString;
+    name: z.ZodString;
+    kind: z.ZodEnum<{
+        internal: "internal";
+        server: "server";
+        client: "client";
+        producer: "producer";
+        consumer: "consumer";
+    }>;
+    category: z.ZodEnum<{
+        custom: "custom";
+        database: "database";
+        http: "http";
+        framework: "framework";
+        other: "other";
+    }>;
+    durationMs: z.ZodNumber;
+    status: z.ZodEnum<{
+        error: "error";
+        unset: "unset";
+        ok: "ok";
+    }>;
+    nextSpanType: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export declare const capturedQuerySchema: z.ZodObject<{
+    key: z.ZodString;
+    shape: z.ZodString;
+    durationMs: z.ZodNullable<z.ZodNumber>;
+    source: z.ZodEnum<{
+        drizzle: "drizzle";
+        prisma: "prisma";
+        manual: "manual";
+    }>;
+    success: z.ZodBoolean;
+}, z.core.$strict>;
+export declare const capturedErrorSchema: z.ZodObject<{
+    key: z.ZodString;
+    name: z.ZodString;
+    message: z.ZodString;
+    route: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>;
+export declare const capturedFindingSchema: z.ZodObject<{
+    key: z.ZodString;
+    ruleId: z.ZodEnum<{
+        "n-plus-one-queries": "n-plus-one-queries";
+        "slow-span": "slow-span";
+        "repeated-external-http": "repeated-external-http";
+        "error-fingerprint": "error-fingerprint";
+    }>;
+    category: z.ZodEnum<{
+        runtime: "runtime";
+        database: "database";
+        http: "http";
+        performance: "performance";
+        errors: "errors";
+    }>;
+    severity: z.ZodEnum<{
+        error: "error";
+        info: "info";
+        warning: "warning";
+    }>;
+    status: z.ZodEnum<{
+        observed: "observed";
+        possible: "possible";
+        "insufficient-evidence": "insufficient-evidence";
+    }>;
+}, z.core.$strict>;
+export declare const capturedTraceSchema: z.ZodObject<{
+    traceId: z.ZodString;
+    injectedSpanId: z.ZodString;
+    key: z.ZodString;
+    method: z.ZodNullable<z.ZodString>;
+    route: z.ZodNullable<z.ZodString>;
+    rootName: z.ZodString;
+    statusCode: z.ZodNullable<z.ZodNumber>;
+    durationMs: z.ZodNumber;
+    spanCount: z.ZodNumber;
+    errorCount: z.ZodNumber;
+    databaseQueryCount: z.ZodNumber;
+    fetchCount: z.ZodNumber;
+    spans: z.ZodArray<z.ZodObject<{
+        key: z.ZodString;
+        name: z.ZodString;
+        kind: z.ZodEnum<{
+            internal: "internal";
+            server: "server";
+            client: "client";
+            producer: "producer";
+            consumer: "consumer";
+        }>;
+        category: z.ZodEnum<{
+            custom: "custom";
+            database: "database";
+            http: "http";
+            framework: "framework";
+            other: "other";
+        }>;
+        durationMs: z.ZodNumber;
+        status: z.ZodEnum<{
+            error: "error";
+            unset: "unset";
+            ok: "ok";
+        }>;
+        nextSpanType: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    queries: z.ZodArray<z.ZodObject<{
+        key: z.ZodString;
+        shape: z.ZodString;
+        durationMs: z.ZodNullable<z.ZodNumber>;
+        source: z.ZodEnum<{
+            drizzle: "drizzle";
+            prisma: "prisma";
+            manual: "manual";
+        }>;
+        success: z.ZodBoolean;
+    }, z.core.$strict>>;
+    errors: z.ZodArray<z.ZodObject<{
+        key: z.ZodString;
+        name: z.ZodString;
+        message: z.ZodString;
+        route: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export declare const correlationSchema: z.ZodObject<{
+    status: z.ZodEnum<{
+        incomplete: "incomplete";
+        verified: "verified";
+    }>;
+    reasons: z.ZodArray<z.ZodString>;
+    traces: z.ZodArray<z.ZodObject<{
+        traceId: z.ZodString;
+        injectedSpanId: z.ZodString;
+        key: z.ZodString;
+        method: z.ZodNullable<z.ZodString>;
+        route: z.ZodNullable<z.ZodString>;
+        rootName: z.ZodString;
+        statusCode: z.ZodNullable<z.ZodNumber>;
+        durationMs: z.ZodNumber;
+        spanCount: z.ZodNumber;
+        errorCount: z.ZodNumber;
+        databaseQueryCount: z.ZodNumber;
+        fetchCount: z.ZodNumber;
+        spans: z.ZodArray<z.ZodObject<{
+            key: z.ZodString;
+            name: z.ZodString;
+            kind: z.ZodEnum<{
+                internal: "internal";
+                server: "server";
+                client: "client";
+                producer: "producer";
+                consumer: "consumer";
+            }>;
+            category: z.ZodEnum<{
+                custom: "custom";
+                database: "database";
+                http: "http";
+                framework: "framework";
+                other: "other";
+            }>;
+            durationMs: z.ZodNumber;
+            status: z.ZodEnum<{
+                error: "error";
+                unset: "unset";
+                ok: "ok";
+            }>;
+            nextSpanType: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+        queries: z.ZodArray<z.ZodObject<{
+            key: z.ZodString;
+            shape: z.ZodString;
+            durationMs: z.ZodNullable<z.ZodNumber>;
+            source: z.ZodEnum<{
+                drizzle: "drizzle";
+                prisma: "prisma";
+                manual: "manual";
+            }>;
+            success: z.ZodBoolean;
+        }, z.core.$strict>>;
+        errors: z.ZodArray<z.ZodObject<{
+            key: z.ZodString;
+            name: z.ZodString;
+            message: z.ZodString;
+            route: z.ZodNullable<z.ZodString>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export declare const capturedSampleSchema: z.ZodObject<{
+    id: z.ZodString;
+    status: z.ZodEnum<{
+        failed: "failed";
+        interrupted: "interrupted";
+        passed: "passed";
+        timedOut: "timedOut";
+        skipped: "skipped";
+    }>;
+    expectedStatus: z.ZodEnum<{
+        failed: "failed";
+        passed: "passed";
+        skipped: "skipped";
+    }>;
+    retry: z.ZodNumber;
+    repeatEachIndex: z.ZodNumber;
+    durationMs: z.ZodNumber;
+    capturedAt: z.ZodNumber;
+    correlation: z.ZodObject<{
+        status: z.ZodEnum<{
+            incomplete: "incomplete";
+            verified: "verified";
+        }>;
+        reasons: z.ZodArray<z.ZodString>;
+        traces: z.ZodArray<z.ZodObject<{
+            traceId: z.ZodString;
+            injectedSpanId: z.ZodString;
+            key: z.ZodString;
+            method: z.ZodNullable<z.ZodString>;
+            route: z.ZodNullable<z.ZodString>;
+            rootName: z.ZodString;
+            statusCode: z.ZodNullable<z.ZodNumber>;
+            durationMs: z.ZodNumber;
+            spanCount: z.ZodNumber;
+            errorCount: z.ZodNumber;
+            databaseQueryCount: z.ZodNumber;
+            fetchCount: z.ZodNumber;
+            spans: z.ZodArray<z.ZodObject<{
+                key: z.ZodString;
+                name: z.ZodString;
+                kind: z.ZodEnum<{
+                    internal: "internal";
+                    server: "server";
+                    client: "client";
+                    producer: "producer";
+                    consumer: "consumer";
+                }>;
+                category: z.ZodEnum<{
+                    custom: "custom";
+                    database: "database";
+                    http: "http";
+                    framework: "framework";
+                    other: "other";
+                }>;
+                durationMs: z.ZodNumber;
+                status: z.ZodEnum<{
+                    error: "error";
+                    unset: "unset";
+                    ok: "ok";
+                }>;
+                nextSpanType: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>;
+            queries: z.ZodArray<z.ZodObject<{
+                key: z.ZodString;
+                shape: z.ZodString;
+                durationMs: z.ZodNullable<z.ZodNumber>;
+                source: z.ZodEnum<{
+                    drizzle: "drizzle";
+                    prisma: "prisma";
+                    manual: "manual";
+                }>;
+                success: z.ZodBoolean;
+            }, z.core.$strict>>;
+            errors: z.ZodArray<z.ZodObject<{
+                key: z.ZodString;
+                name: z.ZodString;
+                message: z.ZodString;
+                route: z.ZodNullable<z.ZodString>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+    findings: z.ZodArray<z.ZodObject<{
+        key: z.ZodString;
+        ruleId: z.ZodEnum<{
+            "n-plus-one-queries": "n-plus-one-queries";
+            "slow-span": "slow-span";
+            "repeated-external-http": "repeated-external-http";
+            "error-fingerprint": "error-fingerprint";
+        }>;
+        category: z.ZodEnum<{
+            runtime: "runtime";
+            database: "database";
+            http: "http";
+            performance: "performance";
+            errors: "errors";
+        }>;
+        severity: z.ZodEnum<{
+            error: "error";
+            info: "info";
+            warning: "warning";
+        }>;
+        status: z.ZodEnum<{
+            observed: "observed";
+            possible: "possible";
+            "insufficient-evidence": "insufficient-evidence";
+        }>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export declare const scenarioSchema: z.ZodObject<{
+    identity: z.ZodObject<{
+        id: z.ZodString;
+        source: z.ZodEnum<{
+            annotation: "annotation";
+            "test-id": "test-id";
+            title: "title";
+        }>;
+        title: z.ZodString;
+        file: z.ZodString;
+        project: z.ZodString;
+        tags: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>;
+    samples: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        status: z.ZodEnum<{
+            failed: "failed";
+            interrupted: "interrupted";
+            passed: "passed";
+            timedOut: "timedOut";
+            skipped: "skipped";
+        }>;
+        expectedStatus: z.ZodEnum<{
+            failed: "failed";
+            passed: "passed";
+            skipped: "skipped";
+        }>;
+        retry: z.ZodNumber;
+        repeatEachIndex: z.ZodNumber;
+        durationMs: z.ZodNumber;
+        capturedAt: z.ZodNumber;
+        correlation: z.ZodObject<{
+            status: z.ZodEnum<{
+                incomplete: "incomplete";
+                verified: "verified";
+            }>;
+            reasons: z.ZodArray<z.ZodString>;
+            traces: z.ZodArray<z.ZodObject<{
+                traceId: z.ZodString;
+                injectedSpanId: z.ZodString;
+                key: z.ZodString;
+                method: z.ZodNullable<z.ZodString>;
+                route: z.ZodNullable<z.ZodString>;
+                rootName: z.ZodString;
+                statusCode: z.ZodNullable<z.ZodNumber>;
+                durationMs: z.ZodNumber;
+                spanCount: z.ZodNumber;
+                errorCount: z.ZodNumber;
+                databaseQueryCount: z.ZodNumber;
+                fetchCount: z.ZodNumber;
+                spans: z.ZodArray<z.ZodObject<{
+                    key: z.ZodString;
+                    name: z.ZodString;
+                    kind: z.ZodEnum<{
+                        internal: "internal";
+                        server: "server";
+                        client: "client";
+                        producer: "producer";
+                        consumer: "consumer";
+                    }>;
+                    category: z.ZodEnum<{
+                        custom: "custom";
+                        database: "database";
+                        http: "http";
+                        framework: "framework";
+                        other: "other";
+                    }>;
+                    durationMs: z.ZodNumber;
+                    status: z.ZodEnum<{
+                        error: "error";
+                        unset: "unset";
+                        ok: "ok";
+                    }>;
+                    nextSpanType: z.ZodOptional<z.ZodString>;
+                }, z.core.$strict>>;
+                queries: z.ZodArray<z.ZodObject<{
+                    key: z.ZodString;
+                    shape: z.ZodString;
+                    durationMs: z.ZodNullable<z.ZodNumber>;
+                    source: z.ZodEnum<{
+                        drizzle: "drizzle";
+                        prisma: "prisma";
+                        manual: "manual";
+                    }>;
+                    success: z.ZodBoolean;
+                }, z.core.$strict>>;
+                errors: z.ZodArray<z.ZodObject<{
+                    key: z.ZodString;
+                    name: z.ZodString;
+                    message: z.ZodString;
+                    route: z.ZodNullable<z.ZodString>;
+                }, z.core.$strict>>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+        findings: z.ZodArray<z.ZodObject<{
+            key: z.ZodString;
+            ruleId: z.ZodEnum<{
+                "n-plus-one-queries": "n-plus-one-queries";
+                "slow-span": "slow-span";
+                "repeated-external-http": "repeated-external-http";
+                "error-fingerprint": "error-fingerprint";
+            }>;
+            category: z.ZodEnum<{
+                runtime: "runtime";
+                database: "database";
+                http: "http";
+                performance: "performance";
+                errors: "errors";
+            }>;
+            severity: z.ZodEnum<{
+                error: "error";
+                info: "info";
+                warning: "warning";
+            }>;
+            status: z.ZodEnum<{
+                observed: "observed";
+                possible: "possible";
+                "insufficient-evidence": "insufficient-evidence";
+            }>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    findings: z.ZodArray<z.ZodObject<{
+        key: z.ZodString;
+        ruleId: z.ZodEnum<{
+            "n-plus-one-queries": "n-plus-one-queries";
+            "slow-span": "slow-span";
+            "repeated-external-http": "repeated-external-http";
+            "error-fingerprint": "error-fingerprint";
+        }>;
+        category: z.ZodEnum<{
+            runtime: "runtime";
+            database: "database";
+            http: "http";
+            performance: "performance";
+            errors: "errors";
+        }>;
+        severity: z.ZodEnum<{
+            error: "error";
+            info: "info";
+            warning: "warning";
+        }>;
+        status: z.ZodEnum<{
+            observed: "observed";
+            possible: "possible";
+            "insufficient-evidence": "insufficient-evidence";
+        }>;
+    }, z.core.$strict>>;
+    notes: z.ZodArray<z.ZodString>;
+    limitations: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+export declare const regressionStatsSchema: z.ZodObject<{
+    scenarios: z.ZodNumber;
+    samples: z.ZodNumber;
+    verifiedSamples: z.ZodNumber;
+    incompleteSamples: z.ZodNumber;
+    traces: z.ZodNumber;
+    requests: z.ZodNumber;
+    spans: z.ZodNumber;
+    errors: z.ZodNumber;
+    databaseQueries: z.ZodNumber;
+}, z.core.$strict>;
+export declare const commandSnapshotSchema: z.ZodObject<{
+    executable: z.ZodString;
+    args: z.ZodArray<z.ZodString>;
+    exitCode: z.ZodNullable<z.ZodNumber>;
+    signal: z.ZodNullable<z.ZodString>;
+    durationMs: z.ZodNumber;
+}, z.core.$strict>;
+export declare const runCollectorSchema: z.ZodObject<{
+    version: z.ZodString;
+    connected: z.ZodBoolean;
+}, z.core.$strict>;
+export declare const testRunSchema: z.ZodObject<{
+    format: z.ZodLiteral<"stacknext-test-run">;
+    version: z.ZodLiteral<1>;
+    id: z.ZodString;
+    name: z.ZodString;
+    projectName: z.ZodString;
+    status: z.ZodEnum<{
+        running: "running";
+        completed: "completed";
+        failed: "failed";
+        interrupted: "interrupted";
+        incomplete: "incomplete";
+    }>;
+    createdAt: z.ZodNumber;
+    completedAt: z.ZodNullable<z.ZodNumber>;
+    command: z.ZodObject<{
+        executable: z.ZodString;
+        args: z.ZodArray<z.ZodString>;
+        exitCode: z.ZodNullable<z.ZodNumber>;
+        signal: z.ZodNullable<z.ZodString>;
+        durationMs: z.ZodNumber;
+    }, z.core.$strict>;
+    environment: z.ZodObject<{
+        nodeVersion: z.ZodString;
+        nextVersion: z.ZodNullable<z.ZodString>;
+        platform: z.ZodString;
+        arch: z.ZodString;
+        runtime: z.ZodLiteral<"nodejs">;
+        databases: z.ZodArray<z.ZodString>;
+        instrumentation: z.ZodObject<{
+            verbose: z.ZodBoolean;
+            verboseSource: z.ZodString;
+            captureFetch: z.ZodBoolean;
+            captureErrors: z.ZodBoolean;
+        }, z.core.$strict>;
+        sdkVersion: z.ZodString;
+        playwrightVersion: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+    collector: z.ZodObject<{
+        version: z.ZodString;
+        connected: z.ZodBoolean;
+    }, z.core.$strict>;
+    scenarios: z.ZodArray<z.ZodObject<{
+        identity: z.ZodObject<{
+            id: z.ZodString;
+            source: z.ZodEnum<{
+                annotation: "annotation";
+                "test-id": "test-id";
+                title: "title";
+            }>;
+            title: z.ZodString;
+            file: z.ZodString;
+            project: z.ZodString;
+            tags: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>;
+        samples: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            status: z.ZodEnum<{
+                failed: "failed";
+                interrupted: "interrupted";
+                passed: "passed";
+                timedOut: "timedOut";
+                skipped: "skipped";
+            }>;
+            expectedStatus: z.ZodEnum<{
+                failed: "failed";
+                passed: "passed";
+                skipped: "skipped";
+            }>;
+            retry: z.ZodNumber;
+            repeatEachIndex: z.ZodNumber;
+            durationMs: z.ZodNumber;
+            capturedAt: z.ZodNumber;
+            correlation: z.ZodObject<{
+                status: z.ZodEnum<{
+                    incomplete: "incomplete";
+                    verified: "verified";
+                }>;
+                reasons: z.ZodArray<z.ZodString>;
+                traces: z.ZodArray<z.ZodObject<{
+                    traceId: z.ZodString;
+                    injectedSpanId: z.ZodString;
+                    key: z.ZodString;
+                    method: z.ZodNullable<z.ZodString>;
+                    route: z.ZodNullable<z.ZodString>;
+                    rootName: z.ZodString;
+                    statusCode: z.ZodNullable<z.ZodNumber>;
+                    durationMs: z.ZodNumber;
+                    spanCount: z.ZodNumber;
+                    errorCount: z.ZodNumber;
+                    databaseQueryCount: z.ZodNumber;
+                    fetchCount: z.ZodNumber;
+                    spans: z.ZodArray<z.ZodObject<{
+                        key: z.ZodString;
+                        name: z.ZodString;
+                        kind: z.ZodEnum<{
+                            internal: "internal";
+                            server: "server";
+                            client: "client";
+                            producer: "producer";
+                            consumer: "consumer";
+                        }>;
+                        category: z.ZodEnum<{
+                            custom: "custom";
+                            database: "database";
+                            http: "http";
+                            framework: "framework";
+                            other: "other";
+                        }>;
+                        durationMs: z.ZodNumber;
+                        status: z.ZodEnum<{
+                            error: "error";
+                            unset: "unset";
+                            ok: "ok";
+                        }>;
+                        nextSpanType: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strict>>;
+                    queries: z.ZodArray<z.ZodObject<{
+                        key: z.ZodString;
+                        shape: z.ZodString;
+                        durationMs: z.ZodNullable<z.ZodNumber>;
+                        source: z.ZodEnum<{
+                            drizzle: "drizzle";
+                            prisma: "prisma";
+                            manual: "manual";
+                        }>;
+                        success: z.ZodBoolean;
+                    }, z.core.$strict>>;
+                    errors: z.ZodArray<z.ZodObject<{
+                        key: z.ZodString;
+                        name: z.ZodString;
+                        message: z.ZodString;
+                        route: z.ZodNullable<z.ZodString>;
+                    }, z.core.$strict>>;
+                }, z.core.$strict>>;
+            }, z.core.$strict>;
+            findings: z.ZodArray<z.ZodObject<{
+                key: z.ZodString;
+                ruleId: z.ZodEnum<{
+                    "n-plus-one-queries": "n-plus-one-queries";
+                    "slow-span": "slow-span";
+                    "repeated-external-http": "repeated-external-http";
+                    "error-fingerprint": "error-fingerprint";
+                }>;
+                category: z.ZodEnum<{
+                    runtime: "runtime";
+                    database: "database";
+                    http: "http";
+                    performance: "performance";
+                    errors: "errors";
+                }>;
+                severity: z.ZodEnum<{
+                    error: "error";
+                    info: "info";
+                    warning: "warning";
+                }>;
+                status: z.ZodEnum<{
+                    observed: "observed";
+                    possible: "possible";
+                    "insufficient-evidence": "insufficient-evidence";
+                }>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+        findings: z.ZodArray<z.ZodObject<{
+            key: z.ZodString;
+            ruleId: z.ZodEnum<{
+                "n-plus-one-queries": "n-plus-one-queries";
+                "slow-span": "slow-span";
+                "repeated-external-http": "repeated-external-http";
+                "error-fingerprint": "error-fingerprint";
+            }>;
+            category: z.ZodEnum<{
+                runtime: "runtime";
+                database: "database";
+                http: "http";
+                performance: "performance";
+                errors: "errors";
+            }>;
+            severity: z.ZodEnum<{
+                error: "error";
+                info: "info";
+                warning: "warning";
+            }>;
+            status: z.ZodEnum<{
+                observed: "observed";
+                possible: "possible";
+                "insufficient-evidence": "insufficient-evidence";
+            }>;
+        }, z.core.$strict>>;
+        notes: z.ZodArray<z.ZodString>;
+        limitations: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>>;
+    warnings: z.ZodArray<z.ZodString>;
+    notes: z.ZodArray<z.ZodString>;
+    limitations: z.ZodArray<z.ZodString>;
+    stats: z.ZodObject<{
+        scenarios: z.ZodNumber;
+        samples: z.ZodNumber;
+        verifiedSamples: z.ZodNumber;
+        incompleteSamples: z.ZodNumber;
+        traces: z.ZodNumber;
+        requests: z.ZodNumber;
+        spans: z.ZodNumber;
+        errors: z.ZodNumber;
+        databaseQueries: z.ZodNumber;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export declare const baselineSchema: z.ZodObject<{
+    format: z.ZodLiteral<"stacknext-baseline">;
+    version: z.ZodLiteral<1>;
+    id: z.ZodString;
+    name: z.ZodString;
+    projectName: z.ZodString;
+    createdAt: z.ZodNumber;
+    sourceRunId: z.ZodString;
+    environment: z.ZodObject<{
+        nodeVersion: z.ZodString;
+        nextVersion: z.ZodNullable<z.ZodString>;
+        platform: z.ZodString;
+        arch: z.ZodString;
+        runtime: z.ZodLiteral<"nodejs">;
+        databases: z.ZodArray<z.ZodString>;
+        instrumentation: z.ZodObject<{
+            verbose: z.ZodBoolean;
+            verboseSource: z.ZodString;
+            captureFetch: z.ZodBoolean;
+            captureErrors: z.ZodBoolean;
+        }, z.core.$strict>;
+        sdkVersion: z.ZodString;
+        playwrightVersion: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+    scenarios: z.ZodArray<z.ZodObject<{
+        identity: z.ZodObject<{
+            id: z.ZodString;
+            source: z.ZodEnum<{
+                annotation: "annotation";
+                "test-id": "test-id";
+                title: "title";
+            }>;
+            title: z.ZodString;
+            file: z.ZodString;
+            project: z.ZodString;
+            tags: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>;
+        samples: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            status: z.ZodEnum<{
+                failed: "failed";
+                interrupted: "interrupted";
+                passed: "passed";
+                timedOut: "timedOut";
+                skipped: "skipped";
+            }>;
+            expectedStatus: z.ZodEnum<{
+                failed: "failed";
+                passed: "passed";
+                skipped: "skipped";
+            }>;
+            retry: z.ZodNumber;
+            repeatEachIndex: z.ZodNumber;
+            durationMs: z.ZodNumber;
+            capturedAt: z.ZodNumber;
+            correlation: z.ZodObject<{
+                status: z.ZodEnum<{
+                    incomplete: "incomplete";
+                    verified: "verified";
+                }>;
+                reasons: z.ZodArray<z.ZodString>;
+                traces: z.ZodArray<z.ZodObject<{
+                    traceId: z.ZodString;
+                    injectedSpanId: z.ZodString;
+                    key: z.ZodString;
+                    method: z.ZodNullable<z.ZodString>;
+                    route: z.ZodNullable<z.ZodString>;
+                    rootName: z.ZodString;
+                    statusCode: z.ZodNullable<z.ZodNumber>;
+                    durationMs: z.ZodNumber;
+                    spanCount: z.ZodNumber;
+                    errorCount: z.ZodNumber;
+                    databaseQueryCount: z.ZodNumber;
+                    fetchCount: z.ZodNumber;
+                    spans: z.ZodArray<z.ZodObject<{
+                        key: z.ZodString;
+                        name: z.ZodString;
+                        kind: z.ZodEnum<{
+                            internal: "internal";
+                            server: "server";
+                            client: "client";
+                            producer: "producer";
+                            consumer: "consumer";
+                        }>;
+                        category: z.ZodEnum<{
+                            custom: "custom";
+                            database: "database";
+                            http: "http";
+                            framework: "framework";
+                            other: "other";
+                        }>;
+                        durationMs: z.ZodNumber;
+                        status: z.ZodEnum<{
+                            error: "error";
+                            unset: "unset";
+                            ok: "ok";
+                        }>;
+                        nextSpanType: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strict>>;
+                    queries: z.ZodArray<z.ZodObject<{
+                        key: z.ZodString;
+                        shape: z.ZodString;
+                        durationMs: z.ZodNullable<z.ZodNumber>;
+                        source: z.ZodEnum<{
+                            drizzle: "drizzle";
+                            prisma: "prisma";
+                            manual: "manual";
+                        }>;
+                        success: z.ZodBoolean;
+                    }, z.core.$strict>>;
+                    errors: z.ZodArray<z.ZodObject<{
+                        key: z.ZodString;
+                        name: z.ZodString;
+                        message: z.ZodString;
+                        route: z.ZodNullable<z.ZodString>;
+                    }, z.core.$strict>>;
+                }, z.core.$strict>>;
+            }, z.core.$strict>;
+            findings: z.ZodArray<z.ZodObject<{
+                key: z.ZodString;
+                ruleId: z.ZodEnum<{
+                    "n-plus-one-queries": "n-plus-one-queries";
+                    "slow-span": "slow-span";
+                    "repeated-external-http": "repeated-external-http";
+                    "error-fingerprint": "error-fingerprint";
+                }>;
+                category: z.ZodEnum<{
+                    runtime: "runtime";
+                    database: "database";
+                    http: "http";
+                    performance: "performance";
+                    errors: "errors";
+                }>;
+                severity: z.ZodEnum<{
+                    error: "error";
+                    info: "info";
+                    warning: "warning";
+                }>;
+                status: z.ZodEnum<{
+                    observed: "observed";
+                    possible: "possible";
+                    "insufficient-evidence": "insufficient-evidence";
+                }>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+        findings: z.ZodArray<z.ZodObject<{
+            key: z.ZodString;
+            ruleId: z.ZodEnum<{
+                "n-plus-one-queries": "n-plus-one-queries";
+                "slow-span": "slow-span";
+                "repeated-external-http": "repeated-external-http";
+                "error-fingerprint": "error-fingerprint";
+            }>;
+            category: z.ZodEnum<{
+                runtime: "runtime";
+                database: "database";
+                http: "http";
+                performance: "performance";
+                errors: "errors";
+            }>;
+            severity: z.ZodEnum<{
+                error: "error";
+                info: "info";
+                warning: "warning";
+            }>;
+            status: z.ZodEnum<{
+                observed: "observed";
+                possible: "possible";
+                "insufficient-evidence": "insufficient-evidence";
+            }>;
+        }, z.core.$strict>>;
+        notes: z.ZodArray<z.ZodString>;
+        limitations: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>>;
+    warnings: z.ZodArray<z.ZodString>;
+    notes: z.ZodArray<z.ZodString>;
+    limitations: z.ZodArray<z.ZodString>;
+    stats: z.ZodObject<{
+        scenarios: z.ZodNumber;
+        samples: z.ZodNumber;
+        verifiedSamples: z.ZodNumber;
+        incompleteSamples: z.ZodNumber;
+        traces: z.ZodNumber;
+        requests: z.ZodNumber;
+        spans: z.ZodNumber;
+        errors: z.ZodNumber;
+        databaseQueries: z.ZodNumber;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export declare const comparisonOptionsSchema: z.ZodObject<{
+    minSamples: z.ZodNumber;
+    durationRegressionPct: z.ZodNumber;
+    durationRegressionMs: z.ZodNumber;
+    durationImprovementPct: z.ZodNumber;
+    durationImprovementMs: z.ZodNumber;
+    countRegressionMin: z.ZodNumber;
+    ignoreEnvironment: z.ZodBoolean;
+}, z.core.$strict>;
+export declare const environmentDifferenceSchema: z.ZodObject<{
+    field: z.ZodString;
+    baseline: z.ZodString;
+    candidate: z.ZodString;
+}, z.core.$strict>;
+export declare const regressionMetricSchema: z.ZodObject<{
+    key: z.ZodString;
+    label: z.ZodString;
+    kind: z.ZodEnum<{
+        duration: "duration";
+        count: "count";
+        "test-status": "test-status";
+        error: "error";
+        finding: "finding";
+    }>;
+    status: z.ZodEnum<{
+        improved: "improved";
+        regressed: "regressed";
+        unchanged: "unchanged";
+        inconclusive: "inconclusive";
+    }>;
+    severity: z.ZodEnum<{
+        high: "high";
+        medium: "medium";
+        low: "low";
+        none: "none";
+    }>;
+    baselineValue: z.ZodNullable<z.ZodNumber>;
+    candidateValue: z.ZodNullable<z.ZodNumber>;
+    delta: z.ZodNullable<z.ZodNumber>;
+    percent: z.ZodNullable<z.ZodNumber>;
+    sampleCount: z.ZodNumber;
+    note: z.ZodOptional<z.ZodString>;
+    unmeasured: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strict>;
+export declare const scenarioComparisonSideSchema: z.ZodObject<{
+    samples: z.ZodNumber;
+    verifiedSamples: z.ZodNumber;
+    incompleteSamples: z.ZodNumber;
+    traces: z.ZodNumber;
+    findings: z.ZodNumber;
+}, z.core.$strict>;
+export declare const scenarioComparisonSchema: z.ZodObject<{
+    scenarioId: z.ZodString;
+    title: z.ZodString;
+    file: z.ZodString;
+    project: z.ZodString;
+    status: z.ZodEnum<{
+        improved: "improved";
+        regressed: "regressed";
+        unchanged: "unchanged";
+        inconclusive: "inconclusive";
+    }>;
+    severity: z.ZodEnum<{
+        high: "high";
+        medium: "medium";
+        low: "low";
+        none: "none";
+    }>;
+    reasons: z.ZodArray<z.ZodString>;
+    metrics: z.ZodArray<z.ZodObject<{
+        key: z.ZodString;
+        label: z.ZodString;
+        kind: z.ZodEnum<{
+            duration: "duration";
+            count: "count";
+            "test-status": "test-status";
+            error: "error";
+            finding: "finding";
+        }>;
+        status: z.ZodEnum<{
+            improved: "improved";
+            regressed: "regressed";
+            unchanged: "unchanged";
+            inconclusive: "inconclusive";
+        }>;
+        severity: z.ZodEnum<{
+            high: "high";
+            medium: "medium";
+            low: "low";
+            none: "none";
+        }>;
+        baselineValue: z.ZodNullable<z.ZodNumber>;
+        candidateValue: z.ZodNullable<z.ZodNumber>;
+        delta: z.ZodNullable<z.ZodNumber>;
+        percent: z.ZodNullable<z.ZodNumber>;
+        sampleCount: z.ZodNumber;
+        note: z.ZodOptional<z.ZodString>;
+        unmeasured: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strict>>;
+    baseline: z.ZodObject<{
+        samples: z.ZodNumber;
+        verifiedSamples: z.ZodNumber;
+        incompleteSamples: z.ZodNumber;
+        traces: z.ZodNumber;
+        findings: z.ZodNumber;
+    }, z.core.$strict>;
+    candidate: z.ZodObject<{
+        samples: z.ZodNumber;
+        verifiedSamples: z.ZodNumber;
+        incompleteSamples: z.ZodNumber;
+        traces: z.ZodNumber;
+        findings: z.ZodNumber;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export declare const comparisonSummarySchema: z.ZodObject<{
+    scenarios: z.ZodNumber;
+    regressed: z.ZodNumber;
+    improved: z.ZodNumber;
+    unchanged: z.ZodNumber;
+    inconclusive: z.ZodNumber;
+}, z.core.$strict>;
+export declare const comparisonSchema: z.ZodObject<{
+    format: z.ZodLiteral<"stacknext-comparison">;
+    version: z.ZodLiteral<1>;
+    id: z.ZodString;
+    projectName: z.ZodString;
+    createdAt: z.ZodNumber;
+    baselineId: z.ZodString;
+    candidateId: z.ZodString;
+    status: z.ZodEnum<{
+        improved: "improved";
+        regressed: "regressed";
+        unchanged: "unchanged";
+        inconclusive: "inconclusive";
+    }>;
+    severity: z.ZodEnum<{
+        high: "high";
+        medium: "medium";
+        low: "low";
+        none: "none";
+    }>;
+    environment: z.ZodObject<{
+        compatible: z.ZodBoolean;
+        ignored: z.ZodBoolean;
+        differences: z.ZodArray<z.ZodObject<{
+            field: z.ZodString;
+            baseline: z.ZodString;
+            candidate: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+    options: z.ZodObject<{
+        minSamples: z.ZodNumber;
+        durationRegressionPct: z.ZodNumber;
+        durationRegressionMs: z.ZodNumber;
+        durationImprovementPct: z.ZodNumber;
+        durationImprovementMs: z.ZodNumber;
+        countRegressionMin: z.ZodNumber;
+        ignoreEnvironment: z.ZodBoolean;
+    }, z.core.$strict>;
+    summary: z.ZodObject<{
+        scenarios: z.ZodNumber;
+        regressed: z.ZodNumber;
+        improved: z.ZodNumber;
+        unchanged: z.ZodNumber;
+        inconclusive: z.ZodNumber;
+    }, z.core.$strict>;
+    scenarios: z.ZodArray<z.ZodObject<{
+        scenarioId: z.ZodString;
+        title: z.ZodString;
+        file: z.ZodString;
+        project: z.ZodString;
+        status: z.ZodEnum<{
+            improved: "improved";
+            regressed: "regressed";
+            unchanged: "unchanged";
+            inconclusive: "inconclusive";
+        }>;
+        severity: z.ZodEnum<{
+            high: "high";
+            medium: "medium";
+            low: "low";
+            none: "none";
+        }>;
+        reasons: z.ZodArray<z.ZodString>;
+        metrics: z.ZodArray<z.ZodObject<{
+            key: z.ZodString;
+            label: z.ZodString;
+            kind: z.ZodEnum<{
+                duration: "duration";
+                count: "count";
+                "test-status": "test-status";
+                error: "error";
+                finding: "finding";
+            }>;
+            status: z.ZodEnum<{
+                improved: "improved";
+                regressed: "regressed";
+                unchanged: "unchanged";
+                inconclusive: "inconclusive";
+            }>;
+            severity: z.ZodEnum<{
+                high: "high";
+                medium: "medium";
+                low: "low";
+                none: "none";
+            }>;
+            baselineValue: z.ZodNullable<z.ZodNumber>;
+            candidateValue: z.ZodNullable<z.ZodNumber>;
+            delta: z.ZodNullable<z.ZodNumber>;
+            percent: z.ZodNullable<z.ZodNumber>;
+            sampleCount: z.ZodNumber;
+            note: z.ZodOptional<z.ZodString>;
+            unmeasured: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strict>>;
+        baseline: z.ZodObject<{
+            samples: z.ZodNumber;
+            verifiedSamples: z.ZodNumber;
+            incompleteSamples: z.ZodNumber;
+            traces: z.ZodNumber;
+            findings: z.ZodNumber;
+        }, z.core.$strict>;
+        candidate: z.ZodObject<{
+            samples: z.ZodNumber;
+            verifiedSamples: z.ZodNumber;
+            incompleteSamples: z.ZodNumber;
+            traces: z.ZodNumber;
+            findings: z.ZodNumber;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+    warnings: z.ZodArray<z.ZodString>;
+    limitations: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+export declare const traceReferenceSchema: z.ZodObject<{
+    traceId: z.ZodString;
+    injectedSpanId: z.ZodString;
+}, z.core.$strict>;
+export declare const sampleSubmissionSchema: z.ZodObject<{
+    id: z.ZodString;
+    status: z.ZodEnum<{
+        failed: "failed";
+        interrupted: "interrupted";
+        passed: "passed";
+        timedOut: "timedOut";
+        skipped: "skipped";
+    }>;
+    expectedStatus: z.ZodEnum<{
+        failed: "failed";
+        passed: "passed";
+        skipped: "skipped";
+    }>;
+    retry: z.ZodNumber;
+    repeatEachIndex: z.ZodNumber;
+    durationMs: z.ZodNumber;
+    capturedAt: z.ZodNumber;
+    traces: z.ZodArray<z.ZodObject<{
+        traceId: z.ZodString;
+        injectedSpanId: z.ZodString;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export declare const createRunRequestSchema: z.ZodObject<{
+    name: z.ZodString;
+    projectName: z.ZodString;
+    environment: z.ZodObject<{
+        nodeVersion: z.ZodString;
+        nextVersion: z.ZodNullable<z.ZodString>;
+        platform: z.ZodString;
+        arch: z.ZodString;
+        runtime: z.ZodLiteral<"nodejs">;
+        databases: z.ZodArray<z.ZodString>;
+        instrumentation: z.ZodObject<{
+            verbose: z.ZodBoolean;
+            verboseSource: z.ZodString;
+            captureFetch: z.ZodBoolean;
+            captureErrors: z.ZodBoolean;
+        }, z.core.$strict>;
+        sdkVersion: z.ZodString;
+        playwrightVersion: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+    collectorVersion: z.ZodString;
+    command: z.ZodObject<{
+        executable: z.ZodString;
+        args: z.ZodArray<z.ZodString>;
+        exitCode: z.ZodNullable<z.ZodNumber>;
+        signal: z.ZodNullable<z.ZodString>;
+        durationMs: z.ZodNumber;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export declare const submitSampleRequestSchema: z.ZodObject<{
+    scenario: z.ZodObject<{
+        id: z.ZodString;
+        source: z.ZodEnum<{
+            annotation: "annotation";
+            "test-id": "test-id";
+            title: "title";
+        }>;
+        title: z.ZodString;
+        file: z.ZodString;
+        project: z.ZodString;
+        tags: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>;
+    sample: z.ZodObject<{
+        id: z.ZodString;
+        status: z.ZodEnum<{
+            failed: "failed";
+            interrupted: "interrupted";
+            passed: "passed";
+            timedOut: "timedOut";
+            skipped: "skipped";
+        }>;
+        expectedStatus: z.ZodEnum<{
+            failed: "failed";
+            passed: "passed";
+            skipped: "skipped";
+        }>;
+        retry: z.ZodNumber;
+        repeatEachIndex: z.ZodNumber;
+        durationMs: z.ZodNumber;
+        capturedAt: z.ZodNumber;
+        traces: z.ZodArray<z.ZodObject<{
+            traceId: z.ZodString;
+            injectedSpanId: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export declare const completeRunRequestSchema: z.ZodObject<{
+    status: z.ZodEnum<{
+        completed: "completed";
+        failed: "failed";
+        interrupted: "interrupted";
+        incomplete: "incomplete";
+    }>;
+    warnings: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    command: z.ZodOptional<z.ZodObject<{
+        executable: z.ZodString;
+        args: z.ZodArray<z.ZodString>;
+        exitCode: z.ZodNullable<z.ZodNumber>;
+        signal: z.ZodNullable<z.ZodString>;
+        durationMs: z.ZodNumber;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type DatabaseName = z.infer<typeof databaseNameSchema>;
+export type EnvironmentSnapshot = z.infer<typeof environmentSnapshotSchema>;
+export type ScenarioIdentity = z.infer<typeof scenarioIdentitySchema>;
+export type CapturedSpan = z.infer<typeof capturedSpanSchema>;
+export type CapturedQuery = z.infer<typeof capturedQuerySchema>;
+export type CapturedError = z.infer<typeof capturedErrorSchema>;
+export type CapturedFinding = z.infer<typeof capturedFindingSchema>;
+export type CapturedTrace = z.infer<typeof capturedTraceSchema>;
+export type CapturedSample = z.infer<typeof capturedSampleSchema>;
+export type CapturedScenario = z.infer<typeof scenarioSchema>;
+export type RegressionStats = z.infer<typeof regressionStatsSchema>;
+export type CommandSnapshot = z.infer<typeof commandSnapshotSchema>;
+export type TestRun = z.infer<typeof testRunSchema>;
+export type Baseline = z.infer<typeof baselineSchema>;
+export type ComparisonOptions = z.infer<typeof comparisonOptionsSchema>;
+export type EnvironmentDifference = z.infer<typeof environmentDifferenceSchema>;
+export type RegressionMetric = z.infer<typeof regressionMetricSchema>;
+export type ScenarioComparison = z.infer<typeof scenarioComparisonSchema>;
+export type ComparisonSummary = z.infer<typeof comparisonSummarySchema>;
+export type Comparison = z.infer<typeof comparisonSchema>;
+export type TraceReference = z.infer<typeof traceReferenceSchema>;
+export type SampleSubmission = z.infer<typeof sampleSubmissionSchema>;
+export type CreateRunRequest = z.infer<typeof createRunRequestSchema>;
+export type SubmitSampleRequest = z.infer<typeof submitSampleRequestSchema>;
+export type CompleteRunRequest = z.infer<typeof completeRunRequestSchema>;
+export interface RunSummary {
+    id: string;
+    name: string;
+    projectName: string;
+    status: TestRun['status'];
+    createdAt: number;
+    completedAt: number | null;
+    durationMs: number | null;
+    scenarios: number;
+    samples: number;
+    verifiedSamples: number;
+    incompleteSamples: number;
+    environment: EnvironmentSnapshot;
+}
+export interface BaselineSummary {
+    id: string;
+    name: string;
+    projectName: string;
+    createdAt: number;
+    sourceRunId: string;
+    scenarios: number;
+    samples: number;
+    environment: EnvironmentSnapshot;
+}
+export interface ComparisonSummaryItem {
+    id: string;
+    projectName: string;
+    baselineId: string;
+    candidateId: string;
+    createdAt: number;
+    status: Comparison['status'];
+    severity: Comparison['severity'];
+    summary: ComparisonSummary;
+    environmentCompatible: boolean;
+}
+//# sourceMappingURL=schema.d.ts.map