@carbonbox/domain 0.37.0 → 0.38.0

package/build/carbonbox/reporting/report-preparation-questionnaires/domain/value-objects/PreparationAnswer.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PreparationAnswer = void 0;
+const ValueObject_1 = require("../../../../shared/domain/value-objects/ValueObject");
+const InvalidPreparationAnswerError_1 = require("../exceptions/InvalidPreparationAnswerError");
+class PreparationAnswer extends ValueObject_1.ValueObject {
+    constructor(value, skipDomainValidation) {
+        super(value, skipDomainValidation, PreparationAnswer.PROPERTY_NAME, PreparationAnswer.EXPECTED_TYPE);
+        if (!skipDomainValidation) {
+            this.validatePreparationAnswer(value);
+        }
+    }
+    static create(value) {
+        return new PreparationAnswer(value, false);
+    }
+    static fromPrimitives(primitives) {
+        return new PreparationAnswer(primitives, true);
+    }
+    validatePreparationAnswer(value) {
+        if (!value.questionId || value.questionId.trim() === '') {
+            throw InvalidPreparationAnswerError_1.InvalidPreparationAnswerError.create(value.questionId, 'UNKNOWN', value.answer, 'questionId cannot be empty');
+        }
+        if (typeof value.answer !== 'string' || value.answer.trim() === '') {
+            throw InvalidPreparationAnswerError_1.InvalidPreparationAnswerError.create(value.questionId, 'UNKNOWN', String(value.answer), 'answer cannot be empty');
+        }
+        if (!value.answeredAt || Number.isNaN(Date.parse(value.answeredAt))) {
+            throw InvalidPreparationAnswerError_1.InvalidPreparationAnswerError.create(value.questionId, 'UNKNOWN', value.answer, 'answeredAt must be an ISO 8601 timestamp');
+        }
+        if (!value.answeredBy || value.answeredBy.trim() === '') {
+            throw InvalidPreparationAnswerError_1.InvalidPreparationAnswerError.create(value.questionId, 'UNKNOWN', value.answer, 'answeredBy cannot be empty');
+        }
+    }
+    getQuestionId() {
+        return this.value.questionId;
+    }
+    getAnswer() {
+        return this.value.answer;
+    }
+    getAnsweredAt() {
+        return this.value.answeredAt;
+    }
+    getAnsweredBy() {
+        return this.value.answeredBy;
+    }
+    toPrimitives() {
+        return {
+            questionId: this.value.questionId,
+            answer: this.value.answer,
+            answeredAt: this.value.answeredAt,
+            answeredBy: this.value.answeredBy,
+        };
+    }
+}
+exports.PreparationAnswer = PreparationAnswer;
+PreparationAnswer.PROPERTY_NAME = 'preparationAnswer';
+PreparationAnswer.EXPECTED_TYPE = 'PreparationAnswerPrimitives';

package/build/carbonbox/reporting/report-preparation-questionnaires/domain/value-objects/PreparationQuestion.js

