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

    
/// name = 
    
    'AuditEvent4to5'

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

    
/// status = 
    
    'active'


    conceptmap
     "
AuditEventAction    " {

      prefix 
s     = "
http://hl7.org/fhir/4.0/audit-event-action    "

      prefix 
t     = "
    http://hl7.org/fhir/audit-event-action
    "


  s    :
C     -
 t    :
C
  s    :
R     -
 t    :
R
  s    :
U     -
 t    :
U
  s    :
D     -
 t    :
D
  s    :
E     -
 t    :
E
    }


    uses
     "
http://hl7.org/fhir/4.0/StructureDefinition/AuditEvent    " 
    alias 
AuditEventR4     as 
    source

    uses
     "
    http://hl7.org/fhir/StructureDefinition/AuditEvent
    " 
    alias 
AuditEventR5     as 
    target


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


    group 
AuditEvent    (
    source
     src
     : 
AuditEventR4,     target
     tgt
     : 
AuditEventR5    )
     extends 
DomainResource     <<type+>>
     {

  src.type    
 ->     
tgt.category    ;

  src.subtype    
 ->     
tgt.code    ;

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

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

  src.outcome     as 
    s
     where 
outcome = '0'    
 ->     
 tgt.outcome     as 
    t
    , 
 t.code =     create
    (
    'Coding'
    )
     as 
    tc
    , 
 tc.system =     'http://hl7.org/fhir/issue-severity'
    , 
 tc.code =     'success'
    , 
 tc.display =     'Success'
    ;

  src.outcome     as 
    s
     where 
outcome = '4'    
 ->     
 tgt.outcome     as 
    t
    , 
 t.code =     create
    (
    'Coding'
    )
     as 
    tc
    , 
 tc.system =     'http://hl7.org/fhir/issue-severity'
    , 
 tc.code =     'warning'
    , 
 tc.display =     'Warning'
    ;

  src.outcome     as 
    s
     where 
outcome = '8'    
 ->     
 tgt.outcome     as 
    t
    , 
 t.code =     create
    (
    'Coding'
    )
     as 
    tc
    , 
 tc.system =     'http://hl7.org/fhir/issue-severity'
    , 
 tc.code =     'error'
    , 
 tc.display =     'error'
    ;

  src.outcome     as 
    s
     where 
outcome = '12'    
 ->     
 tgt.outcome     as 
    t
    , 
 t.code =     create
    (
    'Coding'
    )
     as 
    tc
    , 
 tc.system =     'http://hl7.org/fhir/issue-severity'
    , 
 tc.code =     'fatal'
    , 
 tc.display =     'Fatal'
    ;

  src.agent     as 
    s
    
 ->     
tgt.agent     as 
    t
     then 
AuditEventAgent    (
    s
    , 
    t
    )
    ;
     // 
    src.authorization -> tgt.authorization;

  src.source     as 
    s
    
 ->     
tgt.source     as 
    t
     then 
AuditEventSource    (
    s
    , 
    t
    )
    ;

  src.entity     as 
    s
    
 ->     
tgt.entity     as 
    t
     then 
AuditEventEntity    (
    s
    , 
    t
    )
    ;

    }


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

    // src.code -> tgt.code;

    // src.detail -> tgt.detail;

    // 
    }

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

  src.type    
 ->     
tgt.type    ;

  src.role    
 ->     
tgt.role    ;

  src.who    
 ->     
tgt.who    ;

  src.requestor    
 ->     
tgt.requestor    ;

  src.location    
 ->     
tgt.location    ;

  src.policy    
 ->     
tgt.policy    ;

  src.network     as 
    v
    
 ->     
    tgt
     then
     {

    v.address    
 ->     
tgt.network    ;

      }
    ;
     // 
    src.network : Reference -> tgt.network;

  src.purposeOfUse    
 ->     
tgt.authorization    ;

    }


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

  src.site     as 
    v
    
 ->     
 tgt.site =     create
    (
    'Reference'
    )
     as 
    t
    , 
 t.display =     v
    ;

  src.observer    
 ->     
tgt.observer    ;

  src.type    
 ->     
tgt.type    ;

    }


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

  src.what    
 ->     
tgt.what    ;

  src.role    
 ->     
tgt.role    ;

  src.securityLabel    
 ->     
tgt.securityLabel    ;

  src.query    
 ->     
tgt.query    ;

  src.detail     as 
    s
    
 ->     
tgt.detail     as 
    t
     then 
AuditEventEntityDetail    (
    s
    , 
    t
    )
    ;

    }


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

  src.type    
 ->     
tgt.type    ;

  src.value     : 
string    
 ->     
tgt.value    ;
     // 
    src.value : Quantity -> tgt.value;

  src.value     : 
base64Binary    
 ->     
tgt.value    ;
     // 
    src.value : boolean -> tgt.value;

    }