@tldiagram/core-ui 1.87.0

package/dist/App.d.ts

@@ -0,0 +1 @@
+export default function App(): import("react/jsx-runtime").JSX.Element;

package/dist/api/client.d.ts

@@ -0,0 +1,143 @@
+import type { Connector, DependencyConnector, DependencyElement, ElementPlacement, ExploreData, LibraryElement, PlacedElement, View, ViewConnector, ViewLayer, ViewPlacement, ViewTreeNode } from '../types';
+import { PlanElement, PlanConnector } from '@buf/tldiagramcom_diagram.bufbuild_es/diag/v1/workspace_service_pb';
+export interface DependenciesResponse {
+    elements: DependencyElement[];
+    connectors: DependencyConnector[];
+}
+export declare const api: {
+    system: {
+        ready: () => Promise<{
+            ok: boolean;
+        }>;
+    };
+    user: {
+        getPreferences: () => Promise<{
+            accent_color: string | null;
+            background_color: string | null;
+            element_color: string | null;
+        }>;
+        updatePreferences: (prefs: {
+            accent_color?: string;
+            background_color?: string;
+            element_color?: string;
+        }) => Promise<void>;
+    };
+    elements: {
+        list: (params?: {
+            limit?: number;
+            offset?: number;
+            search?: string;
+        }) => Promise<LibraryElement[]>;
+        get: (id: number) => Promise<LibraryElement>;
+        create: (data: Partial<LibraryElement>) => Promise<LibraryElement>;
+        update: (id: number, data: Partial<LibraryElement>) => Promise<LibraryElement>;
+        delete: (_orgId: string, id: number) => Promise<void>;
+        placements: (id: number) => Promise<ViewPlacement[]>;
+    };
+    workspace: {
+        elements: {
+            list: (params?: {
+                limit?: number;
+                offset?: number;
+                search?: string;
+            }) => Promise<LibraryElement[]>;
+            get: (id: number) => Promise<LibraryElement>;
+            create: (data: Partial<LibraryElement>) => Promise<LibraryElement>;
+            update: (id: number, data: Partial<LibraryElement>) => Promise<LibraryElement>;
+            delete: (_orgId: string, id: number) => Promise<void>;
+            placements: (id: number) => Promise<ViewPlacement[]>;
+            navigations: {
+                list: (elementId: number, fromDiagramId: number) => Promise<ViewConnector[]>;
+                listParents: (elementId: number, toDiagramId: number) => Promise<ViewConnector[]>;
+            };
+        };
+        views: {
+            list: () => Promise<View[]>;
+            content: (id: number) => Promise<{
+                placements: PlacedElement[];
+                connectors: Connector[];
+            }>;
+            tree: () => Promise<ViewTreeNode[]>;
+            get: (id: number) => Promise<ViewTreeNode>;
+            create: (data: {
+                name: string;
+                label?: string;
+                parent_view_id?: number | null;
+            }) => Promise<View>;
+            update: (id: number, data: {
+                name: string;
+                label?: string;
+            }) => Promise<View>;
+            rename: (id: number, name: string) => Promise<View>;
+            setLevel: (id: number, level: number) => Promise<void>;
+            delete: (_orgId: string, id: number) => Promise<void>;
+            thumbnail: (_id: number) => Promise<string | null>;
+            placements: {
+                list: (diagramId: number) => Promise<ElementPlacement[]>;
+                add: (diagramId: number, elementId: number, x?: number, y?: number) => Promise<ElementPlacement>;
+                updatePosition: (diagramId: number, elementId: number, x: number, y: number) => Promise<void>;
+                remove: (diagramId: number, elementId: number) => Promise<void>;
+            };
+            layers: {
+                list: (diagramId: number) => Promise<ViewLayer[]>;
+                create: (diagramId: number, data: {
+                    name: string;
+                    tags: string[];
+                    color?: string;
+                }) => Promise<ViewLayer>;
+                update: (_diagramId: number, layerId: number, data: Partial<ViewLayer>) => Promise<ViewLayer>;
+                delete: (_diagramId: number, layerId: number) => Promise<void>;
+            };
+        };
+        connectors: {
+            list: (diagramId: number) => Promise<Connector[]>;
+            create: (diagramId: number, data: {
+                source_element_id: number;
+                target_element_id: number;
+                label?: string;
+                description?: string;
+                relationship?: string;
+                direction?: string;
+                style?: string;
+                url?: string;
+                source_handle?: string | null;
+                target_handle?: string | null;
+            }) => Promise<Connector>;
+            update: (_diagramId: number, connectorId: number, data: {
+                source_element_id?: number;
+                target_element_id?: number;
+                label?: string;
+                description?: string;
+                relationship?: string;
+                direction?: string;
+                style?: string;
+                url?: string;
+                source_handle?: string | null;
+                target_handle?: string | null;
+            }) => Promise<Connector>;
+            delete: (_orgId: string, connectorId: number) => Promise<void>;
+        };
+    };
+    dependencies: {
+        list: () => Promise<DependenciesResponse>;
+    };
+    explore: {
+        load: () => Promise<ExploreData & {
+            password_required?: boolean;
+        }>;
+    };
+    import: {
+        resources: (orgId: string, data: {
+            elements: PlanElement[];
+            connectors: PlanConnector[];
+        }) => Promise<{
+            view_id: number;
+            view_url: string;
+        }>;
+        parseStructurizr: (code: string) => Promise<{
+            elements: PlanElement[];
+            connectors: PlanConnector[];
+            warnings: string[];
+        }>;
+    };
+};

