@examplary/qti 0.0.1 → 1.0.1

package/dist/qti/interactions/match-interaction.d.ts

@@ -0,0 +1,31 @@
+import { SimpleAssociableChoiceOptions } from "./associate-interaction";
+import { QtiPromptInteraction, QtiPromptInteractionOptions } from "./interaction";
+export type MatchInteractionOptions = QtiPromptInteractionOptions & {
+    shuffle?: boolean;
+    minAssociations?: number;
+    maxAssociations?: number;
+    sourceChoices?: SimpleAssociableChoiceOptions[];
+    targetChoices?: SimpleAssociableChoiceOptions[];
+};
+/**
+ * Presents two sets of choices for candidates to match or associate with each other.
+ * Commonly used for matching terms with definitions or pairing related concepts.
+ *
+ * @see https://www.imsglobal.org/spec/qti/v3p0/impl#h.be4ll1tm4t99
+ *
+ * @example
+ * const interaction = new MatchInteraction({
+ *   responseIdentifier: "RESPONSE",
+ *   sourceChoices: [
+ *     { identifier: "S1", content: "Paris", matchMax: 1 },
+ *     { identifier: "S2", content: "London", matchMax: 1 },
+ *   ],
+ *   targetChoices: [
+ *     { identifier: "T1", content: "France", matchMax: 1 },
+ *     { identifier: "T2", content: "England", matchMax: 1 },
+ *   ],
+ * });
+ */
+export declare class MatchInteraction extends QtiPromptInteraction {
+    constructor(options: MatchInteractionOptions);
+}

package/dist/qti/interactions/match-interaction.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MatchInteraction = void 0;
+const xmlbuilder2_1 = require("xmlbuilder2");
+const interaction_1 = require("./interaction");
+const html_1 = require("../../utils/html");
+/**
+ * Presents two sets of choices for candidates to match or associate with each other.
+ * Commonly used for matching terms with definitions or pairing related concepts.
+ *
+ * @see https://www.imsglobal.org/spec/qti/v3p0/impl#h.be4ll1tm4t99
+ *
+ * @example
+ * const interaction = new MatchInteraction({
+ *   responseIdentifier: "RESPONSE",
+ *   sourceChoices: [
+ *     { identifier: "S1", content: "Paris", matchMax: 1 },
+ *     { identifier: "S2", content: "London", matchMax: 1 },
+ *   ],
+ *   targetChoices: [
+ *     { identifier: "T1", content: "France", matchMax: 1 },
+ *     { identifier: "T2", content: "England", matchMax: 1 },
+ *   ],
+ * });
+ */
+class MatchInteraction extends interaction_1.QtiPromptInteraction {
+    constructor(options) {
+        super(options);
+        this.item = (0, xmlbuilder2_1.fragment)().ele("qti-match-interaction", {
+            "response-identifier": options.responseIdentifier,
+            label: options.label,
+            shuffle: options.shuffle ? "true" : "false",
+            "min-associations": options.minAssociations?.toString(),
+            "max-associations": options.maxAssociations?.toString(),
+        });
+        const sourceSet = this.item.ele("qti-simple-match-set");
+        for (const choice of options.sourceChoices || []) {
+            const choiceEl = sourceSet.ele("qti-simple-associable-choice", {
+                identifier: choice.identifier,
+                "match-max": choice.matchMax?.toString(),
+                "match-min": choice.matchMin?.toString(),
+                "match-group": choice.matchGroup,
+                fixed: choice.fixed ? "true" : undefined,
+                "template-identifier": choice.templateIdentifier,
+            });
+            if (choice.content) {
+                (0, html_1.appendHtmlFragment)(choice.content, choiceEl);
+            }
+        }
+        const targetSet = this.item.ele("qti-simple-match-set");
+        for (const choice of options.targetChoices || []) {
+            const choiceEl = targetSet.ele("qti-simple-associable-choice", {
+                identifier: choice.identifier,
+                "match-max": choice.matchMax?.toString(),
+                "match-min": choice.matchMin?.toString(),
+                "match-group": choice.matchGroup,
+                fixed: choice.fixed ? "true" : undefined,
+                "template-identifier": choice.templateIdentifier,
+            });
+            if (choice.content) {
+                (0, html_1.appendHtmlFragment)(choice.content, choiceEl);
+            }
+        }
+    }
+}
+exports.MatchInteraction = MatchInteraction;

