E-health-identification {joint-iso-itu-t(2) telebiometrics(42)
  e-health-protocol(3) modules(0) identification(0) version1(1)}
  "/Telebiometrics/E_Health_Protocol/Modules/Identification/Version1"
  DEFINITIONS AUTOMATIC TAGS ::=
BEGIN

IMPORTS
  id-th
    FROM Telebiometrics {joint-iso-itu-t(2) telebiometrics(42) tmm(1)
      modules(0)      modules(0) main(0) version(0)};

IDENTIFICATION ::= 0db>CLASS {&category        OID UNIQUE,
                          &Identification  
}WITH SYNTAX {CATEGORY &category
              IDENTIFIED WITH &Identification
}

OID ::= OBJECT IDENTIFIER

Identification ::= SEQUENCE {
  category        IDENTIFICATION.&category({Categories}),
  identification  IDENTIFICATION.&Identification({Categories}{@category})
}

Categories IDENTIFICATION ::=
  {patientIdentification | medicalStaffIdentification | observerIdentification
   | pharmaceuticalStaffIdentification | laboratoryIdentification |
   manufacturerIdentification | deviceIdentification | softwareIdentification |
   insuranceIdentification | medicalRecordIdentification, ...}

patientIdentification IDENTIFICATION ::= {
  CATEGORY         {id-th  1}
  IDENTIFIED WITH  PatientIdentification
}

PatientIdentification ::= SEQUENCE {
  scheme      PATIENT-SCHEME.&id({PatientSchemes}),
  schemeName  PATIENT-SCHEME.&name({PatientSchemes}{@.scheme}) OPTIONAL,
  patientId   PATIENT-SCHEME.&Identification({PatientSchemes}{@.scheme})
}

PATIENT-SCHEME ::= CLASS {
  &id              OID UNIQUE,
  &name            SchemeName OPTIONAL,
  &Identification  
}
WITH SYNTAX {
  SCHEME
  [NAME &name]
  IDENTIFIED BY &id
  USING &Identification
}

SchemeName ::= CHOICE {string  ISO646String,
                       iri     OID-IRI,
                       ...
}

PatientSchemes PATIENT-SCHEME ::=
  {...}

medicalStaffIdentification IDENTIFICATION ::= {
  CATEGORY         {id-th  2}
  IDENTIFIED WITH  MedicalStaffIdentification
}

MedicalStaffIdentification ::= SEQUENCE {
  scheme          MEDICAL-STAFF-SCHEME.&id({MedicalStaffSchemes}),
  schemeName
    MEDICAL-STAFF-SCHEME.&name({MedicalStaffSchemes}{@.scheme}) OPTIONAL,
  medicalStaffId
    MEDICAL-STAFF-SCHEME.&Identification({MedicalStaffSchemes}{@.scheme}),
  qualifications
    MEDICAL-STAFF-SCHEME.&Qualifications({MedicalStaffSchemes}{@.scheme})
      OPTIONAL
}

MEDICAL-STAFF-SCHEME ::= CLASS {
  &id              OID UNIQUE,
  &name            SchemeName OPTIONAL,
  &Identification  ,
  &Qualifications  ,
  &Observer        
}
WITH SYNTAX {
  SCHEME
  [NAME &name]
  IDENTIFIED BY &id
  USING &Identification
  WITH &Qualifications
  AND &Observer
}

MedicalStaffSchemes MEDICAL-STAFF-SCHEME ::=
  {...}

observerIdentification IDENTIFICATION ::= {
  CATEGORY         {id-th  3}
  IDENTIFIED WITH  ObserverIdentification
}

ObserverIdentification ::= SEQUENCE {
  scheme      MEDICAL-STAFF-SCHEME.&id({MedicalStaffSchemes}),
  schemeName
    MEDICAL-STAFF-SCHEME.&name({MedicalStaffSchemes}{@.scheme}) OPTIONAL,
  observerId
    MEDICAL-STAFF-SCHEME.&Observer({MedicalStaffSchemes}{@.scheme})
}

