/// url = 'http://hl7.org/fhir/StructureMap/TestScript4to5'
/// name = 'TestScript4to5'
/// title = 'FML Conversion for TestScript: R4 to R5'
/// status = 'active'

conceptmap "AssertionDirectionType" {
  prefix s = "http://hl7.org/fhir/4.0/assert-direction-codes"
  prefix t = "http://hl7.org/fhir/assert-direction-codes"

  s:response - t:response
  s:request - t:request
}

conceptmap "AssertionOperatorType" {
  prefix s = "http://hl7.org/fhir/4.0/assert-operator-codes"
  prefix t = "http://hl7.org/fhir/assert-operator-codes"

  s:equals - t:equals
  s:notEquals - t:notEquals
  s:in - t:in
  s:notIn - t:notIn
  s:greaterThan - t:greaterThan
  s:lessThan - t:lessThan
  s:empty - t:empty
  s:notEmpty - t:notEmpty
  s:contains - t:contains
  s:notContains - t:notContains
  s:eval - t:eval
}

conceptmap "AssertionResponseTypes" {
  prefix s = "http://hl7.org/fhir/4.0/assert-response-code-types"
  prefix t = "http://hl7.org/fhir/assert-response-code-types"

  s:okay - t:okay
  s:created - t:created
  s:noContent - t:noContent
  s:notModified - t:notModified
  s:bad - t:badRequest
  s:forbidden - t:forbidden
  s:notFound - t:notFound
  s:methodNotAllowed - t:methodNotAllowed
  s:conflict - t:conflict
  s:gone - t:gone
  s:preconditionFailed - t:preconditionFailed
  s:unprocessable - t:unprocessableContent
}

conceptmap "PublicationStatus" {
  prefix s = "http://hl7.org/fhir/4.0/publication-status"
  prefix t = "http://hl7.org/fhir/publication-status"

  s:draft - t:draft
  s:active - t:active
  s:retired - t:retired
  s:unknown - t:unknown
}

conceptmap "TestScriptRequestMethodCode" {
  prefix s = "http://hl7.org/fhir/4.0/http-operations"
  prefix t = "http://hl7.org/fhir/http-operations"

  s:delete - t:delete
  s:get - t:get
  s:options - t:options
  s:patch - t:patch
  s:post - t:post
  s:put - t:put
  s:head - t:head
}

uses "http://hl7.org/fhir/4.0/StructureDefinition/TestScript" alias TestScriptR4 as source
uses "http://hl7.org/fhir/StructureDefinition/TestScript" alias TestScriptR5 as target

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

group TestScript(source src : TestScriptR4, target tgt : TestScriptR5) extends DomainResource <<type+>> {
  src.url -> tgt.url;
  src.identifier -> tgt.identifier;
  src.version -> tgt.version;
  src.name -> tgt.name; // src.versionAlgorithm : string -> tgt.versionAlgorithm;
  src.title -> tgt.title;
  src.status as v -> tgt.status = translate(v, '#PublicationStatus', 'code');
  src.experimental -> tgt.experimental;
  src.date -> tgt.date;
  src.publisher -> tgt.publisher;
  src.contact -> tgt.contact;
  src.description -> tgt.description;
  src.useContext -> tgt.useContext;
  src.jurisdiction -> tgt.jurisdiction;
  src.purpose -> tgt.purpose;
  src.copyright -> tgt.copyright;
  src.origin as s -> tgt.origin as t then TestScriptOrigin(s, t); // src.copyrightLabel -> tgt.copyrightLabel;
  src.destination as s -> tgt.destination as t then TestScriptDestination(s, t);
  src.metadata as s -> tgt.metadata as t then TestScriptMetadata(s, t);
  src.fixture as s -> tgt.fixture as t then TestScriptFixture(s, t); // src.scope as s -> tgt.scope as t then TestScriptScope(s,t);
  src.profile -> tgt.profile;
  src.variable as s -> tgt.variable as t then TestScriptVariable(s, t);
  src.setup as s -> tgt.setup as t then TestScriptSetup(s, t);
  src.test as s -> tgt.test as t then TestScriptTest(s, t);
  src.teardown as s -> tgt.teardown as t then TestScriptTeardown(s, t);
}

group TestScriptOrigin(source src, target tgt) extends BackboneElement {
  src.index -> tgt.index;
  src.profile -> tgt.profile;
}

group TestScriptDestination(source src, target tgt) extends BackboneElement {
  src.index -> tgt.index;
  src.profile -> tgt.profile;
}

group TestScriptMetadata(source src, target tgt) extends BackboneElement {
  src.link as s -> tgt.link as t then TestScriptMetadataLink(s, t);
  src.capability as s -> tgt.capability as t then TestScriptMetadataCapability(s, t);
}

group TestScriptMetadataLink(source src, target tgt) extends BackboneElement {
  src.url -> tgt.url;
  src.description -> tgt.description;
}

