@farming-labs/docs 0.2.74 → 0.2.77

package/dist/agent-DRKj42ht.d.mts

@@ -0,0 +1,938 @@
+import { Bn as LlmsTxtMaxCharsConfig, Cn as DocsSearchSourcePage, En as DocsSitemapConfig, Fn as FeedbackConfig, G as DocsAgentFeedbackData, Hn as LlmsTxtSectionConfig, Mt as DocsI18nConfig, Rt as DocsMcpConfig, Vn as LlmsTxtMaxCharsMode, an as DocsRobotsConfig, fn as DocsSearchConfig, kt as DocsConfig, nr as PageAgentFrontmatter, ur as ResolvedDocsRelatedLink, zn as LlmsTxtConfig } from "./types-B-5Kzmkn.mjs";
+import { O as DocsA2AAgentCardOptions, R as DocsDiscoveryApiRouteOptions, z as DocsPublishedAgentSkill } from "./standards-discovery-BbslY4id.mjs";
+import { DocsMcpPage, DocsMcpResolvedConfig } from "./mcp.mjs";
+
+//#region src/i18n.d.ts
+interface ResolvedDocsI18n {
+  locales: string[];
+  defaultLocale: string;
+}
+interface DocsPathMatch {
+  /** Slug path relative to the docs root (no leading slash). */
+  slug: string;
+  /** Entry path used for URLs (no locale segment). */
+  entryPath: string;
+}
+declare function resolveDocsI18n(config?: DocsI18nConfig | null): ResolvedDocsI18n | null;
+declare function resolveDocsLocale(searchParams: URLSearchParams, i18n?: ResolvedDocsI18n | null): string | undefined;
+declare function resolveDocsPath(pathname: string, entry: string): DocsPathMatch;
+//#endregion
+//#region src/mcp-auth.d.ts
+declare const DEFAULT_MCP_ROUTE = "/api/docs/mcp";
+declare const DEFAULT_MCP_PUBLIC_ROUTE = "/mcp";
+declare const DEFAULT_MCP_WELL_KNOWN_ROUTE = "/.well-known/mcp";
+declare const DEFAULT_MCP_PROTECTED_RESOURCE_METADATA_ROUTE = "/.well-known/oauth-protected-resource";
+declare function getDocsMcpResourcePaths(route?: string): string[];
+declare function buildDocsMcpProtectedResourceMetadataRoute(resourcePath: string): string;
+declare function getDocsMcpProtectedResourceMetadataRoutes(route?: string): string[];
+declare function hasDocsMcpProtectedResourceConfig(mcp?: boolean | DocsMcpConfig): boolean;
+declare function isDocsMcpRequest(url: URL, mcp?: boolean | DocsMcpConfig): boolean;
+//#endregion
+//#region src/audience.d.ts
+/** The two content projections emitted by the docs framework. */
+type DocsContentAudience = "human" | "agent";
+/** Resolve whether content with an optional audience restriction is visible. */
+declare function resolveDocsAudienceExposure(only: unknown, audience: DocsContentAudience): boolean;
+interface DocsMarkdownPromptBlock {
+  /** Raw JSX attributes between the Prompt name and opening bracket. */
+  attributes: string;
+  /** Literal source between the Prompt tags, with enclosing Markdown container prefixes removed. */
+  children: string;
+  /** Collision-safe placeholder carried through document-level rendering. */
+  token: string;
+}
+interface ExtractedDocsMarkdownPromptBlocks {
+  blocks: DocsMarkdownPromptBlock[];
+  markdown: string;
+}
+interface DocsAudienceMdxIssue {
+  code: "missing-only" | "invalid-only" | "dynamic-only" | "ignored-agent-only" | "ignored-human-only";
+  index: number;
+  message: string;
+}
+/**
+ * Extract live MDX Prompt blocks while leaving Markdown literals untouched.
+ *
+ * Prompt bodies are copyable source, so callers can safely run audience,
+ * reference-definition, and heading passes over `markdown`, then restore each
+ * block from its token. Fences (including container fences), inline code, links,
+ * comments, raw elements, and other literal contexts are never extracted.
+ */
+declare function extractDocsMarkdownPromptBlocks(content: string): ExtractedDocsMarkdownPromptBlocks;
+/** Find audience declarations that cannot be projected consistently at build time. */
+declare function findDocsAudienceMdxIssues(content: string): DocsAudienceMdxIssue[];
+/**
+ * Resolve MDX into its human or agent projection.
+ *
+ * `<Agent>` is shorthand for `<Audience only="agent">`, while `<Human>` is
+ * shorthand for `<Audience only="human">`. Unknown `Audience.only` values are
+ * treated as shared content so an authoring typo never silently deletes content.
+ * These primitives shape content for each surface; they are not an access-control boundary.
+ */
+declare function resolveDocsAudienceMdxContent(content: string, audience: DocsContentAudience): string;
+/** Backwards-compatible name retained for existing integrations. */
+declare function resolveDocsAgentMdxContent(content: string, audience: DocsContentAudience): string;
+//#endregion
+//#region src/agent.d.ts
+declare const DEFAULT_DOCS_API_ROUTE = "/api/docs";
+declare const DEFAULT_DOCS_CONFIG_FORMAT = "docs-config-map.v1";
+declare const DEFAULT_DOCS_CONFIG_ROUTE = "/api/docs?format=config";
+declare const DEFAULT_DOCS_DIAGNOSTICS_FORMAT = "docs-diagnostics.v1";
+declare const DEFAULT_DOCS_DIAGNOSTICS_ROUTE = "/api/docs?format=diagnostics";
+declare const DEFAULT_OPENAPI_SCHEMA_ROUTE = "/api/docs?format=openapi";
+declare const DEFAULT_AGENT_SPEC_ROUTE = "/api/docs/agent/spec";
+declare const DEFAULT_AGENT_SPEC_WELL_KNOWN_ROUTE = "/.well-known/agent";
+declare const DEFAULT_AGENT_SPEC_WELL_KNOWN_JSON_ROUTE = "/.well-known/agent.json";
+declare const DEFAULT_LLMS_TXT_ROUTE = "/llms.txt";
+declare const DEFAULT_LLMS_FULL_TXT_ROUTE = "/llms-full.txt";
+declare const DEFAULT_LLMS_TXT_WELL_KNOWN_ROUTE = "/.well-known/llms.txt";
+declare const DEFAULT_LLMS_FULL_TXT_WELL_KNOWN_ROUTE = "/.well-known/llms-full.txt";
+declare const DEFAULT_LLMS_TXT_MAX_CHARS = 50000;
+declare const DEFAULT_SKILL_MD_ROUTE = "/skill.md";
+declare const DEFAULT_SKILL_MD_WELL_KNOWN_ROUTE = "/.well-known/skill.md";
+declare const DEFAULT_AGENTS_MD_ROUTE = "/AGENTS.md";
+declare const DEFAULT_AGENTS_MD_WELL_KNOWN_ROUTE = "/.well-known/AGENTS.md";
+declare const DEFAULT_AGENT_MD_ROUTE = "/AGENT.md";
+declare const DEFAULT_AGENT_MD_WELL_KNOWN_ROUTE = "/.well-known/AGENT.md";
+declare const DEFAULT_AGENT_FEEDBACK_ROUTE = "/api/docs/agent/feedback";
+declare const DEFAULT_AGENT_FEEDBACK_PAYLOAD_SCHEMA: Record<string, unknown>;
+declare const DOCS_MARKDOWN_SIGNATURE_AGENT_HEADER = "Signature-Agent";
+declare const DOCS_MARKDOWN_SECTION_INDEX_FORMAT = "docs-markdown-sections.v2";
+declare const DOCS_AI_AGENT_USER_AGENT_HEADER_PATTERN: string;
+declare const DOCS_TRADITIONAL_BOT_USER_AGENT_HEADER_PATTERN: string;
+declare const DOCS_BOT_LIKE_USER_AGENT_HEADER_PATTERN: string;
+interface DocsMcpEndpointCandidate {
+  baseUrl: string;
+  route: string;
+  url: string;
+  label: string;
+}
+interface DocsMcpEndpointCandidateOptions {
+  includeOriginFallback?: boolean;
+  includeRootDomainFallback?: boolean;
+  includeMcpSubdomainFallback?: boolean;
+}
+interface DocsAgentFeedbackResolvedConfig {
+  enabled: boolean;
+  route: string;
+  schemaRoute: string;
+  payloadSchema: Record<string, unknown>;
+  schema: Record<string, unknown>;
+  onFeedback?: (data: DocsAgentFeedbackData) => void | Promise<void>;
+}
+interface DocsAgentFeedbackRequest {
+  kind: "schema" | "submit";
+}
+interface DocsAgentFeedbackDiscoveryConfig {
+  enabled?: boolean;
+  route?: string;
+  schemaRoute?: string;
+}
+interface DocsLlmsDiscoveryConfig extends DocsDiscoveryApiRouteOptions {
+  enabled?: boolean;
+  /** Whether this deployment actually serves the RFC 9727 API catalog. Defaults to true. */
+  apiCatalog?: boolean;
+  baseUrl?: string;
+  siteTitle?: string;
+  siteDescription?: string;
+  maxChars?: LlmsTxtMaxCharsConfig;
+  sections?: LlmsTxtSectionConfig[];
+  openapi?: boolean | DocsOpenApiDiscoveryConfig;
+}
+interface DocsOpenApiDiscoveryConfig {
+  enabled?: boolean;
+  url?: string;
+  /** Whether `url` came from the framework default or explicit configuration. */
+  urlSource?: "default" | "configured";
+  source?: "generated" | "configured";
+  specUrl?: string;
+  apiReferencePath?: string;
+  /** Product API targets described by this OpenAPI document. */
+  catalogTargets?: readonly string[];
+}
+interface DocsOpenApiResolvedDiscoveryConfig {
+  enabled: boolean;
+  url?: string;
+  /** Whether `url` came from the framework default or explicit configuration. */
+  urlSource?: "default" | "configured";
+  source?: "generated" | "configured";
+  specUrl?: string;
+  apiReferencePath?: string;
+  /** Product API targets described by this OpenAPI document. */
+  catalogTargets?: readonly string[];
+}
+type DocsConfigMapJsonPrimitive = string | number | boolean | null;
+type DocsConfigMapJsonValue = DocsConfigMapJsonPrimitive | DocsConfigMapJsonValue[] | {
+  [key: string]: DocsConfigMapJsonValue;
+};
+interface DocsConfigMapPointer {
+  /** Dot-path form for humans and TypeScript users, e.g. `mcp.tools.readPage`. */
+  path: string;
+  /** Coarse value kind at this pointer. */
+  kind: string;
+}
+interface DocsConfigMap {
+  schemaVersion: 1;
+  format: typeof DEFAULT_DOCS_CONFIG_FORMAT;
+  source: {
+    /** Best-effort source label; adapters only receive the runtime config object. */file: string; /** Best-effort language hint based on serializing the runtime config object. */
+    language: "ts" | "tsx";
+  };
+  serialization: {
+    mode: "json-safe";
+    redacted: string;
+    nonSerializable: "described";
+  };
+  values: {
+    [key: string]: DocsConfigMapJsonValue;
+  };
+  /** RFC 6901 JSON Pointer index for mapping response values back to docs.config paths. */
+  pointers: Record<string, DocsConfigMapPointer>;
+}
+type DocsDiagnosticsStatus = "enabled" | "disabled";
+type DocsDiagnosticsIssueSeverity = "warning" | "error";
+interface DocsDiagnosticsIssue {
+  severity: DocsDiagnosticsIssueSeverity;
+  code: string;
+  path?: string;
+  message: string;
+}
+interface DocsDiagnosticsFeature {
+  status: DocsDiagnosticsStatus;
+  reason?: string;
+  route?: string | null;
+  routes?: Record<string, string | null>;
+  agentEndpoint?: string | null;
+  structuredAgentEndpoint?: string | null;
+  audienceParam?: string;
+  defaultAudience?: "human" | "agent";
+  supportedAudiences?: Array<"human" | "agent">;
+  filterParams?: {
+    framework: "framework";
+    version: "version";
+    package: "package";
+    tags: "tags";
+  };
+  responseFormat?: "docs-search.v1";
+  warningsField?: "warnings";
+  /** Opaque continuation token accepted by structured search. */
+  cursorParam?: "cursor";
+  /** Optional continuation token returned when another result page is available. */
+  nextCursorField?: "nextCursor";
+  /** Boolean structured-response field indicating whether another page is available. */
+  hasMoreField?: "hasMore";
+  /** Structured-response field containing the total matches across all pages. */
+  totalField?: "total";
+  provider?: string;
+  mode?: string;
+  transport?: "GET" | "POST" | "GET/HEAD" | "GET/POST";
+  tools?: Record<string, boolean>;
+  human?: boolean;
+  agent?: boolean;
+}
+interface DocsDiagnostics {
+  schemaVersion: 1;
+  format: typeof DEFAULT_DOCS_DIAGNOSTICS_FORMAT;
+  ok: boolean;
+  adapter: string | null;
+  routes: {
+    docs: string;
+    api: string;
+    config: string;
+    diagnostics: string;
+    agentSpec: string;
+    apiCatalog: string | null;
+    agentSkillsIndex: string;
+    agentSkillsArtifact: string;
+    agents: string;
+    skill: string;
+    search: string | null;
+    agentSearch: string | null;
+    askAi: string | null;
+    mcp: string | null;
+    llmsTxt: string | null;
+    llmsFullTxt: string | null;
+    sitemapXml: string | null;
+    sitemapMarkdown: string | null;
+    robots: string | null;
+    openapi: string | null;
+    apiReference: string | null;
+  };
+  features: {
+    staticExport: DocsDiagnosticsFeature;
+    config: DocsDiagnosticsFeature;
+    diagnostics: DocsDiagnosticsFeature;
+    apiCatalog: DocsDiagnosticsFeature;
+    search: DocsDiagnosticsFeature;
+    ai: DocsDiagnosticsFeature;
+    mcp: DocsDiagnosticsFeature;
+    feedback: DocsDiagnosticsFeature;
+    llmsTxt: DocsDiagnosticsFeature;
+    sitemap: DocsDiagnosticsFeature;
+    robots: DocsDiagnosticsFeature;
+    apiReference: DocsDiagnosticsFeature;
+    agents: DocsDiagnosticsFeature;
+    skills: DocsDiagnosticsFeature;
+    locales: DocsDiagnosticsFeature;
+  };
+  warnings: DocsDiagnosticsIssue[];
+  errors: DocsDiagnosticsIssue[];
+}
+interface DocsDiagnosticsOptions extends DocsDiscoveryApiRouteOptions {
+  adapter?: string;
+  /** Effective RFC 9727 catalog availability after runtime overrides are applied. */
+  apiCatalog?: boolean;
+  entry?: string;
+  i18n?: ResolvedDocsI18n | null;
+  mcp?: DocsMcpResolvedConfig;
+  feedback?: DocsAgentFeedbackDiscoveryConfig;
+  openapi?: boolean | DocsOpenApiDiscoveryConfig;
+}
+interface DocsLlmsTxtResolvedMaxChars {
+  mode: LlmsTxtMaxCharsMode;
+  chars: number;
+}
+interface DocsLlmsTxtResolvedSection {
+  title: string;
+  description?: string;
+  match: string[];
+  route: string;
+  fullRoute: string;
+  maxChars: DocsLlmsTxtResolvedMaxChars;
+}
+interface DocsLlmsTxtRequest {
+  format: "llms" | "llms-full";
+  section?: DocsLlmsTxtResolvedSection;
+}
+interface DocsLlmsTxtPageInput {
+  url: string;
+  /** Override the Markdown link emitted in llms.txt. */
+  markdownUrl?: string;
+  title: string;
+  description?: string;
+  content: string;
+  rawContent?: string;
+  agentContent?: string;
+  agentRawContent?: string;
+  agentFallbackContent?: string;
+  agentFallbackRawContent?: string;
+}
+interface DocsLlmsTxtGeneratedSection extends DocsLlmsTxtResolvedSection {
+  llmsTxt: string;
+  llmsFullTxt: string;
+}
+interface DocsLlmsTxtGeneratedContent {
+  llmsTxt: string;
+  llmsFullTxt: string;
+  maxChars: DocsLlmsTxtResolvedMaxChars;
+  sections: DocsLlmsTxtGeneratedSection[];
+}
+interface DocsLlmsTxtSelectedContent {
+  content: string;
+  label: string;
+  maxChars: DocsLlmsTxtResolvedMaxChars;
+}
+interface DocsLlmsTxtMaxCharsIssue {
+  mode: Exclude<LlmsTxtMaxCharsMode, "off">;
+  chars: number;
+  actual: number;
+  label: string;
+  message: string;
+}
+interface DocsAgentDiscoverySpecOptions extends DocsDiscoveryApiRouteOptions {
+  origin: string;
+  entry?: string;
+  /** Public rendered docs path when it differs from `entry`. */
+  docsPath?: string;
+  /** Whether this deployment actually serves the RFC 9727 API catalog. Defaults to true. */
+  apiCatalog?: boolean;
+  i18n?: ResolvedDocsI18n | null;
+  search?: boolean | DocsSearchConfig;
+  mcp: DocsMcpResolvedConfig;
+  feedback?: DocsAgentFeedbackDiscoveryConfig;
+  llms?: DocsLlmsDiscoveryConfig;
+  sitemap?: boolean | DocsSitemapConfig;
+  robots?: boolean | DocsRobotsConfig;
+  openapi?: boolean | DocsOpenApiDiscoveryConfig;
+  markdown?: {
+    acceptHeader?: boolean;
+    signatureAgentHeader?: boolean; /** Whether runtime Markdown routes support `?sections` metadata discovery. Defaults to true. */
+    sectionDiscovery?: boolean;
+  };
+  /** Additional validated project skills to cross-list in custom discovery. */
+  publishedSkills?: readonly DocsPublishedAgentSkill[];
+  /** Explicit metadata for a real A2A service; omitted sites do not publish an Agent Card. */
+  agentCard?: DocsA2AAgentCardOptions;
+}
+interface DocsSkillDocumentOptions extends DocsDiscoveryApiRouteOptions {
+  origin: string;
+  entry?: string;
+  /** Public rendered docs path when it differs from `entry`. */
+  docsPath?: string;
+  /** Whether this deployment actually serves the RFC 9727 API catalog. Defaults to true. */
+  apiCatalog?: boolean;
+  search?: boolean | DocsSearchConfig;
+  mcp: DocsMcpResolvedConfig;
+  feedback?: DocsAgentFeedbackDiscoveryConfig;
+  llms?: DocsLlmsDiscoveryConfig;
+  sitemap?: boolean | DocsSitemapConfig;
+  robots?: boolean | DocsRobotsConfig;
+  openapi?: boolean | DocsOpenApiDiscoveryConfig;
+  markdown?: {
+    acceptHeader?: boolean;
+    signatureAgentHeader?: boolean; /** Whether runtime Markdown routes support `?sections` metadata discovery. Defaults to true. */
+    sectionDiscovery?: boolean;
+  };
+}
+interface DocsAgentsDocumentOptions extends DocsSkillDocumentOptions {}
+interface DocsStandardsDiscoveryResponseOptions extends DocsAgentDiscoverySpecOptions {
+  request: Request;
+  preferredSkillDocument?: string | null;
+  fallbackSkillDocument: string;
+}
+interface DocsAgentContractMcpTools {
+  list?: "list_tasks";
+  read?: "read_task";
+}
+interface DocsMarkdownPage {
+  slug?: string;
+  url: string;
+  title: string;
+  description?: string;
+  /** Override the public Markdown representation URL when it differs from `${url}.md`. */
+  markdownUrl?: string;
+  lastModified?: string;
+  lastmod?: string;
+  related?: ResolvedDocsRelatedLink[];
+  agent?: PageAgentFrontmatter;
+  content: string;
+  rawContent?: string;
+  agentContent?: string;
+  agentRawContent?: string;
+  agentFallbackContent?: string;
+  agentFallbackRawContent?: string;
+}
+interface DocsMarkdownDocumentOptions {
+  llms?: boolean | DocsLlmsDiscoveryConfig | LlmsTxtConfig;
+  origin?: string;
+  sitemap?: boolean | DocsSitemapConfig;
+}
+interface DocsMarkdownSection {
+  id: string;
+  heading: string;
+  level: number;
+  content: string;
+  startLine: number;
+  endLine: number;
+}
+interface DocsMarkdownSectionMetadata {
+  id: string;
+  heading: string;
+  level: number;
+  parentId?: string;
+  startLine: number;
+  endLine: number;
+  estimatedTokens: number;
+  utf8Bytes: number;
+  canonicalUrl: string;
+  markdownUrl: string;
+}
+interface DocsMarkdownSectionIndex {
+  schemaVersion: 2;
+  format: typeof DOCS_MARKDOWN_SECTION_INDEX_FORMAT;
+  canonicalUrl: string;
+  markdownUrl: string;
+  sectionIndexUrl: string;
+  lineNumbering: "body";
+  sectionCount: number;
+  estimatedTokens: number;
+  utf8Bytes: number;
+  fetchBudget?: {
+    tokenBudget?: number;
+    byteBudget?: number;
+  };
+  sections: DocsMarkdownSectionMetadata[];
+}
+interface DocsMarkdownSectionIndexOptions {
+  canonicalUrl: string;
+  markdownUrl: string;
+  sectionIndexUrl?: string;
+  tokenBudget?: number | null;
+  byteBudget?: number | null;
+}
+interface DocsMarkdownSectionRequest {
+  section?: string | null;
+  tokenBudget?: number | null;
+  byteBudget?: number | null;
+}
+interface DocsMarkdownSectionResult {
+  found: boolean;
+  requestedSection?: string;
+  section?: DocsMarkdownSection;
+  document: string;
+  truncated: boolean;
+  tokenBudget?: number;
+  byteBudget?: number;
+  estimatedTokens: number;
+  utf8Bytes: number;
+  availableSections: DocsMarkdownSection[];
+}
+interface DocsMarkdownNotFoundOptions extends DocsDiscoveryApiRouteOptions {
+  entry?: string;
+  requestedPath: string;
+  origin?: string;
+  pages?: DocsMarkdownPage[];
+  sitemap?: boolean | DocsSitemapConfig;
+}
+interface DocsMarkdownRecoveryMatch {
+  title: string;
+  url: string;
+  markdownUrl: string;
+  description?: string;
+  confidence: number;
+}
+interface DocsMarkdownRecoveryResult {
+  matches: DocsMarkdownRecoveryMatch[];
+  redirect?: DocsMarkdownRecoveryMatch;
+}
+interface DocsMarkdownCanonicalUrlOptions {
+  origin: string;
+  entry?: string;
+  requestedPath: string;
+  locale?: string | null;
+}
+interface DocsMarkdownResponseOptions extends DocsMarkdownNotFoundOptions {
+  request: Request;
+  document: string | null;
+  /** Override the human-readable canonical URL, for example when docsPath differs from entry. */
+  canonicalUrl?: string;
+  /** Override the selected Markdown representation URL. */
+  contentLocation?: string;
+  locale?: string | null;
+  /** Exact source modification timestamp. Date-only values are intentionally ignored. */
+  lastModified?: string | Date | null;
+  cacheControl?: string;
+}
+declare function normalizeDocsPathSegment(value: string): string;
+declare function normalizeDocsUrlPath(value: string): string;
+declare function isDocsConfigRequest(url: URL): boolean;
+declare function isDocsDiagnosticsRequest(url: URL): boolean;
+/** Prefer an explicitly configured API route; otherwise infer a query-form route from the request. */
+declare function resolveDocsRequestApiRoute(url: URL, configuredApiRoute?: string): string;
+declare function buildDocsConfigMap(config: DocsConfig | Record<string, unknown>, options?: {
+  file?: string;
+}): DocsConfigMap;
+declare function buildDocsDiagnostics(config: DocsConfig | Record<string, unknown>, options?: DocsDiagnosticsOptions): DocsDiagnostics;
+declare function buildDocsAgentFeedbackSchema(payloadSchema: Record<string, unknown>): Record<string, unknown>;
+declare function resolveDocsAgentFeedbackConfig(feedback?: boolean | FeedbackConfig): DocsAgentFeedbackResolvedConfig;
+declare function resolveDocsAgentFeedbackRequest(url: URL, feedback: DocsAgentFeedbackResolvedConfig): DocsAgentFeedbackRequest | null;
+declare function parseDocsAgentFeedbackData(request: Request): Promise<{
+  ok: true;
+  data: DocsAgentFeedbackData;
+} | {
+  ok: false;
+  response: Response;
+}>;
+declare function validateDocsAgentFeedbackPayload(value: unknown, schema: Record<string, unknown>, valuePath?: string): string | undefined;
+declare function toDocsMarkdownUrl(url: string, options?: {
+  locale?: string;
+}): string;
+declare function resolveDocsMarkdownCanonicalUrl({
+  origin,
+  entry,
+  requestedPath,
+  locale
+}: DocsMarkdownCanonicalUrlOptions): string;
+declare function getDocsMarkdownCanonicalLinkHeader(options: DocsMarkdownCanonicalUrlOptions): string;
+declare function resolveDocsLlmsTxtSections(llms?: boolean | DocsLlmsDiscoveryConfig | LlmsTxtConfig): DocsLlmsTxtResolvedSection[];
+declare function matchesDocsLlmsTxtSection(pageUrl: string, section: DocsLlmsTxtResolvedSection): boolean;
+declare function resolveDocsLlmsTxtRequest(url: URL, llms?: boolean | DocsLlmsDiscoveryConfig | LlmsTxtConfig, basePath?: string, options?: DocsDiscoveryApiRouteOptions): DocsLlmsTxtRequest | null;
+declare function renderDocsLlmsTxt(pages: DocsLlmsTxtPageInput[], options?: DocsLlmsDiscoveryConfig): DocsLlmsTxtGeneratedContent;
+declare function selectDocsLlmsTxtContent(content: DocsLlmsTxtGeneratedContent, request: DocsLlmsTxtRequest): DocsLlmsTxtSelectedContent | null;
+declare function getDocsLlmsTxtMaxCharsIssue(label: string, content: string, maxChars: DocsLlmsTxtResolvedMaxChars): DocsLlmsTxtMaxCharsIssue | null;
+/** Build and serve standards-based discovery without replacing the custom agent manifest. */
+declare function createDocsStandardsDiscoveryResponse({
+  request,
+  preferredSkillDocument,
+  fallbackSkillDocument,
+  origin,
+  entry,
+  docsPath,
+  apiCatalog: explicitApiCatalog,
+  apiRoute,
+  i18n: _i18n,
+  search: _search,
+  mcp,
+  feedback,
+  llms,
+  sitemap,
+  robots,
+  openapi,
+  markdown: _markdown,
+  publishedSkills,
+  agentCard
+}: DocsStandardsDiscoveryResponseOptions): Promise<Response | null>;
+declare function isDocsAgentDiscoveryRequest(url: URL, options?: DocsDiscoveryApiRouteOptions): boolean;
+declare function buildDocsMcpEndpointCandidates(baseUrl: string, routes?: readonly string[], options?: DocsMcpEndpointCandidateOptions): DocsMcpEndpointCandidate[];
+declare function isDocsSkillRequest(url: URL, options?: DocsDiscoveryApiRouteOptions): boolean;
+declare function resolveDocsSkillFormat(url: URL): "skill" | null;
+declare function isDocsAgentsRequest(url: URL, options?: DocsDiscoveryApiRouteOptions): boolean;
+declare function resolveDocsAgentsFormat(url: URL): "agents" | null;
+declare function isDocsPublicGetRequest(entry: string, url: URL, request: Request, options?: DocsDiscoveryApiRouteOptions & {
+  sitemap?: boolean | DocsSitemapConfig;
+  llms?: boolean | DocsLlmsDiscoveryConfig | LlmsTxtConfig;
+  robots?: boolean | DocsRobotsConfig;
+}): boolean;
+declare function isDocsLlmsTxtPublicRequest(url: URL, llms?: boolean | DocsLlmsDiscoveryConfig | LlmsTxtConfig, basePath?: string, options?: DocsDiscoveryApiRouteOptions): boolean;
+declare function resolveDocsLlmsTxtFormat(url: URL, basePath?: string, options?: DocsDiscoveryApiRouteOptions): "llms" | "llms-full" | null;
+declare function resolveDocsMarkdownRequest(entry: string, url: URL, request: Request, options?: DocsDiscoveryApiRouteOptions): {
+  requestedPath: string;
+} | null;
+declare function hasDocsMarkdownSignatureAgent(request: Request): boolean;
+type DocsMarkdownAgentDetection = {
+  detected: true;
+  method: "signature_agent" | "user_agent" | "heuristic";
+} | {
+  detected: false;
+  method: null;
+};
+declare function detectDocsMarkdownAgentRequest(request: Request): DocsMarkdownAgentDetection;
+declare function getDocsMarkdownVaryHeader(request: Request): string | null;
+declare function resolveDocsMarkdownRecovery({
+  entry,
+  requestedPath,
+  pages
+}: DocsMarkdownNotFoundOptions): DocsMarkdownRecoveryResult;
+declare function resolveDocsMarkdownSectionRequest(url: URL): DocsMarkdownSectionRequest | null;
+declare function isDocsMarkdownSectionIndexRequest(url: URL): boolean;
+declare function collectDocsMarkdownSections(document: string): DocsMarkdownSection[];
+declare function buildDocsMarkdownSectionIndex(document: string, options: DocsMarkdownSectionIndexOptions): DocsMarkdownSectionIndex;
+declare function selectDocsMarkdownSection(document: string, request: DocsMarkdownSectionRequest): DocsMarkdownSectionResult;
+declare function renderDocsMarkdownNotFound({
+  entry,
+  apiRoute,
+  requestedPath,
+  origin,
+  pages,
+  sitemap
+}: DocsMarkdownNotFoundOptions): string;
+/** Build one standards-aware Markdown response for every framework adapter. */
+declare function createDocsMarkdownResponse(options: DocsMarkdownResponseOptions): Response;
+declare function findDocsMarkdownPage<T extends DocsMarkdownPage>(entry: string, pages: T[], requestedPath: string): T | null;
+declare function renderDocsMarkdownDocument(page: DocsMcpPage | DocsSearchSourcePage, options?: DocsMarkdownDocumentOptions): string;
+declare function renderDocsMarkdownDocument(page: DocsMarkdownPage, options?: DocsMarkdownDocumentOptions): string;
+declare function renderDocsSkillDocument(options: DocsSkillDocumentOptions): string;
+declare function renderDocsAgentsDocument(options: DocsAgentsDocumentOptions): string;
+/** Resolve only the task tools that the advertised MCP endpoint actually exposes. */
+declare function resolveDocsAgentContractMcpTools(mcp: DocsMcpResolvedConfig): DocsAgentContractMcpTools | undefined;
+declare function buildDocsAgentDiscoverySpec({
+  origin,
+  entry,
+  apiRoute,
+  apiCatalog: explicitApiCatalog,
+  i18n,
+  search,
+  mcp,
+  feedback,
+  llms,
+  sitemap,
+  robots,
+  openapi,
+  markdown,
+  publishedSkills,
+  agentCard
+}: DocsAgentDiscoverySpecOptions): {
+  $schema: string;
+  format: string;
+  version: string;
+  name: string;
+  baseUrl: string;
+  site: {
+    title: string;
+    description: string | undefined;
+    entry: string;
+    baseUrl: string;
+  };
+  locales: {
+    enabled: boolean;
+    available: string[];
+    default: string | null;
+    queryParam: string;
+    fallbackQueryParam: string;
+  };
+  capabilities: {
+    markdownRoutes: boolean;
+    markdownSectionDiscovery: boolean;
+    agentMdOverrides: boolean;
+    agentBlocks: boolean;
+    structuredAgentContracts: boolean;
+    agents: boolean;
+    llms: boolean;
+    skills: boolean;
+    apiCatalog: boolean;
+    agentSkillsDiscovery: boolean;
+    mcp: boolean;
+    search: boolean;
+    sitemap: boolean;
+    robots: boolean;
+    structuredData: boolean;
+    apiReference: boolean;
+    openapi: boolean;
+    agentFeedback: boolean;
+    locales: boolean;
+  };
+  api: {
+    openapi: string;
+    agentCard?: string | undefined;
+    agentSkillsIndex: string;
+    legacySkillsIndex: string;
+    apiCatalog?: string | undefined;
+    apiCatalogQuery?: string | undefined;
+    docs: string;
+    config: string;
+    diagnostics: string;
+    agentSpec: string;
+    agentSpecDefault: string;
+    agentSpecFallback: string;
+    agentSpecWellKnown: string;
+    agentSpecWellKnownJson: string;
+    agentSpecQuery: string;
+    agents: string;
+  };
+  apiCatalog: {
+    enabled: boolean;
+    route: string | null;
+    api: string | null;
+    mediaType: string;
+    profile: string;
+  };
+  config: {
+    format: string;
+    endpoint: string;
+  };
+  markdown: {
+    enabled: boolean;
+    acceptHeader: string | null;
+    signatureAgentHeader: string | null;
+    pagePattern: string;
+    rootPage: string;
+    apiPattern: string;
+    sectionDiscovery: {
+      format?: string | undefined;
+      indexParam?: string | undefined;
+      sectionParam?: string | undefined;
+      tokenBudgetParam?: string | undefined;
+      byteBudgetParam?: string | undefined;
+      enabled: boolean;
+    };
+    resolutionOrder: string[];
+  };
+  agentContract: {
+    usefulContractFields: string[];
+    fields: {
+      readonly tokenBudget: "number";
+      readonly task: "string";
+      readonly outcome: "string";
+      readonly appliesTo: {
+        readonly framework: "string|string[]";
+        readonly version: "string|string[]";
+        readonly package: "string|string[]";
+      };
+      readonly prerequisites: "string[]";
+      readonly files: "string[]";
+      readonly commands: "Array<string|{run,cwd?,description?}>";
+      readonly sideEffects: "string[]";
+      readonly verification: "Array<string|{description?,run?,expect?}>";
+      readonly rollback: "string[]";
+      readonly failureModes: "Array<string|{symptom,resolution?}>";
+    };
+    mcpTools?: DocsAgentContractMcpTools | undefined;
+    enabled: boolean;
+    schemaVersion: string;
+    source: string;
+    frontmatterPath: string;
+    markdownSection: string;
+    mcpField: string;
+  };
+  llms: {
+    sections?: {
+      title: string;
+      description: string | undefined;
+      match: string[];
+      txt: string;
+      full: string;
+    }[] | undefined;
+    enabled: boolean;
+    defaultTxt: string;
+    defaultFull: string;
+    txt: string;
+    full: string;
+    publicTxt: string;
+    publicFull: string;
+    wellKnownTxt: string;
+    wellKnownFull: string;
+  };
+  sitemap: {
+    enabled: boolean;
+    xml: {
+      enabled: boolean;
+      route: string;
+      api: string;
+      defaultRoute: string;
+    };
+    markdown: {
+      enabled: boolean;
+      route: string;
+      docsRoute: string | undefined;
+      wellKnownRoute: string;
+      api: string;
+      defaultRoute: string;
+      defaultDocsRoute: string;
+      defaultWellKnownRoute: string;
+    };
+  };
+  robots: {
+    enabled: boolean;
+    route: string;
+    defaultRoute: string;
+  };
+  structuredData: {
+    enabled: boolean;
+    format: string;
+    schema: string;
+    fields: string[];
+    canonicalUrlField: string;
+    breadcrumbType: string;
+    agentContractType: string;
+  };
+  openapi: {
+    enabled: boolean;
+    url: string | null;
+    source: "generated" | "configured" | null;
+    specUrl: string | null;
+    apiReferencePath: string | null;
+    format: string;
+  };
+  search: {
+    enabled: boolean;
+    endpoint: string;
+    agentEndpoint: string;
+    structuredAgentEndpoint: string;
+    method: string;
+    queryParam: string;
+    localeParam: string;
+    audienceParam: string;
+    defaultAudience: string;
+    supportedAudiences: string[];
+    responseParam: string;
+    structuredResponseValue: string;
+    responseFormat: string;
+    filterParams: {
+      framework: string;
+      version: string;
+      package: string;
+      tags: string;
+    };
+    repeatedFilterParams: string[];
+    warningsField: string;
+    cursorParam: string;
+    nextCursorField: string;
+    hasMoreField: string;
+    totalField: string;
+  };
+  agents: {
+    enabled: boolean;
+    file: string;
+    route: string;
+    wellKnown: string;
+    api: string;
+    generatedFallback: boolean;
+    aliases: string[];
+  };
+  skills: {
+    enabled: boolean;
+    file: string;
+    route: string;
+    wellKnown: string;
+    api: string;
+    generatedFallback: boolean;
+    registry: string;
+    install: string;
+    discovery: {
+      schema: string;
+      index: string;
+      artifact: string;
+      archive: string;
+      file: string;
+      legacyIndex: string;
+      apiIndex: string;
+      apiArtifact: string;
+      apiFile: string;
+      digest: string;
+    };
+    published: {
+      name: string;
+      description: string;
+      type: "skill-md" | "archive";
+      url: string;
+      digest: `sha256:${string}`;
+      files: {
+        path: string;
+        url: string;
+        digest: `sha256:${string}`;
+      }[];
+    }[];
+    recommended: {
+      name: string;
+      description: string;
+    }[];
+  };
+  mcp: {
+    protectedResource?: {
+      metadataEndpoints: string[];
+      authorizationServers: string[];
+      scopesSupported: string[];
+      requiredScopes: string[];
+    } | undefined;
+    enabled: boolean;
+    endpoint: string;
+    defaultEndpoint: string;
+    publicEndpoint: string;
+    wellKnownEndpoint: string;
+    publicEndpoints: string[];
+    canonicalEndpoint: string;
+    name: string;
+    version: string;
+    tools: {
+      listDocs: boolean;
+      listPages: boolean;
+      listPageSections?: boolean;
+      readPage: boolean;
+      listTasks?: boolean;
+      readTask?: boolean;
+      searchDocs: boolean;
+      getNavigation: boolean;
+      getCodeExamples: boolean;
+      getConfigSchema: boolean;
+      getContext: boolean;
+    };
+  };
+  feedback: {
+    enabled: boolean;
+    schema: string;
+    submit: string;
+    schemaQuery: string;
+    submitQuery: string;
+  };
+  instructions: {
+    preferMarkdownRoutes: boolean;
+    useMcpWhenAvailable: boolean;
+    useOpenApiWhenAvailable: boolean;
+    readFeedbackSchemaBeforeSubmitting: boolean;
+    doNotAssumeFeedbackPayloadShape: boolean;
+  };
+};
+declare function acceptsDocsMarkdown(request: Request): boolean;
+declare function resolveDocsOpenApiDiscoveryConfig(openapi?: boolean | DocsOpenApiDiscoveryConfig): DocsOpenApiResolvedDiscoveryConfig;
+//#endregion
+export { DocsMarkdownPage as $, resolveDocsLlmsTxtRequest as $t, DocsAgentFeedbackDiscoveryConfig as A, DocsPathMatch as An, hasDocsMarkdownSignatureAgent as At, DocsDiagnosticsIssueSeverity as B, normalizeDocsPathSegment as Bt, DOCS_AI_AGENT_USER_AGENT_HEADER_PATTERN as C, DEFAULT_MCP_ROUTE as Cn, createDocsMarkdownResponse as Ct, DOCS_TRADITIONAL_BOT_USER_AGENT_HEADER_PATTERN as D, getDocsMcpResourcePaths as Dn, getDocsLlmsTxtMaxCharsIssue as Dt, DOCS_MARKDOWN_SIGNATURE_AGENT_HEADER as E, getDocsMcpProtectedResourceMetadataRoutes as En, findDocsMarkdownPage as Et, DocsConfigMapJsonValue as F, isDocsLlmsTxtPublicRequest as Ft, DocsLlmsTxtGeneratedSection as G, renderDocsMarkdownDocument as Gt, DocsDiagnosticsStatus as H, parseDocsAgentFeedbackData as Ht, DocsConfigMapPointer as I, isDocsMarkdownSectionIndexRequest as It, DocsLlmsTxtRequest as J, resolveDocsAgentContractMcpTools as Jt, DocsLlmsTxtMaxCharsIssue as K, renderDocsMarkdownNotFound as Kt, DocsDiagnostics as L, isDocsPublicGetRequest as Lt, DocsAgentFeedbackResolvedConfig as M, resolveDocsI18n as Mn, isDocsAgentsRequest as Mt, DocsAgentsDocumentOptions as N, resolveDocsLocale as Nn, isDocsConfigRequest as Nt, DocsAgentContractMcpTools as O, hasDocsMcpProtectedResourceConfig as On, getDocsMarkdownCanonicalLinkHeader as Ot, DocsConfigMap as P, resolveDocsPath as Pn, isDocsDiagnosticsRequest as Pt, DocsMarkdownAgentDetection as Q, resolveDocsLlmsTxtFormat as Qt, DocsDiagnosticsFeature as R, isDocsSkillRequest as Rt, DEFAULT_SKILL_MD_WELL_KNOWN_ROUTE as S, DEFAULT_MCP_PUBLIC_ROUTE as Sn, collectDocsMarkdownSections as St, DOCS_MARKDOWN_SECTION_INDEX_FORMAT as T, buildDocsMcpProtectedResourceMetadataRoute as Tn, detectDocsMarkdownAgentRequest as Tt, DocsLlmsDiscoveryConfig as U, renderDocsAgentsDocument as Ut, DocsDiagnosticsOptions as V, normalizeDocsUrlPath as Vt, DocsLlmsTxtGeneratedContent as W, renderDocsLlmsTxt as Wt, DocsLlmsTxtResolvedSection as X, resolveDocsAgentFeedbackRequest as Xt, DocsLlmsTxtResolvedMaxChars as Y, resolveDocsAgentFeedbackConfig as Yt, DocsLlmsTxtSelectedContent as Z, resolveDocsAgentsFormat as Zt, DEFAULT_LLMS_TXT_MAX_CHARS as _, findDocsAudienceMdxIssues as _n, buildDocsAgentFeedbackSchema as _t, DEFAULT_AGENT_MD_ROUTE as a, resolveDocsOpenApiDiscoveryConfig as an, DocsMarkdownSectionIndexOptions as at, DEFAULT_OPENAPI_SCHEMA_ROUTE as b, resolveDocsAudienceMdxContent as bn, buildDocsMarkdownSectionIndex as bt, DEFAULT_AGENT_SPEC_WELL_KNOWN_JSON_ROUTE as c, selectDocsLlmsTxtContent as cn, DocsMarkdownSectionResult as ct, DEFAULT_DOCS_CONFIG_FORMAT as d, validateDocsAgentFeedbackPayload as dn, DocsOpenApiDiscoveryConfig as dt, resolveDocsLlmsTxtSections as en, DocsMarkdownRecoveryMatch as et, DEFAULT_DOCS_CONFIG_ROUTE as f, DocsAudienceMdxIssue as fn, DocsOpenApiResolvedDiscoveryConfig as ft, DEFAULT_LLMS_FULL_TXT_WELL_KNOWN_ROUTE as g, extractDocsMarkdownPromptBlocks as gn, buildDocsAgentDiscoverySpec as gt, DEFAULT_LLMS_FULL_TXT_ROUTE as h, ExtractedDocsMarkdownPromptBlocks as hn, acceptsDocsMarkdown as ht, DEFAULT_AGENT_FEEDBACK_ROUTE as i, resolveDocsMarkdownSectionRequest as in, DocsMarkdownSectionIndex as it, DocsAgentFeedbackRequest as j, ResolvedDocsI18n as jn, isDocsAgentDiscoveryRequest as jt, DocsAgentDiscoverySpecOptions as k, isDocsMcpRequest as kn, getDocsMarkdownVaryHeader as kt, DEFAULT_AGENT_SPEC_WELL_KNOWN_ROUTE as l, selectDocsMarkdownSection as ln, DocsMcpEndpointCandidate as lt, DEFAULT_DOCS_DIAGNOSTICS_ROUTE as m, DocsMarkdownPromptBlock as mn, DocsStandardsDiscoveryResponseOptions as mt, DEFAULT_AGENTS_MD_WELL_KNOWN_ROUTE as n, resolveDocsMarkdownRecovery as nn, DocsMarkdownResponseOptions as nt, DEFAULT_AGENT_MD_WELL_KNOWN_ROUTE as o, resolveDocsRequestApiRoute as on, DocsMarkdownSectionMetadata as ot, DEFAULT_DOCS_DIAGNOSTICS_FORMAT as p, DocsContentAudience as pn, DocsSkillDocumentOptions as pt, DocsLlmsTxtPageInput as q, renderDocsSkillDocument as qt, DEFAULT_AGENT_FEEDBACK_PAYLOAD_SCHEMA as r, resolveDocsMarkdownRequest as rn, DocsMarkdownSection as rt, DEFAULT_AGENT_SPEC_ROUTE as s, resolveDocsSkillFormat as sn, DocsMarkdownSectionRequest as st, DEFAULT_AGENTS_MD_ROUTE as t, resolveDocsMarkdownCanonicalUrl as tn, DocsMarkdownRecoveryResult as tt, DEFAULT_DOCS_API_ROUTE as u, toDocsMarkdownUrl as un, DocsMcpEndpointCandidateOptions as ut, DEFAULT_LLMS_TXT_ROUTE as v, resolveDocsAgentMdxContent as vn, buildDocsConfigMap as vt, DOCS_BOT_LIKE_USER_AGENT_HEADER_PATTERN as w, DEFAULT_MCP_WELL_KNOWN_ROUTE as wn, createDocsStandardsDiscoveryResponse as wt, DEFAULT_SKILL_MD_ROUTE as x, DEFAULT_MCP_PROTECTED_RESOURCE_METADATA_ROUTE as xn, buildDocsMcpEndpointCandidates as xt, DEFAULT_LLMS_TXT_WELL_KNOWN_ROUTE as y, resolveDocsAudienceExposure as yn, buildDocsDiagnostics as yt, DocsDiagnosticsIssue as z, matchesDocsLlmsTxtSection as zt };