@@ -0,0 +1,173 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PreparationQuestion = void 0;
+const ValueObject_1 = require("../../../../shared/domain/value-objects/ValueObject");
+const ClientInputFieldType_1 = require("../../../shared/domain/enums/ClientInputFieldType");
+const QuestionnaireQuestionOrigin_1 = require("../../../shared/domain/enums/QuestionnaireQuestionOrigin");
+const InvalidPreparationQuestionError_1 = require("../exceptions/InvalidPreparationQuestionError");
+const InvalidPreparationAnswerError_1 = require("../exceptions/InvalidPreparationAnswerError");
+class PreparationQuestion extends ValueObject_1.ValueObject {
+    constructor(value, skipDomainValidation) {
+        super(value, skipDomainValidation, PreparationQuestion.PROPERTY_NAME, PreparationQuestion.EXPECTED_TYPE);
+        if (!skipDomainValidation) {
+            this.validatePreparationQuestion(value);
+        }
+    }
+    static create(value) {
+        return new PreparationQuestion(value, false);
+    }
+    static fromPrimitives(primitives) {
+        return new PreparationQuestion(primitives, true);
+    }
+    validatePreparationQuestion(value) {
+        if (!value.id || value.id.trim() === '') {
+            throw InvalidPreparationQuestionError_1.InvalidPreparationQuestionError.create(value.id, 'id cannot be empty');
+        }
+        if (!Object.values(QuestionnaireQuestionOrigin_1.QuestionnaireQuestionOrigin).includes(value.origin)) {
+            throw InvalidPreparationQuestionError_1.InvalidPreparationQuestionError.create(value.id, `origin '${value.origin}' is not supported`);
+        }
+        if (!value.questionText || value.questionText.trim() === '') {
+            throw InvalidPreparationQuestionError_1.InvalidPreparationQuestionError.create(value.id, 'questionText cannot be empty');
+        }
+        if (!Object.values(ClientInputFieldType_1.ClientInputFieldType).includes(value.fieldType)) {
+            throw InvalidPreparationQuestionError_1.InvalidPreparationQuestionError.create(value.id, `fieldType '${value.fieldType}' is not supported`);
+        }
+        const isChoice = PreparationQuestion.CHOICE_FIELD_TYPES.includes(value.fieldType);
+        if (isChoice && (!Array.isArray(value.options) || value.options.length === 0)) {
+            throw InvalidPreparationQuestionError_1.InvalidPreparationQuestionError.create(value.id, `fieldType '${value.fieldType}' requires at least one option`);
+        }
+        if (!isChoice && Array.isArray(value.options) && value.options.length > 0) {
+            throw InvalidPreparationQuestionError_1.InvalidPreparationQuestionError.create(value.id, `fieldType '${value.fieldType}' must not define options`);
+        }
+        if (value.minLength !== null && (!Number.isInteger(value.minLength) || value.minLength < 0)) {
+            throw InvalidPreparationQuestionError_1.InvalidPreparationQuestionError.create(value.id, 'minLength must be a non-negative integer or null');
+        }
+        if (value.maxLength !== null && (!Number.isInteger(value.maxLength) || value.maxLength <= 0)) {
+            throw InvalidPreparationQuestionError_1.InvalidPreparationQuestionError.create(value.id, 'maxLength must be a positive integer or null');
+        }
+        if (value.minLength !== null && value.maxLength !== null && value.minLength > value.maxLength) {
+            throw InvalidPreparationQuestionError_1.InvalidPreparationQuestionError.create(value.id, 'minLength cannot exceed maxLength');
+        }
+        if (!Number.isInteger(value.order) || value.order < 0) {
+            throw InvalidPreparationQuestionError_1.InvalidPreparationQuestionError.create(value.id, 'order must be a non-negative integer');
+        }
+    }
+    /**
+     * Validates a candidate answer against the question field type and constraints.
+     * Throws InvalidPreparationAnswerError when the answer is not acceptable.
+     */
+    validateAnswer(answer) {
+        const questionId = this.value.id;
+        const { fieldType } = this.value;
+        if (typeof answer !== 'string' || answer.trim() === '') {
+            throw InvalidPreparationAnswerError_1.InvalidPreparationAnswerError.create(questionId, fieldType, String(answer), 'answer cannot be empty');
+        }
+        const trimmedAnswer = answer.trim();
+        if (PreparationQuestion.TEXT_FIELD_TYPES.includes(fieldType)) {
+            this.validateTextAnswer(trimmedAnswer);
+            return;
+        }
+        if (fieldType === ClientInputFieldType_1.ClientInputFieldType.NUMBER) {
+            if (!Number.isFinite(Number(trimmedAnswer))) {
+                throw InvalidPreparationAnswerError_1.InvalidPreparationAnswerError.create(questionId, fieldType, trimmedAnswer, 'answer must be a numeric value');
+            }
+            return;
+        }
+        if (fieldType === ClientInputFieldType_1.ClientInputFieldType.DATE) {
+            if (Number.isNaN(Date.parse(trimmedAnswer))) {
+                throw InvalidPreparationAnswerError_1.InvalidPreparationAnswerError.create(questionId, fieldType, trimmedAnswer, 'answer must be an ISO 8601 date');
+            }
+            return;
+        }
+        if (fieldType === ClientInputFieldType_1.ClientInputFieldType.SINGLE_CHOICE) {
+            if (!this.value.options.includes(trimmedAnswer)) {
+                throw InvalidPreparationAnswerError_1.InvalidPreparationAnswerError.create(questionId, fieldType, trimmedAnswer, `answer must be one of: ${this.value.options.join(', ')}`);
+            }
+            return;
+        }
+        if (fieldType === ClientInputFieldType_1.ClientInputFieldType.MULTIPLE_CHOICE) {
+            this.validateMultipleChoiceAnswer(trimmedAnswer);
+        }
+    }
+    validateTextAnswer(answer) {
+        if (this.value.minLength !== null && answer.length < this.value.minLength) {
+            throw InvalidPreparationAnswerError_1.InvalidPreparationAnswerError.create(this.value.id, this.value.fieldType, answer, `answer must have at least ${this.value.minLength} characters`);
+        }
+        if (this.value.maxLength !== null && answer.length > this.value.maxLength) {
+            throw InvalidPreparationAnswerError_1.InvalidPreparationAnswerError.create(this.value.id, this.value.fieldType, answer, `answer must have at most ${this.value.maxLength} characters`);
+        }
+    }
+    validateMultipleChoiceAnswer(answer) {
+        let selectedOptions;
+        try {
+            selectedOptions = JSON.parse(answer);
+        }
+        catch {
+            throw InvalidPreparationAnswerError_1.InvalidPreparationAnswerError.create(this.value.id, this.value.fieldType, answer, 'answer must be a JSON array of selected options');
+        }
+        if (!Array.isArray(selectedOptions) || selectedOptions.length === 0) {
+            throw InvalidPreparationAnswerError_1.InvalidPreparationAnswerError.create(this.value.id, this.value.fieldType, answer, 'answer must be a non-empty JSON array of selected options');
+        }
+        const invalidOptions = selectedOptions.filter((option) => typeof option !== 'string' || !this.value.options.includes(option));
+        if (invalidOptions.length > 0) {
+            throw InvalidPreparationAnswerError_1.InvalidPreparationAnswerError.create(this.value.id, this.value.fieldType, answer, `selected options must be among: ${this.value.options.join(', ')}`);
+        }
+    }
+    getId() {
+        return this.value.id;
+    }
+    getOrigin() {
+        return this.value.origin;
+    }
+    getTargetSectionId() {
+        return this.value.targetSectionId;
+    }
+    getQuestionText() {
+        return this.value.questionText;
+    }
+    getFieldType() {
+        return this.value.fieldType;
+    }
+    getAiInstruction() {
+        return this.value.aiInstruction;
+    }
+    getOrder() {
+        return this.value.order;
+    }
+    isRequired() {
+        return this.value.isRequired;
+    }
+    isFromTemplate() {
+        return this.value.origin === QuestionnaireQuestionOrigin_1.QuestionnaireQuestionOrigin.TEMPLATE;
+    }
+    isCustom() {
+        return this.value.origin === QuestionnaireQuestionOrigin_1.QuestionnaireQuestionOrigin.CUSTOM;
+    }
+    toPrimitives() {
+        return {
+            id: this.value.id,
+            origin: this.value.origin,
+            targetSectionId: this.value.targetSectionId,
+            questionText: this.value.questionText,
+            helpText: this.value.helpText,
+            fieldType: this.value.fieldType,
+            options: [...this.value.options],
+            isRequired: this.value.isRequired,
+            aiInstruction: this.value.aiInstruction,
+            minLength: this.value.minLength,
+            maxLength: this.value.maxLength,
+            order: this.value.order,
+        };
+    }
+}
+exports.PreparationQuestion = PreparationQuestion;
+PreparationQuestion.PROPERTY_NAME = 'preparationQuestion';
+PreparationQuestion.EXPECTED_TYPE = 'PreparationQuestionPrimitives';
+PreparationQuestion.CHOICE_FIELD_TYPES = [
+    ClientInputFieldType_1.ClientInputFieldType.SINGLE_CHOICE,
+    ClientInputFieldType_1.ClientInputFieldType.MULTIPLE_CHOICE,
+];
+PreparationQuestion.TEXT_FIELD_TYPES = [
+    ClientInputFieldType_1.ClientInputFieldType.SHORT_TEXT,
+    ClientInputFieldType_1.ClientInputFieldType.LONG_TEXT,
+];

