path: root/epan/dissectors/asn1/camel/CAP-gsmSSF-gsmSCF-ops-args.asn

-- 3GPP TS 29.078 11.0.0 (2011-09)
-- 6	Circuit Switched Call Control
-- 6.1	gsmSSF/CCF - gsmSCF Interface
-- 6.1.1	Operations and arguments
CAP-gsmSSF-gsmSCF-ops-args {itu-t(0) identified-organization(4) etsi(0) mobileDomain(0)
umts-network(1) modules(3) cap-gsmSSF-gsmSCF-ops-args(101) version8(7)}

DEFINITIONS IMPLICIT TAGS ::= BEGIN

-- This module contains the operations and operation arguments used for the
-- gsmSSF - gsmSCF interface, for the control of circuit switched calls.

-- The table in subclause 2.1 lists the specifications that contain the modules
-- that are used by CAP.

IMPORTS

	errortypes,
	datatypes,
	operationcodes,
	classes,
	tc-Messages,
	ros-InformationObjects
FROM CAP-object-identifiers {itu-t(0) identified-organization(4) etsi(0) mobileDomain(0)
umts-network(1) modules(3) cap-object-identifiers(100) version8(7)}

	OPERATION
FROM Remote-Operations-Information-Objects ros-InformationObjects

	CallingPartysCategory,
	HighLayerCompatibility,
	LegID,
	RedirectionInformation,
	ServiceKey
FROM CS1-DataTypes {itu-t(0) identified-organization(4) etsi(0) inDomain(1) in-network(1)
modules(0) cs1-datatypes(2) version1(0)}

	MiscCallInfo
FROM CS2-datatypes {itu-t(0) identified-organization(4) etsi(0) inDomain(1) in-network(1)
cs2(20) modules(0) in-cs2-datatypes (0) version1(0)}

	Ext-BasicServiceCode,
	IMEI,
	IMSI,
	ISDN-AddressString
FROM MAP-CommonDataTypes {itu-t(0) identified-organization(4) etsi(0) mobileDomain(0)
gsm-Network(1) modules(3) map-CommonDataTypes(18) version12(12)}

	CUG-Index,
	CUG-Interlock,
	CUG-Info,
	LocationInformation,
	MS-Classmark2,
	SubscriberState,
	SupportedCamelPhases,
	OfferedCamel4Functionalities
FROM MAP-MS-DataTypes {itu-t(0) identified-organization(4) etsi(0) mobileDomain(0)
gsm-Network(1) modules(3) map-MS-DataTypes(11) version12(12)}

	CallReferenceNumber,
	SuppressionOfAnnouncement,
	UU-Data
FROM MAP-CH-DataTypes {itu-t(0) identified-organization(4) etsi(0) mobileDomain(0)
gsm-Network(1) modules(3) map-CH-DataTypes(13) version12(12)}

	PARAMETERS-BOUND
FROM CAP-classes classes

	opcode-activityTest,
	opcode-applyCharging,
	opcode-applyChargingReport,
	opcode-assistRequestInstructions,
	opcode-callGap,
	opcode-callInformationReport,
	opcode-callInformationRequest,
	opcode-cancel,
	opcode-collectInformation,
	opcode-connect,
	opcode-connectToResource,
	opcode-continue,
	opcode-continueWithArgument,
	opcode-disconnectForwardConnection,
	opcode-dFCWithArgument,
	opcode-disconnectLeg,
	opcode-entityReleased,
	opcode-establishTemporaryConnection,
	opcode-eventReportBCSM,
	opcode-furnishChargingInformation,
	opcode-initialDP,
	opcode-initiateCallAttempt,
	opcode-moveLeg,
	opcode-playTone,
	opcode-releaseCall,
	opcode-requestReportBCSMEvent,
	opcode-resetTimer,
	opcode-sendChargingInformation,
	opcode-splitLeg
FROM CAP-operationcodes operationcodes
-- The CAP Operation identifiers for CAP V4 in Rel-6 are the same as the CAP Operation
-- identifiers for CAP V4 in Rel-5.

	AChBillingChargingCharacteristics {},
	AdditionalCallingPartyNumber {},
	AlertingPattern,
	AChChargingAddress {},
	AssistingSSPIPRoutingAddress {},
	BCSMEvent {},
	BCSM-Failure,
	BearerCapability {},
	Burst,
	CalledPartyNumber {},
	CalledPartyBCDNumber {},
	CallingPartyNumber {},
	CallResult {},
	CallSegmentID {},
	CallSegmentToCancel {},
	CallSegmentFailure {},
	Carrier,
	Cause {},
	CGEncountered,
	ChargeNumber {},
	ControlType,
	CorrelationID {},
	DestinationRoutingAddress {},
	EventSpecificInformationBCSM {},
	EventTypeBCSM,
	Extensions {},
	FCIBillingChargingCharacteristics {},
	GapCriteria {},
	GapIndicators,
	GapTreatment,
	GenericNumbers {},
	InvokeID,
	IPRoutingAddress {},
	IPSSPCapabilities {},
	leg1,
	leg2,
	LegOrCallSegment {},
	LocationNumber {},
	LowLayerCompatibility {},
	MonitorMode,
	NAOliInfo,
	OCSIApplicable,
	OriginalCalledPartyID {},
	ReceivingSideID,
	RedirectingPartyID {},
	RequestedInformationList {},
	RequestedInformationTypeList,
	ScfID {},
	SCIBillingChargingCharacteristics {},
	SendingSideID,
	ServiceInteractionIndicatorsTwo,
	TimeAndTimezone {},
	TimerID,
	TimerValue
