VoiceManager DEFINITIONS AUTOMATIC TAGS ::=
BEGIN

MSISDN ::= SEQUENCE {
    number       [0] UTF8String,
    nai          [1] INTEGER,
    presentation [2] INTEGER OPTIONAL --0-передать номер, 1-скрыть номер
}

RedirReasonInfo ::= SEQUENCE {
    redirecting-reason      [0] INTEGER,
    redirecting-count       [1] INTEGER,
    redirecting-orig-reason [2] INTEGER
}

CallIndicators ::= SEQUENCE {
    diversion-treatment [0] INTEGER OPTIONAL --переадресация: 0-нет индикации, 1-допускается, 2-не допускается
}

-- CMD new_call_out
-- EV  call_in
Call ::= SEQUENCE {
    calling-pn           [0] MSISDN, -- MSISDN-A
    called-pn            [1] MSISDN, -- MSISDN-B
    original-pn          [2] MSISDN OPTIONAL, -- MSISDN-C
    redirecting-pn       [3] MSISDN OPTIONAL, -- MSISDN-D
    location-pn          [4] MSISDN OPTIONAL, -- MSISDN-E
    redir-info           [5] RedirReasonInfo OPTIONAL,
    call-indicators      [6] CallIndicators OPTIONAL,
    group-id             [7] UTF8String OPTIONAL,
    calling-contact      [8] Contact OPTIONAL,     -- From:
    called-contact       [9] Contact OPTIONAL,     -- To:
    history-contacts    [10] ContactList OPTIONAL, -- History-Info:
	username            [11] UTF8String OPTIONAL
}

-- CMD call_in_up
-- EV  call_up
PickUp ::= SEQUENCE {
-- nothing
}

-- VP_RESP new_call_out_resp
Trying ::= SEQUENCE {
-- nothing
}

-- RejectCode основан на ISUP-REL кодах

-- Руководство перевода кодов SIP <-> ISUP
-- http://www.scriru.com/15/SIP-SIPT74838788227.php
-- http://zakonprost.ru/content/base/part/610482

-- При получении из телефонной сети SIP
-- заполняется sip-code и подбирается RejectCode, если ничего не подходит устанавливается undefined

-- При получении из телефонной сети SIP-I/T
-- заполняется sip-code и isup-code затем подбирается RejectCode, если ничего не подходит устанавливается undefined

-- При получении из телефонной сети SS7
-- заполняется isup-code затем подбирается RejectCode, если ни чего не подходит устанавливается undefined

-- При получении кода со стороны услуги недостающие коды подбираются в соответствии с RejectCode и руководством перевода кодов SIP <-> ISUP
-- Если RejectCode == undefined и не заданы другие коды, RejectCode := normal-call-clearing
-- Если коды заданы они не изменяются.

RejectCode ::= ENUMERATED {
    undefined                 (0),
    unallocated-number        (1),
    no-route-to-network       (2),
    no-route-to-destination   (3),
    normal-call-clearing     (16),
    user-busy                (17),
    no-user-responding       (18),
    no-answer-from-user      (19),
    subscriber-absent        (20),
    call-rejected            (21),
    address-incomplete       (28),
    normal-unspecified       (31),
    network-out-of-order     (38),
    temporary-failure        (41),
    service-unavailable      (63),
    not-implemented          (79),
    interworking-unspecified (127)
}
--

KV-Pair ::= SEQUENCE {
	key [0] UTF8String,
	value [1] UTF8String OPTIONAL
}

KV-List ::= SEQUENCE OF KV-Pair

Uri ::= SEQUENCE {
    host        [0] UTF8String,
    port        [1] INTEGER OPTIONAL,
    user        [2] UTF8String OPTIONAL,
    parameters  [3] KV-List OPTIONAL
}

Contact ::= SEQUENCE {
    nickname    [0] UTF8String OPTIONAL,
    uri         [1] Uri,
    parameters  [2] KV-List OPTIONAL
}

ContactList ::= SEQUENCE OF Contact

