@snackbit/opendil 0.0.0 → 0.1.0

package/dist/types/dil/runtime/expressions.d.ts

@@ -0,0 +1,59 @@
+import { PresentationScheduler } from "./presentation-scheduler";
+import { type Scope } from "./evaluation-cache";
+export type { Scope } from "./evaluation-cache";
+export interface BindingState {
+    values: Record<string, unknown>;
+    versions: Record<string, number>;
+    catalog: number;
+}
+export declare class EvaluationPending extends Error {
+    constructor();
+}
+export declare class ExpressionEngine {
+    readonly events: EventTarget;
+    private readonly updates;
+    readonly store: import("zustand").StoreApi<BindingState>;
+    private worker;
+    private readonly cache;
+    private readonly queue;
+    private intent;
+    private failed;
+    private gestureUntil;
+    private handleRefs;
+    private released;
+    private pendingChanges;
+    private urgentKeys;
+    compilations: number;
+    get stopped(): boolean;
+    get stats(): {
+        cached: number;
+        handles: number;
+        inFlight: number;
+        evaluations: number;
+        queued: number;
+        mutations: number;
+    };
+    markGesture(): void;
+    constructor(events?: EventTarget, updates?: PresentationScheduler);
+    private reference;
+    private replaceHandles;
+    private retire;
+    private notify;
+    private fill;
+    private receive;
+    halt(reason: string, report?: boolean): void;
+    dispose(): void;
+    /** Committed views own demand; cancelled renders never enqueue worker work. */
+    retain(expressions: readonly string[], scope?: Scope): () => void;
+    read(source: string, scope?: Scope): unknown;
+    hasValue(source: string, scope?: Scope): boolean;
+    isFresh(source: string, scope?: Scope): boolean;
+    evaluate(source: string, scope?: Scope): unknown;
+    private check;
+    evaluationRevision(source: string | undefined, scope?: Scope): number;
+    signature(expressions: readonly string[], scope: Scope, state: BindingState): string;
+    declare(source: string): void;
+    private call;
+    private decode;
+    private revive;
+}

package/dist/types/dil/runtime/markdown-stream.d.ts

@@ -0,0 +1,17 @@
+export interface MarkdownBlock {
+    offset: number;
+    text: string;
+}
+export interface MarkdownSnapshot {
+    source: string;
+    offset: number;
+    blocks: readonly MarkdownBlock[];
+    complete: boolean;
+    trailing?: MarkdownBlock;
+}
+export declare const EMPTY_MARKDOWN: MarkdownSnapshot;
+/** Only the trailing block is reparsed; completed blocks keep their values and keys. */
+export declare function advanceMarkdown(previous: MarkdownSnapshot, source: string, complete: boolean): MarkdownSnapshot;
+export declare function currentMarkdown(snapshot: MarkdownSnapshot): readonly MarkdownBlock[];
+export declare function markdownIndent(source: string): number | undefined;
+export declare function normalizeMarkdown(source: string, indentation: number): string;

package/dist/types/dil/runtime/presentation-history.d.ts

@@ -0,0 +1,14 @@
+export type PresentationPhase = "ready" | "revealing" | "visible";
+/** Logical message state survives view replacement and virtualization. */
+export declare class PresentationHistory {
+    private phases;
+    private attributes;
+    private virtual;
+    phase(key: string): PresentationPhase | undefined;
+    set(key: string, phase: PresentationPhase): void;
+    last(key: string): Record<string, unknown> | undefined;
+    remember(key: string, value: Record<string, unknown>): void;
+    visited(key: string): boolean;
+    visit(key: string): void;
+    forget(prefix: string): void;
+}

package/dist/types/dil/runtime/presentation-scheduler.d.ts

@@ -0,0 +1,16 @@
+export type UpdateInterval = "instant" | number;
+export declare function parseUpdateInterval(value: unknown): UpdateInterval;
+/** Latest work per owner, bounded by cadence rather than waiting for a quiet stream. */
+export declare class PresentationScheduler {
+    private pending;
+    private timer;
+    private last;
+    private interval;
+    private disposed;
+    configure(value: UpdateInterval): void;
+    enqueue(key: string, task: () => void, urgent?: boolean): void;
+    cancel(key: string): void;
+    private schedule;
+    private flush;
+    dispose(): void;
+}

