/**
 * Orchestrator tool registry. Each entry is a `DefinedTool` — call
 * `.toAiTool()` to get an AI-SDK-compatible tool object, or `.run()` for
 * direct unit-test invocation.
 *
 * Phase 1 covers the canonical tool patterns:
 *   - HTTP / sitemap I/O          (fetch_page, fetch_sitemap)
 *   - Page parsing                (parse_page)
 *   - Template clustering         (detect_templates, sample_template)
 *   - Per-page rule checks        (check_rule_*)
 *   - Cluster-aware rule checks   (check_rule_near_duplicate, check_rule_schema_consistency)
 *   - Multi-page AEO rule checks  (check_rule_faq_coverage, _citable_facts, etc.)
 *   - Domain-level checks         (check_domain_llms_txt, check_domain_crawler_access)
 *
 * Future phases extend this map with the remaining rule wrappers (links/*,
 * tech/redirect-chain, tech/soft-404, etc. — most useful as part of
 * `check_all_rules` once that escape hatch lands), schema/text validators,
 * and external probes (SerpAPI, ask_ai_engine).
 */
export { defineTool } from "./types.js";
export type { DefinedTool, ToolDefinition, ToolOk, ToolErr, ToolResult } from "./types.js";
export { fetchPageTool } from "./fetch-page.js";
export { fetchSitemapTool } from "./fetch-sitemap.js";
export { parsePageTool } from "./parse-page.js";
export { detectTemplatesTool } from "./detect-templates.js";
export { sampleTemplateTool } from "./sample-template.js";
export { checkRuleThinContentTool } from "./check-rule-thin-content.js";
export { checkRuleMissingAuthorTool } from "./check-rule-missing-author.js";
export { checkRuleCanonicalConsistencyTool } from "./check-rule-canonical-consistency.js";
export { checkRuleJsonLdValidTool } from "./check-rule-json-ld-valid.js";
export { checkRuleAnswerFirstTool } from "./check-rule-answer-first.js";
export { checkRuleNearDuplicateTool } from "./check-rule-near-duplicate.js";
export { checkRuleFaqCoverageTool } from "./check-rule-faq-coverage.js";
export { checkRuleCitableFactsTool } from "./check-rule-citable-facts.js";
export { checkRuleFreshnessSignalsTool } from "./check-rule-freshness-signals.js";
export { checkRuleContentModularityTool } from "./check-rule-content-modularity.js";
export { checkRuleSummaryBaitTool } from "./check-rule-summary-bait.js";
export { checkRuleRequiredFieldsTool } from "./check-rule-required-fields.js";
export { checkRuleSchemaConsistencyTool } from "./check-rule-schema-consistency.js";
export { checkDomainLlmsTxtTool } from "./check-domain-llms-txt.js";
export { checkDomainCrawlerAccessTool } from "./check-domain-crawler-access.js";
export { checkRobotsTool } from "./check-robots.js";
export { checkIndexabilityTool } from "./check-indexability.js";
export { validateJsonLdTool } from "./validate-jsonld.js";
export { querySerpTool } from "./query-serp.js";
export { askAiEngineTool } from "./ask-ai-engine.js";
/**
 * The full orchestrator tool registry, keyed by tool name.
 *
 * To convert into AI-SDK input shape:
 *   const aiTools = Object.fromEntries(
 *     Object.entries(orchestratorTools).map(([k, t]) => [k, t.toAiTool()])
 *   );
 *   streamText({ tools: aiTools, ... });
 */
