@examplary/qti 0.0.1 → 1.0.1

package/README.md

@@ -20,9 +20,14 @@ const item = new QtiItem({
   title: "Sample Question",
 });
 
-item.addItemBodyFromHtml("<p>What is 2 + 2?</p>");
 item.addResponseDeclaration({ identifier: "RESPONSE" });
 item.addCorrectResponse("RESPONSE", ["4"]);
+
+item.addItemBodyFromHtml("<p>What is 2 + 2?</p>");
+item.addInteraction(
+  new TextEntryInteraction({ responseIdentifier: "RESPONSE" }),
+);
+
 item.addResponseProcessing(ResponseProcessingTemplate.MatchCorrect);
 
 item.addToTest(test);

package/dist/ims/ims-manifest.js

@@ -1,5 +1,8 @@
-import { create } from "xmlbuilder2/lib/index.js";
-export var ImsManifestResourceType;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImsManifest = exports.ImsManifestResourceType = void 0;
+const xmlbuilder2_1 = require("xmlbuilder2");
+var ImsManifestResourceType;
 (function (ImsManifestResourceType) {
     // QTI 3 AssessmentTest
     ImsManifestResourceType["imsqti_test_xmlv3p0"] = "imsqti_test_xmlv3p0";
@@ -45,10 +48,15 @@ export var ImsManifestResourceType;
     ImsManifestResourceType["resourceextmetadata/xml"] = "resourceextmetadata/xml";
     // QTI 3 Usage Data (may need to pass to a CAT engine)
     ImsManifestResourceType["qtiusagedata/xml"] = "qtiusagedata/xml";
-})(ImsManifestResourceType || (ImsManifestResourceType = {}));
-export class ImsManifest {
+})(ImsManifestResourceType || (exports.ImsManifestResourceType = ImsManifestResourceType = {}));
+class ImsManifest {
+    resources = new Map();
+    identifier;
+    title;
+    language;
+    toolName;
+    toolVersion;
     constructor(options) {
-        this.resources = new Map();
         this.identifier = options?.identifier || "manifest-" + Date.now();
         this.title = options?.title || "QTI 3 Package";
         this.language = options?.language || "en";
@@ -66,7 +74,7 @@ export class ImsManifest {
         return Array.from(this.resources.values());
     }
     buildXml() {
-        const manifest = create({ version: "1.0", encoding: "UTF-8" }).ele("manifest", {
+        const manifest = (0, xmlbuilder2_1.create)({ version: "1.0", encoding: "UTF-8" }).ele("manifest", {
             xmlns: "http://www.imsglobal.org/xsd/qti/qtiv3p0/imscp_v1p1",
             "xmlns:lom": "http://ltsc.ieee.org/xsd/LOM",
             "xmlns:xsi": "http://www.w3.org/2001/XMLSchema-instance",
@@ -123,4 +131,4 @@ export class ImsManifest {
         return manifest.end({ prettyPrint: true });
     }
 }
-//# sourceMappingURL=ims-manifest.js.map
+exports.ImsManifest = ImsManifest;

package/dist/ims/ims-package.d.ts

@@ -21,7 +21,7 @@ export declare class ImsPackage {
     /**
      * Add a resource to the IMS Package, along with its associated files.
      */
-    addResource(resource: ImsManifestResourceWithoutFiles, files: ImsPackageFile[]): void;
+    addResource(resource: ImsManifestResourceWithoutFiles, files: ImsPackageFile[]): Promise<void>;
     /**
      * Add a file directly to the final ZIP, without adding it to the manifest.
      * Can fetch from URL or add from data.

package/dist/ims/ims-package.js

@@ -1,19 +1,27 @@
-import Zip from "jszip";
-import { ImsManifest, } from "./ims-manifest";
-export class ImsPackage {
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImsPackage = void 0;
+const jszip_1 = __importDefault(require("jszip"));
+const ims_manifest_1 = require("./ims-manifest");
+class ImsPackage {
+    manifest;
+    zip;
     /**
      * Create a new IMS Package.
      */
     constructor(manifestOptions) {
-        this.manifest = new ImsManifest(manifestOptions);
-        this.zip = new Zip();
+        this.manifest = new ims_manifest_1.ImsManifest(manifestOptions);
+        this.zip = new jszip_1.default();
     }
     /**
      * Add a resource to the IMS Package, along with its associated files.
      */
-    addResource(resource, files) {
+    async addResource(resource, files) {
         for (const file of files) {
-            this.addFileDirectly(file);
+            await this.addFileDirectly(file);
         }
         this.manifest.addResource({
             ...resource,
@@ -45,4 +53,4 @@ export class ImsPackage {
         return this.zip.generateAsync({ type: "arraybuffer" });
     }
 }
-//# sourceMappingURL=ims-package.js.map
+exports.ImsPackage = ImsPackage;

package/dist/index.d.ts

@@ -1,5 +1,7 @@
 export * from "./ims/ims-manifest";
 export * from "./ims/ims-package";
+export * from "./qti/qti-element";
 export * from "./qti/qti-test";
 export * from "./qti/qti-item";
+export * from "./qti/interactions";
 export * from "./qti/types";

package/dist/index.js

@@ -1,6 +1,23 @@
-export * from "./ims/ims-manifest";
-export * from "./ims/ims-package";
-export * from "./qti/qti-test";
-export * from "./qti/qti-item";
-export * from "./qti/types";
-//# sourceMappingURL=index.js.map
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./ims/ims-manifest"), exports);
+__exportStar(require("./ims/ims-package"), exports);
+__exportStar(require("./qti/qti-element"), exports);
+__exportStar(require("./qti/qti-test"), exports);
+__exportStar(require("./qti/qti-item"), exports);
+__exportStar(require("./qti/interactions"), exports);
+__exportStar(require("./qti/types"), exports);

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

@@ -0,0 +1,36 @@
+import { QtiPromptInteraction, QtiPromptInteractionOptions } from "./interaction";
+export type SimpleAssociableChoiceOptions = {
+    identifier: string;
+    matchMax?: number;
+    matchMin?: number;
+    matchGroup?: string;
+    fixed?: boolean;
+    templateIdentifier?: string;
+    content?: string;
+};
+export type AssociateInteractionOptions = QtiPromptInteractionOptions & {
+    shuffle?: boolean;
+    minAssociations?: number;
+    maxAssociations?: number;
+    choices?: SimpleAssociableChoiceOptions[];
+};
+/**
+ * Presents a set of choices for candidates to pair or associate with each other.
+ * Unlike MatchInteraction, choices come from a single set and can be paired freely.
+ *
+ * @see https://www.imsglobal.org/spec/qti/v3p0/impl#h.7cs7637r54vv
+ *
+ * @example
+ * const interaction = new AssociateInteraction({
+ *   responseIdentifier: "RESPONSE",
+ *   choices: [
+ *     { identifier: "A", content: "Cat", matchMax: 1 },
+ *     { identifier: "B", content: "Dog", matchMax: 1 },
+ *     { identifier: "C", content: "Meow", matchMax: 1 },
+ *     { identifier: "D", content: "Bark", matchMax: 1 },
+ *   ],
+ * });
+ */
+export declare class AssociateInteraction extends QtiPromptInteraction {
+    constructor(options: AssociateInteractionOptions);
+}

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

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AssociateInteraction = 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 pair or associate with each other.
+ * Unlike MatchInteraction, choices come from a single set and can be paired freely.
+ *
+ * @see https://www.imsglobal.org/spec/qti/v3p0/impl#h.7cs7637r54vv
+ *
+ * @example
+ * const interaction = new AssociateInteraction({
+ *   responseIdentifier: "RESPONSE",
+ *   choices: [
+ *     { identifier: "A", content: "Cat", matchMax: 1 },
+ *     { identifier: "B", content: "Dog", matchMax: 1 },
+ *     { identifier: "C", content: "Meow", matchMax: 1 },
+ *     { identifier: "D", content: "Bark", matchMax: 1 },
+ *   ],
+ * });
+ */
+class AssociateInteraction extends interaction_1.QtiPromptInteraction {
+    constructor(options) {
+        super(options);
+        this.item = (0, xmlbuilder2_1.fragment)().ele("qti-associate-interaction", {
+            "response-identifier": options.responseIdentifier,
+            label: options.label,
+            shuffle: options.shuffle ? "true" : "false",
+            "min-associations": options.minAssociations?.toString(),
+            "max-associations": options.maxAssociations?.toString(),
+        });
+        for (const choice of options.choices || []) {
+            const choiceEl = this.item.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.AssociateInteraction = AssociateInteraction;

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

@@ -0,0 +1,36 @@
+import { QtiPromptInteraction, QtiPromptInteractionOptions } from "./interaction";
+export type SimpleChoiceOptions = {
+    identifier: string;
+    fixed?: boolean;
+    templateIdentifier?: string;
+    label?: string;
+    content?: string;
+};
+export type ChoiceInteractionOptions = QtiPromptInteractionOptions & {
+    shuffle?: boolean;
+    maxChoices?: number;
+    minChoices?: number;
+    orientation?: "horizontal" | "vertical";
+    minSelectionsMessage?: string;
+    maxSelectionsMessage?: string;
+    choices?: SimpleChoiceOptions[];
+};
+/**
+ * Presents a set of choices for candidates to select one or more options.
+ * Supports single-select (radio) or multi-select (checkbox) modes via maxChoices.
+ *
+ * @see https://www.imsglobal.org/spec/qti/v3p0/impl#h.j9nu1oa1tu3b
+ *
+ * @example
+ * const interaction = new ChoiceInteraction({
+ *   responseIdentifier: "RESPONSE",
+ *   maxChoices: 1,
+ *   choices: [
+ *     { identifier: "A", content: "Option A" },
+ *     { identifier: "B", content: "Option B" },
+ *   ],
+ * });
+ */
+export declare class ChoiceInteraction extends QtiPromptInteraction {
+    constructor(options: ChoiceInteractionOptions);
+}

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

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChoiceInteraction = 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 select one or more options.
+ * Supports single-select (radio) or multi-select (checkbox) modes via maxChoices.
+ *
+ * @see https://www.imsglobal.org/spec/qti/v3p0/impl#h.j9nu1oa1tu3b
+ *
+ * @example
+ * const interaction = new ChoiceInteraction({
+ *   responseIdentifier: "RESPONSE",
+ *   maxChoices: 1,
+ *   choices: [
+ *     { identifier: "A", content: "Option A" },
+ *     { identifier: "B", content: "Option B" },
+ *   ],
+ * });
+ */
+class ChoiceInteraction extends interaction_1.QtiPromptInteraction {
+    constructor(options) {
+        super(options);
+        this.item = (0, xmlbuilder2_1.fragment)().ele("qti-choice-interaction", {
+            "response-identifier": options.responseIdentifier,
+            label: options.label,
+            shuffle: options.shuffle ? "true" : "false",
+            "max-choices": options.maxChoices?.toString(),
+            "min-choices": options.minChoices?.toString(),
+            orientation: options.orientation,
+            "data-min-selections-message": options.minSelectionsMessage,
+            "data-max-selections-message": options.maxSelectionsMessage,
+        });
+        for (const choice of options.choices || []) {
+            (0, html_1.appendHtmlFragment)(choice.content || "", this.item.ele("qti-simple-choice", {
+                identifier: choice.identifier,
+                fixed: choice.fixed ? "true" : "false",
+                "template-identifier": choice.templateIdentifier,
+                label: choice.label,
+            }));
+        }
+    }
+}
+exports.ChoiceInteraction = ChoiceInteraction;

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

@@ -0,0 +1,25 @@
+import { QtiPromptInteraction, QtiPromptInteractionOptions } from "./interaction";
+export type DrawingObjectOptions = {
+    data: string;
+    type: string;
+    width?: number;
+    height?: number;
+};
+export type DrawingInteractionOptions = QtiPromptInteractionOptions & {
+    object: DrawingObjectOptions;
+};
+/**
+ * Presents a canvas where candidates can draw or annotate over a background image.
+ * Used for freeform drawing, labeling, or annotation tasks.
+ *
+ * @see https://www.imsglobal.org/spec/qti/v3p0/impl#h.8yrkpwgsrs4b
+ *
+ * @example
+ * const interaction = new DrawingInteraction({
+ *   responseIdentifier: "RESPONSE",
+ *   object: { data: "canvas.png", type: "image/png", width: 400, height: 300 },
+ * });
+ */
+export declare class DrawingInteraction extends QtiPromptInteraction {
+    constructor(options: DrawingInteractionOptions);
+}

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

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DrawingInteraction = void 0;
+const xmlbuilder2_1 = require("xmlbuilder2");
+const interaction_1 = require("./interaction");
+/**
+ * Presents a canvas where candidates can draw or annotate over a background image.
+ * Used for freeform drawing, labeling, or annotation tasks.
+ *
+ * @see https://www.imsglobal.org/spec/qti/v3p0/impl#h.8yrkpwgsrs4b
+ *
+ * @example
+ * const interaction = new DrawingInteraction({
+ *   responseIdentifier: "RESPONSE",
+ *   object: { data: "canvas.png", type: "image/png", width: 400, height: 300 },
+ * });
+ */
+class DrawingInteraction extends interaction_1.QtiPromptInteraction {
+    constructor(options) {
+        super(options);
+        this.item = (0, xmlbuilder2_1.fragment)().ele("qti-drawing-interaction", {
+            "response-identifier": options.responseIdentifier,
+            label: options.label,
+        });
+        this.item.ele("object", {
+            data: options.object.data,
+            type: options.object.type,
+            width: options.object.width?.toString(),
+            height: options.object.height?.toString(),
+        });
+    }
+}
+exports.DrawingInteraction = DrawingInteraction;

package/dist/qti/interactions/end-attempt-interaction.d.ts

@@ -0,0 +1,21 @@
+import { QtiInteraction, QtiInteractionOptions } from "./interaction";
+export type EndAttemptInteractionOptions = QtiInteractionOptions & {
+    title: string;
+    countAttempt?: boolean;
+};
+/**
+ * Presents a button that allows candidates to voluntarily end their assessment attempt.
+ * Used for "give up" or "submit early" functionality in adaptive testing scenarios.
+ *
+ * @see https://www.imsglobal.org/spec/qti/v3p0/impl#h.b3g8rgbtuwqp
+ *
+ * @example
+ * const interaction = new EndAttemptInteraction({
+ *   responseIdentifier: "RESPONSE",
+ *   title: "Give Up",
+ *   countAttempt: true,
+ * });
+ */
+export declare class EndAttemptInteraction extends QtiInteraction {
+    constructor(options: EndAttemptInteractionOptions);
+}

package/dist/qti/interactions/end-attempt-interaction.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EndAttemptInteraction = void 0;
+const xmlbuilder2_1 = require("xmlbuilder2");
+const interaction_1 = require("./interaction");
+/**
+ * Presents a button that allows candidates to voluntarily end their assessment attempt.
+ * Used for "give up" or "submit early" functionality in adaptive testing scenarios.
+ *
+ * @see https://www.imsglobal.org/spec/qti/v3p0/impl#h.b3g8rgbtuwqp
+ *
+ * @example
+ * const interaction = new EndAttemptInteraction({
+ *   responseIdentifier: "RESPONSE",
+ *   title: "Give Up",
+ *   countAttempt: true,
+ * });
+ */
+class EndAttemptInteraction extends interaction_1.QtiInteraction {
+    constructor(options) {
+        super(options);
+        this.item = (0, xmlbuilder2_1.fragment)().ele("qti-end-attempt-interaction", {
+            "response-identifier": options.responseIdentifier,
+            label: options.label,
+            title: options.title,
+            "count-attempt": options.countAttempt ? "true" : undefined,
+        });
+    }
+}
+exports.EndAttemptInteraction = EndAttemptInteraction;

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

@@ -0,0 +1,28 @@
+import { QtiPromptInteraction, QtiPromptInteractionOptions } from "./interaction";
+export type ExtendedTextInteractionOptions = QtiPromptInteractionOptions & {
+    base?: number;
+    stringIdentifier?: string;
+    expectedLength?: number;
+    patternMask?: string;
+    placeholderText?: string;
+    maxStrings?: number;
+    minStrings?: number;
+    expectedLines?: number;
+    format?: "plain" | "pre-formatted" | "xhtml";
+};
+/**
+ * Allows candidates to enter extended text responses, such as essays or paragraphs.
+ * Supports configurable length constraints, formatting options, and input validation.
+ *
+ * @see https://www.imsglobal.org/spec/qti/v3p0/impl#h.omuxci3o5dmg
+ *
+ * @example
+ * const interaction = new ExtendedTextInteraction({
+ *   responseIdentifier: "RESPONSE",
+ *   expectedLines: 10,
+ *   format: "plain",
+ * });
+ */
+export declare class ExtendedTextInteraction extends QtiPromptInteraction {
+    constructor(options: ExtendedTextInteractionOptions);
+}

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

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExtendedTextInteraction = void 0;
+const xmlbuilder2_1 = require("xmlbuilder2");
+const interaction_1 = require("./interaction");
+/**
+ * Allows candidates to enter extended text responses, such as essays or paragraphs.
+ * Supports configurable length constraints, formatting options, and input validation.
+ *
+ * @see https://www.imsglobal.org/spec/qti/v3p0/impl#h.omuxci3o5dmg
+ *
+ * @example
+ * const interaction = new ExtendedTextInteraction({
+ *   responseIdentifier: "RESPONSE",
+ *   expectedLines: 10,
+ *   format: "plain",
+ * });
+ */
+class ExtendedTextInteraction extends interaction_1.QtiPromptInteraction {
+    constructor(options) {
+        super(options);
+        this.item = (0, xmlbuilder2_1.fragment)().ele("qti-extended-text-interaction", {
+            "response-identifier": options.responseIdentifier,
+            label: options.label,
+            base: options.base?.toString(),
+            "string-identifier": options.stringIdentifier,
+            "expected-length": options.expectedLength?.toString(),
+            "pattern-mask": options.patternMask,
+            "placeholder-text": options.placeholderText,
+            "max-strings": options.maxStrings?.toString(),
+            "min-strings": options.minStrings?.toString(),
+            "expected-lines": options.expectedLines?.toString(),
+            format: options.format,
+        });
+    }
+}
+exports.ExtendedTextInteraction = ExtendedTextInteraction;

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

@@ -0,0 +1,34 @@
+import { QtiPromptInteraction, QtiPromptInteractionOptions } from "./interaction";
+export type GapTextOptions = {
+    identifier: string;
+    matchMax?: number;
+    matchMin?: number;
+    matchGroup?: string;
+    content?: string;
+};
+export type GapMatchInteractionOptions = QtiPromptInteractionOptions & {
+    shuffle?: boolean;
+    minAssociations?: number;
+    maxAssociations?: number;
+    gapTexts?: GapTextOptions[];
+    content?: string;
+};
+/**
+ * Presents candidates with a set of gaps within content and a set of choices to fill them.
+ * Candidates drag or select choices to match them with the appropriate gaps.
+ *
+ * @see https://www.imsglobal.org/spec/qti/v3p0/impl#h.7sroqk3xl8e1
+ *
+ * @example
+ * const interaction = new GapMatchInteraction({
+ *   responseIdentifier: "RESPONSE",
+ *   gapTexts: [
+ *     { identifier: "gap-1", content: "Paris" },
+ *     { identifier: "gap-2", content: "London" },
+ *   ],
+ *   content: "<p>The capital of France is <qti-gap identifier='G1'/>.</p>",
+ * });
+ */
+export declare class GapMatchInteraction extends QtiPromptInteraction {
+    constructor(options: GapMatchInteractionOptions);
+}

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

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GapMatchInteraction = void 0;
+const xmlbuilder2_1 = require("xmlbuilder2");
+const interaction_1 = require("./interaction");
+const html_1 = require("../../utils/html");
+/**
+ * Presents candidates with a set of gaps within content and a set of choices to fill them.
+ * Candidates drag or select choices to match them with the appropriate gaps.
+ *
+ * @see https://www.imsglobal.org/spec/qti/v3p0/impl#h.7sroqk3xl8e1
+ *
+ * @example
+ * const interaction = new GapMatchInteraction({
+ *   responseIdentifier: "RESPONSE",
+ *   gapTexts: [
+ *     { identifier: "gap-1", content: "Paris" },
+ *     { identifier: "gap-2", content: "London" },
+ *   ],
+ *   content: "<p>The capital of France is <qti-gap identifier='G1'/>.</p>",
+ * });
+ */
+class GapMatchInteraction extends interaction_1.QtiPromptInteraction {
+    constructor(options) {
+        super(options);
+        this.item = (0, xmlbuilder2_1.fragment)().ele("qti-gap-match-interaction", {
+            "response-identifier": options.responseIdentifier,
+            label: options.label,
+            shuffle: options.shuffle ? "true" : "false",
+            "min-associations": options.minAssociations?.toString(),
+            "max-associations": options.maxAssociations?.toString(),
+        });
+        for (const gapText of options.gapTexts || []) {
+            const gapTextEl = this.item.ele("qti-gap-text", {
+                identifier: gapText.identifier,
+                "match-max": gapText.matchMax?.toString(),
+                "match-min": gapText.matchMin?.toString(),
+                "match-group": gapText.matchGroup,
+            });
+            if (gapText.content) {
+                (0, html_1.appendHtmlFragment)(gapText.content, gapTextEl);
+            }
+        }
+        if (options.content) {
+            (0, html_1.appendHtmlFragment)(options.content, this.item);
+        }
+    }
+}
+exports.GapMatchInteraction = GapMatchInteraction;

package/dist/qti/interactions/graphic-associate-interaction.d.ts

@@ -0,0 +1,37 @@
+import { HotspotShape, ObjectOptions } from "./hotspot-interaction";
+import { QtiPromptInteraction, QtiPromptInteractionOptions } from "./interaction";
+export { HotspotShape, ObjectOptions };
+export type AssociableHotspotOptions = {
+    identifier: string;
+    shape: HotspotShape;
+    coords: string;
+    matchMax?: number;
+    matchMin?: number;
+    matchGroup?: string;
+    hotspotLabel?: string;
+};
+export type GraphicAssociateInteractionOptions = QtiPromptInteractionOptions & {
+    minAssociations?: number;
+    maxAssociations?: number;
+    object: ObjectOptions;
+    associableHotspots?: AssociableHotspotOptions[];
+};
+/**
+ * Presents an image with hotspots for candidates to associate or connect with each other.
+ * Used for drawing connections between points on a diagram or map.
+ *
+ * @see https://www.imsglobal.org/spec/qti/v3p0/impl#h.acwq9g2z1cwt
+ *
+ * @example
+ * const interaction = new GraphicAssociateInteraction({
+ *   responseIdentifier: "RESPONSE",
+ *   object: { data: "circuit.png", type: "image/png", width: 400, height: 300 },
+ *   associableHotspots: [
+ *     { identifier: "A", shape: "circle", coords: "100,100,15", matchMax: 1 },
+ *     { identifier: "B", shape: "circle", coords: "200,100,15", matchMax: 1 },
+ *   ],
+ * });
+ */
+export declare class GraphicAssociateInteraction extends QtiPromptInteraction {
+    constructor(options: GraphicAssociateInteractionOptions);
+}