import * as lit from 'lit';
import { LitElement, CSSResultGroup, PropertyValues } from 'lit';
import { I as Interaction, b as RecordValue } from './record.d-wB9uYs-j.js';
import { V as ValidatableInteraction } from './interaction.interface.d-CvjHM2bi.js';
import { C as ConfigContext } from './config.context.d-BvU9r-Mg.js';
import { B as BaseType, a as Cardinality, b as ItemContext, Q as QtiAreaMapEntry } from './item.types.d-DuVR0ZVK.js';
import { Q as QtiContext } from './qti.context.d-CejJMlfZ.js';
import * as lit_directives_ref_js from 'lit/directives/ref.js';

/**
 * 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;
    render(): lit.TemplateResult<1>;
}
declare global {
    interface HTMLElementTagNameMap {
        'qti-associable-hotspot': QtiAssociableHotspot;
    }
}

/**
 * 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`).
     */
    internals: ElementInternals;
    connectedCallback(): void;
    render(): lit.TemplateResult<1>;
}
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;
    }
}

/**
 * What each drop target currently holds, published by the drag-drop interaction.
 *
 * Today this is *derived* from the DOM in one place (`DragDropSlottedMixin`), replacing nine
 * separate `querySelectorAll` readbacks scattered across capacity checks, association counts and
 * response serialisation. It is the seam for the next step: once drop targets render their own
 * chips from this context, the map becomes authoritative and the DOM becomes derived from it.
 *
 * Provided by the `qti-*-interaction`, never by `qti-assessment-item` - interactions must work
 * standalone. Consumers read `this.ctx?.dragsByTarget?.[id] ?? []`.
 *
 * Reassign, never mutate: an in-place change does not notify consumers.
 */
interface DragDropState {
    /**
     * Target identifier -> the drag identifiers it holds, in DOM order.
     * Matched with the interaction's `draggablesSelector`, which is what the response is built from.
     */
    readonly dragsByTarget: Readonly<Record<string, readonly string[]>>;
    /**
     * Target identifier -> how many chips it holds for capacity purposes.
     *
     * Deliberately *not* `dragsByTarget[id].length`. Capacity counts
     * `max(draggablesSelector matches, [qti-draggable] matches)`, because a dropped clone may not
     * match the interaction's structural selector (match-interaction's nested choices do; a bare
     * clone elsewhere may only carry the attribute). Response serialisation uses the selector
     * only. Collapsing the two would silently change `matchMax` behaviour.
     */
    readonly countByTarget: Readonly<Record<string, number>>;
    /**
     * Target identifier -> the chip nodes it holds, for targets that render their own chips.
     *
     * This is the authoritative half. A target that opts in (`acceptsDeclarativeDrops`) renders
     * `repeat(nodesByTarget[id])` into its own shadow root, and the interaction never appends into
     * it. The nodes are cloned **once, when the drop happens**, and the same node reference is
     * passed on every render -- Lit renders a `Node` by reference, so a stable node is moved, never
     * recreated. Cloning inside `render()` would mint a new element per update: focus loss,
     * restarted transitions, a half-built shadow root.
     *
     * Today it is still *derived* from the DOM alongside `dragsByTarget`. It becomes authoritative
     * when the first target opts in to rendering its own chips.
     */
    readonly nodesByTarget: Readonly<Record<string, readonly HTMLElement[]>>;
}

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.
 *
 * @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;
}

type Choice = HTMLElement & ChoiceInterface & {
    internals: ElementInternals;
};
interface ChoicesInterface extends ValidatableInteraction {
    minChoices: number;
    maxChoices: number;
    value: string | null;
    response: string | string[] | null;
}

/** The elements a measurement pass looks at. */
interface DropzoneAutoSizeTargets {
    /** Measured. The largest of these decides the reservation. */
    draggables: HTMLElement[];
    /** Not measured — only their presence gates the pass (nothing to reserve for, nothing to do). */
    droppables: HTMLElement[];
    /** The chip banks, which get a matching `min-height` so an emptied bank does not collapse. */
    dragContainers: HTMLElement[];
}
type DropzoneAutoSize = LitElement & {
    autoSizeDropzones: boolean;
    /**
     * False when something else owns the width axis — see the class below.
     *
     * Declared as an accessor, not a `readonly` property. The class implements it as a getter and
     * `DragDropSlottedMixin` overrides it with another getter; a property here makes that override a
     * TS2611 ("defined as a property in the base, overridden as an accessor").
     */
    get autoSizeDropzoneWidth(): boolean;
    updateMinDimensionsForDropZones(): void;
    /** Overridable hooks — see the class below. Public because a subclass has to be able to say
     *  `override`, which the house style already does for `afterCache` and `isDragDropEnabled`. */
    collectAutoSizeTargets(): DropzoneAutoSizeTargets;
    dropzonePropertyTarget(): HTMLElement;
};

