cognikit 0.1.0

package/dist/interactions/adjacency-table/index.d.ts

@@ -0,0 +1,26 @@
+import { BaseInteraction } from "../../core/BaseInteraction";
+import { Variant } from "../../shared/types";
+import { InteractionConfig, InteractionMechanic } from "../../types/Interactions";
+import { ValueTableData, TableCompletion } from "../../types/Tables";
+export declare class AdjacencyTable extends BaseInteraction<ValueTableData> {
+    interactionMechanic: InteractionMechanic;
+    private _tableConfig;
+    private _$table;
+    constructor(data: ValueTableData, config: InteractionConfig);
+    protected initialize(): void;
+    protected cleanup(): void;
+    onVariantChange(newVariant: Variant): void;
+    render(): void;
+    /**
+     * Update progress bar based on how many non-diagonal cells are filled
+     */
+    private updateProgressBasedOnCompletion;
+    getCurrentState(): TableCompletion;
+    isInteractionComplete(): boolean;
+    onHint(): void;
+    /**
+     * Override submit to include grading using adjacency grader
+     */
+    submit(): void;
+    reset(): void;
+}

package/dist/interactions/categorize-the-words/index.d.ts

@@ -0,0 +1,2 @@
+export { CategorizeTheWords } from "./static";
+export { SequentialCategorizeTheWords } from "./sequential";

package/dist/interactions/categorize-the-words/sequential.d.ts

@@ -0,0 +1,33 @@
+import { BaseInteraction } from "../../core/BaseInteraction";
+import { Variant } from "../../shared/types";
+import { InteractionConfig, InteractionMechanic } from "../../types/Interactions";
+import { GradingResult } from "../../types/Grading";
+import { TextEngineSequentialInteractionData } from "../../types/Text";
+export declare class SequentialCategorizeTheWords extends BaseInteraction<TextEngineSequentialInteractionData> {
+    interactionMechanic: InteractionMechanic;
+    private _slides;
+    private _currentStep;
+    private _textConfig;
+    private _$text;
+    private _responses;
+    private _gradingByStep;
+    private _isGraded;
+    get slidesCount(): number;
+    constructor(data: TextEngineSequentialInteractionData, config: InteractionConfig);
+    protected initialize(): void;
+    protected cleanup(): void;
+    onVariantChange(newVariant: Variant): void;
+    setSteps(stepIndex: number): void;
+    render(): void;
+    private getTargetIndices;
+    private getTotalTargetCount;
+    private saveCurrentStepResponse;
+    private getResponseForStep;
+    private updateProgressAcrossSteps;
+    getCurrentState(): any;
+    isInteractionComplete(): boolean;
+    onHint(): void;
+    grade(): GradingResult;
+    submit(): void;
+    reset(): void;
+}

package/dist/interactions/categorize-the-words/static.d.ts

@@ -0,0 +1,22 @@
+import { BaseInteraction } from "../../core/BaseInteraction";
+import { Variant } from "../../shared/types";
+import { InteractionConfig, InteractionMechanic } from "../../types/Interactions";
+import { TextEngineClassificationData } from "../../types/Text";
+import { type TextEngineClassificationUserData } from "../../engines/text";
+export declare class CategorizeTheWords extends BaseInteraction<TextEngineClassificationData> {
+    interactionMechanic: InteractionMechanic;
+    private _textConfig;
+    private _$text;
+    constructor(data: TextEngineClassificationData, config: InteractionConfig);
+    protected initialize(): void;
+    protected cleanup(): void;
+    onVariantChange(newVariant: Variant): void;
+    render(): void;
+    private getTargetIndices;
+    getCurrentState(): TextEngineClassificationUserData;
+    isInteractionComplete(): boolean;
+    onHint(): void;
+    grade(): import("../../types").GradingResult;
+    submit(): void;
+    reset(): void;
+}

package/dist/interactions/classification-matrix/index.d.ts

