@leavepulse/ui 0.43.2 → 0.43.4

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

@@ -0,0 +1,90 @@
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: __VLS_WithSlots<import("vue").DefineComponent<{
+    /** Same syntax as the input's: "image/*", ".yaml,.yml". */
+    accept?: string;
+    /** Take more than one at a time. */
+    multiple?: boolean;
+    disabled?: boolean;
+    /**
+     * Also accept a paste anywhere on the page, not only while focused.
+     * Off by default: two zones both listening would each take the same
+     * screenshot, and a page with one obvious target is the case for it.
+     */
+    pasteTarget?: boolean;
+    /** Largest file accepted, in bytes. Bigger ones are rejected, not silently
+     *  dropped — a picture that vanishes reads as a broken uploader. */
+    maxBytes?: number;
+    icon?: string;
+    title?: string;
+    hint?: string;
+    /**
+     * How the well sits against what holds it. A drop target reads as a hole
+     * in the surface, not a tile on top of it, so the default is darker than
+     * the card — which is what a dashed border is already suggesting.
+     * `flush` for a zone that fills a panel of its own, `soft` when it sits
+     * directly on the page background and needs to lift off it instead.
+     */
+    tone?: "sunken" | "flush" | "soft";
+    /** Draw the entrance when the zone first comes into view. */
+    animate?: boolean;
+}, {
+    browse: () => void | undefined;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
+    files: (files: File[]) => any;
+    rejected: (reason: {
+        file: File;
+        cause: "type" | "size";
+    }[]) => any;
+}, string, import("vue").PublicProps, Readonly<{
+    /** Same syntax as the input's: "image/*", ".yaml,.yml". */
+    accept?: string;
+    /** Take more than one at a time. */
+    multiple?: boolean;
+    disabled?: boolean;
+    /**
+     * Also accept a paste anywhere on the page, not only while focused.
+     * Off by default: two zones both listening would each take the same
+     * screenshot, and a page with one obvious target is the case for it.
+     */
+    pasteTarget?: boolean;
+    /** Largest file accepted, in bytes. Bigger ones are rejected, not silently
+     *  dropped — a picture that vanishes reads as a broken uploader. */
+    maxBytes?: number;
+    icon?: string;
+    title?: string;
+    hint?: string;
+    /**
+     * How the well sits against what holds it. A drop target reads as a hole
+     * in the surface, not a tile on top of it, so the default is darker than
+     * the card — which is what a dashed border is already suggesting.
+     * `flush` for a zone that fills a panel of its own, `soft` when it sits
+     * directly on the page background and needs to lift off it instead.
+     */
+    tone?: "sunken" | "flush" | "soft";
+    /** Draw the entrance when the zone first comes into view. */
+    animate?: boolean;
+}> & Readonly<{
+    onFiles?: ((files: File[]) => any) | undefined;
+    onRejected?: ((reason: {
+        file: File;
+        cause: "type" | "size";
+    }[]) => any) | undefined;
+}>, {
+    title: string;
+    animate: boolean;
+    icon: string;
+    accept: string;
+    multiple: boolean;
+    hint: string;
+    tone: "sunken" | "flush" | "soft";
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, {
+    default?: (props: {
+        over: boolean;
+    }) => any;
+}>;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

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

@@ -0,0 +1,28 @@
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: __VLS_WithSlots<import("vue").DefineComponent<{
+    icon?: string;
+    title: string;
+    description?: string;
+    /**
+     * Tightens the block for empty states nested inside a card or a panel,
+     * where the full-page padding would dwarf its container.
+     */
+    compact?: boolean;
+}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{
+    icon?: string;
+    title: string;
+    description?: string;
+    /**
+     * Tightens the block for empty states nested inside a card or a panel,
+     * where the full-page padding would dwarf its container.
+     */
+    compact?: boolean;
+}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, {
+    default?: (props: {}) => any;
+}>;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

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

@@ -0,0 +1,126 @@
+import { type FileNode } from "./fileTree";
+export type { FileNode } from "./fileTree";
+/** Rolled-up stats for the ticked entries — what a backup picker summarises. */
+export interface FileTreeSummary {
+    /** Ticked files (directories excluded — they're containers, not payload). */
+    files: number;
+    /** Ticked directories. */
+    dirs: number;
+    /** Total bytes across ticked files, or undefined when no size is known. */
+    bytes?: number;
+    /** `bytes` pre-formatted ("2.4 GB"), or "—". */
+    sizeLabel: string;
+}
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: __VLS_WithSlots<import("vue").DefineComponent<{
+    nodes: FileNode[];
+    /** Selected node id (v-model:selected). */
+    selected?: string;
+    /** Expanded directory ids (v-model:expanded). Omit to let the tree own it. */
+    expanded?: string[];
+    /** Directory ids currently fetching children — shows a spinner on the row. */
+    loadingIds?: string[];
+    /**
+     * Multi-select mode: every row gets a tri-state checkbox and ticking a
+     * directory cascades to its loaded subtree. This is the mode for "pick what
+     * to back up" — `selected` stays independent (it's the highlighted row).
+     */
+    checkable?: boolean;
+    /** Ticked node ids (v-model:checked). */
+    checked?: string[];
+    /** Right-aligned size column (directories roll up their subtree). */
+    showSize?: boolean;
+    /** Right-aligned last-modified column. */
+    showModified?: boolean;
+    /** Directories first, then by name. Turn off to keep the caller's order. */
+    sort?: boolean;
+    /** Row icon size in px. */
+    iconSize?: number;
+    /** Skeleton rows while the initial listing loads. */
+    loading?: boolean;
+    skeletonRows?: number;
+    /** Empty-state copy when `nodes` is empty. */
+    emptyLabel?: string;
+    emptyDescription?: string;
+}, {
+    reveal: (id: string) => void;
+    expandAll: () => void;
+    collapseAll: () => void;
+    checkAll: () => void;
+    clearChecked: () => void;
+    summary: import("vue").ComputedRef<FileTreeSummary>;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
+    expand: (node: FileNode) => any;
+    select: (node: FileNode) => any;
+    summary: (summary: FileTreeSummary) => any;
+    open: (node: FileNode) => any;
+    collapse: (node: FileNode) => any;
+    "update:selected": (id: string) => any;
+    "update:expanded": (ids: string[]) => any;
+    "update:checked": (ids: string[]) => any;
+}, string, import("vue").PublicProps, Readonly<{
+    nodes: FileNode[];
+    /** Selected node id (v-model:selected). */
+    selected?: string;
+    /** Expanded directory ids (v-model:expanded). Omit to let the tree own it. */
+    expanded?: string[];
+    /** Directory ids currently fetching children — shows a spinner on the row. */
+    loadingIds?: string[];
+    /**
+     * Multi-select mode: every row gets a tri-state checkbox and ticking a
+     * directory cascades to its loaded subtree. This is the mode for "pick what
+     * to back up" — `selected` stays independent (it's the highlighted row).
+     */
+    checkable?: boolean;
+    /** Ticked node ids (v-model:checked). */
+    checked?: string[];
+    /** Right-aligned size column (directories roll up their subtree). */
+    showSize?: boolean;
+    /** Right-aligned last-modified column. */
+    showModified?: boolean;
+    /** Directories first, then by name. Turn off to keep the caller's order. */
+    sort?: boolean;
+    /** Row icon size in px. */
+    iconSize?: number;
+    /** Skeleton rows while the initial listing loads. */
+    loading?: boolean;
+    skeletonRows?: number;
+    /** Empty-state copy when `nodes` is empty. */
+    emptyLabel?: string;
+    emptyDescription?: string;
+}> & Readonly<{
+    onExpand?: ((node: FileNode) => any) | undefined;
+    onSelect?: ((node: FileNode) => any) | undefined;
+    onSummary?: ((summary: FileTreeSummary) => any) | undefined;
+    onOpen?: ((node: FileNode) => any) | undefined;
+    onCollapse?: ((node: FileNode) => any) | undefined;
+    "onUpdate:selected"?: ((id: string) => any) | undefined;
+    "onUpdate:expanded"?: ((ids: string[]) => any) | undefined;
+    "onUpdate:checked"?: ((ids: string[]) => any) | undefined;
+}>, {
+    sort: boolean;
+    loading: boolean;
+    skeletonRows: number;
+    emptyLabel: string;
+    iconSize: number;
+    checkable: boolean;
+    showSize: boolean;
+    showModified: boolean;
+    emptyDescription: string;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, {
+    /** Replace the row's label (icons, chevron and indent stay). */
+    row(props: {
+        node: FileNode;
+        depth: number;
+        expanded: boolean;
+        selected: boolean;
+    }): unknown;
+    /** Footer under the tree, handed the live selection stats. */
+    summary(props: FileTreeSummary): unknown;
+}>;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

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

@@ -0,0 +1,62 @@
+import { type FileNode, type NodeStats } from "./fileTree";
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: __VLS_WithSlots<import("vue").DefineComponent<{
+    node: FileNode;
+    /** Nesting depth, 0 at the root — drives the indent guide and aria-level. */
+    depth: number;
+    expanded: Set<string>;
+    loading: Set<string>;
+    selectedId?: string;
+    focusedId?: string;
+    sort: boolean;
+    /** Rendered size of the row's icon, in px. */
+    iconSize: number;
+    /** Render a tri-state checkbox per row (multi-select mode). */
+    checkable: boolean;
+    checked: Set<string>;
+    /** Per-node state, derived once by the root for the whole tree. */
+    stats: Map<string, NodeStats>;
+    showSize: boolean;
+    showModified: boolean;
+}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
+    check: (node: FileNode, value: boolean) => any;
+    focus: (node: FileNode) => any;
+    select: (node: FileNode) => any;
+    toggle: (node: FileNode) => any;
+}, string, import("vue").PublicProps, Readonly<{
+    node: FileNode;
+    /** Nesting depth, 0 at the root — drives the indent guide and aria-level. */
+    depth: number;
+    expanded: Set<string>;
+    loading: Set<string>;
+    selectedId?: string;
+    focusedId?: string;
+    sort: boolean;
+    /** Rendered size of the row's icon, in px. */
+    iconSize: number;
+    /** Render a tri-state checkbox per row (multi-select mode). */
+    checkable: boolean;
+    checked: Set<string>;
+    /** Per-node state, derived once by the root for the whole tree. */
+    stats: Map<string, NodeStats>;
+    showSize: boolean;
+    showModified: boolean;
+}> & Readonly<{
+    onCheck?: ((node: FileNode, value: boolean) => any) | undefined;
+    onFocus?: ((node: FileNode) => any) | undefined;
+    onSelect?: ((node: FileNode) => any) | undefined;
+    onToggle?: ((node: FileNode) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, {
+    row(props: {
+        node: FileNode;
+        depth: number;
+        expanded: boolean;
+        selected: boolean;
+    }): unknown;
+}>;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

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

@@ -0,0 +1,24 @@
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: __VLS_WithSlots<import("vue").DefineComponent<{
+    label?: string;
+    hint?: string;
+    error?: string;
+    required?: boolean;
+}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{
+    label?: string;
+    hint?: string;
+    error?: string;
+    required?: boolean;
+}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, {
+    default?: (props: {
+        id: string;
+    }) => any;
+} & {
+    hint?: (props: {}) => any;
+}>;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

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

@@ -0,0 +1,9 @@
+import "../icons";
+type __VLS_Props = {
+    /** iconify name, e.g. "lucide:check". Bare names assume the lucide set. */
+    name: string;
+    size?: number | string;
+};
+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;

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

@@ -0,0 +1,106 @@
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: import("vue").DefineComponent<{
+    /** The picture to work on. */
+    file: File | Blob;
+    /**
+     * Shape of the crop box.
+     *
+     * The named ones are shorthand for the common cases; a NUMBER is the real
+     * interface — `:aspect="2.35"` for anamorphic, `:aspect="0.8"` for a
+     * shelf label — so a consumer whose shape is not on the list is not stuck
+     * choosing the nearest wrong one. "free" keeps the source's own
+     * proportions and crops only what panning and zoom leave outside.
+     */
+    aspect?: "free" | "square" | "4:3" | "3:4" | "16:9" | number;
+    /** Longest edge of the exported image. Larger sources are scaled down. */
+    maxEdge?: number;
+    /**
+     * Encoding of the export; read the result's `blob.type` for the one used.
+     *
+     * JPEG, the default, is the smallest for photographs, the case this was
+     * built for. It has no alpha channel, though: a transparent PNG comes back
+     * with its background filled black, and a logo or an icon is ruined by the
+     * crop. "source" keeps the picture's own format where a canvas can write it
+     * (PNG, JPEG, WebP) and falls back to PNG for the ones it cannot (GIF, BMP,
+     * SVG), so transparency survives either way. An animated GIF still comes
+     * back as its first frame: a canvas holds one picture.
+     */
+    type?: "image/jpeg" | "image/png" | "image/webp" | "source";
+    /** Quality of a lossy export (JPEG, WebP); PNG ignores it. */
+    quality?: number;
+    /**
+     * Labels for the toolbar. Defaulted in English rather than left blank: an
+     * icon button with no accessible name is announced as "button", and the
+     * kit cannot reach the consumer's translations. Apps with i18n pass their
+     * own strings.
+     */
+    labels?: Partial<Record<"rotateLeft" | "rotateRight" | "zoomIn" | "zoomOut" | "reset" | "canvas", string>>;
+    /** Fade the picture in when the editor first comes into view. */
+    animate?: boolean;
+}, {
+    export: () => Promise<Blob | null>;
+    reset: () => void;
+    edited: import("vue").ComputedRef<boolean>;
+    shortcuts: readonly [{
+        readonly keys: readonly ["←", "→", "↑", "↓"];
+        readonly label: "Pan (Shift for a bigger step)";
+    }, {
+        readonly keys: readonly ["+", "−"];
+        readonly label: "Zoom";
+    }, {
+        readonly keys: readonly ["R"];
+        readonly label: "Rotate a quarter turn (Shift reverses)";
+    }, {
+        readonly keys: readonly ["Alt", "wheel"];
+        readonly label: "Turn freely (Shift snaps to 15°)";
+    }, {
+        readonly keys: readonly ["0"];
+        readonly label: "Reset";
+    }];
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{
+    /** The picture to work on. */
+    file: File | Blob;
+    /**
+     * Shape of the crop box.
+     *
+     * The named ones are shorthand for the common cases; a NUMBER is the real
+     * interface — `:aspect="2.35"` for anamorphic, `:aspect="0.8"` for a
+     * shelf label — so a consumer whose shape is not on the list is not stuck
+     * choosing the nearest wrong one. "free" keeps the source's own
+     * proportions and crops only what panning and zoom leave outside.
+     */
+    aspect?: "free" | "square" | "4:3" | "3:4" | "16:9" | number;
+    /** Longest edge of the exported image. Larger sources are scaled down. */
+    maxEdge?: number;
+    /**
+     * Encoding of the export; read the result's `blob.type` for the one used.
+     *
+     * JPEG, the default, is the smallest for photographs, the case this was
+     * built for. It has no alpha channel, though: a transparent PNG comes back
+     * with its background filled black, and a logo or an icon is ruined by the
+     * crop. "source" keeps the picture's own format where a canvas can write it
+     * (PNG, JPEG, WebP) and falls back to PNG for the ones it cannot (GIF, BMP,
+     * SVG), so transparency survives either way. An animated GIF still comes
+     * back as its first frame: a canvas holds one picture.
+     */
+    type?: "image/jpeg" | "image/png" | "image/webp" | "source";
+    /** Quality of a lossy export (JPEG, WebP); PNG ignores it. */
+    quality?: number;
+    /**
+     * Labels for the toolbar. Defaulted in English rather than left blank: an
+     * icon button with no accessible name is announced as "button", and the
+     * kit cannot reach the consumer's translations. Apps with i18n pass their
+     * own strings.
+     */
+    labels?: Partial<Record<"rotateLeft" | "rotateRight" | "zoomIn" | "zoomOut" | "reset" | "canvas", string>>;
+    /** Fade the picture in when the editor first comes into view. */
+    animate?: boolean;
+}> & Readonly<{}>, {
+    type: "image/jpeg" | "image/png" | "image/webp" | "source";
+    animate: boolean;
+    labels: Partial<Record<"rotateLeft" | "rotateRight" | "zoomIn" | "zoomOut" | "reset" | "canvas", string>>;
+    aspect: "free" | "square" | "4:3" | "3:4" | "16:9" | number;
+    maxEdge: number;
+    quality: number;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;

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

@@ -0,0 +1,65 @@
+export interface InfraNodeData {
+    name: string;
+    /** Role key: selects the colour/glyph, and shown as-is unless `roleLabel`. */
+    role: string;
+    /**
+     * What to print for the role. The key itself ("host", "proxy") is an API
+     * value, not a word for an operator to read in their own language.
+     */
+    roleLabel?: string;
+    overlay?: string;
+    online?: boolean;
+    kind?: string;
+    project?: string;
+    /** Control-plane firewall rule count on this host (badge when > 0). */
+    firewallCount?: number;
+    /** Service count on this host (badge when defined — services toggle on). */
+    serviceCount?: number;
+    /**
+     * How old this node's readings are, human-readable ("28d"). An unreachable
+     * machine keeps serving its last snapshot, which reads as current unless the
+     * card says otherwise — so when set, the counts below are struck through and
+     * the age is shown in their place.
+     */
+    staleFor?: string;
+    /** Fade the node back (search miss / not part of the focused node's graph). */
+    dimmed?: boolean;
+    /**
+     * Wording for this node's badges. Carried in `data` because that is what
+     * LpTopologyCanvas forwards to the node renderer; a component prop would
+     * never reach it.
+     */
+    labels?: InfraNodeLabels;
+}
+/**
+ * Wording for the badges, so the node speaks the app's language.
+ *
+ * The kit ships English defaults; a localised app passes its own. `{n}` is the
+ * count, `{age}` the value of `staleFor`.
+ */
+export interface InfraNodeLabels {
+    /** Tooltip on the firewall badge. Default: "{n} firewall rule(s)". */
+    firewallRules?: string;
+    /** Tooltip on the service badge. Default: "{n} service(s)". */
+    services?: string;
+    /** Tooltip on the service badge when readings are stale. */
+    servicesStale?: string;
+    /** Tooltip on the staleness badge. */
+    noContact?: string;
+    /** Suffix after the age, e.g. "old" in "4m old". */
+    old?: string;
+}
+type __VLS_Props = {
+    data: InfraNodeData;
+    selected?: boolean;
+    /** Extra/overriding role styles, merged over the defaults below. */
+    roles?: Record<string, InfraRoleStyle>;
+};
+export interface InfraRoleStyle {
+    /** CSS colour — normally a var() reference, e.g. var(--color-node-edge). */
+    color: string;
+    icon: string;
+}
+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;

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

@@ -0,0 +1,80 @@
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: __VLS_WithSlots<import("vue").DefineComponent<{
+    modelValue?: string;
+    size?: "sm" | "md" | "lg" | undefined;
+    invalid?: boolean;
+    placeholder?: string;
+    type?: string;
+    disabled?: boolean;
+    label?: string;
+    hint?: string;
+    error?: string;
+    icon?: string;
+    /**
+     * Marks the label with the required indicator. The attribute still reaches
+     * the underlying <input> for native validation; this only makes the field
+     * read as required.
+     */
+    required?: boolean;
+    /**
+     * RegExp/string the whole value must match to be valid. Validation only —
+     * never blocks typing; a non-matching non-empty value shows the invalid
+     * style + aria-invalid. A bare string is anchored, like HTML `pattern`.
+     */
+    pattern?: RegExp | string;
+    /**
+     * One-char RegExp of allowed characters (e.g. /[0-9]/). Hard-blocks
+     * disallowed input/paste at the source — cursor- and IME-safe.
+     */
+    restrict?: RegExp;
+}, {
+    focus: (options?: FocusOptions) => void | undefined;
+    blur: () => void | undefined;
+    select: () => void | undefined;
+    input: import("vue").Ref<HTMLInputElement | null, HTMLInputElement | null>;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
+    "update:modelValue": (value: string) => any;
+}, string, import("vue").PublicProps, Readonly<{
+    modelValue?: string;
+    size?: "sm" | "md" | "lg" | undefined;
+    invalid?: boolean;
+    placeholder?: string;
+    type?: string;
+    disabled?: boolean;
+    label?: string;
+    hint?: string;
+    error?: string;
+    icon?: string;
+    /**
+     * Marks the label with the required indicator. The attribute still reaches
+     * the underlying <input> for native validation; this only makes the field
+     * read as required.
+     */
+    required?: boolean;
+    /**
+     * RegExp/string the whole value must match to be valid. Validation only —
+     * never blocks typing; a non-matching non-empty value shows the invalid
+     * style + aria-invalid. A bare string is anchored, like HTML `pattern`.
+     */
+    pattern?: RegExp | string;
+    /**
+     * One-char RegExp of allowed characters (e.g. /[0-9]/). Hard-blocks
+     * disallowed input/paste at the source — cursor- and IME-safe.
+     */
+    restrict?: RegExp;
+}> & Readonly<{
+    "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+}>, {
+    type: string;
+    size: "sm" | "md" | "lg";
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, {
+    leading?: (props: {}) => any;
+} & {
+    trailing?: (props: {}) => any;
+}>;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

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

@@ -0,0 +1,24 @@
+/**
+ * Custom Vue Flow node for a project SWIMLANE on LpTopologyCanvas: a sized
+ * background zone that groups the nodes of one project (overlay network). It is
+ * a NODE (not an overlay) so Vue Flow transforms it with pan/zoom for free.
+ *
+ * Purely decorative: the lane never intercepts pointer events (pan/drag pass
+ * through to the canvas), is non-selectable / non-draggable (set on the node
+ * object by the canvas), and sits below real nodes via a low z-index. The label
+ * tab stays clickable-looking but is inert. Tailwind utilities only so styles
+ * reach consumer apps via @source.
+ */
+export interface LaneNodeData {
+    label: string;
+    /** Optional accent colour token for the lane border + label. */
+    accent?: string;
+    width: number;
+    height: number;
+}
+type __VLS_Props = {
+    data: LaneNodeData;
+};
+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;