@citolab/qti-components 8.0.0 → 8.0.2

package/dist/processing.d.ts

@@ -1 +1,730 @@
-export * from '@qti-components/processing';
+import * as lit from 'lit';
+import { LitElement, nothing } from 'lit';
+import { Q as QtiRuleBase } from './qti-rule-base.d-ajOnfGXY.js';
+import { I as ItemContext, B as BaseType, f as ResponseVariable, V as VariableDeclaration } from './item.types.d-QU7LljEK.js';
+import { Q as QtiExpression, a as QtiExpressionBase, T as TestContext } from './qti-expression.d-BietT_8b.js';
+import { Q as QtiConditionExpression } from './qti-condition-expression.d-aMvBvpc6.js';
+import './qti.context.d-CejJMlfZ.js';
+
+declare class QtiRule extends LitElement implements QtiRuleBase {
+    render(): lit.TemplateResult<1>;
+    process(): void;
+}
+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;
+    protected context?: ItemContext;
+    get childExpression(): QtiExpression<string>;
+    process(): number;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'qti-lookup-outcome-value': QtiLookupOutcomeValue;
+    }
+}
+
+declare class QtiResponseCondition extends QtiRule {
+    render(): lit.TemplateResult<1>;
+    process(): void;
+}
+
+/**
+ * Web component that processes `setOutcomeValue` in QTI.
+ */
+declare class QtiSetOutcomeValue extends QtiRule {
+    #private;
+    /**
+     * Processes the QTI rule and dispatches a custom event with the computed outcome value.
+     */
+    process(): void;
+}
+/**
+ * Encapsulates the logic for processing QTI setOutcomeValue expressions.
+ */
+declare class QtiSetOutcomeValueRule<T> implements QtiRuleBase {
+    private expression;
+    constructor(expression: QtiExpressionBase<T>);
+    /**
+     * Evaluates the expression and returns its value.
+     */
+    process(): string | string[] | null;
+}
+
+declare class QtiResponseElse extends LitElement {
+    render(): lit.TemplateResult<1>;
+    calculate(): boolean;
+    getSubRules(): QtiRule[];
+    process(): void;
+}
+
+declare class QtiResponseIf extends QtiResponseElse {
+    calculate(): boolean;
+    getSubRules(): QtiRule[];
+}
+
+declare class QtiResponseElseIf extends QtiResponseIf {
+    render(): lit.TemplateResult<1>;
+}
+
+type Constructor$1<T> = new (...args: any[]) => T;
+declare const QtiAnd_base: {
+    new (...args: any[]): {
+        calculateChildren(children: Array<MockQtiExpression$1<any>>): boolean;
+    };
+} & Constructor$1<QtiConditionExpression>;
+/**
+ * @summary The qti-and operator evaluates multiple boolean expressions.
+ * @documentation https://www.imsglobal.org/spec/qti/v3p0/info/index.html#and
+ *
+ * Takes 1 or more sub-expressions with base-type boolean and single cardinality.
+ * Returns true if all sub-expressions are true, false if any are false.
+ * Special cases: Returns NULL if any sub-expression is NULL and all others are true.
+ */
+declare class QtiAnd extends QtiAnd_base {
+    calculate(): boolean;
+}
+type MockQtiExpression$1<T> = {
+    calculate: () => T;
+};
+type MockConstructor$1 = new (...args: any[]) => {};
+declare function qtiAndMixin<TBase extends MockConstructor$1>(Base: TBase): {
+    new (...args: any[]): {
+        calculateChildren(children: Array<MockQtiExpression$1<any>>): boolean;
+    };
+} & TBase;
+
+/**
+ * @summary The qti-any-N operator checks if a specific range of expressions are true.
+ * @documentation https://www.imsglobal.org/spec/qti/v3p0/info/index.html#anyN
+ *
+ * Takes 1 or more sub-expressions with base-type boolean and single cardinality.
+ * Attributes 'min' and 'max' define the required range of true values.
+ * Returns true if true count is within [min, max], false if outside this range.
+ * Special cases: Returns NULL if validity cannot be determined due to NULL arguments.
+ */
+declare class QtiAnyN extends QtiExpression<boolean | null> {
+    min: number;
+    max: number;
+    getResult(): boolean | null;
+}
+
+declare class QtiBaseValue extends QtiExpression<string> {
+    baseType: BaseType;
+    getResult(): string;
+}
+
+/**
+ * @summary The qti-container-size operator returns the count of items in a container.
+ * @documentation https://www.imsglobal.org/spec/qti/v3p0/info/index.html#containerSize
+ *
+ * Takes 1 sub-expression with multiple or ordered cardinality.
+ * Returns a single integer representing the number of items.
+ * Special cases: Returns 0 if the sub-expression is NULL.
+ */
+declare class QtiContainerSize extends QtiExpression<number> {
+    getResult(): number;
+}
+
+declare class QtiContains extends QtiConditionExpression {
+    getResult(): boolean;
+}
+
+/**
+ * @summary The qti-correct operator retrieves the defined correct response for a variable.
+ * @documentation https://www.imsglobal.org/spec/qti/v3p0/info/index.html#correct
+ *
+ * Looks up the declaration for the identified response variable.
+ * Returns the associated correctResponse value(s).
+ * Special cases: Returns NULL if no correct response was declared.
+ */
+declare class QtiCorrect extends QtiExpression<string | string[]> {
+    get interpretation(): string;
+    getResult(): string | string[];
+}
+
+/**
+ * @summary The qti-default operator retrieves the defined default value for a variable.
+ * @documentation https://www.imsglobal.org/spec/qti/v3p0/info/index.html#default
+ *
+ * Looks up the declaration for the identified item variable.
+ * Returns the associated defaultValue.
+ * Special cases: Returns NULL if no default value was declared.
+ */
+declare class QtiDefault extends QtiExpression<any> {
+    identifier: string;
+    protected context?: ItemContext;
+    protected _testContext?: TestContext;
+    getResult(): any;
+}
+
+/**
+ * @summary The qti-equal-rounded operator compares two values after rounding.
+ * @documentation https://www.imsglobal.org/spec/qti/v3p0/info/index.html#equalRounded
+ *
+ * Takes 2 sub-expressions with numerical base-types and single cardinality.
+ * Requires 'figures' and 'rounding-mode' (decimalPlaces or significantFigures) attributes.
+ * Returns true if equal after specified rounding, false otherwise.
+ * Special cases: Returns NULL if either sub-expression is NULL.
+ */
+declare class QtiEqualRounded extends QtiExpression<boolean> {
+    roundingMode: 'decimalPlaces' | 'significantFigures';
+    get figures(): number;
+    getResult(): boolean;
+}
+
+/**
+ * @summary The qti-round operator rounds a numerical value to the nearest integer.
+ * @documentation https://www.imsglobal.org/spec/qti/v3p0/info/index.html#round
+ *
+ * Takes 1 numerical sub-expression of single cardinality.
+ * Returns integer n for input in range [n-0.5, n+0.5).
+ * Special cases: Returns NULL if input is NULL or NaN.
+ */
+declare class QtiRound extends QtiExpression<number | null> {
+    getResult(): number | null;
+}
+
+/**
+ * @summary The qti-round-to operator rounds a numerical value to specified precision.
+ * @documentation https://www.imsglobal.org/spec/qti/v3p0/impl#h.round-to
+ *
+ * Takes one sub-expression with single cardinality and numerical base-type.
+ * Returns a single float rounded by the specified method to the specified precision.
+ * Supports rounding to decimal places or significant figures.
+ */
+declare class QtiRoundTo extends QtiExpression<number | null> {
+    #private;
+    roundingMode: 'decimalPlaces' | 'significantFigures';
+    figures: number;
+    getResult(): number | null;
+}
+
+/**
+ * @summary The qti-equal operator checks if two numerical expressions are equal.
+ * @documentation https://www.imsglobal.org/spec/qti/v3p0/info/index.html#equal
+ *
+ * Takes 2 sub-expressions with numerical base-types and single cardinality.
+ * Supports tolerance-mode (exact, absolute, relative) for floating-point comparisons.
+ * Returns true if numerically equal within specified tolerance, false otherwise.
+ * Special cases: Returns NULL if either sub-expression is NULL.
+ */
+declare class QtiEqual extends QtiExpression<boolean> {
+    toleranceMode: 'exact' | 'relative' | 'absolute';
+    getResult(): boolean;
+}
+
+/**
+ * @summary The qti-divide operator performs numerical division.
+ * @documentation https://www.imsglobal.org/spec/qti/v3p0/info/index.html#divide
+ *
+ * Takes exactly 2 sub-expressions with numerical base-types and single cardinality.
+ * Returns a single float representing (first / second).
+ * Special cases: Returns NULL if either sub-expression is NULL or if divisor is 0.
+ */
+declare class QtiDivide extends QtiExpression<number | null> {
+    #private;
+    getResult(): number | null;
+}
+
+declare class QtiDurationGte extends QtiExpression<boolean | null> {
+    #private;
+    getResult(): boolean | null;
+}
+
+/**
+ * @summary The qti-duration-lt operator compares two time durations.
+ * @documentation https://www.imsglobal.org/spec/qti/v3p0/info/index.html#durationLT
+ *
+ * Takes 2 sub-expressions with base-type duration and single cardinality.
+ * Returns true if the first duration is shorter than the second.
+ * Special cases: Returns NULL if either argument is NULL; handles variable precision.
+ */
+declare class QtiDurationLt extends QtiExpression<boolean | null> {
+    #private;
+    getResult(): boolean | null;
+}
+
+/**
+ * @summary The qti-gcd operator calculates the greatest common divisor of integer values.
+ * @documentation https://www.imsglobal.org/spec/qti/v3p0/impl#h.gcd
+ *
+ * Takes 1 or more sub-expressions with base-type integer and any cardinality.
+ * Returns a single integer equal to the greatest common divisor of all argument values.
+ * Special cases: gcd(0,0)=0, gcd(0,n)=n if n≠0, returns NULL if any argument is NULL or non-numerical.
+ */
+declare class QtiGcd extends QtiExpression<number | null> {
+    #private;
+    getResult(): number | null;
+}
+
+declare class QtiGt extends QtiExpression<boolean> {
+    getResult(): boolean;
+}
+
+declare class QtiGte extends QtiConditionExpression {
+    getResult(): boolean;
+}
+
+declare class QtiInside extends QtiExpression<boolean | null> {
+    #private;
+    shape: string;
+    coords: string;
+    getResult(): boolean | null;
+}
+
+/**
+ * @summary The qti-integer-divide operator performs integer division rounded down.
+ * @documentation https://www.imsglobal.org/spec/qti/v3p0/info/index.html#integerDivide
+ *
+ * Takes 2 sub-expressions with base-type integer and single cardinality.
+ * Returns result of (x / y) rounded down toward negative infinity.
+ * Special cases: Returns NULL if any argument is NULL or if divisor is 0.
+ */
+declare class QtiIntegerDivide extends QtiExpression<number | null> {
+    #private;
+    getResult(): number | null;
+}
+
+/**
+ * @summary The qti-integer-modulus operator returns the remainder of integer division.
+ * @documentation https://www.imsglobal.org/spec/qti/v3p0/info/index.html#integerModulus
+ *
+ * Takes 2 sub-expressions with base-type integer and single cardinality.
+ * Returns the remainder (x % y).
+ * Special cases: Returns NULL if any argument is NULL or if divisor is 0.
+ */
+declare class QtiIntegerModulus extends QtiExpression<number | null> {
+    #private;
+    getResult(): number | null;
+}
+
+/**
+ * @summary The qti-integer-to-float operator converts an integer to a float.
+ * @documentation https://www.imsglobal.org/spec/qti/v3p0/info/index.html#integerToFloat
+ *
+ * Takes 1 sub-expression with base-type integer and single cardinality.
+ * Returns a value of base-type float with the same numeric value.
+ * Special cases: Returns NULL if sub-expression is NULL.
+ */
+declare class QtiIntegerToFloat extends QtiExpression<number | null> {
+    getResult(): number | null;
+}
+
+declare class QtiLcm extends QtiExpression<number | null> {
+    #private;
+    getResult(): number | null;
+}
+
+/**
+ * @summary The qti-null expression returns the NULL value.
+ * @documentation https://www.imsglobal.org/spec/qti/v3p0/impl#h.null
+ *
+ * A simple expression that returns the NULL value. The null value is treated
+ * as if it is of any desired base-type.
+ */
+declare class QtiNull extends QtiExpression<null> {
+    getResult(): null;
+}
+
+/**
+ * @summary The qti-is-null operator checks if a variable or expression is missing its value.
+ * @documentation https://www.imsglobal.org/spec/qti/v3p0/info/index.html#isNull
+ *
+ * Takes 1 sub-expression with any base-type or cardinality.
+ * Returns true if the sub-expression is NULL, false otherwise.
+ * Special cases: Empty containers and empty strings are treated as NULL.
+ */
+declare class QtiIsNull extends QtiExpression<boolean> {
+    getResult(): boolean;
+}
+
+/**
+ * @summary The qti-field-value operator retrieves a specific field from a record.
+ * @documentation https://www.imsglobal.org/spec/qti/v3p0/info/index.html#fieldValue
+ *
+ * Takes a sub-expression with record cardinality. 'field-identifier' identifies the field.
+ * Returns the value of the specified field.
+ * Special cases: Returns NULL if sub-expression is NULL or field does not exist.
+ */
+declare class QtiFieldValue extends QtiExpression<string | string[]> {
+    getResult(): any;
+}
+
+declare class QtiLt extends QtiExpression<boolean> {
+    getResult(): boolean;
+}
+
+declare class QtiLte extends QtiConditionExpression {
+    getResult(): boolean;
+}
+
+/**
+ * @summary The qti-map-response operator applies a mapping to a candidate's response.
+ * @documentation https://www.imsglobal.org/spec/qti/v3p0/info/index.html#mapResponse
+ *
+ * Transforms the bound response variable using the declaration's qti-mapping.
+ * Returns a single float representing the mapped score (or sum of mapped values).
+ * Special cases: Returns 0.0 if response is NULL; counts identical values in containers once.
+ */
+declare class QtiMapResponse extends QtiExpression<number> {
+    identifier: string;
+    getResult(): number;
+}
+
+declare class QtiMapResponsePoint extends QtiExpression<number> {
+    identifier: string;
+    getResult(): number;
+}
+
+/**
+ * @summary The qti-math-operator performs mathematical operations on numerical values.
+ * @documentation https://www.imsglobal.org/spec/qti/v3p0/impl#h.math-operator
+ *
+ * Takes 1 or more sub-expressions with single cardinality and numerical base-types.
+ * The result is a single float, except for signum, floor and ceil which return integers.
+ * Returns NULL if any argument is NULL or falls outside the function's natural domain.
+ */
+declare class QtiMathOperator extends QtiExpression<number | null> {
+    #private;
+    name: string;
+    getResult(): number | null;
+}
+
+/**
+ * @summary The qti-match operator compares two expressions for exact value equality.
+ * @documentation https://www.imsglobal.org/spec/qti/v3p0/info/index.html#match
+ *
+ * Takes 2 sub-expressions which must have the same base-type and cardinality.
+ * Returns true if they represent the same value, false otherwise.
+ * Special cases: Must not be used for float or duration types; returns NULL if any argument is NULL.
+ */
+declare class QtiMatch extends QtiExpression<boolean> {
+    getResult(): boolean;
+    static match(valueToMap: ResponseVariable, correctValueInfo: ResponseVariable): boolean;
+}
+
+/**
+ * @summary The qti-max operator finds the largest value in a numerical set.
+ * @documentation https://www.imsglobal.org/spec/qti/v3p0/info/index.html#max
+ *
+ * Takes 1 or more numerical sub-expressions of any cardinality.
+ * Returns the largest value in the collection.
+ * Special cases: Returns NULL if any argument is NULL or non-numerical.
+ */
+declare class QtiMax extends QtiExpression<number | null> {
+    #private;
+    getResult(): number | null;
+}
+
+declare class QtiMember extends QtiExpression<boolean | null> {
+    getResult(): boolean;
+}
+
+/**
+ * @summary The qti-min operator finds the smallest value in a numerical set.
+ * @documentation https://www.imsglobal.org/spec/qti/v3p0/info/index.html#min
+ *
+ * Takes 1 or more numerical sub-expressions of any cardinality.
+ * Returns the smallest value in the collection.
+ * Special cases: Returns NULL if any argument is NULL or non-numerical.
+ */
+declare class QtiMin extends QtiExpression<number | null> {
+    #private;
+    getResult(): number | null;
+}
+
+declare class QtiMultiple extends QtiExpression<VariableDeclaration<string | string[]>[]> {
+    getResult(): ResponseVariable[];
+}
+
+/**
+ * @summary The qti-not operator performs logical negation.
+ * @documentation https://www.imsglobal.org/spec/qti/v3p0/info/index.html#not
+ *
+ * Takes exactly 1 sub-expression with base-type boolean and single cardinality.
+ * Returns true if sub-expression is false, and false if sub-expression is true.
+ * Special cases: Returns NULL if sub-expression is NULL.
+ */
+declare class QtiNot extends QtiExpression<boolean> {
+    render(): lit.TemplateResult<1>;
+    getResult(): boolean;
+}
+
+/**
+ * @summary The qti-or operator evaluates if any provided boolean expressions are true.
+ * @documentation https://www.imsglobal.org/spec/qti/v3p0/info/index.html#or
+ *
+ * Takes 1 or more sub-expressions with base-type boolean and single cardinality.
+ * Returns true if at least one sub-expression is true, false if all are false.
+ * Special cases: Returns NULL if any sub-expression is NULL and all others are false.
+ */
+declare class QtiOr extends QtiConditionExpression {
+    getResult(): boolean;
+}
+
+declare class QtiOrdered extends QtiExpression<ResponseVariable[]> {
+    getResult(): ResponseVariable[];
+}
+
+/**
+ * @summary The qti-power operator raises the first expression to the power of the second.
+ * @documentation https://www.imsglobal.org/spec/qti/v3p0/impl#h.power
+ *
+ * Takes 2 sub-expressions with single cardinality and numerical base-types.
+ * Returns a single float corresponding to the first expression raised to the power of the second.
+ * Returns NULL if either expression is NULL or if the result is outside the float value set.
+ */
+declare class QtiPower extends QtiExpression<number | null> {
+    getResult(): number | null;
+}
+
+/**
+ * @summary The qti-pattern-match operator checks a string against a regular expression.
+ * @documentation https://www.imsglobal.org/spec/qti/v3p0/info/index.html#patternMatch
+ *
+ * Takes 1 string sub-expression; 'pattern' attribute contains the regex.
+ * Returns true if the string matches the pattern, false otherwise.
+ * Special cases: Returns NULL if sub-expression is NULL.
+ */
+declare class QtiPatternMatch extends QtiExpression<boolean | null> {
+    pattern: string;
+    getResult(): boolean | null;
+}
+
+declare class QtiPrintedVariable extends LitElement {
+    identifier: string;
+    protected context?: ItemContext;
+    render(): lit.TemplateResult<1> | typeof nothing;
+    calculate(): VariableDeclaration<string | string[]>;
+}
+
+/**
+ * @summary The qti-product operator calculates the product of multiple numerical values.
+ * @documentation https://www.imsglobal.org/spec/qti/v3p0/info/index.html#product
+ *
+ * Takes 1 or more sub-expressions with numerical base-types and any cardinality.
+ * Returns a single float (or integer if all arguments are integers).
+ * Special cases: Returns NULL if any sub-expression is NULL.
+ */
+declare class QtiProduct extends QtiExpression<number> {
+    getResult(): number;
+}
+
+/**
+ * @summary The qti-repeat operator generates a container by repeating an expression.
+ * @documentation https://www.imsglobal.org/spec/qti/v3p0/info/index.html#repeat
+ *
+ * Attributes 'number-repeats' determines the count of iterations.
+ * Returns an ordered container filled with results of the evaluated sub-expressions.
+ * Special cases: Returns NULL if number-repeats < 1; ignores evaluated NULL values.
+ */
+declare class QtiRepeat extends QtiExpression<ResponseVariable[]> {
+    #private;
+    numberRepeats: string;
+    getResult(): ResponseVariable[];
+}
+
+/**
+ * Web component that processes `setCorrectResponse` in QTI.
+ */
+declare class QtiSetCorrectResponse extends QtiRule {
+    #private;
+    /**
+     * Processes the QTI rule and dispatches a custom event with the computed correct response value.
+     */
+    process(): void;
+}
+/**
+ * Encapsulates the logic for processing QTI setCorrectResponse expressions.
+ */
+declare class QtiSetCorrectResponseRule<T> implements QtiRuleBase {
+    #private;
+    private expression;
+    constructor(expression: QtiExpressionBase<T>);
+    /**
+     * Evaluates the expression and returns its value.
+     */
+    process(): unknown;
+}
+
+/**
+ * Web component that processes `setTemplateValue` in QTI.
+ */
+declare class QtiSetTemplateValue extends QtiRule {
+    #private;
+    /**
+     * Processes the QTI rule and dispatches a custom event with the computed template value.
+     */
+    process(): void;
+}
+/**
+ * Encapsulates the logic for processing QTI setTemplateValue expressions.
+ */
+declare class QtiSetTemplateValueRule<T> implements QtiRuleBase {
+    #private;
+    private expression;
+    constructor(expression: QtiExpressionBase<T>);
+    /**
+     * Evaluates the expression and returns its value.
+     */
+    process(): unknown;
+}
+
+/**
+ * @summary The qti-stats-operator performs statistical calculations on a container.
+ * @documentation https://www.imsglobal.org/spec/qti/v3p0/info/index.html#statsOperator
+ *
+ * Takes 1 container (multiple/ordered) of numerical base-type.
+ * 'name' attribute identifies function (mean, popSD, popVariance, sampleSD, sampleVariance).
+ * Returns result as a single float.
+ * Special cases: Returns NULL if any values in container are NULL or non-numerical.
+ */
+declare class QtiStatsOperator extends QtiExpression<number | null> {
+    #private;
+    name: string;
+    getResult(): number | null;
+}
+
+type Constructor<T> = new (...args: any[]) => T;
+declare const QtiSubtract_base: {
+    new (...args: any[]): {
+        calculateChildren(children: Array<MockQtiExpression<any>>): number;
+    };
+} & Constructor<QtiExpression<number>>;
+/**
+ * @summary The qti-subtract operator performs numerical subtraction.
+ * @documentation https://www.imsglobal.org/spec/qti/v3p0/info/index.html#subtract
+ *
+ * Takes exactly 2 sub-expressions with numerical base-types and single cardinality.
+ * Returns (first - second) as a float, or integer if both inputs are integers.
+ * Special cases: Returns NULL if either sub-expression is NULL.
+ */
+declare class QtiSubtract extends QtiSubtract_base {
+    getResult(): number;
+}
+type MockQtiExpression<T> = {
+    calculate: () => T;
+};
+type MockConstructor = new (...args: any[]) => {};
+declare function qtiSubtractMixin<TBase extends MockConstructor>(Base: TBase): {
+    new (...args: any[]): {
+        calculateChildren(children: Array<MockQtiExpression<any>>): number;
+    };
+} & TBase;
+
+declare global {
+    interface HTMLElementTagNameMap {
+        'qti-subtract': QtiSubtract;
+    }
+}
+
+/**
+ * @summary The qti-substring operator checks if one string is contained within another.
+ * @documentation https://www.imsglobal.org/spec/qti/v3p0/info/index.html#substring
+ *
+ * Takes 2 sub-expressions with base-type string and single cardinality.
+ * Returns true if the first string is a substring of the second.
+ * Special cases: Returns NULL if either argument is NULL.
+ */
+declare class QtiSubstring extends QtiExpression<boolean | null> {
+    caseSensitive: string;
+    getResult(): boolean | null;
+}
+
+declare class QtiStringMatch extends QtiExpression<boolean> {
+    caseSensitive: string;
+    getResult(): boolean;
+}
+
+/**
+ * @summary The qti-sum operator calculates the total of multiple numerical values.
+ * @documentation https://www.imsglobal.org/spec/qti/v3p0/info/index.html#sum
+ *
+ * Takes 1 or more sub-expressions with numerical base-types and any cardinality.
+ * Returns a single float (or integer if all arguments are integers) representing the total.
+ * Special cases: Returns NULL if any sub-expression is NULL.
+ */
+declare class QtiSum extends QtiExpression<number> {
+    getResult(): number;
+}
+declare class QtiSumExpression implements QtiExpressionBase<number> {
+    private expressions;
+    constructor(expressions: QtiExpressionBase<number>[]);
+    calculate(): number;
+}
+
+/**
+ * @summary The qti-truncate operator removes fractional parts of a number.
+ * @documentation https://www.imsglobal.org/spec/qti/v3p0/info/index.html#truncate
+ *
+ * Takes 1 numerical sub-expression of single cardinality.
+ * Returns integer formed by truncating value toward zero.
+ * Special cases: Returns NULL if input is NULL or NaN.
+ */
+declare class QtiTruncate extends QtiExpression<number | null> {
+    getResult(): number | null;
+}
+
+declare class QtiVariable extends QtiExpression<string | string[]> {
+    getResult(): Readonly<string | string[]>;
+}
+
+/**
+ * @summary The qti-random-integer operator selects a random integer from a specified range.
+ * @documentation https://www.imsglobal.org/spec/qti/v3p0/impl#h.random-integer
+ *
+ * Selects a random integer from the range [min,max] satisfying min + step * n for some integer n.
+ * For example, with min=2, max=11 and step=3 the values {2,5,8,11} are possible.
+ */
+declare class QtiRandomInteger extends QtiExpression<number> {
+    min: number;
+    max: number;
+    step: number;
+    getResult(): number;
+    /**
+     * Get all possible values for testing purposes
+     */
+    getPossibleValues(): number[];
+}
+
+declare class QtiRandom extends QtiExpression<string> {
+    getResult(): any;
+}
+
+/**
+ * @summary The qti-delete operator removes all instances of a value from a container.
+ * @documentation https://www.imsglobal.org/spec/qti/v3p0/info/index.html#delete
+ *
+ * Takes a single value (1st) and a container (2nd) of the same base-type.
+ * Returns a new container derived from the 2nd with all instances of 1st removed.
+ * Special cases: Returns NULL if either argument is NULL.
+ */
+declare class QtiDelete extends QtiExpression<string[] | null> {
+    getResult(): string[] | null;
+}
+
+/**
+ * @summary The qti-index operator retrieves a specific item from an ordered container.
+ * @documentation https://www.imsglobal.org/spec/qti/v3p0/info/index.html#index
+ *
+ * Takes 1 ordered container sub-expression; 'n' attribute specifies 1-based index.
+ * Returns the nth value from the container with original base-type and single cardinality.
+ * Special cases: Returns NULL if container is NULL or n exceeds container size.
+ */
+declare class QtiIndex extends QtiExpression<any> {
+    #private;
+    n: string;
+    getResult(): any;
+}
+
+export { QtiAnd, QtiAnyN, QtiBaseValue, QtiContainerSize, QtiContains, QtiCorrect, QtiDefault, QtiDelete, QtiDivide, QtiDurationGte, QtiDurationLt, QtiEqual, QtiEqualRounded, QtiFieldValue, QtiGcd, QtiGt, QtiGte, QtiIndex, QtiInside, QtiIntegerDivide, QtiIntegerModulus, QtiIntegerToFloat, QtiIsNull, QtiLcm, QtiLookupOutcomeValue, QtiLt, QtiLte, QtiMapResponse, QtiMapResponsePoint, QtiMatch, QtiMathOperator, QtiMax, QtiMember, QtiMin, QtiMultiple, QtiNot, QtiNull, QtiOr, QtiOrdered, QtiPatternMatch, QtiPower, QtiPrintedVariable, QtiProduct, QtiRandom, QtiRandomInteger, QtiRepeat, QtiResponseCondition, QtiResponseElse, QtiResponseElseIf, QtiResponseIf, QtiRound, QtiRoundTo, QtiSetCorrectResponse, QtiSetCorrectResponseRule, QtiSetOutcomeValue, QtiSetOutcomeValueRule, QtiSetTemplateValue, QtiSetTemplateValueRule, QtiStatsOperator, QtiStringMatch, QtiSubstring, QtiSubtract, QtiSum, QtiSumExpression, QtiTruncate, QtiVariable, qtiAndMixin, qtiSubtractMixin };