@examplary/schemas 1.15.0 → 1.16.0

package/dist/common/scalar.js

@@ -1,7 +1,10 @@
-import { z } from "zod";
-export const ScalarSchema = z.union([
-    z.string(),
-    z.number(),
-    z.boolean(),
-    z.null(),
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ScalarSchema = void 0;
+const zod_1 = require("zod");
+exports.ScalarSchema = zod_1.z.union([
+    zod_1.z.string(),
+    zod_1.z.number(),
+    zod_1.z.boolean(),
+    zod_1.z.null(),
 ]);

package/dist/common/translatable.js

@@ -1,9 +1,12 @@
-import { z } from "zod";
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Translatable = void 0;
+const zod_1 = require("zod");
 // Translatable type - can be a simple string or translation object
-export const Translatable = z.union([
-    z.string().describe("Simple string value"),
-    z
-        .record(z.string().regex(/^[a-z]{2}(-[A-Z]{2})?$/, "Language code format"), z.string())
+exports.Translatable = zod_1.z.union([
+    zod_1.z.string().describe("Simple string value"),
+    zod_1.z
+        .record(zod_1.z.string().regex(/^[a-z]{2}(-[A-Z]{2})?$/, "Language code format"), zod_1.z.string())
         .refine((obj) => Object.keys(obj).length >= 1, "Translation object must have at least one property")
         .describe("Translation object with language codes as keys"),
 ]);

package/dist/index.js

@@ -1,7 +1,23 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
 // Question types
-export * from "./question-type";
+__exportStar(require("./question-type"), exports);
 // Questions
-export * from "./question";
+__exportStar(require("./question"), exports);
 // Common
-export * from "./common/scalar";
-export * from "./common/translatable";
+__exportStar(require("./common/scalar"), exports);
+__exportStar(require("./common/translatable"), exports);

package/dist/question/index.js

@@ -1,2 +1,18 @@
-export * from "./question";
-export * from "./question-scoring";
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./question"), exports);
+__exportStar(require("./question-scoring"), exports);

package/dist/question/question-scoring.js

@@ -1,62 +1,65 @@
-import { z } from "zod";
-export const ScoringCriterionSchema = z.object({
-    id: z.string(),
-    title: z
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QuestionScoringSchema = exports.RubricType = exports.TopLevelScoringCriterionSchema = exports.ScoringCriterionSchema = void 0;
+const zod_1 = require("zod");
+exports.ScoringCriterionSchema = zod_1.z.object({
+    id: zod_1.z.string(),
+    title: zod_1.z
         .string()
         .nullish()
         .describe("The title of the scoring criterion or level. Only applies to analytical levels and holistic criteria."),
-    description: z
+    description: zod_1.z
         .string()
         .nullish()
         .describe("The description of the scoring criterion or level. For analytical levels, this describes the specific requirements to earn the points for that level. For holistic criteria, this describes the overall requirement to earn the points for that criterion."),
-    points: z
+    points: zod_1.z
         .number()
         .nullish()
         .describe("The default amount of points to assign if this criterion or level is selected."),
-    minPoints: z
+    minPoints: zod_1.z
         .number()
         .nullish()
         .describe("The minimum amount of points that can be assigned if this criterion or level is selected."),
-    maxPoints: z
+    maxPoints: zod_1.z
         .number()
         .nullish()
         .describe("The maximum amount of points that can be assigned if this criterion or level is selected."),
 });
-export const TopLevelScoringCriterionSchema = ScoringCriterionSchema.extend({
-    levels: z
-        .array(ScoringCriterionSchema)
+exports.TopLevelScoringCriterionSchema = exports.ScoringCriterionSchema.extend({
+    levels: zod_1.z
+        .array(exports.ScoringCriterionSchema)
         .nullish()
         .describe("The levels of a analytical rubric criterion. Each level represents a different point value and description for the same criterion."),
 });
-export var RubricType;
+var RubricType;
 (function (RubricType) {
     RubricType["Simple"] = "simple";
     RubricType["Analytical"] = "analytical";
     RubricType["Holistic"] = "holistic";
     RubricType["ExactValues"] = "exact-values";
-})(RubricType || (RubricType = {}));
-export const QuestionScoringSchema = z.object({
-    rubricType: z
+})(RubricType || (exports.RubricType = RubricType = {}));
+exports.QuestionScoringSchema = zod_1.z.object({
+    rubricType: zod_1.z
         .enum(RubricType)
         .nullish()
         .describe("The type of rubric. Different rubric types have different shapes."),
-    criteria: z
-        .array(TopLevelScoringCriterionSchema)
+    criteria: zod_1.z
+        .array(exports.TopLevelScoringCriterionSchema)
         .nullish()
         .describe("The criteria for scoring the question. For 'simple' rubric type, criteria have no levels, and their points stack (total = sum of points for all criteria that apply). For 'analytical' rubric type, there should be at least one criteria, with levels. For each criteria, a matching level is picked. For 'holistic' rubric type, there should be multiple criteria, without levels (score = single selected criteria). For 'exact-values' rubric type, each criteria represents a specific value that must be matched exactly."),
-    exactValuesCaseInsensitive: z
+    exactValuesCaseInsensitive: zod_1.z
         .boolean()
         .nullish()
         .describe("Whether exact values matching should be case insensitive. Only applicable for 'exact-values' rubric type."),
-    guidance: z
+    guidance: zod_1.z
         .string()
         .nullish()
         .describe("Optional additional grading guidance text."),
-    modelAnswer: z
+    modelAnswer: zod_1.z
         .string()
         .nullish()
         .describe("Optional example model answer text to show to graders."),
-    templateId: z
+    templateId: zod_1.z
         .string()
         .nullish()
         .describe("The ID of the scoring template applied, if any."),

package/dist/question/question.js

@@ -1,43 +1,46 @@
-import { z } from "zod";
-import { QuestionScoringSchema } from "./question-scoring";
-import { ScalarSchema } from "../common/scalar";
-export const QuestionSchema = z.looseObject({
-    id: z.string().describe("Question ID"),
-    type: z.string().describe("ID of the question type"),
-    title: z.string().nullish().describe("Title for the question (stem)"),
-    description: z
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QuestionSchema = void 0;
+const zod_1 = require("zod");
+const question_scoring_1 = require("./question-scoring");
+const scalar_1 = require("../common/scalar");
+exports.QuestionSchema = zod_1.z.looseObject({
+    id: zod_1.z.string().describe("Question ID"),
+    type: zod_1.z.string().describe("ID of the question type"),
+    title: zod_1.z.string().nullish().describe("Title for the question (stem)"),
+    description: zod_1.z
         .string()
         .nullish()
         .describe("Optional description for the question"),
-    settings: z
+    settings: zod_1.z
         .looseObject({})
         .describe("Settings for the question, often specific to the question type"),
     // Scoring
-    scoring: QuestionScoringSchema.nullish().describe("Scoring configuration for the question"),
+    scoring: question_scoring_1.QuestionScoringSchema.nullish().describe("Scoring configuration for the question"),
     // Tags and metadata
-    tags: z
-        .array(z.string())
+    tags: zod_1.z
+        .array(zod_1.z.string())
         .nullish()
         .describe("Tags associated with the question for categorization and search"),
-    externalId: z
+    externalId: zod_1.z
         .string()
         .nullish()
         .describe("Optional external ID for the question, used to link to external systems"),
-    metadata: z
-        .record(z.string(), ScalarSchema)
+    metadata: zod_1.z
+        .record(zod_1.z.string(), scalar_1.ScalarSchema)
         .nullish()
         .describe("Metadata for the question"),
     // Internal tracking
-    v: z
+    v: zod_1.z
         .number()
         .nullish()
         .describe("Version number, incremented when question is edited"),
-    questionBankItemId: z
+    questionBankItemId: zod_1.z
         .string()
         .nullish()
         .describe("ID of the question in the question bank"),
-    traceIds: z
-        .array(z.string())
+    traceIds: zod_1.z
+        .array(zod_1.z.string())
         .nullish()
         .describe("Trace IDs for internal tracking of AI generation processes"),
 });

package/dist/question-type/index.d.ts

@@ -12,5 +12,7 @@ export * from "./question-type-scanning-options";
 export type * from "./question-type-scanning-options";
 export * from "./question-type-capabilities";
 export type * from "./question-type-capabilities";
+export * from "./question-type-response-processing";
+export type * from "./question-type-response-processing";
 export * from "./question-type-qti3";
 export type * from "./question-type-qti3";

package/dist/question-type/index.js

@@ -1,8 +1,25 @@
-export * from "./question-type";
-export * from "./question-type-setting";
-export * from "./question-type-components";
-export * from "./question-type-generation-options";
-export * from "./question-type-grading-options";
-export * from "./question-type-scanning-options";
-export * from "./question-type-capabilities";
-export * from "./question-type-qti3";
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./question-type"), exports);
+__exportStar(require("./question-type-setting"), exports);
+__exportStar(require("./question-type-components"), exports);
+__exportStar(require("./question-type-generation-options"), exports);
+__exportStar(require("./question-type-grading-options"), exports);
+__exportStar(require("./question-type-scanning-options"), exports);
+__exportStar(require("./question-type-capabilities"), exports);
+__exportStar(require("./question-type-response-processing"), exports);
+__exportStar(require("./question-type-qti3"), exports);

package/dist/question-type/question-type-capabilities.js

@@ -1,6 +1,9 @@
-import { z } from "zod";
-export const QuestionTypeCapabilitiesSchema = z.looseObject({
-    "answer-scanning": z
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QuestionTypeCapabilitiesSchema = void 0;
+const zod_1 = require("zod");
+exports.QuestionTypeCapabilitiesSchema = zod_1.z.looseObject({
+    "answer-scanning": zod_1.z
         .boolean()
         .optional()
         .describe("Whether this question type allows the student to scan an answer using their phone. Only supported for practice spaces."),

package/dist/question-type/question-type-components.js

@@ -1,17 +1,20 @@
-import { z } from "zod";
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QuestionTypeComponents = exports.ComponentReference = exports.PathOrUrlReference = void 0;
+const zod_1 = require("zod");
 // Path or URL reference type
-export const PathOrUrlReference = z
+exports.PathOrUrlReference = zod_1.z
     .string()
     .regex(/^(https?:\/\/|\.)([a-zA-Z0-9._~:/?#@!$&'()*+,;=%-]+)$/, "Valid path or URL format");
 // Component reference type
-export const ComponentReference = PathOrUrlReference.describe("Reference to a component, typically a file path or URL");
+exports.ComponentReference = exports.PathOrUrlReference.describe("Reference to a component, typically a file path or URL");
 // Components configuration
-export const QuestionTypeComponents = z
+exports.QuestionTypeComponents = zod_1.z
     .object({
-    assessment: ComponentReference.optional().describe("Path to the assessment component (question content)"),
-    print: ComponentReference.optional().describe("Path to the print component (for printing the question)"),
-    "settings-area": ComponentReference.optional().describe("Path to the settings area component (for configuring question settings)"),
-    results: ComponentReference.optional().describe("Path to the results component (for displaying answers)"),
+    assessment: exports.ComponentReference.optional().describe("Path to the assessment component (question content)"),
+    print: exports.ComponentReference.optional().describe("Path to the print component (for printing the question)"),
+    "settings-area": exports.ComponentReference.optional().describe("Path to the settings area component (for configuring question settings)"),
+    results: exports.ComponentReference.optional().describe("Path to the results component (for displaying answers)"),
 })
     .strict()
     .describe("Paths to the components used by this question type");

package/dist/question-type/question-type-generation-options.js

@@ -1,12 +1,15 @@
-import { z } from "zod";
-export const QuestionTypeGenerationOptions = z
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QuestionTypeGenerationOptions = void 0;
+const zod_1 = require("zod");
+exports.QuestionTypeGenerationOptions = zod_1.z
     .object({
-    enabled: z
+    enabled: zod_1.z
         .boolean()
         .describe("Whether this question type can be automatically generated using AI (default to false)"),
-    instructions: z
+    instructions: zod_1.z
         .string()
-        .or(z.array(z.string()))
+        .or(zod_1.z.array(zod_1.z.string()))
         .optional()
         .describe("Optional instructions to guide AI in generating this question type"),
 })

package/dist/question-type/question-type-grading-options.js

@@ -1,12 +1,15 @@
-import { z } from "zod";
-export const QuestionTypeGradingOptions = z
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QuestionTypeGradingOptions = void 0;
+const zod_1 = require("zod");
+exports.QuestionTypeGradingOptions = zod_1.z
     .object({
-    enabled: z
+    enabled: zod_1.z
         .boolean()
         .describe("Whether this question type can be automatically graded using AI (default to false)"),
-    instructions: z
+    instructions: zod_1.z
         .string()
-        .or(z.array(z.string()))
+        .or(zod_1.z.array(zod_1.z.string()))
         .optional()
         .describe("Optional instructions to guide AI in grading this question type"),
 })

package/dist/question-type/question-type-qti3.js

@@ -1,21 +1,24 @@
-import { z } from "zod";
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Qti3ImportMapping = exports.Qti3Mapping = exports.QtiInteractionType = void 0;
+const zod_1 = require("zod");
 /**
  * A value that can either be a literal or a JSONata expression string.
  * JSONata expressions are evaluated at transform time against the question context.
  */
-const JsonataExpr = z
+const JsonataExpr = zod_1.z
     .union([
-    z.string(),
-    z.number(),
-    z.boolean(),
-    z.array(z.any()),
-    z.record(z.string(), z.any()),
+    zod_1.z.string(),
+    zod_1.z.number(),
+    zod_1.z.boolean(),
+    zod_1.z.array(zod_1.z.any()),
+    zod_1.z.record(zod_1.z.string(), zod_1.z.any()),
 ])
     .describe("Literal or JSONata expression string starting with '='");
 /**
  * Supported QTI 3.0 interaction types
  */
-export const QtiInteractionType = z.enum([
+exports.QtiInteractionType = zod_1.z.enum([
     "AssociateInteraction",
     "ChoiceInteraction",
     "DrawingInteraction",
@@ -41,11 +44,11 @@ export const QtiInteractionType = z.enum([
 /**
  * Complete QTI mapping configuration for a question type
  */
-export const Qti3Mapping = z
+exports.Qti3Mapping = zod_1.z
     .object({
-    interaction: z.object({
-        type: QtiInteractionType.describe("The QTI interaction type to generate"),
-        options: z.record(z.string(), JsonataExpr).optional(),
+    interaction: zod_1.z.object({
+        type: exports.QtiInteractionType.describe("The QTI interaction type to generate"),
+        options: zod_1.z.record(zod_1.z.string(), JsonataExpr).optional(),
     }),
 })
     .describe("QTI 3.0 mapping configuration for transforming questions to QTI format");
@@ -59,17 +62,17 @@ export const Qti3Mapping = z
  *   - correctResponse: string[] of correct response identifiers/values
  *   - points: number of points from the QTI score outcome
  */
-export const Qti3ImportMapping = z
+exports.Qti3ImportMapping = zod_1.z
     .object({
-    interaction: z.object({
-        type: QtiInteractionType.describe("The QTI interaction type this question type handles on import"),
+    interaction: zod_1.z.object({
+        type: exports.QtiInteractionType.describe("The QTI interaction type this question type handles on import"),
     }),
-    condition: z
+    condition: zod_1.z
         .string()
         .optional()
         .describe("Optional JSONata expression (starting with =) that must evaluate to true for this mapping to be used. Evaluated against the same context as settings: { interaction, correctResponse, points }. Useful when multiple question types handle the same interaction type (e.g. single vs multiple choice)."),
-    settings: z
-        .record(z.string(), JsonataExpr)
+    settings: zod_1.z
+        .record(zod_1.z.string(), JsonataExpr)
         .optional()
         .describe("JSONata expressions mapping QTI interaction properties to question settings"),
 })

package/dist/question-type/question-type-response-processing.d.ts

@@ -0,0 +1,47 @@
+import { z } from "zod";
+export declare const QuestionTypeResponseProcessing: z.ZodObject<{
+    condition: z.ZodString;
+    testCases: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        answer: z.ZodObject<{
+            value: z.ZodOptional<z.ZodOptional<z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNull]>>]>>>>;
+        }, z.core.$loose>;
+        question: z.ZodObject<{
+            id: z.ZodOptional<z.ZodString>;
+            type: z.ZodOptional<z.ZodString>;
+            title: z.ZodOptional<z.ZodOptional<z.ZodNullable<z.ZodString>>>;
+            description: z.ZodOptional<z.ZodOptional<z.ZodNullable<z.ZodString>>>;
+            settings: z.ZodOptional<z.ZodObject<{}, z.core.$loose>>;
+            scoring: z.ZodOptional<z.ZodOptional<z.ZodNullable<z.ZodObject<{
+                rubricType: z.ZodOptional<z.ZodNullable<z.ZodEnum<typeof import("..").RubricType>>>;
+                criteria: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodObject<{
+                    id: z.ZodString;
+                    title: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                    description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                    points: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+                    minPoints: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+                    maxPoints: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+                    levels: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodObject<{
+                        id: z.ZodString;
+                        title: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                        description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                        points: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+                        minPoints: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+                        maxPoints: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+                    }, z.core.$strip>>>>;
+                }, z.core.$strip>>>>;
+                exactValuesCaseInsensitive: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+                guidance: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                modelAnswer: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                templateId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            }, z.core.$strip>>>>;
+            tags: z.ZodOptional<z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>>;
+            externalId: z.ZodOptional<z.ZodOptional<z.ZodNullable<z.ZodString>>>;
+            metadata: z.ZodOptional<z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>>>>>;
+            v: z.ZodOptional<z.ZodOptional<z.ZodNullable<z.ZodNumber>>>;
+            questionBankItemId: z.ZodOptional<z.ZodOptional<z.ZodNullable<z.ZodString>>>;
+            traceIds: z.ZodOptional<z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>>;
+        }, z.core.$loose>;
+        expectedOutcome: z.ZodBoolean;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type QuestionTypeResponseProcessingType = z.infer<typeof QuestionTypeResponseProcessing>;

package/dist/question-type/question-type-response-processing.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QuestionTypeResponseProcessing = void 0;
+const zod_1 = require("zod");
+const question_1 = require("../question/question");
+const AnswerSchema = zod_1.z.looseObject({
+    // TODO: this is a partial answer schema, should we move the Answer schema to this package?
+    value: zod_1.z
+        .union([zod_1.z.string(), zod_1.z.array(zod_1.z.union([zod_1.z.string(), zod_1.z.null()]))])
+        .nullish(),
+});
+const QuestionTypeResponseProcessingTestCase = zod_1.z.object({
+    answer: AnswerSchema.partial(),
+    question: question_1.QuestionSchema.partial(),
+    expectedOutcome: zod_1.z.boolean(),
+});
+exports.QuestionTypeResponseProcessing = zod_1.z
+    .object({
+    condition: zod_1.z
+        .string()
+        .regex(/^=/, "Response processing condition must start with '='")
+        .describe("JSONata expression string starting with '=' that evaluates to a boolean to determine if the response is correct"),
+    testCases: zod_1.z
+        .array(QuestionTypeResponseProcessingTestCase)
+        .optional()
+        .describe("Array of test cases to validate the response processing logic for this question type"),
+})
+    .describe("Options for response processing");

package/dist/question-type/question-type-scanning-options.js

@@ -1,9 +1,12 @@
-import { z } from "zod";
-export const QuestionTypeScanningOptions = z
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QuestionTypeScanningOptions = void 0;
+const zod_1 = require("zod");
+exports.QuestionTypeScanningOptions = zod_1.z
     .object({
-    instructions: z
+    instructions: zod_1.z
         .string()
-        .or(z.array(z.string()))
+        .or(zod_1.z.array(zod_1.z.string()))
         .optional()
         .describe("Optional instructions to guide AI in converting answers for this question type when scanning documents"),
 })

package/dist/question-type/question-type-setting.d.ts

@@ -14,9 +14,9 @@ export declare const QuestionTypeSetting: z.ZodObject<{
         boolean: "boolean";
         enum: "enum";
         custom: "custom";
+        tags: "tags";
         "string-array": "string-array";
         "scoring-criteria": "scoring-criteria";
-        tags: "tags";
         "question-type": "question-type";
     }>;
     index: z.ZodOptional<z.ZodNumber>;

package/dist/question-type/question-type-setting.js

@@ -1,24 +1,27 @@
-import { z } from "zod";
-import { Translatable } from "../common/translatable";
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QuestionTypeSetting = exports.QuestionTypeSettingOption = void 0;
+const zod_1 = require("zod");
+const translatable_1 = require("../common/translatable");
 // Setting option for enum type settings
-export const QuestionTypeSettingOption = z
+exports.QuestionTypeSettingOption = zod_1.z
     .object({
-    value: z.string().describe("Option value"),
-    label: Translatable.describe("Option label"),
+    value: zod_1.z.string().describe("Option value"),
+    label: translatable_1.Translatable.describe("Option label"),
 })
     .strict()
     .describe("Setting option");
 // Setting configuration
-export const QuestionTypeSetting = z
+exports.QuestionTypeSetting = zod_1.z
     .object({
-    id: z.string().describe("Unique identifier for the setting"),
-    name: Translatable.describe("Display name for the setting"),
-    helpText: Translatable.optional().describe("Help text for the setting"),
-    description: z
+    id: zod_1.z.string().describe("Unique identifier for the setting"),
+    name: translatable_1.Translatable.describe("Display name for the setting"),
+    helpText: translatable_1.Translatable.optional().describe("Help text for the setting"),
+    description: zod_1.z
         .string()
         .optional()
         .describe("Description to help AI agents auto-generate question settings"),
-    type: z
+    type: zod_1.z
         .enum([
         "enum",
         "string",
@@ -31,27 +34,27 @@ export const QuestionTypeSetting = z
         "question-type",
     ])
         .describe("Type of the setting"),
-    index: z.number().optional(),
-    hidden: z
+    index: zod_1.z.number().optional(),
+    hidden: zod_1.z
         .boolean()
         .optional()
         .describe("Whether the setting is hidden from the user"),
-    default: z.any().nullish().describe("Default value for the setting"),
-    required: z
+    default: zod_1.z.any().nullish().describe("Default value for the setting"),
+    required: zod_1.z
         .boolean()
         .optional()
         .describe("Whether this setting is required"),
-    options: z
-        .array(QuestionTypeSettingOption)
+    options: zod_1.z
+        .array(exports.QuestionTypeSettingOption)
         .optional()
         .describe("Available options for enum type settings"),
-    placeholder: Translatable.nullish().describe("Placeholder text for the setting"),
-    step: z.number().optional().describe("Step value for number type settings"),
-    min: z
+    placeholder: translatable_1.Translatable.nullish().describe("Placeholder text for the setting"),
+    step: zod_1.z.number().optional().describe("Step value for number type settings"),
+    min: zod_1.z
         .number()
         .optional()
         .describe("Minimum value for number type settings"),
-    max: z
+    max: zod_1.z
         .number()
         .optional()
         .describe("Maximum value for number type settings"),