-- IVR_RESP call_in_resp
HangUp ::= SEQUENCE {
    code                    [0] RejectCode,
    sip-code                [1] INTEGER OPTIONAL,           -- код отбоя SIP
    sip-code-desc           [2] UTF8String OPTIONAL,        -- описание кода отбоя SIP
    isup-code               [3] INTEGER OPTIONAL,           -- код отбоя ISUP
    sip-redirect-contacts   [4] ContactList OPTIONAL        -- список адресов для перенаправления вызова SIP
}

-- EV call_kpv
Ringing ::= SEQUENCE {
    sip-code      [0] INTEGER OPTIONAL,   -- код SIP
    sip-code-desc [1] UTF8String OPTIONAL -- описание кода SIP
}

-- EV dtmf
Dtmf ::= SEQUENCE {
    code     [0] INTEGER,
    duration [1] INTEGER --ms
}


-- CMD play_list
PlayList ::= SEQUENCE {
    list [0] SEQUENCE OF UTF8String
}

PlayListPause ::= SEQUENCE {
-- nothing
}

PlayListResume ::= SEQUENCE {
-- nothing
}

-- CMD play_list_stop
PlayListStop ::= SEQUENCE {
-- nothing
}

-- EV play_file_finish
-- play file OK - status = 0, play file error - status > 0
PlayFileFinished ::= SEQUENCE {
    file    [0] UTF8String,
    status  [1] INTEGER,
    message [2] UTF8String OPTIONAL
}

-- EV NEW
-- play list OK - status = 0, play list error - status > 0
PlayListFinished ::= SEQUENCE {
    status  [1] INTEGER,
    message [2] UTF8String OPTIONAL
}

-- CMD bind_to
-- bind other channel with call_id to the current call
BindVoiceChannel ::= SEQUENCE {
    call-id   [0] UTF8String,
    re-invite [1] INTEGER OPTIONAL
}

-- CMD unbind_to
-- Disconnect From Any Source
UnBindVoiceChannels ::= SEQUENCE {
-- nothing
}

LadspaParam ::= SEQUENCE {
    name    [0] UTF8String,
    val     [1] REAL
}

LadspaEffect ::= SEQUENCE {
    name    [0] UTF8String,
    params  [1] SEQUENCE OF LadspaParam
}

LadspaPlugin ::= SEQUENCE {
    name    [0] UTF8String,
    effects [1] SEQUENCE OF LadspaEffect
}

-- CMD enable effects
-- Enable LADSPA effects in the channel
EnableLadspaEffects ::= SEQUENCE {
    plugins [0] SEQUENCE OF LadspaPlugin
}

-- CMD disable effects
-- Disable LADSPA effects in the channel
DisableLadspaEffects ::= SEQUENCE {
-- nothing
}

WriteDirection ::= ENUMERATED {
    input    (0),
    output   (1),
    both     (2)
}

-- EV
VoiceChannelStatus ::= SEQUENCE {
    direction [0] WriteDirection,
    status    [1] INTEGER
}

-- CMD write_file
WriteFile ::= SEQUENCE {
    file      [0] UTF8String,
    direction [1] WriteDirection,
    vad-report[2] INTEGER OPTIONAL
}

-- VP_RESP write_file_resp
WriteFileFinished ::= SEQUENCE {
    file    [0] UTF8String,
    status  [1] INTEGER,
    message [2] UTF8String OPTIONAL,
    vad-report [3] INTEGER OPTIONAL
}

-- CMD write_file_stop
-- stop all records
WriteFileStop ::= SEQUENCE {
-- nothing
}

-- CMD
WriteFilePause ::= SEQUENCE {
-- nothing
}

-- CMD
WriteFileResume ::= SEQUENCE {
-- nothing
}

Timestamp ::= SEQUENCE {
    sec  [0] INTEGER,
    nsec [1] INTEGER
}

