@leavepulse/ui 0.43.2 → 0.43.3

package/dist/components/LpTable.vue.d.ts

@@ -0,0 +1,124 @@
+import { type ContextMenuItemDef } from "./LpContextMenu.vue";
+export interface TableColumn<Row> {
+    key: string;
+    label: string;
+    align?: "left" | "right" | "center";
+    width?: string;
+    /** Allow clicking the header to sort by this column. */
+    sortable?: boolean;
+    /**
+     * Offer "show only these values" in the header's menu, built from the values
+     * actually present in the rows. For a column that holds a small vocabulary —
+     * a type, a state, a site — where the question is "just the mains leads,
+     * please". Pointless on a column of unique values, so it is opt-in.
+     */
+    filterable?: boolean;
+    /**
+     * How a raw cell value reads in that filter list. `power_ac` is the stored
+     * vocabulary; the menu should say what the column itself says.
+     */
+    valueLabel?: (value: unknown) => string;
+    /** Keep this column out of the show/hide list — an actions column has no
+     *  name to offer and nothing to gain from being hidden. */
+    alwaysVisible?: boolean;
+}
+export interface SortState {
+    key: string;
+    dir: "asc" | "desc";
+}
+/**
+ * What a server-backed table asks for. `hidden` mirrors the header filter: the
+ * values unticked per column, so a value the server has never sent before shows
+ * up instead of being silently excluded.
+ */
+export interface TableQuery {
+    page: number;
+    pageSize: number;
+    sort: SortState | null;
+    hidden: Record<string, unknown[]>;
+}
+/**
+ * One page of a server-backed table. `facets` are the distinct values of the
+ * filterable columns across the whole result — one page cannot know them, and a
+ * filter built from twenty-five rows would offer whatever happened to be on it.
+ */
+export interface TablePage<Row> {
+    rows: Row[];
+    total: number;
+    facets?: Record<string, unknown[]>;
+}
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: <T extends Record<string, unknown>>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: import("vue").PublicProps & __VLS_PrettifyLocal<{
+        columns: TableColumn<T>[];
+        /** The rows, for a table that holds its data. Ignored when `load` is set. */
+        rows?: T[];
+        /**
+         * Fetch the rows instead of being handed them: paging, sorting and the
+         * header filters then happen on the server. Debounced and abortable, the
+         * same way as the command palette's `search` — a stale page never lands
+         * over a fresher one.
+         */
+        load?: (query: TableQuery, signal: AbortSignal) => TablePage<T> | Promise<TablePage<T>>;
+        /** Rows per page with `load`. */
+        pageSize?: number;
+        /** Wait after a sort or filter change before `load` runs. */
+        debounce?: number;
+        loadingLabel?: string;
+        errorLabel?: string;
+        /** Stable id per row — required for selection; falls back to index otherwise. */
+        rowKey?: keyof T | ((row: T) => string | number);
+        emptyLabel?: string;
+        emptyIcon?: string;
+        /** Render a leading checkbox column; selection binds via v-model:selected. */
+        selectable?: boolean;
+        /** Selected row keys (v-model:selected). */
+        selected?: (string | number)[];
+        /** Active sort (v-model:sort). When set, the parent owns ordering (server
+         *  side); otherwise the table sorts its own rows client-side. */
+        sort?: SortState | null;
+        /** Pin the header while the body scrolls. Pair with a height on the wrapper. */
+        stickyHeader?: boolean;
+        /** Per-row right-click menu. Return [] (or omit the prop) to disable it for
+         *  a row; the row then keeps the browser's native context menu. */
+        rowMenu?: (row: T) => ContextMenuItemDef[];
+        /** Wording for the header's right-click menu. Passed in because the kit
+         *  carries no translations: an app that leaves these alone gets English. */
+        sortAscLabel?: string;
+        sortDescLabel?: string;
+        sortClearLabel?: string;
+        /** Wording for the value filter and the column chooser. */
+        filterLabel?: string;
+        showAllLabel?: string;
+        columnsLabel?: string;
+    } & {
+        "onUpdate:selected"?: ((value: (string | number)[]) => any) | undefined;
+        "onUpdate:sort"?: ((value: SortState | null) => any) | undefined;
+        onRowClick?: ((row: T) => any) | undefined;
+    }> & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: import("vue").ShallowUnwrapRef<{
+        reload: () => void;
+    }>) => void;
+    attrs: any;
+    slots: {
+        [x: `cell-${string}`]: ((props: {
+            row: T;
+            value: unknown;
+        }) => any) | undefined;
+    };
+    emit: {
+        (e: "update:selected", value: (string | number)[]): void;
+        (e: "update:sort", value: SortState | null): void;
+        (e: "rowClick", row: T): void;
+    };
+}>) => import("vue").VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+type __VLS_PrettifyLocal<T> = (T extends any ? {
+    [K in keyof T]: T[K];
+} : {
+    [K in keyof T as K]: T[K];
+}) & {};

