-- c-basic-offset: 2; tab-width: 2; indent-tabs-mode: t
-- vi: set shiftwidth=2 tabstop=2 noexpandtab:
-- :indentSize=2:tabSize=2:noTabs=false:

-- Sub-Volume IV ASN.1 reference definitions for ICAO Doc. 9705,
-- Second Edition
-- Version 1.1, 03 Oct 2001

-- protected mode PDR's
-- 2011-10-25 	Doc 9705 Draft Ed 3 (ICAO web site - 11/00) including "9705 PDRS FOR CPDLC"
-- based on "ACP WGN SG/N2 Version 1.1 (Output Montreal - May 2005)"


-- plain old CPDLC 
CPDLCAPDUsVersion1 DEFINITIONS ::=  
BEGIN

IMPORTS
				ATCUplinkMessage,	ATCDownlinkMessage 
		FROM PMCPDLCMessageSetVersion1
				ATCForwardMessage, ATCForwardResponse 
		FROM PMCPDLCAPDUsVersion1;

-- ----------------------------------------------------------------------------------
-- Ground Generated Messages - Top level
-- ----------------------------------------------------------------------------------
GroundPDUs ::= CHOICE
{
		abortUser		[0]	CPDLCUserAbortReason,
		abortProvider		[1]	CPDLCProviderAbortReason,
		startup			[2]	UplinkMessage,
		send			[3]	ATCUplinkMessage,
		forward		[4]	ATCForwardMessage,
		forwardresponse	[5]	ATCForwardResponse,
		...
}

UplinkMessage ::= CHOICE
{
		noMessage		[0]	NULL,
		aTCUplinkMessage	[1]	ATCUplinkMessage
}

AircraftPDUs::= CHOICE
{
		abortUser	[0]	CPDLCUserAbortReason,
		abortProvider	[1]	CPDLCProviderAbortReason,
		startdown	[2]	StartDownMessage,
		send		[3]	ATCDownlinkMessage,
		...
}

StartDownMessage ::= SEQUENCE
{
		mode			Mode DEFAULT cpdlc,
		startDownlinkMessage	DownlinkMessage
}

Mode ::= ENUMERATED
{
		cpdlc		(0),
		dsc		(1)
}

DownlinkMessage ::= CHOICE
{
		noMessage			[0]	NULL,
		aTCDownlinkMessage		[1]	ATCDownlinkMessage
}

CPDLCUserAbortReason ::= ENUMERATED
{
		undefined					(0),
		no-message-identification-numbers-available	(1),
		duplicate-message-identification-numbers	(2),
		no-longer-next-data-authority			(3),
		current-data-authority-abort			(4),
		commanded-termination			(5),
		invalid-response				(6),
		...
}


CPDLCProviderAbortReason ::= ENUMERATED
{
		timer-expired					(0),
		undefined-error				(1),
		invalid-PDU					(2),
		protocol-error					(3),
		communication-service-error			(4),
		communication-service-failure			(5),
		invalid-QOS-parameter				(6),
		expected-PDU-missing				(7),
		...
	}

END

-- protected mode PMCPDLC
PMCPDLCAPDUsVersion1 DEFINITIONS::=
BEGIN

IMPORTS
DateTimeGroup,
AircraftFlightIdentification,
AircraftAddress
FROM PMCPDLCMessageSetVersion1;

-- ----------------------------------------------------------------------------------
-- Ground Generated Messages - Top level
-- ----------------------------------------------------------------------------------
ProtectedGroundPDUs ::= CHOICE
{
		abortUser				[0]	PMCPDLCUserAbortReason,
		abortProvider		[1]	PMCPDLCProviderAbortReason,
		startup					[2]	ProtectedUplinkMessage,
		send						[3]	ProtectedUplinkMessage,
		forward					[4]	ATCForwardMessage,
		forwardresponse	[5]	ATCForwardResponse,
		...
}

ProtectedUplinkMessage::= SEQUENCE
{
		algorithmIdentifier	[0] AlgorithmIdentifier OPTIONAL,
		protectedMessage		[1] CPDLCMessage OPTIONAL,
-- PER encoded ATCUplinkMessage
-- (see Module PMCPDLCMessageSetVersion1)
		integrityCheck			[2] BIT STRING,
		...
}

ATCForwardMessage ::= SEQUENCE
{
		forwardHeader		ForwardHeader,
		forwardMessage	ForwardMessage
}

ForwardHeader ::= SEQUENCE
{
		dateTime	DateTimeGroup,
		aircraftID	AircraftFlightIdentification,
		aircraftAddress	AircraftAddress
}

ForwardMessage ::= CHOICE
{
		upElementIDs		[0]	BIT STRING,
--PER encoded ATCUplinkMessageData,
-- (see Module PMCPDLCMessageSetVersion1)
		downElementIDs	[1]	BIT STRING
--PER encoded ATCDownlinkMessageData,
-- (see Module PMCPDLCMessageSetVersion1)
}

ATCForwardResponse ::= ENUMERATED
{
		success								(0),
		service-not-supported	(1),
		version-not-equal			(2),
		...
}
-- ----------------------------------------------------------------------------------
-- Aircraft Generated Messages - Top level
-- ----------------------------------------------------------------------------------
ProtectedAircraftPDUs::= CHOICE
{
		abortUser			[0]	PMCPDLCUserAbortReason,
		abortProvider [1]	PMCPDLCProviderAbortReason,
		startdown			[2]	ProtectedStartDownMessage,
		send					[3]	ProtectedDownlinkMessage,
		...
}


ProtectedStartDownMessage ::= SEQUENCE
{
		mode	ProtectedMode DEFAULT cpdlc,
		startDownlinkMessage ProtectedDownlinkMessage
}

ProtectedMode ::= ENUMERATED
{
		cpdlc	(0),
		dsc	(1)
}

ProtectedDownlinkMessage::= SEQUENCE
{
		algorithmIdentifier	[0] AlgorithmIdentifier OPTIONAL,
		protectedMessage		[1] CPDLCMessage OPTIONAL,
--PER encoded ATCDownlinkMessage,
-- (see Module PMCPDLCMessageSetVersion1)
		integrityCheck			[2] BIT STRING,
		...
}

-- ----------------------------------------------------------------------------------
-- Uplink and Downlink messages - Common Elements
-- ----------------------------------------------------------------------------------
AlgorithmIdentifier ::= RELATIVE-OID 
--root is {icao-arc atn-algorithms(9)}

CPDLCMessage ::= BIT STRING

PMCPDLCUserAbortReason ::= ENUMERATED
{
		undefined																		(0),
		no-message-identification-numbers-available	(1),
		duplicate-message-identification-numbers		(2),
		no-longer-next-data-authority								(3),
		current-data-authority-abort								(4),
		commanded-termination												(5),
		invalid-response														(6),
		time-out-of-synchronisation									(7),
		unknown-integrity-check											(8),
		validation-failure													(9),
		unable-to-decode-message										(10),
		invalid-pdu																	(11),
		invalid-CPDLC-message												(12),
		...
}

PMCPDLCProviderAbortReason ::= ENUMERATED
{
		timer-expired																(0),
		undefined-error															(1),
		invalid-PDU																	(2),
		protocol-error															(3),
		communication-service-error									(4),
		communication-service-failure								(5),
		invalid-QOS-parameter												(6),
		expected-PDU-missing												(7),
		...
}

END

PMCPDLCMessageSetVersion1 DEFINITIONS::=
BEGIN

ATCUplinkMessage ::= SEQUENCE
{
		header	ATCMessageHeader,
		messageData	ATCUplinkMessageData
}

ATCUplinkMessageData ::= SEQUENCE
{
		elementIds	SEQUENCE SIZE (1..5) OF ATCUplinkMsgElementId,
		constrainedData	SEQUENCE
		{
				routeClearanceData	SEQUENCE SIZE (1..2) OF RouteClearance OPTIONAL,
				...
		}	OPTIONAL
}

ATCDownlinkMessage ::= SEQUENCE
{
		header	ATCMessageHeader,
		messageData	ATCDownlinkMessageData
}

ATCDownlinkMessageData ::= SEQUENCE
{
		elementIds	SEQUENCE SIZE (1..5) OF ATCDownlinkMsgElementId,
		constrainedData	SEQUENCE
		{
				routeClearanceData		SEQUENCE SIZE (1..2) OF RouteClearance OPTIONAL,
			...
		}	OPTIONAL
}

-- ----------------------------------------------------------------------------------
-- Uplink and Downlink messages - Common Elements
-- ----------------------------------------------------------------------------------
ATCMessageHeader ::= SEQUENCE
{
		messageIdNumber		[0]	MsgIdentificationNumber,
		messageRefNumber	[1]	MsgReferenceNumber	OPTIONAL,
		dateTime					[2]	DateTimeGroup,
		logicalAck				[3]	LogicalAck	DEFAULT notRequired
}

MsgIdentificationNumber ::= INTEGER (0..63)

MsgReferenceNumber ::= INTEGER (0..63)

LogicalAck ::= ENUMERATED
{
		required	(0),
		notRequired	(1)
}