FROM CAP-datatypes datatypes
-- For Rel-6, the CAP-datatypes module is updated to version8(7); Object Identifier 'datatypes'
-- is also updated to version8(7). As a result, the present module uses Rel-6 data type definitions.

	cancelFailed,
	eTCFailed,
	missingCustomerRecord,
	missingParameter,
	parameterOutOfRange,
	requestedInfoError,
	systemFailure,
	taskRefused,
	unexpectedComponentSequence,
	unexpectedDataValue,
	unexpectedParameter,
	unknownLegID,
	unknownCSID
FROM CAP-errortypes errortypes
-- For Rel-6, the CAP-errortypes module is updated to version8(7); Object Identifier
-- 'errortypes' is also updated to version8(7). As a result, the present module uses Rel-6
-- error type definitions.

;

activityTest OPERATION ::= {
	RETURN RESULT	TRUE
	CODE			opcode-activityTest}
-- Direction: gsmSCF -> gsmSSF, Timer: Tat
-- This operation is used to check for the continued existence of a relationship
-- between the gsmSCF and gsmSSF, assist gsmSSF or gsmSRF. If the relationship is
-- still in existence, then the gsmSSF will respond. If no reply is received,
-- then the gsmSCF will assume that the gsmSSF, assist gsmSSF or gsmSRF has failed
-- in some way.

applyCharging {PARAMETERS-BOUND : bound} OPERATION ::= {
	ARGUMENT		ApplyChargingArg {bound}
	RETURN RESULT	FALSE
	ERRORS			{missingParameter |
					unexpectedComponentSequence |
					unexpectedParameter |
					unexpectedDataValue |
					parameterOutOfRange |
					systemFailure |
					taskRefused |
					unknownLegID |
					unknownCSID}
	CODE			opcode-applyCharging}
-- Direction: gsmSCF -> gsmSSF, Timer: Tac
-- This operation is used for interacting from the gsmSCF with the gsmSSF charging mechanisms.
-- The ApplyChargingReport operation provides the feedback from the gsmSSF to the gsmSCF.

ApplyChargingArg {PARAMETERS-BOUND : bound} ::= SEQUENCE {
	aChBillingChargingCharacteristics	[0] AChBillingChargingCharacteristics {bound},
	partyToCharge						[2] SendingSideID DEFAULT sendingSideID : leg1,
	extensions							[3] Extensions {bound}						OPTIONAL,
	aChChargingAddress					[50] AChChargingAddress {bound}
												DEFAULT legID:sendingSideID:leg1,
	...,
	-- WS modification Frensh National standard addition
	-- https://bugs.wireshark.org/bugzilla/show_bug.cgi?id=7656
	iTXcharging [64] BOOLEAN OPTIONAL
	-- End WS
	}

-- The partyToCharge parameter indicates the party in the call to which the ApplyCharging operation
-- shall be applied.

applyChargingReport {PARAMETERS-BOUND : bound} OPERATION ::= {
	ARGUMENT		ApplyChargingReportArg {bound}
	RETURN RESULT	FALSE
	ERRORS			{missingParameter |
					unexpectedComponentSequence |
					unexpectedParameter |
					unexpectedDataValue |
					unknownCSID |
					unknownLegID |
					parameterOutOfRange |
					systemFailure |
					taskRefused}
	CODE			opcode-applyChargingReport}
-- Direction: gsmSSF -> gsmSCF, Timer: Tacr
-- This operation is used by the gsmSSF to report to the gsmSCF the occurrence of a
-- specific charging event as requested by the gsmSCF using the ApplyCharging operation.

ApplyChargingReportArg {PARAMETERS-BOUND : bound} ::= CallResult {bound}

assistRequestInstructions {PARAMETERS-BOUND : bound} OPERATION ::= {
	ARGUMENT		AssistRequestInstructionsArg {bound}
	RETURN RESULT	FALSE
	ERRORS			{missingCustomerRecord |
					missingParameter |
					systemFailure |
					taskRefused |
					unexpectedComponentSequence |
					unexpectedDataValue |
					unexpectedParameter}
	CODE			opcode-assistRequestInstructions}
-- Direction: gsmSSF -> gsmSCF or gsmSRF -> gsmSCF, Timer: Tari
-- This operation is used when there is an assist procedure and may be
-- sent by the gsmSSF or gsmSRF to the gsmSCF. This operation is sent by the
-- assisting gsmSSF to gsmSCF, when the initiating gsmSSF has set up a connection to
-- the gsmSRF or to the assisting gsmSSF as a result of receiving an
-- EstablishTemporaryConnection from
-- the gsmSCF.
-- Refer to clause 11 for a description of the procedures associated with this operation.

AssistRequestInstructionsArg {PARAMETERS-BOUND : bound} ::= SEQUENCE {
	correlationID						[0] CorrelationID {bound},
	iPSSPCapabilities					[2] IPSSPCapabilities {bound},
	extensions							[3] Extensions {bound}						OPTIONAL,
	...
	}
