import { z } from 'zod';
import * as react_jsx_runtime from 'react/jsx-runtime';
import React from 'react';

declare const LacStatusSchema: z.ZodEnum<["draft", "active", "frozen", "deprecated"]>;
declare const LacNodeSchema: z.ZodObject<{
    id: z.ZodString;
    type: z.ZodString;
    title: z.ZodString;
    status: z.ZodEnum<["draft", "active", "frozen", "deprecated"]>;
    domain: z.ZodString;
    schemaVersion: z.ZodLiteral<2>;
    priority: z.ZodOptional<z.ZodNumber>;
    tags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    owner: z.ZodOptional<z.ZodString>;
    jira: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>>;
    parent: z.ZodOptional<z.ZodString>;
    children: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    blockedBy: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    enables: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    references: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    supersedes: z.ZodOptional<z.ZodString>;
    supersededBy: z.ZodOptional<z.ZodString>;
    fixes: z.ZodOptional<z.ZodString>;
    resolvedInto: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    statusHistory: z.ZodOptional<z.ZodArray<z.ZodObject<{
        from: z.ZodEnum<["draft", "active", "frozen", "deprecated"]>;
        to: z.ZodEnum<["draft", "active", "frozen", "deprecated"]>;
        date: z.ZodString;
        reason: z.ZodOptional<z.ZodString>;
    }, "strip", z.ZodTypeAny, {
        from: "draft" | "active" | "frozen" | "deprecated";
        to: "draft" | "active" | "frozen" | "deprecated";
        date: string;
        reason?: string | undefined;
    }, {
        from: "draft" | "active" | "frozen" | "deprecated";
        to: "draft" | "active" | "frozen" | "deprecated";
        date: string;
        reason?: string | undefined;
    }>, "many">>;
    annotations: z.ZodOptional<z.ZodArray<z.ZodObject<{
        id: z.ZodString;
        author: z.ZodString;
        date: z.ZodString;
        type: z.ZodString;
        body: z.ZodString;
    }, "strip", z.ZodTypeAny, {
        date: string;
        type: string;
        id: string;
        author: string;
        body: string;
    }, {
        date: string;
        type: string;
        id: string;
        author: string;
        body: string;
    }>, "many">>;
    fieldLocks: z.ZodOptional<z.ZodArray<z.ZodObject<{
        field: z.ZodString;
        lockedAt: z.ZodString;
        lockedBy: z.ZodString;
        reason: z.ZodOptional<z.ZodString>;
    }, "strip", z.ZodTypeAny, {
        field: string;
        lockedAt: string;
        lockedBy: string;
        reason?: string | undefined;
    }, {
        field: string;
        lockedAt: string;
        lockedBy: string;
        reason?: string | undefined;
    }>, "many">>;
    nodeLocked: z.ZodOptional<z.ZodBoolean>;
    views: z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnknown>>;
}, "strip", z.ZodTypeAny, {
    type: string;
    status: "draft" | "active" | "frozen" | "deprecated";
    id: string;
    title: string;
    domain: string;
    schemaVersion: 2;
    views: Record<string, Record<string, unknown>>;
    priority?: number | undefined;
    tags?: string[] | undefined;
    owner?: string | undefined;
    jira?: string | string[] | undefined;
    parent?: string | undefined;
    children?: string[] | undefined;
    blockedBy?: string[] | undefined;
    enables?: string[] | undefined;
    references?: string[] | undefined;
    supersedes?: string | undefined;
    supersededBy?: string | undefined;
    fixes?: string | undefined;
    resolvedInto?: string[] | undefined;
    statusHistory?: {
        from: "draft" | "active" | "frozen" | "deprecated";
        to: "draft" | "active" | "frozen" | "deprecated";
        date: string;
        reason?: string | undefined;
    }[] | undefined;
    annotations?: {
        date: string;
        type: string;
        id: string;
        author: string;
        body: string;
    }[] | undefined;
    fieldLocks?: {
        field: string;
        lockedAt: string;
        lockedBy: string;
        reason?: string | undefined;
    }[] | undefined;
    nodeLocked?: boolean | undefined;
}, {
    type: string;
    status: "draft" | "active" | "frozen" | "deprecated";
    id: string;
    title: string;
    domain: string;
    schemaVersion: 2;
    views: Record<string, Record<string, unknown>>;
    priority?: number | undefined;
    tags?: string[] | undefined;
    owner?: string | undefined;
    jira?: string | string[] | undefined;
    parent?: string | undefined;
    children?: string[] | undefined;
    blockedBy?: string[] | undefined;
    enables?: string[] | undefined;
    references?: string[] | undefined;
    supersedes?: string | undefined;
    supersededBy?: string | undefined;
    fixes?: string | undefined;
    resolvedInto?: string[] | undefined;
    statusHistory?: {
        from: "draft" | "active" | "frozen" | "deprecated";
        to: "draft" | "active" | "frozen" | "deprecated";
        date: string;
        reason?: string | undefined;
    }[] | undefined;
    annotations?: {
        date: string;
        type: string;
        id: string;
        author: string;
        body: string;
    }[] | undefined;
    fieldLocks?: {
        field: string;
        lockedAt: string;
        lockedBy: string;
        reason?: string | undefined;
    }[] | undefined;
    nodeLocked?: boolean | undefined;
}>;
declare const LacGraphSchema: z.ZodObject<{
    schemaVersion: z.ZodLiteral<2>;
    project: z.ZodString;
    generated: z.ZodString;
    nodes: z.ZodArray<z.ZodObject<{
        id: z.ZodString;
        type: z.ZodString;
        title: z.ZodString;
        status: z.ZodEnum<["draft", "active", "frozen", "deprecated"]>;
        domain: z.ZodString;
        schemaVersion: z.ZodLiteral<2>;
        priority: z.ZodOptional<z.ZodNumber>;
        tags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
        owner: z.ZodOptional<z.ZodString>;
        jira: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>>;
        parent: z.ZodOptional<z.ZodString>;
        children: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
        blockedBy: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
        enables: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
        references: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
        supersedes: z.ZodOptional<z.ZodString>;
        supersededBy: z.ZodOptional<z.ZodString>;
        fixes: z.ZodOptional<z.ZodString>;
        resolvedInto: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
        statusHistory: z.ZodOptional<z.ZodArray<z.ZodObject<{
            from: z.ZodEnum<["draft", "active", "frozen", "deprecated"]>;
            to: z.ZodEnum<["draft", "active", "frozen", "deprecated"]>;
            date: z.ZodString;
            reason: z.ZodOptional<z.ZodString>;
        }, "strip", z.ZodTypeAny, {
            from: "draft" | "active" | "frozen" | "deprecated";
            to: "draft" | "active" | "frozen" | "deprecated";
            date: string;
            reason?: string | undefined;
        }, {
            from: "draft" | "active" | "frozen" | "deprecated";
            to: "draft" | "active" | "frozen" | "deprecated";
            date: string;
            reason?: string | undefined;
        }>, "many">>;
        annotations: z.ZodOptional<z.ZodArray<z.ZodObject<{
            id: z.ZodString;
            author: z.ZodString;
            date: z.ZodString;
            type: z.ZodString;
            body: z.ZodString;
        }, "strip", z.ZodTypeAny, {
            date: string;
            type: string;
            id: string;
            author: string;
            body: string;
        }, {
            date: string;
            type: string;
            id: string;
            author: string;
            body: string;
        }>, "many">>;
        fieldLocks: z.ZodOptional<z.ZodArray<z.ZodObject<{
            field: z.ZodString;
            lockedAt: z.ZodString;
            lockedBy: z.ZodString;
            reason: z.ZodOptional<z.ZodString>;
        }, "strip", z.ZodTypeAny, {
            field: string;
            lockedAt: string;
            lockedBy: string;
            reason?: string | undefined;
        }, {
            field: string;
            lockedAt: string;
            lockedBy: string;
            reason?: string | undefined;
        }>, "many">>;
        nodeLocked: z.ZodOptional<z.ZodBoolean>;
        views: z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnknown>>;
    }, "strip", z.ZodTypeAny, {
        type: string;
        status: "draft" | "active" | "frozen" | "deprecated";
        id: string;
        title: string;
        domain: string;
        schemaVersion: 2;
        views: Record<string, Record<string, unknown>>;
        priority?: number | undefined;
        tags?: string[] | undefined;
        owner?: string | undefined;
        jira?: string | string[] | undefined;
        parent?: string | undefined;
        children?: string[] | undefined;
        blockedBy?: string[] | undefined;
        enables?: string[] | undefined;
        references?: string[] | undefined;
        supersedes?: string | undefined;
        supersededBy?: string | undefined;
        fixes?: string | undefined;
        resolvedInto?: string[] | undefined;
        statusHistory?: {
            from: "draft" | "active" | "frozen" | "deprecated";
            to: "draft" | "active" | "frozen" | "deprecated";
            date: string;
            reason?: string | undefined;
        }[] | undefined;
        annotations?: {
            date: string;
            type: string;
            id: string;
            author: string;
            body: string;
        }[] | undefined;
        fieldLocks?: {
            field: string;
            lockedAt: string;
            lockedBy: string;
            reason?: string | undefined;
        }[] | undefined;
        nodeLocked?: boolean | undefined;
    }, {
        type: string;
        status: "draft" | "active" | "frozen" | "deprecated";
        id: string;
        title: string;
        domain: string;
        schemaVersion: 2;
        views: Record<string, Record<string, unknown>>;
        priority?: number | undefined;
        tags?: string[] | undefined;
        owner?: string | undefined;
        jira?: string | string[] | undefined;
        parent?: string | undefined;
        children?: string[] | undefined;
        blockedBy?: string[] | undefined;
        enables?: string[] | undefined;
        references?: string[] | undefined;
        supersedes?: string | undefined;
        supersededBy?: string | undefined;
        fixes?: string | undefined;
        resolvedInto?: string[] | undefined;
        statusHistory?: {
            from: "draft" | "active" | "frozen" | "deprecated";
            to: "draft" | "active" | "frozen" | "deprecated";
            date: string;
            reason?: string | undefined;
        }[] | undefined;
        annotations?: {
            date: string;
            type: string;
            id: string;
            author: string;
            body: string;
        }[] | undefined;
        fieldLocks?: {
            field: string;
            lockedAt: string;
            lockedBy: string;
            reason?: string | undefined;
        }[] | undefined;
        nodeLocked?: boolean | undefined;
    }>, "many">;
    edges: z.ZodArray<z.ZodObject<{
        from: z.ZodString;
        to: z.ZodString;
        type: z.ZodString;
    }, "strip", z.ZodTypeAny, {
        from: string;
        to: string;
        type: string;
    }, {
        from: string;
        to: string;
        type: string;
    }>, "many">;
    meta: z.ZodObject<{
        counts: z.ZodObject<{
            nodes: z.ZodNumber;
            edges: z.ZodNumber;
        }, "strip", z.ZodTypeAny, {
            nodes: number;
            edges: number;
        }, {
            nodes: number;
            edges: number;
        }>;
        domains: z.ZodArray<z.ZodString, "many">;
    }, "strip", z.ZodTypeAny, {
        counts: {
            nodes: number;
            edges: number;
        };
        domains: string[];
    }, {
        counts: {
            nodes: number;
            edges: number;
        };
        domains: string[];
    }>;
}, "strip", z.ZodTypeAny, {
    schemaVersion: 2;
    project: string;
    generated: string;
    nodes: {
        type: string;
        status: "draft" | "active" | "frozen" | "deprecated";
        id: string;
        title: string;
        domain: string;
        schemaVersion: 2;
        views: Record<string, Record<string, unknown>>;
        priority?: number | undefined;
        tags?: string[] | undefined;
        owner?: string | undefined;
        jira?: string | string[] | undefined;
        parent?: string | undefined;
        children?: string[] | undefined;
        blockedBy?: string[] | undefined;
        enables?: string[] | undefined;
        references?: string[] | undefined;
        supersedes?: string | undefined;
        supersededBy?: string | undefined;
        fixes?: string | undefined;
        resolvedInto?: string[] | undefined;
        statusHistory?: {
            from: "draft" | "active" | "frozen" | "deprecated";
            to: "draft" | "active" | "frozen" | "deprecated";
            date: string;
            reason?: string | undefined;
        }[] | undefined;
        annotations?: {
            date: string;
            type: string;
            id: string;
            author: string;
            body: string;
        }[] | undefined;
        fieldLocks?: {
            field: string;
            lockedAt: string;
            lockedBy: string;
            reason?: string | undefined;
        }[] | undefined;
        nodeLocked?: boolean | undefined;
    }[];
    edges: {
        from: string;
        to: string;
        type: string;
    }[];
    meta: {
        counts: {
            nodes: number;
            edges: number;
        };
        domains: string[];
    };
}, {
    schemaVersion: 2;
    project: string;
    generated: string;
    nodes: {
        type: string;
        status: "draft" | "active" | "frozen" | "deprecated";
        id: string;
        title: string;
        domain: string;
        schemaVersion: 2;
        views: Record<string, Record<string, unknown>>;
        priority?: number | undefined;
        tags?: string[] | undefined;
        owner?: string | undefined;
        jira?: string | string[] | undefined;
        parent?: string | undefined;
        children?: string[] | undefined;
        blockedBy?: string[] | undefined;
        enables?: string[] | undefined;
        references?: string[] | undefined;
        supersedes?: string | undefined;
        supersededBy?: string | undefined;
        fixes?: string | undefined;
        resolvedInto?: string[] | undefined;
        statusHistory?: {
            from: "draft" | "active" | "frozen" | "deprecated";
            to: "draft" | "active" | "frozen" | "deprecated";
            date: string;
            reason?: string | undefined;
        }[] | undefined;
        annotations?: {
            date: string;
            type: string;
            id: string;
            author: string;
            body: string;
        }[] | undefined;
        fieldLocks?: {
            field: string;
            lockedAt: string;
            lockedBy: string;
            reason?: string | undefined;
        }[] | undefined;
        nodeLocked?: boolean | undefined;
    }[];
    edges: {
        from: string;
        to: string;
        type: string;
    }[];
    meta: {
        counts: {
            nodes: number;
            edges: number;
        };
        domains: string[];
    };
}>;
declare const LacIndexSchema: z.ZodObject<{
    schemaVersion: z.ZodLiteral<2>;
    project: z.ZodString;
    generated: z.ZodString;
    nodes: z.ZodArray<z.ZodObject<{
        id: z.ZodString;
        type: z.ZodString;
        title: z.ZodString;
        status: z.ZodEnum<["draft", "active", "frozen", "deprecated"]>;
        domain: z.ZodString;
        priority: z.ZodOptional<z.ZodNumber>;
        tags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    }, "strip", z.ZodTypeAny, {
        type: string;
        status: "draft" | "active" | "frozen" | "deprecated";
        id: string;
        title: string;
        domain: string;
        priority?: number | undefined;
        tags?: string[] | undefined;
    }, {
        type: string;
        status: "draft" | "active" | "frozen" | "deprecated";
        id: string;
        title: string;
        domain: string;
        priority?: number | undefined;
        tags?: string[] | undefined;
    }>, "many">;
}, "strip", z.ZodTypeAny, {
    schemaVersion: 2;
    project: string;
    generated: string;
    nodes: {
        type: string;
        status: "draft" | "active" | "frozen" | "deprecated";
        id: string;
        title: string;
        domain: string;
        priority?: number | undefined;
        tags?: string[] | undefined;
    }[];
}, {
    schemaVersion: 2;
    project: string;
    generated: string;
    nodes: {
        type: string;
        status: "draft" | "active" | "frozen" | "deprecated";
        id: string;
        title: string;
        domain: string;
        priority?: number | undefined;
        tags?: string[] | undefined;
    }[];
}>;
declare const LacConfigSchema: z.ZodObject<{
    schemaVersion: z.ZodLiteral<2>;
    project: z.ZodString;
    extends: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    types: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
        id: z.ZodString;
        label: z.ZodString;
        class: z.ZodEnum<["permanent", "absorbing"]>;
        description: z.ZodOptional<z.ZodString>;
        defaultStatus: z.ZodOptional<z.ZodEnum<["draft", "active", "frozen", "deprecated"]>>;
        requiredViews: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
        statusTransitions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodEnum<["draft", "active", "frozen", "deprecated"]>, "many">>>;
    }, "strip", z.ZodTypeAny, {
        id: string;
        label: string;
        class: "permanent" | "absorbing";
        description?: string | undefined;
        defaultStatus?: "draft" | "active" | "frozen" | "deprecated" | undefined;
        requiredViews?: string[] | undefined;
        statusTransitions?: Record<string, ("draft" | "active" | "frozen" | "deprecated")[]> | undefined;
    }, {
        id: string;
        label: string;
        class: "permanent" | "absorbing";
        description?: string | undefined;
        defaultStatus?: "draft" | "active" | "frozen" | "deprecated" | undefined;
        requiredViews?: string[] | undefined;
        statusTransitions?: Record<string, ("draft" | "active" | "frozen" | "deprecated")[]> | undefined;
    }>>>;
    views: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
        id: z.ZodString;
        label: z.ZodString;
        description: z.ZodOptional<z.ZodString>;
        fields: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
            type: z.ZodString;
            label: z.ZodString;
            required: z.ZodOptional<z.ZodBoolean>;
            prose: z.ZodOptional<z.ZodBoolean>;
        }, "strip", z.ZodTypeAny, {
            type: string;
            label: string;
            required?: boolean | undefined;
            prose?: boolean | undefined;
        }, {
            type: string;
            label: string;
            required?: boolean | undefined;
            prose?: boolean | undefined;
        }>>>;
    }, "strip", z.ZodTypeAny, {
        id: string;
        label: string;
        description?: string | undefined;
        fields?: Record<string, {
            type: string;
            label: string;
            required?: boolean | undefined;
            prose?: boolean | undefined;
        }> | undefined;
    }, {
        id: string;
        label: string;
        description?: string | undefined;
        fields?: Record<string, {
            type: string;
            label: string;
            required?: boolean | undefined;
            prose?: boolean | undefined;
        }> | undefined;
    }>>>;
    index: z.ZodOptional<z.ZodObject<{
        summaryFields: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
        searchFields: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    }, "strip", z.ZodTypeAny, {
        summaryFields?: string[] | undefined;
        searchFields?: string[] | undefined;
    }, {
        summaryFields?: string[] | undefined;
        searchFields?: string[] | undefined;
    }>>;
    hub: z.ZodOptional<z.ZodObject<{
        defaultView: z.ZodOptional<z.ZodString>;
        defaultTab: z.ZodOptional<z.ZodString>;
        accentColor: z.ZodOptional<z.ZodString>;
    }, "strip", z.ZodTypeAny, {
        defaultView?: string | undefined;
        defaultTab?: string | undefined;
        accentColor?: string | undefined;
    }, {
        defaultView?: string | undefined;
        defaultTab?: string | undefined;
        accentColor?: string | undefined;
    }>>;
}, "strip", z.ZodTypeAny, {
    schemaVersion: 2;
    views: Record<string, {
        id: string;
        label: string;
        description?: string | undefined;
        fields?: Record<string, {
            type: string;
            label: string;
            required?: boolean | undefined;
            prose?: boolean | undefined;
        }> | undefined;
    }>;
    project: string;
    types: Record<string, {
        id: string;
        label: string;
        class: "permanent" | "absorbing";
        description?: string | undefined;
        defaultStatus?: "draft" | "active" | "frozen" | "deprecated" | undefined;
        requiredViews?: string[] | undefined;
        statusTransitions?: Record<string, ("draft" | "active" | "frozen" | "deprecated")[]> | undefined;
    }>;
    extends?: string[] | undefined;
    index?: {
        summaryFields?: string[] | undefined;
        searchFields?: string[] | undefined;
    } | undefined;
    hub?: {
        defaultView?: string | undefined;
        defaultTab?: string | undefined;
        accentColor?: string | undefined;
    } | undefined;
}, {
    schemaVersion: 2;
    project: string;
    views?: Record<string, {
        id: string;
        label: string;
        description?: string | undefined;
        fields?: Record<string, {
            type: string;
            label: string;
            required?: boolean | undefined;
            prose?: boolean | undefined;
        }> | undefined;
    }> | undefined;
    extends?: string[] | undefined;
    types?: Record<string, {
        id: string;
        label: string;
        class: "permanent" | "absorbing";
        description?: string | undefined;
        defaultStatus?: "draft" | "active" | "frozen" | "deprecated" | undefined;
        requiredViews?: string[] | undefined;
        statusTransitions?: Record<string, ("draft" | "active" | "frozen" | "deprecated")[]> | undefined;
    }> | undefined;
    index?: {
        summaryFields?: string[] | undefined;
        searchFields?: string[] | undefined;
    } | undefined;
    hub?: {
        defaultView?: string | undefined;
        defaultTab?: string | undefined;
        accentColor?: string | undefined;
    } | undefined;
}>;
type LacStatus = z.infer<typeof LacStatusSchema>;
type LacNode = z.infer<typeof LacNodeSchema>;
type LacGraph = z.infer<typeof LacGraphSchema>;
type LacIndex = z.infer<typeof LacIndexSchema>;
type LacConfig = z.infer<typeof LacConfigSchema>;

