@thejob/schema 1.0.26 → 1.0.28

package/dist/esm/job-application/job-application.schema.js

@@ -1,11 +1,10 @@
-import { DbDefaultSchema, NameIdLogoSchema, OtherValueSchema, SupportedExperienceLevels, } from "../common";
+import { DbDefaultSchema, SupportedExperienceLevels, } from "../common";
 import { getSchemaByQuestion } from "../job/utils";
 import { LocationSchema } from "../location";
 import { MobileNumberSchema } from "../phone";
-import { AnswerChoiceType, QuestionType } from "../question";
 import { ResumeSchema } from "../resume";
 import { EducationSchema, WorkExperienceSchema, } from "../user";
-import { array, boolean, date, lazy, mixed, number, object, string, } from "../yup-extended";
+import { array, boolean, date, lazy, number, object, string, } from "../yup-extended";
 import { JobApplicationStatus, SupportedJobApplicationScores, SupportedJobApplicationsStatuses, } from "./job-application.constant";
 export const JobApplicationSchema = object()
     .shape({
@@ -38,57 +37,60 @@ export const JobApplicationSchema = object()
         .default(JobApplicationStatus.Open)
         .label("Status"),
     questionnaire: array().of(lazy((question) => {
-        const StringSchema = string().max(500);
-        return getSchemaByQuestion(question.type).concat(object().shape({
-            answers: mixed().when("type", {
-                is: (type) => type === QuestionType.Input,
-                then: () => lazy(() => {
-                    if (question.isOptional) {
-                        return StringSchema.optional().label("Answer");
-                    }
-                    else {
-                        return StringSchema.required().label("Answer");
-                    }
-                }),
-                otherwise: () => lazy(() => {
-                    const commonSchema = mixed().oneOfSchema([
-                        StringSchema,
-                        NameIdLogoSchema,
-                        OtherValueSchema,
-                    ]);
-                    if (question.answerChoiceType === AnswerChoiceType.Multiple) {
-                        return lazy(() => {
-                            const subCommonSchema = array().of(commonSchema);
-                            if (question.isOptional) {
-                                return subCommonSchema
-                                    .optional()
-                                    .default([])
-                                    .label("Answer");
-                            }
-                            else {
-                                return subCommonSchema
-                                    .default([])
-                                    .min(1, "Select at least 1 option")
-                                    .required("Select at least 1 option")
-                                    .label("Answer");
-                            }
-                        });
-                    }
-                    else {
-                        return lazy(() => {
-                            if (question.isOptional) {
-                                return commonSchema.optional().label("Answer");
-                            }
-                            else {
-                                return commonSchema
-                                    .required("Select an option")
-                                    .label("Answer");
-                            }
-                        });
-                    }
-                }),
-            }),
-        }));
+        // const StringSchema = string().max(500);
+        return getSchemaByQuestion(question.type);
+        // .concat(
+        //   object().shape({
+        //     answers: mixed<
+        //       string | TNameIdLogoSchema | TOtherValueSchema
+        //     >().when("type", {
+        //       is: (type: QuestionType) => type === QuestionType.Input,
+        //       then: () =>
+        //         lazy(() => {
+        //           if (question.isOptional) {
+        //             return StringSchema.optional().label("Answer");
+        //           } else {
+        //             return StringSchema.required().label("Answer");
+        //           }
+        //         }),
+        //       otherwise: () =>
+        //         lazy(() => {
+        //           const commonSchema = mixed().oneOfSchema([
+        //             StringSchema,
+        //             NameIdLogoSchema,
+        //             OtherValueSchema,
+        //           ]);
+        //           if (question.answerChoiceType === AnswerChoiceType.Multiple) {
+        //             return lazy(() => {
+        //               const subCommonSchema = array().of(commonSchema);
+        //               if (question.isOptional) {
+        //                 return subCommonSchema
+        //                   .optional()
+        //                   .default([])
+        //                   .label("Answer");
+        //               } else {
+        //                 return subCommonSchema
+        //                   .default([])
+        //                   .min(1, "Select at least 1 option")
+        //                   .required("Select at least 1 option")
+        //                   .label("Answer");
+        //               }
+        //             });
+        //           } else {
+        //             return lazy(() => {
+        //               if (question.isOptional) {
+        //                 return commonSchema.optional().label("Answer");
+        //               } else {
+        //                 return commonSchema
+        //                   .required("Select an option")
+        //                   .label("Answer");
+        //               }
+        //             });
+        //           }
+        //         }),
+        //     }),
+        //   })
+        // );
     })),
     history: array()
         .of(object().shape({

package/dist/esm/job-role-template/job-role-template.schema.d.ts

@@ -20,16 +20,32 @@ export declare const JobRoleTemplateSchema: import("yup").ObjectSchema<{
         otherValue: string | string[];
     } | undefined>;
     tags: any[] | undefined;
-    questionnaire: {
-        description?: string | undefined;
+    questionnaire: ({
         label?: string | undefined;
         isNew?: boolean | undefined;
         isOptional?: boolean | undefined;
         readonly?: boolean | undefined;
-        preferredAnswer?: import("..").TMixedValue | undefined;
+        preferredAnswer?: string | undefined;
+        answers?: string | undefined;
+        type: import("..").QuestionType.Input;
+        default: boolean;
+        title: string;
+    } | {
+        label?: string | undefined;
+        isNew?: boolean | undefined;
+        isOptional?: boolean | undefined;
+        readonly?: boolean | undefined;
+        preferredAnswer?: import("..").TMixedValue | import("..").TMixedValue[] | undefined;
+        answers?: import("..").TMixedValue | (string | number | boolean | {
+            logo?: string | undefined;
+            name: string;
+            id: string;
+        } | {
+            value: "others" | (string | undefined)[];
+            otherValue: string | string[];
+        } | undefined)[] | undefined;
         optionsFrom?: string | undefined;
-        answers?: import("..").TMixedValue | undefined;
-        type: NonNullable<import("..").QuestionType | undefined>;
+        type: import("..").QuestionType.Choice;
         default: boolean;
         title: string;
         options: (string | {
@@ -39,9 +55,8 @@ export declare const JobRoleTemplateSchema: import("yup").ObjectSchema<{
         } | {
             value: "others" | (string | undefined)[];
             otherValue: string | string[];
-        })[];
-        answerChoiceType: NonNullable<import("..").AnswerChoiceType | undefined>;
-    }[] | undefined;
+        } | undefined)[];
+    } | {})[] | undefined;
 }, import("yup").AnyObject, {
     headline: undefined;
     slug: undefined;

package/dist/esm/job-role-template/job-role-template.schema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"job-role-template.schema.d.ts","sourceRoot":"","sources":["../../../src/job-role-template/job-role-template.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAG5C,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAQhC,CAAC;AAEH,MAAM,MAAM,sBAAsB,GAAG,SAAS,CAAC,OAAO,qBAAqB,CAAC,CAAC"}
+{"version":3,"file":"job-role-template.schema.d.ts","sourceRoot":"","sources":["../../../src/job-role-template/job-role-template.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAG5C,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAQhC,CAAC;AAEH,MAAM,MAAM,sBAAsB,GAAG,SAAS,CAAC,OAAO,qBAAqB,CAAC,CAAC"}

package/dist/esm/page/page-location/page-location.schema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"page-location.schema.d.ts","sourceRoot":"","sources":["../../../../src/page/page-location/page-location.schema.ts"],"names":[],"mappings":"AACA,OAAO,EAAkB,SAAS,EAAW,MAAM,oBAAoB,CAAC;AAExE,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;MAgBD,CAAC;AAE/B,MAAM,MAAM,mBAAmB,GAAG,SAAS,CAAC,OAAO,kBAAkB,CAAC,CAAC"}
+{"version":3,"file":"page-location.schema.d.ts","sourceRoot":"","sources":["../../../../src/page/page-location/page-location.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAA2B,MAAM,oBAAoB,CAAC;AAExE,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;MAgBD,CAAC;AAE/B,MAAM,MAAM,mBAAmB,GAAG,SAAS,CAAC,OAAO,kBAAkB,CAAC,CAAC"}

package/dist/esm/page/page-location/page-location.schema.js

@@ -1,4 +1,4 @@
-import { object, string, boolean } from "../../yup-extended";
+import { boolean, object, string } from "../../yup-extended";
 export const PageLocationSchema = object()
     .shape({
     isHeadquarters: boolean()

package/dist/esm/question/choice-question.schema.d.ts

@@ -1,5 +1,46 @@
-import { InferType, ObjectSchema } from "../yup-extended";
-import { TQuestionSchema } from "./question.schema";
-export declare const ChoiceQuestionSchema: ObjectSchema<TQuestionSchema>;
+import { InferType } from "../yup-extended";
+import { QuestionType } from "./question.constant";
+import { TMixedValue } from "./question.schema";
+export declare const ChoiceQuestionSchema: import("yup").ObjectSchema<{
+    label: string | undefined;
+    default: boolean;
+    title: string;
+    type: QuestionType.Choice;
+    isOptional: boolean | undefined;
+    readonly: boolean | undefined;
+    isNew: boolean | undefined;
+} & {
+    type: QuestionType.Choice;
+    optionsFrom: string | undefined;
+    options: (string | {
+        logo?: string | undefined;
+        name: string;
+        id: string;
+    } | {
+        value: "others" | (string | undefined)[];
+        otherValue: string | string[];
+    } | undefined)[];
+    preferredAnswer: TMixedValue | TMixedValue[] | undefined;
+    answers: TMixedValue | (string | number | boolean | {
+        logo?: string | undefined;
+        name: string;
+        id: string;
+    } | {
+        value: "others" | (string | undefined)[];
+        otherValue: string | string[];
+    } | undefined)[] | undefined;
+}, import("yup").AnyObject, {
+    label: undefined;
+    default: false;
+    title: undefined;
+    type: undefined;
+    isOptional: undefined;
+    readonly: undefined;
+    isNew: undefined;
+    optionsFrom: undefined;
+    options: "";
+    preferredAnswer: undefined;
+    answers: undefined;
+}, "">;
 export type TChoiceQuestionSchema = InferType<typeof ChoiceQuestionSchema>;
 //# sourceMappingURL=choice-question.schema.d.ts.map

package/dist/esm/question/choice-question.schema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"choice-question.schema.d.ts","sourceRoot":"","sources":["../../../src/question/choice-question.schema.ts"],"names":[],"mappings":"AAEA,OAAO,EAEL,SAAS,EAIT,YAAY,EAEb,MAAM,iBAAiB,CAAC;AAMzB,OAAO,EAAkB,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAiGpE,eAAO,MAAM,oBAAoB,EAAI,YAAY,CAAC,eAAe,CA+BhE,CAAC;AAEF,MAAM,MAAM,qBAAqB,GAAG,SAAS,CAAC,OAAO,oBAAoB,CAAC,CAAC"}
+{"version":3,"file":"choice-question.schema.d.ts","sourceRoot":"","sources":["../../../src/question/choice-question.schema.ts"],"names":[],"mappings":"AAOA,OAAO,EAAS,SAAS,EAA+B,MAAM,iBAAiB,CAAC;AAChF,OAAO,EAAoB,YAAY,EAAE,MAAM,qBAAqB,CAAC;AACrE,OAAO,EAAkB,WAAW,EAAE,MAAM,mBAAmB,CAAC;AA4HhE,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MA4BhC,CAAC;AAEF,MAAM,MAAM,qBAAqB,GAAG,SAAS,CAAC,OAAO,oBAAoB,CAAC,CAAC"}

package/dist/esm/question/choice-question.schema.js

@@ -1,7 +1,7 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import { Common, NameIdLogoSchema, OtherValueSchema } from "../common";
-import { array, lazy, mixed, object, string, } from "../yup-extended";
-import { AnswerChoiceType, QuestionType, SupportedAnswerChoiceTypes, } from "./question.constant";
+import { NameIdLogoSchema, OtherValueSchema, } from "../common";
+import { array, lazy, mixed, object, string } from "../yup-extended";
+import { AnswerChoiceType, QuestionType } from "./question.constant";
 import { QuestionSchema } from "./question.schema";
 // TODO: Refactor this to use string instead of objcts for values
 const displayByName = (option) => {
@@ -76,30 +76,57 @@ const ChoicePreferredAnswerSchema = (label = "Preferred answer") => mixed().when
         .optional()
         .label(label),
 });
-export const ChoiceQuestionSchema = (QuestionSchema.concat(object().shape({
+const ChoiceAnswerSchema = lazy((question) => {
+    const commonSchema = mixed().oneOfSchema([
+        string().max(500),
+        NameIdLogoSchema,
+        OtherValueSchema,
+    ]);
+    if (question.answerChoiceType === AnswerChoiceType.Multiple) {
+        const multiAnswerSchema = array().of(commonSchema);
+        if (question.isOptional) {
+            return multiAnswerSchema.optional().default([]);
+        }
+        else {
+            return multiAnswerSchema
+                .min(1, "Select at least one option.")
+                .required("Select at least one option.")
+                .default([]);
+        }
+    }
+    else {
+        // Single choice
+        if (question.isOptional) {
+            return commonSchema.optional();
+        }
+        else {
+            return commonSchema.required("Select an option.");
+        }
+    }
+});
+export const ChoiceQuestionSchema = QuestionSchema.concat(object().shape({
     type: string()
         .oneOf([QuestionType.Choice])
         .required()
         .label("Question type"),
-    optionsFrom: mixed()
-        .oneOf([Common.Skill, Common.EducationLevel, Common.ExperienceLevel])
-        .optional()
-        .label("Option field"),
+    optionsFrom: string().optional().label("Options From"),
     options: array()
         .of(lazy((option) => {
         if (typeof option === "string") {
             return string();
         }
         else {
-            return mixed().oneOfSchema([NameIdLogoSchema, OtherValueSchema]);
+            return mixed().oneOfSchema([
+                NameIdLogoSchema,
+                OtherValueSchema,
+            ]);
         }
     }))
         .min(1)
         .required()
         .label("Options"),
-    answerChoiceType: string()
-        .oneOf(SupportedAnswerChoiceTypes)
-        .required()
-        .label("Type"),
+    // preferredAnswer uses the existing validation
     preferredAnswer: ChoicePreferredAnswerSchema("Preferred answer"),
-})));
+    // The answers field now has its own complete validation logic
+    answers: ChoiceAnswerSchema,
+}));

package/dist/esm/question/input-question.schema.d.ts

@@ -1,5 +1,27 @@
-import { InferType, ObjectSchema } from "../yup-extended";
-import { TQuestionSchema } from "./question.schema";
-export declare const InputQuestionSchema: ObjectSchema<TQuestionSchema>;
-export type TInputQuestionSchema = Omit<InferType<typeof InputQuestionSchema>, "options">;
+import { InferType } from "../yup-extended";
+import { QuestionType } from "./question.constant";
+export declare const InputQuestionSchema: import("yup").ObjectSchema<{
+    label: string | undefined;
+    default: boolean;
+    title: string;
+    type: QuestionType.Input;
+    isOptional: boolean | undefined;
+    readonly: boolean | undefined;
+    isNew: boolean | undefined;
+} & {
+    type: QuestionType.Input;
+    preferredAnswer: string | undefined;
+    answers: string | undefined;
+}, import("yup").AnyObject, {
+    label: undefined;
+    default: false;
+    title: undefined;
+    type: undefined;
+    isOptional: undefined;
+    readonly: undefined;
+    isNew: undefined;
+    preferredAnswer: undefined;
+    answers: undefined;
+}, "">;
+export type TInputQuestionSchema = InferType<typeof InputQuestionSchema>;
 //# sourceMappingURL=input-question.schema.d.ts.map

package/dist/esm/question/input-question.schema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"input-question.schema.d.ts","sourceRoot":"","sources":["../../../src/question/input-question.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAU,YAAY,EAAU,MAAM,iBAAiB,CAAC;AAC1E,OAAO,EAAkB,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAEpE,eAAO,MAAM,mBAAmB,EAAI,YAAY,CAAC,eAAe,CAM/D,CAAC;AAEF,MAAM,MAAM,oBAAoB,GAAG,IAAI,CACrC,SAAS,CAAC,OAAO,mBAAmB,CAAC,EACrC,SAAS,CACV,CAAC"}
+{"version":3,"file":"input-question.schema.d.ts","sourceRoot":"","sources":["../../../src/question/input-question.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAkB,MAAM,iBAAiB,CAAC;AAC5D,OAAO,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAGnD,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;MAgB/B,CAAC;AAEF,MAAM,MAAM,oBAAoB,GAAG,SAAS,CAAC,OAAO,mBAAmB,CAAC,CAAC"}

package/dist/esm/question/input-question.schema.js

@@ -1,5 +1,18 @@
 import { object, string } from "../yup-extended";
+import { QuestionType } from "./question.constant";
 import { QuestionSchema } from "./question.schema";
-export const InputQuestionSchema = (QuestionSchema.concat(object().shape({
+export const InputQuestionSchema = QuestionSchema.concat(object().shape({
+    type: string()
+        .oneOf([QuestionType.Input])
+        .required()
+        .label("Question type"),
     preferredAnswer: string().max(100).optional().label("Preferred Answer"),
-})));
+    answers: string()
+        .max(500)
+        .when("isOptional", {
+        is: false,
+        then: (schema) => schema.required("This field is required."),
+        otherwise: (schema) => schema.optional(),
+    })
+        .label("Answer"),
+}));

package/dist/esm/question/question.schema.d.ts

@@ -1,7 +1,6 @@
 import { TNameIdLogoSchema, TOtherValueSchema } from "../common";
 import { InferType } from "../yup-extended";
-import { AnswerChoiceType } from "./question.constant";
-export type TMixedValue = string | boolean | number | TNameIdLogoSchema | TOtherValueSchema | Array<string | boolean | number | TNameIdLogoSchema | TOtherValueSchema>;
+export type TMixedValue = string | boolean | number | TNameIdLogoSchema | TOtherValueSchema;
 export declare const QuestionSchema: import("yup").ObjectSchema<{
     label: string | undefined;
     default: boolean;
@@ -9,12 +8,6 @@ export declare const QuestionSchema: import("yup").ObjectSchema<{
     type: NonNullable<import("./question.constant").QuestionType | undefined>;
     isOptional: boolean | undefined;
     readonly: boolean | undefined;
-    preferredAnswer: TMixedValue | undefined;
-    optionsFrom: string | undefined;
-    options: ({} | undefined)[] | undefined;
-    description: string | undefined;
-    answers: TMixedValue | undefined;
-    answerChoiceType: NonNullable<AnswerChoiceType | undefined>;
     isNew: boolean | undefined;
 }, import("yup").AnyObject, {
     label: undefined;
@@ -23,15 +16,7 @@ export declare const QuestionSchema: import("yup").ObjectSchema<{
     type: undefined;
     isOptional: undefined;
     readonly: undefined;
-    preferredAnswer: undefined;
-    optionsFrom: undefined;
-    options: "";
-    description: undefined;
-    answers: undefined;
-    answerChoiceType: AnswerChoiceType.Single;
     isNew: undefined;
 }, "">;
-export type TQuestionSchema = Omit<InferType<typeof QuestionSchema>, "options"> & {
-    options: Array<TNameIdLogoSchema | TOtherValueSchema | string>;
-};
+export type TQuestionSchema = Omit<InferType<typeof QuestionSchema>, "options">;
 //# sourceMappingURL=question.schema.d.ts.map

package/dist/esm/question/question.schema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"question.schema.d.ts","sourceRoot":"","sources":["../../../src/question/question.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,iBAAiB,EAAE,MAAM,WAAW,CAAC;AACjE,OAAO,EAGL,SAAS,EAIV,MAAM,iBAAiB,CAAC;AACzB,OAAO,EACL,gBAAgB,EAGjB,MAAM,qBAAqB,CAAC;AAE7B,MAAM,MAAM,WAAW,GACnB,MAAM,GACN,OAAO,GACP,MAAM,GACN,iBAAiB,GACjB,iBAAiB,GACjB,KAAK,CAAC,MAAM,GAAG,OAAO,GAAG,MAAM,GAAG,iBAAiB,GAAG,iBAAiB,CAAC,CAAC;AAE7E,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAoBzB,CAAC;AAEH,MAAM,MAAM,eAAe,GAAG,IAAI,CAChC,SAAS,CAAC,OAAO,cAAc,CAAC,EAChC,SAAS,CACV,GAAG;IACF,OAAO,EAAE,KAAK,CAAC,iBAAiB,GAAG,iBAAiB,GAAG,MAAM,CAAC,CAAC;CAEhE,CAAC"}
+{"version":3,"file":"question.schema.d.ts","sourceRoot":"","sources":["../../../src/question/question.schema.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,iBAAiB,EAAE,iBAAiB,EAAE,MAAM,WAAW,CAAC;AACjE,OAAO,EAAW,SAAS,EAAkB,MAAM,iBAAiB,CAAC;AAGrE,MAAM,MAAM,WAAW,GACnB,MAAM,GACN,OAAO,GACP,MAAM,GACN,iBAAiB,GACjB,iBAAiB,CAAC;AAEtB,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;MAQzB,CAAC;AAEH,MAAM,MAAM,eAAe,GAAG,IAAI,CAAC,SAAS,CAAC,OAAO,cAAc,CAAC,EAAE,SAAS,CAAC,CAAC"}

package/dist/esm/question/question.schema.js

@@ -1,5 +1,5 @@
-import { array, boolean, mixed, object, string, } from "../yup-extended";
-import { AnswerChoiceType, SupportedAnswerChoiceTypes, SupportedQuestionTypes, } from "./question.constant";
+import { boolean, object, string } from "../yup-extended";
+import { SupportedQuestionTypes } from "./question.constant";
 export const QuestionSchema = object().shape({
     label: string().max(50).optional().label("Label"),
     default: boolean().optional().default(false).label("Default"),
@@ -7,16 +7,8 @@ export const QuestionSchema = object().shape({
     type: string().oneOf(SupportedQuestionTypes).required().label("Type"),
     isOptional: boolean().optional().label("Mark if the question is optional"),
     readonly: boolean().optional().label("Readonly"),
-    preferredAnswer: mixed().optional().label("Preferred Answer"),
-    optionsFrom: string().optional().label("Options From"),
-    options: array().of(mixed()).optional().label("Options"),
-    description: string().optional().label("Content"),
-    answers: mixed().optional().label("Answer"),
-    answerChoiceType: string()
-        .oneOf(SupportedAnswerChoiceTypes)
-        .required()
-        .default(AnswerChoiceType.Single)
-        .label("Answer Choice Type"),
     isNew: boolean().optional().label("Is New"),
 });
-//ljlkj
+// Note: The TMixedValue and TQuestionSchema types might need adjustments
+// depending on how you use them downstream, but this is the logical
+// change for the schema itself.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@thejob/schema",
-  "version": "1.0.26",
+  "version": "1.0.28",
   "main": "dist/cjs/index.js",
   "module": "dist/esm/index.js",
   "types": "dist/esm/index.d.ts",