package/dist/types/dil/runtime/render-budget.d.ts

@@ -0,0 +1,10 @@
+/** Bounds mounted presentation work, including multiplicative repeated templates. */
+export declare class RenderBudget {
+    readonly limit: number;
+    private leases;
+    private total;
+    constructor(limit?: number);
+    get used(): number;
+    reserve(id: string, cost: number): boolean;
+    release(id: string): void;
+}

package/dist/types/dil/runtime/view-cost.d.ts

@@ -0,0 +1,10 @@
+import type { DilDocument } from "./document";
+import type { Scope } from "./expressions";
+export interface CostDocument {
+    nodes: DilDocument["nodes"];
+    engine: Pick<DilDocument["engine"], "read">;
+    attributes: DilDocument["attributes"];
+}
+/** Pure, short-circuiting preflight; unresolved expressions cost a local placeholder. */
+export declare function nodeCost(document: CostDocument, id: number, scope: Scope, svg: boolean, limit: number): number;
+export declare function childrenCost(document: CostDocument, ids: readonly number[], scope: Scope, svg: boolean, limit: number): number;

package/dist/types/dil/view/conditional-view.d.ts

@@ -0,0 +1,12 @@
+import type { ChildList } from "../runtime/child-list";
+import type { DilDocument } from "../runtime/document";
+import type { Scope } from "../runtime/expressions";
+export interface ConditionalViewProps {
+    childrenIds: ChildList;
+    document: DilDocument;
+    scope: Scope;
+    svg: boolean;
+    inline: boolean;
+    instance: string;
+}
+export declare function ConditionalView({ childrenIds, document, scope, svg, inline, instance, }: ConditionalViewProps): import("react").JSX.Element | null;

package/dist/types/dil/view/loading-block.d.ts

@@ -0,0 +1,7 @@
+export interface LoadingBlockProps {
+    name?: string;
+    table?: false | "body" | "row";
+    svg?: boolean;
+    error?: string | undefined;
+}
+export declare function LoadingBlock({ name: _name, table, svg, error, }: LoadingBlockProps): import("react").JSX.Element;

package/dist/types/dil/view/markdown-node.d.ts

@@ -0,0 +1,12 @@
+import { type Scope } from "../runtime/expressions";
+import type { DilNode } from "../parser/types";
+import type { DilDocument } from "../runtime/document";
+export interface MarkdownNodeProps {
+    node: DilNode;
+    document: DilDocument;
+    scope: Scope;
+    inline: boolean;
+    svg: boolean;
+    instance: string;
+}
+export declare function MarkdownNode({ node, document, scope, inline, svg, instance, }: MarkdownNodeProps): import("react").JSX.Element | null;

package/dist/types/dil/view/node-children.d.ts

@@ -0,0 +1,13 @@
+import type { DilDocument } from "../runtime/document";
+import type { Scope } from "../runtime/expressions";
+import type { ChildList } from "../runtime/child-list";
+export interface NodeChildrenProps {
+    childrenIds: ChildList;
+    document: DilDocument;
+    scope: Scope;
+    inline: boolean;
+    svg: boolean;
+    instance: string;
+    flowParent?: number | undefined;
+}
+export declare function NodeChildren({ childrenIds, document, scope, inline, svg, instance, flowParent, }: NodeChildrenProps): import("react").JSX.Element | import("react").JSX.Element[];

package/dist/types/dil/view/node-view.d.ts

@@ -0,0 +1,11 @@
+import type { DilDocument } from "../runtime/document";
+import type { Scope } from "../runtime/expressions";
+export interface NodeViewProps {
+    id: number;
+    document: DilDocument;
+    scope?: Scope;
+    inline?: boolean;
+    svg?: boolean;
+    instance?: string;
+}
+export declare const NodeView: import("react").NamedExoticComponent<NodeViewProps>;

package/dist/types/dil/view/progressive-reveal.d.ts