PhoneApi ::= SEQUENCE {
    call-id [0] UTF8String,
    time-st [1] Timestamp OPTIONAL,
    phone-msg CHOICE {
        m-call                    [11] Call,
        m-pick-up                 [12] PickUp,
        m-trying                  [13] Trying,
        m-ringing                 [14] Ringing,
        m-hang-up                 [15] HangUp,

        m-dtmf                   [100] Dtmf,

        m-play-list              [110] PlayList,
        m-play-list-stop         [111] PlayListStop,
        m-play-file-finished     [112] PlayFileFinished,
        m-play-list-finished     [113] PlayListFinished,
        m-play-list-pause        [114] PlayListPause,
        m-play-list-resume       [115] PlayListResume,

        m-bind-voice-channel     [120] BindVoiceChannel,
        m-unbind-voice-channels  [121] UnBindVoiceChannels,
        m-enable-effects         [122] EnableLadspaEffects,
        m-disable-effects        [123] DisableLadspaEffects, --effect only for output voice

        m-write-file             [130] WriteFile,
        m-write-file-stop        [132] WriteFileStop,
        m-write-file-finished    [131] WriteFileFinished,
        m-write-file-pause       [133] WriteFilePause,
        m-write-file-resume      [134] WriteFileResume,

        m-voice-channel-status   [140] VoiceChannelStatus
    }
}

StatRequestReset ::= SEQUENCE {
-- nothing
}

StatRequestGet ::= SEQUENCE {
-- nothing
}

StatRequest ::= CHOICE {
    reset [0] StatRequestReset,
    get   [1] StatRequestGet
}

StatSIPMessage ::= SEQUENCE {
    code        [0] INTEGER,
    text        [1] UTF8String,
    direction   [2] ENUMERATED
                    {
                        incoming (0),
                        outgoing (1)
                    },
    count       [3] INTEGER
}

StatSIPMessages ::= SEQUENCE OF StatSIPMessage

StatSIPMessagesCall ::= SEQUENCE {
    first    [0] StatSIPMessages,
    repeats  [1] StatSIPMessages
}

StatResponsePeriod ::= SEQUENCE {
    average-talk-time       [0] INTEGER, --sec
    talk-count              [1] INTEGER,
    average-session-time    [2] INTEGER, --sec
    session-count           [3] INTEGER,
    new-session-count       [4] INTEGER,
    period-time             [5] INTEGER, --sec
    incoming-call-messages  [10] StatSIPMessagesCall,
    outgoing-call-messages  [11] StatSIPMessagesCall
}

StatResponse ::= SEQUENCE {
    periods             [0] SEQUENCE OF StatResponsePeriod,
    free-ports          [1] INTEGER,
    trying-state        [2] INTEGER,
    dialog-state        [3] INTEGER,
    completion-state    [4] INTEGER
}

Statistics ::= CHOICE {
    request  [0] StatRequest,
    response [1] StatResponse
}

Redirect ::= SEQUENCE {
    hostname [0] UTF8String OPTIONAL,
    svcname  [1] UTF8String OPTIONAL,
    svcconn  [2] INTEGER OPTIONAL
}

DebugFindType ::= CHOICE
{
     number         [0] UTF8String,
     call-id        [1] UTF8String,
     reg-expression [2] UTF8String
}

DebugRequest ::= CHOICE {
    get-sessions       [0] NULL,
    start-log          [1] INTEGER,
    stop-and-find-log  [2] DebugFindType,
    erase-log          [3] NULL
}

Session ::= SEQUENCE {
    call-id [0] UTF8String,
    state   [1] ENUMERATED
                {
                    trying (0),
                    dialog (1),
                    completed (2),
                    was-deleted (3)
                }
}

DebugResponse ::= CHOICE {
    sessions        [0] SEQUENCE OF Session,
    result-find-log [1] SEQUENCE OF OCTET STRING,
    error           [2] NULL
}

Debug ::= CHOICE {
    request  [0] DebugRequest,
    response [1] DebugResponse
}

QoP-Data ::= ENUMERATED {
	auth (0),
	auth-int (1)
}

Authorization-Header ::= SEQUENCE {
	response [0] UTF8String,
	username [1] UTF8String,
	realm    [2] UTF8String,
	nonce    [3] UTF8String,
	uri      [4] UTF8String,
	qop      [5] QoP-Data OPTIONAL,
	nc       [6] UTF8String OPTIONAL,
	cnonce   [7] UTF8String OPTIONAL,
	opaque   [8] UTF8String OPTIONAL,
	algorithm[9] UTF8String OPTIONAL
}

