@examplary/schemas 1.3.0 → 1.5.0

package/dist/question-type-generation-options.d.ts

@@ -0,0 +1,6 @@
+import { z } from "zod";
+export declare const QuestionTypeGenerationOptions: z.ZodObject<{
+    enabled: z.ZodBoolean;
+    instructions: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type QuestionTypeGenerationOptionsType = z.infer<typeof QuestionTypeGenerationOptions>;

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

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

package/dist/question-type-grading-options.d.ts

@@ -0,0 +1,6 @@
+import { z } from "zod";
+export declare const QuestionTypeGradingOptions: z.ZodObject<{
+    enabled: z.ZodBoolean;
+    instructions: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type QuestionTypeGradingOptionsType = z.infer<typeof QuestionTypeGradingOptions>;

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

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

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

@@ -0,0 +1,35 @@
+import { z } from "zod";
+export declare const QuestionTypeSettingOption: z.ZodObject<{
+    value: z.ZodString;
+    label: z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>]>;
+}, z.core.$strict>;
+export declare const QuestionTypeSetting: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>]>;
+    description: z.ZodOptional<z.ZodString>;
+    type: z.ZodEnum<{
+        string: "string";
+        number: "number";
+        boolean: "boolean";
+        enum: "enum";
+        custom: "custom";
+        "string-array": "string-array";
+        "scoring-criteria": "scoring-criteria";
+        tags: "tags";
+        "question-type": "question-type";
+    }>;
+    index: z.ZodOptional<z.ZodNumber>;
+    hidden: z.ZodOptional<z.ZodBoolean>;
+    default: z.ZodOptional<z.ZodAny>;
+    required: z.ZodOptional<z.ZodBoolean>;
+    options: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        value: z.ZodString;
+        label: z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>]>;
+    }, z.core.$strict>>>;
+    placeholder: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>]>>;
+    step: z.ZodOptional<z.ZodNumber>;
+    min: z.ZodOptional<z.ZodNumber>;
+    max: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
+export type SettingType = z.infer<typeof QuestionTypeSetting>;
+export type SettingOptionType = z.infer<typeof QuestionTypeSettingOption>;

package/dist/question-type-setting.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QuestionTypeSetting = exports.QuestionTypeSettingOption = void 0;
+var zod_1 = require("zod");
+var translatable_1 = require("./translatable");
+// Setting option for enum type settings
+exports.QuestionTypeSettingOption = zod_1.z
+    .object({
+    value: zod_1.z.string().describe("Option value"),
+    label: translatable_1.Translatable.describe("Option label"),
+})
+    .strict()
+    .describe("Setting option");
+// Setting configuration
+exports.QuestionTypeSetting = zod_1.z
+    .object({
+    id: zod_1.z.string().describe("Unique identifier for the setting"),
+    name: translatable_1.Translatable.describe("Display name for the setting"),
+    description: zod_1.z
+        .string()
+        .optional()
+        .describe("Description to help AI agents auto-generate question settings"),
+    type: zod_1.z
+        .enum([
+        "enum",
+        "string",
+        "string-array",
+        "number",
+        "boolean",
+        "custom",
+        "scoring-criteria",
+        "tags",
+        "question-type",
+    ])
+        .describe("Type of the setting"),
+    index: zod_1.z.number().optional(),
+    hidden: zod_1.z
+        .boolean()
+        .optional()
+        .describe("Whether the setting is hidden from the user"),
+    default: zod_1.z.any().optional().describe("Default value for the setting"),
+    required: zod_1.z
+        .boolean()
+        .optional()
+        .describe("Whether this setting is required"),
+    options: zod_1.z
+        .array(exports.QuestionTypeSettingOption)
+        .optional()
+        .describe("Available options for enum type settings"),
+    placeholder: translatable_1.Translatable.optional().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: zod_1.z
+        .number()
+        .optional()
+        .describe("Maximum value for number type settings"),
+})
+    .strict()
+    .describe("Setting configuration");

