Приказ Минкомсвязи России от 23.07.2015 N 279 "Об утверждении Требований к оборудованию и программному обеспечению операторов почтовой связи для обеспечения доступа к базам данных об оказанных услугах почтовой связи и пользователях услугами почтовой связи при проведении оперативно-розыскных мероприятий" (Зарегистрировано в Минюсте России 10.12.2015 N 40066)

                              ┌───────────┐
                              │   sorm    │
                              └─────┬─────┘
                                    │
                              ┌─────┴─────┐
                              │  request  │
                              └─────┬─────┘
                                    │
           ┌────────────────────────┼─────────────────────────────┐
           │                        │                             │
┌──────────┴─────────┐        ┌─────┴─────┐              ┌────────┴───────┐
│     connection     │        │  abonent  │              │   dictionary   │
└─┬──────────────────┘        └─┬─────────┘              └────────────────┘
  │ ┌───────────────┐           │ ┌────────────┐
  └─┤post-connection│           ├─┤   person   │
    └───────────────┘           │ └────────────┘
                                │ ┌────────────┐
                                └─┤organization│
                                  └────────────┘

                            ┌───────────┐
                            │   sorm    │
                            └─────┬─────┘
                                  │
                            ┌─────┴─────┐
                            │  report   │
                            └─────┬─────┘
                                  │
      ┌───────────────────────────┼────────────────────────────┐
      │                           │                            │
┌─────┴─────┐              ┌──────┴─────┐             ┌────────┴───────┐
│  abonent  │              │ connection │             │   dictionary   │
└─┬─────────┘              └──────┬─────┘             └─┬──────────────┘
  │ ┌────────────┐                │ ┌───────────────┐   │ ┌───────────────┐
  ├─┤   person   │                └─┤post-connection│   ├─┤    telcos     │
  │ └────────────┘                  └───────────────┘   │ └───────────────┘
  │ ┌────────────┐                                      │ ┌───────────────┐
  └─┤organization│                                      ├─┤  money-type   │
    └────────────┘                                      │ └───────────────┘
                                                        │ ┌───────────────┐
                                                        ├─┤special-numbers│
                                                        │ └───────────────┘
                                                        │ ┌───────────────┐
                                                        ├─┤  post-office  │
                                                        │ └───────────────┘
                                                        │ ┌───────────────┐
                                                        └─┤   doc-types   │
                                                          └───────────────┘

                           ┌──────────┐
                           │ Sorm.asn │
                           └────┬─────┘
                                │
      ┌─────────────┬───────────┼──────────┬──────────────┬──────────┐
      │             │           │          │              │          │
┌─────┴──────┐ ┌────┴────┐ ┌────┴────┐ ┌───┴────┐ ┌───────┴──┐ ┌─────┴────┐
│Sessions.asn│ │Traps.asn│ │Tasks.asn│ │Manage- │ │Unfor-    │ │Reports.  │
└────────────┘ └─────────┘ └────┬──┬─┘ │ment.asn│ │matted.asn│ │asn       │
                                │  │   └────────┘ └──────────┘ └───┬────┬─┘
                                │  │                               │    │
                                │  │           ┌────────────────┐  │    │
                                │  └───────────┤Dictionaries.asn├──┘    │
                                │              └────────────────┘       │
      ┌─────────────┬───────────┼────────────┬───────────────┐          │
      │             │           │            │               │          │
 ┌────┴──────┐ ┌────┴────┐  ┌───┴─────┐ ┌────┴───────┐ ┌─────┴────────┐ │
 │Tasksonnec-│ │TasksUNI.│  │TasksAbo-│ │Tasks-      │ │TasksNon-     │ │
 │ctions.asn │ │asn      │  │nents.asn│ │Presense.asn│ │Formalized.asn│ │
 └────┬──────┘ └─────────┘  └───┬─────┘ └────────────┘ └──────────────┘ │
      │                         │                                       │
┌─────┴──────────┐     ┌────────┴────────────┐                          │
│RequestedConnec-│     │RequestedAbonents.asn│                          │
│tions.asn       │     └─────────────────────┘                          │
└────────────────┘                                                      │
                                                                        │
                       Совместно используемые модули                    │
                                                                        │
   ┌──────────────────────────────────────────────────────────────────┐ │
   │┌──────────┐ ┌──────────┐ ┌─────────┐ ┌────────────┐ ┌───────────┐│ │
   ││Classifi- │ │Addresses.│ │Post-    │ │Post-       │ │Postlden   ││ │
   ││cation.asn│ │asn       │ │Types.asn│ │Abonents.asn│ │tifiers.asn││ │
   │└──────────┘ └──────────┘ └─────────┘ └────────────┘ └───────────┘│ │
   └──────────────────────────────────────────────────────────────────┘ │
                                                                        │
                    ┌──────────────┬───────────────┬────────────────────┤
                    │              │               │                    │
              ┌─────┴──────┐ ┌─────┴──────┐ ┌──────┴───────┐  ┌─────────┴─┐
              │ReportsCon- │ │Reports-    │ │ReportsNon-   │  │Reportsbo- │
              │nections.asn│ │Presense.asn│ │Formalized.asn│  │nents.asn  │
              └────────────┘ └────────────┘ └──────────────┘  └───────────┘

Addresses.asn

Addresses DEFINITIONS IMPLICIT TAGS ::=
BEGIN

EXPORTS AddressType,
    ReportedAddresses,
    ReportedAddress,
    RequestedAddress;

AddressType ::= ENUMERATED {
    physical (0), --- физический
    legal (1), --- юридический
    delivery (2), --- доставки счета
    receive (3), --- приезда курьера
    common (4), --- общий
   other (5) --- другой
}
ReportedAddresses ::= SEQUENCE OF ReportedAddress

ReportedAddress ::= SEQUENCE {
 address-info AddressInfoReport,                           --- адрес
 title   AddressType OPTIONAL                              --- тип адреса
}
AddressInfoReport ::= CHOICE {
 struct-info[0] AddressStructInfoReport,                   ---
структурированный адрес
 unstruct-mfo[1] UTF8String(SIZE (1 .. 1024))               ---
неструктурированный адрес
}
AddressStructInfoReport ::= SEQUENCE {
 zip [0]   UTF8String (SIZE (1 .. 32)) OPTIONAL,           --- почтовый
индекс, zip-код
 country [1]   UTF8String (SIZE (1 .. 128)) OPTIONAL,      --- страна
 region [2]   UTF8String (SIZE (1 .. 128)) OPTIONAL,       --- область
 zone [3]   UTF8String (SIZE (1 .. 128)) OPTIONAL,         --- район,
муниципальный округ
 city [4]   UTF8String (SIZE (1 .. 128)) OPTIONAL,         --- город,
поселок, деревня
 street [5] UTF8String (SIZE (1 .. 128)) OPTIONAL,         --- улица
 building [6] UTF8String (SIZE (1 .. 128)) OPTIONAL,       --- дом,
строение
 build-sect [7] UTF8String (SIZE (1 .. 128)) OPTIONAL,     --- корпус
 apartment [8] UTF8String (SIZE (1 .. 128)) OPTIONAL       --- квартира,
офис
}
RequestedAddress ::= SEQUENCE {
 address-info RequestedAddressInfo,                        --- адрес
 title   AddressType OPTIONAL                              --- тип адреса
}
RequestedAddressInfo ::= CHOICE {
 struct-info[0] RequestedAddressStructInfo,                ---
структурированный адрес
 unstruct-info[1] UTF8String(SIZE (1 .. 1024))             ---
неструктурированный адрес
}
RequestedAddressStructInfo ::= SEQUENCE {
 country [0]   UTF8String (SIZE (1 .. 128)),               --- страна
 region [1]   UTF8String (SIZE (1 .. 128)) OPTIONAL,       --- область
 zone [2]   UTF8String (SIZE (1 .. 128)) OPTIONAL,         --- район,
муниципальный округ
 city [3]   UTF8String (SIZE (1 .. 128)) OPTIONAL,         --- город,
поселок, деревня
 street [4]   UTF8String (SIZE (1 .. 128)) OPTIONAL,       --- улица
 building [5]   UTF8String (SIZE (1 .. 128)) OPTIONAL,     --- дом,
строение
 build-sect [6]   UTF8String (SIZE (1 .. 128)) OPTIONAL,   --- корпус
 apartment [7]   UTF8String (SIZE (1 .. 128)) OPTIONAL,    --- квартира,
офис
 zip [8]   UTF8String (SIZE (1 .. 32)) OPTIONAL            --- почтовый
индекс, zip-код
}
END

                            Classification.asn

Classification DEFINITIONS IMPLICIT TAGS ::=
BEGIN

EXPORTS TAGGED,
    sorm-message-session,
    sorm-message-trap,
    sorm-message-task,
    sorm-message-report,
    sorm-message-management,
    sorm-message-unformatted,
    sorm-post-abonent-report,

    sorm-post-office,
    sorm-post-office-identifier,

    sorm-report-post-connection,
    sorm-request-post-connection,
    sorm-post-abonent-mailing,

    sorm-requested-post-abonent-person-mailing,
    sorm-requested-post-abonent-organization-mailing,
    sorm-reported-post-abonent-person-mailing,
    sorm-reported-post-abonent-organization-mailing,

    sorm-post-abonent,
    sorm-post-abonent-person,
    sorm-post-abonent-organization,

    sorm-post-type,
    sorm-post-type-package,
    sorm-post-type-money-order,
    sorm-post-type-secogram,
    sorm-post-type-postal-wrapper,
      sorm-post-type-postcard,
      sorm-post-type-ems,
      sorm-post-type-small-packet,
    sorm-post-type-bag-international,

    sorm-request-dictionaries,
    sorm-report-dictionary-telcos,
    sorm-report-dictionary-post-offices,
      sorm-report-dictionary-doc-types,

    sorra-request-presense,
    sorm-report-presense-abonents,
    sorm-report-presense-connections,
    sorm-report-presense-dictionaries,

    sorm-request-abonent,
    sorm-request-contract,
    sorm-requested-abonent-organization,
    sorm-requested-abonent-person,
    sorm-report-abonent-abonent,
    sorm-report-abonent-person,
    sorm-report-abonent-organization
 ;
TAGGED ::= CLASS {
 &id ObjectDescriptor UNIQUE,
 &Data
}
WITH SYNTAX {
 OID &id
 DATA &Data
}
--- Классификация
OID ::= PrintableString

--- Подструктура сообщений
sorm-message-session OID ::= "280"
sorm-message-trap OID ::= "6"
sorm-message-task OID ::= "282"
sorm-message-report OID ::= "7"
sorm-message-management OID ::= "284"
sorm-message-unformatted OID ::= "285"

