/// url = 
    
    'http://hl7.org/fhir/StructureMap/Contract4to5'

    
/// name = 
    
    'Contract4to5'

    
/// title = 
    
    'FML Conversion for Contract: R4 to R5'

    
/// status = 
    
    'draft'


    conceptmap
     "
ContractPublicationStatus    " {

      prefix 
s     = "
http://hl7.org/fhir/4.0/contract-publicationstatus    "

      prefix 
t     = "
    http://hl7.org/fhir/contract-publicationstatus
    "


  s    :
amended     -
 t    :
amended
  s    :
appended     -
 t    :
appended
  s    :
cancelled     -
 t    :
cancelled
  s    :
disputed     -
 t    :
disputed
  s    :
"entered-in-error"     -
 t    :
    "
entered-in-error    "

  s    :
executable     -
 t    :
executable
  s    :
executed     -
 t    :
executed
  s    :
negotiable     -
 t    :
negotiable
  s    :
offered     -
 t    :
offered
  s    :
policy     -
 t    :
policy
  s    :
rejected     -
 t    :
rejected
  s    :
renewed     -
 t    :
renewed
  s    :
revoked     -
 t    :
revoked
  s    :
resolved     -
 t    :
resolved
  s    :
terminated     -
 t    :
terminated
    }


    conceptmap
     "
ContractStatus    " {

      prefix 
s     = "
http://hl7.org/fhir/4.0/contract-status    "

      prefix 
t     = "
    http://hl7.org/fhir/contract-status
    "


  s    :
amended     -
 t    :
amended
  s    :
appended     -
 t    :
appended
  s    :
cancelled     -
 t    :
cancelled
  s    :
disputed     -
 t    :
disputed
  s    :
"entered-in-error"     -
 t    :
    "
entered-in-error    "

  s    :
executable     -
 t    :
executable
  s    :
executed     -
 t    :
executed
  s    :
negotiable     -
 t    :
negotiable
  s    :
offered     -
 t    :
offered
  s    :
policy     -
 t    :
policy
  s    :
rejected     -
 t    :
rejected
  s    :
renewed     -
 t    :
renewed
  s    :
revoked     -
 t    :
revoked
  s    :
resolved     -
 t    :
resolved
  s    :
terminated     -
 t    :
terminated
    }


    uses
     "
http://hl7.org/fhir/4.0/StructureDefinition/Contract    " 
    alias 
ContractR4     as 
    source

    uses
     "
    http://hl7.org/fhir/StructureDefinition/Contract
    " 
    alias 
ContractR5     as 
    target


    imports
     "
http://hl7.org/fhir/StructureMap/*4to5    "


    group 
Contract    (
    source
     src
     : 
ContractR4,     target
     tgt
     : 
ContractR5    )
     extends 