package/build/carbonbox/reporting/report-preparation-questionnaires/domain/value-objects/ReportPreparationQuestionnaireCompletion.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReportPreparationQuestionnaireCompletion = void 0;
+const ValueObject_1 = require("../../../../shared/domain/value-objects/ValueObject");
+class ReportPreparationQuestionnaireCompletion extends ValueObject_1.ValueObject {
+    constructor(value, skipDomainValidation) {
+        super(value, skipDomainValidation, ReportPreparationQuestionnaireCompletion.PROPERTY_NAME, ReportPreparationQuestionnaireCompletion.EXPECTED_TYPE);
+    }
+    static create(value) {
+        return new ReportPreparationQuestionnaireCompletion(value, false);
+    }
+    static fromPrimitives(primitives) {
+        return new ReportPreparationQuestionnaireCompletion(primitives, true);
+    }
+    isComplete() {
+        return this.value.answeredRequired >= this.value.totalRequired;
+    }
+    getAnsweredRequired() {
+        return this.value.answeredRequired;
+    }
+    getTotalRequired() {
+        return this.value.totalRequired;
+    }
+    getAnsweredTotal() {
+        return this.value.answeredTotal;
+    }
+    getTotalQuestions() {
+        return this.value.totalQuestions;
+    }
+    getRequiredCompletionPercentage() {
+        if (this.value.totalRequired === 0) {
+            return 100;
+        }
+        return Math.round((this.value.answeredRequired / this.value.totalRequired) * 100);
+    }
+    toPrimitives() {
+        return {
+            answeredRequired: this.value.answeredRequired,
+            totalRequired: this.value.totalRequired,
+            answeredTotal: this.value.answeredTotal,
+            totalQuestions: this.value.totalQuestions,
+        };
+    }
+}
+exports.ReportPreparationQuestionnaireCompletion = ReportPreparationQuestionnaireCompletion;
+ReportPreparationQuestionnaireCompletion.PROPERTY_NAME = 'completion';
+ReportPreparationQuestionnaireCompletion.EXPECTED_TYPE = 'ReportPreparationQuestionnaireCompletionPrimitives';

