@citolab/qti-components 6.9.1-beta.65 → 6.9.1-beta.67

package/dist/qti-simple-choice-C2d4_r3u.d.cts

@@ -0,0 +1,1137 @@
+import * as lit_html from 'lit-html';
+import * as lit from 'lit';
+import { LitElement, CSSResultGroup, PropertyValueMap } from 'lit';
+import * as lit_html_directives_ref_js from 'lit-html/directives/ref.js';
+
+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: Readonly<string | string[]>;
+}
+type InteractionChangedDetails = ResponseInteraction & {
+    item: string;
+};
+
+type QtiInteractionChanged = CustomEvent<InteractionChangedDetails>;
+declare global {
+    interface GlobalEventHandlersEventMap {
+        'qti-interaction-changed': QtiInteractionChanged;
+    }
+}
+
+type QtiOutcomeChanged = CustomEvent<OutcomeChangedDetails>;
+declare global {
+    interface GlobalEventHandlersEventMap {
+        'qti-outcome-changed': QtiOutcomeChanged;
+    }
+}
+
+declare class QtiMapping extends LitElement {
+    defaultValue: number;
+    lowerBound: number;
+    upperBound: number;
+    get mapEntries(): {
+        mapKey: string;
+        mappedValue: number;
+    }[];
+}
+
+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;
+    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
+ * @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 an outcome has changed.
+ * @event qti-response-processing - Emitted when response-processing is called.
+ *
+ */
+declare class QtiAssessmentItem extends LitElement {
+    title: string;
+    identifier: string;
+    adaptive: 'true' | 'false';
+    timeDependent: 'true' | 'false' | null;
+    disabled: boolean;
+    _handleDisabledChange: (_: boolean, disabled: boolean) => void;
+    readonly: boolean;
+    _handleReadonlyChange: (_: boolean, readonly: boolean) => void;
+    private _context;
+    get variables(): VariableValue<string | string[] | null>[];
+    set variables(value: VariableValue<string | string[] | null>[]);
+    private _initialContext;
+    private _feedbackElements;
+    private _interactionElements;
+    connectedCallback(): Promise<void>;
+    /** @deprecated use variables property instead */
+    set responses(myResponses: ResponseInteraction[]);
+    render(): lit_html.TemplateResult<1>;
+    constructor();
+    showCorrectResponse(show: boolean): void;
+    processResponse(countNumAttempts?: boolean): boolean;
+    resetResponses(): void;
+    getResponse(identifier: string): Readonly<ResponseVariable>;
+    getOutcome(identifier: string): Readonly<OutcomeVariable>;
+    getVariable(identifier: string): Readonly<VariableDeclaration<string | string[] | null>>;
+    private handleUpdateResponseVariable;
+    updateResponseVariable(identifier: string, value: string | string[] | undefined): void;
+    updateOutcomeVariable(identifier: string, value: string | string[] | undefined): void;
+    private _getCompletionStatus;
+    private _emit;
+}
+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;
+    }
+}
+
+type Constructor$1<T = {}> = abstract new (...args: any[]) => T;
+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;
+}
+declare function ActiveElementMixin<T extends Constructor$1<LitElement>>(Base: T, type: string): Constructor$1<ActiveElementMixinInterface> & T;
+
+/**
+ * @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;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'qti-prompt': QtiPrompt;
+    }
+}
+
+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;
+    }
+}
+
+interface ItemContext {
+    href?: string;
+    identifier: string;
+    variables: ReadonlyArray<VariableDeclaration<string | string[]>>;
+}
+declare const itemContextVariables: VariableDeclaration<string | string[]>[];
+declare const itemContext: {
+    __context__: ItemContext;
+};
+
+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();
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'qti-response-declaration': QtiResponseDeclaration;
+    }
+}
+
+declare class QtiCompanionMaterialsInfo extends LitElement {
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'qti-companion-materials-info': QtiCompanionMaterialsInfo;
+    }
+}
+
+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(old: any, disabled: boolean): void;
+    static styles: lit.CSSResult;
+    render(): lit_html.TemplateResult<1>;
+    connectedCallback(): void;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'qti-rubric-block': QtiRubricBlock;
+    }
+}
+
+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>;
+    protected firstUpdated(_changedProperties: PropertyValueMap<any> | Map<PropertyKey, unknown>): void;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'qti-feedback-block': QtiFeedbackBlock;
+    }
+}
+
+declare class QtiFeedbackInline extends QtiFeedback {
+    static styles: lit.CSSResult;
+    render: () => lit_html.TemplateResult<1>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'qti-feedback-inline': QtiFeedbackInline;
+    }
+}
+
+declare class QtiModalFeedback extends QtiFeedback {
+    static styles: lit.CSSResult;
+    render: () => lit_html.TemplateResult<1>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'qti-modal-feedback': QtiModalFeedback;
+    }
+}
+
+interface IInteraction {
+    correctResponse: Readonly<string | string[]>;
+    value: string | string[];
+    responseIdentifier: string;
+    disabled: boolean;
+    readonly: boolean;
+    validate(): boolean;
+    reportValidity(): boolean;
+    reset(): void;
+    saveResponse(value: string | string[]): void;
+}
+
+declare abstract class Interaction extends LitElement implements IInteraction {
+    static formAssociated: boolean;
+    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;
+    protected _correctResponse: string | string[];
+    protected _internals: ElementInternals;
+    constructor();
+    abstract validate(): boolean;
+    reportValidity(): boolean;
+    reset(): void;
+    abstract get value(): string | string[];
+    abstract set value(val: string | string[]);
+    get correctResponse(): string | string[];
+    set correctResponse(value: string | string[]);
+    connectedCallback(): void;
+    saveResponse(value: string | string[]): void;
+}
+
+declare class QtiExtendedTextInteraction extends Interaction {
+    private _rows;
+    /** 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;
+    private _value;
+    classNames: any;
+    handleclassNamesChange(old: any, classes: string): void;
+    get value(): string | string[];
+    set value(val: string | string[]);
+    validate(): boolean;
+    reportValidity(): boolean;
+    static get styles(): lit.CSSResult[];
+    render(): lit_html.TemplateResult<1>;
+    protected textChanged(event: Event): void;
+    private setEmptyAttribute;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'qti-extended-text-interaction': QtiExtendedTextInteraction;
+    }
+}
+
+declare class QtiTextEntryInteraction extends Interaction {
+    static styles: CSSResultGroup;
+    expectedLength: number;
+    patternMask: string;
+    placeholderText: string;
+    dataPatternmaskMessage: string;
+    private _value;
+    inputRef: lit_html_directives_ref_js.Ref<HTMLInputElement>;
+    get value(): string | string[];
+    set value(val: string | string[]);
+    validate(): boolean;
+    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;
+    }
+}
+
+type Choice = HTMLElement & ChoiceInterface & {
+    internals: ElementInternals;
+};
+interface ChoicesInterface extends IInteraction {
+    _choiceElements: Array<Choice>;
+    correctResponse: string | string[];
+}
+
+declare const QtiHottextInteraction_base: (abstract new (...args: any[]) => ChoicesInterface) & typeof Interaction;
+declare class QtiHottextInteraction extends QtiHottextInteraction_base {
+    connectedCallback(): void;
+    render: () => lit_html.TemplateResult<1>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'qti-hottext-interaction': QtiHottextInteraction;
+    }
+}
+
+interface OptionType {
+    textContent: string;
+    value: string;
+    selected: boolean;
+}
+declare class QtiInlineChoiceInteraction extends Interaction {
+    static get styles(): lit.CSSResult[];
+    static inputWidthClass: string[];
+    options: OptionType[];
+    correctOption: string;
+    dataPrompt: string;
+    render(): lit_html.TemplateResult<1>;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    validate(): boolean;
+    reset(): void;
+    set value(value: string);
+    get value(): string;
+    set correctResponse(value: string | string[]);
+    choiceSelected(event: Event): void;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'qti-inline-choice-interaction': QtiInlineChoiceInteraction;
+    }
+}
+
+declare const QtiChoiceInteraction_base: (abstract new (...args: any[]) => {}) & (abstract new (...args: any[]) => {}) & (abstract new (...args: any[]) => ChoicesInterface) & typeof Interaction;
+declare class QtiChoiceInteraction extends QtiChoiceInteraction_base implements ChoicesInterface {
+    static styles: CSSResultGroup;
+    /** orientation of choices */
+    orientation: 'horizontal' | 'vertical';
+    render(): lit_html.TemplateResult<1>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'qti-choice-interaction': QtiChoiceInteraction;
+    }
+}
+
+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 QtiResponseProcessing extends LitElement {
+    static styles: lit.CSSResult[];
+    render(): lit_html.TemplateResult<1>;
+    process(): void;
+    firstUpdated(_changedProperties: PropertyValueMap<any> | Map<PropertyKey, unknown>): void;
+    private fragmentFromString;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'qti-response-processing': QtiResponseProcessing;
+    }
+}
+
+interface QtiExpressionBase<T> {
+    calculate(): Readonly<T>;
+}
+declare abstract class QtiExpression<T> extends LitElement implements QtiExpressionBase<T> {
+    protected result: any;
+    static styles: lit.CSSResult;
+    render(): lit_html.TemplateResult<1>;
+    calculate(): Readonly<T>;
+    protected getResult(): Readonly<T>;
+    protected context?: ItemContext;
+    getVariables: () => VariableDeclaration<number | string | (number | string)[] | null>[];
+}
+
+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;
+    }
+}
+
+/**
+ * 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;
+    get childExpression(): QtiExpression<string>;
+    process(): number;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'qti-lookup-outcome-value': QtiLookupOutcomeValue;
+    }
+}
+
+declare abstract class QtiConditionExpression extends QtiExpression<boolean> {
+    calculate(): Readonly<boolean>;
+    getResult(): Readonly<boolean>;
+}
+
+type Constructor<T> = new (...args: any[]) => T;
+declare const QtiAnd_base: {
+    new (...args: any[]): {
+        calculateChildren(children: Array<MockQtiExpression<any>>): boolean;
+    };
+} & Constructor<QtiConditionExpression>;
+declare class QtiAnd extends QtiAnd_base {
+    calculate(): boolean;
+}
+type MockQtiExpression<T> = {
+    calculate: () => T;
+};
+type MockConstructor = new (...args: any[]) => {};
+declare function qtiAndMixin<TBase extends MockConstructor>(Base: TBase): {
+    new (...args: any[]): {
+        calculateChildren(children: Array<MockQtiExpression<any>>): boolean;
+    };
+} & TBase;
+
+declare global {
+    interface HTMLElementTagNameMap {
+        'qti-and': QtiAnd;
+    }
+}
+
+interface IMSpci<ConfigProperties> {
+    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<ConfigProperties>, state: string) => void;
+    /** @access public
+     * @method getResponse
+     * @return {Object} - the value to assign to the bound QTI response variable
+     */
+    getResponse: () => QtiVariableJSON;
+    /** @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<T>, state?: string) => void;
+    properties: T;
+};
+declare type QtiVariableJSON = {
+    [K in 'list' | 'base']?: {
+        [Ka in 'boolean' | 'integer' | 'float' | 'string' | 'pair' | 'directedPair' | 'identifier']?: ResponseType;
+    };
+};
+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 intervalId;
+    private rawResponse;
+    private pci;
+    responseIdentifier: string;
+    module: string;
+    customInteractionTypeIdentifier: string;
+    private _errorMessage;
+    private convertQtiVariableJSON;
+    private startChecking;
+    private stopChecking;
+    validate(): boolean;
+    set value(val: string | string[]);
+    get value(): string | string[];
+    getTAOConfig(node: any): {};
+    register(pci: IMSpci<unknown>): void;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    buildRequireConfig(): ModuleResolutionConfig;
+    private combineRequireResolvePaths;
+    private removeDoubleSlashes;
+    loadConfig: (url: string, baseUrl?: string) => Promise<ModuleResolutionConfig>;
+    getResolvablePathString: (path: string, basePath?: string) => string;
+    getResolvablePath: (path: string | string[], basePath?: string) => string | string[];
+    render(): lit_html.TemplateResult<1>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'qti-portable-custom-interaction': QtiPortableCustomInteraction;
+    }
+}
+
+declare const QtiAssociateInteraction_base: (abstract new (...args: any[]) => IInteraction) & typeof Interaction;
+declare class QtiAssociateInteraction extends QtiAssociateInteraction_base {
+    private _childrenMap;
+    static styles: CSSResultGroup;
+    private _registerChoiceHandler;
+    constructor();
+    private _registerChoice;
+    render(): lit_html.TemplateResult<1>;
+    disconnectedCallback(): void;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'qti-associate-interaction': QtiAssociateInteraction;
+    }
+}
+
+declare class QtiCustomInteraction extends Interaction {
+    private rawResponse;
+    constructor();
+    responseIdentifier: string;
+    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 value(): string | string[];
+    set value(val: string | string[]);
+    disconnectedCallback(): void;
+    render(): lit_html.TemplateResult<1>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'qti-custom-interaction': QtiCustomInteraction;
+    }
+}
+
+declare class QtiEndAttemptInteraction extends Interaction {
+    countAttempt: string;
+    title: 'end attempt';
+    validate(): boolean;
+    get value(): string | string[];
+    set value(val: string | string[]);
+    render(): lit_html.TemplateResult<1>;
+    endAttempt(e: Event): void;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'qti-end-attempt-interaction': QtiEndAttemptInteraction;
+    }
+}
+
+declare const QtiGapMatchInteraction_base: (abstract new (...args: any[]) => IInteraction) & typeof Interaction;
+declare class QtiGapMatchInteraction extends QtiGapMatchInteraction_base {
+    static styles: lit.CSSResult[];
+    render(): lit_html.TemplateResult<1>;
+    set correctResponse(value: string | string[]);
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'qti-gap-match-interaction': QtiGapMatchInteraction;
+    }
+}
+
+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 value(val: string | string[]);
+    get value(): string | string[];
+    render(): lit_html.TemplateResult<1>;
+    private positionHotspotOnRegister;
+    firstUpdated(e: any): 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: lit.CSSResult;
+    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 {
+    choiceOrdering: boolean;
+    static styles: lit.CSSResult[];
+    render(): lit_html.TemplateResult<1>;
+    private setHotspotOrder;
+    private positionHotspotOnRegister;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'qti-graphic-order-interaction': QtiGraphicOrderInteraction;
+    }
+}
+
+declare const QtiHotspotInteraction_base: (abstract new (...args: any[]) => ChoicesInterface) & typeof Interaction;
+declare class QtiHotspotInteraction extends QtiHotspotInteraction_base {
+    static styles: lit.CSSResult[];
+    render(): lit_html.TemplateResult<1>;
+    private positionHotspotOnRegister;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'qti-hotspot-interaction': QtiHotspotInteraction;
+    }
+}
+
+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;
+    rows: QtiSimpleAssociableChoice[];
+    cols: QtiSimpleAssociableChoice[];
+    lastCheckedRadio: HTMLInputElement | null;
+    _response: string | string[];
+    get value(): string[];
+    set value(val: string[]);
+    correctOptions: string[];
+    responseIdentifier: string;
+    connectedCallback(): Promise<void>;
+    handleRadioClick: (e: any) => void;
+    handleRadioChange: (e: any) => void;
+    set correctResponse(responseValue: string | string[]);
+    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 value(): string | string[];
+    set value(val: string | string[]);
+    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[]) => {}) & (abstract new (...args: any[]) => IInteraction) & typeof Interaction;
+declare class QtiOrderInteraction extends QtiOrderInteraction_base {
+    childrenMap: Element[];
+    nrChoices: number;
+    correctResponses: string[];
+    showCorrectResponses: boolean;
+    /** orientation of choices */
+    orientation: 'horizontal' | 'vertical';
+    static styles: lit.CSSResult[];
+    render(): lit_html.TemplateResult<1>;
+    set correctResponse(value: string | string[]);
+    protected getResponse(): string[];
+    firstUpdated(changedProps: any): Promise<void>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'qti-order-interaction': QtiOrderInteraction;
+    }
+}
+
+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(event: any): 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;
+    private _points;
+    private _imgElement;
+    private _onImageClick;
+    render(): lit_html.TemplateResult<1>;
+    reset(): void;
+    validate(): boolean;
+    set value(val: string | string[]);
+    get value(): string | string[];
+    firstUpdated(): void;
+    disconnectedCallback(): void;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'qti-select-point-interaction': QtiSelectPointInteraction;
+    }
+}
+
+/**
+ * @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 {
+    private _value;
+    csLive: CSSStyleDeclaration;
+    private _knob;
+    private _rail;
+    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;
+    get value(): string | string[];
+    set value(val: string | string[]);
+    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 global {
+    interface HTMLElementTagNameMap {
+        'qti-slider-interaction': QtiSliderInteraction;
+    }
+}
+
+/**
+ * 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(event: Event): void;
+    calculate(): any;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'qti-custom-operator': QtiCustomOperator;
+    }
+}
+
+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 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 QtiGapImg extends LitElement {
+    static styles: lit.CSSResult;
+    tabindex: number | undefined;
+    connectedCallback(): void;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'qti-gap-img': QtiGapImg;
+    }
+}
+
+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 const QtiHotspotChoice_base: (abstract new (...args: any[]) => ActiveElementMixinInterface) & typeof LitElement;
+declare class QtiHotspotChoice extends QtiHotspotChoice_base {
+    static styles: lit.CSSResult;
+    order: number;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'qti-hotspot-choice': QtiHotspotChoice;
+    }
+}
+
+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;
+    }
+}
+
+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 QtiSimpleChoice_base: (abstract new (...args: any[]) => ActiveElementMixinInterface) & typeof LitElement;
+/**
+ * qti-order-interaction
+ * qti-choice-interaction
+ */
+declare class QtiSimpleChoice extends QtiSimpleChoice_base {
+    static styles: lit.CSSResult;
+    marker: string;
+    get checked(): boolean;
+    render(): lit_html.TemplateResult<1>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'qti-simple-choice': QtiSimpleChoice;
+    }
+}
+
+export { QtiAssociateInteraction as $, type ActiveElementMixinInterface as A, type BaseType as B, type Calculate as C, QtiRubricBlock as D, QtiFeedbackBlock as E, QtiFeedbackInline as F, QtiModalFeedback as G, QtiExtendedTextInteraction as H, type ItemContext as I, QtiTextEntryInteraction as J, QtiHottextInteraction as K, QtiInlineChoiceInteraction as L, type Multiple as M, QtiChoiceInteraction as N, type OutcomeChangedDetails as O, QtiOutcomeProcessing as P, QtiRule as Q, type ResponseVariable as R, QtiOutcomeProcessingProcessor as S, QtiResponseProcessing as T, QtiLookupOutcomeValue as U, type VariableDeclaration as V, QtiAnd as W, type MockQtiExpression as X, qtiAndMixin as Y, QtiMapping as Z, QtiPortableCustomInteraction as _, type QtiRuleBase as a, QtiCustomInteraction as a0, QtiEndAttemptInteraction as a1, QtiGapMatchInteraction as a2, QtiGraphicAssociateInteraction as a3, QtiGraphicGapMatchInteraction as a4, QtiGraphicOrderInteraction as a5, QtiHotspotInteraction as a6, QtiMatchInteraction as a7, QtiMediaInteraction as a8, QtiOrderInteraction as a9, QtiPositionObjectStage as aa, QtiSelectPointInteraction as ab, QtiSliderInteraction as ac, itemContextVariables as ad, itemContext as ae, QtiCustomOperator as af, Interaction as ag, QtiAssociableHotspot as ah, QtiGap as ai, QtiGapImg as aj, QtiGapText as ak, QtiHotspotChoice as al, QtiHottext as am, QtiInlineChoice as an, QtiSimpleAssociableChoice as ao, QtiSimpleChoice as ap, type QtiExpressionBase as b, QtiExpression as c, QtiConditionExpression as d, type InteractionChangedDetails as e, type QtiInteractionChanged as f, type QtiOutcomeChanged as g, type directedPair as h, type ResponseInteraction as i, type float as j, type integer as k, type Ordered as l, type Cardinality as m, type VariableValue as n, type OutcomeVariable as o, QtiAssessmentItem as p, QtiAssessmentStimulusRef as q, type ChoiceInterface as r, ActiveElementMixin as s, QtiItemBody as t, QtiPrompt as u, QtiStylesheet as v, QtiOutcomeDeclaration as w, QtiResponseDeclaration as x, QtiCompanionMaterialsInfo as y, QtiContentBody as z };