DomainResource     <<type+>>
     {

  src.identifier    
 ->     
tgt.identifier    ;

  src.url    
 ->     
tgt.url    ;

  src.version    
 ->     
tgt.version    ;

  src.status     as 
    v
    
 ->     
tgt.status =     translate
    (
    v
    , 
    '#ContractStatus'
    , 
    'code'
    )
    ;

  src.legalState    
 ->     
tgt.legalState    ;

  src.instantiatesCanonical    
 ->     
tgt.instantiatesCanonical    ;

  src.instantiatesUri    
 ->     
tgt.instantiatesUri    ;

  src.contentDerivative    
 ->     
tgt.contentDerivative    ;

  src.issued    
 ->     
tgt.issued    ;

  src.applies    
 ->     
tgt.applies    ;

  src.expirationType    
 ->     
tgt.expirationType    ;

  src.subject    
 ->     
tgt.subject    ;

  src.authority    
 ->     
tgt.authority    ;

  src.domain    
 ->     
tgt.domain    ;

  src.site    
 ->     
tgt.site    ;

  src.name    
 ->     
tgt.name    ;

  src.title    
 ->     
tgt.title    ;

  src.subtitle    
 ->     
tgt.subtitle    ;

  src.alias    
 ->     
tgt.alias    ;

  src.author    
 ->     
tgt.author    ;

  src.scope    
 ->     
tgt.scope    ;

  src.topic     : 
CodeableConcept    
 ->     
tgt.topic    ;

  src.topic     : 
Reference    
 ->     
tgt.topic    ;

  src.type    
 ->     
tgt.type    ;

  src.subType    
 ->     
tgt.subType    ;

  src.contentDefinition     as 
    s
    
 ->     
tgt.contentDefinition     as 
    t
     then 
ContractContentDefinition    (
    s
    , 
    t
    )
    ;

  src.term     as 
    s
    
 ->     
tgt.term     as 
    t
     then 
ContractTerm    (
    s
    , 
    t
    )
    ;

  src.supportingInfo    
 ->     
tgt.supportingInfo    ;

  src.relevantHistory    
 ->     
tgt.relevantHistory    ;

  src.signer     as 
    s
    
 ->     
tgt.signer     as 
    t
     then 
ContractSigner    (
    s
    , 
    t
    )
    ;

  src.friendly     as 
    s
    
 ->     
tgt.friendly     as 
    t
     then 
ContractFriendly    (
    s
    , 
    t
    )
    ;

  src.legal     as 
    s
    
 ->     
tgt.legal     as 
    t
     then 
ContractLegal    (
    s
    , 
    t
    )
    ;

  src.rule     as 
    s
    
 ->     
tgt.rule     as 
    t
     then 
ContractRule    (
    s
    , 
    t
    )
    ;

  src.legallyBinding     : 
Attachment    
 ->     
tgt.legallyBinding    ;

  src.legallyBinding     : 
Reference    
 ->     
tgt.legallyBinding    ;

    }


    group 
ContractContentDefinition    (
    source
     src
,     target
     tgt
    )
     extends 
BackboneElement     {

  src.type    
 ->     
tgt.type    ;

  src.subType    
 ->     
tgt.subType    ;

  src.publisher    
 ->     
tgt.publisher    ;

  src.publicationDate    
 ->     
tgt.publicationDate    ;

  src.publicationStatus     as 
    v
    
 ->     
tgt.publicationStatus =     translate
    (
    v
    , 
    '#ContractPublicationStatus'
    , 
    'code'
    )
    ;

  src.copyright    
 ->     
tgt.copyright    ;

    }


    group 
ContractTerm    (
    source
     src
,     target
     tgt
    )
     extends 
BackboneElement     {

  src.identifier    
 ->     
tgt.identifier    ;

  src.issued    
 ->     
tgt.issued    ;

  src.applies    
 ->     
tgt.applies    ;

  src.topic     : 
CodeableConcept    
 ->     
tgt.topic    ;

  src.topic     : 
Reference    
 ->     
tgt.topic    ;

  src.type    
 ->     
tgt.type    ;

  src.subType    
 ->     
tgt.subType    ;

  src.text    
 ->     
tgt.text    ;

  src.securityLabel     as 
    s
    
 ->     
tgt.securityLabel     as 
    t
     then 
ContractTermSecurityLabel    (
    s
    , 
    t
    )
    ;

  src.offer     as 
    s
    
 ->     
tgt.offer     as 
    t
     then 
ContractTermOffer    (
    s
    , 
    t
    )
    ;

  src.asset     as 
    s
    
 ->     
tgt.asset     as 
    t
     then 
ContractTermAsset    (
    s
    , 
    t
    )
    ;

  src.action     as 
    s
    
 ->     
tgt.action     as 
    t
     then 
ContractTermAction    (
    s
    , 
    t
    )
    ;

    }


    group 
ContractTermSecurityLabel    (
    source
     src
,     target
     tgt
    )
     extends 
