@nakafa/aksara-contracts 0.27.0

package/dist/question/identity.js

@@ -0,0 +1,205 @@
+import { Schema } from "effect";
+import { CONTENT_KEY_MAX_LENGTH, ContentKeySchema, CorpusSourcePathSchema, } from "#contracts/ids";
+import { ArtifactLocaleSchema } from "#contracts/locale";
+import { TryoutKeySchema } from "#contracts/tryout/key";
+/** Stable namespace shared by every try-out question-bank identity. */
+export const QUESTION_BANK_KEY_ROOT = "question-bank/tryout";
+const QUESTION_NUMBER_PATTERN = /^question-[1-9]\d*$/u;
+const QUESTION_SEGMENT_PREFIX = "question-";
+const MAX_QUESTION_KEY_LENGTH = CONTENT_KEY_MAX_LENGTH - "/question".length;
+const MAX_QUESTION_SET_KEY_LENGTH = MAX_QUESTION_KEY_LENGTH - "/question-1".length;
+const isTryoutKey = Schema.is(TryoutKeySchema);
+/** Checks that one canonical question number stays a safe integer. */
+function hasSafeQuestionNumber(segment) {
+    return Number.isSafeInteger(Number(segment.slice(QUESTION_SEGMENT_PREFIX.length)));
+}
+/** Canonical terminal directory identity for one numbered question. */
+export const QuestionSegmentSchema = Schema.String.pipe(Schema.check(Schema.isPattern(QUESTION_NUMBER_PATTERN)), Schema.check(Schema.makeFilter(hasSafeQuestionNumber)));
+const isQuestionSegment = Schema.is(QuestionSegmentSchema);
+/** Authored MDX body roles carried by each localized question. */
+export const QuestionBodyKindSchema = Schema.Literals(["question", "answer"]);
+/** Generic hierarchy derived from one canonical try-out question set. */
+export const QuestionSetPartsSchema = Schema.Struct({
+    countryKey: TryoutKeySchema,
+    examKey: TryoutKeySchema,
+    intermediateBankKeys: Schema.Array(TryoutKeySchema),
+    sectionKey: TryoutKeySchema,
+    setKey: TryoutKeySchema,
+});
+/** Generic hierarchy and authored order derived from one question key. */
+export const QuestionKeyPartsSchema = Schema.Struct({
+    ...QuestionSetPartsSchema.fields,
+    questionNumber: Schema.Finite.pipe(Schema.check(Schema.isInt()), Schema.check(Schema.isGreaterThan(0))),
+});
+/** Parses the protocol root plus generic country, exam, and set hierarchy. */
+function parseQuestionSetParts(input) {
+    const prefix = `${QUESTION_BANK_KEY_ROOT}/`;
+    if (!input.startsWith(prefix)) {
+        return;
+    }
+    const keys = input.slice(prefix.length).split("/");
+    if (keys.length < 4 ||
+        keys.some((key) => !isTryoutKey(key) || isQuestionSegment(key))) {
+        return;
+    }
+    return Schema.decodeUnknownSync(QuestionSetPartsSchema)({
+        countryKey: keys.at(0),
+        examKey: keys.at(1),
+        intermediateBankKeys: keys.slice(2, -2),
+        sectionKey: keys.at(-2),
+        setKey: keys.at(-1),
+    });
+}
+/** Parses one numbered question beneath a structurally valid set identity. */
+function parseQuestionKeyParts(input) {
+    const separator = input.lastIndexOf("/");
+    if (separator === -1) {
+        return;
+    }
+    const question = input.slice(separator + 1);
+    const setParts = parseQuestionSetParts(input.slice(0, separator));
+    if (!isQuestionSegment(question) || setParts === undefined) {
+        return;
+    }
+    return {
+        ...setParts,
+        questionNumber: Number(question.slice(QUESTION_SEGMENT_PREFIX.length)),
+    };
+}
+/** Stable logical identity shared by every locale and body of one question. */
+export const QuestionKeySchema = Schema.String.pipe(Schema.check(Schema.isMaxLength(MAX_QUESTION_KEY_LENGTH)), Schema.check(Schema.makeFilter((input) => parseQuestionKeyParts(input) !== undefined, {
+    identifier: "QuestionKey",
+    message: "Invalid try-out question key.",
+})), Schema.brand("@NakafaAI/AksaraQuestionKey"));
+/** Stable logical identity shared by every question within one authored set. */
+export const QuestionSetKeySchema = Schema.String.pipe(Schema.check(Schema.isMaxLength(MAX_QUESTION_SET_KEY_LENGTH)), Schema.check(Schema.makeFilter((input) => parseQuestionSetParts(input) !== undefined, {
+    identifier: "QuestionSetKey",
+    message: "Invalid try-out question-set key.",
+})), Schema.brand("@NakafaAI/AksaraQuestionSetKey"));
+/** Derives the renderer-owned bank identity above one authored set. */
+export function questionBankKey(questionSetKey) {
+    return questionSetKey.slice(0, questionSetKey.lastIndexOf("/"));
+}
+/** Derives generic country, exam, bank, section, and set identities. */
+export function questionSetKeyParts(questionSetKey) {
+    return Schema.decodeUnknownSync(QuestionSetPartsSchema)(parseQuestionSetParts(questionSetKey));
+}
+/** Derives the parent hierarchy and safe authored order from one question. */
+export function questionKeyParts(questionKey) {
+    const parts = Schema.decodeUnknownSync(QuestionKeyPartsSchema)(parseQuestionKeyParts(questionKey));
+    const separator = questionKey.lastIndexOf("/");
+    return {
+        ...parts,
+        questionSetKey: QuestionSetKeySchema.make(questionKey.slice(0, separator)),
+    };
+}
+const QuestionSourceFields = {
+    ...QuestionKeyPartsSchema.fields,
+    questionKey: QuestionKeySchema,
+    sourcePath: CorpusSourcePathSchema,
+};
+/** Complete physical MDX source identity derived from one question body. */
+export const QuestionBodySourcePartsSchema = Schema.Struct({
+    ...QuestionSourceFields,
+    artifactLocale: ArtifactLocaleSchema,
+    bodyKind: QuestionBodyKindSchema,
+    contentKey: ContentKeySchema,
+    kind: Schema.Literal("body"),
+});
+/** Complete physical TypeScript source identity for one assessment item. */
+export const QuestionItemSourcePartsSchema = Schema.Struct({
+    ...QuestionSourceFields,
+    kind: Schema.Literal("item"),
+});
+/** Every direct authored source accepted inside one question directory. */
+export const QuestionSourcePartsSchema = Schema.Union([
+    QuestionBodySourcePartsSchema,
+    QuestionItemSourcePartsSchema,
+]);
+/** Parses one exact body or item source below the question corpus. */
+function parseQuestionSourceParts(input) {
+    const corpusPrefix = "packages/corpus/";
+    const fileSeparator = input.lastIndexOf("/");
+    const questionKey = input.slice(corpusPrefix.length, fileSeparator);
+    const questionParts = parseQuestionKeyParts(questionKey);
+    if (questionParts === undefined ||
+        !Schema.is(QuestionKeySchema)(questionKey)) {
+        return;
+    }
+    const sourceFile = input.slice(fileSeparator + 1);
+    if (sourceFile === "item.ts") {
+        return Schema.decodeSync(QuestionItemSourcePartsSchema)({
+            ...questionParts,
+            kind: "item",
+            questionKey,
+            sourcePath: input,
+        });
+    }
+    const extension = ".mdx";
+    if (!sourceFile.endsWith(extension)) {
+        return;
+    }
+    const fileStem = sourceFile.slice(0, -extension.length);
+    const localeSeparator = fileStem.lastIndexOf(".");
+    if (localeSeparator === -1) {
+        return;
+    }
+    const bodyKind = fileStem.slice(0, localeSeparator);
+    const artifactLocale = fileStem.slice(localeSeparator + 1);
+    if (!(Schema.is(QuestionBodyKindSchema)(bodyKind) &&
+        Schema.is(ArtifactLocaleSchema)(artifactLocale))) {
+        return;
+    }
+    return Schema.decodeSync(QuestionBodySourcePartsSchema)({
+        ...questionParts,
+        artifactLocale,
+        bodyKind,
+        contentKey: `${questionKey}/${bodyKind}`,
+        kind: "body",
+        questionKey,
+        sourcePath: input,
+    });
+}
+/** Exact direct authored source path below one Aksara question directory. */
+export const QuestionSourcePathSchema = CorpusSourcePathSchema.pipe(Schema.check(Schema.makeFilter((input) => parseQuestionSourceParts(input) !== undefined, {
+    message: "Invalid try-out question source path.",
+})), Schema.brand("@NakafaAI/AksaraQuestionSourcePath"));
+/** Derives every logical identity from one validated physical source path. */
+export function questionSourcePathParts(sourcePath) {
+    return Schema.decodeUnknownSync(QuestionSourcePartsSchema)(parseQuestionSourceParts(sourcePath));
+}
+const QuestionIdentityFields = {
+    artifactLocale: ArtifactLocaleSchema,
+    contentKey: ContentKeySchema,
+    peerContentKey: ContentKeySchema,
+    questionKey: QuestionKeySchema,
+    questionNumber: Schema.Finite.pipe(Schema.check(Schema.isInt()), Schema.check(Schema.isGreaterThan(0))),
+    setKey: QuestionSetKeySchema,
+};
+/** Checks logical question, body, peer, set, and numeric identities together. */
+function hasCoherentQuestionIdentity(input) {
+    const expectedQuestionKey = `${input.setKey}/question-${input.questionNumber}`;
+    const peerKind = input.bodyKind === "question" ? "answer" : "question";
+    return (input.questionKey === expectedQuestionKey &&
+        input.contentKey === `${input.questionKey}/${input.bodyKind}` &&
+        input.peerContentKey === `${input.questionKey}/${peerKind}`);
+}
+/** Exact stable identity carried by one localized question prompt. */
+export const QuestionPromptIdentitySchema = Schema.Struct({
+    ...QuestionIdentityFields,
+    bodyKind: Schema.Literal("question"),
+}).pipe(Schema.check(Schema.makeFilter(hasCoherentQuestionIdentity, {
+    message: "Expected question body, peer, set, and number identities to agree.",
+})));
+/** Exact stable identity carried by one localized entitled answer. */
+export const QuestionAnswerIdentitySchema = Schema.Struct({
+    ...QuestionIdentityFields,
+    bodyKind: Schema.Literal("answer"),
+}).pipe(Schema.check(Schema.makeFilter(hasCoherentQuestionIdentity, {
+    message: "Expected answer body, peer, set, and number identities to agree.",
+})));
+/** Complete prompt and answer identity vocabulary for question bodies. */
+export const QuestionBodyIdentitySchema = Schema.Union([
+    QuestionPromptIdentitySchema,
+    QuestionAnswerIdentitySchema,
+]);

