@vectoriox/iox-ui 5.37.0 → 5.39.0

package/composite-core/index.d.ts

@@ -34,6 +34,9 @@ interface CompositeNode extends ElementStyleTarget {
  *  (the builder's `createConfig`, generation-core's `createSerializedNode`), with these props and this
  *  element style. `key` is stable per recipe node — a consumer that needs deterministic ids builds them
  *  from it (generation-core: `<root id>-<key>`). */
+/** `elementStyle: NO_ELEMENT_STYLE` asks for a node that wears NO element style (undefined / null = the type's default,
+ *  as both node factories have always read it): a migrated slider's bare chevrons, a lightbox's slide (CC3). */
+declare const NO_ELEMENT_STYLE = "";
 interface CompositeNodeSpec {
     key: string;
     type: string;
@@ -72,15 +75,22 @@ declare function parentInComposite(root: CompositeNode, node: CompositeNode): Co
 declare function removeFromComposite(root: CompositeNode, node: CompositeNode): boolean;
 
 /**
- * The open/close composites' kinds and roles (CC2 Accordion, CC2.1 Disclosure — composite plan T9 / T21). ONE
- * family: a Disclosure is a one-item accordion whose ROOT is its item, so both run the same state machine, the
- * same attribute planners and the same runtime (`accordion-runtime.ts`). Every consumer that treats "an item",
- * "a header" or "a panel" alike asks these predicates, never a role literal.
+ * The composites' kinds and roles. Two families:
+ * - OPEN/CLOSE (CC2 Accordion, CC2.1 Disclosure — composite plan T9 / T21): a Disclosure is a one-item accordion whose
+ *   ROOT is its item, so both run the same state machine, attribute planners and runtime (`accordion-runtime.ts`);
+ * - EXCLUSIVE (CC4 Tabs — composite T17; the Segmented control joins in CC4b): exactly one item is on, a trigger and
+ *   its panel paired by `itemKey` (`tabs.ts`, `exclusive-runtime.ts`).
+ * Every consumer that treats "an item", "a trigger" or "a panel" alike asks these predicates, never a role literal.
  */
 declare enum CompositeKind {
     Accordion = "accordion",
-    Disclosure = "disclosure"
+    Disclosure = "disclosure",
+    Tabs = "tabs"
 }
+/** The kinds the open/close runtime runs (`AccordionRuntime`). */
+type ToggleCompositeKind = CompositeKind.Accordion | CompositeKind.Disclosure;
+/** The kinds the exclusive runtime runs (`ExclusiveRuntime`): one item on at a time, always one. */
+type ExclusiveCompositeKind = CompositeKind.Tabs;
 declare enum AccordionRole {
     Accordion = "accordion",
     Item = "accordion.item",
@@ -101,10 +111,22 @@ declare enum DisclosureRole {
     Icon = "disclosure.icon",
     Panel = "disclosure.panel"
 }
-interface RoleLike$1 {
+/**
+ * TABS (CC4a — composite T17). The tab LIST holds the triggers, the PANELS holder holds the panels; a tab and its panel
+ * share an `itemKey` (never their index — moving a tab keeps its own panel). From content (R3) the list and the panels
+ * holder are both Repeaters over the SAME source, one row giving its tab AND its panel (paired by the row's id).
+ */
+declare enum TabsRole {
+    Tabs = "tabs",
+    List = "tabs.list",
+    Trigger = "tabs.trigger",
+    Panels = "tabs.panels",
+    Panel = "tabs.panel"
+}
+interface RoleLike$2 {
     role?: string | null;
 }
-/** The roles each kind plays in the shared runtime. */
+/** The roles each open/close kind plays in the shared runtime. */
 interface CompositeKindRoles {
     root: string;
     item: string;
@@ -112,26 +134,61 @@ interface CompositeKindRoles {
     panel: string;
     icon: string;
 }
-declare const COMPOSITE_KIND_ROLES: Readonly<Record<CompositeKind, CompositeKindRoles>>;
+declare const COMPOSITE_KIND_ROLES: Readonly<Record<ToggleCompositeKind, CompositeKindRoles>>;
+/** The roles each EXCLUSIVE kind plays: its root, the holder of its triggers, its triggers, and — when its items show
+ *  a panel (Tabs; a Segmented control has none) — the holder of its panels and the panels. */
+interface ExclusiveKindRoles {
+    root: string;
+    list: string;
+    trigger: string;
+    panels: string | null;
+    panel: string | null;
+}
+declare const EXCLUSIVE_KIND_ROLES: Readonly<Record<ExclusiveCompositeKind, ExclusiveKindRoles>>;
 /** The kind a role belongs to (`disclosure.panel` → Disclosure), or null for any other role. */
 declare function compositeKindOfRole(role: string | null | undefined): CompositeKind | null;
+/** True for a kind the open/close runtime runs. */
+declare function isToggleKind(kind: CompositeKind | null | undefined): kind is ToggleCompositeKind;
+/** True for a kind the exclusive runtime runs. */
+declare function isExclusiveKind(kind: CompositeKind | null | undefined): kind is ExclusiveCompositeKind;
 /** A root that runs the open/close runtime (an Accordion or a Disclosure). */
-declare function isCompositeRoot(node: RoleLike$1 | null | undefined): boolean;
+declare function isCompositeRoot(node: RoleLike$2 | null | undefined): boolean;
 /** An ITEM — an accordion's item, or a disclosure (its own item). */
-declare function isCompositeItem(node: RoleLike$1 | null | undefined): boolean;
+declare function isCompositeItem(node: RoleLike$2 | null | undefined): boolean;
 /** A trigger — rendered as a `<button>` that opens its item, never a link. */
-declare function isCompositeTrigger(node: RoleLike$1 | null | undefined): boolean;
+declare function isCompositeTrigger(node: RoleLike$2 | null | undefined): boolean;
 /** A panel — rendered inside the track + region the one hiding rule collapses. */
-declare function isCompositePanel(node: RoleLike$1 | null | undefined): boolean;
-declare function isDisclosureRoot(node: RoleLike$1 | null | undefined): boolean;
+declare function isCompositePanel(node: RoleLike$2 | null | undefined): boolean;
+declare function isDisclosureRoot(node: RoleLike$2 | null | undefined): boolean;
 /** True for any part of a disclosure (its root included). */
-declare function isDisclosurePart(node: RoleLike$1 | null | undefined): boolean;
+declare function isDisclosurePart(node: RoleLike$2 | null | undefined): boolean;
 /** The composite root a node belongs to: the nearest ancestor (or the node itself) that is one. `path` = the
  *  node's ancestors, root first. */
-declare function compositeRootOf<T extends RoleLike$1>(node: T, path: ReadonlyArray<T>): T | null;
+declare function compositeRootOf<T extends RoleLike$2>(node: T, path: ReadonlyArray<T>): T | null;
 /** The item a node sits in — the nearest item of either kind (itself when it is one) — or null. An accordion
  *  root ends the walk (its items are below it). */
-declare function compositeItemOf<T extends RoleLike$1>(node: T, path: ReadonlyArray<T>): T | null;
+declare function compositeItemOf<T extends RoleLike$2>(node: T, path: ReadonlyArray<T>): T | null;
+/** A root that runs the exclusive runtime (Tabs). */
+declare function isExclusiveRoot(node: RoleLike$2 | null | undefined): boolean;
+/** The holder of an exclusive composite's triggers (a tab list): it takes only triggers. */
+declare function isExclusiveList(node: RoleLike$2 | null | undefined): boolean;
+/** One of an exclusive composite's triggers (a tab): pressing it turns its item on. */
+declare function isExclusiveTrigger(node: RoleLike$2 | null | undefined): boolean;
+/** The holder of an exclusive composite's panels: it takes only panels. */
+declare function isExclusivePanels(node: RoleLike$2 | null | undefined): boolean;
+/** One of an exclusive composite's panels (a tab panel): shown only while its item is on. */
+declare function isExclusivePanel(node: RoleLike$2 | null | undefined): boolean;
+/** True for a trigger or a panel — a part that IS one item of an exclusive composite (it carries the `itemKey`). */
+declare function isExclusiveItemPart(node: RoleLike$2 | null | undefined): boolean;
+/** True for any part of a Tabs (its root included). */
+declare function isTabsPart(node: RoleLike$2 | null | undefined): boolean;
+/** A root of either family — anything that runs a composite runtime. */
+declare function isAnyCompositeRoot(node: RoleLike$2 | null | undefined): boolean;
+/** The exclusive root a node belongs to (the node itself when it is one), or null. `path` = its ancestors, root first. */
+declare function exclusiveRootOf<T extends RoleLike$2>(node: T, path: ReadonlyArray<T>): T | null;
+/** The trigger or panel a node sits in (itself when it is one) inside an exclusive composite, or null. A nested
+ *  exclusive root ends the walk. */
+declare function exclusiveItemPartOf<T extends RoleLike$2>(node: T, path: ReadonlyArray<T>): T | null;
 
 /**
  * ACCORDION (CC2 — composite K1; complex-components boards 3, 4 and 9, APPROVED 2026-10-20). Not a
@@ -442,6 +499,8 @@ interface AccordionRuntimeOptions {
 declare function closestAccordion(el: Element | null | undefined): HTMLElement | null;
 /** The item an element sits in (itself when it is one) — an accordion item, or a disclosure. */
 declare function closestAccordionItem(el: Element | null | undefined): HTMLElement | null;
+/** The composite root whose items an item belongs to: a disclosure is its own root. */
+declare function accordionRootOfItem(item: HTMLElement): HTMLElement | null;
 /** Subscribe to an item turning on / off — what the `itemOn` / `itemOff` interaction triggers listen to. The
  *  item is the element's own item (the element itself when it is one). Returns the unsubscribe. */
 declare function onAccordionItemState(el: Element, on: boolean, handler: () => void): () => void;
@@ -512,12 +571,6 @@ declare enum CompositeItemAction {
     Close = "close",
     Toggle = "toggle"
 }
-/**
- * Run an item action on the element of an ITEM (an accordion item, or a disclosure) — the `openItem` /
- * `closeItem` / `toggleItem` interaction actions, on the canvas and on the live site through this one function.
- * Returns whether the item shows open afterwards, or null when `el` is in no running composite.
- */
-declare function runCompositeItemAction(el: Element | null | undefined, action: CompositeItemAction): boolean | null;
 /** True when an item an action just opened is out of view and the page should scroll to it (T14: "opens that item
  *  and scrolls to it") — never when its head is already on screen, so a button beside it does not jolt the page. */
 declare function shouldScrollToItem(top: number, viewportHeight: number): boolean;
@@ -740,8 +793,14 @@ declare function setCardLinked(card: CompositeNode, on: boolean): boolean;
 interface CompositeRoleSpec {
     /** The role of the part's parent; null for a composite root. */
     readonly parent: string | null;
+    /** The TYPE of the part's parent, for a part whose parent carries no role (a Slider's controls). */
+    readonly parentType?: string;
     readonly locked?: boolean;
+    /** May be deleted, but never moved out of its parent (a Slider's controls work only as its direct children). */
+    readonly pinned?: boolean;
     readonly part?: CardPart;
+    /** The only roles that may be dropped INTO this part (a tab list takes tabs, a panels holder takes panels). */
+    readonly accepts?: ReadonlyArray<string>;
 }
 declare const COMPOSITE_ROLE_SPECS: Readonly<Record<string, CompositeRoleSpec>>;
 declare enum StructureEdit {
@@ -753,19 +812,616 @@ declare enum StructureRefusal {
     /** A locked part cannot be deleted (the card's Content and Title). */
     LockedPart = "locked-part",
     /** A locked part can only live directly inside its own parent role. */
-    LockedPlacement = "locked-placement"
+    LockedPlacement = "locked-placement",
+    /** The new parent takes only certain roles (a tab list takes only tabs, CC4a). */
+    NotAccepted = "not-accepted"
 }
-interface RoleLike {
+interface RoleLike$1 {
     role?: string | null;
+    type?: string;
 }
 /**
  * Why the structure guard refuses `edit` on `node`, or null when it is allowed. `ancestors` (Move only) =
  * the new parent chain, root first, the direct parent last.
  */
-declare function structureRefusal(node: RoleLike | null | undefined, edit: StructureEdit, ancestors?: ReadonlyArray<RoleLike>): StructureRefusal | null;
+declare function structureRefusal(node: RoleLike$1 | null | undefined, edit: StructureEdit, ancestors?: ReadonlyArray<RoleLike$1>): StructureRefusal | null;
 /** True when `node` is a locked part (shown with a lock and no delete in the layer tree). Deleting a whole
  *  composite is always allowed — only its locked parts are refused. */
-declare function isLockedPart(node: RoleLike | null | undefined): boolean;
+declare function isLockedPart(node: RoleLike$1 | null | undefined): boolean;
+/** Why `parent` refuses `node` as a child (it takes only certain roles), or null. */
+declare function acceptsRefusal(node: RoleLike$1 | null | undefined, parent: RoleLike$1 | null | undefined): StructureRefusal | null;
+
+/**
+ * THE ACCESSIBLE CAROUSEL (CC3 — complex-components plan §7c, board 6; board 9 Q13). The Slider's controls are no
+ * longer drawn by Swiper: Previous, Next, Pause and Pagination are REAL nodes with roles — selectable on the canvas,
+ * in the layer tree and the breadcrumb, and styled on their own (R2) — handed to Swiper as its navigation and
+ * pagination elements.
+ *
+ *   SliderContainer  (.swiper)
+ *   ├─ ButtonBlock `button-secondary`   role slider.pause       FIRST focus stop; present while Autoplay is on, locked
+ *   ├─ ButtonBlock `button-secondary`   role slider.prev        › Icon caret (points the reading way in RTL)
+ *   ├─ ButtonBlock `button-secondary`   role slider.next        › Icon caret
+ *   ├─ (the slides — `.swiper-wrapper` › SliderSlide …)
+ *   └─ Container                        role slider.pagination  Swiper draws the dots (or "3 / 6") inside it
+ *
+ * The parts render INSIDE the `.swiper` element, never inside `.swiper-wrapper` (slider.md: a `.swiper-slide` must be
+ * the wrapper's direct child): the parts that come before the first slide in the tree render before the wrapper, the
+ * rest after it. By default they sit over the slides like Swiper's own controls (the shared CSS, iox-design.css, at
+ * zero specificity — a part's own styles win), so a saved slider migrated from Swiper-drawn controls keeps its look.
+ *
+ * The Bindings switches stay the source of truth: Navigation arrows ⇔ Previous + Next, Pagination ⇔ Pagination,
+ * Autoplay ⇔ Pause (WCAG 2.2.2 — "added while Autoplay is on, cannot be removed"). `syncSliderParts` is the one edit.
+ */
+declare enum SliderRole {
+    Pause = "slider.pause",
+    Prev = "slider.prev",
+    Next = "slider.next",
+    Pagination = "slider.pagination"
+}
+/** Parts in the order they are stamped: the pause control first (APG: the first focus stop), the dots last. */
+declare const SLIDER_PART_ROLES: ReadonlyArray<SliderRole>;
+declare const SLIDER_TYPE = "SliderContainer";
+declare const SLIDE_TYPE = "SliderSlide";
+/** The Bindings switches that own the parts. */
+declare enum SliderFlag {
+    Navigation = "enableNavigation",
+    Pagination = "enablePagination",
+    Autoplay = "enableAutoplay"
+}
+/** The trait that names the carousel (Slider ▸ Accessibility ▸ Carousel name) — the A11y trait every named part uses. */
+declare const SLIDER_NAME_TRAIT = "ariaLabel";
+interface RoleLike {
+    role?: string | null;
+    type?: string;
+}
+declare function isSliderPart(node: RoleLike | null | undefined): boolean;
+declare function isSlider(node: RoleLike | null | undefined): boolean;
+/** The slider's own part playing `role` (a direct child), or undefined. */
+declare function sliderPart<T extends RoleLike>(slider: {
+    children?: T[] | null;
+}, role: SliderRole): T | undefined;
+/** True when the slider's controls are parts (it was created or migrated in CC3) — Swiper then draws none of its own. */
+declare function hasSliderParts(slider: {
+    children?: ReadonlyArray<RoleLike> | null;
+}): boolean;
+/** A slider's children split as they render: parts before the first slide, the slides (into `.swiper-wrapper`), and
+ *  the parts after it. */
+declare function splitSliderChildren<T extends RoleLike>(children: ReadonlyArray<T> | null | undefined): {
+    lead: T[];
+    slides: T[];
+    trail: T[];
+};
+/** The slides only (the template slide of a bound slider is `sliderSlides(children)[0]`). */
+declare function sliderSlides<T extends RoleLike>(children: ReadonlyArray<T> | null | undefined): T[];
+/** Each part's glyph (Phosphor) and its default accessible name. */
+declare const SLIDER_PART_GLYPH: Readonly<Record<Exclude<SliderRole, SliderRole.Pagination>, string>>;
+declare const SLIDER_PLAY_GLYPH = "ph-fill ph-play";
+/**
+ * What a saved slider drew through Swiper before CC3, carried into its parts by the migration so it looks the same:
+ * bare chevrons in the author's arrow colour and size, the dots in the author's colour. Swiper's own default colour
+ * is its theme blue — what the live site drew, because the engine never applied the colour traits.
+ */
+interface LegacySliderLook {
+    navigationColor?: string;
+    navigationSize?: number;
+    paginationColor?: string;
+}
+declare const SWIPER_THEME_COLOR = "#007aff";
+/** One part, from the recipe (board 6: `button-secondary` controls, token dots) or in a migrated slider's legacy look. */
+declare function buildSliderPart(create: CompositeNodeFactory, role: SliderRole, legacy?: LegacySliderLook): CompositeNode;
+/** The parts the slider's switches call for, in stamping order. */
+declare function wantedSliderParts(slider: CompositeNode): SliderRole[];
+interface SliderPartsChange {
+    added: CompositeNode[];
+    removed: CompositeNode[];
+}
+/**
+ * Make the slider's parts match its switches — ONE edit (a palette switch, the migration, the composer). Missing
+ * parts are stamped from the recipe (or, `legacy`, in the migrated look) at their place: the pause control, Previous
+ * and Next before the first slide, the pagination after the last; parts whose switch is off are removed. Everything
+ * else (the slides, the author's edits to an existing part) is kept.
+ */
+declare function syncSliderParts(slider: CompositeNode, create: CompositeNodeFactory, legacy?: LegacySliderLook): SliderPartsChange;
+/** True when a saved slider still relies on Swiper-drawn controls: a switch is on and no part exists yet. */
+declare function needsSliderMigration(slider: CompositeNode | null | undefined): boolean;
+/**
+ * The migration of a saved slider (board 9 Q13): its Swiper-drawn arrows, dots — and, when Autoplay is on, the pause
+ * control WCAG 2.2.2 requires — become parts, in the place and the colours Swiper drew them. Idempotent: a slider
+ * that already has parts is left alone. True when it changed.
+ */
+declare function migrateSliderControls(slider: CompositeNode, create: CompositeNodeFactory): boolean;
+/**
+ * A switch flipped in the panel: on a slider still on Swiper-drawn controls, migrate it first (so its other controls
+ * keep their look), then stamp / remove the parts the new switch calls for. ONE edit.
+ */
+declare function setSliderFlag(slider: CompositeNode, flag: SliderFlag, on: boolean, create: CompositeNodeFactory): SliderPartsChange;
+interface SliderWords {
+    stop: string;
+    start: string;
+    prev: string;
+    next: string;
+    carousel: string;
+    slide: string;
+    /** `{{index}}` and `{{slidesLength}}`, Swiper's placeholders. */
+    slideLabel: string;
+    goTo: string;
+}
+declare const SLIDER_WORDS: Readonly<Record<'en' | 'he', SliderWords>>;
+declare function sliderWords(lang?: string | null): SliderWords;
+/** The wrapper's live region (APG): silent while the slides move on their own, polite otherwise. */
+declare function sliderLiveRegion(rotating: boolean): 'off' | 'polite';
+/**
+ * The pause control's state (APG carousel): its NAME says what it will do ("Stop automatic slide show" while it
+ * rotates, "Start automatic slide show" when stopped). An author who named the control keeps the name, and the
+ * state is `aria-pressed` instead (pressed = stopped).
+ */
+declare function sliderPauseAttributes(rotating: boolean, words?: SliderWords, authorName?: string | null): Record<string, string>;
+/** The pause control's glyph: pause while it rotates, play when stopped. */
+declare function sliderPauseGlyph(rotating: boolean): string;
+interface CarouselQuote {
+    quote: string;
+    who: string;
+}
+/** Board 6's sample quotes — PLACEHOLDERS: testimonials are facts the studio gives, never invented. */
+declare const CAROUSEL_QUOTES: ReadonlyArray<CarouselQuote>;
+interface CarouselOptions {
+    /** The carousel's accessible name (a `region` landmark). */
+    name?: string;
+    quotes?: ReadonlyArray<CarouselQuote>;
+}
+/**
+ * The testimonial carousel (board 6): a named Slider, one quote per slide (each a `card`), rotating every 5s with its
+ * control parts — the pause control first, Previous · Next, the dots. ONE recipe for the composer and the builder.
+ */
+declare function buildCarouselRecipe(create: CompositeNodeFactory, options?: CarouselOptions): CompositeNode;
+/** The slide a lightbox opens at for the clicked row (clamped to the slides there are). */
+declare function slideIndexForRow(rowIndex: number, slideCount: number): number;
+
+/**
+ * The accessible carousel's RUNTIME (CC3, board 6; closes vectoriox/iox-ui#13) — DOM only, over a running Swiper,
+ * ONE copy for the engine (both paths) and the admin's Preview. Swiper's A11y module gives the container
+ * `aria-roledescription="carousel"`, every slide `role=group` + "slide" + "n of m"; this adds what the APG
+ * carousel needs on top:
+ * - the PAUSE control (role `slider.pause`, rendered first): it stops rotation for good and starts it again; its
+ *   name says what it will do, its glyph swaps;
+ * - rotation PAUSES while focus is anywhere inside (hover is Swiper's `pauseOnMouseEnter`) and resumes when it
+ *   leaves — unless the visitor pressed pause;
+ * - the wrapper's live region is `off` while the slides move on their own and `polite` otherwise;
+ * - slides that are not in view are `inert` (and hidden from assistive technology), so Tab never lands in one.
+ * The builder's EDIT canvas never attaches it (no autoplay there, and a slide must stay clickable).
+ */
+/** The parts of the Swiper instance this runtime reads — a real Swiper, or a stub in a spec. */
+interface CarouselSwiper {
+    el: HTMLElement;
+    wrapperEl: HTMLElement;
+    slides: HTMLElement[];
+    activeIndex: number;
+    destroyed?: boolean;
+    params?: {
+        slidesPerView?: number | 'auto';
+        autoplay?: {
+            pauseOnMouseEnter?: boolean;
+        } | boolean;
+    };
+    autoplay?: {
+        running: boolean;
+        paused?: boolean;
+        start(): void;
+        stop(): void;
+        pause(): void;
+        resume(): void;
+    };
+    on(event: string, handler: (...args: unknown[]) => void): void;
+    off(event: string, handler: (...args: unknown[]) => void): void;
+}
+interface CarouselA11yOptions {
+    words?: SliderWords;
+}
+/** The part of `role` that belongs to THIS slider (never one of a slider nested in a slide). */
+declare function sliderPartElement(sliderEl: Element, role: SliderRole): HTMLElement | null;
+declare class CarouselA11y {
+    private readonly swiper;
+    /** The visitor pressed pause: rotation stays stopped until they press it again. */
+    private stoppedByVisitor;
+    private focusInside;
+    /** The pointer is over the carousel and Swiper holds rotation for it (`pauseOnMouseEnter`). */
+    private hovering;
+    private readonly cleanups;
+    private readonly words;
+    private readonly pause;
+    private readonly authorName;
+    constructor(swiper: CarouselSwiper, options?: CarouselA11yOptions);
+    /** True while the slides move on their own: autoplay runs and nothing holds it — not focus inside, not the
+     *  pointer over it. (Swiper's own `paused` also flips during every transition, so it is not read here.) */
+    get rotating(): boolean;
+    private get hoverPauses();
+    /** The pause control: stop rotation for good, or start it again. */
+    togglePause(): void;
+    destroy(): void;
+    private listen;
+    private onFocusIn;
+    private onFocusOut;
+    /** Re-state the carousel: the live region, the pause control, the slides out of view. */
+    sync(): void;
+    private syncHiddenSlides;
+}
+/** The carousel runtime attached to a slider element, if any. */
+declare function carouselOf(el: Element | null | undefined): CarouselA11y | null;
+/** Attach once per Swiper (a re-init gets a fresh runtime). */
+declare function attachCarouselA11y(swiper: CarouselSwiper, options?: CarouselA11yOptions): CarouselA11y;
+
+/**
+ * THE LIGHTBOX (CC3 — complex-components plan §7d, board 6). Not a component: a Dialog holding a Slider bound to the
+ * SAME source as the grid of thumbnails. The one new thing is `openDialog`'s "Open at the clicked item"
+ * (`slideTo: 'row'`): a thumbnail in a repeater row opens the lightbox at ITS slide.
+ *
+ *   Dialog `dialog` · centre · full viewport · Inverse scheme      "Lightbox" (a free-standing Dialog: board A4)
+ *   ├─ ButtonBlock `button-ghost`  "Close"  › Icon ×                click → closeDialog
+ *   └─ SliderContainer  one slide in view · keyboard · the source's rows
+ *       ├─ Previous · Next (slider.prev / slider.next, button-secondary)   hidden on a phone (swipe)
+ *       ├─ SliderSlide › Image `media` (contain, keeps its alt) + Text `small` caption
+ *       └─ Pagination (slider.pagination) — the counter "3 / 6"
+ *
+ * Keyboard ← → are the Slider's Keyboard module; Esc and the focus trap are the `<dialog>`'s; focus returns to the
+ * thumbnail that opened it (the dialog opener's own rule).
+ */
+declare const SLIDE_TO_ROW = "row";
+/** The attribute a renderer writes on every repeated row (the context-state provenance, both engine paths, the canvas). */
+declare const ROW_INDEX_ATTRIBUTE = "data-iox-row-idx";
+declare const LIGHTBOX_LABEL = "Lightbox";
+interface LightboxOptions {
+    /** The list the slides come from (the grid's own source). Empty = three manual slides. */
+    source?: string;
+    sourcePath?: string;
+    /** The row field each slide's image and caption read (`item` = the row itself, a bare URL). */
+    imageField?: string;
+    captionField?: string;
+    /** The image's alt binding; '' = decorative (a bare URL row has no words of its own). */
+    altField?: string;
+}
+/** On a phone the arrows give way to a swipe (board 6, "the arrows hide on touch-only widths"). */
+declare const LIGHTBOX_ARROWS_HIDE_AT = "mobile";
+/** A fresh lightbox: the Dialog, its Close part and the Slider (bound to `source`, or three manual slides). */
+declare function buildLightboxRecipe(create: CompositeNodeFactory, options?: LightboxOptions): CompositeNode;
+interface RepeatSource {
+    source: string;
+    path: string;
+}
+/** What a Repeater (its `source` binding) or a bound Slider (its `source` / `sourcePath` traits) repeats over. */
+declare function repeatSourceOf(node: CompositeNode | null | undefined): RepeatSource | null;
+declare function sameRepeatSource(a: RepeatSource | null, b: RepeatSource | null): boolean;
+/** The Slider a lightbox Dialog holds (the first one, depth first), or null. */
+declare function lightboxSliderOf(dialog: CompositeNode | null | undefined): CompositeNode | null;
+/** The repeated rows the element is in: the nearest Repeater or bound Slider among its ancestors (`path` = root → the
+ *  element, inclusive). */
+declare function rowSourceOf(path: ReadonlyArray<CompositeNode>): RepeatSource | null;
+/**
+ * Interactions ▸ openDialog ▸ "Open at the clicked item" is offered only when it can work (board 9): the clicked
+ * element sits in a repeater row AND the target Dialog holds a Slider bound to the same source.
+ */
+declare function canOpenAtClickedItem(ownerPath: ReadonlyArray<CompositeNode>, dialog: CompositeNode | null | undefined): boolean;
+/** The repeated row an element sits in (its row index), 0 when it is in none (the canvas' template row). */
+declare function rowIndexOf(el: Element | null | undefined): number;
+
+/**
+ * TABS (CC4a — composite K2 T17–T20; complex-components boards 3 and 9, APPROVED 2026-10-20). Not a component: a
+ * recipe of ordinary nodes, each part carrying a role, so every tab and every panel is selectable on the canvas, in
+ * the layer tree and the breadcrumb, and wears its own element style (R2).
+ *
+ *   Container `box`                  role tabs          traits activateOn · orientation · ariaLabel (the list's name)
+ *   ├─ Container `tab-list`          role tabs.list     → role=tablist (locked)        — or a Repeater (From content)
+ *   │   └─ ButtonBlock `tab` ×3      role tabs.trigger  itemKey k1…  → <button role=tab> › Text `button-label`
+ *   └─ Container `box`               role tabs.panels   (locked)                        — or a Repeater (From content)
+ *       └─ Container `box` ×3        role tabs.panel    the SAME itemKey as its tab → role=tabpanel, hidden while off
+ *           ├─ Image `media`         4 / 3
+ *           └─ Text `body`
+ *
+ * A tab and its panel are a PAIR by `itemKey` — never by index, so a tab moved to the end still shows its own panel.
+ * The behaviour is BUILT IN (composite plan D1 = B): exactly one item is on (`exclusive`), the APG tabs pattern with
+ * AUTOMATIC activation (arrows move focus and activate, roving tabindex) — one runtime (`exclusive-runtime.ts`) on the
+ * builder canvas and both engine paths, from the attribute planners below.
+ */
+declare enum TabsBehaviourTrait {
+    /** Which pointer gesture turns a tab on: a click (always) or also a hover. */
+    ActivateOn = "activateOn",
+    /** The tab list across the top, or beside the panels. */
+    Orientation = "orientation",
+    /** The tab list's accessible name (`aria-label` on the role=tablist element) — the root's, edited in Accessibility. */
+    Label = "ariaLabel"
+}
+declare enum TabsActivateOn {
+    Click = "click",
+    Hover = "hover"
+}
+declare enum TabsOrientation {
+    Horizontal = "horizontal",
+    Vertical = "vertical"
+}
+declare const TABS_ACTIVATE_ONS: ReadonlyArray<TabsActivateOn>;
+declare const TABS_ORIENTATIONS: ReadonlyArray<TabsOrientation>;
+/** Tabs from content default to six rows: more tabs do not fit a row (board 9 Q13). */
+declare const TABS_CONTENT_LIMIT = 6;
+/** The breakpoint whose layer stacks a VERTICAL tabs (the list above the panels) and a panel's picture above its words. */
+declare const TABS_STACK_BREAKPOINT = "mobile";
+interface TabWords {
+    label: string;
+    text: string;
+}
+/** The words a fresh Tabs starts with — generic, the author's to replace (Card v2.1: never invented facts). */
+declare const TABS_WORDS: ReadonlyArray<TabWords>;
+declare const TABS_NEW_TAB_WORDS: Readonly<TabWords>;
+interface TabsOptions {
+    tabs?: ReadonlyArray<TabWords>;
+    activateOn?: TabsActivateOn;
+    orientation?: TabsOrientation;
+    /** The tab list's accessible name (empty: unnamed — a section heading usually names the section). */
+    label?: string;
+}
+interface TabPair {
+    tab: CompositeNode;
+    panel: CompositeNode;
+}
+/** One tab and its panel, sharing `itemKey`. */
+declare function buildTabPair(create: CompositeNodeFactory, words: TabWords, itemKey: string): TabPair;
+/** A fresh Tabs: three tabs, the first on, activated by a click, the list across the top (board 3). */
+declare function buildTabsRecipe(create: CompositeNodeFactory, options?: TabsOptions): CompositeNode;
+declare function isTabsRoot(node: {
+    role?: string | null;
+} | null | undefined): boolean;
+/** The tab list (the holder of the triggers). */
+declare function tabsListOf(root: CompositeNode): CompositeNode | undefined;
+/** The holder of the panels. */
+declare function tabsPanelsOf(root: CompositeNode): CompositeNode | undefined;
+/** The tabs in order — every tab (Manual), or the one template tab (From content). */
+declare function tabsTriggers(root: CompositeNode): CompositeNode[];
+/** The panels in their holder's order (their order does not pair them — their key does). */
+declare function tabsPanels(root: CompositeNode): CompositeNode[];
+/** True when the Tabs takes its tabs from content (its list is a Repeater, R3). */
+declare function isTabsFromContent(root: CompositeNode | null | undefined): boolean;
+/** The panel paired with `tab` (the same key), or undefined. From content the one template panel pairs the template tab. */
+declare function tabPanelOf(root: CompositeNode, tab: CompositeNode): CompositeNode | undefined;
+/** The tab paired with `panel` (the same key), or undefined. */
+declare function tabTriggerOf(root: CompositeNode, panel: CompositeNode): CompositeNode | undefined;
+/** The other half of a tab ⇄ panel pair, or undefined for any other node. */
+declare function tabsPartnerOf(root: CompositeNode, node: CompositeNode): CompositeNode | undefined;
+/** The words a tab shows: its first Text's. */
+declare function tabLabelNodeOf(tab: CompositeNode): CompositeNode | undefined;
+/** A tab's name in the Items list, the layer tree and the item-action picker: its words. */
+declare function tabLabel(tab: CompositeNode): string;
+/** Items ▸ rename: the tab's words. */
+declare function renameTab(tab: CompositeNode, words: string): boolean;
+/** The first Text inside a panel (the words From content binds to). */
+declare function tabPanelTextOf(panel: CompositeNode): CompositeNode | undefined;
+/** The first Image inside a panel. */
+declare function tabPanelImageOf(panel: CompositeNode): CompositeNode | undefined;
+interface TabsBehaviour {
+    activateOn: TabsActivateOn;
+    orientation: TabsOrientation;
+}
+/** The root's behaviour (an unset trait reads its default: a click, the list across the top). */
+declare function tabsBehaviour(root: CompositeNode | null | undefined): TabsBehaviour;
+/** The tab list's accessible name (empty when unnamed). */
+declare function tabsLabel(root: CompositeNode | null | undefined): string;
+/** Behaviour ▸ Activate on / Orientation (and Accessibility ▸ the list's name). False when the root has no such trait. */
+declare function setTabsBehaviour(root: CompositeNode, patch: Partial<TabsBehaviour> & {
+    label?: string;
+}): boolean;
+/** A key no tab of `root` holds yet (`k4`…). */
+declare function nextTabKey(root: CompositeNode): string;
+/** Items ▸ Add tab (and the toolbar's "Add tab"): a fresh tab after `after` (or at the end) AND its panel. */
+declare function addTabPair(root: CompositeNode, create: CompositeNodeFactory, after?: CompositeNode | null, words?: TabWords): TabPair | null;
+/** Items ▸ drag to reorder: move a tab — and its panel, so the layer tree reads in the same order — to `toIndex`.
+ *  The pairing never depended on the order. False when `tab` is not one of the root's tabs. */
+declare function moveTabPair(root: CompositeNode, tab: CompositeNode, toIndex: number): boolean;
+/** Remove a tab and its panel (the pair) — what "Delete tab and its panel" does. True when the tab was removed. */
+declare function removeTabPair(root: CompositeNode, node: CompositeNode): boolean;
+declare enum TabsEditRefusal {
+    /** A Tabs keeps at least one tab (composite plan T18). */
+    LastTab = "last-tab"
+}
+/** Why removing `node` (a tab or a panel) from `root` is refused, or null. */
+declare function tabsRemovalRefusal(root: CompositeNode | null | undefined, node: CompositeNode | null | undefined): TabsEditRefusal | null;
+/** Every "Item open" (`trigger-on`) state inside a tab or a panel points at ITS tab or panel — the part that carries
+ *  `data-iox-on` while its item is on. */
+declare function tabsItemTriggerIds(root: CompositeNode): void;
+/** The render scope of one Tabs: its scope id, behaviour, every item key in order and the one that is on. */
+interface TabsScope {
+    rootId: string;
+    behaviour: TabsBehaviour;
+    keys: ReadonlyArray<string>;
+    /** The key on at first paint: the first tab (null when there is none). */
+    active: string | null;
+    label: string;
+}
+declare function tabsScope(rootId: string, behaviour: TabsBehaviour, keys: ReadonlyArray<string>, label?: string): TabsScope;
+/** The item keys a manual Tabs pairs by — its tabs' own keys, in order (a tab with none by its index). */
+declare function manualTabKeys(root: CompositeNode): string[];
+interface TabsItemState {
+    key: string;
+    on: boolean;
+    ids: AccordionDomIds;
+}
+/** One item's render state: its key, whether it is on, and its ARIA ids (`iox-tab-<scope>-<key>-h` / `-p`). */
+declare function tabsItemState(scope: TabsScope, key: string): TabsItemState;
+declare const ACTIVATE_ON_ATTRIBUTE = "data-iox-activate-on";
+declare const ORIENTATION_ATTRIBUTE = "data-iox-orientation";
+declare function tabsRootAttributes(behaviour: TabsBehaviour, scopeId?: string): DomAttributes;
+/** The tab list: `role=tablist`, vertical said aloud, named by the root's label. */
+declare function tabListAttributes(behaviour: TabsBehaviour, label?: string): DomAttributes;
+/** A tab: a real button that selects its panel — selected = the one tab in the Tab order (roving tabindex). */
+declare function tabTriggerAttributes(state: TabsItemState): DomAttributes;
+/** A panel: `role=tabpanel`, named by its tab, a Tab stop of its own, and `hidden` (display:none) while off. */
+declare function tabPanelAttributes(state: TabsItemState): DomAttributes;
+/**
+ * The render scope of one rendered Tabs — ONE decision for both engine paths (and the composer's checks): its scope id
+ * (its node id + the rows around it, vectoriox/iox-ui#20), its behaviour, its list's name and every item key in order —
+ * a manual tab's own `itemKey`, or, From content, each ROW's own id (R3: never its index — a reorder in the CMS keeps
+ * every tab with its own panel). `rows` = the rows the tab list's Repeater resolved (null for a manual Tabs).
+ */
+declare function tabsScopeFor(root: CompositeNode, rootCssId: string, rows: ReadonlyArray<unknown> | null, rowKeys?: ReadonlyArray<string>): TabsScope;
+/** The key a manual tab or panel renders with: its own key, else its index among its kind. */
+declare function tabPartKey(node: CompositeNode, index: number): string;
+/**
+ * The attributes a part of a Tabs writes on its own element (both engine paths, SSR included): the root's data
+ * attributes (its scope id when it sits in repeated rows), the list's role and name, a tab's and a panel's state by
+ * `key` (its own key, or — From content — its row's). Anything else writes nothing.
+ */
+declare function tabsPartAttributes(node: {
+    role?: string | null;
+}, scope: TabsScope, key: string | null, rowScoped?: boolean): DomAttributes;
+/**
+ * The APG tabs keys on a tab (automatic activation): → / ← move along a horizontal list — mirrored under RTL — and ↓ /
+ * ↑ along a vertical one; Home / End jump. Every move wraps. Enter / Space are the button's own.
+ */
+declare function tabsKeyAction(key: string, orientation: TabsOrientation, rtl?: boolean): AccordionKeyAction | null;
+interface TabsAutoBinds {
+    /** The first short-text field: the tab's words. */
+    label: string | null;
+    /** The first long-text field: the panel's words. */
+    text: string | null;
+    /** The first image field: the panel's picture. */
+    image: string | null;
+}
+/** R3 (board 3 "Tabs from content"): switching to From content binds the tab's words to the first short-text field,
+ *  the panel's words to the first long-text field and its picture to the first image field. ONE rule for the builder's
+ *  switch and the composer. */
+declare function pickTabsAutoBinds(fields: ReadonlyArray<ContentFieldLike>): TabsAutoBinds;
+/** The bound props of a tab's words, a panel's words and its picture. */
+declare const TABS_LABEL_BIND_PROP = "content";
+declare const TABS_TEXT_BIND_PROP = "content";
+declare const TABS_IMAGE_BIND_PROP = "src";
+/**
+ * Manual → From content (board 9 "Items: Manual · From content"): the list becomes `listRepeater` and the panels
+ * holder `panelsRepeater` (Repeater nodes the caller created with the same ids, roles, names, element styles and
+ * styles — a type change is the consumer's). The FIRST tab and ITS panel become the templates (their parts, styles
+ * and interactions kept; their keys dropped — a row's key is its id); every other pair is removed. Returns the removed
+ * nodes.
+ */
+declare function tabsToContent(root: CompositeNode, listRepeater: CompositeNode, panelsRepeater: CompositeNode): CompositeNode[];
+/**
+ * From content → Manual: the rows come in as static pairs — each a copy of the template tab and panel (`clone`, which
+ * gives the copy fresh ids) whose bound words are written in as its own and whose bindings are dropped. `list` and
+ * `panels` are the manual holders the caller created. Returns the new pairs.
+ */
+declare function tabsToManual(root: CompositeNode, list: CompositeNode, panels: CompositeNode, rows: ReadonlyArray<unknown>, clone: (template: CompositeNode) => CompositeNode, resolve: (row: unknown, binding: CompositeBinding) => unknown): TabPair[];
+
+/**
+ * The EXCLUSIVE composites' RUNTIME (CC4a Tabs; the Segmented control runs it too in CC4b) — ONE copy, DOM only, for
+ * the builder canvas and the live site (both engine paths render the same markup from `tabs.ts`'s attribute planners):
+ *
+ *   [root]   data-iox-composite="tabs"  data-iox-activate-on  data-iox-orientation  [data-iox-scope]
+ *     .iox-role-tabs-list      role=tablist  [aria-orientation=vertical]
+ *       .iox-role-tabs-trigger role=tab  id  aria-selected  aria-controls  tabindex 0|-1  data-iox-item-key  [data-iox-on]
+ *     .iox-role-tabs-panels
+ *       .iox-role-tabs-panel   role=tabpanel  id  aria-labelledby  tabindex=0  data-iox-item-key  [hidden] | [data-iox-on]
+ *
+ * Exactly one item is on, always (a Tabs with tabs never shows none). It owns: a click on a trigger turns its item on
+ * (and a hover, when the root says `activate-on=hover`); the APG tabs keys with AUTOMATIC activation — ← → along a
+ * horizontal list (mirrored under RTL), ↑ ↓ along a vertical one, Home / End — moving focus AND turning the item on,
+ * the roving tabindex keeping one trigger in the Tab order. A trigger and its panel pair by `data-iox-item-key`
+ * (else their index among their kind — the builder's From-content rows). Every change dispatches `iox-item-on` /
+ * `iox-item-off` on the trigger AND its panel (the `itemOn` / `itemOff` interaction triggers). The item shown is
+ * FORCED ?? LIVE: the builder forces one (a selection inside an inactive panel); the live site forces nothing. The
+ * server's first state is trusted (no flash).
+ */
+interface ExclusiveRuntimeOptions {
+    /** The scope id the ARIA ids are built from (else `data-iox-scope`, else the root's `iox-node-<id>`). A function is
+     *  read at every stamp (the builder canvas: a preview row's index is known once it is in the page). */
+    rootId?: string | (() => string);
+    /** The behaviour (else read from the root's data attributes). */
+    behaviour?: TabsBehaviour;
+    /** The list's accessible name, stamped by the runtime (the builder canvas; the engine renders it). */
+    label?: () => string;
+    /** The key forced on, on top of the live state (the builder's design state), or null. */
+    forced?: () => string | null;
+    /** The live item changed (a click, a key, a hover, an action) — the builder's "Showing on canvas" follows it. */
+    onChange?: (key: string) => void;
+    /** Re-stamp when the markup under the root changes (the builder canvas re-renders parts). */
+    observe?: boolean;
+}
+/** The exclusive composite an element belongs to (the element itself when it is a root). */
+declare function closestExclusive(el: Element | null | undefined): HTMLElement | null;
+/** The trigger or panel an element sits in (itself when it is one) — its ITEM part — or null. */
+declare function closestExclusiveItemPart(el: Element | null | undefined): HTMLElement | null;
+declare class ExclusiveRuntime {
+    readonly root: HTMLElement;
+    private readonly options;
+    private live;
+    private shown;
+    private observer;
+    private stampQueued;
+    private behaviourValue;
+    private awaitingItems;
+    readonly kind: ExclusiveCompositeKind;
+    constructor(root: HTMLElement, options?: ExclusiveRuntimeOptions);
+    get behaviour(): TabsBehaviour;
+    /** The behaviour changed in the panel (Activate on, Orientation). */
+    setBehaviour(behaviour: TabsBehaviour): void;
+    /** THIS composite's triggers in document order (a nested composite's are its own). */
+    triggers(): HTMLElement[];
+    /** THIS composite's panels in document order. */
+    panels(): HTMLElement[];
+    /** The key on right now (forced ?? live). */
+    get activeKey(): string | null;
+    /** The key the live state holds (before anything forced). */
+    get liveKey(): string | null;
+    /** The key of a trigger or a panel: its `data-iox-item-key`, else its index among its kind. */
+    keyOf(part: Element): string;
+    /** The key of the item an element sits in (a part inside a tab or a panel), or null. */
+    keyAt(el: Element | null | undefined): string | null;
+    /** Turn `key` on (a click, a key, a hover, the `openItem` action, "Showing on canvas"). */
+    activate(key: string): void;
+    /** Run an item action on `key`: Open turns it on; Close and Toggle do nothing (one item is always on). True when it
+     *  is on afterwards. */
+    run(open: boolean, key: string): boolean;
+    /** The forced key changed (builder design state): show it. */
+    refresh(): void;
+    destroy(): void;
+    private keys;
+    /** The element(s) that ARE the tablist: the ones a renderer already gave the role (the engine's component-path
+     *  Repeater puts it on its inner root, which holds the tabs), else the elements carrying the list's role class. */
+    private lists;
+    private own;
+    private queueStamp;
+    private rootId;
+    /** Write every part's state into its markup; announce what changed. */
+    private stamp;
+    private ownTrigger;
+    private readonly onClick;
+    private readonly onHover;
+    private readonly onKeydown;
+}
+/** The runtime running an exclusive root, or null. */
+declare function exclusiveRuntimeOf(root: Element | null | undefined): ExclusiveRuntime | null;
+/** Attach the runtime to one rendered exclusive root, unless it already runs one. Returns the NEW runtime, or null. */
+declare function attachExclusiveAt(root: HTMLElement, options?: Omit<ExclusiveRuntimeOptions, 'behaviour'>): ExclusiveRuntime | null;
+/** True when `el` is (or sits in) an exclusive item part — a tab or a panel. */
+declare function isExclusiveItemOn(el: Element): boolean;
+/** Subscribe to the item part `el` sits in turning on / off. Returns the unsubscribe. */
+declare function onExclusiveItemState(el: Element, on: boolean, handler: () => void): () => void;
+
+/**
+ * The composites' runtimes behind ONE door (CC4a): the open/close runtime (Accordion, Disclosure) and the exclusive
+ * runtime (Tabs; the Segmented control in CC4b). The engine attaches whichever a rendered root needs; the interaction
+ * engines (builder canvas and live site) ask these for `itemOn` / `itemOff` and run the item actions through them —
+ * never a family's own function, so a new kind joins without touching either engine.
+ */
+type CompositeRuntime = AccordionRuntime | ExclusiveRuntime;
+/** Attach the runtime a rendered composite root needs (its `data-iox-composite`), unless it runs one already. Returns
+ *  the NEW runtime, or null. */
+declare function attachCompositeAt(root: HTMLElement, options?: Omit<AccordionRuntimeOptions, 'rootId' | 'behaviour'> & Omit<ExclusiveRuntimeOptions, 'behaviour'>): CompositeRuntime | null;
+/** Subscribe to the item `el` sits in turning on / off — what the `itemOn` / `itemOff` interaction triggers listen to,
+ *  in both families. Returns the unsubscribe. */
+declare function onCompositeItemState(el: Element, on: boolean, handler: () => void): () => void;
+/** True when the item `el` sits in is on now (an open accordion item, the active tab or its panel). */
+declare function isCompositeItemOn(el: Element): boolean;
+/**
+ * Run an item action on the element of an ITEM — an accordion item, a disclosure, or a tab (CC4a: `openItem` turns it
+ * on; a Tabs always shows one, so Close and Toggle leave it) — the `openItem` / `closeItem` / `toggleItem` interaction
+ * actions, on the canvas and on the live site through this one function. Returns whether the item shows on
+ * afterwards, or null when `el` is in no running composite.
+ */
+declare function runCompositeItemAction(el: Element | null | undefined, action: CompositeItemAction): boolean | null;
 
-export { ACCORDION_BIND_PROP, ACCORDION_CONTENT_LIMIT, ACCORDION_DEFAULT_ONS, ACCORDION_ICONS, ACCORDION_ICON_GLYPH, ACCORDION_NEW_ITEM_WORDS, ACCORDION_WORDS, AccordionClass, AccordionDefaultOn, AccordionEditRefusal, AccordionIcon, AccordionKeyAction, AccordionRole, AccordionRuntime, BADGE_TONES, BADGE_TONE_ICONS, BadgeTone, CARD_LAYOUTS, CARD_LAYOUT_CUSTOM, CARD_PARTS, CARD_PART_ROLE, CARD_STACK_BREAKPOINT, CARD_WORDS, CHIP_ICON, CHIP_STYLE, COMPOSITE_ATTRIBUTE, COMPOSITE_KIND_ROLES, COMPOSITE_ROLE_SPECS, CardLayout, CardPart, CardRole, CompositeBehaviourTrait, CompositeItemAction, CompositeKind, DEFAULT_ON_ATTRIBUTE, DISCLOSURE_ITEM_KEY, DISCLOSURE_WORDS, DisclosureRole, ITEM_KEY_ATTRIBUTE, ITEM_OFF_EVENT, ITEM_ON_EVENT, ITEM_OPEN_STATE, MULTIPLE_ATTRIBUTE, ON_ATTRIBUTE, ON_STATE, PILL_LABEL_STYLE, SCOPE_ATTRIBUTE, StructureEdit, StructureRefusal, UNTIL_FOUND, accordionAnswerOf, accordionBehaviour, accordionDomIds, accordionFocusIndex, accordionHeadingLevel, accordionItemAttributes, accordionItemLabel, accordionItemOf, accordionItemState, accordionItems, accordionKeyAction, accordionPanelAttributes, accordionPanelOf, accordionPartStyle, accordionQuestionOf, accordionRegionAttributes, accordionRemovalRefusal, accordionRootAttributes, accordionRootOf, accordionRuntimeOf, accordionScope, accordionToContent, accordionToManual, accordionTrackAttributes, accordionTriggerAttributes, accordionTriggerOf, addAccordionItem, applyCardLayout, attachAccordionAt, attachAccordions, badgeStyleId, badgeToneOf, buildAccordionItem, buildAccordionRecipe, buildBadge, buildCardRecipe, buildChip, buildCompositeIcon, buildDisclosureRecipe, cardPartsOf, cardRootOf, cardTitleOf, clearLayerStyles, closeAccordionItem, closestAccordion, closestAccordionItem, compositeItemOf, compositeItems, compositeKindOfRole, compositeRootOf, compositeRowKeys, compositeScopeId, detachAccordion, detectAccordionIcon, detectCardLayout, disclosureOpenByDefault, domSafeKey, findByRole, hasLabelledRegion, initialAccordionOpen, isAccordionFromContent, isAccordionItemOn, isAccordionPart, isAccordionRoot, isCardLinked, isCardRoot, isCompositeItem, isCompositePanel, isCompositeRoot, isCompositeTrigger, isDisclosurePart, isDisclosureRoot, isLockedPart, isPillNode, itemOpenTriggerIds, makeCompositePart, moveAccordionItem, nextAccordionState, nextItemKey, onAccordionItemState, openAccordionItem, parentInComposite, pickAccordionAutoBinds, readLayerStyle, readProp, readStyle, removeFromComposite, renameAccordionItem, rowItemKey, runCompositeItemAction, serializeDomAttributes, setAccordionBehaviour, setAccordionIcon, setBadgeTone, setCardLinked, setCardPart, shouldScrollToItem, structureRefusal, walkComposite, writeLayerStyles, writeProp, writeStyles };
-export type { AccordionAutoBinds, AccordionBehaviour, AccordionDomIds, AccordionItemState, AccordionOptions, AccordionRuntimeOptions, AccordionScope, AccordionWords, BaselineStyles, CardEditOptions, CardLayoutResult, CardLayoutState, CardOptions, CardPartChange, CardWords, CompositeBinding, CompositeKindRoles, CompositeLayer, CompositeNode, CompositeNodeFactory, CompositeNodeSpec, CompositeRoleSpec, CompositeTrait, ContentFieldLike, DisclosureOptions, DisclosureWords, DomAttributes, PillOptions };
+export { ACCORDION_BIND_PROP, ACCORDION_CONTENT_LIMIT, ACCORDION_DEFAULT_ONS, ACCORDION_ICONS, ACCORDION_ICON_GLYPH, ACCORDION_NEW_ITEM_WORDS, ACCORDION_WORDS, ACTIVATE_ON_ATTRIBUTE, AccordionClass, AccordionDefaultOn, AccordionEditRefusal, AccordionIcon, AccordionKeyAction, AccordionRole, AccordionRuntime, BADGE_TONES, BADGE_TONE_ICONS, BadgeTone, CARD_LAYOUTS, CARD_LAYOUT_CUSTOM, CARD_PARTS, CARD_PART_ROLE, CARD_STACK_BREAKPOINT, CARD_WORDS, CAROUSEL_QUOTES, CHIP_ICON, CHIP_STYLE, COMPOSITE_ATTRIBUTE, COMPOSITE_KIND_ROLES, COMPOSITE_ROLE_SPECS, CardLayout, CardPart, CardRole, CarouselA11y, CompositeBehaviourTrait, CompositeItemAction, CompositeKind, DEFAULT_ON_ATTRIBUTE, DISCLOSURE_ITEM_KEY, DISCLOSURE_WORDS, DisclosureRole, EXCLUSIVE_KIND_ROLES, ExclusiveRuntime, ITEM_KEY_ATTRIBUTE, ITEM_OFF_EVENT, ITEM_ON_EVENT, ITEM_OPEN_STATE, LIGHTBOX_ARROWS_HIDE_AT, LIGHTBOX_LABEL, MULTIPLE_ATTRIBUTE, NO_ELEMENT_STYLE, ON_ATTRIBUTE, ON_STATE, ORIENTATION_ATTRIBUTE, PILL_LABEL_STYLE, ROW_INDEX_ATTRIBUTE, SCOPE_ATTRIBUTE, SLIDER_NAME_TRAIT, SLIDER_PART_GLYPH, SLIDER_PART_ROLES, SLIDER_PLAY_GLYPH, SLIDER_TYPE, SLIDER_WORDS, SLIDE_TO_ROW, SLIDE_TYPE, SWIPER_THEME_COLOR, SliderFlag, SliderRole, StructureEdit, StructureRefusal, TABS_ACTIVATE_ONS, TABS_CONTENT_LIMIT, TABS_IMAGE_BIND_PROP, TABS_LABEL_BIND_PROP, TABS_NEW_TAB_WORDS, TABS_ORIENTATIONS, TABS_STACK_BREAKPOINT, TABS_TEXT_BIND_PROP, TABS_WORDS, TabsActivateOn, TabsBehaviourTrait, TabsEditRefusal, TabsOrientation, TabsRole, UNTIL_FOUND, acceptsRefusal, accordionAnswerOf, accordionBehaviour, accordionDomIds, accordionFocusIndex, accordionHeadingLevel, accordionItemAttributes, accordionItemLabel, accordionItemOf, accordionItemState, accordionItems, accordionKeyAction, accordionPanelAttributes, accordionPanelOf, accordionPartStyle, accordionQuestionOf, accordionRegionAttributes, accordionRemovalRefusal, accordionRootAttributes, accordionRootOf, accordionRootOfItem, accordionRuntimeOf, accordionScope, accordionToContent, accordionToManual, accordionTrackAttributes, accordionTriggerAttributes, accordionTriggerOf, addAccordionItem, addTabPair, applyCardLayout, attachAccordionAt, attachAccordions, attachCarouselA11y, attachCompositeAt, attachExclusiveAt, badgeStyleId, badgeToneOf, buildAccordionItem, buildAccordionRecipe, buildBadge, buildCardRecipe, buildCarouselRecipe, buildChip, buildCompositeIcon, buildDisclosureRecipe, buildLightboxRecipe, buildSliderPart, buildTabPair, buildTabsRecipe, canOpenAtClickedItem, cardPartsOf, cardRootOf, cardTitleOf, carouselOf, clearLayerStyles, closeAccordionItem, closestAccordion, closestAccordionItem, closestExclusive, closestExclusiveItemPart, compositeItemOf, compositeItems, compositeKindOfRole, compositeRootOf, compositeRowKeys, compositeScopeId, detachAccordion, detectAccordionIcon, detectCardLayout, disclosureOpenByDefault, domSafeKey, exclusiveItemPartOf, exclusiveRootOf, exclusiveRuntimeOf, findByRole, hasLabelledRegion, hasSliderParts, initialAccordionOpen, isAccordionFromContent, isAccordionItemOn, isAccordionPart, isAccordionRoot, isAnyCompositeRoot, isCardLinked, isCardRoot, isCompositeItem, isCompositeItemOn, isCompositePanel, isCompositeRoot, isCompositeTrigger, isDisclosurePart, isDisclosureRoot, isExclusiveItemOn, isExclusiveItemPart, isExclusiveKind, isExclusiveList, isExclusivePanel, isExclusivePanels, isExclusiveRoot, isExclusiveTrigger, isLockedPart, isPillNode, isSlider, isSliderPart, isTabsFromContent, isTabsPart, isTabsRoot, isToggleKind, itemOpenTriggerIds, lightboxSliderOf, makeCompositePart, manualTabKeys, migrateSliderControls, moveAccordionItem, moveTabPair, needsSliderMigration, nextAccordionState, nextItemKey, nextTabKey, onAccordionItemState, onCompositeItemState, onExclusiveItemState, openAccordionItem, parentInComposite, pickAccordionAutoBinds, pickTabsAutoBinds, readLayerStyle, readProp, readStyle, removeFromComposite, removeTabPair, renameAccordionItem, renameTab, repeatSourceOf, rowIndexOf, rowItemKey, rowSourceOf, runCompositeItemAction, sameRepeatSource, serializeDomAttributes, setAccordionBehaviour, setAccordionIcon, setBadgeTone, setCardLinked, setCardPart, setSliderFlag, setTabsBehaviour, shouldScrollToItem, slideIndexForRow, sliderLiveRegion, sliderPart, sliderPartElement, sliderPauseAttributes, sliderPauseGlyph, sliderSlides, sliderWords, splitSliderChildren, structureRefusal, syncSliderParts, tabLabel, tabLabelNodeOf, tabListAttributes, tabPanelAttributes, tabPanelImageOf, tabPanelOf, tabPanelTextOf, tabPartKey, tabTriggerAttributes, tabTriggerOf, tabsBehaviour, tabsItemState, tabsItemTriggerIds, tabsKeyAction, tabsLabel, tabsListOf, tabsPanels, tabsPanelsOf, tabsPartAttributes, tabsPartnerOf, tabsRemovalRefusal, tabsRootAttributes, tabsScope, tabsScopeFor, tabsToContent, tabsToManual, tabsTriggers, walkComposite, wantedSliderParts, writeLayerStyles, writeProp, writeStyles };
+export type { AccordionAutoBinds, AccordionBehaviour, AccordionDomIds, AccordionItemState, AccordionOptions, AccordionRuntimeOptions, AccordionScope, AccordionWords, BaselineStyles, CardEditOptions, CardLayoutResult, CardLayoutState, CardOptions, CardPartChange, CardWords, CarouselA11yOptions, CarouselOptions, CarouselQuote, CarouselSwiper, CompositeBinding, CompositeKindRoles, CompositeLayer, CompositeNode, CompositeNodeFactory, CompositeNodeSpec, CompositeRoleSpec, CompositeRuntime, CompositeTrait, ContentFieldLike, DisclosureOptions, DisclosureWords, DomAttributes, ExclusiveCompositeKind, ExclusiveKindRoles, ExclusiveRuntimeOptions, LegacySliderLook, LightboxOptions, PillOptions, RepeatSource, SliderPartsChange, SliderWords, TabPair, TabWords, TabsAutoBinds, TabsBehaviour, TabsItemState, TabsOptions, TabsScope, ToggleCompositeKind };