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

    
/// name = 
    
    'Device5to4B'

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

    
/// status = 
    
    'active'


    conceptmap
     "
DeviceNameType    " {

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

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


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

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

    }


    conceptmap
     "
FHIRDeviceStatus    " {

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

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


  s    :
active     -
 t    :
active
  s    :
inactive     -
 t    :
inactive
  s    :
"entered-in-error"     -
 t    :
    "
entered-in-error    "

    }


    conceptmap
     "
UDIEntryType    " {

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

      prefix 
t     = "
http://hl7.org/fhir/4.3/udi-entry-type    "


  s    :
barcode     -
 t    :
barcode
  s    :
rfid     -
 t    :
rfid
  s    :
manual     -
 t    :
manual
  s    :
card     -
 t    :
card
  s    :
"self-reported"     -
 t    :
    "
self-reported    "

  s    :
unknown     -
 t    :
unknown
    }


    uses
     "
    http://hl7.org/fhir/StructureDefinition/Device
    " 
    alias 
DeviceR5     as 
    source

    uses
     "
http://hl7.org/fhir/4.3/StructureDefinition/Device    " 
    alias 
DeviceR4B     as 
    target


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


    group 
Device    (
    source
     src
     : 
DeviceR5,     target
     tgt
     : 
DeviceR4B    )
     extends 
DomainResource     <<type+>>
     {

  src.identifier    
 ->     
tgt.identifier    ;

  src.definition    
 ->     
tgt.definition    ;
     // 
    src.displayName -> tgt.displayName;

  src.udiCarrier     as 
    s
    
 ->     
tgt.udiCarrier     as 
    t
     then 
DeviceUdiCarrier    (
    s
    , 
    t
    )
    ;

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

  src.manufacturer    
 ->     
tgt.manufacturer    ;
     // 
    src.availabilityStatus -> tgt.availabilityStatus;

  src.manufactureDate    
 ->     
tgt.manufactureDate    ;

  src.expirationDate    
 ->     
tgt.expirationDate    ;

  src.lotNumber    
 ->     
tgt.lotNumber    ;

  src.serialNumber    
 ->     
tgt.serialNumber    ;

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

  src.modelNumber    
 ->     
tgt.modelNumber    ;

  src.partNumber    
 ->     
tgt.partNumber    ;

  src.type    
 ->     
tgt.type    ;
     // 
    src.category -> tgt.category;

  src.version     as 
    s
    
 ->     
tgt.version     as 
    t
     then 
DeviceVersion    (
    s
    , 
    t
    )
    ;

  src.property     as 
    s
    
 ->     
tgt.property     as 
    t
     then 
DeviceProperty    (
    s
    , 
    t
    )
    ;
     // 
    src.conformsTo as s -> tgt.conformsTo as t then DeviceConformsTo(s,t);

  src.owner    
 ->     
tgt.owner    ;
     // 
    src.mode -> tgt.mode;

  src.contact    
 ->     
tgt.contact    ;

  src.location    
 ->     
tgt.location    ;

  src.url    
 ->     
tgt.url    ;

  src.note    
 ->     
tgt.note    ;
     // 
    src.endpoint -> tgt.endpoint;

  src.safety    
 ->     
tgt.safety    ;

  src.parent    
 ->     
tgt.parent    ;

    }


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

  src.deviceIdentifier    
 ->     
tgt.deviceIdentifier    ;

  src.issuer    
 ->     
tgt.issuer    ;

  src.jurisdiction    
 ->     
tgt.jurisdiction    ;

  src.carrierAIDC    
 ->     
tgt.carrierAIDC    ;

  src.carrierHRF    
 ->     
tgt.carrierHRF    ;

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

    }


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

  src.value    
 ->     
tgt.name    ;

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

    }


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

  src.type    
 ->     
tgt.type    ;

  src.component    
 ->     
tgt.component    ;

  src.value    
 ->     
tgt.value    ;
     // 
    src.installDate -> tgt.installDate;

    }


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

    // src.category -> tgt.category;

    // src.specification -> tgt.specification;

    // src.version -> tgt.version;

    // 
    }

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

  src.type    
 ->     
tgt.type    ;

  src.value     : 
Quantity    
 ->     
tgt.valueQuantity    ;

  src.value     : 
CodeableConcept    
 ->     
tgt.valueCode    ;

    }