@citolab/qti-components 3.0.83 → 6.0.0-0

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

@@ -0,0 +1,786 @@
+import { R as ResponseType$1, a as ResponseInteraction, Q as QtiVariableJSON, B as BaseType, C as Cardinality } from '../ExpressionResult-2192c3d8.js';
+export { c as Calculate, I as InputResponseFormat, M as Multiple, O as Ordered, b as ResponseItem, d as directedPair, f as float, i as integer } from '../ExpressionResult-2192c3d8.js';
+import { V as VariableDeclaration, Q as QtiElement } from '../qti-assessment-item-e9f437d6.js';
+export { O as OutcomeVariable, a as QtiAssessmentItem, R as ResponseVariable } from '../qti-assessment-item-e9f437d6.js';
+import * as lit from 'lit';
+import { LitElement, CSSResultGroup } 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';
+
+interface OutcomeChangedDetails {
+    item: string;
+    outcomeIdentifier: string;
+    value: ResponseType$1;
+}
+type InteractionChangedDetails = ResponseInteraction<QtiVariableJSON>;
+
+type QtiOutcomeChanged = CustomEvent<{
+    item: string;
+    outcomeIdentifier: string;
+    value: ResponseType$1;
+}>;
+declare global {
+    interface GlobalEventHandlersEventMap {
+        'qti-outcome-changed': QtiOutcomeChanged;
+    }
+}
+
+declare namespace qtiOutcomeChanged {
+  export {
+    QtiOutcomeChanged as default,
+  };
+}
+
+type QtiInteractionChanged = CustomEvent<{
+    item: string | null;
+    interaction: ResponseInteraction<QtiVariableJSON>;
+}>;
+declare global {
+    interface GlobalEventHandlersEventMap {
+        'qti-interaction-changed': QtiInteractionChanged;
+    }
+}
+
+declare namespace qtiInteractionChanged {
+  export {
+    QtiInteractionChanged as default,
+  };
+}
+
+type QtiRegisterVariable = CustomEvent<{
+    variable: VariableDeclaration;
+}>;
+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<{
+    responseIdentifier: string;
+    responses: QtiVariableJSON;
+}>;
+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 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 QtiElement {
+    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<2 | 1>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'qti-choice': QtiChoice;
+    }
+}
+
+declare class QtiVariableDeclaration extends QtiElement {
+    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 {
+    static get observedAttributes(): string[];
+    connectedCallback(): void;
+}
+
+declare class QtiCompanionMaterialsInfo extends QtiElement {
+}
+
+interface Logger {
+    view: string;
+    log: (msg: string) => void;
+}
+
+declare class qtiRubricBlock extends QtiElement {
+    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__: Logger;
+    }, this>;
+    render(): lit_html.TemplateResult<1>;
+    connectedCallback(): void;
+}
+
+declare class qtiContentBody extends QtiElement {
+    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, outcomeValue: ResponseType$1): 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 abstract class Interaction extends QtiElement {
+    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: ResponseType$1);
+    connectedCallback(): void;
+    saveResponse(value: QtiVariableJSON): void;
+}
+
+declare class QtiTextEntryInteraction extends Interaction {
+    static inputWidthClass: string[];
+    value: string;
+    expectedLength: any;
+    placeholderText: any;
+    patternMask: any;
+    static get properties(): {
+        expectedLength: {
+            type: NumberConstructor;
+            attribute: string;
+        };
+        patternMask: {
+            type: StringConstructor;
+            attribute: string;
+        };
+        placeholderText: {
+            type: StringConstructor;
+            attribute: string;
+        };
+        value: {
+            type: StringConstructor;
+        };
+    };
+    constructor();
+    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 class QtiExtendedTextInteraction extends Interaction {
+    static rowHeightClass: string[];
+    textareaRef: lit_html_directives_ref.Ref<HTMLTextAreaElement>;
+    expectedLength: any;
+    patternMask: any;
+    placeholderText: any;
+    value: string;
+    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 class QtiHottext extends QtiChoice {
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'qti-hottext': QtiHottext;
+    }
+}
+
+declare abstract class Choices extends Interaction {
+    protected _choiceElements: QtiChoice[];
+    minChoices: number;
+    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 4.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;
+    }
+}
+
+/**
+ * @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 {
+    static styles: CSSResultGroup;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'qti-simple-choice': QtiSimpleChoice;
+    }
+}
+
+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 QtiPortableCustomInteraction extends QtiElement {
+    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: ResponseType$1;
+    reset(): any;
+    validate(): boolean;
+}
+
+declare const QtiAssociateInteraction_base: (new (...args: any[]) => IInteraction) & typeof QtiElement;
+declare class QtiAssociateInteraction extends QtiAssociateInteraction_base {
+    private _childrenMap;
+    static styles: lit.CSSResult;
+    render(): lit_html.TemplateResult<1>;
+    connectedCallback(): void;
+}
+
+declare class qtiSimpleAssociableChoice extends LitElement {
+    connectedCallback(): void;
+    render(): lit_html.TemplateResult<1>;
+}
+
+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 QtiGapText extends LitElement {
+    connectedCallback(): void;
+    render(): lit_html.TemplateResult<1>;
+}
+
+declare class QtiGap extends LitElement {
+    render(): lit_html.TemplateResult<1>;
+}
+
+declare class QtiGraphicAssociateInteraction extends Choices {
+    choiceOrdering: boolean;
+    static styles: lit.CSSResult[];
+    render(): lit_html.TemplateResult<1>;
+    private positionHotspotOnRegister;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+}
+
+declare const QtiGraphicGapMatchInteraction_base: (new (...args: any[]) => IInteraction) & typeof QtiElement;
+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 QtiHotspotChoice extends QtiChoice {
+    order: number;
+    static styles: lit.CSSResult;
+}
+
+declare const QtiMatchInteraction_base: (new (...args: any[]) => IInteraction) & typeof LitElement;
+declare class QtiMatchInteraction extends QtiMatchInteraction_base {
+    static styles: lit.CSSResult[];
+    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 QtiElement;
+declare class QtiOrderInteraction extends QtiOrderInteraction_base {
+    childrenMap: Element[];
+    private _classNames;
+    private _orientation;
+    static layoutClass: string[];
+    static get properties(): {
+        _classNames: {
+            type: StringConstructor;
+            attribute: string;
+        };
+        _orientation: {
+            type: StringConstructor;
+            attribute: string;
+        };
+    };
+    static styles: lit.CSSResult[];
+    render(): lit_html.TemplateResult<1>;
+    connectedCallback(): void;
+}
+
+declare class QtiSelectPointInteraction extends Choices {
+    static styles: lit.CSSResult[];
+    choiceOrdering: boolean;
+    render(): lit_html.TemplateResult<1>;
+    constructor();
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+}
+
+declare class QtiSliderInteraction extends Interaction {
+    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;
+    set response(myResponse: ResponseType$1);
+    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;
+}
+
+/**
+ * Copyright (c) 2020 Jonas Jelonek <jonas.jelonek@protonmail.ch>
+ * https://github.com/jonasjelonek/TouchDragAndDrop
+ */
+declare class TouchDragAndDrop {
+    _touchBegin: number;
+    _touchDown: any;
+    _lastClick: number;
+    _canDrag: boolean;
+    _dragSrc: any;
+    _dragCopy: any;
+    _touchEndCalled: boolean;
+    _dragRunning: boolean;
+    _dataTransfer: {
+        data: {};
+        setData: (type: any, val: any) => void;
+        getData: (type: any) => any;
+        effectAllowed: string;
+    };
+    _copyOffset: {
+        x: number;
+        y: number;
+    };
+    _lastTarget: any;
+    _currentDropContainer: any;
+    _handleClick: boolean;
+    _DBLCLICKDELAY: number;
+    _CONTEXTMENUDELAY: number;
+    _DRAGDELTA: number;
+    _COPYOPACITY: number;
+    static _instance: TouchDragAndDrop;
+    copyStylesDragClone: boolean;
+    dragOnClick: boolean;
+    constructor();
+    addDraggables(draggables: Element[]): void;
+    /**
+     * Callback for touchstart event listener.
+     * @param {TouchEvent} e
+     */
+    _touchStart(e: any): void;
+    /**
+     * Callback for touchmove event listener.
+     * @param {TouchEvent} e
+     */
+    _touchMove(e: any): void;
+    createDragCopy: (e: any, _touches: {
+        clientX: number;
+        clientY: number;
+    }) => void;
+    /**
+     * Callback for touchend event listener.
+     * @param {TouchEvent} e
+     */
+    _touchEnd(e: any): void;
+    /**
+     * Callback for touchcancel event listener, in case browser supports this.
+     * @param {TouchEvent} e
+     */
+    _touchCancel(e: any): void;
+    /**
+     * Determines the next droppable element at current point.
+     * @param {Object} pt
+     */
+    _findDroppable(event: any): any;
+    _getPoint(event: any, page?: any): {
+        x: any;
+        y: any;
+    };
+    /**
+     * Calculates the offset for displaying the drag copy to have a seamless dragging.
+     * @param {Touch} touch The current touch.
+     */
+    _calculateDragCopyPosition(touch: any): void;
+    /**
+     * Calculates the pixel delta between first touch and the current touch position.
+     * @param {Object} touch
+     */
+    _getDelta(touch: any): number;
+    /**
+     *
+     * @param {Element} e The event's target element.
+     * @param {string} eventType The type of the event.
+     * @param {bool} bubble Sets whether the event should bubble.
+     */
+    _dispatchEvent(e: any, eventType: any, bubble?: boolean): boolean;
+    /**
+     * Resets all variables and prepares for new Drag and Drop.
+     */
+    _reset(): void;
+    private getPositionFromEvent;
+}
+
+type Constructor$2<T> = new (...args: any[]) => T;
+declare const DragDropInteractionMixin: <T extends Constructor$2<LitElement>>(superClass: T, draggablesSelector: string, droppablesInShadowRoot: boolean, droppablesSelector: string) => Constructor$2<IInteraction> & T;
+
+type Constructor$1<T> = new (...args: any[]) => T;
+declare class DroppablesInterface {
+}
+declare const DroppablesMixin: <T extends Constructor$1<LitElement>>(superClass: T, droppablesInShadowRoot: boolean, droppablesSelector: string) => Constructor$1<DroppablesInterface> & T;
+
+type Constructor<T> = new (...args: any[]) => T;
+declare class FlippablesInterface {
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+}
+declare const FlippablesMixin: <T extends Constructor<LitElement>>(superClass: T, droppablesSel: string, draggablesSel: string) => Constructor<FlippablesInterface> & T;
+
+export { BaseType, Cardinality, Choices, DragDropInteractionMixin, DroppablesMixin, Events, FlippablesInterface, FlippablesMixin, InteractionChangedDetails, OutcomeChangedDetails, QtiAssociateInteraction, QtiChoice, qtiChoiceElementSelected as QtiChoiceElementSelected, QtiCompanionMaterialsInfo, QtiExtendedTextInteraction, QtiFeedbackInline, QtiGap, QtiGapMatchInteraction, QtiGapText, QtiGraphicAssociateInteraction, QtiGraphicGapMatchInteraction, QtiGraphicOrderInteraction, QtiHotspotChoice, QtiHotspotInteraction, QtiHottext, QtiHottextInteraction, QtiInlineChoiceInteraction, qtiInteractionChanged as QtiInteractionChanged, qtiInteractionResponse as QtiInteractionResponse, qtiLooseChoice as QtiLooseChoice, QtiMatchInteraction, QtiMediaInteraction, QtiModalFeedback, QtiOrderInteraction, qtiOutcomeChanged as QtiOutcomeChanged, QtiOutcomeDeclaration, QtiPortableCustomInteraction, QtiPrompt, qtiRegisterChoice as QtiRegisterChoice, qtiRegisterHotspot as QtiRegisterHotspot, qtiRegisterInteraction as QtiRegisterInteraction, qtiRegisterVariable as QtiRegisterVariable, QtiResponseDeclaration, QtiResponseProcessing, QtiRule, QtiSelectPointInteraction, QtiSliderInteraction, QtiStylesheet, QtiTextEntryInteraction, QtiVariableJSON, ResponseInteraction, ResponseType$1 as ResponseType, TouchDragAndDrop, qtiContentBody, qtiRubricBlock, qtiSimpleAssociableChoice };