export declare const configSchema: {
    readonly $schema: "http://json-schema.org/draft-07/schema#";
    readonly $ref: "#/definitions/VisorConfig";
    readonly definitions: {
        readonly VisorConfig: {
            readonly type: "object";
            readonly properties: {
                readonly version: {
                    readonly type: "string";
                    readonly description: "Configuration version";
                };
                readonly extends: {
                    readonly anyOf: readonly [{
                        readonly type: "string";
                    }, {
                        readonly type: "array";
                        readonly items: {
                            readonly type: "string";
                        };
                    }];
                    readonly description: "Extends from other configurations - can be file path, HTTP(S) URL, or \"default\"";
                };
                readonly checks: {
                    readonly $ref: "#/definitions/Record%3Cstring%2CCheckConfig%3E";
                    readonly description: "Check configurations";
                };
                readonly output: {
                    readonly $ref: "#/definitions/OutputConfig";
                    readonly description: "Output configuration";
                };
                readonly http_server: {
                    readonly $ref: "#/definitions/HttpServerConfig";
                    readonly description: "HTTP server configuration for receiving webhooks";
                };
                readonly env: {
                    readonly $ref: "#/definitions/EnvConfig";
                    readonly description: "Global environment variables";
                };
                readonly ai_model: {
                    readonly type: "string";
                    readonly description: "Global AI model setting";
                };
                readonly ai_provider: {
                    readonly type: "string";
                    readonly description: "Global AI provider setting";
                };
                readonly ai_mcp_servers: {
                    readonly $ref: "#/definitions/Record%3Cstring%2CMcpServerConfig%3E";
                    readonly description: "Global MCP servers configuration for AI checks";
                };
                readonly max_parallelism: {
                    readonly type: "number";
                    readonly description: "Maximum number of checks to run in parallel (default: 3)";
                };
                readonly fail_fast: {
                    readonly type: "boolean";
                    readonly description: "Stop execution when any check fails (default: false)";
                };
                readonly fail_if: {
                    readonly type: "string";
                    readonly description: "Simple global fail condition - fails if expression evaluates to true";
                };
                readonly failure_conditions: {
                    readonly $ref: "#/definitions/FailureConditions";
                    readonly description: "Global failure conditions - optional (deprecated, use fail_if)";
                };
                readonly tag_filter: {
                    readonly $ref: "#/definitions/TagFilter";
                    readonly description: "Tag filter for selective check execution";
                };
                readonly routing: {
                    readonly $ref: "#/definitions/RoutingDefaults";
                    readonly description: "Optional routing defaults for retry/goto/run policies";
                };
            };
            readonly required: readonly ["version", "checks", "output"];
            readonly additionalProperties: false;
            readonly description: "Main Visor configuration";
            readonly patternProperties: {
                readonly "^x-": {};
            };
        };
        readonly "Record<string,CheckConfig>": {
            readonly type: "object";
            readonly additionalProperties: {
                readonly $ref: "#/definitions/CheckConfig";
            };
        };
        readonly CheckConfig: {
            readonly type: "object";
            readonly properties: {
                readonly type: {
                    readonly $ref: "#/definitions/ConfigCheckType";
                    readonly description: "Type of check to perform (defaults to 'ai' if not specified)";
                };
                readonly prompt: {
                    readonly type: "string";
                    readonly description: "AI prompt for the check - can be inline string or file path (auto-detected) - required for AI checks";
                };
                readonly appendPrompt: {
                    readonly type: "string";
                    readonly description: "Additional prompt to append when extending configurations - merged with parent prompt";
                };
                readonly exec: {
                    readonly type: "string";
                    readonly description: "Command execution with Liquid template support - required for command checks";
                };
                readonly stdin: {
                    readonly type: "string";
                    readonly description: "Stdin input for tools with Liquid template support - optional for tool checks";
                };
                readonly url: {
                    readonly type: "string";
                    readonly description: "HTTP URL - required for http output checks";
                };
                readonly body: {
                    readonly type: "string";
                    readonly description: "HTTP body template (Liquid) - required for http output checks";
                };
                readonly method: {
                    readonly type: "string";
                    readonly description: "HTTP method (defaults to POST)";
                };
                readonly headers: {
                    readonly $ref: "#/definitions/Record%3Cstring%2Cstring%3E";
                    readonly description: "HTTP headers";
                };
                readonly endpoint: {
                    readonly type: "string";
                    readonly description: "HTTP endpoint path - required for http_input checks";
                };
                readonly transform: {
                    readonly type: "string";
                    readonly description: "Transform template for http_input data (Liquid) - optional";
                };
                readonly transform_js: {
                    readonly type: "string";
                    readonly description: "Transform using JavaScript expressions (evaluated in secure sandbox) - optional";
                };
                readonly schedule: {
                    readonly type: "string";
                    readonly description: "Cron schedule expression (e.g., \"0 2 * * *\") - optional for any check type";
                };
                readonly focus: {
                    readonly type: "string";
                    readonly description: "Focus area for the check (security/performance/style/architecture/all) - optional";
                };
                readonly command: {
                    readonly type: "string";
                    readonly description: "Command that triggers this check (e.g., \"review\", \"security-scan\") - optional";
                };
                readonly on: {
                    readonly type: "array";
                    readonly items: {
                        readonly $ref: "#/definitions/EventTrigger";
                    };
                    readonly description: "Events that trigger this check (defaults to ['manual'] if not specified)";
                };
                readonly triggers: {
                    readonly type: "array";
                    readonly items: {
                        readonly type: "string";
                    };
                    readonly description: "File patterns that trigger this check (optional)";
                };
                readonly ai: {
                    readonly $ref: "#/definitions/AIProviderConfig";
                    readonly description: "AI provider configuration (optional)";
                };
                readonly ai_model: {
                    readonly type: "string";
                    readonly description: "AI model to use for this check - overrides global setting";
                };
                readonly ai_provider: {
                    readonly type: "string";
                    readonly description: "AI provider to use for this check - overrides global setting";
                };
                readonly ai_mcp_servers: {
                    readonly $ref: "#/definitions/Record%3Cstring%2CMcpServerConfig%3E";
                    readonly description: "MCP servers for this AI check - overrides global setting";
                };
                readonly claude_code: {
                    readonly $ref: "#/definitions/ClaudeCodeConfig";
                    readonly description: "Claude Code configuration (for claude-code type checks)";
                };
                readonly env: {
                    readonly $ref: "#/definitions/EnvConfig";
                    readonly description: "Environment variables for this check";
                };
                readonly depends_on: {
                    readonly type: "array";
                    readonly items: {
                        readonly type: "string";
                    };
                    readonly description: "Check IDs that this check depends on (optional)";
                };
                readonly group: {
                    readonly type: "string";
                    readonly description: "Group name for comment separation (e.g., \"code-review\", \"pr-overview\") - optional";
                };
                readonly schema: {
                    readonly anyOf: readonly [{
                        readonly type: "string";
                    }, {
                        readonly $ref: "#/definitions/Record%3Cstring%2Cunknown%3E";
                    }];
                    readonly description: "Schema type for template rendering (e.g., \"code-review\", \"markdown\") or inline JSON schema object - optional";
                };
                readonly template: {
                    readonly $ref: "#/definitions/CustomTemplateConfig";
                    readonly description: "Custom template configuration - optional";
                };
                readonly if: {
                    readonly type: "string";
                    readonly description: "Condition to determine if check should run - runs if expression evaluates to true";
                };
                readonly reuse_ai_session: {
                    readonly type: "boolean";
                    readonly description: "Whether to reuse AI session from dependency checks (only works with depends_on)";
                };
                readonly fail_if: {
                    readonly type: "string";
                    readonly description: "Simple fail condition - fails check if expression evaluates to true";
                };
                readonly failure_conditions: {
                    readonly $ref: "#/definitions/FailureConditions";
                    readonly description: "Check-specific failure conditions - optional (deprecated, use fail_if)";
                };
                readonly tags: {
                    readonly type: "array";
                    readonly items: {
                        readonly type: "string";
                    };
                    readonly description: "Tags for categorizing and filtering checks (e.g., [\"local\", \"fast\", \"security\"])";
                };
                readonly forEach: {
                    readonly type: "boolean";
                    readonly description: "Process output as array and run dependent checks for each item";
                };
                readonly on_fail: {
                    readonly $ref: "#/definitions/OnFailConfig";
                    readonly description: "Failure routing configuration for this check (retry/goto/run)";
                };
                readonly on_success: {
                    readonly $ref: "#/definitions/OnSuccessConfig";
                    readonly description: "Success routing configuration for this check (post-actions and optional goto)";
                };
            };
            readonly additionalProperties: false;
            readonly description: "Configuration for a single check";
            readonly patternProperties: {
                readonly "^x-": {};
            };
        };
        readonly ConfigCheckType: {
            readonly type: "string";
            readonly enum: readonly ["ai", "command", "http", "http_input", "http_client", "noop", "log", "claude-code"];
            readonly description: "Valid check types in configuration";
        };
        readonly "Record<string,string>": {
            readonly type: "object";
            readonly additionalProperties: {
                readonly type: "string";
            };
        };
        readonly EventTrigger: {
            readonly type: "string";
            readonly enum: readonly ["pr_opened", "pr_updated", "pr_closed", "issue_opened", "issue_comment", "manual", "schedule", "webhook_received"];
            readonly description: "Valid event triggers for checks";
        };
        readonly AIProviderConfig: {
            readonly type: "object";
            readonly properties: {
                readonly provider: {
                    readonly type: "string";
                    readonly enum: readonly ["google", "anthropic", "openai", "bedrock", "mock"];
                    readonly description: "AI provider to use";
                };
                readonly model: {
                    readonly type: "string";
                    readonly description: "Model name to use";
                };
                readonly apiKey: {
                    readonly type: "string";
                    readonly description: "API key (usually from environment variables)";
                };
                readonly timeout: {
                    readonly type: "number";
                    readonly description: "Request timeout in milliseconds";
                };
                readonly debug: {
                    readonly type: "boolean";
                    readonly description: "Enable debug mode";
                };
                readonly mcpServers: {
                    readonly $ref: "#/definitions/Record%3Cstring%2CMcpServerConfig%3E";
                    readonly description: "MCP servers configuration";
                };
            };
            readonly additionalProperties: false;
            readonly description: "AI provider configuration";
            readonly patternProperties: {
                readonly "^x-": {};
            };
        };
        readonly "Record<string,McpServerConfig>": {
            readonly type: "object";
            readonly additionalProperties: {
                readonly $ref: "#/definitions/McpServerConfig";
            };
        };
        readonly McpServerConfig: {
            readonly type: "object";
            readonly properties: {
                readonly command: {
                    readonly type: "string";
                    readonly description: "Command to execute for the MCP server";
                };
                readonly args: {
                    readonly type: "array";
                    readonly items: {
                        readonly type: "string";
                    };
                    readonly description: "Arguments to pass to the command";
                };
                readonly env: {
                    readonly $ref: "#/definitions/Record%3Cstring%2Cstring%3E";
                    readonly description: "Environment variables for the MCP server";
                };
            };
            readonly required: readonly ["command"];
            readonly additionalProperties: false;
            readonly description: "MCP Server configuration";
            readonly patternProperties: {
                readonly "^x-": {};
            };
        };
        readonly ClaudeCodeConfig: {
            readonly type: "object";
            readonly properties: {
                readonly allowedTools: {
                    readonly type: "array";
                    readonly items: {
                        readonly type: "string";
                    };
                    readonly description: "List of allowed tools for Claude Code to use";
                };
                readonly maxTurns: {
                    readonly type: "number";
                    readonly description: "Maximum number of turns in conversation";
                };
                readonly systemPrompt: {
                    readonly type: "string";
                    readonly description: "System prompt for Claude Code";
                };
                readonly mcpServers: {
                    readonly $ref: "#/definitions/Record%3Cstring%2CMcpServerConfig%3E";
                    readonly description: "MCP servers configuration";
                };
                readonly subagent: {
                    readonly type: "string";
                    readonly description: "Path to subagent script";
                };
                readonly hooks: {
                    readonly type: "object";
                    readonly properties: {
                        readonly onStart: {
                            readonly type: "string";
                            readonly description: "Called when check starts";
                        };
                        readonly onEnd: {
                            readonly type: "string";
                            readonly description: "Called when check ends";
                        };
                        readonly onError: {
                            readonly type: "string";
                            readonly description: "Called when check encounters an error";
                        };
                    };
                    readonly additionalProperties: false;
                    readonly description: "Event hooks for lifecycle management";
                    readonly patternProperties: {
                        readonly "^x-": {};
                    };
                };
            };
            readonly additionalProperties: false;
            readonly description: "Claude Code configuration";
            readonly patternProperties: {
                readonly "^x-": {};
            };
        };
        readonly EnvConfig: {
            readonly type: "object";
            readonly additionalProperties: {
                readonly type: readonly ["string", "number", "boolean"];
            };
            readonly description: "Environment variable reference configuration";
        };
        readonly "Record<string,unknown>": {
            readonly type: "object";
            readonly additionalProperties: {};
        };
        readonly CustomTemplateConfig: {
            readonly type: "object";
            readonly properties: {
                readonly file: {
                    readonly type: "string";
                    readonly description: "Path to custom template file (relative to config file or absolute)";
                };
                readonly content: {
                    readonly type: "string";
                    readonly description: "Raw template content as string";
                };
            };
            readonly additionalProperties: false;
            readonly description: "Custom template configuration";
            readonly patternProperties: {
                readonly "^x-": {};
            };
        };
        readonly FailureConditions: {
            readonly type: "object";
            readonly additionalProperties: {
                readonly $ref: "#/definitions/FailureCondition";
            };
            readonly description: "Collection of failure conditions";
        };
        readonly FailureCondition: {
            readonly anyOf: readonly [{
                readonly $ref: "#/definitions/SimpleFailureCondition";
            }, {
                readonly $ref: "#/definitions/ComplexFailureCondition";
            }];
            readonly description: "Failure condition - can be a simple expression string or complex object";
        };
        readonly SimpleFailureCondition: {
            readonly type: "string";
            readonly description: "Simple failure condition - just an expression string";
        };
        readonly ComplexFailureCondition: {
            readonly type: "object";
            readonly properties: {
                readonly condition: {
                    readonly type: "string";
                    readonly description: "Expression to evaluate using Function Constructor";
                };
                readonly message: {
                    readonly type: "string";
                    readonly description: "Human-readable message when condition is met";
                };
                readonly severity: {
                    readonly $ref: "#/definitions/FailureConditionSeverity";
                    readonly description: "Severity level of the failure";
                };
                readonly halt_execution: {
                    readonly type: "boolean";
                    readonly description: "Whether this condition should halt execution";
                };
            };
            readonly required: readonly ["condition"];
            readonly additionalProperties: false;
            readonly description: "Complex failure condition with additional metadata";
            readonly patternProperties: {
                readonly "^x-": {};
            };
        };
        readonly FailureConditionSeverity: {
            readonly type: "string";
            readonly enum: readonly ["error", "warning", "info"];
            readonly description: "Failure condition severity levels";
        };
        readonly OnFailConfig: {
            readonly type: "object";
            readonly properties: {
                readonly retry: {
                    readonly $ref: "#/definitions/RetryPolicy";
                    readonly description: "Retry policy";
                };
                readonly run: {
                    readonly type: "array";
                    readonly items: {
                        readonly type: "string";
                    };
                    readonly description: "Remediation steps to run before reattempt";
                };
                readonly goto: {
                    readonly type: "string";
                    readonly description: "Jump back to an ancestor step (by id)";
                };
                readonly goto_js: {
                    readonly type: "string";
                    readonly description: "Dynamic goto: JS expression returning step id or null";
                };
                readonly run_js: {
                    readonly type: "string";
                    readonly description: "Dynamic remediation list: JS expression returning string[]";
                };
            };
            readonly additionalProperties: false;
            readonly description: "Failure routing configuration per check";
            readonly patternProperties: {
                readonly "^x-": {};
            };
        };
        readonly RetryPolicy: {
            readonly type: "object";
            readonly properties: {
                readonly max: {
                    readonly type: "number";
                    readonly description: "Maximum retry attempts (excluding the first attempt)";
                };
                readonly backoff: {
                    readonly $ref: "#/definitions/BackoffPolicy";
                    readonly description: "Backoff policy";
                };
            };
            readonly additionalProperties: false;
            readonly description: "Retry policy for a step";
            readonly patternProperties: {
                readonly "^x-": {};
            };
        };
        readonly BackoffPolicy: {
            readonly type: "object";
            readonly properties: {
                readonly mode: {
                    readonly type: "string";
                    readonly enum: readonly ["fixed", "exponential"];
                    readonly description: "Backoff mode";
                };
                readonly delay_ms: {
                    readonly type: "number";
                    readonly description: "Initial delay in milliseconds";
                };
            };
            readonly additionalProperties: false;
            readonly description: "Backoff policy for retries";
            readonly patternProperties: {
                readonly "^x-": {};
            };
        };
        readonly OnSuccessConfig: {
            readonly type: "object";
            readonly properties: {
                readonly run: {
                    readonly type: "array";
                    readonly items: {
                        readonly type: "string";
                    };
                    readonly description: "Post-success steps to run";
                };
                readonly goto: {
                    readonly type: "string";
                    readonly description: "Optional jump back to ancestor step (by id)";
                };
                readonly goto_js: {
                    readonly type: "string";
                    readonly description: "Dynamic goto: JS expression returning step id or null";
                };
                readonly run_js: {
                    readonly type: "string";
                    readonly description: "Dynamic post-success steps: JS expression returning string[]";
                };
            };
            readonly additionalProperties: false;
            readonly description: "Success routing configuration per check";
            readonly patternProperties: {
                readonly "^x-": {};
            };
        };
        readonly OutputConfig: {
            readonly type: "object";
            readonly properties: {
                readonly pr_comment: {
                    readonly $ref: "#/definitions/PrCommentOutput";
                    readonly description: "PR comment configuration";
                };
                readonly file_comment: {
                    readonly $ref: "#/definitions/FileCommentOutput";
                    readonly description: "File comment configuration (optional)";
                };
                readonly github_checks: {
                    readonly $ref: "#/definitions/GitHubCheckOutput";
                    readonly description: "GitHub check runs configuration (optional)";
                };
                readonly suppressionEnabled: {
                    readonly type: "boolean";
                    readonly description: "Whether to enable issue suppression via visor-disable comments (default: true)";
                };
            };
            readonly required: readonly ["pr_comment"];
            readonly additionalProperties: false;
            readonly description: "Output configuration";
            readonly patternProperties: {
                readonly "^x-": {};
            };
        };
        readonly PrCommentOutput: {
            readonly type: "object";
            readonly properties: {
                readonly format: {
                    readonly $ref: "#/definitions/ConfigOutputFormat";
                    readonly description: "Format of the output";
                };
                readonly group_by: {
                    readonly $ref: "#/definitions/GroupByOption";
                    readonly description: "How to group the results";
                };
                readonly collapse: {
                    readonly type: "boolean";
                    readonly description: "Whether to collapse sections by default";
                };
                readonly debug: {
                    readonly $ref: "#/definitions/DebugConfig";
                    readonly description: "Debug mode configuration (optional)";
                };
            };
            readonly required: readonly ["format", "group_by", "collapse"];
            readonly additionalProperties: false;
            readonly description: "PR comment output configuration";
            readonly patternProperties: {
                readonly "^x-": {};
            };
        };
        readonly ConfigOutputFormat: {
            readonly type: "string";
            readonly enum: readonly ["table", "json", "markdown", "sarif"];
            readonly description: "Valid output formats";
        };
        readonly GroupByOption: {
            readonly type: "string";
            readonly enum: readonly ["check", "file", "severity"];
            readonly description: "Valid grouping options";
        };
        readonly DebugConfig: {
            readonly type: "object";
            readonly properties: {
                readonly enabled: {
                    readonly type: "boolean";
                    readonly description: "Enable debug mode";
                };
                readonly includePrompts: {
                    readonly type: "boolean";
                    readonly description: "Include AI prompts in debug output";
                };
                readonly includeRawResponses: {
                    readonly type: "boolean";
                    readonly description: "Include raw AI responses in debug output";
                };
                readonly includeTiming: {
                    readonly type: "boolean";
                    readonly description: "Include timing information";
                };
                readonly includeProviderInfo: {
                    readonly type: "boolean";
                    readonly description: "Include provider information";
                };
            };
            readonly required: readonly ["enabled", "includePrompts", "includeRawResponses", "includeTiming", "includeProviderInfo"];
            readonly additionalProperties: false;
            readonly description: "Debug mode configuration";
            readonly patternProperties: {
                readonly "^x-": {};
            };
        };
        readonly FileCommentOutput: {
            readonly type: "object";
            readonly properties: {
                readonly enabled: {
                    readonly type: "boolean";
                    readonly description: "Whether file comments are enabled";
                };
                readonly inline: {
                    readonly type: "boolean";
                    readonly description: "Whether to show inline comments";
                };
            };
            readonly required: readonly ["enabled", "inline"];
            readonly additionalProperties: false;
            readonly description: "File comment output configuration";
            readonly patternProperties: {
                readonly "^x-": {};
            };
        };
        readonly GitHubCheckOutput: {
            readonly type: "object";
            readonly properties: {
                readonly enabled: {
                    readonly type: "boolean";
                    readonly description: "Whether GitHub check runs are enabled";
                };
                readonly per_check: {
                    readonly type: "boolean";
                    readonly description: "Whether to create individual check runs per configured check";
                };
                readonly name_prefix: {
                    readonly type: "string";
                    readonly description: "Custom name prefix for check runs";
                };
            };
            readonly required: readonly ["enabled", "per_check"];
            readonly additionalProperties: false;
            readonly description: "GitHub Check Runs output configuration";
            readonly patternProperties: {
                readonly "^x-": {};
            };
        };
        readonly HttpServerConfig: {
            readonly type: "object";
            readonly properties: {
                readonly enabled: {
                    readonly type: "boolean";
                    readonly description: "Whether HTTP server is enabled";
                };
                readonly port: {
                    readonly type: "number";
                    readonly description: "Port to listen on";
                };
                readonly host: {
                    readonly type: "string";
                    readonly description: "Host/IP to bind to (defaults to 0.0.0.0)";
                };
                readonly tls: {
                    readonly $ref: "#/definitions/TlsConfig";
                    readonly description: "TLS/SSL configuration for HTTPS";
                };
                readonly auth: {
                    readonly $ref: "#/definitions/HttpAuthConfig";
                    readonly description: "Authentication configuration";
                };
                readonly endpoints: {
                    readonly type: "array";
                    readonly items: {
                        readonly $ref: "#/definitions/HttpEndpointConfig";
                    };
                    readonly description: "HTTP endpoints configuration";
                };
            };
            readonly required: readonly ["enabled", "port"];
            readonly additionalProperties: false;
            readonly description: "HTTP server configuration for receiving webhooks";
            readonly patternProperties: {
                readonly "^x-": {};
            };
        };
        readonly TlsConfig: {
            readonly type: "object";
            readonly properties: {
                readonly enabled: {
                    readonly type: "boolean";
                    readonly description: "Enable TLS/HTTPS";
                };
                readonly cert: {
                    readonly type: "string";
                    readonly description: "Path to TLS certificate file or certificate content";
                };
                readonly key: {
                    readonly type: "string";
                    readonly description: "Path to TLS key file or key content";
                };
                readonly ca: {
                    readonly type: "string";
                    readonly description: "Path to CA certificate file or CA content (optional)";
                };
                readonly rejectUnauthorized: {
                    readonly type: "boolean";
                    readonly description: "Reject unauthorized connections (default: true)";
                };
            };
            readonly required: readonly ["enabled"];
            readonly additionalProperties: false;
            readonly description: "TLS/SSL configuration for HTTPS server";
            readonly patternProperties: {
                readonly "^x-": {};
            };
        };
        readonly HttpAuthConfig: {
            readonly type: "object";
            readonly properties: {
                readonly type: {
                    readonly type: "string";
                    readonly enum: readonly ["bearer_token", "hmac", "basic", "none"];
                    readonly description: "Authentication type";
                };
                readonly secret: {
                    readonly type: "string";
                    readonly description: "Secret or token for authentication";
                };
                readonly username: {
                    readonly type: "string";
                    readonly description: "Username for basic auth";
                };
                readonly password: {
                    readonly type: "string";
                    readonly description: "Password for basic auth";
                };
            };
            readonly required: readonly ["type"];
            readonly additionalProperties: false;
            readonly description: "HTTP server authentication configuration";
            readonly patternProperties: {
                readonly "^x-": {};
            };
        };
        readonly HttpEndpointConfig: {
            readonly type: "object";
            readonly properties: {
                readonly path: {
                    readonly type: "string";
                    readonly description: "Path for the webhook endpoint";
                };
                readonly transform: {
                    readonly type: "string";
                    readonly description: "Optional transform template (Liquid) for the received data";
                };
                readonly name: {
                    readonly type: "string";
                    readonly description: "Optional name/ID for this endpoint";
                };
            };
            readonly required: readonly ["path"];
            readonly additionalProperties: false;
            readonly description: "HTTP server endpoint configuration";
            readonly patternProperties: {
                readonly "^x-": {};
            };
        };
        readonly TagFilter: {
            readonly type: "object";
            readonly properties: {
                readonly include: {
                    readonly type: "array";
                    readonly items: {
                        readonly type: "string";
                    };
                    readonly description: "Tags that checks must have to be included (ANY match)";
                };
                readonly exclude: {
                    readonly type: "array";
                    readonly items: {
                        readonly type: "string";
                    };
                    readonly description: "Tags that will exclude checks if present (ANY match)";
                };
            };
            readonly additionalProperties: false;
            readonly description: "Tag filter configuration for selective check execution";
            readonly patternProperties: {
                readonly "^x-": {};
            };
        };
        readonly RoutingDefaults: {
            readonly type: "object";
            readonly properties: {
                readonly max_loops: {
                    readonly type: "number";
                    readonly description: "Per-scope cap on routing transitions (success + failure)";
                };
                readonly defaults: {
                    readonly type: "object";
                    readonly properties: {
                        readonly on_fail: {
                            readonly $ref: "#/definitions/OnFailConfig";
                        };
                    };
                    readonly additionalProperties: false;
                    readonly description: "Default policies applied to checks (step-level overrides take precedence)";
                    readonly patternProperties: {
                        readonly "^x-": {};
                    };
                };
            };
            readonly additionalProperties: false;
            readonly description: "Global routing defaults";
            readonly patternProperties: {
                readonly "^x-": {};
            };
        };
    };
};
export default configSchema;
//# sourceMappingURL=config-schema.d.ts.map