@@ -0,0 +1,6 @@
+import { type RefObject } from "react";
+import type { DilDocument } from "../runtime/document";
+import { type ProgressiveReveal } from "./reveal-options";
+import { RevealController } from "./reveal/controller";
+export declare function revealDelay(index: number, staggerMs?: number): number;
+export declare function useProgressiveReveal(root: RefObject<HTMLElement | null>, options: ProgressiveReveal, document: DilDocument | null): RevealController;

package/dist/types/dil/view/render-boundary.d.ts

@@ -0,0 +1,22 @@
+import { Component, type ReactNode } from "react";
+interface RenderBoundaryProps {
+    revision: string;
+    streaming: boolean;
+    children: ReactNode;
+}
+interface BoundaryState {
+    error: string;
+    revision: string;
+}
+export declare class RenderBoundary extends Component<RenderBoundaryProps, BoundaryState> {
+    state: BoundaryState;
+    static getDerivedStateFromProps(props: RenderBoundaryProps, state: BoundaryState): {
+        revision: string;
+        error: string;
+    } | null;
+    static getDerivedStateFromError(error: unknown): {
+        error: string;
+    };
+    render(): string | number | bigint | boolean | Iterable<ReactNode> | Promise<string | number | bigint | boolean | import("react").ReactPortal | import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>> | Iterable<ReactNode> | null | undefined> | import("react").JSX.Element | null | undefined;
+}
+export {};

package/dist/types/dil/view/render-limit.d.ts

@@ -0,0 +1,14 @@
+import { type ReactNode } from "react";
+import type { DilDocument } from "../runtime/document";
+type BudgetDocument = Pick<DilDocument, "renderBudget" | "reportRenderLimit">;
+export declare const RenderAllowance: import("react").Context<number>;
+export interface RenderLimitProps {
+    document: BudgetDocument;
+    cost?: number;
+    children: ReactNode;
+}
+export declare function RenderExceeded({ document }: {
+    document: BudgetDocument;
+}): null;
+export declare function RenderLimit({ document, cost, children, }: RenderLimitProps): import("react").JSX.Element | null;
+export {};

package/dist/types/dil/view/repeated-nodes.d.ts

@@ -0,0 +1,15 @@
+import type { DilNode } from "../parser/types";
+import type { ChildList } from "../runtime/child-list";
+import type { DilDocument } from "../runtime/document";
+import type { Scope } from "../runtime/expressions";
+interface RepeatedNodesProps {
+    node: DilNode;
+    childrenIds: ChildList;
+    document: DilDocument;
+    scope: Scope;
+    svg: boolean;
+    instance: string;
+    attributes: Record<string, unknown>;
+}
+export declare function RepeatedNodes(props: RepeatedNodesProps): import("react").JSX.Element | import("react").JSX.Element[] | null;
+export {};

package/dist/types/dil/view/reveal/controller.d.ts

@@ -0,0 +1,25 @@
+import type { PresentationHistory } from "../../runtime/presentation-history";
+import type { RevealTiming } from "../reveal-options";
+export declare class RevealController {
+    readonly history: PresentationHistory;
+    private readonly viewport;
+    private timing;
+    private targets;
+    private queued;
+    private frame;
+    private started;
+    private reduced;
+    private nextStart;
+    constructor(history: PresentationHistory, viewport: () => {
+        top: number;
+        bottom: number;
+    });
+    configure(timing: RevealTiming | null): void;
+    start(): () => void;
+    register(key: string, element: HTMLElement, eligible: boolean, skip: boolean): () => void;
+    private prepare;
+    private finish;
+    showAll(): void;
+    private schedule;
+    private flush;
+}

package/dist/types/dil/view/reveal/presentation.d.ts

@@ -0,0 +1,13 @@
+import { type ReactNode } from "react";
+import type { RevealController } from "./controller";
+export declare const RevealContext: import("react").Context<RevealController | null>;
+export declare function usePresentationKey(identity: string): string;
+export declare function usePresentationTarget(identity: string, eligible?: boolean): (element: HTMLElement | null) => void;
+export declare function VirtualPresentation({ identity, returning, children, }: {
+    identity: string;
+    returning: boolean;
+    children: ReactNode;
+}): import("react").JSX.Element;
+export declare function BranchPresentation({ children }: {
+    children: ReactNode;
+}): import("react").JSX.Element;