package/dist/question-type.d.ts

@@ -1,39 +1,4 @@
 import { z } from "zod";
-declare const Translatable: z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>]>;
-declare const ComponentReference: z.ZodString;
-declare const SettingOption: z.ZodObject<{
-    value: z.ZodString;
-    label: z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>]>;
-}, z.core.$strict>;
-declare const Setting: z.ZodObject<{
-    id: z.ZodString;
-    name: z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>]>;
-    type: z.ZodEnum<{
-        string: "string";
-        number: "number";
-        boolean: "boolean";
-        enum: "enum";
-        custom: "custom";
-        "scoring-criteria": "scoring-criteria";
-        "question-type": "question-type";
-    }>;
-    default: z.ZodOptional<z.ZodAny>;
-    required: z.ZodOptional<z.ZodBoolean>;
-    options: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        value: z.ZodString;
-        label: z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>]>;
-    }, z.core.$strict>>>;
-    placeholder: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>]>>;
-    step: z.ZodOptional<z.ZodNumber>;
-    min: z.ZodOptional<z.ZodNumber>;
-    max: z.ZodOptional<z.ZodNumber>;
-}, z.core.$strict>;
-declare const Components: z.ZodObject<{
-    assessment: z.ZodOptional<z.ZodString>;
-    print: z.ZodOptional<z.ZodString>;
-    "settings-area": z.ZodOptional<z.ZodString>;
-    results: z.ZodOptional<z.ZodString>;
-}, z.core.$strict>;
 export declare const QuestionTypeSchema: z.ZodObject<{
     $schema: z.ZodOptional<z.ZodString>;
     id: z.ZodString;
@@ -41,7 +6,14 @@ export declare const QuestionTypeSchema: z.ZodObject<{
     description: z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>]>;
     icon: z.ZodOptional<z.ZodString>;
     shortcut: z.ZodOptional<z.ZodString>;
-    canAutoGenerate: z.ZodOptional<z.ZodBoolean>;
+    generation: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodBoolean;
+        instructions: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    grading: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodBoolean;
+        instructions: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
     timeEstimateMinutes: z.ZodOptional<z.ZodNumber>;
     isAi: z.ZodOptional<z.ZodBoolean>;
     backgroundColor: z.ZodOptional<z.ZodString>;
@@ -66,15 +38,20 @@ export declare const QuestionTypeSchema: z.ZodObject<{
     settings: z.ZodOptional<z.ZodArray<z.ZodObject<{
         id: z.ZodString;
         name: z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>]>;
+        description: z.ZodOptional<z.ZodString>;
         type: z.ZodEnum<{
             string: "string";
             number: "number";
             boolean: "boolean";
             enum: "enum";
             custom: "custom";
+            "string-array": "string-array";
             "scoring-criteria": "scoring-criteria";
+            tags: "tags";
             "question-type": "question-type";
         }>;
+        index: z.ZodOptional<z.ZodNumber>;
+        hidden: z.ZodOptional<z.ZodBoolean>;
         default: z.ZodOptional<z.ZodAny>;
         required: z.ZodOptional<z.ZodBoolean>;
         options: z.ZodOptional<z.ZodArray<z.ZodObject<{
@@ -92,9 +69,3 @@ export declare const QuestionTypeSchema: z.ZodObject<{
     index: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strict>;
 export type QuestionType = z.infer<typeof QuestionTypeSchema>;
-export type TranslatableType = z.infer<typeof Translatable>;
-export type ComponentReferenceType = z.infer<typeof ComponentReference>;
-export type SettingType = z.infer<typeof Setting>;
-export type SettingOptionType = z.infer<typeof SettingOption>;
-export type ComponentsType = z.infer<typeof Components>;
-export {};

package/dist/question-type.js

@@ -2,77 +2,11 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.QuestionTypeSchema = void 0;
 var zod_1 = require("zod");
-// Translatable type - can be a simple string or translation object
-var 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(function (obj) { return Object.keys(obj).length >= 1; }, "Translation object must have at least one property")
-        .describe("Translation object with language codes as keys"),
-]);
-// Path or URL reference type
-var PathOrUrlReference = zod_1.z
-    .string()
-    .regex(/^(https?:\/\/|\.)([a-zA-Z0-9._~:/?#@!$&'()*+,;=%-]+)$/, "Valid path or URL format");
-// Component reference type
-var ComponentReference = PathOrUrlReference.describe("Reference to a component, typically a file path or URL");
-// Setting option for enum type settings
-var SettingOption = zod_1.z
-    .object({
-    value: zod_1.z.string().describe("Option value"),
-    label: Translatable.describe("Option label"),
-})
-    .strict()
-    .describe("Setting option");
-// Setting configuration
-var Setting = zod_1.z
-    .object({
-    id: zod_1.z.string().describe("Unique identifier for the setting"),
-    name: Translatable.describe("Display name for the setting"),
-    type: zod_1.z
-        .enum([
-        "enum",
-        "string",
-        "number",
-        "boolean",
-        "custom",
-        "scoring-criteria",
-        "question-type",
-    ])
-        .describe("Type of the setting"),
-    default: zod_1.z.any().optional().describe("Default value for the setting"),
-    required: zod_1.z
-        .boolean()
-        .optional()
-        .describe("Whether this setting is required"),
-    options: zod_1.z
-        .array(SettingOption)
-        .optional()
-        .describe("Available options for enum type settings"),
-    placeholder: Translatable.optional().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: zod_1.z
-        .number()
-        .optional()
-        .describe("Maximum value for number type settings"),
-})
-    .strict()
-    .describe("Setting configuration");
-// Components configuration
-var Components = 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)"),
-})
-    .strict()
-    .describe("Paths to the components used by this question type");
-// Main question type schema
+var question_type_components_1 = require("./question-type-components");
+var question_type_generation_options_1 = require("./question-type-generation-options");
+var question_type_grading_options_1 = require("./question-type-grading-options");
+var question_type_setting_1 = require("./question-type-setting");
+var translatable_1 = require("./translatable");
 exports.QuestionTypeSchema = zod_1.z
     .object({
     $schema: zod_1.z.string().optional(),
@@ -80,18 +14,16 @@ exports.QuestionTypeSchema = zod_1.z
         .string()
         .regex(/^([a-z][a-z0-9-]*)(\.[a-z][a-z0-9-]*)+$/, "Valid question type ID format")
         .describe("Unique identifier for the question type (e.g. 'my-org.color-picker')"),
-    name: Translatable.describe("Display name for the question type, can be a simple string or translation object"),
-    description: Translatable.describe("Description of the question type, can be a simple string or translation object"),
-    icon: PathOrUrlReference.optional().describe("Path to the icon for this question type"),
+    name: translatable_1.Translatable.describe("Display name for the question type, can be a simple string or translation object"),
+    description: translatable_1.Translatable.describe("Description of the question type, can be a simple string or translation object"),
+    icon: question_type_components_1.PathOrUrlReference.optional().describe("Path to the icon for this question type"),
     shortcut: zod_1.z
         .string()
         .max(1)
         .optional()
         .describe("Keyboard shortcut for quick access to this question type"),
-    canAutoGenerate: zod_1.z
-        .boolean()
-        .optional()
-        .describe("Whether this question type can be automatically generated"),
+    generation: question_type_generation_options_1.QuestionTypeGenerationOptions.optional(),
+    grading: question_type_grading_options_1.QuestionTypeGradingOptions.optional(),
     timeEstimateMinutes: zod_1.z
         .number()
         .min(1)
@@ -113,7 +45,7 @@ exports.QuestionTypeSchema = zod_1.z
         .enum(["start", "end"])
         .optional()
         .describe("Position enforcement for this question type"),
-    enforceTitle: Translatable.optional().describe("Enforced title for this question type"),
+    enforceTitle: translatable_1.Translatable.optional().describe("Enforced title for this question type"),
     hideSettings: zod_1.z
         .boolean()
         .optional()
@@ -126,12 +58,12 @@ exports.QuestionTypeSchema = zod_1.z
         .boolean()
         .optional()
         .describe("Whether this question type has simple scoring"),
-    titlePlaceholder: Translatable.optional().describe("Placeholder text for the title field"),
-    descriptionPlaceholder: Translatable.optional().describe("Placeholder text for the description field"),
-    untitledPlaceholder: Translatable.optional().describe("Placeholder text for untitled questions"),
-    components: Components.optional().describe("Paths to the components used by this question type"),
+    titlePlaceholder: translatable_1.Translatable.optional().describe("Placeholder text for the title field"),
+    descriptionPlaceholder: translatable_1.Translatable.optional().describe("Placeholder text for the description field"),
+    untitledPlaceholder: translatable_1.Translatable.optional().describe("Placeholder text for untitled questions"),
+    components: question_type_components_1.QuestionTypeComponents.optional().describe("Paths to the components used by this question type"),
     settings: zod_1.z
-        .array(Setting)
+        .array(question_type_setting_1.QuestionTypeSetting)
         .optional()
         .describe("Configuration settings for the question type"),
     public: zod_1.z
@@ -139,7 +71,7 @@ exports.QuestionTypeSchema = zod_1.z
         .optional()
         .describe("Whether this question type is public and can be used by all users"),
     translations: zod_1.z
-        .record(zod_1.z.string(), Translatable)
+        .record(zod_1.z.string(), translatable_1.Translatable)
         .optional()
         .describe("Custom translations for this question type"),
     stylesheet: zod_1.z.url().optional(),

package/dist/schemas/question-type.json

@@ -61,9 +61,41 @@
       "type": "string",
       "maxLength": 1
     },
-    "canAutoGenerate": {
-      "description": "Whether this question type can be automatically generated",
-      "type": "boolean"
+    "generation": {
+      "description": "Options for AI question generation",
+      "type": "object",
+      "properties": {
+        "enabled": {
+          "description": "Whether this question type can be automatically generated using AI (default to false)",
+          "type": "boolean"
+        },
+        "instructions": {
+          "description": "Optional instructions to guide AI in generating this question type",
+          "type": "string"
+        }
+      },
+      "required": [
+        "enabled"
+      ],
+      "additionalProperties": false
+    },
+    "grading": {
+      "description": "Options for AI question grading",
+      "type": "object",
+      "properties": {
+        "enabled": {
+          "description": "Whether this question type can be automatically graded using AI (default to false)",
+          "type": "boolean"
+        },
+        "instructions": {
+          "description": "Optional instructions to guide AI in grading this question type",
+          "type": "string"
+        }
+      },
+      "required": [
+        "enabled"
+      ],
+      "additionalProperties": false
     },
     "timeEstimateMinutes": {
       "description": "Estimated time in minutes to complete this question type",
@@ -240,19 +272,32 @@
               }
             ]
           },
+          "description": {
+            "description": "Description to help AI agents auto-generate question settings",
+            "type": "string"
+          },
           "type": {
             "description": "Type of the setting",
             "type": "string",
             "enum": [
               "enum",
               "string",
+              "string-array",
               "number",
               "boolean",
               "custom",
               "scoring-criteria",
+              "tags",
               "question-type"
             ]
           },
+          "index": {
+            "type": "number"
+          },
+          "hidden": {
+            "description": "Whether the setting is hidden from the user",
+            "type": "boolean"
+          },
           "default": {
             "description": "Default value for the setting"
           },

package/dist/translatable.d.ts

@@ -0,0 +1,3 @@
+import { z } from "zod";
+export declare const Translatable: z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>]>;
+export type TranslatableType = z.infer<typeof Translatable>;

package/dist/translatable.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Translatable = void 0;
+var zod_1 = require("zod");
+// Translatable type - can be a simple string or translation object
+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(function (obj) { return Object.keys(obj).length >= 1; }, "Translation object must have at least one property")
+        .describe("Translation object with language codes as keys"),
+]);

