@bryan-thompson/inspector-assessment-client 1.32.2 → 1.32.3

package/lib/lib/assessment/jsonlEventSchemas.d.ts

@@ -0,0 +1,1667 @@
+/**
+ * Zod Schemas for JSONL Event Types
+ *
+ * Runtime validation schemas for all 13 JSONL event types emitted during
+ * CLI assessment runs. Enables type-safe parsing for external consumers.
+ *
+ * @module assessment/jsonlEventSchemas
+ * @see scripts/lib/jsonl-events.ts - TypeScript interface definitions
+ * @see docs/JSONL_EVENTS_REFERENCE.md - Event documentation
+ */
+import { z } from "zod";
+import { ZOD_SCHEMA_VERSION, TransportTypeSchema } from "../../lib/assessment/sharedSchemas.js";
+export { ZOD_SCHEMA_VERSION, TransportTypeSchema };
+/**
+ * Schema for module completion status.
+ */
+export declare const ModuleStatusSchema: z.ZodEnum<["PASS", "FAIL", "NEED_MORE_INFO"]>;
+export type ModuleStatus = z.infer<typeof ModuleStatusSchema>;
+/**
+ * Schema for confidence level (lowercase).
+ */
+export declare const ConfidenceLevelSchema: z.ZodEnum<["high", "medium", "low"]>;
+export type ConfidenceLevel = z.infer<typeof ConfidenceLevelSchema>;
+/**
+ * Schema for risk level (uppercase).
+ */
+export declare const RiskLevelSchema: z.ZodEnum<["HIGH", "MEDIUM", "LOW"]>;
+export type RiskLevel = z.infer<typeof RiskLevelSchema>;
+/**
+ * Schema for AUP violation severity.
+ */
+export declare const SeveritySchema: z.ZodEnum<["CRITICAL", "HIGH", "MEDIUM"]>;
+export type Severity = z.infer<typeof SeveritySchema>;
+/**
+ * Schema for AUP violation location.
+ */
+export declare const LocationSchema: z.ZodEnum<["tool_name", "tool_description", "readme", "source_code"]>;
+export type Location = z.infer<typeof LocationSchema>;
+/**
+ * Schema for annotation field types.
+ */
+export declare const AnnotationFieldSchema: z.ZodEnum<["readOnlyHint", "destructiveHint"]>;
+export type AnnotationField = z.infer<typeof AnnotationFieldSchema>;
+/**
+ * Schema for modules_configured reason.
+ */
+export declare const ModulesConfiguredReasonSchema: z.ZodEnum<["skip-modules", "only-modules", "default"]>;
+export type ModulesConfiguredReason = z.infer<typeof ModulesConfiguredReasonSchema>;
+/**
+ * Schema for tool parameter information.
+ */
+export declare const ToolParamSchema: z.ZodObject<{
+    name: z.ZodString;
+    type: z.ZodString;
+    required: z.ZodBoolean;
+    description: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    name?: string;
+    description?: string;
+    type?: string;
+    required?: boolean;
+}, {
+    name?: string;
+    description?: string;
+    type?: string;
+    required?: boolean;
+}>;
+export type ToolParam = z.infer<typeof ToolParamSchema>;
+/**
+ * Schema for tool annotations object.
+ */
+export declare const ToolAnnotationsSchema: z.ZodNullable<z.ZodObject<{
+    readOnlyHint: z.ZodOptional<z.ZodBoolean>;
+    destructiveHint: z.ZodOptional<z.ZodBoolean>;
+    idempotentHint: z.ZodOptional<z.ZodBoolean>;
+    openWorldHint: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    readOnlyHint?: boolean;
+    destructiveHint?: boolean;
+    idempotentHint?: boolean;
+    openWorldHint?: boolean;
+}, {
+    readOnlyHint?: boolean;
+    destructiveHint?: boolean;
+    idempotentHint?: boolean;
+    openWorldHint?: boolean;
+}>>;
+export type ToolAnnotations = z.infer<typeof ToolAnnotationsSchema>;
+/**
+ * Schema for inferred behavior in annotation_missing events.
+ */
+export declare const InferredBehaviorSchema: z.ZodObject<{
+    expectedReadOnly: z.ZodBoolean;
+    expectedDestructive: z.ZodBoolean;
+    reason: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    reason?: string;
+    expectedReadOnly?: boolean;
+    expectedDestructive?: boolean;
+}, {
+    reason?: string;
+    expectedReadOnly?: boolean;
+    expectedDestructive?: boolean;
+}>;
+export type InferredBehavior = z.infer<typeof InferredBehaviorSchema>;
+/**
+ * Schema for sampled AUP violation.
+ */
+export declare const AUPViolationSampleSchema: z.ZodObject<{
+    category: z.ZodString;
+    categoryName: z.ZodString;
+    severity: z.ZodEnum<["CRITICAL", "HIGH", "MEDIUM"]>;
+    matchedText: z.ZodString;
+    location: z.ZodEnum<["tool_name", "tool_description", "readme", "source_code"]>;
+    confidence: z.ZodEnum<["high", "medium", "low"]>;
+}, "strip", z.ZodTypeAny, {
+    category?: string;
+    confidence?: "high" | "medium" | "low";
+    categoryName?: string;
+    location?: "tool_name" | "tool_description" | "readme" | "source_code";
+    severity?: "MEDIUM" | "HIGH" | "CRITICAL";
+    matchedText?: string;
+}, {
+    category?: string;
+    confidence?: "high" | "medium" | "low";
+    categoryName?: string;
+    location?: "tool_name" | "tool_description" | "readme" | "source_code";
+    severity?: "MEDIUM" | "HIGH" | "CRITICAL";
+    matchedText?: string;
+}>;
+export type AUPViolationSample = z.infer<typeof AUPViolationSampleSchema>;
+/**
+ * Schema for AUP violation metrics.
+ */
+export declare const AUPViolationMetricsSchema: z.ZodObject<{
+    total: z.ZodNumber;
+    critical: z.ZodNumber;
+    high: z.ZodNumber;
+    medium: z.ZodNumber;
+    byCategory: z.ZodRecord<z.ZodString, z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    high?: number;
+    medium?: number;
+    critical?: number;
+    total?: number;
+    byCategory?: Record<string, number>;
+}, {
+    high?: number;
+    medium?: number;
+    critical?: number;
+    total?: number;
+    byCategory?: Record<string, number>;
+}>;
+export type AUPViolationMetrics = z.infer<typeof AUPViolationMetricsSchema>;
+/**
+ * Schema for AUP scanned locations.
+ */
+export declare const AUPScannedLocationsSchema: z.ZodObject<{
+    toolNames: z.ZodBoolean;
+    toolDescriptions: z.ZodBoolean;
+    readme: z.ZodBoolean;
+    sourceCode: z.ZodBoolean;
+}, "strip", z.ZodTypeAny, {
+    readme?: boolean;
+    toolNames?: boolean;
+    toolDescriptions?: boolean;
+    sourceCode?: boolean;
+}, {
+    readme?: boolean;
+    toolNames?: boolean;
+    toolDescriptions?: boolean;
+    sourceCode?: boolean;
+}>;
+export type AUPScannedLocations = z.infer<typeof AUPScannedLocationsSchema>;
+/**
+ * Base schema for all JSONL events.
+ * All events include version (software version) and schemaVersion (event schema version).
+ */
+export declare const BaseEventSchema: z.ZodObject<{
+    /** Inspector software version (e.g., "1.29.0") */
+    version: z.ZodString;
+    /** Event schema version (integer, increment when structure changes) */
+    schemaVersion: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    version?: string;
+    schemaVersion?: number;
+}, {
+    version?: string;
+    schemaVersion?: number;
+}>;
+export type BaseEvent = z.infer<typeof BaseEventSchema>;
+/**
+ * 1. ServerConnectedEvent - Emitted after successful MCP connection.
+ */
+export declare const ServerConnectedEventSchema: z.ZodObject<{
+    /** Inspector software version (e.g., "1.29.0") */
+    version: z.ZodString;
+    /** Event schema version (integer, increment when structure changes) */
+    schemaVersion: z.ZodNumber;
+} & {
+    event: z.ZodLiteral<"server_connected">;
+    serverName: z.ZodString;
+    transport: z.ZodEnum<["stdio", "http", "sse"]>;
+}, "strip", z.ZodTypeAny, {
+    version?: string;
+    event?: "server_connected";
+    schemaVersion?: number;
+    serverName?: string;
+    transport?: "http" | "sse" | "stdio";
+}, {
+    version?: string;
+    event?: "server_connected";
+    schemaVersion?: number;
+    serverName?: string;
+    transport?: "http" | "sse" | "stdio";
+}>;
+export type ServerConnectedEvent = z.infer<typeof ServerConnectedEventSchema>;
+/**
+ * 2. ToolDiscoveredEvent - Emitted for each tool found.
+ */
+export declare const ToolDiscoveredEventSchema: z.ZodObject<{
+    /** Inspector software version (e.g., "1.29.0") */
+    version: z.ZodString;
+    /** Event schema version (integer, increment when structure changes) */
+    schemaVersion: z.ZodNumber;
+} & {
+    event: z.ZodLiteral<"tool_discovered">;
+    name: z.ZodString;
+    description: z.ZodNullable<z.ZodString>;
+    params: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        type: z.ZodString;
+        required: z.ZodBoolean;
+        description: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        name?: string;
+        description?: string;
+        type?: string;
+        required?: boolean;
+    }, {
+        name?: string;
+        description?: string;
+        type?: string;
+        required?: boolean;
+    }>, "many">;
+    annotations: z.ZodNullable<z.ZodObject<{
+        readOnlyHint: z.ZodOptional<z.ZodBoolean>;
+        destructiveHint: z.ZodOptional<z.ZodBoolean>;
+        idempotentHint: z.ZodOptional<z.ZodBoolean>;
+        openWorldHint: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        readOnlyHint?: boolean;
+        destructiveHint?: boolean;
+        idempotentHint?: boolean;
+        openWorldHint?: boolean;
+    }, {
+        readOnlyHint?: boolean;
+        destructiveHint?: boolean;
+        idempotentHint?: boolean;
+        openWorldHint?: boolean;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    name?: string;
+    version?: string;
+    description?: string;
+    annotations?: {
+        readOnlyHint?: boolean;
+        destructiveHint?: boolean;
+        idempotentHint?: boolean;
+        openWorldHint?: boolean;
+    };
+    event?: "tool_discovered";
+    schemaVersion?: number;
+    params?: {
+        name?: string;
+        description?: string;
+        type?: string;
+        required?: boolean;
+    }[];
+}, {
+    name?: string;
+    version?: string;
+    description?: string;
+    annotations?: {
+        readOnlyHint?: boolean;
+        destructiveHint?: boolean;
+        idempotentHint?: boolean;
+        openWorldHint?: boolean;
+    };
+    event?: "tool_discovered";
+    schemaVersion?: number;
+    params?: {
+        name?: string;
+        description?: string;
+        type?: string;
+        required?: boolean;
+    }[];
+}>;
+export type ToolDiscoveredEvent = z.infer<typeof ToolDiscoveredEventSchema>;
+/**
+ * 3. ToolsDiscoveryCompleteEvent - Emitted after all tools listed.
+ */
+export declare const ToolsDiscoveryCompleteEventSchema: z.ZodObject<{
+    /** Inspector software version (e.g., "1.29.0") */
+    version: z.ZodString;
+    /** Event schema version (integer, increment when structure changes) */
+    schemaVersion: z.ZodNumber;
+} & {
+    event: z.ZodLiteral<"tools_discovery_complete">;
+    count: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    version?: string;
+    count?: number;
+    event?: "tools_discovery_complete";
+    schemaVersion?: number;
+}, {
+    version?: string;
+    count?: number;
+    event?: "tools_discovery_complete";
+    schemaVersion?: number;
+}>;
+export type ToolsDiscoveryCompleteEvent = z.infer<typeof ToolsDiscoveryCompleteEventSchema>;
+/**
+ * 4. ModulesConfiguredEvent - Emitted when --skip-modules or --only-modules used.
+ */
+export declare const ModulesConfiguredEventSchema: z.ZodObject<{
+    /** Inspector software version (e.g., "1.29.0") */
+    version: z.ZodString;
+    /** Event schema version (integer, increment when structure changes) */
+    schemaVersion: z.ZodNumber;
+} & {
+    event: z.ZodLiteral<"modules_configured">;
+    enabled: z.ZodArray<z.ZodString, "many">;
+    skipped: z.ZodArray<z.ZodString, "many">;
+    reason: z.ZodEnum<["skip-modules", "only-modules", "default"]>;
+}, "strip", z.ZodTypeAny, {
+    version?: string;
+    enabled?: string[];
+    event?: "modules_configured";
+    schemaVersion?: number;
+    reason?: "default" | "skip-modules" | "only-modules";
+    skipped?: string[];
+}, {
+    version?: string;
+    enabled?: string[];
+    event?: "modules_configured";
+    schemaVersion?: number;
+    reason?: "default" | "skip-modules" | "only-modules";
+    skipped?: string[];
+}>;
+export type ModulesConfiguredEvent = z.infer<typeof ModulesConfiguredEventSchema>;
+/**
+ * 5. ModuleStartedEvent - Emitted when a module begins execution.
+ */
+export declare const ModuleStartedEventSchema: z.ZodObject<{
+    /** Inspector software version (e.g., "1.29.0") */
+    version: z.ZodString;
+    /** Event schema version (integer, increment when structure changes) */
+    schemaVersion: z.ZodNumber;
+} & {
+    event: z.ZodLiteral<"module_started">;
+    module: z.ZodString;
+    estimatedTests: z.ZodNumber;
+    toolCount: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    version?: string;
+    module?: string;
+    event?: "module_started";
+    schemaVersion?: number;
+    estimatedTests?: number;
+    toolCount?: number;
+}, {
+    version?: string;
+    module?: string;
+    event?: "module_started";
+    schemaVersion?: number;
+    estimatedTests?: number;
+    toolCount?: number;
+}>;
+export type ModuleStartedEvent = z.infer<typeof ModuleStartedEventSchema>;
+/**
+ * 6. TestBatchEvent - Emitted during test execution with progress.
+ */
+export declare const TestBatchEventSchema: z.ZodObject<{
+    /** Inspector software version (e.g., "1.29.0") */
+    version: z.ZodString;
+    /** Event schema version (integer, increment when structure changes) */
+    schemaVersion: z.ZodNumber;
+} & {
+    event: z.ZodLiteral<"test_batch">;
+    module: z.ZodString;
+    completed: z.ZodNumber;
+    total: z.ZodNumber;
+    batchSize: z.ZodNumber;
+    elapsed: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    version?: string;
+    completed?: number;
+    module?: string;
+    event?: "test_batch";
+    schemaVersion?: number;
+    total?: number;
+    batchSize?: number;
+    elapsed?: number;
+}, {
+    version?: string;
+    completed?: number;
+    module?: string;
+    event?: "test_batch";
+    schemaVersion?: number;
+    total?: number;
+    batchSize?: number;
+    elapsed?: number;
+}>;
+export type TestBatchEvent = z.infer<typeof TestBatchEventSchema>;
+/**
+ * 7. ModuleCompleteEvent - Emitted after module finishes with summary.
+ * Includes optional AUP enrichment when module=aup.
+ */
+export declare const ModuleCompleteEventSchema: z.ZodObject<{
+    /** Inspector software version (e.g., "1.29.0") */
+    version: z.ZodString;
+    /** Event schema version (integer, increment when structure changes) */
+    schemaVersion: z.ZodNumber;
+} & {
+    event: z.ZodLiteral<"module_complete">;
+    module: z.ZodString;
+    status: z.ZodEnum<["PASS", "FAIL", "NEED_MORE_INFO"]>;
+    score: z.ZodNumber;
+    testsRun: z.ZodNumber;
+    duration: z.ZodNumber;
+    violationsSample: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        category: z.ZodString;
+        categoryName: z.ZodString;
+        severity: z.ZodEnum<["CRITICAL", "HIGH", "MEDIUM"]>;
+        matchedText: z.ZodString;
+        location: z.ZodEnum<["tool_name", "tool_description", "readme", "source_code"]>;
+        confidence: z.ZodEnum<["high", "medium", "low"]>;
+    }, "strip", z.ZodTypeAny, {
+        category?: string;
+        confidence?: "high" | "medium" | "low";
+        categoryName?: string;
+        location?: "tool_name" | "tool_description" | "readme" | "source_code";
+        severity?: "MEDIUM" | "HIGH" | "CRITICAL";
+        matchedText?: string;
+    }, {
+        category?: string;
+        confidence?: "high" | "medium" | "low";
+        categoryName?: string;
+        location?: "tool_name" | "tool_description" | "readme" | "source_code";
+        severity?: "MEDIUM" | "HIGH" | "CRITICAL";
+        matchedText?: string;
+    }>, "many">>;
+    samplingNote: z.ZodOptional<z.ZodString>;
+    violationMetrics: z.ZodOptional<z.ZodObject<{
+        total: z.ZodNumber;
+        critical: z.ZodNumber;
+        high: z.ZodNumber;
+        medium: z.ZodNumber;
+        byCategory: z.ZodRecord<z.ZodString, z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        high?: number;
+        medium?: number;
+        critical?: number;
+        total?: number;
+        byCategory?: Record<string, number>;
+    }, {
+        high?: number;
+        medium?: number;
+        critical?: number;
+        total?: number;
+        byCategory?: Record<string, number>;
+    }>>;
+    scannedLocations: z.ZodOptional<z.ZodObject<{
+        toolNames: z.ZodBoolean;
+        toolDescriptions: z.ZodBoolean;
+        readme: z.ZodBoolean;
+        sourceCode: z.ZodBoolean;
+    }, "strip", z.ZodTypeAny, {
+        readme?: boolean;
+        toolNames?: boolean;
+        toolDescriptions?: boolean;
+        sourceCode?: boolean;
+    }, {
+        readme?: boolean;
+        toolNames?: boolean;
+        toolDescriptions?: boolean;
+        sourceCode?: boolean;
+    }>>;
+    highRiskDomains: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    version?: string;
+    status?: "PASS" | "FAIL" | "NEED_MORE_INFO";
+    module?: string;
+    score?: number;
+    event?: "module_complete";
+    testsRun?: number;
+    duration?: number;
+    schemaVersion?: number;
+    scannedLocations?: {
+        readme?: boolean;
+        toolNames?: boolean;
+        toolDescriptions?: boolean;
+        sourceCode?: boolean;
+    };
+    highRiskDomains?: string[];
+    violationsSample?: {
+        category?: string;
+        confidence?: "high" | "medium" | "low";
+        categoryName?: string;
+        location?: "tool_name" | "tool_description" | "readme" | "source_code";
+        severity?: "MEDIUM" | "HIGH" | "CRITICAL";
+        matchedText?: string;
+    }[];
+    samplingNote?: string;
+    violationMetrics?: {
+        high?: number;
+        medium?: number;
+        critical?: number;
+        total?: number;
+        byCategory?: Record<string, number>;
+    };
+}, {
+    version?: string;
+    status?: "PASS" | "FAIL" | "NEED_MORE_INFO";
+    module?: string;
+    score?: number;
+    event?: "module_complete";
+    testsRun?: number;
+    duration?: number;
+    schemaVersion?: number;
+    scannedLocations?: {
+        readme?: boolean;
+        toolNames?: boolean;
+        toolDescriptions?: boolean;
+        sourceCode?: boolean;
+    };
+    highRiskDomains?: string[];
+    violationsSample?: {
+        category?: string;
+        confidence?: "high" | "medium" | "low";
+        categoryName?: string;
+        location?: "tool_name" | "tool_description" | "readme" | "source_code";
+        severity?: "MEDIUM" | "HIGH" | "CRITICAL";
+        matchedText?: string;
+    }[];
+    samplingNote?: string;
+    violationMetrics?: {
+        high?: number;
+        medium?: number;
+        critical?: number;
+        total?: number;
+        byCategory?: Record<string, number>;
+    };
+}>;
+export type ModuleCompleteEvent = z.infer<typeof ModuleCompleteEventSchema>;
+/**
+ * 8. VulnerabilityFoundEvent - Emitted when security vulnerability detected.
+ */
+export declare const VulnerabilityFoundEventSchema: z.ZodObject<{
+    /** Inspector software version (e.g., "1.29.0") */
+    version: z.ZodString;
+    /** Event schema version (integer, increment when structure changes) */
+    schemaVersion: z.ZodNumber;
+} & {
+    event: z.ZodLiteral<"vulnerability_found">;
+    tool: z.ZodString;
+    pattern: z.ZodString;
+    confidence: z.ZodEnum<["high", "medium", "low"]>;
+    evidence: z.ZodString;
+    riskLevel: z.ZodEnum<["HIGH", "MEDIUM", "LOW"]>;
+    requiresReview: z.ZodBoolean;
+    payload: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    version?: string;
+    evidence?: string;
+    payload?: string;
+    riskLevel?: "LOW" | "MEDIUM" | "HIGH";
+    confidence?: "high" | "medium" | "low";
+    pattern?: string;
+    event?: "vulnerability_found";
+    schemaVersion?: number;
+    tool?: string;
+    requiresReview?: boolean;
+}, {
+    version?: string;
+    evidence?: string;
+    payload?: string;
+    riskLevel?: "LOW" | "MEDIUM" | "HIGH";
+    confidence?: "high" | "medium" | "low";
+    pattern?: string;
+    event?: "vulnerability_found";
+    schemaVersion?: number;
+    tool?: string;
+    requiresReview?: boolean;
+}>;
+export type VulnerabilityFoundEvent = z.infer<typeof VulnerabilityFoundEventSchema>;
+/**
+ * 9. AnnotationMissingEvent - Emitted when tool lacks annotations.
+ */
+export declare const AnnotationMissingEventSchema: z.ZodObject<{
+    /** Inspector software version (e.g., "1.29.0") */
+    version: z.ZodString;
+    /** Event schema version (integer, increment when structure changes) */
+    schemaVersion: z.ZodNumber;
+} & {
+    event: z.ZodLiteral<"annotation_missing">;
+    tool: z.ZodString;
+    title: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    parameters: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        type: z.ZodString;
+        required: z.ZodBoolean;
+        description: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        name?: string;
+        description?: string;
+        type?: string;
+        required?: boolean;
+    }, {
+        name?: string;
+        description?: string;
+        type?: string;
+        required?: boolean;
+    }>, "many">;
+    inferredBehavior: z.ZodObject<{
+        expectedReadOnly: z.ZodBoolean;
+        expectedDestructive: z.ZodBoolean;
+        reason: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        reason?: string;
+        expectedReadOnly?: boolean;
+        expectedDestructive?: boolean;
+    }, {
+        reason?: string;
+        expectedReadOnly?: boolean;
+        expectedDestructive?: boolean;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    version?: string;
+    description?: string;
+    title?: string;
+    event?: "annotation_missing";
+    schemaVersion?: number;
+    tool?: string;
+    parameters?: {
+        name?: string;
+        description?: string;
+        type?: string;
+        required?: boolean;
+    }[];
+    inferredBehavior?: {
+        reason?: string;
+        expectedReadOnly?: boolean;
+        expectedDestructive?: boolean;
+    };
+}, {
+    version?: string;
+    description?: string;
+    title?: string;
+    event?: "annotation_missing";
+    schemaVersion?: number;
+    tool?: string;
+    parameters?: {
+        name?: string;
+        description?: string;
+        type?: string;
+        required?: boolean;
+    }[];
+    inferredBehavior?: {
+        reason?: string;
+        expectedReadOnly?: boolean;
+        expectedDestructive?: boolean;
+    };
+}>;
+export type AnnotationMissingEvent = z.infer<typeof AnnotationMissingEventSchema>;
+/**
+ * 10. AnnotationMisalignedEvent - Emitted when annotation doesn't match behavior.
+ */
+export declare const AnnotationMisalignedEventSchema: z.ZodObject<{
+    /** Inspector software version (e.g., "1.29.0") */
+    version: z.ZodString;
+    /** Event schema version (integer, increment when structure changes) */
+    schemaVersion: z.ZodNumber;
+} & {
+    event: z.ZodLiteral<"annotation_misaligned">;
+    tool: z.ZodString;
+    title: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    parameters: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        type: z.ZodString;
+        required: z.ZodBoolean;
+        description: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        name?: string;
+        description?: string;
+        type?: string;
+        required?: boolean;
+    }, {
+        name?: string;
+        description?: string;
+        type?: string;
+        required?: boolean;
+    }>, "many">;
+    field: z.ZodEnum<["readOnlyHint", "destructiveHint"]>;
+    actual: z.ZodOptional<z.ZodBoolean>;
+    expected: z.ZodBoolean;
+    confidence: z.ZodNumber;
+    reason: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    version?: string;
+    description?: string;
+    confidence?: number;
+    title?: string;
+    event?: "annotation_misaligned";
+    schemaVersion?: number;
+    expected?: boolean;
+    reason?: string;
+    tool?: string;
+    parameters?: {
+        name?: string;
+        description?: string;
+        type?: string;
+        required?: boolean;
+    }[];
+    field?: "readOnlyHint" | "destructiveHint";
+    actual?: boolean;
+}, {
+    version?: string;
+    description?: string;
+    confidence?: number;
+    title?: string;
+    event?: "annotation_misaligned";
+    schemaVersion?: number;
+    expected?: boolean;
+    reason?: string;
+    tool?: string;
+    parameters?: {
+        name?: string;
+        description?: string;
+        type?: string;
+        required?: boolean;
+    }[];
+    field?: "readOnlyHint" | "destructiveHint";
+    actual?: boolean;
+}>;
+export type AnnotationMisalignedEvent = z.infer<typeof AnnotationMisalignedEventSchema>;
+/**
+ * 11. AnnotationReviewRecommendedEvent - Emitted for ambiguous patterns.
+ */
+export declare const AnnotationReviewRecommendedEventSchema: z.ZodObject<{
+    /** Inspector software version (e.g., "1.29.0") */
+    version: z.ZodString;
+    /** Event schema version (integer, increment when structure changes) */
+    schemaVersion: z.ZodNumber;
+} & {
+    event: z.ZodLiteral<"annotation_review_recommended">;
+    tool: z.ZodString;
+    title: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    parameters: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        type: z.ZodString;
+        required: z.ZodBoolean;
+        description: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        name?: string;
+        description?: string;
+        type?: string;
+        required?: boolean;
+    }, {
+        name?: string;
+        description?: string;
+        type?: string;
+        required?: boolean;
+    }>, "many">;
+    field: z.ZodEnum<["readOnlyHint", "destructiveHint"]>;
+    actual: z.ZodOptional<z.ZodBoolean>;
+    inferred: z.ZodBoolean;
+    confidence: z.ZodEnum<["high", "medium", "low"]>;
+    isAmbiguous: z.ZodBoolean;
+    reason: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    version?: string;
+    description?: string;
+    inferred?: boolean;
+    confidence?: "high" | "medium" | "low";
+    title?: string;
+    event?: "annotation_review_recommended";
+    schemaVersion?: number;
+    reason?: string;
+    tool?: string;
+    parameters?: {
+        name?: string;
+        description?: string;
+        type?: string;
+        required?: boolean;
+    }[];
+    field?: "readOnlyHint" | "destructiveHint";
+    actual?: boolean;
+    isAmbiguous?: boolean;
+}, {
+    version?: string;
+    description?: string;
+    inferred?: boolean;
+    confidence?: "high" | "medium" | "low";
+    title?: string;
+    event?: "annotation_review_recommended";
+    schemaVersion?: number;
+    reason?: string;
+    tool?: string;
+    parameters?: {
+        name?: string;
+        description?: string;
+        type?: string;
+        required?: boolean;
+    }[];
+    field?: "readOnlyHint" | "destructiveHint";
+    actual?: boolean;
+    isAmbiguous?: boolean;
+}>;
+export type AnnotationReviewRecommendedEvent = z.infer<typeof AnnotationReviewRecommendedEventSchema>;
+/**
+ * 12. AnnotationAlignedEvent - Emitted when annotations correctly match behavior.
+ */
+export declare const AnnotationAlignedEventSchema: z.ZodObject<{
+    /** Inspector software version (e.g., "1.29.0") */
+    version: z.ZodString;
+    /** Event schema version (integer, increment when structure changes) */
+    schemaVersion: z.ZodNumber;
+} & {
+    event: z.ZodLiteral<"annotation_aligned">;
+    tool: z.ZodString;
+    confidence: z.ZodEnum<["high", "medium", "low"]>;
+    annotations: z.ZodNullable<z.ZodObject<{
+        readOnlyHint: z.ZodOptional<z.ZodBoolean>;
+        destructiveHint: z.ZodOptional<z.ZodBoolean>;
+        openWorldHint: z.ZodOptional<z.ZodBoolean>;
+        idempotentHint: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        readOnlyHint?: boolean;
+        destructiveHint?: boolean;
+        idempotentHint?: boolean;
+        openWorldHint?: boolean;
+    }, {
+        readOnlyHint?: boolean;
+        destructiveHint?: boolean;
+        idempotentHint?: boolean;
+        openWorldHint?: boolean;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    version?: string;
+    confidence?: "high" | "medium" | "low";
+    annotations?: {
+        readOnlyHint?: boolean;
+        destructiveHint?: boolean;
+        idempotentHint?: boolean;
+        openWorldHint?: boolean;
+    };
+    event?: "annotation_aligned";
+    schemaVersion?: number;
+    tool?: string;
+}, {
+    version?: string;
+    confidence?: "high" | "medium" | "low";
+    annotations?: {
+        readOnlyHint?: boolean;
+        destructiveHint?: boolean;
+        idempotentHint?: boolean;
+        openWorldHint?: boolean;
+    };
+    event?: "annotation_aligned";
+    schemaVersion?: number;
+    tool?: string;
+}>;
+export type AnnotationAlignedEvent = z.infer<typeof AnnotationAlignedEventSchema>;
+/**
+ * 13. AssessmentCompleteEvent - Emitted at end of assessment.
+ */
+export declare const AssessmentCompleteEventSchema: z.ZodObject<{
+    /** Inspector software version (e.g., "1.29.0") */
+    version: z.ZodString;
+    /** Event schema version (integer, increment when structure changes) */
+    schemaVersion: z.ZodNumber;
+} & {
+    event: z.ZodLiteral<"assessment_complete">;
+    overallStatus: z.ZodString;
+    totalTests: z.ZodNumber;
+    executionTime: z.ZodNumber;
+    outputPath: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    version?: string;
+    event?: "assessment_complete";
+    schemaVersion?: number;
+    overallStatus?: string;
+    executionTime?: number;
+    totalTests?: number;
+    outputPath?: string;
+}, {
+    version?: string;
+    event?: "assessment_complete";
+    schemaVersion?: number;
+    overallStatus?: string;
+    executionTime?: number;
+    totalTests?: number;
+    outputPath?: string;
+}>;
+export type AssessmentCompleteEvent = z.infer<typeof AssessmentCompleteEventSchema>;
+/**
+ * Union of all JSONL event schemas.
+ * Uses z.union() with z.literal() for event type discrimination.
+ */
+export declare const JSONLEventSchema: z.ZodUnion<[z.ZodObject<{
+    /** Inspector software version (e.g., "1.29.0") */
+    version: z.ZodString;
+    /** Event schema version (integer, increment when structure changes) */
+    schemaVersion: z.ZodNumber;
+} & {
+    event: z.ZodLiteral<"server_connected">;
+    serverName: z.ZodString;
+    transport: z.ZodEnum<["stdio", "http", "sse"]>;
+}, "strip", z.ZodTypeAny, {
+    version?: string;
+    event?: "server_connected";
+    schemaVersion?: number;
+    serverName?: string;
+    transport?: "http" | "sse" | "stdio";
+}, {
+    version?: string;
+    event?: "server_connected";
+    schemaVersion?: number;
+    serverName?: string;
+    transport?: "http" | "sse" | "stdio";
+}>, z.ZodObject<{
+    /** Inspector software version (e.g., "1.29.0") */
+    version: z.ZodString;
+    /** Event schema version (integer, increment when structure changes) */
+    schemaVersion: z.ZodNumber;
+} & {
+    event: z.ZodLiteral<"tool_discovered">;
+    name: z.ZodString;
+    description: z.ZodNullable<z.ZodString>;
+    params: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        type: z.ZodString;
+        required: z.ZodBoolean;
+        description: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        name?: string;
+        description?: string;
+        type?: string;
+        required?: boolean;
+    }, {
+        name?: string;
+        description?: string;
+        type?: string;
+        required?: boolean;
+    }>, "many">;
+    annotations: z.ZodNullable<z.ZodObject<{
+        readOnlyHint: z.ZodOptional<z.ZodBoolean>;
+        destructiveHint: z.ZodOptional<z.ZodBoolean>;
+        idempotentHint: z.ZodOptional<z.ZodBoolean>;
+        openWorldHint: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        readOnlyHint?: boolean;
+        destructiveHint?: boolean;
+        idempotentHint?: boolean;
+        openWorldHint?: boolean;
+    }, {
+        readOnlyHint?: boolean;
+        destructiveHint?: boolean;
+        idempotentHint?: boolean;
+        openWorldHint?: boolean;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    name?: string;
+    version?: string;
+    description?: string;
+    annotations?: {
+        readOnlyHint?: boolean;
+        destructiveHint?: boolean;
+        idempotentHint?: boolean;
+        openWorldHint?: boolean;
+    };
+    event?: "tool_discovered";
+    schemaVersion?: number;
+    params?: {
+        name?: string;
+        description?: string;
+        type?: string;
+        required?: boolean;
+    }[];
+}, {
+    name?: string;
+    version?: string;
+    description?: string;
+    annotations?: {
+        readOnlyHint?: boolean;
+        destructiveHint?: boolean;
+        idempotentHint?: boolean;
+        openWorldHint?: boolean;
+    };
+    event?: "tool_discovered";
+    schemaVersion?: number;
+    params?: {
+        name?: string;
+        description?: string;
+        type?: string;
+        required?: boolean;
+    }[];
+}>, z.ZodObject<{
+    /** Inspector software version (e.g., "1.29.0") */
+    version: z.ZodString;
+    /** Event schema version (integer, increment when structure changes) */
+    schemaVersion: z.ZodNumber;
+} & {
+    event: z.ZodLiteral<"tools_discovery_complete">;
+    count: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    version?: string;
+    count?: number;
+    event?: "tools_discovery_complete";
+    schemaVersion?: number;
+}, {
+    version?: string;
+    count?: number;
+    event?: "tools_discovery_complete";
+    schemaVersion?: number;
+}>, z.ZodObject<{
+    /** Inspector software version (e.g., "1.29.0") */
+    version: z.ZodString;
+    /** Event schema version (integer, increment when structure changes) */
+    schemaVersion: z.ZodNumber;
+} & {
+    event: z.ZodLiteral<"modules_configured">;
+    enabled: z.ZodArray<z.ZodString, "many">;
+    skipped: z.ZodArray<z.ZodString, "many">;
+    reason: z.ZodEnum<["skip-modules", "only-modules", "default"]>;
+}, "strip", z.ZodTypeAny, {
+    version?: string;
+    enabled?: string[];
+    event?: "modules_configured";
+    schemaVersion?: number;
+    reason?: "default" | "skip-modules" | "only-modules";
+    skipped?: string[];
+}, {
+    version?: string;
+    enabled?: string[];
+    event?: "modules_configured";
+    schemaVersion?: number;
+    reason?: "default" | "skip-modules" | "only-modules";
+    skipped?: string[];
+}>, z.ZodObject<{
+    /** Inspector software version (e.g., "1.29.0") */
+    version: z.ZodString;
+    /** Event schema version (integer, increment when structure changes) */
+    schemaVersion: z.ZodNumber;
+} & {
+    event: z.ZodLiteral<"module_started">;
+    module: z.ZodString;
+    estimatedTests: z.ZodNumber;
+    toolCount: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    version?: string;
+    module?: string;
+    event?: "module_started";
+    schemaVersion?: number;
+    estimatedTests?: number;
+    toolCount?: number;
+}, {
+    version?: string;
+    module?: string;
+    event?: "module_started";
+    schemaVersion?: number;
+    estimatedTests?: number;
+    toolCount?: number;
+}>, z.ZodObject<{
+    /** Inspector software version (e.g., "1.29.0") */
+    version: z.ZodString;
+    /** Event schema version (integer, increment when structure changes) */
+    schemaVersion: z.ZodNumber;
+} & {
+    event: z.ZodLiteral<"test_batch">;
+    module: z.ZodString;
+    completed: z.ZodNumber;
+    total: z.ZodNumber;
+    batchSize: z.ZodNumber;
+    elapsed: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    version?: string;
+    completed?: number;
+    module?: string;
+    event?: "test_batch";
+    schemaVersion?: number;
+    total?: number;
+    batchSize?: number;
+    elapsed?: number;
+}, {
+    version?: string;
+    completed?: number;
+    module?: string;
+    event?: "test_batch";
+    schemaVersion?: number;
+    total?: number;
+    batchSize?: number;
+    elapsed?: number;
+}>, z.ZodObject<{
+    /** Inspector software version (e.g., "1.29.0") */
+    version: z.ZodString;
+    /** Event schema version (integer, increment when structure changes) */
+    schemaVersion: z.ZodNumber;
+} & {
+    event: z.ZodLiteral<"module_complete">;
+    module: z.ZodString;
+    status: z.ZodEnum<["PASS", "FAIL", "NEED_MORE_INFO"]>;
+    score: z.ZodNumber;
+    testsRun: z.ZodNumber;
+    duration: z.ZodNumber;
+    violationsSample: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        category: z.ZodString;
+        categoryName: z.ZodString;
+        severity: z.ZodEnum<["CRITICAL", "HIGH", "MEDIUM"]>;
+        matchedText: z.ZodString;
+        location: z.ZodEnum<["tool_name", "tool_description", "readme", "source_code"]>;
+        confidence: z.ZodEnum<["high", "medium", "low"]>;
+    }, "strip", z.ZodTypeAny, {
+        category?: string;
+        confidence?: "high" | "medium" | "low";
+        categoryName?: string;
+        location?: "tool_name" | "tool_description" | "readme" | "source_code";
+        severity?: "MEDIUM" | "HIGH" | "CRITICAL";
+        matchedText?: string;
+    }, {
+        category?: string;
+        confidence?: "high" | "medium" | "low";
+        categoryName?: string;
+        location?: "tool_name" | "tool_description" | "readme" | "source_code";
+        severity?: "MEDIUM" | "HIGH" | "CRITICAL";
+        matchedText?: string;
+    }>, "many">>;
+    samplingNote: z.ZodOptional<z.ZodString>;
+    violationMetrics: z.ZodOptional<z.ZodObject<{
+        total: z.ZodNumber;
+        critical: z.ZodNumber;
+        high: z.ZodNumber;
+        medium: z.ZodNumber;
+        byCategory: z.ZodRecord<z.ZodString, z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        high?: number;
+        medium?: number;
+        critical?: number;
+        total?: number;
+        byCategory?: Record<string, number>;
+    }, {
+        high?: number;
+        medium?: number;
+        critical?: number;
+        total?: number;
+        byCategory?: Record<string, number>;
+    }>>;
+    scannedLocations: z.ZodOptional<z.ZodObject<{
+        toolNames: z.ZodBoolean;
+        toolDescriptions: z.ZodBoolean;
+        readme: z.ZodBoolean;
+        sourceCode: z.ZodBoolean;
+    }, "strip", z.ZodTypeAny, {
+        readme?: boolean;
+        toolNames?: boolean;
+        toolDescriptions?: boolean;
+        sourceCode?: boolean;
+    }, {
+        readme?: boolean;
+        toolNames?: boolean;
+        toolDescriptions?: boolean;
+        sourceCode?: boolean;
+    }>>;
+    highRiskDomains: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    version?: string;
+    status?: "PASS" | "FAIL" | "NEED_MORE_INFO";
+    module?: string;
+    score?: number;
+    event?: "module_complete";
+    testsRun?: number;
+    duration?: number;
+    schemaVersion?: number;
+    scannedLocations?: {
+        readme?: boolean;
+        toolNames?: boolean;
+        toolDescriptions?: boolean;
+        sourceCode?: boolean;
+    };
+    highRiskDomains?: string[];
+    violationsSample?: {
+        category?: string;
+        confidence?: "high" | "medium" | "low";
+        categoryName?: string;
+        location?: "tool_name" | "tool_description" | "readme" | "source_code";
+        severity?: "MEDIUM" | "HIGH" | "CRITICAL";
+        matchedText?: string;
+    }[];
+    samplingNote?: string;
+    violationMetrics?: {
+        high?: number;
+        medium?: number;
+        critical?: number;
+        total?: number;
+        byCategory?: Record<string, number>;
+    };
+}, {
+    version?: string;
+    status?: "PASS" | "FAIL" | "NEED_MORE_INFO";
+    module?: string;
+    score?: number;
+    event?: "module_complete";
+    testsRun?: number;
+    duration?: number;
+    schemaVersion?: number;
+    scannedLocations?: {
+        readme?: boolean;
+        toolNames?: boolean;
+        toolDescriptions?: boolean;
+        sourceCode?: boolean;
+    };
+    highRiskDomains?: string[];
+    violationsSample?: {
+        category?: string;
+        confidence?: "high" | "medium" | "low";
+        categoryName?: string;
+        location?: "tool_name" | "tool_description" | "readme" | "source_code";
+        severity?: "MEDIUM" | "HIGH" | "CRITICAL";
+        matchedText?: string;
+    }[];
+    samplingNote?: string;
+    violationMetrics?: {
+        high?: number;
+        medium?: number;
+        critical?: number;
+        total?: number;
+        byCategory?: Record<string, number>;
+    };
+}>, z.ZodObject<{
+    /** Inspector software version (e.g., "1.29.0") */
+    version: z.ZodString;
+    /** Event schema version (integer, increment when structure changes) */
+    schemaVersion: z.ZodNumber;
+} & {
+    event: z.ZodLiteral<"vulnerability_found">;
+    tool: z.ZodString;
+    pattern: z.ZodString;
+    confidence: z.ZodEnum<["high", "medium", "low"]>;
+    evidence: z.ZodString;
+    riskLevel: z.ZodEnum<["HIGH", "MEDIUM", "LOW"]>;
+    requiresReview: z.ZodBoolean;
+    payload: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    version?: string;
+    evidence?: string;
+    payload?: string;
+    riskLevel?: "LOW" | "MEDIUM" | "HIGH";
+    confidence?: "high" | "medium" | "low";
+    pattern?: string;
+    event?: "vulnerability_found";
+    schemaVersion?: number;
+    tool?: string;
+    requiresReview?: boolean;
+}, {
+    version?: string;
+    evidence?: string;
+    payload?: string;
+    riskLevel?: "LOW" | "MEDIUM" | "HIGH";
+    confidence?: "high" | "medium" | "low";
+    pattern?: string;
+    event?: "vulnerability_found";
+    schemaVersion?: number;
+    tool?: string;
+    requiresReview?: boolean;
+}>, z.ZodObject<{
+    /** Inspector software version (e.g., "1.29.0") */
+    version: z.ZodString;
+    /** Event schema version (integer, increment when structure changes) */
+    schemaVersion: z.ZodNumber;
+} & {
+    event: z.ZodLiteral<"annotation_missing">;
+    tool: z.ZodString;
+    title: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    parameters: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        type: z.ZodString;
+        required: z.ZodBoolean;
+        description: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        name?: string;
+        description?: string;
+        type?: string;
+        required?: boolean;
+    }, {
+        name?: string;
+        description?: string;
+        type?: string;
+        required?: boolean;
+    }>, "many">;
+    inferredBehavior: z.ZodObject<{
+        expectedReadOnly: z.ZodBoolean;
+        expectedDestructive: z.ZodBoolean;
+        reason: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        reason?: string;
+        expectedReadOnly?: boolean;
+        expectedDestructive?: boolean;
+    }, {
+        reason?: string;
+        expectedReadOnly?: boolean;
+        expectedDestructive?: boolean;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    version?: string;
+    description?: string;
+    title?: string;
+    event?: "annotation_missing";
+    schemaVersion?: number;
+    tool?: string;
+    parameters?: {
+        name?: string;
+        description?: string;
+        type?: string;
+        required?: boolean;
+    }[];
+    inferredBehavior?: {
+        reason?: string;
+        expectedReadOnly?: boolean;
+        expectedDestructive?: boolean;
+    };
+}, {
+    version?: string;
+    description?: string;
+    title?: string;
+    event?: "annotation_missing";
+    schemaVersion?: number;
+    tool?: string;
+    parameters?: {
+        name?: string;
+        description?: string;
+        type?: string;
+        required?: boolean;
+    }[];
+    inferredBehavior?: {
+        reason?: string;
+        expectedReadOnly?: boolean;
+        expectedDestructive?: boolean;
+    };
+}>, z.ZodObject<{
+    /** Inspector software version (e.g., "1.29.0") */
+    version: z.ZodString;
+    /** Event schema version (integer, increment when structure changes) */
+    schemaVersion: z.ZodNumber;
+} & {
+    event: z.ZodLiteral<"annotation_misaligned">;
+    tool: z.ZodString;
+    title: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    parameters: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        type: z.ZodString;
+        required: z.ZodBoolean;
+        description: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        name?: string;
+        description?: string;
+        type?: string;
+        required?: boolean;
+    }, {
+        name?: string;
+        description?: string;
+        type?: string;
+        required?: boolean;
+    }>, "many">;
+    field: z.ZodEnum<["readOnlyHint", "destructiveHint"]>;
+    actual: z.ZodOptional<z.ZodBoolean>;
+    expected: z.ZodBoolean;
+    confidence: z.ZodNumber;
+    reason: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    version?: string;
+    description?: string;
+    confidence?: number;
+    title?: string;
+    event?: "annotation_misaligned";
+    schemaVersion?: number;
+    expected?: boolean;
+    reason?: string;
+    tool?: string;
+    parameters?: {
+        name?: string;
+        description?: string;
+        type?: string;
+        required?: boolean;
+    }[];
+    field?: "readOnlyHint" | "destructiveHint";
+    actual?: boolean;
+}, {
+    version?: string;
+    description?: string;
+    confidence?: number;
+    title?: string;
+    event?: "annotation_misaligned";
+    schemaVersion?: number;
+    expected?: boolean;
+    reason?: string;
+    tool?: string;
+    parameters?: {
+        name?: string;
+        description?: string;
+        type?: string;
+        required?: boolean;
+    }[];
+    field?: "readOnlyHint" | "destructiveHint";
+    actual?: boolean;
+}>, z.ZodObject<{
+    /** Inspector software version (e.g., "1.29.0") */
+    version: z.ZodString;
+    /** Event schema version (integer, increment when structure changes) */
+    schemaVersion: z.ZodNumber;
+} & {
+    event: z.ZodLiteral<"annotation_review_recommended">;
+    tool: z.ZodString;
+    title: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    parameters: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        type: z.ZodString;
+        required: z.ZodBoolean;
+        description: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        name?: string;
+        description?: string;
+        type?: string;
+        required?: boolean;
+    }, {
+        name?: string;
+        description?: string;
+        type?: string;
+        required?: boolean;
+    }>, "many">;
+    field: z.ZodEnum<["readOnlyHint", "destructiveHint"]>;
+    actual: z.ZodOptional<z.ZodBoolean>;
+    inferred: z.ZodBoolean;
+    confidence: z.ZodEnum<["high", "medium", "low"]>;
+    isAmbiguous: z.ZodBoolean;
+    reason: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    version?: string;
+    description?: string;
+    inferred?: boolean;
+    confidence?: "high" | "medium" | "low";
+    title?: string;
+    event?: "annotation_review_recommended";
+    schemaVersion?: number;
+    reason?: string;
+    tool?: string;
+    parameters?: {
+        name?: string;
+        description?: string;
+        type?: string;
+        required?: boolean;
+    }[];
+    field?: "readOnlyHint" | "destructiveHint";
+    actual?: boolean;
+    isAmbiguous?: boolean;
+}, {
+    version?: string;
+    description?: string;
+    inferred?: boolean;
+    confidence?: "high" | "medium" | "low";
+    title?: string;
+    event?: "annotation_review_recommended";
+    schemaVersion?: number;
+    reason?: string;
+    tool?: string;
+    parameters?: {
+        name?: string;
+        description?: string;
+        type?: string;
+        required?: boolean;
+    }[];
+    field?: "readOnlyHint" | "destructiveHint";
+    actual?: boolean;
+    isAmbiguous?: boolean;
+}>, z.ZodObject<{
+    /** Inspector software version (e.g., "1.29.0") */
+    version: z.ZodString;
+    /** Event schema version (integer, increment when structure changes) */
+    schemaVersion: z.ZodNumber;
+} & {
+    event: z.ZodLiteral<"annotation_aligned">;
+    tool: z.ZodString;
+    confidence: z.ZodEnum<["high", "medium", "low"]>;
+    annotations: z.ZodNullable<z.ZodObject<{
+        readOnlyHint: z.ZodOptional<z.ZodBoolean>;
+        destructiveHint: z.ZodOptional<z.ZodBoolean>;
+        openWorldHint: z.ZodOptional<z.ZodBoolean>;
+        idempotentHint: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        readOnlyHint?: boolean;
+        destructiveHint?: boolean;
+        idempotentHint?: boolean;
+        openWorldHint?: boolean;
+    }, {
+        readOnlyHint?: boolean;
+        destructiveHint?: boolean;
+        idempotentHint?: boolean;
+        openWorldHint?: boolean;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    version?: string;
+    confidence?: "high" | "medium" | "low";
+    annotations?: {
+        readOnlyHint?: boolean;
+        destructiveHint?: boolean;
+        idempotentHint?: boolean;
+        openWorldHint?: boolean;
+    };
+    event?: "annotation_aligned";
+    schemaVersion?: number;
+    tool?: string;
+}, {
+    version?: string;
+    confidence?: "high" | "medium" | "low";
+    annotations?: {
+        readOnlyHint?: boolean;
+        destructiveHint?: boolean;
+        idempotentHint?: boolean;
+        openWorldHint?: boolean;
+    };
+    event?: "annotation_aligned";
+    schemaVersion?: number;
+    tool?: string;
+}>, z.ZodObject<{
+    /** Inspector software version (e.g., "1.29.0") */
+    version: z.ZodString;
+    /** Event schema version (integer, increment when structure changes) */
+    schemaVersion: z.ZodNumber;
+} & {
+    event: z.ZodLiteral<"assessment_complete">;
+    overallStatus: z.ZodString;
+    totalTests: z.ZodNumber;
+    executionTime: z.ZodNumber;
+    outputPath: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    version?: string;
+    event?: "assessment_complete";
+    schemaVersion?: number;
+    overallStatus?: string;
+    executionTime?: number;
+    totalTests?: number;
+    outputPath?: string;
+}, {
+    version?: string;
+    event?: "assessment_complete";
+    schemaVersion?: number;
+    overallStatus?: string;
+    executionTime?: number;
+    totalTests?: number;
+    outputPath?: string;
+}>]>;
+/**
+ * Inferred union type for all JSONL events.
+ */
+export type JSONLEventParsed = z.infer<typeof JSONLEventSchema>;
+/**
+ * Event type literal union for type guards.
+ */
+export type JSONLEventType = JSONLEventParsed["event"];
+/**
+ * Parse a JSONL event string or object with validation.
+ *
+ * @param input - Raw JSON string or parsed object
+ * @returns Validated and typed event
+ * @throws ZodError if validation fails
+ * @throws SyntaxError if input is invalid JSON string
+ *
+ * @example
+ * ```typescript
+ * const event = parseEvent('{"event":"server_connected",...}');
+ * console.log(event.serverName);
+ * ```
+ */
+export declare function parseEvent(input: string | unknown): JSONLEventParsed;
+/**
+ * Safely parse a JSONL event without throwing.
+ *
+ * @param input - Raw JSON string or parsed object
+ * @returns SafeParseResult with success status and data/error
+ *
+ * @remarks
+ * JSON parse errors are converted to ZodError with code "custom" and message prefixed with "Invalid JSON:".
+ * This allows uniform error handling, but consumers should be aware that not all errors are schema validation failures.
+ *
+ * @example
+ * ```typescript
+ * const result = safeParseEvent(line);
+ * if (result.success) {
+ *   console.log(result.data.event);
+ * } else {
+ *   console.error(result.error);
+ * }
+ * ```
+ */
+export declare function safeParseEvent(input: string | unknown): z.SafeParseReturnType<unknown, JSONLEventParsed>;
+/**
+ * Validate an event and return error messages.
+ *
+ * @param input - Raw event data
+ * @returns Array of validation error messages (empty if valid)
+ *
+ * @example
+ * ```typescript
+ * const errors = validateEvent(data);
+ * if (errors.length > 0) {
+ *   console.error('Validation failed:', errors);
+ * }
+ * ```
+ */
+export declare function validateEvent(input: unknown): string[];
+/**
+ * Type guard for specific event types.
+ *
+ * @param event - Parsed event
+ * @param eventType - Event type to check
+ * @returns True if event matches the specified type
+ *
+ * @example
+ * ```typescript
+ * const event = parseEvent(line);
+ * if (isEventType(event, 'server_connected')) {
+ *   // event is narrowed to ServerConnectedEvent
+ *   console.log(event.serverName);
+ * }
+ * ```
+ */
+export declare function isEventType<T extends JSONLEventType>(event: JSONLEventParsed, eventType: T): event is Extract<JSONLEventParsed, {
+    event: T;
+}>;
+/**
+ * Parse multiple JSONL lines with line number tracking.
+ *
+ * @param lines - Array of JSONL strings
+ * @returns Array of parse results with line numbers (1-indexed)
+ *
+ * @example
+ * ```typescript
+ * const results = parseEventLines(lines);
+ * for (const { line, result } of results) {
+ *   if (!result.success) {
+ *     console.error(`Line ${line}: ${result.error.message}`);
+ *   }
+ * }
+ * ```
+ */
+export declare function parseEventLines(lines: string[]): Array<{
+    line: number;
+    result: z.SafeParseReturnType<unknown, JSONLEventParsed>;
+}>;
+//# sourceMappingURL=jsonlEventSchemas.d.ts.map