-- Параметры почтовых отправлений
sorm-report-post-connection OID ::= "1"

-- Идентификаторы
sorm-request-post-connection OID ::= "21"
sorm-post-abonent-mailing OID ::= "22"
sorm-requested-post-abonent-person-mailing OID ::= "23"
sorm-requested-post-abonent-organization-mailing OID ::= "24"
sorm-reported-post-abonent-person-mailig OID ::= "25"
sorm-reported-post-abonent-organization-mailing OID ::= "26"

-- Абоненты
sorm-request-abonent OID ::= "180"
sorm-request-contract OID ::= "181"
sorm-requested-abonent-organization OID ::= "182"
sorm-requested-abonent-person OID ::= "183"

sorm-report-abonent-abonent OID ::= "30"
sorm-report-abonent-person OID ::= "32"
sorm-report-abonent-organization OID ::= "33"

-- Пользователи услуг почтовой связи
sorm-post-abonent OID ::= "2"
sorm-post-abonent-report OID ::= "3"
sorm-post-abonent-person OID ::= "4"
sorm-post-abonent-organization OID ::= "5"

-- Почтовые идентификаторы
sorm-post-office OID ::= "8"
sorm-post-office-identifier OID ::= "9"

-- Виды почтовых отправлений
sorm-post-type OID ::= "60"
sorm-post-type-package OID ::= "61"
sorm-post-type-money-order OID ::= "62"
sorm-post-type-mail OID ::= "63"
sorm-post-type-secogram OID ::= "64"
sorm-post-type-postal-wrapper OID ::= "65"
sorm-post-type-postcard OID ::= "66"
sorm-post-type-ems OID ::= "67"
sorm-post-type-small-packet OID ::= "68"
sorm-post-type-bag-international OID ::= "69"

-- Справочники
sorm-request-dictionaries OID ::= "110"
sorm-report-dictionary-telcos OID ::= "111"
sorm-report-dictionary-money-types OID ::= "112"
sorm-report-dictionary-post-offices OID ::= "113"
sorm-report-dictionary-doc-types OID ::= "114"

-- Запрос о наличии данных
sorm-request-presense OID ::= "260"
sorm-report-presense-abonents OID ::= "120"
sorm-report-presense-connections OID ::= "121"
sorm-report-presense-dictionaries OID ::= "123"

END

                             Dictionaries.asn

Dictionaries DEFINITIONS IMPLICIT TAGS ::=
BEGIN

EXPORTS
  TelcoID,
  TelcoList,
  MoneyType,
  DictionaryTask,
  DictionaryReport;

IMPORTS DateAndTime
  FROM Sorm
    TAGGED,
    sorm-request-dictionaries,
    sorm-report-dictionary-telcos,
   sorm-report-dictionary-post-offices
  FROM Classification

    ReportedAddress
  FROM Addresses;
-- Идентификатор оператора связи или филиала
TelcoID ::= INTEGER (0 .. 65535)

--- список идентификаторов операторов связи или филиалов
TelcoList ::= SEQUENCE OF TelcoID

-- Запрос
DictionaryTask ::= SEQUENCE {
 id TAGGED.&id ({DictionaryTaskVariants}),
 data TAGGED.&Data ({DictionaryTaskVariants} {@id})
}

DictionaryTaskVariants TAGGED ::= { dictionaryTask }
dictionaryTask TAGGED ::= {
 OID { sorm-request-dictionaries}
 DATA ObjectDescriptor                           -- тип запрашиваемого
справочника (идентификатор отчета)
}

-- ObjectDescriptor принимает значение одно из:
-- sorm-report-dictionary-telcos
-- sorm-report-dictionary-post-offices
-- sorm-report-dictionary-doc-types

-- Отчет
DictionaryReport ::= SEQUENCE {
 id   TAGGED.&id ({DictionaryRecordsVariants}),         ---
идентификатор записи справочника
 data TAGGED.&Data({DictionaryRecordsVariants}{@id})    --- данные
записи справочника
}

DictionaryRecordsVariants TAGGED ::= {
    telcosRecords                                     --- операторы связи,
обслуживаемые ТС ОРМ
  | postOfficeRecords                        --- узлы (отделения) почтовой
связи
  | docTypesRecords                          --- типы документов,
удостоверяющие личность
}

--- операторы связи, обслуживаемые ТС ОРМ
telcosRecords TAGGED ::= {
 OID {sorm-report-dictionary-telcos}
 DATA SEQUENCE OF TelcosRecord }

TelcosRecord ::= SEQUENCE {
 telco-id  TelcoID,                            --- номер филиала или
оператора связи
 begin-time DateAndTime,                            --- время начала
действия
 end-time DateAndTime OPTIONAL,                           --- время
конца действия
 description UTF8String (SIZE (1 .. 256))              -- описание
(наименование) оператора связи или филиала
}
--- размер платежа
MoneyType ::= SEQUENCE {
  value REAL,               --- сумма платежа
  type-id PrintableString (SIZE (1 .. 3))     --- код валюты по ISO 4217
}

--- справочник узлов (отделений) почтовой связи
postOfficeRecords TAGGED ::= {
 OID { sorm-report-dictionary-post-offices }
 DATA SEQUENCE OF PostOfficeRecord }

PostOfficeRecord ::= SEQUENCE {
  telco-id     TelcoID,                       --- номер филиала или
оператора связи
  index-post   PrintableString (SIZE (6 .. 10)) OPTIONAL, --- индекс
узла/отделения почтовой связи
  office-type ENUMERATED {                      --- тип узла/отделения
почтовой связи
    international-point (0),              --- международное место почтового
обмена
    customs (1),                          --- место таможенного досмотра
    regional-centre (2),                  --- региональный центр
    simple (3)                            --- узел почтовой связи
  },

  begin-time   DateAndTime,                                --- время начала
действия
  end-time [0]   DateAndTime OPTIONAL,                     ---
время конца действия
  full-name [1]   UTF8String (SIZE (1 .. 128)) OPTIONAL,   --- полное
наименование отделения почтовой связи
  office-address [2]   ReportedAddress OPTIONAL,           --- адрес
узла/отделения почтовой связи
  contact [3]   UTF8String (SIZE (1 .. 128)) OPTIONAL,     --- контактные
телефоны
  public-point-data [4]   UTF8String (SIZE (1 .. 128)) OPTIONAL     ---
информация о пункте коллективного доступа, расположенного в узле/отделении
почтовой связи
}

docTypesRecords TAGGED ::= {
 OID {sorm-report-dictionary-doc-types}
 DATA SEQUENCE OF DocTypesRecord
}
DocTypesRecord ::= SEQUENCE {
 telco-id   TelcoID,                                      --- идентификатор
оператора связи или филиала
 doc-type-id INTEGER (1 .. 65535),                        --- идентификатор
типа документа
 begin-time  DateAndTime,                                  --- время начала
действия
 end-time   DateAndTime OPTIONAL,                         --- время конца
действия
 description UTF8String (SIZE (1 .. 256))                 --- описание
(наименование)
}
END

                               Management.asn

Management DEFINITIONS IMPLICIT TAGS ::=
BEGIN

EXPORTS managementMessage;

IMPORTS TAGGED,
    sorm-message-management
    FROM Classification;

managementMessage TAGGED ::= {
  OID {sorm-message-management}
  DATA CHOICE {
   request [0] ManagementRequest,
   response [1] ManagementResponse
  }
}

--- тип сообщения "команда управления ТС ОРМ"
ManagementRequest ::= CHOICE {
 get-structure [0]  GetStructureRequest,            --- запрос на получение
структуры ТС ОРМ - КТС и модулей СПО
 get-module-config [1] GetModuleConfigRequest,            --- запрос на
получение конфигурации КТС/модуля СПО
 set-module-config [2] SetModuleConfigRequest,            --- запрос на
изменение конфигурации КТС/модуля СПО
 check-module [3]   CheckModuleRequest,             --- запрос на получение
состояния модуля
 get-module-types [4] GetModuleTypesRequest               --- запрос на
получение типов модулей КТС и СПО
}

--- запрос на получение структуры ТС ОРМ - КТС и модулей СПО
GetStructureRequest ::= NULL

--- запрос на получение конфигурации КТС/модуля СПО
GetModuleConfigRequest::= CHOICE {
 hw-modules-list [0] RequestedHardwareModules,               --- перечень
идентификаторов узлов КТС ТС ОРМ
 sw-modules-list [1] RequestedSoftwareModules                --- перечень
идентификаторов модулей СПО ТС ОРМ
}

RequestedHardwareModules ::= SEQUENCE OF ModuleId             --- перечень
идентификаторов узлов КТС ТС ОРМ
RequestedSoftwareModules ::= SEQUENCE OF ModuleId             --- перечень
идентификаторов модулей СПО ТС ОРМ

--- запрос на изменение конфигурации КТС/модуля СПО
SetModuleConfigRequest::= SEQUENCE {
 module-id   ModuleId,                                    --- идентификатор
конфигурируемого модуля
 module-config ConfiguratedModule                     --- устанавливаемая в
модуль конфигурация
}

ConfiguratedModule ::= CHOICE {
 sw-module [0] SormSoftwareModule,                        --- для узла КТС
 hw-module [1] SormHardwareModule                         --- для узла СПО
}

--- запрос на получение состояния модуля
CheckModuleRequest::= RequestedModulesList

RequestedModulesList ::= CHOICE {
 sw-modules [0] RequestedHardwareModules,                --- идентификаторы
узлов КТС, для которых запрашивается состояние
 hw-modules [1] RequestedSoftwareModules                 --- идентификаторы
модулей ТС ОРМ, для которых запрашивается состояние
}

--- запрос на получение типов модулей КТС и СПО
GetModuleTypesRequest ::= NULL

--- уникальный идентификатор КТС/модуля СПО ТС ОРМ
ModuleId ::= OCTETT STRING (SIZE (8))

--- параметр модуля
ModuleParameter ::= SEQUENCE {
 parameter-name UTF8String (SIZE (1 .. 256)),             --- наименование
параметра
 read-only BOOLEAN,                                 --- контролируемый или
измеряемый параметр
 parameter-value ParameterValue                      --- значение параметра
}

--- варианты значений параметров
ParameterValue ::= CHOICE {
 string [0] UTF8String (SIZE (1 .. 256)),
 integer [1] INTEGER (0 .. 999999999),
 boolean [2] BOOLEAN
}

ModuleParameters ::= SEQUENCE OF ModuleParameter