package/build/carbonbox/reporting/report-preparation-questionnaires/domain/value-objects/ReportPreparationQuestionnaireId.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReportPreparationQuestionnaireId = void 0;
+const AggregateId_1 = require("../../../../shared/domain/value-objects/AggregateId");
+const SemanticUuidPrefix_1 = require("../../../../shared/domain/enums/SemanticUuidPrefix");
+const InvalidAggregatePrefixError_1 = require("../../../../shared/domain/exceptions/InvalidAggregatePrefixError");
+class ReportPreparationQuestionnaireId extends AggregateId_1.AggregateId {
+    constructor(value, skipDomainValidation) {
+        super(value, skipDomainValidation, ReportPreparationQuestionnaireId.PROPERTY_NAME);
+    }
+    static create(value) {
+        AggregateId_1.AggregateId.guardAgainstEmptyValue(value, ReportPreparationQuestionnaireId.PROPERTY_NAME);
+        AggregateId_1.AggregateId.guardAgainstInvalidType(value, ReportPreparationQuestionnaireId.PROPERTY_NAME);
+        AggregateId_1.AggregateId.guardAgainstInvalidId(value, ReportPreparationQuestionnaireId.PROPERTY_NAME);
+        // Validate that the prefix is valid for ReportPreparationQuestionnaire
+        ReportPreparationQuestionnaireId.guardAgainstInvalidPrefix(value);
+        return new ReportPreparationQuestionnaireId(value, false);
+    }
+    /**
+     * Validates that the UUID has a valid ReportPreparationQuestionnaire prefix
+     */
+    static guardAgainstInvalidPrefix(value) {
+        try {
+            const tempInstance = new ReportPreparationQuestionnaireId(value, true);
+            const prefix = tempInstance.extractPrefix();
+            if (ReportPreparationQuestionnaireId.VALID_PREFIXES.includes(prefix) === false) {
+                throw InvalidAggregatePrefixError_1.InvalidAggregatePrefixError.create(value, 'ReportPreparationQuestionnaire', prefix, ReportPreparationQuestionnaireId.VALID_PREFIXES, ReportPreparationQuestionnaireId.PROPERTY_NAME);
+            }
+        }
+        catch (error) {
+            if (error instanceof InvalidAggregatePrefixError_1.InvalidAggregatePrefixError) {
+                throw error;
+            }
+            if (error instanceof Error) {
+                throw InvalidAggregatePrefixError_1.InvalidAggregatePrefixError.create(value, 'ReportPreparationQuestionnaire', 'UNKNOWN', ReportPreparationQuestionnaireId.VALID_PREFIXES, ReportPreparationQuestionnaireId.PROPERTY_NAME);
+            }
+            throw error;
+        }
+    }
+    static fromPrimitives(primitive) {
+        const value = primitive;
+        return new ReportPreparationQuestionnaireId(value, true);
+    }
+    toPrimitives() {
+        return this.value;
+    }
+}
+exports.ReportPreparationQuestionnaireId = ReportPreparationQuestionnaireId;
+ReportPreparationQuestionnaireId.PROPERTY_NAME = 'id';
+ReportPreparationQuestionnaireId.VALID_PREFIXES = [
+    SemanticUuidPrefix_1.SemanticUuidPrefix.RPT_PREPARATION_QUESTIONNAIRE,
+];

