@thejob/schema 1.0.27 → 1.0.29

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

@@ -5,7 +5,6 @@ const common_1 = require("../common");
 const utils_1 = require("../job/utils");
 const location_1 = require("../location");
 const phone_1 = require("../phone");
-const question_1 = require("../question");
 const resume_1 = require("../resume");
 const user_1 = require("../user");
 const yup_extended_1 = require("../yup-extended");
@@ -41,57 +40,60 @@ exports.JobApplicationSchema = (0, yup_extended_1.object)()
         .default(job_application_constant_1.JobApplicationStatus.Open)
         .label("Status"),
     questionnaire: (0, yup_extended_1.array)().of((0, yup_extended_1.lazy)((question) => {
-        const StringSchema = (0, yup_extended_1.string)().max(500);
-        return (0, utils_1.getSchemaByQuestion)(question.type).concat((0, yup_extended_1.object)().shape({
-            answers: (0, yup_extended_1.mixed)().when("type", {
-                is: (type) => type === question_1.QuestionType.Input,
-                then: () => (0, yup_extended_1.lazy)(() => {
-                    if (question.isOptional) {
-                        return StringSchema.optional().label("Answer");
-                    }
-                    else {
-                        return StringSchema.required().label("Answer");
-                    }
-                }),
-                otherwise: () => (0, yup_extended_1.lazy)(() => {
-                    const commonSchema = (0, yup_extended_1.mixed)().oneOfSchema([
-                        StringSchema,
-                        common_1.NameIdLogoSchema,
-                        common_1.OtherValueSchema,
-                    ]);
-                    if (question.answerChoiceType === question_1.AnswerChoiceType.Multiple) {
-                        return (0, yup_extended_1.lazy)(() => {
-                            const subCommonSchema = (0, yup_extended_1.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 (0, yup_extended_1.lazy)(() => {
-                            if (question.isOptional) {
-                                return commonSchema.optional().label("Answer");
-                            }
-                            else {
-                                return commonSchema
-                                    .required("Select an option")
-                                    .label("Answer");
-                            }
-                        });
-                    }
-                }),
-            }),
-        }));
+        // const StringSchema = string().max(500);
+        return (0, utils_1.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: (0, yup_extended_1.array)()
         .of((0, yup_extended_1.object)().shape({

package/dist/cjs/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;
-        optionsFrom?: string | undefined;
-        answers?: import("..").TMixedValue | undefined;
-        type: NonNullable<import("..").QuestionType | 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?: import("..").Common.EducationLevel | import("..").Common.ExperienceLevel | import("..").Common.Skill | undefined;
+        type: import("..").QuestionType.Choice;
         default: boolean;
         title: string;
         options: (string | {
@@ -39,9 +55,20 @@ export declare const JobRoleTemplateSchema: import("yup").ObjectSchema<{
         } | {
             value: "others" | (string | undefined)[];
             otherValue: string | string[];
-        })[];
+        } | undefined)[];
         answerChoiceType: NonNullable<import("..").AnswerChoiceType | undefined>;
-    }[] | undefined;
+    } | {
+        label?: string | undefined;
+        isNew?: boolean | undefined;
+        isOptional?: boolean | undefined;
+        readonly?: boolean | undefined;
+        type: import("..").QuestionType.ReadAndAcknowledge;
+        default: boolean;
+        description: string;
+        title: string;
+        preferredAnswer: NonNullable<import("..").Common.Yes | import("..").Common.No | undefined>;
+        answers: NonNullable<import("..").Common.Yes | import("..").Common.No | undefined>;
+    })[] | undefined;
 }, import("yup").AnyObject, {
     headline: undefined;
     slug: undefined;

package/dist/cjs/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/cjs/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/cjs/question/choice-question.schema.d.ts

@@ -1,5 +1,49 @@
-import { InferType, ObjectSchema } from "../yup-extended";
-import { TQuestionSchema } from "./question.schema";
-export declare const ChoiceQuestionSchema: ObjectSchema<TQuestionSchema>;
+import { Common } from "../common";
+import { InferType } from "../yup-extended";
+import { AnswerChoiceType, 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: Common.EducationLevel | Common.ExperienceLevel | Common.Skill | undefined;
+    options: (string | {
+        logo?: string | undefined;
+        name: string;
+        id: string;
+    } | {
+        value: "others" | (string | undefined)[];
+        otherValue: string | string[];
+    } | undefined)[];
+    answerChoiceType: NonNullable<AnswerChoiceType | 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: "";
+    answerChoiceType: AnswerChoiceType.Single;
+    preferredAnswer: undefined;
+    answers: undefined;
+}, "">;
 export type TChoiceQuestionSchema = InferType<typeof ChoiceQuestionSchema>;
 //# sourceMappingURL=choice-question.schema.d.ts.map

package/dist/cjs/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":"AACA,OAAO,EACL,MAAM,EAKP,MAAM,WAAW,CAAC;AACnB,OAAO,EAAS,SAAS,EAA+B,MAAM,iBAAiB,CAAC;AAChF,OAAO,EACL,gBAAgB,EAChB,YAAY,EAEb,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAAkB,WAAW,EAAE,MAAM,mBAAmB,CAAC;AA6HhE,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAkChC,CAAC;AAEF,MAAM,MAAM,qBAAqB,GAAG,SAAS,CAAC,OAAO,oBAAoB,CAAC,CAAC"}

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

@@ -79,12 +79,41 @@ const ChoicePreferredAnswerSchema = (label = "Preferred answer") => (0, yup_exte
         .optional()
         .label(label),
 });
-exports.ChoiceQuestionSchema = (question_schema_1.QuestionSchema.concat((0, yup_extended_1.object)().shape({
+const ChoiceAnswerSchema = (0, yup_extended_1.lazy)((question) => {
+    const commonSchema = (0, yup_extended_1.mixed)().oneOfSchema([
+        // Note: this can be string, boolean, number, or other complex types
+        (0, yup_extended_1.string)().max(500),
+        common_1.NameIdLogoSchema,
+        common_1.OtherValueSchema,
+    ]);
+    if (question.answerChoiceType === question_constant_1.AnswerChoiceType.Multiple) {
+        const multiAnswerSchema = (0, yup_extended_1.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.");
+        }
+    }
+});
+exports.ChoiceQuestionSchema = question_schema_1.QuestionSchema.concat((0, yup_extended_1.object)().shape({
     type: (0, yup_extended_1.string)()
         .oneOf([question_constant_1.QuestionType.Choice])
         .required()
         .label("Question type"),
-    optionsFrom: (0, yup_extended_1.mixed)()
+    optionsFrom: (0, yup_extended_1.string)()
         .oneOf([common_1.Common.Skill, common_1.Common.EducationLevel, common_1.Common.ExperienceLevel])
         .optional()
         .label("Option field"),
@@ -94,7 +123,10 @@ exports.ChoiceQuestionSchema = (question_schema_1.QuestionSchema.concat((0, yup_
             return (0, yup_extended_1.string)();
         }
         else {
-            return (0, yup_extended_1.mixed)().oneOfSchema([common_1.NameIdLogoSchema, common_1.OtherValueSchema]);
+            return (0, yup_extended_1.mixed)().oneOfSchema([
+                common_1.NameIdLogoSchema,
+                common_1.OtherValueSchema,
+            ]);
         }
     }))
         .min(1)
@@ -103,6 +135,8 @@ exports.ChoiceQuestionSchema = (question_schema_1.QuestionSchema.concat((0, yup_
     answerChoiceType: (0, yup_extended_1.string)()
         .oneOf(question_constant_1.SupportedAnswerChoiceTypes)
         .required()
+        .default(question_constant_1.AnswerChoiceType.Single)
         .label("Type"),
     preferredAnswer: ChoicePreferredAnswerSchema("Preferred answer"),
-})));
+    answers: ChoiceAnswerSchema,
+}));

package/dist/cjs/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 { QuestionType } from "./question.constant";
+export declare const InputQuestionSchema: 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/cjs/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":"AACA,OAAO,EAAE,SAAS,EAAU,YAAY,EAAU,MAAM,iBAAiB,CAAC;AAE1E,OAAO,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAEnD,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;MAe/B,CAAC;AAEF,MAAM,MAAM,oBAAoB,GAAG,SAAS,CAAC,OAAO,mBAAmB,CAAC,CAAC"}

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

@@ -1,8 +1,21 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.InputQuestionSchema = void 0;
+// input-question.schema.ts
 const yup_extended_1 = require("../yup-extended");
 const question_schema_1 = require("./question.schema");
-exports.InputQuestionSchema = (question_schema_1.QuestionSchema.concat((0, yup_extended_1.object)().shape({
+const question_constant_1 = require("./question.constant");
+exports.InputQuestionSchema = question_schema_1.QuestionSchema.concat((0, yup_extended_1.object)().shape({
+    type: (0, yup_extended_1.string)()
+        .oneOf([question_constant_1.QuestionType.Input])
+        .required()
+        .label("Question type"),
     preferredAnswer: (0, yup_extended_1.string)().max(100).optional().label("Preferred Answer"),
-})));
+    answers: (0, yup_extended_1.string)()
+        .max(500)
+        .when("isOptional", {
+        is: false,
+        then: (schema) => schema.required("This field is required."),
+        otherwise: (schema) => schema.optional(),
+    }),
+}));

package/dist/cjs/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/cjs/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/cjs/question/question.schema.js

@@ -10,16 +10,13 @@ exports.QuestionSchema = (0, yup_extended_1.object)().shape({
     type: (0, yup_extended_1.string)().oneOf(question_constant_1.SupportedQuestionTypes).required().label("Type"),
     isOptional: (0, yup_extended_1.boolean)().optional().label("Mark if the question is optional"),
     readonly: (0, yup_extended_1.boolean)().optional().label("Readonly"),
-    preferredAnswer: (0, yup_extended_1.mixed)().optional().label("Preferred Answer"),
-    optionsFrom: (0, yup_extended_1.string)().optional().label("Options From"),
-    options: (0, yup_extended_1.array)().of((0, yup_extended_1.mixed)()).optional().label("Options"),
-    description: (0, yup_extended_1.string)().optional().label("Content"),
-    answers: (0, yup_extended_1.mixed)().optional().label("Answer"),
-    answerChoiceType: (0, yup_extended_1.string)()
-        .oneOf(question_constant_1.SupportedAnswerChoiceTypes)
-        .required()
-        .default(question_constant_1.AnswerChoiceType.Single)
-        .label("Answer Choice Type"),
     isNew: (0, yup_extended_1.boolean)().optional().label("Is New"),
 });
-//ljlkj
+// export type TQuestionnaire = (
+//   | TInputQuestionSchema
+//   | TChoiceQuestionSchema
+//   | TReadAndAcknowledgeQuestionSchema
+// )[];
+// 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/dist/cjs/question/read-and-acknowledge.schema.d.ts

@@ -1,5 +1,30 @@
-import { InferType, ObjectSchema } from "../yup-extended";
-import { TQuestionSchema } from "./question.schema";
-export declare const ReadAndAcknowledgeQuestionSchema: ObjectSchema<TQuestionSchema>;
+import { Common } from "../common";
+import { InferType } from "../yup-extended";
+import { QuestionType } from "./question.constant";
+export declare const ReadAndAcknowledgeQuestionSchema: import("yup").ObjectSchema<{
+    label: string | undefined;
+    default: boolean;
+    title: string;
+    type: QuestionType.ReadAndAcknowledge;
+    isOptional: boolean | undefined;
+    readonly: boolean | undefined;
+    isNew: boolean | undefined;
+} & {
+    type: QuestionType.ReadAndAcknowledge;
+    description: string;
+    preferredAnswer: NonNullable<Common.Yes | Common.No | undefined>;
+    answers: NonNullable<Common.Yes | Common.No | undefined>;
+}, import("yup").AnyObject, {
+    label: undefined;
+    default: false;
+    title: undefined;
+    type: undefined;
+    isOptional: undefined;
+    readonly: undefined;
+    isNew: undefined;
+    description: undefined;
+    preferredAnswer: undefined;
+    answers: undefined;
+}, "">;
 export type TReadAndAcknowledgeQuestionSchema = InferType<typeof ReadAndAcknowledgeQuestionSchema>;
 //# sourceMappingURL=read-and-acknowledge.schema.d.ts.map

package/dist/cjs/question/read-and-acknowledge.schema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"read-and-acknowledge.schema.d.ts","sourceRoot":"","sources":["../../../src/question/read-and-acknowledge.schema.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,SAAS,EAAU,YAAY,EAAU,MAAM,iBAAiB,CAAC;AAC1E,OAAO,EAAkB,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAEpE,eAAO,MAAM,gCAAgC,EAAI,YAAY,CAAC,eAAe,CAU5E,CAAC;AAEF,MAAM,MAAM,iCAAiC,GAAG,SAAS,CACvD,OAAO,gCAAgC,CACxC,CAAC"}
+{"version":3,"file":"read-and-acknowledge.schema.d.ts","sourceRoot":"","sources":["../../../src/question/read-and-acknowledge.schema.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,MAAM,EAAE,MAAM,WAAW,CAAC;AACnC,OAAO,EAAE,SAAS,EAAkB,MAAM,iBAAiB,CAAC;AAC5D,OAAO,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAOnD,eAAO,MAAM,gCAAgC;;;;;;;;;;;;;;;;;;;;;;;;MAU5C,CAAC;AAEF,MAAM,MAAM,iCAAiC,GAAG,SAAS,CACvD,OAAO,gCAAgC,CACxC,CAAC"}

package/dist/cjs/question/read-and-acknowledge.schema.js

@@ -1,13 +1,20 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ReadAndAcknowledgeQuestionSchema = void 0;
+// read-and-acknowledge-question.schema.ts
 const common_1 = require("../common");
 const yup_extended_1 = require("../yup-extended");
+const question_constant_1 = require("./question.constant");
 const question_schema_1 = require("./question.schema");
-exports.ReadAndAcknowledgeQuestionSchema = (question_schema_1.QuestionSchema.concat((0, yup_extended_1.object)().shape({
-    description: (0, yup_extended_1.string)().max(10000).required().label("Content"),
-    preferredAnswer: (0, yup_extended_1.string)()
-        .oneOf([common_1.Common.Yes, common_1.Common.No])
+const AcknowledgeAnswerSchema = (0, yup_extended_1.string)()
+    .oneOf([common_1.Common.Yes, common_1.Common.No])
+    .required("This question must be acknowledged.");
+exports.ReadAndAcknowledgeQuestionSchema = question_schema_1.QuestionSchema.concat((0, yup_extended_1.object)().shape({
+    type: (0, yup_extended_1.string)()
+        .oneOf([question_constant_1.QuestionType.ReadAndAcknowledge])
         .required()
-        .label("Preferred Answer"),
-})));
+        .label("Question type"),
+    description: (0, yup_extended_1.string)().max(10000).required().label("Content"),
+    preferredAnswer: AcknowledgeAnswerSchema.label("Preferred Answer"),
+    answers: AcknowledgeAnswerSchema.label("Answer"),
+}));

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

@@ -1 +1 @@
-{"version":3,"file":"common.schema.d.ts","sourceRoot":"","sources":["../../../src/common/common.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,SAAS,EAQV,MAAM,iBAAiB,CAAC;AAEzB,eAAO,MAAM,gBAAgB;;;;;;;;MAOlB,CAAC;AACZ,MAAM,MAAM,iBAAiB,GAAG,SAAS,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAEnE,eAAO,MAAM,gBAAgB;;;;;;MAwBlB,CAAC;AACZ,MAAM,MAAM,iBAAiB,GAAG,SAAS,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAEnE,eAAO,MAAM,uBAAuB;;;;MAIlC,CAAC;AACH,MAAM,MAAM,wBAAwB,GAAG,SAAS,CAC9C,OAAO,uBAAuB,CAC/B,CAAC;AAEF,eAAO,MAAM,eAAe;;;;;;;;;;;;;;MAYjB,CAAC;AAEZ,MAAM,MAAM,gBAAgB,GAAG,SAAS,CAAC,OAAO,eAAe,CAAC,CAAC;AAEjE,eAAO,MAAM,uBAAuB,GAAI,WAAU,MAAW;;;;;;;;MAKzD,CAAC;AAEL,MAAM,MAAM,wBAAwB,GAAG,SAAS,CAC9C,UAAU,CAAC,OAAO,uBAAuB,CAAC,CAC3C,CAAC;AAEF,eAAO,MAAM,wBAAwB;;;;;;MAGnC,CAAC;AACH,MAAM,MAAM,yBAAyB,GAAG,SAAS,CAC/C,OAAO,wBAAwB,CAChC,CAAC"}
+{"version":3,"file":"common.schema.d.ts","sourceRoot":"","sources":["../../../src/common/common.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,SAAS,EAKV,MAAM,iBAAiB,CAAC;AAEzB,eAAO,MAAM,gBAAgB;;;;;;;;MAOlB,CAAC;AACZ,MAAM,MAAM,iBAAiB,GAAG,SAAS,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAEnE,eAAO,MAAM,gBAAgB;;;;;;MAwBlB,CAAC;AACZ,MAAM,MAAM,iBAAiB,GAAG,SAAS,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAEnE,eAAO,MAAM,uBAAuB;;;;MAIlC,CAAC;AACH,MAAM,MAAM,wBAAwB,GAAG,SAAS,CAC9C,OAAO,uBAAuB,CAC/B,CAAC;AAEF,eAAO,MAAM,eAAe;;;;;;;;;;;;;;MAYjB,CAAC;AAEZ,MAAM,MAAM,gBAAgB,GAAG,SAAS,CAAC,OAAO,eAAe,CAAC,CAAC;AAEjE,eAAO,MAAM,uBAAuB,GAAI,WAAU,MAAW;;;;;;;;MAKzD,CAAC;AAEL,MAAM,MAAM,wBAAwB,GAAG,SAAS,CAC9C,UAAU,CAAC,OAAO,uBAAuB,CAAC,CAC3C,CAAC;AAEF,eAAO,MAAM,wBAAwB;;;;;;MAGnC,CAAC;AACH,MAAM,MAAM,yBAAyB,GAAG,SAAS,CAC/C,OAAO,wBAAwB,CAChC,CAAC"}

package/dist/esm/common/common.schema.js

@@ -1,4 +1,4 @@
-import { object, string, array, boolean, lazy, number, } from "../yup-extended";
+import { array, boolean, lazy, number, object, string, } from "../yup-extended";
 export const NameIdLogoSchema = object()
     .shape({
     id: string().objectId().required().label("Id"),