diff --git a/src/CompositionRoot.ts b/src/CompositionRoot.ts
index b34c916f..6944d4bd 100644
--- a/src/CompositionRoot.ts
+++ b/src/CompositionRoot.ts
@@ -37,12 +37,7 @@ function getCompositionRoot(repositories: Repositories) {
         },
         diseaseOutbreakEvent: {
             get: new GetDiseaseOutbreakByIdUseCase(repositories),
-            getWithOptions: new GetDiseaseOutbreakWithOptionsUseCase(
-                repositories.diseaseOutbreakEventRepository,
-                repositories.optionsRepository,
-                repositories.teamMemberRepository,
-                repositories.orgUnitRepository
-            ),
+            getWithOptions: new GetDiseaseOutbreakWithOptionsUseCase(repositories),
             getAll: new GetAllDiseaseOutbreaksUseCase(repositories.diseaseOutbreakEventRepository),
             save: new SaveDiseaseOutbreakUseCase(repositories.diseaseOutbreakEventRepository),
         },
diff --git a/src/data/repositories/OptionsD2Repository.ts b/src/data/repositories/OptionsD2Repository.ts
index 95dcb035..4019c2be 100644
--- a/src/data/repositories/OptionsD2Repository.ts
+++ b/src/data/repositories/OptionsD2Repository.ts
@@ -1,21 +1,9 @@
-import { D2OptionSetSchema, SelectedPick } from "@eyeseetea/d2-api/2.36";
-import { CodedNamedRef } from "../../domain/entities/Ref";
-import { D2Api } from "../../types/d2-api";
+import { D2Api, MetadataPick } from "../../types/d2-api";
 import { Code, Option } from "../../domain/entities/Ref";
 import { apiToFuture, FutureData } from "../api-futures";
 import { OptionsRepository } from "../../domain/repositories/OptionsRepository";
 import { assertOrError } from "./utils/AssertOrError";
-import { Future } from "../../domain/entities/generic/Future";
-
-type D2OptionSet = SelectedPick<
-    D2OptionSetSchema,
-    {
-        id: true;
-        name: true;
-        code: true;
-        options: { id: true; name: true; code: true };
-    }
->;
+import { getHazardTypeByCode } from "./consts/DiseaseOutbreakConstants";
 
 export class OptionsD2Repository implements OptionsRepository {
     constructor(private api: D2Api) {}
@@ -36,111 +24,57 @@ export class OptionsD2Repository implements OptionsRepository {
             });
     }
 
