@citolab/qti-components 7.3.23 → 7.4.0

package/dist/qti-components/index.d.ts

@@ -1,15 +1,428 @@
-import { a8 as ChoicesInterface, a9 as Interaction, Y as QtiRule, Z as QtiRuleBase, aa as QtiExpressionBase, a4 as QtiExpression, a3 as ItemContext, ab as ResponseVariable, a5 as VariableDeclaration } from '../qti-response-declaration-DKr08ANy.js';
-export { O as Orientation, U as QtiAreaMapEntry, T as QtiAreaMapping, Q as QtiAssessmentItem, a as QtiAssessmentStimulusRef, g as QtiAssociableHotspot, h as QtiAssociateInteraction, i as QtiChoiceInteraction, b as QtiCompanionMaterialsInfo, _ as QtiContentBody, j as QtiCustomInteraction, c as QtiCustomOperator, k as QtiEndAttemptInteraction, l as QtiExtendedTextInteraction, d as QtiFeedbackBlock, e as QtiFeedbackInline, p as QtiGap, m as QtiGapImg, n as QtiGapMatchInteraction, o as QtiGapText, q as QtiGraphicAssociateInteraction, r as QtiGraphicGapMatchInteraction, s as QtiGraphicOrderInteraction, t as QtiHotspotChoice, u as QtiHotspotInteraction, v as QtiHottext, x as QtiInlineChoice, w as QtiInlineChoiceInteraction, J as QtiItemBody, P as QtiLookupOutcomeValue, S as QtiMapEntry, R as QtiMapping, y as QtiMatchInteraction, z as QtiMediaInteraction, f as QtiModalFeedback, A as QtiOrderInteraction, a1 as QtiOutcomeDeclaration, K as QtiOutcomeProcessing, L as QtiOutcomeProcessingProcessor, B as QtiPortableCustomInteraction, C as QtiPositionObjectStage, M as QtiPrompt, a2 as QtiResponseDeclaration, N as QtiResponseProcessing, $ as QtiRubricBlock, D as QtiSelectPointInteraction, E as QtiSimpleAssociableChoice, F as QtiSimpleChoice, G as QtiSliderInteraction, a0 as QtiStylesheet, W as QtiSubtract, H as QtiTextEntryInteraction, I as QtiUploadInteraction, V as areaShape, X as qtiSubtractMixin } from '../qti-response-declaration-DKr08ANy.js';
-import * as lit_html from 'lit-html';
+export { Q as QtiAssessmentItem } from '../qti-assessment-item-D77dJ1Ot.js';
 import * as lit from 'lit';
