/*******************************************************************************
* Copyright Ericsson Telecom AB
*
* XSD to TTCN-3 Translator
*
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*******************************************************************************/
//
//  File:          NoTargetNamespace_RLP_e.ttcn
//  Description:
//  References:
//  Rev:
//  Prodnr:
//  Updated:
//  Contact:       http://ttcn.ericsson.se
//
////////////////////////////////////////////////////////////////////////////////
//
//	Generated from file(s):
//
//	- RLP_SVC.xsd
//			/* xml version = "1.0" */
//			/* targetnamespace = "NoTargetNamespace" */
//
////////////////////////////////////////////////////////////////////////////////


module NoTargetNamespace_RLP_e {


import from XSD all;


type record Box
{
	XSD.ID gid optional,
	XSD.AnySimpleType srsName optional,
	Coord coord,
	Coord coord_1
}
with {
  variant "element";
  variant (gid) "attribute";
  variant (srsName) "attribute";
  variant (coord_1) "name as 'coord'";
};


type record CircularArcArea
{
	XSD.ID gid optional,
	XSD.AnySimpleType srsName optional,
	Coord coord,
	InRadius inRadius,
	OutRadius outRadius,
	StartAngle startAngle,
	StopAngle stopAngle,
	AngularUnit angularUnit optional,
	DistanceUnit distanceUnit optional
}
with {
  variant "element";
  variant (gid) "attribute";
  variant (srsName) "attribute";
};


type record CircularArea
{
	XSD.ID gid optional,
	XSD.AnySimpleType srsName optional,
	Coord coord,
	Radius radius,
	DistanceUnit distanceUnit optional
}
with {
  variant "element";
  variant (gid) "attribute";
  variant (srsName) "attribute";
};


type record CoordinateReferenceSystem
{
	Identifier identifier
}
with {
  variant "element";
  variant (identifier) "name as capitalized";
};


type record EllipticalArea
{
	XSD.ID gid optional,
	XSD.AnySimpleType srsName optional,
	Coord coord,
	Angle angle,
	SemiMajor semiMajor,
	SemiMinor semiMinor,
	AngularUnit angularUnit optional,
	DistanceUnit distanceUnit optional
}
with {
  variant "element";
  variant (gid) "attribute";
  variant (srsName) "attribute";
};


type record Identifier
{
	Code code,
	CodeSpace codeSpace,
	Edition edition
}
with {
  variant "element";
};


type record LineString
{
	XSD.ID gid optional,
	XSD.AnySimpleType srsName optional,
	Coord coord,
	record length(1 .. infinity) of Coord coord_list
}
with {
  variant "element";
  variant (gid) "attribute";
  variant (srsName) "attribute";
  variant (coord_list) "untagged";
};


type record LinearRing
{
	XSD.ID gid optional,
	XSD.AnySimpleType srsName optional,
	Coord coord,
	Coord coord_1,
	Coord coord_2,
	record of Coord coord_list
}
with {
  variant "element";
  variant (gid) "attribute";
  variant (srsName) "attribute";
  variant (coord_1) "name as 'coord'";
  variant (coord_2) "name as 'coord'";
  variant (coord_list) "untagged";
};


type record MultiLineString
{
	XSD.ID gid optional,
	XSD.AnySimpleType srsName optional,
	record length(1 .. infinity) of LineString lineString_list
}
with {
  variant "element";
  variant (gid) "attribute";
  variant (srsName) "attribute";
  variant (lineString_list) "untagged";
};


type record MultiPoint
{
	XSD.ID gid optional,
	XSD.AnySimpleType srsName optional,
	record length(1 .. infinity) of Point point_list
}
with {
  variant "element";
  variant (gid) "attribute";
  variant (srsName) "attribute";
  variant (point_list) "untagged";
};


type record MultiPolygon
{
	XSD.ID gid optional,
	XSD.AnySimpleType srsName optional,
	record length(1 .. infinity) of union {
		Polygon polygon,
		Box box,
		CircularArea circularArea,
		CircularArcArea circularArcArea,
		EllipticalArea ellipticalArea
	} choice_list
}
with {
  variant "element";
  variant (gid) "attribute";
  variant (srsName) "attribute";
  variant (choice_list) "untagged";
  variant (choice_list[-]) "untagged";
  variant (choice_list[-].polygon) "name as capitalized";
  variant (choice_list[-].box) "name as capitalized";
  variant (choice_list[-].circularArea) "name as capitalized";
  variant (choice_list[-].circularArcArea) "name as capitalized";
  variant (choice_list[-].ellipticalArea) "name as capitalized";
};


type record Point
{
	XSD.ID gid optional,
	XSD.AnySimpleType srsName optional,
	Coord coord
}
with {
  variant "element";
  variant (gid) "attribute";
  variant (srsName) "attribute";
};


type record Polygon
{
	XSD.ID gid optional,
	XSD.AnySimpleType srsName optional,
	OuterBoundaryIs outerBoundaryIs,
	record of InnerBoundaryIs innerBoundaryIs_list
}
with {
  variant "element";
  variant (gid) "attribute";
  variant (srsName) "attribute";
  variant (innerBoundaryIs_list) "untagged";
};


type record X
{
	record of XSD.String embed_values
}
with {
  variant "embedValues";
  variant "element";
};


type record Y
{
	record of XSD.String embed_values
}
with {
  variant "embedValues";
  variant "element";
};


type record Z
{
	record of XSD.String embed_values
}
with {
  variant "embedValues";
  variant "element";
};


type record Add_info
{
	record of XSD.String embed_values
}
with {
  variant "name as uncapitalized";
  variant "embedValues";
  variant "element";
};


type record Alt
{
	record of XSD.String embed_values
}
with {
  variant "name as uncapitalized";
  variant "embedValues";
  variant "element";
};


type record Alt_acc
{
	record of XSD.String embed_values,
	enumerated {
		aSSURED,
		bEST_EFFORT
	} qos_class optional
}
with {
  variant "name as uncapitalized";
  variant "embedValues";
  variant "element";
  variant (qos_class) "text 'aSSURED' as capitalized";
  variant (qos_class) "text 'bEST_EFFORT' as capitalized";
  variant (qos_class) "attribute";
};


type record Alt_unc
{
	record of XSD.String embed_values
}
with {
  variant "name as uncapitalized";
  variant "embedValues";
  variant "element";
};


type record Angle
{
	record of XSD.String embed_values
}
with {
  variant "name as uncapitalized";
  variant "embedValues";
  variant "element";
};


type record AngularUnit
{
	record of XSD.String embed_values
}
with {
  variant "name as uncapitalized";
  variant "embedValues";
  variant "element";
};


type record Arfcn
{
	record of XSD.String embed_values
}
with {
  variant "name as uncapitalized";
  variant "embedValues";
  variant "element";
};


type record Base_id
{
	record of XSD.String embed_values
}
with {
  variant "name as uncapitalized";
  variant "embedValues";
  variant "element";
};


type record Base_lat
{
	record of XSD.String embed_values
}
with {
  variant "name as uncapitalized";
  variant "embedValues";
  variant "element";
};


type record Base_long
{
	record of XSD.String embed_values
}
with {
  variant "name as uncapitalized";
  variant "embedValues";
  variant "element";
};


type record Bsic
{
	record of XSD.String embed_values
}
with {
  variant "name as uncapitalized";
  variant "embedValues";
  variant "element";
};


type record Cc
{
	record of XSD.String embed_values
}
with {
  variant "name as uncapitalized";
  variant "embedValues";
  variant "element";
};


type record Cdma_net_param
{
	Nid nid,
	Sid sid,
	Base_id base_id,
	Base_lat base_lat optional,
	Base_long base_long optional,
	Ref_pn ref_pn optional
}
with {
  variant "name as uncapitalized";
  variant "element";
};


type record Cellid
{
	record of XSD.String embed_values
}
with {
  variant "name as uncapitalized";
  variant "embedValues";
  variant "element";
};


type record Cgi
{
	Mcc mcc,
	Mnc mnc,
	Lac lac,
	Cellid cellid
}
with {
  variant "name as uncapitalized";
  variant "element";
};


type record Change_area
{
	enumerated {
		tRUE,
		fALSE
	} loc_estimates,
	enumerated {
		mS_ENTERING,
		mS_LEAVING,
		mS_WITHIN_AREA
	} type_,
	Target_area target_area,
	No_of_reports no_of_reports optional
}
with {
  variant "name as uncapitalized";
  variant "element";
  variant (loc_estimates) "text 'fALSE' as capitalized";
  variant (loc_estimates) "text 'tRUE' as capitalized";
  variant (loc_estimates) "attribute";
  variant (type_) "text 'mS_ENTERING' as capitalized";
  variant (type_) "text 'mS_LEAVING' as capitalized";
  variant (type_) "text 'mS_WITHIN_AREA' as capitalized";
  variant (type_) "name as 'type'";
  variant (type_) "attribute";
};


type record Client
{
	enumerated {
		x1,
		x2,
		x3
	} type_ optional,
	Servicetype servicetype,
	Id id optional,
	Serviceid serviceid optional,
	Requestmode requestmode optional,
	Clientname clientname optional,
	Pseudoid pseudoid optional,
	Poi poi optional
}
with {
  variant "name as uncapitalized";
  variant "element";
  variant (type_) "text 'x1' as '1'";
  variant (type_) "text 'x2' as '2'";
  variant (type_) "text 'x3' as '3'";
  variant (type_) "name as 'type'";
  variant (type_) "defaultForEmpty as '1'";
  variant (type_) "attribute";
};


type record Clientname
{
	record of XSD.String embed_values
}
with {
  variant "name as uncapitalized";
  variant "embedValues";
  variant "element";
};


type record Code
{
	record of XSD.String embed_values
}
with {
  variant "name as uncapitalized";
  variant "embedValues";
  variant "element";
};


type record CodeSpace
{
	record of XSD.String embed_values
}
with {
  variant "name as uncapitalized";
  variant "embedValues";
  variant "element";
};


type record Codeword
{
	record of XSD.String embed_values
}
with {
  variant "name as uncapitalized";
  variant "embedValues";
  variant "element";
};


type record Coord
{
	X x,
	Y y optional,
	Z z optional
}
with {
  variant "name as uncapitalized";
  variant "element";
  variant (x) "name as capitalized";
  variant (y) "name as capitalized";
  variant (z) "name as capitalized";
};


type record Direction
{
	record of XSD.String embed_values
}
with {
  variant "name as uncapitalized";
  variant "embedValues";
  variant "element";
};


type record DistanceUnit
{
	record of XSD.String embed_values
}
with {
  variant "name as uncapitalized";
  variant "embedValues";
  variant "element";
};


type record Duration
{
	record of XSD.String embed_values
}
with {
  variant "name as uncapitalized";
  variant "embedValues";
  variant "element";
};


type record Edition
{
	record of XSD.String embed_values
}
with {
  variant "name as uncapitalized";
  variant "embedValues";
  variant "element";
};


type record Eme_event
{
	enumerated {
		eME_ORG,
		eME_REL
	} eme_trigger,
	record length(1 .. infinity) of Eme_pos eme_pos_list
}
with {
  variant "name as uncapitalized";
  variant "element";
  variant (eme_trigger) "text 'eME_ORG' as capitalized";
  variant (eme_trigger) "text 'eME_REL' as capitalized";
  variant (eme_trigger) "attribute";
  variant (eme_pos_list) "untagged";
};


type record Eme_pos
{
	enumerated {
		cELL,
		oTDOA,
		gPS,
		a_GPS,
		e_OTD,
		u_TDOA,
		oTHER
	} pos_method optional,
	Msid msid,
	union {
		Pd pd,
		Poserr poserr
	} choice,
	Esrd esrd optional,
	Esrk esrk optional
}
with {
  variant "name as uncapitalized";
  variant "element";
  variant (pos_method) "text 'a_GPS' as 'A-GPS'";
  variant (pos_method) "text 'cELL' as capitalized";
  variant (pos_method) "text 'e_OTD' as 'E-OTD'";
  variant (pos_method) "text 'gPS' as capitalized";
  variant (pos_method) "text 'oTDOA' as capitalized";
  variant (pos_method) "text 'oTHER' as capitalized";
  variant (pos_method) "text 'u_TDOA' as 'U-TDOA'";
  variant (pos_method) "attribute";
  variant (choice) "untagged";
};


type record Eqop
{
	Resp_req resp_req optional,
	Resp_timer resp_timer optional,
	union {
		Ll_acc ll_acc,
		Hor_acc hor_acc
	} choice optional,
	Alt_acc alt_acc optional,
	Max_loc_age max_loc_age optional
}
with {
  variant "name as uncapitalized";
  variant "element";
  variant (choice) "untagged";
};


type record Esrd
{
	record of XSD.String embed_values,
	enumerated {
		nA
	} type_ optional
}
with {
  variant "name as uncapitalized";
  variant "embedValues";
  variant "element";
  variant (type_) "text 'nA' as capitalized";
  variant (type_) "name as 'type'";
  variant (type_) "defaultForEmpty as 'NA'";
  variant (type_) "attribute";
};


type record Esrk
{
	record of XSD.String embed_values,
	enumerated {
		nA
	} type_ optional
}
with {
  variant "name as uncapitalized";
  variant "embedValues";
  variant "element";
  variant (type_) "text 'nA' as capitalized";
  variant (type_) "name as 'type'";
  variant (type_) "defaultForEmpty as 'NA'";
  variant (type_) "attribute";
};


type record Frequencyinfo
{
	Uarfcn_ul uarfcn_ul optional,
	Uarfcn_dl uarfcn_dl optional,
	Uarfcn_nt uarfcn_nt optional
}
with {
  variant "name as uncapitalized";
  variant "element";
};


type record Geo_info
{
	CoordinateReferenceSystem coordinateReferenceSystem
}
with {
  variant "name as uncapitalized";
  variant "element";
  variant (coordinateReferenceSystem) "name as capitalized";
};


type record Global_uc_id
{
	Mcc mcc,
	Mnc mnc,
	Uc_id uc_id
}
with {
  variant "name as uncapitalized";
  variant "element";
};


type record Gsm_net_param
{
	Cgi cgi optional,
	Nmr nmr optional,
	Ta ta optional,
	Lmsi lmsi optional
}
with {
  variant "name as uncapitalized";
  variant "element";
};


type record H_ls
{
	record of XSD.String embed_values
}
with {
  variant "name as uncapitalized";
  variant "embedValues";
  variant "element";
};


type record Hor_acc
{
	record of XSD.String embed_values,
	enumerated {
		aSSURED,
		bEST_EFFORT
	} qos_class optional
}
with {
  variant "name as uncapitalized";
  variant "embedValues";
  variant "element";
  variant (qos_class) "text 'aSSURED' as capitalized";
  variant (qos_class) "text 'bEST_EFFORT' as capitalized";
  variant (qos_class) "attribute";
};


type record Id
{
	record of XSD.String embed_values
}
with {
  variant "name as uncapitalized";
  variant "embedValues";
  variant "element";
};


type record Imsi
{
	record of XSD.String embed_values
}
with {
  variant "name as uncapitalized";
  variant "embedValues";
  variant "element";
};


type record InRadius
{
	record of XSD.String embed_values
}
with {
  variant "name as uncapitalized";
  variant "embedValues";
  variant "element";
};


type record InnerBoundaryIs
{
	LinearRing linearRing
}
with {
  variant "name as uncapitalized";
  variant "element";
  variant (linearRing) "name as capitalized";
};


type record Interval
{
	record of XSD.String embed_values
}
with {
  variant "name as uncapitalized";
  variant "embedValues";
  variant "element";
};


type record Lac
{
	record of XSD.String embed_values
}
with {
  variant "name as uncapitalized";
  variant "embedValues";
  variant "element";
};


type record Lcs_ref
{
	record of XSD.String embed_values
}
with {
  variant "name as uncapitalized";
  variant "embedValues";
  variant "element";
};


type record Lev_conf
{
	record of XSD.String embed_values
}
with {
  variant "name as uncapitalized";
  variant "embedValues";
  variant "element";
};


type record Ll_acc
{
	record of XSD.String embed_values,
	enumerated {
		aSSURED,
		bEST_EFFORT
	} qos_class optional
}
with {
  variant "name as uncapitalized";
  variant "embedValues";
  variant "element";
  variant (qos_class) "text 'aSSURED' as capitalized";
  variant (qos_class) "text 'bEST_EFFORT' as capitalized";
  variant (qos_class) "attribute";
};


type record Lmsi
{
	record of XSD.String embed_values
}
with {
  variant "name as uncapitalized";
  variant "embedValues";
  variant "element";
};


type record Loc_type
{
	enumerated {
		cURRENT,
		lAST,
		cURRENT_OR_LAST,
		cURRENT_OR_LAST_AS_FALLBACK,
		iNITIAL
	} type_ optional
}
with {
  variant "name as uncapitalized";
  variant "element";
  variant (type_) "text 'cURRENT' as capitalized";
  variant (type_) "text 'cURRENT_OR_LAST' as capitalized";
  variant (type_) "text 'cURRENT_OR_LAST_AS_FALLBACK' as capitalized";
  variant (type_) "text 'iNITIAL' as capitalized";
  variant (type_) "text 'lAST' as capitalized";
  variant (type_) "name as 'type'";
  variant (type_) "defaultForEmpty as 'CURRENT'";
  variant (type_) "attribute";
};


type record Locationserver
{
	Id id,
	Pwd pwd optional
}
with {
  variant "name as uncapitalized";
  variant "element";
};


type record Max_loc_age
{
	record of XSD.String embed_values
}
with {
  variant "name as uncapitalized";
  variant "embedValues";
  variant "element";
};


type record Mcc
{
	record of XSD.String embed_values
}
with {
  variant "name as uncapitalized";
  variant "embedValues";
  variant "element";
};


type record Mnc
{
	record of XSD.String embed_values
}
with {
  variant "name as uncapitalized";
  variant "embedValues";
  variant "element";
};


type record Ms_action
{
	enumerated {
		mS_AVAIL
	} type_
}
with {
  variant "name as uncapitalized";
  variant "element";
  variant (type_) "text 'mS_AVAIL' as capitalized";
  variant (type_) "name as 'type'";
  variant (type_) "attribute";
};


type record Msid
{
	record of XSD.String embed_values,
	enumerated {
		aSC,
		cRP
	} enc optional,
	enumerated {
		mSISDN,
		iMSI,
		iMEI,
		mIN,
		mDN,
		eME_MSID,
		aSID,
		oPE_ID,
		iPV4,
		iPV6,
		sESSID,
		sIP_URI,
		tEL_URL
	} type_ optional
}
with {
  variant "name as uncapitalized";
  variant "embedValues";
  variant "element";
  variant (enc) "text 'aSC' as capitalized";
  variant (enc) "text 'cRP' as capitalized";
  variant (enc) "defaultForEmpty as 'ASC'";
  variant (enc) "attribute";
  variant (type_) "text 'aSID' as capitalized";
  variant (type_) "text 'eME_MSID' as capitalized";
  variant (type_) "text 'iMEI' as capitalized";
  variant (type_) "text 'iMSI' as capitalized";
  variant (type_) "text 'iPV4' as capitalized";
  variant (type_) "text 'iPV6' as capitalized";
  variant (type_) "text 'mDN' as capitalized";
  variant (type_) "text 'mIN' as capitalized";
  variant (type_) "text 'mSISDN' as capitalized";
  variant (type_) "text 'oPE_ID' as capitalized";
  variant (type_) "text 'sESSID' as capitalized";
  variant (type_) "text 'sIP_URI' as capitalized";
  variant (type_) "text 'tEL_URL' as capitalized";
  variant (type_) "name as 'type'";
  variant (type_) "defaultForEmpty as 'MSISDN'";
  variant (type_) "attribute";
};


type record Msid_range
{
	Start_msid start_msid,
	Stop_msid stop_msid
}
with {
  variant "name as uncapitalized";
  variant "element";
};


type record Msids
{
	record length(1 .. infinity) of union {
		record {
			Msid msid,
			Codeword codeword optional,
			Session session optional,
			Trans_id trans_id optional
		} sequence,
		record {
			Msid_range msid_range,
			record of Codeword codeword_list
		} sequence_1
	} choice_list
}
with {
  variant "name as uncapitalized";
  variant "element";
  variant (choice_list) "untagged";
  variant (choice_list[-]) "untagged";
  variant (choice_list[-].sequence) "untagged";
  variant (choice_list[-].sequence_1) "untagged";
  variant (choice_list[-].sequence_1.codeword_list) "untagged";
};


type record Name_area
{
	record of XSD.String embed_values
}
with {
  variant "name as uncapitalized";
  variant "embedValues";
  variant "element";
};


type record Ndc
{
	record of XSD.String embed_values
}
with {
  variant "name as uncapitalized";
  variant "embedValues";
  variant "element";
};


type record Neid
{
	Vmscid vmscid optional,
	Sgsnid sgsnid optional,
	Vlrid vlrid optional
}
with {
  variant "name as uncapitalized";
  variant "element";
};


type record Net_param
{
	H_ls h_ls optional,
	V_ls v_ls optional,
	Pce pce optional,
	Neid neid optional,
	Imsi imsi optional,
	union {
		Gsm_net_param gsm_net_param,
		Wcdma_net_param wcdma_net_param,
		Cdma_net_param cdma_net_param
	} choice optional
}
with {
  variant "name as uncapitalized";
  variant "element";
  variant (choice) "untagged";
};


type record Nid
{
	record of XSD.String embed_values
}
with {
  variant "name as uncapitalized";
  variant "embedValues";
  variant "element";
};


type record Nmr
{
	record length(1 .. infinity) of Nmr_element nmr_element_list
}
with {
  variant "name as uncapitalized";
  variant "element";
  variant (nmr_element_list) "untagged";
};


type record Nmr_element
{
	Arfcn arfcn,
	Bsic bsic,
	Rxlev rxlev
}
with {
  variant "name as uncapitalized";
  variant "element";
};


type record No_of_reports
{
	record of XSD.String embed_values
}
with {
  variant "name as uncapitalized";
  variant "embedValues";
  variant "element";
};


type record OutRadius
{
	record of XSD.String embed_values
}
with {
  variant "name as uncapitalized";
  variant "embedValues";
  variant "element";
};


type record OuterBoundaryIs
{
	LinearRing linearRing
}
with {
  variant "name as uncapitalized";
  variant "element";
  variant (linearRing) "name as capitalized";
};


type record Pce
{
	record of XSD.String embed_values
}
with {
  variant "name as uncapitalized";
  variant "embedValues";
  variant "element";
};


type record Pd
{
	XSD.Time time,
	Shape shape,
	record {
		Alt alt_,
		Alt_unc alt_unc optional
	} sequence optional,
	Speed speed optional,
	Direction direction optional,
	Lev_conf lev_conf optional,
	Qop_not_met qop_not_met optional
}
with {
  variant "name as uncapitalized";
  variant "element";
  variant (sequence) "untagged";
  variant (sequence.alt_) "name as 'alt'";
};


type record Plmn
{
	Mcc mcc,
	Mnc mnc
}
with {
  variant "name as uncapitalized";
  variant "element";
};


type record Poi
{
	enumerated {
		oN,
		oFF
	} flag optional
}
with {
  variant "name as uncapitalized";
  variant "element";
  variant (flag) "text 'oFF' as capitalized";
  variant (flag) "text 'oN' as capitalized";
  variant (flag) "defaultForEmpty as 'OFF'";
  variant (flag) "attribute";
};


type record Pos
{
	enumerated {
		cELL,
		oTDOA,
		gPS,
		a_GPS,
		e_OTD,
		u_TDOA,
		oTHER
	} pos_method optional,
	Msid msid,
	union {
		Pd pd,
		Poserr poserr
	} choice
}
with {
  variant "name as uncapitalized";
  variant "element";
  variant (pos_method) "text 'a_GPS' as 'A-GPS'";
  variant (pos_method) "text 'cELL' as capitalized";
  variant (pos_method) "text 'e_OTD' as 'E-OTD'";
  variant (pos_method) "text 'gPS' as capitalized";
  variant (pos_method) "text 'oTDOA' as capitalized";
  variant (pos_method) "text 'oTHER' as capitalized";
  variant (pos_method) "text 'u_TDOA' as 'U-TDOA'";
  variant (pos_method) "attribute";
  variant (choice) "untagged";
};


type record Poserr
{
	Result result,
	Add_info add_info optional,
	XSD.Time time
}
with {
  variant "name as uncapitalized";
  variant "element";
};


type record Primaryscramblingcode
{
	record of XSD.String embed_values
}
with {
  variant "name as uncapitalized";
  variant "embedValues";
  variant "element";
};


type record Prio
{
	enumerated {
		nORMAL,
		hIGH
	} type_ optional
}
with {
  variant "name as uncapitalized";
  variant "element";
  variant (type_) "text 'hIGH' as capitalized";
  variant (type_) "text 'nORMAL' as capitalized";
  variant (type_) "name as 'type'";
  variant (type_) "defaultForEmpty as 'NORMAL'";
  variant (type_) "attribute";
};


type record Pseudoid
{
	record of XSD.String embed_values
}
with {
  variant "name as uncapitalized";
  variant "embedValues";
  variant "element";
};


type record Pushaddr
{
	Url url,
	Id id optional,
	Pwd pwd optional
}
with {
  variant "name as uncapitalized";
  variant "element";
};


type record Pwd
{
	record of XSD.String embed_values
}
with {
  variant "name as uncapitalized";
  variant "embedValues";
  variant "element";
};


type record Qop
{
	union {
		Ll_acc ll_acc,
		Hor_acc hor_acc
	} choice optional,
	Alt_acc alt_acc optional
}
with {
  variant "name as uncapitalized";
  variant "element";
  variant (choice) "untagged";
};


type record Qop_not_met
{

}
with {
  variant "name as uncapitalized";
  variant "element";
};


type record Radius
{
	record of XSD.String embed_values
}
with {
  variant "name as uncapitalized";
  variant "embedValues";
  variant "element";
};


type record Ref_pn
{
	record of XSD.String embed_values
}
with {
  variant "name as uncapitalized";
  variant "embedValues";
  variant "element";
};


type record Req_id
{
	record of XSD.String embed_values
}
with {
  variant "name as uncapitalized";
  variant "embedValues";
  variant "element";
};


type record Requestmode
{
	enumerated {
		aCTIVE,
		pASSIVE
	} type_ optional,
	union {
		Requestor requestor,
		Session session
	} choice optional
}
with {
  variant "name as uncapitalized";
  variant "element";
  variant (type_) "text 'aCTIVE' as capitalized";
  variant (type_) "text 'pASSIVE' as capitalized";
  variant (type_) "name as 'type'";
  variant (type_) "defaultForEmpty as 'PASSIVE'";
  variant (type_) "attribute";
  variant (choice) "untagged";
};


type record Requestor
{
	record of XSD.String embed_values,
	enumerated {
		mSISDN,
		nAME,
		eMAIL,
		uRL,
		sIPURL,
		iMS
	} type_ optional
}
with {
  variant "name as uncapitalized";
  variant "embedValues";
  variant "element";
  variant (type_) "text 'eMAIL' as capitalized";
  variant (type_) "text 'iMS' as capitalized";
  variant (type_) "text 'mSISDN' as capitalized";
  variant (type_) "text 'nAME' as capitalized";
  variant (type_) "text 'sIPURL' as capitalized";
  variant (type_) "text 'uRL' as capitalized";
  variant (type_) "name as 'type'";
  variant (type_) "defaultForEmpty as 'MSISDN'";
  variant (type_) "attribute";
};


type record Resp_req
{
	enumerated {
		nO_DELAY,
		lOW_DELAY,
		dELAY_TOL
	} type_ optional
}
with {
  variant "name as uncapitalized";
  variant "element";
  variant (type_) "text 'dELAY_TOL' as capitalized";
  variant (type_) "text 'lOW_DELAY' as capitalized";
  variant (type_) "text 'nO_DELAY' as capitalized";
  variant (type_) "name as 'type'";
  variant (type_) "defaultForEmpty as 'DELAY_TOL'";
  variant (type_) "attribute";
};


type record Resp_timer
{
	record of XSD.String embed_values
}
with {
  variant "name as uncapitalized";
  variant "embedValues";
  variant "element";
};


type record Result
{
	record of XSD.String embed_values,
	XSD.AnySimpleType resid
}
with {
  variant "name as uncapitalized";
  variant "embedValues";
  variant "element";
  variant (resid) "attribute";
};


type record Rlp_hdr
{
	XSD.AnySimpleType ver optional,
	Locationserver locationserver,
	Client client optional,
	Serving_node_action serving_node_action optional,
	Supported_shapes supported_shapes optional,
	Net_param net_param optional
}
with {
  variant "name as uncapitalized";
  variant "element";
  variant (ver) "defaultForEmpty as '1.0.0'";
  variant (ver) "attribute";
};


type record Rlp_svc_init
{
	XSD.AnySimpleType ver optional,
	Rlp_hdr rlp_hdr,
	Srlir srlir
}
with {
  variant "name as uncapitalized";
  variant "element";
  variant (ver) "defaultForEmpty as '1.0.0'";
  variant (ver) "attribute";
};


type record Rxlev
{
	record of XSD.String embed_values
}
with {
  variant "name as uncapitalized";
  variant "embedValues";
  variant "element";
};


type record Sac
{
	record of XSD.String embed_values
}
with {
  variant "name as uncapitalized";
  variant "embedValues";
  variant "element";
};


type record Sai
{
	Mcc mcc,
	Mnc mnc,
	Lac lac,
	Sac sac
}
with {
  variant "name as uncapitalized";
  variant "element";
};


type record SemiMajor
{
	record of XSD.String embed_values
}
with {
  variant "name as uncapitalized";
  variant "embedValues";
  variant "element";
};


type record SemiMinor
{
	record of XSD.String embed_values
}
with {
  variant "name as uncapitalized";
  variant "embedValues";
  variant "element";
};


type record Service_coverage
{
	record length(1 .. infinity) of record {
		Cc cc,
		record of Ndc ndc_list
	} sequence_list
}
with {
  variant "name as uncapitalized";
  variant "element";
  variant (sequence_list) "untagged";
  variant (sequence_list[-]) "untagged";
  variant (sequence_list[-].ndc_list) "untagged";
};


type record Serviceid
{
	record of XSD.String embed_values
}
with {
  variant "name as uncapitalized";
  variant "embedValues";
  variant "element";
};


type record Servicetype
{
	record of XSD.String embed_values
}
with {
  variant "name as uncapitalized";
  variant "embedValues";
  variant "element";
};


type record Serving_node_action
{
	enumerated {
		pOSITION_NOT_ALLOWED,
		pOSITION,
		nOTIFY_AND_POSITION,
		pOSITION_IF_NOT_DISALLOWED,
		pOSITION_IF_ALLOWED
	} active_type optional,
	enumerated {
		pOSITION_NOT_ALLOWED,
		pOSITION,
		nOTIFY_AND_POSITION,
		pOSITION_IF_NOT_DISALLOWED,
		pOSITION_IF_ALLOWED
	} passive_type
}
with {
  variant "name as uncapitalized";
  variant "element";
  variant (active_type) "text 'nOTIFY_AND_POSITION' as capitalized";
  variant (active_type) "text 'pOSITION' as capitalized";
  variant (active_type) "text 'pOSITION_IF_ALLOWED' as capitalized";
  variant (active_type) "text 'pOSITION_IF_NOT_DISALLOWED' as capitalized";
  variant (active_type) "text 'pOSITION_NOT_ALLOWED' as capitalized";
  variant (active_type) "defaultForEmpty as 'POSITION_NOT_ALLOWED'";
  variant (active_type) "attribute";
  variant (passive_type) "text 'nOTIFY_AND_POSITION' as capitalized";
  variant (passive_type) "text 'pOSITION' as capitalized";
  variant (passive_type) "text 'pOSITION_IF_ALLOWED' as capitalized";
  variant (passive_type) "text 'pOSITION_IF_NOT_DISALLOWED' as capitalized";
  variant (passive_type) "text 'pOSITION_NOT_ALLOWED' as capitalized";
  variant (passive_type) "attribute";
};


type record Session
{
	record of XSD.String embed_values,
	enumerated {
		aPN,
		dIAL
	} type_
}
with {
  variant "name as uncapitalized";
  variant "embedValues";
  variant "element";
  variant (type_) "text 'aPN' as capitalized";
  variant (type_) "text 'dIAL' as capitalized";
  variant (type_) "name as 'type'";
  variant (type_) "attribute";
};


type record Sgsnid
{
	enumerated {
		x1,
		x2,
		x3,
		x4
	} capability optional,
	Cc cc optional,
	Ndc ndc optional,
	Sgsnno sgsnno
}
with {
  variant "name as uncapitalized";
  variant "element";
  variant (capability) "text 'x1' as '1'";
  variant (capability) "text 'x2' as '2'";
  variant (capability) "text 'x3' as '3'";
  variant (capability) "text 'x4' as '4'";
  variant (capability) "attribute";
};


type record Sgsnno
{
	record of XSD.String embed_values
}
with {
  variant "name as uncapitalized";
  variant "embedValues";
  variant "element";
};


type record Shape
{
	union {
		Point point,
		LineString lineString,
		Polygon polygon,
		Box box,
		CircularArea circularArea,
		CircularArcArea circularArcArea,
		EllipticalArea ellipticalArea,
		MultiLineString multiLineString,
		MultiPoint multiPoint,
		MultiPolygon multiPolygon,
		LinearRing linearRing
	} choice
}
with {
  variant "name as uncapitalized";
  variant "element";
  variant (choice) "untagged";
  variant (choice.point) "name as capitalized";
  variant (choice.lineString) "name as capitalized";
  variant (choice.polygon) "name as capitalized";
  variant (choice.box) "name as capitalized";
  variant (choice.circularArea) "name as capitalized";
  variant (choice.circularArcArea) "name as capitalized";
  variant (choice.ellipticalArea) "name as capitalized";
  variant (choice.multiLineString) "name as capitalized";
  variant (choice.multiPoint) "name as capitalized";
  variant (choice.multiPolygon) "name as capitalized";
  variant (choice.linearRing) "name as capitalized";
};


type record Sid
{
	record of XSD.String embed_values
}
with {
  variant "name as uncapitalized";
  variant "embedValues";
  variant "element";
};


type record Speed
{
	record of XSD.String embed_values
}
with {
  variant "name as uncapitalized";
  variant "embedValues";
  variant "element";
};


type record Srlir
{
	enumerated {
		hLS,
		vLS
	} recv_role,
	enumerated {
		sYNC,
		aSYNC
	} res_type optional,
	XSD.AnySimpleType ver optional,
	Msid msid,
	Codeword codeword optional,
	Eqop eqop optional,
	Geo_info geo_info optional,
	Loc_type loc_type optional,
	Prio prio optional,
	Pushaddr pushaddr optional,
	Service_coverage service_coverage optional
}
with {
  variant "name as uncapitalized";
  variant "element";
  variant (recv_role) "text 'hLS' as capitalized";
  variant (recv_role) "text 'vLS' as capitalized";
  variant (recv_role) "attribute";
  variant (res_type) "text 'aSYNC' as capitalized";
  variant (res_type) "text 'sYNC' as capitalized";
  variant (res_type) "defaultForEmpty as 'SYNC'";
  variant (res_type) "attribute";
  variant (ver) "defaultForEmpty as '1.0.0'";
  variant (ver) "attribute";
};


type record StartAngle
{
	record of XSD.String embed_values
}
with {
  variant "name as uncapitalized";
  variant "embedValues";
  variant "element";
};


type record Start_msid
{
	Msid msid
}
with {
  variant "name as uncapitalized";
  variant "element";
};


type record Start_time
{
	record of XSD.String embed_values,
	XSD.AnySimpleType utc_off optional
}
with {
  variant "name as uncapitalized";
  variant "embedValues";
  variant "element";
  variant (utc_off) "defaultForEmpty as '0000'";
  variant (utc_off) "attribute";
};


type record StopAngle
{
	record of XSD.String embed_values
}
with {
  variant "name as uncapitalized";
  variant "embedValues";
  variant "element";
};


type record Stop_msid
{
	Msid msid
}
with {
  variant "name as uncapitalized";
  variant "element";
};


type record Stop_time
{
	record of XSD.String embed_values,
	XSD.AnySimpleType utc_off optional
}
with {
  variant "name as uncapitalized";
  variant "embedValues";
  variant "element";
  variant (utc_off) "defaultForEmpty as '0000'";
  variant (utc_off) "attribute";
};


type record Supl_message
{
	record of XSD.String embed_values
}
with {
  variant "name as uncapitalized";
  variant "embedValues";
  variant "element";
};


type record Supl_session_id
{
	record of XSD.String embed_values
}
with {
  variant "name as uncapitalized";
  variant "embedValues";
  variant "element";
};


type record Supported_shapes
{
	enumerated {
		nO,
		yES
	} altitude optional,
	enumerated {
		nO,
		yES
	} box optional,
	enumerated {
		nO,
		yES
	} circularArcArea optional,
	enumerated {
		nO,
		yES
	} circularArea optional,
	enumerated {
		nO,
		yES
	} ellipticalArea optional,
	enumerated {
		nO,
		yES
	} lineString optional,
	enumerated {
		nO,
		yES
	} linearRing optional,
	enumerated {
		nO,
		yES
	} multiLineString optional,
	enumerated {
		nO,
		yES
	} multiPoint optional,
	enumerated {
		nO,
		yES
	} multiPolygon optional,
	enumerated {
		nO,
		yES
	} point optional,
	enumerated {
		nO,
		yES
	} polygon optional
}
with {
  variant "name as uncapitalized";
  variant "element";
  variant (altitude) "text 'nO' as capitalized";
  variant (altitude) "text 'yES' as capitalized";
  variant (altitude) "name as capitalized";
  variant (altitude) "defaultForEmpty as 'NO'";
  variant (altitude) "attribute";
  variant (box) "text 'nO' as capitalized";
  variant (box) "text 'yES' as capitalized";
  variant (box) "name as capitalized";
  variant (box) "defaultForEmpty as 'NO'";
  variant (box) "attribute";
  variant (circularArcArea) "text 'nO' as capitalized";
  variant (circularArcArea) "text 'yES' as capitalized";
  variant (circularArcArea) "name as capitalized";
  variant (circularArcArea) "defaultForEmpty as 'NO'";
  variant (circularArcArea) "attribute";
  variant (circularArea) "text 'nO' as capitalized";
  variant (circularArea) "text 'yES' as capitalized";
  variant (circularArea) "name as capitalized";
  variant (circularArea) "defaultForEmpty as 'NO'";
  variant (circularArea) "attribute";
  variant (ellipticalArea) "text 'nO' as capitalized";
  variant (ellipticalArea) "text 'yES' as capitalized";
  variant (ellipticalArea) "name as capitalized";
  variant (ellipticalArea) "defaultForEmpty as 'NO'";
  variant (ellipticalArea) "attribute";
  variant (lineString) "text 'nO' as capitalized";
  variant (lineString) "text 'yES' as capitalized";
  variant (lineString) "name as capitalized";
  variant (lineString) "defaultForEmpty as 'NO'";
  variant (lineString) "attribute";
  variant (linearRing) "text 'nO' as capitalized";
  variant (linearRing) "text 'yES' as capitalized";
  variant (linearRing) "name as capitalized";
  variant (linearRing) "defaultForEmpty as 'NO'";
  variant (linearRing) "attribute";
  variant (multiLineString) "text 'nO' as capitalized";
  variant (multiLineString) "text 'yES' as capitalized";
  variant (multiLineString) "name as capitalized";
  variant (multiLineString) "defaultForEmpty as 'NO'";
  variant (multiLineString) "attribute";
  variant (multiPoint) "text 'nO' as capitalized";
  variant (multiPoint) "text 'yES' as capitalized";
  variant (multiPoint) "name as capitalized";
  variant (multiPoint) "defaultForEmpty as 'NO'";
  variant (multiPoint) "attribute";
  variant (multiPolygon) "text 'nO' as capitalized";
  variant (multiPolygon) "text 'yES' as capitalized";
  variant (multiPolygon) "name as capitalized";
  variant (multiPolygon) "defaultForEmpty as 'NO'";
  variant (multiPolygon) "attribute";
  variant (point) "text 'nO' as capitalized";
  variant (point) "text 'yES' as capitalized";
  variant (point) "name as capitalized";
  variant (point) "defaultForEmpty as 'NO'";
  variant (point) "attribute";
  variant (polygon) "text 'nO' as capitalized";
  variant (polygon) "text 'yES' as capitalized";
  variant (polygon) "name as capitalized";
  variant (polygon) "defaultForEmpty as 'NO'";
  variant (polygon) "attribute";
};


type record Ta
{
	record of XSD.String embed_values
}
with {
  variant "name as uncapitalized";
  variant "embedValues";
  variant "element";
};


type record Target_area
{
	union {
		record {
			Shape shape,
			Cc cc optional
		} sequence,
		Cc cc,
		record length(1 .. infinity) of Plmn plmn_list
	} choice
}
with {
  variant "name as uncapitalized";
  variant "element";
  variant (choice) "untagged";
  variant (choice.sequence) "untagged";
  variant (choice.plmn_list) "untagged";
};


type record Time
{
	record of XSD.String embed_values,
	XSD.AnySimpleType utc_off optional
}
with {
  variant "name as uncapitalized";
  variant "embedValues";
  variant "element";
  variant (utc_off) "defaultForEmpty as '0000'";
  variant (utc_off) "attribute";
};


type record Time_remaining
{
	record of XSD.String embed_values
}
with {
  variant "name as uncapitalized";
  variant "embedValues";
  variant "element";
};


type record Tlrr_event
{
	union {
		Ms_action ms_action,
		Change_area change_area
	} choice
}
with {
  variant "name as uncapitalized";
  variant "element";
  variant (choice) "untagged";
};


type record Trans_id
{
	record of XSD.String embed_values
}
with {
  variant "name as uncapitalized";
  variant "embedValues";
  variant "element";
};


type record Trl_pos
{
	enumerated {
		cELL,
		oTDOA,
		gPS,
		a_GPS,
		e_OTD,
		u_TDOA,
		oTHER
	} pos_method optional,
	enumerated {
		mS_AVAIL,
		cHANGE_AREA
	} trl_trigger,
	Msid msid,
	union {
		Pd pd,
		Poserr poserr,
		XSD.Time time
	} choice
}
with {
  variant "name as uncapitalized";
  variant "element";
  variant (pos_method) "text 'a_GPS' as 'A-GPS'";
  variant (pos_method) "text 'cELL' as capitalized";
  variant (pos_method) "text 'e_OTD' as 'E-OTD'";
  variant (pos_method) "text 'gPS' as capitalized";
  variant (pos_method) "text 'oTDOA' as capitalized";
  variant (pos_method) "text 'oTHER' as capitalized";
  variant (pos_method) "text 'u_TDOA' as 'U-TDOA'";
  variant (pos_method) "attribute";
  variant (trl_trigger) "text 'cHANGE_AREA' as capitalized";
  variant (trl_trigger) "text 'mS_AVAIL' as capitalized";
  variant (trl_trigger) "attribute";
  variant (choice) "untagged";
};


type record Uarfcn_dl
{
	record of XSD.String embed_values
}
with {
  variant "name as uncapitalized";
  variant "embedValues";
  variant "element";
};


type record Uarfcn_nt
{
	record of XSD.String embed_values
}
with {
  variant "name as uncapitalized";
  variant "embedValues";
  variant "element";
};


type record Uarfcn_ul
{
	record of XSD.String embed_values
}
with {
  variant "name as uncapitalized";
  variant "embedValues";
  variant "element";
};


type record Uc_id
{
	record of XSD.String embed_values,
	enumerated {
		sTALE,
		cURRENT,
		uNKNOWN
	} status optional
}
with {
  variant "name as uncapitalized";
  variant "embedValues";
  variant "element";
  variant (status) "text 'cURRENT' as capitalized";
  variant (status) "text 'sTALE' as capitalized";
  variant (status) "text 'uNKNOWN' as capitalized";
  variant (status) "defaultForEmpty as 'CURRENT'";
  variant (status) "attribute";
};


type record Url
{
	record of XSD.String embed_values
}
with {
  variant "name as uncapitalized";
  variant "embedValues";
  variant "element";
};


type record V_ls
{
	record of XSD.String embed_values
}
with {
  variant "name as uncapitalized";
  variant "embedValues";
  variant "element";
};


type record Vlrid
{
	enumerated {
		x1,
		x2,
		x3,
		x4
	} capability optional,
	Cc cc optional,
	Ndc ndc optional,
	Vlrno vlrno
}
with {
  variant "name as uncapitalized";
  variant "element";
  variant (capability) "text 'x1' as '1'";
  variant (capability) "text 'x2' as '2'";
  variant (capability) "text 'x3' as '3'";
  variant (capability) "text 'x4' as '4'";
  variant (capability) "attribute";
};


type record Vlrno
{
	record of XSD.String embed_values
}
with {
  variant "name as uncapitalized";
  variant "embedValues";
  variant "element";
};


type record Vmscid
{
	enumerated {
		x1,
		x2,
		x3,
		x4
	} capability optional,
	Cc cc optional,
	Ndc ndc optional,
	Vmscno vmscno
}
with {
  variant "name as uncapitalized";
  variant "element";
  variant (capability) "text 'x1' as '1'";
  variant (capability) "text 'x2' as '2'";
  variant (capability) "text 'x3' as '3'";
  variant (capability) "text 'x4' as '4'";
  variant (capability) "attribute";
};


type record Vmscno
{
	record of XSD.String embed_values
}
with {
  variant "name as uncapitalized";
  variant "embedValues";
  variant "element";
};


type record Wcdma_net_param
{
	Global_uc_id global_uc_id optional,
	Frequencyinfo frequencyinfo optional,
	Primaryscramblingcode primaryscramblingcode optional,
	Sai sai optional
}
with {
  variant "name as uncapitalized";
  variant "element";
};


}
with {
  encode "XML";
  variant "controlNamespace 'http://www.w3.org/2001/XMLSchema-instance' prefix 'xsi'";
}