package/dist/question/item.d.ts

@@ -0,0 +1,453 @@
+import { Effect, Schema } from "effect";
+/** One locale-specific response authored without duplicated runtime keys. */
+export declare const QuestionResponseSourceSchema: Schema.Union<readonly [Schema.Struct<{
+    readonly categories: Schema.mutableKey<Schema.mutable<Schema.$Array<Schema.NonEmptyArray<Schema.Union<readonly [Schema.Struct<{
+        readonly display: Schema.Literals<readonly ["block", "inline"]>;
+        readonly kind: Schema.Literal<"math">;
+        readonly math: Schema.String;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"text">;
+        readonly text: Schema.String;
+    }>]>>>>>;
+    readonly kind: Schema.mutableKey<Schema.Literal<"category">>;
+    readonly statements: Schema.mutableKey<Schema.mutable<Schema.$Array<Schema.Struct<{
+        readonly correctCategoryOrder: Schema.mutableKey<Schema.Int>;
+        readonly label: Schema.mutableKey<Schema.NonEmptyArray<Schema.Union<readonly [Schema.Struct<{
+            readonly display: Schema.Literals<readonly ["block", "inline"]>;
+            readonly kind: Schema.Literal<"math">;
+            readonly math: Schema.String;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"text">;
+            readonly text: Schema.String;
+        }>]>>>;
+    }>>>>;
+}>, Schema.Struct<{
+    readonly kind: Schema.mutableKey<Schema.Literal<"multiple-choice">>;
+    readonly options: Schema.mutableKey<Schema.mutable<Schema.$Array<Schema.Struct<{
+        readonly isCorrect: Schema.mutableKey<Schema.Boolean>;
+        readonly label: Schema.mutableKey<Schema.NonEmptyArray<Schema.Union<readonly [Schema.Struct<{
+            readonly display: Schema.Literals<readonly ["block", "inline"]>;
+            readonly kind: Schema.Literal<"math">;
+            readonly math: Schema.String;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"text">;
+            readonly text: Schema.String;
+        }>]>>>;
+    }>>>>;
+}>, Schema.Struct<{
+    readonly kind: Schema.mutableKey<Schema.Literal<"single-choice">>;
+    readonly options: Schema.mutableKey<Schema.mutable<Schema.$Array<Schema.Struct<{
+        readonly isCorrect: Schema.mutableKey<Schema.Boolean>;
+        readonly label: Schema.mutableKey<Schema.NonEmptyArray<Schema.Union<readonly [Schema.Struct<{
+            readonly display: Schema.Literals<readonly ["block", "inline"]>;
+            readonly kind: Schema.Literal<"math">;
+            readonly math: Schema.String;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"text">;
+            readonly text: Schema.String;
+        }>]>>>;
+    }>>>>;
+}>]>;
+export type QuestionResponseSource = typeof QuestionResponseSourceSchema.Type;
+/** Editorial blueprint coordinates used to prove assessment coverage. */
+export declare const QuestionBlueprintSchema: Schema.Struct<{
+    readonly cognitiveLevel: Schema.String;
+    readonly contentDomain: Schema.String;
+    readonly topic: Schema.String;
+}>;
+export type QuestionBlueprint = typeof QuestionBlueprintSchema.Type;
+/** Complete source-owned item, including optional shared-stimulus identity. */
+export declare const QuestionItemSchema: Schema.Struct<{
+    readonly blueprint: Schema.optionalKey<Schema.Struct<{
+        readonly cognitiveLevel: Schema.String;
+        readonly contentDomain: Schema.String;
+        readonly topic: Schema.String;
+    }>>;
+    readonly responses: Schema.$Record<Schema.Literals<readonly ["en", "id", "de"]>, Schema.optional<Schema.Union<readonly [Schema.Struct<{
+        readonly categories: Schema.mutableKey<Schema.mutable<Schema.$Array<Schema.NonEmptyArray<Schema.Union<readonly [Schema.Struct<{
+            readonly display: Schema.Literals<readonly ["block", "inline"]>;
+            readonly kind: Schema.Literal<"math">;
+            readonly math: Schema.String;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"text">;
+            readonly text: Schema.String;
+        }>]>>>>>;
+        readonly kind: Schema.mutableKey<Schema.Literal<"category">>;
+        readonly statements: Schema.mutableKey<Schema.mutable<Schema.$Array<Schema.Struct<{
+            readonly correctCategoryOrder: Schema.mutableKey<Schema.Int>;
+            readonly label: Schema.mutableKey<Schema.NonEmptyArray<Schema.Union<readonly [Schema.Struct<{
+                readonly display: Schema.Literals<readonly ["block", "inline"]>;
+                readonly kind: Schema.Literal<"math">;
+                readonly math: Schema.String;
+            }>, Schema.Struct<{
+                readonly kind: Schema.Literal<"text">;
+                readonly text: Schema.String;
+            }>]>>>;
+        }>>>>;
+    }>, Schema.Struct<{
+        readonly kind: Schema.mutableKey<Schema.Literal<"multiple-choice">>;
+        readonly options: Schema.mutableKey<Schema.mutable<Schema.$Array<Schema.Struct<{
+            readonly isCorrect: Schema.mutableKey<Schema.Boolean>;
+            readonly label: Schema.mutableKey<Schema.NonEmptyArray<Schema.Union<readonly [Schema.Struct<{
+                readonly display: Schema.Literals<readonly ["block", "inline"]>;
+                readonly kind: Schema.Literal<"math">;
+                readonly math: Schema.String;
+            }>, Schema.Struct<{
+                readonly kind: Schema.Literal<"text">;
+                readonly text: Schema.String;
+            }>]>>>;
+        }>>>>;
+    }>, Schema.Struct<{
+        readonly kind: Schema.mutableKey<Schema.Literal<"single-choice">>;
+        readonly options: Schema.mutableKey<Schema.mutable<Schema.$Array<Schema.Struct<{
+            readonly isCorrect: Schema.mutableKey<Schema.Boolean>;
+            readonly label: Schema.mutableKey<Schema.NonEmptyArray<Schema.Union<readonly [Schema.Struct<{
+                readonly display: Schema.Literals<readonly ["block", "inline"]>;
+                readonly kind: Schema.Literal<"math">;
+                readonly math: Schema.String;
+            }>, Schema.Struct<{
+                readonly kind: Schema.Literal<"text">;
+                readonly text: Schema.String;
+            }>]>>>;
+        }>>>>;
+    }>]>>>;
+    readonly stimulusKey: Schema.optionalKey<Schema.String>;
+}>;
+export type QuestionItem = typeof QuestionItemSchema.Type;
+/** Returns blueprint facts in stable field order for signed canonicalizers. */
+export declare function canonicalQuestionBlueprint(blueprint: QuestionBlueprint): {
+    cognitiveLevel: string;
+    contentDomain: string;
+    topic: string;
+};
+declare const QuestionResponseLocaleMissingError_base: Schema.Class<QuestionResponseLocaleMissingError, Schema.TaggedStruct<"QuestionResponseLocaleMissingError", {
+    readonly artifactLocale: Schema.brand<Schema.Literals<readonly ["en", "id", "de"]>, "@NakafaAI/AksaraArtifactLocale">;
+}>, import("effect/Cause").YieldableError>;
+/** One item does not contain the exact artifact locale it must assess. */
+export declare class QuestionResponseLocaleMissingError extends QuestionResponseLocaleMissingError_base {
+}
+/** Resolves and freezes one exact-locale response from an authored item. */
+export declare const questionResponseFor: (item: {
+    readonly blueprint?: {
+        readonly cognitiveLevel: string;
+        readonly contentDomain: string;
+        readonly topic: string;
+    };
+    readonly responses: {
+        readonly de?: {
+            categories: (readonly [{
+                readonly display: "block" | "inline";
+                readonly kind: "math";
+                readonly math: string;
+            } | {
+                readonly kind: "text";
+                readonly text: string;
+            }, ...({
+                readonly display: "block" | "inline";
+                readonly kind: "math";
+                readonly math: string;
+            } | {
+                readonly kind: "text";
+                readonly text: string;
+            })[]])[];
+            kind: "category";
+            statements: {
+                correctCategoryOrder: number;
+                label: readonly [{
+                    readonly display: "block" | "inline";
+                    readonly kind: "math";
+                    readonly math: string;
+                } | {
+                    readonly kind: "text";
+                    readonly text: string;
+                }, ...({
+                    readonly display: "block" | "inline";
+                    readonly kind: "math";
+                    readonly math: string;
+                } | {
+                    readonly kind: "text";
+                    readonly text: string;
+                })[]];
+            }[];
+        } | {
+            kind: "multiple-choice";
+            options: {
+                isCorrect: boolean;
+                label: readonly [{
+                    readonly display: "block" | "inline";
+                    readonly kind: "math";
+                    readonly math: string;
+                } | {
+                    readonly kind: "text";
+                    readonly text: string;
+                }, ...({
+                    readonly display: "block" | "inline";
+                    readonly kind: "math";
+                    readonly math: string;
+                } | {
+                    readonly kind: "text";
+                    readonly text: string;
+                })[]];
+            }[];
+        } | {
+            kind: "single-choice";
+            options: {
+                isCorrect: boolean;
+                label: readonly [{
+                    readonly display: "block" | "inline";
+                    readonly kind: "math";
+                    readonly math: string;
+                } | {
+                    readonly kind: "text";
+                    readonly text: string;
+                }, ...({
+                    readonly display: "block" | "inline";
+                    readonly kind: "math";
+                    readonly math: string;
+                } | {
+                    readonly kind: "text";
+                    readonly text: string;
+                })[]];
+            }[];
+        } | undefined;
+        readonly en?: {
+            categories: (readonly [{
+                readonly display: "block" | "inline";
+                readonly kind: "math";
+                readonly math: string;
+            } | {
+                readonly kind: "text";
+                readonly text: string;
+            }, ...({
+                readonly display: "block" | "inline";
+                readonly kind: "math";
+                readonly math: string;
+            } | {
+                readonly kind: "text";
+                readonly text: string;
+            })[]])[];
+            kind: "category";
+            statements: {
+                correctCategoryOrder: number;
+                label: readonly [{
+                    readonly display: "block" | "inline";
+                    readonly kind: "math";
+                    readonly math: string;
+                } | {
+                    readonly kind: "text";
+                    readonly text: string;
+                }, ...({
+                    readonly display: "block" | "inline";
+                    readonly kind: "math";
+                    readonly math: string;
+                } | {
+                    readonly kind: "text";
+                    readonly text: string;
+                })[]];
+            }[];
+        } | {
+            kind: "multiple-choice";
+            options: {
+                isCorrect: boolean;
+                label: readonly [{
+                    readonly display: "block" | "inline";
+                    readonly kind: "math";
+                    readonly math: string;
+                } | {
+                    readonly kind: "text";
+                    readonly text: string;
+                }, ...({
+                    readonly display: "block" | "inline";
+                    readonly kind: "math";
+                    readonly math: string;
+                } | {
+                    readonly kind: "text";
+                    readonly text: string;
+                })[]];
+            }[];
+        } | {
+            kind: "single-choice";
+            options: {
+                isCorrect: boolean;
+                label: readonly [{
+                    readonly display: "block" | "inline";
+                    readonly kind: "math";
+                    readonly math: string;
+                } | {
+                    readonly kind: "text";
+                    readonly text: string;
+                }, ...({
+                    readonly display: "block" | "inline";
+                    readonly kind: "math";
+                    readonly math: string;
+                } | {
+                    readonly kind: "text";
+                    readonly text: string;
+                })[]];
+            }[];
+        } | undefined;
+        readonly id?: {
+            categories: (readonly [{
+                readonly display: "block" | "inline";
+                readonly kind: "math";
+                readonly math: string;
+            } | {
+                readonly kind: "text";
+                readonly text: string;
+            }, ...({
+                readonly display: "block" | "inline";
+                readonly kind: "math";
+                readonly math: string;
+            } | {
+                readonly kind: "text";
+                readonly text: string;
+            })[]])[];
+            kind: "category";
+            statements: {
+                correctCategoryOrder: number;
+                label: readonly [{
+                    readonly display: "block" | "inline";
+                    readonly kind: "math";
+                    readonly math: string;
+                } | {
+                    readonly kind: "text";
+                    readonly text: string;
+                }, ...({
+                    readonly display: "block" | "inline";
+                    readonly kind: "math";
+                    readonly math: string;
+                } | {
+                    readonly kind: "text";
+                    readonly text: string;
+                })[]];
+            }[];
+        } | {
+            kind: "multiple-choice";
+            options: {
+                isCorrect: boolean;
+                label: readonly [{
+                    readonly display: "block" | "inline";
+                    readonly kind: "math";
+                    readonly math: string;
+                } | {
+                    readonly kind: "text";
+                    readonly text: string;
+                }, ...({
+                    readonly display: "block" | "inline";
+                    readonly kind: "math";
+                    readonly math: string;
+                } | {
+                    readonly kind: "text";
+                    readonly text: string;
+                })[]];
+            }[];
+        } | {
+            kind: "single-choice";
+            options: {
+                isCorrect: boolean;
+                label: readonly [{
+                    readonly display: "block" | "inline";
+                    readonly kind: "math";
+                    readonly math: string;
+                } | {
+                    readonly kind: "text";
+                    readonly text: string;
+                }, ...({
+                    readonly display: "block" | "inline";
+                    readonly kind: "math";
+                    readonly math: string;
+                } | {
+                    readonly kind: "text";
+                    readonly text: string;
+                })[]];
+            }[];
+        } | undefined;
+    };
+    readonly stimulusKey?: string;
+}, artifactLocale: ("de" | "en" | "id") & import("effect/Brand").Brand<"@NakafaAI/AksaraArtifactLocale">) => Effect.Effect<{
+    readonly categories: readonly {
+        readonly categoryKey: string;
+        readonly label: readonly [{
+            readonly display: "block" | "inline";
+            readonly kind: "math";
+            readonly math: string;
+        } | {
+            readonly kind: "text";
+            readonly text: string;
+        }, ...({
+            readonly display: "block" | "inline";
+            readonly kind: "math";
+            readonly math: string;
+        } | {
+            readonly kind: "text";
+            readonly text: string;
+        })[]];
+        readonly order: number;
+    }[];
+    readonly kind: "category";
+    readonly statements: readonly {
+        readonly correctCategoryKey: string;
+        readonly label: readonly [{
+            readonly display: "block" | "inline";
+            readonly kind: "math";
+            readonly math: string;
+        } | {
+            readonly kind: "text";
+            readonly text: string;
+        }, ...({
+            readonly display: "block" | "inline";
+            readonly kind: "math";
+            readonly math: string;
+        } | {
+            readonly kind: "text";
+            readonly text: string;
+        })[]];
+        readonly order: number;
+        readonly statementKey: string;
+    }[];
+} | {
+    readonly kind: "multiple-choice";
+    readonly options: readonly {
+        readonly isCorrect: boolean;
+        readonly label: readonly [{
+            readonly display: "block" | "inline";
+            readonly kind: "math";
+            readonly math: string;
+        } | {
+            readonly kind: "text";
+            readonly text: string;
+        }, ...({
+            readonly display: "block" | "inline";
+            readonly kind: "math";
+            readonly math: string;
+        } | {
+            readonly kind: "text";
+            readonly text: string;
+        })[]];
+        readonly optionKey: string;
+        readonly order: number;
+    }[];
+} | {
+    readonly kind: "single-choice";
+    readonly options: readonly {
+        readonly isCorrect: boolean;
+        readonly label: readonly [{
+            readonly display: "block" | "inline";
+            readonly kind: "math";
+            readonly math: string;
+        } | {
+            readonly kind: "text";
+            readonly text: string;
+        }, ...({
+            readonly display: "block" | "inline";
+            readonly kind: "math";
+            readonly math: string;
+        } | {
+            readonly kind: "text";
+            readonly text: string;
+        })[]];
+        readonly optionKey: string;
+        readonly order: number;
+    }[];
+}, QuestionResponseLocaleMissingError, never>;
+export {};