@cisco_open/linting-orchestrator 1.0.0-rc.4

package/build/schemas.d.ts

@@ -0,0 +1,2568 @@
+/**
+ * OpenAPI/JSON Schema definitions for all orchestrator API responses.
+ *
+ * These schemas are consumed by @fastify/swagger to auto-generate the
+ * OpenAPI 3.0 specification from running code.  They also double as
+ * Fastify response-validation schemas at runtime (opt-in).
+ *
+ * Naming convention:  Schema*  → reusable $ref building-blocks
+ *                     *Schema → full route-level response/request schemas
+ *
+ * @module schemas
+ */
+export declare const ErrorResponseSchema: {
+    readonly $id: "ErrorResponse";
+    readonly type: "object";
+    readonly description: "Standard error response returned by all endpoints on failure";
+    readonly required: readonly ["error", "timestamp"];
+    readonly properties: {
+        readonly error: {
+            readonly type: "string";
+            readonly description: "Error category (e.g., Not Found, Validation Error, Internal Server Error)";
+            readonly example: "Not Found";
+        };
+        readonly message: {
+            readonly type: "string";
+            readonly description: "Human-readable error message with context";
+            readonly example: "Document not found: abc-123";
+        };
+        readonly details: {
+            readonly type: "object";
+            readonly description: "Additional error details such as validation errors or field-level issues";
+            readonly additionalProperties: true;
+        };
+        readonly timestamp: {
+            readonly type: "string";
+            readonly format: "date-time";
+            readonly description: "ISO 8601 timestamp when the error occurred";
+            readonly example: "2026-03-05T12:00:00.000Z";
+        };
+    };
+};
+export declare const JobStatusSchema: {
+    readonly $id: "JobStatus";
+    readonly type: "string";
+    readonly description: "Lifecycle status of a lint job";
+    readonly enum: readonly ["queued", "running", "completed", "completed_with_errors", "failed", "timeout", "cancelled"];
+    readonly example: "completed";
+};
+export declare const JobProgressSchema: {
+    readonly $id: "JobProgress";
+    readonly type: "object";
+    readonly description: "Task-level progress breakdown for a lint job";
+    readonly properties: {
+        readonly totalTasks: {
+            readonly type: "integer";
+            readonly description: "Total number of tasks in the job";
+            readonly example: 1;
+        };
+        readonly completedTasks: {
+            readonly type: "integer";
+            readonly description: "Number of tasks that completed successfully";
+            readonly example: 1;
+        };
+        readonly failedTasks: {
+            readonly type: "integer";
+            readonly description: "Number of tasks that failed with errors";
+            readonly example: 0;
+        };
+        readonly timeoutTasks: {
+            readonly type: "integer";
+            readonly description: "Number of tasks that exceeded the execution timeout";
+            readonly example: 0;
+        };
+        readonly runningTasks: {
+            readonly type: "integer";
+            readonly description: "Number of tasks currently being executed";
+            readonly example: 0;
+        };
+        readonly queuedTasks: {
+            readonly type: "integer";
+            readonly description: "Number of tasks waiting in the queue";
+            readonly example: 0;
+        };
+    };
+};
+export declare const SourcePositionSchema: {
+    readonly $id: "SourcePosition";
+    readonly type: "object";
+    readonly description: "A position in a text document identified by line and character offset";
+    readonly properties: {
+        readonly line: {
+            readonly type: "integer";
+            readonly description: "Zero-based line number in the source document";
+            readonly example: 62;
+        };
+        readonly character: {
+            readonly type: "integer";
+            readonly description: "Zero-based character offset within the line";
+            readonly example: 20;
+        };
+    };
+};
+export declare const SourceRangeSchema: {
+    readonly $id: "SourceRange";
+    readonly type: "object";
+    readonly description: "Source location range within the document (line and character positions)";
+    readonly properties: {
+        readonly start: {
+            readonly $ref: "SourcePosition#";
+        };
+        readonly end: {
+            readonly $ref: "SourcePosition#";
+        };
+    };
+};
+export declare const LintIssueSchema: {
+    readonly $id: "LintIssue";
+    readonly type: "object";
+    readonly description: "A single lint issue found in the document";
+    readonly properties: {
+        readonly ruleId: {
+            readonly type: "string";
+            readonly description: "Unique identifier of the rule that triggered this issue";
+            readonly example: "error-status-code";
+        };
+        readonly code: {
+            readonly type: "string";
+            readonly description: "Machine-readable issue code from the ruleset";
+            readonly example: "error-status-code";
+        };
+        readonly message: {
+            readonly type: "string";
+            readonly description: "Human-readable description of the issue";
+            readonly example: "responses should include at least one error status code (4xx or 5xx)";
+        };
+        readonly severity: {
+            readonly type: "integer";
+            readonly enum: readonly [0, 1, 2, 3];
+            readonly description: "Severity level: 0=error, 1=warn, 2=info, 3=hint";
+            readonly example: 1;
+        };
+        readonly path: {
+            readonly type: "array";
+            readonly description: "JSONPath segments to the location of the issue in the document";
+            readonly items: {
+                readonly oneOf: readonly [{
+                    readonly type: "string";
+                }, {
+                    readonly type: "integer";
+                }];
+            };
+            readonly example: readonly ["paths", "/health", "get", "responses"];
+        };
+        readonly range: {
+            readonly $ref: "SourceRange#";
+        };
+        readonly suggestions: {
+            readonly type: "array";
+            readonly description: "Suggested fixes or improvements for the issue";
+            readonly items: {
+                readonly type: "string";
+            };
+            readonly example: readonly ["Add a 4xx or 5xx response to this operation"];
+        };
+    };
+};
+export declare const ResultSummarySchema: {
+    readonly $id: "ResultSummary";
+    readonly type: "object";
+    readonly description: "Aggregated issue counts by severity level";
+    readonly properties: {
+        readonly totalIssues: {
+            readonly type: "integer";
+            readonly description: "Total number of issues found across all severity levels";
+            readonly example: 13;
+        };
+        readonly errorCount: {
+            readonly type: "integer";
+            readonly description: "Number of issues with error severity (must fix)";
+            readonly example: 5;
+        };
+        readonly warningCount: {
+            readonly type: "integer";
+            readonly description: "Number of issues with warning severity (should fix)";
+            readonly example: 8;
+        };
+        readonly infoCount: {
+            readonly type: "integer";
+            readonly description: "Number of informational issues";
+            readonly example: 0;
+        };
+        readonly hintCount: {
+            readonly type: "integer";
+            readonly description: "Number of hint-level suggestions";
+            readonly example: 0;
+        };
+    };
+};
+export declare const RulesetExecutionResultSchema: {
+    readonly $id: "RulesetExecutionResult";
+    readonly type: "object";
+    readonly description: "Execution details for a single ruleset run against a document";
+    readonly properties: {
+        readonly rulesetName: {
+            readonly type: "string";
+            readonly description: "Name of the executed ruleset";
+            readonly example: "pubhub";
+        };
+        readonly rulesetVersion: {
+            readonly type: "string";
+            readonly description: "Version of the executed ruleset";
+            readonly example: "1.1.0";
+        };
+        readonly executionTime: {
+            readonly type: "number";
+            readonly description: "Execution time in milliseconds for this ruleset";
+            readonly example: 277;
+        };
+        readonly success: {
+            readonly type: "boolean";
+            readonly description: "Whether the ruleset execution completed without internal errors";
+            readonly example: true;
+        };
+        readonly error: {
+            readonly type: "string";
+            readonly description: "Error message if the ruleset execution failed internally";
+            readonly example: "";
+        };
+        readonly issueCount: {
+            readonly type: "integer";
+            readonly description: "Total number of issues found by this ruleset";
+            readonly example: 0;
+        };
+        readonly issues: {
+            readonly type: "array";
+            readonly description: "List of issues found by this ruleset";
+            readonly items: {
+                readonly $ref: "LintIssue#";
+            };
+        };
+        readonly metadata: {
+            readonly type: "object";
+            readonly description: "Execution metadata for this ruleset run";
+            readonly properties: {
+                readonly ruleEngine: {
+                    readonly type: "string";
+                    readonly description: "Name of the rule engine that executed the ruleset";
+                    readonly example: "spectral";
+                };
+                readonly documentId: {
+                    readonly type: "string";
+                    readonly description: "Identifier of the linted document";
+                    readonly example: "41c1d4aa-5825-4313-8ae5-737490707b5b";
+                };
+                readonly cacheHit: {
+                    readonly type: "boolean";
+                    readonly description: "Whether the result was served from cache";
+                    readonly example: false;
+                };
+            };
+        };
+    };
+};
+export declare const RuleInfoSchema: {
+    readonly $id: "RuleInfo";
+    readonly type: "object";
+    readonly description: "Metadata for a single lint rule within a ruleset";
+    readonly properties: {
+        readonly name: {
+            readonly type: "string";
+            readonly description: "Unique rule identifier within the ruleset";
+            readonly example: "operationId-required-and-unique";
+        };
+        readonly severity: {
+            readonly type: "string";
+            readonly enum: readonly ["error", "warn", "info", "hint"];
+            readonly description: "Default severity level of the rule";
+            readonly example: "error";
+        };
+        readonly message: {
+            readonly type: "string";
+            readonly description: "Message template shown when the rule is triggered";
+            readonly example: "Every operation must have a unique operationId";
+        };
+        readonly description: {
+            readonly type: "string";
+            readonly description: "Detailed explanation of what the rule checks and why";
+            readonly example: "Ensures every operation has a unique operationId for code generation";
+        };
+        readonly recommended: {
+            readonly type: "boolean";
+            readonly description: "Whether this rule is recommended to be enabled";
+            readonly example: true;
+        };
+    };
+};
+export declare const DocumentSummarySchema: {
+    readonly $id: "DocumentSummary";
+    readonly type: "object";
+    readonly description: "Summary metadata for an uploaded document";
+    readonly properties: {
+        readonly documentId: {
+            readonly type: "string";
+            readonly description: "Unique document identifier";
+            readonly example: "41c1d4aa-5825-4313-8ae5-737490707b5b";
+        };
+        readonly title: {
+            readonly type: "string";
+            readonly description: "Title from the document info section";
+            readonly example: "My API";
+        };
+        readonly version: {
+            readonly type: "string";
+            readonly description: "API version from the document";
+            readonly example: "1.0.0";
+        };
+        readonly format: {
+            readonly type: "string";
+            readonly description: "Document format (json or yaml)";
+            readonly example: "json";
+        };
+        readonly uploadedAt: {
+            readonly type: "string";
+            readonly format: "date-time";
+            readonly description: "ISO 8601 timestamp when the document was uploaded";
+            readonly example: "2026-03-05T12:00:00.000Z";
+        };
+    };
+};
+export declare const RuleOverridesSchema: {
+    readonly $id: "RuleOverrides";
+    readonly type: "object";
+    readonly description: "Map of rule IDs to override severity. Use \"off\" to exclude a rule, or a severity level to change it.";
+    readonly additionalProperties: {
+        readonly type: "string";
+        readonly enum: readonly ["off", "error", "warn", "info", "hint"];
+    };
+    readonly example: {
+        readonly 'operationId-required': "off";
+        readonly 'error-status-code': "warn";
+    };
+};
+export declare const HealthResponseSchema: {
+    readonly $id: "HealthResponse";
+    readonly type: "object";
+    readonly description: "Server health status including uptime, configuration, and runtime statistics";
+    readonly properties: {
+        readonly status: {
+            readonly type: "string";
+            readonly enum: readonly ["ok"];
+            readonly description: "Server health status indicator";
+            readonly example: "ok";
+        };
+        readonly version: {
+            readonly type: "string";
+            readonly description: "Orchestrator server version (semver)";
+            readonly example: "0.11.0";
+        };
+        readonly timestamp: {
+            readonly type: "string";
+            readonly format: "date-time";
+            readonly description: "Current server time in ISO 8601 format";
+            readonly example: "2026-03-05T12:00:00.000Z";
+        };
+        readonly uptime: {
+            readonly type: "integer";
+            readonly description: "Server uptime in seconds since last start";
+            readonly example: 3600;
+        };
+        readonly mode: {
+            readonly type: "string";
+            readonly enum: readonly ["standalone", "embedded", "companion", "mcp"];
+            readonly description: "Current deployment mode of the server";
+            readonly example: "standalone";
+        };
+        readonly server: {
+            readonly type: "object";
+            readonly description: "HTTP server configuration details";
+            readonly properties: {
+                readonly port: {
+                    readonly type: "integer";
+                    readonly description: "Port the server is listening on";
+                    readonly example: 3003;
+                };
+                readonly host: {
+                    readonly type: "string";
+                    readonly description: "Host address the server is bound to";
+                    readonly example: "0.0.0.0";
+                };
+                readonly startedAt: {
+                    readonly type: "string";
+                    readonly format: "date-time";
+                    readonly description: "ISO 8601 timestamp when the server started";
+                    readonly example: "2026-03-05T11:00:00.000Z";
+                };
+            };
+        };
+        readonly documentStore: {
+            readonly type: "object";
+            readonly description: "Document storage backend configuration";
+            readonly properties: {
+                readonly type: {
+                    readonly type: "string";
+                    readonly enum: readonly ["local", "passthrough"];
+                    readonly description: "Type of document store in use";
+                    readonly example: "local";
+                };
+                readonly baseDir: {
+                    readonly type: "string";
+                    readonly description: "Relative base directory for document storage";
+                    readonly example: "./uploads";
+                };
+                readonly fullPath: {
+                    readonly type: "string";
+                    readonly description: "Absolute resolved path to the document storage directory";
+                    readonly example: "/home/user/spectify/uploads";
+                };
+            };
+        };
+        readonly stats: {
+            readonly type: "object";
+            readonly description: "Orchestrator runtime statistics snapshot (active jobs, worker counts, etc.)";
+            readonly additionalProperties: true;
+            readonly example: {
+                readonly activeJobs: 0;
+                readonly totalJobsProcessed: 42;
+            };
+        };
+        readonly runtime: {
+            readonly type: "object";
+            readonly description: "Runtime environment information (Node.js version, Spectral library versions, active resolver).";
+            readonly properties: {
+                readonly nodeVersion: {
+                    readonly type: "string";
+                    readonly description: "Node.js runtime version";
+                    readonly example: "v22.18.0";
+                };
+                readonly spectralCore: {
+                    readonly type: "string";
+                    readonly description: "Installed @stoplight/spectral-core version";
+                    readonly example: "1.19.0";
+                };
+                readonly spectralRulesets: {
+                    readonly type: "string";
+                    readonly description: "Installed @stoplight/spectral-rulesets version";
+                    readonly example: "1.22.0";
+                };
+                readonly spectralCli: {
+                    readonly type: "string";
+                    readonly description: "Installed @stoplight/spectral-cli version";
+                    readonly example: "6.16.0";
+                };
+                readonly resolver: {
+                    readonly type: readonly ["string", "null"];
+                    readonly description: "Active custom $ref resolver name, or null when using Spectral default resolver";
+                    readonly example: "ignore-external-refs";
+                };
+            };
+        };
+        readonly reportService: {
+            readonly type: "object";
+            readonly description: "Report Service connection status. Only present when configured.";
+            readonly additionalProperties: true;
+            readonly example: {
+                readonly connected: true;
+                readonly url: "http://localhost:3010";
+            };
+        };
+    };
+};
+export declare const DocumentUploadResponseSchema: {
+    readonly $id: "DocumentUploadResponse";
+    readonly type: "object";
+    readonly description: "Response after successfully uploading a document";
+    readonly properties: {
+        readonly documentId: {
+            readonly type: "string";
+            readonly description: "Unique identifier assigned to the uploaded document";
+            readonly example: "41c1d4aa-5825-4313-8ae5-737490707b5b";
+        };
+        readonly version: {
+            readonly type: "string";
+            readonly description: "Version identifier of the stored document";
+            readonly example: "1";
+        };
+        readonly message: {
+            readonly type: "string";
+            readonly description: "Human-readable confirmation message";
+            readonly example: "Document uploaded successfully";
+        };
+    };
+};
+export declare const DocumentUploadRequestSchema: {
+    readonly $id: "DocumentUploadRequest";
+    readonly type: "object";
+    readonly description: "Request body for uploading a document";
+    readonly required: readonly ["content"];
+    readonly properties: {
+        readonly content: {
+            readonly type: "string";
+            readonly description: "Raw document content as a JSON or YAML string";
+            readonly example: "{\"openapi\":\"3.0.0\",\"info\":{\"title\":\"My API\",\"version\":\"1.0\"},\"paths\":{}}";
+        };
+        readonly format: {
+            readonly type: "string";
+            readonly enum: readonly ["json", "yaml"];
+            readonly default: "json";
+            readonly description: "Format of the document content being uploaded";
+            readonly example: "json";
+        };
+        readonly metadata: {
+            readonly type: "object";
+            readonly description: "Optional metadata to associate with the uploaded document";
+            readonly additionalProperties: true;
+            readonly example: {
+                readonly team: "platform";
+                readonly tags: readonly ["internal"];
+            };
+        };
+    };
+};
+export declare const DocumentListResponseSchema: {
+    readonly $id: "DocumentListResponse";
+    readonly type: "object";
+    readonly description: "Paginated list of uploaded documents with metadata";
+    readonly properties: {
+        readonly documents: {
+            readonly type: "array";
+            readonly description: "Array of document summary objects";
+            readonly items: {
+                readonly $ref: "DocumentSummary#";
+            };
+        };
+        readonly total: {
+            readonly type: "integer";
+            readonly description: "Total number of documents matching the query";
+            readonly example: 42;
+        };
+        readonly limit: {
+            readonly type: "integer";
+            readonly description: "Maximum number of results returned in this page";
+            readonly example: 50;
+        };
+        readonly offset: {
+            readonly type: "integer";
+            readonly description: "Number of results skipped for pagination";
+            readonly example: 0;
+        };
+    };
+};
+export declare const DocumentResponseSchema: {
+    readonly $id: "DocumentResponse";
+    readonly type: "object";
+    readonly description: "Full document object including content and metadata";
+    readonly properties: {
+        readonly documentId: {
+            readonly type: "string";
+            readonly description: "Unique document identifier";
+            readonly example: "41c1d4aa-5825-4313-8ae5-737490707b5b";
+        };
+        readonly content: {
+            readonly type: "string";
+            readonly description: "Raw document content as stored";
+            readonly example: "{\"openapi\":\"3.0.0\",\"info\":{\"title\":\"My API\",\"version\":\"1.0\"},\"paths\":{}}";
+        };
+        readonly format: {
+            readonly type: "string";
+            readonly description: "Document format (json or yaml)";
+            readonly example: "json";
+        };
+        readonly metadata: {
+            readonly type: "object";
+            readonly description: "User-supplied metadata associated with the document";
+            readonly additionalProperties: true;
+            readonly example: {
+                readonly team: "platform";
+            };
+        };
+        readonly uploadedAt: {
+            readonly type: "string";
+            readonly format: "date-time";
+            readonly description: "ISO 8601 timestamp when the document was uploaded";
+            readonly example: "2026-03-05T12:00:00.000Z";
+        };
+    };
+};
+export declare const LintJobSubmitResponseSchema: {
+    readonly $id: "LintJobSubmitResponse";
+    readonly type: "object";
+    readonly description: "Response returned when a lint job is successfully queued";
+    readonly properties: {
+        readonly jobId: {
+            readonly type: "string";
+            readonly format: "uuid";
+            readonly description: "Unique job identifier for tracking progress and retrieving results";
+            readonly example: "94c9db52-92fc-4733-806a-fe6d206109aa";
+        };
+        readonly status: {
+            readonly type: "string";
+            readonly enum: readonly ["queued"];
+            readonly description: "Initial status of the newly created job";
+            readonly example: "queued";
+        };
+        readonly message: {
+            readonly type: "string";
+            readonly description: "Human-readable confirmation message";
+            readonly example: "Job submitted successfully";
+        };
+    };
+};
+export declare const CapacityExceededResponseSchema: {
+    readonly $id: "CapacityExceededResponse";
+    readonly type: "object";
+    readonly description: "Response returned when the server cannot accept new jobs due to capacity limits";
+    readonly properties: {
+        readonly error: {
+            readonly type: "string";
+            readonly description: "Error type identifier";
+            readonly example: "Too Many Requests";
+        };
+        readonly message: {
+            readonly type: "string";
+            readonly description: "Human-readable explanation of the capacity limit";
+            readonly example: "Server at capacity with 50 active jobs (max 50)";
+        };
+        readonly activeJobs: {
+            readonly type: "integer";
+            readonly description: "Number of currently active (queued or running) jobs";
+            readonly example: 50;
+        };
+        readonly maxJobs: {
+            readonly type: "integer";
+            readonly description: "Maximum number of concurrent jobs the server allows";
+            readonly example: 50;
+        };
+        readonly retryAfter: {
+            readonly type: "integer";
+            readonly description: "Suggested number of seconds to wait before retrying";
+            readonly example: 5;
+        };
+    };
+};
+export declare const LintJobStatusSchema: {
+    readonly $id: "LintJobStatus";
+    readonly type: "object";
+    readonly description: "Current status and progress of a lint job";
+    readonly properties: {
+        readonly jobId: {
+            readonly type: "string";
+            readonly format: "uuid";
+            readonly description: "Unique job identifier";
+            readonly example: "94c9db52-92fc-4733-806a-fe6d206109aa";
+        };
+        readonly documentId: {
+            readonly type: "string";
+            readonly description: "Identifier of the document being linted";
+            readonly example: "41c1d4aa-5825-4313-8ae5-737490707b5b";
+        };
+        readonly rulesetName: {
+            readonly type: "string";
+            readonly description: "Name of the ruleset used for linting";
+            readonly example: "pubhub";
+        };
+        readonly rulesetVersion: {
+            readonly type: "string";
+            readonly description: "Version of the ruleset used for linting";
+            readonly example: "1.1.0";
+        };
+        readonly ruleOverrides: {
+            readonly $ref: "RuleOverrides#";
+        };
+        readonly status: {
+            readonly $ref: "JobStatus#";
+        };
+        readonly progress: {
+            readonly $ref: "JobProgress#";
+        };
+        readonly startTime: {
+            readonly type: "string";
+            readonly format: "date-time";
+            readonly description: "ISO 8601 timestamp when the job started processing";
+            readonly example: "2026-03-05T12:00:00.000Z";
+        };
+        readonly endTime: {
+            readonly type: "string";
+            readonly format: "date-time";
+            readonly description: "ISO 8601 timestamp when the job finished";
+            readonly example: "2026-03-05T12:00:01.000Z";
+        };
+    };
+};
+export declare const LintJobResultSchema: {
+    readonly $id: "LintJobResult";
+    readonly type: "object";
+    readonly description: "Complete results of a finished lint job including all issues and execution metadata";
+    readonly properties: {
+        readonly jobId: {
+            readonly type: "string";
+            readonly format: "uuid";
+            readonly description: "Unique job identifier";
+            readonly example: "94c9db52-92fc-4733-806a-fe6d206109aa";
+        };
+        readonly documentId: {
+            readonly type: "string";
+            readonly description: "Identifier of the document that was linted";
+            readonly example: "41c1d4aa-5825-4313-8ae5-737490707b5b";
+        };
+        readonly rulesetName: {
+            readonly type: "string";
+            readonly description: "Name of the ruleset used for linting";
+            readonly example: "pubhub";
+        };
+        readonly rulesetVersion: {
+            readonly type: "string";
+            readonly description: "Version of the ruleset used for linting";
+            readonly example: "1.1.0";
+        };
+        readonly ruleOverrides: {
+            readonly $ref: "RuleOverrides#";
+        };
+        readonly status: {
+            readonly $ref: "JobStatus#";
+        };
+        readonly timestamp: {
+            readonly type: "string";
+            readonly format: "date-time";
+            readonly description: "ISO 8601 timestamp when the job completed";
+            readonly example: "2026-03-05T12:00:01.000Z";
+        };
+        readonly totalExecutionTime: {
+            readonly type: "number";
+            readonly description: "Total execution time of the job in milliseconds";
+            readonly example: 321;
+        };
+        readonly summary: {
+            readonly $ref: "ResultSummary#";
+        };
+        readonly results: {
+            readonly type: "array";
+            readonly description: "List of all lint issues found in the document";
+            readonly items: {
+                readonly $ref: "LintIssue#";
+            };
+        };
+        readonly executionDetails: {
+            readonly $ref: "RulesetExecutionResult#";
+        };
+    };
+};
+export declare const ReportGenerationRequestSchema: {
+    readonly $id: "ReportGenerationRequest";
+    readonly type: "object";
+    readonly description: "Request body to generate a report from a completed lint job";
+    readonly required: readonly ["format"];
+    readonly properties: {
+        readonly format: {
+            readonly type: "string";
+            readonly enum: readonly ["sarif"];
+            readonly description: "Output format for the report. Currently only SARIF is supported.";
+            readonly example: "sarif";
+        };
+        readonly options: {
+            readonly type: "object";
+            readonly description: "Optional report generation settings";
+            readonly properties: {
+                readonly includeSnippets: {
+                    readonly type: "boolean";
+                    readonly description: "Include source code snippets in the report for each issue";
+                    readonly example: true;
+                };
+                readonly fingerprintSchemes: {
+                    readonly type: "array";
+                    readonly description: "List of fingerprint scheme names to include for result deduplication";
+                    readonly items: {
+                        readonly type: "string";
+                    };
+                    readonly example: readonly ["v1"];
+                };
+            };
+        };
+    };
+};
+export declare const SarifReportSchema: {
+    readonly $id: "SarifReport";
+    readonly type: "object";
+    readonly description: "SARIF v2.1.0 (Static Analysis Results Interchange Format) report";
+    readonly properties: {
+        readonly version: {
+            readonly type: "string";
+            readonly description: "SARIF format version";
+            readonly example: "2.1.0";
+        };
+        readonly $schema: {
+            readonly type: "string";
+            readonly description: "SARIF JSON schema URI";
+            readonly example: "https://raw.githubusercontent.com/oasis-tcs/sarif-spec/main/sarif-2.1/schema/sarif-schema-2.1.0.json";
+        };
+        readonly runs: {
+            readonly type: "array";
+            readonly description: "Array of analysis runs. Each lint job produces one run.";
+            readonly items: {
+                readonly type: "object";
+                readonly description: "A single SARIF analysis run containing tool info and results";
+                readonly properties: {
+                    readonly tool: {
+                        readonly type: "object";
+                        readonly description: "Information about the analysis tool and its rules";
+                        readonly properties: {
+                            readonly driver: {
+                                readonly type: "object";
+                                readonly description: "The primary analysis tool driver";
+                                readonly properties: {
+                                    readonly name: {
+                                        readonly type: "string";
+                                        readonly description: "Tool name";
+                                        readonly example: "cisco-linting-orchestrator";
+                                    };
+                                    readonly version: {
+                                        readonly type: "string";
+                                        readonly description: "Tool version";
+                                        readonly example: "0.11.0";
+                                    };
+                                };
+                            };
+                        };
+                    };
+                    readonly results: {
+                        readonly type: "array";
+                        readonly description: "Array of analysis results (issues found)";
+                        readonly items: {
+                            readonly type: "object";
+                            readonly description: "A single analysis result";
+                            readonly properties: {
+                                readonly ruleId: {
+                                    readonly type: "string";
+                                    readonly description: "Identifier of the rule that produced this result";
+                                    readonly example: "error-status-code";
+                                };
+                                readonly message: {
+                                    readonly type: "object";
+                                    readonly description: "Message describing the result";
+                                    readonly properties: {
+                                        readonly text: {
+                                            readonly type: "string";
+                                            readonly description: "Plain text message";
+                                            readonly example: "responses should include at least one error status code";
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            };
+        };
+    };
+};
+export declare const JobSummarySchema: {
+    readonly $id: "JobSummary";
+    readonly type: "object";
+    readonly description: "Lightweight summary of a lint job for list views";
+    readonly properties: {
+        readonly jobId: {
+            readonly type: "string";
+            readonly format: "uuid";
+            readonly description: "Unique job identifier";
+            readonly example: "94c9db52-92fc-4733-806a-fe6d206109aa";
+        };
+        readonly documentId: {
+            readonly type: "string";
+            readonly description: "Identifier of the linted document";
+            readonly example: "41c1d4aa-5825-4313-8ae5-737490707b5b";
+        };
+        readonly rulesetName: {
+            readonly type: "string";
+            readonly description: "Name of the ruleset used for linting";
+            readonly example: "pubhub";
+        };
+        readonly rulesetVersion: {
+            readonly type: "string";
+            readonly description: "Version of the ruleset used for linting";
+            readonly example: "1.1.0";
+        };
+        readonly status: {
+            readonly $ref: "JobStatus#";
+        };
+        readonly timestamp: {
+            readonly type: "string";
+            readonly format: "date-time";
+            readonly description: "ISO 8601 timestamp when the job completed";
+            readonly example: "2026-03-05T12:00:01.000Z";
+        };
+        readonly totalExecutionTime: {
+            readonly type: "number";
+            readonly description: "Total execution time in milliseconds";
+            readonly example: 321;
+        };
+        readonly summary: {
+            readonly $ref: "ResultSummary#";
+        };
+    };
+};
+export declare const JobListResponseSchema: {
+    readonly $id: "JobListResponse";
+    readonly type: "object";
+    readonly description: "Paginated list of lightweight job summaries";
+    readonly properties: {
+        readonly jobs: {
+            readonly type: "array";
+            readonly description: "Array of job summary objects";
+            readonly items: {
+                readonly $ref: "JobSummary#";
+            };
+        };
+        readonly pagination: {
+            readonly type: "object";
+            readonly description: "Pagination metadata";
+            readonly properties: {
+                readonly total: {
+                    readonly type: "integer";
+                    readonly description: "Total number of jobs matching the filter criteria";
+                    readonly example: 10;
+                };
+                readonly limit: {
+                    readonly type: "integer";
+                    readonly description: "Maximum number of results returned in this page";
+                    readonly example: 50;
+                };
+                readonly offset: {
+                    readonly type: "integer";
+                    readonly description: "Number of results skipped for pagination";
+                    readonly example: 0;
+                };
+                readonly hasMore: {
+                    readonly type: "boolean";
+                    readonly description: "Whether more results are available beyond this page";
+                    readonly example: false;
+                };
+            };
+        };
+        readonly sessionId: {
+            readonly type: "string";
+            readonly description: "Runtime session ID used to filter stale jobs from previous server instances";
+            readonly example: "a1b2c3d4-e5f6-7890-abcd-ef1234567890";
+        };
+    };
+};
+export declare const JobListDetailedResponseSchema: {
+    readonly $id: "JobListDetailedResponse";
+    readonly type: "object";
+    readonly description: "Paginated list of jobs with full document metadata attached";
+    readonly properties: {
+        readonly jobs: {
+            readonly type: "array";
+            readonly description: "Array of detailed job objects including document metadata";
+            readonly items: {
+                readonly type: "object";
+                readonly description: "A job summary enriched with document metadata";
+                readonly properties: {
+                    readonly jobId: {
+                        readonly type: "string";
+                        readonly format: "uuid";
+                        readonly description: "Unique job identifier";
+                        readonly example: "94c9db52-92fc-4733-806a-fe6d206109aa";
+                    };
+                    readonly documentId: {
+                        readonly type: "string";
+                        readonly description: "Identifier of the linted document";
+                        readonly example: "41c1d4aa-5825-4313-8ae5-737490707b5b";
+                    };
+                    readonly rulesetName: {
+                        readonly type: "string";
+                        readonly description: "Name of the ruleset used for linting";
+                        readonly example: "pubhub";
+                    };
+                    readonly rulesetVersion: {
+                        readonly type: "string";
+                        readonly description: "Version of the ruleset used for linting";
+                        readonly example: "1.1.0";
+                    };
+                    readonly status: {
+                        readonly $ref: "JobStatus#";
+                    };
+                    readonly timestamp: {
+                        readonly type: "string";
+                        readonly format: "date-time";
+                        readonly description: "ISO 8601 timestamp when the job completed";
+                        readonly example: "2026-03-05T12:00:01.000Z";
+                    };
+                    readonly totalExecutionTime: {
+                        readonly type: "number";
+                        readonly description: "Total execution time in milliseconds";
+                        readonly example: 321;
+                    };
+                    readonly summary: {
+                        readonly $ref: "ResultSummary#";
+                    };
+                    readonly document: {
+                        readonly type: "object";
+                        readonly description: "Document metadata from the document store";
+                        readonly properties: {
+                            readonly documentId: {
+                                readonly type: "string";
+                                readonly description: "Document identifier";
+                            };
+                            readonly name: {
+                                readonly type: "string";
+                                readonly description: "Document name or filename";
+                                readonly example: "my-api.yaml";
+                            };
+                            readonly version: {
+                                readonly type: "string";
+                                readonly description: "version from the document";
+                                readonly example: "1.0.0";
+                            };
+                            readonly organization: {
+                                readonly type: "string";
+                                readonly description: "Organization that owns the document";
+                            };
+                            readonly format: {
+                                readonly type: "string";
+                                readonly enum: readonly ["json", "yaml"];
+                                readonly description: "Document format";
+                            };
+                            readonly operationCount: {
+                                readonly type: "integer";
+                                readonly description: "Number of operations in the document";
+                            };
+                            readonly size: {
+                                readonly type: "integer";
+                                readonly description: "Document size in bytes";
+                            };
+                        };
+                    };
+                };
+            };
+        };
+        readonly pagination: {
+            readonly type: "object";
+            readonly description: "Pagination metadata";
+            readonly properties: {
+                readonly total: {
+                    readonly type: "integer";
+                    readonly description: "Total number of jobs matching the filter criteria";
+                    readonly example: 10;
+                };
+                readonly limit: {
+                    readonly type: "integer";
+                    readonly description: "Maximum number of results returned in this page";
+                    readonly example: 50;
+                };
+                readonly offset: {
+                    readonly type: "integer";
+                    readonly description: "Number of results skipped for pagination";
+                    readonly example: 0;
+                };
+                readonly hasMore: {
+                    readonly type: "boolean";
+                    readonly description: "Whether more results are available beyond this page";
+                    readonly example: false;
+                };
+            };
+        };
+        readonly sessionId: {
+            readonly type: "string";
+            readonly description: "Runtime session ID used to filter stale jobs";
+            readonly example: "a1b2c3d4-e5f6-7890-abcd-ef1234567890";
+        };
+    };
+};
+export declare const CacheInvalidationResponseSchema: {
+    readonly $id: "CacheInvalidationResponse";
+    readonly type: "object";
+    readonly description: "Response confirming cache invalidation for a document";
+    readonly properties: {
+        readonly message: {
+            readonly type: "string";
+            readonly description: "Human-readable confirmation message";
+            readonly example: "Cache invalidated for document: abc-123";
+        };
+    };
+};
+export declare const RulesetSummarySchema: {
+    readonly $id: "RulesetSummary";
+    readonly type: "object";
+    readonly description: "Summary metadata for an available ruleset";
+    readonly properties: {
+        readonly name: {
+            readonly type: "string";
+            readonly description: "Unique ruleset identifier (kebab-case)";
+            readonly example: "pubhub";
+        };
+        readonly version: {
+            readonly type: "string";
+            readonly description: "Default version of the ruleset";
+            readonly example: "1.1.0";
+        };
+        readonly defaultVersion: {
+            readonly type: "string";
+            readonly description: "Default version used when no version is specified";
+            readonly example: "1.1.0";
+        };
+        readonly description: {
+            readonly type: "string";
+            readonly description: "Brief description of what the ruleset validates";
+            readonly example: "Validates documents for PubHub publishing readiness";
+        };
+        readonly availableVersions: {
+            readonly type: "array";
+            readonly description: "List of all available version identifiers for this ruleset";
+            readonly items: {
+                readonly type: "string";
+            };
+            readonly example: readonly ["1.0.0", "1.1.0"];
+        };
+        readonly displayName: {
+            readonly type: "string";
+            readonly description: "Human-friendly display name for the ruleset";
+            readonly example: "PubHub Publishing Readiness";
+        };
+        readonly category: {
+            readonly type: "string";
+            readonly enum: readonly ["publishing", "contract", "security", "documentation", "validation", "other"];
+            readonly description: "Classification category of the ruleset";
+            readonly example: "publishing";
+        };
+        readonly ruleCount: {
+            readonly type: "integer";
+            readonly description: "Number of rules in the default version of this ruleset";
+            readonly example: 60;
+        };
+        readonly tags: {
+            readonly type: "array";
+            readonly description: "Tags for filtering or grouping rulesets";
+            readonly items: {
+                readonly type: "string";
+            };
+            readonly example: readonly ["api-insights", "documentation"];
+        };
+    };
+};
+export declare const RulesetDetailsSchema: {
+    readonly $id: "RulesetDetails";
+    readonly type: "object";
+    readonly description: "Detailed information about a ruleset including all individual rules";
+    readonly properties: {
+        readonly name: {
+            readonly type: "string";
+            readonly description: "Unique ruleset identifier (kebab-case)";
+            readonly example: "pubhub";
+        };
+        readonly displayName: {
+            readonly type: "string";
+            readonly description: "Human-friendly display name for the ruleset";
+            readonly example: "PubHub Publishing Readiness";
+        };
+        readonly version: {
+            readonly type: "string";
+            readonly description: "Version of the loaded ruleset";
+            readonly example: "1.1.0";
+        };
+        readonly description: {
+            readonly type: "string";
+            readonly description: "Brief description of what the ruleset validates";
+            readonly example: "Validates documents for PubHub publishing readiness";
+        };
+        readonly category: {
+            readonly type: "string";
+            readonly enum: readonly ["publishing", "contract", "security", "documentation", "validation", "other"];
+            readonly description: "Classification category";
+            readonly example: "publishing";
+        };
+        readonly ruleCount: {
+            readonly type: "integer";
+            readonly description: "Total number of rules in this ruleset version";
+            readonly example: 60;
+        };
+        readonly releaseDate: {
+            readonly type: "string";
+            readonly description: "Release date of this ruleset version";
+            readonly example: "2025-11-19";
+        };
+        readonly deprecated: {
+            readonly type: "boolean";
+            readonly description: "Whether this ruleset version is deprecated";
+            readonly example: false;
+        };
+        readonly tags: {
+            readonly type: "array";
+            readonly description: "Tags for filtering or grouping rulesets";
+            readonly items: {
+                readonly type: "string";
+            };
+            readonly example: readonly ["api-insights", "documentation"];
+        };
+        readonly rules: {
+            readonly type: "array";
+            readonly description: "List of all individual rules in this ruleset version";
+            readonly items: {
+                readonly $ref: "RuleInfo#";
+            };
+        };
+    };
+};
+export declare const StatsResponseSchema: {
+    readonly $id: "StatsResponse";
+    readonly type: "object";
+    readonly description: "Combined storage and orchestrator statistics";
+    readonly properties: {
+        readonly storage: {
+            readonly type: "object";
+            readonly description: "Statistics about the lint result storage backend";
+            readonly properties: {
+                readonly totalJobs: {
+                    readonly type: "integer";
+                    readonly description: "Total number of jobs stored";
+                    readonly example: 42;
+                };
+                readonly totalResults: {
+                    readonly type: "integer";
+                    readonly description: "Total number of lint results stored";
+                    readonly example: 42;
+                };
+                readonly storageSize: {
+                    readonly type: "number";
+                    readonly description: "Approximate storage size in bytes";
+                    readonly example: 102400;
+                };
+            };
+        };
+        readonly orchestrator: {
+            readonly type: "object";
+            readonly description: "Orchestrator runtime statistics including active jobs and worker pool state";
+            readonly additionalProperties: true;
+            readonly example: {
+                readonly activeJobs: 0;
+                readonly totalJobsProcessed: 42;
+                readonly workerPoolSize: 4;
+            };
+        };
+        readonly timestamp: {
+            readonly type: "string";
+            readonly format: "date-time";
+            readonly description: "ISO 8601 timestamp when the statistics were collected";
+            readonly example: "2026-03-05T12:00:00.000Z";
+        };
+    };
+};
+export declare const DocumentListQuerySchema: {
+    readonly type: "object";
+    readonly description: "Query parameters for listing or searching documents";
+    readonly properties: {
+        readonly limit: {
+            readonly type: "integer";
+            readonly default: 50;
+            readonly description: "Maximum number of results to return";
+        };
+        readonly offset: {
+            readonly type: "integer";
+            readonly default: 0;
+            readonly description: "Number of results to skip for pagination";
+        };
+        readonly sortBy: {
+            readonly type: "string";
+            readonly default: "uploadedAt";
+            readonly description: "Field to sort by";
+        };
+        readonly sortOrder: {
+            readonly type: "string";
+            readonly enum: readonly ["asc", "desc"];
+            readonly default: "desc";
+            readonly description: "Sort direction";
+        };
+        readonly search: {
+            readonly type: "string";
+            readonly description: "Text search query across document metadata";
+        };
+        readonly organization: {
+            readonly type: "string";
+            readonly description: "Filter by organization";
+        };
+        readonly tags: {
+            readonly type: "string";
+            readonly description: "Comma-separated list of tags to filter by";
+        };
+        readonly format: {
+            readonly type: "string";
+            readonly description: "Filter by document format (json, yaml)";
+        };
+    };
+};
+export declare const JobListQuerySchema: {
+    readonly type: "object";
+    readonly description: "Query parameters for listing lint jobs";
+    readonly properties: {
+        readonly status: {
+            readonly type: "string";
+            readonly description: "Filter by job status. Comma-separated for multiple values.";
+        };
+        readonly documentId: {
+            readonly type: "string";
+            readonly description: "Filter by document ID";
+        };
+        readonly rulesetName: {
+            readonly type: "string";
+            readonly description: "Filter by ruleset name";
+        };
+        readonly startDate: {
+            readonly type: "string";
+            readonly format: "date-time";
+            readonly description: "Filter jobs created after this date (ISO 8601)";
+        };
+        readonly endDate: {
+            readonly type: "string";
+            readonly format: "date-time";
+            readonly description: "Filter jobs created before this date (ISO 8601)";
+        };
+        readonly limit: {
+            readonly type: "integer";
+            readonly default: 50;
+            readonly description: "Maximum number of results";
+        };
+        readonly offset: {
+            readonly type: "integer";
+            readonly default: 0;
+            readonly description: "Pagination offset";
+        };
+        readonly sortBy: {
+            readonly type: "string";
+            readonly default: "timestamp";
+            readonly description: "Field to sort by";
+        };
+        readonly sortOrder: {
+            readonly type: "string";
+            readonly enum: readonly ["asc", "desc"];
+            readonly default: "desc";
+            readonly description: "Sort direction";
+        };
+    };
+};
+export declare const RulesetNameParamSchema: {
+    readonly type: "object";
+    readonly required: readonly ["name"];
+    readonly properties: {
+        readonly name: {
+            readonly type: "string";
+            readonly description: "Ruleset name (e.g., pubhub, api-insights-completeness)";
+        };
+    };
+};
+export declare const RulesetVersionQuerySchema: {
+    readonly type: "object";
+    readonly properties: {
+        readonly version: {
+            readonly type: "string";
+            readonly description: "Specific version to load. Defaults to the ruleset's default version.";
+        };
+    };
+};
+export declare const sharedSchemas: ({
+    readonly $id: "ErrorResponse";
+    readonly type: "object";
+    readonly description: "Standard error response returned by all endpoints on failure";
+    readonly required: readonly ["error", "timestamp"];
+    readonly properties: {
+        readonly error: {
+            readonly type: "string";
+            readonly description: "Error category (e.g., Not Found, Validation Error, Internal Server Error)";
+            readonly example: "Not Found";
+        };
+        readonly message: {
+            readonly type: "string";
+            readonly description: "Human-readable error message with context";
+            readonly example: "Document not found: abc-123";
+        };
+        readonly details: {
+            readonly type: "object";
+            readonly description: "Additional error details such as validation errors or field-level issues";
+            readonly additionalProperties: true;
+        };
+        readonly timestamp: {
+            readonly type: "string";
+            readonly format: "date-time";
+            readonly description: "ISO 8601 timestamp when the error occurred";
+            readonly example: "2026-03-05T12:00:00.000Z";
+        };
+    };
+} | {
+    readonly $id: "JobStatus";
+    readonly type: "string";
+    readonly description: "Lifecycle status of a lint job";
+    readonly enum: readonly ["queued", "running", "completed", "completed_with_errors", "failed", "timeout", "cancelled"];
+    readonly example: "completed";
+} | {
+    readonly $id: "JobProgress";
+    readonly type: "object";
+    readonly description: "Task-level progress breakdown for a lint job";
+    readonly properties: {
+        readonly totalTasks: {
+            readonly type: "integer";
+            readonly description: "Total number of tasks in the job";
+            readonly example: 1;
+        };
+        readonly completedTasks: {
+            readonly type: "integer";
+            readonly description: "Number of tasks that completed successfully";
+            readonly example: 1;
+        };
+        readonly failedTasks: {
+            readonly type: "integer";
+            readonly description: "Number of tasks that failed with errors";
+            readonly example: 0;
+        };
+        readonly timeoutTasks: {
+            readonly type: "integer";
+            readonly description: "Number of tasks that exceeded the execution timeout";
+            readonly example: 0;
+        };
+        readonly runningTasks: {
+            readonly type: "integer";
+            readonly description: "Number of tasks currently being executed";
+            readonly example: 0;
+        };
+        readonly queuedTasks: {
+            readonly type: "integer";
+            readonly description: "Number of tasks waiting in the queue";
+            readonly example: 0;
+        };
+    };
+} | {
+    readonly $id: "SourcePosition";
+    readonly type: "object";
+    readonly description: "A position in a text document identified by line and character offset";
+    readonly properties: {
+        readonly line: {
+            readonly type: "integer";
+            readonly description: "Zero-based line number in the source document";
+            readonly example: 62;
+        };
+        readonly character: {
+            readonly type: "integer";
+            readonly description: "Zero-based character offset within the line";
+            readonly example: 20;
+        };
+    };
+} | {
+    readonly $id: "SourceRange";
+    readonly type: "object";
+    readonly description: "Source location range within the document (line and character positions)";
+    readonly properties: {
+        readonly start: {
+            readonly $ref: "SourcePosition#";
+        };
+        readonly end: {
+            readonly $ref: "SourcePosition#";
+        };
+    };
+} | {
+    readonly $id: "LintIssue";
+    readonly type: "object";
+    readonly description: "A single lint issue found in the document";
+    readonly properties: {
+        readonly ruleId: {
+            readonly type: "string";
+            readonly description: "Unique identifier of the rule that triggered this issue";
+            readonly example: "error-status-code";
+        };
+        readonly code: {
+            readonly type: "string";
+            readonly description: "Machine-readable issue code from the ruleset";
+            readonly example: "error-status-code";
+        };
+        readonly message: {
+            readonly type: "string";
+            readonly description: "Human-readable description of the issue";
+            readonly example: "responses should include at least one error status code (4xx or 5xx)";
+        };
+        readonly severity: {
+            readonly type: "integer";
+            readonly enum: readonly [0, 1, 2, 3];
+            readonly description: "Severity level: 0=error, 1=warn, 2=info, 3=hint";
+            readonly example: 1;
+        };
+        readonly path: {
+            readonly type: "array";
+            readonly description: "JSONPath segments to the location of the issue in the document";
+            readonly items: {
+                readonly oneOf: readonly [{
+                    readonly type: "string";
+                }, {
+                    readonly type: "integer";
+                }];
+            };
+            readonly example: readonly ["paths", "/health", "get", "responses"];
+        };
+        readonly range: {
+            readonly $ref: "SourceRange#";
+        };
+        readonly suggestions: {
+            readonly type: "array";
+            readonly description: "Suggested fixes or improvements for the issue";
+            readonly items: {
+                readonly type: "string";
+            };
+            readonly example: readonly ["Add a 4xx or 5xx response to this operation"];
+        };
+    };
+} | {
+    readonly $id: "ResultSummary";
+    readonly type: "object";
+    readonly description: "Aggregated issue counts by severity level";
+    readonly properties: {
+        readonly totalIssues: {
+            readonly type: "integer";
+            readonly description: "Total number of issues found across all severity levels";
+            readonly example: 13;
+        };
+        readonly errorCount: {
+            readonly type: "integer";
+            readonly description: "Number of issues with error severity (must fix)";
+            readonly example: 5;
+        };
+        readonly warningCount: {
+            readonly type: "integer";
+            readonly description: "Number of issues with warning severity (should fix)";
+            readonly example: 8;
+        };
+        readonly infoCount: {
+            readonly type: "integer";
+            readonly description: "Number of informational issues";
+            readonly example: 0;
+        };
+        readonly hintCount: {
+            readonly type: "integer";
+            readonly description: "Number of hint-level suggestions";
+            readonly example: 0;
+        };
+    };
+} | {
+    readonly $id: "RulesetExecutionResult";
+    readonly type: "object";
+    readonly description: "Execution details for a single ruleset run against a document";
+    readonly properties: {
+        readonly rulesetName: {
+            readonly type: "string";
+            readonly description: "Name of the executed ruleset";
+            readonly example: "pubhub";
+        };
+        readonly rulesetVersion: {
+            readonly type: "string";
+            readonly description: "Version of the executed ruleset";
+            readonly example: "1.1.0";
+        };
+        readonly executionTime: {
+            readonly type: "number";
+            readonly description: "Execution time in milliseconds for this ruleset";
+            readonly example: 277;
+        };
+        readonly success: {
+            readonly type: "boolean";
+            readonly description: "Whether the ruleset execution completed without internal errors";
+            readonly example: true;
+        };
+        readonly error: {
+            readonly type: "string";
+            readonly description: "Error message if the ruleset execution failed internally";
+            readonly example: "";
+        };
+        readonly issueCount: {
+            readonly type: "integer";
+            readonly description: "Total number of issues found by this ruleset";
+            readonly example: 0;
+        };
+        readonly issues: {
+            readonly type: "array";
+            readonly description: "List of issues found by this ruleset";
+            readonly items: {
+                readonly $ref: "LintIssue#";
+            };
+        };
+        readonly metadata: {
+            readonly type: "object";
+            readonly description: "Execution metadata for this ruleset run";
+            readonly properties: {
+                readonly ruleEngine: {
+                    readonly type: "string";
+                    readonly description: "Name of the rule engine that executed the ruleset";
+                    readonly example: "spectral";
+                };
+                readonly documentId: {
+                    readonly type: "string";
+                    readonly description: "Identifier of the linted document";
+                    readonly example: "41c1d4aa-5825-4313-8ae5-737490707b5b";
+                };
+                readonly cacheHit: {
+                    readonly type: "boolean";
+                    readonly description: "Whether the result was served from cache";
+                    readonly example: false;
+                };
+            };
+        };
+    };
+} | {
+    readonly $id: "RuleInfo";
+    readonly type: "object";
+    readonly description: "Metadata for a single lint rule within a ruleset";
+    readonly properties: {
+        readonly name: {
+            readonly type: "string";
+            readonly description: "Unique rule identifier within the ruleset";
+            readonly example: "operationId-required-and-unique";
+        };
+        readonly severity: {
+            readonly type: "string";
+            readonly enum: readonly ["error", "warn", "info", "hint"];
+            readonly description: "Default severity level of the rule";
+            readonly example: "error";
+        };
+        readonly message: {
+            readonly type: "string";
+            readonly description: "Message template shown when the rule is triggered";
+            readonly example: "Every operation must have a unique operationId";
+        };
+        readonly description: {
+            readonly type: "string";
+            readonly description: "Detailed explanation of what the rule checks and why";
+            readonly example: "Ensures every operation has a unique operationId for code generation";
+        };
+        readonly recommended: {
+            readonly type: "boolean";
+            readonly description: "Whether this rule is recommended to be enabled";
+            readonly example: true;
+        };
+    };
+} | {
+    readonly $id: "DocumentSummary";
+    readonly type: "object";
+    readonly description: "Summary metadata for an uploaded document";
+    readonly properties: {
+        readonly documentId: {
+            readonly type: "string";
+            readonly description: "Unique document identifier";
+            readonly example: "41c1d4aa-5825-4313-8ae5-737490707b5b";
+        };
+        readonly title: {
+            readonly type: "string";
+            readonly description: "Title from the document info section";
+            readonly example: "My API";
+        };
+        readonly version: {
+            readonly type: "string";
+            readonly description: "API version from the document";
+            readonly example: "1.0.0";
+        };
+        readonly format: {
+            readonly type: "string";
+            readonly description: "Document format (json or yaml)";
+            readonly example: "json";
+        };
+        readonly uploadedAt: {
+            readonly type: "string";
+            readonly format: "date-time";
+            readonly description: "ISO 8601 timestamp when the document was uploaded";
+            readonly example: "2026-03-05T12:00:00.000Z";
+        };
+    };
+} | {
+    readonly $id: "RuleOverrides";
+    readonly type: "object";
+    readonly description: "Map of rule IDs to override severity. Use \"off\" to exclude a rule, or a severity level to change it.";
+    readonly additionalProperties: {
+        readonly type: "string";
+        readonly enum: readonly ["off", "error", "warn", "info", "hint"];
+    };
+    readonly example: {
+        readonly 'operationId-required': "off";
+        readonly 'error-status-code': "warn";
+    };
+} | {
+    readonly $id: "HealthResponse";
+    readonly type: "object";
+    readonly description: "Server health status including uptime, configuration, and runtime statistics";
+    readonly properties: {
+        readonly status: {
+            readonly type: "string";
+            readonly enum: readonly ["ok"];
+            readonly description: "Server health status indicator";
+            readonly example: "ok";
+        };
+        readonly version: {
+            readonly type: "string";
+            readonly description: "Orchestrator server version (semver)";
+            readonly example: "0.11.0";
+        };
+        readonly timestamp: {
+            readonly type: "string";
+            readonly format: "date-time";
+            readonly description: "Current server time in ISO 8601 format";
+            readonly example: "2026-03-05T12:00:00.000Z";
+        };
+        readonly uptime: {
+            readonly type: "integer";
+            readonly description: "Server uptime in seconds since last start";
+            readonly example: 3600;
+        };
+        readonly mode: {
+            readonly type: "string";
+            readonly enum: readonly ["standalone", "embedded", "companion", "mcp"];
+            readonly description: "Current deployment mode of the server";
+            readonly example: "standalone";
+        };
+        readonly server: {
+            readonly type: "object";
+            readonly description: "HTTP server configuration details";
+            readonly properties: {
+                readonly port: {
+                    readonly type: "integer";
+                    readonly description: "Port the server is listening on";
+                    readonly example: 3003;
+                };
+                readonly host: {
+                    readonly type: "string";
+                    readonly description: "Host address the server is bound to";
+                    readonly example: "0.0.0.0";
+                };
+                readonly startedAt: {
+                    readonly type: "string";
+                    readonly format: "date-time";
+                    readonly description: "ISO 8601 timestamp when the server started";
+                    readonly example: "2026-03-05T11:00:00.000Z";
+                };
+            };
+        };
+        readonly documentStore: {
+            readonly type: "object";
+            readonly description: "Document storage backend configuration";
+            readonly properties: {
+                readonly type: {
+                    readonly type: "string";
+                    readonly enum: readonly ["local", "passthrough"];
+                    readonly description: "Type of document store in use";
+                    readonly example: "local";
+                };
+                readonly baseDir: {
+                    readonly type: "string";
+                    readonly description: "Relative base directory for document storage";
+                    readonly example: "./uploads";
+                };
+                readonly fullPath: {
+                    readonly type: "string";
+                    readonly description: "Absolute resolved path to the document storage directory";
+                    readonly example: "/home/user/spectify/uploads";
+                };
+            };
+        };
+        readonly stats: {
+            readonly type: "object";
+            readonly description: "Orchestrator runtime statistics snapshot (active jobs, worker counts, etc.)";
+            readonly additionalProperties: true;
+            readonly example: {
+                readonly activeJobs: 0;
+                readonly totalJobsProcessed: 42;
+            };
+        };
+        readonly runtime: {
+            readonly type: "object";
+            readonly description: "Runtime environment information (Node.js version, Spectral library versions, active resolver).";
+            readonly properties: {
+                readonly nodeVersion: {
+                    readonly type: "string";
+                    readonly description: "Node.js runtime version";
+                    readonly example: "v22.18.0";
+                };
+                readonly spectralCore: {
+                    readonly type: "string";
+                    readonly description: "Installed @stoplight/spectral-core version";
+                    readonly example: "1.19.0";
+                };
+                readonly spectralRulesets: {
+                    readonly type: "string";
+                    readonly description: "Installed @stoplight/spectral-rulesets version";
+                    readonly example: "1.22.0";
+                };
+                readonly spectralCli: {
+                    readonly type: "string";
+                    readonly description: "Installed @stoplight/spectral-cli version";
+                    readonly example: "6.16.0";
+                };
+                readonly resolver: {
+                    readonly type: readonly ["string", "null"];
+                    readonly description: "Active custom $ref resolver name, or null when using Spectral default resolver";
+                    readonly example: "ignore-external-refs";
+                };
+            };
+        };
+        readonly reportService: {
+            readonly type: "object";
+            readonly description: "Report Service connection status. Only present when configured.";
+            readonly additionalProperties: true;
+            readonly example: {
+                readonly connected: true;
+                readonly url: "http://localhost:3010";
+            };
+        };
+    };
+} | {
+    readonly $id: "DocumentUploadResponse";
+    readonly type: "object";
+    readonly description: "Response after successfully uploading a document";
+    readonly properties: {
+        readonly documentId: {
+            readonly type: "string";
+            readonly description: "Unique identifier assigned to the uploaded document";
+            readonly example: "41c1d4aa-5825-4313-8ae5-737490707b5b";
+        };
+        readonly version: {
+            readonly type: "string";
+            readonly description: "Version identifier of the stored document";
+            readonly example: "1";
+        };
+        readonly message: {
+            readonly type: "string";
+            readonly description: "Human-readable confirmation message";
+            readonly example: "Document uploaded successfully";
+        };
+    };
+} | {
+    readonly $id: "DocumentUploadRequest";
+    readonly type: "object";
+    readonly description: "Request body for uploading a document";
+    readonly required: readonly ["content"];
+    readonly properties: {
+        readonly content: {
+            readonly type: "string";
+            readonly description: "Raw document content as a JSON or YAML string";
+            readonly example: "{\"openapi\":\"3.0.0\",\"info\":{\"title\":\"My API\",\"version\":\"1.0\"},\"paths\":{}}";
+        };
+        readonly format: {
+            readonly type: "string";
+            readonly enum: readonly ["json", "yaml"];
+            readonly default: "json";
+            readonly description: "Format of the document content being uploaded";
+            readonly example: "json";
+        };
+        readonly metadata: {
+            readonly type: "object";
+            readonly description: "Optional metadata to associate with the uploaded document";
+            readonly additionalProperties: true;
+            readonly example: {
+                readonly team: "platform";
+                readonly tags: readonly ["internal"];
+            };
+        };
+    };
+} | {
+    readonly $id: "DocumentListResponse";
+    readonly type: "object";
+    readonly description: "Paginated list of uploaded documents with metadata";
+    readonly properties: {
+        readonly documents: {
+            readonly type: "array";
+            readonly description: "Array of document summary objects";
+            readonly items: {
+                readonly $ref: "DocumentSummary#";
+            };
+        };
+        readonly total: {
+            readonly type: "integer";
+            readonly description: "Total number of documents matching the query";
+            readonly example: 42;
+        };
+        readonly limit: {
+            readonly type: "integer";
+            readonly description: "Maximum number of results returned in this page";
+            readonly example: 50;
+        };
+        readonly offset: {
+            readonly type: "integer";
+            readonly description: "Number of results skipped for pagination";
+            readonly example: 0;
+        };
+    };
+} | {
+    readonly $id: "DocumentResponse";
+    readonly type: "object";
+    readonly description: "Full document object including content and metadata";
+    readonly properties: {
+        readonly documentId: {
+            readonly type: "string";
+            readonly description: "Unique document identifier";
+            readonly example: "41c1d4aa-5825-4313-8ae5-737490707b5b";
+        };
+        readonly content: {
+            readonly type: "string";
+            readonly description: "Raw document content as stored";
+            readonly example: "{\"openapi\":\"3.0.0\",\"info\":{\"title\":\"My API\",\"version\":\"1.0\"},\"paths\":{}}";
+        };
+        readonly format: {
+            readonly type: "string";
+            readonly description: "Document format (json or yaml)";
+            readonly example: "json";
+        };
+        readonly metadata: {
+            readonly type: "object";
+            readonly description: "User-supplied metadata associated with the document";
+            readonly additionalProperties: true;
+            readonly example: {
+                readonly team: "platform";
+            };
+        };
+        readonly uploadedAt: {
+            readonly type: "string";
+            readonly format: "date-time";
+            readonly description: "ISO 8601 timestamp when the document was uploaded";
+            readonly example: "2026-03-05T12:00:00.000Z";
+        };
+    };
+} | {
+    readonly $id: "LintJobSubmitResponse";
+    readonly type: "object";
+    readonly description: "Response returned when a lint job is successfully queued";
+    readonly properties: {
+        readonly jobId: {
+            readonly type: "string";
+            readonly format: "uuid";
+            readonly description: "Unique job identifier for tracking progress and retrieving results";
+            readonly example: "94c9db52-92fc-4733-806a-fe6d206109aa";
+        };
+        readonly status: {
+            readonly type: "string";
+            readonly enum: readonly ["queued"];
+            readonly description: "Initial status of the newly created job";
+            readonly example: "queued";
+        };
+        readonly message: {
+            readonly type: "string";
+            readonly description: "Human-readable confirmation message";
+            readonly example: "Job submitted successfully";
+        };
+    };
+} | {
+    readonly $id: "CapacityExceededResponse";
+    readonly type: "object";
+    readonly description: "Response returned when the server cannot accept new jobs due to capacity limits";
+    readonly properties: {
+        readonly error: {
+            readonly type: "string";
+            readonly description: "Error type identifier";
+            readonly example: "Too Many Requests";
+        };
+        readonly message: {
+            readonly type: "string";
+            readonly description: "Human-readable explanation of the capacity limit";
+            readonly example: "Server at capacity with 50 active jobs (max 50)";
+        };
+        readonly activeJobs: {
+            readonly type: "integer";
+            readonly description: "Number of currently active (queued or running) jobs";
+            readonly example: 50;
+        };
+        readonly maxJobs: {
+            readonly type: "integer";
+            readonly description: "Maximum number of concurrent jobs the server allows";
+            readonly example: 50;
+        };
+        readonly retryAfter: {
+            readonly type: "integer";
+            readonly description: "Suggested number of seconds to wait before retrying";
+            readonly example: 5;
+        };
+    };
+} | {
+    readonly $id: "LintJobStatus";
+    readonly type: "object";
+    readonly description: "Current status and progress of a lint job";
+    readonly properties: {
+        readonly jobId: {
+            readonly type: "string";
+            readonly format: "uuid";
+            readonly description: "Unique job identifier";
+            readonly example: "94c9db52-92fc-4733-806a-fe6d206109aa";
+        };
+        readonly documentId: {
+            readonly type: "string";
+            readonly description: "Identifier of the document being linted";
+            readonly example: "41c1d4aa-5825-4313-8ae5-737490707b5b";
+        };
+        readonly rulesetName: {
+            readonly type: "string";
+            readonly description: "Name of the ruleset used for linting";
+            readonly example: "pubhub";
+        };
+        readonly rulesetVersion: {
+            readonly type: "string";
+            readonly description: "Version of the ruleset used for linting";
+            readonly example: "1.1.0";
+        };
+        readonly ruleOverrides: {
+            readonly $ref: "RuleOverrides#";
+        };
+        readonly status: {
+            readonly $ref: "JobStatus#";
+        };
+        readonly progress: {
+            readonly $ref: "JobProgress#";
+        };
+        readonly startTime: {
+            readonly type: "string";
+            readonly format: "date-time";
+            readonly description: "ISO 8601 timestamp when the job started processing";
+            readonly example: "2026-03-05T12:00:00.000Z";
+        };
+        readonly endTime: {
+            readonly type: "string";
+            readonly format: "date-time";
+            readonly description: "ISO 8601 timestamp when the job finished";
+            readonly example: "2026-03-05T12:00:01.000Z";
+        };
+    };
+} | {
+    readonly $id: "LintJobResult";
+    readonly type: "object";
+    readonly description: "Complete results of a finished lint job including all issues and execution metadata";
+    readonly properties: {
+        readonly jobId: {
+            readonly type: "string";
+            readonly format: "uuid";
+            readonly description: "Unique job identifier";
+            readonly example: "94c9db52-92fc-4733-806a-fe6d206109aa";
+        };
+        readonly documentId: {
+            readonly type: "string";
+            readonly description: "Identifier of the document that was linted";
+            readonly example: "41c1d4aa-5825-4313-8ae5-737490707b5b";
+        };
+        readonly rulesetName: {
+            readonly type: "string";
+            readonly description: "Name of the ruleset used for linting";
+            readonly example: "pubhub";
+        };
+        readonly rulesetVersion: {
+            readonly type: "string";
+            readonly description: "Version of the ruleset used for linting";
+            readonly example: "1.1.0";
+        };
+        readonly ruleOverrides: {
+            readonly $ref: "RuleOverrides#";
+        };
+        readonly status: {
+            readonly $ref: "JobStatus#";
+        };
+        readonly timestamp: {
+            readonly type: "string";
+            readonly format: "date-time";
+            readonly description: "ISO 8601 timestamp when the job completed";
+            readonly example: "2026-03-05T12:00:01.000Z";
+        };
+        readonly totalExecutionTime: {
+            readonly type: "number";
+            readonly description: "Total execution time of the job in milliseconds";
+            readonly example: 321;
+        };
+        readonly summary: {
+            readonly $ref: "ResultSummary#";
+        };
+        readonly results: {
+            readonly type: "array";
+            readonly description: "List of all lint issues found in the document";
+            readonly items: {
+                readonly $ref: "LintIssue#";
+            };
+        };
+        readonly executionDetails: {
+            readonly $ref: "RulesetExecutionResult#";
+        };
+    };
+} | {
+    readonly $id: "ReportGenerationRequest";
+    readonly type: "object";
+    readonly description: "Request body to generate a report from a completed lint job";
+    readonly required: readonly ["format"];
+    readonly properties: {
+        readonly format: {
+            readonly type: "string";
+            readonly enum: readonly ["sarif"];
+            readonly description: "Output format for the report. Currently only SARIF is supported.";
+            readonly example: "sarif";
+        };
+        readonly options: {
+            readonly type: "object";
+            readonly description: "Optional report generation settings";
+            readonly properties: {
+                readonly includeSnippets: {
+                    readonly type: "boolean";
+                    readonly description: "Include source code snippets in the report for each issue";
+                    readonly example: true;
+                };
+                readonly fingerprintSchemes: {
+                    readonly type: "array";
+                    readonly description: "List of fingerprint scheme names to include for result deduplication";
+                    readonly items: {
+                        readonly type: "string";
+                    };
+                    readonly example: readonly ["v1"];
+                };
+            };
+        };
+    };
+} | {
+    readonly $id: "SarifReport";
+    readonly type: "object";
+    readonly description: "SARIF v2.1.0 (Static Analysis Results Interchange Format) report";
+    readonly properties: {
+        readonly version: {
+            readonly type: "string";
+            readonly description: "SARIF format version";
+            readonly example: "2.1.0";
+        };
+        readonly $schema: {
+            readonly type: "string";
+            readonly description: "SARIF JSON schema URI";
+            readonly example: "https://raw.githubusercontent.com/oasis-tcs/sarif-spec/main/sarif-2.1/schema/sarif-schema-2.1.0.json";
+        };
+        readonly runs: {
+            readonly type: "array";
+            readonly description: "Array of analysis runs. Each lint job produces one run.";
+            readonly items: {
+                readonly type: "object";
+                readonly description: "A single SARIF analysis run containing tool info and results";
+                readonly properties: {
+                    readonly tool: {
+                        readonly type: "object";
+                        readonly description: "Information about the analysis tool and its rules";
+                        readonly properties: {
+                            readonly driver: {
+                                readonly type: "object";
+                                readonly description: "The primary analysis tool driver";
+                                readonly properties: {
+                                    readonly name: {
+                                        readonly type: "string";
+                                        readonly description: "Tool name";
+                                        readonly example: "cisco-linting-orchestrator";
+                                    };
+                                    readonly version: {
+                                        readonly type: "string";
+                                        readonly description: "Tool version";
+                                        readonly example: "0.11.0";
+                                    };
+                                };
+                            };
+                        };
+                    };
+                    readonly results: {
+                        readonly type: "array";
+                        readonly description: "Array of analysis results (issues found)";
+                        readonly items: {
+                            readonly type: "object";
+                            readonly description: "A single analysis result";
+                            readonly properties: {
+                                readonly ruleId: {
+                                    readonly type: "string";
+                                    readonly description: "Identifier of the rule that produced this result";
+                                    readonly example: "error-status-code";
+                                };
+                                readonly message: {
+                                    readonly type: "object";
+                                    readonly description: "Message describing the result";
+                                    readonly properties: {
+                                        readonly text: {
+                                            readonly type: "string";
+                                            readonly description: "Plain text message";
+                                            readonly example: "responses should include at least one error status code";
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            };
+        };
+    };
+} | {
+    readonly $id: "JobSummary";
+    readonly type: "object";
+    readonly description: "Lightweight summary of a lint job for list views";
+    readonly properties: {
+        readonly jobId: {
+            readonly type: "string";
+            readonly format: "uuid";
+            readonly description: "Unique job identifier";
+            readonly example: "94c9db52-92fc-4733-806a-fe6d206109aa";
+        };
+        readonly documentId: {
+            readonly type: "string";
+            readonly description: "Identifier of the linted document";
+            readonly example: "41c1d4aa-5825-4313-8ae5-737490707b5b";
+        };
+        readonly rulesetName: {
+            readonly type: "string";
+            readonly description: "Name of the ruleset used for linting";
+            readonly example: "pubhub";
+        };
+        readonly rulesetVersion: {
+            readonly type: "string";
+            readonly description: "Version of the ruleset used for linting";
+            readonly example: "1.1.0";
+        };
+        readonly status: {
+            readonly $ref: "JobStatus#";
+        };
+        readonly timestamp: {
+            readonly type: "string";
+            readonly format: "date-time";
+            readonly description: "ISO 8601 timestamp when the job completed";
+            readonly example: "2026-03-05T12:00:01.000Z";
+        };
+        readonly totalExecutionTime: {
+            readonly type: "number";
+            readonly description: "Total execution time in milliseconds";
+            readonly example: 321;
+        };
+        readonly summary: {
+            readonly $ref: "ResultSummary#";
+        };
+    };
+} | {
+    readonly $id: "JobListResponse";
+    readonly type: "object";
+    readonly description: "Paginated list of lightweight job summaries";
+    readonly properties: {
+        readonly jobs: {
+            readonly type: "array";
+            readonly description: "Array of job summary objects";
+            readonly items: {
+                readonly $ref: "JobSummary#";
+            };
+        };
+        readonly pagination: {
+            readonly type: "object";
+            readonly description: "Pagination metadata";
+            readonly properties: {
+                readonly total: {
+                    readonly type: "integer";
+                    readonly description: "Total number of jobs matching the filter criteria";
+                    readonly example: 10;
+                };
+                readonly limit: {
+                    readonly type: "integer";
+                    readonly description: "Maximum number of results returned in this page";
+                    readonly example: 50;
+                };
+                readonly offset: {
+                    readonly type: "integer";
+                    readonly description: "Number of results skipped for pagination";
+                    readonly example: 0;
+                };
+                readonly hasMore: {
+                    readonly type: "boolean";
+                    readonly description: "Whether more results are available beyond this page";
+                    readonly example: false;
+                };
+            };
+        };
+        readonly sessionId: {
+            readonly type: "string";
+            readonly description: "Runtime session ID used to filter stale jobs from previous server instances";
+            readonly example: "a1b2c3d4-e5f6-7890-abcd-ef1234567890";
+        };
+    };
+} | {
+    readonly $id: "JobListDetailedResponse";
+    readonly type: "object";
+    readonly description: "Paginated list of jobs with full document metadata attached";
+    readonly properties: {
+        readonly jobs: {
+            readonly type: "array";
+            readonly description: "Array of detailed job objects including document metadata";
+            readonly items: {
+                readonly type: "object";
+                readonly description: "A job summary enriched with document metadata";
+                readonly properties: {
+                    readonly jobId: {
+                        readonly type: "string";
+                        readonly format: "uuid";
+                        readonly description: "Unique job identifier";
+                        readonly example: "94c9db52-92fc-4733-806a-fe6d206109aa";
+                    };
+                    readonly documentId: {
+                        readonly type: "string";
+                        readonly description: "Identifier of the linted document";
+                        readonly example: "41c1d4aa-5825-4313-8ae5-737490707b5b";
+                    };
+                    readonly rulesetName: {
+                        readonly type: "string";
+                        readonly description: "Name of the ruleset used for linting";
+                        readonly example: "pubhub";
+                    };
+                    readonly rulesetVersion: {
+                        readonly type: "string";
+                        readonly description: "Version of the ruleset used for linting";
+                        readonly example: "1.1.0";
+                    };
+                    readonly status: {
+                        readonly $ref: "JobStatus#";
+                    };
+                    readonly timestamp: {
+                        readonly type: "string";
+                        readonly format: "date-time";
+                        readonly description: "ISO 8601 timestamp when the job completed";
+                        readonly example: "2026-03-05T12:00:01.000Z";
+                    };
+                    readonly totalExecutionTime: {
+                        readonly type: "number";
+                        readonly description: "Total execution time in milliseconds";
+                        readonly example: 321;
+                    };
+                    readonly summary: {
+                        readonly $ref: "ResultSummary#";
+                    };
+                    readonly document: {
+                        readonly type: "object";
+                        readonly description: "Document metadata from the document store";
+                        readonly properties: {
+                            readonly documentId: {
+                                readonly type: "string";
+                                readonly description: "Document identifier";
+                            };
+                            readonly name: {
+                                readonly type: "string";
+                                readonly description: "Document name or filename";
+                                readonly example: "my-api.yaml";
+                            };
+                            readonly version: {
+                                readonly type: "string";
+                                readonly description: "version from the document";
+                                readonly example: "1.0.0";
+                            };
+                            readonly organization: {
+                                readonly type: "string";
+                                readonly description: "Organization that owns the document";
+                            };
+                            readonly format: {
+                                readonly type: "string";
+                                readonly enum: readonly ["json", "yaml"];
+                                readonly description: "Document format";
+                            };
+                            readonly operationCount: {
+                                readonly type: "integer";
+                                readonly description: "Number of operations in the document";
+                            };
+                            readonly size: {
+                                readonly type: "integer";
+                                readonly description: "Document size in bytes";
+                            };
+                        };
+                    };
+                };
+            };
+        };
+        readonly pagination: {
+            readonly type: "object";
+            readonly description: "Pagination metadata";
+            readonly properties: {
+                readonly total: {
+                    readonly type: "integer";
+                    readonly description: "Total number of jobs matching the filter criteria";
+                    readonly example: 10;
+                };
+                readonly limit: {
+                    readonly type: "integer";
+                    readonly description: "Maximum number of results returned in this page";
+                    readonly example: 50;
+                };
+                readonly offset: {
+                    readonly type: "integer";
+                    readonly description: "Number of results skipped for pagination";
+                    readonly example: 0;
+                };
+                readonly hasMore: {
+                    readonly type: "boolean";
+                    readonly description: "Whether more results are available beyond this page";
+                    readonly example: false;
+                };
+            };
+        };
+        readonly sessionId: {
+            readonly type: "string";
+            readonly description: "Runtime session ID used to filter stale jobs";
+            readonly example: "a1b2c3d4-e5f6-7890-abcd-ef1234567890";
+        };
+    };
+} | {
+    readonly $id: "CacheInvalidationResponse";
+    readonly type: "object";
+    readonly description: "Response confirming cache invalidation for a document";
+    readonly properties: {
+        readonly message: {
+            readonly type: "string";
+            readonly description: "Human-readable confirmation message";
+            readonly example: "Cache invalidated for document: abc-123";
+        };
+    };
+} | {
+    readonly $id: "RulesetSummary";
+    readonly type: "object";
+    readonly description: "Summary metadata for an available ruleset";
+    readonly properties: {
+        readonly name: {
+            readonly type: "string";
+            readonly description: "Unique ruleset identifier (kebab-case)";
+            readonly example: "pubhub";
+        };
+        readonly version: {
+            readonly type: "string";
+            readonly description: "Default version of the ruleset";
+            readonly example: "1.1.0";
+        };
+        readonly defaultVersion: {
+            readonly type: "string";
+            readonly description: "Default version used when no version is specified";
+            readonly example: "1.1.0";
+        };
+        readonly description: {
+            readonly type: "string";
+            readonly description: "Brief description of what the ruleset validates";
+            readonly example: "Validates documents for PubHub publishing readiness";
+        };
+        readonly availableVersions: {
+            readonly type: "array";
+            readonly description: "List of all available version identifiers for this ruleset";
+            readonly items: {
+                readonly type: "string";
+            };
+            readonly example: readonly ["1.0.0", "1.1.0"];
+        };
+        readonly displayName: {
+            readonly type: "string";
+            readonly description: "Human-friendly display name for the ruleset";
+            readonly example: "PubHub Publishing Readiness";
+        };
+        readonly category: {
+            readonly type: "string";
+            readonly enum: readonly ["publishing", "contract", "security", "documentation", "validation", "other"];
+            readonly description: "Classification category of the ruleset";
+            readonly example: "publishing";
+        };
+        readonly ruleCount: {
+            readonly type: "integer";
+            readonly description: "Number of rules in the default version of this ruleset";
+            readonly example: 60;
+        };
+        readonly tags: {
+            readonly type: "array";
+            readonly description: "Tags for filtering or grouping rulesets";
+            readonly items: {
+                readonly type: "string";
+            };
+            readonly example: readonly ["api-insights", "documentation"];
+        };
+    };
+} | {
+    readonly $id: "RulesetDetails";
+    readonly type: "object";
+    readonly description: "Detailed information about a ruleset including all individual rules";
+    readonly properties: {
+        readonly name: {
+            readonly type: "string";
+            readonly description: "Unique ruleset identifier (kebab-case)";
+            readonly example: "pubhub";
+        };
+        readonly displayName: {
+            readonly type: "string";
+            readonly description: "Human-friendly display name for the ruleset";
+            readonly example: "PubHub Publishing Readiness";
+        };
+        readonly version: {
+            readonly type: "string";
+            readonly description: "Version of the loaded ruleset";
+            readonly example: "1.1.0";
+        };
+        readonly description: {
+            readonly type: "string";
+            readonly description: "Brief description of what the ruleset validates";
+            readonly example: "Validates documents for PubHub publishing readiness";
+        };
+        readonly category: {
+            readonly type: "string";
+            readonly enum: readonly ["publishing", "contract", "security", "documentation", "validation", "other"];
+            readonly description: "Classification category";
+            readonly example: "publishing";
+        };
+        readonly ruleCount: {
+            readonly type: "integer";
+            readonly description: "Total number of rules in this ruleset version";
+            readonly example: 60;
+        };
+        readonly releaseDate: {
+            readonly type: "string";
+            readonly description: "Release date of this ruleset version";
+            readonly example: "2025-11-19";
+        };
+        readonly deprecated: {
+            readonly type: "boolean";
+            readonly description: "Whether this ruleset version is deprecated";
+            readonly example: false;
+        };
+        readonly tags: {
+            readonly type: "array";
+            readonly description: "Tags for filtering or grouping rulesets";
+            readonly items: {
+                readonly type: "string";
+            };
+            readonly example: readonly ["api-insights", "documentation"];
+        };
+        readonly rules: {
+            readonly type: "array";
+            readonly description: "List of all individual rules in this ruleset version";
+            readonly items: {
+                readonly $ref: "RuleInfo#";
+            };
+        };
+    };
+} | {
+    readonly $id: "StatsResponse";
+    readonly type: "object";
+    readonly description: "Combined storage and orchestrator statistics";
+    readonly properties: {
+        readonly storage: {
+            readonly type: "object";
+            readonly description: "Statistics about the lint result storage backend";
+            readonly properties: {
+                readonly totalJobs: {
+                    readonly type: "integer";
+                    readonly description: "Total number of jobs stored";
+                    readonly example: 42;
+                };
+                readonly totalResults: {
+                    readonly type: "integer";
+                    readonly description: "Total number of lint results stored";
+                    readonly example: 42;
+                };
+                readonly storageSize: {
+                    readonly type: "number";
+                    readonly description: "Approximate storage size in bytes";
+                    readonly example: 102400;
+                };
+            };
+        };
+        readonly orchestrator: {
+            readonly type: "object";
+            readonly description: "Orchestrator runtime statistics including active jobs and worker pool state";
+            readonly additionalProperties: true;
+            readonly example: {
+                readonly activeJobs: 0;
+                readonly totalJobsProcessed: 42;
+                readonly workerPoolSize: 4;
+            };
+        };
+        readonly timestamp: {
+            readonly type: "string";
+            readonly format: "date-time";
+            readonly description: "ISO 8601 timestamp when the statistics were collected";
+            readonly example: "2026-03-05T12:00:00.000Z";
+        };
+    };
+})[];
+//# sourceMappingURL=schemas.d.ts.map