interface LacDataExport {
    graph: LacGraph;
    index: LacIndex;
}

interface LacTheme {
    bg: string;
    surface: string;
    surfaceHover: string;
    border: string;
    text: string;
    textMuted: string;
    accent: string;
    accentBg: string;
    fontFamily: string;
    fontMono: string;
    borderRadius: string;
    borderRadiusSm: string;
}
type LacThemeMode = 'dark' | 'light' | 'system';
declare const DARK_THEME: LacTheme;
declare const LIGHT_THEME: LacTheme;
declare function resolveTheme(mode: LacThemeMode, overrides?: Partial<LacTheme>): LacTheme;

interface LacContextValue {
    graph: LacGraph | null;
    loading: boolean;
    error: string | null;
    theme: LacTheme;
    refetch: () => void;
}
interface LacDataProviderProps {
    dataUrl?: string;
    data?: LacGraph;
    children: React.ReactNode;
    theme?: LacThemeMode | Partial<LacTheme>;
    themeOverrides?: Partial<LacTheme>;
}
declare function LacDataProvider({ dataUrl, data: inlineData, children, theme, themeOverrides }: LacDataProviderProps): react_jsx_runtime.JSX.Element;
declare function useLacContext(): LacContextValue;

declare function useLacData(): {
    graph: {
        schemaVersion: 2;
        project: string;
        generated: string;
        nodes: {
            type: string;
            status: "draft" | "active" | "frozen" | "deprecated";
            id: string;
            title: string;
            domain: string;
            schemaVersion: 2;
            views: Record<string, Record<string, unknown>>;
            priority?: number | undefined;
            tags?: string[] | undefined;
            owner?: string | undefined;
            jira?: string | string[] | undefined;
            parent?: string | undefined;
            children?: string[] | undefined;
            blockedBy?: string[] | undefined;
            enables?: string[] | undefined;
            references?: string[] | undefined;
            supersedes?: string | undefined;
            supersededBy?: string | undefined;
            fixes?: string | undefined;
            resolvedInto?: string[] | undefined;
            statusHistory?: {
                from: "draft" | "active" | "frozen" | "deprecated";
                to: "draft" | "active" | "frozen" | "deprecated";
                date: string;
                reason?: string | undefined;
            }[] | undefined;
            annotations?: {
                date: string;
                type: string;
                id: string;
                author: string;
                body: string;
            }[] | undefined;
            fieldLocks?: {
                field: string;
                lockedAt: string;
                lockedBy: string;
                reason?: string | undefined;
            }[] | undefined;
            nodeLocked?: boolean | undefined;
        }[];
        edges: {
            from: string;
            to: string;
            type: string;
        }[];
        meta: {
            counts: {
                nodes: number;
                edges: number;
            };
            domains: string[];
        };
    } | null;
    nodes: {
        type: string;
        status: "draft" | "active" | "frozen" | "deprecated";
        id: string;
        title: string;
        domain: string;
        schemaVersion: 2;
        views: Record<string, Record<string, unknown>>;
        priority?: number | undefined;
        tags?: string[] | undefined;
        owner?: string | undefined;
        jira?: string | string[] | undefined;
        parent?: string | undefined;
        children?: string[] | undefined;
        blockedBy?: string[] | undefined;
        enables?: string[] | undefined;
        references?: string[] | undefined;
        supersedes?: string | undefined;
        supersededBy?: string | undefined;
        fixes?: string | undefined;
        resolvedInto?: string[] | undefined;
        statusHistory?: {
            from: "draft" | "active" | "frozen" | "deprecated";
            to: "draft" | "active" | "frozen" | "deprecated";
            date: string;
            reason?: string | undefined;
        }[] | undefined;
        annotations?: {
            date: string;
            type: string;
            id: string;
            author: string;
            body: string;
        }[] | undefined;
        fieldLocks?: {
            field: string;
            lockedAt: string;
            lockedBy: string;
            reason?: string | undefined;
        }[] | undefined;
        nodeLocked?: boolean | undefined;
    }[];
    edges: {
        from: string;
        to: string;
        type: string;
    }[];
    domains: string[];
    loading: boolean;
    error: string | null;
    theme: LacTheme;
    refetch: () => void;
};
declare function useLacNode(id: string): LacNode | undefined;
declare function useLacNodesByType(type: string): LacNode[];
declare function useLacNodesByStatus(status: LacStatus): LacNode[];
declare function useLacNodesByDomain(domain: string): LacNode[];
declare function useLacSearch(query: string): LacNode[];
declare function useLacSprint(): LacNode[];
declare function useLacNodeWithParent(id: string): {
    node: LacNode | undefined;
    parent: LacNode | undefined;
};
declare function useLacSuccessCriteria(): LacNode[];