package/dist/api/transport-vscode.d.ts

@@ -0,0 +1,8 @@
+declare global {
+    interface Window {
+        __TLD_API_KEY__?: string;
+        __TLD_SERVER_URL__?: string;
+        __TLD_DIAGRAM_ID__?: number;
+    }
+}
+export declare const transport: import("@connectrpc/connect").Transport;

package/dist/api/transport.d.ts

@@ -0,0 +1 @@
+export declare const transport: import("@connectrpc/connect").Transport;

package/dist/components/CodePreviewPanel-vscode.d.ts

@@ -0,0 +1,7 @@
+import type { PlacedElement } from '../types';
+interface Props {
+    element: PlacedElement | null;
+    onClose: () => void;
+}
+export default function CodePreviewPanel({ element, onClose }: Props): import("react/jsx-runtime").JSX.Element | null;
+export {};

package/dist/components/CodePreviewPanel.d.ts

@@ -0,0 +1,9 @@
+import type { PlacedElement } from '../types';
+interface Props {
+    isOpen: boolean;
+    onClose: () => void;
+    element: PlacedElement | null;
+    hasBackdrop?: boolean;
+}
+export default function CodePreviewPanel({ isOpen, onClose, element, hasBackdrop }: Props): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/ConfirmDialog.d.ts

@@ -0,0 +1,12 @@
+interface Props {
+    isOpen: boolean;
+    onClose: () => void;
+    onConfirm: () => void;
+    title: string;
+    body: string;
+    confirmLabel?: string;
+    confirmColorScheme?: string;
+    isLoading?: boolean;
+}
+export default function ConfirmDialog({ isOpen, onClose, onConfirm, title, body, confirmLabel, confirmColorScheme, isLoading, }: Props): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/ConnectorPanel.d.ts

@@ -0,0 +1,21 @@
+import type { ConnectorPanelSlots } from '../slots';
+import type { Connector } from '../types';
+export interface ConnectorPanelProps extends ConnectorPanelSlots {
+    isOpen: boolean;
+    onClose: () => void;
+    connector: Connector | null;
+    orgId: string;
+    onSave: (connector: Connector) => void;
+    autoSave?: boolean;
+    onDelete: (edgeId: number) => void;
+    hasBackdrop?: boolean;
+}
+/**
+ * Name: Edit Connector Panel
+ * Role: Opens when clicked on a connector and displays its fields, allowing for editing. Same as Edit Element Panel but for connectors.
+ * Location: Right side of the screen on desktop. Overlays screen on mobile.
+ * Aliases: Connector Properties, Connector Details.
+ */
+declare function ConnectorPanel({ isOpen, onClose, connector, orgId, onSave, autoSave, onDelete, hasBackdrop, connectorPanelAfterContentSlot }: ConnectorPanelProps): import("react/jsx-runtime").JSX.Element;
+declare const _default: import("react").MemoExoticComponent<typeof ConnectorPanel>;
+export default _default;

package/dist/components/ContextBoundaryElement.d.ts