@@ -0,0 +1,31 @@
+import { BaseInteraction } from "../../core/BaseInteraction";
+import { Variant } from "../../shared/types";
+import { InteractionConfig, InteractionMechanic } from "../../types/Interactions";
+import { BaseTableData, TableCompletion } from "../../types/Tables";
+/**
+ * ClassificationMatrix
+ *
+ * Table-based interaction using checkboxes to assign multiple attributes
+ * to items.
+ *
+ * Inspired from Typeform's matrix and based on my table's engine
+ * See their implementation in their content features:
+ * @see https://admin.typeform.com
+ *
+ */
+export declare class ClassificationMatrix extends BaseInteraction<BaseTableData> {
+    interactionMechanic: InteractionMechanic;
+    private _tableConfig;
+    private _$table;
+    constructor(data: BaseTableData, config: InteractionConfig);
+    protected initialize(): void;
+    protected cleanup(): void;
+    onVariantChange(newVariant: Variant): void;
+    render(): void;
+    private updateProgressBasedOnCompletion;
+    getCurrentState(): TableCompletion;
+    isInteractionComplete(): boolean;
+    onHint(): void;
+    submit(): void;
+    reset(): void;
+}

package/dist/interactions/fill-blanks/index.d.ts

@@ -0,0 +1,2 @@
+export { FillBlanks } from "./static";
+export { SequentialFillBlanks } from "./sequential";

package/dist/interactions/fill-blanks/sequential.d.ts

@@ -0,0 +1,32 @@
+import { BaseInteraction } from "../../core/BaseInteraction";
+import { Variant } from "../../shared/types";
+import { InteractionConfig, InteractionMechanic } from "../../types/Interactions";
+import { TextEngineSequentialInteractionData } from "../../types/Text";
+import { GradingResult } from "../../types/Grading";
+export declare class SequentialFillBlanks extends BaseInteraction<TextEngineSequentialInteractionData> {
+    interactionMechanic: InteractionMechanic;
+    private _slides;
+    private _currentStep;
+    private _textConfig;
+    private _$text;
+    private _responses;
+    private _gradingByStep;
+    private _isGraded;
+    get slidesCount(): number;
+    constructor(data: TextEngineSequentialInteractionData, config: InteractionConfig);
+    protected initialize(): void;
+    protected cleanup(): void;
+    onVariantChange(newVariant: Variant): void;
+    setSteps(stepIndex: number): void;
+    render(): void;
+    private getTotalTargetCount;
+    private saveCurrentStepResponse;
+    private getResponseForStep;
+    private updateProgressAcrossSteps;
+    getCurrentState(): any;
+    isInteractionComplete(): boolean;
+    onHint(): void;
+    grade(): GradingResult;
+    submit(): void;
+    reset(): void;
+}

package/dist/interactions/fill-blanks/static.d.ts

@@ -0,0 +1,23 @@
+import { BaseInteraction } from "../../core/BaseInteraction";
+import { Variant } from "../../shared/types";
+import { InteractionConfig, InteractionMechanic } from "../../types/Interactions";
+import { TextEngineBlanksData } from "../../types/Text";
+import { type TextEngineBlanksUserData } from "../../engines/text";
+export declare class FillBlanks extends BaseInteraction<TextEngineBlanksData> {
+    interactionMechanic: InteractionMechanic;
+    private _textConfig;
+    private _$text;
+    constructor(data: TextEngineBlanksData, config: InteractionConfig);
+    protected initialize(): void;
+    protected cleanup(): void;
+    onVariantChange(newVariant: Variant): void;
+    render(): void;
+    getCurrentState(): TextEngineBlanksUserData;
+    private updateProgressBasedOnInputs;
+    isInteractionComplete(): boolean;
+    onHint(): void;
+    private getHintText;
+    grade(): import("../../types").GradingResult;
+    submit(): void;
+    reset(): void;
+}

package/dist/interactions/index.d.ts

@@ -0,0 +1,17 @@
+import "./register-builtins";
+export * from "./open-classification";
+export * from "./sequential-classification";
+export * from "./registry";
+export * from "./register-builtins";
+export * from "./mcq-mrq";
+export * from "./simultaneous-association";
+export * from "./list-recall";
+export * from "./lookup-table";
+export * from "./classification-matrix";
+export * from "./nary-choice-table";
+export * from "./adjacency-table";
+export * from "./mark-the-words";
+export * from "./categorize-the-words";
+export * from "./text-transformation";
+export * from "./fill-blanks";
+export * from "./rank-order";

package/dist/interactions/list-recall/index.d.ts

@@ -0,0 +1 @@
+export { ListRecall } from "./script";

package/dist/interactions/list-recall/script.d.ts

