@turquoisehealth/pit-viper 2.216.0 → 2.216.1-dev.0

package/pv-components/dist/vue/ai/components/base/PvQueryBuilderInput/QueryFormatter.vue.d.ts

@@ -0,0 +1,20 @@
+import { QueryBuilderOutput } from './useQueryBuilder';
+import { DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+interface QueryFormatterProps {
+    queryTermDisplayLimit?: number;
+}
+type __VLS_Props = QueryFormatterProps;
+type __VLS_PublicProps = {
+    modelValue: QueryBuilderOutput | null;
+    "wrap-content"?: boolean;
+} & __VLS_Props;
+declare const _default: DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+    "update:modelValue": (value: QueryBuilderOutput | null) => any;
+    "update:wrap-content": (value: boolean) => any;
+}, string, PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    "onUpdate:modelValue"?: ((value: QueryBuilderOutput | null) => any) | undefined;
+    "onUpdate:wrap-content"?: ((value: boolean) => any) | undefined;
+}>, {
+    queryTermDisplayLimit: number;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+export default _default;

package/pv-components/dist/vue/ai/components/base/PvQueryBuilderInput/useQueryBuilder.d.ts

@@ -0,0 +1,44 @@
+import { MenuOption } from '../../../types';
+export type QueryBuilderProcessor = "full" | "field-only";
+export interface QueryBuilderOutput {
+    queryTerms: QueryTerm[];
+    freeTextTerms?: string[];
+}
+export interface QueryTerm {
+    queryField?: string;
+    queryDisplayField?: string;
+    exactMatch?: boolean;
+    queryText?: string;
+}
+export interface QueryBuilderSuggestionMenuOption extends MenuOption {
+    queryTerm?: QueryTerm;
+}
+/**
+ * The filter model is structured as follows:
+ * For single conditions
+ * {
+ *     [field]: {
+ *      filterType: "text",
+ *      type: "equals" | "contains",
+ *      filter: string,
+ *     },
+ * }
+ * For multiple conditions on the same field, it will be structured as:
+ * {
+ *    [field]: {
+ *     filterType: "text",
+ *     operator: 'OR',
+ *     conditions: [
+ *         {
+ *         type: "equals" | "contains",
+ *         filter: string,
+ *         }
+ *     ]
+ *    },
+ * }
+ */
+export declare const useQueryBuilder: () => {
+    addQueryOption: (query: QueryBuilderOutput | null, option: QueryBuilderSuggestionMenuOption) => QueryBuilderOutput | null;
+    containsQueryOption: (query: QueryBuilderOutput | null, option: QueryBuilderSuggestionMenuOption) => boolean;
+    removeQueryOption: (query: QueryBuilderOutput | null, option: QueryBuilderSuggestionMenuOption) => QueryBuilderOutput | null;
+};

package/pv-components/dist/vue/ai/components/base/PvRadioGroup/PvRadioGroup.vue.d.ts

@@ -0,0 +1,30 @@
+import { RadioGroupOption } from './types';
+import { DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+interface PvRadioGroupProps {
+    /** Accessible label when no visible legend is provided. */
+    ariaLabel?: string;
+    /** When true, all options are non-interactive and visually dimmed. */
+    disabled?: boolean;
+    /** Visible label rendered above the group. */
+    label?: string;
+    /** Name attribute shared by all radio inputs. Auto-generated if omitted. */
+    name?: string;
+    /** Array of options to render as radio buttons. */
+    options?: RadioGroupOption[];
+    /** Layout direction of the options. */
+    orientation?: "vertical" | "horizontal";
+}
+type __VLS_Props = PvRadioGroupProps;
+type __VLS_PublicProps = {
+    modelValue?: string | number | boolean;
+} & __VLS_Props;
+declare const _default: DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+    "update:modelValue": (value: string | number | boolean) => any;
+}, string, PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    "onUpdate:modelValue"?: ((value: string | number | boolean) => any) | undefined;
+}>, {
+    disabled: boolean;
+    options: RadioGroupOption[];
+    orientation: "vertical" | "horizontal";
+}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLDivElement>;
+export default _default;