-- OPTIONAL denotes network operator specific use. The value of the correlationID may be the
-- Called Party Number supplied by the initiating gsmSSF.

callGap {PARAMETERS-BOUND : bound} OPERATION ::= {
	ARGUMENT		CallGapArg {bound}
	RETURN RESULT	FALSE
	ALWAYS RESPONDS FALSE
	CODE			opcode-callGap}
-- Direction: gsmSCF -> gsmSSF, Timer: Tcg
-- This operation is used to request the gsmSSF to reduce the rate at which specific service
-- requests are sent to the gsmSCF.

CallGapArg {PARAMETERS-BOUND : bound}::= SEQUENCE {
	gapCriteria							[0] GapCriteria {bound},
	gapIndicators						[1] GapIndicators,
	controlType							[2] ControlType								OPTIONAL,
	gapTreatment						[3] GapTreatment {bound}					OPTIONAL,
	extensions							[4] Extensions {bound}						OPTIONAL,
	...
	}
-- OPTIONAL denotes network operator optional. If gapTreatment is not present, then the gsmSSF will
-- use a default treatment depending on network operator implementation.

callInformationReport {PARAMETERS-BOUND : bound} OPERATION ::= {
	ARGUMENT		CallInformationReportArg {bound}
	RETURN RESULT	FALSE
	ALWAYS RESPONDS	FALSE
	CODE			opcode-callInformationReport}
-- Direction: gsmSSF -> gsmSCF, Timer: Tcirp
-- This operation is used to send specific call information for a single call party to the gsmSCF as
-- requested by the gsmSCF in a previous CallInformationRequest.

CallInformationReportArg {PARAMETERS-BOUND : bound} ::= SEQUENCE {
	requestedInformationList			[0] RequestedInformationList {bound},
	extensions							[2] Extensions {bound}						OPTIONAL,
	legID								[3] ReceivingSideID DEFAULT receivingSideID:leg2,
	...
	}

callInformationRequest {PARAMETERS-BOUND : bound} OPERATION ::= {
	ARGUMENT		CallInformationRequestArg {bound}
	RETURN RESULT	FALSE
	ERRORS			{missingParameter |
					parameterOutOfRange |
					requestedInfoError |
					systemFailure |
					taskRefused |
					unexpectedComponentSequence |
					unexpectedDataValue |
					unexpectedParameter |
					unknownLegID}
	CODE			opcode-callInformationRequest}
-- Direction: gsmSCF -> gsmSSF, Timer: Tcirq
-- This operation is used to request the gsmSSF to record specific information about a single
-- call party and report it to the gsmSCF (with a CallInformationReport operation).

CallInformationRequestArg {PARAMETERS-BOUND : bound}::= SEQUENCE {
	requestedInformationTypeList		[0] RequestedInformationTypeList,
	extensions							[2] Extensions {bound}						OPTIONAL,
	legID								[3] SendingSideID DEFAULT sendingSideID:leg2,
	...
	}
-- OPTIONAL denotes network operator optional.

cancel {PARAMETERS-BOUND : bound} OPERATION ::= {
	ARGUMENT		CancelArg {bound}
	RETURN RESULT	FALSE
	ERRORS			{cancelFailed |
					missingParameter |
					taskRefused |
					unknownCSID}
	CODE			opcode-cancel}
-- Direction: gsmSCF -> gsmSSF, or gsmSCF -> gsmSRF, Timer: Tcan
-- This operation cancels the correlated previous operation or all previous requests. The following
-- operations can be canceled: PlayAnnouncement, PromptAndCollectUserInformation.

CancelArg {PARAMETERS-BOUND : bound} ::= CHOICE {
	invokeID							[0] InvokeID,
	allRequests							[1] NULL,
	callSegmentToCancel					[2]	CallSegmentToCancel {bound}
	}
-- The InvokeID has the same value as that which was used for the operation to be cancelled.

collectInformation {PARAMETERS-BOUND : bound} OPERATION::= {
	ARGUMENT			CollectInformationArg {bound}
	RETURN RESULT		FALSE
	ERRORS		{missingParameter |
					parameterOutOfRange |
					SystemFailure	|
					TaskRefused	|
					UnexpectedComponentSequence	|
					UnexpectedDataValue	|
					UnexpectedParameter}
	CODE				opcode-collectInformation}
-- Direction: gsmSCF-> gsmSSF, Timer: Tci
-- This operation is used to request the gsmSSF to perform the call
-- processing actions to prompt a calling party for additional digits.

CollectInformationArg {PARAMETERS-BOUND : bound} ::= SEQUENCE{
	extensions										[0]	Extensions {bound}	OPTIONAL,
	...
}

connect {PARAMETERS-BOUND : bound} OPERATION ::= {
	ARGUMENT		ConnectArg {bound}
	RETURN RESULT	FALSE
	ERRORS			{missingParameter |
					parameterOutOfRange |
					systemFailure |
					taskRefused |
					unexpectedComponentSequence |
					unexpectedDataValue |
					unexpectedParameter |
					unknownLegID}
	CODE			opcode-connect}
-- Direction: gsmSCF-> gsmSSF, Timer: Tcon
-- This operation is used to request the gsmSSF to perform the call processing actions
-- to route or forward a call to a specified destination.

