@intellectif/lk-core 0.4.0 → 0.5.0

package/dist/index-BKyZrd94.d.cts

@@ -0,0 +1,732 @@
+import { A as ActivityData, c as ActivityMedia, t as ValidationResult, e as ActivityType, a as ActivityDataMap } from './activity-wkzRemHx.cjs';
+import { z } from 'zod/v4';
+
+/** What a stimulus primarily is. Drives validation and layout, never scoring. */
+type StimulusKind = 'text' | 'audio' | 'video' | 'image' | 'mixed';
+/**
+ * Shared material that several items refer to: a reading passage, a
+ * recording, a chart. Modelled as CONTENT — it lives inside the item group
+ * that carries it — so it works in a lesson quiz, a sequence and an exam
+ * section alike, and needs no blueprint to exist.
+ *
+ * Learner-visible by definition: the point of a stimulus is that the learner
+ * reads or hears it. The one exception is `transcript`, an author asset that
+ * `redactItemGroup` removes.
+ */
+interface Stimulus {
+    id: string;
+    kind: StimulusKind;
+    /** Optional heading (a passage title). */
+    title?: string;
+    /**
+     * Plain-text body: the passage itself, or short instructions above media.
+     * Required for `text` and `mixed`.
+     */
+    body?: string;
+    /**
+     * Optional sanitised rich-HTML sidecar of `body`. Requires `body`, which is
+     * the accessible fallback rendered when no sanitiser is supplied.
+     */
+    bodyHtml?: string;
+    /** The recording, video or image. Required for `audio`, `video`, `image` and `mixed`. */
+    media?: ActivityMedia;
+    /**
+     * Author-only transcript of `media` — for item generation and grading,
+     * never shown to the learner. Removed by `redactItemGroup`.
+     */
+    transcript?: string;
+    /** BCP 47 language tag of the material, when it differs from the items'. */
+    locale?: string;
+    /** Source credit, shown to the learner after the material. */
+    attribution?: string;
+}
+/**
+ * One stimulus serving several items. Two rules, both taken from observed
+ * failures: a group is SHUFFLE-ATOMIC (shuffling a sequence moves the group
+ * as one block — interleaving two passages' questions is the defect), and its
+ * stimulus is presented persistently alongside every item, never behind a
+ * toggle the learner must reopen per question.
+ *
+ * Generic over the item type so one shape describes a group of full activity
+ * data (authoring, server) and a group of `redact()` projections (client)
+ * without a cast at every boundary.
+ */
+interface ItemGroup<TItem = ActivityData> {
+    schemaVersion: '1.0';
+    type: 'item-group';
+    id: string;
+    title?: string;
+    stimulus: Stimulus;
+    /** The items, in authored order. Non-empty; ids unique within the group; no nested groups. */
+    items: TItem[];
+    /**
+     * `none` (default) keeps authored order; `within-group` shuffles the items
+     * among themselves under the sequence seed. Either way the group stays one
+     * contiguous block.
+     */
+    shuffle?: 'none' | 'within-group';
+}
+/** What a sequence is made of: loose activities and item groups, in authored order. */
+type SequenceEntry<TItem = ActivityData> = TItem | ItemGroup<TItem>;
+/** The group a presented slot belongs to. */
+interface SequenceSlotGroup {
+    id: string;
+    title?: string;
+    stimulus: Stimulus;
+    /** 0-based position of this slot within the group's PRESENTED order. */
+    position: number;
+    /** Number of slots in the group. */
+    size: number;
+}
+/** One presented position in a flattened sequence. */
+interface SequenceSlot<TItem = ActivityData> {
+    /**
+     * Identity of the slot within the sequence definition — unique, and stable
+     * under shuffling. Derived from the AUTHORED position (`"2"` for the third
+     * top-level entry; `"2.1"` for the second item of that entry when it is a
+     * group), so the same activity can appear in two entries and still be two
+     * slots. Feed it to `composeAssessmentScore` as `slotId`.
+     */
+    slotId: string;
+    /** 0-based PRESENTED position, after shuffling. */
+    index: number;
+    activity: TItem;
+    /** Present when the slot comes from an item group. */
+    group?: SequenceSlotGroup;
+}
+
+/**
+ * Optional authored "overall feedback" shown after submission, selected by
+ * whether the learner passed (h5p-style overall feedback). Both fields are
+ * optional; non-empty when present.
+ */
+declare const FeedbackSchema: z.ZodObject<{
+    correct: z.ZodOptional<z.ZodString>;
+    incorrect: z.ZodOptional<z.ZodString>;
+}, z.core.$loose>;
+
+/**
+ * Zod schema for a `TextMatchPolicy` — the opt-in matching tolerances a blank
+ * may declare. Every default reproduces the v1 trim + case-fold semantics.
+ */
+declare const TextMatchPolicySchema: z.ZodObject<{
+    caseSensitive: z.ZodOptional<z.ZodBoolean>;
+    trim: z.ZodOptional<z.ZodBoolean>;
+    normalize: z.ZodOptional<z.ZodEnum<{
+        none: "none";
+        NFC: "NFC";
+        NFKC: "NFKC";
+    }>>;
+    foldDiacritics: z.ZodOptional<z.ZodBoolean>;
+    collapseInnerWhitespace: z.ZodOptional<z.ZodBoolean>;
+    ignorePunctuation: z.ZodOptional<z.ZodBoolean>;
+    levenshtein: z.ZodOptional<z.ZodNumber>;
+    locale: z.ZodOptional<z.ZodString>;
+}, z.core.$loose>;
+/**
+ * Zod schema for a single fill-in-the-blank slot configuration. Loose:
+ * unknown keys are preserved through validation. Accepted answers must
+ * contain non-whitespace characters — a whitespace-only accepted answer
+ * normalizes to the empty string and would mark an empty response correct.
+ */
+declare const BlankConfigSchema: z.ZodObject<{
+    id: z.ZodString;
+    acceptedAnswers: z.ZodArray<z.ZodString>;
+    caseSensitive: z.ZodOptional<z.ZodBoolean>;
+    trimWhitespace: z.ZodOptional<z.ZodBoolean>;
+    match: z.ZodOptional<z.ZodObject<{
+        caseSensitive: z.ZodOptional<z.ZodBoolean>;
+        trim: z.ZodOptional<z.ZodBoolean>;
+        normalize: z.ZodOptional<z.ZodEnum<{
+            none: "none";
+            NFC: "NFC";
+            NFKC: "NFKC";
+        }>>;
+        foldDiacritics: z.ZodOptional<z.ZodBoolean>;
+        collapseInnerWhitespace: z.ZodOptional<z.ZodBoolean>;
+        ignorePunctuation: z.ZodOptional<z.ZodBoolean>;
+        levenshtein: z.ZodOptional<z.ZodNumber>;
+        locale: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>>;
+    hint: z.ZodOptional<z.ZodString>;
+    feedback: z.ZodOptional<z.ZodString>;
+}, z.core.$loose>;
+/**
+ * Zod schema validating the full Fill-in-the-Blanks activity data contract.
+ * Loose at every level: unknown keys are preserved, never stripped (B7).
+ *
+ * The refinement enforces a true one-to-one correspondence between `{{id}}`
+ * placeholders and `blanks[].id`: every blank id appears EXACTLY ONCE in the
+ * passage and exactly once in `blanks[]`. (The previous set-based check let
+ * duplicate placeholders and duplicate blank configs through, corrupting the
+ * partial-score denominator and per-item details.)
+ */
+declare const FillInTheBlanksDataSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"1.0">;
+    type: z.ZodLiteral<"fill-in-the-blanks">;
+    id: z.ZodString;
+    title: z.ZodString;
+    passage: z.ZodString;
+    passageHtml: z.ZodOptional<z.ZodString>;
+    blanks: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        acceptedAnswers: z.ZodArray<z.ZodString>;
+        caseSensitive: z.ZodOptional<z.ZodBoolean>;
+        trimWhitespace: z.ZodOptional<z.ZodBoolean>;
+        match: z.ZodOptional<z.ZodObject<{
+            caseSensitive: z.ZodOptional<z.ZodBoolean>;
+            trim: z.ZodOptional<z.ZodBoolean>;
+            normalize: z.ZodOptional<z.ZodEnum<{
+                none: "none";
+                NFC: "NFC";
+                NFKC: "NFKC";
+            }>>;
+            foldDiacritics: z.ZodOptional<z.ZodBoolean>;
+            collapseInnerWhitespace: z.ZodOptional<z.ZodBoolean>;
+            ignorePunctuation: z.ZodOptional<z.ZodBoolean>;
+            levenshtein: z.ZodOptional<z.ZodNumber>;
+            locale: z.ZodOptional<z.ZodString>;
+        }, z.core.$loose>>;
+        hint: z.ZodOptional<z.ZodString>;
+        feedback: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>>;
+    scoringStrategy: z.ZodEnum<{
+        "all-or-nothing": "all-or-nothing";
+        partial: "partial";
+    }>;
+    media: z.ZodOptional<z.ZodObject<{
+        type: z.ZodEnum<{
+            image: "image";
+            audio: "audio";
+            video: "video";
+            embed: "embed";
+        }>;
+        url: z.ZodUnion<readonly [z.ZodURL, z.ZodString]>;
+        alt: z.ZodOptional<z.ZodString>;
+        captionsUrl: z.ZodOptional<z.ZodUnion<readonly [z.ZodURL, z.ZodString]>>;
+    }, z.core.$loose>>;
+    feedback: z.ZodOptional<z.ZodObject<{
+        correct: z.ZodOptional<z.ZodString>;
+        incorrect: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>>;
+    passThreshold: z.ZodOptional<z.ZodNumber>;
+    locale: z.ZodOptional<z.ZodString>;
+    learningObjectives: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    difficultyLevel: z.ZodOptional<z.ZodLiteral<1 | 2 | 3 | 4 | 5>>;
+}, z.core.$loose>;
+
+/**
+ * Zod schema for a {@link Stimulus}. Loose: unknown keys preserved.
+ *
+ * The semantic guards exist because a stimulus that does not carry what its
+ * `kind` promises is an authoring error that must not reach an exam: an
+ * "audio" stimulus with no recording renders as a blank panel above six
+ * listening questions. Unrepresentable in JSON Schema; dropped from
+ * `stimulusJsonSchema` by design.
+ */
+declare const StimulusSchema: z.ZodObject<{
+    id: z.ZodString;
+    kind: z.ZodEnum<{
+        image: "image";
+        audio: "audio";
+        video: "video";
+        text: "text";
+        mixed: "mixed";
+    }>;
+    title: z.ZodOptional<z.ZodString>;
+    body: z.ZodOptional<z.ZodString>;
+    bodyHtml: z.ZodOptional<z.ZodString>;
+    media: z.ZodOptional<z.ZodObject<{
+        type: z.ZodEnum<{
+            image: "image";
+            audio: "audio";
+            video: "video";
+            embed: "embed";
+        }>;
+        url: z.ZodUnion<readonly [z.ZodURL, z.ZodString]>;
+        alt: z.ZodOptional<z.ZodString>;
+        captionsUrl: z.ZodOptional<z.ZodUnion<readonly [z.ZodURL, z.ZodString]>>;
+    }, z.core.$loose>>;
+    transcript: z.ZodOptional<z.ZodString>;
+    locale: z.ZodOptional<z.ZodString>;
+    attribution: z.ZodOptional<z.ZodString>;
+}, z.core.$loose>;
+/**
+ * Zod schema for an {@link ItemGroup} CONTAINER. Loose: unknown keys
+ * preserved. Validates the group's own fields and the stimulus in full, and
+ * each item only structurally (`type` and `id`); use {@link validateItemGroup}
+ * to validate the items against their registered schemas as well.
+ */
+declare const ItemGroupSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"1.0">;
+    type: z.ZodLiteral<"item-group">;
+    id: z.ZodString;
+    title: z.ZodOptional<z.ZodString>;
+    stimulus: z.ZodObject<{
+        id: z.ZodString;
+        kind: z.ZodEnum<{
+            image: "image";
+            audio: "audio";
+            video: "video";
+            text: "text";
+            mixed: "mixed";
+        }>;
+        title: z.ZodOptional<z.ZodString>;
+        body: z.ZodOptional<z.ZodString>;
+        bodyHtml: z.ZodOptional<z.ZodString>;
+        media: z.ZodOptional<z.ZodObject<{
+            type: z.ZodEnum<{
+                image: "image";
+                audio: "audio";
+                video: "video";
+                embed: "embed";
+            }>;
+            url: z.ZodUnion<readonly [z.ZodURL, z.ZodString]>;
+            alt: z.ZodOptional<z.ZodString>;
+            captionsUrl: z.ZodOptional<z.ZodUnion<readonly [z.ZodURL, z.ZodString]>>;
+        }, z.core.$loose>>;
+        transcript: z.ZodOptional<z.ZodString>;
+        locale: z.ZodOptional<z.ZodString>;
+        attribution: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>;
+    items: z.ZodArray<z.ZodObject<{
+        type: z.ZodString;
+        id: z.ZodString;
+    }, z.core.$loose>>;
+    shuffle: z.ZodOptional<z.ZodEnum<{
+        none: "none";
+        "within-group": "within-group";
+    }>>;
+}, z.core.$loose>;
+/** Strict learner-safe stimulus: everything but the author-only `transcript`. */
+declare const RedactedStimulusSchema: z.ZodObject<{
+    id: z.ZodString;
+    kind: z.ZodEnum<{
+        image: "image";
+        audio: "audio";
+        video: "video";
+        text: "text";
+        mixed: "mixed";
+    }>;
+    title: z.ZodOptional<z.ZodString>;
+    body: z.ZodOptional<z.ZodString>;
+    bodyHtml: z.ZodOptional<z.ZodString>;
+    media: z.ZodOptional<z.ZodObject<{
+        type: z.ZodEnum<{
+            image: "image";
+            audio: "audio";
+            video: "video";
+            embed: "embed";
+        }>;
+        url: z.ZodUnion<readonly [z.ZodURL, z.ZodString]>;
+        alt: z.ZodOptional<z.ZodString>;
+        captionsUrl: z.ZodOptional<z.ZodUnion<readonly [z.ZodURL, z.ZodString]>>;
+    }, z.core.$loose>>;
+    locale: z.ZodOptional<z.ZodString>;
+    attribution: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+/**
+ * Strict learner-safe item group. Items are left opaque here — each is proven
+ * learner-safe by `assertRedacted` against its OWN type's redacted schema,
+ * which is the only place that knowledge lives.
+ */
+declare const RedactedItemGroupSchema: z.ZodObject<{
+    redacted: z.ZodLiteral<true>;
+    schemaVersion: z.ZodLiteral<"1.0">;
+    type: z.ZodLiteral<"item-group">;
+    id: z.ZodString;
+    title: z.ZodOptional<z.ZodString>;
+    stimulus: z.ZodObject<{
+        id: z.ZodString;
+        kind: z.ZodEnum<{
+            image: "image";
+            audio: "audio";
+            video: "video";
+            text: "text";
+            mixed: "mixed";
+        }>;
+        title: z.ZodOptional<z.ZodString>;
+        body: z.ZodOptional<z.ZodString>;
+        bodyHtml: z.ZodOptional<z.ZodString>;
+        media: z.ZodOptional<z.ZodObject<{
+            type: z.ZodEnum<{
+                image: "image";
+                audio: "audio";
+                video: "video";
+                embed: "embed";
+            }>;
+            url: z.ZodUnion<readonly [z.ZodURL, z.ZodString]>;
+            alt: z.ZodOptional<z.ZodString>;
+            captionsUrl: z.ZodOptional<z.ZodUnion<readonly [z.ZodURL, z.ZodString]>>;
+        }, z.core.$loose>>;
+        locale: z.ZodOptional<z.ZodString>;
+        attribution: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+    items: z.ZodArray<z.ZodUnknown>;
+    shuffle: z.ZodOptional<z.ZodEnum<{
+        none: "none";
+        "within-group": "within-group";
+    }>>;
+}, z.core.$strict>;
+/**
+ * Validates an item group in full: the container and stimulus against
+ * {@link ItemGroupSchema}, then every item against the schema registered for
+ * its `type`. Errors from items are reported at `items.<index>.…`.
+ *
+ * Unlike `validateActivity`, an item whose type is not registered is REPORTED
+ * (code `unknown_activity_type`) rather than thrown: a group is validated as
+ * a whole, and an author fixing a six-item group wants every problem listed,
+ * not the first one that happened to throw.
+ */
+declare function validateItemGroup(data: unknown): ValidationResult<ItemGroup>;
+
+/**
+ * JSON Schema (Draft 7) for a `Stimulus`. Structural contract only — the
+ * kind/media/body consistency guards are Zod-only.
+ */
+declare const stimulusJsonSchema: z.core.JSONSchema.JSONSchema;
+/**
+ * JSON Schema (Draft 7) for an `ItemGroup` CONTAINER. Items appear as objects
+ * with `type` and `id` only; each item's own contract is `jsonSchemaFor(type)`.
+ * For an AI generation pipeline, ask for the group and each item separately
+ * rather than a single nested schema — that keeps the per-type schema the
+ * registry's, not a copy.
+ */
+declare const itemGroupJsonSchema: z.core.JSONSchema.JSONSchema;
+/**
+ * JSON Schema (Draft 7) representation of the Multiple Choice activity data
+ * contract, generated natively by Zod 4. Draft 7 is mandated by Requirement
+ * 2.2 for the widest AI-prompt / OpenAPI tooling compatibility. The semantic
+ * `.refine()` guards are not representable in JSON Schema and are
+ * intentionally omitted — the export captures the *structural* contract only.
+ * Since v0.3 the source schemas are loose, so these no longer emit
+ * `additionalProperties: false` — the JSON Schema and `validateActivity` now
+ * agree on unknown-key handling.
+ */
+declare const multipleChoiceJsonSchema: z.core.JSONSchema.JSONSchema;
+/**
+ * JSON Schema (Draft 7) representation of the Fill-in-the-Blanks activity data
+ * contract, generated natively by Zod 4. Structural contract only (semantic
+ * `.refine()` guards are Zod-only and not representable in JSON Schema).
+ */
+declare const fillInTheBlanksJsonSchema: z.core.JSONSchema.JSONSchema;
+/**
+ * JSON Schema (Draft 7) representation of the Written Response activity data
+ * contract. Structural contract only.
+ */
+declare const writtenResponseJsonSchema: z.core.JSONSchema.JSONSchema;
+/**
+ * Derives the JSON Schema (Draft 7) for any REGISTERED activity type — the
+ * live, registry-backed replacement for the static per-type exports above,
+ * and the building block for AI generation pipelines (R6.1): pass the result
+ * as a structured-output schema so a model can only emit valid items.
+ *
+ * @throws UnknownActivityTypeError when `type` has no registered descriptor.
+ */
+declare function jsonSchemaFor(type: string): Record<string, unknown>;
+
+/**
+ * Optional media attached to an activity, rendered above the question or
+ * passage — e.g. a recording to listen to, or an embedded video to watch
+ * before answering. URL-only by design: hosting/delivery (S3/CDN, or the
+ * provider's own embed for `embed`) is the consuming app's responsibility
+ * (see requirements "Non-Goals and Shared Responsibility").
+ *
+ * - `image`: rendered as `<img>` — `alt` is REQUIRED (WCAG 1.1.1 / Req 14.5).
+ * - `audio` / `video`: rendered with native controls; `alt` is an optional
+ *   accessible label; `captionsUrl` points at a WebVTT `<track>`. `url` must
+ *   be a direct media file (NOT a YouTube/Vimeo page — use `embed` for those).
+ * - `embed`: rendered as a sandboxed `<iframe>` for provider players
+ *   (YouTube/Vimeo/etc.). `url` MUST be the provider's *embeddable* URL
+ *   (e.g. `https://www.youtube.com/embed/<id>`). `alt` is REQUIRED and used
+ *   as the iframe's accessible `title` (WCAG 4.1.2 / 2.4.1).
+ */
+/**
+ * Media URL policy (security-reviewed): absolute URLs must use `https:`,
+ * `http:`, `data:`, or `blob:`; root-relative paths (`/media/x.mp3`) are
+ * allowed for same-origin hosting. Everything else — notably `javascript:`,
+ * `file:`, `ftp:` — is rejected: these URLs land in `src` attributes
+ * (including an iframe for `embed`), so an unvetted scheme is a stored-XSS
+ * vector in every consuming app.
+ */
+declare const MediaUrlSchema: z.ZodUnion<readonly [z.ZodURL, z.ZodString]>;
+declare const MediaSchema: z.ZodObject<{
+    type: z.ZodEnum<{
+        image: "image";
+        audio: "audio";
+        video: "video";
+        embed: "embed";
+    }>;
+    url: z.ZodUnion<readonly [z.ZodURL, z.ZodString]>;
+    alt: z.ZodOptional<z.ZodString>;
+    captionsUrl: z.ZodOptional<z.ZodUnion<readonly [z.ZodURL, z.ZodString]>>;
+}, z.core.$loose>;
+
+/**
+ * Zod schema for a single Multiple Choice option. Loose: unknown keys are
+ * preserved through validation (forward-compat / consumer sidecars — B7).
+ */
+declare const MultipleChoiceOptionSchema: z.ZodObject<{
+    id: z.ZodString;
+    text: z.ZodString;
+    isCorrect: z.ZodBoolean;
+    feedback: z.ZodOptional<z.ZodString>;
+}, z.core.$loose>;
+/**
+ * Zod schema validating the full Multiple Choice activity data contract.
+ * Loose at every level: unknown keys are preserved, never stripped, so a
+ * v0.3 runtime reading a future payload (or a consumer sidecar field) does
+ * not silently delete data.
+ *
+ * Semantic guards: (1) at least one option must be correct, otherwise the
+ * activity can never be answered correctly; (2) `mode: 'single'` must have
+ * exactly one correct option — multiple correct options under single-select
+ * make `showCorrectAnswers` and the xAPI correct-response ambiguous and mask
+ * authoring errors; (3) option ids must be unique — the scorer looks options
+ * up by id, so a duplicate id makes one option unscoreable. All are
+ * unrepresentable in JSON Schema and are dropped from `toJSONSchema` output
+ * by design.
+ */
+declare const MultipleChoiceDataSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"1.0">;
+    type: z.ZodLiteral<"multiple-choice">;
+    id: z.ZodString;
+    title: z.ZodString;
+    question: z.ZodString;
+    questionHtml: z.ZodOptional<z.ZodString>;
+    mode: z.ZodEnum<{
+        single: "single";
+        multi: "multi";
+    }>;
+    options: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        text: z.ZodString;
+        isCorrect: z.ZodBoolean;
+        feedback: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>>;
+    scoringStrategy: z.ZodEnum<{
+        "all-or-nothing": "all-or-nothing";
+        partial: "partial";
+    }>;
+    media: z.ZodOptional<z.ZodObject<{
+        type: z.ZodEnum<{
+            image: "image";
+            audio: "audio";
+            video: "video";
+            embed: "embed";
+        }>;
+        url: z.ZodUnion<readonly [z.ZodURL, z.ZodString]>;
+        alt: z.ZodOptional<z.ZodString>;
+        captionsUrl: z.ZodOptional<z.ZodUnion<readonly [z.ZodURL, z.ZodString]>>;
+    }, z.core.$loose>>;
+    feedback: z.ZodOptional<z.ZodObject<{
+        correct: z.ZodOptional<z.ZodString>;
+        incorrect: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>>;
+    passThreshold: z.ZodOptional<z.ZodNumber>;
+    shuffle: z.ZodOptional<z.ZodBoolean>;
+    locale: z.ZodOptional<z.ZodString>;
+    learningObjectives: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    difficultyLevel: z.ZodOptional<z.ZodLiteral<1 | 2 | 3 | 4 | 5>>;
+}, z.core.$loose>;
+
+/** A redacted Multiple Choice option: id and display text only — no `isCorrect`, no feedback. */
+declare const RedactedMultipleChoiceOptionSchema: z.ZodObject<{
+    id: z.ZodString;
+    text: z.ZodString;
+}, z.core.$strict>;
+/**
+ * Redacted Multiple Choice data: renderable (question, mode, options to pick
+ * from) with the answer key, per-option feedback, overall feedback, and the
+ * scoring strategy removed. `scoringStrategy` is answer-key by design: MC
+ * `partial` carries a wrong-selection penalty `all-or-nothing` does not, so
+ * knowing the strategy tells a learner whether guessing is free.
+ */
+declare const RedactedMultipleChoiceDataSchema: z.ZodObject<{
+    type: z.ZodLiteral<"multiple-choice">;
+    question: z.ZodString;
+    questionHtml: z.ZodOptional<z.ZodString>;
+    mode: z.ZodEnum<{
+        single: "single";
+        multi: "multi";
+    }>;
+    options: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        text: z.ZodString;
+    }, z.core.$strict>>;
+    shuffle: z.ZodOptional<z.ZodBoolean>;
+    /** Marker distinguishing a redacted projection from full activity data. */
+    redacted: z.ZodLiteral<true>;
+    schemaVersion: z.ZodLiteral<"1.0">;
+    id: z.ZodString;
+    title: z.ZodString;
+    media: z.ZodOptional<z.ZodObject<{
+        type: z.ZodEnum<{
+            image: "image";
+            audio: "audio";
+            video: "video";
+            embed: "embed";
+        }>;
+        url: z.ZodUnion<readonly [z.ZodURL, z.ZodString]>;
+        alt: z.ZodOptional<z.ZodString>;
+        captionsUrl: z.ZodOptional<z.ZodUnion<readonly [z.ZodURL, z.ZodString]>>;
+    }, z.core.$loose>>;
+    passThreshold: z.ZodOptional<z.ZodNumber>;
+    locale: z.ZodOptional<z.ZodString>;
+    learningObjectives: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    difficultyLevel: z.ZodOptional<z.ZodLiteral<1 | 2 | 3 | 4 | 5>>;
+}, z.core.$strict>;
+/** A redacted blank: id and hint only — no accepted answers, no matching rules, no feedback. */
+declare const RedactedBlankConfigSchema: z.ZodObject<{
+    id: z.ZodString;
+    hint: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+/** Redacted Fill-in-the-Blanks data: passage and blank slots, key removed. */
+declare const RedactedFillInTheBlanksDataSchema: z.ZodObject<{
+    type: z.ZodLiteral<"fill-in-the-blanks">;
+    passage: z.ZodString;
+    passageHtml: z.ZodOptional<z.ZodString>;
+    blanks: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        hint: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    /** Marker distinguishing a redacted projection from full activity data. */
+    redacted: z.ZodLiteral<true>;
+    schemaVersion: z.ZodLiteral<"1.0">;
+    id: z.ZodString;
+    title: z.ZodString;
+    media: z.ZodOptional<z.ZodObject<{
+        type: z.ZodEnum<{
+            image: "image";
+            audio: "audio";
+            video: "video";
+            embed: "embed";
+        }>;
+        url: z.ZodUnion<readonly [z.ZodURL, z.ZodString]>;
+        alt: z.ZodOptional<z.ZodString>;
+        captionsUrl: z.ZodOptional<z.ZodUnion<readonly [z.ZodURL, z.ZodString]>>;
+    }, z.core.$loose>>;
+    passThreshold: z.ZodOptional<z.ZodNumber>;
+    locale: z.ZodOptional<z.ZodString>;
+    learningObjectives: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    difficultyLevel: z.ZodOptional<z.ZodLiteral<1 | 2 | 3 | 4 | 5>>;
+}, z.core.$strict>;
+/**
+ * Redacted Written Response data: the prompt, word bounds and rubric are
+ * learner-visible (a rubric tells the learner what they are graded on);
+ * authored pass/fail feedback is removed until the grade exists.
+ */
+declare const RedactedWrittenResponseDataSchema: z.ZodObject<{
+    type: z.ZodLiteral<"written-response">;
+    prompt: z.ZodString;
+    promptHtml: z.ZodOptional<z.ZodString>;
+    minWords: z.ZodNumber;
+    maxWords: z.ZodNumber;
+    rubric: z.ZodOptional<z.ZodObject<{
+        label: z.ZodOptional<z.ZodString>;
+        criteria: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+            weight: z.ZodNumber;
+        }, z.core.$loose>>;
+    }, z.core.$loose>>;
+    languageTarget: z.ZodOptional<z.ZodString>;
+    /** Marker distinguishing a redacted projection from full activity data. */
+    redacted: z.ZodLiteral<true>;
+    schemaVersion: z.ZodLiteral<"1.0">;
+    id: z.ZodString;
+    title: z.ZodString;
+    media: z.ZodOptional<z.ZodObject<{
+        type: z.ZodEnum<{
+            image: "image";
+            audio: "audio";
+            video: "video";
+            embed: "embed";
+        }>;
+        url: z.ZodUnion<readonly [z.ZodURL, z.ZodString]>;
+        alt: z.ZodOptional<z.ZodString>;
+        captionsUrl: z.ZodOptional<z.ZodUnion<readonly [z.ZodURL, z.ZodString]>>;
+    }, z.core.$loose>>;
+    passThreshold: z.ZodOptional<z.ZodNumber>;
+    locale: z.ZodOptional<z.ZodString>;
+    learningObjectives: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    difficultyLevel: z.ZodOptional<z.ZodLiteral<1 | 2 | 3 | 4 | 5>>;
+}, z.core.$strict>;
+
+/** Zod schema for a single rubric criterion. Loose: unknown keys preserved. */
+declare const WrittenResponseRubricCriterionSchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    weight: z.ZodNumber;
+}, z.core.$loose>;
+/** Zod schema for a written-response grading rubric. Loose: unknown keys preserved. */
+declare const WrittenResponseRubricSchema: z.ZodObject<{
+    label: z.ZodOptional<z.ZodString>;
+    criteria: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        weight: z.ZodNumber;
+    }, z.core.$loose>>;
+}, z.core.$loose>;
+/**
+ * Zod schema validating the Written Response activity data contract (Req 22).
+ *
+ * Wire-format constraints (Req 22.9): field names are locked for
+ * byte-compatibility with consumer-stored rows, and the schema is loose at
+ * EVERY level (Req 22.5) — unknown top-level keys, `promptHtml`, `rubric`
+ * sidecars and any future fields survive `validateActivity` verbatim.
+ */
+declare const WrittenResponseDataSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"1.0">;
+    type: z.ZodLiteral<"written-response">;
+    id: z.ZodString;
+    title: z.ZodString;
+    prompt: z.ZodString;
+    promptHtml: z.ZodOptional<z.ZodString>;
+    minWords: z.ZodNumber;
+    maxWords: z.ZodNumber;
+    rubric: z.ZodOptional<z.ZodObject<{
+        label: z.ZodOptional<z.ZodString>;
+        criteria: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+            weight: z.ZodNumber;
+        }, z.core.$loose>>;
+    }, z.core.$loose>>;
+    languageTarget: z.ZodOptional<z.ZodString>;
+    media: z.ZodOptional<z.ZodObject<{
+        type: z.ZodEnum<{
+            image: "image";
+            audio: "audio";
+            video: "video";
+            embed: "embed";
+        }>;
+        url: z.ZodUnion<readonly [z.ZodURL, z.ZodString]>;
+        alt: z.ZodOptional<z.ZodString>;
+        captionsUrl: z.ZodOptional<z.ZodUnion<readonly [z.ZodURL, z.ZodString]>>;
+    }, z.core.$loose>>;
+    feedback: z.ZodOptional<z.ZodObject<{
+        correct: z.ZodOptional<z.ZodString>;
+        incorrect: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>>;
+    passThreshold: z.ZodOptional<z.ZodNumber>;
+    locale: z.ZodOptional<z.ZodString>;
+    learningObjectives: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    difficultyLevel: z.ZodOptional<z.ZodLiteral<1 | 2 | 3 | 4 | 5>>;
+}, z.core.$loose>;
+
+/**
+ * Validates raw activity data against the schema registered for the given
+ * activity type (built-in or consumer-registered via `registerActivityType`).
+ *
+ * Unknown keys are PRESERVED, not stripped: every built-in schema is loose,
+ * so consumer sidecar fields and forward-version fields survive validation
+ * verbatim in the returned `data`.
+ *
+ * @returns `{ success: true, data }` with the typed, validated data, or
+ *          `{ success: false, errors }` with one entry per failed constraint.
+ * @throws UnknownActivityTypeError when `type` has no registered descriptor.
+ */
+declare function validateActivity<T extends ActivityType>(type: T, data: unknown): ValidationResult<ActivityDataMap[T]>;
+
+export { BlankConfigSchema as B, FeedbackSchema as F, type ItemGroup as I, MediaSchema as M, RedactedBlankConfigSchema as R, type SequenceEntry as S, TextMatchPolicySchema as T, WrittenResponseDataSchema as W, FillInTheBlanksDataSchema as a, ItemGroupSchema as b, MediaUrlSchema as c, MultipleChoiceDataSchema as d, MultipleChoiceOptionSchema as e, RedactedFillInTheBlanksDataSchema as f, RedactedItemGroupSchema as g, RedactedMultipleChoiceDataSchema as h, RedactedMultipleChoiceOptionSchema as i, RedactedStimulusSchema as j, RedactedWrittenResponseDataSchema as k, type SequenceSlot as l, type SequenceSlotGroup as m, type Stimulus as n, type StimulusKind as o, StimulusSchema as p, WrittenResponseRubricCriterionSchema as q, WrittenResponseRubricSchema as r, fillInTheBlanksJsonSchema as s, itemGroupJsonSchema as t, jsonSchemaFor as u, multipleChoiceJsonSchema as v, stimulusJsonSchema as w, validateActivity as x, validateItemGroup as y, writtenResponseJsonSchema as z };