group TestScriptMetadataCapability(source src, target tgt) extends BackboneElement {
  src.required -> tgt.required;
  src.validated -> tgt.validated;
  src.description -> tgt.description;
  src.origin -> tgt.origin;
  src.destination -> tgt.destination;
  src.link -> tgt.link;
  src.capabilities -> tgt.capabilities;
}

// group TestScriptScope(source src, target tgt) extends BackboneElement {
// src.artifact -> tgt.artifact;
// src.conformance -> tgt.conformance;
// src.phase -> tgt.phase;
// }
group TestScriptFixture(source src, target tgt) extends BackboneElement {
  src.autocreate -> tgt.autocreate;
  src.autodelete -> tgt.autodelete;
  src.resource -> tgt.resource;
}

group TestScriptVariable(source src, target tgt) extends BackboneElement {
  src.name -> tgt.name;
  src.defaultValue -> tgt.defaultValue;
  src.description -> tgt.description;
  src.expression -> tgt.expression;
  src.headerField -> tgt.headerField;
  src.hint -> tgt.hint;
  src.path -> tgt.path;
  src.sourceId -> tgt.sourceId;
}

group TestScriptSetup(source src, target tgt) extends BackboneElement {
  src.action as s -> tgt.action as t then TestScriptSetupAction(s, t);
}

group TestScriptSetupAction(source src, target tgt) extends BackboneElement {
  src.operation as s -> tgt.operation as t then TestScriptSetupActionOperation(s, t);
  src.assert as s -> tgt.assert as t then TestScriptSetupActionAssert(s, t);
}

group TestScriptSetupActionOperation(source src, target tgt) extends BackboneElement {
  src.type -> tgt.type;
  src.resource -> tgt.resource;
  src.label -> tgt.label;
  src.description -> tgt.description;
  src.accept -> tgt.accept;
  src.contentType -> tgt.contentType;
  src.destination -> tgt.destination;
  src.encodeRequestUrl -> tgt.encodeRequestUrl;
  src.method as v -> tgt.method = translate(v, '#TestScriptRequestMethodCode', 'code');
  src.origin -> tgt.origin;
  src.params -> tgt.params;
  src.requestHeader as s -> tgt.requestHeader as t then TestScriptSetupActionOperationRequestHeader(s, t);
  src.requestId -> tgt.requestId;
  src.responseId -> tgt.responseId;
  src.sourceId -> tgt.sourceId;
  src.targetId -> tgt.targetId;
  src.url -> tgt.url;
}

group TestScriptSetupActionOperationRequestHeader(source src, target tgt) extends BackboneElement {
  src.field -> tgt.field;
  src.value -> tgt.value;
}

group TestScriptSetupActionAssert(source src, target tgt) extends BackboneElement {
  src.label -> tgt.label;
  src.description -> tgt.description;
  src.direction as v -> tgt.direction = translate(v, '#AssertionDirectionType', 'code');
  src.compareToSourceId -> tgt.compareToSourceId;
  src.compareToSourceExpression -> tgt.compareToSourceExpression;
  src.compareToSourcePath -> tgt.compareToSourcePath;
  src.contentType -> tgt.contentType;
  src.expression -> tgt.expression; // src.defaultManualCompletion as v -> tgt.defaultManualCompletion = translate(v, '#AssertionManualCompletionType', 'code');
  src.headerField -> tgt.headerField;
  src.minimumId -> tgt.minimumId;
  src.navigationLinks -> tgt.navigationLinks;
  src.operator as v -> tgt.operator = translate(v, '#AssertionOperatorType', 'code');
  src.path -> tgt.path;
  src.requestMethod as v -> tgt.requestMethod = translate(v, '#TestScriptRequestMethodCode', 'code');
  src.requestURL -> tgt.requestURL;
  src.resource -> tgt.resource;
  src.response as v -> tgt.response = translate(v, '#AssertionResponseTypes', 'code');
  src.responseCode -> tgt.responseCode;
  src.sourceId -> tgt.sourceId;
  src.validateProfileId -> tgt.validateProfileId; // src.stopTestOnFail -> tgt.stopTestOnFail;
  src.value -> tgt.value;
  src.warningOnly -> tgt.warningOnly;
}

// group TestScriptSetupActionAssertRequirement(source src, target tgt) extends BackboneElement {
// src.link : uri -> tgt.link;
// src.link : canonical -> tgt.link;
// }
group TestScriptTest(source src, target tgt) extends BackboneElement {
  src.name -> tgt.name;
  src.description -> tgt.description;
  src.action as s -> tgt.action as t then TestScriptTestAction(s, t);
}

group TestScriptTestAction(source src, target tgt) extends BackboneElement {
  src.operation as s -> tgt.operation as t then TestScriptSetupActionOperation(s, t);
  src.assert as s -> tgt.assert as t then TestScriptSetupActionAssert(s, t);
}

group TestScriptTeardown(source src, target tgt) extends BackboneElement {
  src.action as s -> tgt.action as t then TestScriptTeardownAction(s, t);
}

group TestScriptTeardownAction(source src, target tgt) extends BackboneElement {
  src.operation as s -> tgt.operation as t then TestScriptSetupActionOperation(s, t);
}