package/dist/types/dil/view/reveal-options.d.ts

@@ -0,0 +1,11 @@
+export interface ProgressiveRevealOptions {
+    staggerMs?: number;
+    durationMs?: number;
+}
+export type ProgressiveReveal = boolean | ProgressiveRevealOptions;
+export interface RevealTiming {
+    staggerMs: number;
+    durationMs: number;
+}
+export declare function revealTiming(value: ProgressiveReveal): RevealTiming | null;
+export declare function readReveal(value: unknown): ProgressiveReveal;

package/dist/types/dil/view/scroll/controller.d.ts

@@ -0,0 +1,28 @@
+import type { scrollSettings } from "../scroll-options";
+type Settings = ReturnType<typeof scrollSettings>;
+/** One moving-target animation per message. Native smooth scrolling would restart on each chunk. */
+export declare class ScrollFollower {
+    private readonly element;
+    private readonly settings;
+    private readonly changed;
+    private readonly view;
+    private readonly reduced;
+    private readonly observer;
+    private readonly unlisten;
+    private releaseAnchor;
+    private frame;
+    private previous;
+    private position;
+    private following;
+    private notified;
+    constructor(element: HTMLElement, settings: () => Settings, changed: (following: boolean) => void, listen: (view: Window, pause: () => void) => () => void);
+    private report;
+    start(): void;
+    end(): void;
+    resume: () => void;
+    pause: () => void;
+    refresh: () => void;
+    private tick;
+    dispose(): void;
+}
+export {};

package/dist/types/dil/view/scroll-options.d.ts

@@ -0,0 +1,10 @@
+export interface AutoScrollOptions {
+    behavior?: "instant" | "smooth";
+    /** Extra distance beyond the message tail, clamped to available document space. */
+    padding?: number;
+}
+export type AutoScroll = boolean | AutoScrollOptions;
+export declare function scrollSettings(value: AutoScroll): {
+    behavior: "instant" | "smooth";
+    padding: number;
+} | null;

package/dist/types/dil/view/stream-follow.d.ts

@@ -0,0 +1,8 @@
+import { type RefObject } from "react";
+import { type AutoScroll } from "./scroll-options";
+export declare function listenForScrollAway(view: Window, pause: () => void): () => void;
+/** Only deliberate reading gestures suspend following, never layout or anchor adjustments. */
+export declare function useStreamFollow(root: RefObject<HTMLElement | null>, options: AutoScroll, streaming: boolean, onChange?: ((following: boolean) => void) | undefined): {
+    pause: () => void | undefined;
+    resume: () => void | undefined;
+};

package/dist/types/dil/view/table-context.d.ts

@@ -0,0 +1,15 @@
+import { type FocusEvent, type ReactNode } from "react";
+export declare const TableScope: import("react").Context<false | "row" | "body">;
+interface RowMeasurement {
+    index: number;
+    group: string;
+    measure: (element: HTMLElement | null) => void;
+    focus: (event: FocusEvent<HTMLElement>) => void;
+    blur: (event: FocusEvent<HTMLElement>) => void;
+}
+export declare const VirtualRowScope: import("react").Context<RowMeasurement | null>;
+export declare function DilTableRow({ children, presentationRef, }: {
+    children: ReactNode;
+    presentationRef?: ((element: HTMLElement | null) => void) | undefined;
+}): import("react").JSX.Element;
+export {};

package/dist/types/dil/view/virtual-flow.d.ts

@@ -0,0 +1,15 @@
+import { type ReactNode } from "react";
+import type { ChildList } from "../runtime/child-list";
+import type { DilDocument } from "../runtime/document";
+import type { Scope } from "../runtime/expressions";
+export interface VirtualFlowProps {
+    identity?: string;
+    count: number;
+    childIds?: ChildList;
+    document: DilDocument;
+    scope: Scope;
+    instance: string;
+    renderItem?: (index: number) => ReactNode;
+    itemKey?: (index: number) => string | number;
+}
+export declare function VirtualFlow({ identity, count, childIds, document, scope, instance, renderItem, itemKey, }: VirtualFlowProps): import("react").JSX.Element;