type MenuAutoSize = LitElement & {
    updateMenuWidth(): void;
    shouldAutoSizeMenu(): boolean;
    menuAutoSizeExtraWidth(): number;
    menuAutoSizePropertyTarget(): HTMLElement | null;
    menuAutoSizeRows(): HTMLElement[];
    withMenuMeasurable<T>(measure: () => T): T;
};

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;
    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;
    render(): lit.TemplateResult<1>;
}
declare global {
    interface HTMLElementTagNameMap {
        'qti-gap-text': QtiGapText;
    }
}

/**
 * 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 & {
    isDragDropEnabled(): boolean;
    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;
    removeChipFromDroppable(droppable: HTMLElement | null, chip: HTMLElement): 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;
    returnAnchorItems?: HTMLElement[];
    /** Last pointer position, so the clone can be repositioned after it is re-hosted mid-drag. */
    lastCoordinates?: {
        x: number;
        y: number;
    };
}

type DragDropSlotted = DragDropCore & DropzoneAutoSize & {
    minAssociations: number;
    maxAssociations: number;
    disableAnimations: boolean;
    enableFlipAnimations: boolean;
    validate(): boolean;
    reportValidity(): boolean;
    reset(): void;
    saveResponse(value?: string | string[]): void;
    shouldTreatBlockedMaxAsInvalid(): boolean;
    shouldReturnToInventoryOnInventoryDrop(): boolean;
    /** Placement, published on `dragDropContext`. An interaction that renders its own drop targets
     *  reads `nodesByTarget` straight out of it. */
    _dragDrop: Readonly<DragDropState>;
    /** The chips a target holds — from the placement map, or the DOM, depending on the target. */
    chipsIn(droppable: HTMLElement): HTMLElement[];
    isDeclarativeTarget(el: HTMLElement | null | undefined): boolean;
    /** Republish placement on `dragDropContext` and re-render the targets that read it. */
    syncDragDropState(): void;
    /**
     * How many associations exist, for `min-associations` / `max-associations`.
     *
     * The default counts placed chips, which is one-to-one with associations only when a chip *is*
     * an association — a gap holding one chip, a match target holding one chip. Associate pairs two
     * chips per association and overrides this. Declared here so it can be.
     */
    totalAssociationsFromState(): number;
};

/**
 * 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;
/**
 * 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>;
    protected updated(changedProperties: Map<string, unknown>): void;
    disconnectedCallback(): void;
}
declare global {
    interface HTMLElementTagNameMap {
        'qti-associate-interaction': QtiAssociateInteraction;
    }
}

type Orientation = 'horizontal' | 'vertical' | undefined;
declare const QtiChoiceInteraction_base: (abstract new (...args: any[]) => {}) & (abstract new (...args: any[]) => ChoicesInterface) & 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 {
    #private;
    static styles: CSSResultGroup;
    /** @deprecated, use 'qti-orientation-horizontal' or 'qti-orientation-vertical' instead */
    orientation: Orientation;
    render(): lit.TemplateResult<1>;
}
declare global {
    interface HTMLElementTagNameMap {
        'qti-choice-interaction': QtiChoiceInteraction;
    }
}

