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

    
/// name = 
    
    'ElementDefinition5to4'

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

    
/// status = 
    
    'active'


    conceptmap
     "
AggregationMode    " {

      prefix 
s     = "
    http://hl7.org/fhir/resource-aggregation-mode
    "

      prefix 
t     = "
http://hl7.org/fhir/4.0/resource-aggregation-mode    "


  s    :
contained     -
 t    :
contained
  s    :
referenced     -
 t    :
referenced
  s    :
bundled     -
 t    :
bundled
    }


    conceptmap
     "
BindingStrength    " {

      prefix 
s     = "
    http://hl7.org/fhir/binding-strength
    "

      prefix 
t     = "
http://hl7.org/fhir/4.0/binding-strength    "


  s    :
required     -
 t    :
required
  s    :
extensible     -
 t    :
extensible
  s    :
preferred     -
 t    :
preferred
  s    :
example     -
 t    :
example
    }


    conceptmap
     "
ConstraintSeverity    " {

      prefix 
s     = "
    http://hl7.org/fhir/constraint-severity
    "

      prefix 
t     = "
http://hl7.org/fhir/4.0/constraint-severity    "


  s    :
error     -
 t    :
error
  s    :
warning     -
 t    :
warning
    }


    conceptmap
     "
DiscriminatorType    " {

      prefix 
s     = "
    http://hl7.org/fhir/discriminator-type
    "

      prefix 
t     = "
http://hl7.org/fhir/4.0/discriminator-type    "


  s    :
value     -
 t    :
value
  s    :
exists     -
 t    :
exists
  s    :
pattern     -
 t    :
pattern
  s    :
type     -
 t    :
type
  s    :
profile     -
 t    :
profile
    }


    conceptmap
     "
PropertyRepresentation    " {

      prefix 
s     = "
    http://hl7.org/fhir/property-representation
    "

      prefix 
t     = "
http://hl7.org/fhir/4.0/property-representation    "


  s    :
xmlAttr     -
 t    :
xmlAttr
  s    :
xmlText     -
 t    :
xmlText
  s    :
typeAttr     -
 t    :
typeAttr
  s    :
cdaText     -
 t    :
cdaText
  s    :
xhtml     -
 t    :
xhtml
    }


    conceptmap
     "
ReferenceVersionRules    " {

      prefix 
s     = "
    http://hl7.org/fhir/reference-version-rules
    "

      prefix 
t     = "
http://hl7.org/fhir/4.0/reference-version-rules    "


  s    :
either     -
 t    :
either
  s    :
independent     -
 t    :
independent
  s    :
specific     -
 t    :
specific
    }


    conceptmap
     "
SlicingRules    " {

      prefix 
s     = "
    http://hl7.org/fhir/resource-slicing-rules
    "

      prefix 
t     = "
http://hl7.org/fhir/4.0/resource-slicing-rules    "


  s    :
closed     -
 t    :
closed
  s    :
open     -
 t    :
open
  s    :
openAtEnd     -
 t    :
openAtEnd
    }


    uses
     "
    http://hl7.org/fhir/StructureDefinition/ElementDefinition
    " 
    alias 
ElementDefinitionR5     as 
    source

    uses
     "
http://hl7.org/fhir/4.0/StructureDefinition/ElementDefinition    " 
    alias 
ElementDefinitionR4     as 
    target


    imports
     "
http://hl7.org/fhir/StructureMap/*5to4    "


    group 
ElementDefinition    (
    source
     src
     : 
ElementDefinitionR5,     target
     tgt
     : 
ElementDefinitionR4    )
     extends 