BackboneElement     {

  src.number    
 ->     
tgt.number    ;

  src.classification    
 ->     
tgt.classification    ;

  src.category    
 ->     
tgt.category    ;

  src.control    
 ->     
tgt.control    ;

    }


    group 
ContractTermOffer    (
    source
     src
,     target
     tgt
    )
     extends 
BackboneElement     {

  src.identifier    
 ->     
tgt.identifier    ;

  src.party     as 
    s
    
 ->     
tgt.party     as 
    t
     then 
ContractTermOfferParty    (
    s
    , 
    t
    )
    ;

  src.topic    
 ->     
tgt.topic    ;

  src.type    
 ->     
tgt.type    ;

  src.decision    
 ->     
tgt.decision    ;

  src.decisionMode    
 ->     
tgt.decisionMode    ;

  src.answer     as 
    s
    
 ->     
tgt.answer     as 
    t
     then 
ContractTermOfferAnswer    (
    s
    , 
    t
    )
    ;

  src.text    
 ->     
tgt.text    ;

  src.linkId    
 ->     
tgt.linkId    ;

  src.securityLabelNumber    
 ->     
tgt.securityLabelNumber    ;

    }


    group 
ContractTermOfferParty    (
    source
     src
,     target
     tgt
    )
     extends 
BackboneElement     {

  src.reference    
 ->     
tgt.reference    ;

  src.role    
 ->     
tgt.role    ;

    }


    group 
ContractTermOfferAnswer    (
    source
     src
,     target
     tgt
    )
     extends 
BackboneElement     {

  src.value     : 
boolean    
 ->     
tgt.value    ;

  src.value     : 
decimal    
 ->     
tgt.value    ;

  src.value     : 
integer    
 ->     
tgt.value    ;

  src.value     : 
date    
 ->     
tgt.value    ;

  src.value     : 
dateTime    
 ->     
tgt.value    ;

  src.value     : 
time    
 ->     
tgt.value    ;

  src.value     : 
string    
 ->     
tgt.value    ;

  src.value     : 
uri    
 ->     
tgt.value    ;

  src.value     : 
Attachment    
 ->     
tgt.value    ;

  src.value     : 
Coding    
 ->     
tgt.value    ;

  src.value     : 
Quantity    
 ->     
tgt.value    ;

  src.value     : 
Reference    
 ->     
tgt.value    ;

    }


    group 
ContractTermAsset    (
    source
     src
,     target
     tgt
    )
     extends 
BackboneElement     {

  src.scope    
 ->     
tgt.scope    ;

  src.type    
 ->     
tgt.type    ;

  src.typeReference    
 ->     
tgt.typeReference    ;

  src.subtype    
 ->     
tgt.subtype    ;

  src.relationship    
 ->     
tgt.relationship    ;

  src.context     as 
    s
    
 ->     
tgt.context     as 
    t
     then 
ContractTermAssetContext    (
    s
    , 
    t
    )
    ;

  src.condition    
 ->     
tgt.condition    ;

  src.periodType    
 ->     
tgt.periodType    ;

  src.period    
 ->     
tgt.period    ;

  src.usePeriod    
 ->     
tgt.usePeriod    ;

  src.text    
 ->     
tgt.text    ;

  src.linkId    
 ->     
tgt.linkId    ;

  src.securityLabelNumber    
 ->     
tgt.securityLabelNumber    ;

  src.valuedItem     as 
    s
    
 ->     
tgt.valuedItem     as 
    t
     then 
ContractTermAssetValuedItem    (
    s
    , 
    t
    )
    ;

    }


    group 
ContractTermAssetContext    (
    source
     src
,     target
     tgt
    )
     extends 
BackboneElement     {

  src.reference    
 ->     
tgt.reference    ;

  src.code    
 ->     
tgt.code    ;

  src.text    
 ->     
tgt.text    ;

    }


    group 
ContractTermAssetValuedItem    (
    source
     src
,     target
     tgt
    )
     extends 
