@citolab/qti-components 7.3.16 → 7.3.18

package/dist/qti-response-declaration-BSUPHx0G.d.ts

@@ -0,0 +1,1358 @@
+import * as lit_html from 'lit-html';
+import * as lit from 'lit';
+import { LitElement, CSSResultGroup, PropertyValueMap } from 'lit';
+import { Cardinality, BaseType, ResponseInteraction, Calculate } from './exports/expression-result.js';
+import { IInteraction } from './exports/interaction.interface.js';
+import * as lit_html_directives_ref_js from 'lit-html/directives/ref.js';
+
+interface VariableValue<T> {
+    identifier: string;
+    value: Readonly<T>;
+    type: 'outcome' | 'response';
+}
+interface VariableDeclaration<T> extends VariableValue<T> {
+    cardinality?: Cardinality;
+    baseType?: BaseType;
+}
+interface OutcomeVariable extends VariableDeclaration<string | string[] | null> {
+    interpolationTable?: Map<number, number>;
+    externalScored?: 'human' | 'externalMachine' | null;
+}
+interface ResponseVariable extends VariableDeclaration<string | string[] | null> {
+    candidateResponse?: string | string[] | null;
+    mapping?: QtiMapping;
+    areaMapping?: QtiAreaMapping;
+    correctResponse?: string | string[] | null;
+}
+
+/**
+ * @summary The qti-assessment-item element contains all the other QTI 3 item structures.
+ * @documentation https://www.imsglobal.org/spec/qti/v3p0/impl#h.dltnnj87l0yj
+ *
+ * @dependency qti-feedback
+ * @dependency qti-responseprocessing
+ *
+ * @event qti-item-context-updated - Emitted when through a user action the itemContext is updated,
+ * typically on interaction with the interactions, or calling response processing.
+ */
+declare class QtiAssessmentItem extends LitElement {
+    private _itemTitle;
+    identifier: string;
+    adaptive: 'true' | 'false';
+    timeDependent: 'true' | 'false' | null;
+    get title(): string;
+    set title(value: string);
+    disabled: boolean;
+    protected _handleDisabledChange: (_: boolean, disabled: boolean) => void;
+    readonly: boolean;
+    protected _handleReadonlyChange: (_: boolean, readonly: boolean) => void;
+    private _context;
+    /**
+     * Sets the identifier for the assessment item reference if this item is in a test.
+     *
+     * @param identifier - The identifier for the assessment item reference.
+     */
+    set assessmentItemRefId(identifier: string);
+    get assessmentItemRefId(): string;
+    get variables(): VariableValue<string | string[] | null>[];
+    set variables(value: VariableValue<string | string[] | null>[]);
+    private _initialContext;
+    private _feedbackElements;
+    private _interactionElements;
+    /** @deprecated use variables property instead */
+    set responses(myResponses: ResponseInteraction[]);
+    render(): lit_html.TemplateResult<1>;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    private _attachEventListeners;
+    private _removeEventListeners;
+    private _handleRegisterVariable;
+    private _handleRegisterFeedback;
+    private _handleRegisterInteraction;
+    private _handleEndAttempt;
+    private _handleSetOutcomeValue;
+    private _handleUpdateResponseVariable;
+    /**
+     * Toggles the display of correct responses for all interactions.
+     * @param show - A boolean indicating whether to show or hide correct responses.
+     */
+    showCorrectResponse(show: boolean): void;
+    processResponse(countNumAttempts?: boolean, reportValidityAfterScoring?: boolean): boolean;
+    resetResponses(): void;
+    protected getResponse(identifier: string): Readonly<ResponseVariable>;
+    protected getOutcome(identifier: string): Readonly<OutcomeVariable>;
+    protected getVariable(identifier: string): Readonly<VariableDeclaration<string | string[] | null>>;
+    /**
+     * Updates the response variable with the specified identifier to the given value.
+     *
+     * @protected
+     *
+     * This method is intended for internal use within the class and subclasses.
+     * It should not be called externally by third parties.
+     *
+     * @param identifier - The identifier of the response variable to update.
+     * @param value - The new value for the response variable.
+     */
+    updateResponseVariable(identifier: string, value: string | string[] | undefined): void;
+    setOutcomeVariable(identifier: string, value: string | string[] | undefined): void;
+    /**
+     * Updates the outcome variable with the specified identifier to the given value.
+     *
+     * @protected
+     *
+     * This method is intended for internal use within the class and subclasses.
+     * It should not be called externally by third parties.
+     *
+     * @param identifier - The identifier of the response variable to update.
+     * @param value - The new value for the response variable.
+     */
+    updateOutcomeVariable(identifier: string, value: string | string[] | undefined): void;
+    validate(reportValidity?: boolean): boolean;
+    reportValidity(): void;
+    private _getCompletionStatus;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'qti-assessment-item': QtiAssessmentItem;
+    }
+}
+
+/**
+ * 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 abstract class QtiFeedback extends LitElement {
+    protected showHide: string;
+    outcomeIdentifier: string;
+    protected identifier: string;
+    showStatus: string;
+    private _context?;
+    connectedCallback(): void;
+    checkShowFeedback(outcomeIdentifier: string): void;
+    private showFeedback;
+}
+
+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 QtiModalFeedback extends QtiFeedback {
+    static styles: lit.CSSResult;
+    render(): lit_html.TemplateResult<1>;
+    openFeedback(): void;
+    closeFeedback(): void;
+    connectedCallback(): void;
+    protected updated(changedProperties: Map<string | number | symbol, unknown>): void;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'qti-modal-feedback': QtiModalFeedback;
+    }
+}
+
+declare class QtiAssociableHotspot extends LitElement {
+    static styles: lit.CSSResult;
+    connectedCallback(): void;
+    render(): lit_html.TemplateResult<1>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'qti-associable-hotspot': QtiAssociableHotspot;
+    }
+}
+
+declare abstract class Interaction extends LitElement implements IInteraction {
+    static formAssociated: boolean;
+    protected _internals: ElementInternals;
+    responseIdentifier: any;
+    disabled: boolean;
+    readonly: boolean;
+    protected _correctResponse: string | string[];
+    get correctResponse(): Readonly<string | string[]>;
+    set correctResponse(val: Readonly<string | string[]>);
+    toggleCorrectResponse(responseVariable: ResponseVariable, 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;
+    toggleCorrectResponse(responseVariable: ResponseVariable, show: boolean): void;
+    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-nteraction 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;
+    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(responseVariable: ResponseVariable, 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[];
+    toggleCorrectResponse(responseVariable: ResponseVariable, 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(responseVariable: ResponseVariable, 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 {
+    render: () => lit_html.TemplateResult<1>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'qti-hottext-interaction': QtiHottextInteraction;
+    }
+}
+
+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 {
+    static get styles(): lit.CSSResult[];
+    static inputWidthClass: string[];
+    protected options: OptionType[];
+    protected correctOption: string;
+    dataPrompt: string;
+    render(): lit_html.TemplateResult<1>;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    validate(): boolean;
+    reset(): void;
+    set response(value: string | null);
+    get response(): string | null;
+    toggleCorrectResponse(responseVariable: ResponseVariable, 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 rows: QtiSimpleAssociableChoice[];
+    protected cols: QtiSimpleAssociableChoice[];
+    protected lastCheckedRadio: HTMLInputElement | null;
+    class: string;
+    protected _response: string | string[];
+    get response(): string[];
+    set response(val: string[]);
+    responseIdentifier: string;
+    protected correctOptions: {
+        text: string;
+        gap: string;
+    }[];
+    connectedCallback(): Promise<void>;
+    protected handleRadioClick: (e: any) => void;
+    protected handleRadioChange: (e: any) => void;
+    validate(): boolean;
+    toggleCorrectResponse(responseVariable: ResponseVariable, 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(responseVariable: ResponseVariable, show: boolean): void;
+    getValue(val: string[]): string[];
+    protected getResponse(): string[];
+    firstUpdated(changedProps: any): Promise<void>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'qti-order-interaction': QtiOrderInteraction;
+    }
+}
+
+interface ItemContext {
+    identifier?: string;
+    href?: string;
+    variables?: ReadonlyArray<VariableDeclaration<string | string[] | null>>;
+}
+declare const itemContextVariables: VariableDeclaration<string | string[]>[];
+
+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;
+    private _lastResponseStr;
+    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>;
+    /**
+     * 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;
+    /**
+     * Start checking for response changes at regular intervals
+     */
+    private startResponseCheck;
+    /**
+     * 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
+     */
+    toggleCorrectResponse(responseVariable: ResponseVariable, 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 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[];
+    private _correctAreas;
+    private _imgElement;
+    private _scaleX;
+    private _scaleY;
+    private _imageWidthOrginal;
+    private _imageHeightOrginal;
+    private _onImageClick;
+    connectedCallback(): void;
+    private _onResize;
+    toggleCorrectResponse(responseVariable: ResponseVariable, show: boolean): any;
+    updated(changedProperties: Map<string | number | symbol, unknown>): void;
+    render(): lit_html.TemplateResult<1>;
+    reset(): void;
+    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(responseVariable: ResponseVariable, 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);
+    validate(): boolean;
+    toggleCorrectResponse(responseVariable: ResponseVariable, 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 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;
+    }
+}
+
+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;
+    }
+}
+
+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;
+    getVariables: () => VariableDeclaration<number | string | (number | string)[] | null>[];
+}
+
+/**
+ * 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;
+    }
+}
+
+type QtiMapping = {
+    defaultValue: number;
+    lowerBound?: number;
+    upperBound?: number;
+    mapEntries: QtiMapEntry[];
+};
+type QtiMapEntry = {
+    mapKey: string;
+    mappedValue: number;
+    caseSensitive: boolean;
+};
+
+type QtiAreaMapping = {
+    defaultValue: number;
+    lowerBound?: number;
+    upperBound?: number;
+    areaMapEntries: QtiAreaMapEntry[];
+};
+type QtiAreaMapEntry = {
+    shape: areaShape;
+    coords: string;
+    mappedValue: number;
+    defaultValue: number;
+};
+type areaShape = 'default' | 'circle' | 'rect' | 'ellipse' | 'poly';
+
+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 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(variable: VariableDeclaration<string | string[] | null>): 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 { QtiContentBody as $, QtiMediaInteraction as A, QtiOrderInteraction as B, QtiPortableCustomInteraction as C, QtiPositionObjectStage as D, QtiSelectPointInteraction as E, QtiSimpleAssociableChoice as F, QtiSimpleChoice as G, QtiSliderInteraction as H, QtiTextEntryInteraction as I, QtiUploadInteraction as J, QtiItemBody as K, QtiOutcomeProcessing as L, QtiOutcomeProcessingProcessor as M, QtiPrompt as N, type Orientation as O, QtiResponseProcessing as P, QtiAssessmentItem as Q, QtiLookupOutcomeValue as R, type QtiMapping as S, type QtiMapEntry as T, type QtiAreaMapping as U, type QtiAreaMapEntry as V, type areaShape as W, QtiSubtract as X, qtiSubtractMixin as Y, QtiRule as Z, type QtiRuleBase as _, QtiAssessmentStimulusRef as a, QtiRubricBlock as a0, QtiStylesheet as a1, QtiOutcomeDeclaration as a2, QtiResponseDeclaration as a3, type ItemContext as a4, type VariableValue as a5, type OutcomeVariable as a6, type VariableDeclaration as a7, QtiExpression as a8, type QtiExpressionBase as a9, type ResponseVariable as aa, Interaction as ab, itemContextVariables as ac, QtiCompanionMaterialsInfo as b, QtiCustomOperator as c, QtiFeedbackBlock as d, QtiFeedbackInline as e, QtiModalFeedback as f, QtiAssociableHotspot as g, QtiAssociateInteraction as h, QtiChoiceInteraction as i, QtiCustomInteraction as j, QtiEndAttemptInteraction as k, QtiExtendedTextInteraction as l, QtiGapImg as m, QtiGapMatchInteraction as n, QtiGapText as o, QtiGap as p, QtiGraphicAssociateInteraction as q, QtiGraphicGapMatchInteraction as r, QtiGraphicOrderInteraction as s, QtiHotspotChoice as t, QtiHotspotInteraction as u, QtiHottextInteraction as v, QtiHottext as w, QtiInlineChoiceInteraction as x, QtiInlineChoice as y, QtiMatchInteraction as z };