import { ReactNode, ReactElement, ComponentType } from 'react';
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>;

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];
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;
}
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 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 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;
}

interface DocumentationAppProps {
    data: DocumentationRuntimeData;
    /** Rendered page body. Omit children to use the compiler's static HTML. */
    children?: ReactNode;
    navigating?: boolean;
    onNavigate?: (href: string) => void;
    onPrefetch?: (href: string) => void;
}
declare function DocumentationApp({ data, children, navigating, onNavigate, }: DocumentationAppProps): ReactElement;

interface TitledProps {
    children?: ReactNode;
    label?: string;
    title?: string;
}
declare function Note(props: TitledProps): ReactElement;
declare function Tip(props: TitledProps): ReactElement;
declare function Warning(props: TitledProps): ReactElement;
declare function Info(props: TitledProps): ReactElement;
declare function Card({ children, href, label, title }: TitledProps & {
    href?: string;
}): ReactElement;
declare function Accordion({ children, label, title }: TitledProps): ReactElement;
declare function AccordionGroup({ children }: TitledProps): ReactElement;
declare function Step({ children, label, title }: TitledProps): ReactElement;
declare function Steps({ children }: TitledProps): ReactElement;
declare function Tab({ children, label, title }: TitledProps): ReactElement;
declare function Tabs({ children }: TitledProps): ReactElement;
declare function CodeGroup({ children, label, title }: TitledProps): ReactElement;

type DocumentationPageComponent = ComponentType<{
    components?: Record<string, ComponentType<never>>;
}>;
interface DocumentationSiteProps extends DocumentationAppProps {
    /** The current compiled Markdown or MDX page. */
    children: ReactNode;
}
type DocumentationSiteComponent = ComponentType<DocumentationSiteProps>;
/** The polished SDK-owned documentation shell. */
declare const DefaultDocumentation: typeof DocumentationApp;
/**
 * The prose subtree has exactly one writer, and `data-prose` names it. `react`
 * means the reconciler owns every node inside and only React components may
 * enhance it; `html` means the compiler's markup owns it and the article's
 * imperative pass may enhance it. Nothing may write across that line — moving a
 * React-owned node out from under its fiber makes the next route swap fail with
 * `removeChild ... not a child of this node`.
 */
declare function DocumentationContent({ data, Page, }: {
    data: DocumentationRuntimeData;
    Page?: DocumentationPageComponent;
}): ReactElement;

export { Accordion as A, Card as C, type DocumentationRuntimeData as D, Info as I, Note as N, Step as S, Tab as T, Warning as W, type DocumentationPageComponent as a, type DocumentationSiteComponent as b, AccordionGroup as c, CodeGroup as d, DefaultDocumentation as e, DocumentationApp as f, type DocumentationAppProps as g, DocumentationContent as h, type DocumentationSiteProps as i, Steps as j, Tabs as k, Tip as l };