package/dist/qti/interactions/media-interaction.d.ts

@@ -0,0 +1,31 @@
+import { QtiPromptInteraction, QtiPromptInteractionOptions } from "./interaction";
+export type MediaObjectOptions = {
+    data: string;
+    type: string;
+    width?: number;
+    height?: number;
+};
+export type MediaInteractionOptions = QtiPromptInteractionOptions & {
+    autostart?: boolean;
+    minPlays?: number;
+    maxPlays?: number;
+    loop?: boolean;
+    object: MediaObjectOptions;
+};
+/**
+ * Presents audio or video content that candidates must engage with before responding.
+ * Used for listening comprehension, video analysis, or multimedia-based questions.
+ *
+ * @see https://www.imsglobal.org/spec/qti/v3p0/impl#h.u9utgghwf8ck
+ *
+ * @example
+ * const interaction = new MediaInteraction({
+ *   responseIdentifier: "RESPONSE",
+ *   minPlays: 1,
+ *   maxPlays: 3,
+ *   object: { data: "audio.mp3", type: "audio/mpeg" },
+ * });
+ */
+export declare class MediaInteraction extends QtiPromptInteraction {
+    constructor(options: MediaInteractionOptions);
+}

package/dist/qti/interactions/media-interaction.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MediaInteraction = void 0;
+const xmlbuilder2_1 = require("xmlbuilder2");
+const interaction_1 = require("./interaction");
+/**
+ * Presents audio or video content that candidates must engage with before responding.
+ * Used for listening comprehension, video analysis, or multimedia-based questions.
+ *
+ * @see https://www.imsglobal.org/spec/qti/v3p0/impl#h.u9utgghwf8ck
+ *
+ * @example
+ * const interaction = new MediaInteraction({
+ *   responseIdentifier: "RESPONSE",
+ *   minPlays: 1,
+ *   maxPlays: 3,
+ *   object: { data: "audio.mp3", type: "audio/mpeg" },
+ * });
+ */
+class MediaInteraction extends interaction_1.QtiPromptInteraction {
+    constructor(options) {
+        super(options);
+        this.item = (0, xmlbuilder2_1.fragment)().ele("qti-media-interaction", {
+            "response-identifier": options.responseIdentifier,
+            label: options.label,
+            autostart: options.autostart ? "true" : undefined,
+            "min-plays": options.minPlays?.toString(),
+            "max-plays": options.maxPlays?.toString(),
+            loop: options.loop ? "true" : undefined,
+        });
+        this.item.ele("object", {
+            data: options.object.data,
+            type: options.object.type,
+            width: options.object.width?.toString(),
+            height: options.object.height?.toString(),
+        });
+    }
+}
+exports.MediaInteraction = MediaInteraction;

package/dist/qti/interactions/order-interaction.d.ts

@@ -0,0 +1,28 @@
+import { SimpleChoiceOptions } from "./choice-interaction";
+import { QtiPromptInteraction, QtiPromptInteractionOptions } from "./interaction";
+export type OrderInteractionOptions = QtiPromptInteractionOptions & {
+    shuffle?: boolean;
+    minChoices?: number;
+    maxChoices?: number;
+    orientation?: "horizontal" | "vertical";
+    choices?: SimpleChoiceOptions[];
+};
+/**
+ * Presents a set of choices for candidates to arrange in a specific order or sequence.
+ * Used for ranking, sequencing, or prioritization questions.
+ *
+ * @see https://www.imsglobal.org/spec/qti/v3p0/impl#h.4n8gips6tlv4
+ *
+ * @example
+ * const interaction = new OrderInteraction({
+ *   responseIdentifier: "RESPONSE",
+ *   choices: [
+ *     { identifier: "A", content: "First step" },
+ *     { identifier: "B", content: "Second step" },
+ *     { identifier: "C", content: "Third step" },
+ *   ],
+ * });
+ */
+export declare class OrderInteraction extends QtiPromptInteraction {
+    constructor(options: OrderInteractionOptions);
+}

