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

    
/// name = 
    
    'DeviceDefinition4Bto5'

    
/// title = 
    
    'FML Conversion for DeviceDefinition: R4B to R5'

    
/// status = 
    
    'active'


    conceptmap
     "
DeviceNameType    " {

      prefix 
s     = "
http://hl7.org/fhir/4.3/device-nametype    "

      prefix 
t     = "
    http://hl7.org/fhir/device-nametype
    "


  s    :
"udi-label-name"     -
 t    :
    "
registered-name    "

  s    :
"user-friendly-name"     -
 t    :
    "
user-friendly-name    "

  s    :
"patient-reported-name"     -
 t    :
    "
patient-reported-name    "

  s    :
"manufacturer-name"     -
 t    :
    "
registered-name    "

  s    :
"model-name"     -
 t    :
    "
registered-name    "

  s    :
other     -
 t    :
    "
registered-name    "

    }


    uses
     "
http://hl7.org/fhir/4.3/StructureDefinition/DeviceDefinition    " 
    alias 
DeviceDefinitionR4B     as 
    source

    uses
     "
    http://hl7.org/fhir/StructureDefinition/DeviceDefinition
    " 
    alias 
DeviceDefinitionR5     as 
    target


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


    group 
DeviceDefinition    (
    source
     src
     : 
DeviceDefinitionR4B,     target
     tgt
     : 
DeviceDefinitionR5    )
     extends 
DomainResource     <<type+>>
     {

  src.identifier    
 ->     
tgt.identifier    ;
     // 
    src.description -> tgt.description;

  src.udiDeviceIdentifier     as 
    s
    
 ->     
tgt.udiDeviceIdentifier     as 
    t
     then 
DeviceDefinitionUdiDeviceIdentifier    (
    s
    , 
    t
    )
    ;

  src.manufacturer     : 
Reference    
 ->     
tgt.manufacturer    ;
     // 
    src.regulatoryIdentifier as s -> tgt.regulatoryIdentifier as t then DeviceDefinitionRegulatoryIdentifier(s,t);

  src.deviceName     as 
    s
    
 ->     
tgt.deviceName     as 
    t
     then 
DeviceDefinitionDeviceName    (
    s
    , 
    t
    )
    ;

  src.modelNumber    
 ->     
tgt.modelNumber    ;

  src.version     as 
    s
    
 ->     
 tgt.version     as 
    t
    , 
 t.value =     s
    ;
     // 
    src.classification as s -> tgt.classification as t then DeviceDefinitionClassification(s,t);

  src.safety    
 ->     
tgt.safety    ;

  src.shelfLifeStorage    
 ->     
tgt.shelfLifeStorage    ;

  src.languageCode    
 ->     
tgt.languageCode    ;

  src.property     as 
    s
    
 ->     
tgt.property     as 
    t
     then 
DeviceDefinitionProperty    (
    s
    , 
    t
    )
    ;

  src.owner    
 ->     
tgt.owner    ;

  src.contact    
 ->     
tgt.contact    ;

  src.note    
 ->     
tgt.note    ;
     // 
    src.link as s -> tgt.link as t then DeviceDefinitionLink(s,t);

  src.material     as 
    s
    
 ->     
tgt.material     as 
    t
     then 
DeviceDefinitionMaterial    (
    s
    , 
    t
    )
    ;

    }


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

  src.deviceIdentifier    
 ->     
tgt.deviceIdentifier    ;

  src.issuer    
 ->     
tgt.issuer    ;

  src.jurisdiction    
 ->     
tgt.jurisdiction    ;

    }


    // 
    group DeviceDefinitionUdiDeviceIdentifierMarketDistribution(source src, target tgt) extends BackboneElement {

    // src.marketPeriod -> tgt.marketPeriod;

    // src.subJurisdiction -> tgt.subJurisdiction;

    // 
    }

    // 
    group DeviceDefinitionRegulatoryIdentifier(source src, target tgt) extends BackboneElement {

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

    // src.deviceIdentifier -> tgt.deviceIdentifier;

    // src.issuer -> tgt.issuer;

    // src.jurisdiction -> tgt.jurisdiction;

    // 
    }

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

  src.name    
 ->     
tgt.name    ;

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

    }


    // 
    group DeviceDefinitionClassification(source src, target tgt) extends BackboneElement {

    // src.type -> tgt.type;

    // src.justification -> tgt.justification;

    // 
    }

    // 
    group DeviceDefinitionConformsTo(source src, target tgt) extends BackboneElement {

    // src.category -> tgt.category;

    // src.specification -> tgt.specification;

    // src.version -> tgt.version;

    // src.source -> tgt.source;

    // 
    }

    // 
    group DeviceDefinitionHasPart(source src, target tgt) extends BackboneElement {

    // src.reference -> tgt.reference;

    // src.count -> tgt.count;

    // 
    }

    // 
    group DeviceDefinitionPackaging(source src, target tgt) extends BackboneElement {

    // src.identifier -> tgt.identifier;

    // src.type -> tgt.type;

    // src.count -> tgt.count;

    // src.distributor as s -> tgt.distributor as t then DeviceDefinitionPackagingDistributor(s,t);

    // 
    }

    // 
    group DeviceDefinitionPackagingDistributor(source src, target tgt) extends BackboneElement {

    // src.name -> tgt.name;

    // src.organizationReference -> tgt.organizationReference;

    // 
    }

    // 
    group DeviceDefinitionVersion(source src, target tgt) extends BackboneElement {

    // src.type -> tgt.type;

    // src.component -> tgt.component;

    // src.value -> tgt.value;

    // 
    }

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

  src.type    
 ->     
tgt.type    ;

  src.valueQuantity     : 
Quantity    
 ->     
tgt.value    ;

  src.valueCode     : 
CodeableConcept    
 ->     
tgt.value    ;

    }


    // 
    group DeviceDefinitionLink(source src, target tgt) extends BackboneElement {

    // src.relation -> tgt.relation;

    // src.relatedDevice -> tgt.relatedDevice;

    // 
    }

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

  src.substance    
 ->     
tgt.substance    ;

  src.alternate    
 ->     
tgt.alternate    ;

  src.allergenicIndicator    
 ->     
tgt.allergenicIndicator    ;

    }