pharmaceuticalStaffIdentification IDENTIFICATION ::= {
  CATEGORY         {id-th  4}
  IDENTIFIED WITH  PharmaceuticalStaffIdentification
}

PharmaceuticalStaffIdentification ::= SEQUENCE {
  scheme          MEDICAL-STAFF-SCHEME.&id({MedicalStaffSchemes}),
  schemeName
    MEDICAL-STAFF-SCHEME.&name({MedicalStaffSchemes}{@.scheme}) OPTIONAL,
  medicalStaffId
    MEDICAL-STAFF-SCHEME.&Identification({MedicalStaffSchemes}{@.scheme}),
  qualifications
    MEDICAL-STAFF-SCHEME.&Qualifications({MedicalStaffSchemes}{@.scheme})
      OPTIONAL
}

laboratoryIdentification IDENTIFICATION ::= {
  CATEGORY         {id-th  5}
  IDENTIFIED WITH  LaboratoryIdentification
}

LaboratoryIdentification ::= SEQUENCE {
  scheme          LABORATORY-SCHEME.&id({LaboratorySchemes}),
  schemeName
    LABORATORY-SCHEME.&name({LaboratorySchemes}{@.scheme}) OPTIONAL,
  qualifications
    LABORATORY-SCHEME.&Qualifications({LaboratorySchemes}{@.scheme})
      OPTIONAL
}

LABORATORY-SCHEME ::= CLASS {
  &id              OID UNIQUE,
  &name            SchemeName OPTIONAL,
  &Qualifications  
}
WITH SYNTAX {
  SCHEME
  [NAME &name]
  IDENTIFIED BY &id
  WITH &Qualifications
}

LaboratorySchemes LABORATORY-SCHEME ::=
  {...}

manufacturerIdentification IDENTIFICATION ::= {
  CATEGORY         {id-th  6}
  IDENTIFIED WITH  ManufacturerIdentification
}

ManufacturerIdentification ::= SEQUENCE {
  scheme          MANUFACTURER-SCHEME.&id({ManufacturerSchemes}),
  schemeName
    MANUFACTURER-SCHEME.&name({ManufacturerSchemes}{@.scheme}) OPTIONAL,
  manufacturerId
    MANUFACTURER-SCHEME.&Manufacturer({ManufacturerSchemes}{@.scheme}),
  drugId
    MANUFACTURER-SCHEME.&Drug({ManufacturerSchemes}{@.scheme})
}

MANUFACTURER-SCHEME ::= CLASS {
  &id            OID UNIQUE,
  &name          SchemeName OPTIONAL,
  &Manufacturer  ,
  &Drug          
}
WITH SYNTAX {
  SCHEME
  [NAME &name]
  IDENTIFIED BY &id
  FOR &Manufacturer
  PRODUCING &Drug
}

ManufacturerSchemes MANUFACTURER-SCHEME ::=
  {...}

DEVICE-SCHEME ::= CLASS {
  &id                OID UNIQUE,
  &name              SchemeName OPTIONAL,
  &Manufacturer      ,
  &Device            ,
  &supportedFormats  Supported-formats
}
WITH SYNTAX {
  SCHEME
  [NAME &name]
  IDENTIFIED BY &id
  FOR &Manufacturer
  PRODUCING &Device
  SUPPORTING &supportedFormats
}

Supported-formats ::= CHOICE {oids  SEQUENCE OF OID,
                              ...
}

deviceIdentification IDENTIFICATION ::= {
  CATEGORY         {id-th  7}
  IDENTIFIED WITH  DeviceIdentification
}

DeviceIdentification ::= SEQUENCE {
  scheme          DEVICE-SCHEME.&id({DeviceSchemes}),
  schemeName      DEVICE-SCHEME.&name({DeviceSchemes}{@.scheme}) OPTIONAL,
  manufacturerId
    DEVICE-SCHEME.&Manufacturer({DeviceSchemes}{@.scheme}) OPTIONAL,
  device          DEVICE-SCHEME.&Device({DeviceSchemes}{@.scheme}),
  formats
    DEVICE-SCHEME.&supportedFormats({DeviceSchemes}{@.scheme})
}