@@ -0,0 +1,25 @@
+import { BaseInteraction } from "../../core/BaseInteraction";
+import { Variant } from "../../shared/types";
+import { InteractionConfig, InteractionMechanic } from "../../types/Interactions";
+import { FreeRecallData } from "../../types/Data";
+export declare class ListRecall extends BaseInteraction<FreeRecallData> {
+    interactionMechanic: InteractionMechanic;
+    private _$chipsContainer;
+    private _$textInput;
+    private _$addButton;
+    private _recalledItems;
+    constructor(data: FreeRecallData, config: InteractionConfig);
+    protected initialize(): void;
+    protected cleanup(): void;
+    onVariantChange(newVariant: Variant): void;
+    render(): void;
+    private handleAddItem;
+    private addChip;
+    getCurrentState(): string[];
+    isInteractionComplete(): boolean;
+    onHint(): void;
+    submit(): void;
+    private gradeRecall;
+    private applyGradingFeedback;
+    reset(): void;
+}

package/dist/interactions/lookup-table/index.d.ts

@@ -0,0 +1,26 @@
+import { BaseInteraction } from "../../core/BaseInteraction";
+import { Variant } from "../../shared/types";
+import { InteractionConfig, InteractionMechanic } from "../../types/Interactions";
+import { ValueTableData, TableCompletion } from "../../types/Tables";
+export declare class LookupTable extends BaseInteraction<ValueTableData> {
+    interactionMechanic: InteractionMechanic;
+    private _tableConfig;
+    private _$table;
+    constructor(data: ValueTableData, config: InteractionConfig);
+    protected initialize(): void;
+    protected cleanup(): void;
+    onVariantChange(newVariant: Variant): void;
+    render(): void;
+    /**
+     * Update progress bar based on how many cells are filled
+     */
+    private updateProgressBasedOnCompletion;
+    getCurrentState(): TableCompletion;
+    isInteractionComplete(): boolean;
+    onHint(): void;
+    /**
+     * Override submit to include grading using lookup grader
+     */
+    submit(): void;
+    reset(): void;
+}

package/dist/interactions/mark-the-words/index.d.ts

@@ -0,0 +1,2 @@
+export { MarkTheWords } from "./static";
+export { SequentialMarkTheWords } from "./sequential";

package/dist/interactions/mark-the-words/sequential.d.ts

@@ -0,0 +1,34 @@
+import { BaseInteraction } from "../../core/BaseInteraction";
+import { Variant } from "../../shared/types";
+import { InteractionConfig, InteractionMechanic } from "../../types/Interactions";
+import { GradingResult } from "../../types/Grading";
+import { TextEngineSequentialInteractionData } from "../../types/Text";
+export declare class SequentialMarkTheWords extends BaseInteraction<TextEngineSequentialInteractionData> {
+    interactionMechanic: InteractionMechanic;
+    private _slides;
+    private _currentStep;
+    private _textConfig;
+    private _$text;
+    private _responses;
+    private _gradingByStep;
+    private _isGraded;
+    get slidesCount(): number;
+    constructor(data: TextEngineSequentialInteractionData, config: InteractionConfig);
+    protected initialize(): void;
+    protected cleanup(): void;
+    onVariantChange(newVariant: Variant): void;
+    setSteps(stepIndex: number): void;
+    render(): void;
+    private getTargetCountForSlide;
+    private getTotalTargetCount;
+    private saveCurrentStepResponse;
+    private getResponseForStep;
+    private getTargetIndices;
+    private updateProgressAcrossSteps;
+    getCurrentState(): any;
+    isInteractionComplete(): boolean;
+    onHint(): void;
+    grade(): GradingResult;
+    submit(): void;
+    reset(): void;
+}

package/dist/interactions/mark-the-words/static.d.ts