package/dist/qti/interactions/order-interaction.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OrderInteraction = void 0;
+const xmlbuilder2_1 = require("xmlbuilder2");
+const interaction_1 = require("./interaction");
+const html_1 = require("../../utils/html");
+/**
+ * Presents a set of choices for candidates to arrange in a specific order or sequence.
+ * Used for ranking, sequencing, or prioritization questions.
+ *
+ * @see https://www.imsglobal.org/spec/qti/v3p0/impl#h.4n8gips6tlv4
+ *
+ * @example
+ * const interaction = new OrderInteraction({
+ *   responseIdentifier: "RESPONSE",
+ *   choices: [
+ *     { identifier: "A", content: "First step" },
+ *     { identifier: "B", content: "Second step" },
+ *     { identifier: "C", content: "Third step" },
+ *   ],
+ * });
+ */
+class OrderInteraction extends interaction_1.QtiPromptInteraction {
+    constructor(options) {
+        super(options);
+        this.item = (0, xmlbuilder2_1.fragment)().ele("qti-order-interaction", {
+            "response-identifier": options.responseIdentifier,
+            label: options.label,
+            shuffle: options.shuffle ? "true" : "false",
+            "min-choices": options.minChoices?.toString(),
+            "max-choices": options.maxChoices?.toString(),
+            orientation: options.orientation,
+        });
+        for (const choice of options.choices || []) {
+            const choiceEl = this.item.ele("qti-simple-choice", {
+                identifier: choice.identifier,
+                fixed: choice.fixed ? "true" : undefined,
+                "template-identifier": choice.templateIdentifier,
+            });
+            if (choice.content) {
+                (0, html_1.appendHtmlFragment)(choice.content, choiceEl);
+            }
+        }
+    }
+}
+exports.OrderInteraction = OrderInteraction;

package/dist/qti/interactions/position-object-interaction.d.ts

@@ -0,0 +1,36 @@
+import { QtiPromptInteraction, QtiPromptInteractionOptions } from "./interaction";
+export type PositionObjectStageOptions = {
+    data: string;
+    type: string;
+    width?: number;
+    height?: number;
+};
+export type PositionObjectOptions = {
+    data: string;
+    type: string;
+    width?: number;
+    height?: number;
+};
+export type PositionObjectInteractionOptions = QtiPromptInteractionOptions & {
+    centerPoint?: string;
+    minChoices?: number;
+    maxChoices?: number;
+    object: PositionObjectOptions;
+    positionObjectStage?: PositionObjectStageOptions;
+};
+/**
+ * Presents a movable object that candidates must position on a background stage.
+ * Used for placing items at specific coordinates on a canvas or diagram.
+ *
+ * @see https://www.imsglobal.org/spec/qti/v3p0/impl#h.4jhs37jil26s
+ *
+ * @example
+ * const interaction = new PositionObjectInteraction({
+ *   responseIdentifier: "RESPONSE",
+ *   object: { data: "marker.png", type: "image/png", width: 20, height: 20 },
+ *   positionObjectStage: { data: "map.png", type: "image/png", width: 400, height: 300 },
+ * });
+ */
+export declare class PositionObjectInteraction extends QtiPromptInteraction {
+    constructor(options: PositionObjectInteractionOptions);
+}

package/dist/qti/interactions/position-object-interaction.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PositionObjectInteraction = void 0;
+const xmlbuilder2_1 = require("xmlbuilder2");
+const interaction_1 = require("./interaction");
+/**
+ * Presents a movable object that candidates must position on a background stage.
+ * Used for placing items at specific coordinates on a canvas or diagram.
+ *
+ * @see https://www.imsglobal.org/spec/qti/v3p0/impl#h.4jhs37jil26s
+ *
+ * @example
+ * const interaction = new PositionObjectInteraction({
+ *   responseIdentifier: "RESPONSE",
+ *   object: { data: "marker.png", type: "image/png", width: 20, height: 20 },
+ *   positionObjectStage: { data: "map.png", type: "image/png", width: 400, height: 300 },
+ * });
+ */
+class PositionObjectInteraction extends interaction_1.QtiPromptInteraction {
+    constructor(options) {
+        super(options);
+        this.item = (0, xmlbuilder2_1.fragment)().ele("qti-position-object-interaction", {
+            "response-identifier": options.responseIdentifier,
+            label: options.label,
+            "center-point": options.centerPoint,
+            "min-choices": options.minChoices?.toString(),
+            "max-choices": options.maxChoices?.toString(),
+        });
+        this.item.ele("object", {
+            data: options.object.data,
+            type: options.object.type,
+            width: options.object.width?.toString(),
+            height: options.object.height?.toString(),
+        });
+        if (options.positionObjectStage) {
+            const stage = this.item.ele("qti-position-object-stage");
+            stage.ele("object", {
+                data: options.positionObjectStage.data,
+                type: options.positionObjectStage.type,
+                width: options.positionObjectStage.width?.toString(),
+                height: options.positionObjectStage.height?.toString(),
+            });
+        }
+    }
+}
+exports.PositionObjectInteraction = PositionObjectInteraction;

