@shoalrun/cli 0.0.0-stage → 0.1.0-alpha.12

package/dist/code-samples.d.ts

@@ -0,0 +1,50 @@
+export type CodeSample = {
+    language: string;
+    label: string;
+    highlight: string;
+    code: string;
+};
+export type RequestAuth = {
+    kind: 'header';
+    name: string;
+    value: string;
+} | {
+    kind: 'cookie';
+    name: string;
+    value: string;
+} | {
+    kind: 'basic';
+    user: string;
+    pass: string;
+} | {
+    kind: 'digest';
+    user: string;
+    pass: string;
+} | {
+    kind: 'bearer';
+    token: string;
+} | {
+    kind: 'authorization';
+    value: string;
+} | {
+    kind: 'mtls';
+    cert: string;
+    key: string;
+};
+export type RequestBody = {
+    mediaType: string;
+    text: string;
+    formFields: string[];
+};
+export type RequestSample = {
+    method: string;
+    url: string;
+    headers: Array<{
+        name: string;
+        value: string;
+    }>;
+    auth: RequestAuth[];
+    contentType?: string;
+    body?: RequestBody;
+};
+export declare function requestSamples(sample: RequestSample): CodeSample[];

package/dist/code-samples.js

@@ -0,0 +1,181 @@
+// A language-neutral view of one API request, plus serializers that turn it into
+// copyable code samples. The HTML reference shows every language; the Markdown
+// twin and the agent bundle keep only the cURL sample by deliberate choice,
+// because agents can translate cURL and one canonical sample keeps the .md
+// output small. See docs/content/api-generation.mdx.
+const shellQuote = (value) => `'${value.replaceAll("'", "'\\''")}'`;
+const phpString = (value) => `'${value.replaceAll('\\', '\\\\').replaceAll("'", "\\'")}'`;
+const rubyString = (value) => `'${value.replaceAll('\\', '\\\\').replaceAll("'", "\\'")}'`;
+const csharpString = (value) => `@"${value.replaceAll('"', '""')}"`;
+const goString = (value) => value.includes('`') ? JSON.stringify(value) : '`' + value + '`';
+const basicHeader = 'Basic <base64 of YOUR_USERNAME:YOUR_PASSWORD>';
+function resolve(sample) {
+    const headers = [];
+    const cookies = [];
+    const notes = [];
+    for (const auth of sample.auth) {
+        if (auth.kind === 'header')
+            headers.push([auth.name, auth.value]);
+        else if (auth.kind === 'cookie')
+            cookies.push(`${auth.name}=${auth.value}`);
+        else if (auth.kind === 'bearer')
+            headers.push(['Authorization', `Bearer ${auth.token}`]);
+        else if (auth.kind === 'authorization')
+            headers.push(['Authorization', auth.value]);
+        else if (auth.kind === 'basic')
+            headers.push(['Authorization', basicHeader]);
+        else if (auth.kind === 'digest')
+            notes.push('HTTP digest auth answers the server challenge with YOUR_USERNAME and YOUR_PASSWORD; most clients handle it for you.');
+        else if (auth.kind === 'mtls')
+            notes.push('Mutual TLS: present CLIENT_CERT.pem and use CLIENT_KEY.pem.');
+    }
+    if (cookies.length)
+        headers.push(['Cookie', cookies.join('; ')]);
+    for (const header of sample.headers)
+        headers.push([header.name, header.value]);
+    if (sample.contentType && !headers.some(([name]) => name.toLowerCase() === 'content-type'))
+        headers.push(['Content-Type', sample.contentType]);
+    return { headers, notes };
+}
+const hasBody = (sample) => !!sample.body && !sample.body.formFields.length;
+function curl(sample) {
+    const parts = [`curl --request ${sample.method.toUpperCase()}`, `--url ${shellQuote(sample.url)}`];
+    for (const auth of sample.auth) {
+        if (auth.kind === 'header')
+            parts.push(`--header ${shellQuote(`${auth.name}: ${auth.value}`)}`);
+        else if (auth.kind === 'cookie')
+            parts.push(`--header ${shellQuote(`Cookie: ${auth.name}=${auth.value}`)}`);
+        else if (auth.kind === 'basic')
+            parts.push(`--user ${shellQuote(`${auth.user}:${auth.pass}`)}`);
+        else if (auth.kind === 'digest')
+            parts.push('--digest', `--user ${shellQuote(`${auth.user}:${auth.pass}`)}`);
+        else if (auth.kind === 'authorization')
+            parts.push(`--header ${shellQuote(`Authorization: ${auth.value}`)}`);
+        else if (auth.kind === 'bearer')
+            parts.push(`--header ${shellQuote(`Authorization: Bearer ${auth.token}`)}`);
+        else if (auth.kind === 'mtls')
+            parts.push(`--cert ${shellQuote(auth.cert)}`, `--key ${shellQuote(auth.key)}`);
+    }
+    for (const header of sample.headers)
+        parts.push(`--header ${shellQuote(`${header.name}: ${header.value}`)}`);
+    if (sample.contentType && !sample.body?.formFields.length)
+        parts.push(`--header ${shellQuote(`Content-Type: ${sample.contentType}`)}`);
+    for (const field of sample.body?.formFields ?? [])
+        parts.push(`--form ${shellQuote(`${field}=@YOUR_${field.replace(/[^a-z0-9]/gi, '_').toUpperCase()}`)}`);
+    if (hasBody(sample))
+        parts.push(`--data-raw ${shellQuote(sample.body.text)}`);
+    return parts.join(' \\\n  ');
+}
+function javascript(sample, node) {
+    const { headers, notes } = resolve(sample);
+    const options = [`  method: ${JSON.stringify(sample.method.toUpperCase())}`];
+    if (headers.length)
+        options.push(`  headers: {\n${headers.map(([name, value]) => `    ${JSON.stringify(name)}: ${JSON.stringify(value)}`).join(',\n')}\n  }`);
+    if (hasBody(sample))
+        options.push(`  body: ${JSON.stringify(sample.body.text)}`);
+    const lines = notes.map(note => `// ${note}`);
+    if (node)
+        lines.push('// Node.js 18 or newer provides a global fetch.');
+    lines.push(`const response = await fetch(${JSON.stringify(sample.url)}, {`, options.join(',\n'), '});', '', 'const data = await response.json();', 'console.log(data);');
+    return lines.join('\n');
+}
+function python(sample) {
+    const { headers, notes } = resolve(sample);
+    const lines = ['import requests', '', ...notes.map(note => `# ${note}`), `url = ${JSON.stringify(sample.url)}`];
+    if (headers.length)
+        lines.push(`headers = {\n${headers.map(([name, value]) => `    ${JSON.stringify(name)}: ${JSON.stringify(value)}`).join(',\n')}\n}`);
+    if (hasBody(sample))
+        lines.push(`data = ${JSON.stringify(sample.body.text)}`);
+    const args = ['url', ...(headers.length ? ['headers=headers'] : []), ...(hasBody(sample) ? ['data=data'] : [])];
+    lines.push('', `response = requests.${sample.method.toLowerCase()}(${args.join(', ')})`, 'print(response.json())');
+    return lines.join('\n');
+}
+function go(sample) {
+    const { headers, notes } = resolve(sample);
+    const imports = ['"fmt"', '"io"', '"net/http"', ...(hasBody(sample) ? ['"strings"'] : [])].sort();
+    const bodyVar = hasBody(sample) ? [`body := strings.NewReader(${goString(sample.body.text)})`, ''] : [];
+    const bodyArg = hasBody(sample) ? 'body' : 'nil';
+    const lines = [
+        ...notes.map(note => `// ${note}`),
+        'package main', '', 'import (', ...imports.map(item => `\t${item}`), ')', '',
+        'func main() {', ...bodyVar.map(line => line ? `\t${line}` : ''),
+        `\treq, err := http.NewRequest(${JSON.stringify(sample.method.toUpperCase())}, ${JSON.stringify(sample.url)}, ${bodyArg})`,
+        '\tif err != nil {', '\t\tpanic(err)', '\t}',
+        ...headers.map(([name, value]) => `\treq.Header.Set(${JSON.stringify(name)}, ${JSON.stringify(value)})`),
+        '\tres, err := http.DefaultClient.Do(req)', '\tif err != nil {', '\t\tpanic(err)', '\t}',
+        '\tdefer res.Body.Close()', '\tdata, err := io.ReadAll(res.Body)', '\tif err != nil {', '\t\tpanic(err)', '\t}',
+        '\tfmt.Println(string(data))', '}'
+    ];
+    return lines.join('\n');
+}
+function java(sample) {
+    const { headers, notes } = resolve(sample);
+    const builder = headers.map(([name, value]) => `            .header(${JSON.stringify(name)}, ${JSON.stringify(value)})`);
+    const bodyMethod = hasBody(sample) ? `            .method(${JSON.stringify(sample.method.toUpperCase())}, HttpRequest.BodyPublishers.ofString(${JSON.stringify(sample.body.text)}))` : `            .method(${JSON.stringify(sample.method.toUpperCase())}, HttpRequest.BodyPublishers.noBody())`;
+    return [
+        ...notes.map(note => `// ${note}`),
+        'import java.net.URI;', 'import java.net.http.HttpClient;', 'import java.net.http.HttpRequest;', 'import java.net.http.HttpResponse;', '',
+        'public class Main {', '    public static void main(String[] args) throws Exception {', '        HttpClient client = HttpClient.newHttpClient();',
+        '        HttpRequest request = HttpRequest.newBuilder()', `            .uri(URI.create(${JSON.stringify(sample.url)}))`, ...builder, bodyMethod, '            .build();',
+        '        HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());', '        System.out.println(response.body());', '    }', '}'
+    ].join('\n');
+}
+function php(sample) {
+    const { headers, notes } = resolve(sample);
+    const array = ['    CURLOPT_URL => ' + phpString(sample.url), `    CURLOPT_CUSTOMREQUEST => ${phpString(sample.method.toUpperCase())}`, '    CURLOPT_RETURNTRANSFER => true'];
+    if (headers.length)
+        array.push(`    CURLOPT_HTTPHEADER => [\n${headers.map(([name, value]) => `        ${phpString(`${name}: ${value}`)}`).join(',\n')}\n    ]`);
+    if (hasBody(sample))
+        array.push(['    CURLOPT_POSTFIELDS => <<<\'JSON\'', sample.body.text, 'JSON'].join('\n'));
+    return [
+        '<?php', '',
+        ...notes.map(note => `// ${note}`),
+        '$ch = curl_init();', 'curl_setopt_array($ch, [', array.join(',\n'), ']);', '',
+        '$response = curl_exec($ch);', 'curl_close($ch);', 'echo $response;'
+    ].join('\n');
+}
+function ruby(sample) {
+    const { headers, notes } = resolve(sample);
+    const klass = sample.method.toLowerCase() === 'get' ? 'Get' : sample.method[0].toUpperCase() + sample.method.slice(1);
+    const lines = [
+        ...notes.map(note => `# ${note}`),
+        "require 'net/http'", "require 'uri'", '',
+        `uri = URI(${rubyString(sample.url)})`, 'http = Net::HTTP.new(uri.host, uri.port)', 'http.use_ssl = true', '',
+        `request = Net::HTTP::${klass}.new(uri)`,
+        ...headers.map(([name, value]) => `request[${rubyString(name)}] = ${rubyString(value)}`),
+        ...(hasBody(sample) ? [`request.body = ${rubyString(sample.body.text)}`] : []),
+        '', 'response = http.request(request)', 'puts response.body'
+    ];
+    return lines.join('\n');
+}
+function csharp(sample) {
+    const { headers, notes } = resolve(sample);
+    const contentHeaders = headers.filter(([name]) => name.toLowerCase() !== 'content-type');
+    const contentType = headers.find(([name]) => name.toLowerCase() === 'content-type')?.[1] ?? sample.body?.mediaType ?? 'application/json';
+    return [
+        ...notes.map(note => `// ${note}`),
+        'using System;', 'using System.Net.Http;', 'using System.Text;', 'using System.Threading.Tasks;', '',
+        'class Program', '{', '    static async Task Main()', '    {', '        using var client = new HttpClient();',
+        `        var request = new HttpRequestMessage(new HttpMethod(${JSON.stringify(sample.method.toUpperCase())}), ${JSON.stringify(sample.url)});`,
+        ...contentHeaders.map(([name, value]) => `        request.Headers.TryAddWithoutValidation(${JSON.stringify(name)}, ${JSON.stringify(value)});`),
+        ...(hasBody(sample) ? [`        request.Content = new StringContent(${csharpString(sample.body.text)}, Encoding.UTF8, ${JSON.stringify(contentType)});`] : []),
+        '        var response = await client.SendAsync(request);', '        Console.WriteLine(await response.Content.ReadAsStringAsync());', '    }', '}'
+    ].join('\n');
+}
+// cURL comes first: the Markdown twin and agent bundle keep only that one.
+export function requestSamples(sample) {
+    const curlSample = { language: 'curl', label: 'cURL', highlight: 'bash', code: curl(sample) };
+    if (sample.body?.formFields.length)
+        return [curlSample];
+    return [
+        curlSample,
+        { language: 'javascript', label: 'JavaScript', highlight: 'javascript', code: javascript(sample, false) },
+        { language: 'node', label: 'Node.js', highlight: 'javascript', code: javascript(sample, true) },
+        { language: 'python', label: 'Python', highlight: 'python', code: python(sample) },
+        { language: 'go', label: 'Go', highlight: 'go', code: go(sample) },
+        { language: 'java', label: 'Java', highlight: 'java', code: java(sample) },
+        { language: 'php', label: 'PHP', highlight: 'php', code: php(sample) },
+        { language: 'ruby', label: 'Ruby', highlight: 'ruby', code: ruby(sample) },
+        { language: 'csharp', label: 'C#', highlight: 'csharp', code: csharp(sample) }
+    ];
+}