Element     <<type+>>
     {

  src.modifierExtension    
 ->     
tgt.modifierExtension    ;

  src.path    
 ->     
tgt.path    ;

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

  src.sliceName    
 ->     
tgt.sliceName    ;

  src.sliceIsConstraining    
 ->     
tgt.sliceIsConstraining    ;

  src.label    
 ->     
tgt.label    ;

  src.code    
 ->     
tgt.code    ;

  src.slicing     as 
    s
    
 ->     
tgt.slicing     as 
    t
     then 
ElementDefinitionSlicing    (
    s
    , 
    t
    )
    ;

  src.short    
 ->     
tgt.short    ;

  src.definition    
 ->     
tgt.definition    ;

  src.comment    
 ->     
tgt.comment    ;

  src.requirements    
 ->     
tgt.requirements    ;

  src.alias    
 ->     
tgt.alias    ;

  src.min    
 ->     
tgt.min    ;

  src.max    
 ->     
tgt.max    ;

  src.base     as 
    s
    
 ->     
tgt.base     as 
    t
     then 
ElementDefinitionBase    (
    s
    , 
    t
    )
    ;

  src.contentReference    
 ->     
tgt.contentReference    ;

  src.type     as 
    s
    
 ->     
tgt.type     as 
    t
     then 
ElementDefinitionType    (
    s
    , 
    t
    )
    ;

  src.defaultValue     : 
base64Binary    
 ->     
tgt.defaultValue    ;

  src.defaultValue     : 
boolean    
 ->     
tgt.defaultValue    ;

  src.defaultValue     : 
canonical    
 ->     
tgt.defaultValue    ;

  src.defaultValue     : 
code    
 ->     
tgt.defaultValue    ;

  src.defaultValue     : 
date    
 ->     
tgt.defaultValue    ;

  src.defaultValue     : 
dateTime    
 ->     
tgt.defaultValue    ;

  src.defaultValue     : 
decimal    
 ->     
tgt.defaultValue    ;

  src.defaultValue     : 
id    
 ->     
tgt.defaultValue    ;

  src.defaultValue     : 
instant    
 ->     
tgt.defaultValue    ;

  src.defaultValue     : 
integer    
 ->     
tgt.defaultValue    ;

  src.defaultValue     : 
markdown    
 ->     
tgt.defaultValue    ;
     // 
    src.defaultValue : integer64 -> tgt.defaultValue;

  src.defaultValue     : 
oid    
 ->     
tgt.defaultValue    ;

  src.defaultValue     : 
positiveInt    
 ->     
tgt.defaultValue    ;

  src.defaultValue     : 
string    
 ->     
tgt.defaultValue    ;

  src.defaultValue     : 
time    
 ->     
tgt.defaultValue    ;

  src.defaultValue     : 
unsignedInt    
 ->     
tgt.defaultValue    ;

  src.defaultValue     : 
uri    
 ->     
tgt.defaultValue    ;

  src.defaultValue     : 
url    
 ->     
tgt.defaultValue    ;

  src.defaultValue     : 
uuid    
 ->     
tgt.defaultValue    ;

  src.defaultValue     : 
Address    
 ->     
tgt.defaultValue    ;

  src.defaultValue     : 
Age    
 ->     
tgt.defaultValue    ;

  src.defaultValue     : 
Annotation    
 ->     
tgt.defaultValue    ;

  src.defaultValue     : 
Attachment    
 ->     
tgt.defaultValue    ;

  src.defaultValue     : 
CodeableConcept    
 ->     
tgt.defaultValue    ;

  src.defaultValue     : 
Coding    
 ->     
tgt.defaultValue    ;
     // 
    src.defaultValue : CodeableReference -> tgt.defaultValue;

  src.defaultValue     : 
ContactPoint    
 ->     
tgt.defaultValue    ;

  src.defaultValue     : 
Count    
 ->     
tgt.defaultValue    ;

  src.defaultValue     : 
Distance    
 ->     
tgt.defaultValue    ;

  src.defaultValue     : 
Duration    
 ->     
tgt.defaultValue    ;

  src.defaultValue     : 
HumanName    
 ->     
tgt.defaultValue    ;

  src.defaultValue     : 
Identifier    
 ->     
tgt.defaultValue    ;

  src.defaultValue     : 
Money    
 ->     
tgt.defaultValue    ;

  src.defaultValue     : 
Period    
 ->     
tgt.defaultValue    ;

  src.defaultValue     : 
Quantity    
 ->     
tgt.defaultValue    ;

  src.defaultValue     : 
Range    
 ->     
tgt.defaultValue    ;

  src.defaultValue     : 
Ratio    
 ->     
tgt.defaultValue    ;

  src.defaultValue     : 
Reference    
 ->     
tgt.defaultValue    ;
     // 
    src.defaultValue : RatioRange -> tgt.defaultValue;

  src.defaultValue     : 
SampledData    
 ->     
tgt.defaultValue    ;

  src.defaultValue     : 
Signature    
 ->     
tgt.defaultValue    ;

  src.defaultValue     : 
Timing    
 ->     
tgt.defaultValue    ;

  src.defaultValue     : 
ContactDetail    
 ->     
tgt.defaultValue    ;

  src.defaultValue     : 
DataRequirement    
 ->     
tgt.defaultValue    ;

  src.defaultValue     : 
Expression    
 ->     
tgt.defaultValue    ;

  src.defaultValue     : 
ParameterDefinition    
 ->     
tgt.defaultValue    ;

  src.defaultValue     : 
RelatedArtifact    
 ->     
tgt.defaultValue    ;

  src.defaultValue     : 
TriggerDefinition    
 ->     
tgt.defaultValue    ;

  src.defaultValue     : 
UsageContext    
 ->     
tgt.defaultValue    ;

  src.defaultValue     : 
Dosage    
 ->     
tgt.defaultValue    ;
     // 
    src.defaultValue : Availability -> tgt.defaultValue;

  src.defaultValue     : 
Meta    
 ->     
tgt.defaultValue    ;

  src.meaningWhenMissing    
 ->     
tgt.meaningWhenMissing    ;

  src.orderMeaning    
 ->     
tgt.orderMeaning    ;

  src.fixed     : 
base64Binary    
 ->     
tgt.fixed    ;

  src.fixed     : 
boolean    
 ->     
tgt.fixed    ;

  src.fixed     : 
canonical    
 ->     
tgt.fixed    ;

  src.fixed     : 
code    
 ->     
tgt.fixed    ;

  src.fixed     : 
date    
 ->     
tgt.fixed    ;

  src.fixed     : 
dateTime    
 ->     
tgt.fixed    ;

  src.fixed     : 
decimal    
 ->     
tgt.fixed    ;

  src.fixed     : 
id    
 ->     
tgt.fixed    ;

  src.fixed     : 
instant    
 ->     
tgt.fixed    ;

  src.fixed     : 
integer    
 ->     
tgt.fixed    ;

  src.fixed     : 
markdown    
 ->     
tgt.fixed    ;
     // 
    src.fixed : integer64 -> tgt.fixed;

  src.fixed     : 
oid    
 ->     
tgt.fixed    ;

  src.fixed     : 
positiveInt    
 ->     
tgt.fixed    ;

  src.fixed     : 
string    
 ->     
tgt.fixed    ;

  src.fixed     : 
time    
 ->     
tgt.fixed    ;

  src.fixed     : 
unsignedInt    
 ->     
tgt.fixed    ;

  src.fixed     : 
uri    
 ->     
tgt.fixed    ;

  src.fixed     : 
url    
 ->     
tgt.fixed    ;

  src.fixed     : 
uuid    
 ->     
tgt.fixed    ;

  src.fixed     : 
Address    
 ->     
tgt.fixed    ;

  src.fixed     : 
Age    
 ->     
tgt.fixed    ;

  src.fixed     : 
Annotation    
 ->     
tgt.fixed    ;

  src.fixed     : 
Attachment    
 ->     
tgt.fixed    ;

  src.fixed     : 
CodeableConcept    
 ->     
tgt.fixed    ;

  src.fixed     : 
Coding    
 ->     
tgt.fixed    ;
     // 
    src.fixed : CodeableReference -> tgt.fixed;

  src.fixed     : 
ContactPoint    
 ->     
tgt.fixed    ;

  src.fixed     : 
Count    
 ->     
tgt.fixed    ;

  src.fixed     : 
Distance    
 ->     
tgt.fixed    ;

  src.fixed     : 
Duration    
 ->     
tgt.fixed    ;

  src.fixed     : 
HumanName    
 ->     
tgt.fixed    ;

  src.fixed     : 
Identifier    
 ->     
tgt.fixed    ;

  src.fixed     : 
Money    
 ->     
tgt.fixed    ;

  src.fixed     : 
Period    
 ->     
tgt.fixed    ;

  src.fixed     : 
Quantity    
 ->     
tgt.fixed    ;

  src.fixed     : 
Range    
 ->     
tgt.fixed    ;

  src.fixed     : 
Ratio    
 ->     
tgt.fixed    ;

  src.fixed     : 
Reference    
 ->     
tgt.fixed    ;
     // 
    src.fixed : RatioRange -> tgt.fixed;

  src.fixed     : 
SampledData    
 ->     
tgt.fixed    ;

  src.fixed     : 
Signature    
 ->     
tgt.fixed    ;

  src.fixed     : 
Timing    
 ->     
tgt.fixed    ;

  src.fixed     : 
ContactDetail    
 ->     
tgt.fixed    ;

  src.fixed     : 
DataRequirement    
 ->     
tgt.fixed    ;

  src.fixed     : 
Expression    
 ->     
tgt.fixed    ;

  src.fixed     : 
ParameterDefinition    
 ->     
tgt.fixed    ;

  src.fixed     : 
RelatedArtifact    
 ->     
tgt.fixed    ;

  src.fixed     : 
TriggerDefinition    
 ->     
tgt.fixed    ;

  src.fixed     : 
UsageContext    
 ->     
tgt.fixed    ;

  src.fixed     : 
Dosage    
 ->     
tgt.fixed    ;
     // 
    src.fixed : Availability -> tgt.fixed;

  src.fixed     : 
Meta    
 ->     
tgt.fixed    ;

  src.pattern     : 
base64Binary    
 ->     
tgt.pattern    ;

  src.pattern     : 
boolean    
 ->     
tgt.pattern    ;

  src.pattern     : 
canonical    
 ->     
tgt.pattern    ;

  src.pattern     : 
code    
 ->     
tgt.pattern    ;

  src.pattern     : 
date    
 ->     
tgt.pattern    ;

  src.pattern     : 
dateTime    
 ->     
tgt.pattern    ;

  src.pattern     : 
decimal    
 ->     
tgt.pattern    ;

  src.pattern     : 
id    
 ->     
tgt.pattern    ;

  src.pattern     : 
instant    
 ->     
tgt.pattern    ;

  src.pattern     : 
integer    
 ->     
tgt.pattern    ;

  src.pattern     : 
markdown    
 ->     
tgt.pattern    ;
     // 
    src.pattern : integer64 -> tgt.pattern;

  src.pattern     : 
oid    
 ->     
tgt.pattern    ;

  src.pattern     : 
positiveInt    
 ->     
tgt.pattern    ;

  src.pattern     : 
string    
 ->     
tgt.pattern    ;

  src.pattern     : 
time    
 ->     
tgt.pattern    ;

  src.pattern     : 
unsignedInt    
 ->     
tgt.pattern    ;

  src.pattern     : 
uri    
 ->     
tgt.pattern    ;

  src.pattern     : 
url    
 ->     
tgt.pattern    ;

  src.pattern     : 
uuid    
 ->     
tgt.pattern    ;

  src.pattern     : 
Address    
 ->     
tgt.pattern    ;

  src.pattern     : 
Age    
 ->     
tgt.pattern    ;

  src.pattern     : 
Annotation    
 ->     
tgt.pattern    ;

  src.pattern     : 
Attachment    
 ->     
tgt.pattern    ;

  src.pattern     : 
CodeableConcept    
 ->     
tgt.pattern    ;

  src.pattern     : 
Coding    
 ->     
tgt.pattern    ;
     // 
    src.pattern : CodeableReference -> tgt.pattern;

  src.pattern     : 
ContactPoint    
 ->     
tgt.pattern    ;

  src.pattern     : 
Count    
 ->     
tgt.pattern    ;

  src.pattern     : 
Distance    
 ->     
tgt.pattern    ;

  src.pattern     : 
Duration    
 ->     
tgt.pattern    ;

  src.pattern     : 
HumanName    
 ->     
tgt.pattern    ;

  src.pattern     : 
Identifier    
 ->     
tgt.pattern    ;

  src.pattern     : 
Money    
 ->     
tgt.pattern    ;

  src.pattern     : 
Period    
 ->     
tgt.pattern    ;

  src.pattern     : 
Quantity    
 ->     
tgt.pattern    ;

  src.pattern     : 
Range    
 ->     
tgt.pattern    ;

  src.pattern     : 
Ratio    
 ->     
tgt.pattern    ;

  src.pattern     : 
Reference    
 ->     
tgt.pattern    ;
     // 
    src.pattern : RatioRange -> tgt.pattern;

  src.pattern     : 
SampledData    
 ->     
tgt.pattern    ;

  src.pattern     : 
Signature    
 ->     
tgt.pattern    ;

  src.pattern     : 
Timing    
 ->     
tgt.pattern    ;

  src.pattern     : 
ContactDetail    
 ->     
tgt.pattern    ;

  src.pattern     : 
DataRequirement    
 ->     
tgt.pattern    ;

  src.pattern     : 
Expression    
 ->     
tgt.pattern    ;

  src.pattern     : 
ParameterDefinition    
 ->     
tgt.pattern    ;

  src.pattern     : 
RelatedArtifact    
 ->     
tgt.pattern    ;

  src.pattern     : 
TriggerDefinition    
 ->     
tgt.pattern    ;

  src.pattern     : 
UsageContext    
 ->     
tgt.pattern    ;

  src.pattern     : 
Dosage    
 ->     
tgt.pattern    ;
     // 
    src.pattern : Availability -> tgt.pattern;

  src.pattern     : 
Meta    
 ->     
tgt.pattern    ;

  src.example     as 
    s
    
 ->     
tgt.example     as 
    t
     then 
ElementDefinitionExample    (
    s
    , 
    t
    )
    ;

  src.minValue     : 
date    
 ->     
tgt.minValue    ;

  src.minValue     : 
dateTime    
 ->     
tgt.minValue    ;

  src.minValue     : 
instant    
 ->     
tgt.minValue    ;

  src.minValue     : 
time    
 ->     
tgt.minValue    ;

  src.minValue     : 
decimal    
 ->     
tgt.minValue    ;

  src.minValue     : 
integer    
 ->     
tgt.minValue    ;

  src.minValue     : 
positiveInt    
 ->     
tgt.minValue    ;
     // 
    src.minValue : integer64 -> tgt.minValue;

  src.minValue     : 
unsignedInt    
 ->     
tgt.minValue    ;

  src.minValue     : 
Quantity    
 ->     
tgt.minValue    ;

  src.maxValue     : 
date    
 ->     
tgt.maxValue    ;

  src.maxValue     : 
dateTime    
 ->     
tgt.maxValue    ;

  src.maxValue     : 
instant    
 ->     
tgt.maxValue    ;

  src.maxValue     : 
time    
 ->     
tgt.maxValue    ;

  src.maxValue     : 
decimal    
 ->     
tgt.maxValue    ;

  src.maxValue     : 
integer    
 ->     
tgt.maxValue    ;

  src.maxValue     : 
positiveInt    
 ->     
tgt.maxValue    ;
     // 
    src.maxValue : integer64 -> tgt.maxValue;

  src.maxValue     : 
unsignedInt    
 ->     
tgt.maxValue    ;

  src.maxValue     : 
Quantity    
 ->     
tgt.maxValue    ;

  src.maxLength    
 ->     
tgt.maxLength    ;

  src.condition    
 ->     
tgt.condition    ;

  src.constraint     as 
    s
    
 ->     
tgt.constraint     as 
    t
     then 
ElementDefinitionConstraint    (
    s
    , 
    t
    )
    ;

  src.mustSupport    
 ->     
tgt.mustSupport    ;
     // 
    src.mustHaveValue -> tgt.mustHaveValue;

  src.isModifier    
 ->     
tgt.isModifier    ;

  src.isModifierReason    
 ->     
tgt.isModifierReason    ;

  src.isSummary    
 ->     
tgt.isSummary    ;

  src.binding     as 
    s
    
 ->     
tgt.binding     as 
    t
     then 
ElementDefinitionBinding    (
    s
    , 
    t
    )
    ;

  src.mapping     as 
    s
    
 ->     
tgt.mapping     as 
    t
     then 
ElementDefinitionMapping    (
    s
    , 
    t
    )
    ;

    }


    group 