@@ -0,0 +1,11 @@
+interface Props {
+    data: {
+        width: number;
+        height: number;
+        parentName: string;
+        onNavigateToDiagram: () => void;
+    };
+}
+declare function ContextBoundaryElement({ data }: Props): import("react/jsx-runtime").JSX.Element;
+declare const _default: import("react").MemoExoticComponent<typeof ContextBoundaryElement>;
+export default _default;

package/dist/components/ContextNeighborElement.d.ts

@@ -0,0 +1,29 @@
+import type { PlacedElement } from '../types';
+interface ContextNeighborData {
+    element_id: number;
+    name: string;
+    kind: string | null;
+    description: string | null;
+    technology: string | null;
+    logo_url: string | null;
+    technology_connectors: PlacedElement['technology_connectors'];
+    ownerViewIds: number[];
+    ownerViewNames: string[];
+    commonAncestorViewId: number | null;
+    commonAncestorViewName: string | null;
+    connectorCount: number;
+    onNavigateToView: (viewId: number) => void;
+    onSelectDetails?: () => void;
+    isCanvasMoving?: boolean;
+    isGroupAnchor?: boolean;
+    groupChildCount?: number;
+    isGroupExpanded?: boolean;
+    onToggleGroup?: () => void;
+    side?: 'top' | 'bottom' | 'left' | 'right';
+}
+interface Props {
+    data: ContextNeighborData;
+}
+declare function ContextNeighborNode({ data }: Props): import("react/jsx-runtime").JSX.Element;
+declare const _default: import("react").MemoExoticComponent<typeof ContextNeighborNode>;
+export default _default;

package/dist/components/ContextStraightConnector.d.ts

@@ -0,0 +1,4 @@
+import { EdgeProps } from 'reactflow';
+declare function ContextStraightConnector({ id, source, target, style, markerEnd, markerStart, data, }: EdgeProps): import("react/jsx-runtime").JSX.Element | null;
+declare const _default: import("react").MemoExoticComponent<typeof ContextStraightConnector>;
+export default _default;

package/dist/components/CrossBranchControls.d.ts

@@ -0,0 +1,9 @@
+import type { CrossBranchContextSettings } from '../crossBranch/types';
+interface Props {
+    settings: CrossBranchContextSettings;
+    onEnabledChange: (enabled: boolean) => void;
+    onDepthChange: (depth: number) => void;
+    label?: string;
+}
+export default function CrossBranchControls({ settings, onEnabledChange, onDepthChange, label, }: Props): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/DependenciesOnboarding.d.ts

@@ -0,0 +1,5 @@
+interface Props {
+    hasElements: boolean;
+}
+export default function DependenciesOnboarding({ hasElements }: Props): import("react/jsx-runtime").JSX.Element | null;
+export {};

package/dist/components/DrawingCanvas.d.ts

@@ -0,0 +1,39 @@
+import React from 'react';
+export type DrawingPoint = {
+    x: number;
+    y: number;
+};
+export type DrawingPath = {
+    id: string;
+    points: DrawingPoint[];
+    color: string;
+    width: number;
+    text?: string;
+    fontSize?: number;
+};
+interface DrawingCanvasProps {
+    paths: DrawingPath[];
+    isDrawing: boolean;
+    isVisible: boolean;
+    strokeColor?: string;
+    strokeWidth?: number;
+    mode?: 'pencil' | 'eraser' | 'text' | 'select';
+    onPathComplete: (path: DrawingPath) => void;
+    onPathDelete?: (pathId: string) => void;
+    onPathUpdate?: (path: DrawingPath) => void;
+    onTextPositionSelected?: (canvasX: number, canvasY: number, flowX: number, flowY: number) => void;
+}
+export interface DrawingCanvasHandle {
+    /** Imperatively update the viewport and redraw avoids React re-renders on every pan frame. */
+    notifyViewportChange: (vp: {
+        x: number;
+        y: number;
+        zoom: number;
+    }) => void;
+}
+/**
+ * A premium free-drawing overlay with smooth ink-like strokes, hit detection for move/erase,
+ * and a broad eraser brush.
+ */
+declare const DrawingCanvas: React.ForwardRefExoticComponent<DrawingCanvasProps & React.RefAttributes<DrawingCanvasHandle>>;
+export default DrawingCanvas;

package/dist/components/ElementLibrary-vscode.d.ts

@@ -0,0 +1,7 @@
+/**
+ * VS Code variant of ElementLibrary.
+ * The element library is surfaced as a native VS Code tree view instead.
+ * This stub prevents the web component (with its drag/touch/scroll logic) from
+ * being bundled into the webview build.
+ */
+export default function ElementLibrary(): null;