package/dist/compact-discovery.d.ts

@@ -0,0 +1,15 @@
+export declare const compactDiscoveryTokenLimit = 2000;
+export type DiscoveryEntry = {
+    key: string;
+    title: string;
+    topic: string;
+    topicLabel: string;
+    markdown: string;
+};
+export declare function boundedDiscovery(options: {
+    route: string;
+    directory: string;
+    intro: string;
+    flat: string;
+    entries: DiscoveryEntry[];
+}): Map<string, string>;

package/dist/compact-discovery.js

@@ -0,0 +1,78 @@
+import { createHash } from 'node:crypto';
+import { markdownTokens, markdownTokenEncoding } from './markdown-size.js';
+import { heading, link, list, paragraph, renderMarkdown, root, text } from './semantic-markdown.js';
+export const compactDiscoveryTokenLimit = 2000;
+// All child routes are root-relative. Never infer membership from navigation:
+// callers supply the complete set of published pages for this scope.
+export function boundedDiscovery(options) {
+    const { route, directory, intro, flat, entries } = options;
+    const artifacts = new Map();
+    if (markdownTokens(flat) <= compactDiscoveryTokenLimit)
+        return new Map([[route, flat]]);
+    const compare = (a, b) => a < b ? -1 : a > b ? 1 : 0;
+    const short = (label) => [...label].slice(0, 100).join('');
+    const preamble = (label) => renderMarkdown(root([
+        heading(1, short(label)),
+        paragraph(link(route, 'Index overview'), text('. Follow a matching page or a narrower index. All pages in this scope remain reachable.')),
+        paragraph(text(`Full-page token counts use ${markdownTokenEncoding}. Prefer the full page. Use a standalone section only for its stated topic; follow Full page for broader questions or missing context. Standalone is an author declaration, not proof of completeness.`)),
+    ])).trimEnd();
+    const body = (header, items) => `${header}\n\n${items.map(item => item.markdown.trim()).join('\n\n')}\n`;
+    const range = (items) => items.length === 1 ? short(items[0].title) : `${short(items[0].title)} … ${short(items.at(-1).title)}`;
+    const child = (key, label, content) => {
+        const url = `${directory}/${createHash('sha256').update(key).digest('hex').slice(0, 24)}.txt`;
+        if (artifacts.has(url))
+            throw new Error(`Duplicate compact discovery index: ${url}`);
+        artifacts.set(url, content);
+        return { key, title: label, markdown: renderMarkdown(root([list([[paragraph(link(url, label), text(': scoped index.'))]])])).trimEnd() };
+    };
+    const partition = (items, header) => {
+        const chunks = [];
+        let chunk = [];
+        for (const item of items) {
+            if (markdownTokens(body(header, [item])) > compactDiscoveryTokenLimit)
+                throw new Error(`Compact discovery entry ${item.key} exceeds ${compactDiscoveryTokenLimit} tokens. Shorten its title or summary.`);
+            if (chunk.length && markdownTokens(body(header, [...chunk, item])) > compactDiscoveryTokenLimit) {
+                chunks.push(chunk);
+                chunk = [];
+            }
+            chunk.push(item);
+        }
+        if (chunk.length)
+            chunks.push(chunk);
+        return chunks;
+    };
+    const branches = (items, label, key) => {
+        const header = preamble(label);
+        let level = items;
+        let depth = 0;
+        while (markdownTokens(body(header, level)) > compactDiscoveryTokenLimit) {
+            const chunks = partition(level, header);
+            if (chunks.length >= level.length)
+                throw new Error('Compact discovery cannot fit index links within its token budget');
+            level = chunks.map(chunk => child(JSON.stringify([key, depth, chunk[0].key, chunk.at(-1).key]), range(chunk), body(header, chunk)));
+            depth++;
+        }
+        return child(key, label, body(header, level));
+    };
+    const groups = new Map();
+    for (const entry of entries) {
+        const group = groups.get(entry.topic) ?? [];
+        group.push(entry);
+        groups.set(entry.topic, group);
+    }
+    let topics = [...groups].sort(([a], [b]) => compare(a, b)).map(([key, group]) => {
+        group.sort((a, b) => compare(a.title, b.title) || compare(a.key, b.key));
+        return branches(group, group[0].topicLabel, JSON.stringify(['topic', key]));
+    });
+    const rootIntro = `${intro}\n\nChoose a topic index below, then follow a matching page or narrower index. All published pages in this scope remain reachable, including pages outside navigation.\n`;
+    let depth = 0;
+    while (markdownTokens(body(rootIntro, topics)) > compactDiscoveryTokenLimit) {
+        const chunks = partition(topics, rootIntro);
+        if (chunks.length >= topics.length)
+            throw new Error('Compact discovery introduction exceeds its token budget');
+        topics = chunks.map(chunk => branches(chunk, range(chunk), JSON.stringify(['overview', depth, chunk[0].key, chunk.at(-1).key])));
+        depth++;
+    }
+    artifacts.set(route, body(rootIntro, topics));
+    return artifacts;
+}

