asn1/camel/CAP-gsmSSF-gsmSCF-ops-args.asn

   1 -- $Id$
   2 -- 3GPP TS 29.078 11.0.0 (2011-09)
   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) version8(7)}
   8
   9 DEFINITIONS IMPLICIT TAGS ::= BEGIN
  10
  11 -- This module contains the operations and operation arguments used for the
  12 -- gsmSSF \96 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) version8(7)}
  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) version12(12)}
  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) version12(12)}
  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) version12(12)}
  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 version8(7); Object Identifier 'datatypes'
 159 -- is also updated to version8(7). 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 version8(7); Object Identifier
 176 -- 'errortypes' is also updated to version8(7). 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 {PARAMETERS-BOUND : bound} OPERATION::= {
 349         ARGUMENT                        CollectInformationArg {bound}
 350         RETURN RESULT           FALSE
 351         ERRORS          {missingParameter |
 352                                         parameterOutOfRange |
 353                                         SystemFailure   |
 354                                         TaskRefused     |
 355                                         UnexpectedComponentSequence     |
 356                                         UnexpectedDataValue     |
 357                                         UnexpectedParameter}
 358         CODE                            opcode-collectInformation}
 359 -- Direction: gsmSCF-> gsmSSF, Timer: Tci
 360 -- This operation is used to request the gsmSSF to perform the call
 361 -- processing actions to prompt a calling party for additional digits.
 362
 363 CollectInformationArg {PARAMETERS-BOUND : bound} ::= SEQUENCE{
 364         extensions                                                                              [0]     Extensions {bound}      OPTIONAL,
 365         ...
 366 }
 367
 368 connect {PARAMETERS-BOUND : bound} OPERATION ::= {
 369         ARGUMENT                ConnectArg {bound}
 370         RETURN RESULT   FALSE
 371         ERRORS                  {missingParameter |
 372                                         parameterOutOfRange |
 373                                         systemFailure |
 374                                         taskRefused |
 375                                         unexpectedComponentSequence |
 376                                         unexpectedDataValue |
 377                                         unexpectedParameter |
 378                                         unknownLegID}
 379         CODE                    opcode-connect}
 380 -- Direction: gsmSCF-> gsmSSF, Timer: Tcon
 381 -- This operation is used to request the gsmSSF to perform the call processing actions
 382 -- to route or forward a call to a specified destination.
 383
 384 ConnectArg {PARAMETERS-BOUND : bound} ::= SEQUENCE {
 385         destinationRoutingAddress                       [0] DestinationRoutingAddress {bound},
 386         alertingPattern                                         [1] AlertingPattern                                                     OPTIONAL,
 387         originalCalledPartyID                           [6] OriginalCalledPartyID {bound}                       OPTIONAL,
 388         extensions                                                      [10] Extensions {bound}                                         OPTIONAL,
 389         carrier                                                         [11] Carrier {bound}                                            OPTIONAL,
 390         callingPartysCategory                           [28] CallingPartysCategory                                      OPTIONAL,
 391         redirectingPartyID                                      [29] RedirectingPartyID {bound}                         OPTIONAL,
 392         redirectionInformation                          [30] RedirectionInformation                                     OPTIONAL,
 393         genericNumbers                                          [14] GenericNumbers {bound}                                     OPTIONAL,
 394         serviceInteractionIndicatorsTwo         [15] ServiceInteractionIndicatorsTwo            OPTIONAL,
 395         chargeNumber                                            [19] ChargeNumber {bound}                                       OPTIONAL,
 396         legToBeConnected                                        [21] LegID                                                                      OPTIONAL,
 397         cug-Interlock                                           [31] CUG-Interlock                                                      OPTIONAL,
 398         cug-OutgoingAccess                                      [32] NULL                                                                       OPTIONAL,
 399         suppressionOfAnnouncement                       [55] SuppressionOfAnnouncement                          OPTIONAL,
 400         oCSIApplicable                                          [56] OCSIApplicable                                                     OPTIONAL,
 401         naOliInfo                                                       [57] NAOliInfo                                                          OPTIONAL,
 402         bor-InterrogationRequested                      [58] NULL                                                                       OPTIONAL,
 403         ... ,
 404         suppress-N-CSI                                          [59] NULL                                                                       OPTIONAL
 405         }
 406 -- na-Info is included at the discretion of the gsmSCF operator.
 407
 408 connectToResource {PARAMETERS-BOUND : bound} OPERATION ::= {
 409         ARGUMENT                ConnectToResourceArg {bound}
 410         RETURN RESULT   FALSE
 411         ERRORS                  {missingParameter |
 412                                         systemFailure |
 413                                         taskRefused |
 414                                         unexpectedComponentSequence |
 415                                         unexpectedDataValue |
 416                                         unexpectedParameter |
 417                                         unknownCSID}
 418         CODE                    opcode-connectToResource}
 419 -- Direction: gsmSCF -> gsmSSF, Timer: Tctr
 420 -- This operation is used to connect a call segment from the gsmSSF to the
 421 -- gsmSRF.
 422
 423 ConnectToResourceArg {PARAMETERS-BOUND : bound} ::= SEQUENCE {
 424         resourceAddress CHOICE {
 425                 ipRoutingAddress                                        [0] IPRoutingAddress {bound},
 426                 none                                                            [3] NULL
 427                 },
 428         extensions                                                      [4] Extensions {bound}                                          OPTIONAL,
 429         serviceInteractionIndicatorsTwo         [7] ServiceInteractionIndicatorsTwo                     OPTIONAL,
 430         callSegmentID                                           [50] CallSegmentID {bound}                                      OPTIONAL,
 431         ...
 432         }
 433
 434 continue OPERATION ::= {
 435         RETURN RESULT   FALSE
 436         ALWAYS RESPONDS FALSE
 437         CODE                    opcode-continue}
 438 -- Direction: gsmSCF -> gsmSSF, Timer: Tcue
 439 -- This operation is used to request the gsmSSF to proceed with call processing at the
 440 -- DP at which it previously suspended call processing to await gsmSCF instructions
 441 -- (i.e. proceed to the next point in call in the BCSM). The gsmSSF continues call
 442 -- processing without substituting new data from gsmSCF.
 443
 444 continueWithArgument {PARAMETERS-BOUND : bound} OPERATION ::= {
 445         ARGUMENT                ContinueWithArgumentArg {bound}
 446         RETURN RESULT   FALSE
 447         ERRORS                  {missingParameter |
 448                                         parameterOutOfRange |
 449                                         unexpectedComponentSequence |
 450                                         unexpectedDataValue |
 451                                         unexpectedParameter |
 452                                         unknownLegID |
 453                                         unknownCSID}
 454         CODE                    opcode-continueWithArgument}
 455 -- Direction: gsmSCF -> gsmSSF, Timer: Tcwa
 456 -- This operation is used to request the gsmSSF to proceed with call processing at the
 457 -- DP at which it previously suspended call processing to await gsmSCF instructions
 458 -- (i.e. proceed to the next point in call in the BCSM). The gsmSSF continues call
 459 -- processing with the modified call setup information as received from the gsmSCF.
 460
 461 ContinueWithArgumentArg {PARAMETERS-BOUND : bound} ::= SEQUENCE {
 462         alertingPattern                                         [1] AlertingPattern                                                     OPTIONAL,
 463         extensions                                                      [6] Extensions {bound}                                          OPTIONAL,
 464         serviceInteractionIndicatorsTwo         [7] ServiceInteractionIndicatorsTwo                     OPTIONAL,
 465         callingPartysCategory                           [12] CallingPartysCategory                                      OPTIONAL,
 466         genericNumbers                                          [16] GenericNumbers {bound}                                     OPTIONAL,
 467         cug-Interlock                                           [17] CUG-Interlock                                                      OPTIONAL,
 468         cug-OutgoingAccess                                      [18] NULL                                                                       OPTIONAL,
 469         chargeNumber                                            [50] ChargeNumber {bound}                                       OPTIONAL,
 470         carrier                                                         [52] Carrier {bound}                                            OPTIONAL,
 471         suppressionOfAnnouncement                       [55] SuppressionOfAnnouncement                          OPTIONAL,
 472         naOliInfo                                                       [56] NAOliInfo                                                          OPTIONAL,
 473         bor-InterrogationRequested                      [57] NULL                                                                       OPTIONAL,
 474         suppress-O-CSI                                          [58] NULL                                                                       OPTIONAL,
 475         continueWithArgumentArgExtension        [59] ContinueWithArgumentArgExtension {bound} OPTIONAL,
 476         ...
 477         }
 478
 479 ContinueWithArgumentArgExtension {PARAMETERS-BOUND : bound} ::= SEQUENCE {
 480         suppress-D-CSI                                          [0]     NULL                                                                    OPTIONAL,
 481         suppress-N-CSI                                          [1]     NULL                                                                    OPTIONAL,
 482         suppressOutgoingCallBarring                     [2]     NULL                                                                    OPTIONAL,
 483         legOrCallSegment                                        [3]     LegOrCallSegment {bound}                                OPTIONAL,
 484         ...
 485         }
 486
 487 disconnectForwardConnection OPERATION ::= {
 488         RETURN RESULT   FALSE
 489         ERRORS                  {systemFailure |
 490                                         taskRefused |
 491                                         unexpectedComponentSequence}
 492         CODE                    opcode-disconnectForwardConnection}
 493 -- Direction: gsmSCF -> gsmSSF, Timer: Tdfc
 494 -- This operation is used to disconnect a forward temporary connection or a connection to a
 495 -- resource. Refer to clause 11 for a description of the procedures associated with this operation.
 496
 497 disconnectForwardConnectionWithArgument {PARAMETERS-BOUND : bound} OPERATION ::= {
 498         ARGUMENT                DisconnectForwardConnectionWithArgumentArg {bound}
 499         RETURN RESULT   FALSE
 500         ERRORS                  {missingParameter |
 501                                         systemFailure |
 502                                         taskRefused |
 503                                         unexpectedComponentSequence |
 504                                         unexpectedDataValue |
 505                                         unexpectedParameter |
 506                                         unknownCSID}
 507         CODE                    opcode-dFCWithArgument}
 508 -- Direction gsmSCF -> gsmSSF, Timer Tdfcwa
 509 -- This operation is used to disconnect a forward temporary connection or a connection to a
 510 -- resource. Refer to clause 11 for a description of the procedures associated with this operation.
 511
 512 DisconnectForwardConnectionWithArgumentArg {PARAMETERS-BOUND : bound} ::= SEQUENCE {
 513         callSegmentID                                           [1] CallSegmentID {bound}                                       OPTIONAL,
 514         extensions                                                      [2] Extensions {bound}                                          OPTIONAL,
 515         ...
 516         }
 517
 518 disconnectLeg {PARAMETERS-BOUND : bound} OPERATION ::= {
 519         ARGUMENT                DisconnectLegArg {bound}
 520         RETURN RESULT   TRUE
 521         ERRORS                  {missingParameter |
 522                                         systemFailure |
 523                                         taskRefused |
 524                                         unexpectedComponentSequence |
 525                                         unexpectedDataValue |
 526                                         unexpectedParameter |
 527                                         unknownLegID}
 528         CODE                    opcode-disconnectLeg}
 529 -- Direction: gsmSCF -> gsmSSF, Timer Tdl
 530 -- This operation is used by the gsmSCF to release a specific leg associated with the call and
 531 -- retain any other legs not specified in the DisconnectLeg. Refer to clause 11 for a description
 532 -- of the procedures associated with this operation.
 533
 534 DisconnectLegArg {PARAMETERS-BOUND : bound} ::= SEQUENCE {
 535         legToBeReleased                                         [0]     LegID,
 536         releaseCause                                            [1]     Cause {bound}                                                   OPTIONAL,
 537         extensions                                                      [2]     Extensions {bound}                                              OPTIONAL,
 538         ...
 539         }
 540
 541 entityReleased {PARAMETERS-BOUND : bound} OPERATION ::= {
 542         ARGUMENT                EntityReleasedArg {bound}
 543         RETURN RESULT   FALSE
 544         ALWAYS RESPONDS FALSE
 545         CODE                    opcode-entityReleased}
 546 -- Direction: gsmSSF -> gsmSCF, Timer: Ter
 547 -- This operation is used by the gsmSSF to inform the gsmSCF of an error or exception
 548
 549 EntityReleasedArg {PARAMETERS-BOUND : bound} ::= CHOICE {
 550         callSegmentFailure                                      [0]     CallSegmentFailure {bound},
 551         bCSM-Failure                                            [1]     BCSM-Failure {bound}
 552         }
 553
 554 establishTemporaryConnection {PARAMETERS-BOUND : bound} OPERATION ::= {
 555         ARGUMENT                EstablishTemporaryConnectionArg {bound}
 556         RETURN RESULT   FALSE
 557         ERRORS                  {eTCFailed |
 558                                         missingParameter |
 559                                         systemFailure |
 560                                         taskRefused |
 561                                         unexpectedComponentSequence |
 562                                         unexpectedDataValue |
 563                                         unexpectedParameter |
 564                                         unknownCSID}
 565         CODE                    opcode-establishTemporaryConnection}
 566 -- Direction: gsmSCF -> gsmSSF, Timer: Tetc
 567 -- This operation is used to create a connection to a resource for a limited period
 568 -- of time (e.g. to play an announcement, to collect user information); it implies
 569 -- the use of the assist procedure. Refer to clause 11 for a description of the
 570 -- procedures associated with this operation.
 571
 572 EstablishTemporaryConnectionArg {PARAMETERS-BOUND : bound} ::= SEQUENCE {
 573         assistingSSPIPRoutingAddress            [0] AssistingSSPIPRoutingAddress {bound},
 574         correlationID                                           [1] CorrelationID {bound}                                       OPTIONAL,
 575         scfID                                                           [3] ScfID {bound}                                                       OPTIONAL,
 576         extensions                                                      [4] Extensions {bound}                                          OPTIONAL,
 577         carrier                                                         [5] Carrier {bound}                                                     OPTIONAL,
 578         serviceInteractionIndicatorsTwo         [6] ServiceInteractionIndicatorsTwo                     OPTIONAL,
 579         callSegmentID                                           [7]     CallSegmentID {bound}                                   OPTIONAL,
 580         naOliInfo                                                       [50] NAOliInfo                                                          OPTIONAL,
 581         chargeNumber                                            [51] ChargeNumber {bound}                                       OPTIONAL,
 582         ...,
 583         originalCalledPartyID                           [52] OriginalCalledPartyID {bound}                      OPTIONAL,
 584         callingPartyNumber                                      [53] CallingPartyNumber {bound}                         OPTIONAL
 585         }
 586
 587 eventReportBCSM {PARAMETERS-BOUND : bound} OPERATION ::= {
 588         ARGUMENT                EventReportBCSMArg {bound}
 589         RETURN RESULT   FALSE
 590         ALWAYS RESPONDS FALSE
 591         CODE                    opcode-eventReportBCSM}
 592 -- Direction: gsmSSF -> gsmSCF, Timer: Terb
 593 -- This operation is used to notify the gsmSCF of a call-related event (e.g. BCSM
 594 -- events such as O_Busy or O_No_Answer) previously requested by the gsmSCF in a
 595 -- RequestReportBCSMEvent operation.
 596
 597 EventReportBCSMArg {PARAMETERS-BOUND : bound} ::= SEQUENCE {
 598         eventTypeBCSM                                           [0] EventTypeBCSM,
 599         eventSpecificInformationBCSM            [2] EventSpecificInformationBCSM {bound}        OPTIONAL,
 600         legID                                                           [3] ReceivingSideID                                                     OPTIONAL,
 601         miscCallInfo                                            [4] MiscCallInfo DEFAULT {messageType request},
 602         extensions                                                      [5] Extensions {bound}                                          OPTIONAL,
 603         ...
 604         }
 605
 606 furnishChargingInformation {PARAMETERS-BOUND : bound} OPERATION ::= {
 607         ARGUMENT                FurnishChargingInformationArg {bound}
 608         RETURN RESULT   FALSE
 609         ERRORS                  {missingParameter |
 610                                         taskRefused |
 611                                         unexpectedComponentSequence |
 612                                         unexpectedDataValue |
 613                                         unexpectedParameter |
 614                                         unknownLegID}
 615         CODE                    opcode-furnishChargingInformation}
 616 -- Direction: gsmSCF -> gsmSSF, Timer: Tfci
 617 -- This operation is used to request the gsmSSF to generate, register a call record
 618 -- or to include some information in the default call record.
 619 -- The registered call record is intended for off line charging of the call.
 620
 621 FurnishChargingInformationArg {PARAMETERS-BOUND : bound} ::=
 622         FCIBillingChargingCharacteristics{bound}
 623
 624 initialDP {PARAMETERS-BOUND : bound} OPERATION ::= {
 625         ARGUMENT                InitialDPArg {bound}
 626         RETURN RESULT   FALSE
 627         ERRORS                  {missingCustomerRecord |
 628                                         missingParameter |
 629                                         parameterOutOfRange |
 630                                         systemFailure |
 631                                         taskRefused |
 632                                         unexpectedComponentSequence |
 633                                         unexpectedDataValue |
 634                                         unexpectedParameter}
 635         CODE                    opcode-initialDP}
 636 -- Direction: gsmSSF -> gsmSCF, Timer: Tidp
 637 -- This operation is used after a TDP to indicate request for service.
 638
 639 InitialDPArg {PARAMETERS-BOUND : bound} ::= SEQUENCE {
 640         serviceKey                                                      [0] ServiceKey  ,
 641         calledPartyNumber                                       [2] CalledPartyNumber {bound}                           OPTIONAL,
 642         callingPartyNumber                                      [3] CallingPartyNumber {bound}                          OPTIONAL,
 643         callingPartysCategory                           [5] CallingPartysCategory                                       OPTIONAL,
 644         cGEncountered                                           [7] CGEncountered                                                       OPTIONAL,
 645         iPSSPCapabilities                                       [8] IPSSPCapabilities {bound}                           OPTIONAL,
 646         locationNumber                                          [10] LocationNumber {bound}                                     OPTIONAL,
 647         originalCalledPartyID                           [12] OriginalCalledPartyID {bound}                      OPTIONAL,
 648         extensions                                                      [15] Extensions {bound}                                         OPTIONAL,
 649         highLayerCompatibility                          [23] HighLayerCompatibility                                     OPTIONAL,
 650         additionalCallingPartyNumber            [25] AdditionalCallingPartyNumber {bound}       OPTIONAL,
 651         bearerCapability                                        [27] BearerCapability {bound}                           OPTIONAL,
 652         eventTypeBCSM                                           [28] EventTypeBCSM                                                      OPTIONAL,
 653         redirectingPartyID                                      [29] RedirectingPartyID {bound}                         OPTIONAL,
 654         redirectionInformation                          [30] RedirectionInformation                                     OPTIONAL,
 655         cause                                                           [17] Cause {bound}                                                      OPTIONAL,
 656         serviceInteractionIndicatorsTwo         [32] ServiceInteractionIndicatorsTwo            OPTIONAL,
 657         carrier                                                         [37] Carrier {bound}                                            OPTIONAL,
 658         cug-Index                                                       [45] CUG-Index                                                          OPTIONAL,
 659         cug-Interlock                                           [46] CUG-Interlock                                                      OPTIONAL,
 660         cug-OutgoingAccess                                      [47] NULL                                                                       OPTIONAL,
 661         iMSI                                                            [50] IMSI                                                                       OPTIONAL,
 662         subscriberState                                         [51] SubscriberState                                            OPTIONAL,
 663         locationInformation                                     [52] LocationInformation                                        OPTIONAL,
 664         ext-basicServiceCode                            [53] Ext-BasicServiceCode                                       OPTIONAL,
 665         callReferenceNumber                                     [54] CallReferenceNumber                                        OPTIONAL,
 666         mscAddress                                                      [55] ISDN-AddressString                                         OPTIONAL,
 667         calledPartyBCDNumber                            [56] CalledPartyBCDNumber {bound}                       OPTIONAL,
 668         timeAndTimezone                                         [57] TimeAndTimezone {bound}                            OPTIONAL,
 669         callForwardingSS-Pending                        [58] NULL                                                                       OPTIONAL,
 670         initialDPArgExtension                           [59] InitialDPArgExtension {bound}                      OPTIONAL,
 671         ...
 672         }
 673
 674 InitialDPArgExtension {PARAMETERS-BOUND : bound} ::= SEQUENCE {
 675         gmscAddress                                                     [0] ISDN-AddressString                                          OPTIONAL,
 676         forwardingDestinationNumber                     [1] CalledPartyNumber {bound}                           OPTIONAL,
 677         ms-Classmark2                                           [2] MS-Classmark2                                                       OPTIONAL,
 678         iMEI                                                            [3] IMEI                                                                        OPTIONAL,
 679         supportedCamelPhases                            [4] SupportedCamelPhases                                        OPTIONAL,
 680         offeredCamel4Functionalities            [5] OfferedCamel4Functionalities                        OPTIONAL,
 681         bearerCapability2                                       [6] BearerCapability {bound}                            OPTIONAL,
 682         ext-basicServiceCode2                           [7] Ext-BasicServiceCode                                        OPTIONAL,
 683         highLayerCompatibility2                         [8] HighLayerCompatibility                                      OPTIONAL,
 684         lowLayerCompatibility                           [9] LowLayerCompatibility {bound}                       OPTIONAL,
 685         lowLayerCompatibility2                          [10] LowLayerCompatibility {bound}                      OPTIONAL,
 686         ...,
 687         enhancedDialledServicesAllowed          [11] NULL                                                                       OPTIONAL,
 688         uu-Data                                                         [12] UU-Data                                                            OPTIONAL,
 689         collectInformationAllowed                       [13] NULL                                                                       OPTIONAL,
 690         releaseCallArgExtensionAllowed          [14] NULL                                                                       OPTIONAL
 691 }
 692 -- If iPSSPCapabilities is not present then this denotes that a colocated gsmSRF is not
 693 -- supported by the gsmSSF. If present, then the gsmSSF supports a colocated gsmSRF capable
 694 -- of playing announcements via elementaryMessageIDs and variableMessages, the playing of
 695 -- tones and the collection of DTMF digits. Other supported capabilities are explicitly
 696 -- detailed in the IPSSPCapabilities parameter itself.
 697 -- Carrier is included at the discretion of the gsmSSF operator.
 698 -- The UserCSGInformation is conveyed in the LocationInformation. The encoding of the parameter is
 699 -- as defined in 3GPP TS 29.002 [11].
 700
 701 initiateCallAttempt {PARAMETERS-BOUND : bound} OPERATION ::= {
 702         ARGUMENT                InitiateCallAttemptArg {bound}
 703         RESULT                  InitiateCallAttemptRes {bound}
 704         ERRORS                  {missingParameter |
 705                                         parameterOutOfRange |
 706                                         systemFailure |
 707                                         taskRefused |
 708                                         unexpectedComponentSequence |
 709                                         unexpectedDataValue |
 710                                         unexpectedParameter
 711                                         }
 712         CODE                    opcode-initiateCallAttempt}
 713 -- Direction: gsmSCF -> gsmSSF, Timer Tica
 714 -- This operation is used to instruct the gsmSSF to create a new call to a call party using the
 715 -- address information provided by the gsmSCF.
 716
 717 InitiateCallAttemptArg {PARAMETERS-BOUND : bound} ::= SEQUENCE {
 718         destinationRoutingAddress                       [0]     DestinationRoutingAddress {bound},
 719         extensions                                                      [4]     Extensions {bound}                                              OPTIONAL,
 720         legToBeCreated                                          [5]     LegID                                                                   OPTIONAL,
 721         newCallSegment                                          [6]     CallSegmentID {bound}                                   OPTIONAL,
 722         callingPartyNumber                                      [30] CallingPartyNumber {bound}                         OPTIONAL,
 723         callReferenceNumber                                     [51] CallReferenceNumber                                        OPTIONAL,
 724         gsmSCFAddress                                           [52] ISDN-AddressString                                         OPTIONAL,
 725         suppress-T-CSI                                          [53] NULL                                                                       OPTIONAL,
 726         ...
 727         }
 728
 729 InitiateCallAttemptRes {PARAMETERS-BOUND : bound} ::= SEQUENCE {
 730         supportedCamelPhases                            [0] SupportedCamelPhases                                        OPTIONAL,
 731         offeredCamel4Functionalities            [1] OfferedCamel4Functionalities                        OPTIONAL,
 732         extensions                                                      [2]     Extensions {bound}                                              OPTIONAL,
 733         ...,
 734         releaseCallArgExtensionAllowed          [3]     NULL                                                                    OPTIONAL
 735         }
 736
 737 moveLeg {PARAMETERS-BOUND : bound} OPERATION ::= {
 738         ARGUMENT                MoveLegArg {bound}
 739         RETURN RESULT   TRUE
 740         ERRORS                  {missingParameter |
 741                                         systemFailure |
 742                                         taskRefused |
 743                                         unexpectedComponentSequence |
 744                                         unexpectedDataValue |
 745                                         unexpectedParameter |
 746                                         unknownLegID}
 747         CODE                    opcode-moveLeg}
 748 -- Direction: gsmSCF -> gsmSSF, Timer: Tml
 749 -- This operation is used by the gsmSCF to move a leg from one call segment to another call segment
 750 -- within the same call segment association.
 751
 752 MoveLegArg {PARAMETERS-BOUND : bound} ::= SEQUENCE{
 753         legIDToMove                                                     [0]     LegID,
 754         extensions                                                      [2]     Extensions {bound}                                              OPTIONAL,
 755         ...
 756         }
 757
 758 playTone {PARAMETERS-BOUND : bound} OPERATION ::= {
 759         ARGUMENT                PlayToneArg {bound}
 760         RETURN RESULT   FALSE
 761         ERRORS                  {missingParameter |
 762                                         parameterOutOfRange |
 763                                         systemFailure |
 764                                         unexpectedComponentSequence |
 765                                         unexpectedDataValue |
 766                                         unexpectedParameter |
 767                                         unknownLegID |
 768                                         unknownCSID}
 769         CODE                    opcode-playTone}
 770 -- Direction: gsmSCF -> gsmSSF, Timer: Tpt
 771 -- This operation is used to play tones to either a leg or a call segment using
 772 -- the MSC's tone generator.
 773
 774 PlayToneArg {PARAMETERS-BOUND : bound} ::= SEQUENCE {
 775         legOrCallSegment                                        [0] LegOrCallSegment {bound},
 776         bursts                                                          [1] Burst,
 777         extensions                                                      [2] Extensions {bound}                                          OPTIONAL,
 778         ...
 779         }
 780
 781 releaseCall {PARAMETERS-BOUND : bound} OPERATION ::= {
 782         ARGUMENT                ReleaseCallArg {bound}
 783         RETURN RESULT   FALSE
 784         ALWAYS RESPONDS FALSE
 785         CODE                    opcode-releaseCall}
 786 -- Direction: gsmSCF ->?gsmSSF, Timer: Trc
 787 -- This operation is used to tear down an existing call at any phase of the call for all parties
 788 -- involved in the call.
 789
 790 ReleaseCallArg {PARAMETERS-BOUND : bound} ::= CHOICE {
 791         allCallSegments                                 AllCallSegments,
 792         allCallSegmentsWithExtension    [2] AllCallSegmentsWithExtension
 793         }
 794
 795 AllCallSegments ::= Cause {bound}
 796 -- A default value of decimal 31 (normal unspecified) shall be given.
 797
 798 AllCallSegmentsWithExtension ::= SEQUENCE {
 799         allCallSegments                         [0] AllCallSegments,
 800         extensions                                      [1] Extensions {bound} OPTIONAL
 801         }
 802
 803 requestReportBCSMEvent {PARAMETERS-BOUND : bound} OPERATION ::= {
 804         ARGUMENT                RequestReportBCSMEventArg {bound}
 805         RETURN RESULT   FALSE
 806         ERRORS                  {missingParameter |
 807                                         parameterOutOfRange |
 808                                         systemFailure |
 809                                         taskRefused |
 810                                         unexpectedComponentSequence |
 811                                         unexpectedDataValue |
 812                                         unexpectedParameter |
 813                                         unknownLegID}
 814         CODE                    opcode-requestReportBCSMEvent}
 815 -- Direction: gsmSCF -> gsmSSF, Timer: Trrb
 816 -- This operation is used to request the gsmSSF to monitor for a call-related event
 817 -- (e.g. BCSM events such as O_Busy or O_No_Answer) and to send a notification
 818 -- to the gsmSCF when the event is detected.
 819 --
 820 -- NOTE:
 821 -- Every EDP must be explicitly armed by the gsmSCF via a RequestReportBCSMEvent operation.
 822 -- No implicit arming of EDPs at the gsmSSF after reception of any operation (different
 823 -- from RequestReportBCSMEvent) from the gsmSCF is allowed.
 824
 825 RequestReportBCSMEventArg {PARAMETERS-BOUND : bound} ::= SEQUENCE {
 826         bcsmEvents                                                      [0] SEQUENCE SIZE(1..bound.&numOfBCSMEvents) OF
 827                                                                                                 BCSMEvent {bound},
 828         extensions                                                      [2] Extensions {bound}                                          OPTIONAL,
 829         ...
 830         }
 831 -- Indicates the BCSM related events for notification.
 832
 833 resetTimer {PARAMETERS-BOUND : bound} OPERATION ::= {
 834         ARGUMENT                ResetTimerArg {bound}
 835         RETURN RESULT   FALSE
 836         ERRORS                  {missingParameter |
 837                                         parameterOutOfRange |
 838                                         taskRefused |
 839                                         unexpectedComponentSequence |
 840                                         unexpectedDataValue |
 841                                         unexpectedParameter |
 842                                         unknownCSID}
 843         CODE                    opcode-resetTimer}
 844 -- Direction: gsmSCF -> gsmSSF, Timer: Trt
 845 -- This operation is used to request the gsmSSF to refresh an application timer in the gsmSSF.
 846
 847 ResetTimerArg {PARAMETERS-BOUND : bound} ::= SEQUENCE {
 848         timerID                                                         [0] TimerID     DEFAULT tssf,
 849         timervalue                                                      [1] TimerValue,
 850         extensions                                                      [2] Extensions {bound}                                          OPTIONAL,
 851         callSegmentID                                           [3]     CallSegmentID {bound}                                   OPTIONAL,
 852         ...
 853         }
 854
 855 sendChargingInformation {PARAMETERS-BOUND : bound} OPERATION ::= {
 856         ARGUMENT                SendChargingInformationArg {bound}
 857         RETURN RESULT   FALSE
 858         ERRORS                  {missingParameter |
 859                                         unexpectedComponentSequence |
 860                                         unexpectedParameter |
 861                                         parameterOutOfRange |
 862                                         systemFailure |
 863                                         taskRefused |
 864                                         unexpectedDataValue |
 865                                         unknownLegID}
 866         CODE                    opcode-sendChargingInformation}
 867 -- Direction: gsmSCF -> gsmSSF, Timer: Tsci
 868 -- This operation is used to instruct the gsmSSF on the charging information to send by the gsmSSF.
 869 -- The charging information can either be sent back by means of signalling or internal
 870 -- if the gsmSSF is located in the local exchange. In the local exchange
 871 -- this information may be used to update the charge meter or to create a standard call record.
 872
 873 SendChargingInformationArg {PARAMETERS-BOUND : bound}::= SEQUENCE {
 874         sCIBillingChargingCharacteristics       [0] SCIBillingChargingCharacteristics {bound},
 875         partyToCharge                                           [1] SendingSideID,
 876         extensions                                                      [2] Extensions {bound}                                          OPTIONAL,
 877         ...
 878         }
 879
 880 splitLeg {PARAMETERS-BOUND : bound} OPERATION ::= {
 881         ARGUMENT                SplitLegArg {bound}
 882         RETURN RESULT   TRUE
 883         ERRORS                  {missingParameter |
 884                                         unexpectedComponentSequence |
 885                                         unexpectedParameter |
 886                                         unexpectedDataValue |
 887                                         systemFailure |
 888                                         taskRefused |
 889                                         unknownLegID}
 890         CODE                    opcode-splitLeg}
 891 -- Direction: gsmSCF -> gsmSSF, Timer Tsl
 892 -- This operation is used by the gsmSCF to separate a leg from its source call segment and
 893 -- place it in a new call segment within the same call segment association.
 894
 895 SplitLegArg {PARAMETERS-BOUND : bound} ::= SEQUENCE {
 896         legToBeSplit                                            [0]     LegID,
 897         newCallSegment                                          [1]     CallSegmentID {bound}                                   OPTIONAL,
 898         extensions                                                      [2]     Extensions {bound}                                              OPTIONAL,
 899         ...
 900         }
 901
 902 END