@cjlapao/ui-kit-vue 0.2.0

package/dist/types/vue/src/components/ConnectionFlow/types.d.ts

@@ -0,0 +1,220 @@
+import type { VNodeChild } from "vue";
+import type { TreeTone } from "../TreeView/types";
+export type ConnectionState = "flowing" | "stopped" | "disabled";
+export interface ConnectionFlowConnectorConfig {
+    /** Active flow state for this connector */
+    state?: ConnectionState;
+    /** Optional React element to render in the middle (e.g. an icon) */
+    icon?: VNodeChild;
+    /** Width of the connector band in px (default: 56) */
+    width?: number;
+    /** Whether to animate the flowing dots (default: true) */
+    animated?: boolean;
+    /** target px per dot cycle (default: 60) */
+    dotSpacing?: number;
+    /** Connector ring border width (default: 'xs') */
+    borderSize?: "fit" | "xs" | "sm" | "md" | "lg";
+    /** Whether to draw half-rings (default: true) */
+    halfRing?: boolean;
+    /** Show the horizontal line between rings (default: true) */
+    showLine?: boolean;
+    /** Override — force the source-side ring tone instead of inheriting from source item */
+    sourceTone?: TreeTone;
+    /** Override — force the target-side ring tone instead of inheriting from this item */
+    targetTone?: TreeTone;
+    /** Source ring background fill color (CSS string, e.g. '#22c55e' or 'rgba(...)') */
+    sourceFill?: string;
+    /** Source ring stroke/border color */
+    sourceBorder?: string;
+    /** Source ring center dot color */
+    sourceDot?: string;
+    /** Target ring background fill color */
+    targetFill?: string;
+    /** Target ring stroke/border color */
+    targetBorder?: string;
+    /** Target ring center dot color */
+    targetDot?: string;
+    /** Animated dot color (overrides what is derived from targetTone) */
+    dotColor?: string;
+    /**
+     * When true, flowing dots are shown even when this connector's state is `'stopped'`
+     * (i.e. already-traversed / completed edges also animate).
+     * Default: false
+     */
+    animateCompleted?: boolean;
+}
+export interface ConnectionFlowItem {
+    id: string;
+    icon?: VNodeChild;
+    iconClassName?: string;
+    title?: VNodeChild;
+    titleClassName?: string;
+    /** When true, the card title wraps on word boundaries up to 10 lines instead of truncating. Default: false */
+    titleWrap?: boolean;
+    /** When true, the card title stays on one line and scrolls horizontally. Default: false */
+    titleScroll?: boolean;
+    subtitle?: VNodeChild;
+    subtitleClassName?: string;
+    description?: VNodeChild;
+    descriptionClassName?: string;
+    /** Optional badge/status slot rendered below description, without tone-derived text styling. */
+    badge?: VNodeChild;
+    tone?: TreeTone;
+    body?: VNodeChild;
+    defaultExpanded?: boolean;
+    actions?: VNodeChild;
+    hoverActions?: VNodeChild;
+    /**
+     * Connector config for the edge leading INTO this item.
+     * If not provided, inherits from the ConnectionFlow's default state.
+     * Ignored for the first item (it has no predecessor).
+     */
+    connector?: ConnectionFlowConnectorConfig;
+    /**
+     * Children render vertically below this item's card using TreeView-style
+     * SVG connectors. The connector between this item and the next sibling
+     * spans the full column height (parent + children).
+     */
+    children?: ConnectionFlowItem[];
+    /**
+     * When true, this item has NO right-side connector to the next sibling
+     * (it terminates the horizontal flow after itself).
+     * Default: false
+     */
+    terminal?: boolean;
+    /**
+     * Active state — drives the vertical sub-tree dot animation color.
+     * Default: false
+     */
+    active?: boolean;
+    /**
+     * When true, this item is part of a parallel group. Consecutive items with
+     * parallel=true are rendered as a single vertical column instead of separate
+     * horizontal nodes. Fan-out (1→N) and fan-in (N→1) connectors are added automatically.
+     * Default: false
+     */
+    parallel?: boolean;
+    /**
+     * When true, the card shows a subtle hover lift effect (shadow + translate-y).
+     * Default: false
+     */
+    hoverable?: boolean;
+    /**
+     * When true, overlays a pulsing background animation on the card (uses the item's tone).
+     * Typically combined with `active: true` to indicate in-progress steps.
+     * Default: false
+     */
+    activePulse?: boolean;
+    /**
+     * When true, this step was skipped — the execution flow bypassed it.
+     * A visual bypass arc is drawn from the last non-skipped predecessor to the
+     * first non-skipped successor, arching over all consecutive skipped items.
+     * Default: false
+     */
+    skipped?: boolean;
+}
+export interface ConnectionFlowProps {
+    /** The nodes to render horizontally */
+    items: ConnectionFlowItem[];
+    /**
+     * Fallback state applied to any connector that doesn't have its own `state`.
+     * Default: 'flowing'
+     */
+    flowState?: ConnectionState;
+    /**
+     * Fallback icon shown in the middle of connectors (overridden per-item).
+     */
+    flowIcon?: VNodeChild;
+    /**
+     * Fallback connector width in px.
+     * Default: 56
+     */
+    connectorWidth?: number;
+    /**
+     * Whether flowing-dot animation is enabled globally.
+     * Default: true
+     */
+    animated?: boolean;
+    /**
+     * Target px between dots globally.
+     * Default: 60
+     */
+    dotSpacing?: number;
+    /**
+     * Ring border size globally.
+     * Default: 'xs'
+     */
+    connectorBorderSize?: "fit" | "xs" | "sm" | "md" | "lg";
+    /**
+     * Draw half-rings (matching TreeView half-connector style).
+     * Default: true
+     */
+    connectorHalf?: boolean;
+    /**
+     * Show the horizontal line between connectors.
+     * Default: true
+     */
+    showLine?: boolean;
+    /** Indent size for children sub-trees. Default: 'xs' */
+    childIndent?: "xs" | "sm" | "md" | "lg";
+    /** Row gap in px between children. Default: 8 */
+    childRowGap?: number;
+    /**
+     * If true, allows the flow to scroll horizontally/vertically if the container is smaller than the flow.
+     * Default: false
+     */
+    allowScroll?: boolean;
+    /**
+     * Set a fixed width for all items in the flow (e.g. 250, '300px').
+     * Primarily useful when `allowScroll` is enabled.
+     */
+    itemWidth?: number | string;
+    /**
+     * When true, automatically scales the entire flow down to fit the container width.
+     * Once the scale would go below `minScale`, the flow is clamped and allowed to scroll.
+     * Default: false
+     */
+    autoScale?: boolean;
+    /**
+     * Minimum CSS scale factor applied when `autoScale` is true.
+     * Below this value the flow falls back to horizontal scroll instead of shrinking further.
+     * Default: 0.55
+     */
+    minScale?: number;
+    /** Extra content to render to the right of the entire flow (e.g. an expand toggle) */
+    rightAction?: VNodeChild;
+    /**
+     * When true, connectors stretch to fill all remaining width instead of using a fixed
+     * pixel size. Card columns collapse to their natural content width. The connector icon
+     * is always positioned at the exact midpoint of the expanded connector.
+     * Default: false
+     */
+    fullWidthConnectors?: boolean;
+    /**
+     * When true, all cards in the flow show a hover lift effect.
+     * Default: false
+     */
+    hoverable?: boolean;
+    /**
+     * When true, flowing dots are rendered on `'stopped'` (completed / already-traversed)
+     * connectors in addition to `'flowing'` ones. Bypass arcs over skipped steps always
+     * animate when `animated` is true, regardless of this flag.
+     * Default: false
+     */
+    animateCompleted?: boolean;
+    /**
+     * When true, the engine automatically manages connector states and skipped detection
+     * based purely on each item's `tone`:
+     *
+     * - **Connector state** (when no explicit `connector.state` is set):
+     *   - Non-neutral source tone → `'stopped'` (solid toned line — step was traversed)
+     *   - Neutral source tone     → `'disabled'` (dashed gray  — step not yet reached)
+     *
+     * - **Skipped detection**: a neutral-tone item that has at least one non-neutral
+     *   successor is automatically treated as skipped — a bypass arc is drawn over it.
+     *
+     * Explicit per-item `connector.state` or `item.skipped` values always take precedence.
+     * Default: false
+     */
+    autoConnectorState?: boolean;
+}

