casa-reoc-0.1.0.0: src/ReOC/Fill.hs

{-# LANGUAGE DataKinds #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE LambdaCase #-}
{-# OPTIONS_GHC -Wall #-}

{- | Filling in each form type: checking an unfilled form, and either giving the valid form or every reason that
it is not valid, each at the path of its field (@fillT@ from the whole form, @fillTAt@ from a path); and
@unfillT@, the unfilled form of a valid form, which @fillT@ gives back.
-}
module ReOC.Fill (
  fillPerson,
  fillPersonAt,
  unfillPerson,
  fillAddress,
  fillAddressAt,
  unfillAddress,
  fillOperationalHeadquarters,
  fillOperationalHeadquartersAt,
  unfillOperationalHeadquarters,
  fillCompany,
  fillCompanyAt,
  unfillCompany,
  fillFlightTermination,
  fillFlightTerminationAt,
  unfillFlightTermination,
  fillEmergencyAction,
  fillEmergencyActionAt,
  unfillEmergencyAction,
  fillRPAType,
  fillRPATypeAt,
  unfillRPAType,
  fillEquipment,
  fillEquipmentAt,
  unfillEquipment,
  fillAircraft,
  fillAircraftAt,
  unfillAircraft,
  fillOperatedType,
  fillOperatedTypeAt,
  unfillOperatedType,
  fillRePLOrigin,
  fillRePLOriginAt,
  unfillRePLOrigin,
  fillOtherReOCRoles,
  fillOtherReOCRolesAt,
  unfillOtherReOCRoles,
  fillNominee,
  fillNomineeAt,
  unfillNominee,
  fillChiefExecutive,
  fillChiefExecutiveAt,
  unfillChiefExecutive,
  fillCRPNominee,
  fillCRPNomineeAt,
  unfillCRPNominee,
  fillChiefPilot,
  fillChiefPilotAt,
  unfillChiefPilot,
  fillMCNominee,
  fillMCNomineeAt,
  unfillMCNominee,
  fillKeyPersonnel,
  fillKeyPersonnelAt,
  unfillKeyPersonnel,
  fillOperator,
  fillOperatorAt,
  unfillOperator,
  fillContactPerson,
  fillContactPersonAt,
  unfillContactPerson,
  fillPrimaryContact,
  fillPrimaryContactAt,
  unfillPrimaryContact,
  fillHistoryAnswer,
  fillHistoryAnswerAt,
  unfillHistoryAnswer,
  fillPersonnelHistory,
  fillPersonnelHistoryAt,
  unfillPersonnelHistory,
  fillRegulatoryAction,
  fillRegulatoryActionAt,
  unfillRegulatoryAction,
  fillRegulatoryHistory,
  fillRegulatoryHistoryAt,
  unfillRegulatoryHistory,
  fillDeclarant,
  fillDeclarantAt,
  unfillDeclarant,
  fillDeclaration,
  fillDeclarationAt,
  unfillDeclaration,
  fillWrittenSignature,
  fillWrittenSignatureAt,
  unfillWrittenSignature,
  fillApplicationForm,
  fillApplicationFormAt,
  unfillApplicationForm,
  fillVersion,
  fillVersionAt,
  unfillVersion,
  fillFirstIssue,
  fillFirstIssueAt,
  unfillFirstIssue,
  fillRevision,
  fillRevisionAt,
  unfillRevision,
  fillPolicies,
  fillPoliciesAt,
  unfillPolicies,
  fillRiskAssessment,
  fillRiskAssessmentAt,
  unfillRiskAssessment,
  fillRisk,
  fillRiskAt,
  unfillRisk,
  fillOperationsManual,
  fillOperationsManualAt,
  unfillOperationsManual,
  fillCRINominee,
  fillCRINomineeAt,
  unfillCRINominee,
  fillRePLHolding,
  fillRePLHoldingAt,
  unfillRePLHolding,
  fillTeachingQualification,
  fillTeachingQualificationAt,
  unfillTeachingQualification,
  fillOperationalExperience,
  fillOperationalExperienceAt,
  unfillOperationalExperience,
  fillTrainingCourse,
  fillTrainingCourseAt,
  unfillTrainingCourse,
  fillTrainingArrangements,
  fillTrainingArrangementsAt,
  unfillTrainingArrangements,
  fillTrainingMaterial,
  fillTrainingMaterialAt,
  unfillTrainingMaterial,
  fillReOC,
  fillReOCAt,
  unfillReOC,
) where

import Control.Lens (preview, review)
import Data.Foldable (toList)
import Data.List.NonEmpty (NonEmpty)
import Data.Validation (Validation, toEither)
import ReOC.Input
import ReOC.Model

-- | Fills in @Person'@ from the whole form.
fillPerson :: (AsReOCError e) => UnfilledPerson -> Either (NonEmpty e) Person
fillPerson =
  toEither . fillPersonAt []

-- | Fills in @Person'@ at a path.
fillPersonAt :: (AsReOCError e) => [Step] -> UnfilledPerson -> Validation (NonEmpty e) Person
fillPersonAt p (Person' x1 x2 x3 x4) =
  Person'
    <$> required (checked (preview _FormText) InvalidFormText) (at p PersonFullName) x1
    <*> required (checked (preview _ARN) InvalidARN) (at p PersonArn) x2
    <*> required (checked parsePhoneNumber InvalidPhoneNumber) (at p PersonPhoneNumber) x3
    <*> required (checked (preview _EmailAddress) InvalidEmailAddress) (at p PersonEmailAddress) x4

-- | The unfilled form of a valid @Person'@.
unfillPerson :: Person -> UnfilledPerson
unfillPerson (Person' x1 x2 x3 x4) =
  Person'
    (Just (review _FormText x1))
    (Just (review _ARN x2))
    (Just (review _PhoneNumber x3))
    (Just (review _EmailAddress x4))

-- | Fills in @Address'@ from the whole form.
fillAddress :: (AsReOCError e) => UnfilledAddress -> Either (NonEmpty e) Address
fillAddress =
  toEither . fillAddressAt []

-- | Fills in @Address'@ at a path.
fillAddressAt :: (AsReOCError e) => [Step] -> UnfilledAddress -> Validation (NonEmpty e) Address
fillAddressAt p (Address' x1 x2 x3 x4) =
  Address'
    <$> nonEmptyElements (checked (preview _Text1) InvalidText1) (at p AddressStreetAddress) x1
    <*> required (checked (preview _Text1) InvalidText1) (at p AddressSuburb) x2
    <*> required accepted (at p AddressStateOrTerritory) x3
    <*> required (checked (preview _Postcode) InvalidPostcode) (at p AddressPostcode) x4

-- | The unfilled form of a valid @Address'@.
unfillAddress :: Address -> UnfilledAddress
unfillAddress (Address' x1 x2 x3 x4) =
  Address'
    (map (review _Text1) (toList x1))
    (Just (review _Text1 x2))
    (Just x3)
    (Just (review _Postcode x4))

-- | Fills in @OperationalHeadquarters'@ from the whole form.
fillOperationalHeadquarters :: (AsReOCError e) => UnfilledOperationalHeadquarters -> Either (NonEmpty e) OperationalHeadquarters
fillOperationalHeadquarters =
  toEither . fillOperationalHeadquartersAt []

-- | Fills in @OperationalHeadquarters'@ at a path.
fillOperationalHeadquartersAt :: (AsReOCError e) => [Step] -> UnfilledOperationalHeadquarters -> Validation (NonEmpty e) OperationalHeadquarters
fillOperationalHeadquartersAt p = \case
  AtRegisteredOffice -> pure AtRegisteredOffice
  OperationalHeadquartersAddress x -> OperationalHeadquartersAddress <$> fillAddressAt (at p OperationalHeadquartersOperationalHeadquartersAddress) x

-- | The unfilled form of a valid @OperationalHeadquarters'@.
unfillOperationalHeadquarters :: OperationalHeadquarters -> UnfilledOperationalHeadquarters
unfillOperationalHeadquarters = \case
  AtRegisteredOffice -> AtRegisteredOffice
  OperationalHeadquartersAddress x -> OperationalHeadquartersAddress (unfillAddress x)

-- | Fills in @Company'@ from the whole form.
fillCompany :: (AsReOCError e) => UnfilledCompany -> Either (NonEmpty e) Company
fillCompany =
  toEither . fillCompanyAt []

-- | Fills in @Company'@ at a path.
fillCompanyAt :: (AsReOCError e) => [Step] -> UnfilledCompany -> Validation (NonEmpty e) Company
fillCompanyAt p (Company' x1 x2 x3 x4 x5 x6 x7 x8) =
  Company'
    <$> required (checked (preview _FormText) InvalidFormText) (at p CompanyCompanyName) x1
    <*> required (checked parseABN InvalidABN) (at p CompanyAbn) x2
    <*> required (checked (preview _ARN) InvalidARN) (at p CompanyArn) x3
    <*> fillAddressAt (at p CompanyRegisteredOffice) x4
    <*> required fillOperationalHeadquartersAt (at p CompanyOperationalHeadquarters) x5
    <*> required (checked parsePhoneNumber InvalidPhoneNumber) (at p CompanyPhoneNumber) x6
    <*> required (checked (preview _EmailAddress) InvalidEmailAddress) (at p CompanyEmailAddress) x7
    <*> optional (checked (preview _FormText) InvalidFormText) (at p CompanyBusinessName) x8

-- | The unfilled form of a valid @Company'@.
unfillCompany :: Company -> UnfilledCompany
unfillCompany (Company' x1 x2 x3 x4 x5 x6 x7 x8) =
  Company'
    (Just (review _FormText x1))
    (Just (review _ABN x2))
    (Just (review _ARN x3))
    (unfillAddress x4)
    (Just (unfillOperationalHeadquarters x5))
    (Just (review _PhoneNumber x6))
    (Just (review _EmailAddress x7))
    (fmap (review _FormText) x8)

-- | Fills in @FlightTermination'@ from the whole form.
fillFlightTermination :: (AsReOCError e) => UnfilledFlightTermination -> Either (NonEmpty e) FlightTermination
fillFlightTermination =
  toEither . fillFlightTerminationAt []

-- | Fills in @FlightTermination'@ at a path.
fillFlightTerminationAt :: (AsReOCError e) => [Step] -> UnfilledFlightTermination -> Validation (NonEmpty e) FlightTermination
fillFlightTerminationAt p = \case
  NoFlightTerminationSystem -> pure NoFlightTerminationSystem
  FlightTerminationSystem x -> FlightTerminationSystem <$> required (checked (preview _Text1) InvalidText1) (at p FlightTerminationFlightTerminationSystem) x

-- | The unfilled form of a valid @FlightTermination'@.
unfillFlightTermination :: FlightTermination -> UnfilledFlightTermination
unfillFlightTermination = \case
  NoFlightTerminationSystem -> NoFlightTerminationSystem
  FlightTerminationSystem x -> FlightTerminationSystem (Just (review _Text1 x))

-- | Fills in @EmergencyAction'@ from the whole form.
fillEmergencyAction :: (AsReOCError e) => UnfilledEmergencyAction -> Either (NonEmpty e) EmergencyAction
fillEmergencyAction =
  toEither . fillEmergencyActionAt []

-- | Fills in @EmergencyAction'@ at a path.
fillEmergencyActionAt :: (AsReOCError e) => [Step] -> UnfilledEmergencyAction -> Validation (NonEmpty e) EmergencyAction
fillEmergencyActionAt p (EmergencyAction' x1 x2 x3) =
  EmergencyAction'
    <$> required (checked (preview _Text1) InvalidText1) (at p EmergencyActionSituation) x1
    <*> required (checked (preview _Text1) InvalidText1) (at p EmergencyActionResponse) x2
    <*> elements (checked (preview _Text1) InvalidText1) (at p EmergencyActionActionSteps) x3

-- | The unfilled form of a valid @EmergencyAction'@.
unfillEmergencyAction :: EmergencyAction -> UnfilledEmergencyAction
unfillEmergencyAction (EmergencyAction' x1 x2 x3) =
  EmergencyAction'
    (Just (review _Text1 x1))
    (Just (review _Text1 x2))
    (fmap (review _Text1) x3)

-- | Fills in @RPAType'@ from the whole form.
fillRPAType :: (AsReOCError e) => UnfilledRPAType -> Either (NonEmpty e) RPAType
fillRPAType =
  toEither . fillRPATypeAt []

-- | Fills in @RPAType'@ at a path.
fillRPATypeAt :: (AsReOCError e) => [Step] -> UnfilledRPAType -> Validation (NonEmpty e) RPAType
fillRPATypeAt p (RPAType' x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12) =
  RPAType'
    <$> required (checked (preview _Text1) InvalidText1) (at p RPATypeRpaMake) x1
    <*> required (checked (preview _Text1) InvalidText1) (at p RPATypeRpaModel) x2
    <*> required (checked (preview _FormText) InvalidFormText) (at p RPATypeShortName) x3
    <*> required accepted (at p RPATypeCategory) x4
    <*> required (checked (preview _GrossWeight) InvalidGrossWeight) (at p RPATypeMaximumGrossWeight) x5
    <*> required (checked (preview _Text1) InvalidText1) (at p RPATypeUserManual) x6
    <*> required accepted (at p RPATypeTransponderCarriage) x7
    <*> required fillFlightTerminationAt (at p RPATypeFlightTermination) x8
    <*> nonEmptyElements (checked (preview _Text1) InvalidText1) (at p RPATypeInspectionItems) x9
    <*> elements (checked (preview _Text1) InvalidText1) (at p RPATypeBeforeFlight) x10
    <*> optional (checked (preview _Text1) InvalidText1) (at p RPATypeBatteryWarnings) x11
    <*> elements fillEmergencyActionAt (at p RPATypeEmergencyActions) x12

-- | The unfilled form of a valid @RPAType'@.
unfillRPAType :: RPAType -> UnfilledRPAType
unfillRPAType (RPAType' x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12) =
  RPAType'
    (Just (review _Text1 x1))
    (Just (review _Text1 x2))
    (Just (review _FormText x3))
    (Just x4)
    (Just (review _GrossWeight x5))
    (Just (review _Text1 x6))
    (Just x7)
    (Just (unfillFlightTermination x8))
    (map (review _Text1) (toList x9))
    (fmap (review _Text1) x10)
    (fmap (review _Text1) x11)
    (fmap unfillEmergencyAction x12)

-- | Fills in @Equipment'@ from the whole form.
fillEquipment :: (AsReOCError e) => UnfilledEquipment -> Either (NonEmpty e) Equipment
fillEquipment =
  toEither . fillEquipmentAt []

-- | Fills in @Equipment'@ at a path.
fillEquipmentAt :: (AsReOCError e) => [Step] -> UnfilledEquipment -> Validation (NonEmpty e) Equipment
fillEquipmentAt p (Equipment' x1 x2) =
  Equipment'
    <$> required (checked (preview _Text1) InvalidText1) (at p EquipmentEquipmentDescription) x1
    <*> required (checked (preview _Text1) InvalidText1) (at p EquipmentSerialNumber) x2

-- | The unfilled form of a valid @Equipment'@.
unfillEquipment :: Equipment -> UnfilledEquipment
unfillEquipment (Equipment' x1 x2) =
  Equipment'
    (Just (review _Text1 x1))
    (Just (review _Text1 x2))

-- | Fills in @Aircraft'@ from the whole form.
fillAircraft :: (AsReOCError e) => UnfilledAircraft -> Either (NonEmpty e) Aircraft
fillAircraft =
  toEither . fillAircraftAt []

-- | Fills in @Aircraft'@ at a path.
fillAircraftAt :: (AsReOCError e) => [Step] -> UnfilledAircraft -> Validation (NonEmpty e) Aircraft
fillAircraftAt p (Aircraft' x1 x2) =
  Aircraft'
    <$> required (checked (preview _Text1) InvalidText1) (at p AircraftSerialNumber) x1
    <*> elements fillEquipmentAt (at p AircraftAssociatedEquipment) x2

-- | The unfilled form of a valid @Aircraft'@.
unfillAircraft :: Aircraft -> UnfilledAircraft
unfillAircraft (Aircraft' x1 x2) =
  Aircraft'
    (Just (review _Text1 x1))
    (fmap unfillEquipment x2)

-- | Fills in @OperatedType'@ from the whole form.
fillOperatedType :: (AsReOCError e) => UnfilledOperatedType -> Either (NonEmpty e) OperatedType
fillOperatedType =
  toEither . fillOperatedTypeAt []

-- | Fills in @OperatedType'@ at a path.
fillOperatedTypeAt :: (AsReOCError e) => [Step] -> UnfilledOperatedType -> Validation (NonEmpty e) OperatedType
fillOperatedTypeAt p (OperatedType' x1 x2) =
  OperatedType'
    <$> fillRPATypeAt (at p OperatedTypeRpaType) x1
    <*> nonEmptyElements fillAircraftAt (at p OperatedTypeAirframes) x2

-- | The unfilled form of a valid @OperatedType'@.
unfillOperatedType :: OperatedType -> UnfilledOperatedType
unfillOperatedType (OperatedType' x1 x2) =
  OperatedType'
    (unfillRPAType x1)
    (map unfillAircraft (toList x2))

-- | Fills in @RePLOrigin'@ from the whole form.
fillRePLOrigin :: (AsReOCError e) => UnfilledRePLOrigin -> Either (NonEmpty e) RePLOrigin
fillRePLOrigin =
  toEither . fillRePLOriginAt []

-- | Fills in @RePLOrigin'@ at a path.
fillRePLOriginAt :: (AsReOCError e) => [Step] -> UnfilledRePLOrigin -> Validation (NonEmpty e) RePLOrigin
fillRePLOriginAt p = \case
  PPLTheory -> pure PPLTheory
  RePLTraining x -> RePLTraining <$> required (checked (preview _FormText) InvalidFormText) (at p RePLOriginRePLTrainingOrganisation) x

-- | The unfilled form of a valid @RePLOrigin'@.
unfillRePLOrigin :: RePLOrigin -> UnfilledRePLOrigin
unfillRePLOrigin = \case
  PPLTheory -> PPLTheory
  RePLTraining x -> RePLTraining (Just (review _FormText x))

-- | Fills in @OtherReOCRoles'@ from the whole form.
fillOtherReOCRoles :: (AsReOCError e) => UnfilledOtherReOCRoles -> Either (NonEmpty e) OtherReOCRoles
fillOtherReOCRoles =
  toEither . fillOtherReOCRolesAt []

-- | Fills in @OtherReOCRoles'@ at a path.
fillOtherReOCRolesAt :: (AsReOCError e) => [Step] -> UnfilledOtherReOCRoles -> Validation (NonEmpty e) OtherReOCRoles
fillOtherReOCRolesAt p = \case
  NoOtherReOCRoles -> pure NoOtherReOCRoles
  OtherReOCRolesHeld x -> OtherReOCRolesHeld <$> required (checked (preview _FormText) InvalidFormText) (at p OtherReOCRolesOtherReOCRolesHeld) x

-- | The unfilled form of a valid @OtherReOCRoles'@.
unfillOtherReOCRoles :: OtherReOCRoles -> UnfilledOtherReOCRoles
unfillOtherReOCRoles = \case
  NoOtherReOCRoles -> NoOtherReOCRoles
  OtherReOCRolesHeld x -> OtherReOCRolesHeld (Just (review _FormText x))

-- | Fills in @Nominee'@ from the whole form.
fillNominee :: (AsReOCError e) => UnfilledNominee -> Either (NonEmpty e) Nominee
fillNominee =
  toEither . fillNomineeAt []

-- | Fills in @Nominee'@ at a path.
fillNomineeAt :: (AsReOCError e) => [Step] -> UnfilledNominee -> Validation (NonEmpty e) Nominee
fillNomineeAt p (Nominee' x1 x2 x3) =
  Nominee'
    <$> fillPersonAt (at p NomineePerson) x1
    <*> elements (checked (preview _Text1) InvalidText1) (at p NomineeOtherQualifications) x2
    <*> required (checked (preview _Text1) InvalidText1) (at p NomineeAviationExperience) x3

-- | The unfilled form of a valid @Nominee'@.
unfillNominee :: Nominee -> UnfilledNominee
unfillNominee (Nominee' x1 x2 x3) =
  Nominee'
    (unfillPerson x1)
    (fmap (review _Text1) x2)
    (Just (review _Text1 x3))

-- | Fills in @ChiefExecutive'@ from the whole form.
fillChiefExecutive :: (AsReOCError e) => UnfilledChiefExecutive -> Either (NonEmpty e) ChiefExecutive
fillChiefExecutive =
  toEither . fillChiefExecutiveAt []

-- | Fills in @ChiefExecutive'@ at a path.
fillChiefExecutiveAt :: (AsReOCError e) => [Step] -> UnfilledChiefExecutive -> Validation (NonEmpty e) ChiefExecutive
fillChiefExecutiveAt p (ChiefExecutive' x1 x2 x3) =
  ChiefExecutive'
    <$> fillNomineeAt (at p ChiefExecutiveNominee) x1
    <*> required accepted (at p ChiefExecutiveDirectorStatus) x2
    <*> optional (checked (preview _FormText) InvalidFormText) (at p ChiefExecutiveManagementExperience) x3

-- | The unfilled form of a valid @ChiefExecutive'@.
unfillChiefExecutive :: ChiefExecutive -> UnfilledChiefExecutive
unfillChiefExecutive (ChiefExecutive' x1 x2 x3) =
  ChiefExecutive'
    (unfillNominee x1)
    (Just x2)
    (fmap (review _FormText) x3)

-- | Fills in @CRPNominee'@ from the whole form.
fillCRPNominee :: (AsReOCError e) => UnfilledCRPNominee -> Either (NonEmpty e) CRPNominee
fillCRPNominee =
  toEither . fillCRPNomineeAt []

-- | Fills in @CRPNominee'@ at a path.
fillCRPNomineeAt :: (AsReOCError e) => [Step] -> UnfilledCRPNominee -> Validation (NonEmpty e) CRPNominee
fillCRPNomineeAt p = \case
  CRPIsCEO -> pure CRPIsCEO
  CRPNominated x -> CRPNominated <$> fillNomineeAt (at p CRPNomineeCrpNominated) x

-- | The unfilled form of a valid @CRPNominee'@.
unfillCRPNominee :: CRPNominee -> UnfilledCRPNominee
unfillCRPNominee = \case
  CRPIsCEO -> CRPIsCEO
  CRPNominated x -> CRPNominated (unfillNominee x)

-- | Fills in @ChiefPilot'@ from the whole form.
fillChiefPilot :: (AsReOCError e) => UnfilledChiefPilot -> Either (NonEmpty e) ChiefPilot
fillChiefPilot =
  toEither . fillChiefPilotAt []

-- | Fills in @ChiefPilot'@ at a path.
fillChiefPilotAt :: (AsReOCError e) => [Step] -> UnfilledChiefPilot -> Validation (NonEmpty e) ChiefPilot
fillChiefPilotAt p (ChiefPilot' x1 x2 x3 x4 x5) =
  ChiefPilot'
    <$> required fillCRPNomineeAt (at p ChiefPilotCrpNominee) x1
    <*> required fillRePLOriginAt (at p ChiefPilotRePLOrigin) x2
    <*> required (checked (preview _FormText) InvalidFormText) (at p ChiefPilotRpaHistory) x3
    <*> required fillOtherReOCRolesAt (at p ChiefPilotOtherReOCRoles) x4
    <*> required accepted (at p ChiefPilotRadio) x5

-- | The unfilled form of a valid @ChiefPilot'@.
unfillChiefPilot :: ChiefPilot -> UnfilledChiefPilot
unfillChiefPilot (ChiefPilot' x1 x2 x3 x4 x5) =
  ChiefPilot'
    (Just (unfillCRPNominee x1))
    (Just (unfillRePLOrigin x2))
    (Just (review _FormText x3))
    (Just (unfillOtherReOCRoles x4))
    (Just x5)

-- | Fills in @MCNominee'@ from the whole form.
fillMCNominee :: (AsReOCError e) => UnfilledMCNominee -> Either (NonEmpty e) MCNominee
fillMCNominee =
  toEither . fillMCNomineeAt []

-- | Fills in @MCNominee'@ at a path.
fillMCNomineeAt :: (AsReOCError e) => [Step] -> UnfilledMCNominee -> Validation (NonEmpty e) MCNominee
fillMCNomineeAt p = \case
  MCIsCEO -> pure MCIsCEO
  MCIsCRP -> pure MCIsCRP
  MCNominated x -> MCNominated <$> fillNomineeAt (at p MCNomineeMcNominated) x

-- | The unfilled form of a valid @MCNominee'@.
unfillMCNominee :: MCNominee -> UnfilledMCNominee
unfillMCNominee = \case
  MCIsCEO -> MCIsCEO
  MCIsCRP -> MCIsCRP
  MCNominated x -> MCNominated (unfillNominee x)

-- | Fills in @KeyPersonnel'@ from the whole form.
fillKeyPersonnel :: (AsReOCError e) => UnfilledKeyPersonnel -> Either (NonEmpty e) KeyPersonnel
fillKeyPersonnel =
  toEither . fillKeyPersonnelAt []

-- | Fills in @KeyPersonnel'@ at a path.
fillKeyPersonnelAt :: (AsReOCError e) => [Step] -> UnfilledKeyPersonnel -> Validation (NonEmpty e) KeyPersonnel
fillKeyPersonnelAt p (KeyPersonnel' x1 x2 x3) =
  KeyPersonnel'
    <$> fillChiefExecutiveAt (at p KeyPersonnelChiefExecutive) x1
    <*> fillChiefPilotAt (at p KeyPersonnelChiefPilot) x2
    <*> required fillMCNomineeAt (at p KeyPersonnelMcNominee) x3

-- | The unfilled form of a valid @KeyPersonnel'@.
unfillKeyPersonnel :: KeyPersonnel -> UnfilledKeyPersonnel
unfillKeyPersonnel (KeyPersonnel' x1 x2 x3) =
  KeyPersonnel'
    (unfillChiefExecutive x1)
    (unfillChiefPilot x2)
    (Just (unfillMCNominee x3))

-- | Fills in @Operator'@ from the whole form.
fillOperator :: (AsReOCError e) => UnfilledOperator -> Either (NonEmpty e) Operator
fillOperator =
  toEither . fillOperatorAt []

-- | Fills in @Operator'@ at a path.
fillOperatorAt :: (AsReOCError e) => [Step] -> UnfilledOperator -> Validation (NonEmpty e) Operator
fillOperatorAt p (Operator' x1 x2 x3) =
  Operator'
    <$> fillCompanyAt (at p OperatorCompany) x1
    <*> fillKeyPersonnelAt (at p OperatorKeyPersonnel) x2
    <*> someElements fillOperatedTypeAt (at p OperatorFleet) x3

-- | The unfilled form of a valid @Operator'@.
unfillOperator :: Operator -> UnfilledOperator
unfillOperator (Operator' x1 x2 x3) =
  Operator'
    (unfillCompany x1)
    (unfillKeyPersonnel x2)
    (map unfillOperatedType (toList (someNonEmpty x3)))

-- | Fills in @ContactPerson'@ from the whole form.
fillContactPerson :: (AsReOCError e) => UnfilledContactPerson -> Either (NonEmpty e) ContactPerson
fillContactPerson =
  toEither . fillContactPersonAt []

-- | Fills in @ContactPerson'@ at a path.
fillContactPersonAt :: (AsReOCError e) => [Step] -> UnfilledContactPerson -> Validation (NonEmpty e) ContactPerson
fillContactPersonAt p (ContactPerson' x1 x2 x3 x4) =
  ContactPerson'
    <$> required (checked (preview _FormText) InvalidFormText) (at p ContactPersonFullName) x1
    <*> required (checked (preview _FormText) InvalidFormText) (at p ContactPersonPosition) x2
    <*> required (checked parsePhoneNumber InvalidPhoneNumber) (at p ContactPersonPhoneNumber) x3
    <*> required (checked (preview _EmailAddress) InvalidEmailAddress) (at p ContactPersonEmailAddress) x4

-- | The unfilled form of a valid @ContactPerson'@.
unfillContactPerson :: ContactPerson -> UnfilledContactPerson
unfillContactPerson (ContactPerson' x1 x2 x3 x4) =
  ContactPerson'
    (Just (review _FormText x1))
    (Just (review _FormText x2))
    (Just (review _PhoneNumber x3))
    (Just (review _EmailAddress x4))

-- | Fills in @PrimaryContact'@ from the whole form.
fillPrimaryContact :: (AsReOCError e) => UnfilledPrimaryContact -> Either (NonEmpty e) PrimaryContact
fillPrimaryContact =
  toEither . fillPrimaryContactAt []

-- | Fills in @PrimaryContact'@ at a path.
fillPrimaryContactAt :: (AsReOCError e) => [Step] -> UnfilledPrimaryContact -> Validation (NonEmpty e) PrimaryContact
fillPrimaryContactAt p = \case
  ApplicantIsPrimaryContact -> pure ApplicantIsPrimaryContact
  PrimaryContactPerson x -> PrimaryContactPerson <$> fillContactPersonAt (at p PrimaryContactPrimaryContactPerson) x

-- | The unfilled form of a valid @PrimaryContact'@.
unfillPrimaryContact :: PrimaryContact -> UnfilledPrimaryContact
unfillPrimaryContact = \case
  ApplicantIsPrimaryContact -> ApplicantIsPrimaryContact
  PrimaryContactPerson x -> PrimaryContactPerson (unfillContactPerson x)

-- | Fills in @HistoryAnswer'@ from the whole form.
fillHistoryAnswer :: (AsReOCError e) => UnfilledHistoryAnswer -> Either (NonEmpty e) HistoryAnswer
fillHistoryAnswer =
  toEither . fillHistoryAnswerAt []

-- | Fills in @HistoryAnswer'@ at a path.
fillHistoryAnswerAt :: (AsReOCError e) => [Step] -> UnfilledHistoryAnswer -> Validation (NonEmpty e) HistoryAnswer
fillHistoryAnswerAt p = \case
  NoHistory -> pure NoHistory
  HistoryDisclosed x -> HistoryDisclosed <$> required (checked (preview _FormText) InvalidFormText) (at p HistoryAnswerHistoryDisclosed) x

-- | The unfilled form of a valid @HistoryAnswer'@.
unfillHistoryAnswer :: HistoryAnswer -> UnfilledHistoryAnswer
unfillHistoryAnswer = \case
  NoHistory -> NoHistory
  HistoryDisclosed x -> HistoryDisclosed (Just (review _FormText x))

-- | Fills in @PersonnelHistory'@ from the whole form.
fillPersonnelHistory :: (AsReOCError e) => UnfilledPersonnelHistory -> Either (NonEmpty e) PersonnelHistory
fillPersonnelHistory =
  toEither . fillPersonnelHistoryAt []

-- | Fills in @PersonnelHistory'@ at a path.
fillPersonnelHistoryAt :: (AsReOCError e) => [Step] -> UnfilledPersonnelHistory -> Validation (NonEmpty e) PersonnelHistory
fillPersonnelHistoryAt p (PersonnelHistory' x1 x2 x3 x4) =
  PersonnelHistory'
    <$> required fillHistoryAnswerAt (at p PersonnelHistoryActionTaken) x1
    <*> required fillHistoryAnswerAt (at p PersonnelHistoryTransportLicenceRefused) x2
    <*> required fillHistoryAnswerAt (at p PersonnelHistoryCriminalConviction) x3
    <*> required fillHistoryAnswerAt (at p PersonnelHistorySuspensionPending) x4

-- | The unfilled form of a valid @PersonnelHistory'@.
unfillPersonnelHistory :: PersonnelHistory -> UnfilledPersonnelHistory
unfillPersonnelHistory (PersonnelHistory' x1 x2 x3 x4) =
  PersonnelHistory'
    (Just (unfillHistoryAnswer x1))
    (Just (unfillHistoryAnswer x2))
    (Just (unfillHistoryAnswer x3))
    (Just (unfillHistoryAnswer x4))

-- | Fills in @RegulatoryAction'@ from the whole form.
fillRegulatoryAction :: (AsReOCError e) => UnfilledRegulatoryAction -> Either (NonEmpty e) RegulatoryAction
fillRegulatoryAction =
  toEither . fillRegulatoryActionAt []

-- | Fills in @RegulatoryAction'@ at a path.
fillRegulatoryActionAt :: (AsReOCError e) => [Step] -> UnfilledRegulatoryAction -> Validation (NonEmpty e) RegulatoryAction
fillRegulatoryActionAt p (RegulatoryAction' x1 x2 x3 x4 x5) =
  RegulatoryAction'
    <$> required accepted (at p RegulatoryActionReocSuspendedOrCancelled) x1
    <*> required (checked (preview _FormText) InvalidFormText) (at p RegulatoryActionTypeOfAction) x2
    <*> required (checked (preview _FormText) InvalidFormText) (at p RegulatoryActionAuthorisationAction) x3
    <*> required accepted (at p RegulatoryActionActionDate) x4
    <*> required (checked (preview _FormText) InvalidFormText) (at p RegulatoryActionActionDetails) x5

-- | The unfilled form of a valid @RegulatoryAction'@.
unfillRegulatoryAction :: RegulatoryAction -> UnfilledRegulatoryAction
unfillRegulatoryAction (RegulatoryAction' x1 x2 x3 x4 x5) =
  RegulatoryAction'
    (Just x1)
    (Just (review _FormText x2))
    (Just (review _FormText x3))
    (Just x4)
    (Just (review _FormText x5))

-- | Fills in @RegulatoryHistory'@ from the whole form.
fillRegulatoryHistory :: (AsReOCError e) => UnfilledRegulatoryHistory -> Either (NonEmpty e) RegulatoryHistory
fillRegulatoryHistory =
  toEither . fillRegulatoryHistoryAt []

-- | Fills in @RegulatoryHistory'@ at a path.
fillRegulatoryHistoryAt :: (AsReOCError e) => [Step] -> UnfilledRegulatoryHistory -> Validation (NonEmpty e) RegulatoryHistory
fillRegulatoryHistoryAt p = \case
  NoRegulatoryAction -> pure NoRegulatoryAction
  RegulatoryActionTaken x -> RegulatoryActionTaken <$> fillRegulatoryActionAt (at p RegulatoryHistoryRegulatoryActionTaken) x

-- | The unfilled form of a valid @RegulatoryHistory'@.
unfillRegulatoryHistory :: RegulatoryHistory -> UnfilledRegulatoryHistory
unfillRegulatoryHistory = \case
  NoRegulatoryAction -> NoRegulatoryAction
  RegulatoryActionTaken x -> RegulatoryActionTaken (unfillRegulatoryAction x)

-- | Fills in @Declarant'@ from the whole form.
fillDeclarant :: (AsReOCError e) => UnfilledDeclarant -> Either (NonEmpty e) Declarant
fillDeclarant =
  toEither . fillDeclarantAt []

-- | Fills in @Declarant'@ at a path.
fillDeclarantAt :: (AsReOCError e) => [Step] -> UnfilledDeclarant -> Validation (NonEmpty e) Declarant
fillDeclarantAt p (Declarant' x1 x2) =
  Declarant'
    <$> required (checked (preview _FormText) InvalidFormText) (at p DeclarantFullName) x1
    <*> required (checked (preview _FormText) InvalidFormText) (at p DeclarantRole) x2

-- | The unfilled form of a valid @Declarant'@.
unfillDeclarant :: Declarant -> UnfilledDeclarant
unfillDeclarant (Declarant' x1 x2) =
  Declarant'
    (Just (review _FormText x1))
    (Just (review _FormText x2))

-- | Fills in @Declaration'@ from the whole form.
fillDeclaration :: (AsReOCError e) => UnfilledDeclaration -> Either (NonEmpty e) Declaration
fillDeclaration =
  toEither . fillDeclarationAt []

-- | Fills in @Declaration'@ at a path.
fillDeclarationAt :: (AsReOCError e) => [Step] -> UnfilledDeclaration -> Validation (NonEmpty e) Declaration
fillDeclarationAt p = \case
  DeclaredByCEO -> pure DeclaredByCEO
  DeclaredByResponsibleManager x -> DeclaredByResponsibleManager <$> required (checked (preview _FormText) InvalidFormText) (at p DeclarationDeclaredByResponsibleManager) x
  DeclaredByAgent x -> DeclaredByAgent <$> required (checked (preview _FormText) InvalidFormText) (at p DeclarationDeclaredByAgent) x
  DeclaredByOther x -> DeclaredByOther <$> fillDeclarantAt (at p DeclarationDeclaredByOther) x

-- | The unfilled form of a valid @Declaration'@.
unfillDeclaration :: Declaration -> UnfilledDeclaration
unfillDeclaration = \case
  DeclaredByCEO -> DeclaredByCEO
  DeclaredByResponsibleManager x -> DeclaredByResponsibleManager (Just (review _FormText x))
  DeclaredByAgent x -> DeclaredByAgent (Just (review _FormText x))
  DeclaredByOther x -> DeclaredByOther (unfillDeclarant x)

-- | Fills in @WrittenSignature'@ from the whole form.
fillWrittenSignature :: (AsReOCError e) => UnfilledWrittenSignature -> Either (NonEmpty e) WrittenSignature
fillWrittenSignature =
  toEither . fillWrittenSignatureAt []

-- | Fills in @WrittenSignature'@ at a path.
fillWrittenSignatureAt :: (AsReOCError e) => [Step] -> UnfilledWrittenSignature -> Validation (NonEmpty e) WrittenSignature
fillWrittenSignatureAt p = \case
  WrittenSignatureImage x -> WrittenSignatureImage <$> required accepted (at p WrittenSignatureWrittenSignatureImage) x
  WrittenSignatureFile x -> WrittenSignatureFile <$> required accepted (at p WrittenSignatureWrittenSignatureFile) x

-- | The unfilled form of a valid @WrittenSignature'@.
unfillWrittenSignature :: WrittenSignature -> UnfilledWrittenSignature
unfillWrittenSignature = \case
  WrittenSignatureImage x -> WrittenSignatureImage (Just x)
  WrittenSignatureFile x -> WrittenSignatureFile (Just x)

-- | Fills in @ApplicationForm'@ from the whole form.
fillApplicationForm :: (AsReOCError e) => UnfilledApplicationForm -> Either (NonEmpty e) ApplicationForm
fillApplicationForm =
  toEither . fillApplicationFormAt []

-- | Fills in @ApplicationForm'@ at a path.
fillApplicationFormAt :: (AsReOCError e) => [Step] -> UnfilledApplicationForm -> Validation (NonEmpty e) ApplicationForm
fillApplicationFormAt p (ApplicationForm' x1 x2 x3 x4 x5 x6 x7) =
  ApplicationForm'
    <$> required fillPrimaryContactAt (at p ApplicationFormPrimaryContact) x1
    <*> fillPersonnelHistoryAt (at p ApplicationFormPersonnelHistory) x2
    <*> required fillRegulatoryHistoryAt (at p ApplicationFormRegulatoryHistory) x3
    <*> required accepted (at p ApplicationFormProceduresLibrary) x4
    <*> atMostElements (checked (preview _FormText) InvalidFormText) (at p ApplicationFormOtherDocuments) x5
    <*> required fillDeclarationAt (at p ApplicationFormDeclaration) x6
    <*> optional fillWrittenSignatureAt (at p ApplicationFormSignature) x7

-- | The unfilled form of a valid @ApplicationForm'@.
unfillApplicationForm :: ApplicationForm -> UnfilledApplicationForm
unfillApplicationForm (ApplicationForm' x1 x2 x3 x4 x5 x6 x7) =
  ApplicationForm'
    (Just (unfillPrimaryContact x1))
    (unfillPersonnelHistory x2)
    (Just (unfillRegulatoryHistory x3))
    (Just x4)
    (map (review _FormText) (atMostList x5))
    (Just (unfillDeclaration x6))
    (fmap unfillWrittenSignature x7)

-- | Fills in @Version'@ from the whole form.
fillVersion :: (AsReOCError e) => UnfilledVersion -> Either (NonEmpty e) Version
fillVersion =
  toEither . fillVersionAt []

-- | Fills in @Version'@ at a path.
fillVersionAt :: (AsReOCError e) => [Step] -> UnfilledVersion -> Validation (NonEmpty e) Version
fillVersionAt p (Version' x1 x2) =
  Version'
    <$> required accepted (at p VersionMajorVersion) x1
    <*> required accepted (at p VersionMinorVersion) x2

-- | The unfilled form of a valid @Version'@.
unfillVersion :: Version -> UnfilledVersion
unfillVersion (Version' x1 x2) =
  Version'
    (Just x1)
    (Just x2)

-- | Fills in @FirstIssue'@ from the whole form.
fillFirstIssue :: (AsReOCError e) => UnfilledFirstIssue -> Either (NonEmpty e) FirstIssue
fillFirstIssue =
  toEither . fillFirstIssueAt []

-- | Fills in @FirstIssue'@ at a path.
fillFirstIssueAt :: (AsReOCError e) => [Step] -> UnfilledFirstIssue -> Validation (NonEmpty e) FirstIssue
fillFirstIssueAt p (FirstIssue' x1 x2 x3 x4 x5) =
  FirstIssue'
    <$> fillVersionAt (at p FirstIssueVersion) x1
    <*> required accepted (at p FirstIssueIssueDate) x2
    <*> required (checked (preview _Text1) InvalidText1) (at p FirstIssueEffective) x3
    <*> required (checked (preview _Text1) InvalidText1) (at p FirstIssueParts) x4
    <*> required (checked (preview _Text1) InvalidText1) (at p FirstIssueDetails) x5

-- | The unfilled form of a valid @FirstIssue'@.
unfillFirstIssue :: FirstIssue -> UnfilledFirstIssue
unfillFirstIssue (FirstIssue' x1 x2 x3 x4 x5) =
  FirstIssue'
    (unfillVersion x1)
    (Just x2)
    (Just (review _Text1 x3))
    (Just (review _Text1 x4))
    (Just (review _Text1 x5))

-- | Fills in @Revision'@ from the whole form.
fillRevision :: (AsReOCError e) => UnfilledRevision -> Either (NonEmpty e) Revision
fillRevision =
  toEither . fillRevisionAt []

-- | Fills in @Revision'@ at a path.
fillRevisionAt :: (AsReOCError e) => [Step] -> UnfilledRevision -> Validation (NonEmpty e) Revision
fillRevisionAt p (Revision' x1 x2 x3 x4 x5) =
  Revision'
    <$> required accepted (at p RevisionVersionIncrement) x1
    <*> required accepted (at p RevisionMonthsAfter) x2
    <*> required (checked (preview _Text1) InvalidText1) (at p RevisionEffective) x3
    <*> required (checked (preview _Text1) InvalidText1) (at p RevisionParts) x4
    <*> required (checked (preview _Text1) InvalidText1) (at p RevisionDetails) x5

-- | The unfilled form of a valid @Revision'@.
unfillRevision :: Revision -> UnfilledRevision
unfillRevision (Revision' x1 x2 x3 x4 x5) =
  Revision'
    (Just x1)
    (Just x2)
    (Just (review _Text1 x3))
    (Just (review _Text1 x4))
    (Just (review _Text1 x5))

-- | Fills in @Policies'@ from the whole form.
fillPolicies :: (AsReOCError e) => UnfilledPolicies -> Either (NonEmpty e) Policies
fillPolicies =
  toEither . fillPoliciesAt []

-- | Fills in @Policies'@ at a path.
fillPoliciesAt :: (AsReOCError e) => [Step] -> UnfilledPolicies -> Validation (NonEmpty e) Policies
fillPoliciesAt p (Policies' x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12) =
  Policies'
    <$> required (checked (preview _Positive) InvalidPositive) (at p PoliciesRecencyFlights) x1
    <*> required (checked (preview _Positive) InvalidPositive) (at p PoliciesRecencyDays) x2
    <*> required (checked (preview _Positive) InvalidPositive) (at p PoliciesRefresherMonths) x3
    <*> required (checked (preview _Positive) InvalidPositive) (at p PoliciesAlcoholHours) x4
    <*> required (checked (preview _Positive) InvalidPositive) (at p PoliciesRestHours) x5
    <*> required (checked (preview _Positive) InvalidPositive) (at p PoliciesDutyHours) x6
    <*> required (checked (preview _Positive) InvalidPositive) (at p PoliciesInspectionMonths) x7
    <*> required (checked (preview _Positive) InvalidPositive) (at p PoliciesInspectionHours) x8
    <*> required (checked (preview _Percentage) InvalidPercentage) (at p PoliciesBatteryReserve) x9
    <*> required accepted (at p PoliciesBackupFrequency) x10
    <*> required (checked (preview _Positive) InvalidPositive) (at p PoliciesIndependentReviewYears) x11
    <*> required (checked (preview _Positive) InvalidPositive) (at p PoliciesCheckingMonths) x12

-- | The unfilled form of a valid @Policies'@.
unfillPolicies :: Policies -> UnfilledPolicies
unfillPolicies (Policies' x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12) =
  Policies'
    (Just (review _Positive x1))
    (Just (review _Positive x2))
    (Just (review _Positive x3))
    (Just (review _Positive x4))
    (Just (review _Positive x5))
    (Just (review _Positive x6))
    (Just (review _Positive x7))
    (Just (review _Positive x8))
    (Just (review _Percentage x9))
    (Just x10)
    (Just (review _Positive x11))
    (Just (review _Positive x12))

-- | Fills in @RiskAssessment'@ from the whole form.
fillRiskAssessment :: (AsReOCError e) => UnfilledRiskAssessment -> Either (NonEmpty e) RiskAssessment
fillRiskAssessment =
  toEither . fillRiskAssessmentAt []

-- | Fills in @RiskAssessment'@ at a path.
fillRiskAssessmentAt :: (AsReOCError e) => [Step] -> UnfilledRiskAssessment -> Validation (NonEmpty e) RiskAssessment
fillRiskAssessmentAt p (RiskAssessment' x1 x2) =
  RiskAssessment'
    <$> required accepted (at p RiskAssessmentRiskLikelihood) x1
    <*> required accepted (at p RiskAssessmentRiskConsequence) x2

-- | The unfilled form of a valid @RiskAssessment'@.
unfillRiskAssessment :: RiskAssessment -> UnfilledRiskAssessment
unfillRiskAssessment (RiskAssessment' x1 x2) =
  RiskAssessment'
    (Just x1)
    (Just x2)

-- | Fills in @Risk'@ from the whole form.
fillRisk :: (AsReOCError e) => UnfilledRisk -> Either (NonEmpty e) Risk
fillRisk =
  toEither . fillRiskAt []

-- | Fills in @Risk'@ at a path.
fillRiskAt :: (AsReOCError e) => [Step] -> UnfilledRisk -> Validation (NonEmpty e) Risk
fillRiskAt p (Risk' x1 x2 x3 x4 x5 x6 x7 x8 x9) =
  Risk'
    <$> required (checked (preview _Text1) InvalidText1) (at p RiskHazard) x1
    <*> required (checked (preview _Text1) InvalidText1) (at p RiskRiskDescription) x2
    <*> required (checked (preview _Text1) InvalidText1) (at p RiskExistingControls) x3
    <*> fillRiskAssessmentAt (at p RiskInitialRisk) x4
    <*> required (checked (preview _Text1) InvalidText1) (at p RiskAdditionalControls) x5
    <*> fillRiskAssessmentAt (at p RiskResidualRisk) x6
    <*> required accepted (at p RiskRiskOwner) x7
    <*> required accepted (at p RiskDateEntered) x8
    <*> required (checked (preview _ReviewMonths) InvalidReviewMonths) (at p RiskReviewMonths) x9

-- | The unfilled form of a valid @Risk'@.
unfillRisk :: Risk -> UnfilledRisk
unfillRisk (Risk' x1 x2 x3 x4 x5 x6 x7 x8 x9) =
  Risk'
    (Just (review _Text1 x1))
    (Just (review _Text1 x2))
    (Just (review _Text1 x3))
    (unfillRiskAssessment x4)
    (Just (review _Text1 x5))
    (unfillRiskAssessment x6)
    (Just x7)
    (Just x8)
    (Just (review _ReviewMonths x9))

-- | Fills in @OperationsManual'@ from the whole form.
fillOperationsManual :: (AsReOCError e) => UnfilledOperationsManual -> Either (NonEmpty e) OperationsManual
fillOperationsManual =
  toEither . fillOperationsManualAt []

-- | Fills in @OperationsManual'@ at a path.
fillOperationsManualAt :: (AsReOCError e) => [Step] -> UnfilledOperationsManual -> Validation (NonEmpty e) OperationsManual
fillOperationsManualAt p (OperationsManual' x1 x2 x3 x4 x5 x6 x7) =
  OperationsManual'
    <$> fillFirstIssueAt (at p OperationsManualFirstIssue) x1
    <*> elements fillRevisionAt (at p OperationsManualRevisions) x2
    <*> nonEmptyElements (checked (preview _Text1) InvalidText1) (at p OperationsManualServices) x3
    <*> fillPoliciesAt (at p OperationsManualPolicies) x4
    <*> nonEmptyElements fillRiskAt (at p OperationsManualRiskRegister) x5
    <*> required accepted (at p OperationsManualCrew) x6
    <*> required accepted (at p OperationsManualPilots) x7

-- | The unfilled form of a valid @OperationsManual'@.
unfillOperationsManual :: OperationsManual -> UnfilledOperationsManual
unfillOperationsManual (OperationsManual' x1 x2 x3 x4 x5 x6 x7) =
  OperationsManual'
    (unfillFirstIssue x1)
    (fmap unfillRevision x2)
    (map (review _Text1) (toList x3))
    (unfillPolicies x4)
    (map unfillRisk (toList x5))
    (Just x6)
    (Just x7)

-- | Fills in @CRINominee'@ from the whole form.
fillCRINominee :: (AsReOCError e) => UnfilledCRINominee -> Either (NonEmpty e) CRINominee
fillCRINominee =
  toEither . fillCRINomineeAt []

-- | Fills in @CRINominee'@ at a path.
fillCRINomineeAt :: (AsReOCError e) => [Step] -> UnfilledCRINominee -> Validation (NonEmpty e) CRINominee
fillCRINomineeAt p = \case
  CRIIsCEO -> pure CRIIsCEO
  CRIIsCRP -> pure CRIIsCRP
  CRIIsMC -> pure CRIIsMC
  CRINominated x -> CRINominated <$> fillNomineeAt (at p CRINomineeCriNominated) x

-- | The unfilled form of a valid @CRINominee'@.
unfillCRINominee :: CRINominee -> UnfilledCRINominee
unfillCRINominee = \case
  CRIIsCEO -> CRIIsCEO
  CRIIsCRP -> CRIIsCRP
  CRIIsMC -> CRIIsMC
  CRINominated x -> CRINominated (unfillNominee x)

-- | Fills in @RePLHolding'@ from the whole form.
fillRePLHolding :: (AsReOCError e) => UnfilledRePLHolding -> Either (NonEmpty e) RePLHolding
fillRePLHolding =
  toEither . fillRePLHoldingAt []

-- | Fills in @RePLHolding'@ at a path.
fillRePLHoldingAt :: (AsReOCError e) => [Step] -> UnfilledRePLHolding -> Validation (NonEmpty e) RePLHolding
fillRePLHoldingAt p = \case
  HoldsRePLForEachType -> pure HoldsRePLForEachType
  RePLHoldingIntent x -> RePLHoldingIntent <$> required (checked (preview _FormText) InvalidFormText) (at p RePLHoldingRePLHoldingIntent) x

-- | The unfilled form of a valid @RePLHolding'@.
unfillRePLHolding :: RePLHolding -> UnfilledRePLHolding
unfillRePLHolding = \case
  HoldsRePLForEachType -> HoldsRePLForEachType
  RePLHoldingIntent x -> RePLHoldingIntent (Just (review _FormText x))

-- | Fills in @TeachingQualification'@ from the whole form.
fillTeachingQualification :: (AsReOCError e) => UnfilledTeachingQualification -> Either (NonEmpty e) TeachingQualification
fillTeachingQualification =
  toEither . fillTeachingQualificationAt []

-- | Fills in @TeachingQualification'@ at a path.
fillTeachingQualificationAt :: (AsReOCError e) => [Step] -> UnfilledTeachingQualification -> Validation (NonEmpty e) TeachingQualification
fillTeachingQualificationAt p = \case
  TeachingQualificationHeld x -> TeachingQualificationHeld <$> required (checked (preview _FormText) InvalidFormText) (at p TeachingQualificationTeachingQualificationHeld) x
  TeachingQualificationIntent x -> TeachingQualificationIntent <$> required (checked (preview _FormText) InvalidFormText) (at p TeachingQualificationTeachingQualificationIntent) x

-- | The unfilled form of a valid @TeachingQualification'@.
unfillTeachingQualification :: TeachingQualification -> UnfilledTeachingQualification
unfillTeachingQualification = \case
  TeachingQualificationHeld x -> TeachingQualificationHeld (Just (review _FormText x))
  TeachingQualificationIntent x -> TeachingQualificationIntent (Just (review _FormText x))

-- | Fills in @OperationalExperience'@ from the whole form.
fillOperationalExperience :: (AsReOCError e) => UnfilledOperationalExperience -> Either (NonEmpty e) OperationalExperience
fillOperationalExperience =
  toEither . fillOperationalExperienceAt []

-- | Fills in @OperationalExperience'@ at a path.
fillOperationalExperienceAt :: (AsReOCError e) => [Step] -> UnfilledOperationalExperience -> Validation (NonEmpty e) OperationalExperience
fillOperationalExperienceAt p = \case
  HasOperationalExperience -> pure HasOperationalExperience
  OperationalExperienceIntent x -> OperationalExperienceIntent <$> required (checked (preview _FormText) InvalidFormText) (at p OperationalExperienceOperationalExperienceIntent) x
  OperationalExperienceNotApplicable -> pure OperationalExperienceNotApplicable

-- | The unfilled form of a valid @OperationalExperience'@.
unfillOperationalExperience :: OperationalExperience -> UnfilledOperationalExperience
unfillOperationalExperience = \case
  HasOperationalExperience -> HasOperationalExperience
  OperationalExperienceIntent x -> OperationalExperienceIntent (Just (review _FormText x))
  OperationalExperienceNotApplicable -> OperationalExperienceNotApplicable

-- | Fills in @TrainingCourse'@ from the whole form.
fillTrainingCourse :: (AsReOCError e) => UnfilledTrainingCourse -> Either (NonEmpty e) TrainingCourse
fillTrainingCourse =
  toEither . fillTrainingCourseAt []

-- | Fills in @TrainingCourse'@ at a path.
fillTrainingCourseAt :: (AsReOCError e) => [Step] -> UnfilledTrainingCourse -> Validation (NonEmpty e) TrainingCourse
fillTrainingCourseAt p (TrainingCourse' x1 x2 x3) =
  TrainingCourse'
    <$> required accepted (at p TrainingCourseCourseKind) x1
    <*> fillOperatedTypeAt (at p TrainingCourseTrainingRPA) x2
    <*> nonEmptyElements accepted (at p TrainingCourseComplexities) x3

-- | The unfilled form of a valid @TrainingCourse'@.
unfillTrainingCourse :: TrainingCourse -> UnfilledTrainingCourse
unfillTrainingCourse (TrainingCourse' x1 x2 x3) =
  TrainingCourse'
    (Just x1)
    (unfillOperatedType x2)
    (toList x3)

-- | Fills in @TrainingArrangements'@ from the whole form.
fillTrainingArrangements :: (AsReOCError e) => UnfilledTrainingArrangements -> Either (NonEmpty e) TrainingArrangements
fillTrainingArrangements =
  toEither . fillTrainingArrangementsAt []

-- | Fills in @TrainingArrangements'@ at a path.
fillTrainingArrangementsAt :: (AsReOCError e) => [Step] -> UnfilledTrainingArrangements -> Validation (NonEmpty e) TrainingArrangements
fillTrainingArrangementsAt p (TrainingArrangements' x1 x2 x3 x4 x5 x6 x7 x8 x9 x10) =
  TrainingArrangements'
    <$> nonEmptyElements (checked (preview _Text1) InvalidText1) (at p TrainingArrangementsTheoryVenues) x1
    <*> nonEmptyElements (checked (preview _Text1) InvalidText1) (at p TrainingArrangementsPracticalAreas) x2
    <*> required (checked (preview _Positive) InvalidPositive) (at p TrainingArrangementsMaxStudentsPerCourse) x3
    <*> required (checked (preview _Positive) InvalidPositive) (at p TrainingArrangementsMaxStudentsPerInstructor) x4
    <*> required accepted (at p TrainingArrangementsTakeover) x5
    <*> required accepted (at p TrainingArrangementsTheory) x6
    <*> required accepted (at p TrainingArrangementsExam) x7
    <*> required (checked (preview _PassMark) InvalidPassMark) (at p TrainingArrangementsExamPassMark) x8
    <*> required accepted (at p TrainingArrangementsExaminer) x9
    <*> optional (checked (preview _Text1) InvalidText1) (at p TrainingArrangementsSimulator) x10

-- | The unfilled form of a valid @TrainingArrangements'@.
unfillTrainingArrangements :: TrainingArrangements -> UnfilledTrainingArrangements
unfillTrainingArrangements (TrainingArrangements' x1 x2 x3 x4 x5 x6 x7 x8 x9 x10) =
  TrainingArrangements'
    (map (review _Text1) (toList x1))
    (map (review _Text1) (toList x2))
    (Just (review _Positive x3))
    (Just (review _Positive x4))
    (Just x5)
    (Just x6)
    (Just x7)
    (Just (review _PassMark x8))
    (Just x9)
    (fmap (review _Text1) x10)

-- | Fills in @TrainingMaterial'@ from the whole form.
fillTrainingMaterial :: (AsReOCError e) => UnfilledTrainingMaterial -> Either (NonEmpty e) TrainingMaterial
fillTrainingMaterial =
  toEither . fillTrainingMaterialAt []

-- | Fills in @TrainingMaterial'@ at a path.
fillTrainingMaterialAt :: (AsReOCError e) => [Step] -> UnfilledTrainingMaterial -> Validation (NonEmpty e) TrainingMaterial
fillTrainingMaterialAt p (TrainingMaterial' x1 x2 x3 x4 x5 x6 x7) =
  TrainingMaterial'
    <$> required fillCRINomineeAt (at p TrainingMaterialCriNominee) x1
    <*> required fillRePLHoldingAt (at p TrainingMaterialRePLHolding) x2
    <*> required fillTeachingQualificationAt (at p TrainingMaterialTeachingQualification) x3
    <*> required fillOperationalExperienceAt (at p TrainingMaterialOperationalExperience) x4
    <*> required fillOtherReOCRolesAt (at p TrainingMaterialCriOtherReOCRoles) x5
    <*> someElements fillTrainingCourseAt (at p TrainingMaterialTrainingCourses) x6
    <*> fillTrainingArrangementsAt (at p TrainingMaterialTrainingArrangements) x7

-- | The unfilled form of a valid @TrainingMaterial'@.
unfillTrainingMaterial :: TrainingMaterial -> UnfilledTrainingMaterial
unfillTrainingMaterial (TrainingMaterial' x1 x2 x3 x4 x5 x6 x7) =
  TrainingMaterial'
    (Just (unfillCRINominee x1))
    (Just (unfillRePLHolding x2))
    (Just (unfillTeachingQualification x3))
    (Just (unfillOperationalExperience x4))
    (Just (unfillOtherReOCRoles x5))
    (map unfillTrainingCourse (toList (someNonEmpty x6)))
    (unfillTrainingArrangements x7)

-- | Fills in @ReOC'@ from the whole form.
fillReOC :: (AsReOCError e) => UnfilledReOC -> Either (NonEmpty e) ReOC
fillReOC =
  toEither . fillReOCAt []

-- | Fills in @ReOC'@ at a path.
fillReOCAt :: (AsReOCError e) => [Step] -> UnfilledReOC -> Validation (NonEmpty e) ReOC
fillReOCAt p (ReOC' x1 x2 x3 x4) =
  ReOC'
    <$> fillOperatorAt (at p ReOCOperator) x1
    <*> fillApplicationFormAt (at p ReOCApplicationForm) x2
    <*> fillOperationsManualAt (at p ReOCOperationsManual) x3
    <*> optional fillTrainingMaterialAt (at p ReOCMaybeTrainingMaterial) x4

-- | The unfilled form of a valid @ReOC'@.
unfillReOC :: ReOC -> UnfilledReOC
unfillReOC (ReOC' x1 x2 x3 x4) =
  ReOC'
    (unfillOperator x1)
    (unfillApplicationForm x2)
    (unfillOperationsManual x3)
    (fmap unfillTrainingMaterial x4)