/**
 * 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;
    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-extended-text-interaction': QtiExtendedTextInteraction;
    }
}

declare const QtiGapMatchInteraction_base: (abstract new (...args: any[]) => DragDropSlottedSortable) & (abstract new (...args: any[]) => 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;
    render(): lit.TemplateResult<1>;
}
declare global {
    interface HTMLElementTagNameMap {
        'qti-gap-match-interaction': QtiGapMatchInteraction;
    }
}

/**
 * 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;
    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-graphic-associate-interaction': QtiGraphicAssociateInteraction;
    }
}

declare const QtiGraphicGapMatchInteraction_base: (abstract new (...args: any[]) => DragDropSlottedSortable) & (abstract new (...args: any[]) => 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;
    /**
     * A hotspot's box is its authored `coords`, always (CONFIGURABILITY.md §4). The measured
     * `--qti-dropzone-min-*` reservation is a floor on the hotspot's `min-width`/`min-height`, and it
     * beat the percentage box from `positionShapes` as soon as the graphic rendered narrower than its
     * declared width: a 275px chip kept a 17% hotspot at 275px over a 482px map. Chips are sized to
     * their hotspots through `--qti-graphic-scale` instead.
     */
    autoSizeDropzones: boolean;
    /**
     * Rendered width of the graphic over its declared width: the factor the drop areas are scaled by.
     * Published as `--qti-graphic-scale` on both slots, so it reaches a chip in the bank and one placed
     * in a hotspot (qti-gap-img.styles.ts), without writing to the light-DOM host.
     */
    private _graphicScale;
    render(): lit.TemplateResult<1>;
    shouldReturnToInventoryOnInventoryDrop(): boolean;
    connectedCallback(): void;
    disconnectedCallback(): void;
}
declare global {
    interface HTMLElementTagNameMap {
        'qti-graphic-gap-match-interaction': QtiGraphicGapMatchInteraction;
    }
}

type HotspotChoice = Choice & {
    order: number | null;
};
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;
    maxChoices: number;
    protected _choiceElements: Choice[];
    render(): lit.TemplateResult<1>;
    protected _choiceElementSelectedHandler(event: CustomEvent<{
        identifier: string;
    }>): void;
    protected handleOrderedResponseChange(): void;
    /** 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-graphic-order-interaction': QtiGraphicOrderInteraction;
    }
}

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;
    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;
/**
 * 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;
    render: () => lit.TemplateResult<1>;
}

interface OptionType {
    content: string | Node[];
    value: string;
    selected: boolean;
}
declare const QtiInlineChoiceInteraction_base: (abstract new (...args: any[]) => 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();
    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): void;
    updated(changed: PropertyValues): 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-inline-choice-interaction': QtiInlineChoiceInteraction;
    }
}

declare const QtiMatchInteraction_base: (abstract new (...args: any[]) => DragDropSlottedSortable) & (abstract new (...args: any[]) => 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;
    /**
     * 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[];
    protected targetChoices: QtiSimpleAssociableChoice[];
    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;
    }
}

declare const QtiOrderInteraction_base: (abstract new (...args: any[]) => DragDropSlottedSortable) & (abstract new (...args: any[]) => 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;
    }
}

/**
 * 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, a field map (`{ time: '4.0', point: '460 245' }`) for `record`
 * cardinality, and an array of values for every other cardinality.
 */
interface PciCorrectResponse {
    value: string | string[] | Record<string, string | string[] | null>;
}
/**
 * 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.
 */
type QtiFileData = {
    data: string;
    mime: string;
    name?: string;
};
type QtiBaseBoolean = boolean;
type QtiBaseInteger = number;
type QtiBaseFloat = number;
type QtiBaseString = string;
type QtiBasePoint = [number, number];
type QtiBasePair = [string, string];
type QtiBaseDirectedPair = [string, string];
type QtiBaseDuration = string;
type QtiBaseFile = QtiFileData;
type QtiBaseUri = string;
type QtiBaseIntOrIdentifier = number | string;
type QtiBaseIdentifier = string;
/**
 * A QTI record entry for `record` cardinality values.
 */
type QtiRecordItem = {
    name: string;
    base?: QtiBaseTypeJSON | null;
    list?: QtiListTypeJSON | null;
};
type ResponseVariableType = QtiVariableJSON;
/**
 * QTI Appendix-C style JSON representation for base cardinality.
 */
type QtiBaseTypeJSON = {
    boolean?: QtiBaseBoolean;
    integer?: QtiBaseInteger;
    float?: QtiBaseFloat;
    string?: QtiBaseString;
    point?: QtiBasePoint;
    pair?: QtiBasePair;
    directedPair?: QtiBaseDirectedPair;
    duration?: QtiBaseDuration;
    file?: QtiBaseFile;
    uri?: QtiBaseUri;
    intOrIdentifier?: QtiBaseIntOrIdentifier;
    identifier?: QtiBaseIdentifier;
} | null;
/**
 * QTI Appendix-C style JSON representation for list cardinality.
 */
