-- Module IN-SCF-SCF-ops-args (Q.1248.6:07/2001)
-- See also ITU-T Q.1248.6 (07/2001)
-- See also the index of all ASN.1 assignments needed in this document
IN-SCF-SCF-ops-args {itu-t recommendation q 1248 modules(1)
in-scf-scf-ops-args(22) version1(0)} DEFINITIONS IMPLICIT TAGS ::=
BEGIN
IMPORTS
OPERATION, Code, ERROR
FROM Remote-Operations-Information-Objects ros-InformationObjects
opcode-announcementCompletionReport, opcode-establishChargingRecord,
opcode-handlingInformationRequest, opcode-handlingInformationResult,
opcode-initiateCallRequest, opcode-networkCapability,
opcode-notificationProvided, opcode-confirmedNotificationProvided,
opcode-provideAnnouncementRequest, opcode-provideUserInformation,
opcode-confirmedReportChargingInformation,
opcode-reportChargingInformation, opcode-requestNotification,
opcode-runUserScript, opcode-transferSTSI
FROM IN-operationcodes operationcodes
EXTENSION, COMMON-BOUNDS, SupportedExtensions
FROM IN-common-classes common-classes
BearerCapability{}, CalledPartyNumber{}, CallingPartyNumber{},
CallingPartyBusinessGroupID, CallingPartysCategory, Carrier{}, Cause{},
CorrelationID{}, Digits{}, DisplayInformation{}, GenericNumber{},
HighLayerCompatibility{}, LocationNumber{}, OriginalCalledPartyID{},
RedirectingPartyID{}, RedirectionInformation, ScfID{}
FROM IN-SSF-SCF-datatypes ssf-scf-datatypes
AccountNumber, Actions, ActivableServices, AgreementID, BearerCapabilities,
CallConditions{}, CallIdentifier, CallRecord{}, ChargingParameters{},
ChargingSignallingInformation, CollectedInfo, ConsumedCreditAction,
DestinationRelatedInfo{}, ErrorTreatment, FreeContainer{},
HighLayerCompatibilities, InformationToSend{}, InfoType, InvokableService,
Meters, Notification, NotificationInformation{}, PartyID,
ReceivedInformation{}, ReportConditionEvent{},
ReportDestinationInformation{}, RequestedNotifications{}, RequestedType,
RoutingAddress{}, ScfAddress{}, SSIInfo{}, SubscriberID{},
SupplementaryServices, TraceInformation{}, UserCredit{},
UserInteractionModes, UserToConnect
FROM IN-SCF-SCF-datatypes scf-scf-datatypes
Extensions{}, Integer4
FROM IN-common-datatypes common-datatypes
Language
FROM IN-SCF-SRF-datatypes scf-srf-datatypes
improperCallerResponse, missingCustomerRecord, missingParameter,
parameterOutOfRange, scfTaskRefused, systemFailure,
unexpectedComponentSequence, unexpectedDataValue, unexpectedParameter,
chainingRefused, scfBindFailure, scfReferral
FROM IN-errortypes errortypes
errcode-scfReferral, errcode-scfTaskRefused
FROM IN-errorcodes errorcodes
SPKM-ERROR
FROM SpkmGssTokens spkmGssTokens
activityTest
FROM IN-SSF-SCF-ops-args ssf-scf-Operations
ros-InformationObjects, ds-UsefulDefinitions, operationcodes, common-classes,
guls-Notation, guls-SecurityTransformations, errortypes, errorcodes,
scf-scf-Protocol, ssf-scf-Operations, spkmGssTokens, ssf-scf-classes,
scf-srf-datatypes, scf-scf-classes, common-datatypes, ssf-scf-datatypes,
scf-scf-datatypes, scf-srf-classes
FROM IN-object-identifiers {itu-t recommendation q 1248 modules(1)
in-object-identifiers(0) version1(0)}
directoryAbstractService, enhancedSecurity, distributedOperations,
basicAccessControl
FROM UsefulDefinitions ds-UsefulDefinitions
SecurityParameters, Credentials, SecurityProblem, securityError
FROM DirectoryAbstractService directoryAbstractService
OPTIONALLY-PROTECTED{}
FROM EnhancedSecurity enhancedSecurity
AuthenticationLevel
FROM BasicAccessControl basicAccessControl
AccessPointInformation
FROM DistributedOperations distributedOperations
SCF-SCF-BOUNDS, scfqop
FROM IN-SCF-SCF-Classes scf-scf-classes
SCF-SSF-BOUNDS
FROM IN-SSF-SCF-Classes ssf-scf-classes
SCF-SRF-BOUNDS
FROM IN-SCF-SRF-Classes scf-srf-classes;
-- The following short-hand notation is used to refer to ASN.1 Information Object Classes
-- representing parameters bounds.
B1 ::=
COMMON-BOUNDS -- defined in Recommendation Q.1248.1
B2 ::= SCF-SSF-BOUNDS -- defined in Recommendation Q.1248.2
B3 ::= SCF-SRF-BOUNDS -- defined in Recommendation Q.1248.3
B6 ::= SCF-SCF-BOUNDS -- defined in this Recommendation Q.1248.6
announcementCompletionReport OPERATION ::= {
ARGUMENT AnnouncementCompletionReportArg
RETURN RESULT FALSE
ALWAYS RESPONDS FALSE
CODE opcode-announcementCompletionReport
}
-- Direction: controlling-SCF -> supporting-SCF, Timer: Tanr
-- This operation is used as the response to a ProvideAnnouncementRequest operation when the announcement
-- completed report indication is set.
AnnouncementCompletionReportArg ::= NULL
establishChargingRecord{B1:b1, B2:b2, B6:b6} OPERATION ::= {
ARGUMENT EstablishChargingRecordArg {b1,
b2,
b6}
RETURN RESULT FALSE
ERRORS
{missingCustomerRecord | missingParameter | systemFailure | scfTaskRefused
| unexpectedComponentSequence | unexpectedDataValue | unexpectedParameter
| parameterOutOfRange | securityError}
ALWAYS RESPONDS FALSE
CODE opcode-establishChargingRecord
}
-- Direction: supporting SCF -> controlling SCF, Timer Tecr
-- This operation is used by the supporting SCF to give charging information to the controlling
-- SCF so that it can charge the user (on-line charging included).
EstablishChargingRecordArg{B1:b1, B2:b2, B6:b6} ::=
OPTIONALLY-PROTECTED
{SEQUENCE {userCredit [0] UserCredit{b6} OPTIONAL,
chargingParameters [1] ChargingParameters{b6} OPTIONAL,
reportExpected [2] BOOLEAN DEFAULT TRUE,
securityParameters [3] SecurityParameters OPTIONAL,
extensions [4] Extensions{b1} OPTIONAL,
consumedCreditAction [10] ConsumedCreditAction OPTIONAL,
newChargingParameters [11] ChargingParameters{b6} OPTIONAL,
reportAddress
[12] ReportDestinationInformation{b2} OPTIONAL,
container [13] FreeContainer{b6} OPTIONAL,
correlationId [14] CorrelationID{b2} OPTIONAL,
acksequence [15] INTEGER(1..127) OPTIONAL,
splitcharge
[16] ChargingSignallingInformation OPTIONAL,
reportCondition [22] ReportConditionEvent{b6} OPTIONAL,
...}, scfqop.&scfArgumentQOP}
handlingInformationRequest{B1:b1, B2:b2, B6:b6} OPERATION ::= {
ARGUMENT HandlingInformationRequestArg {b1,
b2,
b6}
RETURN RESULT FALSE
ERRORS
{missingCustomerRecord | missingParameter | parameterOutOfRange |
systemFailure | scfTaskRefused | unexpectedComponentSequence |
unexpectedDataValue | unexpectedParameter | securityError | scfReferral}
LINKED {handlingInformationResult {b1,
b2}}
ALWAYS RESPONDS FALSE
CODE opcode-handlingInformationRequest
}
-- Direction: controlling SCF -> supporting SCF , Timer Thi
-- This operation may be used to request the execution of an SLP
-- in the assisting SCF and to provide to the assisting
-- SCF the context of the call so that it can help the controlling SCF in the processing of the call.
HandlingInformationRequestArg{B1:b1, B2:b2, B6:b6} ::=
OPTIONALLY-PROTECTED
{SEQUENCE {requestedType [0] RequestedType OPTIONAL,
callingPartyNumber
[1] CallingPartyNumber{b2} OPTIONAL,
locationNumber [2] LocationNumber{b2} OPTIONAL,
calledPartyNumber [3] CalledPartyNumber{b2} OPTIONAL,
dialledDigits [4] GenericNumber{b2} OPTIONAL,
redirectingPartyID
[5] RedirectingPartyID{b2} OPTIONAL,
redirectionInformation
[6] RedirectionInformation OPTIONAL,
originalCalledPartyID
[7] OriginalCalledPartyID{b2} OPTIONAL,
numberOfCallAttempts
[8] INTEGER(1..b6.&ub-nbCall) OPTIONAL,
highLayerCompatibility
[9] HighLayerCompatibility{b2} OPTIONAL,
bearerCapability [10] BearerCapability{b2} OPTIONAL,
invokedSupplementaryService [11] InvokableService OPTIONAL,
activeSupplementaryServices [12] ActivableServices OPTIONAL,
causeOfLastCallFailure [13] Cause{b2} OPTIONAL,
userInteractionModes [14] UserInteractionModes OPTIONAL,
callingPartysCategory
[15] CallingPartysCategory OPTIONAL,
callingPartyBusinessGroupID
[16] CallingPartyBusinessGroupID OPTIONAL,
securityParameters [17] SecurityParameters OPTIONAL,
extensions [18] Extensions{b1} OPTIONAL,
...}, scfqop.&scfArgumentQOP}
handlingInformationResult{B1:b1, B2:b2} OPERATION ::= {
ARGUMENT HandlingInformationResultArg {b1,
b2}
RETURN RESULT FALSE
ERRORS
{missingParameter | systemFailure | parameterOutOfRange |
unexpectedComponentSequence | unexpectedDataValue | unexpectedParameter |
securityError}
ALWAYS RESPONDS FALSE
CODE opcode-handlingInformationResult
}
-- Direction: supporting SCF ->controlling SCF, Timer Thir
-- This operation is used by the assisting SCF to send information to the controlling SCF on how
-- to process the call and to give conditions under which it should be involved in the call
-- processing.
HandlingInformationResultArg{B1:b1, B2:b2} ::=
OPTIONALLY-PROTECTED
{SEQUENCE {routingAddress [0] RoutingAddress{b2} OPTIONAL,
highLayerCompatibility [1] HighLayerCompatibility{b2} OPTIONAL,
supplementaryServices [2] SupplementaryServices OPTIONAL,
preferredLanguage [3] Language OPTIONAL,
carrier [4] Carrier{b2} OPTIONAL,
callingPartyNumber [5] CallingPartyNumber{b2} OPTIONAL,
originalCalledPartyID [6] OriginalCalledPartyID{b2} OPTIONAL,
redirectingPartyID [7] RedirectingPartyID{b2} OPTIONAL,
redirectionInformation [8] RedirectionInformation OPTIONAL,
callingPartysCategory [9] CallingPartysCategory OPTIONAL,
securityParameters [10] SecurityParameters OPTIONAL,
extensions [11] Extensions{b1} OPTIONAL,
...}, scfqop.&scfArgumentQOP}
initiateCallRequest{B1:b1, B2:b2} OPERATION ::= {
ARGUMENT InitiateCallRequestArg {b1,
b2}
RETURN RESULT FALSE
ERRORS
{missingCustomerRecord | missingParameter | systemFailure | scfTaskRefused
| unexpectedComponentSequence | unexpectedDataValue | unexpectedParameter
| parameterOutOfRange | securityError}
ALWAYS RESPONDS FALSE
CODE opcode-initiateCallRequest
}
-- Direction: supporting SCF -> controlling SCF, Timer: Ticr
-- This operation is used by the supporting SCF to request the controlling SCF to create a connection
-- between two parties using the address information provided by the supporting SCF.
InitiateCallRequestArg{B1:b1, B2:b2} ::=
OPTIONALLY-PROTECTED
{SEQUENCE {requestedType [0] RequestedType OPTIONAL,
destinationRelatedInfo
[1] SEQUENCE SIZE (1..2) OF DestinationRelatedInfo{b2}
OPTIONAL,
securityParameters [2] SecurityParameters OPTIONAL,
extensions [3] Extensions{b1} OPTIONAL,
...}, scfqop.&scfArgumentQOP}
networkCapability{B1:b1} OPERATION ::= {
ARGUMENT NetworkCapabilityArg {b1}
RESULT NetworkCapabilityResultArg {b1}
ERRORS
{missingCustomerRecord | missingParameter | systemFailure | scfTaskRefused
| unexpectedComponentSequence | unexpectedDataValue | unexpectedParameter
| securityError}
CODE opcode-networkCapability
}
-- Direction: supporting SCF ->controlling SCF, Timer Tnc
-- This operation is used by the supporting SCF to request from the controlling SCF which type of
-- service it supports.
NetworkCapabilityArg{B1:b1} ::=
OPTIONALLY-PROTECTED
{SEQUENCE {bearerCapabilities [0] BearerCapabilities OPTIONAL,
highLayerCompatibilities [1] HighLayerCompatibilities OPTIONAL,
supplementaryServices [2] SupplementaryServices OPTIONAL,
securityParameters [3] SecurityParameters OPTIONAL,
extensions [4] Extensions{b1} OPTIONAL,
...}, scfqop.&scfArgumentQOP}
NetworkCapabilityResultArg{B1:b1} ::=
OPTIONALLY-PROTECTED
{SEQUENCE {bearerCapabilities [0] BearerCapabilities OPTIONAL,
highLayerCompatibilities [1] HighLayerCompatibilities OPTIONAL,
supplementaryServices [2] SupplementaryServices OPTIONAL,
securityParameters [3] SecurityParameters OPTIONAL,
extensions [4] Extensions{b1} OPTIONAL,
...}, scfqop.&scfArgumentQOP}
notificationProvided{B1:b1, B2:b2} OPERATION ::= {
ARGUMENT NotificationProvidedArg {b1,
b2}
RETURN RESULT FALSE
ERRORS
{missingParameter | systemFailure | scfTaskRefused |
unexpectedComponentSequence | unexpectedDataValue | unexpectedParameter |
missingCustomerRecord | parameterOutOfRange | securityError}
ALWAYS RESPONDS FALSE
CODE opcode-notificationProvided
}
-- Direction: controlling SCF -> supporting SCF, Timer Tnp
-- This operation is used by the controlling SCF to request assistance from the assisting SCF
-- under specific call conditions specified prior to the sending of the operation or to notify the
-- outcome of a previous intervention of the assisting SCF.
NotificationProvidedArg{B1:b1, B2:b2} ::=
OPTIONALLY-PROTECTED
{SEQUENCE {notification [0] Notification,
notificationInformation
[1] NotificationInformation{b2} OPTIONAL,
securityParameters [2] SecurityParameters OPTIONAL,
extensions [3] Extensions{b1} OPTIONAL,
partyID [4] PartyID OPTIONAL,
...}, scfqop.&scfArgumentQOP}
confirmedNotificationProvided{B1:b1, B2:b2} OPERATION ::=
makeConfirm{notificationProvided{b1, b2},
opcode-confirmedNotificationProvided}
--Direction: controlling SCF ->supporting SCF , Timer Thinc
provideAnnouncementRequest{B1:b1, B2:b2} OPERATION ::= {
ARGUMENT ProvideAnnouncementRequestArg {b1,
b2}
RETURN RESULT FALSE
ERRORS
{missingCustomerRecord | missingParameter | systemFailure | scfTaskRefused
| unexpectedComponentSequence | unexpectedDataValue | unexpectedParameter
| parameterOutOfRange | securityError}
LINKED {announcementCompletionReport}
ALWAYS RESPONDS FALSE
CODE opcode-provideAnnouncementRequest
}
-- Direction: supporting SCF -> controlling SCF, Timer: Tpar
-- This operation is used by the supporting SCF to request the controlling SCF
-- to provide announcement to the user.
ProvideAnnouncementRequestArg{B1:b1, B2:b2} ::=
OPTIONALLY-PROTECTED
{SEQUENCE {infoToSend [0] InformationToSend{b2},
preferredLanguage [1] Language OPTIONAL,
securityParameters [2] SecurityParameters OPTIONAL,
srfAddress [3] CalledPartyNumber{b2} OPTIONAL,
userToConnect [4] UserToConnect OPTIONAL,
requestAnnouncementComplete [5] BOOLEAN DEFAULT TRUE,
extensions [6] Extensions{b1} OPTIONAL,
...}, scfqop.&scfArgumentQOP}
provideUserInformation{B1:b1, B2:b2, B6:b6} OPERATION ::= {
ARGUMENT ProvideUserInformationArg {b1,
b2}
RESULT ProvideUserInformationResultArg {b1,
b6}
ERRORS
{missingCustomerRecord | missingParameter | systemFailure | scfTaskRefused
| unexpectedComponentSequence | unexpectedDataValue | unexpectedParameter
| improperCallerResponse | parameterOutOfRange | securityError}
CODE opcode-provideUserInformation
}
-- Direction: supporting SCF -> controlling SCF, Timer Tpui
-- This operation is used by the supporting SCF to request information from the user that can be
-- interrogated by the controlling SCF.
ProvideUserInformationArg{B1:b1, B2:b2} ::=
OPTIONALLY-PROTECTED
{SEQUENCE {constraints [0] CollectedInfo,
infoToSend [1] InformationToSend{b2},
errorInfo [2] InformationToSend{b2} OPTIONAL,
typeOfRequestedInfo [3] InfoType DEFAULT numericString,
numberOfAllowedRetries [4] INTEGER(0..127) DEFAULT 0,
actions [5] Actions OPTIONAL,
preferredLanguage [6] Language OPTIONAL,
securityParameters [7] SecurityParameters OPTIONAL,
extensions [8] Extensions{b1} OPTIONAL,
srfAddress [10] CalledPartyNumber{b2} OPTIONAL,
userToConnect [11] UserToConnect OPTIONAL,
...}, scfqop.&scfArgumentQOP}
ProvideUserInformationResultArg{B1:b1, B6:b6} ::=
OPTIONALLY-PROTECTED
{SEQUENCE {userInformation [0] ReceivedInformation{b6},
securityParameters [1] SecurityParameters OPTIONAL,
extensions [2] Extensions{b1} OPTIONAL
}, scfqop.&scfArgumentQOP}
reportChargingInformation{B1:b1, B2:b2, B6:b6} OPERATION ::= {
ARGUMENT ReportChargingInformationArg {b1,
b2,
b6}
RETURN RESULT FALSE
ERRORS
{missingCustomerRecord | missingParameter | systemFailure | scfTaskRefused
| unexpectedComponentSequence | unexpectedDataValue | unexpectedParameter
| parameterOutOfRange | securityError}
ALWAYS RESPONDS FALSE
CODE opcode-reportChargingInformation
}
-- Direction: controlling SCF -> supporting SCF, Timer Trci
-- This operation is used to give to the assisting network charging information collected by the
-- controlling network.
ReportChargingInformationArg{B1:b1, B2:b2, B6:b6} ::=
OPTIONALLY-PROTECTED
{SEQUENCE {callRecord [0] CallRecord{b2} OPTIONAL,
remainingUserCredit [1] UserCredit{b6} OPTIONAL,
uniqueCallID [2] CallIdentifier OPTIONAL,
accountNumber [3] AccountNumber OPTIONAL,
securityParameters [4] SecurityParameters OPTIONAL,
countersValues [5] Meters OPTIONAL,
resetOfTransmittedCounters [6] BOOLEAN DEFAULT FALSE,
container [13] FreeContainer{b6} OPTIONAL,
correlationId [14] CorrelationID{b2} OPTIONAL,
acksequence [15] INTEGER OPTIONAL,
...,
...,
extensions [31] Extensions{b1} OPTIONAL
}, scfqop.&scfArgumentQOP}
confirmedReportChargingInformation{B1:b1, B2:b2, B6:b6} OPERATION ::=
makeConfirm{reportChargingInformation{b1, b2, b6},
opcode-confirmedReportChargingInformation}
--Direction: controlling SCF -> supporting SCF , Timer Trcic
requestNotification{B1:b1, B2:b2} OPERATION ::= {
ARGUMENT RequestNotificationArg {b1,
b2}
RETURN RESULT FALSE
ERRORS
{missingParameter | systemFailure | scfTaskRefused |
unexpectedComponentSequence | unexpectedDataValue | unexpectedParameter |
parameterOutOfRange | missingCustomerRecord | securityError}
ALWAYS RESPONDS FALSE
CODE opcode-requestNotification
}
-- Direction: supporting SCF -> controlling SCF, Timer Trn
-- This operation is used by the supporting SCF to request notification from the controlling SCF
-- under specific call conditions specified by this operation.
RequestNotificationArg{B1:b1, B2:b2} ::=
OPTIONALLY-PROTECTED
{SEQUENCE {requestedNotifications [0] RequestedNotifications{b2},
securityParameters [1] SecurityParameters OPTIONAL,
...,
...,
extensions [30] Extensions{b1} OPTIONAL
}, scfqop.&scfArgumentQOP}
runUserScript{B1:b1, B2:b2, B6:b6} OPERATION ::= {
ARGUMENT RunUserScriptArg {b1,
b2}
RESULT RunUserScriptResultArg {b1,
b6}
ERRORS
{missingCustomerRecord | missingParameter | systemFailure | scfTaskRefused
| unexpectedComponentSequence | unexpectedDataValue | unexpectedParameter
| improperCallerResponse | parameterOutOfRange | securityError}
CODE opcode-runUserScript
}
-- Direction: supporting SCF -> controlling SCF, Timer Trus
-- This operation is used by the supporting SCF to request the controlling SCF
-- to run a user interaction script.
RunUserScriptArg{B1:b1, B2:b2} ::=
OPTIONALLY-PROTECTED
{SEQUENCE {srfAddress [0] CalledPartyNumber{b2},
correlationID [1] CorrelationID{b2},
scfID [2] ScfID{b2},
userToConnect [3] UserToConnect OPTIONAL,
securityParameters [7] SecurityParameters OPTIONAL,
...,
...,
extensions [30] Extensions{b1} OPTIONAL
}, scfqop.&scfArgumentQOP}
RunUserScriptResultArg{B1:b1, B6:b6} ::=
ProvideUserInformationResultArg{b1, b6}
scfBind{B6:b6} OPERATION ::= {
ARGUMENT SCFBindArgument {b6}
OPTIONAL TRUE
RESULT SCFBindResult {b6}
OPTIONAL TRUE
ERRORS {scfBindFailure}
}
-- Direction: controlling SCF -> supporting SCF, or supporting SCF -> controlling SCF, Timer Tbi
-- This operation is used to establish a relationship between two SCFs. It is sent by the controlling/supporting SCF
-- each time it needs to initiate communications with another SCF.
SCFBindArgument{B6:b6} ::= SEQUENCE {
agreementID [0] AgreementID,
originatingScfAddress [1] ScfAddress{b6} OPTIONAL,
-- absent in a chained operation request which crosses
-- an international internetworking boundary
credentials [2] Credentials OPTIONAL
}
SCFBindResult{B6:b6} ::= SEQUENCE {
respondingScfAddress [0] ScfAddress{b6} OPTIONAL,
-- absent in a chained operation request which crosses
-- an international internetworking boundary
returnedCredentials [1] Credentials OPTIONAL
}
transferSTSI{B1:b1, B6:b6} OPERATION ::= {
ARGUMENT TransferSTSIArg {b1,
b6}
RETURN RESULT FALSE
ERRORS
{missingParameter | systemFailure | scfTaskRefused | unexpectedDataValue |
unexpectedParameter | parameterOutOfRange | securityError}
ALWAYS RESPONDS FALSE
CODE opcode-transferSTSI
}
-- Direction: controlling SCF -> supporting SCF, or supporting SCF -> controlling SCF, Timer Ttstsi
-- This operation is used by the invoking SCF to request or report service information from/to the responding SCF
TransferSTSIArg{B1:b1, B6:b6} ::=
OPTIONALLY-PROTECTED
{SEQUENCE {sSIInfo SSIInfo{b6},
securityParameters [2] SecurityParameters OPTIONAL,
...,
...,
extensions [3] Extensions{b1} OPTIONAL
}, scfqop.&scfArgumentQOP}
scfChained{OPERATION:operation, B1:b1, B2:b2, B6:b6} OPERATION ::= {
ARGUMENT OPTIONALLY-PROTECTED
{SEQUENCE {chainedArgument ChainingArgument{b1, b2},
argument [0] operation.&ArgumentType OPTIONAL
},
scfqop.&scfArgumentQOP}
RESULT OPTIONALLY-PROTECTED
{SEQUENCE {chainedResult ChainingResult{b1, b2, b6},
result [0] operation.&ResultType OPTIONAL
},
scfqop.&scfArgumentQOP}
ERRORS
{operation.&Errors | chainingRefused | securityError | scfReferral}
CODE operation.&operationCode
}
ChainingArgument{B1:b1, B2:b2} ::= SEQUENCE {
originatingSCF [0] ScfID{b2},
target [1] SubscriberID{b2} OPTIONAL,
traceInformation [2] TraceInformation{b2},
scfAuthenticationLevel
[3] AuthenticationLevel DEFAULT basicLevels:{level none},
timeLimit [4] UTCTime OPTIONAL,
securityParameters [5] SecurityParameters OPTIONAL,
extensions [6] Extensions{b1} OPTIONAL,
...
}
ChainingResult{B1:b1, B2:b2, B6:b6} ::= SEQUENCE {
ultimateResponder [0] ScfAddress{b6} OPTIONAL,
traceInformation [1] TraceInformation{b2},
securityParameters [2] SecurityParameters OPTIONAL,
extensions [3] Extensions{b1} OPTIONAL,
...
}
makeConfirm{OPERATION:operation, Code:code} OPERATION ::= {
ARGUMENT operation.&ArgumentType
OPTIONAL operation.&argumentTypeOptional
RESULT NULL
ERRORS {operation.&Errors}
ALWAYS RESPONDS TRUE
CODE code
}
chainedEstablishChargingRecord{B1:b1, B2:b2, B6:b6} OPERATION ::=
scfChained{establishChargingRecord{b1, b2, b6}, b1, b2, b6}
chainedHandlingInformationRequest{B1:b1, B2:b2, B6:b6} OPERATION ::=
scfChained{handlingInformationRequest{b1, b2, b6}, b1, b2, b6}
chainedHandlingInformationResult{B1:b1, B2:b2, B6:b6} OPERATION ::=
scfChained{handlingInformationResult{b1, b2}, b1, b2, b6}
chainedNetworkCapability{B1:b1, B2:b2, B6:b6} OPERATION ::=
scfChained{networkCapability{b1}, b1, b2, b6}
chainedNotificationProvided{B1:b1, B2:b2, B6:b6} OPERATION ::=
scfChained{notificationProvided{b1, b2}, b1, b2, b6}
chainedConfirmedNotificationProvided{B1:b1, B2:b2, B6:b6} OPERATION ::=
scfChained{confirmedNotificationProvided{b1, b2}, b1, b2, b6}
chainedProvideUserInformation{B1:b1, B2:b2, B6:b6} OPERATION ::=
scfChained{provideUserInformation{b1, b2, b6}, b1, b2, b6}
chainedReportChargingInformation{B1:b1, B2:b2, B6:b6} OPERATION ::=
scfChained{reportChargingInformation{b1, b2, b6}, b1, b2, b6}
chainedConfirmedReportChargingInformation{B1:b1, B2:b2, B6:b6} OPERATION ::=
scfChained{confirmedReportChargingInformation{b1, b2, b6}, b1, b2, b6}
chainedRequestNotification{B1:b1, B2:b2, B6:b6} OPERATION ::=
scfChained{requestNotification{b1, b2}, b1, b2, b6}
chainedRunUserScript{B1:b1, B2:b2, B6:b6} OPERATION ::=
scfChained{runUserScript{b1, b2, b6}, b1, b2, b6}
END
-- Generated by Asnp, the ASN.1 pretty-printer of France Telecom R&D