ElementDefinitionSlicing    (
    source
     src
,     target
     tgt
    )
     extends 
Element     {

  src.discriminator     as 
    s
    
 ->     
tgt.discriminator     as 
    t
     then 
ElementDefinitionSlicingDiscriminator    (
    s
    , 
    t
    )
    ;

  src.description    
 ->     
tgt.description    ;

  src.ordered    
 ->     
tgt.ordered    ;

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

    }


    group 
ElementDefinitionSlicingDiscriminator    (
    source
     src
,     target
     tgt
    )
     extends 
Element     {

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

  src.path    
 ->     
tgt.path    ;

    }


    group 
ElementDefinitionBase    (
    source
     src
,     target
     tgt
    )
     extends 
Element     {

  src.path    
 ->     
tgt.path    ;

  src.min    
 ->     
tgt.min    ;

  src.max    
 ->     
tgt.max    ;

    }


    group 
ElementDefinitionType    (
    source
     src
,     target
     tgt
    )
     extends 
Element     {

  src.code    
 ->     
tgt.code    ;

  src.profile    
 ->     
tgt.profile    ;

  src.targetProfile    
 ->     
tgt.targetProfile    ;

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

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

    }


    group 
ElementDefinitionExample    (
    source
     src
,     target
     tgt
    )
     extends 