package/build/carbonbox/reporting/shared/domain/enums/ClientInputFieldType.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClientInputFieldType = void 0;
+/**
+ * Client input field type enumeration
+ * Defines how a CLIENT_INPUT block (questionnaire question) is captured and validated
+ */
+var ClientInputFieldType;
+(function (ClientInputFieldType) {
+    /**
+     * Short free text (single line)
+     */
+    ClientInputFieldType["SHORT_TEXT"] = "SHORT_TEXT";
+    /**
+     * Long free text (paragraphs). Subject to block minLength/maxLength
+     */
+    ClientInputFieldType["LONG_TEXT"] = "LONG_TEXT";
+    /**
+     * Numeric value (integer or decimal)
+     */
+    ClientInputFieldType["NUMBER"] = "NUMBER";
+    /**
+     * Date value (ISO 8601 string)
+     */
+    ClientInputFieldType["DATE"] = "DATE";
+    /**
+     * Exactly one option from the configured list
+     */
+    ClientInputFieldType["SINGLE_CHOICE"] = "SINGLE_CHOICE";
+    /**
+     * One or more options from the configured list (answer is a JSON array of option strings)
+     */
+    ClientInputFieldType["MULTIPLE_CHOICE"] = "MULTIPLE_CHOICE";
+})(ClientInputFieldType || (exports.ClientInputFieldType = ClientInputFieldType = {}));