-    getAllHazardTypes(): FutureData<CodedNamedRef[]> {
-        return apiToFuture(
-            this.api.metadata.get({
-                optionSets: {
-                    fields: {
-                        id: true,
-                        name: true,
-                        code: true,
-                        options: { id: true, name: true, code: true },
-                    },
-                    filter: { code: { eq: "RTSL_ZEB_OS_HAZARD_TYPE" } },
-                },
-            })
-        ).flatMap(response => {
-            if (!response.optionSets[0]) throw new Error("Hazard Types options not found");
-
-            return Future.success(this.mapD2OptionSetToCodedNamedRefs(response.optionSets[0]));
+    getAllHazardTypes(): FutureData<Option[]> {
+        return this.getOptionSetByCode("RTSL_ZEB_OS_HAZARD_TYPE").map(hazardTypes => {
+            return hazardTypes.map(hazardType => ({
+                id: getHazardTypeByCode(hazardType.id),
+                name: hazardType.name,
+            }));
         });
     }
 
-    getAllMainSyndromes(): FutureData<CodedNamedRef[]> {
-        return apiToFuture(
-            this.api.metadata.get({
-                optionSets: {
-                    fields: {
-                        id: true,
-                        name: true,
-                        code: true,
-                        options: { id: true, name: true, code: true },
-                    },
-                    filter: { code: { eq: "RTSL_ZEB_OS_SYNDROME" } },
-                },
-            })
-        ).flatMap(response => {
-            if (!response.optionSets[0]) throw new Error("Main Syndromes options not found");
-            return Future.success(this.mapD2OptionSetToCodedNamedRefs(response.optionSets[0]));
-        });
+    getAllMainSyndromes(): FutureData<Option[]> {
+        return this.getOptionSetByCode("RTSL_ZEB_OS_SYNDROME");
     }
 
-    getAllSuspectedDiseases(): FutureData<CodedNamedRef[]> {
-        return apiToFuture(
-            this.api.metadata.get({
-                optionSets: {
-                    fields: {
-                        id: true,
-                        name: true,
-                        code: true,
-                        options: { id: true, name: true, code: true },
-                    },
-                    filter: { code: { eq: "RTSL_ZEB_OS_DISEASE" } },
-                },
-            })
-        ).flatMap(response => {
-            if (!response.optionSets[0]) throw new Error("Suspected Diseases options not found");
+    getAllSuspectedDiseases(): FutureData<Option[]> {
+        return this.getOptionSetByCode("RTSL_ZEB_OS_DISEASE");
+    }
 
-            return Future.success(this.mapD2OptionSetToCodedNamedRefs(response.optionSets[0]));
-        });
+    getAllNotificationSources(): FutureData<Option[]> {
+        return this.getOptionSetByCode("RTSL_ZEB_OS_SOURCE");
     }
 
-    getAllNotificationSources(): FutureData<CodedNamedRef[]> {
-        return apiToFuture(
-            this.api.metadata.get({
-                optionSets: {
-                    fields: {
-                        id: true,
-                        name: true,
-                        code: true,
-                        options: { id: true, name: true, code: true },
-                    },
-                    filter: { code: { eq: "RTSL_ZEB_OS_SOURCE" } },
-                },
-            })
-        ).flatMap(response => {
-            if (!response.optionSets[0]) throw new Error("Notification Sources options not found");
-            return Future.success(this.mapD2OptionSetToCodedNamedRefs(response.optionSets[0]));
-        });
+    getAllIncidentStatus(): FutureData<Option[]> {
+        return this.getOptionSetByCode("RTSL_ZEB_OS_INCIDENT_STATUS");
     }
 
-    getAllIncidentStatus(): FutureData<CodedNamedRef[]> {
+    private getOptionSetByCode(code: string): FutureData<Option[]> {
         return apiToFuture(
             this.api.metadata.get({
-                optionSets: {
-                    fields: {
-                        id: true,
-                        name: true,
-                        code: true,
-                        options: { id: true, name: true, code: true },
-                    },
-                    filter: { code: { eq: "RTSL_ZEB_OS_INCIDENT_STATUS" } },
-                },
+                optionSets: { fields: optionSetsFields, filter: { code: { eq: code } } },
             })
-        ).flatMap(response => {
-            if (!response.optionSets[0]) throw new Error("Incident Status options not found");
-
-            return Future.success(this.mapD2OptionSetToCodedNamedRefs(response.optionSets[0]));
-        });
+        )
+            .flatMap(response => assertOrError(response.optionSets[0], `OptionSet ${code}`))
+            .map(d2Option => this.mapD2OptionSetToOptions(d2Option));
     }
 
-    private mapD2OptionSetToCodedNamedRefs(optionSet: D2OptionSet): CodedNamedRef[] {
-        return optionSet.options.map(option => {
-            return {
-                id: option.id,
+    private mapD2OptionSetToOptions(optionSet: D2OptionSet): Option[] {
+        return optionSet.options.map(
+            (option): Option => ({
+                id: option.code,
                 name: option.name,
-                code: option.code,
-            };
-        });
+            })
+        );
     }
 }
+
+const optionSetsFields = {
+    name: true,
+    code: true,
+    options: { id: true, name: true, code: true },
+};
+
+type D2OptionSet = MetadataPick<{
+    optionSets: { fields: typeof optionSetsFields };
+}>["optionSets"][number];
diff --git a/src/data/repositories/OrgUnitD2Repository.ts b/src/data/repositories/OrgUnitD2Repository.ts
index 5265d0c1..14ef9b4d 100644
--- a/src/data/repositories/OrgUnitD2Repository.ts
+++ b/src/data/repositories/OrgUnitD2Repository.ts
@@ -1,20 +1,9 @@
-import { D2OrganisationUnitSchema, SelectedPick } from "@eyeseetea/d2-api/2.36";
-import { D2Api } from "../../types/d2-api";
+import { D2Api, MetadataPick } from "../../types/d2-api";
 import { OrgUnit } from "../../domain/entities/OrgUnit";
 import { Id } from "../../domain/entities/Ref";
 import { OrgUnitRepository } from "../../domain/repositories/OrgUnitRepository";
 import { apiToFuture, FutureData } from "../api-futures";
 
-type D2OrgUnit = SelectedPick<
-    D2OrganisationUnitSchema,
-    {
-        id: true;
-        name: true;
-        code: true;
-        level: true;
-    }
->;
-
 export class OrgUnitD2Repository implements OrgUnitRepository {
     constructor(private api: D2Api) {}
 
@@ -22,12 +11,7 @@ export class OrgUnitD2Repository implements OrgUnitRepository {
         return apiToFuture(
             this.api.metadata.get({
                 organisationUnits: {
-                    fields: {
-                        id: true,
-                        name: true,
-                        code: true,
-                        level: true,
-                    },
+                    fields: d2OrgUnitFields,
                 },
             })
         ).map(response => {
@@ -42,37 +26,34 @@ export class OrgUnitD2Repository implements OrgUnitRepository {
         return apiToFuture(
             this.api.metadata.get({
                 organisationUnits: {
-                    fields: {
-                        id: true,
-                        name: true,
-                        code: true,
-                        level: true,
-                    },
+                    fields: d2OrgUnitFields,
                     filter: { id: { in: ids } },
                 },
             })
         ).map(response => {
-            const orgUnits: OrgUnit[] = response.organisationUnits.map((ou): OrgUnit => {
-                return {
-                    id: ou.id,
-                    name: ou.name,
-                    code: ou.code,
-                    level: ou.level === 2 ? "Province" : "District",
-                };
-            });
-
-            return orgUnits;
+            return this.mapD2OrgUnitsToOrgUnits(response.organisationUnits);
         });
     }
 
     private mapD2OrgUnitsToOrgUnits(d2OrgUnit: D2OrgUnit[]): OrgUnit[] {
-        return d2OrgUnit.map(ou => {
-            return {
+        return d2OrgUnit.map(
+            (ou): OrgUnit => ({
                 id: ou.id,
                 name: ou.name,
                 code: ou.code,
                 level: ou.level === 2 ? "Province" : "District",
-            };
-        });
+            })
+        );
     }
 }
+
+const d2OrgUnitFields = {
+    id: true,
+    name: true,
+    code: true,
+    level: true,
+};
+
+type D2OrgUnit = MetadataPick<{
+    organisationUnits: { fields: typeof d2OrgUnitFields };
+}>["organisationUnits"][number];
diff --git a/src/data/repositories/TeamMemberD2Repository.ts b/src/data/repositories/TeamMemberD2Repository.ts
index 663ef242..c40f2fab 100644
--- a/src/data/repositories/TeamMemberD2Repository.ts
+++ b/src/data/repositories/TeamMemberD2Repository.ts
@@ -1,22 +1,10 @@
-import { D2Api, D2UserSchema } from "../../types/d2-api";
+import { D2Api, MetadataPick } from "../../types/d2-api";
 import { TeamMember } from "../../domain/entities/incident-management-team/TeamMember";
 import { Id } from "../../domain/entities/Ref";
 import { TeamMemberRepository } from "../../domain/repositories/TeamMemberRepository";
 import { apiToFuture, FutureData } from "../api-futures";
-import { SelectedPick } from "@eyeseetea/d2-api/api";
 import { assertOrError } from "./utils/AssertOrError";
 
-type D2User = SelectedPick<
-    D2UserSchema,
-    {
-        id: true;
-        name: true;
-        username: true;
-        email: true;
-        phoneNumber: true;
-    }
->;
-
 export class TeamMemberD2Repository implements TeamMemberRepository {
     constructor(private api: D2Api) {}
 
@@ -24,13 +12,7 @@ export class TeamMemberD2Repository implements TeamMemberRepository {
         return apiToFuture(
             this.api.metadata.get({
                 users: {
-                    fields: {
-                        id: true,
-                        name: true,
-                        email: true,
-                        phoneNumber: true,
-                        username: true,
-                    },
+                    fields: d2UserFields,
                 },
             })
         ).map(response => {
@@ -43,13 +25,7 @@ export class TeamMemberD2Repository implements TeamMemberRepository {
         return apiToFuture(
             this.api.metadata.get({
                 users: {
-                    fields: {
-                        id: true,
-                        name: true,
-                        email: true,
-                        phoneNumber: true,
-                        username: true,
-                    },
+                    fields: d2UserFields,
                     filter: { username: { eq: id } },
                 },
             })
@@ -74,3 +50,15 @@ export class TeamMemberD2Repository implements TeamMemberRepository {
         });
     }
 }
+
+const d2UserFields = {
+    id: true,
+    name: true,
+    email: true,
+    phoneNumber: true,
+    username: true,
+};
+
+type _D2User = MetadataPick<{
+    users: { fields: typeof d2UserFields };
+}>["users"][number];
diff --git a/src/data/repositories/consts/DiseaseOutbreakConstants.ts b/src/data/repositories/consts/DiseaseOutbreakConstants.ts
index a9f98879..16528116 100644
--- a/src/data/repositories/consts/DiseaseOutbreakConstants.ts
+++ b/src/data/repositories/consts/DiseaseOutbreakConstants.ts
@@ -52,6 +52,7 @@ export function isHazardType(hazardType: string): hazardType is HazardType {
     return [
         "Biological:Animal",
         "Biological:Human",
+        "Biological:HumanAndAnimal",
         "Chemical",
         "Environmental",
         "Unknown",
@@ -87,28 +88,28 @@ export function getValueFromDiseaseOutbreak(
             diseaseOutbreak.earlyResponseActions.conductEpidemiologicalAnalysis.toISOString(),
         RTSL_ZEB_TEA_LABORATORY_CONFIRMATION: diseaseOutbreak.earlyResponseActions
             .laboratoryConfirmation.na
-            ? "true"
-            : "",
+            ? ""
+            : "true",
         RTSL_ZEB_TEA_SPECIFY_DATE1:
             diseaseOutbreak.earlyResponseActions.laboratoryConfirmation.date?.toISOString() ?? "",
         RTSL_ZEB_TEA_APPROPRIATE_CASE_MANAGEMENT: diseaseOutbreak.earlyResponseActions
             .appropriateCaseManagement.na
-            ? "true"
-            : "",
+            ? ""
+            : "true",
         RTSL_ZEB_TEA_SPECIFY_DATE2:
             diseaseOutbreak.earlyResponseActions.appropriateCaseManagement.date?.toISOString() ??
             "",
         RTSL_ZEB_TEA_APPROPRIATE_PUBLIC_HEALTH: diseaseOutbreak.earlyResponseActions
             .initiatePublicHealthCounterMeasures.na
-            ? "true"
-            : "",
+            ? ""
+            : "true",
         RTSL_ZEB_TEA_SPECIFY_DATE3:
             diseaseOutbreak.earlyResponseActions.initiatePublicHealthCounterMeasures.date?.toISOString() ??
             "",
         RTSL_ZEB_TEA_APPROPRIATE_RISK_COMMUNICATION: diseaseOutbreak.earlyResponseActions
             .initiateRiskCommunication.na
-            ? "true"
-            : "",
+            ? ""
+            : "true",
         RTSL_ZEB_TEA_SPECIFY_DATE4:
             diseaseOutbreak.earlyResponseActions.initiateRiskCommunication.date?.toISOString() ??
             "",
@@ -126,6 +127,8 @@ function getHazardTypeCode(hazardType: HazardType): string {
             return "BIOLOGICAL_ANIMAL";
         case "Biological:Human":
             return "BIOLOGICAL_HUMAN";
+        case "Biological:HumanAndAnimal":
+            return "BIOLOGICAL_HUM_ANM";
         case "Chemical":
             return "CHEMICAL";
         case "Environmental":
@@ -135,6 +138,24 @@ function getHazardTypeCode(hazardType: HazardType): string {
     }
 }
 
+export function getHazardTypeByCode(hazardTypeCode: string): HazardType {
+    switch (hazardTypeCode) {
+        case "BIOLOGICAL_ANIMAL":
+            return "Biological:Animal";
+        case "BIOLOGICAL_HUMAN":
+            return "Biological:Human";
+        case "BIOLOGICAL_HUM_ANM":
+            return "Biological:HumanAndAnimal";
+        case "CHEMICAL":
+            return "Chemical";
+        case "ENVIRONMENTAL":
+            return "Environmental";
+        case "UNKNOWN":
+        default:
+            return "Unknown";
+    }
+}
+
 function getOUTextFromList(OUs: string[]): string {
     return OUs[0] ?? ""; //TO DO : Handle multiple provinces/districts once metadata change is done
 }
diff --git a/src/data/repositories/utils/DiseaseOutbreakMapper.ts b/src/data/repositories/utils/DiseaseOutbreakMapper.ts
index bc2a3564..2711f1b1 100644
--- a/src/data/repositories/utils/DiseaseOutbreakMapper.ts
+++ b/src/data/repositories/utils/DiseaseOutbreakMapper.ts
@@ -15,7 +15,7 @@ import {
     RTSL_ZEBRA_PROGRAM_ID,
     RTSL_ZEBRA_TRACKED_ENTITY_TYPE_ID,
 } from "../consts/DiseaseOutbreakConstants";
-import _c from "../../../domain/entities/generic/Collection";
+import _ from "../../../domain/entities/generic/Collection";
 import { SelectedPick } from "@eyeseetea/d2-api/api";
 import { D2TrackedEntityAttributeSchema } from "../../../types/d2-api";
 import { D2TrackerEnrollment } from "@eyeseetea/d2-api/api/trackerEnrollments";
@@ -123,6 +123,52 @@ function getMultipleOUFromText(text: string): string[] {
     return [text].filter(ou => ou !== "");
 }
 
+function getValueOfCodeIfSpecifyDateIsTrue(
+    attributeValues: Record<DiseaseOutbreakCode, string>,
+    code: DiseaseOutbreakCode,
+    specifyDateCode: DiseaseOutbreakCode
+): string | undefined {
+    return attributeValues[specifyDateCode] === "true" ? attributeValues[code] : undefined;
+}
+
+function getValueByDiseaseOutbreakCode(
+    attributeValues: Record<DiseaseOutbreakCode, string>,
+    code: DiseaseOutbreakCode
+): string | undefined {
+    switch (code) {
+        case "RTSL_ZEB_TEA_LABORATORY_CONFIRMATION":
+        case "RTSL_ZEB_TEA_SPECIFY_DATE1":
+            return getValueOfCodeIfSpecifyDateIsTrue(
+                attributeValues,
+                code,
+                "RTSL_ZEB_TEA_LABORATORY_CONFIRMATION"
+            );
+        case "RTSL_ZEB_TEA_APPROPRIATE_CASE_MANAGEMENT":
+        case "RTSL_ZEB_TEA_SPECIFY_DATE2":
+            return getValueOfCodeIfSpecifyDateIsTrue(
+                attributeValues,
+                code,
+                "RTSL_ZEB_TEA_APPROPRIATE_CASE_MANAGEMENT"
+            );
+        case "RTSL_ZEB_TEA_APPROPRIATE_PUBLIC_HEALTH":
+        case "RTSL_ZEB_TEA_SPECIFY_DATE3":
+            return getValueOfCodeIfSpecifyDateIsTrue(
+                attributeValues,
+                code,
+                "RTSL_ZEB_TEA_APPROPRIATE_PUBLIC_HEALTH"
+            );
+        case "RTSL_ZEB_TEA_APPROPRIATE_RISK_COMMUNICATION":
+        case "RTSL_ZEB_TEA_SPECIFY_DATE4":
+            return getValueOfCodeIfSpecifyDateIsTrue(
+                attributeValues,
+                code,
+                "RTSL_ZEB_TEA_APPROPRIATE_RISK_COMMUNICATION"
+            );
+        default:
+            return attributeValues[code];
+    }
+}
+
 export function mapDiseaseOutbreakEventToTrackedEntityAttributes(
     diseaseOutbreak: DiseaseOutbreakEventBaseAttrs,
     attributesMetadata: D2TrackedEntityAttribute[]
@@ -130,17 +176,33 @@ export function mapDiseaseOutbreakEventToTrackedEntityAttributes(
     const attributeValues: Record<DiseaseOutbreakCode, string> =
         getValueFromDiseaseOutbreak(diseaseOutbreak);
 
-    const attributes: Attribute[] = attributesMetadata.map(attribute => {
-        if (!isStringInDiseaseOutbreakCodes(attribute.trackedEntityAttribute.code)) {
-            throw new Error("Attribute code not found in DiseaseOutbreakCodes");
-        }
-        const typedCode: KeyCode = attribute.trackedEntityAttribute.code;
-        const populatedAttribute = {
-            attribute: attribute.trackedEntityAttribute.id,
-            value: attributeValues[typedCode],
-        };
-        return populatedAttribute;
-    });
+    const attributeValuesCleaned = (Object.keys(attributeValues) as DiseaseOutbreakCode[]).reduce(
+        (acc: Record<DiseaseOutbreakCode, string>, code: DiseaseOutbreakCode) => {
+            const value = getValueByDiseaseOutbreakCode(attributeValues, code);
+            return value
+                ? { ...acc, [code]: getValueByDiseaseOutbreakCode(attributeValues, code) }
+                : acc;
+        },
+        {} as Record<DiseaseOutbreakCode, string>
+    );
+
+    const attributes: Attribute[] = _(
+        attributesMetadata.map((attribute): Attribute | null => {
+            if (!isStringInDiseaseOutbreakCodes(attribute.trackedEntityAttribute.code)) {
+                throw new Error("Attribute code not found in DiseaseOutbreakCodes");
+            }
+            const typedCode: KeyCode = attribute.trackedEntityAttribute.code;
+
+            return attributeValuesCleaned[typedCode]
+                ? {
+                      attribute: attribute.trackedEntityAttribute.id,
+                      value: attributeValuesCleaned[typedCode],
+                  }
+                : null;
+        })
+    )
+        .compact()
+        .value();
 
     const enrollment: D2TrackerEnrollment = {
         orgUnit: RTSL_ZEBRA_ORG_UNIT_ID,
diff --git a/src/domain/entities/ValidationError.ts b/src/domain/entities/ValidationError.ts
index 68ea0518..d6dab030 100644
--- a/src/domain/entities/ValidationError.ts
+++ b/src/domain/entities/ValidationError.ts
@@ -1,8 +1,4 @@
-export type ValidationErrorKey =
-    | "field_is_required"
-    | "field_is_required_na"
-    | "detected_before_emerged"
-    | "notified_before_emerged";
+export type ValidationErrorKey = "field_is_required" | "field_is_required_na";
 
 export type ValidationError = {
     property: string;
diff --git a/src/domain/entities/disease-outbreak-event/DiseaseOutbreakEvent.ts b/src/domain/entities/disease-outbreak-event/DiseaseOutbreakEvent.ts
index 2d0dac40..e9261ab4 100644
--- a/src/domain/entities/disease-outbreak-event/DiseaseOutbreakEvent.ts
+++ b/src/domain/entities/disease-outbreak-event/DiseaseOutbreakEvent.ts
@@ -6,11 +6,12 @@ import { OrgUnit } from "../OrgUnit";
 import { Id, NamedRef } from "../Ref";
 import { RiskAssessment } from "../risk-assessment/RiskAssessment";
 import { Maybe } from "../../../utils/ts-utils";
-import { ValidationError, ValidationErrorKey } from "../ValidationError";
+import { ValidationError } from "../ValidationError";
 
 export type HazardType =
     | "Biological:Human"
     | "Biological:Animal"
+    | "Biological:HumanAndAnimal"
     | "Chemical"
     | "Environmental"
     | "Unknown";
@@ -77,45 +78,8 @@ export type DiseaseOutbreakEventAttrs = DiseaseOutbreakEventBaseAttrs & {
  **/
 
 export class DiseaseOutbreakEvent extends Struct<DiseaseOutbreakEventAttrs>() {
-    //TODO: Add required validations, this is an example:
-    static validate(data: DiseaseOutbreakEventBaseAttrs): ValidationError[] {
-        const validationErrors: ValidationError[] = [
-            {
-                property: "detected_date" as const,
-                errors: DiseaseOutbreakEvent.validateDateDetectedBeforeEmerged(data),
-                value: data.id,
-            },
-            {
-                property: "notified_date" as const,
-                errors: DiseaseOutbreakEvent.validateDateNotifiedBeforeEmerged(data),
-                value: data.id,
-            },
-        ];
-
-        const filteredValidationErrorsWithErrors = validationErrors.filter(
-            v => v.errors.length > 0
-        );
-
-        return filteredValidationErrorsWithErrors.length ? validationErrors : [];
-    }
-
-    static validateDateDetectedBeforeEmerged(
-        data: DiseaseOutbreakEventBaseAttrs
-    ): ValidationErrorKey[] {
-        return data.detected.date &&
-            data.emerged.date &&
-            data.detected.date.getTime() < data.emerged.date.getTime()
-            ? ["detected_before_emerged"]
-            : [];
-    }
-
-    static validateDateNotifiedBeforeEmerged(
-        data: DiseaseOutbreakEventBaseAttrs
-    ): ValidationErrorKey[] {
-        return data.notified.date &&
-            data.emerged.date &&
-            data.notified.date.getTime() < data.emerged.date.getTime()
-            ? ["notified_before_emerged"]
-            : [];
+    //TODO: Add required validations if exists:
+    static validate(_data: DiseaseOutbreakEventBaseAttrs): ValidationError[] {
+        return [];
     }
 }
diff --git a/src/domain/entities/disease-outbreak-event/DiseaseOutbreakEventWithOptions.ts b/src/domain/entities/disease-outbreak-event/DiseaseOutbreakEventWithOptions.ts
index d275c0b9..49c41a6e 100644
--- a/src/domain/entities/disease-outbreak-event/DiseaseOutbreakEventWithOptions.ts
+++ b/src/domain/entities/disease-outbreak-event/DiseaseOutbreakEventWithOptions.ts
@@ -1,16 +1,16 @@
 import { Maybe } from "../../../utils/ts-utils";
 import { TeamMember } from "../incident-management-team/TeamMember";
 import { OrgUnit } from "../OrgUnit";
-import { CodedNamedRef } from "../Ref";
+import { Option } from "../Ref";
 import { DiseaseOutbreakEventBaseAttrs } from "./DiseaseOutbreakEvent";
 
 export type DiseaseOutbreakEventOptions = {
-    hazardTypes: CodedNamedRef[];
-    mainSyndromes: CodedNamedRef[];
-    suspectedDiseases: CodedNamedRef[];
-    notificationSources: CodedNamedRef[];
+    hazardTypes: Option[];
+    mainSyndromes: Option[];
+    suspectedDiseases: Option[];
+    notificationSources: Option[];
     organisationUnits: OrgUnit[];
-    incidentStatus: CodedNamedRef[];
+    incidentStatus: Option[];
     teamMembers: TeamMember[];
 };
 
diff --git a/src/domain/repositories/OptionsRepository.ts b/src/domain/repositories/OptionsRepository.ts
index a24485e3..ccc05468 100644
--- a/src/domain/repositories/OptionsRepository.ts
+++ b/src/domain/repositories/OptionsRepository.ts
@@ -1,11 +1,11 @@
 import { FutureData } from "../../data/api-futures";
-import { CodedNamedRef, Id, Option } from "../entities/Ref";
+import { Id, Option } from "../entities/Ref";
 
 export interface OptionsRepository {
     get(id: Id): FutureData<Option>;
-    getAllHazardTypes(): FutureData<CodedNamedRef[]>;
-    getAllMainSyndromes(): FutureData<CodedNamedRef[]>;
-    getAllSuspectedDiseases(): FutureData<CodedNamedRef[]>;
-    getAllNotificationSources(): FutureData<CodedNamedRef[]>;
-    getAllIncidentStatus(): FutureData<CodedNamedRef[]>;
+    getAllHazardTypes(): FutureData<Option[]>;
+    getAllMainSyndromes(): FutureData<Option[]>;
+    getAllSuspectedDiseases(): FutureData<Option[]>;
+    getAllNotificationSources(): FutureData<Option[]>;
+    getAllIncidentStatus(): FutureData<Option[]>;
 }
diff --git a/src/domain/usecases/GetDiseaseOutbreakWithOptionsUseCase.ts b/src/domain/usecases/GetDiseaseOutbreakWithOptionsUseCase.ts
index 169edbc7..8cfc36b8 100644
--- a/src/domain/usecases/GetDiseaseOutbreakWithOptionsUseCase.ts
+++ b/src/domain/usecases/GetDiseaseOutbreakWithOptionsUseCase.ts
@@ -10,17 +10,21 @@ import { TeamMemberRepository } from "../repositories/TeamMemberRepository";
 
 export class GetDiseaseOutbreakWithOptionsUseCase {
     constructor(
-        private diseaseOutbreakRepository: DiseaseOutbreakEventRepository,
-        private optionsRepository: OptionsRepository,
-        private teamMemberRepository: TeamMemberRepository,
-        private orgUnitRepository: OrgUnitRepository
+        private options: {
+            diseaseOutbreakEventRepository: DiseaseOutbreakEventRepository;
+            optionsRepository: OptionsRepository;
+            teamMemberRepository: TeamMemberRepository;
+            orgUnitRepository: OrgUnitRepository;
+        }
     ) {}
 
     public execute(id?: Id): FutureData<DiseaseOutbreakEventWithOptions> {
         if (id) {
-            return this.diseaseOutbreakRepository.get(id).flatMap(diseaseOutbreakEventBase => {
-                return this.getDiseaseOutbreakEventWithOptions(diseaseOutbreakEventBase);
-            });
+            return this.options.diseaseOutbreakEventRepository
+                .get(id)
+                .flatMap(diseaseOutbreakEventBase => {
+                    return this.getDiseaseOutbreakEventWithOptions(diseaseOutbreakEventBase);
+                });
         } else {
             return this.getDiseaseOutbreakEventWithOptions();
         }
@@ -30,13 +34,13 @@ export class GetDiseaseOutbreakWithOptionsUseCase {
         diseaseOutbreakEventBase?: DiseaseOutbreakEventBaseAttrs
     ): FutureData<DiseaseOutbreakEventWithOptions> {
         return Future.joinObj({
-            hazardTypes: this.optionsRepository.getAllHazardTypes(),
-            mainSyndromes: this.optionsRepository.getAllMainSyndromes(),
-            suspectedDiseases: this.optionsRepository.getAllSuspectedDiseases(),
-            notificationSources: this.optionsRepository.getAllNotificationSources(),
-            organisationUnits: this.orgUnitRepository.getAll(),
-            incidentStatus: this.optionsRepository.getAllIncidentStatus(),
-            teamMembers: this.teamMemberRepository.getAll(),
+            hazardTypes: this.options.optionsRepository.getAllHazardTypes(),
+            mainSyndromes: this.options.optionsRepository.getAllMainSyndromes(),
+            suspectedDiseases: this.options.optionsRepository.getAllSuspectedDiseases(),
+            notificationSources: this.options.optionsRepository.getAllNotificationSources(),
+            organisationUnits: this.options.orgUnitRepository.getAll(),
+            incidentStatus: this.options.optionsRepository.getAllIncidentStatus(),
+            teamMembers: this.options.teamMemberRepository.getAll(),
         }).flatMap(
             ({
                 hazardTypes,
@@ -58,7 +62,7 @@ export class GetDiseaseOutbreakWithOptionsUseCase {
                         notificationSources,
                         incidentStatus,
                     },
-                    // TODO: Get labels form Datastore
+                    // TODO: Get labels form Datastore used in mapEntityToInitialFormState to create initial form state
                     labels: {
                         errors: {
                             field_is_required: "This field is required",
diff --git a/src/domain/usecases/SaveDiseaseOutbreakUseCase.ts b/src/domain/usecases/SaveDiseaseOutbreakUseCase.ts
index 09a4937a..30932c01 100644
--- a/src/domain/usecases/SaveDiseaseOutbreakUseCase.ts
+++ b/src/domain/usecases/SaveDiseaseOutbreakUseCase.ts
@@ -5,38 +5,7 @@ import { DiseaseOutbreakEventRepository } from "../repositories/DiseaseOutbreakE
 export class SaveDiseaseOutbreakUseCase {
     constructor(private diseaseOutbreakRepository: DiseaseOutbreakEventRepository) {}
 
-    public execute(): FutureData<void> {
-        //To DO : remove hardcoding
-        const diseaseOutbreakbase: DiseaseOutbreakEventBaseAttrs = {
-            id: "",
-            eventId: 11,
-            name: "Save Outbreak",
-            created: new Date(),
-            lastUpdated: new Date(),
-            createdByName: "createdByName",
-            hazardType: "Biological:Animal",
-            mainSyndromeCode: "",
-            suspectedDiseaseCode: "",
-            notificationSourceCode: "",
-            areasAffectedDistrictIds: ["oEBf29y8JP8"],
-            areasAffectedProvinceIds: ["AWn3s2RqgAN"],
-            incidentStatus: "Watch",
-            emerged: { date: new Date(), narrative: "emerged" },
-            detected: { date: new Date(), narrative: "detected" },
-            notified: { date: new Date(), narrative: "notified" },
-            earlyResponseActions: {
-                initiateInvestigation: new Date(),
-                conductEpidemiologicalAnalysis: new Date(),
-                laboratoryConfirmation: { date: new Date(), na: true },
-                appropriateCaseManagement: { date: new Date(), na: true },
-                initiatePublicHealthCounterMeasures: { date: new Date(), na: true },
-                initiateRiskCommunication: { date: new Date(), na: true },
-                establishCoordination: new Date(),
-                responseNarrative: "responseNarrative",
-            },
-            incidentManagerName: "test",
-            notes: "notes notes notes",
-        };
-        return this.diseaseOutbreakRepository.save(diseaseOutbreakbase);
+    public execute(diseaseOutbreakEventBaseAttrs: DiseaseOutbreakEventBaseAttrs): FutureData<void> {
+        return this.diseaseOutbreakRepository.save(diseaseOutbreakEventBaseAttrs);
     }
 }
diff --git a/src/webapp/components/date-picker/DatePicker.tsx b/src/webapp/components/date-picker/DatePicker.tsx
index d91eb55f..1f21efdf 100644
--- a/src/webapp/components/date-picker/DatePicker.tsx
+++ b/src/webapp/components/date-picker/DatePicker.tsx
@@ -1,4 +1,4 @@
-import React from "react";
+import React, { useCallback } from "react";
 import styled from "styled-components";
 import { InputLabel } from "@material-ui/core";
 import { LocalizationProvider } from "@mui/x-date-pickers/LocalizationProvider";
@@ -30,6 +30,17 @@ export const DatePicker: React.FC<DatePickerProps> = React.memo(
         error = false,
         required = false,
     }) => {
+        const handleDateChange = useCallback(
+            (date: Date | null) => {
+                onChange(
+                    date
+                        ? new Date(Date.UTC(date.getFullYear(), date.getMonth(), date.getDate()))
+                        : null
+                );
+            },
+            [onChange]
+        );
+
         return (
             <Container>
                 {label && (
@@ -41,7 +52,7 @@ export const DatePicker: React.FC<DatePickerProps> = React.memo(
                 <LocalizationProvider dateAdapter={AdapterDateFns}>
                     <StyledDatePicker
                         value={value}
-                        onChange={onChange}
+                        onChange={handleDateChange}
                         format="dd/MM/yyyy"
                         slots={{ openPickerIcon: IconCalendar24 }}
                         error={error}
diff --git a/src/webapp/components/form/FormState.ts b/src/webapp/components/form/FormState.ts
index 64d4fe4d..e4b45c7a 100644
--- a/src/webapp/components/form/FormState.ts
+++ b/src/webapp/components/form/FormState.ts
@@ -97,11 +97,35 @@ export function getAllFieldsFromSections(formSections: FormSectionState[]): Form
     );
 }
 
-export function getFieldValueById(
+export function getStringFieldValue(id: string, allFields: FormFieldState[]): string {
+    return (
+        getFieldValueById<FormTextFieldState | FormOptionsFieldState | FormAvatarFieldState>(
+            id,
+            allFields
+        ) || ""
+    );
+}
+
+export function getDateFieldValue(id: string, allFields: FormFieldState[]): Date | null {
+    return getFieldValueById<FormDateFieldState>(id, allFields) || null;
+}
+
+export function getBooleanFieldValue(id: string, allFields: FormFieldState[]): boolean {
+    return !!getFieldValueById<FormBooleanFieldState>(id, allFields);
+}
+
+export function getMultipleOptionsFieldValue(id: string, allFields: FormFieldState[]): string[] {
+    return getFieldValueById<FormMultipleOptionsFieldState>(id, allFields) || [];
+}
+
+export function getFieldValueById<F extends FormFieldState>(
     id: string,
     fields: FormFieldState[]
-): FormFieldState["value"] | undefined {
-    return fields.find(field => field.id === id)?.value;
+): F["value"] | undefined {
+    const field = fields.find(field => field.id === id);
+    if (field) {
+        return getFieldValue<F>(field);
+    }
 }
 
 export function getFieldIdFromIdsDictionary<T extends Record<string, string>>(
@@ -111,7 +135,7 @@ export function getFieldIdFromIdsDictionary<T extends Record<string, string>>(
     return fieldIdsDictionary[key] as string;
 }
 
-function getEmptyValueForFieldType(field: FormFieldState): FormFieldState["value"] {
+function getEmptyValueForField<F extends FormFieldState>(field: FormFieldState): F["value"] {
     switch (field.type) {
         case "text":
             return "";
@@ -128,6 +152,10 @@ function getEmptyValueForFieldType(field: FormFieldState): FormFieldState["value
     }
 }
 
+function getFieldValue<F extends FormFieldState>(field: FormFieldState): F["value"] {
+    return field.value;
+}
+
 // UPDATES:
 
 export function updateFormStateAndApplySideEffects(
@@ -182,11 +210,14 @@ function applyEffectNotApplicableFieldUpdatedInSection(
                     f => f.notApplicableFieldId === field.id
                 );
 
+                // TODO fix this: return value type
+                const fieldValue = (
+                    notApplicableField?.value ? getEmptyValueForField(field) : getFieldValue(field)
+                ) as any;
+
                 return {
                     ...field,
-                    value: notApplicableField?.value
-                        ? (getEmptyValueForFieldType(field) as any) // TODO fix this: return value type
-                        : field.value,
+                    value: fieldValue,
                     disabled: !!notApplicableField?.value,
                 };
             }
diff --git a/src/webapp/pages/form-page/disease-outbreak-event/DiseaseOutbreakEventForm.tsx b/src/webapp/pages/form-page/disease-outbreak-event/DiseaseOutbreakEventForm.tsx
index b4fd3763..14c18692 100644
--- a/src/webapp/pages/form-page/disease-outbreak-event/DiseaseOutbreakEventForm.tsx
+++ b/src/webapp/pages/form-page/disease-outbreak-event/DiseaseOutbreakEventForm.tsx
@@ -7,6 +7,7 @@ import { Form } from "../../../components/form/Form";
 import { Id } from "../../../../domain/entities/Ref";
 import { Layout } from "../../../components/layout/Layout";
 import { Loader } from "../../../components/loader/Loader";
+import { RouteName, useRoutes } from "../../../hooks/useRoutes";
 
 type DiseaseOutbreakEventFormProps = {
     diseaseOutbreakEventId?: Id;
@@ -17,9 +18,18 @@ export const DiseaseOutbreakEventForm: React.FC<DiseaseOutbreakEventFormProps> =
     props => {
         const { diseaseOutbreakEventId } = props;
 
+        const { goTo } = useRoutes();
         const snackbar = useSnackbar();
-        const { formLabels, globalMessage, formState, handleFormChange, onSaveForm, onCancelForm } =
-            useDiseaseOutbreakEventForm(diseaseOutbreakEventId);
+        const {
+            formLabels,
+            globalMessage,
+            formState,
+            isSaved,
+            isLoading,
+            handleFormChange,
+            onSaveForm,
+            onCancelForm,
+        } = useDiseaseOutbreakEventForm(diseaseOutbreakEventId);
 
         useEffect(() => {
             if (!globalMessage) return;
@@ -27,7 +37,13 @@ export const DiseaseOutbreakEventForm: React.FC<DiseaseOutbreakEventFormProps> =
             snackbar[globalMessage.type](globalMessage.text);
         }, [globalMessage, snackbar]);
 
-        return formState.kind === "loading" ? (
+        useEffect(() => {
+            if (isSaved) {
+                goTo(RouteName.DASHBOARD);
+            }
+        }, [goTo, isSaved]);
+
+        return formState.kind === "loading" || isLoading ? (
             <Layout hideSideBarOptions>
                 <Loader />
             </Layout>
diff --git a/src/webapp/pages/form-page/disease-outbreak-event/useDiseaseOutbreakEventForm.ts b/src/webapp/pages/form-page/disease-outbreak-event/useDiseaseOutbreakEventForm.ts
index f7edde33..3f9082d6 100644
--- a/src/webapp/pages/form-page/disease-outbreak-event/useDiseaseOutbreakEventForm.ts
+++ b/src/webapp/pages/form-page/disease-outbreak-event/useDiseaseOutbreakEventForm.ts
@@ -44,6 +44,8 @@ type State = {
     formLabels: Maybe<DiseaseOutbreakEventLables>;
     globalMessage: Maybe<GlobalMessage>;
     formState: DiseaseOutbreakEventFormState;
+    isLoading: boolean;
+    isSaved: boolean;
     handleFormChange: (updatedField: FormFieldState) => void;
     onSaveForm: () => void;
     onCancelForm: () => void;
@@ -59,6 +61,8 @@ export function useDiseaseOutbreakEventForm(diseaseOutbreakEventId?: Id): State
     const [diseaseOutbreakEventWithOptions, setDiseaseOutbreakEventWithOptions] =
         useState<DiseaseOutbreakEventWithOptions>();
     const [formLabels, setFormLabels] = useState<DiseaseOutbreakEventLables>();
+    const [isSaved, setIsSaved] = useState(false);
+    const [isLoading, setIsLoading] = useState(false);
 
     useEffect(() => {
         compositionRoot.diseaseOutbreakEvent.getWithOptions.execute(diseaseOutbreakEventId).run(
@@ -107,31 +111,46 @@ export function useDiseaseOutbreakEventForm(diseaseOutbreakEventId?: Id): State
     );
 
     const onSaveForm = useCallback(() => {
-        if (formState.kind !== "loaded" || !diseaseOutbreakEventWithOptions) return;
+        if (
+            formState.kind !== "loaded" ||
+            !diseaseOutbreakEventWithOptions ||
+            !formState.data.isValid
+        )
+            return;
+
+        setIsLoading(true);
+        setIsSaved(false);
 
         const diseaseOutbreakEventData = mapFormStateToEntityData(
             formState.data,
             currentUser.username,
             diseaseOutbreakEventWithOptions
         );
-        console.debug("Event saved:", diseaseOutbreakEventData);
-
-        // TODO: Integrate with save use case
-        // compositionRoot.diseaseOutbreakEvent.save.execute(diseaseOutbreakEventData).run(
-        //     () => {
-        //         setGlobalMessage({
-        //             text: i18n.t(`Disease Outbreak saved successfully`),
-        //             type: "success",
-        //         });
-        //     },
-        //     err => {
-        //         setGlobalMessage({
-        //             text: i18n.t(`Error saving disease outbreak: ${err.message}`),
-        //             type: "success",
-        //         });
-        //     }
-        // );
-    }, [currentUser.username, diseaseOutbreakEventWithOptions, formState]);
+
+        compositionRoot.diseaseOutbreakEvent.save.execute(diseaseOutbreakEventData).run(
+            () => {
+                setGlobalMessage({
+                    text: i18n.t(`Disease Outbreak saved successfully`),
+                    type: "success",
+                });
+                setIsLoading(false);
+                setIsSaved(true);
+            },
+            err => {
+                setGlobalMessage({
+                    text: i18n.t(`Error saving disease outbreak: ${err.message}`),
+                    type: "error",
+                });
+                setIsLoading(false);
+                setIsSaved(false);
+            }
+        );
+    }, [
+        compositionRoot.diseaseOutbreakEvent.save,
+        currentUser.username,
+        diseaseOutbreakEventWithOptions,
+        formState,
+    ]);
 
     const onCancelForm = useCallback(() => {
         goTo(RouteName.DASHBOARD);
@@ -141,6 +160,8 @@ export function useDiseaseOutbreakEventForm(diseaseOutbreakEventId?: Id): State
         formLabels,
         globalMessage,
         formState,
+        isLoading,
+        isSaved,
         handleFormChange,
         onSaveForm,
         onCancelForm,
diff --git a/src/webapp/pages/form-page/disease-outbreak-event/utils/diseaseOutbreakEventFormMapper.ts b/src/webapp/pages/form-page/disease-outbreak-event/utils/diseaseOutbreakEventFormMapper.ts
index 8adfbd39..e0815edf 100644
--- a/src/webapp/pages/form-page/disease-outbreak-event/utils/diseaseOutbreakEventFormMapper.ts
+++ b/src/webapp/pages/form-page/disease-outbreak-event/utils/diseaseOutbreakEventFormMapper.ts
@@ -1,15 +1,22 @@
-import { DiseaseOutbreakEventBaseAttrs } from "../../../../../domain/entities/disease-outbreak-event/DiseaseOutbreakEvent";
+import {
+    DiseaseOutbreakEventBaseAttrs,
+    IncidentStatusType,
+} from "../../../../../domain/entities/disease-outbreak-event/DiseaseOutbreakEvent";
 import { DiseaseOutbreakEventWithOptions } from "../../../../../domain/entities/disease-outbreak-event/DiseaseOutbreakEventWithOptions";
 import {
     FormFieldState,
     FormState,
     getAllFieldsFromSections,
-    getFieldValueById,
+    getDateFieldValue,
+    getMultipleOptionsFieldValue,
+    getBooleanFieldValue,
+    getStringFieldValue,
 } from "../../../../components/form/FormState";
-import { CodedNamedRef } from "../../../../../domain/entities/Ref";
+import { Option } from "../../../../../domain/entities/Ref";
 import { getFieldIdFromIdsDictionary } from "../../../../components/form/FormState";
 import { UserOption } from "../../../../components/user-selector/UserSelector";
-import { Option } from "../../../../components/utils/option";
+import { Option as PresentationOption } from "../../../../components/utils/option";
+import { isHazardType } from "../../../../../data/repositories/consts/DiseaseOutbreakConstants";
 
 export const diseaseOutbreakEventFieldIds = {
     name: "name",
@@ -67,19 +74,21 @@ export function mapEntityToInitialFormState(
         alt: tm.photo ? `Photo of ${tm.name}` : undefined,
     }));
 
-    const provinceOptions: Option[] = organisationUnits
+    const provinceOptions: PresentationOption[] = organisationUnits
         .filter(ou => ou.level === "Province")
         .map(ou => ({ value: ou.id, label: ou.name }));
 
-    const districtOptions: Option[] = organisationUnits
+    const districtOptions: PresentationOption[] = organisationUnits
         .filter(ou => ou.level === "District")
         .map(ou => ({ value: ou.id, label: ou.name }));
 
-    const hazardTypesOptions: Option[] = mapToPresentationOptions(hazardTypes);
-    const mainSyndromesOptions: Option[] = mapToPresentationOptions(mainSyndromes);
-    const suspectedDiseasesOptions: Option[] = mapToPresentationOptions(suspectedDiseases);
-    const notificationSourcesOptions: Option[] = mapToPresentationOptions(notificationSources);
-    const incidentStatusOptions: Option[] = mapToPresentationOptions(incidentStatus);
+    const hazardTypesOptions: PresentationOption[] = mapToPresentationOptions(hazardTypes);
+    const mainSyndromesOptions: PresentationOption[] = mapToPresentationOptions(mainSyndromes);
+    const suspectedDiseasesOptions: PresentationOption[] =
+        mapToPresentationOptions(suspectedDiseases);
+    const notificationSourcesOptions: PresentationOption[] =
+        mapToPresentationOptions(notificationSources);
+    const incidentStatusOptions: PresentationOption[] = mapToPresentationOptions(incidentStatus);
 
     return {
         id: diseaseOutbreakEvent?.id || "",
@@ -689,11 +698,13 @@ export function mapEntityToInitialFormState(
     };
 }
 
-function mapToPresentationOptions(options: CodedNamedRef[]): Option[] {
-    return options.map(option => ({
-        value: option.code,
-        label: option.name,
-    }));
+function mapToPresentationOptions(options: Option[]): PresentationOption[] {
+    return options.map(
+        (option): PresentationOption => ({
+            value: option.id,
+            label: option.name,
+        })
+    );
 }
 
 export function mapFormStateToEntityData(
@@ -705,117 +716,129 @@ export function mapFormStateToEntityData(
 
     const allFields: FormFieldState[] = getAllFieldsFromSections(formState.sections);
 
-    // TODO fix this: return value types
+    const hazardType = getStringFieldValue(diseaseOutbreakEventFieldIds.hazardType, allFields);
+
     const diseaseOutbreakEventEditableData = {
-        name: getFieldValueById(diseaseOutbreakEventFieldIds.name, allFields) || "",
-        hazardType: getFieldValueById(diseaseOutbreakEventFieldIds.hazardType, allFields) || "",
-        mainSyndromeCode:
-            getFieldValueById(diseaseOutbreakEventFieldIds.mainSyndromeCode, allFields) || "",
-        suspectedDiseaseCode:
-            getFieldValueById(diseaseOutbreakEventFieldIds.suspectedDiseaseCode, allFields) || "",
-        notificationSourceCode:
-            getFieldValueById(diseaseOutbreakEventFieldIds.notificationSourceCode, allFields) || "",
-        areasAffectedProvinceIds:
-            getFieldValueById(diseaseOutbreakEventFieldIds.areasAffectedProvinceIds, allFields) ||
-            [],
-        areasAffectedDistrictIds:
-            getFieldValueById(diseaseOutbreakEventFieldIds.areasAffectedDistrictIds, allFields) ||
-            [],
-        incidentStatus:
-            getFieldValueById(diseaseOutbreakEventFieldIds.incidentStatus, allFields) || "",
+        name: getStringFieldValue(diseaseOutbreakEventFieldIds.name, allFields),
+        hazardType: isHazardType(hazardType) ? hazardType : "Unknown",
+        mainSyndromeCode: getStringFieldValue(
+            diseaseOutbreakEventFieldIds.mainSyndromeCode,
+            allFields
+        ),
+        suspectedDiseaseCode: getStringFieldValue(
+            diseaseOutbreakEventFieldIds.suspectedDiseaseCode,
+            allFields
+        ),
+        notificationSourceCode: getStringFieldValue(
+            diseaseOutbreakEventFieldIds.notificationSourceCode,
+            allFields
+        ),
+        areasAffectedProvinceIds: getMultipleOptionsFieldValue(
+            diseaseOutbreakEventFieldIds.areasAffectedProvinceIds,
+            allFields
+        ),
+        areasAffectedDistrictIds: getMultipleOptionsFieldValue(
+            diseaseOutbreakEventFieldIds.areasAffectedDistrictIds,
+            allFields
+        ),
+        incidentStatus: getStringFieldValue(
+            diseaseOutbreakEventFieldIds.incidentStatus,
+            allFields
+        ) as IncidentStatusType,
         emerged: {
-            date: getFieldValueById(diseaseOutbreakEventFieldIds.emergedDate, allFields) || null,
-            narrative:
-                getFieldValueById(diseaseOutbreakEventFieldIds.emergedNarrative, allFields) || "",
+            date: getDateFieldValue(diseaseOutbreakEventFieldIds.emergedDate, allFields) as Date,
+            narrative: getStringFieldValue(
+                diseaseOutbreakEventFieldIds.emergedNarrative,
+                allFields
+            ),
         },
         detected: {
-            date: getFieldValueById(diseaseOutbreakEventFieldIds.detectedDate, allFields) || null,
-            narrative:
-                getFieldValueById(diseaseOutbreakEventFieldIds.detectedNarrative, allFields) || "",
+            date: getDateFieldValue(diseaseOutbreakEventFieldIds.detectedDate, allFields) as Date,
+            narrative: getStringFieldValue(
+                diseaseOutbreakEventFieldIds.detectedNarrative,
+                allFields
+            ),
         },
         notified: {
-            date: getFieldValueById(diseaseOutbreakEventFieldIds.notifiedDate, allFields) || null,
-            narrative:
-                getFieldValueById(diseaseOutbreakEventFieldIds.notifiedNarrative, allFields) || "",
+            date: getDateFieldValue(diseaseOutbreakEventFieldIds.notifiedDate, allFields) as Date,
+            narrative: getStringFieldValue(
+                diseaseOutbreakEventFieldIds.notifiedNarrative,
+                allFields
+            ),
         },
         earlyResponseActions: {
-            initiateInvestigation:
-                getFieldValueById(diseaseOutbreakEventFieldIds.initiateInvestigation, allFields) ||
-                null,
-            conductEpidemiologicalAnalysis:
-                getFieldValueById(
-                    diseaseOutbreakEventFieldIds.conductEpidemiologicalAnalysis,
-                    allFields
-                ) || null,
+            initiateInvestigation: getDateFieldValue(
+                diseaseOutbreakEventFieldIds.initiateInvestigation,
+                allFields
+            ) as Date,
+            conductEpidemiologicalAnalysis: getDateFieldValue(
+                diseaseOutbreakEventFieldIds.conductEpidemiologicalAnalysis,
+                allFields
+            ) as Date,
             laboratoryConfirmation: {
-                laboratoryConfirmationDate:
-                    getFieldValueById(
-                        diseaseOutbreakEventFieldIds.laboratoryConfirmationDate,
-                        allFields
-                    ) || null,
-                laboratoryConfirmationNA:
-                    getFieldValueById(
-                        diseaseOutbreakEventFieldIds.laboratoryConfirmationNA,
-                        allFields
-                    ) || true,
+                date: getDateFieldValue(
+                    diseaseOutbreakEventFieldIds.laboratoryConfirmationDate,
+                    allFields
+                ) as Date,
+                na: getBooleanFieldValue(
+                    diseaseOutbreakEventFieldIds.laboratoryConfirmationNA,
+                    allFields
+                ),
             },
             appropriateCaseManagement: {
-                appropriateCaseManagementDate:
-                    getFieldValueById(
-                        diseaseOutbreakEventFieldIds.appropriateCaseManagementDate,
-                        allFields
-                    ) || null,
-                appropriateCaseManagementNA:
-                    getFieldValueById(
-                        diseaseOutbreakEventFieldIds.appropriateCaseManagementNA,
-                        allFields
-                    ) || true,
+                date: getDateFieldValue(
+                    diseaseOutbreakEventFieldIds.appropriateCaseManagementDate,
+                    allFields
+                ) as Date,
+                na: getBooleanFieldValue(
+                    diseaseOutbreakEventFieldIds.appropriateCaseManagementNA,
+                    allFields
+                ),
             },
             initiatePublicHealthCounterMeasures: {
-                initiatePublicHealthCounterMeasuresDate:
-                    getFieldValueById(
-                        diseaseOutbreakEventFieldIds.initiatePublicHealthCounterMeasuresDate,
-                        allFields
-                    ) || null,
-                initiatePublicHealthCounterMeasuresNA:
-                    getFieldValueById(
-                        diseaseOutbreakEventFieldIds.initiatePublicHealthCounterMeasuresNA,
-                        allFields
-                    ) || true,
+                date: getDateFieldValue(
+                    diseaseOutbreakEventFieldIds.initiatePublicHealthCounterMeasuresDate,
+                    allFields
+                ) as Date,
+                na: getBooleanFieldValue(
+                    diseaseOutbreakEventFieldIds.initiatePublicHealthCounterMeasuresNA,
+                    allFields
+                ),
             },
             initiateRiskCommunication: {
-                initiateRiskCommunicationDate:
-                    getFieldValueById(
-                        diseaseOutbreakEventFieldIds.initiateRiskCommunicationDate,
-                        allFields
-                    ) || null,
-                initiateRiskCommunicationNA:
-                    getFieldValueById(
-                        diseaseOutbreakEventFieldIds.initiateRiskCommunicationNA,
-                        allFields
-                    ) || true,
+                date: getDateFieldValue(
+                    diseaseOutbreakEventFieldIds.initiateRiskCommunicationDate,
+                    allFields
+                ) as Date,
+                na: getBooleanFieldValue(
+                    diseaseOutbreakEventFieldIds.initiateRiskCommunicationNA,
+                    allFields
+                ),
             },
-            establishCoordination:
-                getFieldValueById(diseaseOutbreakEventFieldIds.establishCoordination, allFields) ||
-                null,
-            responseNarrative:
-                getFieldValueById(diseaseOutbreakEventFieldIds.responseNarrative, allFields) || "",
+            establishCoordination: getDateFieldValue(
+                diseaseOutbreakEventFieldIds.establishCoordination,
+                allFields
+            ) as Date,
+            responseNarrative: getStringFieldValue(
+                diseaseOutbreakEventFieldIds.responseNarrative,
+                allFields
+            ),
         },
-        incidentManagerName:
-            getFieldValueById(diseaseOutbreakEventFieldIds.incidentManagerName, allFields) ||
-            undefined,
-        notes: getFieldValueById(diseaseOutbreakEventFieldIds.notes, allFields) || "",
+        incidentManagerName: getStringFieldValue(
+            diseaseOutbreakEventFieldIds.incidentManagerName,
+            allFields
+        ),
+        notes: getStringFieldValue(diseaseOutbreakEventFieldIds.notes, allFields),
     };
 
     const diseaseOutbreakEventBase: DiseaseOutbreakEventBaseAttrs = {
         id: diseaseOutbreakEvent?.id || "",
+        eventId: diseaseOutbreakEvent?.eventId,
         created: diseaseOutbreakEvent?.created || new Date(),
         lastUpdated: diseaseOutbreakEvent?.lastUpdated || new Date(),
         createdByName: diseaseOutbreakEvent?.createdByName || currentUserName,
         ...diseaseOutbreakEventEditableData,
-    } as unknown as DiseaseOutbreakEventBaseAttrs; // TODO fix this type
-
-    return {
-        ...diseaseOutbreakEventBase,
     };
+
+    return diseaseOutbreakEventBase;
 }