Element     {

  src.label    
 ->     
tgt.label    ;

  src.value     : 
base64Binary    
 ->     
tgt.value    ;

  src.value     : 
boolean    
 ->     
tgt.value    ;

  src.value     : 
canonical    
 ->     
tgt.value    ;

  src.value     : 
code    
 ->     
tgt.value    ;

  src.value     : 
date    
 ->     
tgt.value    ;

  src.value     : 
dateTime    
 ->     
tgt.value    ;

  src.value     : 
decimal    
 ->     
tgt.value    ;

  src.value     : 
id    
 ->     
tgt.value    ;

  src.value     : 
instant    
 ->     
tgt.value    ;

  src.value     : 
integer    
 ->     
tgt.value    ;

  src.value     : 
markdown    
 ->     
tgt.value    ;
     // 
    src.value : integer64 -> tgt.value;

  src.value     : 
oid    
 ->     
tgt.value    ;

  src.value     : 
positiveInt    
 ->     
tgt.value    ;

  src.value     : 
string    
 ->     
tgt.value    ;

  src.value     : 
time    
 ->     
tgt.value    ;

  src.value     : 
unsignedInt    
 ->     
tgt.value    ;

  src.value     : 
uri    
 ->     
tgt.value    ;

  src.value     : 
url    
 ->     
tgt.value    ;

  src.value     : 
uuid    
 ->     
tgt.value    ;

  src.value     : 
Address    
 ->     
tgt.value    ;

  src.value     : 
Age    
 ->     
tgt.value    ;

  src.value     : 
Annotation    
 ->     
tgt.value    ;

  src.value     : 
Attachment    
 ->     
tgt.value    ;

  src.value     : 
CodeableConcept    
 ->     
tgt.value    ;

  src.value     : 
Coding    
 ->     
tgt.value    ;
     // 
    src.value : CodeableReference -> tgt.value;

  src.value     : 
ContactPoint    
 ->     
tgt.value    ;

  src.value     : 
Count    
 ->     
tgt.value    ;

  src.value     : 
Distance    
 ->     
tgt.value    ;

  src.value     : 
Duration    
 ->     
tgt.value    ;

  src.value     : 
HumanName    
 ->     
tgt.value    ;

  src.value     : 
Identifier    
 ->     
tgt.value    ;

  src.value     : 
Money    
 ->     
tgt.value    ;

  src.value     : 
Period    
 ->     
tgt.value    ;

  src.value     : 
Quantity    
 ->     
tgt.value    ;

  src.value     : 
Range    
 ->     
tgt.value    ;

  src.value     : 
Ratio    
 ->     
tgt.value    ;

  src.value     : 
Reference    
 ->     
tgt.value    ;
     // 
    src.value : RatioRange -> tgt.value;

  src.value     : 
SampledData    
 ->     
tgt.value    ;

  src.value     : 
Signature    
 ->     
tgt.value    ;

  src.value     : 
Timing    
 ->     
tgt.value    ;

  src.value     : 
ContactDetail    
 ->     
tgt.value    ;

  src.value     : 
DataRequirement    
 ->     
tgt.value    ;

  src.value     : 
Expression    
 ->     
tgt.value    ;

  src.value     : 
ParameterDefinition    
 ->     
tgt.value    ;

  src.value     : 
RelatedArtifact    
 ->     
tgt.value    ;

  src.value     : 
TriggerDefinition    
 ->     
tgt.value    ;

  src.value     : 
UsageContext    
 ->     
tgt.value    ;

  src.value     : 
Dosage    
 ->     
tgt.value    ;
     // 
    src.value : Availability -> tgt.value;

  src.value     : 
Meta    
 ->     
tgt.value    ;

    }


    group 
ElementDefinitionConstraint    (
    source
     src
,     target
     tgt
    )
     extends 
Element     {

  src.key    
 ->     
tgt.key    ;

  src.requirements    
 ->     
tgt.requirements    ;

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

  src.human    
 ->     
tgt.human    ;
     // 
    src.suppress -> tgt.suppress;

  src.expression    
 ->     
tgt.expression    ;

  src.source    
 ->     
tgt.source    ;

    }


    group 
ElementDefinitionBinding    (
    source
     src
,     target
     tgt
    )
     extends 
Element     {

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

  src.description    
 ->     
tgt.description    ;

  src.valueSet    
 ->     
tgt.valueSet    ;

    }


    group 
ElementDefinitionMapping    (
    source
     src
,     target
     tgt
    )
     extends 
Element     {

  src.identity    
 ->     
tgt.identity    ;

  src.language    
 ->     
tgt.language    ;

  src.map    
 ->     
tgt.map    ;

  src.comment    
 ->     
tgt.comment    ;

    }