-import { PropertyValues, LitElement, nothing } from 'lit';
-import { QtiConditionExpression } from '../exports/qti-condition-expression.js';
-import { BaseType } from '../exports/expression-result.js';
-import { TestContext } from '../exports/test.context.js';
-import '../exports/interaction.interface.js';
-import '../exports/config.context.js';
-import 'lit-html/directives/ref.js';
-import '../exports/qti.context.js';
+import { LitElement, CSSResultGroup, PropertyValues, PropertyValueMap, nothing } from 'lit';
+import * as lit_html from 'lit-html';
+import { C as Calculate, f as ResponseVariable, g as Cardinality, B as BaseType, V as VariableDeclaration } from '../variables-Vgyr6yyW.js';
+export { c as QtiAreaMapEntry, b as QtiAreaMapping, a as QtiMapEntry, Q as QtiMapping, d as areaShape } from '../variables-Vgyr6yyW.js';
+import { a as QtiFeedback, b as ItemContext, c as QtiContext, d as QtiContextType, T as TestContext } from '../test.context-L609DNAz.js';
+export { Q as QtiModalFeedback } from '../test.context-L609DNAz.js';
+import { C as ConfigContext } from '../config.context-CmQ9L62n.js';
+import * as lit_html_directives_ref_js from 'lit-html/directives/ref.js';
+
+/**
+ * Represents a custom element for referencing an assessment stimulus.
+ */
+declare class QtiAssessmentStimulusRef extends LitElement {
+    /**
+     * The identifier of the stimulus.
+     */
+    identifier: string;
+    /**
+     * The href of the stimulus.
+     */
+    href: string;
+    /**
+     * Lifecycle method called when the element is connected to the DOM.
+     * Loads and appends the stimulus if the 'qti-assessment-stimulus-ref-connected' event is not prevented.
+     */
+    connectedCallback(): Promise<void>;
+    /**
+     * Loads and appends the stimulus to the specified element.
+     * @param stimulusRef - The element to which the stimulus will be appended.
+     */
+    updateStimulusRef(stimulusRef: Element): Promise<void>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'qti-assessment-stimulus-ref': QtiAssessmentStimulusRef;
+    }
+}
+
+declare class QtiCompanionMaterialsInfo extends LitElement {
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'qti-companion-materials-info': QtiCompanionMaterialsInfo;
+    }
+}
+
+/**
+ * https://www.imsglobal.org/spec/qti/v3p0/impl#h.fi29q8dubjgw
+ * <qti-custom-operator class="js.org">
+        <qti-base-value base-type="string"><![CDATA[
+          console.log(context.variables);
+          return 'B'
+          document.querySelector('qti-end-attempt-interaction').disabled = true;
+          ]]></qti-base-value>
+      </qti-custom-operator>
+    </qti-set-outcome-value>
+ */
+declare class QtiCustomOperator extends LitElement implements Calculate {
+    private operatorFunction;
+    private _context?;
+    render(): lit_html.TemplateResult<1>;
+    handleSlotChange(): void;
+    calculate(): any;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'qti-custom-operator': QtiCustomOperator;
+    }
+}
+
+declare class QtiFeedbackBlock extends QtiFeedback {
+    static styles: lit.CSSResult;
+    render(): lit_html.TemplateResult<1>;
+    connectedCallback(): void;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'qti-feedback-block': QtiFeedbackBlock;
+    }
+}
+
+declare class QtiFeedbackInline extends QtiFeedback {
+    static styles: lit.CSSResult;
+    render: () => lit_html.TemplateResult<1>;
+    connectedCallback(): void;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'qti-feedback-inline': QtiFeedbackInline;
+    }
+}
+
+declare class QtiAssociableHotspot extends LitElement {
+    static styles: lit.CSSResult;
+    connectedCallback(): void;
+    render(): lit_html.TemplateResult<1>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'qti-associable-hotspot': QtiAssociableHotspot;
+    }
+}
+
+interface IInteraction {
+    correctResponse: Readonly<string | string[]>;
+    response: string | string[];
+    responseIdentifier: string;
+    disabled: boolean;
+    readonly: boolean;
+    validate(): boolean;
+    reportValidity(): boolean;
+    reset(): void;
+    saveResponse(value: string | string[]): void;
+}
+
+declare enum Correctness {
+    Correct = "correct",
+    PartiallyCorrect = "partially-correct",
+    Incorrect = "incorrect"
+}
+declare abstract class Interaction extends LitElement implements IInteraction {
+    private _context;
+    protected configContext: ConfigContext;
+    static formAssociated: boolean;
+    protected _internals: ElementInternals;
+    get internals(): ElementInternals;
+    responseIdentifier: any;
+    disabled: boolean;
+    readonly: boolean;
+    protected _isFullCorrectResponse: boolean;
+    get isFullCorrectResponse(): Readonly<boolean>;
+    set isFullCorrectResponse(val: Readonly<boolean>);
+    protected _correctResponse: string | string[];
+    get correctResponse(): Readonly<string | string[]>;
+    set correctResponse(val: Readonly<string | string[]>);
+    get correctness(): Readonly<Correctness | null>;
+    get isInline(): boolean;
+    get responseVariable(): ResponseVariable | undefined;
+    toggleCorrectResponse(show: boolean): void;
+    protected toggleFullCorrectResponse(show: boolean): Promise<void>;
+    protected toggleInternalCorrectResponse(show: boolean): void;
+    toggleCandidateCorrection(show: boolean): void;
+    constructor();
+    abstract validate(): boolean;
+    get value(): string | null;
+    set value(val: string | null);
+    abstract get response(): string | string[] | null;
+    abstract set response(val: string | string[] | null);
+    reportValidity(): boolean;
+    reset(): void;
+    connectedCallback(): void;
+    saveResponse(value: string | string[]): void;
+}
+
+declare const QtiAssociateInteraction_base: (abstract new (...args: any[]) => IInteraction) & 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;
+    render(): lit_html.TemplateResult<1>;
+    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.
+ *
+ * @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 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 {
+    static styles: CSSResultGroup;
+    /** @deprecated, use 'qti-orientation-horizontal' or 'qti-orientation-vertical' instead */
+    orientation: Orientation;
+    private _handleSlotChange;
+    render(): lit_html.TemplateResult<1>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'qti-choice-interaction': QtiChoiceInteraction;
+    }
+}
+
+declare class QtiCustomInteraction extends Interaction {
+    private rawResponse;
+    constructor();
+    data: string;
+    baseItemUrl: string;
+    baseRefUrl: string;
+    id: string;
+    private _errorMessage;
+    manifest: {
+        script: string[];
+        style: string[];
+        media: string[];
+    };
+    connectedCallback(): void;
+    setupCES(): void;
+    private getIFrames;
+    private getInnerIFrames;
+    private postToWindowAndIframes;
+    handlePostMessage(event: MessageEvent): void;
+    validate(): boolean;
+    get response(): string | string[] | null;
+    set response(val: string | string[] | null);
+    disconnectedCallback(): void;
+    render(): lit_html.TemplateResult<1>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'qti-custom-interaction': QtiCustomInteraction;
+    }
+}
+
+declare class QtiEndAttemptInteraction extends LitElement {
+    responseIdentifier: any;
+    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_html.TemplateResult<1>;
+    endAttempt(_: Event): void;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'qti-end-attempt-interaction': QtiEndAttemptInteraction;
+    }
+}
+
+declare class QtiExtendedTextInteraction extends Interaction {
+    static styles: CSSResultGroup;
+    protected _rows: number;
+    /** expected length is mapped to the property maxlength on the textarea */
+    expectedLength: number;
+    patternMask: string;
+    /** text appearing in the extended-text-interaction if it is empty */
+    placeholderText: string;
+    dataPatternmaskMessage: string;
+    classNames: any;
+    handleclassNamesChange(_: any, classes: string): void;
+    response: string | null;
+    protected _handleResponseChange: () => void;
+    get value(): string | null;
+    set value(val: string | null);
+    validate(): boolean;
+    toggleCorrectResponse(): void;
+    reportValidity(): boolean;
+    render(): lit_html.TemplateResult<1>;
+    protected textChanged(event: Event): void;
+    protected setEmptyAttribute(text: string): void;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'qti-extended-text-interaction': QtiExtendedTextInteraction;
+    }
+}
+
+declare class QtiGapImg extends LitElement {
+    static styles: lit.CSSResult;
+    tabindex: number | undefined;
+    connectedCallback(): void;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'qti-gap-img': QtiGapImg;
+    }
+}
+
+declare const QtiGapMatchInteraction_base: (abstract new (...args: any[]) => IInteraction) & typeof Interaction;
+declare class QtiGapMatchInteraction extends QtiGapMatchInteraction_base {
+    static styles: CSSResultGroup;
+    render(): lit_html.TemplateResult<1>;
+    toggleCorrectResponse(show: boolean): void;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'qti-gap-match-interaction': QtiGapMatchInteraction;
+    }
+}
+
+declare const QtiGapText_base: (abstract new (...args: any[]) => ActiveElementMixinInterface) & typeof LitElement;
+declare class QtiGapText extends QtiGapText_base {
+    static styles: lit.CSSResult;
+    tabindex: number | undefined;
+    connectedCallback(): void;
+    render(): lit_html.TemplateResult<1>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'qti-gap-text': QtiGapText;
+    }
+}
+
+declare class QtiGap extends LitElement {
+    static styles: lit.CSSResult;
+    tabindex: number | undefined;
+    render(): lit_html.TemplateResult<1>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'qti-gap': QtiGap;
+    }
+}
+
+declare class QtiGraphicAssociateInteraction extends Interaction {
+    static styles: CSSResultGroup;
+    private hotspots;
+    private startPoint;
+    private endPoint;
+    private _correctLines;
+    private startCoord;
+    private mouseCoord;
+    private grImage;
+    private _response;
+    constructor();
+    reset(): void;
+    validate(): boolean;
+    set response(val: string[]);
+    get response(): string[];
+    toggleInternalCorrectResponse(show: boolean): void;
+    render(): lit_html.TemplateResult<1>;
+    private positionHotspotOnRegister;
+    firstUpdated(): void;
+    disconnectedCallback(): void;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'qti-graphic-associate-interaction': QtiGraphicAssociateInteraction;
+    }
+}
+
+declare const QtiGraphicGapMatchInteraction_base: (abstract new (...args: any[]) => IInteraction) & typeof Interaction;
+declare class QtiGraphicGapMatchInteraction extends QtiGraphicGapMatchInteraction_base {
+    static styles: CSSResultGroup;
+    render(): lit_html.TemplateResult<1>;
+    private positionHotspotOnRegister;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'qti-graphic-gap-match-interaction': QtiGraphicGapMatchInteraction;
+    }
+}
+
+declare const QtiGraphicOrderInteraction_base: (abstract new (...args: any[]) => ChoicesInterface) & typeof Interaction;
+declare class QtiGraphicOrderInteraction extends QtiGraphicOrderInteraction_base {
+    static styles: CSSResultGroup;
+    protected choiceOrdering: boolean;
+    protected _choiceElements: Choice[];
+    render(): lit_html.TemplateResult<1>;
+    private setHotspotOrder;
+    toggleCorrectResponse(show: boolean): void;
+    private positionHotspotOnRegister;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'qti-graphic-order-interaction': QtiGraphicOrderInteraction;
+    }
+}
+
+declare const QtiHotspotChoice_base: (abstract new (...args: any[]) => ActiveElementMixinInterface) & typeof LitElement;
+declare class QtiHotspotChoice extends QtiHotspotChoice_base {
+    static styles: lit.CSSResult;
+    order: number;
+    orderCorrect: number;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'qti-hotspot-choice': QtiHotspotChoice;
+    }
+}
+
+declare const QtiHotspotInteraction_base: (abstract new (...args: any[]) => ChoicesInterface) & typeof Interaction;
+declare class QtiHotspotInteraction extends QtiHotspotInteraction_base {
+    static styles: CSSResultGroup;
+    render(): lit_html.TemplateResult<1>;
+    private positionHotspotOnRegister;
+    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 {
@@ -21,11 +434,706 @@ declare class QtiHottextInteraction extends QtiHottextInteraction_base {
     private updateHostClasses;
 }
 
+declare const QtiHottext_base: (abstract new (...args: any[]) => ActiveElementMixinInterface) & typeof LitElement;
+declare class QtiHottext extends QtiHottext_base {
+    static styles: lit.CSSResult;
+    render(): lit_html.TemplateResult<1>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'qti-hottext': QtiHottext;
+    }
+}
+
+interface OptionType {
+    textContent: string;
+    value: string;
+    selected: boolean;
+}
+declare class QtiInlineChoiceInteraction extends Interaction {
+    get isInline(): boolean;
+    static get styles(): lit.CSSResult[];
+    static inputWidthClass: string[];
+    protected options: OptionType[];
+    protected correctOption: string;
+    dataPrompt: string;
+    configContext: ConfigContext;
+    render(): lit_html.TemplateResult<1>;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    willUpdate(changed: PropertyValues<this>): void;
+    private _updateOptions;
+    validate(): boolean;
+    reset(): void;
+    set response(value: string | null);
+    get response(): string | null;
+    toggleInternalCorrectResponse(show: boolean): void;
+    protected choiceSelected(event: Event): void;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'qti-inline-choice-interaction': QtiInlineChoiceInteraction;
+    }
+}
+
+declare class QtiInlineChoice extends LitElement {
+    static get styles(): lit.CSSResult[];
+    identifier: string;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    render(): lit_html.TemplateResult<1>;
+    private _onSelectInlineChoice;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'qti-inline-choice': QtiInlineChoice;
+    }
+}
+
+declare const QtiSimpleAssociableChoice_base: (abstract new (...args: any[]) => ActiveElementMixinInterface) & typeof LitElement;
+declare class QtiSimpleAssociableChoice extends QtiSimpleAssociableChoice_base {
+    static styles: lit.CSSResult;
+    /** 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_html.TemplateResult<1>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'qti-simple-associable-choice': QtiSimpleAssociableChoice;
+    }
+}
+
+declare const QtiMatchInteraction_base: (abstract new (...args: any[]) => IInteraction) & typeof Interaction;
+declare class QtiMatchInteraction extends QtiMatchInteraction_base {
+    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: any) => void;
+    protected handleRadioChange: (e: any) => void;
+    validate(): boolean;
+    private getMatches;
+    toggleInternalCorrectResponse(show: boolean): void;
+    toggleCandidateCorrection(show: boolean): void;
+    render(): lit_html.TemplateResult<1>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'qti-match-interaction': QtiMatchInteraction;
+    }
+}
+
+declare class QtiMediaInteraction extends Interaction {
+    private _value;
+    reset(): void;
+    validate(): boolean;
+    get response(): string | null;
+    set response(val: string | null);
+    static get properties(): {
+        step: {
+            type: NumberConstructor;
+            attribute: string;
+            default: number;
+        };
+    };
+    static styles: lit.CSSResult[];
+    render(): lit_html.TemplateResult<1>;
+    constructor();
+    connectedCallback(): void;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'qti-media-interaction': QtiMediaInteraction;
+    }
+}
+
+declare const QtiOrderInteraction_base: (abstract new (...args: any[]) => IInteraction) & typeof Interaction;
+declare class QtiOrderInteraction extends QtiOrderInteraction_base {
+    static styles: lit.CSSResult;
+    protected childrenMap: Element[];
+    protected nrChoices: number;
+    correctResponses: string[];
+    showCorrectResponses: boolean;
+    /** orientation of choices */
+    orientation: 'horizontal' | 'vertical';
+    render(): lit_html.TemplateResult<1>;
+    toggleCorrectResponse(show: boolean): void;
+    getValue(val: string[]): string[];
+    protected getResponse(): string[];
+    firstUpdated(changedProps: any): Promise<void>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'qti-order-interaction': QtiOrderInteraction;
+    }
+}
+
+interface PciReadyPayload {
+    responseIdentifier: string;
+    status: 'interacting' | 'suspended' | 'closed' | 'solution' | 'review';
+}
+interface PciDonePayload {
+    responseIdentifier: string;
+    status: 'interacting' | 'suspended' | 'closed' | 'solution' | 'review';
+    outcome?: unknown;
+}
+interface ConfigProperties<T> {
+    properties: T;
+    templateVariables: Record<string, unknown>;
+    contextVariables: Record<string, unknown>;
+    boundTo: unknown;
+    responseIdentifier: string;
+    onready: (payload: PciReadyPayload) => void;
+    ondone?: (payload: PciDonePayload) => void;
+    status?: 'interacting' | 'suspended' | 'closed' | 'solution' | 'review';
+}
+interface IMSpci<T> {
+    typeIdentifier: string;
+    /** @access public
+     *  @method getInstance Create a new instance of this portable custom interaction
+     *  Will be called by the qtiCustomInteractionContext
+     *  @param {DOM Element} dom - the DOM Element this PCI is being added to
+     *  @param {Object} configuration - the configuration to apply to this PCI
+     *  @param {String} state - a previous saved state to apply to this instance.
+     *  This must have been obtained from a prior call to getState on an
+     *  instance of this type (same typeIdentifier)
+     */
+    getInstance: (dom: HTMLElement, configuration: Configuration<T>, state: string) => void;
+    /** @access public
+     * @method getResponse
+     * @return {Object} - the value to assign to the bound QTI response variable
+     */
+    getResponse: () => QtiVariableJSON | undefined;
+    /** @access public
+     * @method setResponse
+     * @param {Object} value - the value to assign to the bound QTI response variable
+     * NOTE: This is not an official QTI method, so no guarantee it is implemented
+     * in all PCIs.
+     */
+    setResponse: (value: QtiVariableJSON) => void;
+    /** @access public
+     * @method getState
+     * @return {String} The current state of this PCI. May be passed to
+     * getInstance to later restore this PCI instance.
+     */
+    getState: () => string;
+    oncompleted?: () => void;
+    destroy?: () => void;
+}
+declare type Configuration<T> = {
+    onready: (pci: IMSpci<ConfigProperties<T>>, state?: string) => void;
+    properties: T;
+};
+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;
+type QtiRecordItem = {
+    name: string;
+    base?: QtiBaseTypeJSON | null;
+    list?: QtiListTypeJSON | null;
+};
+type ResponseVariableType = QtiVariableJSON;
+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;
+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;
+declare type QtiVariableJSON = {
+    base?: QtiBaseTypeJSON;
+    list?: QtiListTypeJSON;
+    record?: QtiRecordItem[] | null;
+};
+interface ModuleResolutionConfig {
+    waitSeconds?: number;
+    context?: string;
+    catchError?: boolean;
+    paths: {
+        [key: string]: string | string[];
+    };
+    shim?: {
+        [key: string]: {
+            deps?: string[];
+            exports?: string;
+        };
+    };
+}
+
+declare class QtiPortableCustomInteraction extends Interaction {
+    private _value;
+    private pci;
+    protected _iframeLoaded: boolean;
+    protected _pendingMessages: Array<{
+        method: string;
+        params: any;
+    }>;
+    protected iframe: HTMLIFrameElement;
+    private _responseCheckInterval;
+    static styles: CSSResultGroup;
+    module: string;
+    customInteractionTypeIdentifier: string;
+    requirePathsJson: string;
+    requireShimJson: string;
+    requireJsUrl: string;
+    baseUrl: string;
+    useIframe: boolean;
+    useDefaultShims: boolean;
+    useDefaultPaths: boolean;
+    private _errorMessage;
+    protected context?: ItemContext;
+    response: string | string[];
+    private dom;
+    private _parsedRequirePaths;
+    private _parsedRequireShim;
+    /**
+     * Parse the require paths JSON string into an object
+     */
+    private getRequirePaths;
+    /**
+     * Parse the require shim JSON string into an object
+     */
+    private getRequireShim;
+    /**
+     * Get the default require paths
+     */
+    private getDefaultRequirePaths;
+    /**
+     * Get the default require shim
+     */
+    private getDefaultRequireShim;
+    /**
+     * Get the final require paths by combining defaults with user-provided paths
+     */
+    private getFinalRequirePaths;
+    /**
+     * Get the final require shim by combining defaults with user-provided shim
+     */
+    private getFinalRequireShim;
+    /**
+     * Converts QtiVariableJSON to a string or string array
+     */
+    private convertQtiVariableJSON;
+    /**
+     * Adds hyphenated versions of camelCase keys to properties object
+     */
+    private addHyphenatedKeys;
+    /**
+     * Converts response variables to QtiVariableJSON
+     */
+    protected responseVariablesToQtiVariableJSON(input: string | string[], cardinality: Cardinality, baseType: BaseType): QtiVariableJSON;
+    validate(): boolean;
+    set value(v: string | null);
+    get value(): string | null;
+    set boundTo(newValue: Record<string, ResponseVariableType>);
+    get boundTo(): Record<string, QtiVariableJSON>;
+    /**
+     * Unescape HTML entities in a string
+     */
+    private unescapeHtml;
+    /**
+     * Unescape HTML entities in all values of an object
+     */
+    private unescapeDataAttributes;
+    /**
+     * DIRECT MODE: Register PCI instance
+     */
+    register(pci: IMSpci<ConfigProperties<unknown>>): void;
+    disconnectedCallback(): void;
+    /**
+     * IFRAME MODE: Send message to iframe
+     */
+    protected sendMessageToIframe(method: string, params: any): void;
+    /**
+     * IFRAME MODE: Process pending messages
+     */
+    private processPendingMessages;
+    /**
+     * IFRAME MODE: Handle iframe messages
+     */
+    protected handleIframeMessage: (event: MessageEvent) => void;
+    /**
+     * IFRAME MODE: Create iframe element
+     */
+    protected createIframe(): void;
+    /**
+     * IFRAME MODE: Send initialization data to iframe
+     */
+    private sendIframeInitData;
+    /**
+     * IFRAME MODE: Get interaction modules from DOM
+     */
+    private getInteractionModules;
+    /**
+     * IFRAME MODE: Add markup and properties to iframe
+     */
+    private addMarkupToIframe;
+    /**
+     * IFRAME MODE: Initialize the interaction
+     */
+    private initializeInteraction;
+    connectedCallback(): void;
+    /**
+     * Stop checking for response changes
+     */
+    private stopResponseCheck;
+    private _onInteractionChanged;
+    /**
+     * DIRECT MODE: Build RequireJS configuration
+     */
+    buildRequireConfig(): ModuleResolutionConfig;
+    /**
+     * DIRECT MODE: Helper method to combine require paths
+     */
+    private combineRequireResolvePaths;
+    /**
+     * DIRECT MODE: Helper method to remove double slashes
+     */
+    private removeDoubleSlashes;
+    /**
+     * DIRECT MODE: Load config from URL
+     */
+    loadConfig: (url: string, baseUrl?: string) => Promise<ModuleResolutionConfig>;
+    /**
+     * DIRECT MODE: Helper method to get resolvable path string
+     */
+    getResolvablePathString: (path: string, basePath?: string) => string;
+    /**
+     * DIRECT MODE: Helper method to get resolvable path
+     */
+    getResolvablePath: (path: string | string[], basePath?: string) => string | string[];
+    /**
+     * 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
+     */
+    disable(): void;
+    /**
+     * Method to enable the PCI for interactive mode
+     */
+    enable(): void;
+    private _previousState;
+    render(): lit_html.TemplateResult<1>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'qti-portable-custom-interaction': QtiPortableCustomInteraction;
+    }
+}
+
 declare class QtiPositionObjectInteraction extends LitElement {
     render(): lit_html.TemplateResult<1>;
     static styles: lit.CSSResult[];
 }
 
