@cjlapao/ui-kit-vue 0.2.0

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

@@ -0,0 +1,51 @@
+import type { VNode } from "vue";
+import type { IconName } from "../icons/registry";
+import type { TrueColor } from "../theme";
+import type { PanelDecoration } from "./Panel.vue";
+export type HeroTitleSize = "xs" | "sm" | "md" | "lg" | "xl";
+export type HeroSubtitleSize = "xs" | "sm" | "md";
+export type HeroPadding = "none" | "xs" | "sm" | "md" | "lg" | "xl";
+export interface HeroProps {
+    /** Main heading text. */
+    title?: string;
+    /** Supporting text rendered below the title at lower opacity. */
+    subtitle?: string;
+    /** Icon name from the registry, or a pre-built element. When omitted the icon slot is not rendered. */
+    icon?: IconName | VNode;
+    /** Colour tone — drives the gradient background. Defaults to `"blue"`. */
+    tone?: TrueColor;
+    /** Size of the title text. Colour is always white. Defaults to `"sm"`. */
+    titleSize?: HeroTitleSize;
+    /** Size of the subtitle text. Colour is always white/75. Defaults to `"xs"`. */
+    subtitleSize?: HeroSubtitleSize;
+    /** Internal padding. Defaults to `"none"`. */
+    padding?: HeroPadding;
+    /** Whether to apply `rounded-xl` corner rounding. Defaults to `true`. */
+    rounded?: boolean;
+    /**
+     * Decorative layer inside the banner:
+     * - `"shapes"`   — three floating circles at low white opacity
+     * - `"gradient"` — a diagonal white-to-transparent light wash
+     * - `"both"`     — circles + wash (default)
+     * - `"none"`     — no decoration
+     */
+    decoration?: PanelDecoration;
+}
+declare const _default: __VLS_WithSlots<import("vue").DefineComponent<HeroProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<HeroProps> & Readonly<{}>, {
+    tone: TrueColor;
+    rounded: boolean;
+    padding: HeroPadding;
+    decoration: PanelDecoration;
+    titleSize: HeroTitleSize;
+    subtitleSize: HeroSubtitleSize;
+}, {}, {}, {}, 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/IconButton.test.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,51 @@
+import type { VNode } from "vue";
+import type { ButtonColor, ButtonSize, ButtonVariant } from "./Button.vue";
+import type { SpinnerColor } from "./Spinner.vue";
+import type { TooltipPosition } from "./Tooltip.vue";
+import type { GlassVibrancy, GlassOpacity, SpecularMode } from "../../../common/theme/glass";
+type IconButtonRounded = "md" | "lg" | "xl" | "full";
+export interface IconButtonProps {
+    icon: string | VNode;
+    variant?: ButtonVariant;
+    color?: ButtonColor;
+    size?: ButtonSize;
+    rounded?: IconButtonRounded;
+    customSizeClass?: string;
+    iconClassName?: string;
+    loading?: boolean;
+    spinnerVariant?: "solid" | "segments";
+    spinnerColor?: SpinnerColor;
+    srLabel?: string;
+    accent?: boolean;
+    accentColor?: ButtonColor;
+    disabled?: boolean;
+    /** When set, a styled tooltip is shown on hover (replaces the native title attribute). */
+    tooltip?: string;
+    /** Position of the tooltip relative to the button. Defaults to 'top'. */
+    tooltipPosition?: TooltipPosition;
+    /** When true, applies glass styling (fill + vibrancy + optional specular overlay). */
+    glass?: boolean;
+    /** Backdrop vibrancy level for glass surfaces. */
+    vibrancy?: GlassVibrancy;
+    /** Glass fill transparency level for glass surfaces. Defaults to "clear" for IconButton. */
+    glassOpacity?: GlassOpacity;
+    /** Specular highlight mode for glass surfaces. Defaults to "none" for IconButton. */
+    specularMode?: SpecularMode;
+}
+declare const _default: import("vue").DefineComponent<IconButtonProps, {
+    el: import("vue").Ref<HTMLButtonElement | null, HTMLButtonElement | null>;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<IconButtonProps> & Readonly<{}>, {
+    glass: boolean;
+    color: ButtonColor;
+    variant: ButtonVariant;
+    size: ButtonSize;
+    disabled: boolean;
+    loading: boolean;
+    accent: boolean;
+    vibrancy: GlassVibrancy;
+    glassOpacity: GlassOpacity;
+    specularMode: SpecularMode;
+    rounded: IconButtonRounded;
+    spinnerVariant: "solid" | "segments";
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

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

@@ -0,0 +1,41 @@
+export interface InfiniteScrollPanelProps<T> {
+    items: T[];
+    isLoading: boolean;
+    hasMore: boolean;
+    /**
+     * Awaited when more items must be fetched — kept as a function prop (not an
+     * emit) because the component awaits its promise to manage the internal
+     * "loading more" state.
+     */
+    onLoadMore: () => Promise<void>;
+    threshold?: number;
+    debounceMs?: number;
+    useFixedColumns?: boolean;
+    minColumnWidthPx?: number;
+    maxColumns?: number;
+    columnTemplate?: string;
+    masonry?: boolean;
+}
+declare const _default: <T>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: __VLS_PrettifyLocal<Pick<Partial<{}> & Omit<{} & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, never>, never> & InfiniteScrollPanelProps<T> & Partial<{}>> & import("vue").PublicProps;
+    expose(exposed: import("vue").ShallowUnwrapRef<{}>): void;
+    attrs: any;
+    slots: {
+        /** Renders each item — replaces the React `renderItem` render prop. */
+        renderItem?: (props: {
+            item: T;
+            index: number;
+        }) => unknown;
+        /** Replaces the React `loadingComponent` node prop. */
+        loadingComponent?: () => unknown;
+        /** Replaces the React `emptyComponent` node prop. */
+        emptyComponent?: () => unknown;
+    };
+    emit: {};
+}>) => import("vue").VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+export default _default;
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};

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

