{
  "resourceType": "StructureDefinition",
  "id": "Device",
  "meta": {
    "lastUpdated": "2019-10-31T22:29:23.356+00:00"
  },
  "extension": [
    {
      "url": "http://hl7.org/fhir/StructureDefinition/structuredefinition-category",
      "valueString": "Base.Entities"
    },
    {
      "url": "http://hl7.org/fhir/StructureDefinition/structuredefinition-standards-status",
      "valueCode": "trial-use"
    },
    {
      "url": "http://hl7.org/fhir/StructureDefinition/structuredefinition-fmm",
      "valueInteger": 2
    },
    {
      "url": "http://hl7.org/fhir/StructureDefinition/structuredefinition-security-category",
      "valueCode": "business"
    },
    {
      "url": "http://hl7.org/fhir/StructureDefinition/structuredefinition-wg",
      "valueCode": "oo"
    }
  ],
  "url": "http://hl7.org/fhir/StructureDefinition/Device",
  "version": "4.0.1",
  "name": "KR_Device",
  "status": "draft",
  "date": "2019-10-31T22:29:23+00:00",
  "publisher": "Health Level Seven International (Orders and Observations)",
  "contact": [
    {
      "telecom": [
        {
          "system": "url",
          "value": "http://hl7.org/fhir"
        }
      ]
    },
    {
      "telecom": [
        {
          "system": "url",
          "value": "http://www.hl7.org/Special/committees/orders/index.cfm"
        }
      ]
    }
  ],
  "description": "해당 액티비티(activity)를 통해 크게 변경되지 않고, 의료 서비스 제공에 사용되는 제조 품목 유형(type)임. Device[]는 의료 또는 비-의료 기기(device)일 수 있음.",
  "purpose": "Allows institutions to track their devices.",
  "fhirVersion": "4.0.1",
  "mapping": [
    {
      "identity": "rim",
      "uri": "http://hl7.org/v3",
      "name": "RIM Mapping"
    },
    {
      "identity": "w5",
      "uri": "http://hl7.org/fhir/fivews",
      "name": "FiveWs Pattern Mapping"
    },
    {
      "identity": "udi",
      "uri": "http://fda.gov/UDI",
      "name": "UDI Mapping"
    }
  ],
  "kind": "resource",
  "abstract": false,
  "type": "Device",
  "baseDefinition": "http://hl7.org/fhir/StructureDefinition/DomainResource",
  "derivation": "specialization",
  "differential": {
    "element": [
      {
        "id": "Device",
        "path": "Device",
        "short": "헬스케어에 사용된 도구/기기",
        "definition": "해당 액티비티(activity)를 통해 크게 변경되지 않고, 의료 서비스 제공에 사용되는 제조 품목 유형임. Device[]는 의료 또는 비-의료 장치일 수 있음.",
        "mapping": [
          {
            "identity": "rim",
            "map": "Device"
          }
        ]
      },
      {
        "id": "Device.id",
        "path": "Device.id",
        "short": "이 아티팩스(artifact)의 논리적 ID",
        "definition": "리소스의 URL에서 사용되는 리소스의 논리적 ID임. 할당되면, 이 값은 변경되지 않음"
      },
      {
        "id": "Device.meta",
        "path": "Device.meta",
        "short": "리소스에 대한 메타 데이터",
        "definition": "리소스에 대한 메타 데이터임. 이것은 인프라에 의해 유지관리되는 내용(content)임. 내용(content) 변경 사항이 항상 리소스의 버전 변경 사항과 연관되어 있지는 않을 수 있음."
      },
      {
        "id": "Device.meta.id",
        "path": "Device.meta.id",
        "short": "요소-간의 참조를 위한 고유 ID",
        "definition": "리소스 안의 요소의 고유 ID(내부 참조용)임. 공백이 없는 문자열 값일수 있음."
      },
      {
        "id": "Device.meta.versionId",
        "path": "Device.meta.versionId",
        "short": "버전별 식별자",
        "definition": "URL의 버전 부분에 나타나는 버전별 식별자임. 이 값은 리소스가 생성,업데이트, 또는 삭제될 떄 변경됨."
      },
      {
        "id": "Device.meta.lastUpdated",
        "path": "Device.meta.lastUpdated",
        "short": "리소스 버전이 마지막으로 변경된 시점",
        "definition": "리소스가 마지막으로 변경된 경우 - 예를 들어 버전이 변경된 경우"
      },
      {
        "id": "Device.meta.source",
        "path": "Device.meta.source",
        "short": "리소스의 출처 식별",
        "definition": "리소스의 소스 시스템을 식별하는 uri. 이를 통해 리소스 정보의 출처를 추적하거나, 차별화 하는데 사용 할수 있는 최소한의 [Provenance](provenance.html#) 정보를 얻을 수 있음. 소스가 다른 FHIR 서버, 문서, 메시지 데이터베이스 등을 식별할수 있음."
      },
      {
        "id": "Device.meta.profile",
        "path": "Device.meta.profile",
        "short": "이 리소스가 준수한다고 주장하는 Profiles[프로파일]",
        "definition": "이 리소스가 준수한다고 주장하는 프로필 목록 ([StructureDefinition] (structuredefinition.html #) 리소스에 대한 참조)임. URL은 [StructureDefinition.url] (structuredefinition-definitions.html # StructureDefinition.url)에 대한 참조임."
      },
      {
        "id": "Device.meta.security",
        "path": "Device.meta.security",
        "short": "이 리소스에 적용된 보안 레이블",
        "definition": "이 리소스에 적용된 보안 레이블임. 이러한 태그는 특정 리소스를 전체 보안 정책 및 인프라에 연결함"
      },
      {
        "id": "Device.meta.security.id",
        "path": "Device.meta.security.id",
        "short": "요소-간의 참조를 위한 고유 ID",
        "definition": "리소스 안의 요소의 고유 ID(내부 참조용)임. 공백이 없는 문자열 값일수 있음."
      },
      {
        "id": "Device.meta.security.system",
        "path": "Device.meta.security.system",
        "short": "해당 전문용어체계(terminology system)의 식별",
        "definition": "코드에서 기호의 의미를 정의하는 CodeSystem[코드시스템]를 식별"
      },
      {
        "id": "Device.meta.security.version",
        "path": "Device.meta.security.version",
        "short": "해당 시스템의 버전 정보 - 필요한 경우",
        "definition": "해당 코드를 선택한 시점에 사용된 코드 시스템의 버전임. 올바로 관리된 코드 시스템은 코드의 의미가 버전과 관계없이 일관적이므로 버전을 보고할 필요가 없음. 그러나 코드 시스템의 관리 상태는 지속적으로 보장할 수 없는 부분이며, 코드의 의미가 일관적임을 보장할 수 없는 경우 버전이 교체되어야 함."
      },
      {
        "id": "Device.meta.security.code",
        "path": "Device.meta.security.code",
        "short": "시스템에 정의된 구문(syntax)의 기호(symbol)",
        "definition": "시스템에 정의된 구문의 기호. 기호는 CodeSystem[코드시스템]에 의해 정의된 구문에서 미리 정의된 코드 또는 표현(expression)일 수 있음. (예: post-coordination)"
      },
      {
        "id": "Device.meta.security.display",
        "path": "Device.meta.security.display",
        "short": "시스템에 정의된 표현",
        "definition": "시스템 내 코드의 의미를 시스템의 규칙에 따라 표현한 것을 의미함."
      },
      {
        "id": "Device.meta.security.userSelected",
        "path": "Device.meta.security.userSelected",
        "short": "해당 코딩 방법이 사용자에 의해 직접 선택되었는지 여부",
        "definition": "해당 코딩 방법이 사용자에 의해 직접 선택되었음을 나타냄. 즉, 선택 가능한 항목 (코드 혹은 디스플레이) 목록에 존재하지 않음을 나타냄."
      },
      {
        "id": "Device.meta.tag",
        "path": "Device.meta.tag",
        "short": "이 리소스에 적용된 태그.",
        "definition": "이 리소스에 적용된 태그.  태그는 리소스를 식별하고 프로세스 및 워크플로에 연결하는 데 사용되며, 애플리케이션은 리소스의 의미를 해석할 때 태그를 고려할 필요 없음."
      },
      {
        "id": "Device.meta.tag.id",
        "path": "Device.meta.tag.id",
        "short": "요소-간의 참조를 위한 고유 ID",
        "definition": "리소스 안의 요소의 고유 ID(내부 참조용)임. 공백이 없는 문자열 값일수 있음."
      },
      {
        "id": "Device.meta.tag.system",
        "path": "Device.meta.tag.system",
        "short": "해당 전문용어체계(terminology system)의 식별",
        "definition": "코드에서 기호의 의미를 정의하는 CodeSystem[코드시스템]를 식별"
      },
      {
        "id": "Device.meta.tag.version",
        "path": "Device.meta.tag.version",
        "short": "해당 시스템의 버전 정보 - 필요한 경우",
        "definition": "해당 코드를 선택한 시점에 사용된 코드 시스템의 버전임. 올바로 관리된 코드 시스템은 코드의 의미가 버전과 관계없이 일관적이므로 버전을 보고할 필요가 없음. 그러나 코드 시스템의 관리 상태는 지속적으로 보장할 수 없는 부분이며, 코드의 의미가 일관적임을 보장할 수 없는 경우 버전이 교체되어야 함."
      },
      {
        "id": "Device.meta.tag.code",
        "path": "Device.meta.tag.code",
        "short": "시스템에 정의된 구문(syntax)의 기호(symbol)",
        "definition": "시스템에 정의된 구문의 기호. 기호는 CodeSystem[코드시스템]에 의해 정의된 구문에서 미리 정의된 코드 또는 표현(expression)일 수 있음. (예: post-coordination)"
      },
      {
        "id": "Device.meta.tag.display",
        "path": "Device.meta.tag.display",
        "short": "시스템에 정의된 표현",
        "definition": "시스템 내 코드의 의미를 시스템의 규칙에 따라 표현한 것을 의미함."
      },
      {
        "id": "Device.meta.tag.userSelected",
        "path": "Device.meta.tag.userSelected",
        "short": "해당 코딩 방법이 사용자에 의해 직접 선택되었는지 여부",
        "definition": "해당 코딩 방법이 사용자에 의해 직접 선택되었음을 나타냄. 즉, 선택 가능한 항목 (코드 혹은 디스플레이) 목록에 존재하지 않음을 나타냄."
      },
      {
        "id": "Device.implicitRules",
        "path": "Device.implicitRules",
        "short": "이 내용(content)가 생성된 일련의 규칙",
        "definition": "리소스를 구성될 때, 준수되고 내용(content)를 처리할 때 이해해야 하는 규칙 집합(set of rules)에 대한 참조. 많은 경우, 이것은 다른 Profile[프로파일] 등과 함께 특수 규칙을 정의하는 구현 가이드에 대한 참조임."
      },
      {
        "id": "Device.language",
        "path": "Device.language",
        "short": "리소스 내용(content) 언어",
        "definition": "리소스가 기록된 기본 언어"
      },
      {
        "id": "Device.text",
        "path": "Device.text",
        "short": "사람의 해석을 위한 자원의 텍스트 요약",
        "definition": "리소스 요약을 포함하고 사람에게 리소스 내용을 나타내는 데 사용될 수 있는 사람이 읽을 수 있는 서술임. 서술은 모든 구조화된 데이터를 인코딩할 필요는 없지만, 사람이 서술을 읽기만한다면 \"임상적으로 안전한\" 데이터를 만들기 위해 충분한 세부 정보를 포함해야함. 자원(Resource) 정의는 임상적 안정성을 보장하기 위해 서술에 어떤 내용을 나타내야 하는지를 정의할  수 있음."
      },
      {
        "id": "Device.text.id",
        "path": "Device.text.id",
        "short": "요소-간의 참조를 위한 고유 ID",
        "definition": "리소스 안의 요소의 고유 ID(내부 참조용)임. 공백이 없는 문자열 값일수 있음."
      },
      {
        "id": "Device.text.status",
        "path": "Device.text.status",
        "short": "generated | extensions | additional | empty",
        "definition": "설명의 상태. 자동으로 생성 되었는지, 사람에 의해 수동적으로 생성되었는지, 데이터 추가가 가능한지 여부를 나타냄."
      },
      {
        "id": "Device.text.div",
        "path": "Device.text.div",
        "short": "제한된 XHTML 컨텐츠",
        "definition": "설명의 실제 내용. 가장 기본적인 XHTML 버전임."
      },
      {
        "id": "Device.contained",
        "path": "Device.contained",
        "short": "contained, 인라인(inline) 리소스",
        "definition": "이러한 자원은 자원을 포함하는 자원과 별도로 독립적인 존재가 아님- 독립적으로 식별할 수 없으며, 자체 독립 트랜잭션(transaction,거래) 범위를 가질 수도 없음."
      },
      {
        "id": "Device.identifier",
        "path": "Device.identifier",
        "short": "인스턴스(instance) 식별자",
        "definition": "제조사, 소유자, 또는 다른 조직에 의해 할당 된 기기의 인스턴스(instance) 식별자",
        "comment": "Device[] 레이블 또는 패키지에 있는 바코드의 바코드 문자열은 인스턴스를 식별하거나, 로컬 사용 시 장치에 지정된 이름을 포함하거나, 또는 장치의 유형을 식별함. Device[] 유형을 식별자가 실벽하는 경우, Device.type 요소를 사용해야 함.",
        "type": [
          {
            "code": "Identifier"
          }
        ],
        "mapping": [
          {
            "identity": "w5",
            "map": "FiveWs.identifier"
          },
          {
            "identity": "rim",
            "map": ".id"
          },
          {
            "identity": "udi",
            "map": "The serial number which is a component of the production identifier (PI), a conditional, variable portion of a UDI.   The identifier.type code should be set to “SNO”(Serial Number) and the system left empty."
          }
        ]
      },
      {
        "id": "Device.identifier.id",
        "path": "Device.identifier.id",
        "short": "요소-간의 참조를 위한 고유 ID",
        "definition": "리소스 안의 요소의 고유 ID(내부 참조용)임. 공백이 없는 문자열 값일수 있음."
      },
      {
        "id": "Device.identifier.use",
        "path": "Device.identifier.use",
        "short": "usual | official | temp | secondary | old (If known)",
        "definition": "해당 식별자의 목적"
      },
      {
        "id": "Device.identifier.type",
        "path": "Device.identifier.type",
        "short": "식별자에 대한 설명",
        "definition": "특정 목적으로 사용되는 식별자를 결정하기 위해 사용하는 식별자의 코드 유형을 나타냄."
      },
      {
        "id": "Device.identifier.type.id",
        "path": "Device.identifier.type.id",
        "short": "요소-간의 참조를 위한 고유 ID",
        "definition": "리소스 안의 요소의 고유 ID(내부 참조용)임. 공백이 없는 문자열 값일수 있음."
      },
      {
        "id": "Device.identifier.type.coding",
        "path": "Device.identifier.type.coding",
        "short": "전문용어체계(terminology system)에 의해 정의된 코드",
        "definition": "전문용어체계(terminology system)에 의해 정의된 코드를 참조"
      },
      {
        "id": "Device.identifier.type.coding.id",
        "path": "Device.identifier.type.coding.id",
        "short": "요소-간의 참조를 위한 고유 ID",
        "definition": "리소스 안의 요소의 고유 ID(내부 참조용)임. 공백이 없는 문자열 값일수 있음."
      },
      {
        "id": "Device.identifier.type.coding.system",
        "path": "Device.identifier.type.coding.system",
        "short": "해당 전문용어체계(terminology system)의 식별",
        "definition": "코드에서 기호의 의미를 정의하는 CodeSystem[코드시스템]를 식별"
      },
      {
        "id": "Device.identifier.type.coding.version",
        "path": "Device.identifier.type.coding.version",
        "short": "해당 시스템의 버전 정보 - 필요한 경우",
        "definition": "해당 코드를 선택한 시점에 사용된 코드 시스템의 버전임. 올바로 관리된 코드 시스템은 코드의 의미가 버전과 관계없이 일관적이므로 버전을 보고할 필요가 없음. 그러나 코드 시스템의 관리 상태는 지속적으로 보장할 수 없는 부분이며, 코드의 의미가 일관적임을 보장할 수 없는 경우 버전이 교체되어야 함."
      },
      {
        "id": "Device.identifier.type.coding.code",
        "path": "Device.identifier.type.coding.code",
        "short": "시스템에 정의된 구문(syntax)의 기호(symbol)",
        "definition": "시스템에 정의된 구문의 기호. 기호는 CodeSystem[코드시스템]에 의해 정의된 구문에서 미리 정의된 코드 또는 표현(expression)일 수 있음. (예: post-coordination)"
      },
      {
        "id": "Device.identifier.type.coding.display",
        "path": "Device.identifier.type.coding.display",
        "short": "시스템에 정의된 표현",
        "definition": "시스템 내 코드의 의미를 시스템의 규칙에 따라 표현한 것을 의미함."
      },
      {
        "id": "Device.identifier.type.coding.userSelected",
        "path": "Device.identifier.type.coding.userSelected",
        "short": "해당 코딩 방법이 사용자에 의해 직접 선택되었는지 여부",
        "definition": "해당 코딩 방법이 사용자에 의해 직접 선택되었음을 나타냄. 즉, 선택 가능한 항목 (코드 혹은 디스플레이) 목록에 존재하지 않음을 나타냄."
      },
      {
        "id": "Device.identifier.type.text",
        "path": "Device.identifier.type.text",
        "short": "개념에 대한 일반 텍스트 묘사",
        "definition": "데이터를 입력한 사용자의 입장에서 보거나/선택하거나/언급한대로의 개념, 혹은 사용자가 의도한 의미를 사람이 사용하는 언어로 표현한 것임."
      },
      {
        "id": "Device.identifier.system",
        "path": "Device.identifier.system",
        "short": "식별자 값의 네임스페이스(namespace)",
        "definition": "설정값에 대한 네임 스페이스 (namespace), 즉 고유한 설정값을 설명하는 URL을 설정함."
      },
      {
        "id": "Device.identifier.value",
        "path": "Device.identifier.value",
        "short": "고유 설정값",
        "definition": "일반적으로 식별자의 사용과와 관련이 있으며, 시스템 컨텍스트 (context) 내에서 고유한 식별자의 일부분임."
      },
      {
        "id": "Device.identifier.period",
        "path": "Device.identifier.period",
        "short": "식별자의 유효 기간",
        "definition": "식별자가 사용 가능했거나 가능한 기간을 나타냄."
      },
      {
        "id": "Device.identifier.period.id",
        "path": "Device.identifier.period.id",
        "short": "요소-간의 참조를 위한 고유 ID",
        "definition": "리소스 안의 요소의 고유 ID(내부 참조용)임. 공백이 없는 문자열 값일수 있음."
      },
      {
        "id": "Device.identifier.period.start",
        "path": "Device.identifier.period.start",
        "short": "해당 유효 기간의 시작 시점 (설정된 날짜 포함)",
        "definition": "해당 유효 기간이 시작되는 시점을 나타냄. 유효 기간은 시작 시점으로 설정된 날짜를 포함함."
      },
      {
        "id": "Device.identifier.period.end",
        "path": "Device.identifier.period.end",
        "short": "해당 유효 기간의 종료 시점 (설정된 날짜 포함)",
        "definition": "기간의 종료. 기간의 종료가 누락된 경우, 인스턴스가 생성될 때 끝이 알려지거나 계획되지 않았음을 의미함. 시작일은 과거일 수 있고 종료일은 미래일 수 있음. 이는 해당 기간이 해당 시간에 종료될 예정임을 의미함"
      },
      {
        "id": "Device.identifier.assigner",
        "path": "Device.identifier.assigner",
        "short": "식별자를 발급한 조직 (단순 텍스트 기입 가능)",
        "definition": "식별자를 발급하고 관리하는 조직을 나타냄."
      },
      {
        "id": "Device.identifier.assigner.id",
        "path": "Device.identifier.assigner.id",
        "short": "요소-간의 참조를 위한 고유 ID",
        "definition": "리소스 안의 요소의 고유 ID(내부 참조용)임. 공백이 없는 문자열 값일수 있음."
      },
      {
        "id": "Device.identifier.assigner.reference",
        "path": "Device.identifier.assigner.reference",
        "short": "문안 참조, 상대적, 내부적 혹은 절대적인 URL",
        "definition": "다른 리소스(resource)을 찾을 수 있는 위치에 대한 참조를 의미함. 해당 참조는 service base URL에 상대적인 경우 상대 참조, 혹은 해당 리소스를 찾을 수 있는 위치인 절대 URL일 수 있음. 해당 참조는 버전에 따라 다를 수 있음. 해당 참조가 FHIR RESTful 서버가 아닌 경우, 버전에 따라 다른 것으로 간주함. 내부 구문 참조('#'으로 시작)는 포함되어 있는 리소스를 참조함."
      },
      {
        "id": "Device.identifier.assigner.type",
        "path": "Device.identifier.assigner.type",
        "short": "참조(reference)가 참조하는 유형  (예. \"Patient\")",
        "definition": "참조 대상의 예상 형식임. Reference.type과 Reference.reference가 모두 채워지고 Reference.reference가 FHIR URL이면 두가지 모두 일치해야함. 유형은이 참조가 참조하는 유형 인 리소스 정의의 표준 URL임. 참조는 http://hl7.org/fhir/StructureDefinition/과 관련된 URL임. (예) \" 환자 \" http://hl7.org/fhir/StructureDefinition/Patient에 대한 참조. 절대 URL은 논리 모델에만 허용됨 (리소스가 아닌 논리 모델의 참조에서만 사용할 수 있음)."
      },
      {
        "id": "Device.identifier.assigner.identifier",
        "path": "Device.identifier.assigner.identifier",
        "short": "문안 참조를 알 수 없는 경우의 논리 참조 (logical reference)",
        "definition": "대상 리소스의 식별자. 이것은 다른 리소스를 직접 참조할 방법이 없을 때 사용- 해당 앤티티(entity)가 FHIR 서버를 통해 사용할 수 없거나  리소스 작성자가 알려진 식별자를 실제 위치로 변활할 방법이 없기 때문에 이 방법이 사용됨. Reference.identifier가 실제로 FHIR 인스턴스로 노출되는 것을 가르킬(point) 필요는 없지만, FHIR 인스턴스로 노출될 것으로 예상되는 비즈니스 개념을 가리켜야하며, 해당 인스턴스는 참조가 허용되는 FHIR 리소스 유형이여야함."
      },
      {
        "id": "Device.identifier.assigner.display",
        "path": "Device.identifier.assigner.display",
        "short": "해당 리소스를 대체하는 텍스트 설명",
        "definition": "리소스 참조 외에도 리소스를 식별하기 위한 일반 텍스트 설명임."
      },
      {
        "id": "Device.definition",
        "path": "Device.definition",
        "short": "Device[] 정의에 대한 참조",
        "definition": "Device[] 정의에 대한 참조",
        "max": "1",
        "type": [
          {
            "code": "Reference",
            "targetProfile": [
              "http://hl7.org/fhir/StructureDefinition/DeviceDefinition"
            ]
          }
        ]
      },
      {
        "id": "Device.definition.id",
        "path": "Device.definition.id",
        "short": "요소-간의 참조를 위한 고유 ID",
        "definition": "리소스 안의 요소의 고유 ID(내부 참조용)임. 공백이 없는 문자열 값일수 있음."
      },
      {
        "id": "Device.definition.reference",
        "path": "Device.definition.reference",
        "short": "문안 참조, 상대적, 내부적 혹은 절대적인 URL",
        "definition": "다른 리소스(resource)을 찾을 수 있는 위치에 대한 참조를 의미함. 해당 참조는 service base URL에 상대적인 경우 상대 참조, 혹은 해당 리소스를 찾을 수 있는 위치인 절대 URL일 수 있음. 해당 참조는 버전에 따라 다를 수 있음. 해당 참조가 FHIR RESTful 서버가 아닌 경우, 버전에 따라 다른 것으로 간주함. 내부 구문 참조('#'으로 시작)는 포함되어 있는 리소스를 참조함."
      },
      {
        "id": "Device.definition.type",
        "path": "Device.definition.type",
        "short": "참조(reference)가 참조하는 유형  (예. \"Patient\")",
        "definition": "참조 대상의 예상 형식임. Reference.type과 Reference.reference가 모두 채워지고 Reference.reference가 FHIR URL이면 두가지 모두 일치해야함. 유형은이 참조가 참조하는 유형 인 리소스 정의의 표준 URL임. 참조는 http://hl7.org/fhir/StructureDefinition/과 관련된 URL임. (예) \" 환자 \" http://hl7.org/fhir/StructureDefinition/Patient에 대한 참조. 절대 URL은 논리 모델에만 허용됨 (리소스가 아닌 논리 모델의 참조에서만 사용할 수 있음)."
      },
      {
        "id": "Device.definition.identifier",
        "path": "Device.definition.identifier",
        "short": "문안 참조를 알 수 없는 경우의 논리 참조 (logical reference)",
        "definition": "대상 리소스의 식별자. 이것은 다른 리소스를 직접 참조할 방법이 없을 때 사용- 해당 앤티티(entity)가 FHIR 서버를 통해 사용할 수 없거나  리소스 작성자가 알려진 식별자를 실제 위치로 변활할 방법이 없기 때문에 이 방법이 사용됨. Reference.identifier가 실제로 FHIR 인스턴스로 노출되는 것을 가르킬(point) 필요는 없지만, FHIR 인스턴스로 노출될 것으로 예상되는 비즈니스 개념을 가리켜야하며, 해당 인스턴스는 참조가 허용되는 FHIR 리소스 유형이여야함."
      },
      {
        "id": "Device.definition.identifier.id",
        "path": "Device.definition.identifier.id",
        "short": "요소-간의 참조를 위한 고유 ID",
        "definition": "리소스 안의 요소의 고유 ID(내부 참조용)임. 공백이 없는 문자열 값일수 있음."
      },
      {
        "id": "Device.definition.identifier.use",
        "path": "Device.definition.identifier.use",
        "short": "usual | official | temp | secondary | old (If known)",
        "definition": "해당 식별자의 목적"
      },
      {
        "id": "Device.definition.identifier.type",
        "path": "Device.definition.identifier.type",
        "short": "식별자에 대한 설명",
        "definition": "특정 목적으로 사용되는 식별자를 결정하기 위해 사용하는 식별자의 코드 유형을 나타냄."
      },
      {
        "id": "Device.definition.identifier.type.id",
        "path": "Device.definition.identifier.type.id",
        "short": "요소-간의 참조를 위한 고유 ID",
        "definition": "리소스 안의 요소의 고유 ID(내부 참조용)임. 공백이 없는 문자열 값일수 있음."
      },
      {
        "id": "Device.definition.identifier.type.coding",
        "path": "Device.definition.identifier.type.coding",
        "short": "전문용어체계(terminology system)에 의해 정의된 코드",
        "definition": "전문용어체계(terminology system)에 의해 정의된 코드를 참조"
      },
      {
        "id": "Device.definition.identifier.type.coding.id",
        "path": "Device.definition.identifier.type.coding.id",
        "short": "요소-간의 참조를 위한 고유 ID",
        "definition": "리소스 안의 요소의 고유 ID(내부 참조용)임. 공백이 없는 문자열 값일수 있음."
      },
      {
        "id": "Device.definition.identifier.type.coding.system",
        "path": "Device.definition.identifier.type.coding.system",
        "short": "해당 전문용어체계(terminology system)의 식별",
        "definition": "코드에서 기호의 의미를 정의하는 CodeSystem[코드시스템]를 식별"
      },
      {
        "id": "Device.definition.identifier.type.coding.version",
        "path": "Device.definition.identifier.type.coding.version",
        "short": "해당 시스템의 버전 정보 - 필요한 경우",
        "definition": "해당 코드를 선택한 시점에 사용된 코드 시스템의 버전임. 올바로 관리된 코드 시스템은 코드의 의미가 버전과 관계없이 일관적이므로 버전을 보고할 필요가 없음. 그러나 코드 시스템의 관리 상태는 지속적으로 보장할 수 없는 부분이며, 코드의 의미가 일관적임을 보장할 수 없는 경우 버전이 교체되어야 함."
      },
      {
        "id": "Device.definition.identifier.type.coding.code",
        "path": "Device.definition.identifier.type.coding.code",
        "short": "시스템에 정의된 구문(syntax)의 기호(symbol)",
        "definition": "시스템에 정의된 구문의 기호. 기호는 CodeSystem[코드시스템]에 의해 정의된 구문에서 미리 정의된 코드 또는 표현(expression)일 수 있음. (예: post-coordination)"
      },
      {
        "id": "Device.definition.identifier.type.coding.display",
        "path": "Device.definition.identifier.type.coding.display",
        "short": "시스템에 정의된 표현",
        "definition": "시스템 내 코드의 의미를 시스템의 규칙에 따라 표현한 것을 의미함."
      },
      {
        "id": "Device.definition.identifier.type.coding.userSelected",
        "path": "Device.definition.identifier.type.coding.userSelected",
        "short": "해당 코딩 방법이 사용자에 의해 직접 선택되었는지 여부",
        "definition": "해당 코딩 방법이 사용자에 의해 직접 선택되었음을 나타냄. 즉, 선택 가능한 항목 (코드 혹은 디스플레이) 목록에 존재하지 않음을 나타냄."
      },
      {
        "id": "Device.definition.identifier.type.text",
        "path": "Device.definition.identifier.type.text",
        "short": "개념에 대한 일반 텍스트 묘사",
        "definition": "데이터를 입력한 사용자의 입장에서 보거나/선택하거나/언급한대로의 개념, 혹은 사용자가 의도한 의미를 사람이 사용하는 언어로 표현한 것임."
      },
      {
        "id": "Device.definition.identifier.system",
        "path": "Device.definition.identifier.system",
        "short": "식별자 값의 네임스페이스(namespace)",
        "definition": "설정값에 대한 네임 스페이스 (namespace), 즉 고유한 설정값을 설명하는 URL을 설정함."
      },
      {
        "id": "Device.definition.identifier.value",
        "path": "Device.definition.identifier.value",
        "short": "고유 설정값",
        "definition": "일반적으로 식별자의 사용과와 관련이 있으며, 시스템 컨텍스트 (context) 내에서 고유한 식별자의 일부분임."
      },
      {
        "id": "Device.definition.identifier.period",
        "path": "Device.definition.identifier.period",
        "short": "식별자의 유효 기간",
        "definition": "식별자가 사용 가능했거나 가능한 기간을 나타냄."
      },
      {
        "id": "Device.definition.identifier.period.id",
        "path": "Device.definition.identifier.period.id",
        "short": "요소-간의 참조를 위한 고유 ID",
        "definition": "리소스 안의 요소의 고유 ID(내부 참조용)임. 공백이 없는 문자열 값일수 있음."
      },
      {
        "id": "Device.definition.identifier.period.start",
        "path": "Device.definition.identifier.period.start",
        "short": "해당 유효 기간의 시작 시점 (설정된 날짜 포함)",
        "definition": "해당 유효 기간이 시작되는 시점을 나타냄. 유효 기간은 시작 시점으로 설정된 날짜를 포함함."
      },
      {
        "id": "Device.definition.identifier.period.end",
        "path": "Device.definition.identifier.period.end",
        "short": "해당 유효 기간의 종료 시점 (설정된 날짜 포함)",
        "definition": "기간의 종료. 기간의 종료가 누락된 경우, 인스턴스가 생성될 때 끝이 알려지거나 계획되지 않았음을 의미함. 시작일은 과거일 수 있고 종료일은 미래일 수 있음. 이는 해당 기간이 해당 시간에 종료될 예정임을 의미함"
      },
      {
        "id": "Device.definition.identifier.assigner",
        "path": "Device.definition.identifier.assigner",
        "short": "식별자를 발급한 조직 (단순 텍스트 기입 가능)",
        "definition": "식별자를 발급하고 관리하는 조직을 나타냄."
      },
      {
        "id": "Device.definition.display",
        "path": "Device.definition.display",
        "short": "해당 리소스를 대체하는 텍스트 설명",
        "definition": "리소스 참조 외에도 리소스를 식별하기 위한 일반 텍스트 설명임."
      },
      {
        "id": "Device.udiCarrier",
        "path": "Device.udiCarrier",
        "short": "Unique Device Identifier (UDI) 바코드 문자열",
        "definition": "Device[] 레이블 또는 패키지에 할당된 고유한 장치 식별자 (UDI). 장치는 판매하는 관할권 또는 여러 관할권에 대한 UDIcarrier만 포함할 수 있음으로, 여러 개의 UDIcarrier를 포함할 수 있음.",
        "comment": "UDI는 Device[]의 고유한 인스턴스를 식별하거나, Device[]의 유형만 식별할 수 있음. Device에 대한 UDI 부품의 전체 매핑은 [UDI mappings](device-mappings.html#udi) 참조.",
        "type": [
          {
            "code": "BackboneElement"
          }
        ],
        "isSummary": true,
        "mapping": [
          {
            "identity": "w5",
            "map": "FiveWs.identifier"
          },
          {
            "identity": "rim",
            "map": ".id and .code"
          }
        ]
      },
      {
        "id": "Device.udiCarrier.id",
        "path": "Device.udiCarrier.id",
        "short": "요소-간의 참조를 위한 고유 ID",
        "definition": "리소스 안의 요소의 고유 ID(내부 참조용)임. 공백이 없는 문자열 값일수 있음."
      },
      {
        "id": "Device.udiCarrier.deviceIdentifier",
        "path": "Device.udiCarrier.deviceIdentifier",
        "short": "UDI 내의 필수 고정 부분",
        "definition": "기기식별자 (DI)는 기기의 특정 버전 혹은 모델을 식별하는 UDI의 필수 고정 부분임.",
        "alias": [
          "DI"
        ],
        "max": "1",
        "type": [
          {
            "code": "string"
          }
        ],
        "isSummary": true,
        "mapping": [
          {
            "identity": "w5",
            "map": "FiveWs.what[x]"
          },
          {
            "identity": "rim",
            "map": "Role.id.extension"
          },
          {
            "identity": "udi",
            "map": "The device identifier (DI), a mandatory, fixed portion of a UDI that identifies the labeler and the specific version or model of a device."
          }
        ]
      },
      {
        "id": "Device.udiCarrier.issuer",
        "path": "Device.udiCarrier.issuer",
        "short": "UDI 발급 기관",
        "definition": "UDI 발급 담당 기관, 미국 FDA 발급 담당 기관은 다음과 같음. 1) GS1 : http://hl7.org/fhir/NamingSystem/gs1-di, 2) HIBCC : http://hl7.org/fhir/NamingSystem/hibcc-dI, 3 ) 혈액 용기 용 ICCBBA : http://hl7.org/fhir/NamingSystem/iccbba-blood-di, 4) 다른 장치 용 ICCBA : http://hl7.org/fhir/NamingSystem/iccbba-other-di.",
        "alias": [
          "Barcode System"
        ],
        "max": "1",
        "type": [
          {
            "code": "uri"
          }
        ],
        "mapping": [
          {
            "identity": "rim",
            "map": "Role.id.root"
          },
          {
            "identity": "udi",
            "map": "All UDIs are to be issued under a system operated by an Jurisdiction-accredited issuing agency.\nGS1 DIs: \n http://hl7.org/fhir/NamingSystem/gs1\nHIBCC DIs:\n http://hl7.org/fhir/NamingSystem/hibcc\nICCBBA DIs for blood containers:\n http://hl7.org/fhir/NamingSystem/iccbba-blood\nICCBA DIs for other devices:\n http://hl7.org/fhir/NamingSystem/iccbba-other"
          }
        ]
      },
      {
        "id": "Device.udiCarrier.jurisdiction",
        "path": "Device.udiCarrier.jurisdiction",
        "short": "UDI 관할권",
        "definition": "관할권 내에서 UDI를 생성/관리할 수 있는 기관. 모든 UDI는 단일 네임스페이스(namespace) 내에서 전역적으로 고유한 특성을 가짐. (예 : FDA에 의해 미국에서 관리되는 장치의 UDI 값 // http : //hl7.org/fhir/NamingSystem/fda-udi)",
        "requirements": "Allows a recipient of a UDI to know which database will contain the UDI-associated metadata.",
        "max": "1",
        "type": [
          {
            "code": "uri"
          }
        ],
        "mapping": [
          {
            "identity": "rim",
            "map": "Role.scoper"
          }
        ]
      },
      {
        "id": "Device.udiCarrier.carrierAIDC",
        "path": "Device.udiCarrier.carrierAIDC",
        "short": "기계가 읽을 수 있는 UDI 바코드 문자열",
        "definition": "기기의 포장에 인쇄된 바코드 문자열의 AIDC (Automatic Identification and Data Capture) 표현으로 전체 UDI 를 나타냄. (예 : 바코드 , RFID) AIDC 형식은 base64로 인코딩 되어야 함.",
        "comment": "수동기록으로인한기록의오류를최소화하기위해가능하면항상장치의식별을위해 AIDC 형태의 UDI를스캔하거나다른방법으로사용해야한다. DI 및 PI에대한별도의바코드가있는경우, 레이블에사람이읽을수있는식순으로문자열과 DI를연결함.",
        "alias": [
          "Automatic Identification and Data Capture"
        ],
        "max": "1",
        "type": [
          {
            "code": "base64Binary"
          }
        ],
        "isSummary": true,
        "mapping": [
          {
            "identity": "rim",
            "map": "Role.id.extension"
          },
          {
            "identity": "udi",
            "map": "A unique device identifier (UDI) on a device label a form that uses automatic identification and data capture (AIDC) technology."
          }
        ]
      },
      {
        "id": "Device.udiCarrier.carrierHRF",
        "path": "Device.udiCarrier.carrierHRF",
        "short": "사람이 읽을 수 있는 UDI 바코드 문자열",
        "definition": "기기의 포장에 인쇄되어 있는 바코드 문자열의 HRF (Human readable form) 표현으로 전체 UDI를 나타냄.",
        "comment": "DI 및 PI에 대한 별도의 바코드가 있는 경우, 먼저 문자열을 DI와 연결하고, 레이블에 사람이 읽을 수 있는 표현 순서대로 표기함",
        "alias": [
          "Human Readable Form"
        ],
        "max": "1",
        "type": [
          {
            "code": "string"
          }
        ],
        "isSummary": true,
        "mapping": [
          {
            "identity": "rim",
            "map": "Role.id.extension"
          },
          {
            "identity": "udi",
            "map": "A unique device identifier (UDI) on a device label in plain text"
          }
        ]
      },
      {
        "id": "Device.udiCarrier.entryType",
        "path": "Device.udiCarrier.entryType",
        "short": "barcode | rfid | manual +",
        "definition": "데이터 입력 방법을 나타내는 코드화된 항목(entry).",
        "requirements": "Supports a way to distinguish hand entered from machine read data.",
        "max": "1",
        "type": [
          {
            "code": "code"
          }
        ],
        "binding": {
          "extension": [
            {
              "url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
              "valueString": "UDIEntryType"
            }
          ],
          "strength": "required",
          "description": "Codes to identify how UDI data was entered.",
          "valueSet": "http://hl7.org/fhir/ValueSet/udi-entry-type|4.0.1"
        },
        "mapping": [
          {
            "identity": "rim",
            "map": "NA"
          }
        ]
      },
      {
        "id": "Device.status",
        "path": "Device.status",
        "short": "active | inactive | entered-in-error | unknown",
        "definition": "기기 가용성 상태",
        "comment": "상태(status)에는 Device()가 현재 유효하지 않음으로 표시하는 비활성(inactive) 및 입력 오류(entered-in-error)가 포함되어 있음으로 해당 요소(element)는 수정자(modifier)로 레이블됨.",
        "max": "1",
        "type": [
          {
            "code": "code"
          }
        ],
        "isModifier": true,
        "isModifierReason": "This element is labelled as a modifier because it is a status element that contains status entered-in-error which means that the resource should not be treated as valid",
        "isSummary": true,
        "binding": {
          "extension": [
            {
              "url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
              "valueString": "FHIRDeviceStatus"
            }
          ],
          "strength": "required",
          "description": "The availability status of the device.",
          "valueSet": "http://hl7.org/fhir/ValueSet/device-status|4.0.1"
        },
        "mapping": [
          {
            "identity": "w5",
            "map": "FiveWs.status"
          },
          {
            "identity": "rim",
            "map": ".statusCode"
          }
        ]
      },
      {
        "id": "Device.statusReason",
        "path": "Device.statusReason",
        "short": "online | paused | standby | offline | not-ready | transduc-discon | hw-discon | off",
        "definition": "Device[] 가용성 상태의 원인",
        "type": [
          {
            "code": "CodeableConcept"
          }
        ],
        "binding": {
          "extension": [
            {
              "url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
              "valueString": "FHIRDeviceStatusReason"
            }
          ],
          "strength": "extensible",
          "description": "The availability status reason of the device.",
          "valueSet": "http://hl7.org/fhir/ValueSet/device-status-reason"
        },
        "mapping": [
          {
            "identity": "w5",
            "map": "FiveWs.status"
          }
        ]
      },
      {
        "id": "Device.statusReason.id",
        "path": "Device.statusReason.id",
        "short": "요소-간의 참조를 위한 고유 ID",
        "definition": "리소스 안의 요소의 고유 ID(내부 참조용)임. 공백이 없는 문자열 값일수 있음."
      },
      {
        "id": "Device.statusReason.coding",
        "path": "Device.statusReason.coding",
        "short": "전문용어체계(terminology system)에 의해 정의된 코드",
        "definition": "전문용어체계(terminology system)에 의해 정의된 코드를 참조"
      },
      {
        "id": "Device.statusReason.coding.id",
        "path": "Device.statusReason.coding.id",
        "short": "요소-간의 참조를 위한 고유 ID",
        "definition": "리소스 안의 요소의 고유 ID(내부 참조용)임. 공백이 없는 문자열 값일수 있음."
      },
      {
        "id": "Device.statusReason.coding.system",
        "path": "Device.statusReason.coding.system",
        "short": "해당 전문용어체계(terminology system)의 식별",
        "definition": "코드에서 기호의 의미를 정의하는 CodeSystem[코드시스템]를 식별"
      },
      {
        "id": "Device.statusReason.coding.version",
        "path": "Device.statusReason.coding.version",
        "short": "해당 시스템의 버전 정보 - 필요한 경우",
        "definition": "해당 코드를 선택한 시점에 사용된 코드 시스템의 버전임. 올바로 관리된 코드 시스템은 코드의 의미가 버전과 관계없이 일관적이므로 버전을 보고할 필요가 없음. 그러나 코드 시스템의 관리 상태는 지속적으로 보장할 수 없는 부분이며, 코드의 의미가 일관적임을 보장할 수 없는 경우 버전이 교체되어야 함."
      },
      {
        "id": "Device.statusReason.coding.code",
        "path": "Device.statusReason.coding.code",
        "short": "시스템에 정의된 구문(syntax)의 기호(symbol)",
        "definition": "시스템에 정의된 구문의 기호. 기호는 CodeSystem[코드시스템]에 의해 정의된 구문에서 미리 정의된 코드 또는 표현(expression)일 수 있음. (예: post-coordination)"
      },
      {
        "id": "Device.statusReason.coding.display",
        "path": "Device.statusReason.coding.display",
        "short": "시스템에 정의된 표현",
        "definition": "시스템 내 코드의 의미를 시스템의 규칙에 따라 표현한 것을 의미함."
      },
      {
        "id": "Device.statusReason.coding.userSelected",
        "path": "Device.statusReason.coding.userSelected",
        "short": "해당 코딩 방법이 사용자에 의해 직접 선택되었는지 여부",
        "definition": "해당 코딩 방법이 사용자에 의해 직접 선택되었음을 나타냄. 즉, 선택 가능한 항목 (코드 혹은 디스플레이) 목록에 존재하지 않음을 나타냄."
      },
      {
        "id": "Device.statusReason.text",
        "path": "Device.statusReason.text",
        "short": "개념에 대한 일반 텍스트 묘사",
        "definition": "데이터를 입력한 사용자의 입장에서 보거나/선택하거나/언급한대로의 개념, 혹은 사용자가 의도한 의미를 사람이 사용하는 언어로 표현한 것임."
      },
      {
        "id": "Device.distinctIdentifier",
        "path": "Device.distinctIdentifier",
        "short": "고유한 식별 문자열",
        "definition": "인간 세포, 조직(tissue) 또는 세포 및 조직 기반 제품에 대한 규정에서 요구된 고유한 식별 문자열",
        "comment": "예를 들어, 이는 *연방 규정 코드 21CFR§1271.290(c)*에 따라 규제되는 미국 기기에 적용됨",
        "alias": [
          "Distinct Identification Code (DIC)"
        ],
        "max": "1",
        "type": [
          {
            "code": "string"
          }
        ],
        "mapping": [
          {
            "identity": "w5",
            "map": "FiveWs.what[x]"
          },
          {
            "identity": "rim",
            "map": ".lotNumberText"
          },
          {
            "identity": "udi",
            "map": "The lot or batch number within which a device was manufactured - which is a component of the production identifier (PI), a conditional, variable portion of a UDI."
          }
        ]
      },
      {
        "id": "Device.manufacturer",
        "path": "Device.manufacturer",
        "short": "기기 제조사 이름",
        "definition": "제조사 이름",
        "max": "1",
        "type": [
          {
            "code": "string"
          }
        ],
        "mapping": [
          {
            "identity": "w5",
            "map": "FiveWs.what[x]"
          },
          {
            "identity": "rim",
            "map": ".playedRole[typeCode=MANU].scoper.name"
          },
          {
            "identity": "udi",
            "map": "N/A"
          }
        ]
      },
      {
        "id": "Device.manufactureDate",
        "path": "Device.manufactureDate",
        "short": "기기 제조일",
        "definition": "기기가 제조된 시간과 날짜",
        "max": "1",
        "type": [
          {
            "code": "dateTime"
          }
        ],
        "mapping": [
          {
            "identity": "w5",
            "map": "FiveWs.what[x]"
          },
          {
            "identity": "rim",
            "map": ".existenceTime.low"
          },
          {
            "identity": "udi",
            "map": "The date a specific device was manufactured - which is a component of the production identifier (PI), a conditional, variable portion of a UDI.  For FHIR, The datetime syntax must converted to YYYY-MM-DD[THH:MM:SS].  If hour is present, the minutes and seconds should both be set to “00”."
          }
        ]
      },
      {
        "id": "Device.expirationDate",
        "path": "Device.expirationDate",
        "short": "기기 만료일",
        "definition": "기기의 유효 기간 (해당 되는 경우)",
        "max": "1",
        "type": [
          {
            "code": "dateTime"
          }
        ],
        "mapping": [
          {
            "identity": "w5",
            "map": "FiveWs.what[x]"
          },
          {
            "identity": "rim",
            "map": ".expirationTime"
          },
          {
            "identity": "udi",
            "map": "the expiration date of a specific device -  which is a component of the production identifier (PI), a conditional, variable portion of a UDI.  For FHIR, The datetime syntax must converted to YYYY-MM-DD[THH:MM:SS].  If hour is present, the minutes and seconds should both be set to “00”."
          }
        ]
      },
      {
        "id": "Device.lotNumber",
        "path": "Device.lotNumber",
        "short": "제품의 제조 로트 넘버 (Lot number)",
        "definition": "제조사로부터 할당된 로트 넘버 (Lot number)",
        "max": "1",
        "type": [
          {
            "code": "string"
          }
        ],
        "mapping": [
          {
            "identity": "w5",
            "map": "FiveWs.what[x]"
          },
          {
            "identity": "rim",
            "map": ".lotNumberText"
          },
          {
            "identity": "udi",
            "map": "The lot or batch number within which a device was manufactured - which is a component of the production identifier (PI), a conditional, variable portion of a UDI."
          }
        ]
      },
      {
        "id": "Device.serialNumber",
        "path": "Device.serialNumber",
        "short": "제조업체에서 할당한 일련 번호",
        "definition": "Device[]가 제조될 때, 조직에서 할당한 일련 번호(serial number)",
        "comment": "영-숫자 최대 20",
        "max": "1",
        "type": [
          {
            "code": "string"
          }
        ],
        "mapping": [
          {
            "identity": "w5",
            "map": "FiveWs.what[x]"
          },
          {
            "identity": "rim",
            "map": ".playedRole[typeCode=MANU].id"
          }
        ]
      },
      {
        "id": "Device.deviceName",
        "path": "Device.deviceName",
        "short": "제조업체에서 할당한 Device[] 이름",
        "definition": "장치, UDI 레이블 또는 Device[]를 설명하는 사람이 제공하는 장치의 제조업체 이름을 나타냄. 일반적으로, 사람이 이름을 제공하거나 장치가 DeviceDefinition에서 사용 가능한 이름 중 하나를 나타낼 때 사용됨",
        "type": [
          {
            "code": "BackboneElement"
          }
        ]
      },
      {
        "id": "Device.deviceName.id",
        "path": "Device.deviceName.id",
        "short": "요소-간의 참조를 위한 고유 ID",
        "definition": "리소스 안의 요소의 고유 ID(내부 참조용)임. 공백이 없는 문자열 값일수 있음."
      },
      {
        "id": "Device.deviceName.name",
        "path": "Device.deviceName.name",
        "short": "기기 이름",
        "definition": "기기 이름",
        "alias": [
          "Σ"
        ],
        "min": 1,
        "max": "1",
        "type": [
          {
            "code": "string"
          }
        ]
      },
      {
        "id": "Device.deviceName.type",
        "path": "Device.deviceName.type",
        "short": "udi-label-name | user-friendly-name | patient-reported-name | manufacturer-name | model-name | other",
        "definition": "DeviceName의 종류. UDILabelName | UserFriendlyName | PatientReportedName | ManufactureDeviceName | ModelName.",
        "min": 1,
        "max": "1",
        "type": [
          {
            "code": "code"
          }
        ],
        "binding": {
          "extension": [
            {
              "url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
              "valueString": "DeviceNameType"
            }
          ],
          "strength": "required",
          "description": "The type of name the device is referred by.",
          "valueSet": "http://hl7.org/fhir/ValueSet/device-nametype|4.0.1"
        },
        "mapping": [
          {
            "identity": "w5",
            "map": "FiveWs.what[x]"
          },
          {
            "identity": "rim",
            "map": ".playedRole[typeCode=MANU].code"
          }
        ]
      },
      {
        "id": "Device.modelNumber",
        "path": "Device.modelNumber",
        "short": "Device[] 모델 넘버",
        "definition": "Device[] 모델 넘버",
        "max": "1",
        "type": [
          {
            "code": "string"
          }
        ],
        "mapping": [
          {
            "identity": "w5",
            "map": "FiveWs.what[x]"
          },
          {
            "identity": "rim",
            "map": ".softwareName (included as part)"
          }
        ]
      },
      {
        "id": "Device.partNumber",
        "path": "Device.partNumber",
        "short": "Device[] 파트 넘버",
        "definition": "Device[] 파트 넘버",
        "comment": "영-숫자 최대 20",
        "max": "1",
        "type": [
          {
            "code": "string"
          }
        ],
        "mapping": [
          {
            "identity": "w5",
            "map": "FiveWs.what[x]"
          },
          {
            "identity": "rim",
            "map": ".playedRole[typeCode=MANU].id"
          }
        ]
      },
      {
        "id": "Device.type",
        "path": "Device.type",
        "short": "Device[] 종류 또는 유형",
        "definition": "Device[] 종류 또는 유형",
        "max": "1",
        "type": [
          {
            "code": "CodeableConcept"
          }
        ],
        "binding": {
          "extension": [
            {
              "url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
              "valueString": "DeviceType"
            }
          ],
          "strength": "example",
          "description": "Codes to identify medical devices.",
          "valueSet": "http://hl7.org/fhir/ValueSet/device-type"
        }
      },
      {
        "id": "Device.type.id",
        "path": "Device.type.id",
        "short": "요소-간의 참조를 위한 고유 ID",
        "definition": "리소스 안의 요소의 고유 ID(내부 참조용)임. 공백이 없는 문자열 값일수 있음."
      },
      {
        "id": "Device.type.coding",
        "path": "Device.type.coding",
        "short": "전문용어체계(terminology system)에 의해 정의된 코드",
        "definition": "전문용어체계(terminology system)에 의해 정의된 코드를 참조"
      },
      {
        "id": "Device.type.coding.id",
        "path": "Device.type.coding.id",
        "short": "요소-간의 참조를 위한 고유 ID",
        "definition": "리소스 안의 요소의 고유 ID(내부 참조용)임. 공백이 없는 문자열 값일수 있음."
      },
      {
        "id": "Device.type.coding.system",
        "path": "Device.type.coding.system",
        "short": "해당 전문용어체계(terminology system)의 식별",
        "definition": "코드에서 기호의 의미를 정의하는 CodeSystem[코드시스템]를 식별"
      },
      {
        "id": "Device.type.coding.version",
        "path": "Device.type.coding.version",
        "short": "해당 시스템의 버전 정보 - 필요한 경우",
        "definition": "해당 코드를 선택한 시점에 사용된 코드 시스템의 버전임. 올바로 관리된 코드 시스템은 코드의 의미가 버전과 관계없이 일관적이므로 버전을 보고할 필요가 없음. 그러나 코드 시스템의 관리 상태는 지속적으로 보장할 수 없는 부분이며, 코드의 의미가 일관적임을 보장할 수 없는 경우 버전이 교체되어야 함."
      },
      {
        "id": "Device.type.coding.code",
        "path": "Device.type.coding.code",
        "short": "시스템에 정의된 구문(syntax)의 기호(symbol)",
        "definition": "시스템에 정의된 구문의 기호. 기호는 CodeSystem[코드시스템]에 의해 정의된 구문에서 미리 정의된 코드 또는 표현(expression)일 수 있음. (예: post-coordination)"
      },
      {
        "id": "Device.type.coding.display",
        "path": "Device.type.coding.display",
        "short": "시스템에 정의된 표현",
        "definition": "시스템 내 코드의 의미를 시스템의 규칙에 따라 표현한 것을 의미함."
      },
      {
        "id": "Device.type.coding.userSelected",
        "path": "Device.type.coding.userSelected",
        "short": "해당 코딩 방법이 사용자에 의해 직접 선택되었는지 여부",
        "definition": "해당 코딩 방법이 사용자에 의해 직접 선택되었음을 나타냄. 즉, 선택 가능한 항목 (코드 혹은 디스플레이) 목록에 존재하지 않음을 나타냄."
      },
      {
        "id": "Device.type.text",
        "path": "Device.type.text",
        "short": "개념에 대한 일반 텍스트 묘사",
        "definition": "데이터를 입력한 사용자의 입장에서 보거나/선택하거나/언급한대로의 개념, 혹은 사용자가 의도한 의미를 사람이 사용하는 언어로 표현한 것임."
      },
      {
        "id": "Device.specialization",
        "path": "Device.specialization",
        "short": "Device[]에서 지원되는 기능, 장치가 특정 목적을 위해 준수하고 통신에 사용되는 표준(standards)",
        "definition": "Device[]에서 지원되는 기능, 장치가 특정 목적을 위해 준수하고 통신에 사용되는 표준(standards)",
        "type": [
          {
            "code": "BackboneElement"
          }
        ]
      },
      {
        "id": "Device.specialization.id",
        "path": "Device.specialization.id",
        "short": "요소-간의 참조를 위한 고유 ID",
        "definition": "리소스 안의 요소의 고유 ID(내부 참조용)임. 공백이 없는 문자열 값일수 있음."
      },
      {
        "id": "Device.specialization.systemType",
        "path": "Device.specialization.systemType",
        "short": "운영 및 통신에 사용되는 표준(standard)",
        "definition": "운영 및 통신에 사용되는 표준(standard)",
        "alias": [
          "Σ"
        ],
        "min": 1,
        "max": "1",
        "type": [
          {
            "code": "CodeableConcept"
          }
        ]
      },
      {
        "id": "Device.specialization.systemType.id",
        "path": "Device.specialization.systemType.id",
        "short": "요소-간의 참조를 위한 고유 ID",
        "definition": "리소스 안의 요소의 고유 ID(내부 참조용)임. 공백이 없는 문자열 값일수 있음."
      },
      {
        "id": "Device.specialization.systemType.coding",
        "path": "Device.specialization.systemType.coding",
        "short": "전문용어체계(terminology system)에 의해 정의된 코드",
        "definition": "전문용어체계(terminology system)에 의해 정의된 코드를 참조"
      },
      {
        "id": "Device.specialization.systemType.coding.id",
        "path": "Device.specialization.systemType.coding.id",
        "short": "요소-간의 참조를 위한 고유 ID",
        "definition": "리소스 안의 요소의 고유 ID(내부 참조용)임. 공백이 없는 문자열 값일수 있음."
      },
      {
        "id": "Device.specialization.systemType.coding.system",
        "path": "Device.specialization.systemType.coding.system",
        "short": "해당 전문용어체계(terminology system)의 식별",
        "definition": "코드에서 기호의 의미를 정의하는 CodeSystem[코드시스템]를 식별"
      },
      {
        "id": "Device.specialization.systemType.coding.version",
        "path": "Device.specialization.systemType.coding.version",
        "short": "해당 시스템의 버전 정보 - 필요한 경우",
        "definition": "해당 코드를 선택한 시점에 사용된 코드 시스템의 버전임. 올바로 관리된 코드 시스템은 코드의 의미가 버전과 관계없이 일관적이므로 버전을 보고할 필요가 없음. 그러나 코드 시스템의 관리 상태는 지속적으로 보장할 수 없는 부분이며, 코드의 의미가 일관적임을 보장할 수 없는 경우 버전이 교체되어야 함."
      },
      {
        "id": "Device.specialization.systemType.coding.code",
        "path": "Device.specialization.systemType.coding.code",
        "short": "시스템에 정의된 구문(syntax)의 기호(symbol)",
        "definition": "시스템에 정의된 구문의 기호. 기호는 CodeSystem[코드시스템]에 의해 정의된 구문에서 미리 정의된 코드 또는 표현(expression)일 수 있음. (예: post-coordination)"
      },
      {
        "id": "Device.specialization.systemType.coding.display",
        "path": "Device.specialization.systemType.coding.display",
        "short": "시스템에 정의된 표현",
        "definition": "시스템 내 코드의 의미를 시스템의 규칙에 따라 표현한 것을 의미함."
      },
      {
        "id": "Device.specialization.systemType.coding.userSelected",
        "path": "Device.specialization.systemType.coding.userSelected",
        "short": "해당 코딩 방법이 사용자에 의해 직접 선택되었는지 여부",
        "definition": "해당 코딩 방법이 사용자에 의해 직접 선택되었음을 나타냄. 즉, 선택 가능한 항목 (코드 혹은 디스플레이) 목록에 존재하지 않음을 나타냄."
      },
      {
        "id": "Device.specialization.systemType.text",
        "path": "Device.specialization.systemType.text",
        "short": "개념에 대한 일반 텍스트 묘사",
        "definition": "데이터를 입력한 사용자의 입장에서 보거나/선택하거나/언급한대로의 개념, 혹은 사용자가 의도한 의미를 사람이 사용하는 언어로 표현한 것임."
      },
      {
        "id": "Device.specialization.version",
        "path": "Device.specialization.version",
        "short": "운영 및 통신에 사용되는 표준(standard) 버전",
        "definition": "운영 및 통신에 사용되는 표준(standard) 버전",
        "max": "1",
        "type": [
          {
            "code": "string"
          }
        ],
        "mapping": [
          {
            "identity": "w5",
            "map": "FiveWs.what[x]"
          }
        ]
      },
      {
        "id": "Device.version",
        "path": "Device.version",
        "short": "Device[]의 실제 디자인 또는 Device[]에서 실행되는 소프트웨어 버전",
        "definition": "Device[]의 실제 디자인 또는 Device[]에서 실행되는 소프트웨어 버전",
        "type": [
          {
            "code": "BackboneElement"
          }
        ]
      },
      {
        "id": "Device.version.id",
        "path": "Device.version.id",
        "short": "요소-간의 참조를 위한 고유 ID",
        "definition": "리소스 안의 요소의 고유 ID(내부 참조용)임. 공백이 없는 문자열 값일수 있음."
      },
      {
        "id": "Device.version.type",
        "path": "Device.version.type",
        "short": "Device[] 버전의 유형",
        "definition": "Device[] 버전의 유형",
        "alias": [
          "Σ"
        ],
        "max": "1",
        "type": [
          {
            "code": "CodeableConcept"
          }
        ]
      },
      {
        "id": "Device.version.type.id",
        "path": "Device.version.type.id",
        "short": "요소-간의 참조를 위한 고유 ID",
        "definition": "리소스 안의 요소의 고유 ID(내부 참조용)임. 공백이 없는 문자열 값일수 있음."
      },
      {
        "id": "Device.version.type.coding",
        "path": "Device.version.type.coding",
        "short": "전문용어체계(terminology system)에 의해 정의된 코드",
        "definition": "전문용어체계(terminology system)에 의해 정의된 코드를 참조"
      },
      {
        "id": "Device.version.type.coding.id",
        "path": "Device.version.type.coding.id",
        "short": "요소-간의 참조를 위한 고유 ID",
        "definition": "리소스 안의 요소의 고유 ID(내부 참조용)임. 공백이 없는 문자열 값일수 있음."
      },
      {
        "id": "Device.version.type.coding.system",
        "path": "Device.version.type.coding.system",
        "short": "해당 전문용어체계(terminology system)의 식별",
        "definition": "코드에서 기호의 의미를 정의하는 CodeSystem[코드시스템]를 식별"
      },
      {
        "id": "Device.version.type.coding.version",
        "path": "Device.version.type.coding.version",
        "short": "해당 시스템의 버전 정보 - 필요한 경우",
        "definition": "해당 코드를 선택한 시점에 사용된 코드 시스템의 버전임. 올바로 관리된 코드 시스템은 코드의 의미가 버전과 관계없이 일관적이므로 버전을 보고할 필요가 없음. 그러나 코드 시스템의 관리 상태는 지속적으로 보장할 수 없는 부분이며, 코드의 의미가 일관적임을 보장할 수 없는 경우 버전이 교체되어야 함."
      },
      {
        "id": "Device.version.type.coding.code",
        "path": "Device.version.type.coding.code",
        "short": "시스템에 정의된 구문(syntax)의 기호(symbol)",
        "definition": "시스템에 정의된 구문의 기호. 기호는 CodeSystem[코드시스템]에 의해 정의된 구문에서 미리 정의된 코드 또는 표현(expression)일 수 있음. (예: post-coordination)"
      },
      {
        "id": "Device.version.type.coding.display",
        "path": "Device.version.type.coding.display",
        "short": "시스템에 정의된 표현",
        "definition": "시스템 내 코드의 의미를 시스템의 규칙에 따라 표현한 것을 의미함."
      },
      {
        "id": "Device.version.type.coding.userSelected",
        "path": "Device.version.type.coding.userSelected",
        "short": "해당 코딩 방법이 사용자에 의해 직접 선택되었는지 여부",
        "definition": "해당 코딩 방법이 사용자에 의해 직접 선택되었음을 나타냄. 즉, 선택 가능한 항목 (코드 혹은 디스플레이) 목록에 존재하지 않음을 나타냄."
      },
      {
        "id": "Device.version.type.text",
        "path": "Device.version.type.text",
        "short": "개념에 대한 일반 텍스트 묘사",
        "definition": "데이터를 입력한 사용자의 입장에서 보거나/선택하거나/언급한대로의 개념, 혹은 사용자가 의도한 의미를 사람이 사용하는 언어로 표현한 것임."
      },
      {
        "id": "Device.version.component",
        "path": "Device.version.component",
        "short": "Device[] 버전의 단일 구성 요소",
        "definition": "Device[] 버전의 단일 구성 요소",
        "max": "1",
        "type": [
          {
            "code": "Identifier"
          }
        ],
        "mapping": [
          {
            "identity": "w5",
            "map": "FiveWs.what[x]"
          }
        ]
      },
      {
        "id": "Device.version.component.id",
        "path": "Device.version.component.id",
        "short": "요소-간의 참조를 위한 고유 ID",
        "definition": "리소스 안의 요소의 고유 ID(내부 참조용)임. 공백이 없는 문자열 값일수 있음."
      },
      {
        "id": "Device.version.component.use",
        "path": "Device.version.component.use",
        "short": "usual | official | temp | secondary | old (If known)",
        "definition": "해당 식별자의 목적"
      },
      {
        "id": "Device.version.component.type",
        "path": "Device.version.component.type",
        "short": "식별자에 대한 설명",
        "definition": "특정 목적으로 사용되는 식별자를 결정하기 위해 사용하는 식별자의 코드 유형을 나타냄."
      },
      {
        "id": "Device.version.component.type.id",
        "path": "Device.version.component.type.id",
        "short": "요소-간의 참조를 위한 고유 ID",
        "definition": "리소스 안의 요소의 고유 ID(내부 참조용)임. 공백이 없는 문자열 값일수 있음."
      },
      {
        "id": "Device.version.component.type.coding",
        "path": "Device.version.component.type.coding",
        "short": "전문용어체계(terminology system)에 의해 정의된 코드",
        "definition": "전문용어체계(terminology system)에 의해 정의된 코드를 참조"
      },
      {
        "id": "Device.version.component.type.coding.id",
        "path": "Device.version.component.type.coding.id",
        "short": "요소-간의 참조를 위한 고유 ID",
        "definition": "리소스 안의 요소의 고유 ID(내부 참조용)임. 공백이 없는 문자열 값일수 있음."
      },
      {
        "id": "Device.version.component.type.coding.system",
        "path": "Device.version.component.type.coding.system",
        "short": "해당 전문용어체계(terminology system)의 식별",
        "definition": "코드에서 기호의 의미를 정의하는 CodeSystem[코드시스템]를 식별"
      },
      {
        "id": "Device.version.component.type.coding.version",
        "path": "Device.version.component.type.coding.version",
        "short": "해당 시스템의 버전 정보 - 필요한 경우",
        "definition": "해당 코드를 선택한 시점에 사용된 코드 시스템의 버전임. 올바로 관리된 코드 시스템은 코드의 의미가 버전과 관계없이 일관적이므로 버전을 보고할 필요가 없음. 그러나 코드 시스템의 관리 상태는 지속적으로 보장할 수 없는 부분이며, 코드의 의미가 일관적임을 보장할 수 없는 경우 버전이 교체되어야 함."
      },
      {
        "id": "Device.version.component.type.coding.code",
        "path": "Device.version.component.type.coding.code",
        "short": "시스템에 정의된 구문(syntax)의 기호(symbol)",
        "definition": "시스템에 정의된 구문의 기호. 기호는 CodeSystem[코드시스템]에 의해 정의된 구문에서 미리 정의된 코드 또는 표현(expression)일 수 있음. (예: post-coordination)"
      },
      {
        "id": "Device.version.component.type.coding.display",
        "path": "Device.version.component.type.coding.display",
        "short": "시스템에 정의된 표현",
        "definition": "시스템 내 코드의 의미를 시스템의 규칙에 따라 표현한 것을 의미함."
      },
      {
        "id": "Device.version.component.type.coding.userSelected",
        "path": "Device.version.component.type.coding.userSelected",
        "short": "해당 코딩 방법이 사용자에 의해 직접 선택되었는지 여부",
        "definition": "해당 코딩 방법이 사용자에 의해 직접 선택되었음을 나타냄. 즉, 선택 가능한 항목 (코드 혹은 디스플레이) 목록에 존재하지 않음을 나타냄."
      },
      {
        "id": "Device.version.component.type.text",
        "path": "Device.version.component.type.text",
        "short": "개념에 대한 일반 텍스트 묘사",
        "definition": "데이터를 입력한 사용자의 입장에서 보거나/선택하거나/언급한대로의 개념, 혹은 사용자가 의도한 의미를 사람이 사용하는 언어로 표현한 것임."
      },
      {
        "id": "Device.version.component.system",
        "path": "Device.version.component.system",
        "short": "식별자 값의 네임스페이스(namespace)",
        "definition": "설정값에 대한 네임 스페이스 (namespace), 즉 고유한 설정값을 설명하는 URL을 설정함."
      },
      {
        "id": "Device.version.component.value",
        "path": "Device.version.component.value",
        "short": "고유 설정값",
        "definition": "일반적으로 식별자의 사용과와 관련이 있으며, 시스템 컨텍스트 (context) 내에서 고유한 식별자의 일부분임."
      },
      {
        "id": "Device.version.component.period",
        "path": "Device.version.component.period",
        "short": "식별자의 유효 기간",
        "definition": "식별자가 사용 가능했거나 가능한 기간을 나타냄."
      },
      {
        "id": "Device.version.component.period.id",
        "path": "Device.version.component.period.id",
        "short": "요소-간의 참조를 위한 고유 ID",
        "definition": "리소스 안의 요소의 고유 ID(내부 참조용)임. 공백이 없는 문자열 값일수 있음."
      },
      {
        "id": "Device.version.component.period.start",
        "path": "Device.version.component.period.start",
        "short": "해당 유효 기간의 시작 시점 (설정된 날짜 포함)",
        "definition": "해당 유효 기간이 시작되는 시점을 나타냄. 유효 기간은 시작 시점으로 설정된 날짜를 포함함."
      },
      {
        "id": "Device.version.component.period.end",
        "path": "Device.version.component.period.end",
        "short": "해당 유효 기간의 종료 시점 (설정된 날짜 포함)",
        "definition": "기간의 종료. 기간의 종료가 누락된 경우, 인스턴스가 생성될 때 끝이 알려지거나 계획되지 않았음을 의미함. 시작일은 과거일 수 있고 종료일은 미래일 수 있음. 이는 해당 기간이 해당 시간에 종료될 예정임을 의미함"
      },
      {
        "id": "Device.version.component.assigner",
        "path": "Device.version.component.assigner",
        "short": "식별자를 발급한 조직 (단순 텍스트 기입 가능)",
        "definition": "식별자를 발급하고 관리하는 조직을 나타냄."
      },
      {
        "id": "Device.version.component.assigner.id",
        "path": "Device.version.component.assigner.id",
        "short": "요소-간의 참조를 위한 고유 ID",
        "definition": "리소스 안의 요소의 고유 ID(내부 참조용)임. 공백이 없는 문자열 값일수 있음."
      },
      {
        "id": "Device.version.component.assigner.reference",
        "path": "Device.version.component.assigner.reference",
        "short": "문안 참조, 상대적, 내부적 혹은 절대적인 URL",
        "definition": "다른 리소스(resource)을 찾을 수 있는 위치에 대한 참조를 의미함. 해당 참조는 service base URL에 상대적인 경우 상대 참조, 혹은 해당 리소스를 찾을 수 있는 위치인 절대 URL일 수 있음. 해당 참조는 버전에 따라 다를 수 있음. 해당 참조가 FHIR RESTful 서버가 아닌 경우, 버전에 따라 다른 것으로 간주함. 내부 구문 참조('#'으로 시작)는 포함되어 있는 리소스를 참조함."
      },
      {
        "id": "Device.version.component.assigner.type",
        "path": "Device.version.component.assigner.type",
        "short": "참조(reference)가 참조하는 유형  (예. \"Patient\")",
        "definition": "참조 대상의 예상 형식임. Reference.type과 Reference.reference가 모두 채워지고 Reference.reference가 FHIR URL이면 두가지 모두 일치해야함. 유형은이 참조가 참조하는 유형 인 리소스 정의의 표준 URL임. 참조는 http://hl7.org/fhir/StructureDefinition/과 관련된 URL임. (예) \" 환자 \" http://hl7.org/fhir/StructureDefinition/Patient에 대한 참조. 절대 URL은 논리 모델에만 허용됨 (리소스가 아닌 논리 모델의 참조에서만 사용할 수 있음)."
      },
      {
        "id": "Device.version.component.assigner.identifier",
        "path": "Device.version.component.assigner.identifier",
        "short": "문안 참조를 알 수 없는 경우의 논리 참조 (logical reference)",
        "definition": "대상 리소스의 식별자. 이것은 다른 리소스를 직접 참조할 방법이 없을 때 사용- 해당 앤티티(entity)가 FHIR 서버를 통해 사용할 수 없거나  리소스 작성자가 알려진 식별자를 실제 위치로 변활할 방법이 없기 때문에 이 방법이 사용됨. Reference.identifier가 실제로 FHIR 인스턴스로 노출되는 것을 가르킬(point) 필요는 없지만, FHIR 인스턴스로 노출될 것으로 예상되는 비즈니스 개념을 가리켜야하며, 해당 인스턴스는 참조가 허용되는 FHIR 리소스 유형이여야함."
      },
      {
        "id": "Device.version.component.assigner.display",
        "path": "Device.version.component.assigner.display",
        "short": "해당 리소스를 대체하는 텍스트 설명",
        "definition": "리소스 참조 외에도 리소스를 식별하기 위한 일반 텍스트 설명임."
      },
      {
        "id": "Device.version.value",
        "path": "Device.version.value",
        "short": "버전 텍스트",
        "definition": "버전 텍스트",
        "min": 1,
        "max": "1",
        "type": [
          {
            "code": "string"
          }
        ]
      },
      {
        "id": "Device.property",
        "path": "Device.property",
        "short": "Device[]가 실제로 작동할 때의 실제 구성 설정 (예. 규정 상태, 시간 속성)",
        "definition": "Device[]가 실제로 작동할 때의 실제 구성 설정 (예. 규정 상태, 시간 속성)",
        "type": [
          {
            "code": "BackboneElement"
          }
        ]
      },
      {
        "id": "Device.property.id",
        "path": "Device.property.id",
        "short": "요소-간의 참조를 위한 고유 ID",
        "definition": "리소스 안의 요소의 고유 ID(내부 참조용)임. 공백이 없는 문자열 값일수 있음."
      },
      {
        "id": "Device.property.type",
        "path": "Device.property.type",
        "short": "DeviceDefinitionPropetyCode (Extensible) 속성을 지정하는 코드",
        "definition": "DeviceDefinitionPropertyCode (Extensible) 속성을 지정하는 코드",
        "min": 1,
        "max": "1",
        "type": [
          {
            "code": "CodeableConcept"
          }
        ]
      },
      {
        "id": "Device.property.type.id",
        "path": "Device.property.type.id",
        "short": "요소-간의 참조를 위한 고유 ID",
        "definition": "리소스 안의 요소의 고유 ID(내부 참조용)임. 공백이 없는 문자열 값일수 있음."
      },
      {
        "id": "Device.property.type.coding",
        "path": "Device.property.type.coding",
        "short": "전문용어체계(terminology system)에 의해 정의된 코드",
        "definition": "전문용어체계(terminology system)에 의해 정의된 코드를 참조"
      },
      {
        "id": "Device.property.type.coding.id",
        "path": "Device.property.type.coding.id",
        "short": "요소-간의 참조를 위한 고유 ID",
        "definition": "리소스 안의 요소의 고유 ID(내부 참조용)임. 공백이 없는 문자열 값일수 있음."
      },
      {
        "id": "Device.property.type.coding.system",
        "path": "Device.property.type.coding.system",
        "short": "해당 전문용어체계(terminology system)의 식별",
        "definition": "코드에서 기호의 의미를 정의하는 CodeSystem[코드시스템]를 식별"
      },
      {
        "id": "Device.property.type.coding.version",
        "path": "Device.property.type.coding.version",
        "short": "해당 시스템의 버전 정보 - 필요한 경우",
        "definition": "해당 코드를 선택한 시점에 사용된 코드 시스템의 버전임. 올바로 관리된 코드 시스템은 코드의 의미가 버전과 관계없이 일관적이므로 버전을 보고할 필요가 없음. 그러나 코드 시스템의 관리 상태는 지속적으로 보장할 수 없는 부분이며, 코드의 의미가 일관적임을 보장할 수 없는 경우 버전이 교체되어야 함."
      },
      {
        "id": "Device.property.type.coding.code",
        "path": "Device.property.type.coding.code",
        "short": "시스템에 정의된 구문(syntax)의 기호(symbol)",
        "definition": "시스템에 정의된 구문의 기호. 기호는 CodeSystem[코드시스템]에 의해 정의된 구문에서 미리 정의된 코드 또는 표현(expression)일 수 있음. (예: post-coordination)"
      },
      {
        "id": "Device.property.type.coding.display",
        "path": "Device.property.type.coding.display",
        "short": "시스템에 정의된 표현",
        "definition": "시스템 내 코드의 의미를 시스템의 규칙에 따라 표현한 것을 의미함."
      },
      {
        "id": "Device.property.type.coding.userSelected",
        "path": "Device.property.type.coding.userSelected",
        "short": "해당 코딩 방법이 사용자에 의해 직접 선택되었는지 여부",
        "definition": "해당 코딩 방법이 사용자에 의해 직접 선택되었음을 나타냄. 즉, 선택 가능한 항목 (코드 혹은 디스플레이) 목록에 존재하지 않음을 나타냄."
      },
      {
        "id": "Device.property.type.text",
        "path": "Device.property.type.text",
        "short": "개념에 대한 일반 텍스트 묘사",
        "definition": "데이터를 입력한 사용자의 입장에서 보거나/선택하거나/언급한대로의 개념, 혹은 사용자가 의도한 의미를 사람이 사용하는 언어로 표현한 것임."
      },
      {
        "id": "Device.property.valueQuantity",
        "path": "Device.property.valueQuantity",
        "short": "수량으로써의 속성 값",
        "definition": "수량으로써의 속성 값",
        "type": [
          {
            "code": "Quantity"
          }
        ]
      },
      {
        "id": "Device.property.valueQuantity.id",
        "path": "Device.property.valueQuantity.id",
        "short": "요소-간의 참조를 위한 고유 ID",
        "definition": "리소스 안의 요소의 고유 ID(내부 참조용)임. 공백이 없는 문자열 값일수 있음."
      },
      {
        "id": "Device.property.valueQuantity.value",
        "path": "Device.property.valueQuantity.value",
        "short": "값의 수치 (근사치 포함)",
        "definition": "측정된 값. 값을 표현할 때 근사치가 포함됨."
      },
      {
        "id": "Device.property.valueQuantity.comparator",
        "path": "Device.property.valueQuantity.comparator",
        "short": "< | <= | >= | > - 값을 이해하는 방법",
        "definition": "값을 이해하고 표현 하는 방법 - 측정 문제로 인해 실제 값이 명시된 값보다 크거나 적은지 여부; (예) 만약 비교자가 \"<\" 이면 실제 값은 명시된 값보다 < (작다)임."
      },
      {
        "id": "Device.property.valueQuantity.unit",
        "path": "Device.property.valueQuantity.unit",
        "short": "단위",
        "definition": "사람이 읽을 수 있는 형식의 단위."
      },
      {
        "id": "Device.property.valueQuantity.system",
        "path": "Device.property.valueQuantity.system",
        "short": "단위 코드",
        "definition": "단위 코드를 제공하는 시스템의 식별임."
      },
      {
        "id": "Device.property.valueQuantity.code",
        "path": "Device.property.valueQuantity.code",
        "short": "단위 코드",
        "definition": "일부 단위 표시 시스템에서 컴퓨터로 처리할 수 있는 형식 단위."
      },
      {
        "id": "Device.property.valueCode",
        "path": "Device.property.valueCode",
        "short": "코드로서의 속성 값 (예 . NTP4 / NTP와 동기화됨)",
        "definition": "코드로서의 속성 값 (예 . NTP4 / NTP와 동기화됨)",
        "type": [
          {
            "code": "CodeableConcept"
          }
        ]
      },
      {
        "id": "Device.property.valueCode.id",
        "path": "Device.property.valueCode.id",
        "short": "요소-간의 참조를 위한 고유 ID",
        "definition": "리소스 안의 요소의 고유 ID(내부 참조용)임. 공백이 없는 문자열 값일수 있음."
      },
      {
        "id": "Device.property.valueCode.coding",
        "path": "Device.property.valueCode.coding",
        "short": "전문용어체계(terminology system)에 의해 정의된 코드",
        "definition": "전문용어체계(terminology system)에 의해 정의된 코드를 참조"
      },
      {
        "id": "Device.property.valueCode.coding.id",
        "path": "Device.property.valueCode.coding.id",
        "short": "요소-간의 참조를 위한 고유 ID",
        "definition": "리소스 안의 요소의 고유 ID(내부 참조용)임. 공백이 없는 문자열 값일수 있음."
      },
      {
        "id": "Device.property.valueCode.coding.system",
        "path": "Device.property.valueCode.coding.system",
        "short": "해당 전문용어체계(terminology system)의 식별",
        "definition": "코드에서 기호의 의미를 정의하는 CodeSystem[코드시스템]를 식별"
      },
      {
        "id": "Device.property.valueCode.coding.version",
        "path": "Device.property.valueCode.coding.version",
        "short": "해당 시스템의 버전 정보 - 필요한 경우",
        "definition": "해당 코드를 선택한 시점에 사용된 코드 시스템의 버전임. 올바로 관리된 코드 시스템은 코드의 의미가 버전과 관계없이 일관적이므로 버전을 보고할 필요가 없음. 그러나 코드 시스템의 관리 상태는 지속적으로 보장할 수 없는 부분이며, 코드의 의미가 일관적임을 보장할 수 없는 경우 버전이 교체되어야 함."
      },
      {
        "id": "Device.property.valueCode.coding.code",
        "path": "Device.property.valueCode.coding.code",
        "short": "시스템에 정의된 구문(syntax)의 기호(symbol)",
        "definition": "시스템에 정의된 구문의 기호. 기호는 CodeSystem[코드시스템]에 의해 정의된 구문에서 미리 정의된 코드 또는 표현(expression)일 수 있음. (예: post-coordination)"
      },
      {
        "id": "Device.property.valueCode.coding.display",
        "path": "Device.property.valueCode.coding.display",
        "short": "시스템에 정의된 표현",
        "definition": "시스템 내 코드의 의미를 시스템의 규칙에 따라 표현한 것을 의미함."
      },
      {
        "id": "Device.property.valueCode.coding.userSelected",
        "path": "Device.property.valueCode.coding.userSelected",
        "short": "해당 코딩 방법이 사용자에 의해 직접 선택되었는지 여부",
        "definition": "해당 코딩 방법이 사용자에 의해 직접 선택되었음을 나타냄. 즉, 선택 가능한 항목 (코드 혹은 디스플레이) 목록에 존재하지 않음을 나타냄."
      },
      {
        "id": "Device.property.valueCode.text",
        "path": "Device.property.valueCode.text",
        "short": "개념에 대한 일반 텍스트 묘사",
        "definition": "데이터를 입력한 사용자의 입장에서 보거나/선택하거나/언급한대로의 개념, 혹은 사용자가 의도한 의미를 사람이 사용하는 언어로 표현한 것임."
      },
      {
        "id": "Device.patient",
        "path": "Device.patient",
        "short": "기기가 부착된 환자",
        "definition": "기기가 부착되어있는 환자의 정보를 의미함.",
        "requirements": "If the device is implanted in a patient, then need to associate the device to the patient.",
        "max": "1",
        "type": [
          {
            "code": "Reference",
            "targetProfile": [
              "http://hl7.org/fhir/StructureDefinition/Patient"
            ]
          }
        ],
        "mapping": [
          {
            "identity": "w5",
            "map": "FiveWs.subject[x]"
          },
          {
            "identity": "rim",
            "map": ".playedRole[typeCode=USED].scoper.playedRole[typeCode=PAT]"
          },
          {
            "identity": "w5",
            "map": "FiveWs.subject"
          }
        ]
      },
      {
        "id": "Device.patient.id",
        "path": "Device.patient.id",
        "short": "요소-간의 참조를 위한 고유 ID",
        "definition": "리소스 안의 요소의 고유 ID(내부 참조용)임. 공백이 없는 문자열 값일수 있음."
      },
      {
        "id": "Device.patient.reference",
        "path": "Device.patient.reference",
        "short": "문안 참조, 상대적, 내부적 혹은 절대적인 URL",
        "definition": "다른 리소스(resource)을 찾을 수 있는 위치에 대한 참조를 의미함. 해당 참조는 service base URL에 상대적인 경우 상대 참조, 혹은 해당 리소스를 찾을 수 있는 위치인 절대 URL일 수 있음. 해당 참조는 버전에 따라 다를 수 있음. 해당 참조가 FHIR RESTful 서버가 아닌 경우, 버전에 따라 다른 것으로 간주함. 내부 구문 참조('#'으로 시작)는 포함되어 있는 리소스를 참조함."
      },
      {
        "id": "Device.patient.type",
        "path": "Device.patient.type",
        "short": "참조(reference)가 참조하는 유형  (예. \"Patient\")",
        "definition": "참조 대상의 예상 형식임. Reference.type과 Reference.reference가 모두 채워지고 Reference.reference가 FHIR URL이면 두가지 모두 일치해야함. 유형은이 참조가 참조하는 유형 인 리소스 정의의 표준 URL임. 참조는 http://hl7.org/fhir/StructureDefinition/과 관련된 URL임. (예) \" 환자 \" http://hl7.org/fhir/StructureDefinition/Patient에 대한 참조. 절대 URL은 논리 모델에만 허용됨 (리소스가 아닌 논리 모델의 참조에서만 사용할 수 있음)."
      },
      {
        "id": "Device.patient.identifier",
        "path": "Device.patient.identifier",
        "short": "문안 참조를 알 수 없는 경우의 논리 참조 (logical reference)",
        "definition": "대상 리소스의 식별자. 이것은 다른 리소스를 직접 참조할 방법이 없을 때 사용- 해당 앤티티(entity)가 FHIR 서버를 통해 사용할 수 없거나  리소스 작성자가 알려진 식별자를 실제 위치로 변활할 방법이 없기 때문에 이 방법이 사용됨. Reference.identifier가 실제로 FHIR 인스턴스로 노출되는 것을 가르킬(point) 필요는 없지만, FHIR 인스턴스로 노출될 것으로 예상되는 비즈니스 개념을 가리켜야하며, 해당 인스턴스는 참조가 허용되는 FHIR 리소스 유형이여야함."
      },
      {
        "id": "Device.patient.identifier.id",
        "path": "Device.patient.identifier.id",
        "short": "요소-간의 참조를 위한 고유 ID",
        "definition": "리소스 안의 요소의 고유 ID(내부 참조용)임. 공백이 없는 문자열 값일수 있음."
      },
      {
        "id": "Device.patient.identifier.use",
        "path": "Device.patient.identifier.use",
        "short": "usual | official | temp | secondary | old (If known)",
        "definition": "해당 식별자의 목적"
      },
      {
        "id": "Device.patient.identifier.type",
        "path": "Device.patient.identifier.type",
        "short": "식별자에 대한 설명",
        "definition": "특정 목적으로 사용되는 식별자를 결정하기 위해 사용하는 식별자의 코드 유형을 나타냄."
      },
      {
        "id": "Device.patient.identifier.type.id",
        "path": "Device.patient.identifier.type.id",
        "short": "요소-간의 참조를 위한 고유 ID",
        "definition": "리소스 안의 요소의 고유 ID(내부 참조용)임. 공백이 없는 문자열 값일수 있음."
      },
      {
        "id": "Device.patient.identifier.type.coding",
        "path": "Device.patient.identifier.type.coding",
        "short": "전문용어체계(terminology system)에 의해 정의된 코드",
        "definition": "전문용어체계(terminology system)에 의해 정의된 코드를 참조"
      },
      {
        "id": "Device.patient.identifier.type.coding.id",
        "path": "Device.patient.identifier.type.coding.id",
        "short": "요소-간의 참조를 위한 고유 ID",
        "definition": "리소스 안의 요소의 고유 ID(내부 참조용)임. 공백이 없는 문자열 값일수 있음."
      },
      {
        "id": "Device.patient.identifier.type.coding.system",
        "path": "Device.patient.identifier.type.coding.system",
        "short": "해당 전문용어체계(terminology system)의 식별",
        "definition": "코드에서 기호의 의미를 정의하는 CodeSystem[코드시스템]를 식별"
      },
      {
        "id": "Device.patient.identifier.type.coding.version",
        "path": "Device.patient.identifier.type.coding.version",
        "short": "해당 시스템의 버전 정보 - 필요한 경우",
        "definition": "해당 코드를 선택한 시점에 사용된 코드 시스템의 버전임. 올바로 관리된 코드 시스템은 코드의 의미가 버전과 관계없이 일관적이므로 버전을 보고할 필요가 없음. 그러나 코드 시스템의 관리 상태는 지속적으로 보장할 수 없는 부분이며, 코드의 의미가 일관적임을 보장할 수 없는 경우 버전이 교체되어야 함."
      },
      {
        "id": "Device.patient.identifier.type.coding.code",
        "path": "Device.patient.identifier.type.coding.code",
        "short": "시스템에 정의된 구문(syntax)의 기호(symbol)",
        "definition": "시스템에 정의된 구문의 기호. 기호는 CodeSystem[코드시스템]에 의해 정의된 구문에서 미리 정의된 코드 또는 표현(expression)일 수 있음. (예: post-coordination)"
      },
      {
        "id": "Device.patient.identifier.type.coding.display",
        "path": "Device.patient.identifier.type.coding.display",
        "short": "시스템에 정의된 표현",
        "definition": "시스템 내 코드의 의미를 시스템의 규칙에 따라 표현한 것을 의미함."
      },
      {
        "id": "Device.patient.identifier.type.coding.userSelected",
        "path": "Device.patient.identifier.type.coding.userSelected",
        "short": "해당 코딩 방법이 사용자에 의해 직접 선택되었는지 여부",
        "definition": "해당 코딩 방법이 사용자에 의해 직접 선택되었음을 나타냄. 즉, 선택 가능한 항목 (코드 혹은 디스플레이) 목록에 존재하지 않음을 나타냄."
      },
      {
        "id": "Device.patient.identifier.type.text",
        "path": "Device.patient.identifier.type.text",
        "short": "개념에 대한 일반 텍스트 묘사",
        "definition": "데이터를 입력한 사용자의 입장에서 보거나/선택하거나/언급한대로의 개념, 혹은 사용자가 의도한 의미를 사람이 사용하는 언어로 표현한 것임."
      },
      {
        "id": "Device.patient.identifier.system",
        "path": "Device.patient.identifier.system",
        "short": "식별자 값의 네임스페이스(namespace)",
        "definition": "설정값에 대한 네임 스페이스 (namespace), 즉 고유한 설정값을 설명하는 URL을 설정함."
      },
      {
        "id": "Device.patient.identifier.value",
        "path": "Device.patient.identifier.value",
        "short": "고유 설정값",
        "definition": "일반적으로 식별자의 사용과와 관련이 있으며, 시스템 컨텍스트 (context) 내에서 고유한 식별자의 일부분임."
      },
      {
        "id": "Device.patient.identifier.period",
        "path": "Device.patient.identifier.period",
        "short": "식별자의 유효 기간",
        "definition": "식별자가 사용 가능했거나 가능한 기간을 나타냄."
      },
      {
        "id": "Device.patient.identifier.period.id",
        "path": "Device.patient.identifier.period.id",
        "short": "요소-간의 참조를 위한 고유 ID",
        "definition": "리소스 안의 요소의 고유 ID(내부 참조용)임. 공백이 없는 문자열 값일수 있음."
      },
      {
        "id": "Device.patient.identifier.period.start",
        "path": "Device.patient.identifier.period.start",
        "short": "해당 유효 기간의 시작 시점 (설정된 날짜 포함)",
        "definition": "해당 유효 기간이 시작되는 시점을 나타냄. 유효 기간은 시작 시점으로 설정된 날짜를 포함함."
      },
      {
        "id": "Device.patient.identifier.period.end",
        "path": "Device.patient.identifier.period.end",
        "short": "해당 유효 기간의 종료 시점 (설정된 날짜 포함)",
        "definition": "기간의 종료. 기간의 종료가 누락된 경우, 인스턴스가 생성될 때 끝이 알려지거나 계획되지 않았음을 의미함. 시작일은 과거일 수 있고 종료일은 미래일 수 있음. 이는 해당 기간이 해당 시간에 종료될 예정임을 의미함"
      },
      {
        "id": "Device.patient.identifier.assigner",
        "path": "Device.patient.identifier.assigner",
        "short": "식별자를 발급한 조직 (단순 텍스트 기입 가능)",
        "definition": "식별자를 발급하고 관리하는 조직을 나타냄."
      },
      {
        "id": "Device.patient.display",
        "path": "Device.patient.display",
        "short": "해당 리소스를 대체하는 텍스트 설명",
        "definition": "리소스 참조 외에도 리소스를 식별하기 위한 일반 텍스트 설명임."
      },
      {
        "id": "Device.owner",
        "path": "Device.owner",
        "short": "기기 담당 조직",
        "definition": "기기의 제공 및 지속적인 유지관리를 담당하는 조직.",
        "max": "1",
        "type": [
          {
            "code": "Reference",
            "targetProfile": [
              "http://hl7.org/fhir/StructureDefinition/Organization"
            ]
          }
        ],
        "mapping": [
          {
            "identity": "w5",
            "map": "FiveWs.source"
          },
          {
            "identity": "rim",
            "map": ".playedRole[typeCode=OWN].scoper"
          }
        ]
      },
      {
        "id": "Device.owner.id",
        "path": "Device.owner.id",
        "short": "요소-간의 참조를 위한 고유 ID",
        "definition": "리소스 안의 요소의 고유 ID(내부 참조용)임. 공백이 없는 문자열 값일수 있음."
      },
      {
        "id": "Device.owner.reference",
        "path": "Device.owner.reference",
        "short": "문안 참조, 상대적, 내부적 혹은 절대적인 URL",
        "definition": "다른 리소스(resource)을 찾을 수 있는 위치에 대한 참조를 의미함. 해당 참조는 service base URL에 상대적인 경우 상대 참조, 혹은 해당 리소스를 찾을 수 있는 위치인 절대 URL일 수 있음. 해당 참조는 버전에 따라 다를 수 있음. 해당 참조가 FHIR RESTful 서버가 아닌 경우, 버전에 따라 다른 것으로 간주함. 내부 구문 참조('#'으로 시작)는 포함되어 있는 리소스를 참조함."
      },
      {
        "id": "Device.owner.type",
        "path": "Device.owner.type",
        "short": "참조(reference)가 참조하는 유형  (예. \"Patient\")",
        "definition": "참조 대상의 예상 형식임. Reference.type과 Reference.reference가 모두 채워지고 Reference.reference가 FHIR URL이면 두가지 모두 일치해야함. 유형은이 참조가 참조하는 유형 인 리소스 정의의 표준 URL임. 참조는 http://hl7.org/fhir/StructureDefinition/과 관련된 URL임. (예) \" 환자 \" http://hl7.org/fhir/StructureDefinition/Patient에 대한 참조. 절대 URL은 논리 모델에만 허용됨 (리소스가 아닌 논리 모델의 참조에서만 사용할 수 있음)."
      },
      {
        "id": "Device.owner.identifier",
        "path": "Device.owner.identifier",
        "short": "문안 참조를 알 수 없는 경우의 논리 참조 (logical reference)",
        "definition": "대상 리소스의 식별자. 이것은 다른 리소스를 직접 참조할 방법이 없을 때 사용- 해당 앤티티(entity)가 FHIR 서버를 통해 사용할 수 없거나  리소스 작성자가 알려진 식별자를 실제 위치로 변활할 방법이 없기 때문에 이 방법이 사용됨. Reference.identifier가 실제로 FHIR 인스턴스로 노출되는 것을 가르킬(point) 필요는 없지만, FHIR 인스턴스로 노출될 것으로 예상되는 비즈니스 개념을 가리켜야하며, 해당 인스턴스는 참조가 허용되는 FHIR 리소스 유형이여야함."
      },
      {
        "id": "Device.owner.identifier.id",
        "path": "Device.owner.identifier.id",
        "short": "요소-간의 참조를 위한 고유 ID",
        "definition": "리소스 안의 요소의 고유 ID(내부 참조용)임. 공백이 없는 문자열 값일수 있음."
      },
      {
        "id": "Device.owner.identifier.use",
        "path": "Device.owner.identifier.use",
        "short": "usual | official | temp | secondary | old (If known)",
        "definition": "해당 식별자의 목적"
      },
      {
        "id": "Device.owner.identifier.type",
        "path": "Device.owner.identifier.type",
        "short": "식별자에 대한 설명",
        "definition": "특정 목적으로 사용되는 식별자를 결정하기 위해 사용하는 식별자의 코드 유형을 나타냄."
      },
      {
        "id": "Device.owner.identifier.type.id",
        "path": "Device.owner.identifier.type.id",
        "short": "요소-간의 참조를 위한 고유 ID",
        "definition": "리소스 안의 요소의 고유 ID(내부 참조용)임. 공백이 없는 문자열 값일수 있음."
      },
      {
        "id": "Device.owner.identifier.type.coding",
        "path": "Device.owner.identifier.type.coding",
        "short": "전문용어체계(terminology system)에 의해 정의된 코드",
        "definition": "전문용어체계(terminology system)에 의해 정의된 코드를 참조"
      },
      {
        "id": "Device.owner.identifier.type.coding.id",
        "path": "Device.owner.identifier.type.coding.id",
        "short": "요소-간의 참조를 위한 고유 ID",
        "definition": "리소스 안의 요소의 고유 ID(내부 참조용)임. 공백이 없는 문자열 값일수 있음."
      },
      {
        "id": "Device.owner.identifier.type.coding.system",
        "path": "Device.owner.identifier.type.coding.system",
        "short": "해당 전문용어체계(terminology system)의 식별",
        "definition": "코드에서 기호의 의미를 정의하는 CodeSystem[코드시스템]를 식별"
      },
      {
        "id": "Device.owner.identifier.type.coding.version",
        "path": "Device.owner.identifier.type.coding.version",
        "short": "해당 시스템의 버전 정보 - 필요한 경우",
        "definition": "해당 코드를 선택한 시점에 사용된 코드 시스템의 버전임. 올바로 관리된 코드 시스템은 코드의 의미가 버전과 관계없이 일관적이므로 버전을 보고할 필요가 없음. 그러나 코드 시스템의 관리 상태는 지속적으로 보장할 수 없는 부분이며, 코드의 의미가 일관적임을 보장할 수 없는 경우 버전이 교체되어야 함."
      },
      {
        "id": "Device.owner.identifier.type.coding.code",
        "path": "Device.owner.identifier.type.coding.code",
        "short": "시스템에 정의된 구문(syntax)의 기호(symbol)",
        "definition": "시스템에 정의된 구문의 기호. 기호는 CodeSystem[코드시스템]에 의해 정의된 구문에서 미리 정의된 코드 또는 표현(expression)일 수 있음. (예: post-coordination)"
      },
      {
        "id": "Device.owner.identifier.type.coding.display",
        "path": "Device.owner.identifier.type.coding.display",
        "short": "시스템에 정의된 표현",
        "definition": "시스템 내 코드의 의미를 시스템의 규칙에 따라 표현한 것을 의미함."
      },
      {
        "id": "Device.owner.identifier.type.coding.userSelected",
        "path": "Device.owner.identifier.type.coding.userSelected",
        "short": "해당 코딩 방법이 사용자에 의해 직접 선택되었는지 여부",
        "definition": "해당 코딩 방법이 사용자에 의해 직접 선택되었음을 나타냄. 즉, 선택 가능한 항목 (코드 혹은 디스플레이) 목록에 존재하지 않음을 나타냄."
      },
      {
        "id": "Device.owner.identifier.type.text",
        "path": "Device.owner.identifier.type.text",
        "short": "개념에 대한 일반 텍스트 묘사",
        "definition": "데이터를 입력한 사용자의 입장에서 보거나/선택하거나/언급한대로의 개념, 혹은 사용자가 의도한 의미를 사람이 사용하는 언어로 표현한 것임."
      },
      {
        "id": "Device.owner.identifier.system",
        "path": "Device.owner.identifier.system",
        "short": "식별자 값의 네임스페이스(namespace)",
        "definition": "설정값에 대한 네임 스페이스 (namespace), 즉 고유한 설정값을 설명하는 URL을 설정함."
      },
      {
        "id": "Device.owner.identifier.value",
        "path": "Device.owner.identifier.value",
        "short": "고유 설정값",
        "definition": "일반적으로 식별자의 사용과와 관련이 있으며, 시스템 컨텍스트 (context) 내에서 고유한 식별자의 일부분임."
      },
      {
        "id": "Device.owner.identifier.period",
        "path": "Device.owner.identifier.period",
        "short": "식별자의 유효 기간",
        "definition": "식별자가 사용 가능했거나 가능한 기간을 나타냄."
      },
      {
        "id": "Device.owner.identifier.period.id",
        "path": "Device.owner.identifier.period.id",
        "short": "요소-간의 참조를 위한 고유 ID",
        "definition": "리소스 안의 요소의 고유 ID(내부 참조용)임. 공백이 없는 문자열 값일수 있음."
      },
      {
        "id": "Device.owner.identifier.period.start",
        "path": "Device.owner.identifier.period.start",
        "short": "해당 유효 기간의 시작 시점 (설정된 날짜 포함)",
        "definition": "해당 유효 기간이 시작되는 시점을 나타냄. 유효 기간은 시작 시점으로 설정된 날짜를 포함함."
      },
      {
        "id": "Device.owner.identifier.period.end",
        "path": "Device.owner.identifier.period.end",
        "short": "해당 유효 기간의 종료 시점 (설정된 날짜 포함)",
        "definition": "기간의 종료. 기간의 종료가 누락된 경우, 인스턴스가 생성될 때 끝이 알려지거나 계획되지 않았음을 의미함. 시작일은 과거일 수 있고 종료일은 미래일 수 있음. 이는 해당 기간이 해당 시간에 종료될 예정임을 의미함"
      },
      {
        "id": "Device.owner.identifier.assigner",
        "path": "Device.owner.identifier.assigner",
        "short": "식별자를 발급한 조직 (단순 텍스트 기입 가능)",
        "definition": "식별자를 발급하고 관리하는 조직을 나타냄."
      },
      {
        "id": "Device.owner.display",
        "path": "Device.owner.display",
        "short": "해당 리소스를 대체하는 텍스트 설명",
        "definition": "리소스 참조 외에도 리소스를 식별하기 위한 일반 텍스트 설명임."
      },
      {
        "id": "Device.contact",
        "path": "Device.contact",
        "short": "담당자 세부 정보",
        "definition": "기기를 담당하는 조직 또는 특정 담당자의 연락처 정보.",
        "comment": "문제 해결 등에 사용됨",
        "type": [
          {
            "code": "ContactPoint"
          }
        ],
        "mapping": [
          {
            "identity": "w5",
            "map": "FiveWs.source"
          },
          {
            "identity": "rim",
            "map": ".scopedRole[typeCode=CON].player"
          }
        ]
      },
      {
        "id": "Device.contact.id",
        "path": "Device.contact.id",
        "short": "요소-간의 참조를 위한 고유 ID",
        "definition": "리소스 안의 요소의 고유 ID(내부 참조용)임. 공백이 없는 문자열 값일수 있음."
      },
      {
        "id": "Device.contact.system",
        "path": "Device.contact.system",
        "short": "phone | fax | email | pager | url | sms | other",
        "definition": "연락처에 대한 통신 방법 - 연락처를 활용하기 위해 필요한 연락 시스템."
      },
      {
        "id": "Device.contact.value",
        "path": "Device.contact.value",
        "short": "실제 연락처의 값",
        "definition": "지정된 통신 방법을 통하여 연락을 할 수 있는 실제 연락처의 값 (예: 전화번호, 이메일주소)"
      },
      {
        "id": "Device.contact.use",
        "path": "Device.contact.use",
        "short": "home | work | temp | old | mobile - 연락처 경로",
        "definition": "연락처의 경로를 식별함."
      },
      {
        "id": "Device.contact.rank",
        "path": "Device.contact.rank",
        "short": "선호되는 사용 순서를 명시함 (1 = 가장 높은 순서)",
        "definition": "연락처 세트를 사용할 선호 순서를 지정. 순위(rank) 값이 낮은 ContactPoint가 순위(rank) 값이 높은 ContactPoint보다 선호됨."
      },
      {
        "id": "Device.contact.period",
        "path": "Device.contact.period",
        "short": "연락처가 사용/사용 된 기간",
        "definition": "연락처가 사용/사용 된 기간."
      },
      {
        "id": "Device.contact.period.id",
        "path": "Device.contact.period.id",
        "short": "요소-간의 참조를 위한 고유 ID",
        "definition": "리소스 안의 요소의 고유 ID(내부 참조용)임. 공백이 없는 문자열 값일수 있음."
      },
      {
        "id": "Device.contact.period.start",
        "path": "Device.contact.period.start",
        "short": "해당 유효 기간의 시작 시점 (설정된 날짜 포함)",
        "definition": "해당 유효 기간이 시작되는 시점을 나타냄. 유효 기간은 시작 시점으로 설정된 날짜를 포함함."
      },
      {
        "id": "Device.contact.period.end",
        "path": "Device.contact.period.end",
        "short": "해당 유효 기간의 종료 시점 (설정된 날짜 포함)",
        "definition": "기간의 종료. 기간의 종료가 누락된 경우, 인스턴스가 생성될 때 끝이 알려지거나 계획되지 않았음을 의미함. 시작일은 과거일 수 있고 종료일은 미래일 수 있음. 이는 해당 기간이 해당 시간에 종료될 예정임을 의미함"
      },
      {
        "id": "Device.location",
        "path": "Device.location",
        "short": "Device[]가 있는 곳",
        "definition": "기기 보관 장소",
        "requirements": "Device.location can be used to track device location.",
        "max": "1",
        "type": [
          {
            "code": "Reference",
            "targetProfile": [
              "http://hl7.org/fhir/StructureDefinition/Location"
            ]
          }
        ],
        "mapping": [
          {
            "identity": "w5",
            "map": "FiveWs.where[x]"
          },
          {
            "identity": "rim",
            "map": ".playedRole[typeCode=LOCE].scoper"
          }
        ]
      },
      {
        "id": "Device.location.id",
        "path": "Device.location.id",
        "short": "요소-간의 참조를 위한 고유 ID",
        "definition": "리소스 안의 요소의 고유 ID(내부 참조용)임. 공백이 없는 문자열 값일수 있음."
      },
      {
        "id": "Device.location.reference",
        "path": "Device.location.reference",
        "short": "문안 참조, 상대적, 내부적 혹은 절대적인 URL",
        "definition": "다른 리소스(resource)을 찾을 수 있는 위치에 대한 참조를 의미함. 해당 참조는 service base URL에 상대적인 경우 상대 참조, 혹은 해당 리소스를 찾을 수 있는 위치인 절대 URL일 수 있음. 해당 참조는 버전에 따라 다를 수 있음. 해당 참조가 FHIR RESTful 서버가 아닌 경우, 버전에 따라 다른 것으로 간주함. 내부 구문 참조('#'으로 시작)는 포함되어 있는 리소스를 참조함."
      },
      {
        "id": "Device.location.type",
        "path": "Device.location.type",
        "short": "참조(reference)가 참조하는 유형  (예. \"Patient\")",
        "definition": "참조 대상의 예상 형식임. Reference.type과 Reference.reference가 모두 채워지고 Reference.reference가 FHIR URL이면 두가지 모두 일치해야함. 유형은이 참조가 참조하는 유형 인 리소스 정의의 표준 URL임. 참조는 http://hl7.org/fhir/StructureDefinition/과 관련된 URL임. (예) \" 환자 \" http://hl7.org/fhir/StructureDefinition/Patient에 대한 참조. 절대 URL은 논리 모델에만 허용됨 (리소스가 아닌 논리 모델의 참조에서만 사용할 수 있음)."
      },
      {
        "id": "Device.location.identifier",
        "path": "Device.location.identifier",
        "short": "문안 참조를 알 수 없는 경우의 논리 참조 (logical reference)",
        "definition": "대상 리소스의 식별자. 이것은 다른 리소스를 직접 참조할 방법이 없을 때 사용- 해당 앤티티(entity)가 FHIR 서버를 통해 사용할 수 없거나  리소스 작성자가 알려진 식별자를 실제 위치로 변활할 방법이 없기 때문에 이 방법이 사용됨. Reference.identifier가 실제로 FHIR 인스턴스로 노출되는 것을 가르킬(point) 필요는 없지만, FHIR 인스턴스로 노출될 것으로 예상되는 비즈니스 개념을 가리켜야하며, 해당 인스턴스는 참조가 허용되는 FHIR 리소스 유형이여야함."
      },
      {
        "id": "Device.location.identifier.id",
        "path": "Device.location.identifier.id",
        "short": "요소-간의 참조를 위한 고유 ID",
        "definition": "리소스 안의 요소의 고유 ID(내부 참조용)임. 공백이 없는 문자열 값일수 있음."
      },
      {
        "id": "Device.location.identifier.use",
        "path": "Device.location.identifier.use",
        "short": "usual | official | temp | secondary | old (If known)",
        "definition": "해당 식별자의 목적"
      },
      {
        "id": "Device.location.identifier.type",
        "path": "Device.location.identifier.type",
        "short": "식별자에 대한 설명",
        "definition": "특정 목적으로 사용되는 식별자를 결정하기 위해 사용하는 식별자의 코드 유형을 나타냄."
      },
      {
        "id": "Device.location.identifier.type.id",
        "path": "Device.location.identifier.type.id",
        "short": "요소-간의 참조를 위한 고유 ID",
        "definition": "리소스 안의 요소의 고유 ID(내부 참조용)임. 공백이 없는 문자열 값일수 있음."
      },
      {
        "id": "Device.location.identifier.type.coding",
        "path": "Device.location.identifier.type.coding",
        "short": "전문용어체계(terminology system)에 의해 정의된 코드",
        "definition": "전문용어체계(terminology system)에 의해 정의된 코드를 참조"
      },
      {
        "id": "Device.location.identifier.type.coding.id",
        "path": "Device.location.identifier.type.coding.id",
        "short": "요소-간의 참조를 위한 고유 ID",
        "definition": "리소스 안의 요소의 고유 ID(내부 참조용)임. 공백이 없는 문자열 값일수 있음."
      },
      {
        "id": "Device.location.identifier.type.coding.system",
        "path": "Device.location.identifier.type.coding.system",
        "short": "해당 전문용어체계(terminology system)의 식별",
        "definition": "코드에서 기호의 의미를 정의하는 CodeSystem[코드시스템]를 식별"
      },
      {
        "id": "Device.location.identifier.type.coding.version",
        "path": "Device.location.identifier.type.coding.version",
        "short": "해당 시스템의 버전 정보 - 필요한 경우",
        "definition": "해당 코드를 선택한 시점에 사용된 코드 시스템의 버전임. 올바로 관리된 코드 시스템은 코드의 의미가 버전과 관계없이 일관적이므로 버전을 보고할 필요가 없음. 그러나 코드 시스템의 관리 상태는 지속적으로 보장할 수 없는 부분이며, 코드의 의미가 일관적임을 보장할 수 없는 경우 버전이 교체되어야 함."
      },
      {
        "id": "Device.location.identifier.type.coding.code",
        "path": "Device.location.identifier.type.coding.code",
        "short": "시스템에 정의된 구문(syntax)의 기호(symbol)",
        "definition": "시스템에 정의된 구문의 기호. 기호는 CodeSystem[코드시스템]에 의해 정의된 구문에서 미리 정의된 코드 또는 표현(expression)일 수 있음. (예: post-coordination)"
      },
      {
        "id": "Device.location.identifier.type.coding.display",
        "path": "Device.location.identifier.type.coding.display",
        "short": "시스템에 정의된 표현",
        "definition": "시스템 내 코드의 의미를 시스템의 규칙에 따라 표현한 것을 의미함."
      },
      {
        "id": "Device.location.identifier.type.coding.userSelected",
        "path": "Device.location.identifier.type.coding.userSelected",
        "short": "해당 코딩 방법이 사용자에 의해 직접 선택되었는지 여부",
        "definition": "해당 코딩 방법이 사용자에 의해 직접 선택되었음을 나타냄. 즉, 선택 가능한 항목 (코드 혹은 디스플레이) 목록에 존재하지 않음을 나타냄."
      },
      {
        "id": "Device.location.identifier.type.text",
        "path": "Device.location.identifier.type.text",
        "short": "개념에 대한 일반 텍스트 묘사",
        "definition": "데이터를 입력한 사용자의 입장에서 보거나/선택하거나/언급한대로의 개념, 혹은 사용자가 의도한 의미를 사람이 사용하는 언어로 표현한 것임."
      },
      {
        "id": "Device.location.identifier.system",
        "path": "Device.location.identifier.system",
        "short": "식별자 값의 네임스페이스(namespace)",
        "definition": "설정값에 대한 네임 스페이스 (namespace), 즉 고유한 설정값을 설명하는 URL을 설정함."
      },
      {
        "id": "Device.location.identifier.value",
        "path": "Device.location.identifier.value",
        "short": "고유 설정값",
        "definition": "일반적으로 식별자의 사용과와 관련이 있으며, 시스템 컨텍스트 (context) 내에서 고유한 식별자의 일부분임."
      },
      {
        "id": "Device.location.identifier.period",
        "path": "Device.location.identifier.period",
        "short": "식별자의 유효 기간",
        "definition": "식별자가 사용 가능했거나 가능한 기간을 나타냄."
      },
      {
        "id": "Device.location.identifier.period.id",
        "path": "Device.location.identifier.period.id",
        "short": "요소-간의 참조를 위한 고유 ID",
        "definition": "리소스 안의 요소의 고유 ID(내부 참조용)임. 공백이 없는 문자열 값일수 있음."
      },
      {
        "id": "Device.location.identifier.period.start",
        "path": "Device.location.identifier.period.start",
        "short": "해당 유효 기간의 시작 시점 (설정된 날짜 포함)",
        "definition": "해당 유효 기간이 시작되는 시점을 나타냄. 유효 기간은 시작 시점으로 설정된 날짜를 포함함."
      },
      {
        "id": "Device.location.identifier.period.end",
        "path": "Device.location.identifier.period.end",
        "short": "해당 유효 기간의 종료 시점 (설정된 날짜 포함)",
        "definition": "기간의 종료. 기간의 종료가 누락된 경우, 인스턴스가 생성될 때 끝이 알려지거나 계획되지 않았음을 의미함. 시작일은 과거일 수 있고 종료일은 미래일 수 있음. 이는 해당 기간이 해당 시간에 종료될 예정임을 의미함"
      },
      {
        "id": "Device.location.identifier.assigner",
        "path": "Device.location.identifier.assigner",
        "short": "식별자를 발급한 조직 (단순 텍스트 기입 가능)",
        "definition": "식별자를 발급하고 관리하는 조직을 나타냄."
      },
      {
        "id": "Device.location.display",
        "path": "Device.location.display",
        "short": "해당 리소스를 대체하는 텍스트 설명",
        "definition": "리소스 참조 외에도 리소스를 식별하기 위한 일반 텍스트 설명임."
      },
      {
        "id": "Device.url",
        "path": "Device.url",
        "short": "기기의 네트워크 주소",
        "definition": "기기에 직접적으로 접근할 수 있는 네트워크 주소",
        "comment": "만약 Device[]가 FHIR 서버를 실행하는 경우, 네크워크 주소는 적합성 선언(conformance statement)를 검생할 수 있는 기본 URL이여야 함.",
        "max": "1",
        "type": [
          {
            "code": "uri"
          }
        ],
        "mapping": [
          {
            "identity": "w5",
            "map": "FiveWs.where[x]"
          },
          {
            "identity": "rim",
            "map": ".telecom"
          }
        ]
      },
      {
        "id": "Device.note",
        "path": "Device.note",
        "short": "기기 관련 설명",
        "definition": "기기의 사용 시 필요한 설명 혹은 사용 정보",
        "type": [
          {
            "code": "Annotation"
          }
        ],
        "mapping": [
          {
            "identity": "rim",
            "map": ".text"
          }
        ]
      },
      {
        "id": "Device.note.id",
        "path": "Device.note.id",
        "short": "요소-간의 참조를 위한 고유 ID",
        "definition": "리소스 안의 요소의 고유 ID(내부 참조용)임. 공백이 없는 문자열 값일수 있음."
      },
      {
        "id": "Device.note.author[x]",
        "path": "Device.note.author[x]",
        "short": "주석(annotation)을 담당하는 사람",
        "definition": "주석(annotation) 작성을 담당하는 사람"
      },
      {
        "id": "Device.note.time",
        "path": "Device.note.time",
        "short": "주석(annotation)이 만들어진 시기",
        "definition": "특정 주석(annotation)을 작성한 시기를 표시함."
      },
      {
        "id": "Device.note.text",
        "path": "Device.note.text",
        "short": "주석- 텍스트 내용 (Markdown)",
        "definition": "마크다운(markdown) 형식의 주석 텍스트임."
      },
      {
        "id": "Device.safety",
        "path": "Device.safety",
        "short": "기기의 안전에 관련된 특성",
        "definition": "해당 의료기기의 안전에 관련된 특성을 제공함. (예 : 라텍스가 포함 된 장치)",
        "type": [
          {
            "code": "CodeableConcept"
          }
        ],
        "isSummary": true,
        "mapping": [
          {
            "identity": "rim",
            "map": "NA"
          }
        ]
      },
      {
        "id": "Device.safety.id",
        "path": "Device.safety.id",
        "short": "요소-간의 참조를 위한 고유 ID",
        "definition": "리소스 안의 요소의 고유 ID(내부 참조용)임. 공백이 없는 문자열 값일수 있음."
      },
      {
        "id": "Device.safety.coding",
        "path": "Device.safety.coding",
        "short": "전문용어체계(terminology system)에 의해 정의된 코드",
        "definition": "전문용어체계(terminology system)에 의해 정의된 코드를 참조"
      },
      {
        "id": "Device.safety.coding.id",
        "path": "Device.safety.coding.id",
        "short": "요소-간의 참조를 위한 고유 ID",
        "definition": "리소스 안의 요소의 고유 ID(내부 참조용)임. 공백이 없는 문자열 값일수 있음."
      },
      {
        "id": "Device.safety.coding.system",
        "path": "Device.safety.coding.system",
        "short": "해당 전문용어체계(terminology system)의 식별",
        "definition": "코드에서 기호의 의미를 정의하는 CodeSystem[코드시스템]를 식별"
      },
      {
        "id": "Device.safety.coding.version",
        "path": "Device.safety.coding.version",
        "short": "해당 시스템의 버전 정보 - 필요한 경우",
        "definition": "해당 코드를 선택한 시점에 사용된 코드 시스템의 버전임. 올바로 관리된 코드 시스템은 코드의 의미가 버전과 관계없이 일관적이므로 버전을 보고할 필요가 없음. 그러나 코드 시스템의 관리 상태는 지속적으로 보장할 수 없는 부분이며, 코드의 의미가 일관적임을 보장할 수 없는 경우 버전이 교체되어야 함."
      },
      {
        "id": "Device.safety.coding.code",
        "path": "Device.safety.coding.code",
        "short": "시스템에 정의된 구문(syntax)의 기호(symbol)",
        "definition": "시스템에 정의된 구문의 기호. 기호는 CodeSystem[코드시스템]에 의해 정의된 구문에서 미리 정의된 코드 또는 표현(expression)일 수 있음. (예: post-coordination)"
      },
      {
        "id": "Device.safety.coding.display",
        "path": "Device.safety.coding.display",
        "short": "시스템에 정의된 표현",
        "definition": "시스템 내 코드의 의미를 시스템의 규칙에 따라 표현한 것을 의미함."
      },
      {
        "id": "Device.safety.coding.userSelected",
        "path": "Device.safety.coding.userSelected",
        "short": "해당 코딩 방법이 사용자에 의해 직접 선택되었는지 여부",
        "definition": "해당 코딩 방법이 사용자에 의해 직접 선택되었음을 나타냄. 즉, 선택 가능한 항목 (코드 혹은 디스플레이) 목록에 존재하지 않음을 나타냄."
      },
      {
        "id": "Device.safety.text",
        "path": "Device.safety.text",
        "short": "개념에 대한 일반 텍스트 묘사",
        "definition": "데이터를 입력한 사용자의 입장에서 보거나/선택하거나/언급한대로의 개념, 혹은 사용자가 의도한 의미를 사람이 사용하는 언어로 표현한 것임."
      },
      {
        "id": "Device.parent",
        "path": "Device.parent",
        "short": "상위 Device[]",
        "definition": "상위 Device[]",
        "max": "1",
        "type": [
          {
            "code": "Reference",
            "targetProfile": [
              "http://hl7.org/fhir/StructureDefinition/Device"
            ]
          }
        ]
      },
      {
        "id": "Device.parent.id",
        "path": "Device.parent.id",
        "short": "요소-간의 참조를 위한 고유 ID",
        "definition": "리소스 안의 요소의 고유 ID(내부 참조용)임. 공백이 없는 문자열 값일수 있음."
      },
      {
        "id": "Device.parent.reference",
        "path": "Device.parent.reference",
        "short": "문안 참조, 상대적, 내부적 혹은 절대적인 URL",
        "definition": "다른 리소스(resource)을 찾을 수 있는 위치에 대한 참조를 의미함. 해당 참조는 service base URL에 상대적인 경우 상대 참조, 혹은 해당 리소스를 찾을 수 있는 위치인 절대 URL일 수 있음. 해당 참조는 버전에 따라 다를 수 있음. 해당 참조가 FHIR RESTful 서버가 아닌 경우, 버전에 따라 다른 것으로 간주함. 내부 구문 참조('#'으로 시작)는 포함되어 있는 리소스를 참조함."
      },
      {
        "id": "Device.parent.type",
        "path": "Device.parent.type",
        "short": "참조(reference)가 참조하는 유형  (예. \"Patient\")",
        "definition": "참조 대상의 예상 형식임. Reference.type과 Reference.reference가 모두 채워지고 Reference.reference가 FHIR URL이면 두가지 모두 일치해야함. 유형은이 참조가 참조하는 유형 인 리소스 정의의 표준 URL임. 참조는 http://hl7.org/fhir/StructureDefinition/과 관련된 URL임. (예) \" 환자 \" http://hl7.org/fhir/StructureDefinition/Patient에 대한 참조. 절대 URL은 논리 모델에만 허용됨 (리소스가 아닌 논리 모델의 참조에서만 사용할 수 있음)."
      },
      {
        "id": "Device.parent.identifier",
        "path": "Device.parent.identifier",
        "short": "문안 참조를 알 수 없는 경우의 논리 참조 (logical reference)",
        "definition": "대상 리소스의 식별자. 이것은 다른 리소스를 직접 참조할 방법이 없을 때 사용- 해당 앤티티(entity)가 FHIR 서버를 통해 사용할 수 없거나  리소스 작성자가 알려진 식별자를 실제 위치로 변활할 방법이 없기 때문에 이 방법이 사용됨. Reference.identifier가 실제로 FHIR 인스턴스로 노출되는 것을 가르킬(point) 필요는 없지만, FHIR 인스턴스로 노출될 것으로 예상되는 비즈니스 개념을 가리켜야하며, 해당 인스턴스는 참조가 허용되는 FHIR 리소스 유형이여야함."
      },
      {
        "id": "Device.parent.identifier.id",
        "path": "Device.parent.identifier.id",
        "short": "요소-간의 참조를 위한 고유 ID",
        "definition": "리소스 안의 요소의 고유 ID(내부 참조용)임. 공백이 없는 문자열 값일수 있음."
      },
      {
        "id": "Device.parent.identifier.use",
        "path": "Device.parent.identifier.use",
        "short": "usual | official | temp | secondary | old (If known)",
        "definition": "해당 식별자의 목적"
      },
      {
        "id": "Device.parent.identifier.type",
        "path": "Device.parent.identifier.type",
        "short": "식별자에 대한 설명",
        "definition": "특정 목적으로 사용되는 식별자를 결정하기 위해 사용하는 식별자의 코드 유형을 나타냄."
      },
      {
        "id": "Device.parent.identifier.type.id",
        "path": "Device.parent.identifier.type.id",
        "short": "요소-간의 참조를 위한 고유 ID",
        "definition": "리소스 안의 요소의 고유 ID(내부 참조용)임. 공백이 없는 문자열 값일수 있음."
      },
      {
        "id": "Device.parent.identifier.type.coding",
        "path": "Device.parent.identifier.type.coding",
        "short": "전문용어체계(terminology system)에 의해 정의된 코드",
        "definition": "전문용어체계(terminology system)에 의해 정의된 코드를 참조"
      },
      {
        "id": "Device.parent.identifier.type.coding.id",
        "path": "Device.parent.identifier.type.coding.id",
        "short": "요소-간의 참조를 위한 고유 ID",
        "definition": "리소스 안의 요소의 고유 ID(내부 참조용)임. 공백이 없는 문자열 값일수 있음."
      },
      {
        "id": "Device.parent.identifier.type.coding.system",
        "path": "Device.parent.identifier.type.coding.system",
        "short": "해당 전문용어체계(terminology system)의 식별",
        "definition": "코드에서 기호의 의미를 정의하는 CodeSystem[코드시스템]를 식별"
      },
      {
        "id": "Device.parent.identifier.type.coding.version",
        "path": "Device.parent.identifier.type.coding.version",
        "short": "해당 시스템의 버전 정보 - 필요한 경우",
        "definition": "해당 코드를 선택한 시점에 사용된 코드 시스템의 버전임. 올바로 관리된 코드 시스템은 코드의 의미가 버전과 관계없이 일관적이므로 버전을 보고할 필요가 없음. 그러나 코드 시스템의 관리 상태는 지속적으로 보장할 수 없는 부분이며, 코드의 의미가 일관적임을 보장할 수 없는 경우 버전이 교체되어야 함."
      },
      {
        "id": "Device.parent.identifier.type.coding.code",
        "path": "Device.parent.identifier.type.coding.code",
        "short": "시스템에 정의된 구문(syntax)의 기호(symbol)",
        "definition": "시스템에 정의된 구문의 기호. 기호는 CodeSystem[코드시스템]에 의해 정의된 구문에서 미리 정의된 코드 또는 표현(expression)일 수 있음. (예: post-coordination)"
      },
      {
        "id": "Device.parent.identifier.type.coding.display",
        "path": "Device.parent.identifier.type.coding.display",
        "short": "시스템에 정의된 표현",
        "definition": "시스템 내 코드의 의미를 시스템의 규칙에 따라 표현한 것을 의미함."
      },
      {
        "id": "Device.parent.identifier.type.coding.userSelected",
        "path": "Device.parent.identifier.type.coding.userSelected",
        "short": "해당 코딩 방법이 사용자에 의해 직접 선택되었는지 여부",
        "definition": "해당 코딩 방법이 사용자에 의해 직접 선택되었음을 나타냄. 즉, 선택 가능한 항목 (코드 혹은 디스플레이) 목록에 존재하지 않음을 나타냄."
      },
      {
        "id": "Device.parent.identifier.type.text",
        "path": "Device.parent.identifier.type.text",
        "short": "개념에 대한 일반 텍스트 묘사",
        "definition": "데이터를 입력한 사용자의 입장에서 보거나/선택하거나/언급한대로의 개념, 혹은 사용자가 의도한 의미를 사람이 사용하는 언어로 표현한 것임."
      },
      {
        "id": "Device.parent.identifier.system",
        "path": "Device.parent.identifier.system",
        "short": "식별자 값의 네임스페이스(namespace)",
        "definition": "설정값에 대한 네임 스페이스 (namespace), 즉 고유한 설정값을 설명하는 URL을 설정함."
      },
      {
        "id": "Device.parent.identifier.value",
        "path": "Device.parent.identifier.value",
        "short": "고유 설정값",
        "definition": "일반적으로 식별자의 사용과와 관련이 있으며, 시스템 컨텍스트 (context) 내에서 고유한 식별자의 일부분임."
      },
      {
        "id": "Device.parent.identifier.period",
        "path": "Device.parent.identifier.period",
        "short": "식별자의 유효 기간",
        "definition": "식별자가 사용 가능했거나 가능한 기간을 나타냄."
      },
      {
        "id": "Device.parent.identifier.period.id",
        "path": "Device.parent.identifier.period.id",
        "short": "요소-간의 참조를 위한 고유 ID",
        "definition": "리소스 안의 요소의 고유 ID(내부 참조용)임. 공백이 없는 문자열 값일수 있음."
      },
      {
        "id": "Device.parent.identifier.period.start",
        "path": "Device.parent.identifier.period.start",
        "short": "해당 유효 기간의 시작 시점 (설정된 날짜 포함)",
        "definition": "해당 유효 기간이 시작되는 시점을 나타냄. 유효 기간은 시작 시점으로 설정된 날짜를 포함함."
      },
      {
        "id": "Device.parent.identifier.period.end",
        "path": "Device.parent.identifier.period.end",
        "short": "해당 유효 기간의 종료 시점 (설정된 날짜 포함)",
        "definition": "기간의 종료. 기간의 종료가 누락된 경우, 인스턴스가 생성될 때 끝이 알려지거나 계획되지 않았음을 의미함. 시작일은 과거일 수 있고 종료일은 미래일 수 있음. 이는 해당 기간이 해당 시간에 종료될 예정임을 의미함"
      },
      {
        "id": "Device.parent.identifier.assigner",
        "path": "Device.parent.identifier.assigner",
        "short": "식별자를 발급한 조직 (단순 텍스트 기입 가능)",
        "definition": "식별자를 발급하고 관리하는 조직을 나타냄."
      },
      {
        "id": "Device.parent.display",
        "path": "Device.parent.display",
        "short": "해당 리소스를 대체하는 텍스트 설명",
        "definition": "리소스 참조 외에도 리소스를 식별하기 위한 일반 텍스트 설명임."
      }
    ]
  }
}