@astryx-vue/core 0.1.1 → 0.1.3

package/dist/{index-Bc0dgVM5.d.ts → index-CTolyeii.d.ts}

@@ -305,12 +305,12 @@ declare const __VLS_base$3: import("vue").DefineComponent<__VLS_PublicProps, {
   focus: () => void | undefined;
   open: () => void;
 }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
-  select: (item: ContextMenuItemData, event: MouseEvent) => any;
   openChange: (isOpen: boolean) => any;
+  select: (item: ContextMenuItemData, event: MouseEvent) => any;
   "update:isOpen": (...args: unknown[]) => any;
 }, string, import("vue").PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
-  onSelect?: ((item: ContextMenuItemData, event: MouseEvent) => any) | undefined;
   onOpenChange?: ((isOpen: boolean) => any) | undefined;
+  onSelect?: ((item: ContextMenuItemData, event: MouseEvent) => any) | undefined;
   "onUpdate:isOpen"?: ((...args: unknown[]) => any) | undefined;
 }>, {
   label: string;
@@ -365,11 +365,11 @@ type __VLS_WithSlots$1<T, S> = T & {
 //#region src/ContextMenu/ContextMenuSubMenu.vue.d.ts
 type __VLS_Slots = ContextMenuSubMenuSlots;
 declare const __VLS_base: import("vue").DefineComponent<ContextMenuSubMenuProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
-  select: (item: ContextMenuItemData, event: MouseEvent) => any;
   openChange: (isOpen: boolean) => any;
+  select: (item: ContextMenuItemData, event: MouseEvent) => any;
 }, string, import("vue").PublicProps, Readonly<ContextMenuSubMenuProps> & Readonly<{
-  onSelect?: ((item: ContextMenuItemData, event: MouseEvent) => any) | undefined;
   onOpenChange?: ((isOpen: boolean) => any) | undefined;
+  onSelect?: ((item: ContextMenuItemData, event: MouseEvent) => any) | undefined;
 }>, {
   isDisabled: boolean;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;

package/dist/index-CVn0GBdB.d.ts

@@ -0,0 +1,115 @@
+import { VNode } from "vue";
+//#region src/Stepper/types.d.ts
+type StepperOrientation = 'horizontal' | 'vertical';
+type StepperDensity = 'compact' | 'balanced' | 'spacious';
+type StepperIndicatorPosition = 'separated' | 'on-track';
+type StepStatus = 'accent' | 'success' | 'warning' | 'error';
+type StepProgress = 'completed' | 'in-progress' | 'not-started';
+type StepIndicator = 'auto' | 'number' | 'none';
+type StepperCollapsedVariant = 'withLabelAndControls' | 'withLabel' | 'hiddenLabel';
+interface StepperHorizontalOptions {
+  /**
+   * Collapse a horizontal stepper when its width is below this value times
+   * the step count. The collapsed view keeps the track.
+   * @default 112
+   */
+  minimumStepWidth?: number;
+  /**
+   * What the collapsed row shows. Controls appear only for
+   * `withLabelAndControls` when `onStepClick` is set.
+   * @default 'withLabelAndControls'
+   */
+  collapsedVariant?: StepperCollapsedVariant;
+}
+interface StepperProps {
+  /** Zero-based index of the current step. */
+  activeStep: number;
+  /** @default 'horizontal' */
+  orientation?: StepperOrientation;
+  /**
+   * When set, steps render as buttons and call this with the zero-based index.
+   * `@step-click` fills the same prop.
+   */
+  onStepClick?: (index: number) => void;
+  /** Accessible name of the list. */
+  label?: string;
+  /** @default 'balanced' */
+  density?: StepperDensity;
+  /** @default 'separated' */
+  indicatorPosition?: StepperIndicatorPosition;
+  /**
+   * In a narrow horizontal stepper, hide every label except the current one.
+   * @default false
+   */
+  hasCollapsibleLabels?: boolean;
+  /**
+   * Narrow-width behavior for a horizontal stepper. `minimumStepWidth` defaults
+   * to 112: a horizontal stepper narrower than that times the step count
+   * collapses to the current step. `collapsedVariant` chooses a label with
+   * controls, the label alone, or the track with no compact row.
+   */
+  horizontalOptions?: StepperHorizontalOptions;
+}
+interface StepperSlots {
+  default?: () => VNode[];
+}
+interface StepProps {
+  /** Zero-based index of this step. */
+  step: number;
+  label: string;
+  description?: string;
+  /** Recolors the indicator only. The connector stays on the progress color. */
+  status?: StepStatus;
+  /** @default false */
+  isDisabled?: boolean;
+  /** @default false */
+  isOptional?: boolean;
+  /**
+   * `auto` shows a check, a ring, or a number. `number` always shows the
+   * step number. `none` leaves the indicator empty.
+   * @default 'auto'
+   */
+  indicator?: StepIndicator;
+  density?: StepperDensity;
+}
+interface StepSlots {
+  /** Content under the label. In a vertical separated step it sits outside the button. */
+  default?: () => VNode[];
+  /** Replaces the built-in indicator artwork. */
+  icon?: () => VNode[];
+  /** Trailing content on the label row. */
+  end?: () => VNode[];
+}
+//#endregion
+//#region src/Stepper/Step.vue.d.ts
+type __VLS_Slots$1 = StepSlots;
+declare const __VLS_base$1: import("vue").DefineComponent<StepProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<StepProps> & Readonly<{}>, {
+  isDisabled: boolean;
+  isOptional: boolean;
+  indicator: StepIndicator;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export$1: __VLS_WithSlots$1<typeof __VLS_base$1, __VLS_Slots$1>;
+declare const _default$1: typeof __VLS_export$1;
+type __VLS_WithSlots$1<T, S> = T & {
+  new (): {
+    $slots: S;
+  };
+};
+//#endregion
+//#region src/Stepper/Stepper.vue.d.ts
+type __VLS_Slots = StepperSlots;
+declare const __VLS_base: import("vue").DefineComponent<StepperProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<StepperProps> & Readonly<{}>, {
+  orientation: StepperOrientation;
+  density: StepperDensity;
+  indicatorPosition: StepperIndicatorPosition;
+  hasCollapsibleLabels: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+type __VLS_WithSlots<T, S> = T & {
+  new (): {
+    $slots: S;
+  };
+};
+//#endregion
+export { StepProps as a, StepperCollapsedVariant as c, StepperIndicatorPosition as d, StepperOrientation as f, StepProgress as i, StepperDensity as l, StepperSlots as m, _default$1 as n, StepSlots as o, StepperProps as p, StepIndicator as r, StepStatus as s, _default as t, StepperHorizontalOptions as u };

package/dist/index-CX97hlld.d.ts

@@ -0,0 +1,158 @@
+import { s as ButtonSize } from "./types-WlmsNL1I.js";
+import { l as FieldStatusVariant, o as FieldStatusInput } from "./types-3eXh_5os.js";
+import { r as PopoverPlacement, t as PopoverAlignment } from "./types-Db3Owy8Q.js";
+import { Component, Ref, VNode, VNodeChild } from "vue";
+//#region src/Icon/types.d.ts
+/**
+ * The semantic names of the artwork astryx-vue keeps for its own chrome.
+ *
+ * A name describes what the icon is for, not one particular drawing, so a theme
+ * can replace the artwork with one declaration. Applications never pass these
+ * names: the artwork is a library implementation detail, and a `icon` prop or
+ * slot takes a CSS icon class or the application's own component instead.
+ */
+type IconName = 'chevronDown' | 'chevronLeft' | 'chevronRight' | 'check' | 'moreHorizontal' | 'copy' | 'calendar' | 'clock' | 'upload' | 'arrowUp' | 'arrowDown' | 'close' | 'funnel' | 'image';
+/**
+ * A built-in name, or any other string.
+ *
+ * The `(string & {})` intersection keeps the built-in names available for
+ * autocomplete while allowing keys contributed by a component or application.
+ */
+type ExtendedIconName = IconName | (string & {});
+//#endregion
+//#region src/ComplexSelector/types.d.ts
+interface ComplexSelectorState {
+  isOpen: boolean;
+  isBusy: boolean;
+  triggerId: string;
+  contentId: string;
+}
+type ComplexSelectorVariant = 'input' | 'ghost';
+interface ComplexSelectorHandle {
+  /** Open the popup. */
+  open: () => void;
+  /** Close the popup. */
+  close: () => void;
+  /** Open when closed, and close when open. */
+  toggle: () => void;
+  /** Whether the popup is open. */
+  isOpen: () => boolean;
+}
+/**
+ * A Vue ref or a callback. In a template, pass a callback: template refs are
+ * unwrapped, so `:handle-ref="someRef"` would hand over `null`.
+ */
+type ComplexSelectorHandleRef = Ref<ComplexSelectorHandle | null> | ((handle: ComplexSelectorHandle | null) => void);
+interface ComplexSelectorTriggerProps {
+  'id': string;
+  'onClick': (event: MouseEvent) => void;
+  'onKeydown': (event: KeyboardEvent) => void;
+  'aria-haspopup': 'dialog';
+  'aria-expanded': boolean;
+  'aria-controls': string | undefined;
+  'aria-busy': true | undefined;
+  'aria-label': string;
+}
+interface ComplexSelectorSlotProps<Value> {
+  /** The value shown in the field, including a pending optimistic value. */
+  value: Value;
+  /** Commit the next value and run `changeAction` when one was provided. */
+  commit: (value: Value) => void;
+  /** Close the popup. */
+  close: () => void;
+  state: ComplexSelectorState;
+}
+interface ComplexSelectorProps<Value = unknown> {
+  /** Field label. It also names the popup. */
+  label: string;
+  /** Current value. Bind with `v-model`. */
+  modelValue: Value;
+  /** Text shown on the trigger. Falls back to `placeholder`. */
+  triggerLabel?: string;
+  /** Shown when `triggerLabel` is empty. */
+  placeholder?: string;
+  /** Hide the visible label. The accessible name stays. */
+  isLabelHidden?: boolean;
+  /** Supporting text under the label. */
+  description?: string;
+  /** @default false */
+  isOptional?: boolean;
+  /** @default false */
+  isRequired?: boolean;
+  /** @default false */
+  isDisabled?: boolean;
+  /** @default false */
+  isLoading?: boolean;
+  status?: FieldStatusInput;
+  /** @default 'attached' */
+  statusVariant?: FieldStatusVariant | 'tooltip';
+  labelTooltip?: string;
+  /** @default 'md' */
+  size?: ButtonSize;
+  width?: number | string;
+  /** @default 'below' */
+  placement?: PopoverPlacement;
+  /**
+   * Popup alignment along the placement axis.
+   * @default 'start'
+   */
+  alignment?: PopoverAlignment;
+  /**
+   * Icon at the start of the built-in trigger. A CSS icon class, a chrome
+   * name, or a component.
+   */
+  startIcon?: ExtendedIconName | Component;
+  /**
+   * `input` is the bordered field. `ghost` matches a toolbar button.
+   * @default 'input'
+   */
+  variant?: ComplexSelectorVariant;
+  /**
+   * Replaces the field and the built-in trigger. Spread the argument onto the
+   * control the popup should hang off. `label` still names the popup.
+   */
+  renderTrigger?: (props: ComplexSelectorTriggerProps) => VNode;
+  /**
+   * Imperative open, close, toggle, and isOpen. A template `ref` on the
+   * component exposes the same methods.
+   */
+  handleRef?: ComplexSelectorHandleRef;
+  /**
+   * Runs after the value changes. While it is pending the trigger shows a
+   * spinner and the slot sees the value that was just committed.
+   */
+  changeAction?: (value: Value) => void | Promise<void>;
+}
+interface ComplexSelectorEmits<Value> {
+  change: [value: Value];
+}
+interface ComplexSelectorSlots<Value> {
+  default?: (props: ComplexSelectorSlotProps<Value>) => VNode[];
+  /**
+   * Replaces the field and the built-in trigger, the same job as
+   * `renderTrigger`. Spread the bindings onto the control.
+   */
+  trigger?: (props: ComplexSelectorTriggerProps) => VNode[];
+}
+//#endregion
+//#region src/ComplexSelector/ComplexSelector.vue.d.ts
+declare const __VLS_export: <Value>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+  props: import("vue").PublicProps & __VLS_PrettifyLocal<(ComplexSelectorProps<Value> & {
+    modelValue: Value;
+  }) & {
+    onChange?: ((value: Value) => any) | undefined;
+    "onUpdate:modelValue"?: ((value: Value) => any) | undefined;
+  }> & (typeof globalThis extends {
+    __VLS_PROPS_FALLBACK: infer P;
+  } ? P : {});
+  expose: (exposed: import("vue").ShallowUnwrapRef<ComplexSelectorHandle>) => void;
+  attrs: any;
+  slots: ComplexSelectorSlots<Value>;
+  emit: ((evt: "change", value: Value) => void) & ((event: "update:modelValue", value: Value) => void);
+}>) => import("vue").VNode & {
+  __ctx?: NonNullable<Awaited<typeof __VLS_setup>>;
+};
+declare const _default: typeof __VLS_export;
+type __VLS_PrettifyLocal<T> = (T extends any ? { [K in keyof T]: T[K]; } : { [K in keyof T as K]: T[K]; }) & {};
+//#endregion
+export { ComplexSelectorProps as a, ComplexSelectorState as c, ComplexSelectorHandleRef as i, ComplexSelectorTriggerProps as l, ComplexSelectorEmits as n, ComplexSelectorSlotProps as o, ComplexSelectorHandle as r, ComplexSelectorSlots as s, _default as t, ComplexSelectorVariant as u };

package/dist/index-CjtAH60j.d.ts

@@ -0,0 +1,38 @@
+import { n as LayerPlacement, t as LayerAlignment } from "./position-DFW5ymAF.js";
+import { a as PopoverRole, i as PopoverProps, n as PopoverPadding } from "./types-Db3Owy8Q.js";
+//#region src/Popover/Popover.vue.d.ts
+declare var __VLS_1: {}, __VLS_9: {};
+type __VLS_Slots = {} & {
+  default?: (props: typeof __VLS_1) => any;
+} & {
+  content?: (props: typeof __VLS_9) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<PopoverProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+  openChange: (isOpen: boolean) => any;
+}, string, import("vue").PublicProps, Readonly<PopoverProps> & Readonly<{
+  onOpenChange?: ((isOpen: boolean) => any) | undefined;
+}>, {
+  label: string;
+  width: string | number;
+  padding: PopoverPadding;
+  isOpen: boolean;
+  placement: LayerPlacement;
+  alignment: LayerAlignment;
+  hasAutoFocus: boolean;
+  isEnabled: boolean;
+  role: PopoverRole;
+  isModal: boolean;
+  hasCloseButton: boolean;
+  closeButtonLabel: string;
+  hasLightDismiss: boolean;
+  hasEscapeDismiss: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+type __VLS_WithSlots<T, S> = T & {
+  new (): {
+    $slots: S;
+  };
+};
+//#endregion
+export { _default as t };

package/dist/{index-5R_pi3eT.d.ts → index-D-ZuubCK.d.ts}

@@ -34,10 +34,10 @@ declare const __VLS_base$2: import("vue").DefineComponent<ItemProps, {
 }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<ItemProps> & Readonly<{}>, {
   isDisabled: boolean;
   as: ItemElement;
-  align: ItemAlign;
-  layout: ItemLayout;
   density: ListDensity;
   isSelected: boolean;
+  align: ItemAlign;
+  layout: ItemLayout;
   isHighlighted: boolean;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const __VLS_export$2: __VLS_WithSlots$2<typeof __VLS_base$2, __VLS_Slots$2>;
@@ -53,8 +53,8 @@ type __VLS_Slots$1 = ListSlots;
 declare const __VLS_base$1: import("vue").DefineComponent<ListProps, {
   element: import("vue").ComputedRef<HTMLUListElement | HTMLOListElement | null>;
 }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<ListProps> & Readonly<{}>, {
-  start: number;
   density: ListDensity;
+  start: number;
   hasDividers: boolean;
   listStyle: ListMarkerStyle;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;

package/dist/index-DA52oIdw.d.ts

@@ -0,0 +1,171 @@
+import { ComputedRef, InjectionKey, VNode } from "vue";
+//#region src/Collapsible/types.d.ts
+/**
+ * Logical side of the trigger label that carries the disclosure chevron.
+ *
+ * `end` is a trailing status indicator: it follows the label, points down while
+ * the content is collapsed, and flips up when it expands. `start` is a leading
+ * disclosure arrow: it sits before the label, points inward toward the content
+ * while collapsed — mirrored under RTL — and turns down when it expands.
+ */
+type CollapsibleChevronPosition = 'start' | 'end';
+interface CollapsibleProps {
+  /**
+   * Plain-text trigger label.
+   *
+   * Use the `trigger` slot when the label needs markup, a heading, or
+   * additional controls; the slot replaces this prop entirely.
+   */
+  trigger?: string;
+  /**
+   * Open state the component starts in while `isOpen` stays unbound.
+   * @default true
+   */
+  defaultIsOpen?: boolean;
+  /**
+   * Whether the trigger can be operated.
+   *
+   * A disabled trigger is dimmed, announces itself as disabled, and leaves the
+   * tab order. Disabling never collapses content that is already open.
+   * @default false
+   */
+  isDisabled?: boolean;
+  /**
+   * Logical side of the trigger label that carries the disclosure chevron.
+   * @default 'end'
+   */
+  chevronPosition?: CollapsibleChevronPosition;
+  /**
+   * Controlled open state, bound with `v-model:isOpen`. Leave it unbound to let
+   * the component own its state, starting from `defaultIsOpen`.
+   *
+   * Inside a `CollapsibleGroup`, the group owns the open state and this prop
+   * is ignored.
+   */
+  isOpen?: boolean;
+  /**
+   * Identifier used by a parent `CollapsibleGroup`. A collapsible without a
+   * `value` keeps its own open state even when it sits inside a group.
+   */
+  value?: string;
+}
+interface CollapsibleEmits {
+  /**
+   * Emitted with the open state the trigger asks for. In uncontrolled usage it
+   * reports the change; in controlled usage it is the request to update the
+   * bound state.
+   */
+  openChange: [isOpen: boolean];
+}
+interface CollapsibleSlots {
+  /** The content hidden while collapsed and revealed while expanded. */
+  default?: () => VNode[];
+  /** The trigger label. Replaces the `trigger` prop. */
+  trigger?: () => VNode[];
+}
+//#endregion
+//#region src/Collapsible/Collapsible.vue.d.ts
+type __VLS_Props$1 = Omit<CollapsibleProps, 'isOpen'>;
+type __VLS_Slots$1 = CollapsibleSlots;
+type __VLS_ModelProps$1 = {
+  'isOpen'?: boolean | undefined;
+};
+type __VLS_PublicProps$1 = __VLS_Props$1 & __VLS_ModelProps$1;
+declare const __VLS_base$1: import("vue").DefineComponent<__VLS_PublicProps$1, {
+  element: import("vue").ComputedRef<HTMLDivElement | null>;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+  openChange: (isOpen: boolean) => any;
+  "update:isOpen": (value: boolean | undefined) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_PublicProps$1> & Readonly<{
+  onOpenChange?: ((isOpen: boolean) => any) | undefined;
+  "onUpdate:isOpen"?: ((value: boolean | undefined) => any) | undefined;
+}>, {
+  isDisabled: boolean;
+  defaultIsOpen: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export$1: __VLS_WithSlots$1<typeof __VLS_base$1, __VLS_Slots$1>;
+declare const _default$1: typeof __VLS_export$1;
+type __VLS_WithSlots$1<T, S> = T & {
+  new (): {
+    $slots: S;
+  };
+};
+//#endregion
+//#region src/Collapsible/context.d.ts
+type CollapsibleGroupDensity = 'compact' | 'balanced' | 'spacious';
+type CollapsibleGroupType = 'single' | 'multiple';
+type CollapsibleGroupValue = string | string[];
+//#endregion
+//#region src/Collapsible/groupTypes.d.ts
+interface CollapsibleGroupProps {
+  /**
+   * `single` keeps one section open and lets a second click close it.
+   * `multiple` toggles each section on its own.
+   * @default 'single'
+   */
+  type?: CollapsibleGroupType;
+  /**
+   * Open section when the group owns its state. A string in single mode, a
+   * list in multiple mode.
+   */
+  defaultValue?: CollapsibleGroupValue;
+  /**
+   * Controlled open section, bound with `v-model:value`.
+   */
+  value?: CollapsibleGroupValue;
+  /**
+   * Draw a hairline between sections and give them accordion padding.
+   * @default false
+   */
+  hasDividers?: boolean;
+  /**
+   * Trigger and content padding. With `hasDividers` and no density, the group
+   * uses `balanced`.
+   */
+  density?: CollapsibleGroupDensity;
+  /**
+   * Chevron side for the group's sections. A section can still set its own
+   * `chevronPosition`.
+   * @default 'end'
+   */
+  chevronPosition?: CollapsibleChevronPosition;
+}
+interface CollapsibleGroupEmits {
+  /**
+   * The next open value: a string in single mode (`''` when everything is
+   * closed) or a list in multiple mode.
+   */
+  change: [value: CollapsibleGroupValue];
+}
+interface CollapsibleGroupSlots {
+  /** `Collapsible` sections. Give each one a `value` so the group can coordinate it. */
+  default?: () => VNode[];
+}
+//#endregion
+//#region src/Collapsible/CollapsibleGroup.vue.d.ts
+type __VLS_Props = CollapsibleGroupProps;
+type __VLS_Slots = CollapsibleGroupSlots;
+type __VLS_ModelProps = {
+  'value'?: CollapsibleGroupValue;
+};
+type __VLS_PublicProps = __VLS_Props & __VLS_ModelProps;
+declare const __VLS_base: import("vue").DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+  "update:value": (value: CollapsibleGroupValue | undefined) => any;
+  change: (value: CollapsibleGroupValue) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+  "onUpdate:value"?: ((value: CollapsibleGroupValue | undefined) => any) | undefined;
+  onChange?: ((value: CollapsibleGroupValue) => any) | undefined;
+}>, {
+  type: CollapsibleGroupType;
+  hasDividers: boolean;
+  chevronPosition: CollapsibleChevronPosition;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+type __VLS_WithSlots<T, S> = T & {
+  new (): {
+    $slots: S;
+  };
+};
+//#endregion
+export { CollapsibleGroupDensity as a, _default$1 as c, CollapsibleProps as d, CollapsibleSlots as f, CollapsibleGroupSlots as i, CollapsibleChevronPosition as l, CollapsibleGroupEmits as n, CollapsibleGroupType as o, CollapsibleGroupProps as r, CollapsibleGroupValue as s, _default as t, CollapsibleEmits as u };

package/dist/{index-D3V7yRUP.d.ts → index-DGNqi2za.d.ts}

@@ -89,8 +89,8 @@ declare const __VLS_base: import("vue").DefineComponent<MultiSelectorProps, {
   size: MultiSelectorSize;
   required: boolean;
   variant: MultiSelectorVariant;
-  modelValue: readonly (string | number)[];
   status: MultiSelectorStatus;
+  modelValue: readonly (string | number)[];
   labelHidden: boolean;
   disabled: boolean;
   clearable: boolean;

package/dist/{index-CCA4R0Mf.d.ts → index-DT9S92sh.d.ts}

@@ -23,6 +23,21 @@ interface TabListProps {
    */
   hasDivider?: boolean;
 }
+interface TabMenuOption {
+  value: string;
+  label: string;
+  /** CSS icon class, for example `i-carbon-settings`. */
+  iconClass?: string;
+}
+interface TabMenuProps {
+  /**
+   * Trigger text when none of the options is the selected tab, and the
+   * accessible name of the menu.
+   */
+  label: string;
+  /** Secondary tabs collected behind the trigger. */
+  options: TabMenuOption[];
+}
 interface TabProps {
   /**
    * Unique value for this tab.
@@ -42,6 +57,12 @@ interface TabListTab {
   value: string;
   disabled: boolean;
   el: HTMLElement;
+  /**
+   * When false, arrowing onto this stop focuses it without changing the
+   * selected value. TabMenu uses that so the overflow trigger is in the
+   * roving order without becoming a tab value of its own.
+   */
+  selectsOnFocus?: boolean;
 }
 //#endregion
 //#region src/TabList/Tab.vue.d.ts
@@ -52,8 +73,8 @@ type __VLS_Slots$1 = {} & {
 declare const __VLS_base$1: import("vue").DefineComponent<TabProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<TabProps> & Readonly<{}>, {
   disabled: boolean;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
-declare const __VLS_export$1: __VLS_WithSlots$1<typeof __VLS_base$1, __VLS_Slots$1>;
-declare const _default$1: typeof __VLS_export$1;
+declare const __VLS_export$2: __VLS_WithSlots$1<typeof __VLS_base$1, __VLS_Slots$1>;
+declare const _default$2: typeof __VLS_export$2;
 type __VLS_WithSlots$1<T, S> = T & {
   new (): {
     $slots: S;
@@ -72,15 +93,19 @@ declare const __VLS_base: import("vue").DefineComponent<TabListProps, {}, {}, {}
   onChange?: ((value: string) => any) | undefined;
 }>, {
   size: TabListSize;
-  layout: TabListLayout;
   hasDivider: boolean;
+  layout: TabListLayout;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
-declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
-declare const _default: typeof __VLS_export;
+declare const __VLS_export$1: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default$1: typeof __VLS_export$1;
 type __VLS_WithSlots<T, S> = T & {
   new (): {
     $slots: S;
   };
 };
 //#endregion
-export { TabListSize as a, TabListProps as i, _default$1 as n, TabListTab as o, TabListLayout as r, TabProps as s, _default as t };
+//#region src/TabList/TabMenu.vue.d.ts
+declare const __VLS_export: import("vue").DefineComponent<TabMenuProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<TabMenuProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+//#endregion
+export { TabListProps as a, TabMenuOption as c, TabListLayout as i, TabMenuProps as l, _default$1 as n, TabListSize as o, _default$2 as r, TabListTab as s, _default as t, TabProps as u };