@@ -0,0 +1,40 @@
+import { BaseInteraction } from "../../core/BaseInteraction";
+import { Variant } from "../../shared/types";
+import { InteractionConfig, InteractionMechanic } from "../../types/Interactions";
+import { TextEngineBaseData } from "../../types/Text";
+import { type TextEngineBaseUserData } from "../../engines/text";
+/**
+ * Mark The Words - Text Highlight Interaction
+ *
+ * Users click to select/highlight target words in a passage of text.
+ * Based on the TextEngineBaseData with highlight mode.
+ *
+ * Example data:
+ * ```
+ * {
+ *   type: 'base',
+ *   parts: ['The', 'cat', 'sat', 'on', 'the', 'mat'],
+ *   targets: [
+ *     { words: ['cat'], startPos: 1, endPos: 1 },
+ *     { words: ['mat'], startPos: 5, endPos: 5 }
+ *   ]
+ * }
+ * ```
+ */
+export declare class MarkTheWords extends BaseInteraction<TextEngineBaseData> {
+    interactionMechanic: InteractionMechanic;
+    private _textConfig;
+    private _$text;
+    constructor(data: TextEngineBaseData, config: InteractionConfig);
+    protected initialize(): void;
+    protected cleanup(): void;
+    onVariantChange(newVariant: Variant): void;
+    render(): void;
+    getCurrentState(): TextEngineBaseUserData;
+    isInteractionComplete(): boolean;
+    onHint(): void;
+    getUserData(): TextEngineBaseUserData;
+    submit(): void;
+    grade(): import("../../types").GradingResult;
+    reset(): void;
+}

package/dist/interactions/mcq-mrq/implementation/grader.d.ts

@@ -0,0 +1,20 @@
+import { GradingResult } from "../../../types/Grading";
+import { RecognitionData } from "../../../types/Data";
+/**
+ * User's answers for MCQ/MRQ
+ * Format: { "question text": ["selected option 1", "selected option 2", ...] }
+ */
+export type RecognitionAnswers = Record<string, string[]>;
+/**
+ * Grader for MCQ/MRQ interactions
+ *
+ * Grading logic per question:
+ * - Each correct option selected: +1 point
+ * - Each incorrect option selected: -1 point (penalty)
+ * - Each correct option NOT selected (missed): -1 point (penalty)
+ * - Score is (correct selections - wrong selections - missed) / total correct options
+ * - Rounded to whole number percentage
+ *
+ * Overall score: average of all question scores
+ */
+export declare function recognitionGrader(data: RecognitionData, userAnswers: RecognitionAnswers): GradingResult;

package/dist/interactions/mcq-mrq/implementation/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./grader";
+export * from "./parser";
+export * from "./validator";

package/dist/interactions/mcq-mrq/implementation/parser.d.ts

@@ -0,0 +1,21 @@
+import { RecognitionData } from "../../../types/Data";
+type ParseResult = {
+    data: RecognitionData;
+    errors?: Record<string, string>;
+};
+/**
+ * Parser for MCQ/MRQ grammar
+ *
+ * Grammar:
+ * # question
+ * [correct1 | correct2] | incorrect1 | incorrect2;
+ *
+ * Rules:
+ * - '#' indicates a question
+ * - '[...]' contains correct options separated by '|'
+ * - Options outside brackets are incorrect
+ * - Lines must end with ';'
+ * - '@:assetName' for asset references (preserved as-is)
+ */
+export declare function recognitionParser(code: string): ParseResult;
+export {};

package/dist/interactions/mcq-mrq/implementation/validator.d.ts

@@ -0,0 +1,17 @@
+import { RecognitionData } from "../../../types/Data";
+type ValidationResult = {
+    ok: boolean;
+    errors?: Record<string, string>;
+};
+/**
+ * Validator for MCQ/MRQ recognition data
+ *
+ * Validates:
+ * - At least one question exists
+ * - Each question has at least one correct answer
+ * - Each question has at least two total options
+ * - No duplicate options within a question
+ * - Question text is not empty
+ */
+export declare function recognitionValidator(data: RecognitionData): ValidationResult;
+export {};

package/dist/interactions/mcq-mrq/index.d.ts

@@ -0,0 +1,2 @@
+export { MCQ } from "./script";
+export * from "./implementation";

package/dist/interactions/mcq-mrq/script.d.ts

