import { z } from 'zod';

declare const themeObjectSchema: z.ZodObject<{
    accent: z.ZodOptional<z.ZodString>;
    accentDark: z.ZodOptional<z.ZodString>;
    background: z.ZodOptional<z.ZodString>;
    density: z.ZodOptional<z.ZodEnum<{
        comfortable: "comfortable";
        compact: "compact";
    }>>;
    logo: z.ZodOptional<z.ZodString>;
    logoDark: z.ZodOptional<z.ZodString>;
    favicon: z.ZodOptional<z.ZodString>;
    defaultMode: z.ZodOptional<z.ZodEnum<{
        light: "light";
        dark: "dark";
        system: "system";
    }>>;
    strictMode: z.ZodOptional<z.ZodBoolean>;
}, z.core.$strip>;

declare const DOCUMENTATION_CONFIG_FILE = "documentation.json";
declare const DOCUMENTATION_MANIFEST_VERSION = 2;
type DocumentationAssistantAccess = 'disabled' | 'public' | 'authenticated';
type DocumentationMcpAccess = 'disabled' | 'public';
declare const DOCUMENTATION_CONTEXTUAL_ACTIONS: readonly ["copy", "view", "assistant", "chatgpt", "claude", "mcp", "add-mcp", "cursor", "vscode"];
type DocumentationContextualAction = (typeof DOCUMENTATION_CONTEXTUAL_ACTIONS)[number];
declare const DEFAULT_DOCUMENTATION_CONTEXTUAL_ACTIONS: readonly DocumentationContextualAction[];
interface DocumentationFontConfig {
    family: string;
    weight?: number | string;
    source?: string;
    format?: string;
}
/**
 * The `theme` object as authored in documentation.json — exactly the keys
 * the config schema accepts under `theme.*`, derived from that schema so
 * the two can never drift. Everything else (fonts, background decoration,
 * styling, logo href) is configured through the Mintlify-style top-level
 * keys and only exists on the resolved theme.
 */
type DocumentationThemeConfig = z.infer<typeof themeObjectSchema>;
/**
 * The fully resolved theme after config loading merges `theme.*` with the
 * Mintlify top-level keys (`colors`, `logo`, `favicon`, `appearance`,
 * `background`, `fonts`, `styling`). This is what the template and runtime
 * consume; it is an output shape, never accepted as `theme.*` input.
 */