SormSoftwareModule ::= SEQUENCE {
 module-id ModuleId,                                     --- уникальный
идентификатор данного модуля
 hardware-module-id ModuleId,                      --- идентификатор KTC,
на котором работает данный блок модуля СПО
 block-name    INTEGER (0 .. 1024),              --- номер блока СПО модуля
 module-name   UTF8String (SIZE (1 .. 512)),             --- наименование
модуля
 module-type    INTEGER (1 .. 512),                --- идентификатор типа
модуля
 module-parameters ModuleParameters,                        --- список
параметров модуля
 sub-modules-list SubmodulesList OPTIONAL                 --- субмодули
}
SubmodulesList ::= SEQUENCE OF SormSoftwareModule

SormHardwareModule ::= SEQUENCE {
 module-id     ModuleId,                                  --- уникальный
идентификатор данного модуля
 block-name   INTEGER (0 .. 1024),                    --- номер блока KTC
 module-name UTF8String (SIZE (1 .. 512)),            --- наименование
модуля
 module-parameters HwParameterGroups                      --- значение
группы параметров KTC
}

HwParameterGroup ::= SEQUENCE {
 group-name   UTF8String (SIZE (1 .. 512)),      --- наименование группы
параметров для KTC
 module-parameters ModuleParameters              --- перечень параметров
для KTC
}

HwParameterGroups ::= SEQUENCE OF HwParameterGroup

SormSoftwareModules ::= SEQUENCE OF SormSoftwareModule

SormHardwareModules ::= SEQUENCE OF SormHardwareModule

--- тип сообщения "ответ на команду управления ТС ОРМ"
ManagementResponse ::= CHOICE {
 get-structure [0]   GetStructureResponse,           --- ответ на запрос
получения структуры ТС ОРМ - КТС и модулей СПО
 get-module-config [1] GetModuleConfigResponse,      --- ответ на запрос
получения конфигурации КТС/модуля СПО
 set-module-config [2] SetModuleConfigResponse,      --- ответ на запрос
изменения конфигурации КТС/модуля СПО
 check-module [3] CheckModuleResponse,               --- ответ на запрос
получения состояния модуля
 get-module-types [4] GetModuleTypesResponse         --- ответ на запрос
получения типов модулей КТС и СПО
}

--- ответ на запрос получения структуры ТС ОРМ - КТС и модулей СПО
GetStructureResponse ::= SEQUENCE {
 sw-modules SormHardwareModules,                    --- перечень всех узлов
КТС
 hw-modules SormSoftwareModules                        --- перечень всех
модулей СПО ТС ОРМ
}

--- ответ на запрос получения конфигурации КТС/модуля СПО
GetModuleConfigResponse ::= SEQUENCE {
 sw-modules SormHardwareModules,                       --- конфигурации
запрошенных узлов КТС
 hw-modules SormSoftwareModules                        --- конфигурации
запрошенных модулей СПО ТС ОРМ
}

--- отчет на запрос изменения конфигурации КТС/модуля СПО
SetModuleConfigResponse::= ConfiguratedModule          --- установленная
в модуль конфигурация

--- ответ на запрос получения состояния модуля
CheckModuleResponse ::= CHOICE {
 hw-modules [0] SormHardwareModules,                       --- текущее
состояние запрошенных модулей СПО ТС ОРМ
 sw-modules [1] SormSoftwareModules                   --- текущее состояние
запрошенных узлов КТС
}

--- ответ на запрос получения типов модулей КТС и СПО
 GetModuleTypesResponse ::= SEQUENCE OF ModuleType

ModuleType ::= SEQUENCE {
 module-type   INTEGER (1 .. 512),                  --- идентификатор типа
модуля
 type-description UTF8String (SIZE (1 .. 128))  --- расшифровка типа модуля
}
END

                             PostAbonents.asn

PostAbonents DEFINITIONS IMPLICIT TAGS ::=
BEGIN

EXPORTS PostContractAbonent,
    RequestedPostMailingAbonent,
   ReportedPostMailingAbonent,
   PassportInfoReport,
   PersonNameInfo;

IMPORTS TAGGED,
    sorm-post-abonent,
    sorm-post-abonent-person,
    sorm-post-abonent-organization,
    sorm-post-abonent-mailig,
    sorm-requested-post-abonent-person-mailing,
    sorm-requested-post-abonent-organization-mailing,
    sorm-reported-post-abonent-person-mailing,
    sorm-reported-post-abonent-organization-mailing

FROM Classification
    DateAndTime
FROM Sorm
    ReportedAddress
FROM Addresses
    TelcoID
FROM Dictionaries
    ;

PostContractAbonent ::= SEQUENCE {
 id   TAGGED.&id ({AbonentsContractData}),
 data TAGGED.&Data({AbonentsContractData} {@id})
}

AbonentsContractData TAGGED ::= {
    postContractAbonent
}

postContractAbonent TAGGED ::= {
 OID sorm-post-abonent
 DATA PostAbonentContractRecord
}

PostAbonentContractRecord ::= SEQUENCE {
 telco-id    TelcoID,                           --- идентификатор оператора
связи или филиала
 abonent     AbonentContractData,                    --- информация об
абоненте (клиенте оператора связи)
 contract-data   PostContract OPTIONAL               --- информация о
заключенном договоре (в случае юридических лиц, предоставляется только для
принадлежности)
}

PostContract ::= SEQUENCE {
 begin-date DateAndTime,                        --- дата и время заключения
договора
 contract UTF8String (SIZE (1 .. 64)),               --- номер договора
 end-date [0] DateAndTime OPTIONAL,                   --- дата и время
расторжения договора

 bank [1]   UTF8String (SIZE (1 .. 256)) OPTIONAL,     --- банк абонента
(используемый при расчетах с оператором связи)
 bank-account [2]  UTF8String (SIZE (1 .. 512)) OPTIONAL, - счет абонента
в банке (используемый при расчетах с оператором связи)
 corr-account [3]  UTF8String (SIZE (1 .. 512)) OPTIONAL,       ---
корреспондентский счет
 kpp [4]   UTF8String (SIZE (9 .. 64)) OPTIONAL,            --- КПП
 bik [5]   UTF8String (SIZE (9 .. 64)) OPTIONAL,            --- БИК

 contacts [6]   SEQUENCE OF ContactInfo OPTIONAL,            --- контактные
лица
 addresses [7]   SEQUENCE OF PostContractAddress OPTIONAL    --- адреса по
договору
}

PostContractAddress ::= SEQUENCE {
 address Reported Address,                 --- адрес, указанный в контракте
 index-post PrintableString (SIZE (1 .. 10)) OPTIONAL   --- почтовый индекс
адреса
}

--- контактная информация по договору
ContactInfo ::= SEQUENCE {
 contact   PersonNameInfo,                                  --- ФИО
отправителя/контактное лицо
 phone-list [0]  SEQUENCE OF UTF8String (SIZE (1 .. 32)) OPTIONAL, ---
список контактных телефонов
 email-list [1]  SEQUENCE OF UTF8String (SIZE (1 .. 128)) OPTIONAL ---
список е-мейл адресов
}

AbonentContractData ::= SEQUENCE {
 id   TAGGED.&id ({AbonentsContractDataVariants}),
 data TAGGED.&Data({AbonentsContractData Variants} {@id})
}

AbonentsContractDataVariants TAGGED ::= {
 abonentContractPerson |                          --- информация об
абоненте - физическом лице
 abonentContractOrganization                      ---
информация об абоненте - юридическом лице
}

--- Пользователь услуг почтовой связи - физическое лицо
abonentContractPerson TAGGED ::= {
 OID {sorm-post-abonent-person }
 DATA AbonentContractPerson
}

AbonentContractPerson ::= SEQUENCE {
 name-info   PersonNameInfo,                         --- ФИО
 birth-date  GeneralizedTime OPTIONAL,                  --- дата рождения
 passport-info PassportInfoReport OPTIONAL,        ---
паспортные данные
 phone-fax   UTF8String (SIZE (1 .. 128)) OPTIONAL     --- контактные
телефоны, факс
}

PersonNameInfo ::= CHOICE {
 struct-name[0] PersonStructNameInfoReport,             ---
структурированное ФИО
 unstruct-name[1] UTF8String(SIZE (1 .. 1024))            ---
неструктурированное ФИО
}

PersonStructNameInfoReport ::= SEQUENCE {
 given-name UTF8String (SIZE (1 .. 128)),              --- имя
 initial      UTF8String (SIZE (1 .. 128)),             --- отчество (при
наличии)
 family-name UTF8String (SIZE (1 .. 128))              --- фамилия
}

PassportInfoReport::= SEQUENCE {
 ident-card-info IdentCardInfoReport,                   --- описание
удостоверения личности
 doc-type-id INTEGER (0 .. 65535) OPTIONAL                  ---
идентификатор типа документа, удостоверяющего личность
}

IdentCardInfoReport ::= CHOICE {
 struct-info [0]   IdentCardStructInfoReport,             ---
структурированная информация
 unstruct-info [1] UTF8String (SIZE (1 .. 512))           ---
неструктурированная информация
}

IdentCardStructlnfoReport ::= SEQUENCE {
 ident-card-serial UTF8String (SIZE (1 ..16)),         --- серия
удостоверения личности
 ident-card-number NumericString (SIZE (1 ..16)),      --- номер
удостоверения личности
 ident-card-description UTF8String (SIZE (1 .. 256))     --- когда и кем
выдано
}

abonentContractOrganization TAGGED ::= {
 OID {sorm-post-abonent-organization }
 DATA AbonentContractOrganization
}

AbonentContractOrganization ::= SEQUENCE {
 full-name   UTF8String (SIZE (1 .. 256)),                   --- полное
наименование
 inn [0]   NumericString (SIZE (10.. 12)) OPTIONAL,          --- ИНН
 ogrn [1]  UTF8String (SIZE (1 .. 32)) OPTIONAL,             --- ОГРН
 okpo [2]  UTF8String (SIZE (1 .. 32)) OPTIONAL,             --- ОКПО
 index-post [3]   PrintableString (SIZE (1 .. 10)) OPTIONAL  --- почтовый
индекс
}

--- поисковые критерии в информации об абоненте отправителе/получателе
почтового отправления
RequestedPostMailingAbonent ::= SEQUENCE {
 id    TAGGED.&id ({RequestedAbonentsMailingData}),
 data  TAGGED.&Data({RequestedAbonentsMailingData}{@id})
}

RequestedAbonentsMailingData TAGGED ::= {
 requestedMailingPerson |                               --- информация об
абоненте - физическом лице
 requestedMailingOrganization                                ---
информация об абоненте - юридическом лице
}

requestedMailingPerson TAGGED ::= {
 OID {sorm-requested-post-abonent-person-maiiing }
 DATA RequestedAbonentMailingPerson
}