package/dist/components/ElementLibrary.d.ts

@@ -0,0 +1,22 @@
+import '../styles/editor-panels.css';
+import type { LibraryElement } from '../types';
+interface Props {
+    existingElementIds: Set<number>;
+    existingElements?: LibraryElement[];
+    onCreateNew: () => void;
+    refresh: number;
+    isOpen: boolean;
+    onClose: () => void;
+    onTapAdd?: (obj: LibraryElement) => void;
+    onFindElement?: (id: number) => void;
+    onTouchDrop?: (obj: LibraryElement, clientX: number, clientY: number) => void;
+}
+/**
+ * Name: Element Library
+ * Role: Panel/drawer that displays the organization's element library and shows which are in the current view and which are not. Includes an add new element button.
+ * Location: Left side panel/drawer on desktop. Collapsed under a button on mobile.
+ * Aliases: Element sidebar, Library panel.
+ */
+declare function ElementLibrary({ existingElementIds, existingElements, onCreateNew, refresh, isOpen, onClose, onTapAdd, onFindElement, onTouchDrop, }: Props): import("react/jsx-runtime").JSX.Element;
+declare const _default: import("react").MemoExoticComponent<typeof ElementLibrary>;
+export default _default;

package/dist/components/ElementNode.d.ts

@@ -0,0 +1,36 @@
+import type { PlacedElement, ViewConnector, Tag } from '../types';
+interface NodeData extends PlacedElement {
+    links: ViewConnector[];
+    parentLinks: ViewConnector[];
+    parentViewId?: number | null;
+    onZoomIn: (elementId: number) => void;
+    onZoomOut: (elementId: number) => void;
+    onNavigateToDiagram: (viewId: number) => void;
+    onSelect: (obj: PlacedElement) => void;
+    onInteractionStart: (elementId: number) => void;
+    onConnectTo: (elementId: number) => void;
+    onStartHandleReconnect?: (args: {
+        edgeId: string;
+        endpoint: 'source' | 'target';
+        handleId: string;
+        clientX: number;
+        clientY: number;
+    }) => void;
+    onRemove: (elementId: number) => void;
+    onHoverZoom: (elementId: number, type: 'in' | 'out' | null) => void;
+    isZoomHovered: 'in' | 'out' | null;
+    interactionSourceId: number | null;
+    onOpenCodePreview?: (elementId: number) => void;
+    isClickConnectMode?: boolean;
+    tagColors: Record<string, Tag>;
+    layerHighlightColor?: string;
+    forceShowTagPopup?: boolean;
+    isCanvasMoving?: boolean;
+}
+interface Props {
+    data: NodeData;
+    selected: boolean;
+}
+declare function ElementNode({ data, selected }: Props): import("react/jsx-runtime").JSX.Element;
+declare const _default: import("react").MemoExoticComponent<typeof ElementNode>;
+export default _default;

package/dist/components/ElementPanel.d.ts

@@ -0,0 +1,25 @@
+import type { ElementPanelSlots } from '../slots';
+import { type LibraryElement, type ViewConnector } from '../types';
+export interface ElementPanelProps extends ElementPanelSlots {
+    isOpen: boolean;
+    onClose: () => void;
+    element?: LibraryElement | null;
+    onSave: (obj: LibraryElement) => void;
+    autoSave?: boolean;
+    onDelete?: (id: number) => void;
+    onPermanentDelete?: (id: number) => void;
+    orgId?: string;
+    links?: ViewConnector[];
+    parentLinks?: ViewConnector[];
+    hasBackdrop?: boolean;
+    availableTags?: string[];
+}
+/**
+ * Name: Edit Element Panel
+ * Role: Opens when clicked on an element and displays its fields, allowing for editing.
+ * Location: Right side of the screen on desktop. Overlays screen on mobile.
+ * Aliases: Element Properties, Element Details.
+ */
+declare function ElementPanel({ isOpen, onClose, element, onSave, autoSave, onDelete, onPermanentDelete, orgId, links, parentLinks, hasBackdrop, availableTags, elementPanelAfterContentSlot }: ElementPanelProps): import("react/jsx-runtime").JSX.Element;
+declare const _default: import("react").MemoExoticComponent<typeof ElementPanel>;
+export default _default;