ConnectArg {PARAMETERS-BOUND : bound} ::= SEQUENCE {
	destinationRoutingAddress			[0] DestinationRoutingAddress {bound},
	alertingPattern						[1] AlertingPattern							OPTIONAL,
	originalCalledPartyID				[6] OriginalCalledPartyID {bound}			OPTIONAL,
	extensions							[10] Extensions {bound}						OPTIONAL,
	carrier								[11] Carrier {bound}						OPTIONAL,
	callingPartysCategory				[28] CallingPartysCategory					OPTIONAL,
	redirectingPartyID					[29] RedirectingPartyID {bound}				OPTIONAL,
	redirectionInformation				[30] RedirectionInformation					OPTIONAL,
	genericNumbers						[14] GenericNumbers {bound}					OPTIONAL,
	serviceInteractionIndicatorsTwo 	[15] ServiceInteractionIndicatorsTwo		OPTIONAL,
	chargeNumber						[19] ChargeNumber {bound}					OPTIONAL,
	legToBeConnected					[21] LegID									OPTIONAL,
	cug-Interlock						[31] CUG-Interlock							OPTIONAL,
	cug-OutgoingAccess					[32] NULL									OPTIONAL,
	suppressionOfAnnouncement			[55] SuppressionOfAnnouncement				OPTIONAL,
	oCSIApplicable						[56] OCSIApplicable							OPTIONAL,
	naOliInfo							[57] NAOliInfo								OPTIONAL,
	bor-InterrogationRequested			[58] NULL									OPTIONAL,
	... ,
	suppress-N-CSI						[59] NULL									OPTIONAL
	}
-- na-Info is included at the discretion of the gsmSCF operator.

connectToResource {PARAMETERS-BOUND : bound} OPERATION ::= {
	ARGUMENT		ConnectToResourceArg {bound}
	RETURN RESULT	FALSE
	ERRORS			{missingParameter |
					systemFailure |
					taskRefused |
					unexpectedComponentSequence |
					unexpectedDataValue |
					unexpectedParameter |
					unknownCSID}
	CODE			opcode-connectToResource}
-- Direction: gsmSCF -> gsmSSF, Timer: Tctr
-- This operation is used to connect a call segment from the gsmSSF to the
-- gsmSRF.

ConnectToResourceArg {PARAMETERS-BOUND : bound} ::= SEQUENCE {
	resourceAddress	CHOICE {
		ipRoutingAddress					[0] IPRoutingAddress {bound},
		none								[3] NULL
		},
	extensions							[4] Extensions {bound}						OPTIONAL,
	serviceInteractionIndicatorsTwo		[7] ServiceInteractionIndicatorsTwo			OPTIONAL,
	callSegmentID						[50] CallSegmentID {bound}					OPTIONAL,
	...
	}

continue OPERATION ::= {
	RETURN RESULT	FALSE
	ALWAYS RESPONDS	FALSE
	CODE			opcode-continue}
-- Direction: gsmSCF -> gsmSSF, Timer: Tcue
-- This operation is used to request the gsmSSF to proceed with call processing at the
-- DP at which it previously suspended call processing to await gsmSCF instructions
-- (i.e. proceed to the next point in call in the BCSM). The gsmSSF continues call
-- processing without substituting new data from gsmSCF.

continueWithArgument {PARAMETERS-BOUND : bound} OPERATION ::= {
	ARGUMENT		ContinueWithArgumentArg {bound}
	RETURN RESULT	FALSE
	ERRORS			{missingParameter |
					parameterOutOfRange |
					unexpectedComponentSequence |
					unexpectedDataValue |
					unexpectedParameter |
					unknownLegID |
					unknownCSID}
	CODE			opcode-continueWithArgument}
-- Direction: gsmSCF -> gsmSSF, Timer: Tcwa
-- This operation is used to request the gsmSSF to proceed with call processing at the
-- DP at which it previously suspended call processing to await gsmSCF instructions
-- (i.e. proceed to the next point in call in the BCSM). The gsmSSF continues call
-- processing with the modified call setup information as received from the gsmSCF.

ContinueWithArgumentArg {PARAMETERS-BOUND : bound} ::= SEQUENCE {
	alertingPattern						[1] AlertingPattern							OPTIONAL,
	extensions							[6] Extensions {bound}						OPTIONAL,
	serviceInteractionIndicatorsTwo		[7] ServiceInteractionIndicatorsTwo			OPTIONAL,
	callingPartysCategory				[12] CallingPartysCategory					OPTIONAL,
	genericNumbers						[16] GenericNumbers {bound}					OPTIONAL,
	cug-Interlock						[17] CUG-Interlock							OPTIONAL,
	cug-OutgoingAccess					[18] NULL									OPTIONAL,
	chargeNumber						[50] ChargeNumber {bound}					OPTIONAL,
	carrier								[52] Carrier {bound}						OPTIONAL,
	suppressionOfAnnouncement			[55] SuppressionOfAnnouncement				OPTIONAL,
	naOliInfo							[56] NAOliInfo								OPTIONAL,
	bor-InterrogationRequested			[57] NULL									OPTIONAL,
	suppress-O-CSI						[58] NULL									OPTIONAL,
	continueWithArgumentArgExtension	[59] ContinueWithArgumentArgExtension {bound} OPTIONAL,
	...
	}