export declare const orchestratorTools: {
    readonly fetch_page: {
        name: string;
        description: string;
        inputSchema: import("zod").ZodType<{
            url: string;
            timeoutMs?: number | undefined;
            cacheDir?: string | undefined;
            cacheTtlMs?: number | undefined;
        }, unknown, import("zod/v4/core").$ZodTypeInternals<{
            url: string;
            timeoutMs?: number | undefined;
            cacheDir?: string | undefined;
            cacheTtlMs?: number | undefined;
        }, unknown>>;
        outputSchema: import("zod").ZodType<{
            url: string;
            status: number;
            headers: Record<string, string>;
            pageId: string;
            bodyExcerpt: string;
            fromCache: boolean;
            bodyBytes: number;
        }, unknown, import("zod/v4/core").$ZodTypeInternals<{
            url: string;
            status: number;
            headers: Record<string, string>;
            pageId: string;
            bodyExcerpt: string;
            fromCache: boolean;
            bodyBytes: number;
        }, unknown>>;
        toAiTool(): import("ai").Tool<{
            url: string;
            timeoutMs?: number | undefined;
            cacheDir?: string | undefined;
            cacheTtlMs?: number | undefined;
        }, import("./types.js").ToolResult<{
            url: string;
            status: number;
            headers: Record<string, string>;
            pageId: string;
            bodyExcerpt: string;
            fromCache: boolean;
            bodyBytes: number;
        }>>;
        run(input: {
            url: string;
            timeoutMs?: number | undefined;
            cacheDir?: string | undefined;
            cacheTtlMs?: number | undefined;
        }, ctx?: import("./types.js").ToolExecuteContext): Promise<import("./types.js").ToolResult<{
            url: string;
            status: number;
            headers: Record<string, string>;
            pageId: string;
            bodyExcerpt: string;
            fromCache: boolean;
            bodyBytes: number;
        }>>;
    };
    readonly fetch_sitemap: {
        name: string;
        description: string;
        inputSchema: import("zod").ZodType<{
            sitemapUrl: string;
            maxUrls?: number | undefined;
            maxDepth?: number | undefined;
            timeoutMs?: number | undefined;
        }, unknown, import("zod/v4/core").$ZodTypeInternals<{
            sitemapUrl: string;
            maxUrls?: number | undefined;
            maxDepth?: number | undefined;
            timeoutMs?: number | undefined;
        }, unknown>>;
        outputSchema: import("zod").ZodType<{
            rootUrl: string;
            urlCount: number;
            urls: string[];
            truncated: boolean;
            childSitemaps: string[];
        }, unknown, import("zod/v4/core").$ZodTypeInternals<{
            rootUrl: string;
            urlCount: number;
            urls: string[];
            truncated: boolean;
            childSitemaps: string[];
        }, unknown>>;
        toAiTool(): import("ai").Tool<{
            sitemapUrl: string;
            maxUrls?: number | undefined;
            maxDepth?: number | undefined;
            timeoutMs?: number | undefined;
        }, import("./types.js").ToolResult<{
            rootUrl: string;
            urlCount: number;
            urls: string[];
            truncated: boolean;
            childSitemaps: string[];
        }>>;
        run(input: {
            sitemapUrl: string;
            maxUrls?: number | undefined;
            maxDepth?: number | undefined;
            timeoutMs?: number | undefined;
        }, ctx?: import("./types.js").ToolExecuteContext): Promise<import("./types.js").ToolResult<{
            rootUrl: string;
            urlCount: number;
            urls: string[];
            truncated: boolean;
            childSitemaps: string[];
        }>>;
    };
    readonly parse_page: {
        name: string;
        description: string;
        inputSchema: import("zod").ZodType<{
            pageId: string;
        }, unknown, import("zod/v4/core").$ZodTypeInternals<{
            pageId: string;
        }, unknown>>;
        outputSchema: import("zod").ZodType<{
            url: string;
            title: string;
            metaDescription: string;
            canonical: string;
            robotsMeta: string;
            headings: {
                h1: string[];
                h2: string[];
            };
            contentWordCount: number;
            jsonLdBlockCount: number;
            jsonLdTypes: string[];
            outboundLinkCount: number;
            internalLinkCount: number;
            hasAuthorSignal: boolean;
            hasFaqBlock: boolean;
        }, unknown, import("zod/v4/core").$ZodTypeInternals<{
            url: string;
            title: string;
            metaDescription: string;
            canonical: string;
            robotsMeta: string;
            headings: {
                h1: string[];
                h2: string[];
            };
            contentWordCount: number;
            jsonLdBlockCount: number;
            jsonLdTypes: string[];
            outboundLinkCount: number;
            internalLinkCount: number;
            hasAuthorSignal: boolean;
            hasFaqBlock: boolean;
        }, unknown>>;
        toAiTool(): import("ai").Tool<{
            pageId: string;
        }, import("./types.js").ToolResult<{
            url: string;
            title: string;
            metaDescription: string;
            canonical: string;
            robotsMeta: string;
            headings: {
                h1: string[];
                h2: string[];
            };
            contentWordCount: number;
            jsonLdBlockCount: number;
            jsonLdTypes: string[];
            outboundLinkCount: number;
            internalLinkCount: number;
            hasAuthorSignal: boolean;
            hasFaqBlock: boolean;
        }>>;
        run(input: {
            pageId: string;
        }, ctx?: import("./types.js").ToolExecuteContext): Promise<import("./types.js").ToolResult<{
            url: string;
            title: string;
            metaDescription: string;
            canonical: string;
            robotsMeta: string;
            headings: {
                h1: string[];
                h2: string[];
            };
            contentWordCount: number;
            jsonLdBlockCount: number;
            jsonLdTypes: string[];
            outboundLinkCount: number;
            internalLinkCount: number;
            hasAuthorSignal: boolean;
            hasFaqBlock: boolean;
        }>>;
    };
    readonly detect_templates: {
        name: string;
        description: string;
        inputSchema: import("zod").ZodType<{
            urls: string[];
            minRatio?: number | undefined;
        }, unknown, import("zod/v4/core").$ZodTypeInternals<{
            urls: string[];
            minRatio?: number | undefined;
        }, unknown>>;
        outputSchema: import("zod").ZodType<{
            templateCount: number;
            totalUrls: number;
            templates: {
                template: string;
                count: number;
                ratio: number;
            }[];
        }, unknown, import("zod/v4/core").$ZodTypeInternals<{
            templateCount: number;
            totalUrls: number;
            templates: {
                template: string;
                count: number;
                ratio: number;
            }[];
        }, unknown>>;
        toAiTool(): import("ai").Tool<{
            urls: string[];
            minRatio?: number | undefined;
        }, import("./types.js").ToolResult<{
            templateCount: number;
            totalUrls: number;
            templates: {
                template: string;
                count: number;
                ratio: number;
            }[];
        }>>;
        run(input: {
            urls: string[];
            minRatio?: number | undefined;
        }, ctx?: import("./types.js").ToolExecuteContext): Promise<import("./types.js").ToolResult<{
            templateCount: number;
            totalUrls: number;
            templates: {
                template: string;
                count: number;
                ratio: number;
            }[];
        }>>;
    };
    readonly sample_template: {
        name: string;
        description: string;
        inputSchema: import("zod").ZodType<{
            urls: string[];
            n: number;
            template?: string | undefined;
        }, unknown, import("zod/v4/core").$ZodTypeInternals<{
            urls: string[];
            n: number;
            template?: string | undefined;
        }, unknown>>;
        outputSchema: import("zod").ZodType<{
            sample: string[];
            sampledFrom: number;
            template: null;
        } | {
            sample: string[];
            sampledFrom: number;
            template: string;
        }, unknown, import("zod/v4/core").$ZodTypeInternals<{
            sample: string[];
            sampledFrom: number;
            template: null;
        } | {
            sample: string[];
            sampledFrom: number;
            template: string;
        }, unknown>>;
        toAiTool(): import("ai").Tool<{
            urls: string[];
            n: number;
            template?: string | undefined;
        }, import("./types.js").ToolResult<{
            sample: string[];
            sampledFrom: number;
            template: null;
        } | {
            sample: string[];
            sampledFrom: number;
            template: string;
        }>>;
        run(input: {
            urls: string[];
            n: number;
            template?: string | undefined;
        }, ctx?: import("./types.js").ToolExecuteContext): Promise<import("./types.js").ToolResult<{
            sample: string[];
            sampledFrom: number;
            template: null;
        } | {
            sample: string[];
            sampledFrom: number;
            template: string;
        }>>;
    };
    readonly check_rule_thin_content: {
        name: string;
        description: string;
        inputSchema: import("zod").ZodType<{
            pageId: string;
            minWords?: number | undefined;
        }, unknown, import("zod/v4/core").$ZodTypeInternals<{
            pageId: string;
            minWords?: number | undefined;
        }, unknown>>;
        outputSchema: import("zod").ZodType<{
            isThin: boolean;
            wordCount: number;
            threshold: number;
            finding: {
                ruleId: "spam/thin-content";
                severity: "error";
                confidence: "high" | "medium" | "low" | "speculative";
                message: string;
                fix?: string | undefined;
            } | null;
        }, unknown, import("zod/v4/core").$ZodTypeInternals<{
            isThin: boolean;
            wordCount: number;
            threshold: number;
            finding: {
                ruleId: "spam/thin-content";
                severity: "error";
                confidence: "high" | "medium" | "low" | "speculative";
                message: string;
                fix?: string | undefined;
            } | null;
        }, unknown>>;
        toAiTool(): import("ai").Tool<{
            pageId: string;
            minWords?: number | undefined;
        }, import("./types.js").ToolResult<{
            isThin: boolean;
            wordCount: number;
            threshold: number;
            finding: {
                ruleId: "spam/thin-content";
                severity: "error";
                confidence: "high" | "medium" | "low" | "speculative";
                message: string;
                fix?: string | undefined;
            } | null;
        }>>;
        run(input: {
            pageId: string;
            minWords?: number | undefined;
        }, ctx?: import("./types.js").ToolExecuteContext): Promise<import("./types.js").ToolResult<{
            isThin: boolean;
            wordCount: number;
            threshold: number;
            finding: {
                ruleId: "spam/thin-content";
                severity: "error";
                confidence: "high" | "medium" | "low" | "speculative";
                message: string;
                fix?: string | undefined;
            } | null;
        }>>;
    };
    readonly check_rule_missing_author: {
        name: string;
        description: string;
        inputSchema: import("zod").ZodType<{
            pageId: string;
        }, unknown, import("zod/v4/core").$ZodTypeInternals<{
            pageId: string;
        }, unknown>>;
        outputSchema: import("zod").ZodType<{
            hasAuthorSignal: boolean;
            finding: {
                ruleId: "content/missing-author";
                severity: "warning";
                confidence: "high" | "medium" | "low" | "speculative";
                message: string;
                fix?: string | undefined;
            } | null;
        }, unknown, import("zod/v4/core").$ZodTypeInternals<{
            hasAuthorSignal: boolean;
            finding: {
                ruleId: "content/missing-author";
                severity: "warning";
                confidence: "high" | "medium" | "low" | "speculative";
                message: string;
                fix?: string | undefined;
            } | null;
        }, unknown>>;
        toAiTool(): import("ai").Tool<{
            pageId: string;
        }, import("./types.js").ToolResult<{
            hasAuthorSignal: boolean;
            finding: {
                ruleId: "content/missing-author";
                severity: "warning";
                confidence: "high" | "medium" | "low" | "speculative";
                message: string;
                fix?: string | undefined;
            } | null;
        }>>;
        run(input: {
            pageId: string;
        }, ctx?: import("./types.js").ToolExecuteContext): Promise<import("./types.js").ToolResult<{
            hasAuthorSignal: boolean;
            finding: {
                ruleId: "content/missing-author";
                severity: "warning";
                confidence: "high" | "medium" | "low" | "speculative";
                message: string;
                fix?: string | undefined;
            } | null;
        }>>;
    };
    readonly check_rule_canonical_consistency: {
        name: string;
        description: string;
        inputSchema: import("zod").ZodType<{
            pageId: string;
            knownUrls?: string[] | undefined;
        }, unknown, import("zod/v4/core").$ZodTypeInternals<{
            pageId: string;
            knownUrls?: string[] | undefined;
        }, unknown>>;
        outputSchema: import("zod").ZodType<{
            hasCanonical: boolean;
            canonicalUrl: string | null;
            selfReferencing: boolean;
            findings: {
                ruleId: "tech/canonical-consistency";
                severity: "error" | "info" | "warning" | "critical";
                message: string;
                fix?: string | undefined;
                relatedUrls?: string[] | undefined;
            }[];
        }, unknown, import("zod/v4/core").$ZodTypeInternals<{
            hasCanonical: boolean;
            canonicalUrl: string | null;
            selfReferencing: boolean;
            findings: {
                ruleId: "tech/canonical-consistency";
                severity: "error" | "info" | "warning" | "critical";
                message: string;
                fix?: string | undefined;
                relatedUrls?: string[] | undefined;
            }[];
        }, unknown>>;
        toAiTool(): import("ai").Tool<{
            pageId: string;
            knownUrls?: string[] | undefined;
        }, import("./types.js").ToolResult<{
            hasCanonical: boolean;
            canonicalUrl: string | null;
            selfReferencing: boolean;
            findings: {
                ruleId: "tech/canonical-consistency";
                severity: "error" | "info" | "warning" | "critical";
                message: string;
                fix?: string | undefined;
                relatedUrls?: string[] | undefined;
            }[];
        }>>;
        run(input: {
            pageId: string;
            knownUrls?: string[] | undefined;
        }, ctx?: import("./types.js").ToolExecuteContext): Promise<import("./types.js").ToolResult<{
            hasCanonical: boolean;
            canonicalUrl: string | null;
            selfReferencing: boolean;
            findings: {
                ruleId: "tech/canonical-consistency";
                severity: "error" | "info" | "warning" | "critical";
                message: string;
                fix?: string | undefined;
                relatedUrls?: string[] | undefined;
            }[];
        }>>;
    };
    readonly check_rule_json_ld_valid: {
        name: string;
        description: string;
        inputSchema: import("zod").ZodType<{
            pageId: string;
        }, unknown, import("zod/v4/core").$ZodTypeInternals<{
            pageId: string;
        }, unknown>>;
        outputSchema: import("zod").ZodType<{
            jsonLdBlockCount: number;
            hasParseError: boolean;
            findings: {
                ruleId: "schema/json-ld-valid";
                severity: "error";
                message: string;
                fix?: string | undefined;
            }[];
        }, unknown, import("zod/v4/core").$ZodTypeInternals<{
            jsonLdBlockCount: number;
            hasParseError: boolean;
            findings: {
                ruleId: "schema/json-ld-valid";
                severity: "error";
                message: string;
                fix?: string | undefined;
            }[];
        }, unknown>>;
        toAiTool(): import("ai").Tool<{
            pageId: string;
        }, import("./types.js").ToolResult<{
            jsonLdBlockCount: number;
            hasParseError: boolean;
            findings: {
                ruleId: "schema/json-ld-valid";
                severity: "error";
                message: string;
                fix?: string | undefined;
            }[];
        }>>;
        run(input: {
            pageId: string;
        }, ctx?: import("./types.js").ToolExecuteContext): Promise<import("./types.js").ToolResult<{
            jsonLdBlockCount: number;
            hasParseError: boolean;
            findings: {
                ruleId: "schema/json-ld-valid";
                severity: "error";
                message: string;
                fix?: string | undefined;
            }[];
        }>>;
    };
    readonly check_rule_answer_first: {
        name: string;
        description: string;
        inputSchema: import("zod").ZodType<{
            pageId: string;
            maxFirstParagraphWords?: number | undefined;
        }, unknown, import("zod/v4/core").$ZodTypeInternals<{
            pageId: string;
            maxFirstParagraphWords?: number | undefined;
        }, unknown>>;
        outputSchema: import("zod").ZodType<{
            finding: {
                ruleId: "aeo/answer-first";
                severity: "error" | "warning";
                confidence: "high" | "medium" | "low" | "speculative";
                message: string;
                fix?: string | undefined;
            } | null;
        }, unknown, import("zod/v4/core").$ZodTypeInternals<{
            finding: {
                ruleId: "aeo/answer-first";
                severity: "error" | "warning";
                confidence: "high" | "medium" | "low" | "speculative";
                message: string;
                fix?: string | undefined;
            } | null;
        }, unknown>>;
        toAiTool(): import("ai").Tool<{
            pageId: string;
            maxFirstParagraphWords?: number | undefined;
        }, import("./types.js").ToolResult<{
            finding: {
                ruleId: "aeo/answer-first";
                severity: "error" | "warning";
                confidence: "high" | "medium" | "low" | "speculative";
                message: string;
                fix?: string | undefined;
            } | null;
        }>>;
        run(input: {
            pageId: string;
            maxFirstParagraphWords?: number | undefined;
        }, ctx?: import("./types.js").ToolExecuteContext): Promise<import("./types.js").ToolResult<{
            finding: {
                ruleId: "aeo/answer-first";
                severity: "error" | "warning";
                confidence: "high" | "medium" | "low" | "speculative";
                message: string;
                fix?: string | undefined;
            } | null;
        }>>;
    };
    readonly check_rule_near_duplicate: {
        name: string;
        description: string;
        inputSchema: import("zod").ZodType<{
            pageIds: string[];
            threshold?: number | undefined;
        }, unknown, import("zod/v4/core").$ZodTypeInternals<{
            pageIds: string[];
            threshold?: number | undefined;
        }, unknown>>;
        outputSchema: import("zod").ZodType<{
            pairCount: number;
            pairs: {
                leftUrl: string;
                rightUrl: string;
                similarity: number;
            }[];
            findings: {
                ruleId: "spam/near-duplicate";
                severity: "critical";
                message: string;
                pageUrl: string;
                similarity: number;
                relatedUrls?: string[] | undefined;
            }[];
        }, unknown, import("zod/v4/core").$ZodTypeInternals<{
            pairCount: number;
            pairs: {
                leftUrl: string;
                rightUrl: string;
                similarity: number;
            }[];
            findings: {
                ruleId: "spam/near-duplicate";
                severity: "critical";
                message: string;
                pageUrl: string;
                similarity: number;
                relatedUrls?: string[] | undefined;
            }[];
        }, unknown>>;
        toAiTool(): import("ai").Tool<{
            pageIds: string[];
            threshold?: number | undefined;
        }, import("./types.js").ToolResult<{
            pairCount: number;
            pairs: {
                leftUrl: string;
                rightUrl: string;
                similarity: number;
            }[];
            findings: {
                ruleId: "spam/near-duplicate";
                severity: "critical";
                message: string;
                pageUrl: string;
                similarity: number;
                relatedUrls?: string[] | undefined;
            }[];
        }>>;
        run(input: {
            pageIds: string[];
            threshold?: number | undefined;
        }, ctx?: import("./types.js").ToolExecuteContext): Promise<import("./types.js").ToolResult<{
            pairCount: number;
            pairs: {
                leftUrl: string;
                rightUrl: string;
                similarity: number;
            }[];
            findings: {
                ruleId: "spam/near-duplicate";
                severity: "critical";
                message: string;
                pageUrl: string;
                similarity: number;
                relatedUrls?: string[] | undefined;
            }[];
        }>>;
    };
    readonly check_rule_faq_coverage: {
        name: string;
        description: string;
        inputSchema: import("zod").ZodType<{
            pageIds: string[];
            minQuestionHeadings?: number | undefined;
        }, unknown, import("zod/v4/core").$ZodTypeInternals<{
            pageIds: string[];
            minQuestionHeadings?: number | undefined;
        }, unknown>>;
        outputSchema: import("zod").ZodType<{
            findings: {
                ruleId: "aeo/faq-coverage";
                severity: "error" | "info" | "warning" | "critical";
                message: string;
                pageUrl?: string | undefined;
                fix?: string | undefined;
            }[];
        }, unknown, import("zod/v4/core").$ZodTypeInternals<{
            findings: {
                ruleId: "aeo/faq-coverage";
                severity: "error" | "info" | "warning" | "critical";
                message: string;
                pageUrl?: string | undefined;
                fix?: string | undefined;
            }[];
        }, unknown>>;
        toAiTool(): import("ai").Tool<{
            pageIds: string[];
            minQuestionHeadings?: number | undefined;
        }, import("./types.js").ToolResult<{
            findings: {
                ruleId: "aeo/faq-coverage";
                severity: "error" | "info" | "warning" | "critical";
                message: string;
                pageUrl?: string | undefined;
                fix?: string | undefined;
            }[];
        }>>;
        run(input: {
            pageIds: string[];
            minQuestionHeadings?: number | undefined;
        }, ctx?: import("./types.js").ToolExecuteContext): Promise<import("./types.js").ToolResult<{
            findings: {
                ruleId: "aeo/faq-coverage";
                severity: "error" | "info" | "warning" | "critical";
                message: string;
                pageUrl?: string | undefined;
                fix?: string | undefined;
            }[];
        }>>;
    };
    readonly check_rule_citable_facts: {
        name: string;
        description: string;
        inputSchema: import("zod").ZodType<{
            pageIds: string[];
            minFactsPerPage?: number | undefined;
        }, unknown, import("zod/v4/core").$ZodTypeInternals<{
            pageIds: string[];
            minFactsPerPage?: number | undefined;
        }, unknown>>;
        outputSchema: import("zod").ZodType<{
            findings: {
                ruleId: "aeo/citable-facts";
                severity: "error" | "info" | "warning" | "critical";
                message: string;
                confidence?: "high" | "medium" | "low" | "speculative" | undefined;
                pageUrl?: string | undefined;
                fix?: string | undefined;
            }[];
        }, unknown, import("zod/v4/core").$ZodTypeInternals<{
            findings: {
                ruleId: "aeo/citable-facts";
                severity: "error" | "info" | "warning" | "critical";
                message: string;
                confidence?: "high" | "medium" | "low" | "speculative" | undefined;
                pageUrl?: string | undefined;
                fix?: string | undefined;
            }[];
        }, unknown>>;
        toAiTool(): import("ai").Tool<{
            pageIds: string[];
            minFactsPerPage?: number | undefined;
        }, import("./types.js").ToolResult<{
            findings: {
                ruleId: "aeo/citable-facts";
                severity: "error" | "info" | "warning" | "critical";
                message: string;
                confidence?: "high" | "medium" | "low" | "speculative" | undefined;
                pageUrl?: string | undefined;
                fix?: string | undefined;
            }[];
        }>>;
        run(input: {
            pageIds: string[];
            minFactsPerPage?: number | undefined;
        }, ctx?: import("./types.js").ToolExecuteContext): Promise<import("./types.js").ToolResult<{
            findings: {
                ruleId: "aeo/citable-facts";
                severity: "error" | "info" | "warning" | "critical";
                message: string;
                confidence?: "high" | "medium" | "low" | "speculative" | undefined;
                pageUrl?: string | undefined;
                fix?: string | undefined;
            }[];
        }>>;
    };
    readonly check_rule_freshness_signals: {
        name: string;
        description: string;
        inputSchema: import("zod").ZodType<{
            pageIds: string[];
            maxStaleDays?: number | undefined;
        }, unknown, import("zod/v4/core").$ZodTypeInternals<{
            pageIds: string[];
            maxStaleDays?: number | undefined;
        }, unknown>>;
        outputSchema: import("zod").ZodType<{
            findings: {
                ruleId: "aeo/freshness-signals";
                severity: "error" | "info" | "warning" | "critical";
                message: string;
                pageUrl?: string | undefined;
                fix?: string | undefined;
            }[];
        }, unknown, import("zod/v4/core").$ZodTypeInternals<{
            findings: {
                ruleId: "aeo/freshness-signals";
                severity: "error" | "info" | "warning" | "critical";
                message: string;
                pageUrl?: string | undefined;
                fix?: string | undefined;
            }[];
        }, unknown>>;
        toAiTool(): import("ai").Tool<{
            pageIds: string[];
            maxStaleDays?: number | undefined;
        }, import("./types.js").ToolResult<{
            findings: {
                ruleId: "aeo/freshness-signals";
                severity: "error" | "info" | "warning" | "critical";
                message: string;
                pageUrl?: string | undefined;
                fix?: string | undefined;
            }[];
        }>>;
        run(input: {
            pageIds: string[];
            maxStaleDays?: number | undefined;
        }, ctx?: import("./types.js").ToolExecuteContext): Promise<import("./types.js").ToolResult<{
            findings: {
                ruleId: "aeo/freshness-signals";
                severity: "error" | "info" | "warning" | "critical";
                message: string;
                pageUrl?: string | undefined;
                fix?: string | undefined;
            }[];
        }>>;
    };
    readonly check_rule_content_modularity: {
        name: string;
        description: string;
        inputSchema: import("zod").ZodType<{
            pageIds: string[];
            maxParagraphWords?: number | undefined;
            minSelfContainedRatio?: number | undefined;
        }, unknown, import("zod/v4/core").$ZodTypeInternals<{
            pageIds: string[];
            maxParagraphWords?: number | undefined;
            minSelfContainedRatio?: number | undefined;
        }, unknown>>;
        outputSchema: import("zod").ZodType<{
            findings: {
                ruleId: "aeo/content-modularity";
                severity: "error" | "info" | "warning" | "critical";
                message: string;
                pageUrl?: string | undefined;
                fix?: string | undefined;
            }[];
        }, unknown, import("zod/v4/core").$ZodTypeInternals<{
            findings: {
                ruleId: "aeo/content-modularity";
                severity: "error" | "info" | "warning" | "critical";
                message: string;
                pageUrl?: string | undefined;
                fix?: string | undefined;
            }[];
        }, unknown>>;
        toAiTool(): import("ai").Tool<{
            pageIds: string[];
            maxParagraphWords?: number | undefined;
            minSelfContainedRatio?: number | undefined;
        }, import("./types.js").ToolResult<{
            findings: {
                ruleId: "aeo/content-modularity";
                severity: "error" | "info" | "warning" | "critical";
                message: string;
                pageUrl?: string | undefined;
                fix?: string | undefined;
            }[];
        }>>;
        run(input: {
            pageIds: string[];
            maxParagraphWords?: number | undefined;
            minSelfContainedRatio?: number | undefined;
        }, ctx?: import("./types.js").ToolExecuteContext): Promise<import("./types.js").ToolResult<{
            findings: {
                ruleId: "aeo/content-modularity";
                severity: "error" | "info" | "warning" | "critical";
                message: string;
                pageUrl?: string | undefined;
                fix?: string | undefined;
            }[];
        }>>;
    };
    readonly check_rule_summary_bait: {
        name: string;
        description: string;
        inputSchema: import("zod").ZodType<{
            pageIds: string[];
            openerWordCount?: number | undefined;
        }, unknown, import("zod/v4/core").$ZodTypeInternals<{
            pageIds: string[];
            openerWordCount?: number | undefined;
        }, unknown>>;
        outputSchema: import("zod").ZodType<{
            findings: {
                ruleId: "aeo/summary-bait";
                severity: "error" | "info" | "warning" | "critical";
                message: string;
                pageUrl?: string | undefined;
                fix?: string | undefined;
            }[];
        }, unknown, import("zod/v4/core").$ZodTypeInternals<{
            findings: {
                ruleId: "aeo/summary-bait";
                severity: "error" | "info" | "warning" | "critical";
                message: string;
                pageUrl?: string | undefined;
                fix?: string | undefined;
            }[];
        }, unknown>>;
        toAiTool(): import("ai").Tool<{
            pageIds: string[];
            openerWordCount?: number | undefined;
        }, import("./types.js").ToolResult<{
            findings: {
                ruleId: "aeo/summary-bait";
                severity: "error" | "info" | "warning" | "critical";
                message: string;
                pageUrl?: string | undefined;
                fix?: string | undefined;
            }[];
        }>>;
        run(input: {
            pageIds: string[];
            openerWordCount?: number | undefined;
        }, ctx?: import("./types.js").ToolExecuteContext): Promise<import("./types.js").ToolResult<{
            findings: {
                ruleId: "aeo/summary-bait";
                severity: "error" | "info" | "warning" | "critical";
                message: string;
                pageUrl?: string | undefined;
                fix?: string | undefined;
            }[];
        }>>;
    };
    readonly check_rule_required_fields: {
        name: string;
        description: string;
        inputSchema: import("zod").ZodType<{
            pageIds: string[];
        }, unknown, import("zod/v4/core").$ZodTypeInternals<{
            pageIds: string[];
        }, unknown>>;
        outputSchema: import("zod").ZodType<{
            findings: {
                ruleId: "schema/required-fields";
                severity: "error" | "info" | "warning" | "critical";
                message: string;
                pageUrl?: string | undefined;
                fix?: string | undefined;
            }[];
        }, unknown, import("zod/v4/core").$ZodTypeInternals<{
            findings: {
                ruleId: "schema/required-fields";
                severity: "error" | "info" | "warning" | "critical";
                message: string;
                pageUrl?: string | undefined;
                fix?: string | undefined;
            }[];
        }, unknown>>;
        toAiTool(): import("ai").Tool<{
            pageIds: string[];
        }, import("./types.js").ToolResult<{
            findings: {
                ruleId: "schema/required-fields";
                severity: "error" | "info" | "warning" | "critical";
                message: string;
                pageUrl?: string | undefined;
                fix?: string | undefined;
            }[];
        }>>;
        run(input: {
            pageIds: string[];
        }, ctx?: import("./types.js").ToolExecuteContext): Promise<import("./types.js").ToolResult<{
            findings: {
                ruleId: "schema/required-fields";
                severity: "error" | "info" | "warning" | "critical";
                message: string;
                pageUrl?: string | undefined;
                fix?: string | undefined;
            }[];
        }>>;
    };
    readonly check_rule_schema_consistency: {
        name: string;
        description: string;
        inputSchema: import("zod").ZodType<{
            pageIds: string[];
        }, unknown, import("zod/v4/core").$ZodTypeInternals<{
            pageIds: string[];
        }, unknown>>;
        outputSchema: import("zod").ZodType<{
            findings: {
                ruleId: "schema/consistency";
                severity: "error" | "info" | "warning" | "critical";
                message: string;
                pageUrl?: string | undefined;
                relatedUrls?: string[] | undefined;
                fix?: string | undefined;
            }[];
        }, unknown, import("zod/v4/core").$ZodTypeInternals<{
            findings: {
                ruleId: "schema/consistency";
                severity: "error" | "info" | "warning" | "critical";
                message: string;
                pageUrl?: string | undefined;
                relatedUrls?: string[] | undefined;
                fix?: string | undefined;
            }[];
        }, unknown>>;
        toAiTool(): import("ai").Tool<{
            pageIds: string[];
        }, import("./types.js").ToolResult<{
            findings: {
                ruleId: "schema/consistency";
                severity: "error" | "info" | "warning" | "critical";
                message: string;
                pageUrl?: string | undefined;
                relatedUrls?: string[] | undefined;
                fix?: string | undefined;
            }[];
        }>>;
        run(input: {
            pageIds: string[];
        }, ctx?: import("./types.js").ToolExecuteContext): Promise<import("./types.js").ToolResult<{
            findings: {
                ruleId: "schema/consistency";
                severity: "error" | "info" | "warning" | "critical";
                message: string;
                pageUrl?: string | undefined;
                relatedUrls?: string[] | undefined;
                fix?: string | undefined;
            }[];
        }>>;
    };
    readonly check_domain_llms_txt: {
        name: string;
        description: string;
        inputSchema: import("zod").ZodType<{
            origin: string;
            timeoutMs?: number | undefined;
        }, unknown, import("zod/v4/core").$ZodTypeInternals<{
            origin: string;
            timeoutMs?: number | undefined;
        }, unknown>>;
        outputSchema: import("zod").ZodType<{
            origin: string;
            llmsTxtUrl: string;
            found: boolean;
            findings: {
                ruleId: "aeo/llms-txt";
                severity: "error" | "info" | "warning" | "critical";
                message: string;
                fix?: string | undefined;
            }[];
        }, unknown, import("zod/v4/core").$ZodTypeInternals<{
            origin: string;
            llmsTxtUrl: string;
            found: boolean;
            findings: {
                ruleId: "aeo/llms-txt";
                severity: "error" | "info" | "warning" | "critical";
                message: string;
                fix?: string | undefined;
            }[];
        }, unknown>>;
        toAiTool(): import("ai").Tool<{
            origin: string;
            timeoutMs?: number | undefined;
        }, import("./types.js").ToolResult<{
            origin: string;
            llmsTxtUrl: string;
            found: boolean;
            findings: {
                ruleId: "aeo/llms-txt";
                severity: "error" | "info" | "warning" | "critical";
                message: string;
                fix?: string | undefined;
            }[];
        }>>;
        run(input: {
            origin: string;
            timeoutMs?: number | undefined;
        }, ctx?: import("./types.js").ToolExecuteContext): Promise<import("./types.js").ToolResult<{
            origin: string;
            llmsTxtUrl: string;
            found: boolean;
            findings: {
                ruleId: "aeo/llms-txt";
                severity: "error" | "info" | "warning" | "critical";
                message: string;
                fix?: string | undefined;
            }[];
        }>>;
    };
    readonly check_domain_crawler_access: {
        name: string;
        description: string;
        inputSchema: import("zod").ZodType<{
            origin: string;
            timeoutMs?: number | undefined;
        }, unknown, import("zod/v4/core").$ZodTypeInternals<{
            origin: string;
            timeoutMs?: number | undefined;
        }, unknown>>;
        outputSchema: import("zod").ZodType<{
            origin: string;
            robotsTxtUrl: string;
            robotsTxtPresent: boolean;
            findings: {
                ruleId: "aeo/crawler-access";
                severity: "error" | "info" | "warning" | "critical";
                message: string;
                fix?: string | undefined;
            }[];
        }, unknown, import("zod/v4/core").$ZodTypeInternals<{
            origin: string;
            robotsTxtUrl: string;
            robotsTxtPresent: boolean;
            findings: {
                ruleId: "aeo/crawler-access";
                severity: "error" | "info" | "warning" | "critical";
                message: string;
                fix?: string | undefined;
            }[];
        }, unknown>>;
        toAiTool(): import("ai").Tool<{
            origin: string;
            timeoutMs?: number | undefined;
        }, import("./types.js").ToolResult<{
            origin: string;
            robotsTxtUrl: string;
            robotsTxtPresent: boolean;
            findings: {
                ruleId: "aeo/crawler-access";
                severity: "error" | "info" | "warning" | "critical";
                message: string;
                fix?: string | undefined;
            }[];
        }>>;
        run(input: {
            origin: string;
            timeoutMs?: number | undefined;
        }, ctx?: import("./types.js").ToolExecuteContext): Promise<import("./types.js").ToolResult<{
            origin: string;
            robotsTxtUrl: string;
            robotsTxtPresent: boolean;
            findings: {
                ruleId: "aeo/crawler-access";
                severity: "error" | "info" | "warning" | "critical";
                message: string;
                fix?: string | undefined;
            }[];
        }>>;
    };
    readonly check_robots: {
        name: string;
        description: string;
        inputSchema: import("zod").ZodType<{
            origin: string;
            testUrl?: string | undefined;
            userAgent?: string | undefined;
            timeoutMs?: number | undefined;
        }, unknown, import("zod/v4/core").$ZodTypeInternals<{
            origin: string;
            testUrl?: string | undefined;
            userAgent?: string | undefined;
            timeoutMs?: number | undefined;
        }, unknown>>;
        outputSchema: import("zod").ZodType<{
            origin: string;
            robotsTxtUrl: string;
            robotsTxtPresent: boolean;
            disallowPatterns: string[];
            crawlDelaySeconds: number;
            hasSitemapDirective: boolean;
            testUrlBlocked: boolean | null;
        }, unknown, import("zod/v4/core").$ZodTypeInternals<{
            origin: string;
            robotsTxtUrl: string;
            robotsTxtPresent: boolean;
            disallowPatterns: string[];
            crawlDelaySeconds: number;
            hasSitemapDirective: boolean;
            testUrlBlocked: boolean | null;
        }, unknown>>;
        toAiTool(): import("ai").Tool<{
            origin: string;
            testUrl?: string | undefined;
            userAgent?: string | undefined;
            timeoutMs?: number | undefined;
        }, import("./types.js").ToolResult<{
            origin: string;
            robotsTxtUrl: string;
            robotsTxtPresent: boolean;
            disallowPatterns: string[];
            crawlDelaySeconds: number;
            hasSitemapDirective: boolean;
            testUrlBlocked: boolean | null;
        }>>;
        run(input: {
            origin: string;
            testUrl?: string | undefined;
            userAgent?: string | undefined;
            timeoutMs?: number | undefined;
        }, ctx?: import("./types.js").ToolExecuteContext): Promise<import("./types.js").ToolResult<{
            origin: string;
            robotsTxtUrl: string;
            robotsTxtPresent: boolean;
            disallowPatterns: string[];
            crawlDelaySeconds: number;
            hasSitemapDirective: boolean;
            testUrlBlocked: boolean | null;
        }>>;
    };
    readonly check_indexability: {
        name: string;
        description: string;
        inputSchema: import("zod").ZodType<{
            pageId: string;
            xRobotsTagHeader?: string | undefined;
        }, unknown, import("zod/v4/core").$ZodTypeInternals<{
            pageId: string;
            xRobotsTagHeader?: string | undefined;
        }, unknown>>;
        outputSchema: import("zod").ZodType<{
            url: string;
            indexable: boolean;
            reasons: string[];
            metaRobots: string;
            metaNoindex: boolean;
            xRobotsNoindex: boolean;
            canonicalUrl: string;
            canonicalSelfReferencing: boolean;
        }, unknown, import("zod/v4/core").$ZodTypeInternals<{
            url: string;
            indexable: boolean;
            reasons: string[];
            metaRobots: string;
            metaNoindex: boolean;
            xRobotsNoindex: boolean;
            canonicalUrl: string;
            canonicalSelfReferencing: boolean;
        }, unknown>>;
        toAiTool(): import("ai").Tool<{
            pageId: string;
            xRobotsTagHeader?: string | undefined;
        }, import("./types.js").ToolResult<{
            url: string;
            indexable: boolean;
            reasons: string[];
            metaRobots: string;
            metaNoindex: boolean;
            xRobotsNoindex: boolean;
            canonicalUrl: string;
            canonicalSelfReferencing: boolean;
        }>>;
        run(input: {
            pageId: string;
            xRobotsTagHeader?: string | undefined;
        }, ctx?: import("./types.js").ToolExecuteContext): Promise<import("./types.js").ToolResult<{
            url: string;
            indexable: boolean;
            reasons: string[];
            metaRobots: string;
            metaNoindex: boolean;
            xRobotsNoindex: boolean;
            canonicalUrl: string;
            canonicalSelfReferencing: boolean;
        }>>;
    };
    readonly validate_jsonld: {
        name: string;
        description: string;
        inputSchema: import("zod").ZodType<{
            pageId: string;
        }, unknown, import("zod/v4/core").$ZodTypeInternals<{
            pageId: string;
        }, unknown>>;
        outputSchema: import("zod").ZodType<{
            url: string;
            blocks: {
                index: number;
                types: string[];
                hasContext: boolean;
                missingRequired: string[];
                ok: boolean;
            }[];
            totalBlocks: number;
            okBlocks: number;
        }, unknown, import("zod/v4/core").$ZodTypeInternals<{
            url: string;
            blocks: {
                index: number;
                types: string[];
                hasContext: boolean;
                missingRequired: string[];
                ok: boolean;
            }[];
            totalBlocks: number;
            okBlocks: number;
        }, unknown>>;
        toAiTool(): import("ai").Tool<{
            pageId: string;
        }, import("./types.js").ToolResult<{
            url: string;
            blocks: {
                index: number;
                types: string[];
                hasContext: boolean;
                missingRequired: string[];
                ok: boolean;
            }[];
            totalBlocks: number;
            okBlocks: number;
        }>>;
        run(input: {
            pageId: string;
        }, ctx?: import("./types.js").ToolExecuteContext): Promise<import("./types.js").ToolResult<{
            url: string;
            blocks: {
                index: number;
                types: string[];
                hasContext: boolean;
                missingRequired: string[];
                ok: boolean;
            }[];
            totalBlocks: number;
            okBlocks: number;
        }>>;
    };
    readonly query_serp: {
        name: string;
        description: string;
        inputSchema: import("zod").ZodType<{
            keyword: string;
            locale?: string | undefined;
            language?: string | undefined;
            num?: number | undefined;
            apiKey?: string | undefined;
            cacheDir?: string | undefined;
        }, unknown, import("zod/v4/core").$ZodTypeInternals<{
            keyword: string;
            locale?: string | undefined;
            language?: string | undefined;
            num?: number | undefined;
            apiKey?: string | undefined;
            cacheDir?: string | undefined;
        }, unknown>>;
        outputSchema: import("zod").ZodType<{
            keyword: string;
            locale: string;
            language: string;
            resultCount: number;
            organicResults: {
                position: number;
                title: string;
                url: string;
                snippet: string | null;
                source: string | null;
            }[];
            hasAnswerBox: boolean;
            hasKnowledgeGraph: boolean;
            fromCache: boolean;
            apiCostUsd: number;
        }, unknown, import("zod/v4/core").$ZodTypeInternals<{
            keyword: string;
            locale: string;
            language: string;
            resultCount: number;
            organicResults: {
                position: number;
                title: string;
                url: string;
                snippet: string | null;
                source: string | null;
            }[];
            hasAnswerBox: boolean;
            hasKnowledgeGraph: boolean;
            fromCache: boolean;
            apiCostUsd: number;
        }, unknown>>;
        toAiTool(): import("ai").Tool<{
            keyword: string;
            locale?: string | undefined;
            language?: string | undefined;
            num?: number | undefined;
            apiKey?: string | undefined;
            cacheDir?: string | undefined;
        }, import("./types.js").ToolResult<{
            keyword: string;
            locale: string;
            language: string;
            resultCount: number;
            organicResults: {
                position: number;
                title: string;
                url: string;
                snippet: string | null;
                source: string | null;
            }[];
            hasAnswerBox: boolean;
            hasKnowledgeGraph: boolean;
            fromCache: boolean;
            apiCostUsd: number;
        }>>;
        run(input: {
            keyword: string;
            locale?: string | undefined;
            language?: string | undefined;
            num?: number | undefined;
            apiKey?: string | undefined;
            cacheDir?: string | undefined;
        }, ctx?: import("./types.js").ToolExecuteContext): Promise<import("./types.js").ToolResult<{
            keyword: string;
            locale: string;
            language: string;
            resultCount: number;
            organicResults: {
                position: number;
                title: string;
                url: string;
                snippet: string | null;
                source: string | null;
            }[];
            hasAnswerBox: boolean;
            hasKnowledgeGraph: boolean;
            fromCache: boolean;
            apiCostUsd: number;
        }>>;
    };
    readonly ask_ai_engine: {
        name: string;
        description: string;
        inputSchema: import("zod").ZodType<{
            engine: "anthropic" | "perplexity" | "gemini";
            query: string;
            candidateUrl?: string | undefined;
            apiKey?: string | undefined;
            cacheDir?: string | undefined;
        }, unknown, import("zod/v4/core").$ZodTypeInternals<{
            engine: "anthropic" | "perplexity" | "gemini";
            query: string;
            candidateUrl?: string | undefined;
            apiKey?: string | undefined;
            cacheDir?: string | undefined;
        }, unknown>>;
        outputSchema: import("zod").ZodType<{
            engine: "anthropic" | "perplexity" | "gemini";
            query: string;
            answer: string;
            citedUrls: string[];
            candidateCited: boolean | null;
            fromCache: boolean;
            apiCostUsd: number;
        }, unknown, import("zod/v4/core").$ZodTypeInternals<{
            engine: "anthropic" | "perplexity" | "gemini";
            query: string;
            answer: string;
            citedUrls: string[];
            candidateCited: boolean | null;
            fromCache: boolean;
            apiCostUsd: number;
        }, unknown>>;
        toAiTool(): import("ai").Tool<{
            engine: "anthropic" | "perplexity" | "gemini";
            query: string;
            candidateUrl?: string | undefined;
            apiKey?: string | undefined;
            cacheDir?: string | undefined;
        }, import("./types.js").ToolResult<{
            engine: "anthropic" | "perplexity" | "gemini";
            query: string;
            answer: string;
            citedUrls: string[];
            candidateCited: boolean | null;
            fromCache: boolean;
            apiCostUsd: number;
        }>>;
        run(input: {
            engine: "anthropic" | "perplexity" | "gemini";
            query: string;
            candidateUrl?: string | undefined;
            apiKey?: string | undefined;
            cacheDir?: string | undefined;
        }, ctx?: import("./types.js").ToolExecuteContext): Promise<import("./types.js").ToolResult<{
            engine: "anthropic" | "perplexity" | "gemini";
            query: string;
            answer: string;
            citedUrls: string[];
            candidateCited: boolean | null;
            fromCache: boolean;
            apiCostUsd: number;
        }>>;
    };
};
export type OrchestratorToolName = keyof typeof orchestratorTools;
//# sourceMappingURL=index.d.ts.map