type QtiListTypeJSON = {
    boolean?: QtiBaseBoolean[];
    integer?: QtiBaseInteger[];
    float?: QtiBaseFloat[];
    string?: QtiBaseString[];
    point?: QtiBasePoint[];
    pair?: QtiBasePair[];
    directedPair?: QtiBaseDirectedPair[];
    duration?: QtiBaseDuration[];
    file?: QtiBaseFile[];
    uri?: QtiBaseUri[];
    intOrIdentifier?: QtiBaseIntOrIdentifier[];
    identifier?: QtiBaseIdentifier[];
} | null;
/**
 * Complete QTI variable JSON envelope used by PCI bridge messaging.
 */
declare type QtiVariableJSON = {
    base?: QtiBaseTypeJSON;
    list?: QtiListTypeJSON;
    record?: QtiRecordItem[] | null;
};

/** Text for an inline `<script>`: a `</script` inside it would end the element early. */
declare const inlineScriptText: (text: string) => string;
/** Text for an inline `<style>`: a `</style` inside it would end the element early. */
declare const inlineStyleText: (text: string) => string;
/** A response value as this interaction holds it: a record response is its field map. */
type PciResponseValue = string | string[] | RecordValue;
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;
    static styles: CSSResultGroup;
    module: string;
    customInteractionTypeIdentifier: string;
    requirePathsJson: string;
    requireShimJson: string;
    /** A RequireJS to load in the iframe instead of the inlined copy (src/vendor/require-js.ts). */
    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;
    response: string | string[] | null;
    /**
     * Get direct child elements by tag name
     */
    private getDirectChildrenByTag;
    /**
     * Normalize an input into a list form
     */
    private normalizeListValue;
    /**
     * Convert a variable value to QtiVariableJSON
     */
    private variableToQtiVariableJSON;
    /**
     * Extract default QTI_CONTEXT values from qti-context-declaration elements
     */
    private getQtiContextDefaultsFromItem;
    /**
     * Build a QTI_CONTEXT record for PCI consumption
     */
    private getQtiContextRecord;
    /**
     * Collect template variables referenced by qti-template-variable children
     */
    private getTemplateVariables;
    /**
     * Collect context variables referenced by qti-context-variable children
     */
    private getContextVariables;
    /**
     * Converts response variables to QtiVariableJSON
     */
    protected responseVariablesToQtiVariableJSON(input: PciResponseValue, cardinality: Cardinality, baseType: BaseType, fieldBaseTypes?: Record<string, BaseType>): QtiVariableJSON;
    validate(): boolean;
    set value(v: string | null);
    get value(): string | null;
    set boundTo(newValue: Record<string, ResponseVariableType>);
    get boundTo(): Record<string, QtiVariableJSON>;
    disconnectedCallback(): void;
    /**
     * IFRAME MODE: Send message to iframe
     */
    protected sendMessageToIframe(method: string, params: any): void;
    /**
     * IFRAME MODE: Handle iframe messages
     */
    protected handleIframeMessage: (event: MessageEvent) => void;
    /**
     * IFRAME MODE: Create iframe element
     */
    protected createIframe(): void;
    connectedCallback(): void;
    /**
     * IFRAME MODE: Generate iframe HTML content
     */
    protected generateIframeContent(): string;
    /**
     * Method to disable the PCI for review mode
     * This can be used when showing the correct response
     */
    disable(): void;
    /**
     * Method to enable the PCI for interactive mode
     */
    enable(): void;
    render(): lit.TemplateResult<1>;
}
declare global {
    interface HTMLElementTagNameMap {
        'qti-portable-custom-interaction': QtiPortableCustomInteraction;
    }
}

/**
 * Test-specific extension of QtiPortableCustomInteraction that adds methods
 * for interacting with the iframe content in tests.
 */