interface ResolvedDocumentationTheme extends DocumentationThemeConfig {
    backgroundDark?: string;
    backgroundDecoration?: 'none' | 'gradient' | 'grid';
    bodyFont?: DocumentationFontConfig;
    headingFont?: DocumentationFontConfig;
    monoFont?: DocumentationFontConfig;
    codeBlockMode?: 'dark' | 'system';
    eyebrowStyle?: 'section' | 'breadcrumbs' | 'none';
    logoHref?: string;
}
interface DocumentationLinkConfig {
    label: string;
    href: string;
}
interface DocumentationNavGroup {
    group: string;
    pages: DocumentationNavigationItem[];
}
type DocumentationNavigationItem = string | DocumentationLinkConfig | DocumentationNavGroup;
declare const DOCUMENTATION_OPENAPI_SAMPLE_LANGUAGES: readonly ["curl", "javascript", "python", "go"];
type DocumentationOpenApiSampleLanguage = (typeof DOCUMENTATION_OPENAPI_SAMPLE_LANGUAGES)[number];
type DocumentationOpenApiSampleDefaults = 'required' | 'all';
interface DocumentationOpenApiExamplesConfig {
    languages: DocumentationOpenApiSampleLanguage[];
    defaults: DocumentationOpenApiSampleDefaults;
    autogenerate: boolean;
}
declare const DEFAULT_DOCUMENTATION_OPENAPI_EXAMPLES: {
    readonly languages: readonly ["curl", "python", "javascript", "go"];
    readonly defaults: "all";
    readonly autogenerate: true;
};
interface DocumentationOpenApiConfig {
    source: string;
    route?: string;
    label?: string;
    playground?: boolean;
    baseUrl?: string;
    examples?: DocumentationOpenApiExamplesConfig;
}
interface DocumentationAssistantConfig {
    access: DocumentationAssistantAccess;
    model?: string;
    suggestions?: string[];
}
interface DocumentationMcpConfig {
    access: DocumentationMcpAccess;
}
interface DocumentationContextualConfig {
    actions: DocumentationContextualAction[];
}
interface DocumentationSeoConfig {
    noindex?: boolean;
    ogImage?: string;
    metaTags?: Record<string, string>;
}
interface DocumentationConfig {
    $schema?: string;
    name: string;
    description?: string;
    source: string;
    output: string;
    url?: string;
    /** Explicit custom hostnames that mount this documentation at `/`. */
    domains: string[];
    theme: ResolvedDocumentationTheme;
    navigation?: DocumentationNavigationItem[];
    links: DocumentationLinkConfig[];
    footer: DocumentationLinkConfig[];
    redirects: Record<string, string>;
    openapi: DocumentationOpenApiConfig[];
    assistant: DocumentationAssistantConfig;
    mcp: DocumentationMcpConfig;
    contextual: DocumentationContextualConfig;
    seo: DocumentationSeoConfig;
}
interface DocumentationFrontmatter {
    title?: string;
    description?: string;
    slug?: string;
    hidden?: boolean;
    noindex?: boolean;
}
interface DocumentationHeading {
    depth: number;
    id: string;
    text: string;
}
interface DocumentationPage {
    sourcePath: string;
    relativePath: string;
    route: string;
    title: string;
    description?: string;
    hidden: boolean;
    noindex: boolean;
    markdown: string;
    html: string;
    text: string;
    headings: DocumentationHeading[];
    sourceFormat: 'markdown' | 'mdx' | 'generated';
    kind: 'page' | 'openapi';
    openapi?: DocumentationOpenApiOperation;
}
interface DocumentationNavigationPage {
    kind: 'page';
    route: string;
    label: string;
}
interface DocumentationNavigationLink {
    kind: 'link';
    href: string;
    label: string;
}
interface DocumentationNavigationGroup {
    kind: 'group';
    label: string;
    items: DocumentationNavigationNode[];
}
type DocumentationNavigationNode = DocumentationNavigationPage | DocumentationNavigationLink | DocumentationNavigationGroup;
interface DocumentationOpenApiParameter {
    name: string;
    in: string;
    required: boolean;
    description?: string;
    schema?: unknown;
    example?: unknown;
}
interface DocumentationOpenApiResponse {
    status: string;
    description: string;
    schema?: unknown;
}
interface DocumentationOpenApiCodeSample {
    language: string;
    label: string;
    syntax: string;
    code: string;
    generated: boolean;
}
interface DocumentationOpenApiOperation {
    method: string;
    path: string;
    operationId: string;
    summary: string;
    description?: string;
    tags: string[];
    parameters: DocumentationOpenApiParameter[];
    requestBody?: unknown;
    responses: DocumentationOpenApiResponse[];
    security?: unknown;
    baseUrl?: string;
    playground: boolean;
    codeSamples: DocumentationOpenApiCodeSample[];
}
interface DocumentationSearchEntry {
    route: string;
    title: string;
    description?: string;
    /** Carries ids so search can offer section results, not only whole pages. */
    headings: DocumentationHeading[];
    text: string;
}
interface DocumentationAssistantChunk {
    id: string;
    route: string;
    title: string;
    heading?: string;
    text: string;
}
interface DocumentationGraph {
    config: DocumentationConfig;
    pages: DocumentationPage[];
    navigation: DocumentationNavigationNode[];
    sourceHash: string;
}
interface DocumentationBuildManifest {
    version: typeof DOCUMENTATION_MANIFEST_VERSION;
    sourceHash: string;
    outputHash: string;
    /** Version of the `deepspace` package that compiled this output. */
    sdkVersion: string;
    name: string;
    pageCount: number;
    /** Authored pages plus configured redirect entry points. */
    routes: string[];
    /** Exact non-HTML artifacts that may be served from the public mount. */
    resources: string[];
    assistant: DocumentationAssistantConfig;
    mcp: DocumentationMcpConfig;
    domains: string[];
    /** Default public mount on the ordinary app hostname. */
    basePath: string;
}
interface DocumentationDiagnostic {
    code: string;
    message: string;
    file?: string;
    line?: number;
}
interface DocumentationValidationResult {
    appDir: string;
    configPath: string;
    sourceDir: string;
    outputDir: string;
    graph: DocumentationGraph;
    warnings: DocumentationDiagnostic[];
}
interface DocumentationBuildResult extends DocumentationValidationResult {
    manifest: DocumentationBuildManifest;
    files: string[];
}
interface DocumentationRuntimePageLink {
    route: string;
    title: string;
}
interface DocumentationRuntimePage {
    route: string;
    title: string;
    description?: string;
    html: string;
    headings: DocumentationHeading[];
    kind: DocumentationPage['kind'];
    markdownUrl: string;
    openapi?: DocumentationOpenApiOperation;
}
interface DocumentationRuntimeData {
    /** Public mount (`/docs` on an app host, empty on an explicit documentation domain). */
    basePath: string;
    config: Pick<DocumentationConfig, 'name' | 'description' | 'theme' | 'links' | 'footer' | 'assistant' | 'mcp' | 'contextual'>;
    page: DocumentationRuntimePage;
    navigation: DocumentationNavigationNode[];
    breadcrumbs: string[];
    previous?: DocumentationRuntimePageLink;
    next?: DocumentationRuntimePageLink;
}
type DocumentationRuntimeRouteData = Omit<DocumentationRuntimeData, 'config' | 'navigation'>;
/** Small per-route payload used by the hydrated documentation router. */
interface DocumentationRuntimeRouteDocument {
    canonical: string | null;
    data: DocumentationRuntimeRouteData;
    description: string | null;
    openGraph: Record<'og:title' | 'og:description' | 'og:url', string | null>;
    robots: string | null;
    title: string;
}
declare class DocumentationError extends Error {
    readonly code: string;
    readonly diagnostics: DocumentationDiagnostic[];
    constructor(message: string, code: string, diagnostics?: DocumentationDiagnostic[]);
}

