@citolab/qti-components 6.0.19 → 6.0.22

package/dist/index.d.cts

@@ -0,0 +1,1063 @@
+import * as lit from 'lit';
+import { LitElement, CSSResultGroup, PropertyValueMap } from 'lit';
+import * as lit_html from 'lit-html';
+import { ContextConsumer } from '@lit-labs/context';
+import * as lit_html_directives_ref from 'lit-html/directives/ref';
+import * as cheerio from 'cheerio';
+
+interface directedPair {
+    destination: string;
+    source: string;
+}
+interface ResponseInteraction {
+    responseIdentifier: string;
+    response: string | string[];
+}
+interface Calculate {
+    calculate: () => string | string[];
+}
+type float = number;
+type integer = number;
+type BaseType = 'boolean' | 'directedPair' | 'duration' | 'float' | 'integer' | 'string' | 'identifier' | 'pair';
+type Multiple = string | string[][];
+type Ordered = string | string[][];
+type Cardinality = 'multiple' | 'ordered' | 'single';
+
+interface OutcomeChangedDetails {
+    item: string;
+    outcomeIdentifier: string;
+    value: number | string | string[];
+}
+type InteractionChangedDetails = ResponseInteraction & {
+    item: string;
+};
+
+type QtiOutcomeChanged = CustomEvent<OutcomeChangedDetails>;
+declare global {
+    interface GlobalEventHandlersEventMap {
+        'qti-outcome-changed': QtiOutcomeChanged;
+    }
+}
+
+type qtiOutcomeChanged_QtiOutcomeChanged = QtiOutcomeChanged;
+declare namespace qtiOutcomeChanged {
+  export {
+    qtiOutcomeChanged_QtiOutcomeChanged as QtiOutcomeChanged,
+    QtiOutcomeChanged as default,
+  };
+}
+
+type QtiInteractionChanged = CustomEvent<InteractionChangedDetails>;
+declare global {
+    interface GlobalEventHandlersEventMap {
+        "qti-interaction-changed": QtiInteractionChanged;
+    }
+}
+
+type qtiInteractionChanged_QtiInteractionChanged = QtiInteractionChanged;
+declare namespace qtiInteractionChanged {
+  export {
+    qtiInteractionChanged_QtiInteractionChanged as QtiInteractionChanged,
+    QtiInteractionChanged as default,
+  };
+}
+
+interface VariableDeclaration<T> {
+    identifier: string;
+    cardinality: Cardinality;
+    baseType: BaseType;
+    value: T;
+}
+
+type QtiRegisterVariable = CustomEvent<{
+    variable: VariableDeclaration<number | string | string[]>;
+}>;
+declare global {
+    interface GlobalEventHandlersEventMap {
+        "qti-register-variable": QtiRegisterVariable;
+    }
+}
+
+declare namespace qtiRegisterVariable {
+  export {
+    QtiRegisterVariable as default,
+  };
+}
+
+type QtiRegisterInteraction = CustomEvent<Record<PropertyKey, never>>;
+declare global {
+    interface GlobalEventHandlersEventMap {
+        'qti-register-interaction': QtiRegisterInteraction;
+    }
+}
+
+declare namespace qtiRegisterInteraction {
+  export {
+    QtiRegisterInteraction as default,
+  };
+}
+
+type QtiRegisterChoice = CustomEvent<Record<PropertyKey, never>>;
+declare global {
+    interface GlobalEventHandlersEventMap {
+        'qti-register-choice': QtiRegisterChoice;
+    }
+}
+
+declare namespace qtiRegisterChoice {
+  export {
+    QtiRegisterChoice as default,
+  };
+}
+
+type QtiRegisterHotspot = CustomEvent<Record<PropertyKey, never>>;
+declare global {
+    interface GlobalEventHandlersEventMap {
+        'qti-register-hotspot': QtiRegisterHotspot;
+    }
+}
+
+declare namespace qtiRegisterHotspot {
+  export {
+    QtiRegisterHotspot as default,
+  };
+}
+
+type QtiLooseChoice = CustomEvent<Record<PropertyKey, never>>;
+declare global {
+    interface GlobalEventHandlersEventMap {
+        'qti-loose-choice': QtiLooseChoice;
+    }
+}
+
+declare namespace qtiLooseChoice {
+  export {
+    QtiLooseChoice as default,
+  };
+}
+
+type QtiInteractionResponse = CustomEvent<ResponseInteraction>;
+declare global {
+    interface GlobalEventHandlersEventMap {
+        'qti-interaction-response': QtiInteractionResponse;
+    }
+}
+
+declare namespace qtiInteractionResponse {
+  export {
+    QtiInteractionResponse as default,
+  };
+}
+
+type QtiChoiceElementSelected = CustomEvent<{
+    identifier: string;
+    checked: boolean;
+}>;
+declare global {
+    interface GlobalEventHandlersEventMap {
+        'qti-choice-element-selected': QtiChoiceElementSelected;
+    }
+}
+
+declare namespace qtiChoiceElementSelected {
+  export {
+    QtiChoiceElementSelected as default,
+  };
+}
+
+declare const Events: {
+    ON_OUTCOME_CHANGED: string;
+    ON_INTERACTION_CHANGED: string;
+    ON_REGISTER_VARIABLE: string;
+    ON_REGISTER_FEEDBACK: string;
+    ON_REGISTER_INTERACTION: string;
+    ON_REGISTER_CHOICE: string;
+    ON_REGISTER_HOTSPOT: string;
+    ON_LOOSE_CHOICE: string;
+    ON_INTERACTION_RESPONSE: string;
+    ON_DROPDOWN_SELECTED: string;
+    ON_CHOICE_ELEMENT_SELECTED: string;
+};
+
+declare class QtiMapping extends LitElement {
+    defaultValue: number;
+    lowerBound: number;
+    upperBound: number;
+    get mapEntries(): {
+        mapKey: string;
+        mappedValue: number;
+    }[];
+}
+
+declare class ResponseVariable implements VariableDeclaration<string | string[]> {
+    private _candidateResponse;
+    private _mapping;
+    private _correctResponse;
+    private _cardinality;
+    private _identifier;
+    private _basetype;
+    private _qtiVariable;
+    constructor({ mapping, correctResponse, cardinality, baseType, identifier, }: {
+        mapping: QtiMapping;
+        correctResponse: string | string[];
+        cardinality: Cardinality;
+        baseType: BaseType;
+        identifier: string;
+    });
+    get mapping(): QtiMapping;
+    get correctResponse(): string | string[];
+    get cardinality(): Cardinality;
+    get baseType(): BaseType;
+    get identifier(): string;
+    get value(): string | string[];
+    set value(val: string | string[]);
+}
+
+declare class OutcomeVariable implements VariableDeclaration<number | string | string[] | undefined> {
+    identifier: string;
+    cardinality: Cardinality;
+    baseType: BaseType;
+    value: number | string | string[] | undefined;
+}
+
+/**
+ * @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
+ * @status stable
+ * @since 4.0
+ *
+ * @dependency qti-feedback
+ * @dependency qti-responseprocessing
+ *
+ * @slot - The default slot where all the other QTI 3 item structures go.
+ *
+ * @event qti-interaction-changed - Emitted when an interaction is changed.
+ * @event qti-outcome-changed - Emitted when the radio group receives user input.
+ *
+ */
+declare class QtiAssessmentItem extends LitElement {
+    variables: VariableDeclaration<(string | string[]) | number>[];
+    private feedbackElements;
+    private interactionElements;
+    disabled: boolean;
+    readonly: boolean;
+    title: string;
+    identifier: string;
+    render(): lit_html.TemplateResult<1>;
+    _handleDisabledChange: (_: boolean, disabled: boolean) => void;
+    _handleReadonlyChange: (_: boolean, readonly: boolean) => void;
+    constructor();
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    private _registerVariable;
+    showCorrectResponse(): void;
+    processResponse(): boolean;
+    set responses(myResponses: ResponseInteraction[]);
+    resetInteractions(): void;
+    validateResponses(): boolean;
+    getVariable(identifier: string): VariableDeclaration<any>;
+    getResponse(identifier: string): ResponseVariable | null;
+    getOutcome(identifier: string): OutcomeVariable | null;
+    private registerFeedbackElement;
+    private registerInteractionElement;
+    private interactionResponse;
+    private outcomeChanged;
+    private showFeedback;
+    setOutcomeValue(identifier: string, value: string | number): void;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'qti-assessment-item': QtiAssessmentItem;
+    }
+}
+
+declare class QtiStylesheet extends LitElement {
+    private styleLink;
+    constructor();
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+}
+
+/**
+ * @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
+ *
+ */
+declare class QtiItemBody extends LitElement {
+    static styles: CSSResultGroup;
+    render(): lit_html.TemplateResult<1>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'qti-item-body': QtiItemBody;
+    }
+}
+
+declare class QtiPrompt extends LitElement {
+    render(): lit_html.TemplateResult<1>;
+    connectedCallback(): void;
+}
+
+/**
+ * @summary qti-choice is used by qti-simple-choice, qti-inline-choice, qti-hottext, qti-hotspot-choice.
+ *
+ * @since 1.0
+ * @status stable
+ *
+ * @event qti-register-choice - register itselves on a qti-choice-interaction element.
+ * @event qti-loose-choice - de-register itselves on a qti-choice-interaction element.
+ * @event qti-choice-element-selected - Emitted when the choice is selected.
+ *
+ * @slot - The choices slot element
+ */
+declare abstract class QtiChoice extends LitElement {
+    identifier: string;
+    tabindex: number | undefined;
+    disabled: boolean;
+    readonly: boolean;
+    checked: boolean;
+    handleDisabledChange(_: boolean, disabled: boolean): void;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    reset(): void;
+    private _onKeyUp;
+    private _onClick;
+    private _toggleChecked;
+    validateAllProps(): boolean;
+    render(): lit_html.TemplateResult;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'qti-choice': QtiChoice;
+    }
+}
+
+declare class QtiVariableDeclaration extends LitElement {
+    render(): lit_html.TemplateResult<1>;
+}
+
+declare class QtiResponseDeclaration extends QtiVariableDeclaration {
+    baseType: BaseType;
+    identifier: string;
+    cardinality: Cardinality;
+    connectedCallback(): void;
+    private get correctResponse();
+    private get mapping();
+}
+
+declare class QtiOutcomeDeclaration extends QtiVariableDeclaration {
+    baseType: BaseType;
+    identifier: string;
+    cardinality: Cardinality;
+    get interpolationTable(): any;
+    connectedCallback(): void;
+}
+
+declare class QtiCompanionMaterialsInfo extends LitElement {
+}
+
+interface Audience {
+    view: 'author' | 'candidate' | 'proctor' | 'scorer' | 'testConstructor' | 'tutor';
+}
+
+declare class qtiRubricBlock extends LitElement {
+    id: any;
+    use: 'instructions' | 'scoring' | 'navigation';
+    view: 'author' | 'candidate' | 'proctor' | 'scorer' | 'testConstructor' | 'tutor';
+    classNames: any;
+    handleclassNamesChange(old: any, disabled: boolean): void;
+    static styles: lit.CSSResult;
+    logger: ContextConsumer<{
+        __context__: Audience;
+    }, this>;
+    render(): lit_html.TemplateResult<1>;
+    connectedCallback(): void;
+}
+
+declare class qtiContentBody extends LitElement {
+    render(): lit_html.TemplateResult<1>;
+}
+
+declare abstract class QtiFeedback extends LitElement {
+    protected showHide: string;
+    protected outcomeIdentifier: string;
+    protected identifier: string;
+    protected showStatus: string;
+    constructor();
+    connectedCallback(): void;
+    checkShowFeedback(outcomeIdentifier: string): void;
+    private showFeedback;
+}
+
+declare class QtiFeedbackInline extends QtiFeedback {
+    static styles: lit.CSSResult;
+    render: () => lit_html.TemplateResult<1>;
+}
+
+declare class QtiModalFeedback extends QtiFeedback {
+    render(): lit_html.TemplateResult<1>;
+}
+
+declare class QtiFeedbackBlock extends QtiFeedback {
+    render(): lit_html.TemplateResult<1>;
+    protected firstUpdated(_changedProperties: PropertyValueMap<any> | Map<PropertyKey, unknown>): void;
+}
+
+declare abstract class Interaction extends LitElement {
+    responseIdentifier: string;
+    /** disabled should be exposed to the attributes and accessible as property */
+    disabled: boolean;
+    /** readonly should be exposed to the attributes and accessible as property */
+    readonly: boolean;
+    abstract reset(): void;
+    abstract validate(): boolean;
+    abstract set response(val: string | string[]);
+    connectedCallback(): void;
+    saveResponse(value: string | string[]): void;
+}
+
+declare class QtiTextEntryInteraction extends Interaction {
+    expectedLength: number;
+    patternMask: string;
+    placeholderText: string;
+    private _value;
+    private _size;
+    inputRef: lit_html_directives_ref.Ref<HTMLInputElement>;
+    classNames: any;
+    handleclassNamesChange(old: any, classes: string): void;
+    set response(value: string | undefined);
+    validate(): boolean;
+    static get styles(): lit.CSSResult[];
+    render(): lit_html.TemplateResult<1>;
+    protected textChanged(event: Event): void;
+    reset(): void;
+    private setEmptyAttribute;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'qti-text-entry-interaction': QtiTextEntryInteraction;
+    }
+}
+
+declare class QtiExtendedTextInteraction extends Interaction {
+    textareaRef: lit_html_directives_ref.Ref<HTMLTextAreaElement>;
+    /** 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;
+    private _value;
+    classNames: any;
+    handleclassNamesChange(old: any, disabled: boolean): void;
+    set response(value: string);
+    validate(): boolean;
+    static get styles(): lit.CSSResult[];
+    render(): lit_html.TemplateResult<1>;
+    protected textChanged(event: Event): void;
+    reset(): void;
+    private setEmptyAttribute;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'qti-extended-text-interaction': QtiExtendedTextInteraction;
+    }
+}
+
+declare abstract class Choices extends Interaction {
+    protected _choiceElements: QtiChoice[];
+    /** the minimal number of selections a candidate must make */
+    minChoices: number;
+    /** the maximum number of selections a candidate must make, the other options will be disabled when max options is checked */
+    maxChoices: number;
+    _handleDisabledChange: (_: boolean, disabled: boolean) => void;
+    _handleReadonlyChange: (_: boolean, readonly: boolean) => void;
+    _handleMaxChoicesChange: () => void;
+    constructor();
+    reset(): void;
+    validate(): boolean;
+    set response(myResponse: ResponseType);
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    private _registerChoiceElement;
+    private _looseChoiceElement;
+    private _determineInputType;
+    private _setInputType;
+    private _choiceElementSelectedHandler;
+    private _choiceElementSelected;
+}
+
+declare class QtiHottextInteraction extends Choices {
+    connectedCallback(): void;
+    render: () => lit_html.TemplateResult<1>;
+}
+
+interface OptionType {
+    textContent: string;
+    value: string;
+    selected: boolean;
+}
+declare class QtiInlineChoiceInteraction extends Interaction {
+    options: OptionType[];
+    static inputWidthClass: string[];
+    static get properties(): {
+        options: {
+            type: ArrayConstructor;
+            value: any[];
+            attribute: boolean;
+        };
+    };
+    connectedCallback(): void;
+    static get styles(): lit.CSSResult[];
+    render(): lit_html.TemplateResult<1>;
+    constructor();
+    validate(): boolean;
+    reset(): void;
+    set response(value: string);
+    choiceSelected(event: Event): void;
+}
+
+/**
+ * @summary The ChoiceInteraction.Type (qti-choice-interaction) interaction presents a collection of choices to the candidate.
+ * @documentation https://www.imsglobal.org/spec/qti/v3p0/impl#h.j9nu1oa1tu3b
+ * @status stable
+ * @since 6.0
+ *
+ * @event qti-register-interaction - emitted when the interaction wants to register itself
+ * @event qti-interaction-response - emitted when the interaction changes
+ *
+ * @slot - The default slot where <qti-simple-choice> must be placed.
+ * @slot prompt - slot where the prompt is placed.
+ */
+declare class QtiChoiceInteraction extends Choices {
+    static styles: CSSResultGroup;
+    /** orientation of choices */
+    orientation: 'horizontal' | 'vertical';
+    render: () => lit_html.TemplateResult<1>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'qti-choice-interaction': QtiChoiceInteraction;
+    }
+}
+
+declare class QtiResponseProcessing extends LitElement {
+    render(): lit_html.TemplateResult<1>;
+    static get observedAttributes(): string[];
+    process(): void;
+    private fragmentFromString;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'qti-response-processing': QtiResponseProcessing;
+    }
+}
+
+declare class QtiRule extends LitElement {
+    render(): lit_html.TemplateResult<1>;
+    process(): void;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'qti-rule': QtiRule;
+    }
+}
+
+declare class QtiResponseCondition extends QtiRule {
+    render(): lit_html.TemplateResult<1>;
+    process(): void;
+}
+
+declare class QtiSetOutcomeValue extends QtiRule {
+    process(): void;
+}
+
+declare class QtiResponseElse extends LitElement {
+    static get properties(): {
+        debugCalculateResult: {
+            type: ObjectConstructor;
+        };
+    };
+    render(): lit_html.TemplateResult<1>;
+    calculate(): boolean;
+    getSubRules(): QtiRule[];
+    process(): void;
+}
+
+declare class QtiResponseIf extends QtiResponseElse {
+    render(): lit_html.TemplateResult<1>;
+    calculate(): boolean;
+    getSubRules(): QtiRule[];
+}
+
+declare class QtiResponseElseIf extends QtiResponseIf {
+    render(): lit_html.TemplateResult<1>;
+}
+
+declare class QtiExpression<T> extends LitElement {
+    protected _error: any[];
+    protected set error(val: string);
+    static styles: lit.CSSResult;
+    render(): lit_html.TemplateResult<1>;
+    calculate(): T;
+    protected get assessmentItem(): QtiAssessmentItem;
+    protected getVariables: () => VariableDeclaration<string | string[]>[];
+}
+
+declare class QtiGt extends QtiExpression<boolean> {
+    calculate(): boolean;
+}
+
+declare class QtiConditionExpression extends QtiExpression<boolean> {
+    render(): lit_html.TemplateResult<1>;
+    calculate(): boolean;
+}
+
+declare class QtiGte extends QtiConditionExpression {
+    calculate(): boolean;
+}
+
+declare class QtiLt extends QtiExpression<boolean> {
+    calculate(): boolean;
+}
+
+declare class QtiLte extends QtiConditionExpression {
+    calculate(): boolean;
+}
+
+declare class QtiAnd extends QtiConditionExpression {
+    render(): lit_html.TemplateResult<1>;
+    calculate(): boolean;
+}
+
+declare class QtiProduct extends QtiExpression<number> {
+    mult: number;
+    render: () => lit_html.TemplateResult<1>;
+    calculate(): number;
+}
+
+declare class QtiOr extends QtiConditionExpression {
+    render(): lit_html.TemplateResult<1>;
+    calculate(): boolean;
+}
+
+declare class QtiEqual extends QtiExpression<boolean> {
+    toleranceMode: 'exact' | 'relative' | 'absolute';
+    calculate(): boolean;
+}
+
+declare class QtiEqualRounded extends QtiExpression<boolean> {
+    roundingMode: 'decimalPlaces' | 'significantFigures';
+    get figures(): number;
+    calculate(): boolean;
+}
+
+declare class QtiBaseValue extends QtiExpression<string> {
+    baseType: BaseType;
+    calculate(): string;
+}
+
+declare class QtiContains extends QtiExpression<boolean> {
+    calculate(): boolean;
+}
+
+declare class QtiCorrect extends QtiExpression<string | string[]> {
+    render(): lit_html.TemplateResult<1>;
+    get interpretation(): string;
+    calculate(): string | string[];
+}
+
+declare class QtiIsNull extends QtiExpression<boolean> {
+    calculate(): boolean;
+}
+
+declare class QtiNot extends QtiExpression<boolean> {
+    render(): lit_html.TemplateResult<1>;
+    calculate(): boolean;
+}
+
+declare class QtiMapResponse extends QtiExpression<number> {
+    identifier: string;
+    calculate(): number;
+}
+
+declare class QtiMatch extends QtiExpression<boolean> {
+    calculate(): boolean;
+}
+
+declare class QtiVariable extends QtiExpression<number | string | string[]> {
+    render(): lit_html.TemplateResult<1>;
+    calculate(): any;
+}
+
+declare class QtiMultiple extends QtiExpression<ResponseVariable[]> {
+    calculate(): ResponseVariable[];
+}
+
+declare class QtiOrdered extends QtiExpression<ResponseVariable[]> {
+    calculate(): ResponseVariable[];
+}
+
+declare class QtPrintedVariable extends LitElement {
+    value: string;
+    render(): lit_html.TemplateResult<1>;
+    constructor();
+    calculate(): any;
+}
+
+declare class QtiMember extends QtiExpression<boolean | null> {
+    calculate(): boolean;
+}
+
+declare class QtiPortableCustomInteraction extends LitElement {
+    private responseIdentifier;
+    private module;
+    private customInteractionTypeIdentifier;
+    private baseUrl;
+    private _errorMessage;
+    static get properties(): {
+        responseIdentifier: {
+            type: StringConstructor;
+            attribute: string;
+        };
+        module: {
+            type: StringConstructor;
+            attribute: string;
+        };
+        customInteractionTypeIdentifier: {
+            type: StringConstructor;
+            attribute: string;
+        };
+        baseUrl: {
+            type: StringConstructor;
+            attribute: string;
+        };
+        _errorMessage: {
+            type: StringConstructor;
+            state: boolean;
+        };
+    };
+    getTAOConfig(node: any): {} | void;
+    register(item: any): void;
+    connectedCallback(): void;
+    render(): lit_html.TemplateResult<1>;
+}
+
+interface IInteraction {
+    disabled: boolean;
+    readonly: boolean;
+    response: string | string[];
+    reset(): any;
+    validate(): boolean;
+}
+
+declare const QtiAssociateInteraction_base: (new (...args: any[]) => IInteraction) & typeof LitElement;
+declare class QtiAssociateInteraction extends QtiAssociateInteraction_base {
+    private _childrenMap;
+    static styles: lit.CSSResult;
+    render(): lit_html.TemplateResult<1>;
+    connectedCallback(): void;
+}
+
+declare const QtiGapMatchInteraction_base: (new (...args: any[]) => IInteraction) & typeof LitElement;
+declare class QtiGapMatchInteraction extends QtiGapMatchInteraction_base {
+    static styles: lit.CSSResult[];
+    render(): lit_html.TemplateResult<1>;
+}
+
+declare class QtiGraphicAssociateInteraction extends Interaction {
+    choiceOrdering: boolean;
+    hotspots: any;
+    startPoint: any;
+    endPoint: any;
+    _lines: any[];
+    startCoord: {
+        x: any;
+        y: any;
+    };
+    mouseCoord: {
+        x: number;
+        y: number;
+    };
+    svgContainer: any;
+    grImage: any;
+    static styles: lit.CSSResult[];
+    svg: SVGSVGElement;
+    constructor();
+    reset(): void;
+    validate(): boolean;
+    set response(val: string | string[]);
+    render(): lit_html.TemplateResult<1>;
+    private positionHotspotOnRegister;
+    firstUpdated(e: any): void;
+    disconnectedCallback(): void;
+}
+
+declare const QtiGraphicGapMatchInteraction_base: (new (...args: any[]) => IInteraction) & typeof LitElement;
+declare class QtiGraphicGapMatchInteraction extends QtiGraphicGapMatchInteraction_base {
+    static styles: lit.CSSResult;
+    render(): lit_html.TemplateResult<1>;
+    private positionHotspotOnRegister;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+}
+
+declare class QtiGraphicOrderInteraction extends Choices {
+    choiceOrdering: boolean;
+    static styles: lit.CSSResult[];
+    render(): lit_html.TemplateResult<1>;
+    private setHotspotOrder;
+    private positionHotspotOnRegister;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+}
+
+declare class QtiHotspotInteraction extends Choices {
+    static styles: lit.CSSResult[];
+    render(): lit_html.TemplateResult<1>;
+    private positionHotspotOnRegister;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+}
+
+declare class QtiSimpleAssociableChoice extends LitElement {
+    connectedCallback(): void;
+    render(): lit_html.TemplateResult<1>;
+}
+
+declare const QtiMatchInteraction_base: (new (...args: any[]) => IInteraction) & typeof LitElement;
+declare class QtiMatchInteraction extends QtiMatchInteraction_base {
+    static styles: any[];
+    rows: Element[];
+    cols: Element[];
+    connectedCallback(): void;
+    render(): lit_html.TemplateResult<1>;
+}
+
+declare class QtiMediaInteraction extends Interaction {
+    value: number;
+    reset(): void;
+    validate(): boolean;
+    set response(val: undefined);
+    static get properties(): {
+        step: {
+            type: NumberConstructor;
+            attribute: string;
+            default: number;
+        };
+    };
+    static styles: lit.CSSResult[];
+    render(): lit_html.TemplateResult<1>;
+    constructor();
+    connectedCallback(): void;
+}
+
+declare const QtiOrderInteraction_base: (new (...args: any[]) => IInteraction) & typeof LitElement;
+declare class QtiOrderInteraction extends QtiOrderInteraction_base {
+    childrenMap: Element[];
+    private _classNames;
+    private _orientation;
+    static layoutClass: string[];
+    /** orientation of choices */
+    orientation: 'horizontal' | 'vertical';
+    static styles: lit.CSSResult[];
+    render(): lit_html.TemplateResult<1>;
+    connectedCallback(): void;
+}
+
+declare class QtiSPositionObjectInteraction 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;
+    connectedCallback(): void;
+    removeMoveListener(event: any): void;
+    disconnectedCallback(): void;
+}
+
+declare class QtiSelectPointInteraction extends Interaction {
+    maxChoices: number;
+    minChoices: number;
+    private _points;
+    render(): lit_html.TemplateResult<1>;
+    static styles: lit.CSSResult[];
+    reset(): void;
+    validate(): boolean;
+    set response(val: string | string[]);
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+}
+
+/**
+ * @summary The SliderInteraction.Type (qti-slider-interaction) presents the candidate with a control for selecting a numerical value between a lower and upper bound.
+ * @documentation https://www.imsglobal.org/spec/qti/v3p0/impl#h.s61xcrj4qcyj
+ * @status stable
+ * @since 6.0
+ *
+ * @event qti-register-interaction - emitted when the interaction wants to register itself
+ * @event qti-interaction-response - emitted when the interaction changes
+ *
+ * @cssprop --show-value - shows the current value while sliding
+ * @cssprop --show-ticks - shows the ticks according to steps
+ * @cssprop --show-bounds - shows value for lower and upper boundary
+ *
+ * @csspart slider -- slider inluding, bounds and ticks and value, use it for paddings and margins
+ * @csspart bounds -- div for bounds, containing two divs for with min, and max bounds value
+ * @csspart ticks -- div for ticks, use lineair gradient and exposed css variables for styling
+ * @csspart rail -- div for rail, style according to needs
+ * @csspart knob -- div, should be relative or absolute
+ * @csspart value -- div, containing value
+ *
+ * @slot - The default slot where <qti-simple-choice> must be placed.
+ * @slot prompt - slot where the prompt is placed.
+ */
+declare class QtiSliderInteraction extends Interaction {
+    csLive: CSSStyleDeclaration;
+    private _knob;
+    private _rail;
+    value: number;
+    stepLabel: boolean;
+    reverse: boolean;
+    private _min;
+    set min(value: number);
+    get min(): number;
+    private _max;
+    set max(value: number);
+    get max(): number;
+    private _step;
+    set step(value: number);
+    get step(): number;
+    _handleDisabledChange: (old: any, disabled: any) => void;
+    _handleReadonlyChange: (old: any, readonly: any) => void;
+    reset(): void;
+    validate(): boolean;
+    constructor();
+    set response(myResponse: string | string[]);
+    static styles: lit.CSSResult[];
+    render(): lit_html.TemplateResult<1>;
+    connectedCallback(): void;
+    private _onTouchMove;
+    private _onMouseDown;
+    /** calculateValue gets x position and compares this with the total width in pixels */
+    private calculateValue;
+    private getPositionFromEvent;
+}
+
+declare class QtiEndAttemptInteraction extends LitElement {
+    title: 'end attempt';
+    render(): lit_html.TemplateResult<1>;
+    endAttempt(e: Event): void;
+}
+
+declare class QtiAssociableHotspot extends LitElement {
+    connectedCallback(): void;
+    static styles: lit.CSSResult;
+    render(): lit_html.TemplateResult<1>;
+}
+
+declare class QtiGapImg extends LitElement {
+    tabindex: number | undefined;
+    connectedCallback(): void;
+}
+
+declare class QtiGapText extends LitElement {
+    tabindex: number | undefined;
+    connectedCallback(): void;
+    render(): lit_html.TemplateResult<1>;
+}
+
+declare class QtiGap extends LitElement {
+    tabindex: number | undefined;
+    render(): lit_html.TemplateResult<1>;
+}
+
+declare class QtiHotspotChoice extends QtiChoice {
+    order: number;
+    static styles: lit.CSSResult;
+}
+
+declare class QtiHottext extends QtiChoice {
+    render(): lit_html.TemplateResult<1>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'qti-hottext': QtiHottext;
+    }
+}
+
+declare class QtiInlineChoice extends LitElement {
+}
+
+/**
+ * @summary Short summary of the component's intended use.
+ * @documentation https://www.imsglobal.org/spec/qti/v3p0/impl#h.j9nu1oa1tu3b
+ * @status stable
+ * @since 4.0
+ *
+ * @event qti-choice-element-selected - Emitted when a choice is selected.
+ * @event qti-register-choice - Emitted when an choice is added
+ * @event qti-loose-choice - Emitted when a choice is removed
+ *
+ * @slot - The default slot.
+ */
+declare class QtiSimpleChoice extends QtiChoice {
+    render(): lit_html.TemplateResult<1>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'qti-simple-choice': QtiSimpleChoice;
+    }
+}
+
+declare class QtiItem extends LitElement {
+    disabled: boolean;
+    handleDisabledChange(old: any, disabled: boolean): void;
+    readonly: boolean;
+    handleReadonlyChange(old: any, readonly: boolean): void;
+    responses: ResponseInteraction[];
+    handleResponsesChange(old: any, responses: ResponseInteraction[]): void;
+    set qtiContext(context: {
+        view: 'author' | 'candidate' | 'proctor' | 'scorer' | 'testConstructor' | 'tutor';
+    });
+    private provider;
+    get _item(): QtiAssessmentItem;
+    private _xml;
+    set xml(val: string);
+    get xml(): string;
+    static styles: lit.CSSResult;
+    processResponse: () => boolean;
+    showCorrectResponse: () => void;
+    validateResponses: () => boolean;
+    resetInteractions: () => void;
+    connectedCallback(): void;
+    render: () => lit_html.TemplateResult<1>;
+}
+
+declare const qtiTransform: (xmlValue: string) => {
+    mathml(): any;
+    removeNamesSpaces(): any;
+    pciHooks(uri: string): any;
+    assetsLocation(uri: string, attributes?: string[]): any;
+    customTypes(): any;
+    suffix(elements: string[], suffix: string): any;
+    fn(fn: (xmlString: string) => string): any;
+    fnCh(fn: (xmlString: cheerio.CheerioAPI) => void): any;
+    elementNameAttributes(elements: string[]): any;
+    print(): any;
+    xml(): string;
+};
+
+export { BaseType, Calculate, Cardinality, Events, InteractionChangedDetails, Multiple, Ordered, OutcomeChangedDetails, OutcomeVariable, QtPrintedVariable, QtiAnd, QtiAssessmentItem, QtiAssociableHotspot, QtiAssociateInteraction, QtiBaseValue, QtiChoice, qtiChoiceElementSelected as QtiChoiceElementSelected, QtiChoiceInteraction, QtiCompanionMaterialsInfo, QtiContains, QtiCorrect, QtiEndAttemptInteraction, QtiEqual, QtiEqualRounded, QtiExpression, QtiExtendedTextInteraction, QtiFeedbackBlock, QtiFeedbackInline, QtiGap, QtiGapImg, QtiGapMatchInteraction, QtiGapText, QtiGraphicAssociateInteraction, QtiGraphicGapMatchInteraction, QtiGraphicOrderInteraction, QtiGt, QtiGte, QtiHotspotChoice, QtiHotspotInteraction, QtiHottext, QtiHottextInteraction, QtiInlineChoice, QtiInlineChoiceInteraction, qtiInteractionChanged as QtiInteractionChanged, qtiInteractionResponse as QtiInteractionResponse, QtiIsNull, QtiItem, qtiLooseChoice as QtiLooseChoice, QtiLt, QtiLte, QtiMapResponse, QtiMapping, QtiMatch, QtiMatchInteraction, QtiMediaInteraction, QtiMember, QtiModalFeedback, QtiMultiple, QtiNot, QtiOr, QtiOrderInteraction, QtiOrdered, qtiOutcomeChanged as QtiOutcomeChanged, QtiOutcomeDeclaration, QtiPortableCustomInteraction, QtiPositionObjectStage, QtiProduct, QtiPrompt, qtiRegisterChoice as QtiRegisterChoice, qtiRegisterHotspot as QtiRegisterHotspot, qtiRegisterInteraction as QtiRegisterInteraction, qtiRegisterVariable as QtiRegisterVariable, QtiResponseCondition, QtiResponseDeclaration, QtiResponseElse, QtiResponseElseIf, QtiResponseIf, QtiResponseProcessing, QtiRule, QtiSPositionObjectInteraction, QtiSelectPointInteraction, QtiSetOutcomeValue, QtiSimpleAssociableChoice, QtiSimpleChoice, QtiSliderInteraction, QtiStylesheet, QtiTextEntryInteraction, QtiVariable, ResponseInteraction, ResponseVariable, directedPair, float, integer, qtiContentBody, qtiRubricBlock, qtiTransform };