ContinueWithArgumentArgExtension {PARAMETERS-BOUND : bound} ::= SEQUENCE {
	suppress-D-CSI						[0]	NULL									OPTIONAL,
	suppress-N-CSI						[1]	NULL									OPTIONAL,
	suppressOutgoingCallBarring			[2]	NULL									OPTIONAL,
	legOrCallSegment					[3]	LegOrCallSegment {bound}				OPTIONAL,
	...
	}

disconnectForwardConnection OPERATION ::= {
	RETURN RESULT	FALSE
	ERRORS			{systemFailure |
					taskRefused |
					unexpectedComponentSequence}
	CODE			opcode-disconnectForwardConnection}
-- Direction: gsmSCF -> gsmSSF, Timer: Tdfc
-- This operation is used to disconnect a forward temporary connection or a connection to a
-- resource. Refer to clause 11 for a description of the procedures associated with this operation.

disconnectForwardConnectionWithArgument {PARAMETERS-BOUND : bound} OPERATION ::= {
	ARGUMENT		DisconnectForwardConnectionWithArgumentArg {bound}
	RETURN RESULT	FALSE
	ERRORS			{missingParameter |
					systemFailure |
					taskRefused |
					unexpectedComponentSequence |
					unexpectedDataValue |
					unexpectedParameter |
					unknownCSID}
	CODE			opcode-dFCWithArgument}
-- Direction gsmSCF -> gsmSSF, Timer Tdfcwa
-- This operation is used to disconnect a forward temporary connection or a connection to a
-- resource. Refer to clause 11 for a description of the procedures associated with this operation.

DisconnectForwardConnectionWithArgumentArg {PARAMETERS-BOUND : bound} ::= SEQUENCE {
	callSegmentID						[1] CallSegmentID {bound}					OPTIONAL,
	extensions							[2] Extensions {bound}						OPTIONAL,
	...
	}

disconnectLeg {PARAMETERS-BOUND : bound} OPERATION ::= {
	ARGUMENT		DisconnectLegArg {bound}
	RETURN RESULT	TRUE
	ERRORS			{missingParameter |
					systemFailure |
					taskRefused |
					unexpectedComponentSequence |
					unexpectedDataValue |
					unexpectedParameter |
					unknownLegID}
	CODE			opcode-disconnectLeg}
-- Direction: gsmSCF -> gsmSSF, Timer Tdl
-- This operation is used by the gsmSCF to release a specific leg associated with the call and
-- retain any other legs not specified in the DisconnectLeg. Refer to clause 11 for a description
-- of the procedures associated with this operation.

DisconnectLegArg {PARAMETERS-BOUND : bound} ::= SEQUENCE {
	legToBeReleased						[0]	LegID,
	releaseCause						[1]	Cause {bound}							OPTIONAL,
	extensions							[2]	Extensions {bound}						OPTIONAL,
	...
	}

entityReleased {PARAMETERS-BOUND : bound} OPERATION ::= {
	ARGUMENT		EntityReleasedArg {bound}
	RETURN RESULT	FALSE
	ALWAYS RESPONDS	FALSE
	CODE			opcode-entityReleased}
-- Direction: gsmSSF -> gsmSCF, Timer: Ter
-- This operation is used by the gsmSSF to inform the gsmSCF of an error or exception

EntityReleasedArg {PARAMETERS-BOUND : bound} ::= CHOICE {
	callSegmentFailure					[0]	CallSegmentFailure {bound},
	bCSM-Failure						[1]	BCSM-Failure {bound}
	}

establishTemporaryConnection {PARAMETERS-BOUND : bound} OPERATION ::= {
	ARGUMENT		EstablishTemporaryConnectionArg {bound}
	RETURN RESULT	FALSE
	ERRORS			{eTCFailed |
					missingParameter |
					systemFailure |
					taskRefused |
					unexpectedComponentSequence |
					unexpectedDataValue |
					unexpectedParameter |
					unknownCSID}
	CODE			opcode-establishTemporaryConnection}
-- Direction: gsmSCF -> gsmSSF, Timer: Tetc
-- This operation is used to create a connection to a resource for a limited period
-- of time (e.g. to play an announcement, to collect user information); it implies
-- the use of the assist procedure. Refer to clause 11 for a description of the
-- procedures associated with this operation.

EstablishTemporaryConnectionArg {PARAMETERS-BOUND : bound} ::= SEQUENCE {
	assistingSSPIPRoutingAddress		[0] AssistingSSPIPRoutingAddress {bound},
	correlationID						[1] CorrelationID {bound}					OPTIONAL,
	scfID								[3] ScfID {bound}							OPTIONAL,
	extensions							[4] Extensions {bound}						OPTIONAL,
	carrier								[5] Carrier {bound}							OPTIONAL,
	serviceInteractionIndicatorsTwo		[6] ServiceInteractionIndicatorsTwo			OPTIONAL,
	callSegmentID						[7]	CallSegmentID {bound}					OPTIONAL,
	naOliInfo							[50] NAOliInfo								OPTIONAL,
	chargeNumber						[51] ChargeNumber {bound}					OPTIONAL,
	...,
	originalCalledPartyID				[52] OriginalCalledPartyID {bound}			OPTIONAL,
	callingPartyNumber					[53] CallingPartyNumber {bound}				OPTIONAL
	}

