f5042456b6438a747892ba4c81f36617a48c1bd9
[obnox/wireshark/wip.git] / asn1 / camel / CAP-gsmSSF-gsmSCF-ops-args.asn
1 -- $Id$
2 -- 3GPP TS 29.078 7.3.0 (2006-06)
3 -- 6    Circuit Switched Call Control
4 -- 6.1  gsmSSF/CCF - gsmSCF Interface
5 -- 6.1.1        Operations and arguments
6 CAP-gsmSSF-gsmSCF-ops-args {itu-t(0) identified-organization(4) etsi(0) mobileDomain(0)
7 umts-network(1) modules(3) cap-gsmSSF-gsmSCF-ops-args(101) version5(4)}
8
9 DEFINITIONS IMPLICIT TAGS ::= BEGIN
10
11 -- This module contains the operations and operation arguments used for the
12 -- gsmSSF - gsmSCF interface, for the control of circuit switched calls.
13
14 -- The table in subclause 2.1 lists the specifications that contain the modules
15 -- that are used by CAP.
16
17 IMPORTS
18
19         errortypes,
20         datatypes,
21         operationcodes,
22         classes,
23         tc-Messages,
24         ros-InformationObjects
25 FROM CAP-object-identifiers {itu-t(0) identified-organization(4) etsi(0) mobileDomain(0)
26 umts-network(1) modules(3) cap-object-identifiers(100) version5(4)}
27
28         OPERATION
29 FROM Remote-Operations-Information-Objects ros-InformationObjects
30
31         CallingPartysCategory,
32         HighLayerCompatibility,
33         LegID,
34         RedirectionInformation,
35         ServiceKey
36 FROM CS1-DataTypes {itu-t(0) identified-organization(4) etsi(0) inDomain(1) in-network(1)
37 modules(0) cs1-datatypes(2) version1(0)}
38
39         MiscCallInfo
40 FROM CS2-datatypes {itu-t(0) identified-organization(4) etsi(0) inDomain(1) in-network(1)
41 cs2(20) modules(0) in-cs2-datatypes (0) version1(0)}
42
43         Ext-BasicServiceCode,
44         IMEI,
45         IMSI,
46         ISDN-AddressString
47 FROM MAP-CommonDataTypes {itu-t(0) identified-organization(4) etsi(0) mobileDomain(0)
48 gsm-Network(1) modules(3) map-CommonDataTypes(18) version9(9)}
49
50         CUG-Index,
51         CUG-Interlock,
52         CUG-Info,
53         LocationInformation,
54         MS-Classmark2,
55         SubscriberState,
56         SupportedCamelPhases,
57         OfferedCamel4Functionalities
58 FROM MAP-MS-DataTypes {itu-t(0) identified-organization(4) etsi(0) mobileDomain(0)
59 gsm-Network(1) modules(3) map-MS-DataTypes(11) version9(9)}
60
61         CallReferenceNumber,
62         SuppressionOfAnnouncement,
63         UU-Data
64 FROM MAP-CH-DataTypes {itu-t(0) identified-organization(4) etsi(0) mobileDomain(0)
65 gsm-Network(1) modules(3) map-CH-DataTypes(13) version9(9)}
66
67         PARAMETERS-BOUND
68 FROM CAP-classes classes
69
70         opcode-activityTest,
71         opcode-applyCharging,
72         opcode-applyChargingReport,
73         opcode-assistRequestInstructions,
74         opcode-callGap,
75         opcode-callInformationReport,
76         opcode-callInformationRequest,
77         opcode-cancel,
78         opcode-collectInformation,
79         opcode-connect,
80         opcode-connectToResource,
81         opcode-continue,
82         opcode-continueWithArgument,
83         opcode-disconnectForwardConnection,
84         opcode-dFCWithArgument,
85         opcode-disconnectLeg,
86         opcode-entityReleased,
87         opcode-establishTemporaryConnection,
88         opcode-eventReportBCSM,
89         opcode-furnishChargingInformation,
90         opcode-initialDP,
91         opcode-initiateCallAttempt,
92         opcode-moveLeg,
93         opcode-playTone,
94         opcode-releaseCall,
95         opcode-requestReportBCSMEvent,
96         opcode-resetTimer,
97         opcode-sendChargingInformation,
98         opcode-splitLeg
99 FROM CAP-operationcodes operationcodes
100 -- The CAP Operation identifiers for CAP V4 in Rel-6 are the same as the CAP Operation
101 -- identifiers for CAP V4 in Rel-5.
102
103         AChBillingChargingCharacteristics {},
104         AdditionalCallingPartyNumber {},
105         AlertingPattern,
106         AChChargingAddress {},
107         AssistingSSPIPRoutingAddress {},
108         BCSMEvent {},
109         BCSM-Failure,
110         BearerCapability {},
111         Burst,
112         CalledPartyNumber {},
113         CalledPartyBCDNumber {},
114         CallingPartyNumber {},
115         CallResult {},
116         CallSegmentID {},
117         CallSegmentToCancel {},
118         CallSegmentFailure {},
119         Carrier,
120         Cause {},
121         CGEncountered,
122         ChargeNumber {},
123         ControlType,
124         CorrelationID {},
125         DestinationRoutingAddress {},
126         EventSpecificInformationBCSM {},
127         EventTypeBCSM,
128         Extensions {},
129         FCIBillingChargingCharacteristics {},
130         GapCriteria {},
131         GapIndicators,
132         GapTreatment,
133         GenericNumbers {},
134         InvokeID,
135         IPRoutingAddress {},
136         IPSSPCapabilities {},
137         leg1,
138         leg2,
139         LegOrCallSegment {},
140         LocationNumber {},
141         LowLayerCompatibility {},
142         MonitorMode,
143         NAOliInfo,
144         OCSIApplicable,
145         OriginalCalledPartyID {},
146         ReceivingSideID,
147         RedirectingPartyID {},
148         RequestedInformationList {},
149         RequestedInformationTypeList,
150         ScfID {},
151         SCIBillingChargingCharacteristics {},
152         SendingSideID,
153         ServiceInteractionIndicatorsTwo,
154         TimeAndTimezone {},
155         TimerID,
156         TimerValue
157 FROM CAP-datatypes datatypes
158 -- For Rel-6, the CAP-datatypes module is updated to version5(4); Object Identifier 'datatypes'
159 -- is also updated to version5(4). As a result, the present module uses Rel-6 data type definitions.
160
161         cancelFailed,
162         eTCFailed,
163         missingCustomerRecord,
164         missingParameter,
165         parameterOutOfRange,
166         requestedInfoError,
167         systemFailure,
168         taskRefused,
169         unexpectedComponentSequence,
170         unexpectedDataValue,
171         unexpectedParameter,
172         unknownLegID,
173         unknownCSID
174 FROM CAP-errortypes errortypes
175 -- For Rel-6, the CAP-errortypes module is updated to version5(4); Object Identifier
176 -- 'errortypes' is also updated to version5(4). As a result, the present module uses Rel-6
177 -- error type definitions.
178
179 ;
180
181 activityTest OPERATION ::= {
182         RETURN RESULT   TRUE
183         CODE                    opcode-activityTest}
184 -- Direction: gsmSCF -> gsmSSF, Timer: Tat
185 -- This operation is used to check for the continued existence of a relationship
186 -- between the gsmSCF and gsmSSF, assist gsmSSF or gsmSRF. If the relationship is
187 -- still in existence, then the gsmSSF will respond. If no reply is received,
188 -- then the gsmSCF will assume that the gsmSSF, assist gsmSSF or gsmSRF has failed
189 -- in some way.
190
191 applyCharging {PARAMETERS-BOUND : bound} OPERATION ::= {
192         ARGUMENT                ApplyChargingArg {bound}
193         RETURN RESULT   FALSE
194         ERRORS                  {missingParameter |
195                                         unexpectedComponentSequence |
196                                         unexpectedParameter |
197                                         unexpectedDataValue |
198                                         parameterOutOfRange |
199                                         systemFailure |
200                                         taskRefused |
201                                         unknownLegID |
202                                         unknownCSID}
203         CODE                    opcode-applyCharging}
204 -- Direction: gsmSCF -> gsmSSF, Timer: Tac
205 -- This operation is used for interacting from the gsmSCF with the gsmSSF charging mechanisms.
206 -- The ApplyChargingReport operation provides the feedback from the gsmSSF to the gsmSCF.
207
208 ApplyChargingArg {PARAMETERS-BOUND : bound} ::= SEQUENCE {
209         aChBillingChargingCharacteristics       [0] AChBillingChargingCharacteristics {bound},
210         partyToCharge                                           [2] SendingSideID DEFAULT sendingSideID : leg1,
211         extensions                                                      [3] Extensions {bound}                                          OPTIONAL,
212         aChChargingAddress                                      [50] AChChargingAddress {bound}
213                                                                                                 DEFAULT legID:sendingSideID:leg1,
214         ...
215         }
216
217 -- The partyToCharge parameter indicates the party in the call to which the ApplyCharging operation
218 -- shall be applied.
219
220 applyChargingReport {PARAMETERS-BOUND : bound} OPERATION ::= {
221         ARGUMENT                ApplyChargingReportArg {bound}
222         RETURN RESULT   FALSE
223         ERRORS                  {missingParameter |
224                                         unexpectedComponentSequence |
225                                         unexpectedParameter |
226                                         unexpectedDataValue |
227                                         unknownCSID |
228                                         unknownLegID |
229                                         parameterOutOfRange |
230                                         systemFailure |
231                                         taskRefused}
232         CODE                    opcode-applyChargingReport}
233 -- Direction: gsmSSF -> gsmSCF, Timer: Tacr
234 -- This operation is used by the gsmSSF to report to the gsmSCF the occurrence of a
235 -- specific charging event as requested by the gsmSCF using the ApplyCharging operation.
236
237 ApplyChargingReportArg {PARAMETERS-BOUND : bound} ::= CallResult {bound}
238
239 assistRequestInstructions {PARAMETERS-BOUND : bound} OPERATION ::= {
240         ARGUMENT                AssistRequestInstructionsArg {bound}
241         RETURN RESULT   FALSE
242         ERRORS                  {missingCustomerRecord |
243                                         missingParameter |
244                                         systemFailure |
245                                         taskRefused |
246                                         unexpectedComponentSequence |
247                                         unexpectedDataValue |
248                                         unexpectedParameter}
249         CODE                    opcode-assistRequestInstructions}
250 -- Direction: gsmSSF -> gsmSCF or gsmSRF -> gsmSCF, Timer: Tari
251 -- This operation is used when there is an assist procedure and may be
252 -- sent by the gsmSSF or gsmSRF to the gsmSCF. This operation is sent by the
253 -- assisting gsmSSF to gsmSCF, when the initiating gsmSSF has set up a connection to
254 -- the gsmSRF or to the assisting gsmSSF as a result of receiving an
255 -- EstablishTemporaryConnection from
256 -- the gsmSCF.
257 -- Refer to clause 11 for a description of the procedures associated with this operation.
258
259 AssistRequestInstructionsArg {PARAMETERS-BOUND : bound} ::= SEQUENCE {
260         correlationID                                           [0] CorrelationID {bound},
261         iPSSPCapabilities                                       [2] IPSSPCapabilities {bound},
262         extensions                                                      [3] Extensions {bound}                                          OPTIONAL,
263         ...
264         }
265 -- OPTIONAL denotes network operator specific use. The value of the correlationID may be the
266 -- Called Party Number supplied by the initiating gsmSSF.
267
268 callGap {PARAMETERS-BOUND : bound} OPERATION ::= {
269         ARGUMENT                CallGapArg {bound}
270         RETURN RESULT   FALSE
271         ALWAYS RESPONDS FALSE
272         CODE                    opcode-callGap}
273 -- Direction: gsmSCF -> gsmSSF, Timer: Tcg
274 -- This operation is used to request the gsmSSF to reduce the rate at which specific service
275 -- requests are sent to the gsmSCF.
276
277 CallGapArg {PARAMETERS-BOUND : bound}::= SEQUENCE {
278         gapCriteria                                                     [0] GapCriteria {bound},
279         gapIndicators                                           [1] GapIndicators,
280         controlType                                                     [2] ControlType                                                         OPTIONAL,
281         gapTreatment                                            [3] GapTreatment {bound}                                        OPTIONAL,
282         extensions                                                      [4] Extensions {bound}                                          OPTIONAL,
283         ...
284         }
285 -- OPTIONAL denotes network operator optional. If gapTreatment is not present, then the gsmSSF will
286 -- use a default treatment depending on network operator implementation.
287
288 callInformationReport {PARAMETERS-BOUND : bound} OPERATION ::= {
289         ARGUMENT                CallInformationReportArg {bound}
290         RETURN RESULT   FALSE
291         ALWAYS RESPONDS FALSE
292         CODE                    opcode-callInformationReport}
293 -- Direction: gsmSSF -> gsmSCF, Timer: Tcirp
294 -- This operation is used to send specific call information for a single call party to the gsmSCF as
295 -- requested by the gsmSCF in a previous CallInformationRequest.
296
297 CallInformationReportArg {PARAMETERS-BOUND : bound} ::= SEQUENCE {
298         requestedInformationList                        [0] RequestedInformationList {bound},
299         extensions                                                      [2] Extensions {bound}                                          OPTIONAL,
300         legID                                                           [3] ReceivingSideID DEFAULT receivingSideID:leg2,
301         ...
302         }
303
304 callInformationRequest {PARAMETERS-BOUND : bound} OPERATION ::= {
305         ARGUMENT                CallInformationRequestArg {bound}
306         RETURN RESULT   FALSE
307         ERRORS                  {missingParameter |
308                                         parameterOutOfRange |
309                                         requestedInfoError |
310                                         systemFailure |
311                                         taskRefused |
312                                         unexpectedComponentSequence |
313                                         unexpectedDataValue |
314                                         unexpectedParameter |
315                                         unknownLegID}
316         CODE                    opcode-callInformationRequest}
317 -- Direction: gsmSCF -> gsmSSF, Timer: Tcirq
318 -- This operation is used to request the gsmSSF to record specific information about a single
319 -- call party and report it to the gsmSCF (with a CallInformationReport operation).
320
321 CallInformationRequestArg {PARAMETERS-BOUND : bound}::= SEQUENCE {
322         requestedInformationTypeList            [0] RequestedInformationTypeList,
323         extensions                                                      [2] Extensions {bound}                                          OPTIONAL,
324         legID                                                           [3] SendingSideID DEFAULT sendingSideID:leg2,
325         ...
326         }
327 -- OPTIONAL denotes network operator optional.
328
329 cancel {PARAMETERS-BOUND : bound} OPERATION ::= {
330         ARGUMENT                CancelArg {bound}
331         RETURN RESULT   FALSE
332         ERRORS                  {cancelFailed |
333                                         missingParameter |
334                                         taskRefused |
335                                         unknownCSID}
336         CODE                    opcode-cancel}
337 -- Direction: gsmSCF -> gsmSSF, or gsmSCF -> gsmSRF, Timer: Tcan
338 -- This operation cancels the correlated previous operation or all previous requests. The following
339 -- operations can be canceled: PlayAnnouncement, PromptAndCollectUserInformation.
340
341 CancelArg {PARAMETERS-BOUND : bound} ::= CHOICE {
342         invokeID                                                        [0] InvokeID,
343         allRequests                                                     [1] NULL,
344         callSegmentToCancel                                     [2]     CallSegmentToCancel {bound}
345         }
346 -- The InvokeID has the same value as that which was used for the operation to be cancelled.
347
348 collectInformation OPERATION::= {
349 RETURN RESULT           FALSE
350 ALWAYS RESPONDS         FALSE
351 CODE                            opcode-collectInformation}
352 -- Direction: gsmSCF-> gsmSSF, Timer: Tci 
353 -- This operation is used to request the gsmSSF to perform the call
354 -- processing actions to prompt a calling party for additional destination informationdigits.
355
356 connect {PARAMETERS-BOUND : bound} OPERATION ::= {
357         ARGUMENT                ConnectArg {bound}
358         RETURN RESULT   FALSE
359         ERRORS                  {missingParameter |
360                                         parameterOutOfRange |
361                                         systemFailure |
362                                         taskRefused |
363                                         unexpectedComponentSequence |
364                                         unexpectedDataValue |
365                                         unexpectedParameter |
366                                         unknownLegID}
367         CODE                    opcode-connect}
368 -- Direction: gsmSCF-> gsmSSF, Timer: Tcon 
369 -- This operation is used to request the gsmSSF to perform the call processing actions
370 -- to route or forward a call to a specified destination.
371
372 ConnectArg {PARAMETERS-BOUND : bound} ::= SEQUENCE {
373         destinationRoutingAddress                       [0] DestinationRoutingAddress {bound},
374         alertingPattern                                         [1] AlertingPattern                             OPTIONAL,
375         originalCalledPartyID                           [6] OriginalCalledPartyID {bound}                       OPTIONAL,
376         extensions                                      [10] Extensions {bound}                                 OPTIONAL,
377         carrier                                         [11] Carrier {bound}                                    OPTIONAL,
378         callingPartysCategory                           [28] CallingPartysCategory                              OPTIONAL,
379         redirectingPartyID                              [29] RedirectingPartyID {bound}                         OPTIONAL,
380         redirectionInformation                          [30] RedirectionInformation                             OPTIONAL,
381         genericNumbers                                  [14] GenericNumbers {bound}                             OPTIONAL,
382         serviceInteractionIndicatorsTwo                 [15] ServiceInteractionIndicatorsTwo                    OPTIONAL,
383         chargeNumber                                    [19] ChargeNumber {bound}                               OPTIONAL,
384         legToBeConnected                                [21] LegID                                              OPTIONAL,
385         cug-Interlock                                   [31] CUG-Interlock                                      OPTIONAL,
386         cug-OutgoingAccess                              [32] NULL                                               OPTIONAL,
387         suppressionOfAnnouncement                       [55] SuppressionOfAnnouncement                          OPTIONAL,
388         oCSIApplicable                                  [56] OCSIApplicable                                     OPTIONAL,
389         naOliInfo                                       [57] NAOliInfo                                          OPTIONAL,
390         bor-InterrogationRequested                      [58] NULL                                               OPTIONAL,
391         ...,
392         suppress-N-CSI                                  [59] NULL                                               OPTIONAL
393
394         }
395 -- na-Info is included at the discretion of the gsmSCF operator.
396
397 connectToResource {PARAMETERS-BOUND : bound} OPERATION ::= {
398         ARGUMENT                ConnectToResourceArg {bound}
399         RETURN RESULT   FALSE
400         ERRORS                  {missingParameter |
401                                         systemFailure |
402                                         taskRefused |
403                                         unexpectedComponentSequence |
404                                         unexpectedDataValue |
405                                         unexpectedParameter |
406                                         unknownCSID}
407         CODE                    opcode-connectToResource}
408 -- Direction: gsmSCF -> gsmSSF, Timer: Tctr 
409 -- This operation is used to connect a call segment from the gsmSSF to the
410 -- gsmSRF.
411
412 ConnectToResourceArg {PARAMETERS-BOUND : bound} ::= SEQUENCE {
413         resourceAddress CHOICE {
414                 ipRoutingAddress                                        [0] IPRoutingAddress {bound},
415                 none                                                            [3] NULL
416                 },
417         extensions                                                      [4] Extensions {bound}                                          OPTIONAL,
418         serviceInteractionIndicatorsTwo         [7] ServiceInteractionIndicatorsTwo                     OPTIONAL,
419         callSegmentID                                           [50] CallSegmentID {bound}                                      OPTIONAL,
420         ...
421         }
422
423 continue OPERATION ::= {
424         RETURN RESULT   FALSE
425         ALWAYS RESPONDS FALSE
426         CODE                    opcode-continue}
427 -- Direction: gsmSCF -> gsmSSF, Timer: Tcue 
428 -- This operation is used to request the gsmSSF to proceed with call processing at the
429 -- DP at which it previously suspended call processing to await gsmSCF instructions
430 -- (i.e. proceed to the next point in call in the BCSM). The gsmSSF continues call
431 -- processing without substituting new data from gsmSCF.
432
433 continueWithArgument {PARAMETERS-BOUND : bound} OPERATION ::= {
434         ARGUMENT                ContinueWithArgumentArg {bound}
435         RETURN RESULT   FALSE
436         ERRORS                  {missingParameter |
437                                         parameterOutOfRange |
438                                         unexpectedComponentSequence |
439                                         unexpectedDataValue |
440                                         unexpectedParameter |
441                                         unknownLegID |
442                                         unknownCSID}
443         CODE                    opcode-continueWithArgument}
444 -- Direction: gsmSCF -> gsmSSF, Timer: Tcwa 
445 -- This operation is used to request the gsmSSF to proceed with call processing at the
446 -- DP at which it previously suspended call processing to await gsmSCF instructions
447 -- (i.e. proceed to the next point in call in the BCSM). The gsmSSF continues call
448 -- processing with the modified call setup information as received from the gsmSCF.
449
450 ContinueWithArgumentArg {PARAMETERS-BOUND : bound} ::= SEQUENCE {
451         alertingPattern                                         [1] AlertingPattern                                                     OPTIONAL,
452         extensions                                                      [6] Extensions {bound}                                          OPTIONAL,
453         serviceInteractionIndicatorsTwo         [7] ServiceInteractionIndicatorsTwo                     OPTIONAL,
454         callingPartysCategory                           [12] CallingPartysCategory                                      OPTIONAL,
455         genericNumbers                                          [16] GenericNumbers {bound}                                     OPTIONAL,
456         cug-Interlock                                           [17] CUG-Interlock                                                      OPTIONAL,
457         cug-OutgoingAccess                                      [18] NULL                                                                       OPTIONAL,
458         chargeNumber                                            [50] ChargeNumber {bound}                                       OPTIONAL,
459         carrier                                                         [52] Carrier {bound}                                            OPTIONAL,
460         suppressionOfAnnouncement                       [55] SuppressionOfAnnouncement                          OPTIONAL,
461         naOliInfo                                                       [56] NAOliInfo                                                          OPTIONAL,
462         bor-InterrogationRequested                      [57] NULL                                                                       OPTIONAL,
463         suppress-O-CSI                                          [58] NULL                                                                       OPTIONAL,
464         continueWithArgumentArgExtension        [59] ContinueWithArgumentArgExtension {bound} OPTIONAL,
465         ...
466         }
467
468 ContinueWithArgumentArgExtension {PARAMETERS-BOUND : bound} ::= SEQUENCE {
469         suppress-D-CSI                                          [0]     NULL                                                                    OPTIONAL,
470         suppress-N-CSI                                          [1]     NULL                                                                    OPTIONAL,
471         suppressOutgoingCallBarring                     [2]     NULL                                                                    OPTIONAL,
472         legOrCallSegment                                        [3]     LegOrCallSegment {bound}                                OPTIONAL,
473         ...
474         }
475
476 disconnectForwardConnection OPERATION ::= {
477         RETURN RESULT   FALSE
478         ERRORS                  {systemFailure |
479                                         taskRefused |
480                                         unexpectedComponentSequence}
481         CODE                    opcode-disconnectForwardConnection}
482 -- Direction: gsmSCF -> gsmSSF, Timer: Tdfc
483 -- This operation is used to disconnect a forward temporary connection or a connection to a 
484 -- resource. Refer to clause 11 for a description of the procedures associated with this operation. 
485
486 disconnectForwardConnectionWithArgument {PARAMETERS-BOUND : bound} OPERATION ::= {
487         ARGUMENT                DisconnectForwardConnectionWithArgumentArg {bound}
488         RETURN RESULT   FALSE
489         ERRORS                  {missingParameter |
490                                         systemFailure |
491                                         taskRefused |
492                                         unexpectedComponentSequence |
493                                         unexpectedDataValue |
494                                         unexpectedParameter |
495                                         unknownCSID}
496         CODE                    opcode-dFCWithArgument}
497 -- Direction gsmSCF -> gsmSSF, Timer Tdfcwa
498 -- This operation is used to disconnect a forward temporary connection or a connection to a
499 -- resource. Refer to clause 11 for a description of the procedures associated with this operation.
500
501 DisconnectForwardConnectionWithArgumentArg {PARAMETERS-BOUND : bound} ::= SEQUENCE {
502         callSegmentID                                           [1] CallSegmentID {bound}                                       OPTIONAL,
503         extensions                                                      [2] Extensions {bound}                                          OPTIONAL,
504         ...
505         }
506
507 disconnectLeg {PARAMETERS-BOUND : bound} OPERATION ::= {
508         ARGUMENT                DisconnectLegArg {bound}
509         RETURN RESULT   TRUE
510         ERRORS                  {missingParameter |
511                                         systemFailure |
512                                         taskRefused |
513                                         unexpectedComponentSequence |
514                                         unexpectedDataValue |
515                                         unexpectedParameter |
516                                         unknownLegID}
517         CODE                    opcode-disconnectLeg}
518 -- Direction: gsmSCF -> gsmSSF, Timer Tdl
519 -- This operation is used by the gsmSCF to release a specific leg associated with the call and
520 -- retain any other legs not specified in the DisconnectLeg. Refer to clause 11 for a description
521 -- of the procedures associated with this operation.
522
523 DisconnectLegArg {PARAMETERS-BOUND : bound} ::= SEQUENCE {
524         legToBeReleased                                         [0]     LegID,
525         releaseCause                                            [1]     Cause {bound}                                                   OPTIONAL,
526         extensions                                                      [2]     Extensions {bound}                                              OPTIONAL,
527         ...
528         }
529
530 entityReleased {PARAMETERS-BOUND : bound} OPERATION ::= {
531         ARGUMENT                EntityReleasedArg {bound}
532         RETURN RESULT   FALSE
533         ALWAYS RESPONDS FALSE
534         CODE                    opcode-entityReleased}
535 -- Direction: gsmSSF -> gsmSCF, Timer: Ter
536 -- This operation is used by the gsmSSF to inform the gsmSCF of an error or exception
537
538 EntityReleasedArg {PARAMETERS-BOUND : bound} ::= CHOICE {
539         callSegmentFailure                                      [0]     CallSegmentFailure {bound},
540         bCSM-Failure                                            [1]     BCSM-Failure {bound}
541         }
542
543 establishTemporaryConnection {PARAMETERS-BOUND : bound} OPERATION ::= {
544         ARGUMENT                EstablishTemporaryConnectionArg {bound}
545         RETURN RESULT   FALSE
546         ERRORS                  {eTCFailed |
547                                         missingParameter |
548                                         systemFailure |
549                                         taskRefused |
550                                         unexpectedComponentSequence |
551                                         unexpectedDataValue |
552                                         unexpectedParameter |
553                                         unknownCSID}
554         CODE                    opcode-establishTemporaryConnection}
555 -- Direction: gsmSCF -> gsmSSF, Timer: Tetc 
556 -- This operation is used to create a connection to a resource for a limited period
557 -- of time (e.g. to play an announcement, to collect user information); it implies
558 -- the use of the assist procedure. Refer to clause 11 for a description of the
559 -- procedures associated with this operation.
560
561 EstablishTemporaryConnectionArg {PARAMETERS-BOUND : bound} ::= SEQUENCE {
562         assistingSSPIPRoutingAddress            [0] AssistingSSPIPRoutingAddress {bound},
563         correlationID                                           [1] CorrelationID {bound}                                       OPTIONAL,
564         scfID                                                           [3] ScfID {bound}                                                       OPTIONAL,
565         extensions                                                      [4] Extensions {bound}                                          OPTIONAL,
566         carrier                                                         [5] Carrier {bound}                                                     OPTIONAL,
567         serviceInteractionIndicatorsTwo         [6] ServiceInteractionIndicatorsTwo                     OPTIONAL,
568         callSegmentID                                           [7]     CallSegmentID {bound}                                   OPTIONAL,
569         naOliInfo                                                       [50] NAOliInfo                                                          OPTIONAL,
570         chargeNumber                                            [51] ChargeNumber {bound}                                       OPTIONAL,
571         ...,
572         originalCalledPartyID                           [52] OriginalCalledPartyID {bound}                      OPTIONAL,
573         callingPartyNumber                                      [53] CallingPartyNumber {bound}                         OPTIONAL
574         }
575
576 eventReportBCSM {PARAMETERS-BOUND : bound} OPERATION ::= {
577         ARGUMENT                EventReportBCSMArg {bound}
578         RETURN RESULT   FALSE
579         ALWAYS RESPONDS FALSE
580         CODE                    opcode-eventReportBCSM}
581 -- Direction: gsmSSF -> gsmSCF, Timer: Terb
582 -- This operation is used to notify the gsmSCF of a call-related event (e.g. BCSM
583 -- events such as O_Busy or O_No_Answer) previously requested by the gsmSCF in a
584 -- RequestReportBCSMEvent operation.
585
586 EventReportBCSMArg {PARAMETERS-BOUND : bound} ::= SEQUENCE {
587         eventTypeBCSM                                           [0] EventTypeBCSM,
588         eventSpecificInformationBCSM            [2] EventSpecificInformationBCSM {bound}        OPTIONAL,
589         legID                                                           [3] ReceivingSideID                                                     OPTIONAL,
590         miscCallInfo                                            [4] MiscCallInfo DEFAULT {messageType request},
591         extensions                                                      [5] Extensions {bound}                                          OPTIONAL,
592         ...
593         }
594
595 furnishChargingInformation {PARAMETERS-BOUND : bound} OPERATION ::= {
596         ARGUMENT                FurnishChargingInformationArg {bound}
597         RETURN RESULT   FALSE
598         ERRORS                  {missingParameter |
599                                         taskRefused |
600                                         unexpectedComponentSequence |
601                                         unexpectedDataValue |
602                                         unexpectedParameter |
603                                         unknownLegID}
604         CODE                    opcode-furnishChargingInformation}
605 -- Direction: gsmSCF -> gsmSSF, Timer: Tfci
606 -- This operation is used to request the gsmSSF to generate, register a call record
607 -- or to include some information in the default call record.
608 -- The registered call record is intended for off line charging of the call.
609
610 FurnishChargingInformationArg {PARAMETERS-BOUND : bound} ::=
611         FCIBillingChargingCharacteristics{bound}
612
613 initialDP {PARAMETERS-BOUND : bound} OPERATION ::= {
614         ARGUMENT                InitialDPArg {bound}
615         RETURN RESULT   FALSE
616         ERRORS                  {missingCustomerRecord |
617                                         missingParameter |
618                                         parameterOutOfRange |
619                                         systemFailure |
620                                         taskRefused |
621                                         unexpectedComponentSequence |
622                                         unexpectedDataValue |
623                                         unexpectedParameter}
624         CODE                    opcode-initialDP}
625 -- Direction: gsmSSF -> gsmSCF, Timer: Tidp 
626 -- This operation is used after a TDP to indicate request for service.
627
628 InitialDPArg {PARAMETERS-BOUND : bound} ::= SEQUENCE {
629         serviceKey                                                      [0] ServiceKey  ,
630         calledPartyNumber                                       [2] CalledPartyNumber {bound}                           OPTIONAL,
631         callingPartyNumber                                      [3] CallingPartyNumber {bound}                          OPTIONAL,
632         callingPartysCategory                           [5] CallingPartysCategory                                       OPTIONAL,
633         cGEncountered                                           [7] CGEncountered                                                       OPTIONAL,
634         iPSSPCapabilities                                       [8] IPSSPCapabilities {bound}                           OPTIONAL,
635         locationNumber                                          [10] LocationNumber {bound}                                     OPTIONAL,
636         originalCalledPartyID                           [12] OriginalCalledPartyID {bound}                      OPTIONAL,
637         extensions                                                      [15] Extensions {bound}                                         OPTIONAL,
638         highLayerCompatibility                          [23] HighLayerCompatibility                                     OPTIONAL,
639         additionalCallingPartyNumber            [25] AdditionalCallingPartyNumber {bound}       OPTIONAL,
640         bearerCapability                                        [27] BearerCapability {bound}                           OPTIONAL,
641         eventTypeBCSM                                           [28] EventTypeBCSM                                                      OPTIONAL,
642         redirectingPartyID                                      [29] RedirectingPartyID {bound}                         OPTIONAL,
643         redirectionInformation                          [30] RedirectionInformation                                     OPTIONAL,
644         cause                                                           [17] Cause {bound}                                                      OPTIONAL,
645         serviceInteractionIndicatorsTwo         [32] ServiceInteractionIndicatorsTwo            OPTIONAL,
646         carrier                                                         [37] Carrier {bound}                                            OPTIONAL,
647         cug-Index                                                       [45] CUG-Index                                                          OPTIONAL,
648         cug-Interlock                                           [46] CUG-Interlock                                                      OPTIONAL,
649         cug-OutgoingAccess                                      [47] NULL                                                                       OPTIONAL,
650         iMSI                                                            [50] IMSI                                                                       OPTIONAL,
651         subscriberState                                         [51] SubscriberState                                            OPTIONAL,
652         locationInformation                                     [52] LocationInformation                                        OPTIONAL,
653         ext-basicServiceCode                            [53] Ext-BasicServiceCode                                       OPTIONAL,
654         callReferenceNumber                                     [54] CallReferenceNumber                                        OPTIONAL,
655         mscAddress                                                      [55] ISDN-AddressString                                         OPTIONAL,
656         calledPartyBCDNumber                            [56] CalledPartyBCDNumber {bound}                       OPTIONAL,
657         timeAndTimezone                                         [57] TimeAndTimezone {bound}                            OPTIONAL,
658         callForwardingSS-Pending                        [58] NULL                                                                       OPTIONAL,
659         initialDPArgExtension                           [59] InitialDPArgExtension {bound}                      OPTIONAL,
660         ...
661         }
662
663 InitialDPArgExtension {PARAMETERS-BOUND : bound} ::= SEQUENCE {
664         gmscAddress                                                     [0] ISDN-AddressString                                          OPTIONAL,
665         forwardingDestinationNumber                     [1] CalledPartyNumber {bound}                           OPTIONAL,
666         ms-Classmark2                                           [2] MS-Classmark2                                                       OPTIONAL,
667         iMEI                                                            [3] IMEI                                                                        OPTIONAL,
668         supportedCamelPhases                            [4] SupportedCamelPhases                                        OPTIONAL,
669         offeredCamel4Functionalities            [5] OfferedCamel4Functionalities                        OPTIONAL,
670         bearerCapability2                                       [6] BearerCapability {bound}                            OPTIONAL,
671         ext-basicServiceCode2                           [7] Ext-BasicServiceCode                                        OPTIONAL,
672         highLayerCompatibility2                         [8] HighLayerCompatibility                                      OPTIONAL,
673         lowLayerCompatibility                           [9] LowLayerCompatibility {bound}                       OPTIONAL,
674         lowLayerCompatibility2                          [10] LowLayerCompatibility {bound}                      OPTIONAL,
675         ...,
676         enhancedDialledServicesAllowed          [11] NULL                                                                       OPTIONAL,
677         uu-Data                                                         [12] UU-Data                                                            OPTIONAL,
678         collectInformationAllowed                       [13] NULL                                                                       OPTIONAL
679 }
680 -- If iPSSPCapabilities is not present then this denotes that a colocated gsmSRF is not 
681 -- supported by the gsmSSF. If present, then the gsmSSF supports a colocated gsmSRF capable 
682 -- of playing announcements via elementaryMessageIDs and variableMessages, the playing of
683 -- tones and the collection of DTMF digits. Other supported capabilities are explicitly 
684 -- detailed in the IPSSPCapabilities parameter itself.
685 -- Carrier is included at the discretion of the gsmSSF operator.
686
687 initiateCallAttempt {PARAMETERS-BOUND : bound} OPERATION ::= {
688         ARGUMENT                InitiateCallAttemptArg {bound}
689         RESULT                  InitiateCallAttemptRes {bound}
690         ERRORS                  {missingParameter |
691                                         parameterOutOfRange |
692                                         systemFailure |
693                                         taskRefused |
694                                         unexpectedComponentSequence |
695                                         unexpectedDataValue |
696                                         unexpectedParameter
697                                         }
698         CODE                    opcode-initiateCallAttempt}
699 -- Direction: gsmSCF -> gsmSSF, Timer Tica
700 -- This operation is used to instruct the gsmSSF to create a new call to a call party using the
701 -- address information provided by the gsmSCF.
702
703 InitiateCallAttemptArg {PARAMETERS-BOUND : bound} ::= SEQUENCE {
704         destinationRoutingAddress                       [0]     DestinationRoutingAddress {bound},
705         extensions                                                      [4]     Extensions {bound}                                              OPTIONAL,
706         legToBeCreated                                          [5]     LegID                                                                   OPTIONAL,
707         newCallSegment                                          [6]     CallSegmentID {bound}                                   OPTIONAL,
708         callingPartyNumber                                      [30] CallingPartyNumber {bound}                         OPTIONAL,
709         callReferenceNumber                                     [51] CallReferenceNumber                                        OPTIONAL,
710         gsmSCFAddress                                           [52] ISDN-AddressString                                         OPTIONAL,
711         suppress-T-CSI                                          [53] NULL                                                                       OPTIONAL,
712         ...
713         }
714
715 InitiateCallAttemptRes {PARAMETERS-BOUND : bound} ::= SEQUENCE {
716         supportedCamelPhases                            [0] SupportedCamelPhases                                        OPTIONAL,
717         offeredCamel4Functionalities            [1] OfferedCamel4Functionalities                        OPTIONAL,
718         extensions                                                      [2]     Extensions {bound}                                              OPTIONAL,
719         ...
720         }
721
722 moveLeg {PARAMETERS-BOUND : bound} OPERATION ::= {
723         ARGUMENT                MoveLegArg {bound}
724         RETURN RESULT   TRUE
725         ERRORS                  {missingParameter |
726                                         systemFailure |
727                                         taskRefused |
728                                         unexpectedComponentSequence |
729                                         unexpectedDataValue |
730                                         unexpectedParameter |
731                                         unknownLegID}
732         CODE                    opcode-moveLeg}
733 -- Direction: gsmSCF -> gsmSSF, Timer: Tml
734 -- This operation is used by the gsmSCF to move a leg from one call segment to another call segment
735 -- within the same call segment association.
736
737 MoveLegArg {PARAMETERS-BOUND : bound} ::= SEQUENCE{
738         legIDToMove                                                     [0]     LegID,
739         extensions                                                      [2]     Extensions {bound}                                              OPTIONAL,
740         ...
741         }
742
743 playTone {PARAMETERS-BOUND : bound} OPERATION ::= {
744         ARGUMENT                PlayToneArg {bound}
745         RETURN RESULT   FALSE
746         ERRORS                  {missingParameter |
747                                         parameterOutOfRange |
748                                         systemFailure |
749                                         unexpectedComponentSequence |
750                                         unexpectedDataValue |
751                                         unexpectedParameter |
752                                         unknownLegID |
753                                         unknownCSID}
754         CODE                    opcode-playTone}
755 -- Direction: gsmSCF -> gsmSSF, Timer: Tpt
756 -- This operation is used to play tones to either a leg or a call segment using
757 -- the MSC's tone generator.
758
759 PlayToneArg {PARAMETERS-BOUND : bound} ::= SEQUENCE {
760         legOrCallSegment                                        [0] LegOrCallSegment {bound},
761         bursts                                                          [1] Burst,
762         extensions                                                      [2] Extensions {bound}                                          OPTIONAL,
763         ...
764         }
765
766 releaseCall {PARAMETERS-BOUND : bound} OPERATION ::= {
767         ARGUMENT                ReleaseCallArg {bound}
768         RETURN RESULT   FALSE
769         ALWAYS RESPONDS FALSE
770         CODE                    opcode-releaseCall}
771 -- Direction: gsmSCF ->?gsmSSF, Timer: Trc 
772 -- This operation is used to tear down an existing call at any phase of the call for all parties 
773 -- involved in the call. 
774
775 ReleaseCallArg {PARAMETERS-BOUND : bound} ::= Cause {bound} 
776 -- A default value of decimal 31 (normal unspecified) shall be given.
777
778 requestReportBCSMEvent {PARAMETERS-BOUND : bound} OPERATION ::= {
779         ARGUMENT                RequestReportBCSMEventArg {bound}
780         RETURN RESULT   FALSE
781         ERRORS                  {missingParameter |
782                                         parameterOutOfRange |
783                                         systemFailure |
784                                         taskRefused |
785                                         unexpectedComponentSequence |
786                                         unexpectedDataValue |
787                                         unexpectedParameter |
788                                         unknownLegID}
789         CODE                    opcode-requestReportBCSMEvent}
790 -- Direction: gsmSCF -> gsmSSF, Timer: Trrb
791 -- This operation is used to request the gsmSSF to monitor for a call-related event
792 -- (e.g. BCSM events such as O_Busy or O_No_Answer) and to send a notification
793 -- to the gsmSCF when the event is detected.
794 --
795 -- NOTE:
796 -- Every EDP must be explicitly armed by the gsmSCF via a RequestReportBCSMEvent operation. 
797 -- No implicit arming of EDPs at the gsmSSF after reception of any operation (different 
798 -- from RequestReportBCSMEvent) from the gsmSCF is allowed.
799
800 RequestReportBCSMEventArg {PARAMETERS-BOUND : bound} ::= SEQUENCE {
801         bcsmEvents                                                      [0] SEQUENCE SIZE(1..bound.&numOfBCSMEvents) OF
802                                                                                                 BCSMEvent {bound},
803         extensions                                                      [2] Extensions {bound}                                          OPTIONAL,
804         ...
805         }
806 -- Indicates the BCSM related events for notification.
807
808 resetTimer {PARAMETERS-BOUND : bound} OPERATION ::= {
809         ARGUMENT                ResetTimerArg {bound}
810         RETURN RESULT   FALSE
811         ERRORS                  {missingParameter |
812                                         parameterOutOfRange |
813                                         taskRefused |
814                                         unexpectedComponentSequence |
815                                         unexpectedDataValue |
816                                         unexpectedParameter |
817                                         unknownCSID}
818         CODE                    opcode-resetTimer}
819 -- Direction: gsmSCF -> gsmSSF, Timer: Trt 
820 -- This operation is used to request the gsmSSF to refresh an application timer in the gsmSSF.
821
822 ResetTimerArg {PARAMETERS-BOUND : bound} ::= SEQUENCE {
823         timerID                                                         [0] TimerID     DEFAULT tssf,
824         timervalue                                                      [1] TimerValue,
825         extensions                                                      [2] Extensions {bound}                                          OPTIONAL,
826         callSegmentID                                           [3]     CallSegmentID {bound}                                   OPTIONAL,
827         ...
828         }
829
830 sendChargingInformation {PARAMETERS-BOUND : bound} OPERATION ::= {
831         ARGUMENT                SendChargingInformationArg {bound}
832         RETURN RESULT   FALSE
833         ERRORS                  {missingParameter |
834                                         unexpectedComponentSequence |
835                                         unexpectedParameter |
836                                         parameterOutOfRange |
837                                         systemFailure |
838                                         taskRefused |
839                                         unexpectedDataValue |
840                                         unknownLegID}
841         CODE                    opcode-sendChargingInformation}
842 -- Direction: gsmSCF -> gsmSSF, Timer: Tsci 
843 -- This operation is used to instruct the gsmSSF on the charging information to send by the gsmSSF.
844 -- The charging information can either be sent back by means of signalling or internal
845 -- if the gsmSSF is located in the local exchange. In the local exchange
846 -- this information may be used to update the charge meter or to create a standard call record.
847
848 SendChargingInformationArg {PARAMETERS-BOUND : bound}::= SEQUENCE {
849         sCIBillingChargingCharacteristics       [0] SCIBillingChargingCharacteristics {bound},
850         partyToCharge                                           [1] SendingSideID,
851         extensions                                                      [2] Extensions {bound}                                          OPTIONAL,
852         ...
853         }
854
855 splitLeg {PARAMETERS-BOUND : bound} OPERATION ::= {
856         ARGUMENT                SplitLegArg {bound}
857         RETURN RESULT   TRUE
858         ERRORS                  {missingParameter |
859                                         unexpectedComponentSequence |
860                                         unexpectedParameter |
861                                         unexpectedDataValue |
862                                         systemFailure |
863                                         taskRefused |
864                                         unknownLegID}
865         CODE                    opcode-splitLeg}
866 -- Direction: gsmSCF -> gsmSSF, Timer Tsl
867 -- This operation is used by the gsmSCF to separate a leg from its source call segment and
868 -- place it in a new call segment within the same call segment association.
869
870 SplitLegArg {PARAMETERS-BOUND : bound} ::= SEQUENCE {
871         legToBeSplit                                            [0]     LegID,
872         newCallSegment                                          [1]     CallSegmentID {bound}                                   OPTIONAL,
873         extensions                                                      [2]     Extensions {bound}                                              OPTIONAL,
874         ...
875         }
876
877 END