Authentication-Info-Header ::= SEQUENCE {
	nextnonce [0] UTF8String,
	qop       [1] QoP-Data OPTIONAL,
	nc        [2] UTF8String OPTIONAL,
	rspauth   [3] UTF8String OPTIONAL,
	cnonce    [4] UTF8String OPTIONAL
}

Authentication-Header ::= SEQUENCE {
	realm     [0] UTF8String,
	nonce     [1] UTF8String,
	stale     [2] BOOLEAN OPTIONAL,
	qop       [3] QoP-Data OPTIONAL,
	opaque    [4] UTF8String OPTIONAL,
	algorithm [5] UTF8String OPTIONAL
}

Authentication-Result ::= SEQUENCE {
	code [0] INTEGER, -- 0 - allow, 1 - order, 2 - deny
	text [1] UTF8String OPTIONAL
}

UAS-Authentication-Request ::= SEQUENCE {
	authorization [0] Authorization-Header OPTIONAL,
	method        [2] UTF8String
}

UAS-Authentication-Response ::= SEQUENCE {
	authentication      [0] Authentication-Header OPTIONAL,
	authentication-info [1] Authentication-Info-Header OPTIONAL,
	result              [2] Authentication-Result
}

UAC-Authentication-Request ::= SEQUENCE {
	authentication      [0] Authentication-Header,
	authentication-info [1] Authentication-Info-Header OPTIONAL,
	method              [2] UTF8String,
	username            [4] UTF8String,
	password            [5] UTF8String OPTIONAL
}

UAC-Authentication-Response ::= SEQUENCE {
	authorization [0] Authorization-Header
}

AuthApi ::= CHOICE {
	uas-authentication-request  [0] UAS-Authentication-Request,
	uas-authentication-response [1] UAS-Authentication-Response,
	uac-authentication-request  [2] UAC-Authentication-Request,
	uac-authentication-response [3] UAC-Authentication-Response
}

Register-Request ::= SEQUENCE {
	cseq         [0] INTEGER,
    call-id      [1] UTF8String,
	from         [2] Contact,
	to           [3] Contact,
	contacts     [4] ContactList,
	expires      [5] INTEGER OPTIONAL
}

Register-Response ::= SEQUENCE {
	result      [0] INTEGER, -- 0 - success, >0 - error
	contacts    [1] ContactList OPTIONAL,
	expires     [2] INTEGER OPTIONAL,
	min-expires [3] INTEGER OPTIONAL
}

Location-Request ::= SEQUENCE {
	user [0] Contact
}

Location-Response ::= SEQUENCE {
	result       [0] INTEGER, -- 0 - success, >0 - error
	contacts     [1] ContactList OPTIONAL
}

RegLocApi ::= CHOICE {
	register-request  [0] Register-Request,
	register-response [1] Register-Response,
	location-request  [2] Location-Request,
	location-response [3] Location-Response
}


SIP-Service-Response ::= SEQUENCE {
    code        [0] INTEGER,
	code-desc   [1] UTF8String OPTIONAL,
    contacts    [2] ContactList OPTIONAL
}

SIP-Options ::= SEQUENCE {
    calling-contact [0] Contact,     -- From:
    called-contact  [1] Contact      -- To:
}

SIP-Message ::= SEQUENCE {
    calling-contact [0] Contact,     -- From:
    called-contact  [1] Contact,     -- To:
    expires         [3] INTEGER OPTIONAL
}

SIPServiceApi ::= SEQUENCE {
    call-id     [0] UTF8String,
    time-st     [1] Timestamp OPTIONAL,
    trunk-id    [2] UTF8String OPTIONAL,
    sip-msg CHOICE {
        m-response  [10] SIP-Service-Response,
        m-options   [11] SIP-Options,
        m-message   [12] SIP-Message
    }
}

VoiceManagerMsg ::= CHOICE {
    phone       [0] PhoneApi,
    statistics  [1] Statistics,
    redirect    [2] Redirect,
    debug       [3] Debug,
    auth        [4] AuthApi,
    regloc      [5] RegLocApi,
    sipsrv      [6] SIPServiceApi
}

END