package/dist/components/LpTableOfContents.vue.d.ts

@@ -0,0 +1,19 @@
+export interface TocLink {
+    id: string;
+    text: string;
+    depth?: number;
+    children?: TocLink[];
+}
+type __VLS_Props = {
+    links: TocLink[];
+    /** Heading shown above the list. */
+    title?: string;
+    /** px offset from the top used as the scroll-spy trigger line. */
+    offset?: number;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    title: string;
+    offset: number;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/components/LpTabs.vue.d.ts

@@ -0,0 +1,47 @@
+export interface TabItem {
+    value: string;
+    label: string;
+    /** Optional iconify name (e.g. "lucide:palette"), shown left of the label. */
+    icon?: string;
+}
+type __VLS_Props = {
+    modelValue?: string;
+    items: TabItem[];
+    /**
+     * "contained" (default) wraps the triggers in a bordered, filled bar.
+     * "plain" drops the container chrome — a flat row of tabs with only the
+     * sliding pill marking the active one (for nav bars over a custom surface).
+     * "underline" is a flat row over a hairline baseline, marking the active
+     * tab with a sliding bottom bar instead of a pill (page-section nav style).
+     */
+    variant?: "contained" | "plain" | "underline";
+    /** Tint the active pill + label with the brand colour (nav-bar style). */
+    accent?: boolean;
+    /** Stretch the bar to full width with equal-share triggers. */
+    block?: boolean;
+};
+declare var __VLS_49: {
+    value: string;
+}, __VLS_51: {};
+type __VLS_Slots = {} & {
+    panel?: (props: typeof __VLS_49) => any;
+} & {
+    default?: (props: typeof __VLS_51) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
+    "update:modelValue": (value: string) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+}>, {
+    block: boolean;
+    variant: "contained" | "plain" | "underline";
+    accent: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/LpTextarea.vue.d.ts

@@ -0,0 +1,22 @@
+type __VLS_Props = {
+    modelValue?: string;
+    placeholder?: string;
+    rows?: number;
+    invalid?: boolean;
+    disabled?: boolean;
+    label?: string;
+    hint?: string;
+    error?: string;
+    /**
+     * Marks the label with the required indicator; the attribute still reaches
+     * the <textarea> for native validation.
+     */
+    required?: boolean;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
+    "update:modelValue": (value: string) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/components/LpThemeSwitcher.vue.d.ts

@@ -0,0 +1,47 @@
+import type { TokenSet } from "../theme/tokens";
+type __VLS_Props = {
+    /** Active theme NAME (v-model). Falls back to the first theme. */
+    modelValue?: string;
+    /** Themes to offer. Defaults to all built-in presets. */
+    themes?: TokenSet[];
+    /**
+     * Themes the LEFT-click cycles through — names from `themes`, or TokenSets.
+     * Defaults to the full list (cycle everything). Pass two, e.g.
+     * `:cycle-themes="['Dark', 'Light']"`, for a quick dark/light toggle while
+     * the right-click menu still offers every theme.
+     */
+    cycleThemes?: (string | TokenSet)[];
+    /**
+     * Trigger style:
+     *  - "swatch" (default): a square showing the active theme's brand colour.
+     *  - "icon": a sun/moon icon following the active theme's mode.
+     *  - "pill": swatch + the theme name in a pill (always shows the label).
+     */
+    variant?: "swatch" | "icon" | "pill";
+    /** Show the active theme's name next to the trigger (forced on for "pill"). */
+    showLabel?: boolean;
+    /**
+     * Default theme applied on mount when nothing is cached yet — the theme NAME
+     * (must be in `themes`) or a TokenSet. Lets a consuming app pick its default
+     * declaratively (<LpThemeSwitcher :default="'Violet'">) with no separate
+     * bootstrap plugin; a previously saved choice still wins over it.
+     */
+    default?: string | TokenSet;
+    /** Animate theme changes with the circular reveal. On by default. */
+    transition?: boolean;
+    size?: "sm" | "md" | "lg";
+    "aria-label"?: string;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
+    change: (theme: TokenSet) => any;
+    "update:modelValue": (name: string) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onChange?: ((theme: TokenSet) => any) | undefined;
+    "onUpdate:modelValue"?: ((name: string) => any) | undefined;
+}>, {
+    size: "sm" | "md" | "lg";
+    transition: boolean;
+    variant: "swatch" | "icon" | "pill";
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/components/LpTilt.vue.d.ts

@@ -0,0 +1,31 @@
+type __VLS_Props = {
+    /** Max rotation toward the pointer, in degrees. */
+    max?: number;
+    /** Upward lift on hover, in px. */
+    lift?: number;
+    /** Scale on hover. */
+    scale?: number;
+    /** Render a pointer-tracking glare highlight over the content. */
+    glare?: boolean;
+    /** Perspective depth for the 3D stage, in px. Lower = stronger. */
+    perspective?: number;
+};
+declare var __VLS_1: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    scale: number;
+    max: number;
+    perspective: number;
+    lift: number;
+    glare: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/LpTimeField.vue.d.ts

@@ -0,0 +1,24 @@
+type __VLS_Props = {
+    /** Selected time "HH:mm" (v-model). */
+    modelValue?: string;
+    disabled?: boolean;
+    invalid?: boolean;
+    size?: "sm" | "md" | "lg";
+    /** 24 or 12-hour clock, independent of the browser locale. */
+    hourCycle?: 12 | 24;
+    /** Locale for segment order and the AM/PM marker in 12-hour mode. */
+    locale?: string;
+    /** Show the clock icon at the start of the field. */
+    icon?: boolean;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
+    "update:modelValue": (value: string | undefined) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    "onUpdate:modelValue"?: ((value: string | undefined) => any) | undefined;
+}>, {
+    size: "sm" | "md" | "lg";
+    icon: boolean;
+    hourCycle: 12 | 24;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/components/LpToaster.vue.d.ts

@@ -0,0 +1,3 @@
+declare const __VLS_export: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/components/LpTooltip.vue.d.ts

@@ -0,0 +1,58 @@
+type __VLS_Props = {
+    content?: string;
+    sideOffset?: number;
+    /** Which edge to prefer; flips automatically when there is no room. */
+    side?: "top" | "right" | "bottom" | "left";
+    /**
+     * The tip names the control rather than describing it — for a trigger with
+     * no visible text of its own. Sets the accessible name instead of only
+     * adding a description.
+     */
+    label?: boolean;
+    /** Milliseconds before the tip appears on hover. */
+    delay?: number;
+    /**
+     * Show on any focus, not just keyboard focus. Off by default: a tip that
+     * pops up after every mouse click on the trigger is noise.
+     */
+    showOnPointerFocus?: boolean;
+    /**
+     * Track the pointer instead of anchoring to the trigger's edge.
+     *
+     * For a trigger that is large or oddly shaped — a chart slice, a canvas, a
+     * map region — where the element's bounding box says little about what the
+     * pointer is actually over: anchored to the box, the tip can appear far from
+     * the thing it describes. Following the cursor keeps it next to the reading.
+     */
+    followCursor?: boolean;
+    /**
+     * Suppress the tip. For a trigger whose tip only applies to part of it — a
+     * chart wrapper where the pointer may be over a mark or over empty canvas —
+     * so an empty panel never opens over the gaps.
+     *
+     * This also FORCES CLOSED a tip that is already showing. reka's own
+     * `disabled` does not: it stops managing the tooltip where it stands, so one
+     * that was open when the flag flipped stayed on screen for good — outliving
+     * the pointer, letting a second chart open its own beside it, and surviving
+     * a scroll that should have dismissed it.
+     */
+    disabled?: boolean;
+};
+declare var __VLS_24: {}, __VLS_38: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_24) => any;
+} & {
+    content?: (props: typeof __VLS_38) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    delay: number;
+    side: "top" | "right" | "bottom" | "left";
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/LpTopologyCanvas.vue.d.ts

@@ -0,0 +1,205 @@
+import { type Connection } from "@vue-flow/core";
+import { type InfraNodeData } from "./LpInfraNode.vue";
+import { type ServiceNodeData } from "./LpServiceNode.vue";
+export type EdgeObserved = "applied" | "pending" | "drift";
+export interface TopologyNode {
+    id: string;
+    position: {
+        x: number;
+        y: number;
+    };
+    /** Host/group nodes use InfraNodeData; service nodes use ServiceNodeData. */
+    data: InfraNodeData | ServiceNodeData;
+    /**
+     * Node kind: "infra" (a host card, default), "service" (a small service node
+     * placed inside a host frame), or "group" (a host frame that contains
+     * services). Services set `parent` to their group's id.
+     */
+    type?: "infra" | "service" | "group";
+    /** For service nodes: the id of the host-frame group node they live in. */
+    parent?: string;
+    /** For group nodes: pixel size of the frame, and an optional label. */
+    width?: number;
+    height?: number;
+    label?: string;
+}
+/**
+ * Edge semantics, encoded with both colour AND line style so the two kinds read
+ * apart at a glance (and for colour-blind users): "network" = a transport wire
+ * between hosts (solid, brand-cyan); "structural" = a depends_on relation
+ * between services (dotted, violet, thinner). Inferred from `kind` when omitted
+ * (`depends_on` → structural, everything else → network).
+ */
+export type EdgeCategory = "network" | "structural";
+export interface TopologyEdge {
+    id: string;
+    source: string;
+    target: string;
+    /** transport label shown on the edge (e.g. "wg", "cloudflared"). */
+    kind?: string;
+    /** Semantic class driving colour + dash. Inferred from `kind` if omitted. */
+    category?: EdgeCategory;
+    observed?: EdgeObserved;
+    /**
+     * Push the edge into the background, matching the node data's `dimmed`. A
+     * focus highlight has to fade the edges too — dimming only the nodes leaves
+     * every unrelated line at full strength.
+     */
+    dimmed?: boolean;
+    /**
+     * Points the edge should curve through, when the host's layout knows where
+     * the gaps are. Requires `edgeType: "waypoints"`; ignored otherwise.
+     */
+    waypoints?: {
+        x: number;
+        y: number;
+    }[];
+}
+/**
+ * A background swimlane: a sized zone (one per project / overlay network) drawn
+ * beneath the nodes. The consumer computes the geometry; the canvas renders it
+ * as a non-interactive Vue Flow node so it pans/zooms in lockstep with the
+ * graph. Lanes are layered below real nodes and never intercept pointer events.
+ */
+export interface TopologyLane {
+    id: string;
+    label: string;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    /** Optional accent colour token for the lane border + label. */
+    accent?: string;
+}
+/** Canvas viewport transform — for restoring a saved pan/zoom. */
+export interface CanvasViewport {
+    x: number;
+    y: number;
+    zoom: number;
+}
+type __VLS_Props = {
+    nodes: TopologyNode[];
+    edges: TopologyEdge[];
+    /** Allow drag-to-connect (emits `connect`). Default false (read-only). */
+    connectable?: boolean;
+    /**
+     * Desktop-style marquee selection: drag on empty canvas to rubber-band a
+     * box and select every node inside; the selected set then drags together.
+     * Hold Shift to add to the selection. Panning moves to a right-drag / the
+     * space bar so left-drag is free for selecting. Default false (left-drag
+     * pans, the classic read-only behaviour). Emits `selection-change`.
+     */
+    selectable?: boolean;
+    /** Show the edge-type legend (Network / Depends-on / Pending / Drift). */
+    legend?: boolean;
+    /**
+     * Where the legend sits. Defaults to bottom-left: hosts commonly float a
+     * toolbar across the top, which would cover a top-anchored legend, and the
+     * minimap owns the bottom-right.
+     */
+    legendPosition?: "top-left" | "top-right" | "bottom-left" | "bottom-right";
+    /**
+     * Edge shape. The default bezier bulges away from the straight line between
+     * its ends, which suits a free-form graph and cuts through everything in a
+     * LAYERED one — a long edge crosses the cards standing between its columns.
+     * `smoothstep` routes orthogonally through the gaps instead.
+     */
+    edgeType?: "default" | "smoothstep" | "step" | "straight" | "waypoints";
+    /** Rename legend rows to match what this graph's edges actually mean. */
+    legendLabels?: Partial<Record<"network" | "structural" | "pending" | "drift", string>>;
+    /**
+     * Background swimlanes drawn beneath the nodes (one per project / overlay).
+     * Non-interactive; pan/zoom with the graph. Empty = no lanes.
+     */
+    lanes?: TopologyLane[];
+    /**
+     * Minimap and zoom controls. On by default — a full-page map needs both —
+     * but a graph embedded at a few hundred pixels has nothing to navigate, and
+     * the overlays then cover a real share of the picture.
+     */
+    minimap?: boolean;
+    controls?: boolean;
+};
+declare function applyViewport(v: CanvasViewport): Promise<void>;
+declare var __VLS_29: {};
+type __VLS_Slots = {} & {
+    'legend-extra'?: (props: typeof __VLS_29) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {
+    fitView: import("@vue-flow/core").FitView;
+    setViewport: typeof applyViewport;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
+    connect: (value: Connection) => any;
+    "node-select": (id: string) => any;
+    "node-activate": (id: string) => any;
+    "node-contextmenu": (value: {
+        id: string;
+        x: number;
+        y: number;
+    }) => any;
+    "edge-contextmenu": (value: {
+        id: string;
+        x: number;
+        y: number;
+    }) => any;
+    "pane-click": () => any;
+    "selection-change": (ids: string[]) => any;
+    "update:nodes": (value: TopologyNode[]) => any;
+    "node-drag-stop": (value: {
+        id: string;
+        position: {
+            x: number;
+            y: number;
+        };
+    }) => any;
+    "viewport-change": (value: {
+        zoom: number;
+        x: number;
+        y: number;
+    }) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onConnect?: ((value: Connection) => any) | undefined;
+    "onNode-select"?: ((id: string) => any) | undefined;
+    "onNode-activate"?: ((id: string) => any) | undefined;
+    "onNode-contextmenu"?: ((value: {
+        id: string;
+        x: number;
+        y: number;
+    }) => any) | undefined;
+    "onEdge-contextmenu"?: ((value: {
+        id: string;
+        x: number;
+        y: number;
+    }) => any) | undefined;
+    "onPane-click"?: (() => any) | undefined;
+    "onSelection-change"?: ((ids: string[]) => any) | undefined;
+    "onUpdate:nodes"?: ((value: TopologyNode[]) => any) | undefined;
+    "onNode-drag-stop"?: ((value: {
+        id: string;
+        position: {
+            x: number;
+            y: number;
+        };
+    }) => any) | undefined;
+    "onViewport-change"?: ((value: {
+        zoom: number;
+        x: number;
+        y: number;
+    }) => any) | undefined;
+}>, {
+    legend: boolean;
+    controls: boolean;
+    connectable: boolean;
+    selectable: boolean;
+    legendPosition: "top-left" | "top-right" | "bottom-left" | "bottom-right";
+    lanes: TopologyLane[];
+    minimap: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/LpUptimeBar.vue.d.ts

@@ -0,0 +1,46 @@
+export type UptimeStatus = "operational" | "degraded" | "down" | "maintenance" | "empty";
+export interface UptimeSegment {
+    /** Health of this slice. `empty` renders a faded placeholder (no data). */
+    status: UptimeStatus;
+    /** Optional rich tooltip body; falls back to a humanised status. */
+    label?: string;
+}
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: import("vue").DefineComponent<{
+    /** Oldest → newest. Each entry is one slice of the timeline. */
+    segments: UptimeSegment[];
+    /** Caption shown under the left edge (oldest point). */
+    startLabel?: string;
+    /** Caption shown under the right edge (newest point). */
+    endLabel?: string;
+    /** Show the computed uptime % above the bar. */
+    showUptime?: boolean;
+    /** Override the headline shown next to the uptime %. */
+    title?: string;
+    /**
+     * Per-status colours. Any CSS colour (hex, rgb, `var(--token)`). Unset
+     * statuses fall back to the theme tokens below. Pass e.g.
+     * `{ degraded: '#ffb84d' }` to recolour just one state.
+     */
+    colors?: Partial<Record<UptimeStatus, string>>;
+}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{
+    /** Oldest → newest. Each entry is one slice of the timeline. */
+    segments: UptimeSegment[];
+    /** Caption shown under the left edge (oldest point). */
+    startLabel?: string;
+    /** Caption shown under the right edge (newest point). */
+    endLabel?: string;
+    /** Show the computed uptime % above the bar. */
+    showUptime?: boolean;
+    /** Override the headline shown next to the uptime %. */
+    title?: string;
+    /**
+     * Per-status colours. Any CSS colour (hex, rgb, `var(--token)`). Unset
+     * statuses fall back to the theme tokens below. Pass e.g.
+     * `{ degraded: '#ffb84d' }` to recolour just one state.
+     */
+    colors?: Partial<Record<UptimeStatus, string>>;
+}> & Readonly<{}>, {
+    showUptime: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;

package/dist/components/LpWaypointEdge.vue.d.ts

@@ -0,0 +1,33 @@
+/**
+ * An edge that curves THROUGH a list of waypoints.
+ *
+ * The built-in shapes each fail one way in a layered graph: a bezier bulges off
+ * the line between its ends and cuts through whatever stands between the
+ * columns, and orthogonal routing clears the cards but draws the graph as a
+ * grid of right angles. Given the gaps a layout already knows about, a curve
+ * threaded through them is both — clear of the cards and still a curve.
+ *
+ * Waypoints ride on the edge's `data.waypoints`; with none, this is a plain
+ * bezier, so the type is safe to use for every edge in a graph.
+ */
+import { Position } from "@vue-flow/core";
+type __VLS_Props = {
+    id: string;
+    sourceX: number;
+    sourceY: number;
+    targetX: number;
+    targetY: number;
+    sourcePosition?: Position;
+    targetPosition?: Position;
+    data?: {
+        waypoints?: {
+            x: number;
+            y: number;
+        }[];
+    };
+    markerEnd?: string;
+    style?: Record<string, unknown>;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;