package/dist/types/dil/widgets/action-feedback.d.ts

@@ -0,0 +1,11 @@
+import { type ReactNode } from "react";
+import type { StoreApi } from "zustand/vanilla";
+import type { DocumentStatus } from "../runtime/document";
+export type ActionFeedback = "idle" | "copied" | "failed";
+/** Shows the clipboard outcome of the action this control started, briefly. */
+export declare function useActionFeedback(status: StoreApi<DocumentStatus>): readonly [ActionFeedback, (result: unknown) => void];
+/** Always mounted around the control so showing feedback never remounts or blurs it. */
+export declare function ActionFeedbackTooltip({ feedback, children, }: {
+    feedback: ActionFeedback;
+    children: ReactNode;
+}): import("react").JSX.Element;

package/dist/types/dil/widgets/async-image.d.ts

@@ -0,0 +1,6 @@
+export interface AsyncImageProps {
+    query: string;
+    presentationRef?: ((element: HTMLElement | null) => void) | undefined;
+}
+/** Offline illustration. A host-mode component override can supply an image service. */
+export declare function AsyncImage({ query, presentationRef }: AsyncImageProps): import("react").JSX.Element;

package/dist/types/dil/widgets/charts/chart-legend.d.ts

@@ -0,0 +1,10 @@
+import type { ChartItem } from "./chart-selection";
+export interface ChartLegendProps {
+    items: readonly ChartItem[];
+    hidden: ReadonlySet<string>;
+    hovered: string | null;
+    select: (id: string, toggle: boolean) => void;
+    highlight: (id: string | null) => void;
+    interactive: boolean;
+}
+export declare function ChartLegend({ items, hidden, hovered, select, highlight, interactive, }: ChartLegendProps): import("react").JSX.Element;

package/dist/types/dil/widgets/charts/chart-selection.d.ts

@@ -0,0 +1,8 @@
+export interface ChartItem {
+    id: string;
+    label: string;
+    color: string;
+}
+/** Grafana: isolate on plain click, toggle individually with Ctrl/Cmd. */
+export declare function selectChartItem(ids: readonly string[], hidden: ReadonlySet<string>, id: string, toggle: boolean): Set<string>;
+export declare function reconcileChartSelection(ids: readonly string[], hidden: ReadonlySet<string>): Set<string>;

package/dist/types/dil/widgets/charts/chart-series.d.ts

@@ -0,0 +1,11 @@
+import type { ChartItem } from "./chart-selection";
+export interface ChartSeriesProps {
+    item: ChartItem;
+    index: number;
+    type: string;
+    hidden: boolean;
+    muted: boolean;
+    rows: Record<string, unknown>[];
+    highlight: (id: string | null) => void;
+}
+export declare function ChartSeries({ item, index, type, hidden, muted, rows, highlight, }: ChartSeriesProps): import("react").JSX.Element;

package/dist/types/dil/widgets/charts/chart-snapping.d.ts

@@ -0,0 +1,15 @@
+import type { ChartItem } from "./chart-selection";
+export interface ChartPoint {
+    index: number;
+    item: ChartItem;
+    row: Record<string, unknown>;
+    x: number;
+    y: number;
+    value: number;
+}
+type AxisScale = (value: unknown, options?: {
+    position: "middle";
+}) => number | undefined;
+export declare function projectChartPoints(rows: Record<string, unknown>[], items: readonly ChartItem[], xKey: string, xScale: AxisScale, yScale: AxisScale): ChartPoint[];
+export declare function nearestChartPoint(points: readonly ChartPoint[], x: number, y: number, scatter: boolean): ChartPoint | undefined;
+export {};

package/dist/types/dil/widgets/charts/dil-chart.d.ts