type HubTab = 'sprint' | 'guide' | 'decisions' | 'success' | 'search';
interface LacHubProps {
    dataUrl?: string;
    data?: LacGraph;
    defaultTab?: HubTab;
    theme?: LacThemeMode | Partial<LacTheme>;
    themeOverrides?: Partial<LacTheme>;
    guideUrl?: string;
    style?: React.CSSProperties;
    fullscreen?: boolean;
}
declare function LacHub({ dataUrl, data, defaultTab, theme, themeOverrides, guideUrl, style, fullscreen }: LacHubProps): react_jsx_runtime.JSX.Element;

interface LacFeatureCardProps {
    node: LacNode;
    theme: LacTheme;
    defaultView?: string;
    onClose?: () => void;
    style?: React.CSSProperties;
    nodeIndex?: Map<string, LacNode>;
    onNodeRequest?: (id: string) => void;
    onFileOpen?: (path: string) => void;
    onSave?: (id: string, domain: string, fields: Record<string, unknown>) => Promise<void>;
    typeIcons?: Record<string, string>;
}
declare function LacFeatureCard({ node, theme: t, defaultView, onClose, style, nodeIndex, onNodeRequest, onFileOpen, onSave, typeIcons }: LacFeatureCardProps): react_jsx_runtime.JSX.Element;

