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

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

@@ -0,0 +1,36 @@
+import { PvHorizontalScrollerProps } from './types';
+import { DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+import { PvButtonSize, PvButtonVariant } from '../PvButton/types';
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {
+        scrollContainer: HTMLDivElement;
+        contentContainer: HTMLDivElement;
+    };
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: DefineComponent<PvHorizontalScrollerProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<PvHorizontalScrollerProps> & Readonly<{}>, {
+    ariaLabel: string;
+    scrollBehavior: ScrollBehavior;
+    buttonSize: PvButtonSize;
+    buttonVariant: PvButtonVariant;
+    hideScrollbar: boolean;
+    leftAriaLabel: string;
+    rightAriaLabel: string;
+    scrollFraction: number;
+    showFades: boolean;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {
+    scrollContainer: HTMLDivElement;
+    contentContainer: HTMLDivElement;
+}, 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/PvHorizontalScroller/types.d.ts

@@ -0,0 +1,21 @@
+import { PvButtonSize, PvButtonVariant } from '../PvButton/types';
+export interface PvHorizontalScrollerProps {
+    /** Accessible label for the scrollable region. */
+    ariaLabel?: string;
+    /** Size for the left/right scroll buttons. */
+    buttonSize?: PvButtonSize;
+    /** Variant for the left/right scroll buttons. */
+    buttonVariant?: PvButtonVariant;
+    /** Hide the native horizontal scrollbar while keeping wheel/touch scrolling enabled. */
+    hideScrollbar?: boolean;
+    /** Accessible label for the left scroll button. */
+    leftAriaLabel?: string;
+    /** Accessible label for the right scroll button. */
+    rightAriaLabel?: string;
+    /** Browser scroll behavior used when clicking an arrow. */
+    scrollBehavior?: ScrollBehavior;
+    /** Fraction of the visible container width to scroll per arrow click. */
+    scrollFraction?: number;
+    /** Show gradient edge fades behind the arrow buttons. */
+    showFades?: boolean;
+}

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

@@ -0,0 +1,42 @@
+import { MenuOption, MenuOptionSelectedEvent } from '../../../types';
+import { PvHoverActionMenuProps, PvHoverActionMenuPosition } from './types';
+import { DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+import { PvActionBarTheme } from '../PvActionBar/types';
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: Readonly<{
+        /**
+         * Content the actions are attached to. When options are present the wrapper
+         * is focusable, so the actions reveal on hover or focus within without
+         * requiring the slotted content to be focusable.
+         */
+        default(): never;
+    }> & {
+        /**
+         * Content the actions are attached to. When options are present the wrapper
+         * is focusable, so the actions reveal on hover or focus within without
+         * requiring the slotted content to be focusable.
+         */
+        default(): never;
+    };
+    refs: {};
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: DefineComponent<PvHoverActionMenuProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+    "option-select": (payload: MenuOptionSelectedEvent) => any;
+}, string, PublicProps, Readonly<PvHoverActionMenuProps> & Readonly<{
+    "onOption-select"?: ((payload: MenuOptionSelectedEvent) => any) | undefined;
+}>, {
+    variant: PvActionBarTheme;
+    disabled: boolean;
+    options: MenuOption[];
+    position: PvHoverActionMenuPosition;
+}, {}, {}, {}, 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/PvHoverActionMenu/types.d.ts

@@ -0,0 +1,15 @@
+import { PvActionBarTheme } from '../PvActionBar/types';
+import { MenuOption } from '../../../types';
+export type PvHoverActionMenuPosition = "bottom-left" | "bottom-right" | "top-left" | "top-right";
+export interface PvHoverActionMenuProps {
+    disabled?: boolean;
+    options?: MenuOption[];
+    /**
+     * Corner the action menu is anchored to within the wrapper. The offset from
+     * that corner can be tuned with the `--pv-hover-action-menu-offset-block`
+     * (default 8px) and `--pv-hover-action-menu-offset-inline` (default 8px) CSS
+     * custom properties.
+     */
+    position?: PvHoverActionMenuPosition;
+    variant?: PvActionBarTheme;
+}

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

@@ -0,0 +1,14 @@
+import { PvIconSize } from '../baseProps';
+import { DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+declare const _default: DefineComponent<{
+    /** Name of the icon from the SVG sprite sheet (e.g. "user", "check-circle"). */
+    name: string;
+    /** Pixel size of the icon. When omitted the icon inherits its container's size. */
+    size?: PvIconSize;
+}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<{
+    /** Name of the icon from the SVG sprite sheet (e.g. "user", "check-circle"). */
+    name: string;
+    /** Pixel size of the icon. When omitted the icon inherits its container's size. */
+    size?: PvIconSize;
+}> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, SVGSVGElement>;
+export default _default;

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

@@ -0,0 +1,59 @@
+import { PvInputType, PvInputVariant } from './types';
+import { DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+interface PvInputProps {
+    /** When true, upper label is visible */
+    showLabel?: boolean;
+    /** When true, applies invalid/error styling to the input and lower label. */
+    error?: boolean;
+    /** When true, the input is non-interactive and visually dimmed. */
+    disabled?: boolean;
+    /** Placeholder text shown when the input is empty. */
+    placeholder?: string;
+    /**
+     * The HTML input type.
+     */
+    type?: PvInputType;
+    /** HTML id for the input element. Auto-generated when omitted. */
+    id?: string;
+    /** Helper or validation text displayed below the input. Turns red when error is true. */
+    lowerLabel?: string;
+    /**
+     * Background color variant of the input field.
+     */
+    variant?: PvInputVariant;
+    /** The step attribute for number inputs (e.g. '0.01' for currency). */
+    step?: string;
+    /** Static text shown before the Input */
+    prefixLabel?: string;
+    /** Optional Icon on the left of the Input */
+    inputIcon?: string;
+}
+type __VLS_Props = PvInputProps;
+type __VLS_PublicProps = {
+    modelValue?: string;
+} & __VLS_Props;
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        label?(_: {}): any;
+    };
+    refs: {};
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+    "update:modelValue": (value: string) => any;
+}, string, PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+}>, {
+    variant: PvInputVariant;
+    type: PvInputType;
+    id: string;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+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/PvInput/types.d.ts

@@ -0,0 +1,3 @@
+import { PvTextInputColors } from '../baseProps';
+export type PvInputVariant = Extract<PvTextInputColors, "white" | "grey">;
+export type PvInputType = "text" | "password" | "number";

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

@@ -0,0 +1,29 @@
+import { DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+export interface PvInsightCardProps {
+    /** Name of the icon displayed beside the insight text. */
+    icon: string;
+    /** Short insight label displayed next to the icon. */
+    insight: string;
+    /** Optional label displayed above the title in a smaller, tertiary style. */
+    upperLabel?: string;
+    /** Main heading text of the insight card. */
+    title?: string;
+    /** Descriptive text displayed below the title. */
+    description?: string;
+    /** When true, shows a "new-tab" icon button in the top-right corner. */
+    showButton?: boolean;
+    /** When true, the card is rendered as an interactive (clickable) element. */
+    interactive?: boolean;
+}
+declare const _default: DefineComponent<PvInsightCardProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
+    click: () => any;
+    "icon-click": () => any;
+}, string, PublicProps, Readonly<PvInsightCardProps> & Readonly<{
+    onClick?: (() => any) | undefined;
+    "onIcon-click"?: (() => any) | undefined;
+}>, {
+    icon: string;
+    interactive: boolean;
+    showButton: boolean;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+export default _default;

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

@@ -0,0 +1,57 @@
+import { VNodeChild, DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+import { MenuOption, MenuOptionSelectedEvent, SeeMoreEvent } from '../../../types';
+import { PvMenuProps, PvMenuChildrenDisplay } from './types';
+type __VLS_Props = PvMenuProps;
+type __VLS_PublicProps = {
+    "selectedItems"?: MenuOption[];
+    "expandedOptionId"?: string | undefined;
+} & __VLS_Props;
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: Readonly<{
+        popover?(props: {
+            option: MenuOption;
+            popoverId: string;
+            close: () => void;
+        }): VNodeChild;
+    }> & {
+        popover?(props: {
+            option: MenuOption;
+            popoverId: string;
+            close: () => void;
+        }): VNodeChild;
+    };
+    refs: {
+        rootMenuRef: HTMLUListElement;
+        nestedMenuPopoverRef: HTMLDivElement;
+        nestedMenuRef: HTMLUListElement;
+    };
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+    "update:selectedItems": (value: MenuOption<unknown>[]) => any;
+    "update:expandedOptionId": (value: string | undefined) => any;
+} & {
+    "handle-selected": (payload: MenuOptionSelectedEvent) => any;
+    "see-more": (payload: SeeMoreEvent) => any;
+}, string, PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    "onHandle-selected"?: ((payload: MenuOptionSelectedEvent) => any) | undefined;
+    "onSee-more"?: ((payload: SeeMoreEvent) => any) | undefined;
+    "onUpdate:selectedItems"?: ((value: MenuOption<unknown>[]) => any) | undefined;
+    "onUpdate:expandedOptionId"?: ((value: string | undefined) => any) | undefined;
+}>, {
+    childrenDisplay: PvMenuChildrenDisplay;
+    highlightParentItems: boolean;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {
+    rootMenuRef: HTMLUListElement;
+    nestedMenuPopoverRef: HTMLDivElement;
+    nestedMenuRef: HTMLUListElement;
+}, any>;
+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/PvMenu/PvMenuControlPanel.vue.d.ts

@@ -0,0 +1,26 @@
+import { MenuActionsVariant } from '../PvMultiSelectButton/types.ts';
+import { DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+type __VLS_Props = {
+    variant?: MenuActionsVariant;
+    disabled?: boolean;
+    /**
+     * Human-readable filter name used to derive `data-dd-action-name` on the
+     * Select All and Clear All buttons (e.g. "Select all Payer Network options",
+     * "Clear Payer Network selections"). Leave unset to skip the attributes.
+     * Cancel/Confirm intentionally don't get derived labels — the cancel-confirm
+     * variant has no production consumers today.
+     */
+    rumFilterName?: string;
+};
+declare const _default: DefineComponent<__VLS_Props, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
+    "handle-select-all": () => any;
+    "handle-clear-all": () => any;
+    "handle-cancel": () => any;
+    "handle-confirm": () => any;
+}, string, PublicProps, Readonly<__VLS_Props> & Readonly<{
+    "onHandle-select-all"?: (() => any) | undefined;
+    "onHandle-clear-all"?: (() => any) | undefined;
+    "onHandle-cancel"?: (() => any) | undefined;
+    "onHandle-confirm"?: (() => any) | undefined;
+}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLDivElement>;
+export default _default;

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

@@ -0,0 +1,3 @@
+import { DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+declare const _default: DefineComponent<{}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, HTMLDivElement>;
+export default _default;

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

@@ -0,0 +1,42 @@
+import { MenuOption, MultiSelectState } from '../../../types';
+/**
+ * Returns true when an option has children, whether they are already loaded or
+ * only represented by the server-provided `totalChildCount` for lazy-loading.
+ * Fully loaded children still count as cascade children — this helper answers
+ * "is this a parent?", not "are there more children to load?".
+ */
+export declare function hasCascadeChildren<T>(option: MenuOption<T>): boolean;
+/** Recursively collect all leaf (childless) options from a tree. */
+export declare function collectLeafOptions<T>(options: MenuOption<T>[]): MenuOption<T>[];
+/**
+ * Merge two sets of leaf options, deduplicating by ID.
+ *
+ * Returns a single array containing every leaf from `base`, plus any leaves
+ * from `overlay` whose ID doesn't already appear in `base`. This is used to
+ * combine original (unfiltered) leaves with dynamically loaded (see-more)
+ * leaves so that the full set is available for selection / checked-state logic.
+ */
+export declare function mergeLeafOptions<T>(base: MenuOption<T>[], overlay: MenuOption<T>[]): MenuOption<T>[];
+/**
+ * Count selected items, collapsing fully-selected parents to 1.
+ *
+ * Walks the option tree bottom-up. A parent whose leaf descendants are ALL
+ * selected counts as 1 (replacing the individual counts of its sub-tree).
+ * Selected leaves not under a fully-selected parent each count as 1.
+ *
+ * This is order-independent — it walks the tree structure directly and does
+ * not depend on Map iteration order.
+ */
+export declare function countWithCollapsedParents<T>(options: MenuOption<T>[], selectedIds: Set<string>): number;
+export declare function countFromSelectionState(state: MultiSelectState): number;
+/**
+ * Recursively filter a tree for a search value.
+ *
+ * - If a node's own text matches, it is kept with all its children intact.
+ * - If a node's own text does NOT match but one or more of its descendants do,
+ *   the node is kept as a container showing only the matching descendants.
+ *   This means a search term that matches a child will surface that child even
+ *   when the parent label itself doesn't contain the search term.
+ * - Nodes with no match anywhere in their subtree are removed entirely.
+ */
+export declare function filterOptionsRecursive<T>(options: MenuOption<T>[], searchValue: string, showParentOnChildQueryMatch?: boolean): MenuOption<T>[];

package/pv-components/dist/vue/ai/components/base/PvMenu/items/PvMenuBaseItem.vue.d.ts

@@ -0,0 +1,11 @@
+import { MenuOption, MenuOptionConfig } from '../../../../types.ts';
+import { DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+interface PvMenuBaseItemProps extends MenuOption {
+    menuOptionConfig?: MenuOptionConfig;
+    queryText?: string | null;
+}
+declare const _default: DefineComponent<PvMenuBaseItemProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<PvMenuBaseItemProps> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {
+    mainText: HTMLSpanElement;
+    subText: HTMLSpanElement;
+}, any>;
+export default _default;

package/pv-components/dist/vue/ai/components/base/PvMenu/items/PvMenuItem.vue.d.ts

@@ -0,0 +1,26 @@
+import { MenuOption, MenuOptionConfig, MenuOptionSelectedEvent, SeeMoreEvent } from '../../../../types.ts';
+import { DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+interface PvMenuItemProps extends MenuOption {
+    level?: number;
+    config?: MenuOptionConfig;
+    queryText?: string | null;
+    highlightSearchText?: boolean;
+    itemClass?: string;
+}
+type __VLS_Props = PvMenuItemProps;
+type __VLS_PublicProps = {
+    "selectedIds"?: string[];
+} & __VLS_Props;
+declare const _default: DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+    "update:selectedIds": (value: string[]) => any;
+} & {
+    "handle-selected": (payload: MenuOptionSelectedEvent) => any;
+    "see-more": (payload: SeeMoreEvent) => any;
+}, string, PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    "onHandle-selected"?: ((payload: MenuOptionSelectedEvent) => any) | undefined;
+    "onSee-more"?: ((payload: SeeMoreEvent) => any) | undefined;
+    "onUpdate:selectedIds"?: ((value: string[]) => any) | undefined;
+}>, {
+    level: number;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+export default _default;

package/pv-components/dist/vue/ai/components/base/PvMenu/items/PvMenuItemAction.vue.d.ts

@@ -0,0 +1,9 @@
+import { MenuAction, MenuOption } from '../../../../types';
+import { DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+interface PvMenuItemActionProps {
+    action: MenuAction<any>;
+    option: MenuOption;
+    disabled?: boolean;
+}
+declare const _default: DefineComponent<PvMenuItemActionProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<PvMenuItemActionProps> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+export default _default;

package/pv-components/dist/vue/ai/components/base/PvMenu/items/PvMenuItemVariant.vue.d.ts

@@ -0,0 +1,22 @@
+import { MenuOption, MenuOptionConfig, MenuOptionSelectedEvent } from '../../../../types.ts';
+import { DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+export interface PvMenuItemVariantProps extends MenuOption {
+    selected?: boolean;
+    indeterminate?: boolean;
+    queryText?: string | null;
+    highlightSearchText?: boolean;
+    menuOptionConfig?: MenuOptionConfig;
+    showChevron?: boolean;
+    chevronIcon?: string;
+    expanded?: boolean;
+}
+declare const _default: DefineComponent<PvMenuItemVariantProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
+    "handle-selected": (payload: MenuOptionSelectedEvent) => any;
+    "toggle-expanded": () => any;
+}, string, PublicProps, Readonly<PvMenuItemVariantProps> & Readonly<{
+    "onHandle-selected"?: ((payload: MenuOptionSelectedEvent) => any) | undefined;
+    "onToggle-expanded"?: (() => any) | undefined;
+}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {
+    inputRef: HTMLInputElement;
+}, any>;
+export default _default;

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

@@ -0,0 +1,11 @@
+import { ComputedRef, InjectionKey, Ref } from 'vue';
+import { MenuOption } from '../../../types';
+export declare const SelectedItemsKey: InjectionKey<Ref<MenuOption[]>>;
+export declare const EnableCascadeSelectionKey: InjectionKey<ComputedRef<boolean>>;
+export declare const MenuInteractionModeKey: InjectionKey<ComputedRef<boolean>>;
+export declare const MenuAncestorIdsKey: InjectionKey<string[]>;
+export declare const OriginalOptionsMapKey: InjectionKey<ComputedRef<Map<string, MenuOption>>>;
+export declare const CascadeSelectedParentIdsKey: InjectionKey<Ref<Set<string>>>;
+export declare const CascadeDeselectedChildIdsKey: InjectionKey<Ref<Map<string, Set<string>>>>;
+export declare const ParentSelectsAllChildrenKey: InjectionKey<ComputedRef<boolean>>;
+export declare const EnableChildExpansionKey: InjectionKey<ComputedRef<boolean>>;

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

@@ -0,0 +1,31 @@
+import { MenuOption, MenuOptionConfig } from '../../../types';
+export type PvMenuChildrenDisplay = "inline" | "popover";
+export interface PvMenuProps {
+    /** Array of menu options to render. */
+    options: MenuOption[];
+    /** Render child options inline or render each top-level option's direct children in a click-opened popover. Popover mode ignores enableCascadeSelection. */
+    childrenDisplay?: PvMenuChildrenDisplay;
+    /** Configuration for menu item appearance and behavior (variant, action, etc.). */
+    config?: MenuOptionConfig;
+    /** Search query text used to highlight matching text in menu items. */
+    queryText?: string | null;
+    /** data-testid attribute applied to each menu list item. */
+    itemTestId?: string;
+    /** CSS class applied to each menu list item element. */
+    itemClass?: string;
+    /** When true, only selected items are visible (used during loading states). */
+    isLoading?: boolean;
+    /** When true, the top-level See more button shows a loading spinner. */
+    isSeeMoreLoading?: boolean;
+    /** When true, only one item can be selected at a time (radio behavior). */
+    singleSelect?: boolean;
+    /** When true, a selected single-select item cannot be deselected by selecting it again. */
+    disableDeselect?: boolean;
+    /** When false, expandable parents do not receive the active-row background from selection or expansion. */
+    highlightParentItems?: boolean;
+    /** When true, selecting an inline parent option toggles all its leaf children. Ignored in popover mode. */
+    enableCascadeSelection?: boolean;
+    hasMoreOptions?: boolean;
+    /** When true, item clicks are ignored — the list is display-only. */
+    readOnly?: boolean;
+}

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

@@ -0,0 +1,66 @@
+import { CSSProperties, Ref, ComputedRef } from 'vue';
+export interface PopoverComponent {
+    popoverRef: PopoverRefElement;
+}
+export interface TriggerComponent {
+    triggerRef: HTMLElement | null;
+}
+export interface PopoverRefElement {
+    popoverRoot: HTMLElement | null;
+}
+export declare const useMenuPosition: ({ alignment, useTeleport, popoverCssProperties, }?: {
+    alignment?: "top" | "right" | "top right";
+    useTeleport?: boolean;
+    popoverCssProperties?: CSSProperties;
+}) => {
+    triggerRef: Ref<HTMLElement | null, HTMLElement | null>;
+    popoverRef: Ref<{
+        popoverRoot: HTMLElement | null;
+    } | null, PopoverRefElement | {
+        popoverRoot: HTMLElement | null;
+    } | null>;
+    triggerRect: Ref<{
+        height: number;
+        width: number;
+        x: number;
+        y: number;
+        readonly bottom: number;
+        readonly left: number;
+        readonly right: number;
+        readonly top: number;
+        toJSON: () => any;
+    } | null, DOMRect | {
+        height: number;
+        width: number;
+        x: number;
+        y: number;
+        readonly bottom: number;
+        readonly left: number;
+        readonly right: number;
+        readonly top: number;
+        toJSON: () => any;
+    } | null>;
+    popoverRect: Ref<{
+        height: number;
+        width: number;
+        x: number;
+        y: number;
+        readonly bottom: number;
+        readonly left: number;
+        readonly right: number;
+        readonly top: number;
+        toJSON: () => any;
+    } | null, DOMRect | {
+        height: number;
+        width: number;
+        x: number;
+        y: number;
+        readonly bottom: number;
+        readonly left: number;
+        readonly right: number;
+        readonly top: number;
+        toJSON: () => any;
+    } | null>;
+    popoverPositionStyle: ComputedRef<CSSProperties | undefined>;
+    updateRects: () => void;
+};

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

@@ -0,0 +1,31 @@
+import { DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+export interface ModalProps {
+    header: string;
+    subheader?: string;
+    disableCloseOnClickOutside?: boolean;
+    hideFooter?: boolean;
+    hideHeader?: boolean;
+}
+declare const _default: __VLS_WithTemplateSlots< DefineComponent<{
+    modelValue: boolean;
+} & ModalProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+    "update:modelValue": (value: boolean) => any;
+}, string, PublicProps, Readonly<{
+    modelValue: boolean;
+} & ModalProps> & Readonly<{
+    "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+}>, {
+    disableCloseOnClickOutside: boolean;
+    hideFooter: boolean;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {
+    dialog: HTMLDialogElement;
+}, HTMLDialogElement>, {
+    body?(_: {}): any;
+    footer?(_: {}): any;
+}>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};