requestedMailingOrganization TAGGED ::= {
 OID { sorm-requested-post-abonent-organization-mailing}
 DATA RequestedAbonentMailingOrganization
}

RequestedAbonentMailingPerson ::= SEQUENCE {
 name-info [0]   PersonNameInfo OPTIONAL,                     --- ФИО
 birth-date [1]  GeneralizedTime OPTIONAL,                    --- дата
рождения
 passport-info [2]   PassportInfoReport OPTIONAL,            --- паспортные
данные
 phone-fax [3]   UTF8String (SIZE (1 .. 128)) OPTIONAL,         ---
контактные телефоны, факс
 address [4]   RequestedAddress OPTIONAL                     --- контактный
адрес
}

RequestedAbonentMailingOrganization ::= SEQUENCE {
 full-name [0]   UTF8String (SIZE (1 .. 256)) OPTIONAL,         --- полное
наименование
 contact [1]   UTF8String (SIZE (1 .. 256)) OPTIONAL,           --- ФИО
отправителя/контактное лицо
 phone-fax [2]   UTF8String (SIZE (1 .. 128)) OPTIONAL,             ---
контактные телефоны, факс
 index-post [3]   PrintableString (SIZE (1 .. 10)) OPTIONAL,   --- почтовый
индекс
 address [4]   RequestedAddress OPTIONAL                     --- контактный
адрес
}

ReportedPostMailingAbonent ::= SEQUENCE {
 personality-info   ReportedPostMailingAbonentInfo,
 phone-fax [0]   UTF8String (SIZE (1 .. 128)) OPTIONAL,         ---
контактные телефоны, факс
 contract [1]    UTF8String (SIZE (1 .. 64)) OPTIONAL,   --- номер договора
 contact-address [2]   ReportedAddress OPTIONAL                 --- адрес
}

--- информация об абоненте отправителе/получателе почтового отправления
в записи блока отчета
ReportedPostMailingAbonentInfo ::= SEQUENCE {
 id   TAGGED.&id ({ReportedAbonentsMailingData}),
 data TAGGED.&Data({ReportedAbonentsMailingData} {@id})
}

ReportedAbonentsMailingData TAGGED ::= {
 reportedMailingPerson |                                 --- информация об
абоненте - физическом лице
 reportedMailingOrganization
информация об абоненте - юридическом лице
}

reportedMailingPerson TAGGED ::= {
 OID {sorm-reported-post-abonent-person-mailing }
 DATA ReportedAbonentMailingPerson
}

reportedMailingOrganization TAGGED ::= {
 OID {sorm-reported-post-abonent-organization-mailing}
 DATA ReportedAbonentMailingOrganization
}

ReportedAbonentMailingPerson ::= SEQUENCE {
 name-info [0]   PersonNameInfo OPTIONAL,                    --- ФИО
 birth-date [1]  GeneralizedTime OPTIONAL,                   --- дата
рождения
 passport-info [2]   PassportInfoReport OPTIONAL         --- паспортные
данные
}

ReportedAbonentMailingOrganization ::= SEQUENCE {
 full-name [0]   UTF8String (SIZE (1 .. 256)) OPTIONAL,      --- полное
наименование
 contact [1]   UTF8String (SIZE (1 .. 256)) OPTIONAL,         --- ФИО
отправителя/контактное лицо
 index-post [3]   PrintableString (SIZE (1 .. 10)) OPTIONAL  --- почтовый
индекс
}
END

                            PostIdentifiers.asn

PostIdentifiers DEFINITIONS IMPLICIT TAGS ::=
BEGIN

EXPORTS PostOffice;
IMPORTS TAGGED,
    sorm-post-office,
    sorm-post-office-identifier
    FROM Classification;

--- идентификаторы отделения почтовой связи
PostOffice ::= SEQUENCE {
 id TAGGED.&id ({PostOfficeVariants}),
 data TAGGED.&Data ({PostOfficeVariants}{@id})
}

--- варианты запрашиваемых идентификаторов
PostOfficeVariants TAGGED ::= {
 postOfficeldentifier                           --- идентификатор почтового
отделения
}

--- поля параметра запроса на физическое лицо
postOfficeIdentifier TAGGED ::= {
 OID {sorm-post-office-identifier}
 DATA PostOfficeIdentifier
}

PostOfficeIdentifier ::= SEQUENCE {
 index-post PrintableString (SIZE (1 .. 10)) OPTIONAL, --- индекс отделения
почтовой связи
 full-name UTF8String (SIZE (1 .. 128)) OPTIONAL    --- полное наименование
отделения почтовой связи
}
END

                               PostTypes.asn

PostTypes DEFINITIONS IMPLICIT TAGS ::=
BEGIN

EXPORTS PostType,
    PostInfo;

IMPORTS DateAndTime
 FROM Sorm

 TAGGED,
 sorm-post-type,
 sorm-post-type-mail,
 sorm-post-type-package,
 sorm-post-type-money-order,
 sorm-post-type-secogram,
 sorm-post-type-postal-wrapper,
 sorm-post-type-postcard,
 sorm-post-type-ems,
 sorm-post-type-small-packet,
 sorm-post-type-bag-international

 FROM Classification

 PostOffice
 FROM PostIdentifiers

 MoneyType
 FROM Dictionaries
 ;

PostType ::= SEQUENCE {
 id TAGGED.&id ({ReportedPostVariants}),
 data TAGGED.&Data ({ReportedPostVariants} {@id})
}

ReportedPostVariants TAGGED ::= {
     postMail         --- письмо
     | postPackage      --- посылка
     | postMoneyOrder        --- денежный перевод
    | postSecogram        --- секограмма
    | postalWrapper       --- бандероль
     | postCard            --- почтовая карточка
    | postEMS           --- экспресс-отправление
    | postPacket           --- пакет
    | postBagInternational --- мешок, международное
}

MailingType ::= ENUMERATED {
    simple (0),                  -- простое почтовое отправление
    registered (1),                     -- заказное почтовое
отправление
    international (3),                 -- международное почтовое
отправление
    ordinary (4),                      -- обыкновенное почтовое
отправление
    with-declared-value (5),           -- почтовое отправление с
объявленной ценностью
    with-declared-value-and-cod (6)      -- почтовое отправление
с объявленной ценностью и наложенным платежом
}

--- письмо
postMail TAGGED ::= {
 OLD { sorm-post-type-mail}
 DATA PostMailContent
}

--- письмо
PostMailContent ::= SEQUENCE {
  type-mail        MailingType,                 --- тип письма
  pay-on-delivery [2] MoneyType OPTIONAL,        --- наложенный
платеж
  first-class [3]     BOOLEAN OPTIONAL            --- почтовое
отправление первым классом
}

-- посылка
postPackage TAGGED ::= {
 OID {sorm-post-type-package}
 DATA PostPackageContent
}

--- посылка
PostPackageContent ::= SEQUENCE {
  type-package   MailingType,              --- тип посылки
  pay-on-delivery [2] MoneyType OPTIONAL       --- наложенный платеж
}

--- денежный перевод
postMoneyOrder TAGGED ::= {
 OID {sorm-post-type-money-order}
 DATA PostMoneyOrderContent
}

--- денежный перевод
PostMoneyOrderContent ::= SEQUENCE {
  amount Money Type,                            --- величина почтового
перевода
  inn [1]    NumericString (SIZE (10 .. 12)) OPTIONAL,       --- ИНН
  correspondent-account [2] NumericString (SIZE (20)) OPTIONAL, --- кор.
счет
  current-account [3] PrintableString (SIZE (20 .. 25)) OPTIONAL, --- рас.
счет
  name-bank [4]   UTF8String (SIZE (1 .. 256)) OPTIONAL,            ---
наименование банка
  bic [5] NumericString (SIZE (9)) OPTIONAL,                    --- БИК
  message [6]    UTF8String (SIZE (1 .. 70)) OPTIONAL         -- Сообщение
}

--- секограмма
postSecogram TAGGED ::= {
 OID {sorm-post-type-secogram}
 DATA PostSecogramContent
}

--- секограмма
PostSecogramContent ::= MailingType

--- бандероль
postalWrapper TAGGED ::= {
 OID {sorm-post-type-postal-wrapper}
 DATA PostalWrapperContent
}

--- бандероль
PostalWrapperContent ::= SEQUENCE {
  type-wrapper   MailingType,                    --- тип бандероли
  pay-on-delivery [2] MoneyType OPTIONAL,     --- наложенный платеж
  first-class [3]   BOOLEAN OPTIONAL         --- почтовое отправление
первым классом
}

--- почтовая карточка
postCard TAGGED ::= {
 OID {sorm-post-type-postcard}
 DATA PostcardContent
}

--- почтовая карточка
PostcardContent ::= MailingType

--- экспресс-отправление
postEMS TAGGED ::= {
 OID {sorm-post-type-ems}
DATA PostEMSContent
}

--- экспресс-отправление
PostEMSContent ::= SEQUENCE {
  type-ems   MailingType,                     --- тип экспресс-отправления
  pay-on-delivery [2] Money Type OPTIONAL            --- наложенный платеж
}

--- пакет
postPacket TAGGED ::= {
 OID {sorm-post-type-small-packet}
 DATA PostPacketContent
}

--- пакет
PostPacketContent ::= MailingType

--- мешок, международное
postBagInternational TAGGED ::= {
 OID {sorm-post-type-bag-international}
 DATA PostBagContent
}

--- мешок, международное
PostBagContent ::= MailingType

--- характеристики отправления
PostInfo ::= SEQUENCE {
  post-weight [0]   Weight OPTIONAL,                   --- вес почтового
отправления
  post-cost [1]    MoneyType OPTIONAL,                    --- объявленная
стоимость отправления
  post-description [2] UTF8String (SIZE (1 .. 1024)) OPTIONAL ---
заявленное описание содержимого отправления
}

-- вес почтового отправления
Weight ::= SEQUENCE {
  weight [0]   INTEGER OPTIONAL,                               --- грамм
  weight-text [1] UTF8String (SIZE (1 .. 16)) OPTIONAL --- текстовое
описание веса
}
END

                                Reports.asn

Reports DEFINITIONS IMPLICIT TAGS ::=
BEGIN

EXPORTS reportMessage,
        Acknowledgement;

IMPORTS TAGGED,
    sorm-message-report
    FROM Classification

    Message, MessageID, DateAndTime
    FROM Sorm

    TaskID
    FROM Tasks

    DictionaryReport
    FROM Dictionaries

    PostingReport
    FROM ReportsConnections

    PresenseReport
    FROM ReportsPresense

    NonFormalizedReport
    FROM ReportsNonFormalized

    AbonentsReport
    FROM ReportsAbonents;