interface LacSprintBoardProps {
    theme?: LacTheme;
    domains?: string[];
    onNodeClick?: (node: LacNode) => void;
}
declare function LacSprintBoard({ theme: propTheme, domains, onNodeClick }: LacSprintBoardProps): react_jsx_runtime.JSX.Element;

interface LacDecisionLogProps {
    theme?: LacTheme;
    onNodeClick?: (node: LacNode) => void;
}
declare function LacDecisionLog({ theme: propTheme, onNodeClick }: LacDecisionLogProps): react_jsx_runtime.JSX.Element;

interface LacSuccessBoardProps {
    theme?: LacTheme;
    onNodeClick?: (node: LacNode) => void;
}
declare function LacSuccessBoard({ theme: propTheme, onNodeClick }: LacSuccessBoardProps): react_jsx_runtime.JSX.Element;

interface LacSearchProps {
    theme?: LacTheme;
    placeholder?: string;
    onNodeClick?: (node: LacNode) => void;
    autoFocus?: boolean;
    value?: string;
    onChange?: (query: string) => void;
}
declare function LacSearch({ theme: propTheme, placeholder, onNodeClick, autoFocus, value: controlled, onChange: onChangeProp }: LacSearchProps): react_jsx_runtime.JSX.Element;

interface LacGuideProps {
    theme?: LacTheme;
    onNodeClick?: (node: LacNode) => void;
}
declare function LacGuide({ theme: propTheme, onNodeClick }: LacGuideProps): react_jsx_runtime.JSX.Element;