package/pv-components/dist/vue/ai/components/base/PvRadioGroup/types.d.ts

@@ -0,0 +1,5 @@
+export interface RadioGroupOption {
+    label: string;
+    value: string | number | boolean;
+    disabled?: boolean;
+}

package/pv-components/dist/vue/ai/components/base/PvRange/PvRange.vue.d.ts

@@ -0,0 +1,36 @@
+import { PvRangeProps, PvRangeValue, PvRangeSize, PvRangeColor, PvRangeMode } from './types';
+import { DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+type __VLS_Props = PvRangeProps;
+type __VLS_PublicProps = {
+    modelValue?: number;
+    "rangeValue"?: PvRangeValue;
+} & __VLS_Props;
+declare const _default: DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+    "update:modelValue": (value: number) => any;
+    "update:rangeValue": (value: PvRangeValue) => any;
+}, string, PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    "onUpdate:modelValue"?: ((value: number) => any) | undefined;
+    "onUpdate:rangeValue"?: ((value: PvRangeValue) => any) | undefined;
+}>, {
+    size: PvRangeSize;
+    label: string;
+    disabled: boolean;
+    step: number | null;
+    color: PvRangeColor;
+    mode: PvRangeMode;
+    showClear: boolean;
+    min: number | null;
+    max: number | null;
+    allowMinMaxEqual: boolean;
+    alwaysEditMin: boolean;
+    dataType: string | null;
+    maxLabel: string;
+    minLabel: string;
+    showBoundLabels: boolean;
+    showInputs: boolean;
+    showValueTooltips: boolean;
+    valueDecimals: number | null;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {
+    sliderRef: HTMLDivElement;
+}, any>;
+export default _default;

package/pv-components/dist/vue/ai/components/base/PvRange/types.d.ts

@@ -0,0 +1,44 @@
+export type PvRangeColor = "single" | "multiple";
+export type PvRangeMode = "single" | "dual";
+export type PvRangeSize = "sm" | "md" | "lg";
+export interface PvRangeProps {
+    /** When true, min and max handles may have the same value in dual mode. */
+    allowMinMaxEqual?: boolean;
+    /** When true, track clicks always move the minimum handle instead of the nearest handle in dual mode. */
+    alwaysEditMin?: boolean;
+    /** Accessible name for the range slider. */
+    ariaLabel?: string;
+    /** Track color mode. `single` uses a neutral unselected track, `multiple` uses the secondary data color. */
+    color?: PvRangeColor;
+    /** Value display type for dual-mode inputs, tooltips, and bound labels. */
+    dataType?: string | null;
+    disabled?: boolean;
+    /** Accessible group label in dual mode. */
+    label?: string;
+    /** Upper slider bound. */
+    max?: number | null;
+    maxLabel?: string;
+    /** Lower slider bound. */
+    min?: number | null;
+    minLabel?: string;
+    /** Slider interaction mode. `single` uses the default v-model; `dual` ignores modelValue and uses v-model:rangeValue. */
+    mode?: PvRangeMode;
+    /** Whether to show min/max bound values above the slider in dual mode. */
+    showBoundLabels?: boolean;
+    /** Whether to show the Clear range action when a dual-mode value is active. */
+    showClear?: boolean;
+    /** Whether to show min/max text inputs in dual mode. */
+    showInputs?: boolean;
+    /** Whether to show handle value tooltips while interacting in dual mode. */
+    showValueTooltips?: boolean;
+    /** Visual size. */
+    size?: PvRangeSize;
+    /** Slider/input step. Use 0 for continuous values. */
+    step?: number | null;
+    /** Decimal places for dual-mode display values. */
+    valueDecimals?: number | null;
+}
+export interface PvRangeValue {
+    max: number | null;
+    min: number | null;
+}

package/pv-components/dist/vue/ai/components/base/PvRating/PvRating.vue.d.ts

@@ -0,0 +1,15 @@
+import { PvRatingVariant, PvRatingSize } from './types';
+import { DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+interface PvRatingProps {
+    /** Display variant: "dot" or "star" style */
+    variant?: PvRatingVariant;
+    /** Rating value between 0 and 5 */
+    value: number;
+    /** Size of the rating display in pixels */
+    size?: PvRatingSize;
+}
+declare const _default: DefineComponent<PvRatingProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<PvRatingProps> & Readonly<{}>, {
+    size: PvRatingSize;
+    variant: PvRatingVariant;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLDivElement>;
+export default _default;

package/pv-components/dist/vue/ai/components/base/PvRating/types.d.ts

@@ -0,0 +1,4 @@
+export declare const PvRatingSizes: readonly [12, 16, 20, 24, 32, 64];
+export type PvRatingSize = (typeof PvRatingSizes)[number];
+export declare const PvRatingVariants: readonly ["dot", "star"];
+export type PvRatingVariant = (typeof PvRatingVariants)[number];

package/pv-components/dist/vue/ai/components/base/PvReleaseBadge/PvReleaseBadge.vue.d.ts

@@ -0,0 +1,10 @@
+import { PvReleaseBadgeVariant } from './types';
+import { DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+export interface PvReleaseBadgeProps {
+    /** Release stage variant that determines the badge label and color */
+    variant: PvReleaseBadgeVariant;
+    /** Apply inverse styling (neutral background) */
+    inverse?: boolean;
+}
+declare const _default: DefineComponent<PvReleaseBadgeProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<PvReleaseBadgeProps> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLDivElement>;
+export default _default;

package/pv-components/dist/vue/ai/components/base/PvReleaseBadge/types.d.ts

@@ -0,0 +1 @@
+export type PvReleaseBadgeVariant = "release-alpha" | "release-beta";

package/pv-components/dist/vue/ai/components/base/PvSearchInput/PvSearchInput.vue.d.ts

@@ -0,0 +1,33 @@
+import { DefineComponent, ShallowRef, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+export interface PvSearchInputProps {
+    /**
+     * Placeholder text shown when the input is empty.
+     */
+    placeholder?: string;
+    /**
+     * When true, the input is non-interactive and visually dimmed.
+     */
+    disabled?: boolean;
+    /** When true, displays a keyboard shortcut badge ("/" key) and registers the hotkey to focus the input. */
+    displayShortcut?: boolean;
+}
+export interface PvSearchInputExposed {
+    input: HTMLInputElement | null;
+}
+type __VLS_Props = PvSearchInputProps;
+type __VLS_PublicProps = {
+    modelValue?: string;
+} & __VLS_Props;
+declare const _default: DefineComponent<__VLS_PublicProps, {
+    input: Readonly< ShallowRef<HTMLInputElement | null>>;
+}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+    "update:modelValue": (value: string) => any;
+}, string, PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+}>, {
+    disabled: boolean;
+    placeholder: string;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {
+    'search-input': HTMLInputElement;
+}, HTMLDivElement>;
+export default _default;

package/pv-components/dist/vue/ai/components/base/PvSegmentedControl/PvSegmentedControl.vue.d.ts

@@ -0,0 +1,23 @@
+import { PvSegmentControlSize, PvSegmentedControlOption } from './types';
+import { DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+interface PvSegmentControlProps {
+    /** The list of options rendered as segments. Each option can have a label, icon, or both. */
+    options: PvSegmentedControlOption[];
+    /**
+     * Controls the overall height of the segmented control.
+     */
+    size?: PvSegmentControlSize;
+}
+type __VLS_Props = PvSegmentControlProps;
+type __VLS_PublicProps = {
+    modelValue: string;
+} & __VLS_Props;
+declare const _default: DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+    "update:modelValue": (value: string) => any;
+}, string, PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+}>, {
+    size: PvSegmentControlSize;
+    options: PvSegmentedControlOption[];
+}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLDivElement>;
+export default _default;

package/pv-components/dist/vue/ai/components/base/PvSegmentedControl/types.d.ts

@@ -0,0 +1,18 @@
+import { PvSize } from '../baseProps';
+export type PvSegmentControlSize = Extract<PvSize, "lg" | "xl">;
+export interface PvSegmentedControlOption {
+    /** When true, the option cannot be selected. */
+    disabled?: boolean;
+    /** Tooltip text shown when hovering this option (typically used to explain why an option is disabled). */
+    disabledReason?: string;
+    /** Name of the icon to display alongside the label. */
+    icon?: string;
+    /** Which side of the label the icon appears on. */
+    iconPosition?: "left" | "right";
+    /** Visible text for the option. Omit for icon-only segments. */
+    label?: string;
+    /** Accessible name for icon-only segments (no label). Required when label is omitted. */
+    ariaLabel?: string;
+    /** Unique identifier emitted as the model value when this option is selected. */
+    value: string;
+}

package/pv-components/dist/vue/ai/components/base/PvSelectButton/PvSelectButton.vue.d.ts

@@ -0,0 +1,85 @@
+import { CSSProperties, Component, VNodeProps, AllowedComponentProps, ComponentCustomProps, PublicProps, ShallowUnwrapRef, VNode } from 'vue';
+import { PvSelectButtonSize, PvSelectButtonVariant } from './types';
+import { MenuAction, MenuOption, MenuOptionsVariant } from '../../../types';
+import { PvCounterBadgeVariant } from '../PvCounterBadge/types';
+import { PvPopoverV2Props } from '../PvPopoverV2/types.ts';
+import { PvMenuChildrenDisplay } from '../PvMenu/types';
+export interface PvSelectButtonProps<T = unknown> {
+    /** Whether the dropdown is open on initial render */
+    defaultOpen?: boolean;
+    /** Prevent the button from being clicked */
+    disabled?: boolean;
+    /** Show a loading state on the trigger button */
+    isLoading?: boolean;
+    /** Visual style of the trigger button */
+    variant?: PvSelectButtonVariant;
+    /** Inverse button colors for dark backgrounds */
+    inverse?: boolean;
+    /** Size of the trigger button */
+    size?: PvSelectButtonSize;
+    /** Configuration passed to the underlying PvPopoverV2 */
+    popoverProperties?: PvPopoverV2Props;
+    /** Custom CSS properties applied to the popover container */
+    popoverCssProperties?: CSSProperties;
+    /** Static text shown before the label on the trigger button */
+    prefixLabel?: string;
+    /** Text label on the trigger button; updates to the selected option's text when an item is chosen */
+    label?: string;
+    /**
+     * Keep the trigger showing `label` even after an option is selected, instead of
+     * swapping to the selected option's text. Use when the label is a fixed title
+     * (e.g. a column name) and the current selection is surfaced only inside the dropdown.
+     */
+    staticLabel?: boolean;
+    /** Hide the search input inside the dropdown */
+    disableSearchInput?: boolean;
+    /** Placeholder text for the search input */
+    searchPlaceholder?: string;
+    /** Visual style of menu options (simple, icon, company, avatar, radio) */
+    optionsVariant?: Exclude<MenuOptionsVariant, "checkbox">;
+    /** The list of selectable options */
+    options?: MenuOption<T>[];
+    /** Render nested options inline or in click-opened popovers. */
+    childrenDisplay?: PvMenuChildrenDisplay;
+    /** Custom Vue component used to render each option */
+    optionsRenderer?: Component;
+    /** Action configuration for per-option action buttons */
+    optionsAction?: MenuAction<T>;
+    /** Prevent deselecting the currently selected item */
+    disableDeselect?: boolean;
+    /** Where to place the counter badge on the trigger */
+    counterPosition?: "left" | "right";
+    /** Variant of the counter badge which appears on the button and menu items */
+    counterBadgeVariant?: PvCounterBadgeVariant;
+    /** Whether to highlight the search text in the options list */
+    highlightSearchText?: boolean;
+    /**
+     * `data-dd-action-name` attached to the trigger button so Datadog RUM
+     * resolves the click to a named action. Leave unset to skip.
+     */
+    rumActionName?: string;
+}
+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<{
+        readonly "onUpdate:modelValue"?: ((value: MenuOption<unknown>) => any) | undefined;
+        readonly "onDropdown-open"?: (() => any) | undefined;
+        readonly "onDropdown-closed"?: (() => any) | undefined;
+        readonly "onUpdate:searchInput"?: ((value: string) => any) | undefined;
+    } & VNodeProps & AllowedComponentProps & ComponentCustomProps, never>, "onUpdate:modelValue" | "onDropdown-open" | "onDropdown-closed" | "onUpdate:searchInput"> & ({
+        modelValue?: MenuOption;
+        searchInput?: string;
+    } & PvSelectButtonProps<T>) & Partial<{}>> & PublicProps;
+    expose(exposed: ShallowUnwrapRef<{}>): void;
+    attrs: any;
+    slots: {};
+    emit: {
+        (e: "dropdown-open"): void;
+        (e: "dropdown-closed"): void;
+    } & (((evt: "update:modelValue", value: MenuOption<unknown>) => void) & ((evt: "update:searchInput", value: string) => void));
+}>) => VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+export default _default;
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};