reportMessage TAGGED ::= {
 OID {sorm-message-report}
 DATA CHOICE {
 report [0]          Report,                    --- тип сообщения "отчет"
 аск [1]             Acknowledgement            --- тип сообщения
"подтверждение"
 }
}

-- БЛОК данных сообщения типа "отчет"
Report ::= SEQUENCE {
 request-id MessageID,                              --- идентификатор
запроса, запросивший отчет
 task-id TaskID,                                  --- идентификатор задачи,
сгенерировавшей данный отчет
 total-blocks-number INTEGER (1 .. 1000000000000),           --- общее
количество блоков в отчете
 block-number INTEGER (1 .. 1000000000000),                 ---
порядковый номер текущего блока
 report-block ReportDataBlock                           --- блок данных
отчета
}

-- Подтверждение приема блока, передается с номером сообщения
соответствующему номеру сообщения блока отчета
Acknowledgement ::= SEQUENCE {
 successful BOOLEAN,                                         --- признак
успешного приема блока
 broken-record INTEGER (10 .. 100000) OPTIONAL,              --- номер
записи в отчете, обработанной на ПУ с ошибкой
 error-description UTF8String (SIZE (1 ..1024)) OPTIONAL           ---
описание ошибки приема блока в произвольной форме
}

ReportDataBlock ::= CHOICE {
 dictionary [0]   DictionaryReport,                        --- отчеты задач
пополнения справочников (нормативно-справочная информация)
 abonents [1]     AbonentsReport,                          --- отчеты задач
поисков по принадлежности абонентов
 connections [2]      PostingReport,               --- отчеты задач поисков
по оказанным услугам почтовой связи
 presense [3]   PresenseReport,                         --- отчеты задач по
запросу наличия в ТС ОРМ информации
 nonFormalized [4]   NonFormalizedReport                --- отчеты задач по
обработке неформализованных данных
}
END

                            ReportsAbonents.asn

ReportsAbonents DEFINITIONS IMPLICIT TAGS ::=
BEGIN
EXPORTS AbonentsReport;
IMPORTS TAGGED,
    sorm-post-abonent-report
   FROM Classification

    PostContractAbonent
    FROM PostAbonents;

AbonentsReport ::= SEQUENCE {
 id   TAGGED.&id ({AbonentsReportVariants}),
 data TAGGED.&Data({AbonentsReportVariants} {@id})
}

AbonentsReportVariants TAGGED ::= {
 reportAbonent                                 --- информация об абоненте
}

reportAbonent TAGGED ::= {
 OID {sorm-post-abonent-report}
 DATA SEQUENCE OF PostContractAbonent
}
END

                          ReportsConnections.asn

ReportsConnections DEFINITIONS IMPLICIT TAGS ::=
BEGIN
EXPORTS PostingReport,
    PostRecord;
IMPORTS DateAndTime
  FROM Sorm
    TelcoID
  FROM Dictionaries
    TAGGED,
    sorm-report-post-connection
  FROM Classification
    PostOffice
  FROM Postldentifiers
    PostType,
    PostInfo
  FROM PostTypes
    ReportedPostMailingAbonent
  FROM PostAbonents
    Reported Address
  FROM Addresses
    ;

PostingReport ::= SEQUENCE OF PostRecord

PostRecord ::= SEQUENCE {
 id TAGGED.&id ({ReportedPostVariants}),
 data TAGGED.&Data ({ReportedPostVariants}{@id})
}

ReportedPostVariants TAGGED ::= { postRecord }

-- Детализированные записи об оказанных услугах почтовой связи
postRecord TAGGED ::= {
 OLD { sorm-report-post-connection}
 DATA PostRecordContent
}

PostRecordContent ::= SEQUENCE {
  telco-id   TelcoID,                 --- идентификатор оператора связи или
филиала
  post-id   UTF8String (SIZE (1 .. 32)),     --- идентификатор почтового
отправления
  post-registration DateAndTime,             --- дата регистрации почтового
отправления
  sender-region-id   UTF8String (1 .. 32),        --- идентификатор региона
отправителя
  receiver-region-id   UTF8String (1 .. 32),       -- идентификатор региона
получателя
  operation-type ENUMERATED {             --- атрибут операции по обработке
отправления
  international-import (0),        --- импорт в пункт международного обмена
  customs-delivery (1),                  --- передано таможне
  international-office-receive (2),      --- прибыло в место международного
обмена
  international-office-send (3),   --- покинуло место международного обмена
  post-office-receive (4),                 ---прибыло в сортировочный центр
  post-office-send (5),                    --- покинуло сортировочный центр
  post-office-processing (6)         --- обработано на сортировочном центре
  },
  operation-description UTF8String (SIZE (1 .. 256)), --- описание операции
  sender-info       ReportedPostMailingAbonent,           --- информация об
отправителе
  reciever-info ReportedPostMailingAbonent,               --- информация об
адресате почтового отправления
  receiver-post-office PostOffice,                      --- информация об
узле назначения почтовой связи (получателя)
  post-office-type ENUMERATED {           --- тип операции на узле почтовой
связи
    receive (0),         --- приема почтового отправления
    process (1),         --- обработки почтового отправления
    delivery (2),        --- выдачи почтового отправления
    delivery-failed (3)  --- неудачная попытка вручения
  },
  post-office PostOffice,            --- информация об узле почтовой связи
  delivery-address [0]   ReportedAddress,   --- адрес доставки отправления
  time-of-send [1] DateAndTime OPTIONAL,      --- дата и время отправления
  time-of-receive [2]   DateAndTime OPTIONAL,   --- дата и время получения
  post-type [3]   PostType OPTIONAL, --- информация о почтовом отправлении
  post-info [4] PostInfo    OPTIONAL,       --- характеристики отправления
  total-parts [5] INTEGER (1 .. 1000) OPTIONAL,       --- общее количество
составных частей отправления
  part-number [6] UTF8String (1 .. 128) OPTIONAL,        --- идентификатор
составной части отправления
  third-part-payment [7] ReportedPostMailingAbonent OPTIONAL ---
информация об оплачивающей третьей стороне
}
END

                         ReportsNonFormalized.asn

ReportsNonFormalized DEFINITIONS IMPLICIT TAGS ::=
BEGIN

EXPORTS NonFormalizedReport;

IMPORTS

    EntityId,
    NonFormalizedEntityAttributeData
    FROM TasksNonFormalized

    StandardInterval
    FROM ReportsPresense;

--- отчет задачи по обработке неформализованных данных
NonFormalizedReport ::= CHOICE {
 nonformalized-report [0]   NonFormalizedRecords,           --- отчет по
задаче обработки неформализованных данных
 nonformalized-presense [1] NonFormalizedPresenseInfo              ---
отчет по наличию неформализованных данных заданного вида
}

NonFormalizedRecords ::= SEQUENCE OF NonFormalizedRecord

NonFormalizedPresenseInfo ::= SEQUENCE OF StandardInterval         ---
- диапазоны времени, за которые есть неформализованные данные

--- запись неформализованных данных
NonFormalizedRecord ::= SEQUENCE OF NonFormalizedEntityAttributeData
END

                            ReportsPresense.asn

ReportsPresense DEFINITIONS IMPLICIT TAGS ::=
BEGIN

EXPORTS PresenseReport,
    Standardlnterval;

IMPORTS FindRange,
    DateAndTime
  FROM Sorm

    TelcoID
  FROM Dictionaries

    TAGGED,
    sorm-report-presense-abonents,
    sorm-report-presense-connections,
    sorm-report-presense-dictionaries
    FROM Classification;

--- отчет по запросу наличия информации
PresenseReport ::= SEQUENCE {
 id TAGGED.&id ({ReportedPresensesVariants}),
 data TAGGED.&Data ({ReportedPresenses Variants} {@id})
}

ReportedPresenses Variants TAGGED ::= {
  abonentsPresence
 | connectionsPresence
 | dictionariesPresence
}.

--- отчет по наличию информации по абонентам и их идентификаторам.
--- Для каждого стандарта может быть указано более одного, либо ни
--- одного интервала (фактические периоды наличия информации);
abonentsPresence TAGGED ::= {
 OID { sorm-report-presense-abonents }
 DATA SEQUENCE OF StandardInterval
}

--- отчет по наличию информации по оказанным услугам почтовой связи
--- может быть указано более одного, либо ни одного, интервала
(фактические периоды наличия информации);
connectionsPresence TAGGED ::= {
 OID {sorm-report-presense-connections}
 DATA SEQUENCE OF ConnectionsPresenseRecord
}

ConnectionsPresenseRecord ::= SEQUENCE OF StandardInterval

--- отчет о наличии информации справочников в ТС ОРМ
--- если какой-либо из справочников не публикуется ТС ОРМ, запись
о нем отсутствует
dictionariesPresence TAGGED ::= {
 OID { sorm-report-presense-dictionaries}
 DATA SEQUENCE OF DictionaryInfo
}

--- запись отчета о наличии информации справочников
Dictionarylnfo ::= SEQUENCE {
 telco-id     TelcoID,                    --- идентификатор оператора связи
или филиала

 dict ObjectDescriptor,                        --- тип справочника, по
которому есть информация
                                          --- (идентификатор запроса
справочника) (Requested...)
 count   INTEGER (1 .. 4294967295),                --- количество записей в
справочнике
 change-dates FindRange                        --- минимальное и
максимальное дата/время изменения записей в справочнике
}

-- ObjectDescriptor принимает значение одно из:
-- sorm-report-dictionary-telcos
-- sorm-report-dictionary-money-types
-- sorm-report-dictionary-post-offices
-- sorm-report-dictionary-doc-types
-- интервал времени, на котором имеются данные по абонентам, соединениям
Standardlnterval ::= SEQUENCE {
 telco-id TelcoID,                              --- идентификатор оператора
связи или филиала
 range FindRange                                --- интервал времени, на
который имеются данные в ИС
}
END

                           RequestedAbonents.asn

RequestedAbonents DEFINITIONS IMPLICIT TAGS ::=
BEGIN

EXPORTS RequestedAbonent;

IMPORTS TAGGED,
    sorm-request-abonent,
    sorm-requested-abonent-organization,
    sorm-requested-abonent-person
    FROM Classification

    Requested Address
    FROM Addresses

    PersonN amelnfo,
   PassportlnfoReport
    FROM PostAbonents
    ;
