From eea7dedabcfcb7f59d344456da7be1e42cdb20e4 Mon Sep 17 00:00:00 2001 From: Dimitri Sokolyuk Date: Mon, 5 Oct 2015 18:32:50 +0200 Subject: Rename to lowercase --- kxtde/kxtda.asn1 | 1928 ++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 1928 insertions(+) create mode 100644 kxtde/kxtda.asn1 (limited to 'kxtde/kxtda.asn1') diff --git a/kxtde/kxtda.asn1 b/kxtde/kxtda.asn1 new file mode 100644 index 0000000..ddc5f13 --- /dev/null +++ b/kxtde/kxtda.asn1 @@ -0,0 +1,1928 @@ +CSTA-event-report-definitions + { iso( 1) identified-organization( 3) icd-ecma( 12) + standard( 0) csta3( 285) event-report-definitions( 21) } +DEFINITIONS ::= +BEGIN + +OPERATION ::= CLASS +{ + &ArgumentType OPTIONAL, + &argumentTypeOptional BOOLEAN OPTIONAL, + &returnResult BOOLEAN DEFAULT TRUE, + &ResultType OPTIONAL, + &resultTypeOptional BOOLEAN OPTIONAL, + &Errors ERROR OPTIONAL, + &Linked OPERATION OPTIONAL, + &synchronous BOOLEAN DEFAULT FALSE, + &alwaysReturns BOOLEAN DEFAULT TRUE, + &InvokePriority Priority OPTIONAL, + &ResultPriority Priority OPTIONAL, + &operationCode Code UNIQUE OPTIONAL +} +WITH SYNTAX +{ + [ARGUMENT &ArgumentType [OPTIONAL &argumentTypeOptional]] + [RESULT &ResultType [OPTIONAL &resultTypeOptional]] + [RETURN RESULT &returnResult] + [ERRORS &Errors] + [LINKED &Linked] + [SYNCHRONOUS &synchronous] + [ALWAYS RESPONDS &alwaysReturns] + [INVOKE PRIORITY &InvokePriority] + [RESULT-PRIORITY &ResultPriority] + [CODE &operationCode] +} + +ERROR ::= CLASS +{ + &ParameterType OPTIONAL, + ¶meterTypeOptional BOOLEAN OPTIONAL, + &ErrorPriority Priority OPTIONAL, + &errorCode Code UNIQUE OPTIONAL +} +WITH SYNTAX +{ + [PARAMETER &ParameterType [OPTIONAL ¶meterTypeOptional]] + [PRIORITY &ErrorPriority] + [CODE &errorCode] +} + +Code ::= CHOICE +{ + local INTEGER, + global OBJECT IDENTIFIER +} +Priority ::= INTEGER (0..MAX) + +ChargingEvent ::= SEQUENCE +{ connection ConnectionID, + chargedDevice DeviceID, + chargingInfo ChargingInfo, + cause EventCause OPTIONAL, + extensions CSTACommonArguments OPTIONAL} + +DigitsGeneratedEvent ::= SEQUENCE +{ connection ConnectionID, + digitGeneratedList IA5String, + digitDurationList [0] IMPLICIT SEQUENCE OF INTEGER OPTIONAL, + pauseDurationList [1] IMPLICIT SEQUENCE OF INTEGER OPTIONAL, + connectionInfo ConnectionInformation OPTIONAL, + extensions CSTACommonArguments OPTIONAL} + +TelephonyTonesGeneratedEvent ::= SEQUENCE +{ connection ConnectionID, + toneGenerated TelephonyTone OPTIONAL, + toneFrequency [0] IMPLICIT INTEGER OPTIONAL, + toneDuration [1] IMPLICIT INTEGER OPTIONAL, + pauseDuration [2] IMPLICIT INTEGER OPTIONAL, + connectionInfo ConnectionInformation OPTIONAL, + extensions CSTACommonArguments OPTIONAL} + +ServiceCompletionFailureEvent ::= SEQUENCE +{ primaryCall PrimaryOrSecondaryCall, + secondaryCall [0] IMPLICIT PrimaryOrSecondaryCall OPTIONAL, + otherDevsPrimaryCallList [1] IMPLICIT SEQUENCE OF OtherCall OPTIONAL, + otherDevsSecondaryCallList [2] IMPLICIT SEQUENCE OF OtherCall OPTIONAL, + mediaCallCharacteristics [3] IMPLICIT MediaCallCharacteristics OPTIONAL, + cause EventCause, + extensions CSTACommonArguments OPTIONAL} + +PrimaryOrSecondaryCall ::= SEQUENCE +{ deviceID DeviceID, + connectionID ConnectionID, + localConnectionState LocalConnectionState, + connectionInfo ConnectionInformation OPTIONAL} + +OtherCall ::= SEQUENCE +{ deviceID DeviceID, + connectionID ConnectionID, + localConnectionState LocalConnectionState OPTIONAL, + connectionInfo ConnectionInformation OPTIONAL} + +TransferredEvent ::= + SEQUENCE + { primaryOldCall ConnectionID, + secondaryOldCall [0] IMPLICIT ConnectionID OPTIONAL, + transferringDevice SubjectDeviceID, + transferredToDevice SubjectDeviceID, + transferredConnections [1] IMPLICIT ConnectionList, + localConnectionInfo LocalConnectionState OPTIONAL, + correlatorData [2] IMPLICIT CorrelatorData OPTIONAL, + userData UserData OPTIONAL, + chargingInfo [3] IMPLICIT ChargingInfo OPTIONAL, + cause EventCause, + servicesPermitted [4] IMPLICIT ServicesPermitted OPTIONAL, + mediaCallCharacteristics [5] IMPLICIT MediaCallCharacteristics OPTIONAL, + callCharacteristics [6] IMPLICIT CallCharacteristics OPTIONAL, + callLinkageDataList [7] IMPLICIT CallLinkageDataList OPTIONAL, + extensions CSTACommonArguments OPTIONAL} + +QueuedEvent ::= + SEQUENCE + { queuedConnection ConnectionID, + queue SubjectDeviceID, + callingDevice CallingDeviceID, + calledDevice CalledDeviceID, + lastRedirectionDevice RedirectionDeviceID, + numberQueued [0] IMPLICIT INTEGER OPTIONAL, + callsInFront [1] IMPLICIT INTEGER OPTIONAL, + localConnectionInfo LocalConnectionState OPTIONAL, + correlatorData [2] IMPLICIT CorrelatorData OPTIONAL, + userData UserData OPTIONAL, + cause EventCause, + servicesPermitted [3] IMPLICIT ServicesPermitted OPTIONAL, + networkCallingDevice NetworkCallingDeviceID OPTIONAL, + networkCalledDevice NetworkCalledDeviceID OPTIONAL, + associatedCallingDevice AssociatedCallingDeviceID OPTIONAL, + associatedCalledDevice AssociatedCalledDeviceID OPTIONAL, + mediaCallCharacteristics [4] IMPLICIT MediaCallCharacteristics OPTIONAL, + callCharacteristics [5] IMPLICIT CallCharacteristics OPTIONAL, + queuedConnectionInfo [6] IMPLICIT ConnectionInformation OPTIONAL, + callLinkageData [7] IMPLICIT CallLinkageData OPTIONAL, + extensions CSTACommonArguments OPTIONAL} + +HookswitchEvent ::= SEQUENCE +{ device SubjectDeviceID, + hookswitch HookswitchID, + hookswitchOnHook BOOLEAN, + extensions CSTACommonArguments OPTIONAL} + +OfferedEvent ::= SEQUENCE + { offeredConnection ConnectionID, + offeredDevice SubjectDeviceID, + callingDevice CallingDeviceID, + calledDevice CalledDeviceID, + lastRedirectionDevice RedirectionDeviceID, + originatingNIDConnection ConnectionID OPTIONAL, + localConnectionInfo LocalConnectionState OPTIONAL, + correlatorData CorrelatorData OPTIONAL, + userData UserData OPTIONAL, + cause EventCause, + servicesPermitted [0] IMPLICIT ServicesPermitted OPTIONAL, + networkCallingDevice NetworkCallingDeviceID OPTIONAL, + networkCalledDevice NetworkCalledDeviceID OPTIONAL, + associatedCallingDevice AssociatedCallingDeviceID OPTIONAL, + associatedCalledDevice AssociatedCalledDeviceID OPTIONAL, + mediaCallCharacteristics [1] IMPLICIT MediaCallCharacteristics OPTIONAL, + callCharacteristics [2] IMPLICIT CallCharacteristics OPTIONAL, + offeredConnectionInfo [3] IMPLICIT ConnectionInformation OPTIONAL, + callLinkageData [4] IMPLICIT CallLinkageData OPTIONAL, + extensions CSTACommonArguments OPTIONAL} + +FailedEvent ::= SEQUENCE + { failedConnection ConnectionID, + failingDevice SubjectDeviceID, + callingDevice CallingDeviceID, + calledDevice CalledDeviceID, + lastRedirectionDevice RedirectionDeviceID, + originatingNIDConnection ConnectionID OPTIONAL, + localConnectionInfo LocalConnectionState OPTIONAL, + correlatorData [0] IMPLICIT CorrelatorData OPTIONAL, + userData UserData OPTIONAL, + cause EventCause, + servicesPermitted [1] IMPLICIT ServicesPermitted OPTIONAL, + networkCallingDevice NetworkCallingDeviceID OPTIONAL, + networkCalledDevice NetworkCalledDeviceID OPTIONAL, + associatedCallingDevice AssociatedCallingDeviceID OPTIONAL, + associatedCalledDevice AssociatedCalledDeviceID OPTIONAL, + mediaCallCharacteristics [2] IMPLICIT MediaCallCharacteristics OPTIONAL, + callCharacteristics [3] IMPLICIT CallCharacteristics OPTIONAL, + failedConnectionInfo [4] IMPLICIT ConnectionInformation OPTIONAL, --corrected 06/2001 + callLinkageData [5] IMPLICIT CallLinkageData OPTIONAL, + extensions CSTACommonArguments OPTIONAL} + +HeldEvent ::= + SEQUENCE + { heldConnection ConnectionID, + holdingDevice SubjectDeviceID, + localConnectionInfo LocalConnectionState OPTIONAL, + correlatorData [0] IMPLICIT CorrelatorData OPTIONAL, + cause EventCause, + servicesPermitted [1] IMPLICIT ServicesPermitted OPTIONAL, + mediaCallCharacteristics [2] IMPLICIT MediaCallCharacteristics OPTIONAL, + callCharacteristics [3] IMPLICIT CallCharacteristics OPTIONAL, + heldConnectionInfo [4] IMPLICIT ConnectionInformation OPTIONAL, + callLinkageData [5] IMPLICIT CallLinkageData OPTIONAL, + extensions CSTACommonArguments OPTIONAL} + +NetworkCapabilitiesChangedEvent ::= SEQUENCE + { outboundConnection ConnectionID, + networkInterfaceUsed SubjectDeviceID, + calledDevice CalledDeviceID, + progressIndicator ProgressIndicator, + localConnectionInfo LocalConnectionState OPTIONAL, + correlatorData CorrelatorData OPTIONAL, + userData UserData OPTIONAL, + networkCapability [0] IMPLICIT NetworkCapability OPTIONAL, + cause EventCause, + servicesPermitted [1] IMPLICIT ServicesPermitted OPTIONAL, + mediaCallCharacteristics [2] IMPLICIT MediaCallCharacteristics OPTIONAL, + callCharacteristics [3] IMPLICIT CallCharacteristics OPTIONAL, + outboundConnectionInfo [4] IMPLICIT ConnectionInformation OPTIONAL, + callLinkageData [5] IMPLICIT CallLinkageData OPTIONAL, + extensions CSTACommonArguments OPTIONAL} + +NetworkReachedEvent ::= + SEQUENCE + { outboundConnection ConnectionID, + networkInterfaceUsed SubjectDeviceID, + callingDevice CallingDeviceID, + calledDevice CalledDeviceID, + lastRedirectionDevice RedirectionDeviceID, + originatingNIDConneciton ConnectionID OPTIONAL, + localConnectionInfo LocalConnectionState OPTIONAL, + correlatorData [0] IMPLICIT CorrelatorData OPTIONAL, + userData UserData OPTIONAL, + networkCapability [1] IMPLICIT NetworkCapability OPTIONAL, + cause EventCause, + servicesPermitted [2] IMPLICIT ServicesPermitted OPTIONAL, + mediaCallCharacteristics [3] IMPLICIT MediaCallCharacteristics OPTIONAL, + callCharacteristics [4] IMPLICIT CallCharacteristics OPTIONAL, + outboundConnectionInfo [5] IMPLICIT ConnectionInformation OPTIONAL, + networkCallingDevice NetworkCallingDeviceID OPTIONAL, + networkCalledDevice NetworkCalledDeviceID OPTIONAL, + associatedCallingDevice AssociatedCallingDeviceID OPTIONAL, + callLinkageData [6] IMPLICIT CallLinkageData OPTIONAL, + extensions CSTACommonArguments OPTIONAL} + +OriginatedEvent ::= SEQUENCE +{ originatedConnection ConnectionID, + callingDevice SubjectDeviceID, + calledDevice CalledDeviceID, + originatingDevice DeviceID OPTIONAL, + localConnectionInfo LocalConnectionState OPTIONAL, + correlatorData [2] IMPLICIT CorrelatorData OPTIONAL, + cause EventCause, + servicesPermitted [3] IMPLICIT ServicesPermitted OPTIONAL, + networkCallingDevice NetworkCallingDeviceID OPTIONAL, + networkCalledDevice NetworkCalledDeviceID OPTIONAL, + associatedCallingDevice AssociatedCallingDeviceID OPTIONAL, + associatedCalledDevice AssociatedCalledDeviceID OPTIONAL, + mediaCallCharacteristics [4] IMPLICIT MediaCallCharacteristics OPTIONAL, + callCharacteristics [5] IMPLICIT CallCharacteristics OPTIONAL, + originatedConnectionInfo [6] IMPLICIT ConnectionInformation OPTIONAL, + callLinkageData [7] IMPLICIT CallLinkageData OPTIONAL, + extensions CSTACommonArguments OPTIONAL} + +RetrievedEvent ::= + SEQUENCE + { retrievedConnection ConnectionID, + retrievingDevice SubjectDeviceID, + localConnectionInfo LocalConnectionState OPTIONAL, + correlatorData [0] IMPLICIT CorrelatorData OPTIONAL, + cause EventCause, + servicesPermitted [1] IMPLICIT ServicesPermitted OPTIONAL, + mediaCallCharacteristics [2] IMPLICIT MediaCallCharacteristics OPTIONAL, + callCharacteristics [3] IMPLICIT CallCharacteristics OPTIONAL, + retrievedConnectionInfo [4] IMPLICIT ConnectionInformation OPTIONAL, + callLinkageData [5] IMPLICIT CallLinkageData OPTIONAL, + extensions CSTACommonArguments OPTIONAL} + +ServiceInitiatedEvent ::= + SEQUENCE + { initiatedConnection ConnectionID, + initiatingDevice SubjectDeviceID, + localConnectionInfo LocalConnectionState OPTIONAL, + correlatorData [0] IMPLICIT CorrelatorData OPTIONAL, + cause EventCause, + servicesPermitted [1] IMPLICIT ServicesPermitted OPTIONAL, + mediaCallCharacteristics [2] IMPLICIT MediaCallCharacteristics OPTIONAL, + callCharacteristics [3] IMPLICIT CallCharacteristics OPTIONAL, + initiatedConnectionInfo [4] IMPLICIT ConnectionInformation OPTIONAL, + networkCallingDevice NetworkCallingDeviceID OPTIONAL, + networkCalledDevice NetworkCalledDeviceID OPTIONAL, + associatedCallingDevice AssociatedCallingDeviceID OPTIONAL, + callLinkageData [5] IMPLICIT CallLinkageData OPTIONAL, + extensions CSTACommonArguments OPTIONAL} + +CallInformationEvent ::= SEQUENCE +{ connection ConnectionID, + device SubjectDeviceID, + callingDevice CallingDeviceID OPTIONAL, + accountInfo [0] IMPLICIT AccountInfo OPTIONAL, + authCode [1] IMPLICIT AuthCode OPTIONAL, + correlatorData [2] IMPLICIT CorrelatorData OPTIONAL, + servicesPermitted [3] IMPLICIT ServicesPermitted OPTIONAL, + userData UserData OPTIONAL, + callQualifyingData [4] IMPLICIT CallQualifyingData OPTIONAL, + connectionInfo ConnectionInformation OPTIONAL, + callLinkageDataList [5] IMPLICIT CallLinkageDataList OPTIONAL, + extensions CSTACommonArguments OPTIONAL} + +BridgedEvent ::= SEQUENCE +{ bridgedConnection ConnectionID, + bridgedAppearance SubjectDeviceID, + localConnectionInfo LocalConnectionState OPTIONAL, + correlatorData [0] IMPLICIT CorrelatorData OPTIONAL, + userData UserData OPTIONAL, + cause EventCause, + servicesPermitted [1] IMPLICIT ServicesPermitted OPTIONAL, + mediaCallCharacteristics [2] IMPLICIT MediaCallCharacteristics OPTIONAL, + callCharacteristics [3] IMPLICIT CallCharacteristics OPTIONAL, + bridgedConnectionInfo [4] IMPLICIT ConnectionInformation OPTIONAL, + callLinkageData [5] IMPLICIT CallLinkageData OPTIONAL, + extensions CSTACommonArguments OPTIONAL} + +CallClearedEvent ::= + SEQUENCE + { clearedCall ConnectionID, + correlatorData [1] IMPLICIT CorrelatorData OPTIONAL, + userData UserData OPTIONAL, + cause EventCause, + mediaCallCharacteristics [2] IMPLICIT MediaCallCharacteristics OPTIONAL, + callCharacteristics [3] IMPLICIT CallCharacteristics OPTIONAL, + callLinkageData [4] IMPLICIT CallLinkageData OPTIONAL, + extensions CSTACommonArguments OPTIONAL} + +ConferencedEvent ::= SEQUENCE +{ primaryOldCall ConnectionID, + secondaryOldCall ConnectionID OPTIONAL, + conferencingDevice SubjectDeviceID, + addedParty SubjectDeviceID, + conferenceConnections ConnectionList, + localConnectionInfo LocalConnectionState OPTIONAL, + correlatorData [1] IMPLICIT CorrelatorData OPTIONAL, + userData UserData OPTIONAL, + cause EventCause, + servicesPermitted [2] IMPLICIT ServicesPermitted OPTIONAL, + mediaCallCharacteristics [3] IMPLICIT MediaCallCharacteristics OPTIONAL, + callCharacteristics [4] IMPLICIT CallCharacteristics OPTIONAL, + callLinkageDataList [6] IMPLICIT CallLinkageDataList OPTIONAL, + extensions [5] IMPLICIT CSTACommonArguments OPTIONAL} + +ConnectionClearedEvent ::= +SEQUENCE +{ droppedConnection ConnectionID, + releasingDevice SubjectDeviceID, + localConnectionInfo LocalConnectionState OPTIONAL, + correlatorData [0] IMPLICIT CorrelatorData OPTIONAL, + userData UserData OPTIONAL, + chargingInfo [1] IMPLICIT ChargingInfo OPTIONAL, + cause EventCause, + servicesPermitted [2] IMPLICIT ServicesPermitted OPTIONAL, + mediaCallCharacteristics [3] IMPLICIT MediaCallCharacteristics OPTIONAL, + callCharacteristics [4] IMPLICIT CallCharacteristics OPTIONAL, + droppedConnectionInfo [5] IMPLICIT ConnectionInformation OPTIONAL, + callLinkageData [6] IMPLICIT CallLinkageData OPTIONAL, + extensions CSTACommonArguments OPTIONAL} + +DeliveredEvent ::= + SEQUENCE + { connection ConnectionID, + alertingDevice SubjectDeviceID, + callingDevice CallingDeviceID, + calledDevice CalledDeviceID, + lastRedirectionDevice RedirectionDeviceID, + originatingNIDConnection ConnectionID OPTIONAL, + localConnectionInfo LocalConnectionState OPTIONAL, + correlatorData [0] IMPLICIT CorrelatorData OPTIONAL, + userData UserData OPTIONAL, + cause EventCause, + servicesPermitted [1] IMPLICIT ServicesPermitted OPTIONAL, + networkCallingDevice NetworkCallingDeviceID OPTIONAL, + networkCalledDevice NetworkCalledDeviceID OPTIONAL, + associatedCallingDevice AssociatedCallingDeviceID OPTIONAL, + associatedCalledDevice AssociatedCalledDeviceID OPTIONAL, + mediaCallCharacteristics [2] IMPLICIT MediaCallCharacteristics OPTIONAL, + callCharacteristics [3] IMPLICIT CallCharacteristics OPTIONAL, + connectionInfo [4] IMPLICIT ConnectionInformation OPTIONAL, + callLinkageData [5] IMPLICIT CallLinkageData OPTIONAL, + extensions CSTACommonArguments OPTIONAL} + +DigitsDialedEvent ::= SEQUENCE + { dialingConnection ConnectionID, + dialingDevice SubjectDeviceID, + dialingSequence DeviceID, + localConnectionInfo LocalConnectionState OPTIONAL, + correlatorData [0] IMPLICIT CorrelatorData OPTIONAL, + cause EventCause, + servicesPermitted [1] IMPLICIT ServicesPermitted OPTIONAL, + networkCallingDevice NetworkCallingDeviceID OPTIONAL, + networkCalledDevice NetworkCalledDeviceID OPTIONAL, + associatedCallingDevice AssociatedCallingDeviceID OPTIONAL, + associatedCalledDevice AssociatedCalledDeviceID OPTIONAL, + dialingConnectionInfo [2] IMPLICIT ConnectionInformation OPTIONAL, + callCharacteristics [3] IMPLICIT CallCharacteristics OPTIONAL, + callLinkageData [4] IMPLICIT CallLinkageData OPTIONAL, + extensions CSTACommonArguments OPTIONAL} + +DivertedEvent ::= SEQUENCE +{ connection ConnectionID, + divertingDevice SubjectDeviceID, + newDestination SubjectDeviceID, + callingDevice CallingDeviceID OPTIONAL, + calledDevice CalledDeviceID OPTIONAL, + lastRedirectionDevice RedirectionDeviceID, + localConnectionInfo LocalConnectionState OPTIONAL, + correlatorData [0] IMPLICIT CorrelatorData OPTIONAL, + userData UserData OPTIONAL, + cause EventCause, + servicesPermitted [1] IMPLICIT ServicesPermitted OPTIONAL, + mediaCallCharacteristics [2] IMPLICIT MediaCallCharacteristics OPTIONAL, + callCharacteristics [3] IMPLICIT CallCharacteristics OPTIONAL, + connectionInfo [4] IMPLICIT ConnectionInformation OPTIONAL, + networkCallingDevice NetworkCallingDeviceID OPTIONAL, + networkCalledDevice NetworkCalledDeviceID OPTIONAL, + associatedCallingDevice AssociatedCallingDeviceID OPTIONAL, + associatedCalledDevice AssociatedCalledDeviceID OPTIONAL, + callLinkageData [5] IMPLICIT CallLinkageData OPTIONAL, + extensions CSTACommonArguments OPTIONAL} + +EstablishedEvent ::= + SEQUENCE + { establishedConnection ConnectionID, + answeringDevice SubjectDeviceID, + callingDevice CallingDeviceID, + calledDevice CalledDeviceID, + lastRedirectionDevice RedirectionDeviceID, + originatingNIDConnection ConnectionID OPTIONAL, + localConnectionInfo LocalConnectionState OPTIONAL, + correlatorData [1] IMPLICIT CorrelatorData OPTIONAL, + userData UserData OPTIONAL, + cause EventCause, + servicesPermitted [2] IMPLICIT ServicesPermitted OPTIONAL, + networkCallingDevice NetworkCallingDeviceID OPTIONAL, + networkCalledDevice NetworkCalledDeviceID OPTIONAL, + associatedCallingDevice AssociatedCallingDeviceID OPTIONAL, + associatedCalledDevice AssociatedCalledDeviceID OPTIONAL, + mediaCallCharacteristics [3] IMPLICIT MediaCallCharacteristics OPTIONAL, + callCharacteristics [4] IMPLICIT CallCharacteristics OPTIONAL, + establishedConnectionInfo [5] IMPLICIT ConnectionInformation OPTIONAL, + callLinkageData [6] IMPLICIT CallLinkageData OPTIONAL, + extensions CSTACommonArguments OPTIONAL} + +EventCause ::= ENUMERATED +-- a general list of cause codes +-- Present in Added in Added in +-- Version 1 Version 2 Version 3 +{ aCDBusy (57), + aCDForward (58), + aCDSaturated (59), + activeParticipation (1), + alertTimeExpired (60), + alternate (2), + autoWork (61), + blocked (35), + busy (3), + callBack (4), + callCancelled (5), + callForward (9), + callForwardImmediate (6), + callForwardBusy (7), + callForwardNoAnswer (8), + callNotAnswered (10), + callPickup (11), + campOn (12), + campOnTrunks (62), + characterCountReached (36), + conference (63), + consultation (37), + destDetected (64), + destNotObtainable (13), + destOutOfOrder (65), + distributed (38), + distributionDelay (66), + doNotDisturb (14), + dTMFDigitDetected (39), + durationExceeded (40), + endOfMessageDetected (41), + enteringDistribution (42), + forcedPause (43), + forcedTransition (67), + incompatibleDestination (15), + intrude (68), + invalidAccountCode (16), + invalidNumberFormat (69), + joinCall (70), + keyOperation (17), + keyOperationInUse (71), + lockout (18), + maintenance (19), + makeCall (44), + makePredictiveCall (72), + messageDurationExceeded (73), + messageSizeExceeded (45), + multipleAlerting (74), + multipleQueuing (75), + networkCongestion (20), + networkDialling (76), + networkNotObtainable (21), + networkOutOfOrder (77), + networkSignal (46), + newCall (22), + nextMessage (47), + noAvailableAgents (23), + normal (78), + normalClearing (48), + noSpeechDetected (49), + notAvaliableBearerService (79), + notSupportedBearerService (80), + numberChanged (50), + numberUnallocated (81), + overflow (26), + override (24), + park (25), + queueCleared (82), + recall (27), + redirected (28), + remainsInQueue (83), + reorderTone (29), + reserved (84), + resourcesNotAvailable (30), + selectedTrunkBusy (85), + silentParticipation (31), + singleStepConference (51), + singleStepTransfer (52), + speechDetected (53), + suspend (86), + switchingFunctionTerminated (54), + terminationCharacterReceived (55), + timeout (56), + transfer (32), + trunksBusy (33), + unauthorisedBearerService (87)} +-- voiceUnitInitiator (34) } + +ConnectionID ::= [APPLICATION 11] CHOICE +{ callID [0] IMPLICIT CallID, + deviceID [1] LocalDeviceID, + both SEQUENCE + { callID [0] IMPLICIT CallID, + deviceID [1] LocalDeviceID + } +} + +CallID ::= IA5String (SIZE(0..8)) +--OCTET STRING (SIZE(0..8)) + +LocalDeviceID ::= CHOICE + { staticID DeviceID, + dynamicID [3] IMPLICIT OCTET STRING (SIZE(0..32)) } + +AgentID ::= OCTET STRING (SIZE(0..32)) + +AgentPassword ::= OCTET STRING (SIZE(0..32)) + +MessageID ::= OCTET STRING + +ServicesPermitted ::= SEQUENCE +{ callControlServices CallControlServices, + callAssociatedServices CallAssociatedServices, + mediaAttachmentServices MediaAttachmentServices, + routeingServices RouteingServices, + voiceUnitServices VoiceUnitServices} + +CallControlServices ::= BIT STRING +{ acceptCall (0), + alternateCall (1), + answerCall (2), + callBack (3), + callBackMessage (4), + campOnCall (5), + clearCall (6), + clearConnection (7), + conferenceCall (8), + consultationCall (9), + deflectCall (10), + dialDigits (11), + directedPickupCall (12), + groupPickupCall (13), + holdCall (14), + intrudeCall (15), + joinCall (16), + makeCall (17), + makePredictiveCall (18), + parkCall (19), + reconnectCall (20), + retrieveCall (21), + singleStepConference (22), + singleStepTransfer (23), + transferCall (24)} + + +CallAssociatedServices ::= BIT STRING +{ associateData (0), + cancelTelephonyTones (1), + generateDigits (2), + generateTelephonyTones (3), + sendUserInformation (4)} + +MediaAttachmentServices ::= BIT STRING +{ attachMediaService (0), + detachMediaService (1)} + +RouteingServices ::= BIT STRING +{ routeRegister ( 0), + routeRegisterCancel ( 1), + routeRegisterAbort ( 2), + reRoute ( 3), + routeEnd ( 4), + routeReject ( 5), + routeRequest ( 6), + routeSelect ( 7), + routeUsed ( 8)} + +VoiceUnitServices ::= BIT STRING +{ concatenateMessage (0), + deleteMessage (1), + playMessage (2), + queryVoiceAttribute (3), + recordMessage (4), + reposition (5), + resume (6), + review (7), + setVoiceAttribute (8), + stop (9), + suspend (10), + synthesizeMessage (11)} + +cSTAEventReport OPERATION ::= +{ ARGUMENT CSTAEventReportArgument + ALWAYS RESPONDS FALSE + CODE local:21 +} + +CSTAEventReportArgument ::= SEQUENCE +{ crossRefIdentifier MonitorCrossRefID, + eventSpecificInfo EventSpecificInfo} + +EventSpecificInfo ::= CHOICE +{ callControlEvents [0] CallControlEvents, + callAssociatedEvents [1] CallAssociatedEvents, + mediaAttachmentEvents [2] MediaAttachmentEvents, + physicalDeviceFeatureEvents [3] PhysicalDeviceFeatureEvents, + logicalDeviceFeatureEvents [4] LogicalDeviceFeatureEvents, + deviceMaintenanceEvents [5] DeviceMaintenanceEvents, + voiceUnitEvents [6] VoiceUnitEvents, + vendorSpecEvents [7] VendorSpecEvents} + + +CallControlEvents ::= CHOICE +{ bridged [ 0] IMPLICIT BridgedEvent, + callCleared [ 1] IMPLICIT CallClearedEvent, + conferenced [ 2] IMPLICIT ConferencedEvent, + connectionCleared [ 3] IMPLICIT ConnectionClearedEvent, + delivered [ 4] IMPLICIT DeliveredEvent, + digitsDialed [ 5] IMPLICIT DigitsDialedEvent, + diverted [ 6] IMPLICIT DivertedEvent, + established [ 7] IMPLICIT EstablishedEvent, + failed [ 8] IMPLICIT FailedEvent, + held [ 9] IMPLICIT HeldEvent, + networkCapabilitiesChanged [10] IMPLICIT NetworkCapabilitiesChangedEvent, + networkReached [11] IMPLICIT NetworkReachedEvent, + offered [12] IMPLICIT OfferedEvent, + originated [13] IMPLICIT OriginatedEvent, + queued [14] IMPLICIT QueuedEvent, + retrieved [15] IMPLICIT RetrievedEvent, + serviceInitiated [16] IMPLICIT ServiceInitiatedEvent, + transferred [17] IMPLICIT TransferredEvent} + +CallAssociatedEvents ::= CHOICE +{ callInformation [ 0] IMPLICIT CallInformationEvent, + charging [ 1] IMPLICIT ChargingEvent, + digitsGeneratedEvent [ 2] IMPLICIT DigitsGeneratedEvent, + telephonyTonesGeneratedEvent [ 3] IMPLICIT TelephonyTonesGeneratedEvent, + serviceCompletionFailure [ 4] IMPLICIT ServiceCompletionFailureEvent} + +MediaAttachmentEvents ::= CHOICE +{ mediaAttached [ 0] IMPLICIT MediaAttachedEvent, + mediaDetached [ 1] IMPLICIT MediaDetachedEvent} + +PhysicalDeviceFeatureEvents ::= CHOICE +{ buttonInformation [ 0] IMPLICIT ButtonInformationEvent, + buttonPress [ 1] IMPLICIT ButtonPressEvent, + displayUpdated [ 2] IMPLICIT DisplayUpdatedEvent, + hookswitch [ 3] IMPLICIT HookswitchEvent, + lampMode [ 4] IMPLICIT LampModeEvent, + messageWaiting [ 5] IMPLICIT MessageWaitingEvent, + microphoneGain [ 6] IMPLICIT MicrophoneGainEvent, + microphoneMute [ 7] IMPLICIT MicrophoneMuteEvent, + ringerStatus [ 8] IMPLICIT RingerStatusEvent, + speakerMute [ 9] IMPLICIT SpeakerMuteEvent, + speakerVolume [10] IMPLICIT SpeakerVolumeEvent} + +LogicalDeviceFeatureEvents ::= CHOICE +{ agentBusy [ 0] IMPLICIT AgentBusyEvent, + agentLoggedOn [ 1] IMPLICIT AgentLoggedOnEvent, + agentLoggedOff [ 2] IMPLICIT AgentLoggedOffEvent, + agentNotReady [ 3] IMPLICIT AgentNotReadyEvent, + agentReady [ 4] IMPLICIT AgentReadyEvent, + agentWorkingAfterCall [ 5] IMPLICIT AgentWorkingAfterCallEvent, + autoAnswer [ 6] IMPLICIT AutoAnswerEvent, + autoWorkMode [ 7] IMPLICIT AutoWorkModeEvent, + callBack [ 8] IMPLICIT CallBackEvent, + callBackMessage [ 9] IMPLICIT CallBackMessageEvent, + callerIDStatus [10] IMPLICIT CallerIDStatusEvent, + doNotDisturb [11] IMPLICIT DoNotDisturbEvent, + forwarding [12] IMPLICIT ForwardingEvent, + routeingMode [13] IMPLICIT RouteingModeEvent} + +DeviceMaintenanceEvents ::= CHOICE +{ backInService [ 0] IMPLICIT BackInServiceEvent, + deviceCapabilityChanged [ 1] IMPLICIT DeviceCapsChangedEvent, + outOfService [ 2] IMPLICIT OutOfServiceEvent} + +VoiceUnitEvents ::= CHOICE +{ play [ 0] IMPLICIT PlayEvent, + record [ 1] IMPLICIT RecordEvent, + review [ 2] IMPLICIT ReviewEvent, + stop [ 3] IMPLICIT StopEvent, + suspendPlay [ 4] IMPLICIT SuspendPlayEvent, + suspendRecord [ 5] IMPLICIT SuspendRecordEvent, + voiceAttributesChange [ 6] IMPLICIT VoiceAttributesChangeEvent} + +VendorSpecEvents::= CHOICE +{ privateEvent [ 0] IMPLICIT PrivateEvent} + + +ButtonInformationEvent ::= SEQUENCE +{ device SubjectDeviceID, + button ButtonID, + buttonLabel IA5String (SIZE(0..64)) OPTIONAL, + buttonAssociatedNumber DeviceID OPTIONAL, + buttonPressIndicator BOOLEAN OPTIONAL, + extensions CSTACommonArguments OPTIONAL} + +DisplayUpdatedEvent ::= SEQUENCE +{ device SubjectDeviceID, + displayID DisplayID OPTIONAL, + logicalRows INTEGER, + logicalColumns INTEGER, + physicalRows [0] IMPLICIT INTEGER OPTIONAL, + physicalColumns [1] IMPLICIT INTEGER OPTIONAL, + physicalBaseRowNumber [2] IMPLICIT INTEGER OPTIONAL, + physicalBaseColumnNumber [3] IMPLICIT INTEGER OPTIONAL, + characterSet CharacterSet OPTIONAL, + contentsOfDisplay IA5String, + extensions CSTACommonArguments OPTIONAL} + +MessageWaitingEvent ::= SEQUENCE +{ targetDevice SubjectDeviceID, + deviceForMessage DeviceID OPTIONAL, + messageWaitingOn BOOLEAN, + extensions CSTACommonArguments OPTIONAL} + +DeviceCapsChangedEvent ::= SEQUENCE +{ device SubjectDeviceID, + cause EventCause OPTIONAL, + extensions CSTACommonArguments OPTIONAL} + +OutOfServiceEvent ::= SEQUENCE +{ device SubjectDeviceID, + cause EventCause OPTIONAL, + extensions CSTACommonArguments OPTIONAL} + +BackInServiceEvent ::= SEQUENCE +{ device SubjectDeviceID, + cause EventCause OPTIONAL, + extensions CSTACommonArguments OPTIONAL} + +RouteingModeEvent ::= SEQUENCE +{ device SubjectDeviceID, + routeingMode BOOLEAN, + extensions CSTACommonArguments OPTIONAL} + +ForwardingEvent ::= SEQUENCE +{ device SubjectDeviceID, + forwardingType ForwardingType OPTIONAL, + forwardStatus BOOLEAN, + forwardTo DeviceID OPTIONAL, + forwardDefault ForwardDefault OPTIONAL, + ringCount INTEGER (1..100) OPTIONAL, + extensions CSTACommonArguments OPTIONAL} + +DoNotDisturbEvent ::= SEQUENCE +{ device SubjectDeviceID, + doNotDisturbOn BOOLEAN, + callOrigination CallOrigination OPTIONAL, + callingDeviceList SEQUENCE OF DeviceID OPTIONAL, + extensions CSTACommonArguments OPTIONAL} + +CallerIDStatusEvent ::= SEQUENCE +{ device DeviceID, + callerIDProvided BOOLEAN, + extensions CSTACommonArguments OPTIONAL} + +CallBackMessageEvent ::= SEQUENCE +{ originatingDevice SubjectDeviceID, + targetDevice SubjectDeviceID, + callBackMsgSetCanceled BOOLEAN, + extensions CSTACommonArguments OPTIONAL} + +CallBackEvent ::= SEQUENCE +{ originatingDevice SubjectDeviceID, + targetDevice SubjectDeviceID, + callBackSetCanceled BOOLEAN, + extensions CSTACommonArguments OPTIONAL} + +AutoWorkModeEvent ::= SEQUENCE +{ invokingDevice SubjectDeviceID, + autoWorkOn BOOLEAN, + autoWorkInterval INTEGER, + extensions CSTACommonArguments OPTIONAL} + +AutoAnswerEvent ::= SEQUENCE +{ invokingDevice SubjectDeviceID, + autoAnswerOn BOOLEAN, + numberOfRings INTEGER OPTIONAL, + extensions CSTACommonArguments OPTIONAL} + +AgentWorkingAfterCallEvent ::= SEQUENCE +{ agentDevice SubjectDeviceID, + agentID AgentID OPTIONAL, + acdGroup DeviceID OPTIONAL, + pendingAgentState [2] IMPLICIT ENUMERATED + {notReady (0), + ready (1), + null (2)} OPTIONAL, + cause [3] IMPLICIT EventCause OPTIONAL, + extensions CSTACommonArguments OPTIONAL} + +AgentReadyEvent ::= SEQUENCE +{ agentDevice SubjectDeviceID, + agentID AgentID OPTIONAL, + acdGroup DeviceID OPTIONAL, + cause EventCause OPTIONAL, + extensions CSTACommonArguments OPTIONAL} + +AgentNotReadyEvent ::= SEQUENCE +{ agentDevice SubjectDeviceID, + agentID AgentID OPTIONAL, + acdGroup DeviceID OPTIONAL, + cause EventCause OPTIONAL, + extensions CSTACommonArguments OPTIONAL} + +AgentLoggedOnEvent ::= SEQUENCE +{ agentDevice SubjectDeviceID, + agentID [2] IMPLICIT AgentID OPTIONAL, + acdGroup DeviceID OPTIONAL, + agentPassword [3] IMPLICIT AgentPassword OPTIONAL, + cause EventCause OPTIONAL, + extensions CSTACommonArguments OPTIONAL} + +AgentLoggedOffEvent ::= SEQUENCE +{ agentDevice SubjectDeviceID, + agentID [2] IMPLICIT AgentID OPTIONAL, + acdGroup DeviceID OPTIONAL, + agentPassword [3] IMPLICIT AgentPassword OPTIONAL, + cause EventCause OPTIONAL, + extensions CSTACommonArguments OPTIONAL} + +AgentBusyEvent ::= SEQUENCE +{ agentDevice SubjectDeviceID, + agentID AgentID OPTIONAL, + acdGroup DeviceID OPTIONAL, + pendingAgentState [2] IMPLICIT PendingAgentState OPTIONAL, + cause [3] IMPLICIT EventCause OPTIONAL, + extensions CSTACommonArguments OPTIONAL} + +PrivateEvent ::= BIT STRING + +CSTAObject ::= CHOICE + {deviceObject DeviceID, + callObject ConnectionID} + +CallingDeviceID ::= [APPLICATION 1] CHOICE + {deviceIdentifier DeviceID, + notKnown [7] IMPLICIT NULL} + +CalledDeviceID ::= [APPLICATION 2] CHOICE + {deviceIdentifier DeviceID, + notKnown [7] IMPLICIT NULL} + +SubjectDeviceID ::= [APPLICATION 3] CHOICE + {deviceIdentifier DeviceID, + notKnown [7] IMPLICIT NULL} + + +RedirectionDeviceID ::= [APPLICATION 4] CHOICE + {numberdialed DeviceID, + notKnown [7] IMPLICIT NULL, + notRequired [8] IMPLICIT NULL, + notSpecified [9] IMPLICIT NULL} + +AssociatedCallingDeviceID ::= [APPLICATION 5] CHOICE + {deviceIdentifier DeviceID, + notKnown [7] IMPLICIT NULL} + +AssociatedCalledDeviceID ::= [APPLICATION 6] CHOICE + {deviceIdentifier DeviceID, + notKnown [7] IMPLICIT NULL} + +NetworkCallingDeviceID ::= [APPLICATION 7] CHOICE + {deviceIdentifier DeviceID, + notKnown [7] IMPLICIT NULL} + +NetworkCalledDeviceID ::= [APPLICATION 8] CHOICE + {deviceIdentifier DeviceID, + notKnown [7] IMPLICIT NULL} + +DeviceID ::= SEQUENCE +{ deviceIdentifier CHOICE + { dialingNumber [0] IMPLICIT NumberDigits, + deviceNumber [1] IMPLICIT DeviceNumber, + implicitPublic [2] IMPLICIT NumberDigits, + explicitPublic [3] PublicTON, + implicitPrivate [4] IMPLICIT NumberDigits, + explicitPrivate [5] PrivateTON, + other [6] IMPLICIT OtherPlan}, + mediaCallCharacteristics MediaCallCharacteristics OPTIONAL} + +PublicTON ::= CHOICE + { unknown [0] IMPLICIT IA5String, + international [1] IMPLICIT IA5String, + national [2] IMPLICIT IA5String, + networkspecific [3] IMPLICIT IA5String, + subscriber [4] IMPLICIT IA5String, + abbreviated [5] IMPLICIT IA5String } + +PrivateTON ::= CHOICE + { unknown [0] IMPLICIT IA5String, + level3RegionalNumber [1] IMPLICIT IA5String, + level2RegionalNumber [2] IMPLICIT IA5String, + level1RegionalNumber [3] IMPLICIT IA5String, + pTNSpecificNumber [4] IMPLICIT IA5String, + localNumber [5] IMPLICIT IA5String, + abbreviated [6] IMPLICIT IA5String } + +OtherPlan ::= OCTET STRING -- Allows future expansion to cover other numbering + -- plans + +NumberDigits ::= IA5String + +DeviceNumber ::= INTEGER + +SuspendPlayEvent ::= SEQUENCE +{ connection ConnectionID, + message MessageID, + length [0] IMPLICIT INTEGER OPTIONAL, + currentPosition [1] IMPLICIT INTEGER OPTIONAL, + cause EventCause OPTIONAL, + servicesPermitted ServicesPermitted OPTIONAL, + extensions CSTACommonArguments OPTIONAL} + +SuspendRecordEvent ::= SEQUENCE +{ connection ConnectionID, + message MessageID, + length [0] IMPLICIT INTEGER OPTIONAL, + currentPosition [1] IMPLICIT INTEGER OPTIONAL, + cause EventCause OPTIONAL, + servicesPermitted ServicesPermitted OPTIONAL, + extensions CSTACommonArguments OPTIONAL} + +VoiceAttributesChangeEvent ::= SEQUENCE +{ connection ConnectionID, + message MessageID, + playVolume [0] Volume OPTIONAL, + recordingGain [1] IMPLICIT INTEGER (0 .. 100) OPTIONAL, + speed [2] IMPLICIT INTEGER OPTIONAL, + currentPosition [3] IMPLICIT INTEGER OPTIONAL, + cause EventCause OPTIONAL, + servicesPermitted ServicesPermitted OPTIONAL, + extensions CSTACommonArguments OPTIONAL} + +ReviewEvent ::= BIT STRING +{ length ( 0), -- optional parameters + currentPosition ( 1), -- optional parameters + cause ( 2), -- optional parameters + servicesPermitted ( 3), -- optional parameters + privateData ( 4)} -- optional parameters + +StopEvent ::= BIT STRING +{ length ( 0), -- optional parameters + currentPosition ( 1), -- optional parameters + speed ( 2), -- optional parameters + cause ( 3), -- optional parameters + servicesPermitted ( 4), -- optional parameters + privateData ( 5)} -- optional parameters + +PlayEvent ::=SEQUENCE +{ connection ConnectionID, + message MessageID, + length [0] IMPLICIT INTEGER OPTIONAL, + currentPosition [1] IMPLICIT INTEGER OPTIONAL, + speed [2] IMPLICIT INTEGER OPTIONAL, + cause EventCause OPTIONAL, + servicesPermitted ServicesPermitted OPTIONAL, + extensions CSTACommonArguments OPTIONAL} + +RecordEvent ::= SEQUENCE +{ connection ConnectionID, + message MessageID, + length [0] IMPLICIT INTEGER OPTIONAL, + currentPosition [1] IMPLICIT INTEGER OPTIONAL, + cause EventCause OPTIONAL, + servicesPermitted ServicesPermitted OPTIONAL, + extensions CSTACommonArguments OPTIONAL} + +SpeakerMuteEvent ::= SEQUENCE +{ invokingDevice SubjectDeviceID, + auditoryApparatus AuditoryApparatusID, + speakerMuteOn BOOLEAN, + extensions CSTACommonArguments OPTIONAL} + +SpeakerVolumeEvent ::= SEQUENCE +{ invokingDevice SubjectDeviceID, + auditoryApparatus AuditoryApparatusID, + speakerVolume Volume, + extensions CSTACommonArguments OPTIONAL} + +RingerStatusEvent ::= SEQUENCE +{ device SubjectDeviceID, + ringer RingerID, + ringMode RingMode OPTIONAL, + ringCount [0] IMPLICIT INTEGER (0..1000) OPTIONAL, + ringPattern [1] IMPLICIT INTEGER OPTIONAL, + ringVolume [2] Volume OPTIONAL, + extensions CSTACommonArguments OPTIONAL} + +MicrophoneMuteEvent ::= SEQUENCE +{ invokingDevice SubjectDeviceID, + auditoryApparatus AuditoryApparatusID, + microphoneMuteOn BOOLEAN, + extensions CSTACommonArguments OPTIONAL} + +MicrophoneGainEvent ::= SEQUENCE +{ invokingDevice SubjectDeviceID, + auditoryApparatus AuditoryApparatusID, + microphoneGain MicrophoneGain, + extensions CSTACommonArguments OPTIONAL} + +AuditoryApparatusList ::= SEQUENCE OF + SEQUENCE { + auditoryApparatus AuditoryApparatusID, + auditoryApparatusType ENUMERATED { + speakerphone (0), + handset (1), + headset (2), + speakerOnlyPhone (3), + other (4) + }, + speaker BIT STRING { + present (0), + volumeSettable (1), + volumeReadable (2), + muteSettable (3), + muteReadable (4) + }, + microphone BIT STRING { + present (0), + gainSettable (1), + gainReadable (2), + muteSettable (3), + muteReadable (4) + }, + hookswitch BIT STRING { + hookswitchSettable (0), + hookswitchOnHook (1) + }, + hookswitchID HookswitchID + } + +AuditoryApparatusID ::= OCTET STRING (SIZE(0..4)) + +ButtonID ::= OCTET STRING (SIZE(0..4)) + +CharacterSet ::= ENUMERATED +{ ascii (0), + unicode (1), + proprietary (2)} + +DisplayID ::= OCTET STRING (SIZE(0..4)) + +HookswitchID ::= OCTET STRING (SIZE(0..4)) + +LampBrightness ::= ENUMERATED +{ unspecified (0), + dim (1), + bright (2)} + +LampColor ::= INTEGER +{ noColor (0), + red (1), + yellow (2), + green (3), + blue (4), + unknown (5)} (0..100) + +LampID ::= OCTET STRING (SIZE(0..4)) + +LampMode ::= INTEGER +{ brokenFlutter (0), + flutter (1), + off (2), + steady (3), + wink (4), + unknown (5)} (0..100) + +MicrophoneGain ::= CHOICE +{ micGainAbs MicGainAbs, + micGainInc MicGainInc} + +MicGainInc ::= ENUMERATED +{ increment (0), + decrement (1)} + +MicGainAbs ::= INTEGER (0..100) + +RingerID ::= OCTET STRING (SIZE(0..4)) + +RingMode ::= ENUMERATED +{ ringing (0), + notRinging (1)} + +Volume ::= CHOICE +{ volAbs VolAbs, + volInc VolInc} + +VolInc ::= ENUMERATED +{ increment (0), + decrement (1)} + +VolAbs ::= INTEGER (0..100) + +CSTACommonArguments ::= [APPLICATION 30] IMPLICIT SEQUENCE + {security [0] IMPLICIT CSTASecurityData OPTIONAL, + privateData [1] IMPLICIT SEQUENCE OF CSTAPrivateData OPTIONAL } + +CSTAPrivateData ::= CHOICE +{ string OCTET STRING, + private NULL} -- The actual encoding is added here, + -- replacing NULL with another valid ASN.1 type. + +CSTASecurityData ::= SEQUENCE +{ messageSequenceNumber [0] IMPLICIT INTEGER OPTIONAL, + timestamp TimeInfo OPTIONAL, + securityInfo SecurityInfo OPTIONAL} + +SecurityInfo ::= CHOICE +{ string OCTET STRING, + private NULL} -- The actual encoding is added here, + -- replacing NULL with another valid ASN.1 type. + +TimeInfo ::= GeneralizedTime + +LampModeEvent ::= SEQUENCE +{ device SubjectDeviceID, + lamp LampID, + lampLabel OCTET STRING (SIZE(0..64)) OPTIONAL, + lampMode LampMode, + lampBrightness LampBrightness OPTIONAL, + lampColor LampColor OPTIONAL, + extensions CSTACommonArguments OPTIONAL} + +MediaAttachedEvent ::= SEQUENCE +{ mediaConnection ConnectionID, + mediaDevice SubjectDeviceID, + mediaServiceType MediaServiceType, + mediaServiceVersion INTEGER OPTIONAL, + mediaServiceInstanceID [0] IMPLICIT MediaServiceInstanceID OPTIONAL, + mediaStreamID [1] IMPLICIT MediaStreamID OPTIONAL, + mediaCallCharacteristics [2] IMPLICIT MediaCallCharacteristics OPTIONAL, + callCharacteristics CallCharacteristics OPTIONAL, + localConnectionInfo LocalConnectionState OPTIONAL, + mediaConnectionInfo [3] IMPLICIT ConnectionInformation OPTIONAL, + extension CSTACommonArguments OPTIONAL} + +MediaDetachedEvent ::= SEQUENCE +{ mediaConnection ConnectionID, + mediaDevice SubjectDeviceID, + mediaServiceType MediaServiceType, + mediaServiceVersion INTEGER OPTIONAL, + mediaServiceInstanceID [0] IMPLICIT MediaServiceInstanceID OPTIONAL, + mediaStreamID [1] IMPLICIT MediaStreamID OPTIONAL, + mediaCallCharacteristics [2] IMPLICIT MediaCallCharacteristics OPTIONAL, + callCharacteristics CallCharacteristics OPTIONAL, + localConnectionInfo LocalConnectionState OPTIONAL, + mediaConnectionInfo [3] IMPLICIT ConnectionInformation OPTIONAL, + extension CSTACommonArguments OPTIONAL} + +ButtonPressEvent ::= SEQUENCE +{ device SubjectDeviceID, + button ButtonID, + buttonLabel IA5String (SIZE(0..64)) OPTIONAL, + buttonAssociatedNumber DeviceID OPTIONAL, + extensions CSTACommonArguments OPTIONAL} + +UserData ::= [APPLICATION 29] OCTET STRING (SIZE(0..256)) + +AuthCode ::= OCTET STRING (SIZE(0..32)) + +CorrelatorData ::= OCTET STRING (SIZE(0..32)) + +CallCharacteristics ::= BIT STRING +{ acdCall (0), + priorityCall (1), + maintainanceCall (2), + directAgent (3), + assistCall (4), + voiceUnitCall (5)} + +CallQualifyingData ::= OCTET STRING (SIZE(0..32)) + +MediaServiceType ::= ENUMERATED +{ cstaVoiceUnit ( 0), + dataModem ( 1), + digitalDataIsochronousIeee1394 ( 2), + digitalDataIsochronousGeoport ( 3), + digitalDataIsochronousIeeeAtm ( 4), + digitalDataIsochronousIeeeIsdn ( 5), + digitalDataApi ( 6), + ectfS100MediaServicesDefault ( 7), + ectfS100MediaServicesAppServices ( 8), + cstaIVRScript1 ( 9), + cstaIVRScript2 (10), + cstaIVRScript3 (11), + cstaIVRScript4 (12), + cstaIVRScript5 (13), + cstaIVRScript6 (14), + cstaIVRScript7 (15), + cstaIVRScript8 (16), + cstaIVRScript9 (17), + cstaIVRScript10 (18), + liveSoundCaptureAnalog (19), + liveSoundTransmitAnalog (20), + liveSoundCaptureIeee1394 (21), + liveSoundTransmitIeee1394 (22), + liveSoundCaptureTransmitGeoport (23), + liveSoundCaptureTransmitAtm (24), + liveSoundCaptureTransmitISDN (25), + soundCaptureTransmitADPCM (26), + soundCaptureTransmitApi (27), + usb (28), + sfSpecific1 (29), + sfSpecific2 (30), + sfSpecific3 (31), + sfSpecific4 (32), + sfSpecific5 (33), + sfSpecific6 (34), + sfSpecific7 (35), + sfSpecific8 (36), + sfSpecific9 (37), + sfSpecific10 (38)} + +MediaStreamID ::= OCTET STRING +MediaServiceInstanceID ::= OCTET STRING (SIZE(0..64)) + +ConnectionInformation ::= SEQUENCE +{ flowDirection ENUMERATED + { transmit (0), + receive (1), + transmitAndReceive (2) + } OPTIONAL, + numberOfChannels INTEGER DEFAULT 1 } + +ConnectionMode ::= ENUMERATED +{ consultationConference (0), + consultationConferenceHold (1), + deflect (2), + directedPickup (3), + join (4), + singleStepConference (5), + singleStepConferenceHold (6), + singleStepTransfer (7), + transfer (8), + direct (9)} + +ConnectionModeBMap ::= BIT STRING +{ consultationConference (0), + consultationConferenceHold (1), + deflect (2), + directedPickup (3), + join (4), + singleStepConference (5), + singleStepConferenceHold (6), + singleStepTransfer (7), + transfer (8), + direct (9)} + +MediaCallCharacteristics ::= SEQUENCE +{ mediaClass MediaClass, + connectionRate [0] IMPLICIT INTEGER OPTIONAL, + -- value 0 indicates that + -- the connection rate is + -- unknown + bitRate [1] IMPLICIT ENUMERATED + { constant (0), + variable (1)} DEFAULT constant, + delayTolerance [2] IMPLICIT INTEGER OPTIONAL, + switchingSubDomainCCIEType [3] IMPLICIT ENUMERATED { + isdn (0), + atm (1), + isoEthernet (2), + rsvp (3), + other (4) + } OPTIONAL, + switchingSubDomainInformationElements OCTET STRING OPTIONAL + -- is mandatory, if the switchingSubDomainCCIEType is present, + -- should be ignored otherwise + } + +MediaClass ::= BIT STRING +{ voice (0), + data (1), + image (2), + audio (4), + other (3), + notKnown (5)} + +CallLinkageDataList ::= SEQUENCE +{ newCallLinkageData CallLinkageData, + oldCallLinkageData CallLinkageData } + +CallLinkageData ::= SEQUENCE +{ globalCallData GlobalCallData, + threadData ThreadData OPTIONAL } + +ForwardingType ::= ENUMERATED +{ forwardImmediate (0), + forwardBusy (1), + forwardNoAns (2), + forwardDND (9), + forwardBusyInt (3), + forwardBusyExt (4), + forwardNoAnsInt (5), + forwardNoAnsExt (6), + forwardImmInt (7), + forwardImmExt (8), + forwardDNDInt (10), + forwardDNDExt (11)} + +ForwardDefault ::= ENUMERATED +{ forwardingTypeAndForwardDN (0), + forwardingType (1), + forwardDN (2)} + +PendingAgentState ::= ENUMERATED +{ agentNotReady (0), + agentNull (1), + agentReady (2), + agentWorkingAfterCall (3)} + +ChargingInfo ::= SEQUENCE + { numberUnits NumberUnits, + typeOfChargingInfo ENUMERATED + { subTotal (0), + total (1) + } + } + + +NumberUnits ::= CHOICE +{ numberOfChargeUnits [0] IMPLICIT NumberOfChargingUnits, + numberOfCurrencyUnits [1] IMPLICIT NumberOfCurrencyUnits} + + +NumberOfChargingUnits ::= SEQUENCE OF SEQUENCE + { chargingUnits INTEGER, + typeOfUnits OCTET STRING OPTIONAL } + +NumberOfCurrencyUnits ::= SEQUENCE +{ currencyType OCTET STRING, -- size 0 indicates default currency + currencyAmount INTEGER, + currencyMultiplier ENUMERATED + { oneThousandth (0), + oneHundredth (1), + oneTenth (2), + one (3), + ten (4), + hundred (5), + thousand (6) + } +} + +CallOrigination ::= BIT STRING +{ internal (0), + external (1)} + +MonitorObject ::= CSTAObject --corrected 12/2000 + +MonitorCrossRefID ::= [APPLICATION 21] IMPLICIT OCTET STRING (SIZE(0..4)) + +MonitorType ::= ENUMERATED + { call (0), + device (1) } + +MonitorMediaClass ::= BIT STRING +{ voice (0), + data (1), + image (2), + audio (4), + other (3)} + +NetworkCapability ::= SEQUENCE + { networkType ENUMERATED + { iSDNPublic (0), + nonISDNPublic (1), + iSDNPrivate (2), + nonISDNPrivate (3), + other (4) }, + eventsProvided BIT STRING + { bridged (0), + callCleared (1), + conferenced (2), + connectionCleared (3), + delivered (4), + digitsDialed (5), + diverted (6), + established (7), + failed (8), + held (9), + networkCapabilitiesChange (10), + networkReached (11), + offered (12), + originated (13), + queued (14), + retrieved (15), + serviceInitiated (16), + transferred (17) } OPTIONAL} + +ProgressIndicator ::= SEQUENCE + { progressLocation ENUMERATED + { user (0), + privateNetServingLocal (1), + publicNetServingLocal (2), + transitNetwork (3), + publicNetServingRemote (4), + privateNetServingRemote (5), + localInterface (6), + internationalNetwork (7), + networkBeyondInterwk (8), + other (9) }, + progressDescription ENUMERATED + { iSDNProgressDesc (0), + qSIGProgressDesc (1), + other (2) }} + +ThreadData ::= SEQUENCE +{ threadSwitchingSubDomainName IA5String (SIZE(1..64)) OPTIONAL, + threadLinkageID ThreadLinkageID, + threadIDTimeStamp TimeInfo OPTIONAL } + +ThreadLinkageID ::= CHOICE +{ subDomainThreadID [0] IMPLICIT OCTET STRING (SIZE(1..8)), + globallyUniqueThreadID [1] IMPLICIT OCTET STRING (SIZE(1..16)) } + +GlobalCallData ::= SEQUENCE +{ globalCallSwitchingSubDomainName IA5String (SIZE(1..64)) OPTIONAL, + globalCallLinkageID GlobalCallLinkageID, + callLinkageIDTimestamp TimeInfo OPTIONAL } + +GlobalCallLinkageID ::= CHOICE +{ subDomainCallLinkageID [0] IMPLICIT OCTET STRING (SIZE(1..8)), + globallyUniqueCallLinkageID [1] IMPLICIT OCTET STRING (SIZE(1..16)) } + +ConnectionList ::= SEQUENCE OF SEQUENCE + { newConnection [0] ConnectionID OPTIONAL, + oldConnection [1] ConnectionID OPTIONAL, + endpoint [2] CHOICE + { deviceID DeviceID, + notKnown NULL} OPTIONAL, + associatedNID [3] CHOICE + { deviceID DeviceID, + notKnown NULL} OPTIONAL, + resultingConnectionInfo ConnectionInformation OPTIONAL} + +LocalConnectionState ::= [APPLICATION 14] IMPLICIT ENUMERATED + { null (0), + initiated (1), + alerting (2), + connected (3), + hold (4), + queued (5), + fail (6)} + +AccountInfo ::= OCTET STRING (SIZE(0..32)) + +TelephonyTone ::= ENUMERATED +{ beep ( 0), + billing ( 1), + busy ( 2), + carrier ( 3), + confirmation ( 4), + dial ( 5), + faxCNG ( 6), + hold ( 7), + howler ( 8), + intrusion ( 9), + modemCNG (10), + park (11), + recordWarning (12), + reorder (13), + ringback (14), + silence (15), + sitVC (16), + sitIC (17), + sitRO (18), + sitNC (19), + switchSpec0 (20), + switchSpec1 (21), + switchSpec2 (22), + switchSpec3 (23), + switchSpec4 (24), + switchSpec5 (25), + switchSpec6 (26), + switchSpec7 (27), + switchSpec8 (28), + switchSpec9 (29), + switchSpec10 (30), + switchSpec11 (31), + switchSpec12 (32), + switchSpec13 (33), + switchSpec14 (34), + switchSpec15 (35), + switchSpec16 (36), + switchSpec17 (37), + switchSpec18 (38), + switchSpec19 (39), + switchSpec20 (40), + switchSpec21 (41), + switchSpec22 (42), + switchSpec23 (43), + switchSpec24 (44), + switchSpec25 (45), + switchSpec26 (46), + switchSpec27 (47), + switchSpec28 (48), + switchSpec29 (49), + switchSpec30 (50), + switchSpec31 (51), + switchSpec32 (52), + switchSpec33 (53), + switchSpec34 (54), + switchSpec35 (55), + switchSpec36 (56), + switchSpec37 (57), + switchSpec38 (58), + switchSpec39 (59), + switchSpec40 (60), + switchSpec41 (61), + switchSpec42 (62), + switchSpec43 (63), + switchSpec44 (64), + switchSpec45 (65), + switchSpec46 (66), + switchSpec47 (67), + switchSpec48 (68), + switchSpec49 (69), + switchSpec50 (70), + switchSpec51 (71), + switchSpec52 (72), + switchSpec53 (73), + switchSpec54 (74), + switchSpec55 (75), + switchSpec56 (76), + switchSpec57 (77), + switchSpec58 (78), + switchSpec59 (79), + switchSpec60 (80), + switchSpec61 (81), + switchSpec62 (82), + switchSpec63 (83), + switchSpec64 (84), + switchSpec65 (85), + switchSpec66 (86), + switchSpec67 (87), + switchSpec68 (88), + switchSpec69 (89), + switchSpec70 (90), + switchSpec71 (91), + switchSpec72 (92), + switchSpec73 (93), + switchSpec74 (94), + switchSpec75 (95), + switchSpec76 (96), + switchSpec77 (97), + switchSpec78 (98), + switchSpec79 (99), + switchSpec80 (100), + switchSpec81 (101), + switchSpec82 (102), + switchSpec83 (103), + switchSpec84 (104), + switchSpec85 (105), + switchSpec86 (106), + switchSpec87 (107), + switchSpec88 (108), + switchSpec89 (109), + switchSpec90 (110), + switchSpec91 (111), + switchSpec92 (112), + switchSpec93 (113), + switchSpec94 (114), + switchSpec95 (115), + switchSpec96 (116), + switchSpec97 (117), + switchSpec98 (118), + switchSpec99 (119), + switchSpec100 (120)} + +CSTAapdu ::= CHOICE +{svcRequest ROIVapdu, + svcResult RORSapdu, + svcError ROERapdu, + svcReject RORJapdu } + +ROIVapdu ::= [1] IMPLICIT SEQUENCE +{invokeID INTEGER, + serviceID INTEGER, + serviceArgs ANY DEFINED BY serviceID } + +RORSapdu ::= [2] IMPLICIT SEQUENCE +{invokeID INTEGER, -- no. de sequencia + result SEQUENCE + {serviceID INTEGER, + serviceResult ANY DEFINED BY serviceID OPTIONAL } } + +ROERapdu ::= [3] IMPLICIT SEQUENCE +{invokeID INTEGER, + unknown INTEGER, + typeOfError UniversalFailure } + +RORJapdu ::= [4] IMPLICIT SEQUENCE +{invokeID CHOICE + {invokeID INTEGER, + null NULL }, + typeOfProblem CHOICE + {general [0] IMPLICIT GeneralProblem, + invoke [1] IMPLICIT InvokeProblem, + result [2] IMPLICIT ReturnResultProblem, + error [3] IMPLICIT ReturnErrorProblem } } + +GeneralProblem ::= ENUMERATED +{unrecognizedAPDU (0), + mistypedAPDU (1), + badlyStructuredAPDU (2) } + +InvokeProblem ::= ENUMERATED +{duplicateInvocation (0), + unrecognizedOperation (1), + mistypedArgument (2), + resourceLimitation (3), + initiatorReleasing (4), + unrecognizedLinkedID (5), -- Not used in CSTA + linkedResponseUnexpected (6), -- " " " " + unexepectedChildOperation (7) -- " " " " -- } + +ReturnResultProblem ::= ENUMERATED +{unrecognizedInvocation (0), + resultResponseUnexpected (1), + mistypedResult (2) } + +ReturnErrorProblem ::= ENUMERATED +{unrecognizedInvocation (0), + errorResponseUnexpected (1), + unrecognizedError (2), + unexpectedError (3), + mistypedParameter (4) } + +-- CSTA codes. Generate a C enum in order to be used as ServiceID values +-- in ROIVapdu +CSTAServices ::= ENUMERATED { + alternateCallSID (1), + answerCallSID (2), + callCompletionSID (3), + clearCallSID (4), + clearConnectionSID (5), + conferenceCallSID (6), + consultationCallSID (7), + divertCallSID (8), + holdCallSID (9), + makeCallSID (10), + makePredictiveCallSID (11), + queryDeviceSID (12), + reconnectCallSID (13), + retrieveCallSID (14), + setFeatureSID (15), + transferCallSID (16), + associateDataSID (17), + parkCallSID (18), + sendDTMFTonesSID (19), + singleStepConfSID (20), + cSTAeventReportSID (21), + routeRequestSID (31), + reRouteRequestSID (32), + routeSelectRequestSID (33), + routeUsedRequestSID (34), + routeEndRequestSID (35), + singleStepTransSID (50), + escapeServiceSID (51), + systemStatusSID (52), + monitorStartSID (71), + changeMonitorFilterSID (72), + monitorStopSID (73), + snapshotDeviceSID (74), + snapshotCallSID (75), + startDataPathSID (110), + stopDataPathSID (111), + sendDataSID (112), + sendMulticastDataSID (113), + sendBroadcastDataSID (114), + suspendDataPathSID (115), + dataPathSuspendedSID (116), + resumeDataPathSID (117), + dataPathResumedSID (118), + fastDataSID (119), + concatenateMessageSID (500), + deleteMessageSID (501), + playMessageSID (502), + queryVoiceAttributeSID (503), + repositionSID (504), + resumeSID (505), + reviewSID (506), + setVoiceAttributeSID (507), + stopSID (508), + suspendSID (509), + synthesizeMessageSID (510), + recordMessageSID (511) } + +-- +-- Usefull types +-- + +UniversalFailure ::= CHOICE +{operationalErrors [1] IMPLICIT Operations, + stateErrors [2] IMPLICIT StateIncompatibility, + systemResourceErrors [3] IMPLICIT SystemResourceAvailability, + subscribedResourceAvailabilityErrors [4] IMPLICIT SubscribedResourceAvailability, + performanceErrors [5] IMPLICIT PerformanceManagement, + securityErrors [6] IMPLICIT SecurityError, + unspecifiedErrors [7] IMPLICIT NULL, + nonStandardErrors --Matracom specs [8] IMPLICIT -- CSTAPrivateData} + +Operations ::= ENUMERATED +{generic (1), +requestIncompatibleWithObject (2), +valueOutOfRange (3), +objectNotKnown (4), +invalidCallingDevice (5), +invalidCalledDevice (6), +invalidForwardingDestination (7), +privilegeViolationOnSpecifiedDevice (8), +privilegeViolationOnCalledDevice (9), +privilegeViolationOnCallingDevice (10), +invalidCSTACallIdentifier (11), +invalidCSTADeviceIdentifier (12), +invalidCSTAConnectionIdentifier (13), +invalidDestination (14), +invalidFeature (15), +invalidAllocationState (16), +invalidCrossRefID (17), +invalidObjectType (18), +securityViolation (19), +invalidCSTAApplicationCorrelator (20), +invalidAccountCode (21), +invalidAuthorisationCode (22), +requestIncompatibleWithCallingDevice (23), +requestIncompatibleWithCalledDevice (24), +invalidMessageIdentifier (25), +messageIdentifierRequired (26), +mediaIncompatible (27) } + +StateIncompatibility ::= ENUMERATED +{generic (1), +invalidObjectState (2), +invalidConnectionID (3), +noActiveCall (4), +noHeldCall (5), +noCallToClear (6), +noConnectionToClear (7), +noCallToAnswer (8), +noCallToComplete (9), +notAbleToPlay (10), +notAbleToResume (11), +endOfMessage (12), +beginingOfMessage (13), +messageSuspended (14) } + +SystemResourceAvailability ::= ENUMERATED +{generic (1), +serviceBusy (2), +resourceBusy (3), +resourceOutOfService (4), +networkBusy (5), +networkOutOfService (6), +overallMonitorLimitExceeded (7), +conferenceMemberLimitExceeded (8) } + +SubscribedResourceAvailability ::= ENUMERATED +{generic (1), +objectMonitorLimitExceeded (2), +trunkLimitExceeded (3), +outstandingRequestLimitExceeded (4) } + +PerformanceManagement ::= ENUMERATED +{generic (1), +performanceLimitExceeded (2) } + +SecurityError ::= ENUMERATED +{unspecified (0), +sequenceNumberViolated (1), +timeStampViolated (2), +pACViolated (3), +sealViolated (4) } + +CallControlEventIDs ::= BIT STRING + { + callCleared (0), + conferenced (1), + connectionCleared (2), + delivered (3), + diverted (4), + established (5), + failed (6), + held (7), + networkReached (8), + originated (9), + queued (10), + retrieved (11), + serviceInitiated (12), + transferred (13), + digitsDialed (14), + bridged (15), + networkCapabilitiesChanged (16), + offered (17) +} + +CallAssociatedEventIDs ::= BIT STRING +{ callInformation (0), + charging (1), + dTMFDigitsDetected (2), + telephonyTonesDetected (3), + serviceCompletionFailure (4)} + +MediaAttachmentEventIDs ::= BIT STRING +{ mediaAttached (0), + mediaDetached (1)} + +PhysicalDeviceFeatureEventIDs ::= BIT STRING + {buttonInformation (0), + buttonPress (1), + displayUpdated (2), + hookswitch (3), + lampMode (4), + messageWaiting (5), + microphoneGain (6), + microphoneMute (7), + ringerStatus (8), + speakerMute (9), + speakerVolume (10)} + +LogicalDeviceFeatureEventIDs ::= BIT STRING +{ agentBusy ( 0), + agentLoggedOn ( 1), + agentLoggedOff ( 2), + agentNotReady ( 3), + agentReady ( 4), + agentWorkingAfterCall ( 5), + autoAnswer ( 6), + autoWorkMode ( 7), + callBack ( 8), + callBackMessage ( 9), + callerIDStatus (10), + doNotDisturb (11), + forwarding (12), + routeingMode (13)} + +DeviceMaintenanceEventIDs ::= BIT STRING +{ backInService (0), + deviceCapabilityChanged (2), + outOfService (1) } + +VoiceUnitEventIDs ::= BIT STRING + { play (1), + record (3), + review (5), + stop (0), + suspendPlay (2), + suspendRecord (4), + voiceAttributesChange (6) } + +VendorSpecEventIDs::= BIT STRING +{ privateEvent (0)} + +MonitorFilter ::= SEQUENCE -- default is no filter (i.e. all events) + {callControl [0] IMPLICIT CallControlEventIDs DEFAULT {}, + callAssociated [6] IMPLICIT CallAssociatedEventIDs DEFAULT {}, + mediaAttachment [7] IMPLICIT MediaAttachmentEventIDs DEFAULT {}, + physicalDeviceFeature [8] IMPLICIT PhysicalDeviceFeatureEventIDs DEFAULT {}, + logicalDeviceFeature [9] IMPLICIT LogicalDeviceFeatureEventIDs DEFAULT {}, + maintenance [3] IMPLICIT DeviceMaintenanceEventIDs DEFAULT {}, + voiceUnit [5] IMPLICIT VoiceUnitEventIDs DEFAULT {}, + private [4] IMPLICIT VendorSpecEventIDs DEFAULT {}} + +MonitorStartArgument ::= SEQUENCE +{ monitorObject MonitorObject, + requestedMonitorFilter [0] IMPLICIT MonitorFilter OPTIONAL, + monitorType MonitorType OPTIONAL, + requestedMonitorMediaClass [1] IMPLICIT MonitorMediaClass OPTIONAL, + extensions CSTACommonArguments OPTIONAL} + +MonitorStartResult ::= SEQUENCE +{ crossRefIdentifier MonitorCrossRefID, + actualmonitorFilter [0] IMPLICIT MonitorFilter OPTIONAL, + actualMonitorMediaClass [1] IMPLICIT MonitorMediaClass OPTIONAL, + monitorExistingCalls BOOLEAN OPTIONAL, + extensions CSTACommonArguments OPTIONAL} + +END -- of CSTA-event-report-definitions -- cgit v1.2.3