@@ -0,0 +1,37 @@
+import { BaseInteraction } from "../../core/BaseInteraction";
+import { Variant } from "../../shared/types";
+import { InteractionConfig, InteractionMechanic } from "../../types/Interactions";
+import { NormalizedAssets } from "../../types/Assets";
+import { RecognitionData } from "../../types/Data";
+import { RecognitionAnswers } from "./implementation/grader";
+export declare class MCQ extends BaseInteraction<RecognitionData> {
+    interactionMechanic: InteractionMechanic;
+    private currentQuestionIndex;
+    private userAnswers;
+    private shuffledOptions;
+    private isGraded;
+    private $questionBlock;
+    private $questionText;
+    private $optionsContainer;
+    private $modeLabel;
+    private variant;
+    get slidesCount(): number;
+    constructor(data: RecognitionData, config: InteractionConfig, assets: NormalizedAssets | null);
+    protected initialize(): void;
+    protected cleanup(): void;
+    onVariantChange(newVariant: Variant): void;
+    /**
+     * Called by shell when radio navigation changes
+     * @param stepIndex 1-based index from shell
+     */
+    setSteps(stepIndex: number): void;
+    render(): void;
+    private renderCurrentQuestion;
+    private handleOptionClick;
+    private updateProgress;
+    getCurrentState(): RecognitionAnswers;
+    isInteractionComplete(): boolean;
+    onHint(): void;
+    submit(): void;
+    reset(): void;
+}

package/dist/interactions/nary-choice-table/index.d.ts

@@ -0,0 +1,28 @@
+import { BaseInteraction } from "../../core/BaseInteraction";
+import { Variant } from "../../shared/types";
+import { InteractionConfig, InteractionMechanic } from "../../types/Interactions";
+import { BaseTableData, TableCompletion } from "../../types/Tables";
+export declare class NaryChoiceTable extends BaseInteraction<BaseTableData> {
+    interactionMechanic: InteractionMechanic;
+    private _tableConfig;
+    private _$table;
+    constructor(data: BaseTableData, config: InteractionConfig);
+    protected initialize(): void;
+    protected cleanup(): void;
+    onVariantChange(newVariant: Variant): void;
+    render(): void;
+    /**
+     * Update progress bar based on how many rows have exactly one selection
+     * N-ary requires single selection per row
+     */
+    private updateProgressBasedOnCompletion;
+    getCurrentState(): TableCompletion;
+    isInteractionComplete(): boolean;
+    onHint(): void;
+    /**
+     * Override submit to include grading using n-ary grader
+     * N-ary grading is binary per row (100% or 0%)
+     */
+    submit(): void;
+    reset(): void;
+}

package/dist/interactions/open-classification/index.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Open Classification
+ *
+ * No idea if there's something like out there, but it's something I just came with
+ */
+import { BaseInteraction } from "../../core/BaseInteraction";
+import { Variant } from "../../shared/types";
+import { InteractionConfig, InteractionMechanic } from "../../types/Interactions";
+import { NormalizedAssets } from "../../types/Assets";
+import { ClassificationData } from "../../types/Data";
+export declare class OpenClassification extends BaseInteraction<ClassificationData> {
+    interactionMechanic: InteractionMechanic;
+    private categories;
+    private allItems;
+    private categoryColors;
+    private categorized;
+    private currentCategory;
+    private currentColor;
+    private $categoriesBar;
+    constructor(data: ClassificationData, config: InteractionConfig, assets: NormalizedAssets | null);
+    protected initialize(): void;
+    protected cleanup(): void;
+    onVariantChange(newVariant: Variant): void;
+    render(): void;
+    private setItems;
+    private setCategories;
+    getCurrentState(): any;
+    isInteractionComplete(): boolean;
+    onHint(): void;
+    submit(): void;
+    reset(): void;
+}

package/dist/interactions/rank-order/implementation/grader.d.ts

@@ -0,0 +1,15 @@
+import { SeriationData } from "../../../types/Data";
+import { GradingResult } from "../../../types/Grading";
+/**
+ * Grades a seriation/sequencing interaction with partial credit
+ *
+ * Scoring approach:
+ * - Correct position: 100% for that item
+ * - Adjacent position (±1): 50% for that item
+ * - Further away: 0% for that item
+ *
+ * @param correctOrder - The correct sequence of items
+ * @param userOrder - The user's submitted sequence
+ * @param parent - Parent element containing chips (for visual feedback)
+ */
+export declare function seriationGrader(correctOrder: SeriationData["items"], userOrder: string[], parent: HTMLElement): GradingResult;

package/dist/interactions/rank-order/implementation/index.d.ts

@@ -0,0 +1,3 @@
+export { seriationValidator } from "./validator";
+export { seriationGrader } from "./grader";
+export { seriationParser } from "./parser";

package/dist/interactions/rank-order/implementation/parser.d.ts