interface LacHelpPanelProps {
    nodeId?: string;
    query?: string;
    theme?: LacTheme;
    open?: boolean;
    onClose?: () => void;
    position?: 'inline' | 'right' | 'bottom';
    style?: React.CSSProperties;
}
declare function LacHelpPanel({ nodeId, query, theme: propTheme, open, onClose, position, style }: LacHelpPanelProps): react_jsx_runtime.JSX.Element | null;

type LacNodeFieldAs = 'prose' | 'list' | 'code' | 'badge' | 'raw';
interface LacNodeFieldProps {
    /** The node object (use useLacNode to get it) */
    node: LacNode;
    /** Dot-path to the field, e.g. "views.user.userGuide" or "views.dev.componentFile" */
    field: string;
    /** How to render the value. Defaults to auto-detect (list → bullets, string → prose) */
    as?: LacNodeFieldAs;
    /** Show a label above the value */
    label?: string;
    /** Style overrides on the wrapper */
    style?: React.CSSProperties;
    textColor?: string;
    mutedColor?: string;
    accentColor?: string;
    fontSize?: string;
}
declare function LacNodeField({ node, field, as, label, style, textColor, mutedColor, accentColor, fontSize, }: LacNodeFieldProps): react_jsx_runtime.JSX.Element | null;