-- ----------------------------------------------------------------------------------
-- Uplink message element
-- ----------------------------------------------------------------------------------
ATCUplinkMsgElementId ::= CHOICE
{
		--	UNABLE	
		-- Urg(N)/Alr(M)/Resp(N)
		uM0NULL	[0] NULL,

		-- STANDBY 
		-- Urg(N)/Alr(L)/Resp(N)
		uM1NULL [1] NULL,
	
		-- REQUEST DEFERRED 
		-- Urg(N)/Alr(L)/Resp(N)
		uM2NULL [2] NULL,
	
		-- ROGER 
		-- Urg(N)/Alr(L)/Resp(N)
		uM3NULL [3] NULL,

		-- AFFIRM 
		-- Urg(N)/Alr(L)/Resp(N)
		uM4NULL [4] NULL,

		-- NEGATIVE Urg(N)/Alr(L)/Resp(N)
		uM5NULL [5] NULL,

		-- EXPECT [level] Urg(L)/Alr(L)/Resp(R)
		uM6Level [6] Level,

		-- EXPECT CLIMB AT [time] 
		-- Urg(L)/Alr(L)/Resp(R)
		uM7Time [7] Time,

		-- EXPECT CLIMB AT [position] 
		-- Urg(L)/Alr(L)/Resp(R)
		uM8Position [8] Position,

		-- EXPECT DESCENT AT [time] 
		-- Urg(L)/Alr(L)/Resp(R)
		uM9Time [9] Time,
	
		-- EXPECT DESCENT AT [position] 
		-- Urg(L)/Alr(L)/Resp(R)
		uM10Position [10] Position,
	
		-- EXPECT CRUISE CLIMB AT [time] 
		-- Urg(L)/Alr(L)/Resp(R)
		uM11Time [11] Time,

		-- EXPECT CRUISE CLIMB AT [position] 
		-- Urg(L)/Alr(L)/Resp(R)
		uM12Position [12] Position,

		-- AT [time] EXPECT CLIMB TO [level] 
		-- Urg(L)/Alr(L)/Resp(R)
		uM13TimeLevel [13] TimeLevel,

	-- AT [position] EXPECT CLIMB TO [level] 
	-- Urg(L)/Alr(L)/Resp(R)
		uM14PositionLevel [14] PositionLevel,
	
		-- AT [time] EXPECT DESCENT TO [level] 
		-- Urg(L)/Alr(L)/Resp(R)
		uM15TimeLevel [15] TimeLevel,

	-- AT [position] EXPECT DESCENT TO [level] 
	-- Urg(L)/Alr(L)/Resp(R)
		uM16PositionLevel [16] PositionLevel,

		-- AT [time] EXPECT CRUISE CLIMB TO [level] 
		-- Urg(L)/Alr(L)/Resp(R)
		uM17TimeLevel [17] TimeLevel,
	
		-- AT [position] EXPECT CRUISE CLIMB TO [level] 
		-- Urg(L)/Alr(L)/Resp(R)
		uM18PositionLevel [18] PositionLevel,

		-- MAINTAIN [level] 
		-- Urg(N)/Alr(M)/Resp(W/U)
		uM19Level [19] Level,
	
		-- CLIMB TO [level] 
		-- Urg(N)/Alr(M)/Resp(W/U)
		uM20Level [20] Level,

		-- AT [time] CLIMB TO [level] 
		-- Urg(N)/Alr(M)/Resp(W/U)
		uM21TimeLevel [21] TimeLevel,

		-- AT [position] CLIMB TO [level] 
		-- Urg(N)/Alr(M)/Resp(W/U)
		uM22PositionLevel [22] PositionLevel,

		-- DESCEND TO [level] 
		-- Urg(N)/Alr(M)/Resp(W/U)
		uM23Level [23] Level,

		-- AT [time] DESCEND TO [level] 
		-- Urg(N)/Alr(M)/Resp(W/U)
		uM24TimeLevel [24] TimeLevel,
	
		-- AT [position] DESCEND TO [level] 
		-- Urg(N)/Alr(M)/Resp(W/U)
		uM25PositionLevel [25] PositionLevel,
	
		-- CLIMB TO REACH [level] BY [time] 
		-- Urg(N)/Alr(M)/Resp(W/U)
		uM26LevelTime [26] LevelTime,

		-- CLIMB TO REACH [level] BY [position] 
		-- Urg(N)/Alr(M)/Resp(W/U)
		uM27LevelPosition [27] LevelPosition,
	
		-- DESCEND TO REACH [level] BY [time] 
		-- Urg(N)/Alr(M)/Resp(W/U)
		uM28LevelTime [28] LevelTime,

		-- DESCEND TO REACH [level] BY [position] 
		-- Urg(N)/Alr(M)/Resp(W/U)
		uM29LevelPosition [29] LevelPosition,

		-- MAINTAIN BLOCK [level] TO [level] 
		-- Urg(N)/Alr(M)/Resp(W/U)
		uM30LevelLevel  [30] LevelLevel,

		-- CLIMB TO AND MAINTAIN BLOCK [level] TO [level] 
		-- Urg(N)/Alr(M)/Resp(W/U)
		uM31LevelLevel	[31] LevelLevel,

		-- DESCEND TO AND MAINTAIN BLOCK [level] TO [level]
		-- Urg(N)/Alr(M)/Resp(W/U)
		uM32LevelLevel [32] LevelLevel,
	
		-- Reserved 
		-- Urg(L)/Alr(L)/Resp(Y)
		uM33NULL [33] NULL,

		-- CRUISE CLIMB TO [level] 
		-- Urg(N)/Alr(M)/Resp(W/U)
		uM34Level [34] Level,

		-- CRUISE CLIMB ABOVE [level] 
		-- Urg(N)/Alr(M)/Resp(W/U)
		uM35Level [35] Level,
	
		-- EXPEDITE CLIMB TO [level] 
		-- Urg(U)/Alr(M)/Resp(W/U)
		uM36Level [36] Level,

		-- EXPEDITE DESCENT TO [level] 
		-- Urg(U)/Alr(M)/Resp(W/U)
		uM37Level [37] Level,

		-- IMMEDIATELY CLIMB TO [level] 
		-- Urg(D)/Alr(H)/Resp(W/U)
		uM38Level [38] Level,

		-- IMMEDIATELY DESCEND TO [level] 
		-- Urg(D)/Alr(H)/Resp(W/U)
		uM39Level [39] Level,

		-- Reserved 
		-- Urg(L)/Alr(L)/Resp(Y)
		uM40NULL [40] NULL,

		-- Reserved Urg(L)/Alr(L)/Resp(Y)
		uM41NULL [41] NULL,

		-- EXPECT TO CROSS [position] AT [level] 
		-- Urg(L)/Alr(L)/Resp(R)
		uM42PositionLevel [42] PositionLevel,

		-- EXPECT TO CROSS [position] AT OR ABOVE [level] 
		-- Urg(L)/Alr(L)/Resp(R)
		uM43PositionLevel	[43] PositionLevel,

		-- EXPECT TO CROSS [position] AT OR BELOW [level]
		-- Urg(L)/Alr(L)/Resp(R)
		uM44PositionLevel	[44] PositionLevel,

		-- EXPECT TO CROSS [position] AT AND MAINTAIN [level]
		-- Urg(L)/Alr(L)/Resp(R)
		uM45PositionLevel	[45] PositionLevel,

		-- CROSS [position] AT [level] 
		-- Urg(N)/Alr(M)/Resp(W/U)
		uM46PositionLevel [46] PositionLevel,

		-- CROSS [position] AT OR ABOVE [level] 
		-- Urg(N)/Alr(M)/Resp(W/U)
		uM47PositionLevel [47] PositionLevel,

		-- CROSS [position] AT OR BELOW [level]
		-- Urg(N)/Alr(M)/Resp(W/U)
		uM48PositionLevel [48]	PositionLevel,

		-- CROSS [position] AT AND MAINTAIN [level] 
		-- Urg(N)/Alr(M)/Resp(W/U)
		uM49PositionLevel [49] PositionLevel,
	
		-- CROSS [position] BETWEEN [level] AND [level] 
		-- Urg(N)/Alr(M)/Resp(W/U)
		uM50PositionLevelLevel [50] PositionLevelLevel,

		-- CROSS [position] AT [time] 
		-- Urg(N)/Alr(M)/Resp(W/U)
		uM51PositionTime [51] PositionTime,

		-- CROSS [position] AT OR BEFORE [time] 
		-- Urg(N)/Alr(M)/Resp(W/U)
		uM52PositionTime [52] PositionTime,

		-- CROSS [position] AT OR AFTER [time] 
		-- Urg(N)/Alr(M)/Resp(W/U)
		uM53PositionTime [53] PositionTime,

		-- CROSS [position] BETWEEN [time] AND [time] 
		-- Urg(N)/Alr(M)/Resp(W/U)
		uM54PositionTimeTime [54] PositionTimeTime,

		-- CROSS [position] AT [speed] 
		-- Urg(N)/Alr(M)/Resp(W/U)
		uM55PositionSpeed [55] PositionSpeed,

		-- CROSS [position] AT OR LESS THAN [speed] 
		-- Urg(N)/Alr(M)/Resp(W/U)
		uM56PositionSpeed [56] PositionSpeed,

		-- CROSS [position] AT OR GREATER THAN [speed]
		-- Urg(N)/Alr(M)/Resp(W/U)
		uM57PositionSpeed	[57] PositionSpeed,

		-- CROSS [position] AT [time] AT [level] 
		-- Urg(N)/Alr(M)/Resp(W/U)
		uM58PositionTimeLevel [58] PositionTimeLevel,

		-- CROSS [position] AT OR BEFORE [time] AT [level] 
		-- Urg(N)/Alr(M)/Resp(W/U)
		uM59PositionTimeLevel [59] PositionTimeLevel,

		-- CROSS [position] AT OR AFTER [time] AT [level] 
		-- Urg(N)/Alr(M)/Resp(W/U)
		uM60PositionTimeLevel [60] PositionTimeLevel,

		-- CROSS [position] AT AND MAINTAIN [level] AT [speed]
		-- Urg(N)/Alr(M)/Resp(W/U)
		uM61PositionLevelSpeed [61] PositionLevelSpeed,

		-- AT [time] CROSS [position] AT AND MAINTAIN [level]
		-- Urg(N)/Alr(M)/Resp(W/U) 
		uM62TimePositionLevel	[62] TimePositionLevel,

		-- AT [time] CROSS [position] AT AND MAINTAIN [level] AT [speed]
		-- Urg(N)/Alr(M)/Resp(W/U)
		uM63TimePositionLevelSpeed [63] TimePositionLevelSpeed,

		-- OFFSET [specifiedDistance] [direction] OF ROUTE
		-- Urg(N)/Alr(M)/Resp(W/U)
		uM64DistanceSpecifiedDirection	[64] DistanceSpecifiedDirection,

		-- AT [position] OFFSET [specifiedDistance] [direction] OF ROUTE
		-- Urg(N)/Alr(M)/Resp(W/U)
		uM65PositionDistanceSpecifiedDirection[65] PositionDistanceSpecifiedDirection,

		-- AT [time] OFFSET [specifiedDistance] [direction] OF ROUTE
		-- Urg(N)/Alr(M)/Resp(W/U)
		uM66TimeDistanceSpecifiedDirection [66] TimeDistanceSpecifiedDirection,

		-- PROCEED BACK ON ROUTE
		-- Urg(N)/Alr(M)/Resp(W/U)
		uM67NULL	[67] NULL,

		-- REJOIN ROUTE BY [position]
		-- Urg(N)/Alr(M)/Resp(W/U)
		uM68Position	[68] Position,

		-- REJOIN ROUTE BY [time]
		-- Urg(N)/Alr(M)/Resp(W/U)
		uM69Time	[69] Time,

		-- EXPECT BACK ON ROUTE BY [position]
		-- Urg(L)/Alr(L)/Resp(R)
		uM70Position	[70] Position,

		-- EXPECT BACK ON ROUTE BY [time]
		-- Urg(L)/Alr(L)/Resp(R)
		uM71Time	[71] Time,

		-- RESUME OWN NAVIGATION
		-- Urg(N)/Alr(M)/Resp(W/U)
		uM72NULL	[72] NULL,

		-- [DepartureClearance]
		-- Urg(N)/Alr(M)/Resp(W/U)
		uM73DepartureClearance	[73] DepartureClearance,

		-- PROCEED DIRECT TO [position]
		-- Urg(N)/Alr(M)/Resp(W/U)
		uM74Position	[74] Position,

		-- WHEN ABLE PROCEED DIRECT TO [position] 
		-- Urg(N)/Alr(M)/Resp(W/U)
		uM75Position [75] Position,

		-- AT [time] PROCEED DIRECT TO [position] 
		-- Urg(N)/Alr(M)/Resp(W/U)
		uM76TimePosition [76] TimePosition,

		-- AT [position] PROCEED DIRECT TO [position] 
		-- Urg(N)/Alr(M)/Resp(W/U)
		uM77PositionPosition [77] PositionPosition,

		-- AT [level] PROCEED DIRECT TO [position] 
		-- Urg(N)/Alr(M)/Resp(W/U)
		uM78LevelPosition [78] LevelPosition,

		-- CLEARED TO [position] VIA [routeClearance] 
		-- Urg(N)/Alr(M)/Resp(W/U)
		uM79PositionRouteClearance [79] PositionRouteClearanceIndex,

		-- CLEARED [routeClearance] 
		-- Urg(N)/Alr(M)/Resp(W/U)
		uM80RouteClearance [80] RouteClearanceIndex,

		-- CLEARED [procedureName] 
		-- Urg(N)/Alr(M)/Resp(W/U)
		uM81ProcedureName [81] ProcedureName,

		-- CLEARED TO DEVIATE UP TO [specifiedDistance] [direction] OF ROUTE
		-- Urg(N)/Alr(M)/Resp(W/U)
		uM82DistanceSpecifiedDirection [82] DistanceSpecifiedDirection,

		-- AT [position] CLEARED [routeClearance] 
		-- Urg(N)/Alr(M)/Resp(W/U)
		uM83PositionRouteClearance [83] PositionRouteClearanceIndex,

		-- AT [position] CLEARED [procedureName] 
		-- Urg(N)/Alr(M)/Resp(W/U)
		uM84PositionProcedureName [84] PositionProcedureName,

		-- EXPECT [routeClearance] 
		-- Urg(L)/Alr(L)/Resp(R)
		uM85RouteClearance [85] RouteClearanceIndex,

		-- AT [position] EXPECT [routeClearance] 
		-- Urg(L)/Alr(L)/Resp(R)
		uM86PositionRouteClearance [86] PositionRouteClearanceIndex,

		-- EXPECT DIRECT TO [position] 
		-- Urg(L)/Alr(L)/Resp(R)
		uM87Position [87] Position,

		-- AT [position] EXPECT DIRECT TO [position] 
		-- Urg(L)/Alr(L)/Resp(R)
		uM88PositionPosition [88]PositionPosition,

		-- AT [time] EXPECT DIRECT TO [position] 
		-- Urg(L)/Alr(L)/Resp(R)
		uM89TimePosition [89] TimePosition,


		-- AT [level] EXPECT DIRECT TO [position]
		-- Urg(L)/Alr(L)/Resp(R)
		uM90LevelPosition	[90] LevelPosition,

		-- HOLD AT [position] MAINTAIN [level] INBOUND TRACK [degrees][direction] TURNS [legtype]
		-- Urg(N)/Alr(M)/Resp(W/U)
		uM91HoldClearance	[91] HoldClearance,

		-- HOLD AT [position] AS PUBLISHED MAINTAIN [level]
		--  Urg(N)/Alr(M)/Resp(W/U)
		uM92PositionLevel	[92] PositionLevel,

		-- EXPECT FURTHER CLEARANCE AT [time] 
		-- Urg(L)/Alr(L)/Resp(R)
		uM93Time [93] Time,

		-- TURN [direction] HEADING [degrees] 
		-- Urg(N)/Alr(M)/Resp(W/U)
		uM94DirectionDegrees [94] DirectionDegrees,

		-- TURN [direction] GROUND TRACK [degrees] 
		-- Urg(N)/Alr(M)/Resp(W/U)
		uM95DirectionDegrees [95] DirectionDegrees,

		-- CONTINUE PRESENT HEADING 
		-- Urg(N)/Alr(M)/Resp(W/U)
		uM96NULL [96] NULL,

		-- AT [position] FLY HEADING [degrees] 
		-- Urg(N)/Alr(M)/Resp(W/U)
		uM97PositionDegrees [97] PositionDegrees,

		-- IMMEDIATELY TURN [direction] HEADING [degrees]
		-- Urg(D)/Alr(H)/Resp(W/U)
		uM98DirectionDegrees [98] DirectionDegrees,

		-- EXPECT [procedureName] 
		-- Urg(L)/Alr(L)/Resp(R)
		uM99ProcedureName [99] ProcedureName,

		-- AT [time] EXPECT [speed] 
		-- Urg(L)/Alr(L)/Resp(R)
		uM100TimeSpeed [100] TimeSpeed,

		-- AT [position] EXPECT [speed] 
		-- Urg(L)/Alr(L)/Resp(R)
		uM101PositionSpeed [101] PositionSpeed,

		-- AT [level] EXPECT [speed] 
		-- Urg(L)/Alr(L)/Resp(R)
		uM102LevelSpeed [102] LevelSpeed,

		-- AT [time] EXPECT [speed] TO [speed] 
		-- Urg(L)/Alr(L)/Resp(R)
		uM103TimeSpeedSpeed [103] TimeSpeedSpeed,

		-- AT [position] EXPECT [speed] TO [speed] 
		-- Urg(L)/Alr(L)/Resp(R)
		uM104PositionSpeedSpeed [104] PositionSpeedSpeed,

		-- AT [level] EXPECT [speed] TO [speed] 
		-- Urg(L)/Alr(L)/Resp(R)
		uM105LevelSpeedSpeed [105] LevelSpeedSpeed,

		-- MAINTAIN [speed] 
		-- Urg(N)/Alr(M)/Resp(W/U)
		uM106Speed [106] Speed,

		-- MAINTAIN PRESENT SPEED 
		-- Urg(N)/Alr(M)/Resp(W/U)
		uM107NULL [107] NULL,

		-- MAINTAIN [speed] OR GREATER 
		-- Urg(N)/Alr(M)/Resp(W/U)
		uM108Speed [108] Speed,

		-- MAINTAIN [speed] OR LESS 
		-- Urg(N)/Alr(M)/Resp(W/U)
		uM109Speed [109] Speed,

		-- MAINTAIN [speed] TO [speed] 
		-- Urg(N)/Alr(M)/Resp(W/U)
		uM110SpeedSpeed [110] SpeedSpeed,

		-- INCREASE SPEED TO [speed] 
		-- Urg(N)/Alr(M)/Resp(W/U)
		uM111Speed [111] Speed,

		-- INCREASE SPEED TO [speed] OR GREATER 
		-- Urg(N)/Alr(M)/Resp(W/U)
		uM112Speed [112] Speed,

		-- REDUCE SPEED TO [speed] 
		-- Urg(N)/Alr(M)/Resp(W/U)
		uM113Speed [113] Speed,

		-- REDUCE SPEED TO [speed] OR LESS 
		-- Urg(N)/Alr(M)/Resp(W/U)
		uM114Speed [114] Speed,

		-- DO NOT EXCEED [speed] 
		-- Urg(N)/Alr(M)/Resp(W/U)
		uM115Speed [115] Speed,

		-- RESUME NORMAL SPEED 
		-- Urg(N)/Alr(M)/Resp(W/U)
		uM116NULL [116] NULL,

		-- CONTACT [unitname] [frequency] 
		-- Urg(N)/Alr(M)/Resp(W/U)
		uM117UnitNameFrequency [117] UnitNameFrequency,

		-- AT [position] CONTACT [unitname] [frequency] 
		-- Urg(N)/Alr(M)/Resp(W/U)
		uM118PositionUnitNameFrequency [118] PositionUnitNameFrequency,

		-- AT [time] CONTACT [unitname] [frequency] 
		-- Urg(N)/Alr(M)/Resp(W/U)
		uM119TimeUnitNameFrequency [119] TimeUnitNameFrequency,

		-- MONITOR [unitname] [frequency] 
		-- Urg(N)/Alr(M)/Resp(W/U)
		uM120UnitNameFrequency [120] UnitNameFrequency,

		-- AT [position] MONITOR [unitname] [frequency] 
		-- Urg(N)/Alr(M)/Resp(W/U)
		uM121PositionUnitNameFrequency [121] PositionUnitNameFrequency,

		-- AT [time] MONITOR [unitname] [frequency] 
		-- Urg(N)/Alr(M)/Resp(W/U)
		uM122TimeUnitNameFrequency [122] TimeUnitNameFrequency,

		-- SQUAWK [code] 
		-- Urg(N)/Alr(M)/Resp(W/U)
		uM123Code [123] Code,

		-- STOP SQUAWK 
		-- Urg(N)/Alr(M)/Resp(W/U)
		uM124NULL [124] NULL,

		-- SQUAWK MODE CHARLIE 
		-- Urg(N)/Alr(M)/Resp(W/U)
   uM125NULL [125] NULL,

		-- STOP SQUAWK MODE CHARLIE 
		-- Urg(N)/Alr(M)/Resp(W/U)
		uM126NULL [126] NULL,

		-- REPORT BACK ON ROUTE 
		-- Urg(N)/Alr(L)/Resp(W/U)
		uM127NULL [127] NULL,

		-- REPORT LEAVING [level] 
		-- Urg(N)/Alr(L)/Resp(W/U)
		uM128Level [128] Level,

		-- REPORT MAINTAINING [level] 
		-- Urg(N)/Alr(L)/Resp(W/U)
		uM129Level [129] Level,

		-- REPORT PASSING [position] 
		-- Urg(N)/Alr(L)/Resp(W/U)
		uM130Position [130] Position,

		-- REPORT REMAINING FUEL AND PERSONS ON BOARD
		-- Urg(U)/Alr(M)/Resp(Y)
		uM131NULL [131] NULL,

		-- REPORT POSITION 
		-- Urg(N)/Alr(M)/Resp(Y)
		uM132NULL [132] NULL,

		-- REPORT PRESENT LEVEL 
		-- Urg(N)/Alr(M)/Resp(Y)
		uM133NULL [133] NULL,

		-- REPORT [speedtype] [speedtype] [speedtype]SPEED 
		-- Urg(N)/Alr(M)/Resp(Y)
		uM134SpeedTypeSpeedTypeSpeedType [134] SpeedTypeSpeedTypeSpeedType,

		-- CONFIRM ASSIGNED LEVEL 
		-- Urg(N)/Alr(L)/Resp(Y)
		uM135NULL [135] NULL,

		-- CONFIRM ASSIGNED SPEED 
		-- Urg(N)/Alr(L)/Resp(Y)
		uM136NULL [136] NULL,

		-- CONFIRM ASSIGNED ROUTE 
		-- Urg(N)/Alr(L)/Resp(Y)
		uM137NULL [137] NULL,

	-- CONFIRM TIME OVER REPORTED WAYPOINT 
	-- Urg(N)/Alr(L)/Resp(Y)
		uM138NULL [138] NULL,

		-- CONFIRM REPORTED WAYPOINT 
		-- Urg(N)/Alr(L)/Resp(Y)
		uM139NULL [139] NULL,

		-- CONFIRM NEXT WAYPOINT 
		-- Urg(N)/Alr(L)/Resp(Y)
		uM140NULL [140] NULL,

		-- CONFIRM NEXT WAYPOINT ETA 
		-- Urg(N)/Alr(L)/Resp(Y)
		uM141NULL [141] NULL,
	
		-- CONFIRM ENSUING WAYPOINT 
		-- Urg(N)/Alr(L)/Resp(Y)
		uM142NULL [142] NULL,

		-- CONFIRM REQUEST 
		-- Urg(N)/Alr(L)/Resp(Y)
		uM143NULL [143] NULL,

		-- CONFIRM SQUAWK 
		-- Urg(N)/Alr(L)/Resp(Y)
		uM144NULL [144] NULL,

		-- REPORT HEADING 
		-- Urg(N)/Alr(M)/Resp(Y)
		uM145NULL [145] NULL,

		-- REPORT GROUND TRACK 
		-- Urg(N)/Alr(M)/Resp(Y)
		uM146NULL [146] NULL,
	
		-- REQUEST POSITION REPORT 
		-- Urg(N)/Alr(M)/Resp(Y )
		uM147NULL [147] NULL,

		-- WHEN CAN YOU ACCEPT [level] 
		-- Urg(N)/Alr(L)/Resp(Y)
		uM148Level [148] Level,

		-- CAN YOU ACCEPT [level] AT [position] 
		-- Urg(N)/Alr(L)/Resp(A/N)
		uM149LevelPosition [149] LevelPosition,

		-- CAN YOU ACCEPT [level] AT [time] 
		-- Urg(N)/Alr(L)/Resp(A/N)
		uM150LevelTime [150] LevelTime,

		-- WHEN CAN YOU ACCEPT [speed]
		-- Urg(N)/Alr(L)/Resp(Y)
		uM151Speed	[151] Speed,

		-- WHEN CAN YOU ACCEPT [specifiedDistance] [direction] OFFSET
		-- Urg(N)/Alr(L)/Resp(Y)
		uM152DistanceSpecifiedDirection [152] DistanceSpecifiedDirection,

		-- ALTIMETER [altimeter]
		-- Urg(N)/Alr(L)/Resp(R)
		uM153Altimeter	[153] Altimeter,

		-- RADAR SERVICE TERMINATED
		-- Urg(N)/Alr(L)/Resp(R)
		uM154NULL	[154] NULL,

		-- RADAR CONTACT [position]
		-- Urg(N)/Alr(M)/Resp(R)
		uM155Position	[155] Position,

		-- RADAR CONTACT LOST
		-- Urg(N)/Alr(M)/Resp(R)
		uM156NULL	[156] NULL,

		-- CHECK STUCK MICROPHONE [frequency]
		-- Urg(U)/Alr(M)/Resp(N)
		uM157Frequency	[157] Frequency,

		-- ATIS [atiscode]
		-- Urg(N)/Alr(L)/Resp(R)
		uM158AtisCode	[158] ATISCode,

		-- ERROR [errorInformation]
		-- Urg(U)/Alr(M)/Resp(N)
		uM159ErrorInformation	[159] ErrorInformation,

		-- NEXT DATA AUTHORITY [facility]
		-- Urg(L)/Alr(N)/Resp(N)
		uM160Facility	[160] Facility,

		-- END SERVICE
		-- Urg(L)/Alr(N)/Resp(N)
		uM161NULL	[161] NULL,

		-- SERVICE UNAVAILABLE
		-- Urg(L)/Alr(L)/Resp(N )
		uM162NULL	[162] NULL,

		-- [facilitydesignation]
		-- Urg(L)/Alr(N)/Resp(N)
		uM163FacilityDesignation	[163] FacilityDesignation,

		-- WHEN READY
		-- Urg(L)/Alr(N)/Resp(N)
		uM164NULL	[164] NULL,

		-- THEN
		-- Urg(L)/Alr(N)/Resp(N)
		uM165NULL	[165] NULL,

		-- DUE TO [traffictype]TRAFFIC 
		-- Urg(L)/Alr(N)/Resp(N)
		uM166TrafficType [166] TrafficType,

		-- DUE TO AIRSPACE RESTRICTION 
		-- Urg(L)/Alr(N)/Resp(N)
		uM167NULL [167] NULL,

		-- DISREGARD 
		-- Urg(U)/Alr(M)/Resp(R)
		uM168NULL [168] NULL,

		-- [freetext] 
		-- Urg(N)/Alr(L)/Resp(R)
		uM169FreeText [169] FreeText,

		-- [freetext] 
		-- Urg(D)/Alr(H)/Resp(R)
		uM170FreeText [170] FreeText,

		-- CLIMB AT [verticalRate] MINIMUM 
		-- Urg(N)/Alr(M)/Resp(W/U)
		uM171VerticalRate [171] VerticalRate,

		-- CLIMB AT [verticalRate] MAXIMUM 
		-- Urg(N)/Alr(M)/Resp(W/U)
		uM172VerticalRate [172] VerticalRate,

		-- DESCEND AT [verticalRate] MINIMUM 
		-- Urg(N)/Alr(M)/Resp(W/U)
		uM173VerticalRate [173] VerticalRate,

		-- DESCEND AT [verticalRate] MAXIMUM 
		-- Urg(N)/Alr(M)/Resp(W/U)
		uM174VerticalRate [174] VerticalRate,

		-- REPORT REACHING [level] 
		-- Urg(N)/Alr(L)/Resp(W/U)
		uM175Level [175] Level,

		-- MAINTAIN OWN SEPARATION AND VMC 
		-- Urg(N)/Alr(M)/Resp(W/U)
		uM176NULL [176] NULL,

		-- AT PILOTS DISCRETION 
		-- Urg(L)/Alr(L)/Resp(N)
		uM177NULL [177] NULL,

		-- Reserved 
		-- Urg(L)/Alr(L)/Resp(Y)
		uM178NULL [178] NULL,

		-- SQUAWK IDENT 
		-- Urg(N)/Alr(M)/Resp(W/U)
		uM179NULL [179] NULL,

		-- REPORT REACHING BLOCK [level] TO [level] 
		-- Urg(N)/Alr(L)/Resp(W/U)
		uM180LevelLevel [180] LevelLevel,

		-- REPORT DISTANCE [tofrom] [position] 
		-- Urg(N)/Alr(M)/Resp(Y)
		uM181ToFromPosition [181] ToFromPosition,

		-- CONFIRM ATIS CODE 
		-- Urg(N)/Alr(L)/Resp(Y)
		uM182NULL [182] NULL,

		-- [freetext] 
		-- Urg(N)/Alr(M)/Resp(N)
		uM183FreeText [183] FreeText,

		-- AT [time] REPORT DISTANCE [tofrom] [position] 
		-- Urg(N)/Alr(L)/Resp(Y)
		uM184TimeToFromPosition [184] TimeToFromPosition,
	
		-- AFTER PASSING [position] CLIMB TO [level] 
		-- Urg(N)/Alr(M)/Resp(W/U)
		uM185PositionLevel [185] PositionLevel,

		-- AFTER PASSING [position] DESCEND TO [level] 
		-- Urg(N)/Alr(M)/Resp(W/U)
		uM186PositionLevel [186] PositionLevel,

		-- [freetext] 
		-- Urg(L)/Alr(N)/Resp(N)
		uM187FreeText [187] FreeText,

		-- AFTER PASSING [position] MAINTAIN [speed] 
		-- Urg(N)/Alr(M)/Resp(W/U)
		uM188PositionSpeed [188] PositionSpeed,

		-- ADJUST SPEED TO [speed] 
		-- Urg(N)/Alr(M)/Resp(W/U)
		uM189Speed [189] Speed,

		-- FLY HEADING [degrees] 
		-- Urg(N)/Alr(M)/Resp(W/U)
		uM190Degrees [190] Degrees,

		-- ALL ATS TERMINATED 
		-- Urg(N)/Alr(M)/Resp(R)
		uM191NULL [191] NULL,

		-- REACH [level] BY [time] 
	-- Urg(N)/Alr(M)/Resp(W/U)
		uM192LevelTime [192] LevelTime,

		-- IDENTIFICATION LOST 
		-- Urg(N)/Alr(M)/Resp(R)
		uM193NULL [193] NULL,

		-- [freetext] 
		-- Urg(N)/Alr(L)/Resp(Y)
		uM194FreeText [194] FreeText,

		-- [freetext] 
		-- Urg(L)/Alr(L)/Resp(R)
		uM195FreeText [195] FreeText,

		-- [freetext] 
		-- Urg(N)/Alr(M)/Resp
		uM196FreeText [196] FreeText,

		-- [freetext] 
		-- Urg(U)/Alr(M)/Resp(W/U)
		uM197FreeText [197] FreeText,

		-- [freetext] 
		-- Urg(D)/Alr(H)/Resp(W/U)
		uM198FreeText [198] FreeText,

		-- [freetext] 
		-- Urg(N)/Alr(L)/Resp(N)
		uM199FreeText [199] FreeText,
	
		-- REPORT REACHING 
		-- Urg(N)/Alr(L)/Resp(W/U)
		uM200NULL [200] NULL,

		-- Not Used 
		-- Urg(L)/Alr(L)/Resp(N)
		uM201NULL [201] NULL,

		-- Not Used 
		-- Urg(L)/Alr(L)/Resp(N)
		uM202NULL [202] NULL,

		-- [freetext] 
		-- Urg(N)/Alr(M)/Resp(R)
		uM203FreeText [203] FreeText,

		-- [freetext] 
		-- Urg(N)/Alr(M)/Resp(Y)
		uM204FreeText [204] FreeText,

		-- [freetext] 
		-- Urg(N)/Alr(M)/Resp(A/N)
		uM205FreeText [205] FreeText,

		-- [freetext] 
		-- Urg(L)/Alr(N)/Resp(Y)
		uM206FreeText [206] FreeText,

		-- [freetext] 
		-- Urg(L)/Alr(L)/Resp(Y)
		uM207FreeText [207] FreeText,

		-- [freetext] 
		-- Urg(L)/Alr(L)/Resp(N)
		uM208FreeText [208] FreeText,
	
		-- REACH [level] BY [position] 
		-- Urg(N)/Alr(M)/Resp(W/U)
		uM209LevelPosition [209] LevelPosition,

		-- IDENTIFIED [position] 
		-- Urg(N)/Alr(M)/Resp(R)
		uM210Position [210] Position,

		-- REQUEST FORWARDED 
		-- Urg(N)/Alr(L)/Resp(N)
		uM211NULL [211] NULL,

		-- [facilitydesignation] ATIS [atiscode] CURRENT 
		-- Urg(N)/Alr(L)/Resp(R)
		uM212FacilityDesignationATISCode [212] FacilityDesignationATISCode,

		-- [facilitydesignation] ALTIMETER [altimeter] 
		-- Urg(N)/Alr(L)/Resp(R)
		uM213FacilityDesignationAltimeter [213] FacilityDesignationAltimeter,

		-- RVR RUNWAY [runway] [rvr] 
		-- Urg(N)/Alr(M)/Resp(R)
		uM214RunwayRVR [214] RunwayRVR,
	
		-- TURN [direction][degrees] 
		-- Urg(N)/Alr(M)/Resp(W/U)
		uM215DirectionDegrees [215] DirectionDegrees,

		-- REQUEST FLIGHT PLAN 
		-- Urg(N)/Alr(M)/Resp(Y)
		uM216NULL [216] NULL,

		-- REPORT ARRIVAL 
		-- Urg(N)/Alr(M)/Resp(Y)
		uM217NULL [217] NULL,

		-- REQUEST ALREADY RECEIVED 
		-- Urg(L)/Alr(N)/Resp(N)
		uM218NULL [218] NULL,

		-- STOP CLIMB AT [level] 
		-- Urg(U)/Alr(M)/Resp(W/U)
		uM219Level [219] Level,

		-- STOP DESCENT AT [level] 
		-- Urg(U)/Alr(M)/Resp(W/U)
		uM220Level [220] Level,

		-- STOP TURN HEADING [degrees] 
		-- Urg(U)/Alr(M)/Resp(W/U)
		uM221Degrees [221] Degrees,

		-- NO SPEED RESTRICTION 
		-- Urg(L)/Alr(L)/Resp(R)
		uM222NULL [222] NULL,

		-- REDUCE TO MINIMUM APPROACH SPEED 
		-- Urg(N)/Alr(M)/Resp(W/U)
		uM223NULL [223] NULL,

	-- NO DELAY EXPECTED 
	-- Urg(N)/Alr(L)/Resp(R)
		uM224NULL [224] NULL,

		-- DELAY NOT DETERMINED 
		-- Urg(N)/Alr(L)/Resp(R)
		uM225NULL [225] NULL,

		-- EXPECTED APPROACH TIME [time] 
		-- Urg(N)/Alr(L)/Resp(R)
		uM226Time [226] Time,

		-- LOGICAL ACKNOWLEDGMENT 
		-- Urg(N)/Alr(M)/Resp(N)
		uM227NULL [227] NULL,

		-- REPORT ETA [position] 
		--Urg(L)/Alr(L)/Resp(Y)
		uM228Position [228] Position,

		-- REPORT ALTERNATE AERODROME 
		-- Urg(L)/Alr(L)/Resp(Y)
		uM229NULL [229] NULL,

		-- IMMEDIATELY 
		-- Urg(D)/Alr(H)/Resp(N)
		uM230NULL [230] NULL,

		-- STATE PREFERRED LEVEL 
		-- Urg(L)/Alr(L)/Resp(Y)
		uM231NULL [231] NULL,

		-- STATE TOP OF DESCENT 
		-- Urg(L)/Alr(L)/Resp(Y)
		uM232NULL [232] NULL,

		-- USE OF LOGICAL ACKNOWLEDGMENT PROHIBITED
		-- Urg(N)/Alr(M)/Resp(N)
		uM233NULL [233] NULL,

		-- FLIGHT PLAN NOT HELD 
		-- Urg(L)/Alr(L)/Resp(N)
		uM234NULL [234] NULL,

		-- ROGER 7500 
		-- Urg(U)/Alr(H)/Resp(N)
		uM235NULL [235] NULL,

		-- LEAVE CONTROLLED AIRSPACE 
		-- Urg(N)/Alr(M)/Resp(W/U)
		uM236NULL [236] NULL,
		...,

		-- REQUEST AGAIN WITH NEXT UNIT
		-- Urg(N)/Alr(L)/Resp(N)
		uM237NULL	[237]NULL
}