package/dist/compiler-config.d.ts

@@ -0,0 +1,67 @@
+/**
+ * Structural types for the resolved YAML configuration consumed by the
+ * compiler. loadConfig validates syntax, includes, top-level keys,
+ * schemaVersion, and selected dedicated sections, but not every setting.
+ * Nested values therefore stay unknown until a compiler validator narrows
+ * them.
+ */
+export type ConfigMapping = Record<string, unknown>;
+export interface ResolvedCompilerConfig extends ConfigMapping {
+    schemaVersion: 1;
+    exports?: unknown;
+    site?: unknown;
+    navigation?: unknown;
+    redirects?: unknown;
+    apis?: unknown;
+    relationships?: unknown;
+    variables?: unknown;
+    snippets?: unknown;
+    callouts?: unknown;
+    badges?: unknown;
+    publications?: unknown;
+    outputs?: unknown;
+    templates?: unknown;
+    theme?: unknown;
+    frontmatter?: unknown;
+    metadata?: unknown;
+    audit?: unknown;
+    readerFilters?: unknown;
+    retrieval?: unknown;
+    chat?: unknown;
+    authoring?: unknown;
+    search?: unknown;
+    cookbooks?: unknown;
+    analytics?: unknown;
+    mcp?: unknown;
+}
+export interface CompilerSiteConfig extends ConfigMapping {
+    title: string;
+    basePath?: unknown;
+    contentDir?: string;
+}
+export interface CompilerPublicationsConfig extends ConfigMapping {
+    channels: Record<string, {
+        pathPrefix?: string;
+    }>;
+    versions: Record<string, {
+        pathPrefix?: string;
+    }>;
+    defaults?: {
+        channel?: string;
+        version?: string;
+        language?: string;
+    };
+}
+export declare function isConfigMapping(value: unknown): value is ConfigMapping;
+export declare function configField(value: unknown, key: string): unknown;
+/** Narrow only invariants already guaranteed by loadConfig. */
+export declare function resolvedCompilerConfig(value: unknown): ResolvedCompilerConfig;
+/** A section-level mapping guard for validators that accept arbitrary YAML. */
+export declare function configMappingAt(value: unknown, setting: string): ConfigMapping;
+export declare function navigationCounts(outputs: unknown): boolean;
+/**
+ * Apply the compiler's existing required-section checks at their original
+ * points in the build. Publication entries stay unknown until later checks.
+ */
+export declare function requireSiteSection(config: ResolvedCompilerConfig): CompilerSiteConfig;
+export declare function requirePublicationsSection(config: ResolvedCompilerConfig): CompilerPublicationsConfig;