eventReportBCSM {PARAMETERS-BOUND : bound} OPERATION ::= {
	ARGUMENT		EventReportBCSMArg {bound}
	RETURN RESULT	FALSE
	ALWAYS RESPONDS	FALSE
	CODE			opcode-eventReportBCSM}
-- Direction: gsmSSF -> gsmSCF, Timer: Terb
-- This operation is used to notify the gsmSCF of a call-related event (e.g. BCSM
-- events such as O_Busy or O_No_Answer) previously requested by the gsmSCF in a
-- RequestReportBCSMEvent operation.

EventReportBCSMArg {PARAMETERS-BOUND : bound} ::= SEQUENCE {
	eventTypeBCSM						[0] EventTypeBCSM,
	eventSpecificInformationBCSM		[2] EventSpecificInformationBCSM {bound}	OPTIONAL,
	legID								[3] ReceivingSideID							OPTIONAL,
	miscCallInfo						[4] MiscCallInfo DEFAULT {messageType request},
	extensions							[5] Extensions {bound}						OPTIONAL,
	...
	}

furnishChargingInformation {PARAMETERS-BOUND : bound} OPERATION ::= {
	ARGUMENT		FurnishChargingInformationArg {bound}
	RETURN RESULT	FALSE
	ERRORS			{missingParameter |
					taskRefused |
					unexpectedComponentSequence |
					unexpectedDataValue |
					unexpectedParameter |
					unknownLegID}
	CODE			opcode-furnishChargingInformation}
-- Direction: gsmSCF -> gsmSSF, Timer: Tfci
-- This operation is used to request the gsmSSF to generate, register a call record
-- or to include some information in the default call record.
-- The registered call record is intended for off line charging of the call.

FurnishChargingInformationArg {PARAMETERS-BOUND : bound} ::=
	FCIBillingChargingCharacteristics{bound}

initialDP {PARAMETERS-BOUND : bound} OPERATION ::= {
	ARGUMENT		InitialDPArg {bound}
	RETURN RESULT	FALSE
	ERRORS			{missingCustomerRecord |
					missingParameter |
					parameterOutOfRange |
					systemFailure |
					taskRefused |
					unexpectedComponentSequence |
					unexpectedDataValue |
					unexpectedParameter}
	CODE			opcode-initialDP}
-- Direction: gsmSSF -> gsmSCF, Timer: Tidp
-- This operation is used after a TDP to indicate request for service.

InitialDPArg {PARAMETERS-BOUND : bound} ::= SEQUENCE {
	serviceKey							[0] ServiceKey	,
	calledPartyNumber					[2] CalledPartyNumber {bound}				OPTIONAL,
	callingPartyNumber					[3] CallingPartyNumber {bound}				OPTIONAL,
	callingPartysCategory				[5] CallingPartysCategory					OPTIONAL,
	cGEncountered						[7] CGEncountered							OPTIONAL,
	iPSSPCapabilities					[8] IPSSPCapabilities {bound}				OPTIONAL,
	locationNumber						[10] LocationNumber {bound}					OPTIONAL,
	originalCalledPartyID				[12] OriginalCalledPartyID {bound}			OPTIONAL,
	extensions							[15] Extensions {bound}						OPTIONAL,
	highLayerCompatibility				[23] HighLayerCompatibility					OPTIONAL,
	additionalCallingPartyNumber		[25] AdditionalCallingPartyNumber {bound}	OPTIONAL,
	bearerCapability					[27] BearerCapability {bound}				OPTIONAL,
	eventTypeBCSM						[28] EventTypeBCSM							OPTIONAL,
	redirectingPartyID					[29] RedirectingPartyID {bound}				OPTIONAL,
	redirectionInformation				[30] RedirectionInformation					OPTIONAL,
	cause								[17] Cause {bound}							OPTIONAL,
	serviceInteractionIndicatorsTwo		[32] ServiceInteractionIndicatorsTwo		OPTIONAL,
	carrier								[37] Carrier {bound}						OPTIONAL,
	cug-Index							[45] CUG-Index								OPTIONAL,
	cug-Interlock						[46] CUG-Interlock							OPTIONAL,
	cug-OutgoingAccess					[47] NULL									OPTIONAL,
	iMSI								[50] IMSI									OPTIONAL,
	subscriberState						[51] SubscriberState						OPTIONAL,
	locationInformation					[52] LocationInformation					OPTIONAL,
	ext-basicServiceCode				[53] Ext-BasicServiceCode					OPTIONAL,
	callReferenceNumber					[54] CallReferenceNumber					OPTIONAL,
	mscAddress							[55] ISDN-AddressString						OPTIONAL,
	calledPartyBCDNumber				[56] CalledPartyBCDNumber {bound}			OPTIONAL,
	timeAndTimezone						[57] TimeAndTimezone {bound}				OPTIONAL,
	callForwardingSS-Pending			[58] NULL									OPTIONAL,
	initialDPArgExtension				[59] InitialDPArgExtension {bound}			OPTIONAL,
	...
	}