interface BuildDocumentationOptions {
    appDir: string;
    outputDir?: string;
    baseUrl?: string;
    /** Public mount on the ordinary app host. Defaults to `/docs`. */
    basePath?: string;
}
declare function buildDocumentation(options: BuildDocumentationOptions): DocumentationBuildResult;

interface LoadedDocumentationConfig {
    config: DocumentationConfig;
    configPath: string;
    sourceDir: string;
    outputDir: string;
    raw: string;
    warnings: DocumentationDiagnostic[];
}
declare function loadDocumentationConfig(appDir: string): LoadedDocumentationConfig;

declare function validateDocumentation(appDir: string): DocumentationValidationResult;

/** Normalize and validate every public documentation route in one place. */
declare function normalizeRoute(value: string): string;
declare function routeFromRelativePath(relativePath: string): string;

declare function slugify(value: string): string;

interface ParsedMarkdown {
    frontmatter: DocumentationFrontmatter;
    markdown: string;
    html: string;
    text: string;
    headings: DocumentationHeading[];
}
declare function parseMarkdown(source: string, file: string): ParsedMarkdown;
declare function parseFrontmatter(source: string, file: string): {
    frontmatter: DocumentationFrontmatter;
    body: string;
};
declare function htmlToText(html: string): string;

declare const AGENT_SKILLS_SCHEMA = "https://schemas.agentskills.io/discovery/0.2.0/schema.json";
interface DocumentationSkillArtifacts {
    name: string;
    description: string;
    markdown: string;
    discoveryIndex: Record<string, unknown>;
}
/** Build one deterministic, installable skill from the same graph as the site. */
declare function createDocumentationSkillArtifacts(graph: DocumentationGraph, baseUrl?: string, basePath?: string): DocumentationSkillArtifacts;
declare function documentationSkillName(value: string): string;

interface DocumentationViteServer {
    restart(): Promise<void>;
    watcher: {
        add(paths: string[]): void;
        on(event: 'all', handler: (event: string, path: string) => void): void;
        on(event: 'ready', handler: () => void): void;
    };
    config: {
        logger: {
            info(message: string): void;
            error(message: string): void;
        };
    };
}
/**
 * Vite bridge for the app Worker's ASSETS binding.
 *
 * Both development and production write Vite's reserved public namespace so
 * the Cloudflare ASSETS binding has one identical source in both environments.
 * Documentation's feature metadata sets `run_worker_first = true`, leaving the
 * app Worker as the single router while binding reads bypass it as assets.
 */
declare function deepSpaceDocumentation(): {
    name: string;
    config(config: {
        root?: string;
    }, _environment: {
        command: 'build' | 'serve';
    }): {
        server: {
            watch: {
                ignored: string[];
            };
        };
    };
    configResolved(config: {
        root: string;
    }): void;
    configureServer(server: DocumentationViteServer): void;
};

export { AGENT_SKILLS_SCHEMA, type BuildDocumentationOptions, DEFAULT_DOCUMENTATION_CONTEXTUAL_ACTIONS, DEFAULT_DOCUMENTATION_OPENAPI_EXAMPLES, DOCUMENTATION_CONFIG_FILE, DOCUMENTATION_CONTEXTUAL_ACTIONS, DOCUMENTATION_MANIFEST_VERSION, DOCUMENTATION_OPENAPI_SAMPLE_LANGUAGES, type DocumentationAssistantAccess, type DocumentationAssistantChunk, type DocumentationAssistantConfig, type DocumentationBuildManifest, type DocumentationBuildResult, type DocumentationConfig, type DocumentationContextualAction, type DocumentationContextualConfig, type DocumentationDiagnostic, DocumentationError, type DocumentationFontConfig, type DocumentationFrontmatter, type DocumentationGraph, type DocumentationHeading, type DocumentationLinkConfig, type DocumentationMcpAccess, type DocumentationMcpConfig, type DocumentationNavGroup, type DocumentationNavigationGroup, type DocumentationNavigationItem, type DocumentationNavigationLink, type DocumentationNavigationNode, type DocumentationNavigationPage, type DocumentationOpenApiCodeSample, type DocumentationOpenApiConfig, type DocumentationOpenApiExamplesConfig, type DocumentationOpenApiOperation, type DocumentationOpenApiParameter, type DocumentationOpenApiResponse, type DocumentationOpenApiSampleDefaults, type DocumentationOpenApiSampleLanguage, type DocumentationPage, type DocumentationRuntimeData, type DocumentationRuntimePage, type DocumentationRuntimePageLink, type DocumentationRuntimeRouteData, type DocumentationRuntimeRouteDocument, type DocumentationSearchEntry, type DocumentationSeoConfig, type DocumentationSkillArtifacts, type DocumentationThemeConfig, type DocumentationValidationResult, type LoadedDocumentationConfig, type ResolvedDocumentationTheme, buildDocumentation, createDocumentationSkillArtifacts, deepSpaceDocumentation, documentationSkillName, htmlToText, loadDocumentationConfig, normalizeRoute, parseFrontmatter, parseMarkdown, routeFromRelativePath, slugify, validateDocumentation };