RequestedAbonent ::= SEQUENCE {
 id TAGGED.&id ({RequestedAbonentVariants}),
 data TAGGED.&Data ({RequestedAbonentVariants}{@id})
}
- варианты запрашиваемых идентификаторов
RequestedAbonentVariants TAGGED ::= {
 requestedPostContractData |
 abonentContractPerson |
 requestedAbonentContractOrganization
}
requestedPostContractData TAGGED ::= {
 OID { sorm-request-contract}
 DATA RequestedPostContract
}
RequestedPostContract ::= CHOICE {
 contract [0] UTF8String (SIZE (1 .. 64)),     --- номер договора
 bank [1]    UTF8String (SIZE(1 .. 256)),      --- банк абонента
(используемый при расчетах с оператором связи)
 bank-account [2] UTF8String (SIZE(1 .. 512)),  --- счет абонента в
банке (используемый при расчетах с оператором связи)
 corr-account [3] UTF8String (SIZE(1 .. 512)),        --- корреспондентский
счет
 kpp [4]   UTF8String (SIZE(9 .. 64)),             --- КПП
 bik [5]  UTF8String (SIZE(9 .. 64)),              --- БИК

 contacts [6] RequestedContactlnfo,                --- контактное лицо
 addresses [7] RequestedPostContractAddress          --- адрес по договору
}

RequestedPostContractAddress ::= CHOICE {
 address [0] RequestedAddress,                  --- адрес, указанный в
контракте
 index-post [1] PrintableString (SIZE (1 .. 10)) --- почтовый индекс адреса
}

- контактная информация по договору
RequestedContactlnfo ::= CHOICE {
  contact [0]   PersonNameInfo,        --- ФИО отправителя/контактное лицо
 phone [1]   UTF8String (SIZE (1 .. 32)),  --- контактный телефон
 email [2]    UTF8String (SIZE (1 .. 128))   --- е-мейл адрес
}

- Пользователь услуг почтовой связи - физическое лицо
abonentContractPerson TAGGED ::= {
 OID { sorm-requested-abonent-person}
 DATA RequestedAbonentContractPerson
}
RequestedAbonentContractPerson ::= CHOICE {
 name-info [0] PersonNameInfo,                           --- ФИО
 birth-date [1] GeneraIizedTime,                          --- дата рождения
 passport-info [2] PassportInfoReport,               --- паспортные данные
 phone-fax [3] UTF8String (SIZE (1 .. 128))               --- контактные
телефоны, факс
}

requestedAbonentContractOrganization TAGGED ::= {
 OID { sorm-requested-abonent-organization }
 DATA RequestedAbonentContractOrganization
}

RequestedAbonentContractOrganization ::= CHOICE {
 full-name [0]   UTF8String (SIZE (1 .. 128)),     --- полное наименование
 inn [1]      NumericString (SIZE (10 .. 12)),           --- ИНН
 ogrn [2]    UTF8String (SIZE(1 .. 32)),           --- ОГРН
 okpo [3] UTF8String (SIZE(1.. 32)),               --- ОКПО
 index-post [4] PrintableString (SIZE (1 .. 10))       --- почтовый индекс
}
END

                         RequestedConnections.asn

RequestedConnections DEFINITIONS IMPLICIT TAGS ::=
BEGIN

EXPORTS RequestedConnection;

IMPORTS TAGGED,
    sorm-request-post-connection
    FROM Classification

DateAndTime

    FROM Sorm
PostOffice
    FROM PostIdentifiers
      PostType,
     PostInfo
    FROM PostTypes
      RequestedPostMailingAbonent
    FROM PostAbonents
      RequestedAddress
    FROM Addresses
      ;

RequestedConnection ::= SEQUENCE {
 id TAGGED.&id ({RequestedConnectionVariants}),
 data TAGGED.&Data ({RequestedConnectionVariants}{@id})
}

--- варианты запрашиваемых параметров связей
RequestedConnectionVariants TAGGED ::= {
 requestedPostConnection    --- параметры записи о почтовом отправлении
}

requestedPostConnection TAGGED ::= {
 OID { sorm-request-post-connection }
 DATA CHOICE {
    post-id [0]    UTF8String (SIZE (1 .. 32)), --- идентификатор почтового
отправления
    operation-type [1] ENUMERATED {             --- атрибут операции по
обработке отправления
          international-import (0),       --- импорт в пункт международного
обмена
          customs-delivery (1),          --- передано таможне
          international-office-receive (2),  --- прибыло в место
международного обмена
          international-office-send (3),  --- покинуло место международного
обмена
          post-office-receive (4),       --- прибыло в сортировочный центр
          post-office-send (5)          --- покинуло сортировочный центр
    },

  operation-description UTF8String (SIZE (1 .. 256)), --- описание операции

  sender-info [3]     RequestedPostMailingAbonent,        --- информация об
отправителе

  receiver-info [4]   RequestedPostMailingAbonent,        --- информация об
адресате почтового отправления

  receiver-post-office [5] PostOffice, --- информация об узле почтовой связи

  post-office-type [6] ENUMERATED {           --- тип операции на узле
почтовой связи
     receive (0),       --- приема почтового отправления
     process (1),       --- обработки почтового отправления
     delivery (2),      --- выдачи почтового отправления
     delivery-failed (3)  --- неудачная попытка вручения
  },
  post-office [7]        PostOffice,  --- информация об узле почтовой связи

  delivery-address [8]  RequestedAddress, --- адрес доставки отправления
  post-type [9]      PostType,     --- информация о почтовом отправлении
  post-info [10]     PostInfo     --- характеристики отправления
}
}
END

                                Sessions.asn

Sessions DEFINITIONS IMPLICIT TAGS ::=
BEGIN

EXPORTS sessionMessage;

IMPORTS TAGGED
    ,sorm-message-session
    FROM Classification;

sessionMessage TAGGED ::= {
 OID {sorm-message-session}
 DATA CHOICE {
  connect [0]       ConnectRequest,                  --- запрос на открытие
сессии
  connect-response [1]  ConnectResponse,             --- ответ на запрос
открытия сессии

  adjustment [2]       AdjustmentRequest,            --- согласование
поддерживаемых типов со стороны ПУ
  adjustment-response [3]    AdjustmentResponse,     --- ответ на запрос
согласования данных
  disconnect [4]       DisconnectRequest,            --- запрос на закрытие
сессии
  disconnect-response [5]   DisconnectResponse          --- ответ на запрос
закрытия сессии }
  }
}

 --- запрос создания сессии
ConnectRequest ::= SEQUENCE {
  session-timeout     INTEGER (60 .. 2592000),       --- максимальное время
неактивности
  max-data-length      INTEGER (10 .. 100000),       --- максимальная длина
блока отчета (в строках)
  data-packet-window-size   INTEGER (4 .. 256),          --- окно канала
передачи данных
                                                 --- максимальное число
блоков данных, которое может быть
                                                 --- отправлено без
подтверждения приема
  data-load-timeout     INTEGER (1 .. 60),             --- таймаут начала
передачи блоков отчетов
  request-response-timeout   INTEGER (1 .. 60),          --- таймаут ответа
на запрос
  data-packet-response-timeout INTEGER (1 .. 60)         --- таймаут
подтверждения приема блока данных отчета
}

-- ответ на запрос создания сессии
ConnectResponse ::= SEQUENCE {
  confirmed-data-packet-window-size INTEGER (4 .. 256),        ---
подтвержденное окно передачи данных
                                                 --- то окно, которое может
обеспечить ТС ОРМ
                                                 --- должно быть меньше или
равно окну, переданному в ConnectRequest
  confirmed-session-timeout     INTEGER (60 .. 2592000),  ---
подтвержденное максимальное время неактивности
                                                 --- должно быть больше или
равно значению, переданному в ConnectRequest
  confirmed-data-load-timeout   INTEGER (1 .. 60),        ---
подтвержденный таймаут начала передачи блоков отчетов
                                                 --- должен быть больше или
равен значению, переданному в ConnectRequest
  confirmed-request-response-timeout INTEGER (1 .. 60),   ---
подтвержденный таймаут ответа на запрос
                                                 --- должен быть больше или
равен значению, переданному в ConnectRequest
  supports SEQUENCE OF ObjectDescriptor                     --- весь список
поддерживаемых ТС ОРМ типов запросов, типов отчетов
}

--- согласование поддерживаемых типов со стороны ПУ
AdjustmentRequest ::= SEQUENCE {
  supports SEQUENCE OF ObjectDescriptor                          --- список
поддерживаемых ПУ типов запросов, типов отчетов
                                             --- данный список должен
быть меньшим либо равным списку в сообщении ConnectRequest
}

-- ответ на согласование списка поддерживаемых типов
AdjustmentResponse ::= NULL                             --- ответ на запрос
согласования данных

--- запрос завершения сессии
DisconnectRequest ::= NULL

--- ответ на запрос завершения сессии
DisconnectResponse ::= NULL

END

                                  Sorm.asn

Sorm DEFINITIONS IMPLICIT TAGS ::=
BEGIN

EXPORTS DateAndTime,
    FindRange,
    MessageID,
    Message;

IMPORTS TAGGED FROM Classification
    sessionMessage FROM Sessions
    trapMessage FROM Traps
    taskMessage FROM Tasks
    reportMessage FROM Reports
    managementMessage FROM Management
   unformattedMessage FROM Unformatted;

Version ::= PrintabieString
vers Version ::= "2.0.0.0"                  --- текущая версия протокола

-- Оболочка сообщения СОРМ --
Message ::= SEQUENCE {
  version    Version DEFAULT vers,                --- версия протокола
  message-id   MessageED,                   --- номер запроса
  message-time  DateAndTime,                      --- время и дата запроса
  operator-name PrintableString (SIZE (6.. 128)) OPTIONAL, --- наименование
оператора связи

  id    TAGGED.&id ({SormPDUs}),                  --- идентификатор блока
данных
  data TAGGED.&Data({SormPDUs}{@id})                    --- данные блока
данных
}

-- Блок данных сообщения
SormPDUs TAGGED ::= {
   sessionMessage                            --- сообщения организации
сессии
   trapMessage                       --- сообщения сигналов
   taskMessage                       --- сообщения работы с задачами
   reportMessage                            --- сообщения работы с
отчетами
   managementMessage                        --- сообщения канала
передачи мониторинга (КПМ)
   unformattedMessage                       --- сообщения канала
передачи неформатированных данных (КПНФ)
}

--- Общие данные

--- Номер сообщения
MessageID ::= INTEGER (0 .. 4294967295)

-- Дата и время
DateAndTime ::= UTCTime

-- Диапазон поиска
FindRange ::= SEQUENCE {
  begin-find [0] DateAndTime OPTIONAL,             --- время и дата начала
поиска информации
  end-find [1] DateAndTime OPTIONAL                --- время и дата
окончания поиска информации
}
END

                                 Tasks.asn

Tasks DEFINITION SIMPLICIT TAGS ::=
BEGIN