package/dist/qti/interactions/select-point-interaction.d.ts

@@ -0,0 +1,28 @@
+import { QtiPromptInteraction, QtiPromptInteractionOptions } from "./interaction";
+export type SelectPointObjectOptions = {
+    data: string;
+    type: string;
+    width?: number;
+    height?: number;
+};
+export type SelectPointInteractionOptions = QtiPromptInteractionOptions & {
+    minChoices?: number;
+    maxChoices?: number;
+    object: SelectPointObjectOptions;
+};
+/**
+ * Presents an image where candidates select specific coordinate points.
+ * Used for identifying precise locations on maps, graphs, or diagrams.
+ *
+ * @see https://www.imsglobal.org/spec/qti/v3p0/impl#h.ev30y6ze263d
+ *
+ * @example
+ * const interaction = new SelectPointInteraction({
+ *   responseIdentifier: "RESPONSE",
+ *   maxChoices: 1,
+ *   object: { data: "graph.png", type: "image/png", width: 400, height: 300 },
+ * });
+ */
+export declare class SelectPointInteraction extends QtiPromptInteraction {
+    constructor(options: SelectPointInteractionOptions);
+}

package/dist/qti/interactions/select-point-interaction.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SelectPointInteraction = void 0;
+const xmlbuilder2_1 = require("xmlbuilder2");
+const interaction_1 = require("./interaction");
+/**
+ * Presents an image where candidates select specific coordinate points.
+ * Used for identifying precise locations on maps, graphs, or diagrams.
+ *
+ * @see https://www.imsglobal.org/spec/qti/v3p0/impl#h.ev30y6ze263d
+ *
+ * @example
+ * const interaction = new SelectPointInteraction({
+ *   responseIdentifier: "RESPONSE",
+ *   maxChoices: 1,
+ *   object: { data: "graph.png", type: "image/png", width: 400, height: 300 },
+ * });
+ */
+class SelectPointInteraction extends interaction_1.QtiPromptInteraction {
+    constructor(options) {
+        super(options);
+        this.item = (0, xmlbuilder2_1.fragment)().ele("qti-select-point-interaction", {
+            "response-identifier": options.responseIdentifier,
+            label: options.label,
+            "min-choices": options.minChoices?.toString(),
+            "max-choices": options.maxChoices?.toString(),
+        });
+        this.item.ele("object", {
+            data: options.object.data,
+            type: options.object.type,
+            width: options.object.width?.toString(),
+            height: options.object.height?.toString(),
+        });
+    }
+}
+exports.SelectPointInteraction = SelectPointInteraction;

package/dist/qti/interactions/slider-interaction.d.ts

@@ -0,0 +1,26 @@
+import { QtiPromptInteraction, QtiPromptInteractionOptions } from "./interaction";
+export type SliderInteractionOptions = QtiPromptInteractionOptions & {
+    lowerBound: number;
+    upperBound: number;
+    step?: number;
+    stepLabel?: boolean;
+    orientation?: "horizontal" | "vertical";
+    reverse?: boolean;
+};
+/**
+ * Presents a slider control for candidates to select a numeric value within a range.
+ * Used for questions requiring numeric input, ratings, or scale-based responses.
+ *
+ * @see https://www.imsglobal.org/spec/qti/v3p0/impl#h.s61xcrj4qcyj
+ *
+ * @example
+ * const interaction = new SliderInteraction({
+ *   responseIdentifier: "RESPONSE",
+ *   lowerBound: 0,
+ *   upperBound: 100,
+ *   step: 10,
+ * });
+ */
+export declare class SliderInteraction extends QtiPromptInteraction {
+    constructor(options: SliderInteractionOptions);
+}