type AudienceRole = 'user' | 'dev' | 'support' | 'product' | 'tester';
declare const ROLE_META: Record<AudienceRole, {
    label: string;
    description: string;
    emoji: string;
}>;
interface LacRoleViewProps {
    role: AudienceRole;
    /** Filter nodes to specific domains */
    domain?: string | string[];
    /** Override which node types to show (overrides role default) */
    nodeTypes?: string[];
    /** Show a role picker above the content */
    showRolePicker?: boolean;
    onRoleChange?: (role: AudienceRole) => void;
    /** Layout variant */
    layout?: 'accordion' | 'cards' | 'flat';
    /** Empty state message */
    emptyMessage?: string;
    style?: React.CSSProperties;
    /** Colors — defaults to a clean light theme so it works in any app */
    colors?: {
        bg?: string;
        surface?: string;
        border?: string;
        text?: string;
        muted?: string;
        accent?: string;
        sectionHeading?: string;
    };
}
declare function LacRoleView({ role, domain, nodeTypes: nodeTypesOverride, showRolePicker, onRoleChange, layout, emptyMessage, style, colors, }: LacRoleViewProps): react_jsx_runtime.JSX.Element;
interface LacRoleSwitcherProps {
    value: AudienceRole;
    onChange: (role: AudienceRole) => void;
    style?: React.CSSProperties;
    colors?: LacRoleViewProps['colors'];
}
declare function LacRoleSwitcher({ value, onChange, style, colors }: LacRoleSwitcherProps): react_jsx_runtime.JSX.Element;

