@citolab/qti-components 7.28.1 → 8.0.1

package/dist/interactions.d.ts

@@ -1,501 +1,269 @@
 import * as lit from 'lit';
-import { CSSResultGroup, LitElement, PropertyValues, PropertyValueMap } from 'lit';
-import { a as Interaction, I as IInteraction, C as Correctness } from './interaction-Bgzlw7Iu.js';
-import { C as ConfigContext } from './config.context-BjZ2bZSY.js';
-import { a as Cardinality, B as BaseType } from './variables-CMYcDbyW.js';
-import { I as ItemContext } from './item.context-CkUeDcaO.js';
-import { Q as QtiContext } from './qti.context-CejJMlfZ.js';
+import { CSSResultGroup, LitElement, PropertyValueMap, PropertyValues } from 'lit';
+import { I as Interaction } from './interaction.d-D4MstYRz.js';
 import * as lit_directives_ref_js from 'lit/directives/ref.js';
+import { Q as QtiAreaMapEntry, B as BaseType, a as Cardinality, I as ItemContext } from './item.types.d-QU7LljEK.js';
+import * as _qti_components_portable_custom_interaction_qti_portable_custom_test_interaction_js from '@qti-components/portable-custom-interaction/qti-portable-custom-test-interaction.js';
+import { Q as QtiContext } from './qti.context.d-CejJMlfZ.js';
+import * as _qti_components_interactions_core_mixins_drag_drop_observables from '@qti-components/interactions-core/mixins/drag-drop-observables';
+import { QtiSimpleAssociableChoice as QtiSimpleAssociableChoice$1 } from '@qti-components/interactions-core/elements/qti-simple-associable-choice';
+export * from '@qti-components/interactions-core/elements/qti-simple-associable-choice';
+import * as _qti_components_interactions_core_mixins_menu_auto_size from '@qti-components/interactions-core/mixins/menu-auto-size';
+import { C as ConfigContext } from './config.context.d-BvU9r-Mg.js';
+import * as _qti_components_interactions_core_mixins_choices_choices_mixin from '@qti-components/interactions-core/mixins/choices/choices.mixin';
+import { Choice, ChoicesInterface as ChoicesInterface$1 } from '@qti-components/interactions-core/mixins/choices/choices.mixin';
+import { V as ValidatableInteraction } from './interaction.interface.d-CvjHM2bi.js';
+export * from '@qti-components/interactions-core/elements/qti-gap-img';
+export * from '@qti-components/interactions-core/elements/qti-gap-text';
+export * from '@qti-components/interactions-core/elements/qti-gap';
+export * from '@qti-components/interactions-core/elements/qti-inline-choice';
+export * from '@qti-components/interactions-core/elements/qti-hottext';
+export * from '@qti-components/interactions-core/elements/qti-simple-choice';
+export * from '@qti-components/interactions-core/elements/qti-hotspot-choice';
+export * from '@qti-components/interactions-core/elements/qti-associable-hotspot';
+export * from '@qti-components/interactions-core/elements/qti-prompt';
 
 /**
- * Collision detection algorithms for drag and drop interactions
- * Based on dnd-kit collision detection strategies
- */
-type CollisionDetectionAlgorithm = 'pointerWithin' | 'rectangleIntersection' | 'closestCenter' | 'closestCorners' | 'closestCornersWithInventoryPriority';
-
-type DragDropCore = Interaction & {
-    trackedDraggables: HTMLElement[];
-    trackedDroppables: HTMLElement[];
-    trackedDragContainers: HTMLElement[];
-    allDropzones: HTMLElement[];
-    dragState: DragState;
-    collisionDetectionAlgorithm: CollisionDetectionAlgorithm;
-    get response(): string | string[] | null;
-    set response(value: string | string[] | null);
-    saveResponse(value?: string | string[]): void;
-    validate(): boolean;
-    reportValidity(): boolean;
-    cacheInteractiveElements(): void;
-    resetDragState(): void;
-    afterCache(): void;
-    allowDrop(draggable: HTMLElement, droppable: HTMLElement): boolean;
-    handleDrop(draggable: HTMLElement, droppable: HTMLElement): void;
-    handleInvalidDrop(dragSource: HTMLElement | null): void;
-    initiateDrag(dragElement: HTMLElement, startX: number, startY: number, inputType: 'mouse' | 'touch', eventSource?: 'pointer' | 'mouse' | 'touch', pointerId?: number, startedFromTrustedEvent?: boolean): void;
-    createDragClone(element: HTMLElement, rect: DOMRect): HTMLElement;
-    updateClonePosition(clientX: number, clientY: number): void;
-    activateAllDroppables(): void;
-    setupMoveObservables(inputType: 'mouse' | 'touch', eventSource?: 'pointer' | 'mouse' | 'touch'): void;
-};
-interface DragState {
-    dragging: boolean;
-    dragSource: HTMLElement | null;
-    dragClone: HTMLElement | null;
-    startOffset: {
-        x: number;
-        y: number;
-    };
-    currentTarget: HTMLElement | null;
-    sourceDroppable: HTMLElement | null;
-    inputType: 'mouse' | 'touch' | null;
-    pointerId?: number;
-    startedFromTrustedEvent?: boolean;
-    initialCoordinates?: {
-        x: number;
-        y: number;
-    };
-    activationTimeout?: number;
-    touchCleanup?: () => void;
-    lastTargetChangeTime?: number;
-}
-
-type DragDropSlotted = DragDropCore & {
-    minAssociations: number;
-    maxAssociations: number;
-    disableAnimations: boolean;
-    enableFlipAnimations: boolean;
-    autoSizeDropzones: boolean;
-    validate(): boolean;
-    reportValidity(): boolean;
-    reset(): void;
-    saveResponse(value?: string | string[]): void;
-    shouldTreatBlockedMaxAsInvalid(): boolean;
-    shouldReturnToInventoryOnInventoryDrop(): boolean;
-};
-
-/**
- * Shared utilities for sortable drag-and-drop behavior.
- * Used by both DragDropSortableMixin (standalone) and SlotSortableEnhancerMixin (composition).
- */
-
-/**
- * Configuration for drop placeholder styling
- */
-interface PlaceholderConfig {
-    borderStyle?: string;
-    borderColor?: string;
-    background?: string;
-    transitionDuration?: number;
-}
-
-type DragDropSlottedSortable = DragDropSlotted & {
-    allowReorder: boolean;
-    readonly isDraggingFromSlot: boolean;
-    sortablePlaceholderConfig: PlaceholderConfig;
-};
-
-declare const QtiAssociateInteraction_base: (abstract new (...args: any[]) => DragDropSlottedSortable) & (abstract new (...args: any[]) => DragDropSlotted) & typeof Interaction;
-declare class QtiAssociateInteraction extends QtiAssociateInteraction_base {
-    static styles: CSSResultGroup;
-    protected _childrenMap: Element[];
-    protected _registerChoiceHandler: (event: CustomEvent) => void;
-    constructor();
-    protected _registerChoice(event: CustomEvent): void;
-    protected getResponse(): string[];
-    getValue(val: string[]): string[];
-    render(): lit.TemplateResult<1>;
-    protected updated(changedProperties: Map<string, unknown>): void;
-    disconnectedCallback(): void;
-}
-declare global {
-    interface HTMLElementTagNameMap {
-        'qti-associate-interaction': QtiAssociateInteraction;
-    }
-}
-
-interface ChoiceInterface {
-    identifier: string;
-    disabled: boolean;
-    readonly: boolean;
-}
-/**
- * A mixin that adds choice functionality to a LitElement-based class.
- * It dispatches events with a custom `type` and handles selection logic.
+ * Upload interaction: candidates attach a file as their response.
  *
- * @param Base - The base class to extend.
- * @param type - The type of the choice, used in event names.
- * @returns A new class extending the base class with choice functionality.
+ * @slot prompt - The prompt shown above the file input.
  */