package/dist/compiler-config.js

@@ -0,0 +1,66 @@
+export function isConfigMapping(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+// Mirrors optional property access on YAML values without assigning an unvalidated shape.
+export function configField(value, key) {
+    return value === null || value === undefined ? undefined : Object(value)[key];
+}
+/** Narrow only invariants already guaranteed by loadConfig. */
+export function resolvedCompilerConfig(value) {
+    if (!isConfigMapping(value) || value.schemaVersion !== 1) {
+        throw new Error('Resolved configuration must be a schemaVersion 1 mapping');
+    }
+    return value;
+}
+/** A section-level mapping guard for validators that accept arbitrary YAML. */
+export function configMappingAt(value, setting) {
+    if (!isConfigMapping(value))
+        throw new Error(`${setting} must be a mapping`);
+    return value;
+}
+export function navigationCounts(outputs) {
+    const navigation = configField(configField(outputs, 'html'), 'navigation');
+    if (navigation === undefined)
+        return true;
+    const settings = configMappingAt(navigation, 'outputs.html.navigation');
+    const showCounts = settings.showCounts;
+    if (showCounts === undefined)
+        return true;
+    if (typeof showCounts !== 'boolean')
+        throw new Error('outputs.html.navigation.showCounts must be true or false');
+    return showCounts;
+}
+/**
+ * Apply the compiler's existing required-section checks at their original
+ * points in the build. Publication entries stay unknown until later checks.
+ */
+export function requireSiteSection(config) {
+    const site = config.site;
+    if (!isConfigMapping(site) || typeof site.title !== 'string' || !site.title.trim()) {
+        throw new Error('site must be a mapping with a nonempty title');
+    }
+    if (site.contentDir !== undefined && typeof site.contentDir !== 'string')
+        throw new Error('site.contentDir must be a path');
+    return site;
+}
+export function requirePublicationsSection(config) {
+    const publications = config.publications;
+    if (!isConfigMapping(publications) || !isConfigMapping(publications.channels) || !isConfigMapping(publications.versions)) {
+        throw new Error('publications needs channels and versions mappings');
+    }
+    if (publications.defaults !== undefined && !isConfigMapping(publications.defaults)) {
+        throw new Error('publications.defaults must be a mapping of channel, version, and language');
+    }
+    for (const group of ['channels', 'versions']) {
+        for (const [name, value] of Object.entries(publications[group])) {
+            if (!isConfigMapping(value) || (value.pathPrefix !== undefined && typeof value.pathPrefix !== 'string')) {
+                throw new Error(`publications.${group}.${name} needs a mapping with an optional pathPrefix string`);
+            }
+        }
+    }
+    const defaults = publications.defaults;
+    if (isConfigMapping(defaults) && ['channel', 'version', 'language'].some(key => defaults[key] !== undefined && typeof defaults[key] !== 'string')) {
+        throw new Error('publications.defaults must be a mapping of channel, version, and language');
+    }
+    return publications;
+}

package/dist/compiler.d.ts

@@ -0,0 +1,208 @@
+import { type BuildProvenance } from './build-info.js';
+import { Mode } from './palettes.js';
+import { Variant } from './content.js';
+export declare const themePresets: Record<string, string>;
+export declare function checkThemeContrast(configFile: string): Promise<{
+    modes: Mode[];
+    palette: string;
+}>;
+export declare function compile(configFile: string, destination?: string, provenance?: BuildProvenance, options?: {
+    apiReview?: 'report';
+    sourceOverrides?: ReadonlyMap<string, string>;
+    authoringFiles?: ReadonlySet<string>;
+}): Promise<{
+    authoringSources?: {
+        id: string;
+        file: string;
+        url: string;
+        markdownUrl: string;
+    }[] | undefined;
+    buildId: string;
+    apiPublicationReview: {
+        apiId: string;
+        digest: string;
+        pages: Array<{
+            id: string;
+            url: string;
+            markdownUrl: string;
+        }>;
+        focusedContracts: string[];
+        fullSources: string[];
+        inputs: Array<{
+            source: string;
+            files: Array<{
+                path: string;
+                digest: string;
+            }>;
+        }>;
+    }[];
+    documents: ({
+        digest: string;
+        markdownBytes: number;
+        markdownTokens: number;
+        markdownTokenEncoding: string;
+        cardTargets: string[];
+        cardQueries: import("./cards.js").CardRequest[];
+        snippets: string[];
+        apiEmbeds: {
+            component: "ApiExample" | "ApiSchema";
+            operation?: string;
+            api?: string;
+            kind?: "request" | "response";
+            mediaType?: string;
+            status?: string;
+            example?: string;
+            schema?: string;
+        }[];
+        focusedContractUrl: string | null;
+        focusedContractBytes: number | null | undefined;
+        focusedContractDigest: string | null | undefined;
+        sections: {
+            id: string;
+            title: string;
+            depth: 2;
+            standalone?: true;
+            markdownUrl: string;
+            parentMarkdownUrl: string;
+            parentDigest: string;
+            digest: string;
+            markdownBytes: number;
+            markdownTokens: number;
+            markdownTokenEncoding: string;
+        }[];
+        readerFilters?: import("./reader-filters.js").ReaderSelection | undefined;
+        subarea?: string | string[] | undefined;
+        area?: string | string[] | undefined;
+        product?: string | undefined;
+        contentDigest: string | undefined;
+        breadcrumbs: {
+            label: string;
+            url?: string;
+        }[];
+        verified?: string | undefined;
+        updated?: string | undefined;
+        indexable: boolean;
+        navigationTab: {
+            id: string;
+            label: string;
+            variant: Variant;
+            url: string;
+            markdownUrl: string;
+            indexUrl: string;
+        };
+        variant: Variant;
+        url: string;
+        markdownUrl: string;
+        subjectDeprecation?: import("./subject-deprecation.js").ResolvedSubjectDeprecation | undefined;
+        change?: import("./authored-change.js").ResolvedChange | undefined;
+        id: string;
+        demo: boolean;
+        type: string;
+        title: string;
+        summary: string;
+        subjectLifecycle: "deprecated" | "in-development" | "beta" | "experimental" | null;
+    } | {
+        digest: string;
+        markdownBytes: number;
+        markdownTokens: number;
+        markdownTokenEncoding: string;
+        cardTargets: string[];
+        cardQueries: import("./cards.js").CardRequest[];
+        snippets: string[];
+        apiEmbeds: {
+            component: "ApiExample" | "ApiSchema";
+            operation?: string;
+            api?: string;
+            kind?: "request" | "response";
+            mediaType?: string;
+            status?: string;
+            example?: string;
+            schema?: string;
+        }[];
+        focusedContractUrl: string | null;
+        focusedContractBytes: number | null | undefined;
+        focusedContractDigest: string | null | undefined;
+        sections: {
+            id: string;
+            title: string;
+            depth: 2;
+            standalone?: true;
+            markdownUrl: string;
+            parentMarkdownUrl: string;
+            parentDigest: string;
+            digest: string;
+            markdownBytes: number;
+            markdownTokens: number;
+            markdownTokenEncoding: string;
+        }[];
+        readerFilters?: import("./reader-filters.js").ReaderSelection | undefined;
+        subarea?: string | string[] | undefined;
+        area?: string | string[] | undefined;
+        product?: string | undefined;
+        contentDigest: string | undefined;
+        breadcrumbs: {
+            label: string;
+            url?: string;
+        }[];
+        verified?: string | undefined;
+        updated?: string | undefined;
+        indexable: boolean;
+        navigationTab?: undefined;
+        variant: Variant;
+        url: string;
+        markdownUrl: string;
+        subjectDeprecation?: import("./subject-deprecation.js").ResolvedSubjectDeprecation | undefined;
+        change?: import("./authored-change.js").ResolvedChange | undefined;
+        id: string;
+        demo: boolean;
+        type: string;
+        title: string;
+        summary: string;
+        subjectLifecycle: "deprecated" | "in-development" | "beta" | "experimental" | null;
+    })[];
+    operations: Record<string, {
+        id: string;
+        type: string;
+        channel: string;
+        version: string;
+        language: string;
+        url: string;
+        markdownUrl: string;
+        focusedContractUrl?: string;
+    }[]>;
+    relationships: (import("./cards.js").Relationship & {
+        variant: Variant;
+    })[];
+    redirects: {
+        from: string;
+        to: string;
+        markdownFrom: string;
+        markdownTo: string;
+        status: number;
+    }[];
+    apiSources: {
+        apiId: string;
+        channel: string;
+        version: string;
+        endpoint: string | null;
+        referenceUrl: string;
+        sourceUrl: string;
+        mediaType: string;
+    }[];
+    navigationTabs?: {
+        id: string;
+        label: string;
+        variant: Variant;
+        url: string;
+        markdownUrl: string;
+        indexUrl: string;
+    }[] | undefined;
+    dependencies: string[];
+    taxonomy?: import("./taxonomy.js").Taxonomy | undefined;
+    readerFacets?: Record<string, import("./reader-filters.js").ReaderFacet> | undefined;
+    sitemap?: string | undefined;
+    basePath: string;
+    searchSynonyms?: unknown[] | undefined;
+    schemaVersion: number;
+    configDigest: string;
+}>;