------------------------------------------------------------------------------------
-- Downlink message element
-- ----------------------------------------------------------------------------------
ATCDownlinkMsgElementId ::= CHOICE
{
		-- WILCO
		-- Urg(N)/Alr(M)/Resp(N)
		dM0NULL	[0] NULL,

		--UNABLE
		-- Urg(N)/Alr(M)/Resp(N)
		dM1NULL	[1] NULL,

		-- STANDBY
		-- Urg(N)/Alr(M)/Resp(N)
		dM2NULL	[2] NULL,

		-- ROGER
		-- Urg(N)/Alr(M)/Resp(N)
		dM3NULL	[3] NULL,

		-- AFFIRM
		-- Urg(N)/Alr(M)/Resp(N)
		dM4NULL	[4] NULL,

		-- NEGATIVE
		-- Urg(N)/Alr(M)/Resp(N)
		dM5NULL	[5] NULL,

		-- REQUEST [level]
	-- Urg(N)/Alr(L)/Resp(Y)
		dM6Level	[6] Level,

		-- REQUEST BLOCK [level] TO [level]
	-- Urg(N)/Alr(L)/Resp(Y)
		dM7LevelLevel	[7] LevelLevel,

		-- REQUEST CRUISE CLIMB TO [level]
		-- Urg(N)/Alr(L)/Resp(Y)
		dM8Level [8] Level,

		-- REQUEST CLIMB TO [level]
		-- Urg(N)/Alr(L)/Resp(Y)
		dM9Level	[9] Level,

		-- REQUEST DESCENT TO [level]
		-- Urg(N)/Alr(L)/Resp(Y)
		dM10Level	[10] Level,

		-- AT [position] REQUEST CLIMB TO [level]
		-- Urg(N)/Alr(L)/Resp(Y)
		dM11PositionLevel	[11] PositionLevel,

		-- AT [position] REQUEST DESCENT TO [level]
		-- Urg(N)/Alr(L)/Resp(Y)
		dM12PositionLevel	[12] PositionLevel,

		-- AT [time] REQUEST CLIMB TO [level]
		-- Urg(N)/Alr(L)/Resp(Y)
		dM13TimeLevel	[13] TimeLevel,

		-- AT [time] REQUEST DESCENT TO [level]
		-- Urg(N)/Alr(L)/Resp(Y)
		dM14TimeLevel	[14] TimeLevel,

		-- REQUEST OFFSET [specifiedDistance] [direction] OF ROUTE
		-- Urg(N)/Alr(L)/Resp(Y)
		dM15DistanceSpecifiedDirection	[15] DistanceSpecifiedDirection,

		-- AT [position] REQUEST OFFSET [specifiedDistance] [direction] OF ROUTE
		-- Urg(N)/Alr(L)/Resp(Y)
		dM16PositionDistanceSpecifiedDirection [16] PositionDistanceSpecifiedDirection,

		-- AT [time] REQUEST OFFSET [specifiedDistance] [direction] OF ROUTE
		-- Urg(N)/Alr(L)/Resp(Y)
		dM17TimeDistanceSpecifiedDirection [17] TimeDistanceSpecifiedDirection,

		-- REQUEST [speed]
		-- Urg(N)/Alr(L)/Resp(Y)
		dM18Speed	[18] Speed,

		-- REQUEST [speed] TO [speed]
		-- Urg(N)/Alr(L)/Resp(Y)
		dM19SpeedSpeed	[19] SpeedSpeed,

		-- REQUEST VOICE CONTACT
		-- Urg(N)/Alr(L)/Resp(Y)
		dM20NULL	[20] NULL,

		-- REQUEST VOICE CONTACT [frequency]
		-- Urg(N)/Alr(L)/Resp(Y)
		dM21Frequency	[21] Frequency,

		-- REQUEST DIRECT TO [position]
		-- Urg(N)/Alr(L)/Resp(Y)
		dM22Position	[22] Position,

		-- REQUEST [procedureName]
		-- Urg(N)/Alr(L)/Resp(Y)
		dM23ProcedureName	[23] ProcedureName,

		-- REQUEST CLEARANCE [routeClearance]
		-- Urg(N)/Alr(L)/Resp(Y)
		dM24RouteClearance	[24] RouteClearanceIndex,

		-- REQUEST [clearanceType] CLEARANCE
		-- Urg(N)/Alr(L)/Resp(Y)
		dM25ClearanceType	[25] ClearanceType,

		-- REQUEST WEATHER DEVIATION TO [position] VIA [routeClearance]
		-- Urg(N)/Alr(M)/Resp(Y)
		dM26PositionRouteClearance [26] PositionRouteClearanceIndex,

		-- REQUEST WEATHER DEVIATION UP TO [specifiedDistance] [direction] OF ROUTE
		-- Urg(N)/Alr(M)/Resp(Y)
		dM27DistanceSpecifiedDirection [27] DistanceSpecifiedDirection,

		-- LEAVING [level]
		-- Urg(N)/Alr(L)/Resp(N)
		dM28Level	[28] Level,

		-- CLIMBING TO [level]
		-- Urg(N)/Alr(L)/Resp(N)
		dM29Level	[29]Level,

		-- DESCENDING TO [level]
		-- Urg(N)/Alr(L)/Resp(N)
		dM30Level	[30] Level,

		-- PASSING [position]
		-- Urg(N)/Alr(L)/Resp(N)
		dM31Position	[31] Position,

		-- PRESENT LEVEL [level] 
		-- Urg(N)/Alr(L)/Resp(N)
		dM32Level [32] Level,

		-- PRESENT POSITION [position] 
		-- Urg(N)/Alr(L)/Resp(N)
		dM33Position [33] Position,

		-- PRESENT SPEED [speed] 
		-- Urg(N)/Alr(L)/Resp(N)
		dM34Speed [34] Speed,

		-- PRESENT HEADING [degrees] 
		-- Urg(N)/Alr(L)/Resp(N)
		dM35Degrees [35] Degrees,

		-- PRESENT GROUND TRACK [degrees] 
		-- Urg(N)/Alr(L)/Resp(N)
		dM36Degrees [36] Degrees,

		-- MAINTAINING [level] 
		-- Urg(N)/Alr(L)/Resp(N)
		dM37Level [37] Level,

		-- ASSIGNED LEVEL [level] 
		-- Urg(N)/Alr(M)/Resp(N)
		dM38Level [38] Level,

		-- ASSIGNED SPEED [speed] 
		-- Urg(N)/Alr(M)/Resp(N)
		dM39Speed [39] Speed,

		-- ASSIGNED ROUTE [routeClearance] 
		-- Urg(N)/Alr(M)/Resp(N)
		dM40RouteClearance [40] RouteClearanceIndex,

		-- BACK ON ROUTE 
		-- Urg(N)/Alr(M)/Resp(N)
		dM41NULL [41] NULL,

		-- NEXT WAYPOINT [position] 
		-- Urg(N)/Alr(L)/Resp(N)
		dM42Position [42] Position,

		-- NEXT WAYPOINT ETA [time] 
		-- Urg(N)/Alr(L)/Resp(N)
		dM43Time [43] Time,

		-- ENSUING WAYPOINT [position] 
		-- Urg(N)/Alr(L)/Resp(N)
		dM44Position [44] Position,

		-- REPORTED WAYPOINT [position] 
		-- Urg(N)/Alr(L)/Resp(N)
		dM45Position [45] Position,

		-- REPORTED WAYPOINT [time] 
		-- Urg(N)/Alr(L)/Resp(N)
		dM46Time [46] Time,

		-- SQUAWKING [code] 
		-- Urg(N)/Alr(L)/Resp(N)
		dM47Code [47] Code,

		-- POSITION REPORT [positionreport] 
		-- Urg(N)/Alr(M)/Resp(N)
		dM48PositionReport [48] PositionReport,

		-- WHEN CAN WE EXPECT [speed] 
		-- Urg(L)/Alr(L)/Resp(Y)
		dM49Speed [49] Speed,

		-- WHEN CAN WE EXPECT [speed] TO [speed]
		-- Urg(L)/Alr(L)/Resp(Y)
		dM50SpeedSpeed [50] SpeedSpeed,

		-- WHEN CAN WE EXPECT BACK ON ROUTE 
		-- Urg(L)/Alr(L)/Resp(Y)
		dM51NULL [51] NULL,

		-- WHEN CAN WE EXPECT LOWER LEVEL 
		-- Urg(L)/Alr(L)/Resp(Y)
		dM52NULL [52] NULL,

		-- WHEN CAN WE EXPECT HIGHER LEVEL Urg(L)/Alr(L)/Resp(Y)
		dM53NULL [53] NULL,
	
		-- WHEN CAN WE EXPECT CRUISE CLIMB TO [level] 
		-- Urg(L)/Alr(L)/Resp(Y)
		dM54Level	[54] Level,

		-- PAN PAN PAN
		-- Urg(U)/Alr(H)/Resp(Y)
		dM55NULL	[55] NULL,

		-- MAYDAY MAYDAY MAYDAY
		-- Urg(D)/Alr(H)/Resp(Y)
		dM56NULL	[56] NULL,

		-- [remainingFuel] OF FUEL REMAINING AND [personsonboard] PERSONS ON BOARD
		-- Urg(U)/Alr(H)/Resp(Y)
		dM57RemainingFuelPersonsOnBoard	[57] RemainingFuelPersonsOnBoard,

		-- CANCEL EMERGENCY
		-- Urg(U)/Alr(M)/Resp(Y)
		dM58NULL	[58] NULL,

		-- DIVERTING TO [position] VIA [routeClearance]
		-- Urg(U)/Alr(H)/Resp(Y)
		dM59PositionRouteClearance	[59] PositionRouteClearanceIndex,

		-- OFFSETTING [specifiedDistance] [direction] OF ROUTE 
		-- Urg(U)/Alr(H)/Resp(Y)
		dM60DistanceSpecifiedDirection [60] DistanceSpecifiedDirection,

		-- DESCENDING TO [level]
		-- Urg(U)/Alr(H)/Resp(Y)
		dM61Level	[61] Level,

		-- ERROR [errorInformation] 
		-- Urg(U)/Alr(L)/Resp(N)
		dM62ErrorInformation [62] ErrorInformation,

		-- NOT CURRENT DATA AUTHORITY 
		-- Urg(L)/Alr(L)/Resp(N)
		dM63NULL [63] NULL,

		-- [facilitydesignation]
		-- Urg(L)/Alr(L)/Resp(N)
		dM64FacilityDesignation [64] FacilityDesignation,

		--  DUE TO WEATHER 
		-- Urg(L)/Alr(L)/Resp(N)
		dM65NULL [65] NULL,

		-- DUE TO AIRCRAFT PERFORMANCE 
		-- Urg(L)/Alr(L)/Resp(N)
		dM66NULL [66] NULL,

		-- [freetext] 
		-- Urg(N)/Alr(L)/Resp(N)
		dM67FreeText [67] FreeText,

		-- [freetext] 
		-- Urg(D)/Alr(H)/Resp(Y)
		dM68FreeText [68] FreeText,

		-- REQUEST VMC DESCENT 
		-- Urg(N)/Alr(L)/Resp(Y)
		dM69NULL [69] NULL,

		-- REQUEST HEADING [degrees] 
		-- Urg(N)/Alr(L)/Resp(Y)
		dM70Degrees [70] Degrees,

		-- REQUEST GROUND TRACK [degrees] 
		-- Urg(N)/Alr(L)/Resp(Y)
		dM71Degrees [71] Degrees,

		-- REACHING [level] 
		-- Urg(N)/Alr(L)/Resp(N)
		dM72Level [72] Level,

		-- [versionnumber] 
		-- Urg(L)/Alr(L)/Resp(N)
		dM73Versionnumber [73] VersionNumber,

		-- REQUEST TO MAINTAIN OWN SEPARATION AND VMC
		-- Urg(L)/Alr(L)/Resp(Y)
		dM74NULL [74] NULL,

		-- AT PILOTS DISCRETION 
		-- Urg(L)/Alr(L)/Resp(N)
		dM75NULL [75] NULL,

		-- REACHING BLOCK [level] TO [level] 
		-- Urg(N)/Alr(L)/Resp(N)
		dM76LevelLevel [76] LevelLevel,

		-- ASSIGNED BLOCK [level] TO [level]
		-- Urg(N)/Alr(M)/Resp(N)
		dM77LevelLevel	[77] LevelLevel,

		-- AT [time] [distance] [tofrom] [position]
		-- Urg(N)/Alr(L)/Resp(N)
		dM78TimeDistanceToFromPosition	[78] TimeDistanceToFromPosition,

		-- ATIS [atiscode]
		-- Urg(N)/Alr(L)/Resp(N)
		dM79AtisCode	[79] ATISCode,

		-- DEVIATING UP TO [specifiedDistance] [direction] OF ROUTE
		-- Urg(U)/Alr(H)/Resp(Y)
		dM80DistanceSpecifiedDirection [80] DistanceSpecifiedDirection,

		-- WE CAN ACCEPT [level] AT [time]
		-- Urg(L)/Alr(L)/Resp(N)
		dM81LevelTime	[81] LevelTime,

		-- WE CANNOT ACCEPT [level]
		-- Urg(L)/Alr(L)/Resp(N)
		dM82Level	[82] Level,

		-- WE CAN ACCEPT [speed] AT [time]
		-- Urg(L)/Alr(L)/Resp(N)
		dM83SpeedTime	[83] SpeedTime,

		-- WE CANNOT ACCEPT [speed]
		-- Urg(L)/Alr(L)/Resp(N)
		dM84Speed	[84] Speed,

		-- WE CAN ACCEPT [specifiedDistance] [direction] AT [time]
		-- Urg(L)/Alr(L)/Resp(N)
		dM85DistanceSpecifiedDirectionTime [85] DistanceSpecifiedDirectionTime,

		-- WE CANNOT ACCEPT [specifiedDistance] [direction]
		-- Urg(L)/Alr(L)/Resp(N)
		dM86DistanceSpecifiedDirection	[86] DistanceSpecifiedDirection,

		-- WHEN CAN WE EXPECT CLIMB TO [level]
		-- Urg(L)/Alr(L)/Resp(Y)
		dM87Level	[87] Level,

		-- WHEN CAN WE EXPECT DESCENT TO [level]
		--Urg(L)/Alr(L)/Resp(Y)
		dM88Level	[88] Level,

		-- MONITORING [unitname] [frequency]
		-- Urg(U)/Alr(M)/Resp(N)
		dM89UnitnameFrequency	[89] UnitNameFrequency,

		-- [freetext]
		-- Urg(N)/Alr(M)/Resp(N)
		dM90FreeText	[90] FreeText,

		-- [freetext]
		-- Urg(N)/Alr(L)/Resp(Y)
		dM91FreeText	[91] FreeText,

		-- [freetext] 
		-- Urg(L)/Alr(L)/Resp(Y)
		dM92FreeText [92] FreeText,

		-- [freetext] 
		-- Urg(U)/Alr(H)/Resp(N)
		dM93FreeText [93] FreeText,

		-- [freetext] 
		-- Urg(D)/Alr(H)/Resp(N)
		dM94FreeText [94] FreeText,

		-- [freetext] 
		-- Urg(U)/Alr(M)/Resp(N)
		dM95FreeText [95] FreeText,

		-- [freetext] 
		-- Urg(U)/Alr(L)/Resp(N)
		dM96FreeText [96] FreeText,

		-- [freetext] 
		-- Urg(L)/Alr(L)/Resp(N)
		dM97FreeText [97] FreeText,

		-- [freetext] 
		-- Urg(N)/Alr(N)/Resp(N)
		dM98FreeText [98] FreeText,

		-- CURRENT DATA AUTHORITY 
		-- Urg(L)/Alr(L)/Resp(N)
		dM99NULL [99] NULL,

		-- LOGICAL ACKNOWLEDGMENT 
		-- Urg(N)/Alr(M)/Resp(N)
		dM100NULL [100] NULL,

		-- REQUEST END OF SERVICE 
		-- Urg(L)/Alr(L)/Resp(Y)
		dM101NULL [101] NULL,

		-- LANDING REPORT 
		-- Urg(N)/Alr(N)/Resp(N)
		dM102NULL [102] NULL,

		-- CANCELLING IFR 
		-- Urg(N)/Alr(L)/Resp(Y)
		dM103NULL [103] NULL,

		-- ETA[position][time] 
		-- Urg(L)/Alr(L)/Resp(N)
		dM104PositionTime [104] PositionTime,

		-- ALTERNATE AERODROME[airport] 
		-- Urg(L)/Alr(L)/Resp(N)
		dM105Airport [105] Airport,

		-- PREFERRED LEVEL[level] 
		-- Urg(L)/Alr(L)/Resp(N)
		dM106Level [106] Level,

		-- NOT AUTHORIZED NEXT DATA AUTHORITY 
		-- Urg(L)/Alr(L)/Resp(N)
		dM107NULL [107] NULL,

		-- DE-ICING COMPLETE 
		-- Urg(L)/Alr(L)/Resp(N)
		dM108NULL [108] NULL,

		-- TOP OF DESCENT [time] 
		-- Urg(L)/Alr(L)/Resp(N)
		dM109Time [109] Time,

		-- TOP OF DESCENT [position] 
		-- Urg(L)/Alr(L)/Resp(N)
		dM110Position [110] Position,

		-- TOP OF DESCENT [time] [position] 
		-- Urg(L)/Alr(L)/Resp(N)
		dM111TimePosition [111] TimePosition,

		-- SQUAWKING 7500 
		-- Urg(U)/Alr(H)/Resp(N)
		dM112NULL [112] NULL,

		-- [speedType] [speedType] [speedType] SPEED [speed]
		-- Urg(N)/Alr(L)/Resp(N)
		dM113SpeedTypeSpeedTypeSpeedTypeSpeed	[113]	SpeedTypeSpeedTypeSpeedTypeSpeed,

		...
}