EXPORTS taskMessage,
    TaskID,
   ObjectUNI,
   LogicalOperation,
    CreateTaskResponse;

IMPORTS TAGGED,
    sorm-message-task
  FROM Classification
    FindRange,
    MessageID
  FROM Sorm
    TelcoList,
    DictionaryTask
  FROM Dictionaries
    AbonentsTask
  FROM TasksAbonents
    ConnectionsTask
  FROM TasksConnections
    UNIControlTaskRequest,
    UNIControITaskResponse
  FROM TasksUNI
    PresenseTask
  FROM TasksPresense
    NonFormalizedTaskRequest,
    NonFormalizedTaskResponse
  FROM
    TasksNonFormalized;

taskMessage TAGGED ::= {
  OID {sorm-message-task}
  DATA CHOICE {
  data-ready-request [0]      DataReadyRequest,             --- запрос
готовности данных
  data-ready-response [1]     DataReadyResponse,            --- ответ на
запрос готовности данных
  data-load-request [2]       DataLoadRequest,              --- запрос
загрузки данных
  data-load-response [3]      DataLoadResponse,             --- ответ на
запрос загрузки данных
  data-drop-request [4]       DataDropRequest,              --- запрос
удаления данных
  data-drop-response [5]      DataDropResponse,             --- ответ на
запрос удаления данных
  data-interrupt-request [6]  DataInterruptRequest,         --- запрос
прерывания загрузки данных
  data-interrupt-response [7] DataInterruptResponse,        --- ответ на
запрос прерывания загрузки данных
  create-task-request [8]     CreateTaskRequest,        --- запрос на
создание задачи по обработке информации
  create-task-response [9]    CreateTaskResponse,           --- ответ на
запрос создания задачи
  uni-task-request [10]       UNIControlTaskRequest,        --- запрос на
постановку/снятие объекта наблюдения на контроль
  uni-task-response [11]       UNIControlTaskResponse,      --- ответ на
запрос постановки/снятия объекта наблюдения с контроля
  non-formalized-task-request [12] NonFormalizedTaskRequest,            ---
запрос на создание задачи по обработке неформализованных данных
  non-formalized-task-response [13] NonFormalizedTaskResponse           ---
ответ на запрос создания задачи по обработке неформализованных данных
  }
}

--- в этом запросе не параметров
DataReadyRequest ::= NULL

--- запрос загрузки данных конкретной задачи
DataLoadRequest ::= TaskID

--- запрос удаления данных конкретной задачи
DataDropRequest ::= TaskID

--- запрос прерывания загрузки данных
DataInterruptRequest ::= TaskID

--- запрос на создание задачи поиска
CreateTaskRequest ::= SEQUENCE {
  telcos [0]  TelcoList OPTIONAL,                     --- список операторов
связи
  range [1]    FindRange OPTIONAL,                       --- временной
диапазон поиска
  report-limit [2] INTEGER (1 .. 10000000) OPTIONAL,     --- ограничение
на максимальное количество возвращаемых записей
  task [3] CHOICE {
      dictionary [0]       DictionaryTask,               --- задачи
пополнения справочников (нормативно-справочная информация)
  abonents [1]             AbonentsTask,                 --- задачи поисков
по принадлежности абонентов
  connections [2]          ConnectionsTask,              --- задачи поисков
по соединениям абонентов
  presense [3]        PresenseTask                --- задачи предоставления
сведений о наличии данных
  }
}

-- последовательность записей о готовности данных задач
DataReadyResponse ::= SEQUENCE OF DataReadyTaskRecord

DataReadyTaskRecord ::= SEQUENCE {
  task-id TaskID,                                   --- идентификатор
задачи
  result TaskResult                                 --- результат
выполнения задачи
}

TaskResult ::= SEQUENCE {
  result ENUMERATED {
      data-not-ready (0),                           --- данные не готовы,
задача еще выполняется
      data-ready (1),                               --- данные есть, задача
выполнена
      data-not-found (2),                           --- данных нет, задача
выполнена
      error (3)                                 --- в процессе выполнения
задачи произошла ошибка
  },
  report-records-number [0] INTEGER (0 .. 999999999999) OPTIONAL,   --- для
выполненной задачи - количество
                                                --- записей в отчете
  report-limit-exeeded [1] BOOLEAN OPTIONAL,                ---
количество записей превысило лимит, заданный при создании задачи
  error-description   [2] UTF8String (SIZE (1 .. 256)) OPTIONAL --- краткое
описание произошедшей ошибки,
                                                      --- если обнаружена
}

DataLoadResponse ::= SEQUENCE {
  task-id      TaskID,                                    --- идентификатор
задачи, сгенерировавшей данный отчет
  data-exists        BOOLEAN,                                   --- признак
существования результатов исполнения задачи
                                                  --- (есть данные или нет)
  data-blocks-number INTEGER (0 .. 999999999999) OPTIONAL,              ---
количество блоков в отчете
  error-description  UTF8String (SIZE (1 .. 256)) OPTIONAL              ---
краткое описание ошибки, если обнаружена
}

DataDropResponse ::= SEQUENCE {
  task-id      TaskID,                                --- идентификатор
задачи, данные которой будут удалены
  successful         BOOLEAN,                              --- признак
успешного выполнения запроса
  error-description  UTF8String (SIZE (1 .. 256)) OPTIONAL              ---
краткое описание ошибки, если обнаружена
}

DataInterruptResponse ::= SEQUENCE {
  request-id     MessageID,                           --- идентификатор
прерванного запроса загрузки данных
  successful     BOOLEAN,                             --- признак успешного
выполнения запроса
  data-blocks-available INTEGER (0 .. 999999999999) OPTIONAL,   ---
количество оставшихся непереданными блоков
  error-description    UTF8String (SIZE (1 .. 256)) OPTIONAL    --- краткое
описание ошибки, если обнаружена
}

CreateTaskResponse ::= SEQUENCE {
  task-id    TaskID OPTIONAL,                         --- идентификатор
задачи
  successful  BOOLEAN,                                --- признак успешного
выполнения запроса
  error-description UTF8String (SIZE (1 .. 256)) OPTIONAL       --- краткое
описание ошибки, если обнаружена
}

-- идентификатор задачи
TaskID ::= INTEGER (0 .. 4294967295)

-- идентификатор объекта наблюдения
ObjectUNI ::= INTEGER (0 .. 4294967295)

LogicalOperation ::= ENUMERATED {
  operation-open-bracket (0),  -- открывающая скобка - "("
  operation-close-bracket (1), -- закрывающая скобка - ")"
  operation-or (2),    -- логическое "или"
  operation-and (3), -- логическое "и"
  operation-not (4)          -- логическое "не"
}
END

                             TasksAbonents.asn

TasksAbonents DEFINITIONS IMPLICIT TAGS ::=
BEGIN

EXPORTS AbonentsTask;

IMPORTS
  LogicalOperation FROM Tasks
  RequestedAbonent FROM RequestedAbonents;

AbonentsTask ::= RequestedIdentifiers      --- задача на поиск информации о
принадлежности абонентов оператора почтовой связи

RequestedIdentifiers ::= SEQUENCE OF RequestedIdentifierParameters       --
последовательность из идентификаторов и логических операций

RequestedIdentifierParameters ::= CHOICE {
 separator [0] LogicalOperation,               --- логическая операция или
скобка
 find-mask [1] RequestedAbonent                --- параметр - идентификатор
}
END

                            TasksConnections.asn

TasksConnections DEFINITIONS IMPLICIT TAGS ::=
BEGIN

EXPORTS ConnectionsTask,
  RequestedConnectionldentifiers;

IMPORTS
  LogicalOperation FROM Tasks
  RequestedConnection FROM RequestedConnections
  ;

ConnectionsTask ::= RequestedConnectionIdentifiers --- задача на поиск
телефонных соединений между абонентами

RequestedConnectionIdentifiers ::= SEQUENCE OF
RequestedConnectionParameter

RequestedConnectionParameter ::= CHOICE {
 separator [0] LogicalOperation,                    --- логический оператор
связки
 find-mask [1] RequestedConnection                         --- параметр
запроса
}
END

                           TasksNonFormalized.asn

TasksNonFormalized DEFINITIONS IMPLICIT TAGS ::=
BEGIN

EXPORTS
    EntityId,
    NonFormalizedTaskRequest,
    NonFormalizedTaskResponse,
    NonFormalizedEntityAttributeData;

IMPORTS TelcoList
    FROM Dictionaries
    FindRange,
    MessageID,
    DateAndTime
    FROM Sorm
    LogicalOperation,
    CreateTaskResponse
    FROM Tasks
  ;

-- TaskID,
    -- LogicalOperation;

NonFormalizedTaskRequest ::= CHOICE {
  get-entities [0] GetEntities,               --- тип сообщения "запрос
получения списка типов сущностей"
  get-attributes [1] GetEntityAtttibutes,               --- тип сообщения
"запрос получения списка атрибутов сущности"
  validate-task [2]  ValidateNonFormalizedTask,         --- тип сообщения
"задача поиска неформализованных данных"
  validate-presense [3] NonFormalizedPresenseTask       --- тип сообщения
"задача предоставления сведений о наличии неформализованных данных"
}

NonFormalizedTaskResponse ::= CHOICE {
  entities [0] GetEntitiesResponse,           --- ответ на запрос получения
списка типов сущностей
  entity-attributes [1] GetEntityAtttibutesResponse,  --- ответ на запрос
получения списка атрибутов сущности
  validate-task  [2] ValidateNonFormalizedTaskResponse, --- ответ на запрос
задачи поиска неформализованных данных
  validate-presense [3] NonFormalizedPresenseTaskResponse --- ответ на запрос
задач предоставления сведений о наличии неформализованных данных
}

--- тип сообщения "запрос получения списка типов сущностей"
GetEntities ::= NULL

--- тип сообщения "запрос получения списка атрибутов сущности"
GetEntityAtttibutes ::= EntityId

--- тип сообщения "задача поиск неформализованных данных"
ValidateNonFormalizedTask ::= SEQUENCE {
 entity-id EntityId,                     --- сущность для поиска по
неформализованным данным
  parameters NonFormalizedParameters,                --- критерии поиска по
неформализованным данным
  range     FindRange OPTIONAL,                      --- временной диапазон
поиска
  report-limit INTEGER (1 .. 10000000) OPTIONAL       --- ограничение на
максимальное количество возвращаемых записей
}

--- тип сообщения "задача предоставления сведений о наличии
неформализованных данных"
NonFormalizedPresenseTask ::= EntityId

NonFormalizedParameters ::= SEQUENCE OF NonFormalizedParameter