+declare class QtiPositionObjectStage extends LitElement {
+    choiceOrdering: boolean;
+    startX: any;
+    startY: any;
+    dragElement: any;
+    render(): lit_html.TemplateResult<1>;
+    static styles: lit.CSSResult[];
+    constructor();
+    dragElementHandler(event: any): void;
+    firstUpdated(a: any): void;
+    removeMoveListener(): void;
+    disconnectedCallback(): void;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'qti-position-object-stage': QtiPositionObjectStage;
+    }
+}
+
+declare class QtiSelectPointInteraction extends Interaction {
+    static styles: lit.CSSResult[];
+    maxChoices: number;
+    minChoices: number;
+    response: string[] | null;
+    private _correctAreas;
+    private _responseCorrection;
+    private _imgElement;
+    private _scaleX;
+    private _scaleY;
+    private _imageWidthOriginal;
+    private _imageHeightOriginal;
+    private _onImageClick;
+    connectedCallback(): void;
+    private _onResize;
+    get responsePoints(): {
+        x: number;
+        y: number;
+    }[];
+    toggleCandidateCorrection(show: boolean): void;
+    toggleCorrectResponse(show: boolean): any;
+    updated(changedProperties: Map<string | number | symbol, unknown>): void;
+    render(): lit_html.TemplateResult<1>;
+    validate(): boolean;
+    private calculateScale;
+    firstUpdated(): void;
+    disconnectedCallback(): void;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'qti-select-point-interaction': QtiSelectPointInteraction;
+    }
+}
+
+declare const QtiSimpleChoice_base: (abstract new (...args: any[]) => ActiveElementMixinInterface) & typeof LitElement;
+/**
+ * qti-order-interaction
+ * qti-choice-interaction
+ */
+declare class QtiSimpleChoice extends QtiSimpleChoice_base {
+    templateIdentifier: string | null;
+    showHide: string | null;
+    fixed: boolean;
+    static styles: lit.CSSResult;
+    marker: string;
+    get checked(): boolean;
+    render(): lit_html.TemplateResult<1>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'qti-simple-choice': QtiSimpleChoice;
+    }
+}
+
+declare class QtiSliderInteraction extends Interaction {
+    static styles: CSSResultGroup;
+    private _value;
+    private _correctResponseNumber;
+    private _rail;
+    min: number;
+    max: number;
+    step: number;
+    validate(): boolean;
+    connectedCallback(): void;
+    get response(): string;
+    set response(val: string);
+    toggleCorrectResponse(show: boolean): void;
+    private _updateValue;
+    render(): lit_html.TemplateResult<1>;
+    private _onMouseDown;
+    private _onTouchStart;
+    private _startDrag;
+    private _onDrag;
+    private _onDragEnd;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'qti-slider-interaction': QtiSliderInteraction;
+    }
+}
+
+declare class QtiTextEntryInteraction extends Interaction {
+    static styles: CSSResultGroup;
+    inputRef: lit_html_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_html.TemplateResult<1>;
+    protected textChanged(event: Event): void;
+    reportValidity(): boolean;
+    reset(): void;
+    private setEmptyAttribute;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'qti-text-entry-interaction': QtiTextEntryInteraction;
+    }
+}
+
+declare class QtiUploadInteraction extends Interaction {
+    private _file;
+    private _base64;
+    reset(): void;
+    validate(): boolean;
+    get response(): string | null;
+    set response(base64: string | null);
+    static get properties(): {
+        [key: string]: lit.PropertyDeclaration<unknown, unknown>;
+    };
+    static styles: lit.CSSResult[];
+    render(): lit_html.TemplateResult<1>;
+    private _onFileChange;
+    private _convertToBase64;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'qti-upload-interaction': QtiUploadInteraction;
+    }
+}
+
+/**
+ * @summary The qti-item-body node contains the text, graphics, media objects and interactions that describe the item's content and information about how it is structured.
+ * @documentation https://www.imsglobal.org/spec/qti/v3p0/impl#h.sphpo6lu6zqi
+ * @status stable
+ * @since 4.0
+ *
+ * @slot - item body content.
+ * @slot qti-rubric-block - the qti rubric block is placed above the item
+ * @part qti-rubric-block - the qti rubric block part
+ */
+declare class QtiItemBody extends LitElement {
+    static styles: CSSResultGroup;
+    render(): lit_html.TemplateResult<1>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'qti-item-body': QtiItemBody;
+    }
+}
+
+declare class QtiRule extends LitElement implements QtiRuleBase {
+    render(): lit_html.TemplateResult<1>;
+    process(): void;
+}
+interface QtiRuleBase {
+    process(): any;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'qti-rule': QtiRule;
+    }
+}
+
+declare class QtiOutcomeProcessing extends LitElement {
+    static styles: lit.CSSResult[];
+    render(): lit_html.TemplateResult<1>;
+    process(): void;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'qti-outcome-processing': QtiOutcomeProcessing;
+    }
+}
+declare class QtiOutcomeProcessingProcessor {
+    process(rules: QtiRuleBase[]): void;
+}
+
+declare class QtiPrompt extends LitElement {
+    render(): lit_html.TemplateResult<1>;
+    connectedCallback(): void;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'qti-prompt': QtiPrompt;
+    }
+}
+
+declare class QtiResponseProcessing extends LitElement {
+    static styles: lit.CSSResult[];
+    render(): lit_html.TemplateResult<1>;
+    process(): void;
+    firstUpdated(_changedProperties: PropertyValueMap<any> | Map<PropertyKey, unknown>): void;
+    private fragmentFromString;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'qti-response-processing': QtiResponseProcessing;
+    }
+}
+
+interface QtiExpressionBase<T> {
+    calculate(): Readonly<T>;
+}
+declare abstract class QtiExpression<T> extends LitElement implements QtiExpressionBase<T> {
+    protected result: any;
+    static styles: lit.CSSResult;
+    render(): lit_html.TemplateResult<1>;
+    calculate(): Readonly<T>;
+    protected getResult(): Readonly<T>;
+    protected context?: ItemContext;
+    protected qtiContext?: QtiContext;
+    getVariables: () => (ResponseVariable | VariableDeclaration<QtiContextType>)[];
+}
+
+/**
+ * The lookupOutcomeValue rule sets the value of an outcome variable to the value obtained
+ * by looking up the value of the associated expression in the lookupTable associated
+ * with the outcome's declaration.
+ */
+declare class QtiLookupOutcomeValue extends QtiRule {
+    identifier: string;
+    protected context?: ItemContext;
+    get childExpression(): QtiExpression<string>;
+    process(): number;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'qti-lookup-outcome-value': QtiLookupOutcomeValue;
+    }
+}
+
 declare class QtiResponseCondition extends QtiRule {
     render(): lit_html.TemplateResult<1>;
     process(): void;
@@ -73,22 +1181,27 @@ declare class QtiResponseElseIf extends QtiResponseIf {
     render(): lit_html.TemplateResult<1>;
 }
 
-type Constructor<T> = new (...args: any[]) => T;
+declare abstract class QtiConditionExpression extends QtiExpression<boolean> {
+    calculate(): Readonly<boolean>;
+    getResult(): Readonly<boolean>;
+}
+
+type Constructor$1<T> = new (...args: any[]) => T;
 declare const QtiAnd_base: {
     new (...args: any[]): {
-        calculateChildren(children: Array<MockQtiExpression<any>>): boolean;
+        calculateChildren(children: Array<MockQtiExpression$1<any>>): boolean;
     };
-} & Constructor<QtiConditionExpression>;
+} & Constructor$1<QtiConditionExpression>;
 declare class QtiAnd extends QtiAnd_base {
     calculate(): boolean;
 }