InitialDPArgExtension {PARAMETERS-BOUND : bound} ::= SEQUENCE {
	gmscAddress							[0] ISDN-AddressString						OPTIONAL,
	forwardingDestinationNumber			[1] CalledPartyNumber {bound}				OPTIONAL,
	ms-Classmark2						[2] MS-Classmark2							OPTIONAL,
	iMEI								[3] IMEI									OPTIONAL,
	supportedCamelPhases				[4] SupportedCamelPhases					OPTIONAL,
	offeredCamel4Functionalities		[5] OfferedCamel4Functionalities			OPTIONAL,
	bearerCapability2					[6] BearerCapability {bound}				OPTIONAL,
	ext-basicServiceCode2				[7] Ext-BasicServiceCode					OPTIONAL,
	highLayerCompatibility2				[8] HighLayerCompatibility					OPTIONAL,
	lowLayerCompatibility				[9] LowLayerCompatibility {bound}			OPTIONAL,
	lowLayerCompatibility2				[10] LowLayerCompatibility {bound}			OPTIONAL,
	...,
	enhancedDialledServicesAllowed		[11] NULL									OPTIONAL,
	uu-Data								[12] UU-Data								OPTIONAL,
	collectInformationAllowed			[13] NULL									OPTIONAL,
	releaseCallArgExtensionAllowed		[14] NULL									OPTIONAL
}
-- If iPSSPCapabilities is not present then this denotes that a colocated gsmSRF is not
-- supported by the gsmSSF. If present, then the gsmSSF supports a colocated gsmSRF capable
-- of playing announcements via elementaryMessageIDs and variableMessages, the playing of
-- tones and the collection of DTMF digits. Other supported capabilities are explicitly
-- detailed in the IPSSPCapabilities parameter itself.
-- Carrier is included at the discretion of the gsmSSF operator.
-- The UserCSGInformation is conveyed in the LocationInformation. The encoding of the parameter is
-- as defined in 3GPP TS 29.002 [11].

initiateCallAttempt {PARAMETERS-BOUND : bound} OPERATION ::= {
	ARGUMENT		InitiateCallAttemptArg {bound}
	RESULT			InitiateCallAttemptRes {bound}
	ERRORS			{missingParameter |
					parameterOutOfRange |
					systemFailure |
					taskRefused |
					unexpectedComponentSequence |
					unexpectedDataValue |
					unexpectedParameter
					}
	CODE			opcode-initiateCallAttempt}
-- Direction: gsmSCF -> gsmSSF, Timer Tica
-- This operation is used to instruct the gsmSSF to create a new call to a call party using the
-- address information provided by the gsmSCF.

InitiateCallAttemptArg {PARAMETERS-BOUND : bound} ::= SEQUENCE {
	destinationRoutingAddress			[0]	DestinationRoutingAddress {bound},
	extensions							[4]	Extensions {bound}						OPTIONAL,
	legToBeCreated						[5]	LegID									OPTIONAL,
	newCallSegment						[6]	CallSegmentID {bound}					OPTIONAL,
	callingPartyNumber					[30] CallingPartyNumber {bound}				OPTIONAL,
	callReferenceNumber					[51] CallReferenceNumber					OPTIONAL,
	gsmSCFAddress						[52] ISDN-AddressString						OPTIONAL,
	suppress-T-CSI						[53] NULL									OPTIONAL,
	...
	}

InitiateCallAttemptRes {PARAMETERS-BOUND : bound} ::= SEQUENCE {
	supportedCamelPhases				[0] SupportedCamelPhases					OPTIONAL,
	offeredCamel4Functionalities		[1] OfferedCamel4Functionalities			OPTIONAL,
	extensions							[2]	Extensions {bound}						OPTIONAL,
	...,
	releaseCallArgExtensionAllowed		[3]	NULL									OPTIONAL
	}

moveLeg {PARAMETERS-BOUND : bound} OPERATION ::= {
	ARGUMENT		MoveLegArg {bound}
	RETURN RESULT	TRUE
	ERRORS			{missingParameter |
					systemFailure |
					taskRefused |
					unexpectedComponentSequence |
					unexpectedDataValue |
					unexpectedParameter |
					unknownLegID}
	CODE			opcode-moveLeg}
-- Direction: gsmSCF -> gsmSSF, Timer: Tml
-- This operation is used by the gsmSCF to move a leg from one call segment to another call segment
-- within the same call segment association.

MoveLegArg {PARAMETERS-BOUND : bound} ::= SEQUENCE{
	legIDToMove							[0]	LegID,
	extensions							[2]	Extensions {bound}						OPTIONAL,
	...
	}

playTone {PARAMETERS-BOUND : bound} OPERATION ::= {
	ARGUMENT		PlayToneArg {bound}
	RETURN RESULT	FALSE
	ERRORS			{missingParameter |
					parameterOutOfRange |
					systemFailure |
					unexpectedComponentSequence |
					unexpectedDataValue |
					unexpectedParameter |
					unknownLegID |
					unknownCSID}
	CODE			opcode-playTone}
-- Direction: gsmSCF -> gsmSSF, Timer: Tpt
-- This operation is used to play tones to either a leg or a call segment using
-- the MSC's tone generator.

PlayToneArg {PARAMETERS-BOUND : bound} ::= SEQUENCE {
	legOrCallSegment					[0] LegOrCallSegment {bound},
	bursts								[1] Burst,
	extensions							[2] Extensions {bound}						OPTIONAL,
	...
	}