@@ -0,0 +1,25 @@
+import { ParsingResult } from "../../../shared";
+/**
+ * Parses a simple DSL for seriation data
+ *
+ * Format: Items separated by pipes (|) or newlines
+ *
+ * Example 1 (pipe-separated):
+ * ```
+ * Egg | Caterpillar | Chrysalis | Butterfly
+ * ```
+ *
+ * Example 2 (numbered):
+ * ```
+ * 1. American Revolution
+ * 2. French Revolution
+ * 3. Industrial Revolution
+ * 4. World War I
+ * ```
+ *
+ * Example 3 (with assets):
+ * ```
+ * @:step1 | @:step2 | @:step3 | Final Product
+ * ```
+ */
+export declare function seriationParser(code: string): ParsingResult;

package/dist/interactions/rank-order/implementation/validator.d.ts

@@ -0,0 +1,3 @@
+import { ValidationResult } from "../../../shared";
+import { SeriationData } from "../../../types/Data";
+export declare function seriationValidator(data: SeriationData): ValidationResult;

package/dist/interactions/rank-order/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./implementation";
+export { RankOrder } from "./script";

package/dist/interactions/rank-order/script.d.ts

@@ -0,0 +1,39 @@
+import { BaseInteraction } from "../../core/BaseInteraction";
+import { Variant } from "../../shared/types";
+import { InteractionConfig, InteractionMechanic } from "../../types/Interactions";
+import { NormalizedAssets } from "../../types/Assets";
+import { SeriationData } from "../../types/Data";
+export declare class RankOrder extends BaseInteraction<SeriationData> {
+    interactionMechanic: InteractionMechanic;
+    private currentOrder;
+    private isGraded;
+    private $container;
+    private $rowsContainer;
+    private draggedRowIndex;
+    private dragOverRowIndex;
+    private isDragging;
+    private draggedRow;
+    private dragOffsetY;
+    private boundPointerMove;
+    private boundPointerUp;
+    private variant;
+    private readonly MAX_ITEMS;
+    private readonly MIN_ITEM_HEIGHT;
+    constructor(data: SeriationData, config: InteractionConfig, assets: NormalizedAssets | null);
+    protected initialize(): void;
+    protected cleanup(): void;
+    onVariantChange(newVariant: Variant): void;
+    render(): void;
+    private renderRows;
+    private createButton;
+    private swapItems;
+    private handlePointerDown;
+    private handlePointerMove;
+    private handlePointerUp;
+    private getRowIndexAtY;
+    getCurrentState(): any;
+    isInteractionComplete(): boolean;
+    onHint(): void;
+    submit(): void;
+    reset(): void;
+}

package/dist/interactions/register-builtins.d.ts

@@ -0,0 +1 @@
+export declare const registerBuiltInInteractions: () => void;

package/dist/interactions/registry.d.ts

@@ -0,0 +1,30 @@
+import { BaseInteraction } from "../core/BaseInteraction";
+import { CognitiveOp } from "../shared/types";
+import { InteractionData } from "../types/Data";
+import { InteractionMechanic } from "../types/Interactions";
+export type InteractionConstructor = new (...args: any[]) => BaseInteraction<InteractionData>;
+export type InteractionCapabilities = {
+    isSequential: boolean;
+    implementsProgress: boolean;
+    usesAssets: boolean;
+    hasParser: boolean;
+    hasValidator: boolean;
+    hasGrader: boolean;
+};
+export type InteractionRegistryItem = {
+    id: string;
+    label: string;
+    elementTag: string;
+    cognitiveOp?: CognitiveOp;
+    mechanic: InteractionMechanic;
+    engine: "tables" | "text" | "direct" | "mixed";
+    ctor: InteractionConstructor;
+    capabilities: InteractionCapabilities;
+};
+export declare const registerInteraction: (item: InteractionRegistryItem) => void;
+export declare const unregisterInteraction: (id: string) => boolean;
+export declare const clearInteractionRegistry: () => void;
+export declare const getInteractionRegistry: () => ReadonlyMap<string, InteractionRegistryItem>;
+export declare const listInteractions: () => InteractionRegistryItem[];
+export declare const getInteraction: (id: string) => InteractionRegistryItem | null;
+export declare const createInteraction: (id: string, ...args: any[]) => BaseInteraction<InteractionData>;