declare class QtiPortableCustomInteractionTest extends QtiPortableCustomInteraction {
    #private;
    /** Wait until the PCI has completed its iframe handshake, even if it became ready before the test started. */
    waitForReady(timeout?: number): Promise<void>;
    /**
     * Gets the HTML content of the iframe for testing purposes
     * @returns Promise that resolves with the HTML content string
     */
    getIFrameContent(): Promise<string>;
    setTestContext(newContext: ItemContext): void;
    /**
     * Recreates the iframe completely
     * @returns Promise that resolves when the iframe is loaded
     */
    recreateIframe(): Promise<void>;
    /**
     * Override the original disconnectedCallback to handle iframe recreation
     */
    disconnectedCallback(): void;
    /**
     * Simulates a mouse click at specific coordinates within the iframe
     * @param x The x coordinate
     * @param y The y coordinate
     * @returns Promise that resolves when the click is performed
     */
    iFrameMouseClick(x: number, y: number): Promise<void>;
    /**
     * Clicks on an element identified by a CSS selector
     * @param selector The CSS selector string
     * @returns Promise that resolves with boolean indicating if the element was found and clicked
     */
    iFrameClickOnElement(selector: string): Promise<boolean>;
    /**
     * Clicks on an element containing the specified text
     * @param text The text to search for within elements
     * @returns Promise that resolves with boolean indicating if the element was found and clicked
     */
    iFrameClickOnElementByText(text: string): Promise<boolean>;
    /**
     * Sets the value of an input element identified by a CSS selector
     * @param selector The CSS selector string
     * @param value The value to set
     * @returns Promise that resolves with boolean indicating if the element was found and value was set
     */
    iFrameSetValueElement(selector: string, value: string): Promise<boolean>;
    /**
     * Gets the bounding client rect for an element inside the iframe
     * @param selector The CSS selector string
     * @returns Promise that resolves with the rect or null
     */
    iFrameGetBoundingClientRect(selector: string): Promise<{
        left: number;
        top: number;
        width: number;
        height: number;
    } | null>;
    /**
     * Sets the value of an input element containing the specified text
     * @param text The text to search for within elements
     * @param value The value to set
     * @returns Promise that resolves with boolean indicating if the element was found and value was set
     */
    iFrameSetValueElementByText(text: string, value: string): Promise<boolean>;
    /**
     * Performs a mousedown event on an element identified by a CSS selector
     * @param selector The CSS selector string
     * @returns Promise that resolves with boolean indicating if the element was found and mousedown was performed
     */
    iFrameMousedownOnElement(selector: string): Promise<boolean>;
    /**
     * Override the original generateIframeContent method to include
     * the test message handlers in the iframe HTML
     */
    generateIframeContent(): string;
}
declare global {
    interface HTMLElementTagNameMap {
        'qti-portable-custom-interaction-test': QtiPortableCustomInteractionTest;
    }
}

/**
 * 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;
    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-select-point-interaction': QtiSelectPointInteraction;
    }
}

/**
 * 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;
    willUpdate(changed: PropertyValues): void;
    /**
     * Shows the value without publishing it: it came from the item (a default or a restored answer) or
     * from the host, which hold it already. Only the candidate's input is published.
     */
    get response(): string | null;
    set response(val: string | null);
    /** Extension hook for optional content rendered on the slider rail. */
    protected renderRailSupplement(): unknown;
    render(): lit.TemplateResult<1>;
}
declare global {
    interface HTMLElementTagNameMap {
        'qti-slider-interaction': QtiSliderInteraction;
    }
}

/**
 * Text-entry interaction: single-line inline text input.
 *
 * @customElement qti-text-entry-interaction
 *
 * @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.
 *
 * @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 QtiTextEntryInteraction extends Interaction {
    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 isInline(): boolean;
    validate(): 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;
    reportValidity(): boolean;
    reset(): void;
}
declare global {
    interface HTMLElementTagNameMap {
        'qti-text-entry-interaction': QtiTextEntryInteraction;
    }
}

export { inlineStyleText as A, QtiPortableCustomInteractionTest as B, type Choice as C, type Orientation as O, QtiAssociableHotspot as Q, QtiAssociateInteraction as a, QtiChoiceInteraction as b, QtiExtendedTextInteraction as c, QtiGap as d, QtiGapImg as e, QtiGapMatchInteraction as f, QtiGapText as g, QtiGraphicAssociateInteraction as h, QtiGraphicGapMatchInteraction as i, QtiGraphicOrderInteraction as j, QtiHotspotChoice as k, QtiHotspotInteraction as l, QtiHottext as m, QtiHottextInteraction as n, QtiInlineChoice as o, QtiInlineChoiceInteraction as p, QtiMatchInteraction as q, QtiOrderInteraction as r, QtiPortableCustomInteraction as s, QtiPrompt as t, QtiSelectPointInteraction as u, QtiSimpleAssociableChoice as v, QtiSimpleChoice as w, QtiSliderInteraction as x, QtiTextEntryInteraction as y, inlineScriptText as z };