package/build/carbonbox/reporting/shared/domain/enums/QuestionnaireQuestionOrigin.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QuestionnaireQuestionOrigin = void 0;
+/**
+ * Questionnaire question origin enumeration
+ * Defines where a report preparation question comes from
+ */
+var QuestionnaireQuestionOrigin;
+(function (QuestionnaireQuestionOrigin) {
+    /**
+     * Materialized from a CLIENT_INPUT block of the report template (question id = block id)
+     */
+    QuestionnaireQuestionOrigin["TEMPLATE"] = "TEMPLATE";
+    /**
+     * Added by the client (or on its behalf) to provide extra information for the AI
+     */
+    QuestionnaireQuestionOrigin["CUSTOM"] = "CUSTOM";
+})(QuestionnaireQuestionOrigin || (exports.QuestionnaireQuestionOrigin = QuestionnaireQuestionOrigin = {}));

package/build/carbonbox/reporting/shared/domain/exceptions/InvalidReportBlockClientInputError.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InvalidReportBlockClientInputError = void 0;
+const CodedRootError_1 = require("../../../../shared/domain/exceptions/CodedRootError");
+const ErrorCode_1 = require("../../../../shared/domain/enums/ErrorCode");
+class InvalidReportBlockClientInputError extends CodedRootError_1.CodedRootError {
+    constructor(sectionId, blockId, reason) {
+        const technicalMessage = `Invalid client input configuration for block '${blockId}' in section '${sectionId}': ${reason}`;
+        const context = {
+            sectionId,
+            blockId,
+            reason,
+            timestamp: new Date().toISOString(),
+        };
+        const suggestions = [
+            'CLIENT_INPUT blocks must define a clientInput descriptor (questionText, fieldType, options, isRequired)',
+            'Blocks with any other nature must set clientInput to null',
+            'SINGLE_CHOICE and MULTIPLE_CHOICE questions must provide at least one option',
+            `Review the template definition of block '${blockId}' in section '${sectionId}'`,
+        ];
+        super(ErrorCode_1.ErrorCode.INVALID_REPORT_BLOCK_CLIENT_INPUT, technicalMessage, context, suggestions);
+        this.name = 'InvalidReportBlockClientInputError';
+    }
+    static create(sectionId, blockId, reason) {
+        return new InvalidReportBlockClientInputError(sectionId, blockId, reason);
+    }
+    logError() {
+        return `${this.name}: ${this.technicalMessage}`;
+    }
+}
+exports.InvalidReportBlockClientInputError = InvalidReportBlockClientInputError;

package/build/carbonbox/reporting/shared/domain/types/ReportBlockClientInputPrimitives.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/build/carbonbox/reporting/shared/domain/value-objects/ReportSection.js

@@ -2,10 +2,13 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ReportSection = void 0;
 const ValueObject_1 = require("../../../../shared/domain/value-objects/ValueObject");
+const BlockNature_1 = require("../enums/BlockNature");
+const ClientInputFieldType_1 = require("../enums/ClientInputFieldType");
 const InvalidReportSectionIdError_1 = require("../exceptions/InvalidReportSectionIdError");
 const InvalidReportSectionTitleError_1 = require("../exceptions/InvalidReportSectionTitleError");
 const InvalidReportSectionOrderError_1 = require("../exceptions/InvalidReportSectionOrderError");
 const EmptyReportSectionBlocksError_1 = require("../exceptions/EmptyReportSectionBlocksError");