package/dist/components/ExploreOnboarding.d.ts

@@ -0,0 +1,5 @@
+interface Props {
+    hasLinkedNodes: boolean;
+}
+export default function ExploreOnboarding({ hasLinkedNodes }: Props): import("react/jsx-runtime").JSX.Element | null;
+export {};

package/dist/components/ExplorePageOnboarding.d.ts

@@ -0,0 +1,5 @@
+interface Props {
+    hasDiagrams: boolean;
+}
+export default function ExplorePageOnboarding({ hasDiagrams }: Props): import("react/jsx-runtime").JSX.Element | null;
+export {};

package/dist/components/ExportModal.d.ts

@@ -0,0 +1,16 @@
+export type ExportFormat = 'svg' | 'png' | 'mermaid';
+export interface ExportOptions {
+    format: ExportFormat;
+    scale: 1 | 2 | 3;
+    filename: string;
+}
+interface Props {
+    isOpen: boolean;
+    onClose: () => void;
+    defaultFilename: string;
+    isExporting?: boolean;
+    onExport: (options: ExportOptions) => Promise<void> | void;
+}
+declare function ExportModal({ isOpen, onClose, defaultFilename, isExporting, onExport, }: Props): import("react/jsx-runtime").JSX.Element;
+declare const _default: import("react").MemoExoticComponent<typeof ExportModal>;
+export default _default;

package/dist/components/FloatingEdge.d.ts

@@ -0,0 +1,9 @@
+import { type EdgeProps } from 'reactflow';
+export interface FloatingConnectorData {
+    color: string;
+    /** true = portal/navigational link (dotted), false = hierarchy (solid) */
+    dashed?: boolean;
+}
+declare function FloatingConnector({ source, target, data, selected, }: EdgeProps<FloatingConnectorData>): import("react/jsx-runtime").JSX.Element | null;
+declare const _default: import("react").MemoExoticComponent<typeof FloatingConnector>;
+export default _default;

package/dist/components/GitSourceLinker.d.ts

@@ -0,0 +1,8 @@
+import type { LibraryElement } from '../types';
+interface Props {
+    element: LibraryElement;
+    isReadOnly: boolean;
+    onUpdate: (updates: Partial<LibraryElement>) => void;
+}
+export default function GitSourceLinker({ element, isReadOnly, onUpdate }: Props): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/HeaderContext.d.ts