package/dist/types/vue/src/components/CustomIcon.vue.d.ts

@@ -0,0 +1,24 @@
+import { type IconName } from "../icons/registry";
+import type { IconSize } from "../types/Icon";
+export interface CustomIconProps {
+    /** Name of the icon to display */
+    icon: IconName;
+    /** Alternative text for accessibility */
+    alt?: string;
+    /** Size of the icon in pixels */
+    customSize?: number | string;
+    /** Size of the icon: xs, sm, md, lg, xl */
+    size?: IconSize;
+    /** Whether the icon should use color or be monochrome */
+    colored?: boolean;
+    /** Primary color to use for the icon */
+    color?: string;
+    /** Hover color for the icon */
+    hoverColor?: string;
+}
+declare const _default: import("vue").DefineComponent<CustomIconProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<CustomIconProps> & Readonly<{}>, {
+    size: IconSize;
+    alt: string;
+    colored: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/types/vue/src/components/DetailItemCard.vue.d.ts

@@ -0,0 +1,25 @@
+export interface DetailItemCardProps {
+    title: string;
+    subtitle?: string;
+    description?: string;
+    defaultExpanded?: boolean;
+    badgesAlignment?: "bottom" | "right" | "bottom-end";
+}
+declare const _default: __VLS_WithSlots<import("vue").DefineComponent<DetailItemCardProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<DetailItemCardProps> & Readonly<{}>, {
+    defaultExpanded: boolean;
+    badgesAlignment: "bottom" | "right" | "bottom-end";
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, {
+    badges?: (props: {}) => any;
+} & {
+    badges?: (props: {}) => any;
+} & {
+    badges?: (props: {}) => any;
+} & {
+    default?: (props: {}) => any;
+}>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/types/vue/src/components/DropdownButton.vue.d.ts

@@ -0,0 +1,45 @@
+import type { ButtonProps, ButtonSize } from "./Button.vue";
+import type { DropdownMenuOption } from "./DropdownMenu.vue";
+export interface DropdownButtonOption extends DropdownMenuOption {
+    value: string;
+}
+export interface DropdownButtonProps extends Omit<ButtonProps, "leadingIcon" | "trailingIcon" | "iconOnly" | "fullWidth"> {
+    label?: string;
+    options: DropdownButtonOption[];
+    dropdownIcon?: ButtonProps["leadingIcon"];
+    fullWidth?: boolean;
+    split?: boolean;
+    /**
+     * Hide the dropdown caret trigger when there are no menu options.
+     * Defaults to true so empty split buttons render as a single clean button.
+     */
+    hideDropdownTriggerWhenEmpty?: boolean;
+    menuWidth?: number | "trigger";
+    menuClassName?: string;
+}
+declare const _default: __VLS_WithSlots<import("vue").DefineComponent<DropdownButtonProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    primaryClick: (event: MouseEvent) => any;
+    optionSelect: (option: DropdownButtonOption) => any;
+}, string, import("vue").PublicProps, Readonly<DropdownButtonProps> & Readonly<{
+    onPrimaryClick?: ((event: MouseEvent) => any) | undefined;
+    onOptionSelect?: ((option: DropdownButtonOption) => any) | undefined;
+}>, {
+    color: import("..").TrueColor;
+    variant: import("./Button.vue").ButtonVariant;
+    split: boolean;
+    size: ButtonSize;
+    fullWidth: boolean;
+    dropdownIcon: string | import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }>;
+    hideDropdownTriggerWhenEmpty: boolean;
+    menuWidth: number | "trigger";
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, {
+    default?: (props: {}) => any;
+}>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/types/vue/src/components/DropdownMenu.vue.d.ts

@@ -0,0 +1,33 @@
+import type { Ref, VNode } from "vue";
+export interface DropdownMenuOption {
+    label: string | VNode;
+    value: string;
+    description?: string | VNode;
+    icon?: string | VNode;
+    disabled?: boolean;
+    danger?: boolean;
+}
+export interface DropdownMenuProps {
+    /** Anchor element (or a template ref holding it) the menu is positioned against. */
+    anchorRef: HTMLElement | Ref<HTMLElement | null> | null;
+    open: boolean;
+    items: DropdownMenuOption[];
+    align?: "start" | "end";
+    side?: "auto" | "top" | "bottom";
+    width?: number | "trigger";
+    maxHeight?: number;
+    itemClassName?: string;
+}
+declare const _default: import("vue").DefineComponent<DropdownMenuProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    select: (item: DropdownMenuOption) => any;
+    close: () => any;
+}, string, import("vue").PublicProps, Readonly<DropdownMenuProps> & Readonly<{
+    onSelect?: ((item: DropdownMenuOption) => any) | undefined;
+    onClose?: (() => any) | undefined;
+}>, {
+    width: number | "trigger";
+    align: "start" | "end";
+    side: "auto" | "top" | "bottom";
+    maxHeight: number;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/types/vue/src/components/DynamicFormField.vue.d.ts

@@ -0,0 +1,16 @@
+import type { CapsuleBlueprintParameter } from "../types/CapsuleBlueprint";
+type DynamicValue = string | boolean;
+export interface DynamicFormFieldProps {
+    parameter: CapsuleBlueprintParameter;
+    value: DynamicValue;
+    error?: string;
+    isVisible?: boolean;
+}
+declare const _default: import("vue").DefineComponent<DynamicFormFieldProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    change: (serviceName: string, key: string, value: DynamicValue, triggerDependencyEvaluation?: boolean | undefined) => any;
+}, string, import("vue").PublicProps, Readonly<DynamicFormFieldProps> & Readonly<{
+    onChange?: ((serviceName: string, key: string, value: DynamicValue, triggerDependencyEvaluation?: boolean | undefined) => any) | undefined;
+}>, {
+    isVisible: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/types/vue/src/components/DynamicImg.vue.d.ts

@@ -0,0 +1,11 @@
+export interface DynamicImgProps {
+    base64: string;
+    fill?: string;
+    stroke?: string;
+    title?: string;
+    size?: "xs" | "sm" | "md" | "lg" | "xl";
+}
+declare const _default: import("vue").DefineComponent<DynamicImgProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<DynamicImgProps> & Readonly<{}>, {
+    size: "xs" | "sm" | "md" | "lg" | "xl";
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/types/vue/src/components/EmptyState.vue.d.ts

@@ -0,0 +1,53 @@
+import type { VNode } from "vue";
+import type { ButtonVariant, ButtonSize, ButtonColor } from "./Button.vue";
+import type { IconSize } from "../types/Icon";
+import type { Size, TrueColor } from "../theme/Theme";
+export type TextSize = "xs" | "sm" | "md" | "lg" | "xl";
+/** Accepts all theme colors. The original five semantic names (neutral/info/success/warning/danger) are preserved unchanged. */
+export type EmptyStateTone = TrueColor;
+export interface EmptyStateProps {
+    title?: string;
+    subtitle?: string;
+    actionLabel?: string;
+    onAction?: () => void;
+    actionVariant?: ButtonVariant;
+    actionColor?: ButtonColor;
+    icon?: string | VNode;
+    iconSize?: IconSize;
+    iconColor?: TrueColor;
+    textSize?: TextSize;
+    showIcon?: boolean;
+    tone?: EmptyStateTone;
+    disableBorder?: boolean;
+    transparentBackground?: boolean;
+    fullWidth?: boolean;
+    fullHeight?: boolean;
+    actionSize?: ButtonSize;
+    actionLeadingIcon?: string | VNode;
+    size?: Size;
+}
+declare const _default: __VLS_WithSlots<import("vue").DefineComponent<EmptyStateProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<EmptyStateProps> & Readonly<{}>, {
+    icon: string | VNode;
+    tone: EmptyStateTone;
+    size: Size;
+    fullWidth: boolean;
+    actionVariant: ButtonVariant;
+    actionColor: ButtonColor;
+    iconSize: IconSize;
+    textSize: TextSize;
+    showIcon: boolean;
+    disableBorder: boolean;
+    transparentBackground: boolean;
+    fullHeight: boolean;
+    actionSize: ButtonSize;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, {
+    title?: (props: {}) => any;
+} & {
+    subtitle?: (props: {}) => any;
+}>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/types/vue/src/components/FormField.vue.d.ts

@@ -0,0 +1,43 @@
+type FormFieldLayout = "stacked" | "inline";
+type FormFieldValidationStatus = "none" | "error" | "success";
+type FormFieldWidth = "auto" | "full";
+export interface FormFieldProps {
+    label?: string;
+    labelFor?: string;
+    description?: string;
+    hint?: string;
+    error?: string;
+    validationStatus?: FormFieldValidationStatus;
+    required?: boolean;
+    optionalLabel?: string;
+    labelAction?: string;
+    layout?: FormFieldLayout;
+    helpText?: string;
+    width?: FormFieldWidth;
+}
+declare const _default: __VLS_WithSlots<import("vue").DefineComponent<FormFieldProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<FormFieldProps> & Readonly<{}>, {
+    required: boolean;
+    width: FormFieldWidth;
+    layout: FormFieldLayout;
+    validationStatus: FormFieldValidationStatus;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, {
+    label?: (props: {}) => any;
+} & {
+    optionalLabel?: (props: {}) => any;
+} & {
+    description?: (props: {}) => any;
+} & {
+    labelAction?: (props: {}) => any;
+} & {
+    helpText?: (props: {}) => any;
+} & {
+    error?: (props: {}) => any;
+} & {
+    hint?: (props: {}) => any;
+}>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/types/vue/src/components/FormLayout.vue.d.ts

@@ -0,0 +1,20 @@
+type FormLayoutColumns = 1 | 2 | 3;
+type FormLayoutGap = "sm" | "md" | "lg";
+export interface FormLayoutProps {
+    columns?: FormLayoutColumns;
+    gap?: FormLayoutGap;
+    verticalPadding?: FormLayoutGap;
+}
+declare const _default: __VLS_WithSlots<import("vue").DefineComponent<FormLayoutProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<FormLayoutProps> & Readonly<{}>, {
+    columns: FormLayoutColumns;
+    gap: FormLayoutGap;
+    verticalPadding: FormLayoutGap;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, {
+    default?: (props: {}) => any;
+}>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/types/vue/src/components/FormSection.vue.d.ts

@@ -0,0 +1,23 @@
+export interface FormSectionProps {
+    title?: string;
+    description?: string;
+    footer?: string;
+    padding?: "sm" | "md" | "lg";
+}
+declare const _default: __VLS_WithSlots<import("vue").DefineComponent<FormSectionProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<FormSectionProps> & Readonly<{}>, {
+    padding: "sm" | "md" | "lg";
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, {
+    title?: (props: {}) => any;
+} & {
+    description?: (props: {}) => any;
+} & {
+    default?: (props: {}) => any;
+} & {
+    footer?: (props: {}) => any;
+}>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/types/vue/src/components/GlassBackground.vue.d.ts

@@ -0,0 +1,51 @@
+import type { CSSProperties } from "vue";
+import type { TrueColor } from "../theme/Theme";
+export type GradientDirection = "t" | "tr" | "r" | "br" | "b" | "bl" | "l" | "tl";
+export type GlassBackgroundPosition = "fixed" | "absolute";
+export interface GlassBackgroundProps {
+    /** Positioning mode.
+     *  `"fixed"` (default) — covers the full viewport, always visible.
+     *  `"absolute"` — fills a `position: relative` parent (e.g. a PlaygroundSection preview).
+     *  Parent must be `relative` when `"absolute"`.
+     */
+    position?: GlassBackgroundPosition;
+    /** Primary theme color driving the gradient (default: "purple"). */
+    color?: TrueColor;
+    /** Secondary color for the middle gradient stop. Derived from color if omitted. */
+    colorSecondary?: TrueColor;
+    /** Deep color for the final gradient stop. Derived if omitted. */
+    colorDeep?: TrueColor;
+    /** Gradient direction (default: "br" → bottom-right). */
+    direction?: GradientDirection;
+    /** Enable a slow-moving shimmer overlay (default: false). */
+    shimmer?: boolean;
+    /** Show ambient glow circles behind content (default: true). */
+    ambient?: boolean;
+    /** Additional CSS classes applied to the root element. */
+    className?: string;
+    /** Additional inline styles applied to the root element. */
+    style?: CSSProperties;
+}
+/**
+ * Derive a sensible secondary color based on the primary.
+ */
+export declare function getFallbackSecondary(color: TrueColor): TrueColor;
+/**
+ * Derive a deep color for the final gradient stop.
+ */
+export declare function getFallbackDeep(color: TrueColor): TrueColor;
+declare const _default: __VLS_WithSlots<import("vue").DefineComponent<GlassBackgroundProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<GlassBackgroundProps> & Readonly<{}>, {
+    color: TrueColor;
+    position: GlassBackgroundPosition;
+    shimmer: boolean;
+    direction: GradientDirection;
+    ambient: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, {
+    default?: (props: {}) => any;
+}>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/types/vue/src/components/GlassPanel.vue.d.ts

@@ -0,0 +1,24 @@
+declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & (new () => {
+    $slots: S;
+});
+declare const __VLS_component: import("vue").DefineComponent<{}, {
+    vibrancy: number;
+    radius: number;
+    tint: string;
+    tintStrength: number;
+    frost: number;
+    borderGlow: number;
+    $props: {
+        readonly vibrancy?: number | undefined;
+        readonly radius?: number | undefined;
+        readonly tint?: string | undefined;
+        readonly tintStrength?: number | undefined;
+        readonly frost?: number | undefined;
+        readonly borderGlow?: number | undefined;
+    };
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+type __VLS_Slots = {
+    default?: ((props: {}) => any) | undefined;
+};

package/dist/types/vue/src/components/HeaderGroup.vue.d.ts

@@ -0,0 +1,11 @@
+export interface HeaderGroupProps {
+}
+declare const _default: __VLS_WithSlots<import("vue").DefineComponent<HeaderGroupProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<HeaderGroupProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, {
+    default?: (props: {}) => any;
+}>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/types/vue/src/components/HelpButton.vue.d.ts

@@ -0,0 +1,44 @@
+import type { IconName } from "../icons/registry";
+import { type VNode } from "vue";
+import type { TrueColor } from "../theme/Theme";
+export type HelpButtonPlacement = "top" | "bottom" | "left" | "right" | "auto";
+export interface HelpButtonProps {
+    /**
+     * Help content to display in the panel.
+     * Pass a `string` to render as Markdown (tables and URLs supported).
+     * Pass a `VNode` (or use the default slot) to render arbitrary content directly.
+     */
+    content?: string | VNode;
+    /** Optional title shown in the panel header. Defaults to "Help". */
+    title?: string;
+    /**
+     * Preferred placement of the floating panel relative to the trigger button.
+     * "auto" (default) picks the side with the most available space.
+     */
+    placement?: HelpButtonPlacement;
+    /** Accent color for the trigger button and the panel header stripe. */
+    color?: TrueColor;
+    /** Size of the trigger icon button. */
+    size?: "xs" | "sm" | "md" | "lg";
+    /** Icon for the trigger button. Defaults to "Help". */
+    icon?: IconName;
+    /** Maximum width of the floating panel in px. Defaults to 360. */
+    maxWidth?: number;
+}
+declare const _default: __VLS_WithSlots<import("vue").DefineComponent<HelpButtonProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<HelpButtonProps> & Readonly<{}>, {
+    icon: IconName;
+    color: TrueColor;
+    size: "xs" | "sm" | "md" | "lg";
+    maxWidth: number;
+    placement: HelpButtonPlacement;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, {
+    title?: (props: {}) => any;
+} & {
+    default?: (props: {}) => any;
+}>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};