+const InvalidReportBlockClientInputError_1 = require("../exceptions/InvalidReportBlockClientInputError");
 class ReportSection extends ValueObject_1.ValueObject {
     constructor(value, skipDomainValidation) {
         super(value, skipDomainValidation, ReportSection.PROPERTY_NAME, ReportSection.EXPECTED_TYPE);
@@ -32,6 +35,36 @@ class ReportSection extends ValueObject_1.ValueObject {
         if (!Array.isArray(value.blocks) || value.blocks.length === 0) {
             throw EmptyReportSectionBlocksError_1.EmptyReportSectionBlocksError.create(value.id);
         }
+        value.blocks.forEach((block) => this.validateBlockClientInput(value.id, block));
+    }
+    /**
+     * Invariant: a block has a clientInput descriptor if and only if its nature is CLIENT_INPUT.
+     * The descriptor is the questionnaire question the client answers to fill the block.
+     */
+    validateBlockClientInput(sectionId, block) {
+        const isClientInput = block.nature === BlockNature_1.BlockNature.CLIENT_INPUT;
+        if (isClientInput && block.clientInput === null) {
+            throw InvalidReportBlockClientInputError_1.InvalidReportBlockClientInputError.create(sectionId, block.id, 'CLIENT_INPUT blocks must define a clientInput descriptor');
+        }
+        if (!isClientInput && block.clientInput !== null) {
+            throw InvalidReportBlockClientInputError_1.InvalidReportBlockClientInputError.create(sectionId, block.id, `clientInput must be null for blocks of nature '${block.nature}'`);
+        }
+        if (!isClientInput || block.clientInput === null) {
+            return;
+        }
+        if (!block.clientInput.questionText || block.clientInput.questionText.trim() === '') {
+            throw InvalidReportBlockClientInputError_1.InvalidReportBlockClientInputError.create(sectionId, block.id, 'questionText cannot be empty');
+        }
+        if (!Object.values(ClientInputFieldType_1.ClientInputFieldType).includes(block.clientInput.fieldType)) {
+            throw InvalidReportBlockClientInputError_1.InvalidReportBlockClientInputError.create(sectionId, block.id, `fieldType '${block.clientInput.fieldType}' is not supported`);
+        }
+        const isChoice = ReportSection.CHOICE_FIELD_TYPES.includes(block.clientInput.fieldType);
+        if (isChoice && (!Array.isArray(block.clientInput.options) || block.clientInput.options.length === 0)) {
+            throw InvalidReportBlockClientInputError_1.InvalidReportBlockClientInputError.create(sectionId, block.id, `fieldType '${block.clientInput.fieldType}' requires at least one option`);
+        }
+        if (!isChoice && Array.isArray(block.clientInput.options) && block.clientInput.options.length > 0) {
+            throw InvalidReportBlockClientInputError_1.InvalidReportBlockClientInputError.create(sectionId, block.id, `fieldType '${block.clientInput.fieldType}' must not define options`);
+        }
     }
     getId() {
         return this.value.id;
@@ -45,6 +78,12 @@ class ReportSection extends ValueObject_1.ValueObject {
     getBlocks() {
         return this.value.blocks;
     }
+    /**
+     * Blocks whose content is provided by the client through the report preparation questionnaire.
+     */
+    getClientInputBlocks() {
+        return this.value.blocks.filter((block) => block.nature === BlockNature_1.BlockNature.CLIENT_INPUT);
+    }
     isRequired() {
         return this.value.isRequired;
     }
@@ -65,3 +104,7 @@ class ReportSection extends ValueObject_1.ValueObject {
 exports.ReportSection = ReportSection;
 ReportSection.PROPERTY_NAME = 'reportSection';
 ReportSection.EXPECTED_TYPE = 'ReportSectionPrimitives';
+ReportSection.CHOICE_FIELD_TYPES = [
+    ClientInputFieldType_1.ClientInputFieldType.SINGLE_CHOICE,
+    ClientInputFieldType_1.ClientInputFieldType.MULTIPLE_CHOICE,
+];

package/build/carbonbox/shared/domain/authorization/enums/Permission.js

@@ -272,4 +272,10 @@ var Permission;
     Permission["REPORTING_ADD_TEXT_BANK_ENTRY"] = "REPORTING_ADD_TEXT_BANK_ENTRY";
     Permission["REPORTING_VIEW_TEXT_BANK"] = "REPORTING_VIEW_TEXT_BANK";
     Permission["REPORTING_VIEW_TEXT_BANK_LIST"] = "REPORTING_VIEW_TEXT_BANK_LIST";
+    Permission["REPORTING_CREATE_REPORT_PREPARATION_QUESTIONNAIRE"] = "REPORTING_CREATE_REPORT_PREPARATION_QUESTIONNAIRE";
+    Permission["REPORTING_ANSWER_REPORT_PREPARATION_QUESTIONNAIRE"] = "REPORTING_ANSWER_REPORT_PREPARATION_QUESTIONNAIRE";
+    Permission["REPORTING_COMPLETE_REPORT_PREPARATION_QUESTIONNAIRE"] = "REPORTING_COMPLETE_REPORT_PREPARATION_QUESTIONNAIRE";
+    Permission["REPORTING_MANAGE_REPORT_PREPARATION_QUESTIONNAIRE_CUSTOM_QUESTIONS"] = "REPORTING_MANAGE_REPORT_PREPARATION_QUESTIONNAIRE_CUSTOM_QUESTIONS";
+    Permission["REPORTING_VIEW_REPORT_PREPARATION_QUESTIONNAIRE"] = "REPORTING_VIEW_REPORT_PREPARATION_QUESTIONNAIRE";
+    Permission["REPORTING_VIEW_REPORT_PREPARATION_QUESTIONNAIRE_LIST"] = "REPORTING_VIEW_REPORT_PREPARATION_QUESTIONNAIRE_LIST";
 })(Permission || (exports.Permission = Permission = {}));

package/build/carbonbox/shared/domain/enums/ErrorCode.js

@@ -153,6 +153,15 @@ var ErrorCode;
     ErrorCode["REPORT_TEMPLATE_CANNOT_BE_ACTIVATED"] = "CBX-RPT-015";
     ErrorCode["REPORT_TEMPLATE_CANNOT_BE_DEPRECATED"] = "CBX-RPT-016";
     ErrorCode["REPORT_TEMPLATE_CANNOT_BE_VERSIONED"] = "CBX-RPT-017";
+    ErrorCode["INVALID_REPORT_BLOCK_CLIENT_INPUT"] = "CBX-RPT-018";
+    ErrorCode["PREPARATION_QUESTION_NOT_FOUND"] = "CBX-RPT-019";
+    ErrorCode["INVALID_PREPARATION_ANSWER"] = "CBX-RPT-020";
+    ErrorCode["DUPLICATE_PREPARATION_QUESTION"] = "CBX-RPT-021";
+    ErrorCode["TEMPLATE_QUESTION_CANNOT_BE_REMOVED"] = "CBX-RPT-022";
+    ErrorCode["REPORT_PREPARATION_QUESTIONNAIRE_CANNOT_BE_MODIFIED"] = "CBX-RPT-023";
+    ErrorCode["REPORT_PREPARATION_QUESTIONNAIRE_CANNOT_BE_COMPLETED"] = "CBX-RPT-024";
+    ErrorCode["REPORT_PREPARATION_QUESTIONNAIRE_CANNOT_BE_REOPENED"] = "CBX-RPT-025";
+    ErrorCode["INVALID_PREPARATION_QUESTION"] = "CBX-RPT-026";
     // Shared/Common Errors (CBX-SHR-XXX)
     ErrorCode["INVALID_EMAIL"] = "CBX-SHR-001";
     ErrorCode["INVALID_DATE_FORMAT"] = "CBX-SHR-002";

package/build/carbonbox/shared/domain/enums/SemanticUuidPrefix.js

@@ -83,6 +83,8 @@ var SemanticUuidPrefix;
     SemanticUuidPrefix["RPT_TEXT_BANK"] = "RPT-TXB";
     SemanticUuidPrefix["RPT_SECTION"] = "RPT-SEC";
     SemanticUuidPrefix["RPT_BLOCK"] = "RPT-BLK";
+    SemanticUuidPrefix["RPT_PREPARATION_QUESTIONNAIRE"] = "RPT-PRE";
+    SemanticUuidPrefix["RPT_PREPARATION_QUESTION"] = "RPT-PRE-QST";
     // Future expansion examples (when system grows):
     // ADC_SUB_FIELDS = 'ADC-SUB-FLD', // Activity Data Collection -> Submissions -> Fields
     // USR_STH_CHO_MGT = 'USR-STH-CHO-MGT', // Users -> Stakeholders -> Carbon Host -> Management