@@ -0,0 +1,5 @@
+export interface DilChartProps {
+    content: unknown;
+    presentationRef?: ((element: HTMLElement | null) => void) | undefined;
+}
+export declare function DilChart({ content, presentationRef }: DilChartProps): import("react").JSX.Element;

package/dist/types/dil/widgets/charts/snap-cursor.d.ts

@@ -0,0 +1,16 @@
+import { type ChartPoint } from "./chart-snapping";
+import type { ChartItem } from "./chart-selection";
+export interface ChartHit {
+    point: ChartPoint;
+    clientX: number;
+    clientY: number;
+}
+export interface SnapCursorProps {
+    rows: Record<string, unknown>[];
+    items: readonly ChartItem[];
+    xKey: string;
+    scatter: boolean;
+    hit: ChartHit | null;
+    onHover: (hit: ChartHit | null) => void;
+}
+export declare function SnapCursor({ rows, items, xKey, scatter, hit, onHover, }: SnapCursorProps): import("react").JSX.Element | null;

package/dist/types/dil/widgets/charts/snap-tooltip.d.ts

@@ -0,0 +1,10 @@
+import type { ChartItem } from "./chart-selection";
+import type { ChartHit } from "./snap-cursor";
+export interface SnapTooltipProps {
+    hit: ChartHit | null;
+    items: readonly ChartItem[];
+    xKey: string;
+    scatter: boolean;
+    onHover: (hit: ChartHit | null) => void;
+}
+export declare function SnapTooltip({ hit, items, xKey, scatter, onHover, }: SnapTooltipProps): import("react").JSX.Element | null;

package/dist/types/dil/widgets/code/code-editor.d.ts

@@ -0,0 +1,9 @@
+import { type ChangeEvent } from "react";
+export interface CodeEditorProps {
+    source: string;
+    language: string;
+    ready: boolean;
+    wrapped: boolean;
+    onChange: (event: ChangeEvent<HTMLTextAreaElement>) => void;
+}
+export declare function CodeEditor({ source, language, ready, wrapped, onChange, }: CodeEditorProps): import("react").JSX.Element;

package/dist/types/dil/widgets/code/highlighted-code.d.ts

@@ -0,0 +1,25 @@
+import { type ReactNode } from "react";
+declare const highlighter: {
+    highlight: (language: string, value: string, options?: Readonly<import("lowlight").Options> | null | undefined) => import("hast").Root;
+    highlightAuto: (value: string, options?: Readonly<import("lowlight").AutoOptions> | null | undefined) => import("hast").Root;
+    listLanguages: () => Array<string>;
+    register: {
+        (grammars: Readonly<Record<string, import("highlight.js").LanguageFn>>): undefined;
+        (name: string, grammar: import("highlight.js").LanguageFn): undefined;
+    };
+    registerAlias: {
+        (aliases: Readonly<Record<string, ReadonlyArray<string> | string>>): undefined;
+        (language: string, alias: ReadonlyArray<string> | string): undefined;
+    };
+    registered: (aliasOrName: string) => boolean;
+};
+type Tree = ReturnType<typeof highlighter.highlight>;
+export declare function renderTokens(node: Tree | Tree["children"][number], count: {
+    value: number;
+}): ReactNode;
+/** Highlight AST nodes become React text/spans; authored code never becomes raw HTML. */
+export declare const HighlightedCode: import("react").NamedExoticComponent<{
+    source: string;
+    language: string;
+}>;
+export {};

package/dist/types/dil/widgets/code-block.d.ts

@@ -0,0 +1,11 @@
+import type { DilDocument } from "../runtime/document";
+export interface CodeBlockProps {
+    source: string;
+    language: string;
+    editable: boolean;
+    ready: boolean;
+    document: DilDocument;
+    identity: string;
+    presentationRef?: ((element: HTMLElement | null) => void) | undefined;
+}
+export declare function CodeBlock({ source, language, editable, ready, document, identity, presentationRef, }: CodeBlockProps): import("react").JSX.Element;

package/dist/types/dil/widgets/control-revision.d.ts

@@ -0,0 +1 @@
+export declare const ControlRevisionContext: import("react").Context<number>;