BackboneElement     {

  src.entity     : 
CodeableConcept    
 ->     
tgt.entity    ;

  src.entity     : 
Reference    
 ->     
tgt.entity    ;

  src.identifier    
 ->     
tgt.identifier    ;

  src.effectiveTime    
 ->     
tgt.effectiveTime    ;

  src.quantity    
 ->     
tgt.quantity    ;

  src.unitPrice    
 ->     
tgt.unitPrice    ;

  src.factor    
 ->     
tgt.factor    ;

  src.points    
 ->     
tgt.points    ;

  src.net    
 ->     
tgt.net    ;

  src.payment    
 ->     
tgt.payment    ;

  src.paymentDate    
 ->     
tgt.paymentDate    ;

  src.responsible    
 ->     
tgt.responsible    ;

  src.recipient    
 ->     
tgt.recipient    ;

  src.linkId    
 ->     
tgt.linkId    ;

  src.securityLabelNumber    
 ->     
tgt.securityLabelNumber    ;

    }


    group 
ContractTermAction    (
    source
     src
,     target
     tgt
    )
     extends 
BackboneElement     {

  src.doNotPerform    
 ->     
tgt.doNotPerform    ;

  src.type    
 ->     
tgt.type    ;

  src.subject     as 
    s
    
 ->     
tgt.subject     as 
    t
     then 
ContractTermActionSubject    (
    s
    , 
    t
    )
    ;

  src.intent    
 ->     
tgt.intent    ;

  src.linkId    
 ->     
tgt.linkId    ;

  src.status    
 ->     
tgt.status    ;

  src.context    
 ->     
tgt.context    ;

  src.contextLinkId    
 ->     
tgt.contextLinkId    ;

  src.occurrence     : 
dateTime    
 ->     
tgt.occurrence    ;

  src.occurrence     : 
Period    
 ->     
tgt.occurrence    ;

  src.occurrence     : 
Timing    
 ->     
tgt.occurrence    ;

  src.requester    
 ->     
tgt.requester    ;

  src.requesterLinkId    
 ->     
tgt.requesterLinkId    ;

  src.performerType    
 ->     
tgt.performerType    ;

  src.performerRole    
 ->     
tgt.performerRole    ;

  src.performer    
 ->     
tgt.performer    ;

  src.performerLinkId    
 ->     
tgt.performerLinkId    ;

  src.reason    
 ->     
tgt.reason    ;

  src.reasonLinkId    
 ->     
tgt.reasonLinkId    ;

  src.note    
 ->     
tgt.note    ;

  src.securityLabelNumber    
 ->     
tgt.securityLabelNumber    ;

    }


    group 
ContractTermActionSubject    (
    source
     src
,     target
     tgt
    )
     extends 
BackboneElement     {

  src.reference    
 ->     
tgt.reference    ;

  src.role    
 ->     
tgt.role    ;

    }


    group 
ContractSigner    (
    source
     src
,     target
     tgt
    )
     extends 
BackboneElement     {

  src.type    
 ->     
tgt.type    ;

  src.party    
 ->     
tgt.party    ;

  src.signature    
 ->     
tgt.signature    ;

    }


    group 
ContractFriendly    (
    source
     src
,     target
     tgt
    )
     extends 
BackboneElement     {

  src.content     : 
Attachment    
 ->     
tgt.content    ;

  src.content     : 
Reference    
 ->     
tgt.content    ;

    }


    group 
ContractLegal    (
    source
     src
,     target
     tgt
    )
     extends 
BackboneElement     {

  src.content     : 
Attachment    
 ->     
tgt.content    ;

  src.content     : 
Reference    
 ->     
tgt.content    ;

    }


    group 
ContractRule    (
    source
     src
,     target
     tgt
    )
     extends 
BackboneElement     {

  src.content     : 
Attachment    
 ->     
tgt.content    ;

  src.content     : 
Reference    
 ->     
tgt.content    ;

    }