releaseCall {PARAMETERS-BOUND : bound} OPERATION ::= {
	ARGUMENT		ReleaseCallArg {bound}
	RETURN RESULT	FALSE
	ALWAYS RESPONDS	FALSE
	CODE			opcode-releaseCall}
-- Direction: gsmSCF ->?gsmSSF, Timer: Trc
-- This operation is used to tear down an existing call at any phase of the call for all parties
-- involved in the call.

ReleaseCallArg {PARAMETERS-BOUND : bound} ::= CHOICE {
	allCallSegments					AllCallSegments,
	allCallSegmentsWithExtension	[2] AllCallSegmentsWithExtension
	}

AllCallSegments ::= Cause {bound}
-- A default value of decimal 31 (normal unspecified) shall be given.

AllCallSegmentsWithExtension ::= SEQUENCE {
	allCallSegments				[0] AllCallSegments,
	extensions					[1] Extensions {bound} OPTIONAL
	}

requestReportBCSMEvent {PARAMETERS-BOUND : bound} OPERATION ::= {
	ARGUMENT		RequestReportBCSMEventArg {bound}
	RETURN RESULT	FALSE
	ERRORS			{missingParameter |
					parameterOutOfRange |
					systemFailure |
					taskRefused |
					unexpectedComponentSequence |
					unexpectedDataValue |
					unexpectedParameter |
					unknownLegID}
	CODE			opcode-requestReportBCSMEvent}
-- Direction: gsmSCF -> gsmSSF, Timer: Trrb
-- This operation is used to request the gsmSSF to monitor for a call-related event
-- (e.g. BCSM events such as O_Busy or O_No_Answer) and to send a notification
-- to the gsmSCF when the event is detected.
--
-- NOTE:
-- Every EDP must be explicitly armed by the gsmSCF via a RequestReportBCSMEvent operation.
-- No implicit arming of EDPs at the gsmSSF after reception of any operation (different
-- from RequestReportBCSMEvent) from the gsmSCF is allowed.

RequestReportBCSMEventArg {PARAMETERS-BOUND : bound} ::= SEQUENCE {
	bcsmEvents							[0] SEQUENCE SIZE(1..bound.&numOfBCSMEvents) OF
												BCSMEvent {bound},
	extensions							[2] Extensions {bound}						OPTIONAL,
	...
	}
-- Indicates the BCSM related events for notification.

resetTimer {PARAMETERS-BOUND : bound} OPERATION ::= {
	ARGUMENT		ResetTimerArg {bound}
	RETURN RESULT	FALSE
	ERRORS			{missingParameter |
					parameterOutOfRange |
					taskRefused |
					unexpectedComponentSequence |
					unexpectedDataValue |
					unexpectedParameter |
					unknownCSID}
	CODE			opcode-resetTimer}
-- Direction: gsmSCF -> gsmSSF, Timer: Trt
-- This operation is used to request the gsmSSF to refresh an application timer in the gsmSSF.

ResetTimerArg {PARAMETERS-BOUND : bound} ::= SEQUENCE {
	timerID								[0] TimerID	DEFAULT tssf,
	timervalue							[1] TimerValue,
	extensions							[2] Extensions {bound}						OPTIONAL,
	callSegmentID						[3]	CallSegmentID {bound}					OPTIONAL,
	...
	}

sendChargingInformation {PARAMETERS-BOUND : bound} OPERATION ::= {
	ARGUMENT		SendChargingInformationArg {bound}
	RETURN RESULT	FALSE
	ERRORS			{missingParameter |
					unexpectedComponentSequence |
					unexpectedParameter |
					parameterOutOfRange |
					systemFailure |
					taskRefused |
					unexpectedDataValue |
					unknownLegID}
	CODE			opcode-sendChargingInformation}
-- Direction: gsmSCF -> gsmSSF, Timer: Tsci
-- This operation is used to instruct the gsmSSF on the charging information to send by the gsmSSF.
-- The charging information can either be sent back by means of signalling or internal
-- if the gsmSSF is located in the local exchange. In the local exchange
-- this information may be used to update the charge meter or to create a standard call record.

SendChargingInformationArg {PARAMETERS-BOUND : bound}::= SEQUENCE {
	sCIBillingChargingCharacteristics	[0] SCIBillingChargingCharacteristics {bound},
	partyToCharge						[1] SendingSideID,
	extensions							[2] Extensions {bound}						OPTIONAL,
	...
	}

splitLeg {PARAMETERS-BOUND : bound} OPERATION ::= {
	ARGUMENT		SplitLegArg {bound}
	RETURN RESULT	TRUE
	ERRORS			{missingParameter |
					unexpectedComponentSequence |
					unexpectedParameter |
					unexpectedDataValue |
					systemFailure |
					taskRefused |
					unknownLegID}
	CODE			opcode-splitLeg}
-- Direction: gsmSCF -> gsmSSF, Timer Tsl
-- This operation is used by the gsmSCF to separate a leg from its source call segment and
-- place it in a new call segment within the same call segment association.

SplitLegArg {PARAMETERS-BOUND : bound} ::= SEQUENCE {
	legToBeSplit						[0]	LegID,
	newCallSegment						[1]	CallSegmentID {bound}					OPTIONAL,
	extensions							[2]	Extensions {bound}						OPTIONAL,
	...
	}

END