interface LacHelpButtonProps {
    /** Node ID to show help for */
    nodeId: string;
    /** Which audience lens to show. Defaults to 'user' */
    role?: AudienceRole;
    /** Allow switching roles inside the drawer */
    allowRoleSwitch?: boolean;
    /** Button label. Defaults to "?" */
    label?: string | React.ReactNode;
    /** 'fixed' positions in corner of viewport; 'inline' renders as a normal button */
    position?: 'fixed' | 'inline';
    style?: React.CSSProperties;
    colors?: {
        bg?: string;
        surface?: string;
        border?: string;
        text?: string;
        muted?: string;
        accent?: string;
        buttonBg?: string;
        buttonText?: string;
        overlay?: string;
    };
}
declare function LacHelpButton({ nodeId, role: initialRole, allowRoleSwitch, label, position, style, colors, }: LacHelpButtonProps): react_jsx_runtime.JSX.Element | null;

interface LacAboutProps {
    /**
     * Default audience role. Pass `showRoleSwitcher` to let the viewer pick.
     * Defaults to 'user' — the grandparent-readable view.
     */
    role?: AudienceRole;
    showRoleSwitcher?: boolean;
    /** Limit to a specific domain (e.g. 'games' shows only game nodes) */
    domain?: string | string[];
    /** Layout for the role view section */
    layout?: 'accordion' | 'flat';
    style?: React.CSSProperties;
    colors?: {
        bg?: string;
        surface?: string;
        border?: string;
        text?: string;
        muted?: string;
        accent?: string;
        accentDark?: string;
    };
}
declare function LacAbout({ role: initialRole, showRoleSwitcher, domain, layout, style, colors, }: LacAboutProps): react_jsx_runtime.JSX.Element;