AircraftAddress ::= BIT STRING (SIZE(24))

AircraftFlightIdentification ::= IA5String (SIZE (2..8))

Airport ::= IA5String (SIZE (4))

Altimeter ::= CHOICE
{
		altimeterEnglish	[0]	AltimeterEnglish,
		altimeterMetric	[1]	AltimeterMetric
}

AltimeterEnglish ::= INTEGER (2200..3200)
-- unit = Inches Mercury, Range (22.00 .. 32.00), resolution = 0.01

AltimeterMetric ::= INTEGER (7500..12500)
-- unit = Hectopascal, Range (750.0..1250.0), resolution = 0.1

ATISCode ::= IA5String (SIZE (1))

ATSRouteDesignator ::= IA5String (SIZE (2..7))

ATWAlongTrackWaypoint ::= SEQUENCE
{
		position		[0]	Position,
		aTWDistance	[1]	ATWDistance,
		speed				[2]	Speed							OPTIONAL,
		aTWLevels		[3]	ATWLevelSequence	OPTIONAL
}

ATWLevel ::= SEQUENCE
{
		atw	ATWLevelTolerance,
		level	Level
}

ATWLevelSequence ::= SEQUENCE SIZE (1..2) OF ATWLevel

ATWLevelTolerance ::= ENUMERATED
{
		at				(0),
		atorabove (1),
		atorbelow (2)
}