@@ -0,0 +1,16 @@
+import React from 'react';
+type HeaderPayload = {
+    node: React.ReactNode | null;
+    hideMobileBar?: boolean;
+} | React.ReactNode | null;
+type HeaderSetter = (payload: HeaderPayload) => void;
+declare const HeaderContext: React.Context<{
+    header: HeaderPayload;
+    setHeader: HeaderSetter;
+} | undefined>;
+export declare function HeaderProvider({ children }: {
+    children: React.ReactNode;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function useSetHeader(): HeaderSetter;
+export declare function useHeader(): HeaderPayload;
+export default HeaderContext;

package/dist/components/Icons.d.ts

@@ -0,0 +1,95 @@
+export declare function ZoomOutIcon({ size, strokeWidth }: {
+    size?: number;
+    strokeWidth?: number;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function ZoomInIcon({ size, strokeWidth }: {
+    size?: number;
+    strokeWidth?: number;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function AddElementIcon({ size, strokeWidth }: {
+    size?: number;
+    strokeWidth?: number;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function FitViewIcon({ size, strokeWidth }: {
+    size?: number;
+    strokeWidth?: number;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function ShareIcon({ size, strokeWidth }: {
+    size?: number;
+    strokeWidth?: number;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function TrashIcon({ size, strokeWidth }: {
+    size?: number;
+    strokeWidth?: number;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function EditIcon({ size, strokeWidth }: {
+    size?: number;
+    strokeWidth?: number;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function GitIcon({ size, strokeWidth }: {
+    size?: number;
+    strokeWidth?: number;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function MoveSourceIcon({ size, strokeWidth }: {
+    size?: number;
+    strokeWidth?: number;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function MoveTargetIcon({ size, strokeWidth }: {
+    size?: number;
+    strokeWidth?: number;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function NavigationIcon({ size, strokeWidth }: {
+    size?: number;
+    strokeWidth?: number;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function LibraryIcon({ size }: {
+    size?: number;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function ExpandExtrasIcon({ size, strokeWidth }: {
+    size?: number;
+    strokeWidth?: number;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function CollapseExtrasIcon({ size, strokeWidth }: {
+    size?: number;
+    strokeWidth?: number;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function EyeIcon({ size, strokeWidth }: {
+    size?: number;
+    strokeWidth?: number;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function EyeOffIcon({ size, strokeWidth }: {
+    size?: number;
+    strokeWidth?: number;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function ImportIcon({ size, strokeWidth }: {
+    size?: number;
+    strokeWidth?: number;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function LayerIcon({ size, strokeWidth }: {
+    size?: number;
+    strokeWidth?: number;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function ChevronLeftIcon({ size, strokeWidth }: {
+    size?: number;
+    strokeWidth?: number;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function ChevronRightIcon({ size, strokeWidth }: {
+    size?: number;
+    strokeWidth?: number;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function ChevronDownIcon({ size, strokeWidth }: {
+    size?: number;
+    strokeWidth?: number;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function TagsIcon({ size, strokeWidth }: {
+    size?: number;
+    strokeWidth?: number;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function GridIcon({ size, strokeWidth }: {
+    size?: number;
+    strokeWidth?: number;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function FocusIcon({ size, strokeWidth }: {
+    size?: number;
+    strokeWidth?: number;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/components/ImportModal.d.ts

@@ -0,0 +1,10 @@
+import { ParsedImport } from '../pkg/importer/mermaid';
+interface Props {
+    isOpen: boolean;
+    onClose: () => void;
+    isImporting?: boolean;
+    onImport: (parsed: ParsedImport) => Promise<void> | void;
+}
+declare function ImportModal({ isOpen, onClose, isImporting, onImport }: Props): import("react/jsx-runtime").JSX.Element;
+declare const _default: import("react").MemoExoticComponent<typeof ImportModal>;
+export default _default;

package/dist/components/InlineElementAdder.d.ts

@@ -0,0 +1,17 @@
+import type { LibraryElement } from '../types';
+interface Props {
+    x: number;
+    y: number;
+    allElements: LibraryElement[];
+    existingElementIds: Set<number>;
+    onConfirmNew: (name: string) => Promise<void>;
+    onConfirmExisting: (obj: LibraryElement) => Promise<void>;
+    onCancel: () => void;
+    expandResults?: boolean;
+    allowCreate?: boolean;
+    placeholder?: string;
+    title?: string;
+    getSecondaryLabel?: (obj: LibraryElement) => string | null;
+}
+export default function InlineElementAdder({ x, y, allElements, existingElementIds, onConfirmNew, onConfirmExisting, onCancel, expandResults, allowCreate, placeholder, title, getSecondaryLabel, }: Props): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/LayoutSection.d.ts

@@ -0,0 +1,7 @@
+import type { ViewTreeNode } from '../types';
+interface Props {
+    view: ViewTreeNode | null;
+    canEdit: boolean;
+}
+export default function LayoutSection({ view, canEdit }: Props): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/LocalSourceLinker.d.ts

@@ -0,0 +1,8 @@
+import type { LibraryElement } from '../types';
+interface Props {
+    element: LibraryElement;
+    isReadOnly: boolean;
+    onUpdate: (updates: Partial<LibraryElement>) => void;
+}
+export default function LocalSourceLinker({ element, isReadOnly, onUpdate }: Props): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/MiniZoomOnboarding.d.ts

@@ -0,0 +1,5 @@
+interface Props {
+    isVisible: boolean;
+}
+export default function MiniZoomOnboarding({ isVisible }: Props): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/NavBreadcrumb.d.ts

@@ -0,0 +1,6 @@
+import type { ViewTreeNode } from '../types';
+interface Props {
+    diagram: ViewTreeNode;
+}
+export default function NavBreadcrumb({ diagram }: Props): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/NodeBody.d.ts

@@ -0,0 +1,12 @@
+import { FlexProps } from '@chakra-ui/react';
+interface ElementBodyProps extends FlexProps {
+    name: string;
+    type: string;
+    technology?: string;
+    logoUrl?: string;
+    nameSize?: string;
+    typeSize?: string;
+    techSize?: string;
+}
+export declare const ElementBody: ({ name, type, technology, logoUrl, nameSize, typeSize, techSize, children, ...props }: ElementBodyProps) => import("react/jsx-runtime").JSX.Element;
+export {};