-- ASN module extracted from ITU-T X.1080.2 (10/2021)

Biology-to-Machine { joint-iso-itu-t(2) telebiometrics(42) thprot(10) part2(2)
   modules(0) b2m(0) version1(1)}

DEFINITIONS IMPLICIT TAGS ::=
BEGIN

IMPORTS

  SupportedGenInfo, SupportedUnits
    FROM
      InfoObjects {joint-iso-itu-t(2) telebiometrics(42) thprot(10) part2(2)
                   modules(0) infoObjects(2) version1(1)}

  moving-detect
    FROM MonitorTypes
      {joint-iso-itu-t(2) telebiometrics(42) thprot(10) part2(2)
      modules(0) monitor-types(1) monitors(0) version1(1)} ;

id-telebio         OBJECT IDENTIFIER ::= { joint-iso-itu-t(2) telebiometrics(42) }
id-thprot          OBJECT IDENTIFIER ::= { id-telebio thprot(10) }
id-x1080-2         OBJECT IDENTIFIER ::= { id-thprot part2(2) }
id-x1080-2-modules OBJECT IDENTIFIER ::= { id-x1080-2 modules(0) }
id-mt              OBJECT IDENTIFIER ::= { id-x1080-2 monitor-type(1) }
id-un              OBJECT IDENTIFIER ::= { id-x1080-2 unit(2) }
id-gi              OBJECT IDENTIFIER ::= { id-x1080-2 gen-info(3) }

MONITOR-TYPE ::= TYPE-IDENTIFIER

Direction ::= ENUMERATED {in(0), out(1)}

DeviceInfo ::= SEQUENCE {
  vendor [0] UTF8String OPTIONAL,
  type   [1] UTF8String OPTIONAL,
  id     [2] UTF8String OPTIONAL,
  ... }

SupportedMonitorTypes MONITOR-TYPE ::= {moving-detect}

OPTIONS ::= CLASS {
  &Voice-options   OPTIONAL,
  &Video-options   OPTIONAL }
WITH SYNTAX {
  [VOICE OPTIONS   &Voice-options]
  [VIDEO OPTIONS   &Video-options] }

UNIT ::= CLASS {
  &name      PrintableString,
  &symbol    PrintableString,
  &quantity  PrintableString OPTIONAL,
  &Value,
  &id        OBJECT IDENTIFIER UNIQUE }
WITH SYNTAX {
  NAME       &name
  SYMBOL     &symbol
  [QUANTITY  &quantity]
  VALUE      &Value
  ID         &id }

Unit{UNIT:SupportedUnits} ::= SEQUENCE {
  id            UNIT.&id({SupportedUnits}),
  name          UNIT.&name({SupportedUnits}{@id}),
  symbol        UNIT.&symbol({SupportedUnits}{@id}),
  quantity  [0] UNIT.&quantity({SupportedUnits}{@id}) OPTIONAL,
  value     [1] UNIT.&Value }

GEN-INFO ::= CLASS {
  &Type,
  &id     OBJECT IDENTIFIER UNIQUE }
WITH SYNTAX {
  SYNTAX  &Type
  ID      &id }

Gen-Info {GEN-INFO:SupportedGenInfo} ::= SEQUENCE {
  type     GEN-INFO.&id({SupportedGenInfo}),
  value    GEN-INFO.&Type({SupportedGenInfo}{@type}) }

B2M-protocol ::= CHOICE {
  b2mInitReq   [0] B2MInitReq,
  b2mInitAcc   [1] B2MInitAcc,
  b2mInitRej   [2] B2MInitRej,
  b2mInitAbt   [3] B2MInitAbt,
  b2mTranf     [4] B2MDataTransfer,
  ... }

B2MInitReq ::= SEQUENCE {
  version           Version,
  requirements      ENUMERATED {
    none                               (0),
    with-2-way-voice                   (1),
    with-reverse-video-and-2-way-voice (2),
    with-2-way-video-and-voice         (3),
    ... } DEFAULT none,
  voice-options [0] OPTIONS.&Voice-options OPTIONAL,
  video-options [1] OPTIONS.&Video-options OPTIONAL,
  monitorTypes      SEQUENCE SIZE (1..MAX) OF MONITOR-TYPE.&id ({SupportedMonitorTypes}),
  ... }

Version ::= BIT STRING {
  v1 (0)  -- version 1
  }

B2MInitAcc ::= SEQUENCE {
  version       Version,
  monitorTypes  SEQUENCE SIZE (1..MAX) OF MONITOR-TYPE.&id OPTIONAL,
  ... }

B2MInitRej ::= SEQUENCE {
  version Version,
  initErr InitError,
  ... }

InitError ::=  ENUMERATED {
  initiation-not-allowed      (0),
  versions-not-supported      (1),
  voice-option-not-available  (2),
  video-option-not-available  (3),
  monitor-types-not-supported (4),
  ... }

B2MInitAbt ::= SEQUENCE {
  version Version,
  accErr  AccError,
  ... }

AccError ::= ENUMERATED {
  only-one-version              (0),
  unexpected-version            (1),
  unexpected-monitorTypes       (2),
  critical-monitorTypes-missing (3),
  ... }

B2MDataTransfer ::= SEQUENCE {
  time              GeneralizedTime,
  genInfos      [0] SEQUENCE SIZE (1..MAX) OF CHOICE {
    genInfoType     GEN-INFO.&id({SupportedGenInfo}),
    genInfo         Gen-Info{{SupportedGenInfo}},
    ... } OPTIONAL,
  monTypes    [1] SEQUENCE SIZE (1..MAX) OF SEQUENCE SIZE (1..MAX) OF SEQUENCE {
    deviceInfo  [1] DeviceInfo OPTIONAL,
    mon         [2] MONITOR-TYPE.&Type ({SupportedMonitorTypes}) OPTIONAL,
    ... },
  ... }

InvokeID ::= INTEGER (0..MAX)

END -- Biology-to-Machine