ATWDistance ::= SEQUENCE
{
		atwDistanceTolerance	ATWDistanceTolerance,
		distance	Distance
}

ATWDistanceTolerance ::= ENUMERATED
{
		plus	(0),
		minus	(1)
}

ClearanceType ::= ENUMERATED
{
		noneSpecified	(0),
		approach			(1),
		departure			(2),
		further				(3),
		start-up			(4),
		pushback			(5),
		taxi					(6),
		take-off			(7),
		landing				(8),
		oceanic				(9),
		en-route			(10),
		downstream		(11),
		...
}

Code ::= SEQUENCE SIZE (4) OF CodeOctalDigit

CodeOctalDigit ::= INTEGER (0..7)

ControlledTime ::= SEQUENCE
{
		time	Time,
		timeTolerance	TimeTolerance
}

Date ::= SEQUENCE
{
		year	Year,
		month	Month,
		day	Day
}

DateTimeGroup ::= SEQUENCE
{
		date	Date,
		timehhmmss	Timehhmmss
}

Day ::= INTEGER (1..31)
--unit = Day, Range (1..31), resolution = 1

DegreeIncrement ::= INTEGER (1..20)
--unit = Degree, Range (1..20), resolution = 1

Degrees ::= CHOICE
{
		degreesMagnetic	[0]	DegreesMagnetic,
		degreesTrue			[1]	DegreesTrue
}