package/dist/types/dil/widgets/control-state.d.ts

@@ -0,0 +1,8 @@
+export interface ControlDraft<T> {
+    upstream: T;
+    value: T;
+    revision: number;
+    pending: number;
+}
+export declare function synchronizeDraft<T>(state: ControlDraft<T>, upstream: T, revision: number): ControlDraft<T>;
+export declare function editDraft<T>(state: ControlDraft<T>, value: T, result: unknown, commit: boolean): ControlDraft<T>;

package/dist/types/dil/widgets/controls.d.ts

@@ -0,0 +1,25 @@
+import { type ReactNode } from "react";
+import type { StoreApi } from "zustand/vanilla";
+import type { DocumentStatus } from "../runtime/document";
+import { type Attributes } from "./primitives/attribute-values";
+export declare const PopoverTriggerScope: import("react").Context<boolean>;
+export interface ControlProps {
+    attributes: Attributes;
+    children?: ReactNode;
+    ready: boolean;
+    label: string;
+    className?: string | undefined;
+    presentationRef?: ((element: HTMLElement | null) => void) | undefined;
+}
+/** Actions report clipboard outcomes from their own document. */
+export interface ActionProps extends ControlProps {
+    status: StoreApi<DocumentStatus>;
+}
+export declare function ButtonControl({ attributes, children, ready, label, className, presentationRef, status, }: ActionProps): import("react").JSX.Element;
+export declare function CheckboxControl({ attributes, children, ready, className, presentationRef, }: ControlProps): import("react").JSX.Element;
+export declare function SliderControl({ attributes, ready, label, className, presentationRef, }: ControlProps): import("react").JSX.Element;
+export declare function InputControl({ attributes, ready, label, className, presentationRef, }: ControlProps): import("react").JSX.Element;
+export declare function SegmentedControl({ attributes, ready, label, className, presentationRef, }: ControlProps): import("react").JSX.Element;
+export declare function RadioGroupControl({ attributes, children, ready, label, className, presentationRef, }: ControlProps): import("react").JSX.Element;
+export declare function RadioControl({ attributes, children, ready, className, presentationRef, }: ControlProps): import("react").JSX.Element;
+export declare function PressableControl({ attributes, children, ready, className, presentationRef, status, }: ActionProps): import("react").JSX.Element;

package/dist/types/dil/widgets/graphs/graph-model.d.ts

@@ -0,0 +1,13 @@
+import { type Edge, type Node } from "@xyflow/react";
+export declare const SERVICE_WIDTH = 160;
+export declare const SERVICE_HEIGHT = 72;
+export declare const COLUMN_GAP = 64;
+export type ServiceData = {
+    label: string;
+    sub: string;
+};
+export type ServiceGraphNode = Node<ServiceData, "service">;
+export declare function graphModel(content: unknown): {
+    nodes: ServiceGraphNode[];
+    edges: Edge[];
+};

package/dist/types/dil/widgets/graphs/node-graph.d.ts

@@ -0,0 +1,6 @@
+import { type Attributes } from "../primitives/attribute-values";
+export interface NodeGraphProps {
+    attributes: Attributes;
+    presentationRef?: ((element: HTMLElement | null) => void) | undefined;
+}
+export declare function NodeGraph({ attributes, presentationRef }: NodeGraphProps): import("react").JSX.Element;

package/dist/types/dil/widgets/graphs/service-node.d.ts

@@ -0,0 +1,3 @@
+import { type NodeProps } from "@xyflow/react";
+import type { ServiceGraphNode } from "./graph-model";
+export declare function ServiceNode({ data, selected }: NodeProps<ServiceGraphNode>): import("react").JSX.Element;

package/dist/types/dil/widgets/mermaid-diagram.d.ts

@@ -0,0 +1,5 @@
+export interface MermaidDiagramProps {
+    source: string;
+    presentationRef?: ((element: HTMLElement | null) => void) | undefined;
+}
+export declare function MermaidDiagram({ source, presentationRef, }: MermaidDiagramProps): import("react").JSX.Element | null;