@@ -0,0 +1,113 @@
+export type InfoRowSize = "xs" | "sm" | "md" | "lg";
+export type InfoRowPadding = "none" | "xs" | "sm" | "md" | "lg" | "xl" | "2xl" | "3xl";
+export interface InfoRowProps {
+    /** Row label (left side). Use the `label` slot for composed/styled labels. */
+    label?: string;
+    /**
+     * Override label text size independently from `size`.
+     * When omitted the shared `size` prop drives label size.
+     */
+    labelSize?: InfoRowSize;
+    /**
+     * Extra classes for the label span — use for custom colour, weight, etc.
+     * e.g. `labelClassName="text-emerald-600 font-semibold"`
+     */
+    labelClassName?: string;
+    /**
+     * Fixed width class for the label column (e.g. `"w-32"`).
+     * Defaults to a size-appropriate width (`w-16` / `w-20` / `w-24` / `w-28`).
+     * Pass `""` to let the label size naturally.
+     */
+    labelWidth?: string;
+    /**
+     * Row value (right side).
+     * - `string` / `number` — rendered as text, copy button enabled automatically.
+     * - `boolean` — rendered as "Yes" / "No" with copy enabled.
+     * - `value` slot — rendered as-is, copy button suppressed.
+     * - `null` / `undefined` / `''` — treated as empty (see `hideIfEmpty`).
+     */
+    value?: string | number | boolean | null;
+    /**
+     * Override value text size independently from `size`.
+     * When omitted the shared `size` prop drives value size.
+     */
+    valueSize?: InfoRowSize;
+    /**
+     * Extra classes for the value span — use for custom colour, weight, etc.
+     * e.g. `valueClassName="text-sky-500"`
+     */
+    valueClassName?: string;
+    /** Controls both label and value text size when individual overrides are absent. Defaults to `'md'`. */
+    size?: InfoRowSize;
+    /**
+     * Vertical padding override. Accepts the full size scale including `'none'`.
+     * When omitted, padding is derived from `size` (xs→py-1, sm→py-1.5, md→py-2, lg→py-2.5).
+     */
+    padding?: InfoRowPadding;
+    /**
+     * Show a copy-to-clipboard button.
+     * Defaults to `true` — shown automatically when the resolved value is a string or number.
+     * Pass `false` to suppress the button entirely.
+     */
+    copyable?: boolean;
+    /**
+     * Render the value in a monospace font.
+     * Shorthand for `valueClassName="font-mono"`.
+     */
+    mono?: boolean;
+    /**
+     * Hide the row entirely when `value` is `null`, `undefined`, or `''`.
+     * Defaults to `true`. Set to `false` to show the `emptyText` placeholder instead.
+     */
+    hideIfEmpty?: boolean;
+    /**
+     * Placeholder text shown when `hideIfEmpty` is `false` and the value is empty.
+     * Defaults to `'—'`.
+     */
+    emptyText?: string;
+    /**
+     * Allow the value to wrap to multiple lines instead of truncating.
+     * Defaults to `false`.
+     */
+    wrap?: boolean;
+    /**
+     * Show a tooltip with the full value when the text is truncated.
+     * Only active when `wrap` is `false` and the value is a string or number.
+     * Defaults to `true`.
+     */
+    tooltipOnTruncate?: boolean;
+    /** Remove the bottom border (e.g. for the last row when handled externally). */
+    noBorder?: boolean;
+    /**
+     * Remove the default horizontal padding (`px-3`/`px-4`).
+     * Useful when the parent already provides horizontal spacing.
+     */
+    noPadding?: boolean;
+    /**
+     * Add a subtle hover background and rounded corners (matches classic detail-panel row style).
+     * Defaults to `false`.
+     */
+    hoverable?: boolean;
+}
+declare const _default: __VLS_WithSlots<import("vue").DefineComponent<InfoRowProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<InfoRowProps> & Readonly<{}>, {
+    size: InfoRowSize;
+    wrap: boolean;
+    hoverable: boolean;
+    noPadding: boolean;
+    copyable: boolean;
+    mono: boolean;
+    hideIfEmpty: boolean;
+    emptyText: string;
+    tooltipOnTruncate: boolean;
+    noBorder: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, {
+    label?: (props: {}) => any;
+} & {
+    value?: (props: {}) => any;
+}>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

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

@@ -0,0 +1,269 @@
+import { type PropType, type VNode } from "vue";
+import type { ButtonProps, ButtonVariant, ButtonColor } from "./Button.vue";
+import type { ModalFocusTarget } from "./Modal.vue";
+import type { Size } from "../theme";
+import { type IconName } from "../icons/registry";
+/** Where the panel is anchored inside its positioned ancestor. */
+export type InlinePanelAnchor = "top" | "bottom" | "center" | "fill";
+/** Header action rendered as a kit Button; `label` becomes the button content. */
+export type InlinePanelHeaderAction = ButtonProps & {
+    label?: string | VNode;
+    onClick?: (event: MouseEvent) => void;
+};
+export interface InlinePanelProps {
+    isOpen: boolean;
+    title?: string;
+    description?: string;
+    /** Icon name string or a VNode rendered in the header. */
+    icon?: IconName | VNode;
+    bodyHeader?: string;
+    bodyClassName?: string;
+    /** Slot rendered in the footer bar (use alongside actions). */
+    footer?: string;
+    /** Alias for footer — matches Modal API. */
+    actions?: string;
+    /**
+     * Width preset for the content card. Only meaningful when anchor is
+     * "top" or "bottom". Ignored for "fill". Default: "md".
+     */
+    size?: Size;
+    maxWidth?: number | string;
+    minWidth?: number | string;
+    height?: number | string;
+    maxHeight?: number | string;
+    minHeight?: number | string;
+    /**
+     * "fill"   — covers the entire parent (absolute inset-0).
+     * "top"    — slides in from the top edge.
+     * "bottom" — slides up from the bottom edge.
+     *
+     * The parent element MUST have `position: relative` (or any non-static
+     * position) for the overlay to clip correctly.
+     *
+     * @default "fill"
+     */
+    anchor?: InlinePanelAnchor;
+    /** z-index of the panel relative to its positioned parent. @default 20 */
+    zIndex?: number;
+    /** Press Escape to close. @default true */
+    closeOnEsc?: boolean;
+    /**
+     * Click the backdrop behind the panel card to close.
+     * Only relevant when anchor is "top" or "bottom".
+     * @default false  (more conservative than Modal — inline forms are higher-risk to dismiss accidentally)
+     */
+    closeOnBackdropClick?: boolean;
+    /** Show a semi-transparent backdrop behind the card (top/bottom only). @default false */
+    showBackdrop?: boolean;
+    loading?: boolean;
+    loadingTitle?: string;
+    loadingLabel?: string;
+    headerActions?: InlinePanelHeaderAction[];
+    backTooltip?: string;
+    hideCloseButton?: boolean;
+    showFooterDivider?: boolean;
+    /** Ref to the element that should receive focus when the panel opens. */
+    initialFocusRef?: ModalFocusTarget;
+    ariaLabel?: string;
+    role?: "dialog" | "alertdialog";
+}
+export interface ConfirmInlinePanelProps extends Omit<InlinePanelProps, "actions" | "footer" | "role"> {
+    confirmLabel?: string | VNode;
+    cancelLabel?: string | VNode;
+    confirmVariant?: ButtonVariant;
+    confirmColor?: ButtonColor;
+    isConfirmDisabled?: boolean;
+}
+export declare const ConfirmInlinePanel: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    anchor: {
+        type: PropType<InlinePanelAnchor>;
+        default: string;
+    };
+    showBackdrop: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    size: {
+        type: PropType<Size>;
+        default: string;
+    };
+    confirmLabel: {
+        type: PropType<string | VNode>;
+        default: string;
+    };
+    cancelLabel: {
+        type: PropType<string | VNode>;
+        default: string;
+    };
+    confirmVariant: {
+        type: PropType<ButtonVariant>;
+        default: string;
+    };
+    confirmColor: {
+        type: PropType<ButtonColor>;
+        default: string;
+    };
+    isConfirmDisabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>, () => VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("close" | "confirm")[], "close" | "confirm", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    anchor: {
+        type: PropType<InlinePanelAnchor>;
+        default: string;
+    };
+    showBackdrop: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    size: {
+        type: PropType<Size>;
+        default: string;
+    };
+    confirmLabel: {
+        type: PropType<string | VNode>;
+        default: string;
+    };
+    cancelLabel: {
+        type: PropType<string | VNode>;
+        default: string;
+    };
+    confirmVariant: {
+        type: PropType<ButtonVariant>;
+        default: string;
+    };
+    confirmColor: {
+        type: PropType<ButtonColor>;
+        default: string;
+    };
+    isConfirmDisabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>> & Readonly<{
+    onClose?: ((...args: any[]) => any) | undefined;
+    onConfirm?: ((...args: any[]) => any) | undefined;
+}>, {
+    anchor: InlinePanelAnchor;
+    size: Size;
+    confirmLabel: string | VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }>;
+    cancelLabel: string | VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }>;
+    confirmVariant: ButtonVariant;
+    confirmColor: import("../theme").TrueColor;
+    isConfirmDisabled: boolean;
+    showBackdrop: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export interface DeleteConfirmInlinePanelProps extends Omit<ConfirmInlinePanelProps, "confirmLabel" | "confirmVariant" | "confirmColor"> {
+    /** The exact string the user must type to enable the delete button. */
+    confirmValue: string;
+    /** Human-readable label shown in the instruction, e.g. "snapshot name". @default "name" */
+    confirmValueLabel?: string;
+    confirmLabel?: string | VNode;
+}
+export declare const DeleteConfirmInlinePanel: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    isOpen: {
+        type: BooleanConstructor;
+        required: true;
+    };
+    confirmValue: {
+        type: StringConstructor;
+        required: true;
+    };
+    confirmValueLabel: {
+        type: StringConstructor;
+        default: string;
+    };
+    confirmLabel: {
+        type: PropType<string | VNode>;
+        default: string;
+    };
+    cancelLabel: {
+        type: PropType<string | VNode>;
+        default: string;
+    };
+    isConfirmDisabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>, () => VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("close" | "confirm")[], "close" | "confirm", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    isOpen: {
+        type: BooleanConstructor;
+        required: true;
+    };
+    confirmValue: {
+        type: StringConstructor;
+        required: true;
+    };
+    confirmValueLabel: {
+        type: StringConstructor;
+        default: string;
+    };
+    confirmLabel: {
+        type: PropType<string | VNode>;
+        default: string;
+    };
+    cancelLabel: {
+        type: PropType<string | VNode>;
+        default: string;
+    };
+    isConfirmDisabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>> & Readonly<{
+    onClose?: ((...args: any[]) => any) | undefined;
+    onConfirm?: ((...args: any[]) => any) | undefined;
+}>, {
+    confirmLabel: string | VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }>;
+    cancelLabel: string | VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }>;
+    isConfirmDisabled: boolean;
+    confirmValueLabel: string;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: __VLS_WithSlots<import("vue").DefineComponent<InlinePanelProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
+    close: () => any;
+    back: () => any;
+}, string, import("vue").PublicProps, Readonly<InlinePanelProps> & Readonly<{
+    onClose?: (() => any) | undefined;
+    onBack?: (() => any) | undefined;
+}>, {
+    anchor: InlinePanelAnchor;
+    role: "dialog" | "alertdialog";
+    size: Size;
+    zIndex: number;
+    closeOnBackdropClick: boolean;
+    closeOnEsc: boolean;
+    headerActions: InlinePanelHeaderAction[];
+    hideCloseButton: boolean;
+    backTooltip: string;
+    showBackdrop: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, {
+    title?: (props: {}) => any;
+} & {
+    description?: (props: {}) => any;
+} & {
+    bodyHeader?: (props: {}) => any;
+} & {
+    default?: (props: {}) => any;
+} & {
+    footer?: (props: {}) => any;
+} & {
+    actions?: (props: {}) => any;
+}>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

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

@@ -0,0 +1,39 @@
+import type { VNode } from "vue";
+import type { ButtonColor } from "./Button.vue";
+type InputValidationStatus = "none" | "error" | "success";
+type InputSize = "sm" | "md" | "lg";
+export type InputVariant = "flat" | "elevated" | "ghost" | "underline";
+type IconRenderer = string | VNode;
+export interface InputProps {
+    /** Current value of the input (v-model). */
+    modelValue?: string;
+    size?: InputSize;
+    tone?: ButtonColor;
+    /** Visual surface style. Defaults to `flat`. */
+    variant?: InputVariant;
+    validationStatus?: InputValidationStatus;
+    leadingIcon?: IconRenderer;
+    trailingIcon?: IconRenderer;
+    /** When provided, the trailing icon renders as an interactive button instead of a static decoration. */
+    onTrailingIconClick?: (event: MouseEvent) => void;
+    wrapperClassName?: string;
+    unstyled?: boolean;
+    fullHeight?: boolean;
+    disabled?: boolean;
+}
+export type InputValidationStatusType = InputValidationStatus;
+declare const _default: import("vue").DefineComponent<InputProps, {
+    el: import("vue").Ref<HTMLInputElement | null, HTMLInputElement | null>;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:modelValue": (value: string) => any;
+}, string, import("vue").PublicProps, Readonly<InputProps> & Readonly<{
+    "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+}>, {
+    tone: ButtonColor;
+    variant: InputVariant;
+    size: InputSize;
+    fullHeight: boolean;
+    validationStatus: InputValidationStatus;
+    unstyled: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

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

@@ -0,0 +1,27 @@
+import type { ButtonColor } from "./Button.vue";
+type InputGroupSize = "sm" | "md" | "lg";
+type InputGroupValidationStatus = "none" | "error" | "success";
+export interface InputGroupProps {
+    leadingAddon?: string;
+    trailingAddon?: string;
+    tone?: ButtonColor;
+    size?: InputGroupSize;
+    validationStatus?: InputGroupValidationStatus;
+    disabled?: boolean;
+}
+declare const _default: __VLS_WithSlots<import("vue").DefineComponent<InputGroupProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<InputGroupProps> & Readonly<{}>, {
+    tone: ButtonColor;
+    size: InputGroupSize;
+    disabled: boolean;
+    validationStatus: InputGroupValidationStatus;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, {
+    leadingAddon?: (props: {}) => any;
+} & {
+    trailingAddon?: (props: {}) => any;
+}>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

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

@@ -0,0 +1,21 @@
+export interface KeyValuePair {
+    key: string;
+    value: string;
+}
+export interface KeyValueArrayFieldProps {
+    label: string;
+    hint?: string;
+    modelValue: KeyValuePair[];
+    error?: string;
+    help?: string;
+    isVisible?: boolean;
+    addLabel?: string;
+}
+declare const _default: import("vue").DefineComponent<KeyValueArrayFieldProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
+    "update:modelValue": (value: KeyValuePair[]) => any;
+}, string, import("vue").PublicProps, Readonly<KeyValueArrayFieldProps> & Readonly<{
+    "onUpdate:modelValue"?: ((value: KeyValuePair[]) => any) | undefined;
+}>, {
+    isVisible: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

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

@@ -0,0 +1,39 @@
+import type { VNode } from "vue";
+import type { SpinnerColor, SpinnerProps } from "./Spinner.vue";
+type LoaderVariant = "spinner" | "progress";
+type LoaderSize = "sm" | "md" | "lg";
+type GlassBlurIntensity = "none" | "low" | "medium" | "high";
+type LoaderColor = SpinnerColor;
+export interface LoaderProps {
+    variant?: LoaderVariant;
+    size?: LoaderSize;
+    color?: LoaderColor;
+    spinnerVariant?: SpinnerProps["variant"];
+    spinnerThickness?: SpinnerProps["thickness"];
+    title?: string | VNode | null;
+    label?: string | VNode | null;
+    progress?: number;
+    overlay?: boolean;
+    glass?: boolean;
+    glassBlurIntensity?: GlassBlurIntensity;
+}
+declare const _default: __VLS_WithSlots<import("vue").DefineComponent<LoaderProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<LoaderProps> & Readonly<{}>, {
+    glass: boolean;
+    color: LoaderColor;
+    variant: LoaderVariant;
+    progress: number;
+    size: LoaderSize;
+    spinnerVariant: import("./Spinner.vue").SpinnerVariant;
+    spinnerThickness: import("./Spinner.vue").SpinnerThickness;
+    overlay: boolean;
+    glassBlurIntensity: GlassBlurIntensity;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, {
+    title?: () => unknown;
+    label?: () => unknown;
+}>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};