DegreesMagnetic ::= INTEGER (1..360)
--unit = degree, Range (1..360), resolution = 1

DegreesTrue ::= INTEGER (1..360)
--unit = degree, Range (1..360), resolution = 1

DepartureClearance ::= SEQUENCE
{
		aircraftFlightIdentification	[0]	AircraftFlightIdentification,
		clearanceLimit								[1]	Position,
		flightInformation							[2]	FlightInformation						OPTIONAL,
		furtherInstructions						[3]	FurtherInstructions					OPTIONAL
}

DepartureMinimumInterval ::= INTEGER (1..150)
--unit = Minute, Range (0.1..15.0), resolution = 0.1

Direction ::= ENUMERATED
{
		left				(0),
		right				(1),
		eitherSide	(2),
		north				(3),
		south				(4),
		east				(5),
		west				(6),
		northEast		(7),
		northWest		(8),
		southEast		(9),
		southWest		(10)
}

DirectionDegrees ::= SEQUENCE
{
		direction	Direction,
		degrees	Degrees
}

Distance ::= CHOICE
{
		distanceNm	[0]	DistanceNm,
		distanceKm	[1]	DistanceKm
}


DistanceKm ::= INTEGER (0..8000)
--	unit = Kilometer, Range (0..2000), resolution = 0.25

DistanceNm ::= INTEGER (0..9999)
--	unit = Nautical Mile, Range (0..999.9), resolution = 0.1

DistanceSpecified ::= CHOICE
{
		distanceSpecifiedNm	[0]	DistanceSpecifiedNm,
		distanceSpecifiedKm	[1]	DistanceSpecifiedKm
}


DistanceSpecifiedDirection ::= SEQUENCE
{
		distanceSpecified	DistanceSpecified,
		direction	Direction
}

DistanceSpecifiedDirectionTime ::= SEQUENCE
{
		distanceSpecifiedDirection	DistanceSpecifiedDirection,
		time	Time
}

DistanceSpecifiedKm ::= INTEGER (1..500)
--	unit = Kilometer, Range (1..500), resolution = 1

DistanceSpecifiedNm ::= INTEGER (1..250)
--	unit = Nautical Mile, Range (1..250), resolution = 1

ErrorInformation ::= ENUMERATED
{
		unrecognizedMsgReferenceNumber		(0),
		logicalAcknowledgmentNotAccepted	(1),
		insufficientResources							(2),
		invalidMessageElementCombination	(3),
		invalidMessageElement							(4),
		...
}

Facility ::= CHOICE{
		noFacility						[0]	NULL,
		facilityDesignation		[1]	FacilityDesignation
}

FacilityDesignation ::= IA5String (SIZE (4..8))

FacilityFunction ::= ENUMERATED
{
		center						(0),
		approach					(1),
		tower							(2),
		final							(3),
		groundControl			(4),
		clearanceDelivery (5),
		departure					(6),
		control						(7),
		radio							(8),
		...
}

FacilityDesignationAltimeter ::= SEQUENCE
{
		facilityDesignation	FacilityDesignation,
		altimeter	Altimeter
}

FacilityDesignationATISCode ::= SEQUENCE
{
		facilityDesignation	FacilityDesignation,
		aTISCode	ATISCode
}

FacilityName ::= IA5String (SIZE (3..18))

Fix ::= IA5String (SIZE (1..5))

FixName ::= SEQUENCE
{
		name		[0]	Fix,
		latlon	[1]	LatitudeLongitude	OPTIONAL
}

FlightInformation ::= CHOICE
{
		routeOfFlight		[0]	RouteInformation,
		levelsOfFlight	[1]	LevelsOfFlight,
		routeAndLevels	[2]	RouteAndLevels
}

FreeText ::= IA5String (SIZE (1..256))

Frequency ::= CHOICE
{
		frequencyhf					[0]	Frequencyhf,
		frequencyvhf				[1]	Frequencyvhf,
		frequencyuhf				[2]	Frequencyuhf,
		frequencysatchannel	[3]	Frequencysatchannel
}