-type MockQtiExpression<T> = {
+type MockQtiExpression$1<T> = {
     calculate: () => T;
 };
-type MockConstructor = new (...args: any[]) => {};
-declare function qtiAndMixin<TBase extends MockConstructor>(Base: TBase): {
+type MockConstructor$1 = new (...args: any[]) => {};
+declare function qtiAndMixin<TBase extends MockConstructor$1>(Base: TBase): {
     new (...args: any[]): {
-        calculateChildren(children: Array<MockQtiExpression<any>>): boolean;
+        calculateChildren(children: Array<MockQtiExpression$1<any>>): boolean;
     };
 } & TBase;
 
@@ -307,6 +1420,31 @@ declare class QtiProduct extends QtiExpression<number> {
     getResult(): number;
 }
 
+type Constructor<T> = new (...args: any[]) => T;
+declare const QtiSubtract_base: {
+    new (...args: any[]): {
+        calculateChildren(children: Array<MockQtiExpression<any>>): number;
+    };
+} & Constructor<QtiExpression<number>>;
+declare class QtiSubtract extends QtiSubtract_base {
+    getResult(): number;
+}
+type MockQtiExpression<T> = {
+    calculate: () => T;
+};
+type MockConstructor = new (...args: any[]) => {};
+declare function qtiSubtractMixin<TBase extends MockConstructor>(Base: TBase): {
+    new (...args: any[]): {
+        calculateChildren(children: Array<MockQtiExpression<any>>): number;
+    };
+} & TBase;
+
+declare global {
+    interface HTMLElementTagNameMap {
+        'qti-subtract': QtiSubtract;
+    }
+}
+
 declare class QtiStringMatch extends QtiExpression<boolean> {
     caseSensitive: string;
     getResult(): boolean;
@@ -359,4 +1497,85 @@ declare class QtiIndex extends QtiExpression<any> {
     private lookupVariableValue;
 }
 
-export { QtiAnd, QtiBaseValue, QtiContainerSize, QtiContains, QtiCorrect, QtiDefault, QtiDelete, QtiEqual, QtiEqualRounded, QtiFieldValue, QtiGcd, QtiGt, QtiGte, QtiHottextInteraction, QtiIndex, QtiIsNull, QtiLt, QtiLte, QtiMapResponse, QtiMapResponsePoint, QtiMatch, QtiMathOperator, QtiMember, QtiMultiple, QtiNot, QtiNull, QtiOr, QtiOrdered, QtiPositionObjectInteraction, QtiPower, QtiPrintedVariable, QtiProduct, QtiRandom, QtiRandomInteger, QtiResponseCondition, QtiResponseElse, QtiResponseElseIf, QtiResponseIf, QtiRound, QtiRoundTo, QtiRule, QtiRuleBase, QtiSetOutcomeValue, QtiSetOutcomeValueRule, QtiStringMatch, QtiSum, QtiSumExpression, QtiVariable, qtiAndMixin };
+declare class QtiContentBody extends LitElement {
+    render(): lit_html.TemplateResult<1>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'qti-content-body': QtiContentBody;
+    }
+}
+
+declare class QtiRubricBlock extends LitElement {
+    id: any;
+    use: 'instructions' | 'scoring' | 'navigation';
+    view: 'author' | 'candidate' | 'proctor' | 'scorer' | 'testConstructor' | 'tutor';
+    classNames: any;
+    handleclassNamesChange(): void;
+    static styles: lit.CSSResult;
+    render(): lit_html.TemplateResult<1>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'qti-rubric-block': QtiRubricBlock;
+    }
+}
+
+declare class QtiStylesheet extends LitElement {
+    private styleElement;
+    protected firstUpdated(_changedProperties: PropertyValueMap<any> | Map<PropertyKey, unknown>): void;
+    private minifyCss;
+    disconnectedCallback(): void;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'qti-stylesheet': QtiStylesheet;
+    }
+}
+
+declare class QtiVariableDeclaration extends LitElement {
+    render(): lit_html.TemplateResult<1>;
+    protected defaultValues(cardinality: Cardinality): string | string[];
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'qti-variabledeclaration': QtiVariableDeclaration;
+    }
+}
+
+declare class QtiOutcomeDeclaration extends QtiVariableDeclaration {
+    baseType: BaseType;
+    externalScored: 'human' | 'externalMachine' | null;
+    identifier: string;
+    cardinality: Cardinality;
+    itemContext?: ItemContext;
+    static styles: lit.CSSResult[];
+    render(): lit_html.TemplateResult<1>;
+    get interpolationTable(): Map<number, number> | null;
+    connectedCallback(): void;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'qti-outcome-declaration': QtiOutcomeDeclaration;
+    }
+}
+
+declare class QtiResponseDeclaration extends QtiVariableDeclaration {
+    baseType: BaseType;
+    identifier: string;
+    cardinality: Cardinality;
+    itemContext?: ItemContext;
+    static styles: lit.CSSResult[];
+    render(): lit_html.TemplateResult<1>;
+    connectedCallback(): void;
+    private get correctResponse();
+    private get mapping();
+    private get areaMapping();
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'qti-response-declaration': QtiResponseDeclaration;
+    }
+}
+
+export { type Orientation, QtiAnd, QtiAssessmentStimulusRef, QtiAssociableHotspot, QtiAssociateInteraction, QtiBaseValue, QtiChoiceInteraction, QtiCompanionMaterialsInfo, QtiContainerSize, QtiContains, QtiContentBody, QtiCorrect, QtiCustomInteraction, QtiCustomOperator, QtiDefault, QtiDelete, QtiEndAttemptInteraction, QtiEqual, QtiEqualRounded, QtiExtendedTextInteraction, QtiFeedbackBlock, QtiFeedbackInline, QtiFieldValue, QtiGap, QtiGapImg, QtiGapMatchInteraction, QtiGapText, QtiGcd, QtiGraphicAssociateInteraction, QtiGraphicGapMatchInteraction, QtiGraphicOrderInteraction, QtiGt, QtiGte, QtiHotspotChoice, QtiHotspotInteraction, QtiHottext, QtiHottextInteraction, QtiIndex, QtiInlineChoice, QtiInlineChoiceInteraction, QtiIsNull, QtiItemBody, QtiLookupOutcomeValue, QtiLt, QtiLte, QtiMapResponse, QtiMapResponsePoint, QtiMatch, QtiMatchInteraction, QtiMathOperator, QtiMediaInteraction, QtiMember, QtiMultiple, QtiNot, QtiNull, QtiOr, QtiOrderInteraction, QtiOrdered, QtiOutcomeDeclaration, QtiOutcomeProcessing, QtiOutcomeProcessingProcessor, QtiPortableCustomInteraction, QtiPositionObjectInteraction, QtiPositionObjectStage, QtiPower, QtiPrintedVariable, QtiProduct, QtiPrompt, QtiRandom, QtiRandomInteger, QtiResponseCondition, QtiResponseDeclaration, QtiResponseElse, QtiResponseElseIf, QtiResponseIf, QtiResponseProcessing, QtiRound, QtiRoundTo, QtiRubricBlock, QtiRule, type QtiRuleBase, QtiSelectPointInteraction, QtiSetOutcomeValue, QtiSetOutcomeValueRule, QtiSimpleAssociableChoice, QtiSimpleChoice, QtiSliderInteraction, QtiStringMatch, QtiStylesheet, QtiSubtract, QtiSum, QtiSumExpression, QtiTextEntryInteraction, QtiUploadInteraction, QtiVariable, qtiAndMixin, qtiSubtractMixin };