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