Frequencyhf ::= INTEGER (2850..28000)
--	unit = Kilohertz, Range (2850..28000), resolution = 1

Frequencysatchannel ::= NumericString (SIZE (12))
--	Frequencysatchannel corresponds to a 12 digit telephone number

Frequencyuhf ::= INTEGER (9000..15999)
--	unit = Megahertz, Range (225.000..399.975), resolution = 0.025

Frequencyvhf ::= INTEGER (23600..27398)
--	unit = Megahertz, Range (118.000..136.990), resolution = 0.005

FurtherInstructions ::= SEQUENCE
{
		code								[0]	Code							OPTIONAL,
		frequencyDeparture	[1]	UnitNameFrequency	OPTIONAL,
		clearanceExpiryTime	[2]	Time							OPTIONAL,
		airportDeparture		[3]	Airport						OPTIONAL,
		airportDestination	[4]	Airport						OPTIONAL,
		timeDeparture				[5]	TimeDeparture			OPTIONAL,
		runwayDeparture			[6]	Runway						OPTIONAL,
		revisionNumber			[7]	RevisionNumber		OPTIONAL,
		aTISCode						[8]	ATISCode					OPTIONAL
}


Holdatwaypoint ::= SEQUENCE
{
		position								[0]	Position,
		holdatwaypointspeedlow	[1]	Speed				OPTIONAL,
		aTWlevel								[2] ATWLevel		OPTIONAL,
		holdatwaypointspeedhigh	[3]	Speed 			OPTIONAL,
		direction								[4]	Direction		OPTIONAL,
		degrees									[5]	Degrees			OPTIONAL,
		eFCtime									[6]	Time				OPTIONAL,
		legtype									[7]	LegType			OPTIONAL
}

HoldClearance ::= SEQUENCE
{
		position	[0]	Position,
		level			[1]	Level,
		degrees		[2]	Degrees,
		direction	[3]	Direction,
		legType		[4]	LegType				OPTIONAL
}


Humidity ::= INTEGER (0..100)
--	unit = Percent humidity, Range (0..100), resolution = 1

InterceptCourseFrom ::= SEQUENCE
{
		fromSelection	InterceptCourseFromSelection,
		degrees				Degrees
}

InterceptCourseFromSelection ::= CHOICE
{
		publishedIdentifier				[0]	PublishedIdentifier,
		latitudeLongitude					[1]	LatitudeLongitude,
		placeBearingPlaceBearing	[2]	PlaceBearingPlaceBearing,
		placeBearingDistance			[3]	PlaceBearingDistance
}

Icing ::= ENUMERATED
{
		reserved	(0),
		light			(1),
		moderate	(2),
		severe		(3)
}


Latitude ::= SEQUENCE
{
		latitudeType			LatitudeType,
		latitudeDirection	LatitudeDirection
}

LatitudeDegrees ::= INTEGER (0..90000)
-- unit = Degree, Range (0..90), resolution = 0.001

LatitudeDegreesMinutes ::= SEQUENCE
{
		latitudeWholeDegrees	LatitudeWholeDegrees,
		minutesLatLon					MinutesLatLon
}

LatitudeDegreesMinutesSeconds ::= SEQUENCE
{
		latitudeWholeDegrees	LatitudeWholeDegrees,
		latlonWholeMinutes		LatLonWholeMinutes,
		secondsLatLon					SecondsLatLon
}

LatitudeDirection ::= ENUMERATED
{
		north	(0),
		south	(1)
}

LatitudeWholeDegrees ::= INTEGER (0..89)
-- unit = Degree, Range (0..89), resolution = 1

LatitudeLongitude ::= SEQUENCE
{
		latitude	[0]	Latitude	OPTIONAL,
		longitude	[1]	Longitude	OPTIONAL
}

LatitudeReportingPoints ::= SEQUENCE
{
		latitudeDirection	LatitudeDirection,
		latitudeDegrees		LatitudeDegrees
}

LatitudeType ::= CHOICE
{
		latitudeDegrees					[0]	LatitudeDegrees,
		latitudeDegreesMinutes	[1]	LatitudeDegreesMinutes,
		latitudeDMS							[2]	LatitudeDegreesMinutesSeconds
}

LatLonWholeMinutes ::= INTEGER (0..59)
-- unit = Minute, Range (0..59), resolution = 1

LatLonReportingPoints ::= CHOICE
{
		latitudeReportingPoints		[0]	LatitudeReportingPoints,
		longitudeReportingPoints	[1]	LongitudeReportingPoints
}

LegDistance ::= CHOICE
{
		legDistanceEnglish	[0] LegDistanceEnglish,
		legDistanceMetric		[1]	LegDistanceMetric
}

LegDistanceEnglish ::= INTEGER (0..50)
-- unit = Nautical Mile, Range (0..50), resolution = 1

LegDistanceMetric ::= INTEGER (1..128)
-- unit = Kilometer, Range (1..128), resolution = 1

LegTime ::= INTEGER (0..10)
--unit = Minute, Range (0..10), resolution = 1

LegType ::= CHOICE
{
		legDistance	[0]	LegDistance,
		legTime			[1]	LegTime
}

Level ::= CHOICE
{
		singleLevel	[0]	LevelType,
		blockLevel	[1]	SEQUENCE SIZE (2) OF LevelType
}

LevelFeet ::= INTEGER (-60..7000)
--unit = Feet, Range (-600..70000), resolution = 10

LevelFlightLevel ::= INTEGER (30..700)
--unit = Level (100 Feet), Range (030..700), resolution = 1

LevelFlightLevelMetric ::= INTEGER (100..2500)
--unit = Level (10 Meters), Range (100..2500), resolution = 1
LevelLevel ::= SEQUENCE SIZE (2) OF Level
LevelMeters ::= INTEGER (-30..25000)
--unit = Meter, Range (-30..25000), resolution = 1

LevelPosition ::= SEQUENCE
{
		level			Level,
		position	Position
}

LevelProcedureName ::= SEQUENCE
{
		level					Level,
		procedureName	ProcedureName
}

LevelsOfFlight ::= CHOICE
{
		level								[0]	Level,
		procedureName				[1]	ProcedureName,
		levelProcedureName	[2]	LevelProcedureName
}

LevelSpeed ::= SEQUENCE
{
		level	Level,
		speed	SpeedSpeed
}

LevelSpeedSpeed ::= SEQUENCE
{
		level		Level,
		speeds	SpeedSpeed
}

LevelTime ::= SEQUENCE
{
		level	Level,
		time	Time
}

LevelType ::= CHOICE
{
		levelFeet								[0]	LevelFeet,
		levelMeters							[1]	LevelMeters,
		levelFlightLevel				[2]	LevelFlightLevel,
		levelFlightLevelMetric	[3]	LevelFlightLevelMetric
}

Longitude ::= SEQUENCE
{
		longitudeType				LongitudeType,
		longitudeDirection	LongitudeDirection
}

LongitudeDegrees ::= INTEGER (0..180000)
--unit = Degree, Range (0..180), resolution = 0.001

LongitudeDegreesMinutes ::= SEQUENCE
{
		longitudeWholeDegrees	LongitudeWholeDegrees,
		minutesLatLon					MinutesLatLon
}

LongitudeDegreesMinutesSeconds ::= SEQUENCE
{
		longitudeWholeDegrees	LongitudeWholeDegrees,
		latLonWholeMinutes		LatLonWholeMinutes,
		secondsLatLon					SecondsLatLon
}

LongitudeDirection ::= ENUMERATED
{
		east	(0),
		west	(1)
}

LongitudeWholeDegrees ::= INTEGER (0..179)
-- unit = Degree, Range (0..179), resolution = 1

LongitudeReportingPoints ::= SEQUENCE
{
		longitudeDirection	LongitudeDirection,
		longitudeDegrees		LongitudeDegrees
}

LongitudeType ::= CHOICE
{
		longitudeDegrees				[0]	LongitudeDegrees,
		longitudeDegreesMinutes [1]	LongitudeDegreesMinutes,
		longitudeDMS						[2]	LongitudeDegreesMinutesSeconds
}

MinutesLatLon ::= INTEGER (0..5999)
--unit = Minute, Range (0..59.99), resolution = 0.01

Month ::= INTEGER (1..12)
--unit = 1 Month, Range (1..12), resolution = 1

Navaid ::= SEQUENCE
{
		name		[0]	NavaidName,
		latlon	[1]	LatitudeLongitude	OPTIONAL
}

NavaidName ::= IA5String (SIZE (1..4))

PersonsOnBoard ::= INTEGER (1..1024)

PlaceBearing ::= SEQUENCE
{
		publishedIdentifier	PublishedIdentifier,
		degrees							Degrees
}

PlaceBearingDistance ::= SEQUENCE
{
		publishedIdentifier	PublishedIdentifier,
		degrees							Degrees,
		distance						Distance
}

PlaceBearingPlaceBearing ::= SEQUENCE SIZE (2) OF PlaceBearing

Position ::= CHOICE
{
		fixName								[0]	FixName,
		navaid								[1]	Navaid,
		airport								[2]	Airport,
		latitudeLongitude			[3]	LatitudeLongitude,
		placeBearingDistance	[4]	PlaceBearingDistance
}

PositionDegrees ::= SEQUENCE
{
		position	Position,
		degrees		Degrees
}


PositionDistanceSpecifiedDirection ::= SEQUENCE
{
		position	Position,
		distanceSpecifiedDirection	DistanceSpecifiedDirection
}

PositionLevel ::= SEQUENCE
{
		position	Position,
		level			Level
}

PositionLevelLevel ::= SEQUENCE
{
		position	Position,
		levels	LevelLevel
}

PositionLevelSpeed ::= SEQUENCE
{
		positionlevel	PositionLevel,
		speed					Speed
}

PositionPosition ::= SEQUENCE SIZE (2) OF Position

PositionProcedureName ::= SEQUENCE
{
		position			Position,
		procedureName	ProcedureName
}

PositionReport ::= SEQUENCE
{
		positioncurrent					[0]		Position,
		timeatpositioncurrent		[1]		Time,
		level										[2]		Level,
		fixnext									[3]		Position				OPTIONAL,
		timeetaatfixnext				[4]		Time						OPTIONAL,
		fixnextplusone					[5]		Position				OPTIONAL,
		timeetaatdestination		[6]		Time						OPTIONAL,
		remainingFuel						[7]		RemainingFuel		OPTIONAL,
		temperature							[8]		Temperature			OPTIONAL,
		winds										[9]		Winds						OPTIONAL,
		turbulence							[10]	Turbulence			OPTIONAL,
		icing										[11]	Icing						OPTIONAL,
		speed										[12]	Speed						OPTIONAL,
		speedground							[13]	SpeedGround			OPTIONAL,
		verticalChange					[14]	VerticalChange	OPTIONAL,
		trackAngle							[15]	Degrees					OPTIONAL,
		heading									[16]	Degrees					OPTIONAL,
		distance								[17]	Distance				OPTIONAL,
		humidity								[18]	Humidity				OPTIONAL,
		reportedWaypointPosition[19]	Position				OPTIONAL,
		reportedWaypointTime		[20]	Time						OPTIONAL,
		reportedWaypointLevel		[21]	Level						OPTIONAL
}

PositionRouteClearanceIndex ::= SEQUENCE
{
		position						Position,
		routeClearanceIndex	RouteClearanceIndex
}

PositionSpeed ::= SEQUENCE
{
		position	Position,
		speed			Speed
}

PositionSpeedSpeed ::= SEQUENCE
{
		position	Position,
		speeds		SpeedSpeed
}

PositionTime ::= SEQUENCE
{
		position	Position,
		time			Time
}

PositionTimeLevel ::= SEQUENCE
{
		positionTime	PositionTime,
		level	Level
}

PositionTimeTime ::= SEQUENCE
{
		position	Position,
		times			TimeTime
}