-interface ActiveElementMixinInterface {
-    identifier: string;
-    tabIndex: number;
-    disabled: boolean;
-    readonly: boolean;
-    internals: ElementInternals;
-}
-
-type Choice = HTMLElement & ChoiceInterface & {
-    internals: ElementInternals;
-};
-interface ChoicesInterface extends IInteraction {
-    minChoices: number;
-    maxChoices: number;
-    value: string | null;
-    response: string | string[] | null;
-    validate(): boolean;
-    reportValidity(): boolean;
-}
-
-type Orientation = 'horizontal' | 'vertical' | undefined;
-declare const QtiChoiceInteraction_base: (abstract new (...args: any[]) => {}) & (abstract new (...args: any[]) => ChoicesInterface) & typeof Interaction;
-declare class QtiChoiceInteraction extends QtiChoiceInteraction_base implements ChoicesInterface {
+declare class QtiUploadInteraction extends Interaction {
     #private;
     static styles: CSSResultGroup;
-    /** @deprecated, use 'qti-orientation-horizontal' or 'qti-orientation-vertical' instead */
-    orientation: Orientation;
+    reset(): void;
+    validate(): boolean;
+    get response(): string | null;
+    set response(base64: string | null);
+    static get properties(): {
+        [key: string]: lit.PropertyDeclaration<unknown, unknown>;
+    };
     render(): lit.TemplateResult<1>;
 }
 declare global {
     interface HTMLElementTagNameMap {
-        'qti-choice-interaction': QtiChoiceInteraction;
+        'qti-upload-interaction': QtiUploadInteraction;
     }
 }
 
 /**
- * QTI Custom Interaction component for legacy CES-based interactions.
+ * Text-entry interaction: single-line inline text input.
  *
- * This component implements support for custom interactions originally built for the CES
- * (Custom Element Standard) player - the predecessor to FACET and the Trifork QTI Player.
- *
- * @remarks
- * The interaction workflow:
- * 1. Fetch the CI manifest (JSON file with script, style, media references)
- * 2. Check if bootstrap.js uses the CES API
- * 3. If CES is used:
- *    - Fetch index.html from main window (where service worker/fetch works)
- *    - Inject registerCES proxy script for postMessage-based communication
- *    - Create blob URL and pass it to ciBootstrap
- * 4. Create pciContainer iframe with style and bootstrap script
- * 5. Handle postMessage events for getMedia, getResponse, setResponse, getBlobUrl
+ * @customElement qti-text-entry-interaction
  *
- * The postMessage bridge is necessary because:
- * - Iframes created via document.write() have about:blank origin
- * - They cannot access the parent's global CES object (cross-origin)
- * - Service workers don't control about:blank documents
+ * @attr {string} response-identifier - Required. Identifier of the bound response variable.
+ * @attr {number} expected-length - Hint at the expected answer length; drives the rendered
+ *   field width and the input's `maxlength`.
+ * @attr {string} pattern-mask - Regular expression the value must match to be valid.
+ * @attr {string} placeholder-text - Placeholder shown while the field is empty.
+ * @attr {string} data-patternmask-message - Custom validation message shown when
+ *   `pattern-mask` fails. Part of the QTI shared interaction vocabulary.
+ * @attr {number} [base=10] - Not implemented. Numeric base used when recording the value.
+ * @attr {string} string-identifier - Not implemented. Identifier of a second, string-typed
+ *   response variable that also receives the raw entry.
+ * @attr {string} format - Not implemented. QTI types this as a bare normalized string here rather
+ *   than as the `plain | preformatted | xhtml` vocabulary it defines for extended-text, and a
+ *   single-line input has no formatting to render: it can show neither preserved line breaks nor
+ *   markup. The field is always plain text, so this is not planned either.
  *
- * Messages are sent to all parent windows to support embedding scenarios like Storybook
- * where window.top might not be the actual host application.
+ * @csspart answer - The answer-key line, revealed above the field when the correct response is shown.
+ * @csspart input - The text input element.
+ * @csspart message - The validation message, hidden until `reportValidity` shows it.
  */
-declare class QtiCustomInteraction extends Interaction {
-    #private;
-    static styles: CSSResultGroup;
-    constructor();
-    data: string;
-    baseItemUrl: string;
-    baseRefUrl: string;
-    id: string;
-    private _errorMessage;
-    manifest: {
-        script: string[];
-        style: string[];
-        media: string[];
-    };
-    connectedCallback(): void;
-    /**
-     * Sets up the CES custom interaction by creating the iframe structure and
-     * handling the CES API communication via postMessage.
-     *
-     * For interactions that use CES, this method:
-     * 1. Fetches the original bootstrap.js and checks if it uses CES
-     * 2. If CES is used, fetches index.html and injects the registerCES proxy
-     * 3. Creates a blob URL for the modified HTML (stored in _contentBlobUrl)
-     * 4. Replaces bootstrap.js with ciBootstrap that loads the blob URL
-     * 5. Sets up postMessage listeners for CES API calls
-     */
-    setupCES(): Promise<void>;
-    handlePostMessage(event: MessageEvent): void;
-    validate(): boolean;
-    get response(): string | string[] | null;
-    set response(val: string | string[] | null);
-    disconnectedCallback(): void;
-    render(): lit.TemplateResult<1>;
-}
-declare global {
-    interface HTMLElementTagNameMap {
-        'qti-custom-interaction': QtiCustomInteraction;
-    }
-}
-
-declare class QtiEndAttemptInteraction extends LitElement {
-    static styles: CSSResultGroup;
-    responseIdentifier: string;
-    disabled: boolean;
-    /** Defines the number of attempts that a user can make using the 'endAttemptInteraction' mechanism (this can be used to limit the number of hints, etc.). [More information](https://www.imsglobal.org/sites/default/files/spec/qti/v3/info/index.html#DataCharacteristic_EndAttemptInteraction.Attr_count-attempt) */
-    countAttempt: 'true' | 'false' | null;
-    title: string;
-    render(): lit.TemplateResult<1>;
-    endAttempt(_: Event): void;
-}
-declare global {
-    interface HTMLElementTagNameMap {
-        'qti-end-attempt-interaction': QtiEndAttemptInteraction;
-    }
-}
-
-declare class QtiExtendedTextInteraction extends Interaction {
+declare class QtiTextEntryInteraction extends Interaction {
     static styles: CSSResultGroup;
-    protected _rows: number;
-    /** expected length is mapped to the property maxlength on the textarea */
+    inputRef: lit_directives_ref_js.Ref<HTMLInputElement>;
     expectedLength: number;
     patternMask: string;
-    /** text appearing in the extended-text-interaction if it is empty */
     placeholderText: string;
     dataPatternmaskMessage: string;
-    classNames: string;
-    handleclassNamesChange(_: any, classes: string): void;
     response: string | null;
-    protected _handleResponseChange: () => void;
+    private _input;
+    protected _handleValueChange: () => void;
     get value(): string | null;
     set value(val: string | null);
+    get isInline(): boolean;
     validate(): boolean;
-    toggleCorrectResponse(): void;
-    reportValidity(): boolean;
+    /** The answer-key line, revealed above the field when the correct response is shown. */
+    protected renderAnswer(): unknown;
+    /** The field itself. */
+    protected renderInput(): unknown;
+    /** Hidden until `Interaction.reportValidity` shows it. */
+    protected renderValidationMessage(): unknown;
     render(): lit.TemplateResult<1>;
     protected textChanged(event: Event): void;
-    protected setEmptyAttribute(text: string): void;
+    reportValidity(): boolean;
+    reset(): void;
 }
 declare global {
     interface HTMLElementTagNameMap {
-        'qti-extended-text-interaction': QtiExtendedTextInteraction;
+        'qti-text-entry-interaction': QtiTextEntryInteraction;
     }
 }
 
-declare const QtiGapMatchInteraction_base: (abstract new (...args: any[]) => DragDropSlottedSortable) & (abstract new (...args: any[]) => DragDropSlotted) & typeof Interaction;
-declare class QtiGapMatchInteraction extends QtiGapMatchInteraction_base {
+/**
+ * Slider interaction: candidates pick a numeric value along a rail.
+ *
+ * @slot prompt - The prompt shown above the slider.
+ *
+ * @csspart slider - The slider root element.
+ * @csspart bounds - The min/max bounds label wrapper.
+ * @csspart ticks - The tick marks along the rail.
+ * @csspart rail - The rail element the knob slides along.
+ * @csspart knob - The draggable knob.
+ * @csspart value - The current value display (used twice in the layout).
+ * @csspart knob-correct - Ghost knob shown at the correct response position.
+ */
+declare class QtiSliderInteraction extends Interaction {
     #private;
     static styles: CSSResultGroup;
+    private _rail;
+    min: number;
+    max: number;
+    step: number;
+    validate(): boolean;
+    connectedCallback(): void;
+    get response(): string;
+    set response(val: string | null);
+    /** Extension hook for optional content rendered on the slider rail. */
+    protected renderRailSupplement(): unknown;
     render(): lit.TemplateResult<1>;
-    toggleCorrectResponse(show: boolean): void;
-    toggleCandidateCorrection(show: boolean): void;
 }
 declare global {
     interface HTMLElementTagNameMap {
-        'qti-gap-match-interaction': QtiGapMatchInteraction;
+        'qti-slider-interaction': QtiSliderInteraction;
     }
 }
 
-declare class QtiGraphicAssociateInteraction extends Interaction {
+/**
+ * Select-point interaction: candidates place points onto a background image.
+ *
+ * @customElement qti-select-point-interaction
+ *
+ * @attr {string} response-identifier - Required. Identifier of the bound response variable,
+ *   which must have base-type `point`.
+ * @attr {number} [max-choices=0] - Maximum points the candidate may place; `0` means unlimited.
+ * @attr {number} [min-choices=0] - Minimum points for a valid response.
+ * @attr {string} area-mappings - Extension, not QTI. JSON array of
+ *   `{shape, coords, mappedValue?, defaultValue?}` entries used when no
+ *   `qti-response-declaration` supplies an `qti-area-mapping`.
+ *
+ * @slot prompt - The prompt shown above the image.
+ * @slot - Default slot for the base image.
+ *
+ * @csspart point - Each selected point marker.
+ * @cssprop --qti-select-point-icon - Marker mask image (SVG data URL). Should be a solid silhouette for color inheritance.
+ * @cssprop --qti-select-point-marker-size - Marker size.
+ * @cssprop --qti-select-point-marker-anchor - Vertical translate anchor (`-100%` for bottom tip, `-50%` for center).
+ * @cssprop --qti-select-point-marker-color - Marker color; defaults to currentColor so it can be inherited.
+ */
+declare class QtiSelectPointInteraction extends Interaction {
     #private;
     static styles: CSSResultGroup;
-    private _correctLines;
-    private startCoord;
-    private mouseCoord;
-    grImage: any[];
-    private _response;
-    constructor();
-    reset(): void;
-    validate(): boolean;
-    set response(val: string[]);
-    get response(): string[];
-    toggleInternalCorrectResponse(show: boolean): void;
+    maxChoices: number;
+    minChoices: number;
+    response: string[] | null;
+    /**
+     * Standalone area mapping as a JSON string. Mirrors the editor's
+     * `#syncAreaEntriesFromAttribute` codec — each entry has `{shape, coords, mappedValue?, defaultValue?}`
+     * and `shape` must be `'circle'` or `'rect'`. Used when no
+     * `qti-response-declaration` provides `areaMapping`.
+     *
+     * @example
+     * ```html
+     * <qti-select-point-interaction area-mappings='[{"shape":"circle","coords":"191,393,10","mappedValue":1}]'>
+     * ```
+     */
+    areaMappings: string | null;
+    private _areaEntries;
+    protected _handleAreaMappingsChange: () => void;
+    protected get _effectiveAreaEntries(): QtiAreaMapEntry[];
+    connectedCallback(): void;
+    get responsePoints(): {
+        x: number;
+        y: number;
+    }[];
+    /** Extension hook for additional part tokens on a rendered response point. */
+    protected pointPart(_point: string, _index: number): string;
+    /** Extension hook for optional layers rendered above the response points. */
+    protected renderSupplementalLayer(): unknown;
+    /** Positions overlay elements that carry `data-coord` and `data-shape`. */
+    protected positionOverlayElements(elements: Iterable<HTMLElement>): void;
     render(): lit.TemplateResult<1>;
+    validate(): boolean;
+    reportValidity(): boolean;
     firstUpdated(): void;
     disconnectedCallback(): void;
 }
 declare global {
     interface HTMLElementTagNameMap {
-        'qti-graphic-associate-interaction': QtiGraphicAssociateInteraction;
+        'qti-select-point-interaction': QtiSelectPointInteraction;
     }
 }
 
-declare const QtiGraphicGapMatchInteraction_base: (abstract new (...args: any[]) => DragDropSlottedSortable) & (abstract new (...args: any[]) => DragDropSlotted) & typeof Interaction;
-declare class QtiGraphicGapMatchInteraction extends QtiGraphicGapMatchInteraction_base {
-    #private;
+/**
+ * Position-object interaction: candidates place draggable objects onto a stage image.
+ *
+ * @slot - Default slot for the object choices and stage.
+ */
+declare class QtiPositionObjectInteraction extends LitElement {
     static styles: CSSResultGroup;
     render(): lit.TemplateResult<1>;
-    shouldReturnToInventoryOnInventoryDrop(): boolean;
-    connectedCallback(): void;
+}
+
+declare class QtiPositionObjectStage extends LitElement {
+    static styles: CSSResultGroup;
+    choiceOrdering: boolean;
+    startX: any;
+    startY: any;
+    dragElement: any;
+    render(): lit.TemplateResult<1>;
+    constructor();
+    dragElementHandler(event: MouseEvent): void;
+    firstUpdated(a: PropertyValueMap<any>): void;
+    removeMoveListener(): void;
     disconnectedCallback(): void;
 }
 declare global {
     interface HTMLElementTagNameMap {
-        'qti-graphic-gap-match-interaction': QtiGraphicGapMatchInteraction;
+        'qti-position-object-stage': QtiPositionObjectStage;
     }
 }
 
-declare const QtiGraphicOrderInteraction_base: (abstract new (...args: any[]) => ChoicesInterface) & typeof Interaction;
-declare class QtiGraphicOrderInteraction extends QtiGraphicOrderInteraction_base {
-    #private;
-    static styles: CSSResultGroup;
-    protected choiceOrdering: boolean;
-    protected _choiceElements: Choice[];
-    render(): lit.TemplateResult<1>;
-    toggleCorrectResponse(show: boolean): void;
-    connectedCallback(): void;
-    disconnectedCallback(): void;
-}
-declare global {
-    interface HTMLElementTagNameMap {
-        'qti-graphic-order-interaction': QtiGraphicOrderInteraction;
-    }
-}
-
-declare const QtiHotspotInteraction_base: (abstract new (...args: any[]) => ChoicesInterface) & typeof Interaction;
-declare class QtiHotspotInteraction extends QtiHotspotInteraction_base {
-    #private;
-    static styles: CSSResultGroup;
-    render(): lit.TemplateResult<1>;
-    connectedCallback(): void;
-    disconnectedCallback(): void;
-}
-declare global {
-    interface HTMLElementTagNameMap {
-        'qti-hotspot-interaction': QtiHotspotInteraction;
-    }
-}
-
-declare const QtiHottextInteraction_base: (abstract new (...args: any[]) => ChoicesInterface) & typeof Interaction;
-declare class QtiHottextInteraction extends QtiHottextInteraction_base {
-    #private;
-    static styles: CSSResultGroup;
-    class: string;
-    render: () => lit.TemplateResult<1>;
-    connectedCallback(): void;
-    updated(_changedProperties: PropertyValues): void;
-}
-
-interface OptionType {
-    content: string | Node[];
-    value: string;
-    selected: boolean;
-}
-declare class QtiInlineChoiceInteraction extends Interaction {
-    #private;
-    constructor();
-    get isInline(): boolean;
-    static get styles(): lit.CSSResultGroup[];
-    protected options: OptionType[];
-    protected correctOption: any;
-    protected _dropdownOpen: boolean;
-    private _slotObserver;
-    private readonly _menuId;
-    configContext: ConfigContext;
-    render(): lit.TemplateResult<1>;
-    connectedCallback(): Promise<void>;
-    disconnectedCallback(): void;
-    willUpdate(changed: PropertyValues<this>): void;
-    updated(changed: PropertyValues<this>): void;
-    validate(): boolean;
-    reset(): void;
-    set response(value: string | null);
-    get response(): string | null;
-    toggleInternalCorrectResponse(show: boolean): void;
-}
-declare global {
-    interface HTMLElementTagNameMap {
-        'qti-inline-choice-interaction': QtiInlineChoiceInteraction;
-    }
-}
-
-declare const QtiSimpleAssociableChoice_base: (abstract new (...args: any[]) => ActiveElementMixinInterface) & typeof LitElement;
-declare class QtiSimpleAssociableChoice extends QtiSimpleAssociableChoice_base {
-    static styles: CSSResultGroup;
-    /** the minimal number of selections a candidate must make */
-    matchMin: number;
-    /** the maximum number of selections a candidate must make, the other options will be disabled when max options is checked */
-    matchMax: number;
-    fixed: boolean;
-    connectedCallback(): void;
-    render(): lit.TemplateResult<1>;
-}
-declare global {
-    interface HTMLElementTagNameMap {
-        'qti-simple-associable-choice': QtiSimpleAssociableChoice;
-    }
-}
-
-declare const QtiMatchInteraction_base: (abstract new (...args: any[]) => DragDropSlottedSortable) & (abstract new (...args: any[]) => DragDropSlotted) & typeof Interaction;
-declare class QtiMatchInteraction extends QtiMatchInteraction_base {
-    #private;
-    static styles: CSSResultGroup;
-    protected sourceChoices: QtiSimpleAssociableChoice[];
-    protected targetChoices: QtiSimpleAssociableChoice[];
-    protected lastCheckedRadio: HTMLInputElement | null;
-    class: string;
-    protected _response: string | string[];
-    get response(): string[];
-    set response(val: string[]);
-    responseIdentifier: string;
-    protected correctOptions: {
-        source: string;
-        target: string;
-    }[];
-    connectedCallback(): Promise<void>;
-    protected handleRadioClick: (e: {
-        target: HTMLInputElement;
-    }) => void;
-    protected handleRadioChange: (e: {
-        target: any;
-    }) => void;
-    validate(): boolean;
-    toggleInternalCorrectResponse(show: boolean): void;
-    toggleCandidateCorrection(show: boolean): void;
-    render(): lit.TemplateResult<1>;
-}
-declare global {
-    interface HTMLElementTagNameMap {
-        'qti-match-interaction': QtiMatchInteraction;
-    }
-}
-
-declare class QtiMediaInteraction extends Interaction {
-    #private;
-    static styles: CSSResultGroup;
-    reset(): void;
-    validate(): boolean;
-    get response(): string | null;
-    set response(val: string | null);
-    static get properties(): {
-        step: {
-            type: NumberConstructor;
-            attribute: string;
-            default: number;
-        };
-    };
-    render(): lit.TemplateResult<1>;
-    constructor();
-    connectedCallback(): void;
-}
-declare global {
-    interface HTMLElementTagNameMap {
-        'qti-media-interaction': QtiMediaInteraction;
-    }
-}
-
-declare const QtiOrderInteraction_base: (abstract new (...args: any[]) => DragDropSlottedSortable) & (abstract new (...args: any[]) => DragDropSlotted) & typeof Interaction;
-declare class QtiOrderInteraction extends QtiOrderInteraction_base {
-    #private;
-    static styles: lit.CSSResult;
-    protected childrenMap: Element[];
-    protected nrChoices: number;
-    correctResponses: string[];
-    showCorrectResponses: boolean;
-    /** orientation of choices */
-    orientation: 'horizontal' | 'vertical';
-    render(): lit.TemplateResult<1>;
-    toggleCorrectResponse(show: boolean): void;
-    toggleCandidateCorrection(show: boolean): void;
-    getValue(val: string[]): string[];
-    protected getResponse(): string[];
-    shouldTreatBlockedMaxAsInvalid(): boolean;
-    firstUpdated(): Promise<void>;
+/**
+ * Shared status values for PCI lifecycle callbacks.
+ *
+ * Matches the status vocabulary used in IMS QTI 3 PCI documentation.
+ */
+type PciInteractionStatus = 'interacting' | 'suspended' | 'closed' | 'solution' | 'review';
+/**
+ * Correct response of a response declaration, mirroring `qti-correct-response`.
+ *
+ * `value` holds the authored `qti-value` content: a single value for `single`
+ * cardinality, an array of values for every other cardinality.
+ */
+interface PciCorrectResponse {
+    value: string | string[];
 }
-declare global {
-    interface HTMLElementTagNameMap {
-        'qti-order-interaction': QtiOrderInteraction;
-    }
+/**
+ * Response declaration passed into the `getInstance` configuration so a PCI can
+ * render a correct response itself when the item is in `solution` status.
+ *
+ * Mirrors `qti-response-declaration` with camelCased names. Every field is
+ * optional, a delivery engine passes as much or as little as it has, and
+ * `correctResponse` is absent when the response variable has none.
+ *
+ * `correctResponse` is also withheld while the candidate is still working: it is
+ * only sent when `status` is `solution` or `review`, so a PCI never holds the
+ * answer key during `interacting`.
+ *
+ * See https://github.com/1EdTech/qti-project-management/issues/210
+ */
+interface PciResponseDeclaration {
+    baseType?: BaseType;
+    cardinality?: Cardinality;
+    correctResponse?: PciCorrectResponse;
 }
-
 /**
  * QTI base-type `file` representation.
  */
@@ -571,13 +339,13 @@ declare type QtiVariableJSON = {
 declare class QtiPortableCustomInteraction extends Interaction {
     #private;
     protected _iframeLoaded: boolean;
+    protected _interactionReady: boolean;
     protected _pendingMessages: Array<{
         method: string;
         params: any;
     }>;
     protected iframe: HTMLIFrameElement;
     protected _iframeMessageOrigin: string | null;
-    private _iframeObjectUrl;
     static styles: CSSResultGroup;
     module: string;
     customInteractionTypeIdentifier: string;
@@ -586,6 +354,22 @@ declare class QtiPortableCustomInteraction extends Interaction {
     requireJsUrl: string;
     baseUrl: string;
     useDefaultPaths: boolean;
+    /**
+     * Item lifecycle status handed to the PCI in its `getInstance` configuration.
+     * A delivery engine sets `solution` to let a PCI render the correct response.
+     */
+    status: PciInteractionStatus;
+    /**
+     * Response declaration passed into the PCI configuration, so a PCI can render
+     * the correct response itself instead of having it pushed in as a response.
+     *
+     * Derived from the item context, unless a host sets it explicitly - the
+     * correct response viewer does, since it has no response declaration of its own.
+     *
+     * See https://github.com/1EdTech/qti-project-management/issues/210
+     */
+    set responseDeclaration(declaration: PciResponseDeclaration | null);
+    get responseDeclaration(): PciResponseDeclaration | null;
     private _errorMessage;
     protected context?: ItemContext;
     protected qtiContext?: QtiContext;
@@ -657,12 +441,6 @@ declare class QtiPortableCustomInteraction extends Interaction {
      * IFRAME MODE: Generate iframe HTML content
      */
     protected generateIframeContent(): string;
-    /**
-     * Toggle the display of the correct response
-     * @param responseVariable The response variable containing the correct response
-     * @param show Whether to show or hide the correct response
-     */
-    toggleInternalCorrectResponse(show: boolean): void;
     /**
      * Method to disable the PCI for review mode
      * This can be used when showing the correct response
@@ -680,236 +458,1112 @@ declare global {
     }
 }
 
-declare class QtiPositionObjectInteraction extends LitElement {
+declare const QtiOrderInteraction_base: (abstract new (...args: any[]) => _qti_components_interactions_core_mixins_drag_drop_observables.DragDropSlottedSortable) & (abstract new (...args: any[]) => _qti_components_interactions_core_mixins_drag_drop_observables.DragDropSlotted) & typeof Interaction;
+/**
+ * Order interaction: candidates arrange choices into a target sequence.
+ *
+ * @customElement qti-order-interaction
+ *
+ * @attr {string} response-identifier - Required. Identifier of the bound response variable.
+ * @attr {'horizontal'|'vertical'} [orientation=vertical] - Layout direction of the drop
+ *   sequence. Unlike on `qti-choice-interaction`, QTI does not deprecate this for order.
+ * @attr {boolean} [shuffle=false] - Requests choice shuffling. Applied by the transform
+ *   pipeline (`qti-transformers`), not by this element.
+ * @attr {number} [min-associations=1] - Non-QTI vocabulary inherited from the drag-drop
+ *   mixin; currently the only way to set the lower bound. QTI spells this `min-choices`.
+ * @attr {number} [max-associations=0] - Non-QTI vocabulary inherited from the drag-drop
+ *   mixin; currently the only way to set the upper bound. QTI spells this `max-choices`.
+ * @attr {number} min-choices - Not implemented. The QTI-correct spelling of the lower bound.
+ *   See plans/interaction-attribute-spec-conformance.md.
+ * @attr {number} max-choices - Not implemented. The QTI-correct spelling of the upper bound.
+ *   See plans/interaction-attribute-spec-conformance.md.
+ * @attr {boolean} [auto-size-dropzones=true] - Extension, not QTI. Sizes every drop target to
+ *   the widest chip so placement does not reflow the layout. On by default: an order slot is a
+ *   socket cut to one chip, and both axes are measured (see DROP-SIZING.md).
+ * @attr {boolean} [disable-animations=false] - Extension, not QTI. Disables the FLIP move
+ *   animation.
+ *
+ * @slot prompt - The prompt shown above the interaction.
+ * @slot drags - The draggable choice sources.
+ *
+ * @csspart container - The outer container wrapping drags and drops.
+ * @csspart drags - Wrapper around the drag sources slot.
+ * @csspart drops - The drop-target region.
+ * @csspart drop - Each individual drop target.
+ * @csspart drag - A choice that has been placed into a drop target.
+ */
+declare class QtiOrderInteraction extends QtiOrderInteraction_base {
+    static styles: lit.CSSResult[];
+    protected childrenMap: Element[];
+    protected nrChoices: number;
+    /** orientation of choices */
+    orientation: 'horizontal' | 'vertical';
+    render(): lit.TemplateResult<1>;
+    getValue(val: string[]): string[];
+    protected getResponse(): string[];
+    shouldTreatBlockedMaxAsInvalid(): boolean;
+    firstUpdated(): Promise<void>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'qti-order-interaction': QtiOrderInteraction;
+    }
+}
+
+/**
+ * Media interaction: wraps an embedded media object (audio/video) and tracks play events.
+ *
+ * @slot prompt - The prompt shown above the media element.
+ * @slot - Default slot for the embedded media element.
+ */
+declare class QtiMediaInteraction extends Interaction {
+    #private;
     static styles: CSSResultGroup;
+    reset(): void;
+    validate(): boolean;
+    get response(): string | null;
+    set response(val: string | null);
+    static get properties(): {
+        step: {
+            type: NumberConstructor;
+            attribute: string;
+            default: number;
+        };
+    };
     render(): lit.TemplateResult<1>;
+    constructor();
+    connectedCallback(): void;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'qti-media-interaction': QtiMediaInteraction;
+    }
 }
 
-declare class QtiPositionObjectStage extends LitElement {
+declare const QtiMatchInteraction_base: (abstract new (...args: any[]) => _qti_components_interactions_core_mixins_drag_drop_observables.DragDropSlottedSortable) & (abstract new (...args: any[]) => _qti_components_interactions_core_mixins_drag_drop_observables.DragDropSlotted) & typeof Interaction;
+/**
+ * Match interaction: candidates pair items from two sets, either as drag-and-drop or as a tabular grid.
+ *
+ * @customElement qti-match-interaction
+ *
+ * @attr {string} response-identifier - Required. Identifier of the bound response variable.
+ * @attr {number} [max-associations=0] - Maximum pairings across the whole interaction; `0`
+ *   means unlimited. QTI's own default is `1`; this element defaults to unlimited because a
+ *   literal `1` breaks any multi-pair match item. See plans/interaction-attribute-spec-conformance.md.
+ * @attr {number} [min-associations=1] - Minimum pairings for a valid response.
+ * @attr {boolean} [shuffle=false] - Requests shuffling of both match sets. Applied by the
+ *   transform pipeline (`qti-transformers`), not by this element.
+ * @attr {'qti-match-tabular'|'qti-choices-top'|'qti-choices-bottom'|'qti-choices-left'|'qti-choices-right'} class -
+ *   QTI shared presentation vocabulary. `qti-match-tabular` renders a checkbox/radio grid
+ *   instead of drag-and-drop; the `qti-choices-*` values position the source set.
+ * @attr {boolean} [auto-size-dropzones=false] - Extension, not QTI. Sizes every drop target to
+ *   the widest chip so placement does not reflow the layout. The mixin default is `true`; this
+ *   interaction is the one that overrides it to `false`, because a match target is a category card
+ *   rather than a socket (see the field below and DROP-SIZING.md §1).
+ * @attr {boolean} [disable-animations=false] - Extension, not QTI. Disables the FLIP move
+ *   animation.
+ *
+ * @slot prompt - The prompt shown above the interaction.
+ * @slot match-cols - Column headers (tabular mode).
+ * @slot match-rows - Row headers (tabular mode).
+ * @slot - Default slot for the two match sets (drag-and-drop mode).
+ *
+ * @csspart grid - The tabular grid container.
+ * @csspart corner - The top-left corner cell of the grid.
+ * @csspart cols-wrap - Wrapper row for the column headers.
+ * @csspart c-header - The column header slot wrapper.
+ * @csspart rows-wrap - Wrapper column for the row headers.
+ * @csspart r-header - The row header slot wrapper.
+ * @csspart checkbox-grid - The interactive cell grid area.
+ * @csspart input-cell - Each cell's label element.
+ * @csspart control - The visible checkbox/radio box (tabular mode). Also carries the variant
+ *   tokens `radio` | `checkbox`, `checked`, and `correct` | `incorrect` — e.g.
+ *   `::part(control radio checked correct)`. These mirror the custom-state vocabulary; the cells
+ *   are plain spans in the shadow root, so they cannot carry real `:state()`.
+ * @csspart control-mark - The inner mark element; carries the same variant tokens as `control`.
+ * @csspart message - Live validation message region (role="alert").
+ */
+declare class QtiMatchInteraction extends QtiMatchInteraction_base {
     static styles: CSSResultGroup;
-    choiceOrdering: boolean;
-    startX: any;
-    startY: any;
-    dragElement: any;
+    /**
+     * Match targets are categories, not slots. They should look able to hold several answers, so they
+     * take a flat floor (the `--qti-dropzone-min-height` fallback) rather than the size of the widest chip.
+     *
+     * This is a property of the INTERACTION, not of an individual target. A `match-max="1"` target is
+     * still a category that happens to take one answer, and it sits in a grid beside targets that take
+     * several — sizing each one to its own contents would make that grid ragged. So the whole
+     * interaction opts out, and the per-target `match-max` decides nothing about size here.
+     *
+     * The interactions where a drop IS a slot — gap-match, order, associate — keep measurement on, and
+     * their drops are exactly the widest chip plus the inset.
+     */
+    autoSizeDropzones: boolean;
+    protected sourceChoices: QtiSimpleAssociableChoice$1[];
+    protected targetChoices: QtiSimpleAssociableChoice$1[];
+    protected lastCheckedRadio: HTMLInputElement | null;
+    class: string;
+    protected _response: string | string[];
+    get response(): string[];
+    set response(val: string[]);
+    isDragDropEnabled(): boolean;
+    initiateDrag(...args: any[]): void;
+    afterCache(): void;
+    responseIdentifier: string;
+    connectedCallback(): Promise<void>;
+    protected willUpdate(changed: PropertyValues): void;
+    private syncTabularSlotting;
+    protected handleRadioClick: (e: {
+        target: HTMLInputElement;
+    }) => void;
+    protected handleRadioChange: (e: {
+        target: any;
+    }) => void;
+    validate(): boolean;
+    /** Extension hook for packages that add visual state tokens to tabular cells. */
+    protected getCellStateVariant(_value: string, _checked: boolean): string;
     render(): lit.TemplateResult<1>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'qti-match-interaction': QtiMatchInteraction;
+    }
+}
+
+interface OptionType {
+    content: string | Node[];
+    value: string;
+    selected: boolean;
+}
+declare const QtiInlineChoiceInteraction_base: (abstract new (...args: any[]) => _qti_components_interactions_core_mixins_menu_auto_size.MenuAutoSize) & typeof Interaction;
+/**
+ * Inline choice interaction: dropdown selector rendered inline with surrounding text.
+ *
+ * @customElement qti-inline-choice-interaction
+ *
+ * @attr {string} response-identifier - Required. Identifier of the bound response variable.
+ * @attr {string} data-prompt - Placeholder shown before a choice is picked. Falls back to
+ *   the item configuration's `inlineChoicePrompt`, then to `select`.
+ * @attr {boolean} [shuffle=false] - Requests option shuffling. Applied by the transform
+ *   pipeline (`qti-transformers`), not by this element.
+ * @attr {boolean} [required=false] - Whether a choice must be selected for the response to be
+ *   valid. Written as `required="true"` / `required="false"`; a bare `required` is accepted too.
+ * @attr {number} [min-choices=0] - Equivalent spelling of `required`: `1` demands an answer.
+ *   Absent from the QTI attribute table for this element but used by the conformance suite.
+ *
+ * @slot - Default slot for `qti-inline-choice` options.
+ *
+ * @csspart trigger - The dropdown trigger button.
+ * @csspart value - The currently displayed value inside the trigger.
+ * @csspart dropdown-icon - The chevron icon inside the trigger; also carries `dropdown-icon-open` when open.
+ * @csspart menu - The popover element containing the option list.
+ * @csspart option - Each option button; also carries `option-prompt` and `option-selected` variants.
+ * @csspart option-content - The content wrapper inside each option.
+ */
+declare class QtiInlineChoiceInteraction extends QtiInlineChoiceInteraction_base {
+    #private;
     constructor();
-    dragElementHandler(event: MouseEvent): void;
-    firstUpdated(a: PropertyValueMap<any>): void;
-    removeMoveListener(): void;
+    get isInline(): boolean;
+    static get styles(): lit.CSSResultGroup[];
+    protected options: OptionType[];
+    protected _dropdownOpen: boolean;
+    private _slotObserver;
+    private readonly _menuId;
+    configContext: ConfigContext;
+    /**
+     * Placeholder shown in the closed combobox before a choice is picked.
+     *
+     * Declared rather than read straight off `dataset` so it reaches the custom elements
+     * manifest, the generated types and the Storybook controls — and so that changing it
+     * re-renders, which reading `dataset` at render time never did.
+     *
+     * Falls back to the item configuration's `inlineChoicePrompt`, then to `select`.
+     */
+    dataPrompt: string;
+    protected _handleDataPromptChange: () => void;
+    /**
+     * Whether a choice must be selected for the response to be valid. QTI defaults this to
+     * false, so an untouched dropdown is a valid empty response unless an author opts in.
+     *
+     * QTI writes `required="true"` / `required="false"` rather than using HTML's bare-attribute
+     * boolean, so `required="false"` must read as false — which Lit's default Boolean converter
+     * would get backwards, since it only tests for the attribute's presence.
+     */
+    required: boolean;
+    /**
+     * Minimum selections for a valid response — in practice 0 or 1, since the dropdown holds one.
+     *
+     * Not in the QTI 3 Implementation Guide's attribute table for this element, which offers only
+     * `required`. It is in the conformance suite: `Advanced/Q12-inline-choice/inline-choice-sv-3`
+     * expresses "must answer" as `min-choices="1"`, and pairs it with `data-min-selections-message`.
+     * Authors reach for it because every sibling interaction takes it, so it is honoured here as an
+     * equivalent spelling of `required`.
+     */
+    minChoices: number;
+    protected _handleRequiredChange: () => void;
+    /** The closed combobox — the box showing the chosen option. */
+    protected renderTrigger(): unknown;
+    /** The popover listbox. */
+    protected renderMenu(): unknown;
+    /** Hidden until `Interaction.reportValidity` shows it. */
+    protected renderValidationMessage(): unknown;
+    render(): lit.TemplateResult<1>;
+    connectedCallback(): Promise<void>;
     disconnectedCallback(): void;
+    willUpdate(changed: PropertyValues<this>): void;
+    updated(changed: PropertyValues<this>): void;
+    /**
+     * Autosizing is opt-in through `configContext.inlineChoiceAutosize`, and an explicit
+     * `qti-input-width-*` class always wins.
+     *
+     * That second check has to live here rather than in CSS: the measurement is written as an inline
+     * style on the trigger, and the width classes set the same property on `:host`, so the cascade
+     * would hand it to the measurement every time. Not writing at all is what makes the class win.
+     */
+    shouldAutoSizeMenu(): boolean;
+    /**
+     * The chevron sits in the trigger and not in the menu, so the menu never measures it.
+     *
+     * `offsetWidth`, NOT `getBoundingClientRect().width`: the icon rotates when the menu opens, and a
+     * client rect reports the TRANSFORMED box — so a chevron caught mid-rotation measures wider than
+     * it is, and the trigger grew and shrank by a few pixels on every open. offsetWidth is the layout
+     * box and ignores the transform. (Same trap the drag-drop clone code documents for a chip picked
+     * up mid-animation.)
+     */
+    menuAutoSizeExtraWidth(): number;
+    validate(): boolean;
+    reportValidity(): boolean;
+    reset(): void;
+    /**
+     * Captures an attribute-set response before slotted options have been
+     * gathered. `#updateOptions` consumes it once the options exist.
+     * `undefined` = no pending value.
+     */
+    private _pendingResponse;
+    set response(value: string | null);
+    get response(): string | null;
 }
 declare global {
     interface HTMLElementTagNameMap {
-        'qti-position-object-stage': QtiPositionObjectStage;
+        'qti-inline-choice-interaction': QtiInlineChoiceInteraction;
     }
 }
 
-declare class QtiSelectPointInteraction extends Interaction {
-    #private;
+declare const QtiHottextInteraction_base: (abstract new (...args: any[]) => _qti_components_interactions_core_mixins_choices_choices_mixin.ChoicesInterface) & typeof Interaction;
+/**
+ * Hottext interaction: candidates select highlighted words within a text block.
+ *
+ * @customElement qti-hottext-interaction
+ *
+ * @attr {string} response-identifier - Required. Identifier of the bound response variable.
+ * @attr {number} [max-choices=1] - Maximum selectable hottexts; `0` means unlimited.
+ * @attr {number} [min-choices=0] - Minimum selectable hottexts for a valid response.
+ * @attr {'qti-unselected-hidden'} class - QTI shared presentation vocabulary.
+ *   `qti-unselected-hidden` leaves the selectable words visually indistinguishable from the
+ *   surrounding prose until they are selected.
+ *
+ * @slot - Default slot for the mixed content and `qti-hottext` choices.
+ *
+ * @csspart message - Live validation message region (role="alert").
+ */
+declare class QtiHottextInteraction extends QtiHottextInteraction_base {
     static styles: CSSResultGroup;
-    maxChoices: number;
-    minChoices: number;
-    response: string[] | null;
-    private _correctAreas;
-    private _responseCorrection;
+    render: () => lit.TemplateResult<1>;
+}
+
+/**
+ * A drop target positioned over an image. Like `qti-gap`, it renders the chips it holds from
+ * `dragDropContext` rather than having them appended into it.
+ *
+ * @csspart drop - The region a chip lands in.
+ */
+declare class QtiAssociableHotspot extends LitElement {
+    static styles: CSSResultGroup;
+    /** Carries `:state(filled)` while the hotspot holds a chip. */
+    internals: ElementInternals;
+    /** Opt-in marker read by `DragDropSlottedMixin`; see qti-gap. */
+    readonly acceptsDeclarativeDrops = true;
+    identifier: string;
+    private _dragDrop?;
+    /** The chips this hotspot holds. Stable node references, cloned once at drop time. */
+    get drags(): readonly HTMLElement[];
     connectedCallback(): void;
-    get responsePoints(): {
-        x: number;
-        y: number;
-    }[];
-    toggleCandidateCorrection(show: boolean): void;
-    toggleCorrectResponse(show: boolean): any;
-    updated(changedProperties: Map<string | number | symbol, unknown>): void;
     render(): lit.TemplateResult<1>;
-    validate(): boolean;
-    firstUpdated(): void;
-    disconnectedCallback(): void;
 }
 declare global {
     interface HTMLElementTagNameMap {
-        'qti-select-point-interaction': QtiSelectPointInteraction;
+        'qti-associable-hotspot': QtiAssociableHotspot;
     }
 }
 
-declare class QtiSliderInteraction extends Interaction {
+/**
+ * A gap in the prose, and the first drop target to render its own chips.
+ *
+ * The interaction owns placement and publishes it on `dragDropContext`; this element subscribes and
+ * renders what it holds. Nothing appends into it. That inverts the old flow, where `handleDrop` did
+ * `cloneNode` + `appendChild` and the response was recovered afterwards by reading the DOM back
+ * out — which is why placement and the response could ever disagree at all.
+ *
+ * The chips land in this shadow root rather than in the light DOM, so a theme reaches them as
+ * `::part(drag)` — a bare `::part()` matches in any shadow root — instead of by tag. The gap's own
+ * `:state(filled)` says whether it holds anything.
+ *
+ * @customElement qti-gap
+ *
+ * @attr {string} identifier - Required. Value recorded as the gap side of the response pair.
+ * @attr {number} [match-max=1] - How many tokens this gap can hold; `0` means unlimited. Read
+ *   from the DOM by the drag-drop mixin.
+ * @attr {number} [match-min=0] - Minimum tokens this gap must hold.
+ * @attr {boolean} [required=false] - Not implemented. Whether this gap must be filled for the
+ *   response to be valid.
+ * @attr {string} template-identifier - Not implemented. Identifier of a template variable
+ *   controlling this gap's visibility.
+ * @attr {'show'|'hide'} [show-hide=show] - Not implemented. How `template-identifier` controls
+ *   visibility.
+ *
+ * @csspart drop - The region a chip lands in. Reserves the widest chip's box; see qti-gap.styles.
+ */
+declare class QtiGap extends LitElement {
+    static styles: CSSResultGroup;
+    /** Carries `:state(filled)` while the gap holds a chip. */
+    internals: ElementInternals;
+    /**
+     * Opt-in marker, read by `DragDropSlottedMixin`. While this is true the interaction keeps this
+     * target's chips in its placement map and never touches this element's children.
+     */
+    readonly acceptsDeclarativeDrops = true;
+    tabindex: number | undefined;
+    identifier: string;
+    private _dragDrop?;
+    /** The chips this gap holds. Stable node references, cloned once at drop time by the interaction. */
+    get drags(): readonly HTMLElement[];
+    render(): lit.TemplateResult<1>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'qti-gap': QtiGap;
+    }
+}
+
+declare class QtiGapImg extends LitElement {
+    static styles: CSSResultGroup;
+    tabindex: number | undefined;
+    /**
+     * `qti-gap-img` is a draggable chip, so it needs ElementInternals to carry the drag states
+     * (`dragging`, `placeholder`). It works without a shadow root.
+     *
+     * NOTE: this element never calls `super.connectedCallback()`, so Lit never enables updating
+     * and it has no shadow root — which makes `qti-gap-img.styles.ts` dead code. Fixing that means
+     * adding a `<slot>` to a `render()` first, otherwise the authored `<img>` child disappears.
+     */
+    internals: ElementInternals;
+    connectedCallback(): void;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'qti-gap-img': QtiGapImg;
+    }
+}
+
+declare const QtiHotspotChoice_base: (abstract new (...args: any[]) => ActiveElementMixinInterface) & typeof LitElement;
+declare class QtiHotspotChoice extends QtiHotspotChoice_base {
+    static styles: CSSResultGroup;
+    order: number;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'qti-hotspot-choice': QtiHotspotChoice;
+    }
+}
+
+declare const QtiHottext_base: (abstract new (...args: any[]) => ActiveElementMixinInterface) & typeof LitElement;
+/**
+ * A selectable span of text inside `qti-hottext-interaction`.
+ *
+ * @customElement qti-hottext
+ *
+ * @attr {string} identifier - Required. Value recorded in the response when this span is
+ *   selected.
+ * @attr {string} template-identifier - Not implemented. Identifier of a template variable
+ *   controlling this span's visibility.
+ * @attr {'show'|'hide'} [show-hide=show] - Not implemented. How `template-identifier` controls
+ *   visibility.
+ */
+declare class QtiHottext extends QtiHottext_base {
+    static styles: CSSResultGroup;
+    render(): lit.TemplateResult<1>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'qti-hottext': QtiHottext;
+    }
+}
+
+declare class QtiPrompt extends LitElement {
+    static styles: CSSResultGroup;
+    render(): lit.TemplateResult<1>;
+    connectedCallback(): void;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'qti-prompt': QtiPrompt;
+    }
+}
+
+declare const QtiSimpleAssociableChoice_base: (abstract new (...args: any[]) => ActiveElementMixinInterface) & typeof LitElement;
+/**
+ * A choice in one of the two match sets of `qti-match-interaction`, or in
+ * `qti-associate-interaction`.
+ *
+ * @customElement qti-simple-associable-choice
+ *
+ * @attr {string} identifier - Required. Value recorded in the response pair when this choice
+ *   participates in an association.
+ * @attr {number} [match-max=1] - How many associations this choice may take part in; `0` means
+ *   unlimited. On a target this is its capacity — the bucket size in a sorting item.
+ * @attr {number} [match-min=0] - Minimum associations this choice must take part in.
+ * @attr {boolean} [fixed=false] - Pins this choice in place when the enclosing interaction is
+ *   shuffled.
+ * @attr {string} template-identifier - Not implemented. Identifier of a template variable
+ *   controlling this choice's visibility.
+ * @attr {'show'|'hide'} [show-hide=show] - Not implemented. How `template-identifier` controls
+ *   visibility.
+ */
+declare class QtiSimpleAssociableChoice extends QtiSimpleAssociableChoice_base {
+    static styles: CSSResultGroup;
+    /** the minimal number of selections a candidate must make */
+    matchMin: number;
+    /** the maximum number of selections a candidate must make, the other options will be disabled when max options is checked */
+    matchMax: number;
+    fixed: boolean;
+    connectedCallback(): void;
+    /** Opt-in marker read by `DragDropSlottedMixin`; see qti-gap. */
+    readonly acceptsDeclarativeDrops = true;
+    private _dragDrop?;
+    /** The chips this choice holds when it acts as a drop target (match-interaction's second set). */
+    get drags(): readonly HTMLElement[];
+    render(): lit.TemplateResult<1>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'qti-simple-associable-choice': QtiSimpleAssociableChoice;
+    }
+}
+
+declare const QtiSimpleChoice_base: (abstract new (...args: any[]) => ActiveElementMixinInterface) & typeof LitElement;
+/**
+ * A choice, used by `qti-choice-interaction` and `qti-order-interaction`.
+ *
+ * The `control` part is one box whose *role* is carried by state, not by its name: a radio
+ * circle under `:state(radio)`, a checkbox square under `:state(checkbox)`, and a drag grip
+ * when the choice is draggable. Style it as `qti-simple-choice::part(control)`.
+ *
+ * @customElement qti-simple-choice
+ *
+ * @attr {string} identifier - Required. Value recorded in the response when this choice is
+ *   selected, or its position when used for ordering.
+ * @attr {boolean} [fixed=false] - Pins this choice in place when the enclosing interaction is
+ *   shuffled.
+ * @attr {string} template-identifier - Identifier of a template variable controlling this
+ *   choice's visibility.
+ * @attr {'show'|'hide'} [show-hide=show] - How `template-identifier` controls visibility.
+ *
+ * @csspart control - The box before the label (radio / checkbox / drag grip).
+ * @csspart control-mark - The mark inside the box (inner dot / checkmark).
+ * @csspart label - The default slot holding the choice content.
+ * @csspart marker - The order-number badge, when `marker` is set.
+ */
+declare class QtiSimpleChoice extends QtiSimpleChoice_base {
+    static styles: CSSResultGroup;
+    static shadowRootOptions: ShadowRootInit;
+    templateIdentifier: string | null;
+    showHide: string | null;
+    fixed: boolean;
+    marker: string;
+    get checked(): boolean;
+    render(): lit.TemplateResult<1>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'qti-simple-choice': QtiSimpleChoice;
+    }
+}
+
+/**
+ * A mixin that adds choice functionality to a LitElement-based class.
+ * It dispatches events with a custom `type` and handles selection logic.
+ *
+ * @param Base - The base class to extend.
+ * @param type - The type of the choice, used in event names.
+ * @returns A new class extending the base class with choice functionality.
+ */
+interface ActiveElementMixinInterface {
+    identifier: string;
+    tabIndex: number;
+    disabled: boolean;
+    readonly: boolean;
+    internals: ElementInternals;
+}
+
+interface ChoicesInterface extends ValidatableInteraction {
+    minChoices: number;
+    maxChoices: number;
+    value: string | null;
+    response: string | string[] | null;
+}
+
+declare const QtiInlineChoice_base: (abstract new (...args: any[]) => ActiveElementMixinInterface) & typeof LitElement;
+/**
+ * An option in the dropdown of `qti-inline-choice-interaction`.
+ *
+ * @customElement qti-inline-choice
+ *
+ * @attr {string} identifier - Required. Value recorded in the response when this option is
+ *   selected.
+ * @attr {boolean} [fixed=false] - Pins this option in place when the interaction is shuffled.
+ * @attr {string} template-identifier - Not implemented. Identifier of a template variable
+ *   controlling this option's visibility.
+ * @attr {'show'|'hide'} [show-hide=show] - Not implemented. How `template-identifier` controls
+ *   visibility.
+ */
+declare class QtiInlineChoice extends QtiInlineChoice_base {
     #private;
     static styles: CSSResultGroup;
-    private _rail;
-    min: number;
-    max: number;
-    step: number;
-    validate(): boolean;
+    identifier: string;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    render(): lit.TemplateResult<1>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'qti-inline-choice': QtiInlineChoice;
+    }
+}
+
+declare const QtiGapText_base: (abstract new (...args: any[]) => ActiveElementMixinInterface) & typeof LitElement;
+/**
+ * A draggable text token that fills a `qti-gap` inside `qti-gap-match-interaction`.
+ *
+ * @customElement qti-gap-text
+ *
+ * @attr {string} identifier - Required. Value recorded in the response pair when this token is
+ *   placed into a gap.
+ * @attr {number} [match-max=1] - How many gaps this token may fill; `0` means unlimited.
+ *   Read from the DOM by the drag-drop mixin.
+ * @attr {number} [match-min=0] - Minimum gaps this token must fill.
+ * @attr {boolean} [fixed=false] - Pins this token in place when the interaction is shuffled.
+ * @attr {string} template-identifier - Not implemented. Identifier of a template variable
+ *   controlling this token's visibility.
+ * @attr {'show'|'hide'} [show-hide=show] - Not implemented. How `template-identifier` controls
+ *   visibility.
+ */
+declare class QtiGapText extends QtiGapText_base {
+    static styles: CSSResultGroup;
+    tabindex: number | undefined;
     connectedCallback(): void;
-    get response(): string;
-    set response(val: string);
-    toggleCorrectResponse(show: boolean): void;
     render(): lit.TemplateResult<1>;
 }
 declare global {
     interface HTMLElementTagNameMap {
-        'qti-slider-interaction': QtiSliderInteraction;
+        'qti-gap-text': QtiGapText;
     }
 }
 
-declare class QtiTextEntryInteraction extends Interaction {
+declare const QtiHotspotInteraction_base: (abstract new (...args: any[]) => ChoicesInterface) & typeof Interaction;
+/**
+ * Hotspot interaction: candidates select one or more hotspots on an image.
+ *
+ * @slot prompt - The prompt shown above the image.
+ * @slot - Default slot for the image and hotspot choices.
+ */
+declare class QtiHotspotInteraction extends QtiHotspotInteraction_base {
     #private;
     static styles: CSSResultGroup;
-    inputRef: lit_directives_ref_js.Ref<HTMLInputElement>;
-    expectedLength: number;
-    patternMask: string;
-    placeholderText: string;
-    dataPatternmaskMessage: string;
-    response: string | null;
-    private _input;
-    protected _handleValueChange: () => void;
-    get value(): string | null;
-    set value(val: string | null);
-    get correctness(): Readonly<Correctness | null>;
-    get isInline(): boolean;
-    validate(): boolean;
-    toggleInternalCorrectResponse(show: boolean): void;
     render(): lit.TemplateResult<1>;
-    protected textChanged(event: Event): void;
-    reportValidity(): boolean;
-    reset(): void;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
 }
 declare global {
     interface HTMLElementTagNameMap {
-        'qti-text-entry-interaction': QtiTextEntryInteraction;
+        'qti-hotspot-interaction': QtiHotspotInteraction;
     }
 }
 
-declare class QtiUploadInteraction extends Interaction {
+type HotspotChoice = Choice & {
+    order: number;
+};
+declare const QtiGraphicOrderInteraction_base: (abstract new (...args: any[]) => ChoicesInterface) & typeof Interaction;
+/**
+ * Graphic order interaction: candidates order hotspots on an image.
+ *
+ * @slot prompt - The prompt shown above the image.
+ * @slot - Default slot for the image and hotspot choices.
+ *
+ * @csspart message - Live validation message region (role="alert").
+ */
+declare class QtiGraphicOrderInteraction extends QtiGraphicOrderInteraction_base {
     #private;
     static styles: CSSResultGroup;
-    reset(): void;
-    validate(): boolean;
-    get response(): string | null;
-    set response(base64: string | null);
-    static get properties(): {
-        [key: string]: lit.PropertyDeclaration<unknown, unknown>;
-    };
+    protected choiceOrdering: boolean;
+    protected _choiceElements: Choice[];
     render(): lit.TemplateResult<1>;
+    /** Extension hook for packages that add semantic color states to locator pins. */
+    protected resolvePinColor(_choice: HotspotChoice): string;
+    protected refreshLocatorPins(): void;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
 }
 declare global {
     interface HTMLElementTagNameMap {
-        'qti-upload-interaction': QtiUploadInteraction;
+        'qti-graphic-order-interaction': QtiGraphicOrderInteraction;
     }
 }
 
-declare class QtiGapImg extends LitElement {
+declare const QtiGraphicGapMatchInteraction_base: (abstract new (...args: any[]) => _qti_components_interactions_core_mixins_drag_drop_observables.DragDropSlottedSortable) & (abstract new (...args: any[]) => _qti_components_interactions_core_mixins_drag_drop_observables.DragDropSlotted) & typeof Interaction;
+/**
+ * Graphic gap-match interaction: candidates drag choices onto image hotspots.
+ *
+ * @slot prompt - The prompt shown above the image.
+ * @slot drags - The draggable choice sources.
+ * @slot - Default slot for the base image and hotspots.
+ *
+ * @csspart image - Wrapper around the image slot.
+ * @csspart drags - Wrapper around the drag sources slot.
+ * @csspart message - Live validation message region (role="alert").
+ */
+declare class QtiGraphicGapMatchInteraction extends QtiGraphicGapMatchInteraction_base {
+    #private;
     static styles: CSSResultGroup;
-    tabindex: number | undefined;
+    render(): lit.TemplateResult<1>;
+    shouldReturnToInventoryOnInventoryDrop(): boolean;
     connectedCallback(): void;
+    disconnectedCallback(): void;
 }
 declare global {
     interface HTMLElementTagNameMap {
-        'qti-gap-img': QtiGapImg;
+        'qti-graphic-gap-match-interaction': QtiGraphicGapMatchInteraction;
     }
 }
 
-declare const QtiGapText_base: (abstract new (...args: any[]) => ActiveElementMixinInterface) & typeof LitElement;
-declare class QtiGapText extends QtiGapText_base {
+/**
+ * Graphic associate interaction: candidates connect points/hotspots on an image with lines.
+ *
+ * @slot prompt - The prompt shown above the image.
+ * @slot - Default slot for hotspot choices layered over the image.
+ *
+ * @csspart line - Each line drawn by the candidate.
+ * @csspart correct-line - Each line displayed as part of the correct response.
+ * @csspart point - Each in-progress endpoint indicator.
+ * @csspart message - Live validation message region (role="alert").
+ */
+declare class QtiGraphicAssociateInteraction extends Interaction {
+    #private;
     static styles: CSSResultGroup;
-    tabindex: number | undefined;
-    connectedCallback(): void;
+    private startCoord;
+    private mouseCoord;
+    grImage: any[];
+    private _response;
+    constructor();
+    reset(): void;
+    validate(): boolean;
+    set response(val: string | string[] | null);
+    get response(): string[] | null;
+    /** Extension hook for optional SVG lines rendered above the candidate response. */
+    protected renderSupplementalLines(): unknown;
     render(): lit.TemplateResult<1>;
+    firstUpdated(): void;
+    disconnectedCallback(): void;
 }
 declare global {
     interface HTMLElementTagNameMap {
-        'qti-gap-text': QtiGapText;
+        'qti-graphic-associate-interaction': QtiGraphicAssociateInteraction;
     }
 }
 
-declare class QtiGap extends LitElement {
+declare const QtiGapMatchInteraction_base: (abstract new (...args: any[]) => _qti_components_interactions_core_mixins_drag_drop_observables.DragDropSlottedSortable) & (abstract new (...args: any[]) => _qti_components_interactions_core_mixins_drag_drop_observables.DragDropSlotted) & typeof Interaction;
+/**
+ * Drag-and-drop gap-match interaction: candidates drag choices into gap targets.
+ *
+ * @customElement qti-gap-match-interaction
+ *
+ * @attr {string} response-identifier - Required. Identifier of the bound response variable.
+ * @attr {number} [max-associations=1] - Maximum gaps that may be filled across the whole
+ *   interaction; `0` means unlimited.
+ * @attr {number} [min-associations=1] - Minimum filled gaps for a valid response.
+ * @attr {boolean} [shuffle=false] - Requests shuffling of the `qti-gap-text` sources. Applied
+ *   by the transform pipeline (`qti-transformers`), not by this element.
+ * @attr {'qti-choices-top'|'qti-choices-bottom'|'qti-choices-left'|'qti-choices-right'} class -
+ *   QTI shared presentation vocabulary positioning the gap-choices container.
+ * @attr {boolean} [auto-size-dropzones=true] - Extension, not QTI. Sizes every gap to the
+ *   widest chip so placement does not reflow the prose. On by default: a gap is a slot, and a slot
+ *   that is already the size of the chip it will hold does not resize when one lands in it.
+ * @attr {boolean} [disable-animations=false] - Extension, not QTI. Disables the FLIP move
+ *   animation.
+ *
+ * @slot prompt - The prompt shown above the interaction.
+ * @slot drags - The draggable choice sources.
+ * @slot - Default slot for the drop targets (gaps).
+ *
+ * @csspart drags - Wrapper around the drag sources slot.
+ * @csspart drops - Wrapper around the drop targets slot.
+ * @csspart message - Live validation message region (role="alert").
+ */
+declare class QtiGapMatchInteraction extends QtiGapMatchInteraction_base {
     static styles: CSSResultGroup;
-    tabindex: number | undefined;
     render(): lit.TemplateResult<1>;
 }
 declare global {
     interface HTMLElementTagNameMap {
-        'qti-gap': QtiGap;
+        'qti-gap-match-interaction': QtiGapMatchInteraction;
     }
 }
 
-declare const QtiInlineChoice_base: (abstract new (...args: any[]) => ActiveElementMixinInterface) & typeof LitElement;
-declare class QtiInlineChoice extends QtiInlineChoice_base {
+/**
+ * A multi-line text-entry interaction.
+ *
+ * @customElement qti-extended-text-interaction
+ *
+ * @attr {string} response-identifier - Required. Identifier of the bound response variable.
+ * @attr {number} expected-length - Hint at the expected answer length in characters; sets the
+ *   textarea's `maxlength`. Also the last-resort row count, used only when neither a
+ *   `qti-height-lines-*` class nor `expected-lines` is present.
+ * @attr {string} pattern-mask - Regular expression the value must match to be valid.
+ * @attr {string} placeholder-text - Placeholder shown while the textarea is empty.
+ * @attr {string} data-patternmask-message - Custom validation message shown when
+ *   `pattern-mask` fails. Part of the QTI shared interaction vocabulary.
+ * @attr {'qti-height-lines-3'|'qti-height-lines-6'|'qti-height-lines-15'} class - QTI shared
+ *   presentation vocabulary controlling the rendered height. Outranks both `expected-lines`
+ *   and `expected-length`.
+ * @attr {number} expected-lines - Expected number of lines of response, and the rendered row
+ *   count unless a `qti-height-lines-*` class is present.
+ * @attr {number} [base=10] - Not implemented. Numeric base used when recording the value.
+ * @attr {string} string-identifier - Not implemented. Identifier of a second, string-typed
+ *   response variable that also receives the raw entry.
+ * @attr {number} max-strings - Not implemented. Maximum number of separate string responses. QTI
+ *   defines these for a multi-string response — several bound variables, one field each. This
+ *   element renders a single textarea bound to one variable, so there is nothing for the bounds
+ *   to count: reading them as a word or paragraph limit would invent a rule QTI does not state.
+ *   Implement alongside multi-string rendering, not before it.
+ * @attr {number} min-strings - Not implemented. See `max-strings`.
+ * @attr {'plain'|'preformatted'|'xhtml'} [format=plain] - How the response is presented.
+ *   `preformatted` renders the field monospaced; `xhtml` is accepted but downgraded to plain,
+ *   because the field is a textarea with no rich-text editor behind it.
+ *
+ * @slot prompt - The prompt shown above the textarea.
+ *
+ * @csspart textarea - The textarea input element.
+ */
+declare class QtiExtendedTextInteraction extends Interaction {
     #private;
     static styles: CSSResultGroup;
-    identifier: string;
-    connectedCallback(): void;
-    disconnectedCallback(): void;
+    protected _rows: number;
+    /** expected length is mapped to the property maxlength on the textarea */
+    expectedLength: number;
+    /** QTI's own hint at the response height. Outranked by `qti-height-lines-*`; see `#resolveRows`. */
+    expectedLines: number;
+    /**
+     * How the response text is presented. Reflected so themes can key off
+     * `:host([format='preformatted'])`.
+     *
+     * `xhtml` is accepted and recorded but renders as `plain`: the field is a `<textarea>`, and
+     * there is no rich-text editor behind it. Downgrading loudly beats either refusing valid QTI
+     * or pretending to support formatting the candidate cannot actually produce.
+     */
+    format: 'plain' | 'preformatted' | 'xhtml';
+    protected _handleFormatChange: () => void;
+    patternMask: string;
+    /** text appearing in the extended-text-interaction if it is empty */
+    placeholderText: string;
+    dataPatternmaskMessage: string;
+    classNames: string;
+    protected _handleRowsInputChange(): void;
+    response: string | null;
+    protected _handleResponseChange: () => void;
+    get value(): string | null;
+    set value(val: string | null);
+    validate(): boolean;
+    reportValidity(): boolean;
+    /** The prompt, above the field. */
+    protected renderPrompt(): unknown;
+    /** The field itself. */
+    protected renderTextarea(): unknown;
+    /** Hidden until `Interaction.reportValidity` shows it. */
+    protected renderValidationMessage(): unknown;
     render(): lit.TemplateResult<1>;
+    protected textChanged(event: Event): void;
 }
 declare global {
     interface HTMLElementTagNameMap {
-        'qti-inline-choice': QtiInlineChoice;
+        'qti-extended-text-interaction': QtiExtendedTextInteraction;
     }
 }
 
-declare const QtiHottext_base: (abstract new (...args: any[]) => ActiveElementMixinInterface) & typeof LitElement;
-declare class QtiHottext extends QtiHottext_base {
+/**
+ * A button that ends the current attempt.
+ *
+ * @csspart button - The end-attempt button element.
+ */
+declare class QtiEndAttemptInteraction extends LitElement {
     static styles: CSSResultGroup;
+    responseIdentifier: string;
+    disabled: boolean;
+    /** Defines the number of attempts that a user can make using the 'endAttemptInteraction' mechanism (this can be used to limit the number of hints, etc.). [More information](https://www.imsglobal.org/sites/default/files/spec/qti/v3/info/index.html#DataCharacteristic_EndAttemptInteraction.Attr_count-attempt) */
+    countAttempt: 'true' | 'false' | null;
+    title: string;
     render(): lit.TemplateResult<1>;
+    endAttempt(_: Event): void;
 }
 declare global {
     interface HTMLElementTagNameMap {
-        'qti-hottext': QtiHottext;
+        'qti-end-attempt-interaction': QtiEndAttemptInteraction;
     }
 }
 
-declare const QtiSimpleChoice_base: (abstract new (...args: any[]) => ActiveElementMixinInterface) & typeof LitElement;
 /**
- * qti-order-interaction
- * qti-choice-interaction
+ * QTI Custom Interaction component for legacy CES-based interactions.
+ *
+ * This component implements support for custom interactions originally built for the CES
+ * (Custom Element Standard) player - the predecessor to FACET and the Trifork QTI Player.
+ *
+ * @remarks
+ * The interaction workflow:
+ * 1. Fetch the CI manifest (JSON file with script, style, media references)
+ * 2. Check if bootstrap.js uses the CES API
+ * 3. If CES is used:
+ *    - Fetch index.html from main window (where service worker/fetch works)
+ *    - Inject registerCES proxy script for postMessage-based communication
+ *    - Create blob URL and pass it to ciBootstrap
+ * 4. Create pciContainer iframe with style and bootstrap script
+ * 5. Handle postMessage events for getMedia, getResponse, setResponse, getBlobUrl
+ *
+ * The postMessage bridge is necessary because:
+ * - Iframes created via document.write() have about:blank origin
+ * - They cannot access the parent's global CES object (cross-origin)
+ * - Service workers don't control about:blank documents
+ *
+ * Messages are sent to all parent windows to support embedding scenarios like Storybook
+ * where window.top might not be the actual host application.
  */
-declare class QtiSimpleChoice extends QtiSimpleChoice_base {
+declare class QtiCustomInteraction extends Interaction {
+    #private;
     static styles: CSSResultGroup;
-    templateIdentifier: string | null;
-    showHide: string | null;
-    fixed: boolean;
-    marker: string;
-    get checked(): boolean;
+    constructor();
+    data: string;
+    baseItemUrl: string;
+    baseRefUrl: string;
+    id: string;
+    private _errorMessage;
+    manifest: {
+        script: string[];
+        style: string[];
+        media: string[];
+    };
+    connectedCallback(): void;
+    /**
+     * Sets up the CES custom interaction by creating the iframe structure and
+     * handling the CES API communication via postMessage.
+     *
+     * For interactions that use CES, this method:
+     * 1. Fetches the original bootstrap.js and checks if it uses CES
+     * 2. If CES is used, fetches index.html and injects the registerCES proxy
+     * 3. Creates a blob URL for the modified HTML (stored in _contentBlobUrl)
+     * 4. Replaces bootstrap.js with ciBootstrap that loads the blob URL
+     * 5. Sets up postMessage listeners for CES API calls
+     */
+    setupCES(): Promise<void>;
+    handlePostMessage(event: MessageEvent): void;
+    validate(): boolean;
+    get response(): string | string[] | null;
+    set response(val: string | string[] | null);
+    disconnectedCallback(): void;
     render(): lit.TemplateResult<1>;
 }
 declare global {
     interface HTMLElementTagNameMap {
-        'qti-simple-choice': QtiSimpleChoice;
-    }
-}
-
-declare const QtiHotspotChoice_base: (abstract new (...args: any[]) => ActiveElementMixinInterface) & typeof LitElement;
-declare class QtiHotspotChoice extends QtiHotspotChoice_base {
-    static styles: CSSResultGroup;
-    order: number;
-    orderCorrect: number;
-}
-declare global {
-    interface HTMLElementTagNameMap {
-        'qti-hotspot-choice': QtiHotspotChoice;
+        'qti-custom-interaction': QtiCustomInteraction;
     }
 }
 
-declare class QtiAssociableHotspot extends LitElement {
+type Orientation = 'horizontal' | 'vertical' | undefined;
+declare const QtiChoiceInteraction_base: (abstract new (...args: any[]) => {}) & (abstract new (...args: any[]) => ChoicesInterface$1) & typeof Interaction;
+/**
+ * A single-response or multiple-response choice interaction.
+ *
+ * @customElement qti-choice-interaction
+ *
+ * @attr {string} response-identifier - Required. Identifier of the bound response variable.
+ * @attr {number} [max-choices=1] - Maximum selectable choices. `1` is a single-response
+ *   item; `0` means unlimited and makes it a multiple-response item.
+ * @attr {number} [min-choices=0] - Minimum selectable choices for a valid response.
+ * @attr {'horizontal'|'vertical'} [orientation=vertical] - Deprecated by QTI in favour of
+ *   the `qti-orientation-*` class vocabulary.
+ * @attr {boolean} [shuffle=false] - Requests choice shuffling. Applied by the transform
+ *   pipeline (`qti-transformers`), not by this element.
+ * @attr {'qti-orientation-horizontal'|'qti-orientation-vertical'|'qti-choices-stacking-1'|'qti-choices-stacking-2'|'qti-choices-stacking-3'|'qti-choices-stacking-4'|'qti-choices-stacking-5'|'qti-labels-none'|'qti-labels-decimal'|'qti-labels-lower-alpha'|'qti-labels-upper-alpha'|'qti-labels-suffix-none'|'qti-labels-suffix-period'|'qti-labels-suffix-parenthesis'|'qti-input-control-hidden'} class - QTI shared presentation vocabulary. Space-separated; takes precedence over `orientation`.
+ *
+ * @slot prompt - The prompt shown above the choices.
+ * @slot - Default slot for `qti-simple-choice` elements.
+ *
+ * @csspart prompt - Wrapper around the prompt slot.
+ * @csspart slot - Wrapper around the default slot containing the choices.
+ * @csspart message - Live validation message region (role="alert").
+ */
+declare class QtiChoiceInteraction extends QtiChoiceInteraction_base implements ChoicesInterface$1 {
+    #private;
     static styles: CSSResultGroup;
-    connectedCallback(): void;
+    /** @deprecated, use 'qti-orientation-horizontal' or 'qti-orientation-vertical' instead */
+    orientation: Orientation;
     render(): lit.TemplateResult<1>;
 }
 declare global {
     interface HTMLElementTagNameMap {
-        'qti-associable-hotspot': QtiAssociableHotspot;
+        'qti-choice-interaction': QtiChoiceInteraction;
     }
 }
 
-declare class QtiPrompt extends LitElement {
+declare const QtiAssociateInteraction_base: (abstract new (...args: any[]) => _qti_components_interactions_core_mixins_drag_drop_observables.DragDropSlottedSortable) & (abstract new (...args: any[]) => _qti_components_interactions_core_mixins_drag_drop_observables.DragDropSlotted) & typeof Interaction;
+/**
+ * Drag-and-drop associate interaction: candidates pair associable choices.
+ *
+ * @slot prompt - The prompt shown above the choices.
+ * @slot qti-simple-associable-choice - The associable choice sources.
+ *
+ * @csspart drags - Wrapper around the associable choice slot.
+ * @csspart drops - The container holding all drop targets.
+ * @csspart drop-row - Container for one left/right drop pair.
+ * @csspart drop - Each individual drop target.
+ * @csspart message - Live validation message region (role="alert").
+ */
+declare class QtiAssociateInteraction extends QtiAssociateInteraction_base {
+    #private;
     static styles: CSSResultGroup;
+    protected _childrenMap: Element[];
+    protected _registerChoiceHandler: (event: CustomEvent) => void;
+    constructor();
+    protected _registerChoice(event: CustomEvent): void;
+    protected getResponse(): string[];
+    /**
+     * How many associations the candidate has made.
+     *
+     * The mixin counts placed chips, which is right for gap-match — one chip in one gap is one
+     * association — and wrong here. An association is a *pair*, so three associations are six chips,
+     * and `max-associations="3"` compared 6 against 3 and declared the item invalid the moment it was
+     * correctly filled in.
+     *
+     * A half-filled row is not an association yet, and `getResponse()` already knows that: it emits a
+     * pair only when both sides hold a chip. Counting its entries counts associations by definition,
+     * and keeps the number validation sees equal to the number the response reports.
+     */
+    totalAssociationsFromState(): number;
+    getValue(val: string[]): string[];
     render(): lit.TemplateResult<1>;
-    connectedCallback(): void;
+    protected updated(changedProperties: Map<string, unknown>): void;
+    disconnectedCallback(): void;
 }
 declare global {
     interface HTMLElementTagNameMap {
-        'qti-prompt': QtiPrompt;
+        'qti-associate-interaction': QtiAssociateInteraction;
     }
 }
 
-export { type Orientation, QtiAssociableHotspot, QtiAssociateInteraction, QtiChoiceInteraction, QtiCustomInteraction, QtiEndAttemptInteraction, QtiExtendedTextInteraction, QtiGap, QtiGapImg, QtiGapMatchInteraction, QtiGapText, QtiGraphicAssociateInteraction, QtiGraphicGapMatchInteraction, QtiGraphicOrderInteraction, QtiHotspotChoice, QtiHotspotInteraction, QtiHottext, QtiHottextInteraction, QtiInlineChoice, QtiInlineChoiceInteraction, QtiMatchInteraction, QtiMediaInteraction, QtiOrderInteraction, QtiPortableCustomInteraction, QtiPositionObjectInteraction, QtiPositionObjectStage, QtiPrompt, QtiSelectPointInteraction, QtiSimpleAssociableChoice, QtiSimpleChoice, QtiSliderInteraction, QtiTextEntryInteraction, QtiUploadInteraction };
+declare const qtiInteractionElements: readonly [{
+    readonly tag: "qti-associable-hotspot";
+    readonly ctor: typeof QtiAssociableHotspot;
+}, {
+    readonly tag: "qti-gap";
+    readonly ctor: typeof QtiGap;
+}, {
+    readonly tag: "qti-gap-img";
+    readonly ctor: typeof QtiGapImg;
+}, {
+    readonly tag: "qti-gap-text";
+    readonly ctor: typeof QtiGapText;
+}, {
+    readonly tag: "qti-hotspot-choice";
+    readonly ctor: typeof QtiHotspotChoice;
+}, {
+    readonly tag: "qti-hottext";
+    readonly ctor: typeof QtiHottext;
+}, {
+    readonly tag: "qti-inline-choice";
+    readonly ctor: typeof QtiInlineChoice;
+}, {
+    readonly tag: "qti-prompt";
+    readonly ctor: typeof QtiPrompt;
+}, {
+    readonly tag: "qti-simple-associable-choice";
+    readonly ctor: typeof QtiSimpleAssociableChoice;
+}, {
+    readonly tag: "qti-simple-choice";
+    readonly ctor: typeof QtiSimpleChoice;
+}, {
+    readonly tag: "qti-associate-interaction";
+    readonly ctor: typeof QtiAssociateInteraction;
+}, {
+    readonly tag: "qti-choice-interaction";
+    readonly ctor: typeof QtiChoiceInteraction;
+}, {
+    readonly tag: "qti-custom-interaction";
+    readonly ctor: typeof QtiCustomInteraction;
+}, {
+    readonly tag: "qti-end-attempt-interaction";
+    readonly ctor: typeof QtiEndAttemptInteraction;
+}, {
+    readonly tag: "qti-extended-text-interaction";
+    readonly ctor: typeof QtiExtendedTextInteraction;
+}, {
+    readonly tag: "qti-gap-match-interaction";
+    readonly ctor: typeof QtiGapMatchInteraction;
+}, {
+    readonly tag: "qti-graphic-associate-interaction";
+    readonly ctor: typeof QtiGraphicAssociateInteraction;
+}, {
+    readonly tag: "qti-graphic-gap-match-interaction";
+    readonly ctor: typeof QtiGraphicGapMatchInteraction;
+}, {
+    readonly tag: "qti-graphic-order-interaction";
+    readonly ctor: typeof QtiGraphicOrderInteraction;
+}, {
+    readonly tag: "qti-hotspot-interaction";
+    readonly ctor: typeof QtiHotspotInteraction;
+}, {
+    readonly tag: "qti-hottext-interaction";
+    readonly ctor: typeof QtiHottextInteraction;
+}, {
+    readonly tag: "qti-inline-choice-interaction";
+    readonly ctor: typeof QtiInlineChoiceInteraction;
+}, {
+    readonly tag: "qti-match-interaction";
+    readonly ctor: typeof QtiMatchInteraction;
+}, {
+    readonly tag: "qti-media-interaction";
+    readonly ctor: typeof QtiMediaInteraction;
+}, {
+    readonly tag: "qti-order-interaction";
+    readonly ctor: typeof QtiOrderInteraction;
+}, {
+    readonly tag: "qti-portable-custom-interaction";
+    readonly ctor: typeof QtiPortableCustomInteraction;
+}, {
+    readonly tag: "qti-portable-custom-interaction-test";
+    readonly ctor: typeof _qti_components_portable_custom_interaction_qti_portable_custom_test_interaction_js.QtiPortableCustomInteractionTest;
+}, {
+    readonly tag: "qti-position-object-interaction";
+    readonly ctor: typeof QtiPositionObjectInteraction;
+}, {
+    readonly tag: "qti-position-object-stage";
+    readonly ctor: typeof QtiPositionObjectStage;
+}, {
+    readonly tag: "qti-select-point-interaction";
+    readonly ctor: typeof QtiSelectPointInteraction;
+}, {
+    readonly tag: "qti-slider-interaction";
+    readonly ctor: typeof QtiSliderInteraction;
+}, {
+    readonly tag: "qti-text-entry-interaction";
+    readonly ctor: typeof QtiTextEntryInteraction;
+}, {
+    readonly tag: "qti-upload-interaction";
+    readonly ctor: typeof QtiUploadInteraction;
+}];
+
+export { type Orientation, QtiAssociateInteraction, QtiChoiceInteraction, QtiCustomInteraction, QtiEndAttemptInteraction, QtiExtendedTextInteraction, QtiGapMatchInteraction, QtiGraphicAssociateInteraction, QtiGraphicGapMatchInteraction, QtiGraphicOrderInteraction, QtiHotspotInteraction, QtiHottextInteraction, QtiInlineChoiceInteraction, QtiMatchInteraction, QtiMediaInteraction, QtiOrderInteraction, QtiPortableCustomInteraction, QtiPositionObjectInteraction, QtiPositionObjectStage, QtiSelectPointInteraction, QtiSliderInteraction, QtiTextEntryInteraction, QtiUploadInteraction, qtiInteractionElements };