package/dist/qti/interactions/slider-interaction.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SliderInteraction = void 0;
+const xmlbuilder2_1 = require("xmlbuilder2");
+const interaction_1 = require("./interaction");
+/**
+ * Presents a slider control for candidates to select a numeric value within a range.
+ * Used for questions requiring numeric input, ratings, or scale-based responses.
+ *
+ * @see https://www.imsglobal.org/spec/qti/v3p0/impl#h.s61xcrj4qcyj
+ *
+ * @example
+ * const interaction = new SliderInteraction({
+ *   responseIdentifier: "RESPONSE",
+ *   lowerBound: 0,
+ *   upperBound: 100,
+ *   step: 10,
+ * });
+ */
+class SliderInteraction extends interaction_1.QtiPromptInteraction {
+    constructor(options) {
+        super(options);
+        this.item = (0, xmlbuilder2_1.fragment)().ele("qti-slider-interaction", {
+            "response-identifier": options.responseIdentifier,
+            label: options.label,
+            "lower-bound": options.lowerBound.toString(),
+            "upper-bound": options.upperBound.toString(),
+            step: options.step?.toString(),
+            "step-label": options.stepLabel ? "true" : undefined,
+            orientation: options.orientation,
+            reverse: options.reverse ? "true" : undefined,
+        });
+    }
+}
+exports.SliderInteraction = SliderInteraction;

package/dist/qti/interactions/text-entry-interaction.d.ts

@@ -0,0 +1,25 @@
+import { QtiInteraction, QtiInteractionOptions } from "./interaction";
+export type TextEntryInteractionOptions = QtiInteractionOptions & {
+    stringIdentifier?: string;
+    expectedLength?: number;
+    placeholderText?: string;
+    format?: string;
+    patternMask?: string;
+    patternMaskMessage?: string;
+};
+/**
+ * Presents a text input field for candidates to enter a short text response.
+ * Used for fill-in-the-blank or short answer questions embedded inline.
+ *
+ * @see https://www.imsglobal.org/spec/qti/v3p0/impl#h.5bw8rpbotrcs
+ *
+ * @example
+ * const interaction = new TextEntryInteraction({
+ *   responseIdentifier: "RESPONSE",
+ *   expectedLength: 20,
+ *   placeholderText: "Enter your answer",
+ * });
+ */
+export declare class TextEntryInteraction extends QtiInteraction {
+    constructor(options: TextEntryInteractionOptions);
+}

package/dist/qti/interactions/text-entry-interaction.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TextEntryInteraction = void 0;
+const xmlbuilder2_1 = require("xmlbuilder2");
+const interaction_1 = require("./interaction");
+/**
+ * Presents a text input field for candidates to enter a short text response.
+ * Used for fill-in-the-blank or short answer questions embedded inline.
+ *
+ * @see https://www.imsglobal.org/spec/qti/v3p0/impl#h.5bw8rpbotrcs
+ *
+ * @example
+ * const interaction = new TextEntryInteraction({
+ *   responseIdentifier: "RESPONSE",
+ *   expectedLength: 20,
+ *   placeholderText: "Enter your answer",
+ * });
+ */
+class TextEntryInteraction extends interaction_1.QtiInteraction {
+    constructor(options) {
+        super(options);
+        this.item = (0, xmlbuilder2_1.fragment)().ele("qti-text-entry-interaction", {
+            "response-identifier": options.responseIdentifier,
+            label: options.label,
+            "string-identifier": options.stringIdentifier,
+            "expected-length": options.expectedLength?.toString(),
+            "placeholder-text": options.placeholderText,
+            format: options.format,
+            "pattern-mask": options.patternMask,
+            "data-patternmask-message": options.patternMaskMessage,
+        });
+    }
+}
+exports.TextEntryInteraction = TextEntryInteraction;

package/dist/qti/interactions/upload-interaction.d.ts

@@ -0,0 +1,19 @@
+import { QtiPromptInteraction, QtiPromptInteractionOptions } from "./interaction";
+export type UploadInteractionOptions = QtiPromptInteractionOptions & {
+    type?: string;
+};
+/**
+ * Allows candidates to upload a file as their response.
+ * Used for submitting documents, images, or other file-based answers.
+ *
+ * @see https://www.imsglobal.org/spec/qti/v3p0/impl#h.qtnex0r52anx
+ *
+ * @example
+ * const interaction = new UploadInteraction({
+ *   responseIdentifier: "RESPONSE",
+ *   type: "application/pdf",
+ * });
+ */
+export declare class UploadInteraction extends QtiPromptInteraction {
+    constructor(options: UploadInteractionOptions);
+}