interface LacInheritedHelpProps {
    /** The child node ID (e.g. "feature-count-the-dots-g1a2") */
    nodeId: string;
    /** Audience role — determines which fields to show */
    role?: AudienceRole;
    /** Show a role picker above */
    showRolePicker?: boolean;
    /** Whether to show the connector line between parent and child */
    showConnector?: boolean;
    style?: React.CSSProperties;
    colors?: {
        bg?: string;
        surface?: string;
        border?: string;
        text?: string;
        muted?: string;
        accent?: string;
        parentAccent?: string;
    };
}
declare function LacInheritedHelp({ nodeId, role: initialRole, showRolePicker, showConnector, style, colors, }: LacInheritedHelpProps): react_jsx_runtime.JSX.Element | null;
interface LacInheritedHelpButtonProps {
    nodeId: string;
    role?: AudienceRole;
    allowRoleSwitch?: boolean;
    label?: string | React.ReactNode;
    position?: 'fixed' | 'inline';
    style?: React.CSSProperties;
    colors?: LacInheritedHelpProps['colors'];
}
declare function LacInheritedHelpButton({ nodeId, role: initialRole, allowRoleSwitch, label, position, style, colors, }: LacInheritedHelpButtonProps): react_jsx_runtime.JSX.Element | null;

interface Props {
    content: string;
    theme: LacTheme;
    onFileOpen?: (path: string) => void;
}
declare function MarkdownField({ content, theme, onFileOpen }: Props): react_jsx_runtime.JSX.Element;

export { type AudienceRole, DARK_THEME, type HubTab, LIGHT_THEME, LacAbout, type LacAboutProps, type LacConfig, type LacDataExport, LacDataProvider, type LacDataProviderProps, LacDecisionLog, type LacDecisionLogProps, LacFeatureCard, type LacFeatureCardProps, type LacGraph, LacGuide, type LacGuideProps, LacHelpButton, type LacHelpButtonProps, LacHelpPanel, type LacHelpPanelProps, LacHub, type LacHubProps, type LacIndex, LacInheritedHelp, LacInheritedHelpButton, type LacInheritedHelpButtonProps, type LacInheritedHelpProps, type LacNode, LacNodeField, type LacNodeFieldAs, type LacNodeFieldProps, LacRoleSwitcher, type LacRoleSwitcherProps, LacRoleView, type LacRoleViewProps, LacSearch, type LacSearchProps, LacSprintBoard, type LacSprintBoardProps, type LacStatus, LacSuccessBoard, type LacSuccessBoardProps, type LacTheme, type LacThemeMode, MarkdownField, ROLE_META, resolveTheme, useLacContext, useLacData, useLacNode, useLacNodeWithParent, useLacNodesByDomain, useLacNodesByStatus, useLacNodesByType, useLacSearch, useLacSprint, useLacSuccessCriteria };