@astryx-vue/core 0.1.0 → 0.1.3

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-C_2Z65Rp.d.ts

@@ -0,0 +1,67 @@
+import { Ref, VNode } from "vue";
+//#region src/TreeList/types.d.ts
+type TreeListDensity = 'compact' | 'balanced' | 'spacious';
+type TreeListVariant = 'lineGuides' | 'noGuides';
+interface TreeListItemData {
+  id: string;
+  label: string;
+  description?: string;
+  /** Glyph name, or a CSS icon class starting with `i-`. */
+  icon?: string;
+  /** Trailing glyph or CSS icon class. */
+  endIcon?: string;
+  /** Compact trailing badge, for counts. */
+  badge?: string;
+  children?: TreeListItemData[];
+  href?: string;
+  target?: string;
+  isDisabled?: boolean;
+  isSelected?: boolean;
+  isExpanded?: boolean;
+  onClick?: (event: MouseEvent) => void;
+}
+interface TreeListProps {
+  items: TreeListItemData[];
+  /** @default 'balanced' */
+  density?: TreeListDensity;
+  /** @default 'lineGuides' */
+  variant?: TreeListVariant;
+  header?: string;
+  label?: string;
+}
+interface TreeListSlots {
+  header?: () => VNode[];
+  start?: (props: {
+    item: TreeListItemData;
+  }) => VNode[];
+  end?: (props: {
+    item: TreeListItemData;
+  }) => VNode[];
+}
+//#endregion
+//#region src/TreeList/TreeList.vue.d.ts
+type __VLS_Slots = TreeListSlots;
+declare const __VLS_base: import("vue").DefineComponent<TreeListProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<TreeListProps> & Readonly<{}>, {
+  variant: TreeListVariant;
+  density: TreeListDensity;
+}, {}, {}, {}, 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
+//#region src/TreeList/useTreeFocus.d.ts
+interface UseTreeFocusOptions {
+  onToggleExpand?: (id: string) => void;
+  onActivate?: (current: HTMLElement) => boolean;
+}
+declare function useTreeFocus(options: UseTreeFocusOptions): {
+  treeRef: Ref<HTMLElement | null>;
+  handleKeyDown: (event: KeyboardEvent) => void;
+  handleFocus: () => void;
+};
+//#endregion
+export { TreeListItemData as a, TreeListVariant as c, TreeListDensity as i, useTreeFocus as n, TreeListProps as o, _default as r, TreeListSlots as s, UseTreeFocusOptions as t };

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-CtlkhQ55.d.ts

@@ -0,0 +1,36 @@
+//#region src/Thumbnail/types.d.ts
+type ThumbnailRemoveVisibility = 'always' | 'hover';
+interface ThumbnailProps {
+  src?: string;
+  alt?: string;
+  /** Accessible name. Not drawn; used by the tooltip and the remove button. */
+  label?: string;
+  isLoading?: boolean;
+  isDisabled?: boolean;
+  /**
+   * When the remove button is visible. `hover` also reveals it on keyboard
+   * focus, and keeps it visible for coarse pointers.
+   * @default 'hover'
+   */
+  showRemoveOn?: ThumbnailRemoveVisibility;
+}
+interface ThumbnailEmits {
+  remove: [event: MouseEvent];
+  click: [event: MouseEvent];
+}
+//#endregion
+//#region src/Thumbnail/Thumbnail.vue.d.ts
+declare const __VLS_export: import("vue").DefineComponent<ThumbnailProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+  click: (event: MouseEvent) => any;
+  remove: (event: MouseEvent) => any;
+}, string, import("vue").PublicProps, Readonly<ThumbnailProps> & Readonly<{
+  onClick?: ((event: MouseEvent) => any) | undefined;
+  onRemove?: ((event: MouseEvent) => any) | undefined;
+}>, {
+  isDisabled: boolean;
+  isLoading: boolean;
+  showRemoveOn: ThumbnailRemoveVisibility;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+//#endregion
+export { ThumbnailRemoveVisibility as i, ThumbnailEmits as n, ThumbnailProps as r, _default as t };

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

@@ -32,12 +32,12 @@ declare const __VLS_base$2: import("vue").DefineComponent<ItemProps, {
   focus: typeof focus;
   blur: typeof blur;
 }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<ItemProps> & Readonly<{}>, {
-  as: ItemElement;
   isDisabled: boolean;
+  as: ItemElement;
+  density: ListDensity;
+  isSelected: boolean;
   align: ItemAlign;
   layout: ItemLayout;
-  isSelected: boolean;
-  density: ListDensity;
   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-C8NW9xre.d.ts → index-DGNqi2za.d.ts}

@@ -76,27 +76,27 @@ declare const __VLS_base: import("vue").DefineComponent<MultiSelectorProps, {
   focus: () => void | undefined;
   blur: () => void | undefined;
 }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
-  search: (query: string) => any;
   change: (value: (string | number)[]) => any;
-  openChange: (isOpen: boolean) => any;
+  search: (query: string) => any;
   "update:modelValue": (value: (string | number)[]) => any;
+  openChange: (isOpen: boolean) => any;
 }, string, import("vue").PublicProps, Readonly<MultiSelectorProps> & Readonly<{
-  onSearch?: ((query: string) => any) | undefined;
   onChange?: ((value: (string | number)[]) => any) | undefined;
-  onOpenChange?: ((isOpen: boolean) => any) | undefined;
+  onSearch?: ((query: string) => any) | undefined;
   "onUpdate:modelValue"?: ((value: (string | number)[]) => any) | undefined;
+  onOpenChange?: ((isOpen: boolean) => any) | undefined;
 }>, {
   size: MultiSelectorSize;
-  variant: MultiSelectorVariant;
   required: boolean;
+  variant: MultiSelectorVariant;
+  status: MultiSelectorStatus;
   modelValue: readonly (string | number)[];
   labelHidden: boolean;
   disabled: boolean;
-  status: MultiSelectorStatus;
   clearable: boolean;
   optional: boolean;
-  searchable: boolean;
   presentation: MultiSelectorPresentation;
+  searchable: boolean;
   selectAll: boolean;
   triggerDisplay: MultiSelectorTriggerDisplay;
   maxBadges: number;

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 };