package/pv-components/dist/vue/ai/components/base/PvSelectButton/PvSelectButtonTrigger/PvSelectButtonTrigger.vue.d.ts

@@ -0,0 +1,14 @@
+import { PvSelectButtonTriggerProps } from './types';
+import { DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+import { PvSelectButtonSize, PvSelectButtonVariant } from '../../PvMultiSelectButton/types';
+declare const _default: DefineComponent<PvSelectButtonTriggerProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
+    "handle-clear": () => any;
+}, string, PublicProps, Readonly<PvSelectButtonTriggerProps> & Readonly<{
+    "onHandle-clear"?: (() => any) | undefined;
+}>, {
+    size: PvSelectButtonSize;
+    variant: PvSelectButtonVariant;
+    counterStyle: "primary" | "secondary";
+    showDropdown: boolean;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLButtonElement>;
+export default _default;

package/pv-components/dist/vue/ai/components/base/PvSelectButton/PvSelectButtonTrigger/types.d.ts

@@ -0,0 +1,27 @@
+import { Component } from 'vue';
+import { PvCounterBadgeVariant } from '../../PvCounterBadge/types';
+import { PvSelectButtonSize, PvSelectButtonVariant } from '../../PvMultiSelectButton/types';
+import { MenuOption, MenuOptionConfig } from '../../../../types';
+export interface PvSelectButtonTriggerProps {
+    avatar?: MenuOption["avatar"];
+    companyLogo?: string;
+    counterBadgeVariant?: PvCounterBadgeVariant;
+    counterPosition?: "left" | "right" | "none";
+    counterValue?: number;
+    disabled?: boolean;
+    icon?: string;
+    inverse?: boolean;
+    isLoading?: boolean;
+    label?: string;
+    menuOptionConfig?: MenuOptionConfig;
+    open: boolean;
+    prefixLabel?: string;
+    renderer?: Component;
+    selectedOption?: MenuOption;
+    showClear?: boolean;
+    showDropdown?: boolean;
+    size?: PvSelectButtonSize;
+    variant?: PvSelectButtonVariant;
+    counterStyle?: "primary" | "secondary";
+    selectedItems?: MenuOption[];
+}

package/pv-components/dist/vue/ai/components/base/PvSelectButton/mocks.d.ts

@@ -0,0 +1,21 @@
+export declare const simpleNestedOptions: {
+    id: string;
+    text: string;
+    children: {
+        id: string;
+        text: string;
+    }[];
+}[];
+export declare const simpleOptions: {
+    id: string;
+    text: string;
+}[];
+export declare const companyOption: {
+    id: string;
+    text: string;
+    companyName: string;
+}[];
+export declare const checkboxOptions: {
+    id: string;
+    text: string;
+}[];

package/pv-components/dist/vue/ai/components/base/PvSelectButton/types.d.ts

@@ -0,0 +1,3 @@
+import { PvSize, PvVariants } from '../baseProps';
+export type PvSelectButtonVariant = Extract<PvVariants, "secondary" | "ghost">;
+export type PvSelectButtonSize = Extract<PvSize, "lg" | "xl">;

package/pv-components/dist/vue/ai/components/base/PvSelectableCard/PvSelectableCard.vue.d.ts

@@ -0,0 +1,30 @@
+import { DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+interface PvSelectableCardProps {
+    /** Visual style variant of the selectable card. */
+    variant?: "default" | "highlight";
+    /** Value associated with this card, used as the input element's value. */
+    value?: string;
+    /** Unique identifier for the card's input element. Auto-generated if not provided. */
+    id?: string;
+    /** When true, renders as a checkbox (allowing deselection). When false, renders as a radio button. */
+    deselect?: boolean;
+    /** Whether the card is currently in the selected state. */
+    selected?: boolean;
+}
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: HTMLLabelElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: DefineComponent<PvSelectableCardProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<PvSelectableCardProps> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLLabelElement>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/pv-components/dist/vue/ai/components/base/PvSidebar/PvSidebar.vue.d.ts

@@ -0,0 +1,38 @@
+import { DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+type __VLS_Props = {
+    disableToggle?: boolean;
+    variant?: "primary" | "secondary";
+};
+type __VLS_PublicProps = {
+    modelValue?: boolean;
+} & __VLS_Props;
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        'sidebar-header'?(_: {}): any;
+        sidebar?(_: {}): any;
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+    "update:modelValue": (value: boolean) => any;
+} & {
+    change: (payload: {
+        collapsed: boolean;
+    }) => any;
+}, string, PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+    onChange?: ((payload: {
+        collapsed: boolean;
+    }) => any) | undefined;
+}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLDivElement>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/pv-components/dist/vue/ai/components/base/PvSkeleton/PvSkeleton.vue.d.ts

@@ -0,0 +1,17 @@
+import { PvSkeletonSize, PvSkeletonVariant } from './types';
+import { DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+interface PvSkeletonProps {
+    /** The size of the skeleton placeholder. Sets the height, and the width for the "square" and "circle" variants. Overridden by `width`/`height` when provided. */
+    size?: PvSkeletonSize;
+    /** The shape variant. "rectangle" fills available width; "square" and "circle" use equal height and width. */
+    variant?: PvSkeletonVariant;
+    /** Optional explicit width (any CSS length, e.g. "45%" or "48px"). Overrides the width derived from `size`/`variant`. */
+    width?: string;
+    /** Optional explicit height (any CSS length, e.g. "8px"). Overrides the height derived from `size`. */
+    height?: string;
+}
+declare const _default: DefineComponent<PvSkeletonProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<PvSkeletonProps> & Readonly<{}>, {
+    size: PvSkeletonSize;
+    variant: PvSkeletonVariant;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+export default _default;

package/pv-components/dist/vue/ai/components/base/PvSkeleton/types.d.ts

@@ -0,0 +1,8 @@
+import { PvSize } from '../baseProps';
+export type PvSkeletonSize = Extract<PvSize, "xs" | "sm" | "md" | "lg" | "xl">;
+export type PvSkeletonVariant = "square" | "rectangle" | "circle";
+/**
+ * @deprecated Misspelled name kept as an alias of {@link PvSkeletonSize} for
+ * backwards compatibility. Use `PvSkeletonSize` instead.
+ */
+export type PvSekeltonSize = PvSkeletonSize;

package/pv-components/dist/vue/ai/components/base/PvSpinner/PvSpinner.vue.d.ts

@@ -0,0 +1,13 @@
+import { PvSpinnerSize, PvSpinnerVariant } from './types';
+import { DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+interface PvSpinnerProps {
+    /** The size of the spinner. Controls the rendered diameter via a CSS custom property. */
+    size?: PvSpinnerSize;
+    /** The color variant of the spinner. Use "white" on dark backgrounds and "dark" on light backgrounds. */
+    variant?: PvSpinnerVariant;
+}
+declare const _default: DefineComponent<PvSpinnerProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<PvSpinnerProps> & Readonly<{}>, {
+    size: PvSpinnerSize;
+    variant: PvSpinnerVariant;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLDivElement>;
+export default _default;

package/pv-components/dist/vue/ai/components/base/PvSpinner/types.d.ts

@@ -0,0 +1,3 @@
+import { PvSize, PvThemes, PvVariants } from '../baseProps';
+export type PvSpinnerSize = Extract<PvSize, "xs" | "sm" | "md" | "lg" | "xl">;
+export type PvSpinnerVariant = Extract<PvVariants, "primary"> | Extract<PvThemes, "white" | "dark">;

package/pv-components/dist/vue/ai/components/base/PvSplitButton/PvSplitButton.vue.d.ts

@@ -0,0 +1,27 @@
+import { PvSplitButtonProps } from './types';
+import { DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+import { PvAlignmentPositions } from '../baseProps';
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        'menu-content'?(_: {}): any;
+    };
+    refs: {};
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: DefineComponent<PvSplitButtonProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
+    click: () => any;
+}, string, PublicProps, Readonly<PvSplitButtonProps> & Readonly<{
+    onClick?: (() => any) | undefined;
+}>, {
+    position: PvAlignmentPositions;
+    offset: number;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLDivElement>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/pv-components/dist/vue/ai/components/base/PvSplitButton/types.d.ts

@@ -0,0 +1,12 @@
+import { PvButtonProps, PvButtonVariant } from '../PvButton/types';
+import { PvAlignmentPositions } from '../baseProps';
+export interface PvSplitButtonProps extends Omit<PvButtonProps, "variant" | "label" | "ariaLabel"> {
+    /** Text within the action button */
+    label: string;
+    /** Visual style — restricted to primary and secondary */
+    variant?: Extract<PvButtonVariant, "primary" | "secondary">;
+    /** Offset in pixels between the trigger and the popover */
+    offset?: number;
+    /** Where the popover opens relative to the trigger */
+    position?: PvAlignmentPositions;
+}

package/pv-components/dist/vue/ai/components/base/PvSprite/PvSprite.vue.d.ts

@@ -0,0 +1,9 @@
+import { DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+type PvSpriteProps = {
+    src: string;
+    variant?: "v1" | "v2";
+};
+declare const _default: DefineComponent<PvSpriteProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<PvSpriteProps> & Readonly<{}>, {
+    variant: "v1" | "v2";
+}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+export default _default;

package/pv-components/dist/vue/ai/components/base/PvStepper/PvStepper.vue.d.ts

@@ -0,0 +1,16 @@
+import { DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+interface StepperProps {
+    count?: number;
+    active?: number;
+    clickable?: boolean;
+}
+declare const _default: DefineComponent<StepperProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
+    "update:active": (index: number) => any;
+}, string, PublicProps, Readonly<StepperProps> & Readonly<{
+    "onUpdate:active"?: ((index: number) => any) | undefined;
+}>, {
+    active: number;
+    count: number;
+    clickable: boolean;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLDivElement>;
+export default _default;