PositionUnitNameFrequency ::= SEQUENCE
{
		position	Position,
		unitname	UnitName,
	frequency	Frequency
}

Procedure ::= IA5String (SIZE (1..20))

ProcedureName ::= SEQUENCE
{
		type				[0]	ProcedureType,
		procedure		[1]	Procedure,
		transition	[2]	ProcedureTransition	OPTIONAL
}

ProcedureTransition ::= IA5String (SIZE (1..5))

ProcedureType ::= ENUMERATED
{
		arrival		(0),
		approach	(1),
		departure	(2)
}

PublishedIdentifier ::= CHOICE
{
		fixName	[0]	FixName,
		navaid	[1]	Navaid
}

RemainingFuel ::= Time

RemainingFuelPersonsOnBoard ::= SEQUENCE
{
		remainingFuel		RemainingFuel,
		personsOnBoard	PersonsOnBoard
}

ReportingPoints ::= SEQUENCE
{
		latLonReportingPoints	[0]	LatLonReportingPoints,
		degreeIncrement				[1]	DegreeIncrement					OPTIONAL
}

RevisionNumber ::= INTEGER (1..16)

RouteAndLevels ::= SEQUENCE
{
		routeOfFlight		RouteInformation,
		levelsOfFlight	LevelsOfFlight
}

RouteClearance ::= SEQUENCE
{
		airportDeparture						[0]	Airport																			OPTIONAL,
		airportDestination					[1]	Airport																			OPTIONAL,	
		runwayDeparture							[2]	Runway																			OPTIONAL,
		procedureDeparture					[3]	ProcedureName																OPTIONAL,
		runwayArrival								[4]	Runway																			OPTIONAL,
		procedureApproach						[5]	ProcedureName																OPTIONAL,
		procedureArrival						[6]	ProcedureName																OPTIONAL,
		routeInformations						[7]	SEQUENCE SIZE (1..128)	OF RouteInformation	OPTIONAL,
		routeInformationAdditional	[8]	RouteInformationAdditional									OPTIONAL
}

RouteClearanceIndex ::= INTEGER (1..2)
-- RouteClearanceIndex identifies the position of the RouteClearance data
-- in the ASN.1 type for
-- ATC UplinkMessage, constrained Data, routeClearance Data
-- ATC DownlinkMessage, constrained Data, routeClearance Data

RouteInformation ::= CHOICE
{
		publishedIdentifier				[0]	PublishedIdentifier,
		latitudeLongitude					[1]	LatitudeLongitude,
		placeBearingPlaceBearing	[2]	PlaceBearingPlaceBearing,
		placeBearingDistance			[3]	PlaceBearingDistance,
		aTSRouteDesignator				[4]	ATSRouteDesignator
}


RouteInformationAdditional ::= SEQUENCE
{
		aTWAlongTrackWaypoints	[0]	SEQUENCE SIZE (1..8) OF ATWAlongTrackWaypoint		OPTIONAL,
		reportingpoints					[1]	ReportingPoints																	OPTIONAL,
		interceptCourseFroms		[2]	SEQUENCE SIZE (1..4) OF InterceptCourseFrom			OPTIONAL,
		holdAtWaypoints					[3]	SEQUENCE SIZE (1..8) OF Holdatwaypoint					OPTIONAL,
		waypointSpeedLevels			[4]	SEQUENCE SIZE (1..32) OF WaypointSpeedLevel			OPTIONAL,
		rTARequiredTimeArrivals	[5]	SEQUENCE SIZE (1..32) OF RTARequiredTimeArrival	OPTIONAL
}

RTARequiredTimeArrival ::= SEQUENCE
{
		position			[0]	Position,
		rTATime				[1]	RTATime,
		rTATolerance	[2]	RTATolerance	OPTIONAL
}

RTATime ::= SEQUENCE
{
		time						Time,
		timeTolerance		TimeTolerance
}

RTATolerance ::= INTEGER (1..150)
--unit= Minute, Range (0.1..15.0), resolution = 0.1

Runway ::= SEQUENCE
{
		direction			RunwayDirection,
		configuration	RunwayConfiguration
}

RunwayDirection ::= INTEGER (1..36)

RunwayConfiguration ::= ENUMERATED
{
		left		(0),
		right		(1),
		center	(2),
		none		(3)
}

RunwayRVR ::= SEQUENCE
{
		runway	Runway,
		rVR			RVR
}

RVR ::= CHOICE
{
		rVRFeet		[0]	RVRFeet,
		rVRMeters	[1]	RVRMeters
}

RVRFeet ::= INTEGER (0..6100)
-- unit = Feet, Range (0..6100), resolution = 1

RVRMeters ::= INTEGER (0..1500)
-- unit = Meters (0..1500), resolution = 1

SecondsLatLon ::= INTEGER (0..59)
--unit = Second, Range (0.. 59), resolution = 1

Speed ::= CHOICE
{
		speedIndicated				[0]	SpeedIndicated,
		speedIndicatedMetric	[1]	SpeedIndicatedMetric,
		speedTrue							[2]	SpeedTrue,
		speedTrueMetric				[3]	SpeedTrueMetric,
		speedGround						[4]	SpeedGround,
		speedGroundMetric			[5]	SpeedGroundMetric,
		speedMach							[6]	SpeedMach
}

SpeedIndicated ::= INTEGER (0..400)
-- unit = Knots, Range (0..400), resolution = 1

SpeedIndicatedMetric ::= INTEGER (0..800)
-- unit = Kilometers/Hour, Range (0..800), resolution = 1

SpeedGround ::= INTEGER (-50..2000)
-- unit = Knots, Range (-50..2000), resolution = 1

SpeedGroundMetric ::= INTEGER (-100..4000)
-- unit = Kilometers/Hour, Range (-100..4000), resolution = 1

SpeedMach ::= INTEGER (500..4000)
-- unit = Mach Range (0.5 to 4.0), resolution = 0.001

SpeedSpeed ::= SEQUENCE SIZE (2) OF Speed
SpeedTime ::= SEQUENCE
{
	speed	Speed,
	time	Time
}

SpeedTrue ::= INTEGER (0..2000)
-- unit = Knots, Range (0..2000), resolution = 1

SpeedTrueMetric ::= INTEGER (0..4000)
-- unit = Kilometers/Hour, Range (0..4000), resolution = 1

SpeedType ::= ENUMERATED
{
		noneSpecified	(0),
		indicated			(1),
		true					(2),
		ground				(3),
		mach					(4),
		approach			(5),
		cruise				(6),
		minimum				(7),
		maximum 			(8),
		...
}

SpeedTypeSpeedTypeSpeedType ::= SEQUENCE SIZE (3) OF SpeedType

SpeedTypeSpeedTypeSpeedTypeSpeed ::= SEQUENCE
{
		speedTypes	SpeedTypeSpeedTypeSpeedType,
		speed				Speed
}

Temperature ::= INTEGER (-100..100)
-- unit = Degree Celsius, Range (-100..100), resolution = 1

Time ::= SEQUENCE
{
		hours		TimeHours,
		minutes	TimeMinutes
}

TimeLevel ::= SEQUENCE
{
		time	Time,
		level	Level
}

TimeDeparture ::= SEQUENCE
{
		timeDepartureAllocated					[0]	Time											OPTIONAL,
		timeDepartureControlled					[1]	ControlledTime						OPTIONAL,
		timeDepartureClearanceExpected	[2]	Time											OPTIONAL,
		departureMinimumInterval				[3]	DepartureMinimumInterval	OPTIONAL
}


TimeDistanceSpecifiedDirection ::= SEQUENCE
{
		time												Time,
		distanceSpecifiedDirection	DistanceSpecifiedDirection
}

TimeDistanceToFromPosition ::= SEQUENCE
{
		time			Time,
	distance	Distance,
	tofrom		ToFrom,
	position	Position
}

Timehhmmss ::= SEQUENCE
{
	hoursminutes	Time,
	seconds				TimeSeconds
}

TimeHours ::= INTEGER (0..23)
-- unit = Hour, Range (0..23), resolution = 1

TimeUnitNameFrequency ::= SEQUENCE
{
		time			Time,
		unitName	UnitName,
		frequency	Frequency
}

TimeMinutes ::= INTEGER (0..59)
-- unit = Minute, Range (0..59), resolution = 1

TimePosition ::= SEQUENCE
{
		time			Time,
		position	Position
}

TimePositionLevel ::= SEQUENCE
{
		timeposition	TimePosition,
		level					Level
}

TimePositionLevelSpeed ::= SEQUENCE
{
		timeposition	TimePosition,
		levelspeed		LevelSpeed
}

TimeSeconds ::= INTEGER (0..59)
-- unit = Second, Range (0..59), resolution = 1

TimeSpeed ::= SEQUENCE
{
		time	Time,
		speed	Speed
}

TimeSpeedSpeed ::= SEQUENCE
{
		time				Time,
		speedspeed	SpeedSpeed
}

TimeTime ::= SEQUENCE SIZE (2) OF Time

TimeToFromPosition ::= SEQUENCE
{
		time			Time,
		tofrom		ToFrom,
		position	Position
}
TimeTolerance ::= ENUMERATED
{
		at				(0),
		atorafter	(1),
		atorbefore(2)
}

ToFrom ::= ENUMERATED
{
		to		(0),
		from	(1)
}

ToFromPosition ::= SEQUENCE
{
		toFrom		ToFrom,
		position	Position
}

TrafficType ::= ENUMERATED
{
		noneSpecified			(0),
		oppositeDirection (1),
		sameDirection			(2),
		converging				(3),
		crossing					(4),
		diverging					(5),
		...
}

Turbulence ::= ENUMERATED
{
		light			(0),
		moderate	(1),
		severe		(2)
}

UnitName ::= SEQUENCE
{
		facilityDesignation	[0]	FacilityDesignation,
		facilityName				[1]	FacilityName					OPTIONAL,
		facilityFunction		[2]	FacilityFunction
}

UnitNameFrequency ::= SEQUENCE
{
		unitName	UnitName,
		frequency	Frequency
}

VersionNumber ::= INTEGER (0..15)

VerticalChange ::= SEQUENCE
{
		direction	VerticalDirection,
		rate			VerticalRate
}

VerticalDirection ::= ENUMERATED
{
		up		(0),	
		down	(1)
}

VerticalRate ::= CHOICE
{
		verticalRateEnglish	[0]	VerticalRateEnglish,
		verticalRateMetric	[1]	VerticalRateMetric
}

VerticalRateEnglish ::= INTEGER (0..3000)
-- unit = Feet/Minute, Range (0..30000), resolution = 10

VerticalRateMetric ::= INTEGER (0..1000)
-- unit = Meters/Minute, Range (0..10000), resolution = 10

WaypointSpeedLevel ::= SEQUENCE
{
		position	[0]	Position,
		speed			[1]	Speed							OPTIONAL,
		aTWLevels	[2]	ATWLevelSequence	OPTIONAL
}

WindDirection ::= INTEGER (1..360)
-- unit = Degree, Range (1..360), resolution = 1

Winds ::= SEQUENCE
{
		direction	WindDirection,
		speed			WindSpeed
}

WindSpeed ::= CHOICE
{
		windSpeedEnglish	[0]	WindSpeedEnglish,
		windSpeedMetric		[1]	WindSpeedMetric
}

WindSpeedEnglish ::= INTEGER (0..255)
-- unit = Knot, Range (0..255), resolution = 1

WindSpeedMetric ::= INTEGER (0..511)
-- unit = Kilometer/Hour, Range (0..511), resolution = 1

Year ::= INTEGER (1996..2095)
-- unit = Year, Range (1996..2095), resolution = 1

END


--
-- Editor modelines  -  http://www.wireshark.org/tools/modelines.html
--
-- Local variables:
-- c-basic-offset: 2
-- tab-width: 2
-- indent-tabs-mode: t
-- End:
--
-- vi: set shiftwidth=2 tabstop=2 noexpandtab:
-- :indentSize=2:tabSize=2:noTabs=false:
--