DeviceSchemes DEVICE-SCHEME ::=
  {...}

softwareIdentification IDENTIFICATION ::= {
  CATEGORY         {id-th  8}
  IDENTIFIED WITH  SoftwareIdentification
}

SOFTWARE-SCHEME ::= CLASS {
  &id            OID UNIQUE,
  &name          SchemeName OPTIONAL,
  &Manufacturer  ,
  &Software      
}
WITH SYNTAX {
  SCHEME
  [NAME &name]
  IDENTIFIED BY &id
  FOR &Manufacturer
  PRODUCING &Software
}

SoftwareIdentification ::= SEQUENCE {
  scheme          SOFTWARE-SCHEME.&id({SoftwareSchemes}),
  schemeName
    SOFTWARE-SCHEME.&name({SoftwareSchemes}{@.scheme}) OPTIONAL,
  manufacturerId
    SOFTWARE-SCHEME.&Manufacturer({SoftwareSchemes}{@.scheme}) OPTIONAL,
  software        SOFTWARE-SCHEME.&Software({SoftwareSchemes}{@.scheme})
}

SoftwareSchemes SOFTWARE-SCHEME ::=
  {...}

insuranceIdentification IDENTIFICATION ::= {
  CATEGORY         {id-th  9}
  IDENTIFIED WITH  InsuranceIdentification
}

InsuranceIdentification ::= SEQUENCE {
  scheme          INSURANCE-SCHEME.&id({InsuranceSchemes}),
  schemeName
    INSURANCE-SCHEME.&name({InsuranceSchemes}{@.scheme}) OPTIONAL,
  manufacturerId  INSURANCE-SCHEME.&Company({InsuranceSchemes}{@.scheme}),
  insurance
    INSURANCE-SCHEME.&InsuranceType({InsuranceSchemes}{@.scheme}),
  insuranceCert
    INSURANCE-SCHEME.&Certification({InsuranceSchemes}{@.scheme})
}

INSURANCE-SCHEME ::= CLASS {
  &id             OID UNIQUE,
  &name           SchemeName OPTIONAL,
  &Company        ,
  &InsuranceType  ,
  &Certification  
}
WITH SYNTAX {
  SCHEME
  [NAME &name]
  IDENTIFIED BY &id
  FOR &Company
  USING &InsuranceType
  CERTIFIED WITH &Certification
}

InsuranceSchemes INSURANCE-SCHEME ::=
  {...}

medicalRecordIdentification IDENTIFICATION ::= {
  CATEGORY         {id-th  10}
  IDENTIFIED WITH  MedicalRecordIdentification
}

MedicalRecordIdentification ::= SEQUENCE {
  scheme       MEDICAL-RECORD-SCHEME.&id({MedicalRecordSchemes}),
  schemeName
    MEDICAL-RECORD-SCHEME.&name({MedicalRecordSchemes}{@.scheme}) OPTIONAL,
  definingOrg
    MEDICAL-RECORD-SCHEME.&Organisation({MedicalRecordSchemes}{@.scheme}),
  recordType
    MEDICAL-RECORD-SCHEME.&RecordType({MedicalRecordSchemes}{@.scheme}),
  record
    MEDICAL-RECORD-SCHEME.&Record({MedicalRecordSchemes}{@.scheme})
}

MEDICAL-RECORD-SCHEME ::= CLASS {
  &id            OID UNIQUE,
  &name          SchemeName OPTIONAL,
  &Organisation  ,
  &RecordType    ,
  &Record        
}
WITH SYNTAX {
  SCHEME
  [NAME &name]
  IDENTIFIED BY &id
  FOR &Organisation
  USING &RecordType
  WITH FORMAT &Record
}

MedicalRecordSchemes MEDICAL-RECORD-SCHEME ::=
  {...}

END