package/dist/qti/interactions/upload-interaction.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UploadInteraction = void 0;
+const xmlbuilder2_1 = require("xmlbuilder2");
+const interaction_1 = require("./interaction");
+/**
+ * Allows candidates to upload a file as their response.
+ * Used for submitting documents, images, or other file-based answers.
+ *
+ * @see https://www.imsglobal.org/spec/qti/v3p0/impl#h.qtnex0r52anx
+ *
+ * @example
+ * const interaction = new UploadInteraction({
+ *   responseIdentifier: "RESPONSE",
+ *   type: "application/pdf",
+ * });
+ */
+class UploadInteraction extends interaction_1.QtiPromptInteraction {
+    constructor(options) {
+        super(options);
+        this.item = (0, xmlbuilder2_1.fragment)().ele("qti-upload-interaction", {
+            "response-identifier": options.responseIdentifier,
+            label: options.label,
+            type: options.type,
+        });
+    }
+}
+exports.UploadInteraction = UploadInteraction;

package/dist/qti/qti-element.d.ts

@@ -0,0 +1,11 @@
+import { XMLBuilder } from "xmlbuilder2/lib/interfaces";
+export type NamespacedElementContent = string | {
+    [key: string]: NamespacedElementContent;
+} | NamespacedElementContent[];
+export declare abstract class QtiElement {
+    protected abstract getRootElement(): XMLBuilder;
+    buildXml(): string;
+    registerNamespace(prefix: string, uri: string): void;
+    addNamespacedElement(namespace: string, elementName: string, content: NamespacedElementContent, attributes?: Record<string, string>): void;
+    private appendContent;
+}

package/dist/qti/qti-element.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QtiElement = void 0;
+class QtiElement {
+    buildXml() {
+        return this.getRootElement().end({ prettyPrint: true });
+    }
+    registerNamespace(prefix, uri) {
+        this.getRootElement().att(`xmlns:${prefix}`, uri);
+    }
+    addNamespacedElement(namespace, elementName, content, attributes) {
+        const element = this.getRootElement().ele(`${namespace}:${elementName}`, attributes);
+        this.appendContent(element, namespace, content);
+    }
+    appendContent(element, namespace, content) {
+        if (typeof content === "string") {
+            element.txt(content);
+        }
+        else if (Array.isArray(content)) {
+            for (const item of content) {
+                this.appendContent(element, namespace, item);
+            }
+        }
+        else {
+            for (const [key, value] of Object.entries(content)) {
+                const child = element.ele(`${namespace}:${key}`);
+                this.appendContent(child, namespace, value);
+            }
+        }
+    }
+}
+exports.QtiElement = QtiElement;

package/dist/qti/qti-item.d.ts

@@ -1,3 +1,6 @@
+import { XMLBuilder } from "xmlbuilder2/lib/interfaces";
+import { QtiInteraction } from "./interactions/interaction";
+import { QtiElement } from "./qti-element";
 import { QtiTest } from "./qti-test";
 import { QtiCardinality, QtiBaseType, QtiAudience } from "./types";
 import { ImsPackage } from "../ims/ims-package";
@@ -35,7 +38,7 @@ export declare enum ResponseProcessingTemplate {
     MapResponse = "https://purl.imsglobal.org/spec/qti/v3p0/rptemplates/map_response.xml",
     MapResponsePoint = "https://purl.imsglobal.org/spec/qti/v3p0/rptemplates/map_response_point.xml"
 }
-export declare class QtiItem {
+export declare class QtiItem extends QtiElement {
     identifier: string;
     adaptive?: boolean;
     timeDependent?: boolean;
@@ -48,14 +51,15 @@ export declare class QtiItem {
     private itemBody?;
     private responseDeclarations;
     constructor(options?: QtiItemOptions);
-    buildXml(): string;
-    addToPackage(pkg: ImsPackage): void;
+    addToPackage(pkg: ImsPackage): Promise<void>;
     addToTest(test: QtiTest): void;
     private getOrCreateItemBody;
     addItemBodyFromHtml(html: string): void;
+    addInteraction(interaction: QtiInteraction): void;
     addPciInteraction(interaction: PciInteraction, externalModules?: boolean): void;
     addResponseDeclaration(responseDeclaration?: ResponseDeclaration): void;
     addCorrectResponse(identifier: string, values: string[]): void;
     addResponseProcessing(template: ResponseProcessingTemplate): void;
     addOutcomeDeclaration(outcomeDeclaration?: OutcomeDeclaration): void;
+    protected getRootElement(): XMLBuilder;
 }