NonFormalizedParameter ::= CHOICE {
 separator [0] LogicalOperation,                 --- логическая операция
 find-mask [1] NonFormalizedEntityCondition           --- условие
}

NonFormalizedEntityCondition ::= SEQUENCE {
 attribute   NonFormalizedEntityAttribute,          --- атрибут сущности
 operation   MathOperation,                      --- операция
 attribute-value NonFormalizedEntityAttributeData   --- значение атрибута
}

NonFormalizedEntity Attribute ::= SEQUENCE {
 attribute-name UTF8String (SIZE (1 .. 256)),       --- текстовое
наименование атрибута сущности
 attribute-type AttributeType                       --- тип данных атрибута
}

NonFormalizedEntity AttributeData ::= CHOICE {
 datetime [0] DateAndTime,                          --- дата и время с
точностью до секунд
 integer [1] INTEGER (0 .. 4294967296),             --- целочисленный
 string [2] UTF8String (SIZE (0 .. 1024)),          --- строковый
 boolean [3] BOOLEAN,                               --- булевый
 float [4] REAL,                                --- с плавающей запятой
 empty [5] NULL                                 --- пустое значение (null)
}

--- математические операции сравнения
MathOperation ::= ENUMERATED {
 equal (0),    --- равно
 less (1),     --- меньше
 greater (2),  --- больше
 not-equal (3), --- не равно
 less-or-equal (4), --- меньше или равно
 greater-or-equal (5) - больше или равно
}

GetEntitiesResponse ::= SEQUENCE OF NonFormalizedEntity

NonFormalizedEntity ::= SEQUECE {
 entity-id EntityId,                              --- уникальный
идентификатор сущности
 entity-name UTF8String (SIZE (1 .. 256))                 --- текстовое
наименование сущности
}

GetEntityAtttibutesResponse ::= SEQUENCE {
 entity-id EntityIld,                              --- уникальный
идентификатор сущности
 entity-attributes SEQUENCE OF NonFormalizedEntityAttribute    --- атрибуты
сущности
}

ValidateNonFormalizedTaskResponse ::= CreateTaskResponse
NonFormalizedPresenseTaskResponse ::= CreateTaskResponse
--- типы данных атрибутов
AttributeType ::= ENUMERATED {
 date-time (0), --- дата и время с точностью до секунд
 integer (1),  --- целочисленный
 string (2),  --- строковый
 boolean (3),  --- булевый
 float (4)    --- с плавающей запятой
}

--- Идентификатор сущности
EntityId INTEGER (0 .. 4294967296)

END

                             TasksPresense.asn

TasksPresense DEFINITIONS IMPLICIT TAGS ::=
BEGIN

EXPORTS PresenseTask;

IMPORTS
    TAGGED,
    sorm-request-presense
    FROM Classification;

PresenseTask ::= SEQUENCE {
 id TAGGED.&id ({PresenseListVariants}),
 data TAGGED.&Data ({PresenseListVariants}{@id})
}

PresenseListVariants TAGGED ::= { presenseInfo }

presenseInfo TAGGED ::= {
 OID {sorm-request-presense}
 DATA ENUMERATED {
  abonents (1),      --- запрос наличия информации по пользователям
услугами почтовой связи
  connections (2),    --- запрос наличия информации по записям об оказанных
услугах почтовой связи -
  dictionaries (3)    --- запрос наличия справочников
 }
}
END

                                TasksUNI.asn

TasksUNI DEFINITIONS IMPLICIT TAGS ::=
BEGIN

EXPORTS
    UNIControlTaskRequest,
    UNIControlTaskResponse;

IMPORTS
    TAGGED
    FROM Classification

    RequestedConnection
    FROM RequestedConnections

    LogicalOperation,
     ObjectUNI
     FROM Tasks

    TelcoList
    FROM Dictionaries
    ;

UNIControlTaskRequest ::= CHOICE {
    create-uni [0] CreateUNIRequest,         --- запрос на создание объекта
наблюдения и постановки его на контроль
    drop-uni [1] DropUNIRequest              --- запрос на снятие объекта
наблюдения с контроля и удаление объекта наблюдения
}

UIControlTaskResponse ::= CHOICE {
    create-uni [0] CreateUNIResponse,
    drop-uni [1] DropUNIResponse
}

CreateUNIRequest ::= SEQUENCE {
  uni-id ObjectUNI,                   --- идентификатор объекта наблюдения,
переданный ПУ
  uni-criteria SEQUENCE OF UNIParameter,           --- критерии отбора для
объекта наблюдения
  telcos     TelcoList OPTIONAL              --- список операторов связи
}

UNIParameter ::= CHOICE {
 separator [0] LogicalOperation,                    --- логический оператор
связки
  find-mask [1] UNIRequestedConnectionIdentifiers         --- параметр
запроса
}

UNIRequestedConnectionIdentifiers ::= SEQUENCE {
 uni-criteria RequestedConnection,                 --- критерий в записи об
отравлении для контроля
 mispelling-distance INTEGER (1 .. 10) OPTIONAL              --- количество
ошибок ввода, заполняется для строковых критериев
}

CreateUNIResponse::= SEQUENCE {
     uni-id       ObjectUNI OPTIONAL,                   --- идентификатор
объекта наблюдения (переданный ПУ), по которому подтверждается команда
    uni-successful   BOOLEAN,                                   --- признак
успешной постановки объекта наблюдения на контроль
    uni-error-description UTF8String (SIZE (1 .. 256)) OPTIONAL --- краткое
описание ошибки, если обнаружена
}
DropUNIRequest ::= ObjectUNI                      --- идентификатор объекта
наблюдения для снятия с контроля

DropUNIResponse ::= SEQUENCE {
    uni-dropped ObjectUNI,
    uni-successful BOOLEAN,                                     --- признак
успешного снятия объекта наблюдения с контроля
    uni-error-description UTF8String (SIZE (1 .. 256)) OPTIONAL --- краткое
описание ошибки, если обнаружена
}
END

                                 Traps.asn

Traps DEFINITIONS IMPLICIT TAGS ::=
BEGIN

EXPORTS trapMessage;

IMPORTS
  TAGGED,
  sorm-message-trap
  FROM Classification
   MessageID
  FROM Sorm
   PostRecord
  FROM ReportsConnections
   ObjectUNI
  FROM Tasks
  ;
trapMessage TAGGED ::= {
   OID { sorm-message-trap }
   DATA CHOICE {
    trap [0] Trap,                               --- тип сообщения "сигнал"
    trap-uni [1] TrapUNI,                              --- тип сообщения
"отобранная информация по объектам наблюдения"
    trap-ack [2] TrapAck                               --- тип сообщения
"подтверждение сигнала"
  }
}

--- Блок данных сообщения типа "сигнал"
Trap ::= SEQUENCE {
 trap-type TrapType,                                  -- тип сообщения
 trap-message UTF8String (SIZE (1 .. 256)) OPTIONAL,            -- описание
сообщения
  reference-message MessageID OPTIONAL                           -- номер
сообщения, к которому относится данный сигнал
                                                 -- (например, номер
сообщения запросившего отчет при прерывании передачи)
}

TrapType ::= ENUMERATED {
 heartbeat (0),                                  -- тестовый пакет
 no-source-data (1),                         -- нет данных/связи с ИС ОПС в
течение периода времени
 restart-software (2),                                -- перезапуск ПО
 unauthorized-access (3),                             -- попытка
несанкционированного доступа
 critical-error (4),                                  -- критическая ошибка
ПО, потеря данных, дальнейшая работа невозможна
 major-error (5),                                  -- серьезная ошибка ПО,
потеря данных, но дальнейшая работа возможна
 minor-error (6)                                   -- незначительная ошибка
ПО, данные не потеряны, дальнейшая работа возможна
}
TrapUNI ::= SEQUENCE OF UNIData
UNIData ::= SEQUENCE {
  object-unis SEQUENCE OF ObjectUNI,            --- идентификаторы объектов
наблюдения, по которым отобраны записи об отправлениях
  post-records PostRecord                  --- отобранные записи о почтовых
отправлениях по объекту наблюдения
}
-- Блок данных сообщения типа "подтверждение сигнала"
-- Номер сообщения TrapAck должен соответствовать номеру сообщения Trap
TrapAck ::= NULL

END

                              Unformatted.asn

Unformatted DEFINITIONS IMPLICIT TAGS ::=

BEGIN

EXPORTS unformattedMessage;
IMPORTS TAGGED,
  sorm-message-unformatted
  FROM Classification
  TelcoList,
  DictionaryReport
  FROM Dictionaries
  Acknowledgement
  FROM Reports
  PostingReport
  FROM ReportsConnections
  DateAndTime,
  MessageID
  FROM Sorm
  AbonentsReport
  FROM ReportsAbonents
;
unformattedMessage TAGGED ::= {
  OID { sorm-message-unformatted }
  DATA CHOICE {
    request [0] RawRequest,
    response [1] RawResponse,
    report [2] RawReport,
    report-ack [3] RawAcknowledgement
  }
}

RawRequest ::= SEQUENCE {
 telcos TelcoList, --- список операторов связи
  raw-task RawRequestTask --- запрос получения неформатированных данных
}

RawRequestTask ::= CHOICE {
  data-start-request [1] DataStartRequest, --- запрос на начало передачи
неформатированных данных
  data-stop-request [2]  DataStopRequest   --- запрос на остановку передачи
неформатированных данных
}

DataStartRequest ::= NULL

DataStopRequest ::= NULL

RawResponse ::= CHOICE {
  data-start-response [1] DataStartResponse,  --- ответ на запрос начала
передачи неформатированных данных
  data-stop-response [2] DataStopResponse     --- ответ на запрос остановки
передачи неформатированных данных
}

DataStartResponse ::= BOOLEAN             --- признак успешности выполнения
команды
DataStopResponse ::= BOOLEAN              --- признак успешности выполнения
команды

RawReport ::= SEQUENCE {
 request-id     MessageID,                    --- идентификатор запроса
 stream-id      UTF8String (SIZE (1 .. 256)),    --- идентификатор потока в
сессии
 total-blocks-number INTEGER (0 .. 999999999999),      --- общее количество
блоков в отчете
 block-number     INTEGER (1 .. 1000000000000),     --- порядковый номер
текущего блока
 report-block    RawDataBlock                 --- блок данных отчета
}

RawDataBlock ::= CHOICE {
 abonents [0] AbonentsReport,            --- записи отчетов об абонентах
 reports [1] PostingReport,      --- записи отчетов о почтовых отправлениях
 dictionaries [2] DictionaryReport --- записи отчетов о справочниках
}

Raw Acknowledgement ::= Acknowledgement
END.