package/package.json

@@ -1,26 +1,26 @@
 {
   "name": "@examplary/schemas",
   "packageManager": "yarn@4.8.1",
-  "version": "1.3.0",
+  "version": "1.5.0",
   "description": "Schemas for the Examplary platform.",
   "scripts": {
     "build:schema": "tsx ./scripts/build.ts",
     "build:tsc": "tsc ./src/index.ts --outDir dist --skipLibCheck --declaration",
     "start": "yarn build:tsc --watch",
     "build": "yarn build:tsc && yarn build:schema",
-    "deploy": "serverless deploy --verbose --stage ${STAGE:-dev}",
+    "deploy": "bash -c 'serverless deploy --verbose --stage ${STAGE/staging/production}'",
     "release": "semantic-release -e semantic-release-monorepo"
   },
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "devDependencies": {
-    "serverless": "^4.17.2",
-    "serverless-lift": "^1.31.0",
-    "tsx": "^4.20.3",
-    "typescript": "^5.8.3"
+    "serverless": "^4.19.1",
+    "serverless-lift": "^1.32.0",
+    "tsx": "^4.20.5",
+    "typescript": "^5.9.2"
   },
   "dependencies": {
-    "zod": "^4.0.10"
+    "zod": "^4.1.9"
   },
   "homepage": "https://developers.examplary.ai/",
   "author": {

package/src/index.ts

@@ -1,2 +1,13 @@
+// General
+export * from "./translatable";
+export type * from "./translatable";
+
+// Question types
 export * from "./question-type";
 export type * from "./question-type";
+export * from "./question-type-setting";
+export type * from "./question-type-setting";
+export * from "./question-type-components";
+export type * from "./question-type-components";
+export * from "./question-type-generation-options";
+export type * from "./question-type-generation-options";

package/src/question-type-components.ts

@@ -0,0 +1,36 @@
+import { z } from "zod";
+
+// Path or URL reference type
+export const PathOrUrlReference = 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",
+);
+
+// Components configuration
+export const QuestionTypeComponents = 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)",
+    ),
+  })
+  .strict()
+  .describe("Paths to the components used by this question type");
+
+export type ComponentReferenceType = z.infer<typeof ComponentReference>;
+export type ComponentsType = z.infer<typeof QuestionTypeComponents>;

package/src/question-type-generation-options.ts

@@ -0,0 +1,21 @@
+import { z } from "zod";
+
+export const QuestionTypeGenerationOptions = z
+  .object({
+    enabled: z
+      .boolean()
+      .describe(
+        "Whether this question type can be automatically generated using AI (default to false)",
+      ),
+    instructions: z
+      .string()
+      .optional()
+      .describe(
+        "Optional instructions to guide AI in generating this question type",
+      ),
+  })
+  .describe("Options for AI question generation");
+
+export type QuestionTypeGenerationOptionsType = z.infer<
+  typeof QuestionTypeGenerationOptions
+>;

package/src/question-type-grading-options.ts

@@ -0,0 +1,21 @@
+import { z } from "zod";
+
+export const QuestionTypeGradingOptions = z
+  .object({
+    enabled: z
+      .boolean()
+      .describe(
+        "Whether this question type can be automatically graded using AI (default to false)",
+      ),
+    instructions: z
+      .string()
+      .optional()
+      .describe(
+        "Optional instructions to guide AI in grading this question type",
+      ),
+  })
+  .describe("Options for AI question grading");
+
+export type QuestionTypeGradingOptionsType = z.infer<
+  typeof QuestionTypeGradingOptions
+>;