-- Small modifications made to the original due to as2wrs shortfalls, to be corrected. -- Module IN-SSF-SCF-ops-args (Q.1248.2:07/2001) IN-SSF-SCF-ops-args {itu-t recommendation q 1248 modules(1) in-ssf-scf-ops-args(8) version1(0)} DEFINITIONS IMPLICIT TAGS ::= BEGIN IMPORTS common-classes, common-datatypes, errortypes, scf-srf-classes, scf-srf-datatypes, ssf-scf-classes, ssf-scf-datatypes, operationcodes, ros-InformationObjects FROM IN-object-identifiers {itu-t recommendation q 1248 modules(1) in-object-identifiers(0) version1(0)} OPERATION FROM Remote-Operations-Information-Objects ros-InformationObjects COMMON-BOUNDS FROM IN-common-classes common-classes SCF-SSF-BOUNDS FROM IN-SSF-SCF-Classes ssf-scf-classes SCF-SRF-BOUNDS FROM IN-SCF-SRF-Classes scf-srf-classes opcode-activateServiceFiltering, opcode-activityTest, opcode-analysedInformation, opcode-analyseInformation, opcode-applyCharging, opcode-applyChargingReport, opcode-assistRequestInstructions, opcode-authorizeTermination, opcode-callFiltering, opcode-callGap, opcode-callInformationReport, opcode-callInformationRequest, opcode-cancel, opcode-cancelStatusReportRequest, opcode-collectedInformation, opcode-collectInformation, opcode-connect, opcode-connectToResource, opcode-continue, opcode-continueWithArgument, opcode-createCallSegmentAssociation, opcode-createOrRemoveTriggerData, opcode-disconnectForwardConnection, opcode-dFCWithArgument, opcode-disconnectLeg, opcode-entityReleased, opcode-establishTemporaryConnection, opcode-eventNotificationCharging, opcode-eventReportBCSM, opcode-eventReportFacility, opcode-facilitySelectedAndAvailable, opcode-furnishChargingInformation, opcode-holdCallInNetwork, opcode-initialDP, opcode-initiateCallAttempt, opcode-manageTriggerData, opcode-mergeCallSegments, opcode-moveCallSegments, opcode-oAbandon, opcode-oAnswer, opcode-oCalledPartyBusy, opcode-oDisconnect, opcode-oMidCall, opcode-moveLeg, opcode-oNoAnswer, opcode-originationAttempt, opcode-originationAttemptAuthorized, opcode-oSuspended, opcode-reconnect, opcode-releaseCall, opcode-reportUTSI, opcode-requestCurrentStatusReport, opcode-requestEveryStatusChangeReport, opcode-requestFirstStatusMatchReport, opcode-requestNotificationChargingEvent, opcode-requestReportBCSMEvent, opcode-requestReportUTSI, opcode-requestReportFacilityEvent, opcode-resetTimer, opcode-monitorRouteReport, opcode-monitorRouteRequest, opcode-routeSelectFailure, opcode-selectFacility, opcode-selectRoute, opcode-sendChargingInformation, opcode-sendFacilityInformation, opcode-sendSTUI, opcode-serviceFilteringResponse, opcode-setServiceProfile, opcode-splitLeg, opcode-statusReport, opcode-tAnswer, opcode-tBusy, opcode-tDisconnect, opcode-termAttemptAuthorized, opcode-terminationAttempt, opcode-tMidCall, opcode-tNoAnswer, opcode-tSuspended FROM IN-operationcodes operationcodes Extensions{}, Integer4, InvokeID FROM IN-common-datatypes common-datatypes AccessCode{}, ActionIndicator, ActionPerformed, AChBillingChargingCharacteristics{}, AdditionalCallingPartyNumber{}, AlertingPattern, ApplicationTimer, AssistingSSPIPRoutingAddress{}, BackwardGVNS{}, BCSMEvent{}, BearerCapability{}, BISDNParameters{}, CalledDirectoryNumber{}, CalledPartyBusinessGroupID, CalledPartyNumber{}, CalledPartySubaddress{}, CallingGeodeticLocation{}, CallingPartyBusinessGroupID, CallingPartyNumber{}, CallingPartysCategory, CallingPartySubaddress{}, CallProcessingOperation, CallReference{}, CallResult{}, CallSegmentID{}, Carrier{}, Cause{}, CCSS, CGEncountered, ChargeNumber{}, ChargingEvent{}, CNInfo{}, Component, ComponentCorrelationID, ComponentType, ConnectionIdentifier{}, ControlType, CorrelationID{}, CountersValue{}, CreateOrRemoveIndicator, CSAID{}, GenericIdentifier{}, GlobalCallReference{}, CUG-Index, CUG-Interlock, CutAndPaste, DateAndTime, DefaultFaultHandling{}, DestinationIndex{}, DestinationRoutingAddress{}, Digits{}, DisplayInformation{}, DpSpecificCommonParameters{}, Duration, EventSpecificInformationBCSM{}, EventSpecificInformationCharging{}, EventTypeBCSM, EventTypeCharging{}, FacilityGroup, FacilityGroupMember, FCIBillingChargingCharacteristics{}, FeatureCode{}, FeatureRequestIndicator, FilteredCallTreatment{}, FilteringCharacteristics, FilteringCriteria{}, FilteringTimeOut, ForwardCallIndicators, ForwardGVNS{}, ForwardingCondition, GapCriteria{}, GapIndicators, GapTreatment{}, GenericName{}, GenericNumbers{}, HighLayerCompatibility{}, HoldCause, initialCallSegment, INprofile{}, INServiceCompatibilityIndication{}, INServiceCompatibilityResponse, IPAvailable{}, IPRelatedInformation{}, IPRoutingAddress{}, IPSSPCapabilities{}, ISDNAccessRelatedInformation{}, LegID, leg1, LocationNumber{}, MiscCallInfo, MonitorMode, MonitoringCriteria, MonitoringTimeOut, NumberingPlan, OriginalCalledPartyID{}, ProfileIdentifier{}, QoSParameter{}, Reason{}, RedirectingPartyID{}, RedirectionInformation, RegistratorIdentifier, ReportCondition, RouteingNumber{}, RequestedInformationList{}, RequestedInformationTypeList{}, RequestedUTSIList{}, ResourceID{}, ResourceStatus, ResponseCondition, RouteCountersValue{}, RouteList{}, ScfID{}, SCIBillingChargingCharacteristics{}, SDSSinformation{}, ServiceInteractionIndicators{}, ServiceInteractionIndicatorsTwo, ServiceKey, ServiceProfileIdentifier, TDPIdentifier, TerminalType, TimerID, TimerValue, TravellingClassMark{}, TriggerData, TriggerDataIdentifier{}, TriggerDPType, Triggers{}, TriggerStatus, TriggerResults{}, TriggerType, USIInformation{}, USIServiceIndicator{}, VPNIndicator FROM IN-SSF-SCF-datatypes ssf-scf-datatypes InformationToSend{} FROM IN-SCF-SRF-datatypes scf-srf-datatypes cancelFailed, eTCFailed, improperCallerResponse, missingCustomerRecord, missingParameter, parameterOutOfRange, requestedInfoError, systemFailure, taskRefused, unavailableResource, unexpectedComponentSequence, unexpectedDataValue, unexpectedParameter, unknownLegID, unknownResource FROM IN-errortypes errortypes; -- The following three definitions are local short-hand notation for convenience. -- B1 ::= -- COMMON-BOUNDS defined in Part 1 of Recommendation Q.1248 -- B2 ::= SCF-SSF-BOUNDS defined in this part (Part 2) of Recommendation Q.1248 -- B3 ::= SCF-SRF-BOUNDS defined in Part 3 of Recommendation Q.1248 -- Operations and Arguments: activateServiceFiltering OPERATION ::= { ARGUMENT ActivateServiceFilteringArg {b1, b2, b3} RETURN RESULT TRUE ERRORS {missingParameter | parameterOutOfRange | systemFailure | taskRefused | unexpectedComponentSequence | unexpectedParameter} CODE opcode-activateServiceFiltering } -- Direction: SCF -> SSF, Timer: Tasf -- When receiving this operation, the SSF handles calls to destination in a specified manner -- without sending queries for every detected call. It is used for example for providing -- televoting or mass calling services. Simple registration functionality (counters) and -- announcement control may be located at the SSF. The operation initializes the specified -- counters in the SSF. ActivateServiceFilteringArg ::= SEQUENCE { filteredCallTreatment [0] FilteredCallTreatment{b2, b3}, filteringCharacteristics [1] FilteringCharacteristics, filteringTimeOut [2] FilteringTimeOut, filteringCriteria [3] FilteringCriteria{b2}, startTime [4] DateAndTime OPTIONAL, extensions [5] Extensions{b1} OPTIONAL, ... } activityTest OPERATION ::= { RETURN RESULT TRUE ALWAYS RESPONDS FALSE CODE opcode-activityTest } -- Direction: SCF -> SSF or SSF-> SCF, Timer: Tat -- This operation is used to check for the continued existence of a relationship between the SCF -- and SSF. If the relationship is still in existence, then the SSF will respond. If no reply is -- received, then the SCF will assume that the SSF has failed in some way and will take the -- appropriate action.. As an option, this operation may be used in the reverse direction by the -- SSF to check for the continued existence of a relationship with the SCF. analysedInformation OPERATION ::= { ARGUMENT AnalysedInformationArg {b1, b2} RETURN RESULT FALSE ERRORS {missingCustomerRecord | missingParameter | parameterOutOfRange | systemFailure | taskRefused | unexpectedComponentSequence | unexpectedDataValue | unexpectedParameter} ALWAYS RESPONDS FALSE CODE opcode-analysedInformation } -- Direction: SSF -> SCF, Timer: Tadi -- This operation is used to indicate availability of routing address and call type. (DP - -- Analysed_Info). AnalysedInformationArg ::= SEQUENCE { dpSpecificCommonParameters [0] DpSpecificCommonParameters{b1, b2}, dialledDigits [1] CalledPartyNumber{b2} OPTIONAL, callingPartyBusinessGroupID [2] CallingPartyBusinessGroupID OPTIONAL, callingPartySubaddress [3] CallingPartySubaddress{b2} OPTIONAL, callingFacilityGroup [4] FacilityGroup OPTIONAL, callingFacilityGroupMember [5] FacilityGroupMember OPTIONAL, originalCalledPartyID [6] OriginalCalledPartyID{b2} OPTIONAL, prefix [7] Digits{b2} OPTIONAL, redirectingPartyID [8] RedirectingPartyID{b2} OPTIONAL, redirectionInformation [9] RedirectionInformation OPTIONAL, routeList [10] RouteList{b2} OPTIONAL, travellingClassMark [11] TravellingClassMark{b2} OPTIONAL, extensions [12] Extensions{b1} OPTIONAL, featureCode [13] FeatureCode{b2} OPTIONAL, accessCode [14] AccessCode{b2} OPTIONAL, carrier [15] Carrier{b2} OPTIONAL, componentType [16] ComponentType OPTIONAL, component [17] Component OPTIONAL, componentCorrelationID [18] ComponentCorrelationID OPTIONAL, ... } analyseInformation OPERATION ::= { ARGUMENT AnalyseInformationArg {b1, b2} RETURN RESULT FALSE ERRORS {missingParameter | parameterOutOfRange | systemFailure | taskRefused | unexpectedComponentSequence | unexpectedDataValue | unexpectedParameter} ALWAYS RESPONDS FALSE CODE opcode-analyseInformation } -- Direction: SCF -> SSF, Timer: Tai -- This operation is used to request the SSF to perform the originating basic call processing actions -- to analyse destination information that is either collected from a calling party or provided by the SCF -- (e.g. for number translation). This includes actions to validate the information according to an office -- or customized dialing plan, and if valid, to determine call termination information, to include the called -- party address, the type of call (e.g. intra-network or inter-network), and carrier (if inter-network). -- If the called party is not served by the SSF, the SSF also determines a route index based on the called -- party address and class of service, where the route index points to a list of outgoing trunk groups. AnalyseInformationArg ::= SEQUENCE { destinationRoutingAddress [0] DestinationRoutingAddress{b2}, alertingPattern [1] AlertingPattern OPTIONAL, iSDNAccessRelatedInformation [2] ISDNAccessRelatedInformation{b2} OPTIONAL, originalCalledPartyID [3] OriginalCalledPartyID{b2} OPTIONAL, extensions [4] Extensions{b1} OPTIONAL, callingPartyNumber [5] CallingPartyNumber{b2} OPTIONAL, callingPartysCategory [6] CallingPartysCategory OPTIONAL, calledPartyNumber [7] CalledPartyNumber{b2} OPTIONAL, chargeNumber [8] ChargeNumber{b2} OPTIONAL, travellingClassMark [9] TravellingClassMark{b2} OPTIONAL, carrier [10] Carrier{b2} OPTIONAL, serviceInteractionIndicators [11] ServiceInteractionIndicators{b2} OPTIONAL, iNServiceCompatibilityResponse [12] INServiceCompatibilityResponse OPTIONAL, forwardGVNS [13] ForwardGVNS{b2} OPTIONAL, backwardGVNS [14] BackwardGVNS{b2} OPTIONAL, serviceInteractionIndicatorsTwo [15] ServiceInteractionIndicatorsTwo OPTIONAL, correlationID [16] CorrelationID{b2} OPTIONAL, scfID [17] ScfID{b2} OPTIONAL, callSegmentID [18] CallSegmentID{b2} OPTIONAL, legToBeCreated [19] LegID OPTIONAL, ... } -- OPTIONAL parameters are only provided if modifications desired to basic call processing values applyCharging OPERATION ::= { ARGUMENT ApplyChargingArg {b1, b2} RETURN RESULT FALSE ERRORS {missingParameter | unexpectedComponentSequence | unexpectedParameter | unexpectedDataValue | parameterOutOfRange | systemFailure | taskRefused | unknownLegID} ALWAYS RESPONDS FALSE CODE opcode-applyCharging } -- Direction: SCF -> SSF, Timer: Tac -- This operation is used for interacting from the SCF with the SSF charging mechanisms. -- The ApplyChargingReport operation provides the feedback from the SSF to the SCF. -- This operation is can also be used to instruct the SSF to release the call regarding some condition. ApplyChargingArg ::= SEQUENCE { aChBillingChargingCharacteristics [0] AChBillingChargingCharacteristics{b2}, partyToCharge [2] LegID OPTIONAL, extensions [3] Extensions{b1} OPTIONAL, releaseIndication [4] BOOLEAN OPTIONAL, releaseCause [5] Cause{b2} OPTIONAL, ... } -- The TAG value 1 should not be used for future extensions (used in CS-1 by regions). -- The partyToCharge parameter indicates the party in the call to which the ApplyCharging operation -- should be applied. If it is not present, then it is applied to the A-party -- The releaseIndicator shall be present and set to TRUE if the release condition is specified in the -- aCHBillingCharacteristics parameter. applyChargingReport OPERATION ::= { ARGUMENT ApplyChargingReportArg {b2} RETURN RESULT FALSE ERRORS {missingParameter | unexpectedComponentSequence | unexpectedParameter | unexpectedDataValue | parameterOutOfRange | systemFailure | taskRefused} ALWAYS RESPONDS FALSE CODE opcode-applyChargingReport } -- Direction: SSF -> SCF, Timer: Tacr -- This operation is used by the SSF to report to the SCF the occurrence of a specific charging event -- as requested by the SCF using the ApplyCharging operation. ApplyChargingReportArg ::= CallResult{b2} -- Note: When the SSF sends the ApplyChargingReport operation as the last event from the Call Segment, the -- lastEventIndicator parameter is to indicate whether the event is last to the SCF and should be included -- into the CallResult parameter. assistRequestInstructions OPERATION ::= { ARGUMENT AssistRequestInstructionsArg {b1, b2} RETURN RESULT FALSE ERRORS {missingCustomerRecord | missingParameter | systemFailure | taskRefused | unexpectedComponentSequence | unexpectedDataValue | unexpectedParameter} ALWAYS RESPONDS FALSE CODE opcode-assistRequestInstructions } -- Direction: SSF -> SCF or SRF -> SCF, Timer: Tari -- This operation is used when there is an assist or a hand-off procedure and may be sent by the SSF -- or SRF to the SCF. This operation is sent by the assisting SSF to SCF, when the initiating SSF has -- set up a connection to the SRF or to the assisting SSF as a result of receiving an EstablishTemporaryConnection -- or Connect/SelectRoute operation (in the case of hand-off) from the SCF. AssistRequestInstructionsArg ::= SEQUENCE { correlationID [0] CorrelationID{b2}, iPAvailable [1] IPAvailable{b2} OPTIONAL, iPSSPCapabilities [2] IPSSPCapabilities{b2} OPTIONAL, extensions [3] Extensions{b1} OPTIONAL, ... } -- OPTIONAL denotes network operator specific use. The value of the correlationID may be the -- Called Party Number supplied by the initiating SSF. authorizeTermination OPERATION ::= { ARGUMENT AuthorizeTerminationArg {b1, b2} RETURN RESULT FALSE ERRORS {missingParameter | systemFailure | taskRefused | unexpectedComponentSequence | unexpectedDataValue | unexpectedParameter} ALWAYS RESPONDS FALSE CODE opcode-authorizeTermination } -- Direction: SCF -> SSF. Timer: Tatr -- This operation is used to request the SSF to resume terminating call processing action at the -- Authorize_Termination PIC of the call based on the information received from the SCF. AuthorizeTerminationArg ::= SEQUENCE { alertingPattern [0] AlertingPattern OPTIONAL, callingPartyNumber [1] CallingPartyNumber{b2} OPTIONAL, destinationNumberRoutingAddress [2] CalledPartyNumber{b2} OPTIONAL, displayInformation [3] DisplayInformation{b2} OPTIONAL, iSDNAccessRelatedInformation [4] ISDNAccessRelatedInformation{b2} OPTIONAL, originalCalledPartyID [5] OriginalCalledPartyID{b2} OPTIONAL, travellingClassMark [6] TravellingClassMark{b2} OPTIONAL, extensions [7] Extensions{b1} OPTIONAL, iNServiceCompatibilityResponse [8] INServiceCompatibilityResponse OPTIONAL, forwardGVNS [9] ForwardGVNS{b2} OPTIONAL, backwardGVNS [10] BackwardGVNS{b2} OPTIONAL, legID [11] LegID OPTIONAL, serviceInteractionIndicatorsTwo [12] ServiceInteractionIndicatorsTwo OPTIONAL, scfID [13] ScfID{b2} OPTIONAL, ... } -- OPTIONAL parameters are only provided if modifications are desired to basic call processing values. callFiltering OPERATION ::= { ARGUMENT CallFilteringArg {b1, b2} RETURN RESULT FALSE ERRORS {missingParameter | parameterOutOfRange | systemFailure | taskRefused | unexpectedComponentSequence | unexpectedDataValue | unexpectedParameter} ALWAYS RESPONDS FALSE CODE opcode-callFiltering } -- Direction: SCF -> SSF, Timer: Tcf -- This operation is used to allow the SCF to influence basic call gapping procedures based in the CCF by sending information from the SCF to the SSF. The SSF relays the received information transparently to the CCF. This way, the SCF can influence the rate at which call attempts are allowed through. The operation thus influences the filtering of calls, as opposed to service requests as is done by the Callgap operation. CallFilteringArg ::= SEQUENCE { destinationIndex [0] DestinationIndex{b2}, gapIndicators [1] GapIndicators, registratorIdentifier [2] RegistratorIdentifier OPTIONAL, ..., -- ..., extensions [3] Extensions{b1} OPTIONAL } -- OPTIONAL denotes network operator optional. callGap OPERATION ::= { ARGUMENT CallGapArg {b1, b2, b3} RETURN RESULT FALSE ALWAYS RESPONDS FALSE CODE opcode-callGap } -- Direction: SCF -> SSF, Timer: Tcg -- This operation is used to request the SSF to reduce the rate at which specific service requests are sent to -- the SCF. Use of this operation by the SCF to gap queries and updates at the SDF is outside the scope of this capability set . CallGapArg ::= SEQUENCE { gapCriteria [0] GapCriteria{b2}, gapIndicators [1] GapIndicators, controlType [2] ControlType OPTIONAL, gapTreatment [3] GapTreatment{b2, b3} OPTIONAL, extensions [4] Extensions{b1} OPTIONAL, ... } -- OPTIONAL denotes network operator optional. If gapTreatment is not present, the SSF will use -- a default treatment depending on network operator implementation. callInformationReport OPERATION ::= { ARGUMENT CallInformationReportArg {b1, b2} RETURN RESULT FALSE ALWAYS RESPONDS FALSE CODE opcode-callInformationReport } -- Direction: SSF -> SCF, Timer: Tcirp -- This operation is used to send specific call information for a single call to the SCF as requested by the SCF -- in a previous CallInformationRequest. CallInformationReportArg ::= SEQUENCE { requestedInformationList [0] RequestedInformationList{b2}, correlationID [1] CorrelationID{b2} OPTIONAL, extensions [2] Extensions{b1} OPTIONAL, legID [3] LegID OPTIONAL, lastEventIndicator [4] BOOLEAN DEFAULT FALSE, ... } -- OPTIONAL denotes network operator optional. -- The lastEventIndicator parameter is set with 'TRUE' when the report is last in the Call Segment. -- In the CS-1, the lastEventIndicator should not be sent, and the meaning of DEFAULT is not applied. The SCF -- must decide whether the report is last without this parameter. callInformationRequest OPERATION ::= { ARGUMENT CallInformationRequestArg {b1, b2} RETURN RESULT FALSE ERRORS {missingParameter | parameterOutOfRange | requestedInfoError | systemFailure | taskRefused | unexpectedComponentSequence | unexpectedDataValue | unexpectedParameter | unknownLegID} ALWAYS RESPONDS FALSE CODE opcode-callInformationRequest } -- Direction: SCF -> SSF, Timer: Tcirq -- This operation is used to request the SSF to record specific information about a single call and report it to -- the SCF (with a CallInformationReport operation). CallInformationRequestArg ::= SEQUENCE { requestedInformationTypeList [0] RequestedInformationTypeList{b2}, correlationID [1] CorrelationID{b2} OPTIONAL, extensions [2] Extensions{b1} OPTIONAL, legID [3] LegID OPTIONAL, ... } -- OPTIONAL denotes network operator optional . cancel OPERATION ::= { ARGUMENT CancelArg {b2} RETURN RESULT FALSE ERRORS {cancelFailed | missingParameter | taskRefused} ALWAYS RESPONDS FALSE CODE opcode-cancel } -- Direction: SCF -> SSF, or SCF -> SRF, Timer: Tcan -- This operation cancels the correlated previous operation or all previous requests -- This operation can also be used to cancel all outstanding requests and enable the state machine (SSF) -- to go to idle. In this case the Cancel operation does not specify any specific operation to be cancelled. -- For the SCF-SRF operations that can be cancelled, refer to Part 3 of Q.1248 CancelArg ::= CHOICE { invokeID [0] InvokeID, allRequests [1] NULL, callSegmentToCancel [2] SEQUENCE {invokeID [0] InvokeID, callSegmentID [1] CallSegmentID{b2}, ...}, allRequestsForCallSegment [3] CallSegmentID{b2}, ... } -- The InvokeID has the same value as that which was used for the SCF-SRF operation, i.e. is used to identify -- the correlated previous SCF-SRF operation to be canccelled. cancelStatusReportRequest OPERATION ::= { ARGUMENT CancelStatusReportRequestArg {b1, b2} RETURN RESULT FALSE ERRORS {cancelFailed | missingParameter | taskRefused} ALWAYS RESPONDS FALSE CODE opcode-cancelStatusReportRequest } -- Direction: SCF -> SSF, Timer: Tcsr -- This operation cancels the following processes: RequestFirstStatusMatchReport and -- RequestEveryStatusChangeReport. CancelStatusReportRequestArg ::= SEQUENCE { resourceID [0] ResourceID{b2} OPTIONAL, extensions [1] Extensions{b1} OPTIONAL, ... } collectedInformation OPERATION ::= { ARGUMENT CollectedInformationArg {b1, b2} RETURN RESULT FALSE ERRORS {missingCustomerRecord | missingParameter | systemFailure | taskRefused | unexpectedComponentSequence | unexpectedDataValue | unexpectedParameter} ALWAYS RESPONDS FALSE CODE opcode-collectedInformation } -- Direction: SSF -> SCF, Timer: Tcdi -- This operation is used to indicate availability of complete initial information package/dialing string from -- originating party. (This event may have already occurred in the case of en bloc signaling, in which case -- the waiting duration in this PIC is zero.) (DP - Collected_Info CollectedInformationArg ::= SEQUENCE { dpSpecificCommonParameters [0] DpSpecificCommonParameters{b1, b2}, dialledDigits [1] CalledPartyNumber{b2} OPTIONAL, callingPartyBusinessGroupID [2] CallingPartyBusinessGroupID OPTIONAL, callingPartySubaddress [3] CallingPartySubaddress{b2} OPTIONAL, callingFacilityGroup [4] FacilityGroup OPTIONAL, callingFacilityGroupMember [5] FacilityGroupMember OPTIONAL, originalCalledPartyID [6] OriginalCalledPartyID{b2} OPTIONAL, prefix [7] Digits{b2} OPTIONAL, redirectingPartyID [8] RedirectingPartyID{b2} OPTIONAL, redirectionInformation [9] RedirectionInformation OPTIONAL, travellingClassMark [10] TravellingClassMark{b2} OPTIONAL, extensions [11] Extensions{b1} OPTIONAL, featureCode [12] FeatureCode{b2} OPTIONAL, accessCode [13] AccessCode{b2} OPTIONAL, carrier [14] Carrier{b2} OPTIONAL, componentType [15] ComponentType OPTIONAL, component [16] Component OPTIONAL, componentCorrelationID [17] ComponentCorrelationID OPTIONAL, ... } collectInformation OPERATION ::= { ARGUMENT CollectInformationArg {b1, b2} OPTIONAL TRUE RETURN RESULT FALSE ERRORS {missingParameter | parameterOutOfRange | systemFailure | taskRefused | unexpectedComponentSequence | unexpectedDataValue | unexpectedParameter} ALWAYS RESPONDS FALSE CODE opcode-collectInformation } -- Direction: SCF -> SSF, Timer: Tci -- This operation is used to request the SSF to perform the originating basic call processing actions to prompt -- a calling party for destination information, then collect destination information according to a specified -- numbering plan (e.g. for virtual private networks). CollectInformationArg ::= SEQUENCE { alertingPattern [0] AlertingPattern OPTIONAL, numberingPlan [1] NumberingPlan OPTIONAL, originalCalledPartyID [2] OriginalCalledPartyID{b2} OPTIONAL, travellingClassMark [3] TravellingClassMark{b2} OPTIONAL, extensions [4] Extensions{b1} OPTIONAL, callingPartyNumber [5] CallingPartyNumber{b2} OPTIONAL, dialledDigits [6] CalledPartyNumber{b2} OPTIONAL, serviceInteractionIndicators [7] ServiceInteractionIndicators{b2} OPTIONAL, iNServiceCompatibilityResponse [8] INServiceCompatibilityResponse OPTIONAL, forwardGVNS [9] ForwardGVNS{b2} OPTIONAL, backwardGVNS [10] BackwardGVNS{b2} OPTIONAL, serviceInteractionIndicatorsTwo [11] ServiceInteractionIndicatorsTwo OPTIONAL, callSegmentID [12] CallSegmentID{b2} OPTIONAL, legToBeCreated [13] LegID OPTIONAL, ... } connect OPERATION ::= { ARGUMENT ConnectArg {b1, b2} RETURN RESULT FALSE ERRORS {missingParameter | parameterOutOfRange | systemFailure | taskRefused | unexpectedComponentSequence | unexpectedDataValue | unexpectedParameter} ALWAYS RESPONDS FALSE CODE opcode-connect } -- Direction: SCF -> SSF, Timer: Tcon -- This operation is used to request the SSF to perform the call processing actions to route or forward a call to -- a specified destination. To do so, the SSF may or may not use destination information from the calling party -- (e.g. dialed digits) and existing call setup information (e.g. route index to a list of trunk groups), depending on -- the information provided by the SCF. -- When address information is only included in the Connect operation, call processing resumes at PIC3 in -- the O-BCSM. -- When address information and routing information is included, call processing resumes at PIC4. ConnectArg ::= SEQUENCE { destinationRoutingAddress [0] DestinationRoutingAddress{b2}, alertingPattern [1] AlertingPattern OPTIONAL, correlationID [2] CorrelationID{b2} OPTIONAL, cutAndPaste [3] CutAndPaste OPTIONAL, forwardingCondition [4] ForwardingCondition OPTIONAL, iSDNAccessRelatedInformation [5] ISDNAccessRelatedInformation{b2} OPTIONAL, originalCalledPartyID [6] OriginalCalledPartyID{b2} OPTIONAL, routeList [7] RouteList{b2} OPTIONAL, -- maximum number of routes is limited to 3 scfID [8] ScfID{b2} OPTIONAL, travellingClassMark [9] TravellingClassMark{b2} OPTIONAL, extensions [10] Extensions{b1} OPTIONAL, carrier [11] Carrier{b2} OPTIONAL, serviceInteractionIndicators [26] ServiceInteractionIndicators{b2} OPTIONAL, callingPartyNumber [27] CallingPartyNumber{b2} OPTIONAL, callingPartysCategory [28] CallingPartysCategory OPTIONAL, redirectingPartyID [29] RedirectingPartyID{b2} OPTIONAL, redirectionInformation [30] RedirectionInformation OPTIONAL, displayInformation [12] DisplayInformation{b2} OPTIONAL, forwardCallIndicators [13] ForwardCallIndicators OPTIONAL, genericNumbers [14] GenericNumbers{b2} OPTIONAL, serviceInteractionIndicatorsTwo [15] ServiceInteractionIndicatorsTwo OPTIONAL, iNServiceCompatibilityResponse [16] INServiceCompatibilityResponse OPTIONAL, forwardGVNS [17] ForwardGVNS{b2} OPTIONAL, backwardGVNS [18] BackwardGVNS{b2} OPTIONAL, chargeNumber [19] ChargeNumber{b2} OPTIONAL, callSegmentID [20] CallSegmentID{b2} OPTIONAL, legToBeCreated [21] LegID OPTIONAL, sDSSinformation [22] SDSSinformation{b2} OPTIONAL, calledDirectoryNumber [23] CalledDirectoryNumber{b2} OPTIONAL, bearerCapability [24] BearerCapability{b2} OPTIONAL, calledPartySubaddress [60] CalledPartySubaddress{b2} OPTIONAL, connectionIdentifier [61] ConnectionIdentifier{b2} OPTIONAL, genericIdentifier [62] GenericIdentifier{b2} OPTIONAL, qOSParameter [63] QoSParameter{b2} OPTIONAL, bISDNParameters [64] BISDNParameters{b2} OPTIONAL, ..., cug-Interlock [31] CUG-Interlock OPTIONAL, cug-OutgoingAccess [32] NULL OPTIONAL, ipRelatedInformation [33] IPRelatedInformation{b2} OPTIONAL } -- OPTIONAL parameters are only provided if modifications desired to basic call processing values connectToResource OPERATION ::= { ARGUMENT ConnectToResourceArg {b1, b2} RETURN RESULT FALSE ERRORS {missingParameter | systemFailure | taskRefused | unexpectedComponentSequence | unexpectedDataValue | unexpectedParameter | unknownLegID} ALWAYS RESPONDS FALSE CODE opcode-connectToResource } -- Direction: SCF -> SSF, Timer: Tctr -- This operation is used to connect a call from the SSP to the physical entity containing the SRF. ConnectToResourceArg ::= SEQUENCE { resourceAddress CHOICE {ipRoutingAddress [0] IPRoutingAddress{b2}, legID [1] LegID, ipAddressAndLegID [2] SEQUENCE {ipRoutingAddress [0] IPRoutingAddress{b2}, legID [1] LegID, ...}, none [3] NULL, callSegmentID [5] CallSegmentID{b2}, ipAddressAndCallSegment [6] SEQUENCE {ipRoutingAddress [0] IPRoutingAddress{b2}, callSegmentID [1] CallSegmentID{b2}, ...}}, extensions [4] Extensions{b1} OPTIONAL, serviceInteractionIndicators [30] ServiceInteractionIndicators{b2} OPTIONAL, serviceInteractionIndicatorsTwo [7] ServiceInteractionIndicatorsTwo OPTIONAL, uSIServiceIndicator [35] USIServiceIndicator{b2} OPTIONAL, uSIInformation [36] USIInformation{b2} OPTIONAL, ... } continue OPERATION ::= { RETURN RESULT FALSE ALWAYS RESPONDS FALSE CODE opcode-continue } -- Direction: SCF -> SSF, Timer: Tcue -- This operation is used to request the SSF to proceed with call processing at the DP at which it -- previously suspended call processing to await SCF instructions (i.e. proceed to the next point -- in call in the BCSM). The SSF continues call processing without substituting new data from SCF. -- This operation is not valid for a single call segment CSA with more than 2 legs or a multi call segment CSA. continueWithArgument OPERATION ::= { ARGUMENT ContinueWithArgumentArg {b1, b2} RETURN RESULT FALSE ERRORS {missingParameter | unexpectedComponentSequence | unexpectedParameter | unexpectedDataValue | unknownLegID} ALWAYS RESPONDS FALSE CODE opcode-continueWithArgument } -- Direction: SCF -> SSF, Timer: Tcwa -- This operation is used to request the SSF to proceed with call processing at the DP a which it previously -- suspended call processing to await SCF instructions. -- It is also used to provide additional service related information to a User (Called Party or Calling Party) whilst -- the call processing proceeds. ContinueWithArgumentArg ::= SEQUENCE { legorCSID CHOICE {legID [0] LegID, csID [9] CallSegmentID{b2}} --DEFAULT legID:sendingSideID:leg1 --, alertingPattern [1] AlertingPattern OPTIONAL, genericName [2] GenericName{b2} OPTIONAL, iNServiceCompatibilityResponse [3] INServiceCompatibilityResponse OPTIONAL, forwardGVNS [4] ForwardGVNS{b2} OPTIONAL, backwardGVNS [5] BackwardGVNS{b2} OPTIONAL, extensions [6] Extensions{b1} OPTIONAL, serviceInteractionIndicatorsTwo [7] ServiceInteractionIndicatorsTwo OPTIONAL, sDSSinformation [8] SDSSinformation{b2} OPTIONAL, connectionIdentifier [60] ConnectionIdentifier{b2} OPTIONAL, ..., iSDNAccessRelatedInformation [19] ISDNAccessRelatedInformation{b2} OPTIONAL, originalCalledPartyID [10] OriginalCalledPartyID{b2} OPTIONAL, callingPartyNumber [11] CallingPartyNumber{b2} OPTIONAL, callingPartysCategory [12] CallingPartysCategory OPTIONAL, redirectingPartyID [13] RedirectingPartyID{b2} OPTIONAL, redirectionInformation [14] RedirectionInformation OPTIONAL, forwardCallIndicators [15] ForwardCallIndicators OPTIONAL, genericNumbers [16] GenericNumbers{b2} OPTIONAL, cug-Interlock [17] CUG-Interlock OPTIONAL, cug-OutgoingAccess [18] NULL OPTIONAL, ipRelationInformation [20] IPRelatedInformation{b2} OPTIONAL } -- OPTIONAL parameters are only provided if modifications desired to basic call processing values createCallSegmentAssociation OPERATION ::= { ARGUMENT CreateCallSegmentAssociationArg {b1} OPTIONAL TRUE RESULT CreateCallSegmentAssociationResultArg {b1, b2} ERRORS {missingParameter | systemFailure | taskRefused | unexpectedComponentSequence | unexpectedDataValue | unexpectedParameter} CODE opcode-createCallSegmentAssociation } -- Direction SCF -> SSF, Timer Tcsa -- This operation is used to create a new CSA. The new CSA will not contain any Call Segments after creation. -- The SSF is responsible for specifying a new CSA identifier for the created CSA which is unique within -- the SSF. CreateCallSegmentAssociationArg ::= SEQUENCE { extensions [0] Extensions{b1} OPTIONAL, ... } CreateCallSegmentAssociationResultArg ::= SEQUENCE { newCallSegmentAssociation [0] CSAID{b2}, extensions [1] Extensions{b1} OPTIONAL, ... } createOrRemoveTriggerData OPERATION ::= { ARGUMENT CreateOrRemoveTriggerDataArg {b1, b2, b3} RESULT CreateOrRemoveTriggerDataResultArg {b1, b2} ERRORS {missingParameter | missingCustomerRecord | parameterOutOfRange | systemFailure | taskRefused | unexpectedComponentSequence | unexpectedDataValue | unexpectedParameter} CODE opcode-createOrRemoveTriggerData } -- Direction: SCF -> SSF, Class 1, Timer: Tcrt -- This trigger management operation is used by the SCF outside the context of a call to create a new -- trigger detection point in the CCF/SSF by downloading trigger data -- (e.g. triggering criteria, ServiceKey, SCF address,....) -- or to remove an existing trigger. CreateOrRemoveTriggerDataArg ::= SEQUENCE { createOrRemove [0] CreateOrRemoveIndicator DEFAULT create, dPName [1] EventTypeBCSM OPTIONAL, triggerDPType [2] TriggerDPType DEFAULT tdp-r, serviceKey [3] ServiceKey OPTIONAL, profile [4] ProfileIdentifier{b2} OPTIONAL, triggerData [5] TriggerData OPTIONAL, defaultFaultHandling [6] DefaultFaultHandling{b2, b3} OPTIONAL, tDPIdentifier [7] TDPIdentifier{b2} OPTIONAL, ..., -- ..., extensions [30] Extensions{b1} OPTIONAL } CreateOrRemoveTriggerDataResultArg ::= SEQUENCE { triggerStatus [0] TriggerStatus, tDPIdentifier [1] TDPIdentifier{b2}, registratorIdentifier [2] RegistratorIdentifier OPTIONAL, ..., -- ..., extensions [30] Extensions{b1} OPTIONAL } disconnectForwardConnection OPERATION ::= { RETURN RESULT FALSE ERRORS {systemFailure | taskRefused | unexpectedComponentSequence} ALWAYS RESPONDS FALSE CODE opcode-disconnectForwardConnection } -- Direction: SCF -> SSF, Timer: Tdfc -- This operation is used to disconnect a forward temporary connection or a connection to a resource. disconnectForwardConnectionWithArgument OPERATION ::= { ARGUMENT DisconnectForwardConnectionWithArgumentArg {b1, b2} RETURN RESULT FALSE ERRORS {missingParameter | systemFailure | taskRefused | unexpectedComponentSequence | unexpectedDataValue | unexpectedParameter | unknownLegID} ALWAYS RESPONDS FALSE CODE opcode-dFCWithArgument } -- Direction: SCF -> SSF, Timer: Tdfcwa -- This operation is used to disconnect a forward temporary connection or a connection to a resource. DisconnectForwardConnectionWithArgumentArg ::= SEQUENCE { partyToDisconnect CHOICE {legID [0] LegID, callSegmentID [1] CallSegmentID{b2}}, extensions [2] Extensions{b1} OPTIONAL, uSIServiceIndicator [3] USIServiceIndicator{b2} OPTIONAL, uSIInformation [4] USIInformation{b2} OPTIONAL, ... } disconnectLeg OPERATION ::= { ARGUMENT DisconnectLegArg {b1, b2} RETURN RESULT TRUE ERRORS {missingParameter | systemFailure | taskRefused | unexpectedComponentSequence | unexpectedDataValue | unexpectedParameter | unknownLegID} CODE opcode-disconnectLeg } -- Direction: SCF -> SSF. Timer: T dl -- This operation is issued by the SCF to release a specific leg associated with the call and retain any -- other legs not specified in the DisconnectLeg. Any leg may be disconnected, including the controlling -- leg, without completely releasing all legs. DisconnectLegArg ::= SEQUENCE { legToBeReleased [0] LegID, releaseCause [1] Cause{b2} OPTIONAL, extensions [2] Extensions{b1} OPTIONAL, ... } entityReleased OPERATION ::= { ARGUMENT EntityReleasedArg {b2} RETURN RESULT FALSE ALWAYS RESPONDS FALSE CODE opcode-entityReleased } -- Direction SSF -> SCF, Timer: Ter -- This operation is used by SSF to inform the SCF of an error/exception EntityReleasedArg ::= CHOICE { cSFailure [0] SEQUENCE {callSegmentID [0] CallSegmentID{b2}, reason [1] Reason{b2} OPTIONAL, cause [2] Cause{b2} OPTIONAL, ...}, bCSMFailure [1] SEQUENCE {legID [0] LegID, reason [1] Reason{b2} OPTIONAL, cause [2] Cause{b2} OPTIONAL, ...} } establishTemporaryConnection OPERATION ::= { ARGUMENT EstablishTemporaryConnectionArg {b1, b2} RETURN RESULT FALSE ERRORS {eTCFailed | missingParameter | systemFailure | taskRefused | unexpectedComponentSequence | unexpectedDataValue | unexpectedParameter | unknownLegID} ALWAYS RESPONDS FALSE CODE opcode-establishTemporaryConnection } -- Direction: SCF -> SSF, Timer: Tetc -- This operation is used to create a connection to a resource for a limited period of time -- (e.g. to play an announcement, to collect user information); it implies the use of the assist -- procedure. EstablishTemporaryConnectionArg ::= SEQUENCE { assistingSSPIPRoutingAddress [0] AssistingSSPIPRoutingAddress{b2}, correlationID [1] CorrelationID{b2} OPTIONAL, partyToConnect CHOICE {legID [2] LegID, callSegmentID [7] CallSegmentID{b2}} OPTIONAL, scfID [3] ScfID{b2} OPTIONAL, extensions [4] Extensions{b1} OPTIONAL, carrier [5] Carrier{b2} OPTIONAL, serviceInteractionIndicators [30] ServiceInteractionIndicators{b2} OPTIONAL, serviceInteractionIndicatorsTwo [6] ServiceInteractionIndicatorsTwo OPTIONAL, ... } -- OPTIONAL parameters are only provided if modifications desired to basic call processing values eventNotificationCharging OPERATION ::= { ARGUMENT EventNotificationChargingArg {b1, b2} RETURN RESULT FALSE ALWAYS RESPONDS FALSE CODE opcode-eventNotificationCharging } -- Direction: SSF -> SCF, Timer: Tenc -- This operation is used by the SSF to report to the SCF the occurence of a specific charging event -- type as previously requested by the SCF in a RequestNotificationChargingEvent operation. EventNotificationChargingArg ::= SEQUENCE { eventTypeCharging [0] EventTypeCharging{b2}, eventSpecificInformationCharging [1] EventSpecificInformationCharging{b2} OPTIONAL, legID [2] LegID OPTIONAL, extensions [3] Extensions{b1} OPTIONAL, monitorMode [30] MonitorMode DEFAULT notifyAndContinue, ... } -- OPTIONAL denotes network operator specific use. eventReportBCSM OPERATION ::= { ARGUMENT EventReportBCSMArg {b1, b2} RETURN RESULT FALSE ALWAYS RESPONDS FALSE CODE opcode-eventReportBCSM } -- Direction: SSF -> SCF, Timer: Terb -- This operation is used to notify the SCF of a call-related event (e.g. BCSM events such as busy or -- no answer) previously requested by the SCF in a RequestReportBCSMEvent operation. EventReportBCSMArg ::= SEQUENCE { eventTypeBCSM [0] EventTypeBCSM, bcsmEventCorrelationID [1] CorrelationID{b2} OPTIONAL, eventSpecificInformationBCSM [2] EventSpecificInformationBCSM{b2} OPTIONAL, legID [3] LegID OPTIONAL, miscCallInfo [4] MiscCallInfo DEFAULT {messageType request}, extensions [5] Extensions{b1} OPTIONAL, componentType [6] ComponentType OPTIONAL, component [7] Component OPTIONAL, componentCorrelationID [8] ComponentCorrelationID OPTIONAL, ... } eventReportFacility OPERATION ::= { ARGUMENT EventReportFacilityArg {b1} RETURN RESULT FALSE ALWAYS RESPONDS FALSE CODE opcode-eventReportFacility } -- SSF->SCF, Timer: Terf -- This operation is issued by the SSF to report the SCF the event, that was previously requested by the -- SCF, the CCF/SSF receives a DSS1 message which contains a FACILITY IE. Criteria for the report, like -- reception of the ReturnResult which is specified with ComponentType, is optionally checked -- before issuing this operation. EventReportFacilityArg ::= SEQUENCE { componentType [0] ComponentType OPTIONAL, component [1] Component OPTIONAL, legID [2] LegID OPTIONAL, componentCorrelationID [3] ComponentCorrelationID OPTIONAL, extensions [4] Extensions{b1} OPTIONAL, ... } facilitySelectedAndAvailable OPERATION ::= { ARGUMENT FacilitySelectedAndAvailableArg {b1, b2} RETURN RESULT FALSE ERRORS {missingCustomerRecord | missingParameter | systemFailure | taskRefused | unexpectedComponentSequence | unexpectedDataValue | unexpectedParameter} ALWAYS RESPONDS FALSE CODE opcode-facilitySelectedAndAvailable } -- Direction: SSF -> SCF. Timer: Tfs -- This operation is used for indication of a call termination attempt from the terminating half BCSM. (DP - -- Facility_Selected_And_Available). FacilitySelectedAndAvailableArg ::= SEQUENCE { dpSpecificCommonParameters [0] DpSpecificCommonParameters{b1, b2}, calledPartyBusinessGroupID [1] CalledPartyBusinessGroupID OPTIONAL, calledPartySubaddress [2] CalledPartySubaddress{b2} OPTIONAL, callingPartyBusinessGroupID [3] CallingPartyBusinessGroupID OPTIONAL, callingPartyNumber [4] CallingPartyNumber{b2} OPTIONAL, originalCalledPartyID [5] OriginalCalledPartyID{b2} OPTIONAL, redirectingPartyID [6] RedirectingPartyID{b2} OPTIONAL, redirectionInformation [7] RedirectionInformation OPTIONAL, routeList [8] RouteList{b2} OPTIONAL, travellingClassMark [9] TravellingClassMark{b2} OPTIONAL, extensions [10] Extensions{b1} OPTIONAL, componentType [11] ComponentType OPTIONAL, component [12] Component OPTIONAL, componentCorrelationID [13] ComponentCorrelationID OPTIONAL, ... } furnishChargingInformation OPERATION ::= { ARGUMENT FurnishChargingInformationArg {b2} RETURN RESULT FALSE ERRORS {missingParameter | taskRefused | unexpectedComponentSequence | unexpectedDataValue | unexpectedParameter} ALWAYS RESPONDS FALSE CODE opcode-furnishChargingInformation } -- Direction: SCF -> SSF, Timer: Tfci -- This operation is used to request the SSF to generate, register a call record or to include some information -- in the default call record. The registered call record is intended for off line charging of the call. FurnishChargingInformationArg ::= FCIBillingChargingCharacteristics{b2} holdCallInNetwork OPERATION ::= { ARGUMENT HoldCallInNetworkArg RETURN RESULT FALSE ERRORS {missingParameter | systemFailure | taskRefused | unexpectedComponentSequence | unexpectedDataValue | unexpectedParameter} ALWAYS RESPONDS FALSE CODE opcode-holdCallInNetwork } -- Direction: SCF -> SSF, Timer: Thcn -- This operation is used to provide the capability of queueing a call during the setup phase (e.g. to provide -- a call completion to busy, the call would be queued until the destination becomes free). HoldCallInNetworkArg ::= CHOICE { holdcause [0] HoldCause, empty [1] NULL } -- holdcause is optional and denotes network operator specific use. initialDP OPERATION ::= { ARGUMENT InitialDPArg {b1, b2} RETURN RESULT FALSE ERRORS {missingCustomerRecord | missingParameter | parameterOutOfRange | systemFailure | taskRefused | unexpectedComponentSequence | unexpectedDataValue | unexpectedParameter} ALWAYS RESPONDS FALSE CODE opcode-initialDP } -- Direction: SSF -> SCF, Timer: Tidp -- This operation is used after a TDP to indicate request for service. InitialDPArg ::= SEQUENCE { serviceKey [0] ServiceKey OPTIONAL, dialledDigits [1] CalledPartyNumber{b2} OPTIONAL, calledPartyNumber [2] CalledPartyNumber{b2} OPTIONAL, callingPartyNumber [3] CallingPartyNumber{b2} OPTIONAL, callingPartyBusinessGroupID [4] CallingPartyBusinessGroupID OPTIONAL, callingPartysCategory [5] CallingPartysCategory OPTIONAL, callingPartySubaddress [6] CallingPartySubaddress{b2} OPTIONAL, cGEncountered [7] CGEncountered OPTIONAL, iPSSPCapabilities [8] IPSSPCapabilities{b2} OPTIONAL, iPAvailable [9] IPAvailable{b2} OPTIONAL, locationNumber [10] LocationNumber{b2} OPTIONAL, miscCallInfo [11] MiscCallInfo OPTIONAL, originalCalledPartyID [12] OriginalCalledPartyID{b2} OPTIONAL, serviceProfileIdentifier [13] ServiceProfileIdentifier OPTIONAL, terminalType [14] TerminalType OPTIONAL, extensions [15] Extensions{b1} OPTIONAL, triggerType [16] TriggerType OPTIONAL, highLayerCompatibility [23] HighLayerCompatibility{b2} OPTIONAL, serviceInteractionIndicators [24] ServiceInteractionIndicators{b2} OPTIONAL, additionalCallingPartyNumber [25] AdditionalCallingPartyNumber{b2} OPTIONAL, forwardCallIndicators [26] ForwardCallIndicators OPTIONAL, bearerCapability [27] BearerCapability{b2} OPTIONAL, eventTypeBCSM [28] EventTypeBCSM OPTIONAL, redirectingPartyID [29] RedirectingPartyID{b2} OPTIONAL, redirectionInformation [30] RedirectionInformation OPTIONAL, cause [17] Cause{b2} OPTIONAL, componentType [18] ComponentType OPTIONAL, component [19] Component OPTIONAL, componentCorrelationID [20] ComponentCorrelationID OPTIONAL, iSDNAccessRelatedInformation [21] ISDNAccessRelatedInformation{b2} OPTIONAL, iNServiceCompatibilityIndication [22] INServiceCompatibilityIndication{b2} OPTIONAL, genericNumbers [31] GenericNumbers{b2} OPTIONAL, serviceInteractionIndicatorsTwo [32] ServiceInteractionIndicatorsTwo OPTIONAL, forwardGVNS [33] ForwardGVNS{b2} OPTIONAL, createdCallSegmentAssociation [34] CSAID{b2} OPTIONAL, uSIServiceIndicator [35] USIServiceIndicator{b2} OPTIONAL, uSIInformation [36] USIInformation{b2} OPTIONAL, carrier [37] Carrier{b2} OPTIONAL, cCSS [38] CCSS OPTIONAL, vPNIndicator [39] VPNIndicator OPTIONAL, cNInfo [40] CNInfo{b2} OPTIONAL, callReference [41] CallReference{b2} OPTIONAL, routeingNumber [42] RouteingNumber{b2} OPTIONAL, callingGeodeticLocation [43] CallingGeodeticLocation{b2} OPTIONAL, calledPartySubaddress [60] CalledPartySubaddress{b2} OPTIONAL, connectionIdentifier [61] ConnectionIdentifier{b2} OPTIONAL, genericIdentifier [62] GenericIdentifier{b2} OPTIONAL, qOSParameter [63] QoSParameter{b2} OPTIONAL, bISDNParameters [64] BISDNParameters{b2} OPTIONAL, ..., globalCallReference [44] GlobalCallReference{b2} OPTIONAL, cug-Index [45] CUG-Index OPTIONAL, cug-Interlock [46] CUG-Interlock OPTIONAL, cug-OutgoingAccess [47] NULL OPTIONAL, ipRelatedInformation [48] IPRelatedInformation{b2} OPTIONAL } -- OPTIONAL for iPSSPCapabilities, iPAvailable, cGEncountered, and miscCallInfo denotes network -- operator specific use. -- OPTIONAL for terminalType indicates that this parameter applies only at originating or terminating -- local exchanges if the SSF has this information. initiateCallAttempt OPERATION ::= { ARGUMENT InitiateCallAttemptArg {b1, b2} RETURN RESULT FALSE ERRORS {missingParameter | parameterOutOfRange | systemFailure | taskRefused | unexpectedComponentSequence | unexpectedDataValue | unexpectedParameter} ALWAYS RESPONDS FALSE CODE opcode-initiateCallAttempt } -- Direction: SCF -> SSF, Timer: Tica -- This operation is used to request the SSF to create a new call to one call party using address -- information provided by the SCF. InitiateCallAttemptArg ::= SEQUENCE { destinationRoutingAddress [0] DestinationRoutingAddress{b2}, alertingPattern [1] AlertingPattern OPTIONAL, iSDNAccessRelatedInformation [2] ISDNAccessRelatedInformation{b2} OPTIONAL, travellingClassMark [3] TravellingClassMark{b2} OPTIONAL, extensions [4] Extensions{b1} OPTIONAL, serviceInteractionIndicators [29] ServiceInteractionIndicators{b2} OPTIONAL, callingPartyNumber [30] CallingPartyNumber{b2} OPTIONAL, legToBeCreated [5] LegID --DEFAULT sendingSideID:leg1--, newCallSegment [6] CallSegmentID{b2} DEFAULT initialCallSegment, iNServiceCompatibilityResponse [7] INServiceCompatibilityResponse OPTIONAL, serviceInteractionIndicatorsTwo [8] ServiceInteractionIndicatorsTwo OPTIONAL, carrier [9] Carrier{b2} OPTIONAL, correlationID [10] CorrelationID{b2} OPTIONAL, scfID [11] ScfID{b2} OPTIONAL, callReference [12] CallReference{b2} OPTIONAL, calledDirectoryNumber [13] CalledDirectoryNumber{b2} OPTIONAL, bearerCapability [60] BearerCapability{b2} OPTIONAL, calledPartySubaddress [61] CalledPartySubaddress{b2} OPTIONAL, connectionIdentifier [62] ConnectionIdentifier{b2} OPTIONAL, genericIdentifier [63] GenericIdentifier{b2} OPTIONAL, qOSParameter [64] QoSParameter{b2} OPTIONAL, bISDNParameters [65] BISDNParameters{b2} OPTIONAL, ..., originalCalledPartyID [14] OriginalCalledPartyID{b2} OPTIONAL, callingPartysCategory [15] CallingPartysCategory OPTIONAL, redirectingPartyID [16] RedirectingPartyID{b2} OPTIONAL, redirectionInformation [17] RedirectionInformation OPTIONAL, displayInformation [18] DisplayInformation{b2} OPTIONAL, forwardCallIndicators [19] ForwardCallIndicators OPTIONAL, genericNumbers [20] GenericNumbers{b2} OPTIONAL, forwardGVNS [21] ForwardGVNS{b2} OPTIONAL, globalCallReference [23] GlobalCallReference{b2} OPTIONAL, -- syntax to be confirmed cug-Interlock [24] CUG-Interlock OPTIONAL, cug-OutgoingAccess [25] NULL OPTIONAL, incomingSignallingBufferCopy [26] BOOLEAN DEFAULT FALSE, ipRelatedInformation [27] IPRelatedInformation{b2} OPTIONAL } -- OPTIONAL parameters are only provided if modifications desired to basic call processing values manageTriggerData OPERATION ::= { ARGUMENT ManageTriggerDataArg {b1, b2} RESULT ManageTriggerDataResultArg {b1, b2} ERRORS {missingParameter | parameterOutOfRange | systemFailure | taskRefused | unexpectedComponentSequence | unexpectedDataValue | unexpectedParameter} CODE opcode-manageTriggerData } -- Direction: SCF -> SSF, Class 1, Timer: Tmtd -- This trigger management operation is used outside the context of a call to activate, deactivate or retrieve -- the status of one or several trigger detection point linked to a subscriber profile known at the switch, -- e.g. related to an access line ( i.e. an individual trigger). ManageTriggerDataArg ::= SEQUENCE { actionIndicator [0] ActionIndicator, triggerDataIdentifier CHOICE {profileAndDP [1] TriggerDataIdentifier{b1, b2}, -- one trigger profile [5] ProfileIdentifier{b2}}, registratorIdentifier [2] RegistratorIdentifier OPTIONAL, extensions [3] Extensions{b1} OPTIONAL, tDPIdentifier [4] TDPIdentifier{b2} OPTIONAL, ... } ManageTriggerDataResultArg ::= CHOICE { oneTriggerResult SEQUENCE {actionPerformed [0] ActionPerformed, extensions [1] Extensions{b1} OPTIONAL, ...}, severalTriggerResult [1] SEQUENCE {results [0] TriggerResults{b2}, extensions [1] Extensions{b1} OPTIONAL, ...} } mergeCallSegments OPERATION ::= { ARGUMENT MergeCallSegmentsArg {b1, b2} RETURN RESULT TRUE ERRORS {missingParameter | systemFailure | taskRefused | unexpectedComponentSequence | unexpectedDataValue | unexpectedParameter} CODE opcode-mergeCallSegments } -- Direction: SCF -> SSF. Timer: T mc -- This operation is issued by the SCF to merge two associated CSs , into one CS . MergeCallSegmentsArg ::= SEQUENCE { sourceCallSegment [0] CallSegmentID{b2}, targetCallSegment [1] CallSegmentID{b2} DEFAULT initialCallSegment, extensions [2] Extensions{b1} OPTIONAL, ..., mergeSignallingPaths [3] NULL OPTIONAL } monitorRouteReport OPERATION ::= { ARGUMENT MonitorRouteReportArg {b1, b2} RETURN RESULT FALSE ALWAYS RESPONDS FALSE CODE opcode-monitorRouteReport } -- Direction SSF-> SCF: Timer T mrp -- This operation is used by the SSF to report the result of a route monitoring procedure. MonitorRouteReportArg ::= SEQUENCE { routeCounters [0] RouteCountersValue{b2}, correlationID [2] CorrelationID{b2}, ..., -- ..., extensions [3] Extensions{b1} OPTIONAL } monitorRouteRequest OPERATION ::= { ARGUMENT MonitorRouteRequestArg {b1, b2} RETURN RESULT TRUE ERRORS {missingParameter | systemFailure | taskRefused | unexpectedComponentSequence | unexpectedParameter} CODE opcode-monitorRouteRequest } -- Direction SCF -> SSF. Timer Tmrr -- This operationis issued by the SCF to request the SSF to monitor specified routes. MonitorRouteRequestArg ::= SEQUENCE { routeList [0] RouteList{b2}, correlationID [1] CorrelationID{b2}, monitoringCriteria [2] MonitoringCriteria, monitoringTimeout [3] MonitoringTimeOut, startTime [4] DateAndTime OPTIONAL, ..., -- ..., extensions [5] Extensions{b1} OPTIONAL } moveCallSegments OPERATION ::= { ARGUMENT MoveCallSegmentsArg {b1, b2} RETURN RESULT TRUE ERRORS {missingParameter | systemFailure | taskRefused | unexpectedComponentSequence | unexpectedDataValue | unexpectedParameter | unknownLegID} CODE opcode-moveCallSegments } -- Direction: SCF -> SSF, Timer Tmcs -- This operation moves a CS from the source CSA to the the target CSA MoveCallSegmentsArg ::= SEQUENCE { targetCallSegmentAssociation [0] CSAID{b2}, callSegments [1] SEQUENCE SIZE (1..--b2.&--numOfCSs) OF SEQUENCE {sourceCallSegment [0] CallSegmentID{b2} DEFAULT initialCallSegment, newCallSegment [1] CallSegmentID{b2}, ...}, legs [2] SEQUENCE SIZE (1..--b2.&--numOfLegs) OF SEQUENCE {sourceLeg [0] LegID, newLeg [1] LegID, ...}, extensions [3] Extensions{b1} OPTIONAL, ... } moveLeg OPERATION ::= { ARGUMENT MoveLegArg {b1, b2} RETURN RESULT TRUE ERRORS {missingParameter | systemFailure | taskRefused | unexpectedComponentSequence | unexpectedDataValue | unexpectedParameter | unknownLegID} CODE opcode-moveLeg } -- Direction : SCF ->SSF, Timer: T ml -- This operation is issued by the SCF to move a leg from one CS to another with which it is associated. MoveLegArg ::= SEQUENCE { legIDToMove [0] LegID, targetCallSegment [1] CallSegmentID{b2} DEFAULT 1, extensions [2] Extensions{b1} OPTIONAL, ..., detachSignallingPath [3] NULL OPTIONAL, -- action on source exportSignallingPath [4] NULL OPTIONAL -- action on target } oAbandon OPERATION ::= { ARGUMENT OAbandonArg {b1, b2} RETURN RESULT FALSE ERRORS {missingCustomerRecord | missingParameter | systemFailure | taskRefused | unexpectedComponentSequence | unexpectedDataValue | unexpectedParameter | unknownLegID} ALWAYS RESPONDS FALSE CODE opcode-oAbandon } -- Direction: SSF -> SCF. Timer: T ob -- This operation is issued by the SSF after detecting a valid trigger condition at the O_Abandon DP or to -- report an oAbandon event requested by the RequestReportBCSMEvent. OAbandonArg ::= SEQUENCE { dpSpecificCommonParameters [0] DpSpecificCommonParameters{b1, b2}, callSegmentID [1] CallSegmentID{b2}, releaseCause [2] Cause{b2} OPTIONAL, extensions [3] Extensions{b1} OPTIONAL, ... } -- Use of T/EDP-R is outside -- the scope of this capability set. oAnswer OPERATION ::= { ARGUMENT OAnswerArg {b1, b2} RETURN RESULT FALSE ERRORS {missingCustomerRecord | missingParameter | parameterOutOfRange | systemFailure | taskRefused | unexpectedComponentSequence | unexpectedDataValue | unexpectedParameter} ALWAYS RESPONDS FALSE CODE opcode-oAnswer } -- Direction: SSF -> SCF, Timer: Toa -- This operation is used for indication from the terminating half BCSM that the call is accepted and answered -- by terminating party (e.g. terminating party goes offhook, Q.931 Connect message received, IS-UP Answer -- message received) (DP - O_Answer). OAnswerArg ::= SEQUENCE { dpSpecificCommonParameters [0] DpSpecificCommonParameters{b1, b2}, callingPartyBusinessGroupID [1] CallingPartyBusinessGroupID OPTIONAL, callingPartySubaddress [2] CallingPartySubaddress{b2} OPTIONAL, callingFacilityGroup [3] FacilityGroup OPTIONAL, callingFacilityGroupMember [4] FacilityGroupMember OPTIONAL, originalCalledPartyID [5] OriginalCalledPartyID{b2} OPTIONAL, redirectingPartyID [6] RedirectingPartyID{b2} OPTIONAL, redirectionInformation [7] RedirectionInformation OPTIONAL, routeList [8] RouteList{b2} OPTIONAL, travellingClassMark [9] TravellingClassMark{b2} OPTIONAL, extensions [10] Extensions{b1} OPTIONAL, ... } oCalledPartyBusy OPERATION ::= { ARGUMENT OCalledPartyBusyArg {b1, b2} RETURN RESULT FALSE ERRORS {missingCustomerRecord | missingParameter | parameterOutOfRange | systemFailure | taskRefused | unexpectedComponentSequence | unexpectedDataValue | unexpectedParameter} ALWAYS RESPONDS FALSE CODE opcode-oCalledPartyBusy } -- Direction: SSF -> SCF, Timer: Tob -- This operation is used for Indication from the terminating half BCSM that the terminating party is busy -- (DP - O_Called_Party_Busy). . OCalledPartyBusyArg ::= SEQUENCE { dpSpecificCommonParameters [0] DpSpecificCommonParameters{b1, b2}, busyCause [1] Cause{b2} OPTIONAL, callingPartyBusinessGroupID [2] CallingPartyBusinessGroupID OPTIONAL, callingPartySubaddress [3] CallingPartySubaddress{b2} OPTIONAL, callingFacilityGroup [4] FacilityGroup OPTIONAL, callingFacilityGroupMember [5] FacilityGroupMember OPTIONAL, originalCalledPartyID [6] OriginalCalledPartyID{b2} OPTIONAL, prefix [7] Digits{b2} OPTIONAL, redirectingPartyID [8] RedirectingPartyID{b2} OPTIONAL, redirectionInformation [9] RedirectionInformation OPTIONAL, routeList [10] RouteList{b2} OPTIONAL, travellingClassMark [11] TravellingClassMark{b2} OPTIONAL, extensions [12] Extensions{b1} OPTIONAL, carrier [13] Carrier{b2} OPTIONAL, ... } oDisconnect OPERATION ::= { ARGUMENT ODisconnectArg {b1, b2} RETURN RESULT FALSE ERRORS {missingCustomerRecord | missingParameter | parameterOutOfRange | systemFailure | taskRefused | unexpectedComponentSequence | unexpectedDataValue | unexpectedParameter} ALWAYS RESPONDS FALSE CODE opcode-oDisconnect } -- Direction: SSF -> SCF, Timer: Tod -- This operation is used for a disconnect indication (e.g. onhook, Q.931 Disconnect message, SS7 Release message) -- is received from the originating party, or received from the terminating party via the terminating half BCSM. -- (DP - O_Disconnect). . ODisconnectArg ::= SEQUENCE { dpSpecificCommonParameters [0] DpSpecificCommonParameters{b1, b2}, callingPartyBusinessGroupID [1] CallingPartyBusinessGroupID OPTIONAL, callingPartySubaddress [2] CallingPartySubaddress{b2} OPTIONAL, callingFacilityGroup [3] FacilityGroup OPTIONAL, callingFacilityGroupMember [4] FacilityGroupMember OPTIONAL, releaseCause [5] Cause{b2} OPTIONAL, routeList [6] RouteList{b2} OPTIONAL, extensions [7] Extensions{b1} OPTIONAL, carrier [8] Carrier{b2} OPTIONAL, connectTime [9] Integer4 OPTIONAL, componentType [10] ComponentType OPTIONAL, component [11] Component OPTIONAL, componentCorrelationID [12] ComponentCorrelationID OPTIONAL, ... } oMidCall OPERATION ::= { ARGUMENT MidCallArg {b1, b2} RETURN RESULT FALSE ERRORS {missingCustomerRecord | missingParameter | parameterOutOfRange | systemFailure | taskRefused | unexpectedComponentSequence | unexpectedDataValue | unexpectedParameter} ALWAYS RESPONDS FALSE CODE opcode-oMidCall } -- Direction: SSF -> SCF, Timer: Tomc -- This operation is used to indicate a feature request is received from the originating party -- (e.g. hook flash, ISDN feature activation, Q.931 HOLD or RETrieve message). (DP - O_Mid_Call). MidCallArg ::= SEQUENCE { dpSpecificCommonParameters [0] DpSpecificCommonParameters{b1, b2}, calledPartyBusinessGroupID [1] CalledPartyBusinessGroupID OPTIONAL, calledPartySubaddress [2] CalledPartySubaddress{b2} OPTIONAL, callingPartyBusinessGroupID [3] CallingPartyBusinessGroupID OPTIONAL, callingPartySubaddress [4] CallingPartySubaddress{b2} OPTIONAL, featureRequestIndicator [5] FeatureRequestIndicator OPTIONAL, extensions [6] Extensions{b1} OPTIONAL, carrier [7] Carrier{b2} OPTIONAL, componentType [8] ComponentType OPTIONAL, component [9] Component OPTIONAL, componentCorrelationID [10] ComponentCorrelationID OPTIONAL, ... } oNoAnswer OPERATION ::= { ARGUMENT ONoAnswerArg {b1, b2} RETURN RESULT FALSE ERRORS {missingCustomerRecord | missingParameter | parameterOutOfRange | systemFailure | taskRefused | unexpectedComponentSequence | unexpectedDataValue | unexpectedParameter} ALWAYS RESPONDS FALSE CODE opcode-oNoAnswer } -- Direction: SSF -> SCF, Timer: Tona -- This operation is used for indication from the terminating half BCSM that the terminating party does not -- answer within a specified time period (DP - O_No_Answer). ONoAnswerArg ::= SEQUENCE { dpSpecificCommonParameters [0] DpSpecificCommonParameters{b1, b2}, callingPartyBusinessGroupID [1] CallingPartyBusinessGroupID OPTIONAL, callingPartySubaddress [2] CallingPartySubaddress{b2} OPTIONAL, callingFacilityGroup [3] FacilityGroup OPTIONAL, callingFacilityGroupMember [4] FacilityGroupMember OPTIONAL, originalCalledPartyID [5] OriginalCalledPartyID{b2} OPTIONAL, prefix [6] Digits{b2} OPTIONAL, redirectingPartyID [7] RedirectingPartyID{b2} OPTIONAL, redirectionInformation [8] RedirectionInformation OPTIONAL, routeList [9] RouteList{b2} OPTIONAL, travellingClassMark [10] TravellingClassMark{b2} OPTIONAL, extensions [11] Extensions{b1} OPTIONAL, carrier [12] Carrier{b2} OPTIONAL, ... } originationAttempt OPERATION ::= { ARGUMENT OriginationAttemptArg {b1, b2} RETURN RESULT FALSE ERRORS {missingCustomerRecord | missingParameter | systemFailure | taskRefused | unexpectedComponentSequence | unexpectedDataValue | unexpectedParameter} ALWAYS RESPONDS FALSE CODE opcode-originationAttempt } -- Direction: SSF -> SCF. Timer: Tora -- This operation is used for indication of a call origination attempt from the originating half BCSM. -- (DP - Origination_Attempt). OriginationAttemptArg ::= SEQUENCE { dpSpecificCommonParameters [0] DpSpecificCommonParameters{b1, b2}, callingPartyBusinessGroupID [1] CallingPartyBusinessGroupID OPTIONAL, callingPartySubaddress [2] CallingPartySubaddress{b2} OPTIONAL, callingFacilityGroup [3] FacilityGroup OPTIONAL, callingFacilityGroupMember [4] FacilityGroupMember OPTIONAL, carrier [5] Carrier{b2} OPTIONAL, travellingClassMark [6] TravellingClassMark{b2} OPTIONAL, extensions [7] Extensions{b1} OPTIONAL, componentType [8] ComponentType OPTIONAL, component [9] Component OPTIONAL, componenttCorrelationID [10] ComponentCorrelationID OPTIONAL, ... } originationAttemptAuthorized OPERATION ::= { ARGUMENT OriginationAttemptAuthorizedArg {b1, b2} RETURN RESULT FALSE ERRORS {missingCustomerRecord | missingParameter | parameterOutOfRange | systemFailure | taskRefused | unexpectedComponentSequence | unexpectedDataValue | unexpectedParameter} ALWAYS RESPONDS FALSE CODE opcode-originationAttemptAuthorized } -- Direction: SSF -> SCF, Timer: Toaa -- This operation is used to Indicate the desire to place outgoing call (e.g. offhook, Q.931 Setup message, -- ISUP IAM message) and authority/ability to place outgoing call verified (DP - -- Origination_Attempt_Authorized). OriginationAttemptAuthorizedArg ::= SEQUENCE { dpSpecificCommonParameters [0] DpSpecificCommonParameters{b1, b2}, dialledDigits [1] CalledPartyNumber{b2} OPTIONAL, callingPartyBusinessGroupID [2] CallingPartyBusinessGroupID OPTIONAL, callingPartySubaddress [3] CallingPartySubaddress{b2} OPTIONAL, callingFacilityGroup [4] FacilityGroup OPTIONAL, callingFacilityGroupMember [5] FacilityGroupMember OPTIONAL, travellingClassMark [6] TravellingClassMark{b2} OPTIONAL, extensions [7] Extensions{b1} OPTIONAL, carrier [8] Carrier{b2} OPTIONAL, componentType [9] ComponentType OPTIONAL, component [10] Component OPTIONAL, componentCorrelationID [11] ComponentCorrelationID OPTIONAL, ... } oSuspended OPERATION ::= { ARGUMENT OSuspendedArg {b1, b2} RETURN RESULT FALSE ERRORS {missingCustomerRecord | missingParameter | systemFailure | taskRefused | unexpectedComponentSequence | unexpectedDataValue | unexpectedParameter | unknownLegID} ALWAYS RESPONDS FALSE CODE opcode-oSuspended } -- Direction: SSF -> SCF. Timer: T os -- This operation is issued by the SSF after detecting a valid trigger condition at the O_Suspend DP or to -- report an oSuspend event requested by the RequestReportBCSMEvent. OSuspendedArg ::= SEQUENCE { dpSpecificCommonParameters [0] DpSpecificCommonParameters{b1, b2}, legID [1] LegID OPTIONAL, extensions [2] Extensions{b1} OPTIONAL, ... } reconnect OPERATION ::= { ARGUMENT ReconnectArg {b1, b2} RETURN RESULT FALSE ERRORS {missingParameter | systemFailure | taskRefused | unexpectedComponentSequence | unexpectedDataValue | unexpectedParameter} ALWAYS RESPONDS FALSE CODE opcode-reconnect } -- Direction: SCF -> SSF. Timer: T re -- This operation is issued by the SCF to reestablish communication between the controlling leg and the -- (held) passive leg(s). . ReconnectArg ::= SEQUENCE { notificationDuration [0] ApplicationTimer OPTIONAL, alertingPattern [1] AlertingPattern OPTIONAL, displayInformation [2] DisplayInformation{b2} OPTIONAL, extensions [3] Extensions{b1} OPTIONAL, callSegmentID [4] CallSegmentID{b2} OPTIONAL, ... } releaseCall OPERATION ::= { ARGUMENT ReleaseCallArg {b2} RETURN RESULT FALSE ALWAYS RESPONDS FALSE CODE opcode-releaseCall } -- Direction: SCF -> SSF, Timer: Trc -- This operation is used by the SCF to tear down an existing call segment at any phase of the call for all parties -- involved in the call segment or to tear down all existing call segments within a Call Segment Association. ReleaseCallArg ::= CHOICE { initialCallSegment Cause{b2}, callSegmentToRelease [1] SEQUENCE {callSegment [0] INTEGER(1..--b2.&--numOfCSs), releaseCause [1] Cause{b2} OPTIONAL, forcedRelease [2] BOOLEAN DEFAULT FALSE, ...}, allCallSegments [2] SEQUENCE {releaseCause [0] Cause{b2} OPTIONAL, timeToRelease [1] TimerValue OPTIONAL, forcedRelease [2] BOOLEAN DEFAULT FALSE, ...}, ... } -- A default cause value of decimal 31 (normal unspecified) should be coded appropriately. -- If timeToRelease parameter is omitted, the default shall be no timed disconnect requested -- If forcedRelease parameter is omitted (default value "FALSE") the default shall be no forced release requested. reportUTSI OPERATION ::= { ARGUMENT ReportUTSIArg {b1, b2} RETURN RESULT FALSE ALWAYS RESPONDS FALSE CODE opcode-reportUTSI } -- Direction: SSF -> SCF. Timer: Tru -- This operation is issued by the SSF in the context of the USI feature. It is used to report the receipt -- of a User to Service Information (USI) to the SCF. ReportUTSIArg ::= SEQUENCE { uSIServiceIndicator [0] USIServiceIndicator{b2}, legID [1] LegID --DEFAULT receivingSideID:leg1--, uSIInformation [2] USIInformation{b2}, extensions [3] Extensions{b1} OPTIONAL, ... } requestCurrentStatusReport OPERATION ::= { ARGUMENT RequestCurrentStatusReportArg {b2} RESULT RequestCurrentStatusReportResultArg {b1, b2} ERRORS {missingParameter | parameterOutOfRange | systemFailure | taskRefused | unexpectedComponentSequence | unexpectedDataValue | unexpectedParameter | unknownResource} CODE opcode-requestCurrentStatusReport } -- Direction: SCF -> SSF, Timer: Trcs -- This operation is used to request the SSF to report immediately the busy/idle status of a physical -- termination resource. RequestCurrentStatusReportArg ::= ResourceID{b2} RequestCurrentStatusReportResultArg ::= SEQUENCE { resourceStatus [0] ResourceStatus, resourceID [1] ResourceID{b2} OPTIONAL, extensions [2] Extensions{b1} OPTIONAL, ... } requestEveryStatusChangeReport OPERATION ::= { ARGUMENT RequestEveryStatusChangeReportArg {b1, b2} RETURN RESULT TRUE ERRORS {missingParameter | parameterOutOfRange | systemFailure | taskRefused | unexpectedComponentSequence | unexpectedDataValue | unexpectedParameter | unknownResource} CODE opcode-requestEveryStatusChangeReport } -- Direction: SCF -> SSF, Timer: Tres -- This operation is used to request the SSF to report every change of busy/idle status of a physical -- termination resource. RequestEveryStatusChangeReportArg ::= SEQUENCE { resourceID [0] ResourceID{b2}, correlationID [1] CorrelationID{b2} OPTIONAL, monitorDuration [2] Duration OPTIONAL, extensions [3] Extensions{b1} OPTIONAL, ... } -- For correlationID OPTIONAL denotes network operator optional. -- monitorDuration is required if outside the context of a call. It is not expected if we are in the context -- of a call, because in that case the end of the call implicitly means the end of the monitoring. requestFirstStatusMatchReport OPERATION ::= { ARGUMENT RequestFirstStatusMatchReportArg {b1, b2} RETURN RESULT TRUE ERRORS {missingParameter | parameterOutOfRange | systemFailure | taskRefused | unexpectedComponentSequence | unexpectedDataValue | unexpectedParameter | unknownResource} CODE opcode-requestFirstStatusMatchReport } -- Direction: SCF -> SSF, Timer: Trfs -- This operation is used to request the SSF to report the first change busy/idle to the specified status of -- a physical termination resource. RequestFirstStatusMatchReportArg ::= SEQUENCE { resourceID [0] ResourceID{b2} OPTIONAL, resourceStatus [1] ResourceStatus OPTIONAL, correlationID [2] CorrelationID{b2} OPTIONAL, monitorDuration [3] Duration OPTIONAL, extensions [4] Extensions{b1} OPTIONAL, bearerCapability [5] BearerCapability{b2} OPTIONAL, ... } -- For correlationID OPTIONAL denotes network operator optional. -- monitorDuration is required if outside the context of a call. It is not expected if we are in the context -- of a call, because in that case the end of the call implicitly means the end of the monitoring. requestNotificationChargingEvent OPERATION ::= { ARGUMENT RequestNotificationChargingEventArg {b2} RETURN RESULT FALSE ERRORS {missingParameter | parameterOutOfRange | systemFailure | taskRefused | unexpectedComponentSequence | unexpectedDataValue | unexpectedParameter | unknownLegID} ALWAYS RESPONDS FALSE CODE opcode-requestNotificationChargingEvent } -- Direction: SCF -> SSF, Timer: Trnc -- This operation is used by the SCF to instruct the SSF on how to manage the charging events -- - which are received from other FE's and not under control of the service logic instance. RequestNotificationChargingEventArg ::= SEQUENCE SIZE (1..--b2.&--numOfChargingEvents) OF ChargingEvent{b2} requestReportBCSMEvent OPERATION ::= { ARGUMENT RequestReportBCSMEventArg {b1, b2} RETURN RESULT FALSE ERRORS {missingParameter | parameterOutOfRange | systemFailure | taskRefused | unexpectedComponentSequence | unexpectedDataValue | unexpectedParameter | unknownLegID} ALWAYS RESPONDS FALSE CODE opcode-requestReportBCSMEvent } -- Direction: SCF -> SSF, Timer: Trrb -- This operation is used to request the SSF to monitor for a call-related event (e.g. BCSM events such as -- busy or no answer), then send a notification back to the SCF when the event is detected. -- It is proposed that Event Detection Point (EDP) processing is always initiated by RequestReportBCSMEvent -- and the EDP may be acknowledged with either an EventReportBCSM or by a DP-specific operation. -- NOTE - the application context should identify whether BCSM Event Handling Package -- is being used, or whether DP Specific Event Handling Package is being used. -- For a particular IN, only one of the two alternatives identified by the respective Packages should be -- selected (i.e., only one approach should be selected for a given application context). -- Every EDP must be explicitly armed by the SCF via a RequestReportBCSMEvent operation. -- No implicit arming of EDPs at the SSF after reception of any operation (different from -- RequestReportBCSMEvent) from the SCF is allowed. RequestReportBCSMEventArg ::= SEQUENCE { bcsmEvents [0] SEQUENCE SIZE (1..--b2.&--numOfBCSMEvents) OF BCSMEvent{b2}, bcsmEventCorrelationID [1] CorrelationID{b2} OPTIONAL, extensions [2] Extensions{b1} OPTIONAL, ... } -- Indicates the BCSM related events for notification. -- For correlationID OPTIONAL denotes network operator optional. requestReportFacilityEvent OPERATION ::= { ARGUMENT RequestReportFacilityEventArg {b1} RETURN RESULT FALSE ERRORS {missingParameter | parameterOutOfRange | systemFailure | taskRefused | unexpectedComponentSequence | unexpectedDataValue | unexpectedParameter | unknownLegID} ALWAYS RESPONDS FALSE CODE opcode-requestReportFacilityEvent } -- SCF->SSF, Timer: Trrfe -- This operation is issued by the SCF to request the SSF to report the SCF the event that the CCF/SSF -- receives a DSS1 message which contains a FACILITY IE during a BCSM being suspended at a DP. RequestReportFacilityEventArg ::= SEQUENCE { componentTypes [0] SEQUENCE SIZE (1..3) OF ComponentType DEFAULT {any}, legID [1] LegID OPTIONAL, componentCorrelationID [2] ComponentCorrelationID OPTIONAL, monitorDuration [3] Duration, extensions [4] Extensions{b1} OPTIONAL, ... } -- componentTypes specifies the component types which should be reported to the SCF. -- monitorDuration specifies the monitor duration. requestReportUTSI OPERATION ::= { ARGUMENT RequestReportUTSIArg {b1, b2} RETURN RESULT FALSE ERRORS {missingParameter | parameterOutOfRange | systemFailure | taskRefused | unexpectedComponentSequence | unexpectedDataValue | unexpectedParameter | unknownLegID} ALWAYS RESPONDS FALSE CODE opcode-requestReportUTSI } -- Direction: SCF -> SSF. Timer: Trru -- This operation is issued by the SCF in the context of the USI feature to request the SSF to monitor for -- a User to Service Information (UTSI) information element, which are received from a user. RequestReportUTSIArg ::= SEQUENCE { requestedUTSIList [0] RequestedUTSIList{b2}, extensions [1] Extensions{b1} OPTIONAL, legID [2] LegID --DEFAULT sendingSideID:leg1--, ... } resetTimer OPERATION ::= { ARGUMENT ResetTimerArg {b1, b2} RETURN RESULT FALSE ERRORS {missingParameter | parameterOutOfRange | taskRefused | unexpectedComponentSequence | unexpectedDataValue | unexpectedParameter} ALWAYS RESPONDS FALSE CODE opcode-resetTimer } -- Direction: SCF -> SSF, Timer: Trt -- This operation is used to request the SSF to refresh an application timer in the SSF. ResetTimerArg ::= SEQUENCE { timerID [0] TimerID DEFAULT tssf, timervalue [1] TimerValue, extensions [2] Extensions{b1} OPTIONAL, callSegmentID [3] CallSegmentID{b2} OPTIONAL, ... } routeSelectFailure OPERATION ::= { ARGUMENT RouteSelectFailureArg {b1, b2} RETURN RESULT FALSE ERRORS {missingCustomerRecord | missingParameter | parameterOutOfRange | systemFailure | taskRefused | unexpectedComponentSequence | unexpectedDataValue | unexpectedParameter} ALWAYS RESPONDS FALSE CODE opcode-routeSelectFailure } -- Direction: SSF -> SCF, Timer: Trsf -- This operation is used to indicate that the SSP is unable to select a route (e.g. unable to determine a -- correct route, no more routes on route list) or indication from the terminating half BCSM that a call -- cannot be presented to the terminating party (e.g. network ongestion) (DP - Route_Select_Failure). RouteSelectFailureArg ::= SEQUENCE { dpSpecificCommonParameters [0] DpSpecificCommonParameters{b1, b2}, dialledDigits [1] CalledPartyNumber{b2} OPTIONAL, callingPartyBusinessGroupID [2] CallingPartyBusinessGroupID OPTIONAL, callingPartySubaddress [3] CallingPartySubaddress{b2} OPTIONAL, callingFacilityGroup [4] FacilityGroup OPTIONAL, callingFacilityGroupMember [5] FacilityGroupMember OPTIONAL, failureCause [6] Cause{b2} OPTIONAL, originalCalledPartyID [7] OriginalCalledPartyID{b2} OPTIONAL, prefix [8] Digits{b2} OPTIONAL, redirectingPartyID [9] RedirectingPartyID{b2} OPTIONAL, redirectionInformation [10] RedirectionInformation OPTIONAL, routeList [11] RouteList{b2} OPTIONAL, travellingClassMark [12] TravellingClassMark{b2} OPTIONAL, extensions [13] Extensions{b1} OPTIONAL, carrier [14] Carrier{b2} OPTIONAL, ... } selectFacility OPERATION ::= { ARGUMENT SelectFacilityArg {b1, b2} RETURN RESULT FALSE ERRORS {missingParameter | parameterOutOfRange | systemFailure | taskRefused | unexpectedComponentSequence | unexpectedDataValue | unexpectedParameter} ALWAYS RESPONDS FALSE CODE opcode-selectFacility } -- Direction: SCF -> SSF, Timer: Tsf -- This operation is used to request the SSF to perform the terminating basic call processing -- actions to select the terminating line if it is idle, or selects an idle line from a multi-line hunt -- group, or selects an idle trunk from a trunk group, as appropriate. If no idle line or trunk is -- available, the SSF determines that the terminating facility is busy. SelectFacilityArg ::= SEQUENCE { alertingPattern [0] AlertingPattern OPTIONAL, destinationNumberRoutingAddress [1] CalledPartyNumber{b2} OPTIONAL, iSDNAccessRelatedInformation [2] ISDNAccessRelatedInformation{b2} OPTIONAL, calledFacilityGroup [3] FacilityGroup OPTIONAL, calledFacilityGroupMember [4] FacilityGroupMember OPTIONAL, originalCalledPartyID [5] OriginalCalledPartyID{b2} OPTIONAL, extensions [6] Extensions{b1} OPTIONAL, displayInformation [7] DisplayInformation{b2} OPTIONAL, serviceInteractionIndicators [8] ServiceInteractionIndicators{b2} OPTIONAL, iNServiceCompatibilityResponse [9] INServiceCompatibilityResponse OPTIONAL, forwardGVNS [10] ForwardGVNS{b2} OPTIONAL, backwardGVNS [11] BackwardGVNS{b2} OPTIONAL, serviceInteractionIndicatorsTwo [12] ServiceInteractionIndicatorsTwo OPTIONAL, correlationID [13] CorrelationID{b2} OPTIONAL, scfID [14] ScfID{b2} OPTIONAL, callSegmentID [15] CallSegmentID{b2} OPTIONAL, legToBeCreated [16] LegID OPTIONAL, ..., ipRelatedInformation [17] IPRelatedInformation{b2} OPTIONAL } -- OPTIONAL parameters are only provided if modifications desired to basic call processing values. selectRoute OPERATION ::= { ARGUMENT SelectRouteArg {b1, b2} RETURN RESULT FALSE ERRORS {missingParameter | parameterOutOfRange | systemFailure | taskRefused | unexpectedComponentSequence | unexpectedDataValue | unexpectedParameter} ALWAYS RESPONDS FALSE CODE opcode-selectRoute } -- Direction: SCF -> SSF, Timer: Tsr -- This operation is used to request the SSF to perform the originating basic call processing actions to -- determine routing information and select a route for a call, based either on call information available -- to the SSF, or on call information provided by the SCF (e.g. for alternate routing), to include the -- called party address, type of call, carrier, route index, and one or more alternate route indices. -- Based on the routing information, the SSF attempts to select a primary route for the call, and if the -- route is busy, attempts to select an alternate route. The SSF may fail to select a route for the call -- if all routes are busy. SelectRouteArg ::= SEQUENCE { destinationRoutingAddress [0] DestinationRoutingAddress{b2}, alertingPattern [1] AlertingPattern OPTIONAL, correlationID [2] CorrelationID{b2} OPTIONAL, iSDNAccessRelatedInformation [3] ISDNAccessRelatedInformation{b2} OPTIONAL, originalCalledPartyID [4] OriginalCalledPartyID{b2} OPTIONAL, routeList [5] RouteList{b2} OPTIONAL, scfID [6] ScfID{b2} OPTIONAL, travellingClassMark [7] TravellingClassMark{b2} OPTIONAL, extensions [8] Extensions{b1} OPTIONAL, carrier [9] Carrier{b2} OPTIONAL, serviceInteractionIndicators [10] ServiceInteractionIndicators{b2} OPTIONAL, iNServiceCompatibilityResponse [11] INServiceCompatibilityResponse OPTIONAL, forwardGVNS [12] ForwardGVNS{b2} OPTIONAL, backwardGVNS [13] BackwardGVNS{b2} OPTIONAL, serviceInteractionIndicatorsTwo [14] ServiceInteractionIndicatorsTwo OPTIONAL, callSegmentID [15] CallSegmentID{b2} OPTIONAL, legToBeCreated [16] LegID OPTIONAL, ..., ipRelatedInformation [17] IPRelatedInformation{b2} OPTIONAL } -- OPTIONAL parameters are only provided if modifications desired to basic call processing values. sendChargingInformation OPERATION ::= { ARGUMENT SendChargingInformationArg {b1, b2} RETURN RESULT FALSE ERRORS {missingParameter | unexpectedComponentSequence | unexpectedParameter | parameterOutOfRange | systemFailure | taskRefused | unexpectedDataValue | unknownLegID} ALWAYS RESPONDS FALSE CODE opcode-sendChargingInformation } -- Direction: SCF -> SSF, Timer: Tsci -- This operation is used to instruct the SSF on the charging information to send by the SSF. -- The charging information can either be sent back by means of signalling or internal -- if the SSF is located in the local exchange. In the local exchange -- this information may be used to update the charge meter or to create a standard call record. SendChargingInformationArg ::= SEQUENCE { sCIBillingChargingCharacteristics [0] SCIBillingChargingCharacteristics{b2}, partyToCharge [1] LegID, extensions [2] Extensions{b1} OPTIONAL, nocharge [3] BOOLEAN OPTIONAL, ... } sendFacilityInformation OPERATION ::= { ARGUMENT SendFacilityInformationArg {b1} RETURN RESULT FALSE ERRORS {missingParameter | unexpectedComponentSequence | unexpectedParameter | unexpectedDataValue | systemFailure | taskRefused | unknownLegID} ALWAYS RESPONDS FALSE CODE opcode-sendFacilityInformation } -- SCF->SSF, Timer: Tsfi -- This operation is issued by the SCF during a BCSM being suspended at a DP to request the CCF/SSF -- sending a FACILITY IE to a user with a specified DSS1 message. SendFacilityInformationArg ::= SEQUENCE { componentType [0] ComponentType, legID [1] LegID OPTIONAL, componentCorrelationID [2] ComponentCorrelationID OPTIONAL, component [3] Component, callProcessingOperation [4] CallProcessingOperation DEFAULT fACility, extensions [5] Extensions{b1} OPTIONAL, ... } -- FACILITY information will be delivered with the specified DSS1 message. The message is specified with the -- callProcessingOperation sendSTUI OPERATION ::= { ARGUMENT SendSTUIArg {b1, b2} RETURN RESULT FALSE ERRORS {missingParameter | parameterOutOfRange | unexpectedComponentSequence | unexpectedParameter | unexpectedDataValue | systemFailure | taskRefused | unknownLegID} ALWAYS RESPONDS FALSE CODE opcode-sendSTUI } -- Direction: SCF -> SSF. Timer: Tss -- This operation is issued by the SCF in the context of the USI feature. It is used to request the SSF -- to send a Service to User Information (USI information) data element to the indicated user. SendSTUIArg ::= SEQUENCE { uSIServiceIndicator [0] USIServiceIndicator{b2}, legID [1] LegID --DEFAULT sendingSideID:leg1--, uSIInformation [2] USIInformation{b2}, extensions [3] Extensions{b1} OPTIONAL, ... } serviceFilteringResponse OPERATION ::= { ARGUMENT ServiceFilteringResponseArg {b1, b2} RETURN RESULT FALSE ALWAYS RESPONDS FALSE CODE opcode-serviceFilteringResponse } -- Direction: SSF -> SCF, Timer: Tsfr -- This operation is used to send back to the SCF the values of counters specified in a previous -- ActivateServiceFiltering operation ServiceFilteringResponseArg ::= SEQUENCE { countersValue [0] CountersValue{b2}, filteringCriteria [1] FilteringCriteria{b2}, extensions [2] Extensions{b1} OPTIONAL, responseCondition [3] ResponseCondition OPTIONAL, ... } setServiceProfile OPERATION ::= { ARGUMENT SetServiceProfileArg {b1, b2} RETURN RESULT FALSE ERRORS {missingParameter | parameterOutOfRange | taskRefused | unexpectedComponentSequence | unexpectedDataValue | unexpectedParameter} ALWAYS RESPONDS FALSE CODE opcode-setServiceProfile } -- Direction SCF -> SSF, Timer Tsep --This operation is used within the context of a call to request the SSF to activate/de-activate a list of trigger for one of the parties in the call. SetServiceProfileArg ::= SEQUENCE { iNprofiles [0] SEQUENCE SIZE (1..--b2.&--numOfINProfile) OF INprofile{b1, b2}, ..., -- ..., extensions [30] Extensions{b1} OPTIONAL } splitLeg OPERATION ::= { ARGUMENT SplitLegArg {b1, b2} RETURN RESULT TRUE ERRORS {missingParameter | unexpectedComponentSequence | unexpectedParameter | unexpectedDataValue | systemFailure | taskRefused | unknownLegID} CODE opcode-splitLeg } -- Direction: SCF -> SSF. Timer: T sl -- This operation is issued by the SCF to separate one joined leg from a multi-way connection -- or a single 2 party Call segment. SplitLegArg ::= SEQUENCE { legToBeSplit [0] LegID, newCallSegment [1] INTEGER(2..--b2.&--numOfCSs), extensions [2] Extensions{b1} OPTIONAL, ..., detachSignallingPath [3] NULL OPTIONAL } statusReport OPERATION ::= { ARGUMENT StatusReportArg {b1, b2} RETURN RESULT FALSE ALWAYS RESPONDS FALSE CODE opcode-statusReport } -- Direction: SSF -> SCF, Timer: Tsrp -- This operation is used as a response to RequestFirstStatusMatchReport or -- RequestEveryStatusChangeReport operations. StatusReportArg ::= SEQUENCE { resourceStatus [0] ResourceStatus OPTIONAL, correlationID [1] CorrelationID{b2} OPTIONAL, resourceID [2] ResourceID{b2} OPTIONAL, extensions [3] Extensions{b1} OPTIONAL, reportCondition [4] ReportCondition OPTIONAL, ... } -- For correlationID, OPTIONAL denotes network operator optional. -- resourceID is required when the SSF sends a report as an answer to a previous request when the -- correlationID was present. tAnswer OPERATION ::= { ARGUMENT TAnswerArg {b1, b2} RETURN RESULT FALSE ERRORS {missingCustomerRecord | missingParameter | parameterOutOfRange | unexpectedComponentSequence | unexpectedParameter | unexpectedDataValue | systemFailure | taskRefused} ALWAYS RESPONDS FALSE CODE opcode-tAnswer } -- Direction: SSF -> SCF, Timer: Tta -- This operation is used to indicate that the call is accepted and answered by terminating party -- (e.g. terminating party goes offhook, Q.931 Connect message received, ISUP Answer message -- received) (DP - T_Answer). TAnswerArg ::= SEQUENCE { dpSpecificCommonParameters [0] DpSpecificCommonParameters{b1, b2}, calledPartyBusinessGroupID [1] CalledPartyBusinessGroupID OPTIONAL, calledPartySubaddress [2] CalledPartySubaddress{b2} OPTIONAL, calledFacilityGroup [3] FacilityGroup OPTIONAL, calledFacilityGroupMember [4] FacilityGroupMember OPTIONAL, extensions [5] Extensions{b1} OPTIONAL, componentType [6] ComponentType OPTIONAL, component [7] Component OPTIONAL, componentCorrelationID [8] ComponentCorrelationID OPTIONAL, ... } tBusy OPERATION ::= { ARGUMENT TBusyArg {b1, b2} RETURN RESULT FALSE ERRORS {missingCustomerRecord | missingParameter | parameterOutOfRange | unexpectedComponentSequence | unexpectedParameter | unexpectedDataValue | systemFailure | taskRefused} ALWAYS RESPONDS FALSE CODE opcode-tBusy } -- Direction: SSF -> SCF, Timer: Ttb -- This operation is used to indicate all resources in group busy (DP- TBusy). TBusyArg ::= SEQUENCE { dpSpecificCommonParameters [0] DpSpecificCommonParameters{b1, b2}, busyCause [1] Cause{b2} OPTIONAL, calledPartyBusinessGroupID [2] CalledPartyBusinessGroupID OPTIONAL, calledPartySubaddress [3] CalledPartySubaddress{b2} OPTIONAL, originalCalledPartyID [4] OriginalCalledPartyID{b2} OPTIONAL, redirectingPartyID [5] RedirectingPartyID{b2} OPTIONAL, redirectionInformation [6] RedirectionInformation OPTIONAL, routeList [7] RouteList{b2} OPTIONAL, travellingClassMark [8] TravellingClassMark{b2} OPTIONAL, extensions [9] Extensions{b1} OPTIONAL, ... } tDisconnect OPERATION ::= { ARGUMENT TDisconnectArg {b1, b2} RETURN RESULT FALSE ERRORS {missingCustomerRecord | missingParameter | parameterOutOfRange | unexpectedComponentSequence | unexpectedParameter | unexpectedDataValue | systemFailure | taskRefused} ALWAYS RESPONDS FALSE CODE opcode-tDisconnect } -- Direction: SSF -> SCF, Timer: Ttd -- This operation is used for a disconnect indication (e.g. onhook, Q.931 Disconnect message, -- SS7 Release message) is received from the terminating party, or received from the originating party -- via the originating half BCSM. (DP - T_Disconnect). TDisconnectArg ::= SEQUENCE { dpSpecificCommonParameters [0] DpSpecificCommonParameters{b1, b2}, calledPartyBusinessGroupID [1] CalledPartyBusinessGroupID OPTIONAL, calledPartySubaddress [2] CalledPartySubaddress{b2} OPTIONAL, calledFacilityGroup [3] FacilityGroup OPTIONAL, calledFacilityGroupMember [4] FacilityGroupMember OPTIONAL, releaseCause [5] Cause{b2} OPTIONAL, extensions [6] Extensions{b1} OPTIONAL, connectTime [7] Integer4 OPTIONAL, componentType [8] ComponentType OPTIONAL, component [9] Component OPTIONAL, componentCorrelationID [10] ComponentCorrelationID OPTIONAL, ... } termAttemptAuthorized OPERATION ::= { ARGUMENT TermAttemptAuthorizedArg {b1, b2} RETURN RESULT FALSE ERRORS {missingCustomerRecord | missingParameter | parameterOutOfRange | unexpectedComponentSequence | unexpectedParameter | unexpectedDataValue | systemFailure | taskRefused} ALWAYS RESPONDS FALSE CODE opcode-termAttemptAuthorized } -- Direction: SSF -> SCF, Timer: Ttaa -- This operation is used for indication of incoming call received from originating half BCSM and authority -- to route call to a specified terminating resource (or group) verified. (DP - Termination_Authorized). TermAttemptAuthorizedArg ::= SEQUENCE { dpSpecificCommonParameters [0] DpSpecificCommonParameters{b1, b2}, calledPartyBusinessGroupID [1] CalledPartyBusinessGroupID OPTIONAL, calledPartySubaddress [2] CalledPartySubaddress{b2} OPTIONAL, callingPartyBusinessGroupID [3] CallingPartyBusinessGroupID OPTIONAL, originalCalledPartyID [4] OriginalCalledPartyID{b2} OPTIONAL, redirectingPartyID [5] RedirectingPartyID{b2} OPTIONAL, redirectionInformation [6] RedirectionInformation OPTIONAL, routeList [7] RouteList{b2} OPTIONAL, travellingClassMark [8] TravellingClassMark{b2} OPTIONAL, extensions [9] Extensions{b1} OPTIONAL, callingPartySubaddress [10] CallingPartySubaddress{b2} OPTIONAL, ... } -- OPTIONAL parameters are only provided if modifications desired to basic call processing values terminationAttempt OPERATION ::= { ARGUMENT TerminationAttemptArg {b1, b2} RETURN RESULT FALSE ERRORS {missingCustomerRecord | missingParameter | parameterOutOfRange | unexpectedComponentSequence | unexpectedParameter | unexpectedDataValue | systemFailure | taskRefused} ALWAYS RESPONDS FALSE CODE opcode-terminationAttempt } -- Direction: SSF -> SCF. Timer: Ttra -- This operation is used for indication of a call termination attempt from the terminating half BCSM. (DP - -- Termination_Attempt). TerminationAttemptArg ::= SEQUENCE { dpSpecificCommonParameters [0] DpSpecificCommonParameters{b1, b2}, calledPartyBusinessGroupID [1] CalledPartyBusinessGroupID OPTIONAL, calledPartySubaddress [2] CalledPartySubaddress{b2} OPTIONAL, callingPartyBusinessGroupID [3] CallingPartyBusinessGroupID OPTIONAL, callingPartySubaddress [4] CallingPartySubaddress{b2} OPTIONAL, originalCalledPartyID [5] OriginalCalledPartyID{b2} OPTIONAL, redirectingPartyID [6] RedirectingPartyID{b2} OPTIONAL, redirectionInformation [7] RedirectionInformation OPTIONAL, routeList [8] RouteList{b2} OPTIONAL, travellingClassMark [9] TravellingClassMark{b2} OPTIONAL, extensions [10] Extensions{b1} OPTIONAL, ... } tMidCall OPERATION ::= { ARGUMENT MidCallArg {b1, b2} RETURN RESULT FALSE ERRORS {missingCustomerRecord | missingParameter | parameterOutOfRange | unexpectedComponentSequence | unexpectedParameter | unexpectedDataValue | systemFailure | taskRefused} ALWAYS RESPONDS FALSE CODE opcode-tMidCall } -- Direction: SSF -> SCF, Timer: Ttmc -- This operation is used to indicate that a feature request is received from the terminating party (e.g. hook -- flash, ISDN feature activation Q.931 HOLD or RETrieve message). (DP - T_Mid_Call). tNoAnswer OPERATION ::= { ARGUMENT TNoAnswerArg {b1, b2} RETURN RESULT FALSE ERRORS {missingCustomerRecord | missingParameter | parameterOutOfRange | unexpectedComponentSequence | unexpectedParameter | unexpectedDataValue | systemFailure | taskRefused} ALWAYS RESPONDS FALSE CODE opcode-tNoAnswer } -- Direction: SSF -> SCF, Timer: Ttna -- This operation is used to indicate that the terminating party does not answer within a specified duration. -- (DP - T_No_Answer). . TNoAnswerArg ::= SEQUENCE { dpSpecificCommonParameters [0] DpSpecificCommonParameters{b1, b2}, calledPartyBusinessGroupID [1] CalledPartyBusinessGroupID OPTIONAL, calledPartySubaddress [2] CalledPartySubaddress{b2} OPTIONAL, calledFacilityGroup [3] FacilityGroup OPTIONAL, calledFacilityGroupMember [4] FacilityGroupMember OPTIONAL, originalCalledPartyID [5] OriginalCalledPartyID{b2} OPTIONAL, redirectingPartyID [6] RedirectingPartyID{b2} OPTIONAL, redirectionInformation [7] RedirectionInformation OPTIONAL, travellingClassMark [8] TravellingClassMark{b2} OPTIONAL, extensions [9] Extensions{b1} OPTIONAL, componentType [10] ComponentType OPTIONAL, component [11] Component OPTIONAL, componentCorrelationID [12] ComponentCorrelationID OPTIONAL, ... } tSuspended OPERATION ::= { ARGUMENT TSuspendedArg {b1, b2} RETURN RESULT FALSE ERRORS {missingCustomerRecord | missingParameter | systemFailure | taskRefused | unexpectedComponentSequence | unexpectedDataValue | unexpectedParameter} ALWAYS RESPONDS FALSE CODE opcode-tSuspended } -- Direction: SSF -> SCF. Timer: T ts -- This operation is issued by the SSF after detecting a valid trigger condition at the T_Suspend DP or to -- report a tSuspended event requested by the RequestReportBCSMEvent. TSuspendedArg ::= SEQUENCE { dpSpecificCommonParameters [0] DpSpecificCommonParameters{b1, b2}, legID [1] LegID OPTIONAL, extensions [2] Extensions{b1} OPTIONAL, ... } END -- Generated by Asnp, the ASN.1 pretty-printer of France Telecom R&D