epan/dissectors/pidl/ C99 drsuapi

[wireshark-sm.git] / epan / dissectors / asn1 / ngap / NGAP-IEs.asn

-- 3GPP TS 38.413 V18.3.0 (2024-09)
-- 9.4.5        Information Element Definitions
-- **************************************************************
--
-- Information Element Definitions
--
-- **************************************************************

NGAP-IEs {
itu-t (0) identified-organization (4) etsi (0) mobileDomain (0)
ngran-Access (22) modules (3) ngap (1) version1 (1) ngap-IEs (2) }

DEFINITIONS AUTOMATIC TAGS ::=

BEGIN

IMPORTS

        id-AdditionalDLForwardingUPTNLInformation,
        id-AdditionalULForwardingUPTNLInformation,
        id-AdditionalDLQosFlowPerTNLInformation,
        id-AdditionalDLUPTNLInformationForHOList,
        id-AdditionalNGU-UP-TNLInformation,
        id-AdditionalRedundantDL-NGU-UP-TNLInformation,
        id-AdditionalRedundantDLQosFlowPerTNLInformation,
        id-AdditionalRedundantNGU-UP-TNLInformation,
        id-AdditionalRedundantUL-NGU-UP-TNLInformation,
        id-AdditionalUL-NGU-UP-TNLInformation,
        id-AlternativeQoSParaSetList,
        id-AssistanceInformationQoE-Meas,
        id-AdditionalCancelledlocationReportingReferenceIDList,
        id-BurstArrivalTimeDownlink,
        id-Cause,
        id-CNPacketDelayBudgetDL,
        id-CNPacketDelayBudgetUL,
        id-CNTypeRestrictionsForEquivalent,
        id-CNTypeRestrictionsForServing,
        id-CommonNetworkInstance,
        id-ConfiguredTACIndication,
        id-CN-MT-CommunicationHandling,
        id-CurrentQoSParaSetIndex,
        id-DAPSRequestInfo,
        id-DAPSResponseInfoList,
        id-DataForwardingNotPossible,
        id-DataForwardingResponseERABList,
        id-DirectForwardingPathAvailability,
        id-DL-NGU-UP-TNLInformation,
        id-DownlinkTLContainer,
        id-EndpointIPAddressAndPort,
        id-EnergySavingIndication,
        id-ExtendedMobilityInformation,
        id-ExtendedPacketDelayBudget,
        id-ExtendedRATRestrictionInformation,
        id-ExtendedReportIntervalMDT,
        id-ExtendedSliceSupportList,
        id-ExtendedTAISliceSupportList,
        id-ExtendedUEIdentityIndexValue,
        id-EUTRA-PagingeDRXInformation,
        id-EquivalentSNPNsList,
        id-GlobalCable-ID,
        id-GlobalRANNodeID,
        id-GlobalTNGF-ID,
        id-GlobalTWIF-ID,
        id-GlobalW-AGF-ID,
        id-GUAMIType,
        id-HashedUEIdentityIndexValue,
        id-IncludeBeamMeasurementsIndication,
        id-IntersystemSONInformationRequest,
        id-IntersystemSONInformationReply,
        id-IntersystemResourceStatusUpdate,
        id-IntersystemMobilityFailureforVoiceFallback,
        id-LastEUTRAN-PLMNIdentity,
        id-LastVisitedPSCellList,
        id-LocationReportingAdditionalInfo,
        id-M4ReportAmount,
        id-M5ReportAmount,
        id-M6ReportAmount,
        id-ExcessPacketDelayThresholdConfiguration,
        id-M7ReportAmount,
        id-MaximumIntegrityProtectedDataRate-DL,
        id-MBS-AreaSessionID,
        id-MBS-QoSFlowsToBeSetupList,
        id-MBS-QoSFlowsToBeSetupModList,
        id-MBS-QoSFlowToReleaseList,
        id-MBS-ServiceArea,
        id-MBS-SessionFSAIDList,
        id-MBS-SessionID,
        id-MBS-ActiveSessionInformation-SourcetoTargetList,
        id-MBS-ActiveSessionInformation-TargettoSourceList,
        id-MBS-AssistanceInformation,
        id-MBS-SessionTNLInfo5GC,
        id-MBS-SupportIndicator,
        id-MBSSessionFailedtoSetupList,
        id-MBSSessionFailedtoSetuporModifyList,
        id-MBSSessionSetupResponseList,
        id-MBSSessionSetuporModifyResponseList,
        id-MBSSessionToReleaseList,
        id-MBSSessionSetupRequestList,
        id-MBSSessionSetuporModifyRequestList,
        id-MDTConfiguration,
        id-MicoAllPLMN,
        id-NetworkInstance,
        id-NGAPIESupportInformationRequestList,
        id-NGAPIESupportInformationResponseList,
        id-NID,
        id-NR-CGI,
        id-NRNTNTAIInformation,
        id-NPN-MobilityInformation,
        id-NPN-PagingAssistanceInformation,
        id-NPN-Support,
        id-NR-PagingeDRXInformation,
        id-OldAssociatedQosFlowList-ULendmarkerexpected,
        id-OnboardingSupport,
        id-PagingAssisDataforCEcapabUE,
        id-PagingCauseIndicationForVoiceService,
        id-PDUSessionAggregateMaximumBitRate,
        id-PduSessionExpectedUEActivityBehaviour,
        id-PDUSessionPairID,
        id-PDUSessionResourceFailedToSetupListCxtFail,
        id-PDUSessionResourceReleaseResponseTransfer,
        id-PDUSessionType,
        id-PEIPSassistanceInformation,
        id-PSCellInformation,
        id-PNI-NPNBasedMDT,
        id-PNI-NPN-AreaScopeofMDT,
        id-QMCConfigInfo,
        id-QosFlowAdditionalInfoList,
        id-QosFlowAddOrModifyRequestList,
        id-QosFlowFailedToSetupList,
        id-QosFlowFeedbackList,
        id-QosFlowParametersList,
        id-QosFlowSetupRequestList,
        id-QosFlowToReleaseList,
        id-QosMonitoringRequest,
        id-QosMonitoringReportingFrequency,
        id-SNPN-CellBasedMDT,
        id-SNPN-TAIBasedMDT,
        id-SNPN-BasedMDT,
        id-SuccessfulHandoverReportList,
        id-SupportedUETypeList,
        id-UEContextReferenceAtSource,
        id-RAT-Information,
        id-RedundantCommonNetworkInstance,
        id-RedundantDL-NGU-TNLInformationReused,
        id-RedundantDL-NGU-UP-TNLInformation,
        id-RedundantDLQosFlowPerTNLInformation,
        id-RedundantPDUSessionInformation,
        id-RedundantQosFlowIndicator,
        id-RedundantUL-NGU-UP-TNLInformation,
        id-SCTP-TLAs,
        id-SecondaryRATUsageInformation,
        id-SecurityIndication,
        id-SecurityResult,
        id-SgNB-UE-X2AP-ID,
        id-S-NSSAI,
        id-SONInformationReport,
        id-SourceNodeID,
        id-SourceNodeTNLAddrInfo,
        id-SourceSN-to-TargetSN-QMCInfo,
        id-SourceTNLAddrInfo,
        id-SurvivalTime,
        id-Selected-Target-SNPN-Identity,
        id-TNLAssociationTransportLayerAddressNGRAN,
        id-TAINSAGSupportList,
        id-TargetHomeENB-ID,
        id-TargetRNC-ID,
        id-TimeBasedHandoverInformation,
        id-TraceCollectionEntityURI,
        id-TSCTrafficCharacteristics,
        id-UEHistoryInformationFromTheUE,
        id-UERadioCapabilityForPaging,
        id-UERadioCapabilityForPagingOfNB-IoT,
        id-UL-NGU-UP-TNLInformation,
        id-UL-NGU-UP-TNLModifyList,
        id-ULForwarding,
        id-ULForwardingUP-TNLInformation,
        id-UplinkTLContainer,
        id-UsedRSNInformation,
        id-UserLocationInformationTNGF,
        id-UserLocationInformationTWIF,
        id-UserLocationInformationW-AGF,
        id-UserPlaneErrorIndicator,
        id-EarlyMeasurement,
        id-BeamMeasurementsReportConfiguration,
        id-DLDiscarding,
        id-TAI,
        id-HFCNode-ID-new,
        id-GlobalCable-ID-new,
        id-FiveGProSeLayer2Multipath,
        id-CandidateRelayUEInformationList,
        id-FiveGProSeLayer2UEtoUERelay,
        id-FiveGProSeLayer2UEtoUERemote,
        id-SuccessfulPSCellChangeReportList,
        id-TargetCellCRNTI,
        id-TimeSinceFailure,
        id-ClockQualityReportingControlInfo,
        id-RANfeedbacktype,
        id-QoSFlowTSCList,
        id-TSCTrafficCharacteristicsFeedback,
        id-ANPacketDelayBudgetUL,
        id-MBSCommServiceType,
        id-MobileIAB-MTUserLocationInformation,
        id-PDUsetQoSParameters,
        id-PDUSetbasedHandlingIndicator,
        id-N6JitterInformation,
        id-ECNMarkingorCongestionInformationReportingRequest,
        id-ECNMarkingorCongestionInformationReportingStatus,
        id-MN-only-MDT-collection,
        id-XrDeviceWith2Rx,
        id-MaximumDataBurstVolume,
        id-MBS-NGUFailureIndication,
        id-UserPlaneFailureIndication,
        id-UserPlaneFailureIndicationReport,
        id-QoERVQoEReportingPaths,
        maxnoofAllowedAreas,
        maxnoofAllowedCAGsperPLMN,
        maxnoofAllowedS-NSSAIs,
        maxnoofAoIMinusOne,
        maxnoofBluetoothName,
        maxnoofBPLMNs,
        maxnoofCAGforMDT,
        maxnoofCAGSperCell,
        maxnoofCandidateCells,
        maxnoofCellIDforMDT,
        maxnoofCellIDforQMC,
        maxnoofCellIDforWarning,
        maxnoofCellinAoI,
        maxnoofCellinEAI,
        maxnoofCellsforMBS,
        maxnoofCellsingNB,
        maxnoofCellsinngeNB,
        maxnoofCellsinNGRANNode,
        maxnoofCellinTAI,
        maxnoofCellsinUEHistoryInfo,
        maxnoofCellsUEMovingTrajectory,
        maxnoofDRBs,
        maxnoofEmergencyAreaID,
        maxnoofEAIforRestart,
        maxnoofEPLMNs,
        maxnoofEPLMNsPlusOne,
        maxnoofE-RABs,
        maxnoofErrors,
        maxnoofExtSliceItems,
        maxnoofESNPNs,
        maxnoofForbTACs,
        maxnoofFreqforMDT,
        maxnoofMBSFSAs,
        maxnoofMBSQoSFlows,
        maxnoofMBSServiceAreaInformation,
        maxnoofMBSAreaSessionIDs,
        maxnoofMBSSessions,
        maxnoofMBSSessionsofUE,
        maxnoofMDTPLMNs,
        maxnoofMRBs,
        maxnoofMultiConnectivity,
        maxnoofMultiConnectivityMinusOne,
        maxnoofNeighPCIforMDT,
        maxnoofNGAPIESupportInfo,
        maxnoofNGConnectionsToReset,
        maxNRARFCN,
        maxnoofNRCellBands,
        maxnoofNSAGs,
        maxnoofPagingAreas,
        maxnoofPC5QoSFlows,
        maxnoofPDUSessions,
        maxnoofPLMNs,
        maxnoofPLMNforQMC,
        maxnoofQosFlows,
        maxnoofQosParaSets,
        maxnoofRANNodeinAoI,
        maxnoofRecommendedCells,
        maxnoofRecommendedRANNodes,
        maxnoofAoI,
        maxnoofPSCellsPerPrimaryCellinUEHistoryInfo,
        maxnoofReportedCells,
        maxnoofSensorName,
        maxnoofServedGUAMIs,
        maxnoofSliceItems,
        maxnoofMDTSNPNs,
        maxnoofSNSSAIforQMC,
        maxnoofSuccessfulHOReports,
        maxnoofTACs,
        maxnoofTACsinNTN,
        maxnoofTAforMDT,
        maxnoofTAforQMC,
        maxnoofTAIforInactive,
        maxnoofTAIforMBS,
        maxnoofTAIforPaging,
        maxnoofTAIforRestart,
        maxnoofTAIforWarning,
        maxnoofTAIinAoI,
        maxnoofTargetS-NSSAIs,
        maxnoofTimePeriods,
        maxnoofTNLAssociations,
        maxnoofUEAppLayerMeas,
        maxnoofUEsforPaging,
        maxnoofUETypes,
        maxnoofWLANName,
        maxnoofXnExtTLAs,
        maxnoofXnGTP-TLAs,
        maxnoofXnTLAs,
        maxnoofThresholdsForExcessPacketDelay,
        maxnoofCandidateRelayUEs,
        maxnoofSuccessfulPSCellChangeReports,
        maxnoofCellsTSS,
        maxnoofPeriodicities,
        maxnoofPartiallyAllowedS-NSSAIs,
        maxnoofRSPPQoSFlows


FROM NGAP-Constants

        Criticality,
        ProcedureCode,
        ProtocolIE-ID,
        TriggeringMessage
FROM NGAP-CommonDataTypes

        ProtocolExtensionContainer{},
        ProtocolIE-Container{},
        NGAP-PROTOCOL-EXTENSION,
        ProtocolIE-SingleContainer{},
        NGAP-PROTOCOL-IES
FROM NGAP-Containers;

-- A

AdditionalDLUPTNLInformationForHOList ::= SEQUENCE (SIZE(1..maxnoofMultiConnectivityMinusOne)) OF AdditionalDLUPTNLInformationForHOItem

AdditionalDLUPTNLInformationForHOItem ::= SEQUENCE {
        additionalDL-NGU-UP-TNLInformation                              UPTransportLayerInformation,
        additionalQosFlowSetupResponseList                              QosFlowListWithDataForwarding,
        additionalDLForwardingUPTNLInformation                  UPTransportLayerInformation                                                     OPTIONAL,
        iE-Extensions           ProtocolExtensionContainer { { AdditionalDLUPTNLInformationForHOItem-ExtIEs} }  OPTIONAL,
        ...
}

AdditionalDLUPTNLInformationForHOItem-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        { ID id-AdditionalRedundantDL-NGU-UP-TNLInformation     CRITICALITY ignore      EXTENSION UPTransportLayerInformation           PRESENCE optional               },
        ...
}

AdditionalQosFlowInformation ::= ENUMERATED {
        more-likely,
        ...
}

AerialUEsubscriptionInformation ::= ENUMERATED {
        allowed,
        not-allowed,
        ...
}

A2X-PC5-FlowBitRates ::= SEQUENCE {
        a2X-GuaranteedFlowBitRate               BitRate,
        a2X-MaximumFlowBitRate                  BitRate,
        iE-Extensions           ProtocolExtensionContainer { {A2X-PC5-FlowBitRates-ExtIEs} }    OPTIONAL,
        ...
}

A2X-PC5-FlowBitRates-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

A2X-PC5-QoS-Flow-List ::= SEQUENCE (SIZE(1..maxnoofPC5QoSFlows)) OF A2X-PC5-QoS-Flow-Item

A2X-PC5-QoS-Flow-Item ::= SEQUENCE {
        a2X-PQI                                                         INTEGER (0..255, ...),
        a2X-PC5-FlowBitRates                            A2X-PC5-FlowBitRates                                                    OPTIONAL,
        a2X-Range                                                       ENUMERATED {m50, m80, m180, m200,
                                                                                                        m350, m400, m500, m700,
                                                                                                        m1000, ...}                                                     OPTIONAL,
        iE-Extensions           ProtocolExtensionContainer { {A2X-PC5-QoS-Flow-Item-ExtIEs} }   OPTIONAL,
        ...
}

A2X-PC5-QoS-Flow-Item-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

A2X-PC5-QoS-Parameters ::= SEQUENCE {
        a2X-PC5-QoS-Flow-List                           A2X-PC5-QoS-Flow-List,
        a2X-PC5-LinkAggregateBitRates           BitRate                                                                                 OPTIONAL,
        iE-Extensions           ProtocolExtensionContainer { {A2X-PC5-QoS-Parameters-ExtIEs} }  OPTIONAL,
        ...
}

A2X-PC5-QoS-Parameters-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

AdditionalCancelledlocationReportingReferenceIDList ::= SEQUENCE (SIZE(1.. maxnoofAoIMinusOne)) OF AdditionalCancelledlocationReportingReferenceIDItem

AdditionalCancelledlocationReportingReferenceIDItem ::= SEQUENCE {
        locationReportingReferenceIDToBeCancelled               LocationReportingReferenceID,
        iE-Extensions           ProtocolExtensionContainer { { AdditionalCancelledlocationReportingReferenceIDItem-ExtIEs} }    OPTIONAL,
        ...
}

AdditionalCancelledlocationReportingReferenceIDItem-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

AllocationAndRetentionPriority ::= SEQUENCE {
        priorityLevelARP                                PriorityLevelARP,
        pre-emptionCapability                   Pre-emptionCapability,
        pre-emptionVulnerability                Pre-emptionVulnerability,
        iE-Extensions           ProtocolExtensionContainer { {AllocationAndRetentionPriority-ExtIEs} } OPTIONAL,
        ...
}

AllocationAndRetentionPriority-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

Allowed-CAG-List-per-PLMN ::= SEQUENCE (SIZE(1..maxnoofAllowedCAGsperPLMN)) OF CAG-ID

AllowedNSSAI ::= SEQUENCE (SIZE(1..maxnoofAllowedS-NSSAIs)) OF AllowedNSSAI-Item

AllowedNSSAI-Item ::= SEQUENCE {
        s-NSSAI                         S-NSSAI,
        iE-Extensions           ProtocolExtensionContainer { {AllowedNSSAI-Item-ExtIEs} } OPTIONAL,
        ...
}

AllowedNSSAI-Item-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

Allowed-PNI-NPN-List ::= SEQUENCE (SIZE(1..maxnoofEPLMNsPlusOne)) OF Allowed-PNI-NPN-Item

Allowed-PNI-NPN-Item ::= SEQUENCE {
        pLMNIdentity                            PLMNIdentity,
        pNI-NPN-restricted                      ENUMERATED {restricted, not-restricted, ...},
        allowed-CAG-List-per-PLMN       Allowed-CAG-List-per-PLMN,
        iE-Extensions                   ProtocolExtensionContainer { {Allowed-PNI-NPN-Item-ExtIEs} } OPTIONAL,
        ...
}

Allowed-PNI-NPN-Item-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

AllowedTACs ::= SEQUENCE (SIZE(1..maxnoofAllowedAreas)) OF TAC

AlternativeQoSParaSetIndex ::= INTEGER (1..8, ...)

AlternativeQoSParaSetNotifyIndex ::= INTEGER (0..8, ...)

AlternativeQoSParaSetList ::= SEQUENCE (SIZE(1..maxnoofQosParaSets)) OF AlternativeQoSParaSetItem

AlternativeQoSParaSetItem ::= SEQUENCE {
        alternativeQoSParaSetIndex                      AlternativeQoSParaSetIndex,
        guaranteedFlowBitRateDL                         BitRate                                                                                         OPTIONAL,
        guaranteedFlowBitRateUL                         BitRate                                                                                         OPTIONAL,
        packetDelayBudget                                       PacketDelayBudget                                                                       OPTIONAL,
        packetErrorRate                                         PacketErrorRate                                                                         OPTIONAL,
        iE-Extensions           ProtocolExtensionContainer { {AlternativeQoSParaSetItem-ExtIEs} }       OPTIONAL,
        ...
}

AlternativeQoSParaSetItem-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        { ID id-MaximumDataBurstVolume  CRITICALITY ignore      EXTENSION MaximumDataBurstVolume                PRESENCE optional               },
        ...
}

AssistanceInformationQoE-Meas ::= INTEGER (1..16, ...)

AMFName ::= PrintableString (SIZE(1..150, ...))

AMFNameVisibleString ::= VisibleString (SIZE(1..150, ...))

AMFNameUTF8String ::= UTF8String (SIZE(1..150, ...))

AMFPagingTarget ::= CHOICE {
        globalRANNodeID                 GlobalRANNodeID,
        tAI                                             TAI,
        choice-Extensions               ProtocolIE-SingleContainer { {AMFPagingTarget-ExtIEs} }
}

AMFPagingTarget-ExtIEs NGAP-PROTOCOL-IES ::= {
        ...
}

AMFPointer ::= BIT STRING (SIZE(6))

AMFRegionID ::= BIT STRING (SIZE(8))

AMFSetID ::= BIT STRING (SIZE(10))

AMF-TNLAssociationSetupList ::= SEQUENCE (SIZE(1..maxnoofTNLAssociations)) OF AMF-TNLAssociationSetupItem

AMF-TNLAssociationSetupItem ::= SEQUENCE {
        aMF-TNLAssociationAddress               CPTransportLayerInformation,
        iE-Extensions           ProtocolExtensionContainer { {AMF-TNLAssociationSetupItem-ExtIEs} }     OPTIONAL,
        ...
}

AMF-TNLAssociationSetupItem-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

AMF-TNLAssociationToAddList ::= SEQUENCE (SIZE(1..maxnoofTNLAssociations)) OF AMF-TNLAssociationToAddItem

AMF-TNLAssociationToAddItem ::= SEQUENCE {
        aMF-TNLAssociationAddress               CPTransportLayerInformation,
        tNLAssociationUsage                             TNLAssociationUsage                                                                             OPTIONAL,
        tNLAddressWeightFactor                  TNLAddressWeightFactor,
        iE-Extensions           ProtocolExtensionContainer { {AMF-TNLAssociationToAddItem-ExtIEs} }     OPTIONAL,
        ...
}

AMF-TNLAssociationToAddItem-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

AMF-TNLAssociationToRemoveList ::= SEQUENCE (SIZE(1..maxnoofTNLAssociations)) OF AMF-TNLAssociationToRemoveItem

AMF-TNLAssociationToRemoveItem ::= SEQUENCE {
        aMF-TNLAssociationAddress               CPTransportLayerInformation,
        iE-Extensions           ProtocolExtensionContainer { {AMF-TNLAssociationToRemoveItem-ExtIEs} }  OPTIONAL,
        ...
}

AMF-TNLAssociationToRemoveItem-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        {ID id-TNLAssociationTransportLayerAddressNGRAN CRITICALITY reject      EXTENSION CPTransportLayerInformation   PRESENCE optional},
        ...
}

AMF-TNLAssociationToUpdateList ::= SEQUENCE (SIZE(1..maxnoofTNLAssociations)) OF AMF-TNLAssociationToUpdateItem

AMF-TNLAssociationToUpdateItem ::= SEQUENCE {
        aMF-TNLAssociationAddress               CPTransportLayerInformation,
        tNLAssociationUsage                             TNLAssociationUsage                                                                                     OPTIONAL,
        tNLAddressWeightFactor                  TNLAddressWeightFactor                                                                          OPTIONAL,
        iE-Extensions           ProtocolExtensionContainer { {AMF-TNLAssociationToUpdateItem-ExtIEs} }  OPTIONAL,
        ...
}

AMF-TNLAssociationToUpdateItem-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

AMF-UE-NGAP-ID ::= INTEGER (0..1099511627775)

AreaOfInterest ::= SEQUENCE {
        areaOfInterestTAIList                   AreaOfInterestTAIList                                           OPTIONAL,
        areaOfInterestCellList                  AreaOfInterestCellList                                          OPTIONAL,
        areaOfInterestRANNodeList               AreaOfInterestRANNodeList                                       OPTIONAL,
        iE-Extensions           ProtocolExtensionContainer { {AreaOfInterest-ExtIEs} }  OPTIONAL,
        ...
}

AreaOfInterest-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

AreaOfInterestCellList ::= SEQUENCE (SIZE(1..maxnoofCellinAoI)) OF AreaOfInterestCellItem

AreaOfInterestCellItem ::= SEQUENCE {
        nGRAN-CGI                       NGRAN-CGI,
        iE-Extensions           ProtocolExtensionContainer { {AreaOfInterestCellItem-ExtIEs} }  OPTIONAL,
        ...
}

AreaOfInterestCellItem-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

AreaOfInterestList ::= SEQUENCE (SIZE(1..maxnoofAoI)) OF AreaOfInterestItem

AreaOfInterestItem ::= SEQUENCE {
        areaOfInterest                                          AreaOfInterest,
        locationReportingReferenceID            LocationReportingReferenceID,
        iE-Extensions           ProtocolExtensionContainer { {AreaOfInterestItem-ExtIEs} }      OPTIONAL,
        ...
}

AreaOfInterestItem-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

AreaOfInterestRANNodeList ::= SEQUENCE (SIZE(1..maxnoofRANNodeinAoI)) OF AreaOfInterestRANNodeItem

AreaOfInterestRANNodeItem ::= SEQUENCE {
        globalRANNodeID         GlobalRANNodeID,
        iE-Extensions           ProtocolExtensionContainer { {AreaOfInterestRANNodeItem-ExtIEs} }       OPTIONAL,
        ...
}

AreaOfInterestRANNodeItem-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

AreaOfInterestTAIList ::= SEQUENCE (SIZE(1..maxnoofTAIinAoI)) OF AreaOfInterestTAIItem

AreaOfInterestTAIItem ::= SEQUENCE {
        tAI                                     TAI,
        iE-Extensions           ProtocolExtensionContainer { {AreaOfInterestTAIItem-ExtIEs} }   OPTIONAL,
        ...
}

AreaOfInterestTAIItem-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

AssistanceDataForPaging ::= SEQUENCE {
        assistanceDataForRecommendedCells               AssistanceDataForRecommendedCells                       OPTIONAL,
        pagingAttemptInformation                                PagingAttemptInformation                                        OPTIONAL,
        iE-Extensions           ProtocolExtensionContainer { {AssistanceDataForPaging-ExtIEs} } OPTIONAL,
        ...
}

AssistanceDataForPaging-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        { ID id-NPN-PagingAssistanceInformation         CRITICALITY ignore      EXTENSION NPN-PagingAssistanceInformation                       PRESENCE optional       }|
        { ID id-PagingAssisDataforCEcapabUE                     CRITICALITY ignore      EXTENSION PagingAssisDataforCEcapabUE                           PRESENCE optional       },
        ...
}

AssistanceDataForRecommendedCells ::= SEQUENCE {
        recommendedCellsForPaging               RecommendedCellsForPaging,
        iE-Extensions           ProtocolExtensionContainer { {AssistanceDataForRecommendedCells-ExtIEs} }       OPTIONAL,
        ...
}

AssistanceDataForRecommendedCells-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

AssociatedMBSQosFlowSetupRequestList ::= SEQUENCE (SIZE(1..maxnoofMBSQoSFlows)) OF AssociatedMBSQosFlowSetupRequestItem

AssociatedMBSQosFlowSetupRequestItem ::= SEQUENCE {
        mBS-QosFlowIdentifier                           QosFlowIdentifier,
        associatedUnicastQosFlowIdentifier      QosFlowIdentifier,
        iE-Extensions                                           ProtocolExtensionContainer { { AssociatedMBSQosFlowSetupRequestItem-ExtIEs} }   OPTIONAL,
        ...
}

AssociatedMBSQosFlowSetupRequestItem-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

AssociatedMBSQosFlowSetuporModifyRequestList ::= SEQUENCE (SIZE(1..maxnoofMBSQoSFlows)) OF AssociatedMBSQosFlowSetuporModifyRequestItem

AssociatedMBSQosFlowSetuporModifyRequestItem ::= SEQUENCE {
        mBS-QosFlowIdentifier                           QosFlowIdentifier,
        associatedUnicastQosFlowIdentifier      QosFlowIdentifier,
        iE-Extensions                                           ProtocolExtensionContainer { { AssociatedMBSQosFlowSetuporModifyRequestItem-ExtIEs} }   OPTIONAL,
        ...
}

AssociatedMBSQosFlowSetuporModifyRequestItem-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

AssociatedQosFlowList ::= SEQUENCE (SIZE(1..maxnoofQosFlows)) OF AssociatedQosFlowItem

AssociatedQosFlowItem ::= SEQUENCE {
        qosFlowIdentifier                               QosFlowIdentifier,
        qosFlowMappingIndication                ENUMERATED {ul, dl, ...}                                                        OPTIONAL,
        iE-Extensions           ProtocolExtensionContainer { {AssociatedQosFlowItem-ExtIEs} }   OPTIONAL,
        ...
}

AssociatedQosFlowItem-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        { ID id-CurrentQoSParaSetIndex  CRITICALITY ignore      EXTENSION AlternativeQoSParaSetIndex    PRESENCE optional       },
        ...
}

AssociatedSessionID ::= OCTET STRING

AuthenticatedIndication ::= ENUMERATED {true, ...}

AveragingWindow ::= INTEGER (0..4095, ...)

AreaScopeOfMDT-NR ::= CHOICE {
        cellBased                                       CellBasedMDT-NR,
        tABased                                         TABasedMDT,
        pLMNWide                                        NULL,
        tAIBased                                        TAIBasedMDT,
        choice-Extensions               ProtocolIE-SingleContainer { {AreaScopeOfMDT-NR-ExtIEs} }
}

AreaScopeOfMDT-NR-ExtIEs NGAP-PROTOCOL-IES ::= {
{ ID id-PNI-NPNBasedMDT         CRITICALITY ignore      TYPE PNI-NPNBasedMDT            PRESENCE mandatory }|
{ ID id-SNPN-CellBasedMDT       CRITICALITY ignore      TYPE SNPN-CellBasedMDT          PRESENCE mandatory }|
{ ID id-SNPN-TAIBasedMDT        CRITICALITY ignore      TYPE SNPN-TAIBasedMDT           PRESENCE mandatory }|
{ ID id-SNPN-BasedMDT           CRITICALITY ignore      TYPE SNPN-BasedMDT                      PRESENCE mandatory },
        ...
}

AreaScopeOfMDT-EUTRA ::= CHOICE {
        cellBased                                       CellBasedMDT-EUTRA,
        tABased                                         TABasedMDT,
        pLMNWide                                        NULL,
        tAIBased                                        TAIBasedMDT,
        choice-Extensions               ProtocolIE-SingleContainer { {AreaScopeOfMDT-EUTRA-ExtIEs} }
}

AreaScopeOfMDT-EUTRA-ExtIEs NGAP-PROTOCOL-IES ::= {
        ...
}

AreaScopeOfNeighCellsList ::= SEQUENCE (SIZE(1..maxnoofFreqforMDT)) OF AreaScopeOfNeighCellsItem
AreaScopeOfNeighCellsItem ::= SEQUENCE {
        nrFrequencyInfo                         NRFrequencyInfo,
        pciListForMDT                           PCIListForMDT                                                                                           OPTIONAL,
        iE-Extensions           ProtocolExtensionContainer { { AreaScopeOfNeighCellsItem-ExtIEs} }      OPTIONAL,
        ...
}

AreaScopeOfNeighCellsItem-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

AreaScopeOfQMC ::= CHOICE {
        cellBased                               CellBasedQMC,
        tABased                                 TABasedQMC,
        tAIBased                                        TAIBasedQMC,
        pLMNAreaBased                   PLMNAreaBasedQMC,
        choice-Extensions               ProtocolIE-SingleContainer { { AreaScopeOfQMC-ExtIEs} }
}

AreaScopeOfQMC-ExtIEs NGAP-PROTOCOL-IES ::= {
        ...
}

AvailableRANVisibleQoEMetrics ::= SEQUENCE {
        applicationLayerBufferLevelList         ENUMERATED {true, ...}          OPTIONAL,
        playoutDelayForMediaStartup                     ENUMERATED {true, ...}          OPTIONAL,
        iE-Extensions                           ProtocolExtensionContainer { { AvailableRANVisibleQoEMetrics-ExtIEs} }  OPTIONAL,
        ...
}

AvailableRANVisibleQoEMetrics-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}


-- B

BeamMeasurementsReportConfiguration ::= SEQUENCE {
        beamMeasurementsReportQuantity                  BeamMeasurementsReportQuantity  OPTIONAL,
        maxNrofRS-IndexesToReport               MaxNrofRS-IndexesToReport               OPTIONAL,
        iE-Extensions                                                   ProtocolExtensionContainer { { BeamMeasurementsReportConfiguration-ExtIEs} } OPTIONAL,
        ...
}

BeamMeasurementsReportConfiguration-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

BeamMeasurementsReportQuantity ::= SEQUENCE {
    rSRP                                                ENUMERATED {true, ...},
    rSRQ                                                ENUMERATED {true, ...},
    sINR                                                ENUMERATED {true, ...},
        iE-Extensions                   ProtocolExtensionContainer { { BeamMeasurementsReportQuantity-ExtIEs} } OPTIONAL,
        ...
}

BeamMeasurementsReportQuantity-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

BitRate ::= INTEGER (0..4000000000000, ...)

BroadcastCancelledAreaList ::= CHOICE {
        cellIDCancelledEUTRA                            CellIDCancelledEUTRA,
        tAICancelledEUTRA                                       TAICancelledEUTRA,
        emergencyAreaIDCancelledEUTRA           EmergencyAreaIDCancelledEUTRA,
        cellIDCancelledNR                                       CellIDCancelledNR,
        tAICancelledNR                                          TAICancelledNR,
        emergencyAreaIDCancelledNR                      EmergencyAreaIDCancelledNR,
        choice-Extensions               ProtocolIE-SingleContainer { {BroadcastCancelledAreaList-ExtIEs} }
}

BroadcastCancelledAreaList-ExtIEs NGAP-PROTOCOL-IES ::= {
        ...
}

BroadcastCompletedAreaList ::= CHOICE {
        cellIDBroadcastEUTRA                            CellIDBroadcastEUTRA,
        tAIBroadcastEUTRA                                       TAIBroadcastEUTRA,
        emergencyAreaIDBroadcastEUTRA           EmergencyAreaIDBroadcastEUTRA,
        cellIDBroadcastNR                                       CellIDBroadcastNR,
        tAIBroadcastNR                                          TAIBroadcastNR,
        emergencyAreaIDBroadcastNR                      EmergencyAreaIDBroadcastNR,
        choice-Extensions               ProtocolIE-SingleContainer { {BroadcastCompletedAreaList-ExtIEs} }
}

BroadcastCompletedAreaList-ExtIEs NGAP-PROTOCOL-IES ::= {
        ...
}

BroadcastPLMNList ::= SEQUENCE (SIZE(1..maxnoofBPLMNs)) OF BroadcastPLMNItem

BroadcastPLMNItem ::= SEQUENCE {
        pLMNIdentity                    PLMNIdentity,
        tAISliceSupportList             SliceSupportList,
        iE-Extensions           ProtocolExtensionContainer { {BroadcastPLMNItem-ExtIEs} } OPTIONAL,
        ...
}

BroadcastPLMNItem-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        {ID id-NPN-Support                                      CRITICALITY reject      EXTENSION NPN-Support                           PRESENCE optional}|
        {ID id-ExtendedTAISliceSupportList      CRITICALITY reject      EXTENSION ExtendedSliceSupportList      PRESENCE optional}|
        {ID id-TAINSAGSupportList                       CRITICALITY ignore      EXTENSION TAINSAGSupportList            PRESENCE optional},
        ...
}

BroadcastTransportFailureTransfer ::= SEQUENCE {
        mBS-SessionID                           MBS-SessionID,
        cause                                           Cause,
        criticalityDiagnostics          CriticalityDiagnostics                                                                                                                  OPTIONAL,
        iE-Extensions                           ProtocolExtensionContainer { { BroadcastTransportFailureTransfer-ExtIEs} }      OPTIONAL,
        ...
}

BroadcastTransportFailureTransfer-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

BroadcastTransportRequestTransfer ::= SEQUENCE {
        mBS-SessionID                           MBS-SessionID,
        mBS-SessionTNLInfoNGRAN         MBS-SessionTNLInfoNGRAN,
        iE-Extensions                           ProtocolExtensionContainer { {BroadcastTransportRequestTransfer-ExtIEs} }               OPTIONAL,
        ...
}

BroadcastTransportRequestTransfer-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

BroadcastTransportResponseTransfer ::= SEQUENCE {
        mBS-SessionID                   MBS-SessionID,
        iE-Extensions                   ProtocolExtensionContainer { {BroadcastTransportResponseTransfer-ExtIEs} }              OPTIONAL,
        ...
}

BroadcastTransportResponseTransfer-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

BluetoothMeasurementConfiguration ::= SEQUENCE {
        bluetoothMeasConfig                             BluetoothMeasConfig,
        bluetoothMeasConfigNameList             BluetoothMeasConfigNameList                                                                                     OPTIONAL,
        bt-rssi                                                 ENUMERATED {true, ...}                                                                                          OPTIONAL,
        iE-Extensions           ProtocolExtensionContainer { { BluetoothMeasurementConfiguration-ExtIEs } }     OPTIONAL,
        ...
}

BluetoothMeasurementConfiguration-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

BluetoothMeasConfigNameList ::= SEQUENCE (SIZE(1..maxnoofBluetoothName)) OF BluetoothMeasConfigNameItem

BluetoothMeasConfigNameItem ::= SEQUENCE {
        bluetoothName           BluetoothName,
        iE-Extensions           ProtocolExtensionContainer { { BluetoothMeasConfigNameItem-ExtIEs } }   OPTIONAL,
        ...
}

BluetoothMeasConfigNameItem-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

BluetoothMeasConfig::= ENUMERATED {setup,...}

BluetoothName ::= OCTET STRING (SIZE (1..248))

BurstArrivalTime ::= OCTET STRING

BurstArrivalTimeWindow ::= SEQUENCE {
        burstArrivalTimeWindowStart                             INTEGER (0..640000, ...),
        burstArrivalTimeWindowEnd                               INTEGER (0..640000, ...),
        iE-Extension                    ProtocolExtensionContainer { {BurstArrivalTimeWindow-ExtIEs} } OPTIONAL,
        ...
}

BurstArrivalTimeWindow-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

-- C

CAG-ID ::= BIT STRING (SIZE(32))

CandidateRelayUEInformationList ::= SEQUENCE (SIZE(1.. maxnoofCandidateRelayUEs)) OF CandidateRelayUEInformationItem

CandidateRelayUEInformationItem ::= SEQUENCE {
        candidateRelayUE-Id             CandidateRelayUE-ID,
        iE-Extensions           ProtocolExtensionContainer { { CandidateRelayUEInformationItem-ExtIEs} }        OPTIONAL,
        ...
}

CandidateRelayUEInformationItem-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

CandidateRelayUE-ID ::= BIT STRING (SIZE(24))

CancelAllWarningMessages ::= ENUMERATED {
        true,
        ...
}

CancelledCellsInEAI-EUTRA ::= SEQUENCE (SIZE(1..maxnoofCellinEAI)) OF CancelledCellsInEAI-EUTRA-Item

CancelledCellsInEAI-EUTRA-Item ::= SEQUENCE {
        eUTRA-CGI                               EUTRA-CGI,
        numberOfBroadcasts              NumberOfBroadcasts,
        iE-Extensions           ProtocolExtensionContainer { {CancelledCellsInEAI-EUTRA-Item-ExtIEs} } OPTIONAL,
        ...
}

CancelledCellsInEAI-EUTRA-Item-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

CancelledCellsInEAI-NR ::= SEQUENCE (SIZE(1..maxnoofCellinEAI)) OF CancelledCellsInEAI-NR-Item

CancelledCellsInEAI-NR-Item ::= SEQUENCE {
        nR-CGI                                  NR-CGI,
        numberOfBroadcasts              NumberOfBroadcasts,
        iE-Extensions           ProtocolExtensionContainer { {CancelledCellsInEAI-NR-Item-ExtIEs} } OPTIONAL,
        ...
}

CancelledCellsInEAI-NR-Item-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

CancelledCellsInTAI-EUTRA ::= SEQUENCE (SIZE(1..maxnoofCellinTAI)) OF CancelledCellsInTAI-EUTRA-Item

CancelledCellsInTAI-EUTRA-Item ::= SEQUENCE {
        eUTRA-CGI                               EUTRA-CGI,
        numberOfBroadcasts              NumberOfBroadcasts,
        iE-Extensions           ProtocolExtensionContainer { {CancelledCellsInTAI-EUTRA-Item-ExtIEs} } OPTIONAL,
        ...
}

CancelledCellsInTAI-EUTRA-Item-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

CancelledCellsInTAI-NR ::= SEQUENCE (SIZE(1..maxnoofCellinTAI)) OF CancelledCellsInTAI-NR-Item

CancelledCellsInTAI-NR-Item ::= SEQUENCE{
        nR-CGI                                  NR-CGI,
        numberOfBroadcasts              NumberOfBroadcasts,
        iE-Extensions           ProtocolExtensionContainer { {CancelledCellsInTAI-NR-Item-ExtIEs} } OPTIONAL,
        ...
}

CancelledCellsInTAI-NR-Item-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

CandidateCellList ::= SEQUENCE (SIZE(1.. maxnoofCandidateCells)) OF CandidateCellItem

CandidateCellItem ::= SEQUENCE{
        candidateCell           CandidateCell,
        iE-Extensions           ProtocolExtensionContainer { {CandidateCellItem-ExtIEs} } OPTIONAL,
        ...
}

CandidateCellItem-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

CandidateCell::= CHOICE {
        candidateCGI                    CandidateCellID,
        candidatePCI                    CandidatePCI,
        choice-Extensions               ProtocolIE-SingleContainer { { CandidateCell-ExtIEs} }
}

CandidateCell-ExtIEs NGAP-PROTOCOL-IES ::= {
        ...
}


CandidateCellID::= SEQUENCE {
        candidateCellID                 NR-CGI,
        iE-Extensions                   ProtocolExtensionContainer { { CandidateCellID-ExtIEs} }                        OPTIONAL,
        ...
}

CandidateCellID-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

CandidatePCI::= SEQUENCE {
        candidatePCI                    INTEGER (0..1007, ...),
        candidateNRARFCN                INTEGER (0..maxNRARFCN),
        iE-Extensions                   ProtocolExtensionContainer { { CandidatePCI-ExtIEs} }                   OPTIONAL,
        ...
}

CandidatePCI-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

Cause ::= CHOICE {
        radioNetwork            CauseRadioNetwork,
        transport                       CauseTransport,
        nas                                     CauseNas,
        protocol                        CauseProtocol,
        misc                            CauseMisc,
        choice-Extensions               ProtocolIE-SingleContainer { {Cause-ExtIEs} }
}

Cause-ExtIEs NGAP-PROTOCOL-IES ::= {
        ...
}

CauseMisc ::= ENUMERATED {
        control-processing-overload,
        not-enough-user-plane-processing-resources,
        hardware-failure,
        om-intervention,
        unknown-PLMN-or-SNPN,
        unspecified,
        ...
}

CauseNas ::= ENUMERATED {
        normal-release,
        authentication-failure,
        deregister,
        unspecified,
        ...,
        uE-not-in-PLMN-serving-area,
        mobile-IAB-not-authorized,
        iAB-not-authorized
}

CauseProtocol ::= ENUMERATED {
        transfer-syntax-error,
        abstract-syntax-error-reject,
        abstract-syntax-error-ignore-and-notify,
        message-not-compatible-with-receiver-state,
        semantic-error,
        abstract-syntax-error-falsely-constructed-message,
        unspecified,
        ...
}

CauseRadioNetwork ::= ENUMERATED {
        unspecified,
        txnrelocoverall-expiry,
        successful-handover,
        release-due-to-ngran-generated-reason,
        release-due-to-5gc-generated-reason,
        handover-cancelled,
        partial-handover,
        ho-failure-in-target-5GC-ngran-node-or-target-system,
        ho-target-not-allowed,
        tngrelocoverall-expiry,
        tngrelocprep-expiry,
        cell-not-available,
        unknown-targetID,
        no-radio-resources-available-in-target-cell,
        unknown-local-UE-NGAP-ID,
        inconsistent-remote-UE-NGAP-ID,
        handover-desirable-for-radio-reason,
        time-critical-handover,
        resource-optimisation-handover,
        reduce-load-in-serving-cell,
        user-inactivity,
        radio-connection-with-ue-lost,
        radio-resources-not-available,
        invalid-qos-combination,
        failure-in-radio-interface-procedure,
        interaction-with-other-procedure,
        unknown-PDU-session-ID,
        unkown-qos-flow-ID,
        multiple-PDU-session-ID-instances,
        multiple-qos-flow-ID-instances,
        encryption-and-or-integrity-protection-algorithms-not-supported,
        ng-intra-system-handover-triggered,
        ng-inter-system-handover-triggered,
        xn-handover-triggered,
        not-supported-5QI-value,
        ue-context-transfer,
        ims-voice-eps-fallback-or-rat-fallback-triggered,
        up-integrity-protection-not-possible,
        up-confidentiality-protection-not-possible,
        slice-not-supported,
        ue-in-rrc-inactive-state-not-reachable,
        redirection,
        resources-not-available-for-the-slice,
        ue-max-integrity-protected-data-rate-reason,
        release-due-to-cn-detected-mobility,
        ...,
        n26-interface-not-available,
        release-due-to-pre-emption,
        multiple-location-reporting-reference-ID-instances,
        rsn-not-available-for-the-up,
        npn-access-denied,
        cag-only-access-denied,
        insufficient-ue-capabilities,
        redcap-ue-not-supported,
        unknown-MBS-Session-ID,
        indicated-MBS-session-area-information-not-served-by-the-gNB,
        inconsistent-slice-info-for-the-session,
        misaligned-association-for-multicast-unicast,
        eredcap-ue-not-supported,
        two-rx-xr-ue-not-supported
}

CauseTransport ::= ENUMERATED {
        transport-resource-unavailable,
        unspecified,
        ...
}

Cell-CAGInformation ::= SEQUENCE {
        nGRAN-CGI                               NGRAN-CGI,
        cellCAGList                     CellCAGList,
        iE-Extensions           ProtocolExtensionContainer { {Cell-CAGInformation-ExtIEs} } OPTIONAL,
        ...
}

Cell-CAGInformation-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}


CellCAGList ::= SEQUENCE (SIZE(1..maxnoofCAGSperCell)) OF CAG-ID

CellIDBroadcastEUTRA ::= SEQUENCE (SIZE(1..maxnoofCellIDforWarning)) OF CellIDBroadcastEUTRA-Item

CellIDBroadcastEUTRA-Item ::= SEQUENCE {
        eUTRA-CGI                       EUTRA-CGI,
        iE-Extensions           ProtocolExtensionContainer { {CellIDBroadcastEUTRA-Item-ExtIEs} } OPTIONAL,
        ...
}

CellIDBroadcastEUTRA-Item-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

CellIDBroadcastNR ::= SEQUENCE (SIZE(1..maxnoofCellIDforWarning)) OF CellIDBroadcastNR-Item

CellIDBroadcastNR-Item ::= SEQUENCE {
        nR-CGI                          NR-CGI,
        iE-Extensions           ProtocolExtensionContainer { {CellIDBroadcastNR-Item-ExtIEs} } OPTIONAL,
        ...
}

CellIDBroadcastNR-Item-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

CellIDCancelledEUTRA ::= SEQUENCE (SIZE(1..maxnoofCellIDforWarning)) OF CellIDCancelledEUTRA-Item

CellIDCancelledEUTRA-Item ::= SEQUENCE {
        eUTRA-CGI                               EUTRA-CGI,
        numberOfBroadcasts              NumberOfBroadcasts,
        iE-Extensions           ProtocolExtensionContainer { {CellIDCancelledEUTRA-Item-ExtIEs} } OPTIONAL,
        ...
}

CellIDCancelledEUTRA-Item-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

CellIDCancelledNR ::= SEQUENCE (SIZE(1..maxnoofCellIDforWarning)) OF CellIDCancelledNR-Item

CellIDCancelledNR-Item ::= SEQUENCE {
        nR-CGI                                  NR-CGI,
        numberOfBroadcasts              NumberOfBroadcasts,
        iE-Extensions           ProtocolExtensionContainer { {CellIDCancelledNR-Item-ExtIEs} } OPTIONAL,
        ...
}

CellIDCancelledNR-Item-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

CellIDListForRestart ::= CHOICE {
        eUTRA-CGIListforRestart         EUTRA-CGIList,
        nR-CGIListforRestart            NR-CGIList,
        choice-Extensions               ProtocolIE-SingleContainer { {CellIDListForRestart-ExtIEs} }
}

CellIDListForRestart-ExtIEs NGAP-PROTOCOL-IES ::= {
        ...
}

CellSize ::= ENUMERATED {verysmall, small, medium, large, ...}


CellType ::= SEQUENCE {
        cellSize                CellSize,
        iE-Extensions           ProtocolExtensionContainer { {CellType-ExtIEs} }        OPTIONAL,
        ...
}

CellType-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

CEmodeBSupport-Indicator ::= ENUMERATED {supported,...}


CEmodeBrestricted ::= ENUMERATED {
        restricted,
        not-restricted,
        ...
}

ClockAccuracy ::= CHOICE {
        clockAccuracyValue              INTEGER (1..40000000, ...),
        clockAccuracyIndex              INTEGER (32..47, ...),
        choice-Extensions               ProtocolIE-SingleContainer { { ClockAccuracy-ExtIEs} }
}

ClockAccuracy-ExtIEs NGAP-PROTOCOL-IES ::= {
        ...
}

ClockQualityAcceptanceIndication ::= SEQUENCE {
        clockQualityAcceptanceCriteria          ClockQualityAcceptanceCriteria,
        iE-Extensions                           ProtocolExtensionContainer { {ClockQualityAcceptanceIndication-ExtIEs} } OPTIONAL,
        ...
}

ClockQualityAcceptanceIndication-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

ClockQualityAcceptanceCriteria ::= SEQUENCE {
        synchronisationState                    BIT STRING (SIZE(8, ...))                                       OPTIONAL,
        traceabletoUTC                                  ENUMERATED {true, ...}                                          OPTIONAL,
        traceabletoGNSS                                 ENUMERATED {true, ...}                                          OPTIONAL,
        clockFrequencyStability                 BIT STRING (SIZE(16))                                           OPTIONAL,
        clockAccuracy                                   INTEGER (1..40000000, ...)                                      OPTIONAL,
        parentTImeSource                                BIT STRING (SIZE(16, ...))                                      OPTIONAL,
        iE-Extensions           ProtocolExtensionContainer { { ClockQualityAcceptanceCriteria-ExtIEs} } OPTIONAL,
        ...
}

ClockQualityAcceptanceCriteria-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

ClockQualityReportingControlInfo ::= SEQUENCE {
        clockQualityDetailLevel         ClockQualityDetailLevel,
        iE-Extensions                           ProtocolExtensionContainer { {ClockQualityReportingControlInfo-ExtIEs} } OPTIONAL,
        ...
}

ClockQualityReportingControlInfo-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

ClockQualityDetailLevel ::= CHOICE {
        clockQualityMetrics                                             NULL,
        clockQualityAcceptanceIndication                ClockQualityAcceptanceIndication,
        choice-extensions                       ProtocolIE-SingleContainer { {ClockQualityDetailLevel-ExtIEs} }
}

ClockQualityDetailLevel-ExtIEs NGAP-PROTOCOL-IES ::= {
        ...
}

CNAssistedRANTuning ::= SEQUENCE {
        expectedUEBehaviour                                     ExpectedUEBehaviour                                                     OPTIONAL,
        iE-Extensions           ProtocolExtensionContainer { {CNAssistedRANTuning-ExtIEs} }     OPTIONAL,
        ...
}

CNAssistedRANTuning-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

CNsubgroupID ::= INTEGER (0..7, ...)

CNTypeRestrictionsForEquivalent ::= SEQUENCE (SIZE(1..maxnoofEPLMNs)) OF CNTypeRestrictionsForEquivalentItem

CNTypeRestrictionsForEquivalentItem ::= SEQUENCE {
        plmnIdentity            PLMNIdentity,
        cn-Type                         ENUMERATED {epc-forbidden, fiveGC-forbidden, ...},
        iE-Extensions           ProtocolExtensionContainer { {CNTypeRestrictionsForEquivalentItem-ExtIEs} }             OPTIONAL,
        ...
}

CNTypeRestrictionsForEquivalentItem-ExtIEs NGAP-PROTOCOL-EXTENSION ::={
        ...
}

CNTypeRestrictionsForServing ::= ENUMERATED {
        epc-forbidden,
        ...
}

CommonNetworkInstance ::= OCTET STRING

CompletedCellsInEAI-EUTRA ::= SEQUENCE (SIZE(1..maxnoofCellinEAI)) OF CompletedCellsInEAI-EUTRA-Item

CompletedCellsInEAI-EUTRA-Item ::= SEQUENCE {
        eUTRA-CGI                       EUTRA-CGI,
        iE-Extensions           ProtocolExtensionContainer { {CompletedCellsInEAI-EUTRA-Item-ExtIEs} } OPTIONAL,
        ...
}

CompletedCellsInEAI-EUTRA-Item-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

CompletedCellsInEAI-NR ::= SEQUENCE (SIZE(1..maxnoofCellinEAI)) OF CompletedCellsInEAI-NR-Item

CompletedCellsInEAI-NR-Item ::= SEQUENCE {
        nR-CGI                          NR-CGI,
        iE-Extensions           ProtocolExtensionContainer { {CompletedCellsInEAI-NR-Item-ExtIEs} }     OPTIONAL,
        ...
}

CompletedCellsInEAI-NR-Item-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

CompletedCellsInTAI-EUTRA ::= SEQUENCE (SIZE(1..maxnoofCellinTAI)) OF CompletedCellsInTAI-EUTRA-Item

CompletedCellsInTAI-EUTRA-Item ::= SEQUENCE{
        eUTRA-CGI                       EUTRA-CGI,
        iE-Extensions           ProtocolExtensionContainer { {CompletedCellsInTAI-EUTRA-Item-ExtIEs} } OPTIONAL,
        ...
}

CompletedCellsInTAI-EUTRA-Item-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

CompletedCellsInTAI-NR ::= SEQUENCE (SIZE(1..maxnoofCellinTAI)) OF CompletedCellsInTAI-NR-Item

CompletedCellsInTAI-NR-Item ::= SEQUENCE{
        nR-CGI                          NR-CGI,
        iE-Extensions           ProtocolExtensionContainer { {CompletedCellsInTAI-NR-Item-ExtIEs} } OPTIONAL,
        ...
}

CompletedCellsInTAI-NR-Item-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

ConcurrentWarningMessageInd ::= ENUMERATED {
        true,
        ...
}

ConfidentialityProtectionIndication ::= ENUMERATED {
        required,
        preferred,
        not-needed,
        ...
}

ConfidentialityProtectionResult ::= ENUMERATED {
        performed,
        not-performed,
        ...
}

ConfiguredTACIndication ::= ENUMERATED {
        true,
        ...
}

CoreNetworkAssistanceInformationForInactive ::= SEQUENCE {
        uEIdentityIndexValue                            UEIdentityIndexValue,
        uESpecificDRX                                           PagingDRX                                                                                                                                       OPTIONAL,
        periodicRegistrationUpdateTimer         PeriodicRegistrationUpdateTimer,
        mICOModeIndication                                      MICOModeIndication                                                                                                                      OPTIONAL,
        tAIListForInactive                                      TAIListForInactive,
        expectedUEBehaviour                                     ExpectedUEBehaviour                                                                                                                     OPTIONAL,
        iE-Extensions           ProtocolExtensionContainer { {CoreNetworkAssistanceInformationForInactive-ExtIEs} }     OPTIONAL,
        ...
}

CoreNetworkAssistanceInformationForInactive-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        { ID id-EUTRA-PagingeDRXInformation                                     CRITICALITY ignore      EXTENSION EUTRA-PagingeDRXInformation                                   PRESENCE optional       }|
        { ID id-ExtendedUEIdentityIndexValue                            CRITICALITY ignore      EXTENSION ExtendedUEIdentityIndexValue                                  PRESENCE optional       }|
        { ID id-UERadioCapabilityForPaging                                      CRITICALITY ignore      EXTENSION UERadioCapabilityForPaging                                            PRESENCE optional       }|
        { ID id-MicoAllPLMN                                                                     CRITICALITY ignore      EXTENSION MicoAllPLMN                                                                                   PRESENCE optional       }|
        { ID id-NR-PagingeDRXInformation                                        CRITICALITY ignore      EXTENSION NR-PagingeDRXInformation                                              PRESENCE optional       }|
        { ID id-PagingCauseIndicationForVoiceService            CRITICALITY ignore      EXTENSION PagingCauseIndicationForVoiceService          PRESENCE optional       }|
        { ID id-PEIPSassistanceInformation                                      CRITICALITY ignore      EXTENSION PEIPSassistanceInformation                                            PRESENCE optional       }|
        { ID id-HashedUEIdentityIndexValue                                      CRITICALITY ignore      EXTENSION HashedUEIdentityIndexValue                                            PRESENCE optional       }|
        { ID id-CN-MT-CommunicationHandling                                     CRITICALITY ignore      EXTENSION        CN-MT-CommunicationHandling                            PRESENCE optional       },
        ...
}

CN-MT-CommunicationHandling ::= ENUMERATED {supported, ...}

COUNTValueForPDCP-SN12 ::= SEQUENCE {
        pDCP-SN12                       INTEGER (0..4095),
        hFN-PDCP-SN12           INTEGER (0..1048575),
        iE-Extensions           ProtocolExtensionContainer { {COUNTValueForPDCP-SN12-ExtIEs} }  OPTIONAL,
        ...
}

COUNTValueForPDCP-SN12-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

COUNTValueForPDCP-SN18 ::= SEQUENCE {
        pDCP-SN18                       INTEGER (0..262143),
        hFN-PDCP-SN18           INTEGER (0..16383),
        iE-Extensions           ProtocolExtensionContainer { {COUNTValueForPDCP-SN18-ExtIEs} }  OPTIONAL,
        ...
}

COUNTValueForPDCP-SN18-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

CoverageEnhancementLevel ::= OCTET STRING

CPTransportLayerInformation ::= CHOICE {
        endpointIPAddress               TransportLayerAddress,
        choice-Extensions               ProtocolIE-SingleContainer { {CPTransportLayerInformation-ExtIEs} }
}

CPTransportLayerInformation-ExtIEs NGAP-PROTOCOL-IES ::= {
        { ID id-EndpointIPAddressAndPort                CRITICALITY reject      TYPE EndpointIPAddressAndPort           PRESENCE mandatory      },
        ...
}

CriticalityDiagnostics ::= SEQUENCE {
        procedureCode                                   ProcedureCode                                                                                   OPTIONAL,
        triggeringMessage                               TriggeringMessage                                                                               OPTIONAL,
        procedureCriticality                    Criticality                                                                                             OPTIONAL,
        iEsCriticalityDiagnostics               CriticalityDiagnostics-IE-List                                                  OPTIONAL,
        iE-Extensions           ProtocolExtensionContainer {{CriticalityDiagnostics-ExtIEs}}            OPTIONAL,
        ...
}

CriticalityDiagnostics-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

CriticalityDiagnostics-IE-List ::= SEQUENCE (SIZE(1..maxnoofErrors)) OF CriticalityDiagnostics-IE-Item

CriticalityDiagnostics-IE-Item ::= SEQUENCE {
        iECriticality           Criticality,
        iE-ID                           ProtocolIE-ID,
        typeOfError                     TypeOfError,
        iE-Extensions           ProtocolExtensionContainer {{CriticalityDiagnostics-IE-Item-ExtIEs}} OPTIONAL,
        ...
}

CriticalityDiagnostics-IE-Item-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

C-RNTI ::= BIT STRING (SIZE(16))

CellBasedMDT-NR::= SEQUENCE {
        cellIdListforMDT        CellIdListforMDT-NR,
        iE-Extensions           ProtocolExtensionContainer { {CellBasedMDT-NR-ExtIEs} } OPTIONAL,
        ...
}

CellBasedMDT-NR-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

CellIdListforMDT-NR ::= SEQUENCE (SIZE(1..maxnoofCellIDforMDT)) OF NR-CGI


CellBasedMDT-EUTRA::= SEQUENCE {
        cellIdListforMDT        CellIdListforMDT-EUTRA,
        iE-Extensions           ProtocolExtensionContainer { {CellBasedMDT-EUTRA-ExtIEs} } OPTIONAL,
        ...
}

CellBasedMDT-EUTRA-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

CellBasedQMC ::= SEQUENCE {
        cellIdListforQMC        CellIdListforQMC,
        iE-Extensions           ProtocolExtensionContainer { {CellBasedQMC-ExtIEs} } OPTIONAL,
        ...
}

CellBasedQMC-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

CellIdListforQMC ::= SEQUENCE (SIZE(1..maxnoofCellIDforQMC)) OF NGRAN-CGI

CellIdListforMDT-EUTRA ::= SEQUENCE (SIZE(1..maxnoofCellIDforMDT)) OF EUTRA-CGI

CAGListforMDT ::= SEQUENCE (SIZE(1.. maxnoofCAGforMDT)) OF CAGListforMDTItem

CAGListforMDTItem ::= SEQUENCE {
        plmnID                          PLMNIdentity,
        cAGID                           CAG-ID,
        iE-Extensions           ProtocolExtensionContainer { {CAGListforMDTItem-ExtIEs} }       OPTIONAL,
        ...
}

CAGListforMDTItem-ExtIEs NGAP-PROTOCOL-EXTENSION ::={
        ...
}


-- D

DataCodingScheme ::= BIT STRING (SIZE(8))

DataForwardingAccepted ::= ENUMERATED {
        data-forwarding-accepted,
        ...
}

DataForwardingNotPossible ::= ENUMERATED {
        data-forwarding-not-possible,
        ...
}

DataForwardingResponseDRBList ::= SEQUENCE (SIZE(1..maxnoofDRBs)) OF DataForwardingResponseDRBItem

DataForwardingResponseDRBItem ::= SEQUENCE {
        dRB-ID                                                          DRB-ID,
        dLForwardingUP-TNLInformation           UPTransportLayerInformation                                                             OPTIONAL,
        uLForwardingUP-TNLInformation           UPTransportLayerInformation                                                             OPTIONAL,
        iE-Extensions           ProtocolExtensionContainer {{DataForwardingResponseDRBItem-ExtIEs}}             OPTIONAL,
        ...
}

DataForwardingResponseDRBItem-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

DAPSRequestInfo ::= SEQUENCE {
        dAPSIndicator                           ENUMERATED {daps-ho-required, ...},
        iE-Extensions                           ProtocolExtensionContainer { {DAPSRequestInfo-ExtIEs} } OPTIONAL,
        ...
}

DAPSRequestInfo-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

DAPSResponseInfoList ::= SEQUENCE (SIZE(1.. maxnoofDRBs)) OF DAPSResponseInfoItem

DAPSResponseInfoItem ::= SEQUENCE {
        dRB-ID                          DRB-ID,
        dAPSResponseInfo                DAPSResponseInfo,
        iE-Extension                    ProtocolExtensionContainer { {DAPSResponseInfoItem-ExtIEs} }            OPTIONAL,
        ...
}

DAPSResponseInfoItem-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

DAPSResponseInfo ::= SEQUENCE {
        dapsresponseindicator           ENUMERATED {daps-ho-accepted, daps-ho-not-accepted, ...},
        iE-Extensions                   ProtocolExtensionContainer { { DAPSResponseInfo-ExtIEs} }       OPTIONAL,
        ...
}

DAPSResponseInfo-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}


DataForwardingResponseERABList ::= SEQUENCE (SIZE(1..maxnoofE-RABs)) OF DataForwardingResponseERABListItem

DataForwardingResponseERABListItem ::= SEQUENCE {
        e-RAB-ID                                                        E-RAB-ID,
        dLForwardingUP-TNLInformation           UPTransportLayerInformation,
        iE-Extensions           ProtocolExtensionContainer { {DataForwardingResponseERABListItem-ExtIEs} }      OPTIONAL,
        ...
}

DataForwardingResponseERABListItem-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

DelayCritical ::= ENUMERATED {
        delay-critical,
        non-delay-critical,
        ...
}

DL-CP-SecurityInformation ::= SEQUENCE {
        dl-NAS-MAC                              DL-NAS-MAC,
        iE-Extensions                   ProtocolExtensionContainer { { DL-CP-SecurityInformation-ExtIEs} }      OPTIONAL,
        ...
}

DL-CP-SecurityInformation-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

DL-Signalling ::= ENUMERATED {true,     ...}


DL-NAS-MAC ::= BIT STRING (SIZE (16))

DLForwarding ::= ENUMERATED {
        dl-forwarding-proposed,
        ...
}

DL-NGU-TNLInformationReused ::= ENUMERATED {
        true,
        ...
}

DirectForwardingPathAvailability ::= ENUMERATED {
        direct-path-available,
        ...
}

DRB-ID ::= INTEGER (1..32, ...)

DRBsSubjectToStatusTransferList ::= SEQUENCE (SIZE(1..maxnoofDRBs)) OF DRBsSubjectToStatusTransferItem

DRBsSubjectToStatusTransferItem ::= SEQUENCE {
        dRB-ID                          DRB-ID,
        dRBStatusUL                     DRBStatusUL,
        dRBStatusDL                     DRBStatusDL,
        iE-Extension            ProtocolExtensionContainer { {DRBsSubjectToStatusTransferItem-ExtIEs} } OPTIONAL,
        ...
}

DRBsSubjectToStatusTransferItem-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        { ID id-OldAssociatedQosFlowList-ULendmarkerexpected    CRITICALITY ignore EXTENSION AssociatedQosFlowList       PRESENCE optional },
        ...
}

DRBStatusDL ::= CHOICE {
        dRBStatusDL12                   DRBStatusDL12,
        dRBStatusDL18                   DRBStatusDL18,
        choice-Extensions               ProtocolIE-SingleContainer { {DRBStatusDL-ExtIEs} }
}

DRBStatusDL-ExtIEs NGAP-PROTOCOL-IES ::= {
        ...
}

DRBStatusDL12 ::= SEQUENCE {
        dL-COUNTValue           COUNTValueForPDCP-SN12,
        iE-Extension            ProtocolExtensionContainer { {DRBStatusDL12-ExtIEs} }           OPTIONAL,
        ...
}

DRBStatusDL12-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

DRBStatusDL18 ::= SEQUENCE {
        dL-COUNTValue           COUNTValueForPDCP-SN18,
        iE-Extension            ProtocolExtensionContainer { {DRBStatusDL18-ExtIEs} }           OPTIONAL,
        ...
}

DRBStatusDL18-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

DRBStatusUL ::= CHOICE {
        dRBStatusUL12                   DRBStatusUL12,
        dRBStatusUL18                   DRBStatusUL18,
        choice-Extensions               ProtocolIE-SingleContainer { {DRBStatusUL-ExtIEs} }
}

DRBStatusUL-ExtIEs NGAP-PROTOCOL-IES ::= {
        ...
}

DRBStatusUL12 ::= SEQUENCE {
        uL-COUNTValue                                   COUNTValueForPDCP-SN12,
        receiveStatusOfUL-PDCP-SDUs             BIT STRING (SIZE(1..2048))                                              OPTIONAL,
        iE-Extension            ProtocolExtensionContainer { {DRBStatusUL12-ExtIEs} }           OPTIONAL,
        ...
}

DRBStatusUL12-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

DRBStatusUL18 ::= SEQUENCE {
        uL-COUNTValue                                   COUNTValueForPDCP-SN18,
        receiveStatusOfUL-PDCP-SDUs             BIT STRING (SIZE(1..131072))                                    OPTIONAL,
        iE-Extension            ProtocolExtensionContainer { {DRBStatusUL18-ExtIEs} }           OPTIONAL,
        ...
}

DRBStatusUL18-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

DRBsToQosFlowsMappingList ::= SEQUENCE (SIZE(1..maxnoofDRBs)) OF DRBsToQosFlowsMappingItem

DRBsToQosFlowsMappingItem ::= SEQUENCE {
        dRB-ID                                                          DRB-ID,
        associatedQosFlowList                           AssociatedQosFlowList,
        iE-Extensions           ProtocolExtensionContainer { {DRBsToQosFlowsMappingItem-ExtIEs} }               OPTIONAL,
        ...
}

DRBsToQosFlowsMappingItem-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        { ID id-DAPSRequestInfo CRITICALITY ignore      EXTENSION DAPSRequestInfo       PRESENCE optional  },
        ...
}

Dynamic5QIDescriptor ::= SEQUENCE {
        priorityLevelQos                        PriorityLevelQos,
        packetDelayBudget                       PacketDelayBudget,
        packetErrorRate                         PacketErrorRate,
        fiveQI                                          FiveQI                                                                                                  OPTIONAL,
        delayCritical                           DelayCritical                                                                                   OPTIONAL,
-- The above IE shall be present in case of GBR QoS flow
        averagingWindow                         AveragingWindow                                                                                 OPTIONAL,
-- The above IE shall be present in case of GBR QoS flow
        maximumDataBurstVolume          MaximumDataBurstVolume                                                                  OPTIONAL,
        iE-Extensions           ProtocolExtensionContainer { {Dynamic5QIDescriptor-ExtIEs} }    OPTIONAL,
        ...
}

Dynamic5QIDescriptor-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        { ID id-ExtendedPacketDelayBudget       CRITICALITY ignore      EXTENSION ExtendedPacketDelayBudget             PRESENCE optional               }|
        { ID id-CNPacketDelayBudgetDL           CRITICALITY ignore      EXTENSION ExtendedPacketDelayBudget             PRESENCE optional               }|
        { ID id-CNPacketDelayBudgetUL           CRITICALITY ignore      EXTENSION ExtendedPacketDelayBudget             PRESENCE optional               },
        ...
}

-- E

EarlyMeasurement ::= ENUMERATED {true, ...}

EarlyStatusTransfer-TransparentContainer ::= SEQUENCE {
        procedureStage                  ProcedureStageChoice,
        iE-Extensions                   ProtocolExtensionContainer { {EarlyStatusTransfer-TransparentContainer-ExtIEs} }        OPTIONAL,
        ...
}

EarlyStatusTransfer-TransparentContainer-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

ProcedureStageChoice ::= CHOICE {
        first-dl-count                  FirstDLCount,
        choice-Extensions               ProtocolIE-SingleContainer { {ProcedureStageChoice-ExtIEs} }
}

ProcedureStageChoice-ExtIEs NGAP-PROTOCOL-IES ::= {
        { ID id-DLDiscarding                                            CRITICALITY ignore      TYPE DLDiscarding                                                                       PRESENCE mandatory      },
        ...
}

DLDiscarding ::= SEQUENCE {
        dRBsSubjectToDLDiscarding                                       DRBsSubjectToDLDiscarding-List,
        iE-Extension                                                            ProtocolExtensionContainer { {DLDiscarding-ExtIEs} }    OPTIONAL,
        ...
}

DLDiscarding-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

DRBsSubjectToDLDiscarding-List ::= SEQUENCE (SIZE (1..maxnoofDRBs)) OF DRBsSubjectToDLDiscarding-Item

DRBsSubjectToDLDiscarding-Item ::= SEQUENCE {
        drbID                           DRB-ID,
        dlCount                         DLCountChoice,
        iE-Extension            ProtocolExtensionContainer { { DRBsSubjectToDLDiscarding-Item-ExtIEs} } OPTIONAL,
        ...
}

DRBsSubjectToDLDiscarding-Item-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

DLCountChoice ::= CHOICE {
        count12bits                             COUNTValueForPDCP-SN12,
        count18bits                             COUNTValueForPDCP-SN18,
        choice-extension                ProtocolIE-SingleContainer { {DLCountChoice-ExtIEs} }
}

DLCountChoice-ExtIEs NGAP-PROTOCOL-IES ::= {
        ...
}

FirstDLCount ::= SEQUENCE {
        dRBsSubjectToEarlyStatusTransfer                DRBsSubjectToEarlyStatusTransfer-List,
        iE-Extension            ProtocolExtensionContainer { {FirstDLCount-ExtIEs} }            OPTIONAL,
        ...
}

FirstDLCount-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

DRBsSubjectToEarlyStatusTransfer-List ::= SEQUENCE (SIZE (1.. maxnoofDRBs)) OF DRBsSubjectToEarlyStatusTransfer-Item

DRBsSubjectToEarlyStatusTransfer-Item ::= SEQUENCE {
        dRB-ID                          DRB-ID,
        firstDLCOUNT            DRBStatusDL,
        iE-Extension            ProtocolExtensionContainer { { DRBsSubjectToEarlyStatusTransfer-Item-ExtIEs} }  OPTIONAL,
        ...
}

DRBsSubjectToEarlyStatusTransfer-Item-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

ECNMarkingorCongestionInformationReportingRequest ::= CHOICE {
        eCNMarkingAtRANRequest                          ECNMarkingAtRANRequest,
        eCNMarkingAtUPFRequest                          ECNMarkingAtUPFRequest,
        congestionInformationRequest            CongestionInformationRequest,
        choice-Extensions                               ProtocolIE-SingleContainer { {ECNMarkingorCongestionInformationReportingRequest-ExtIEs} }
}

ECNMarkingorCongestionInformationReportingRequest-ExtIEs NGAP-PROTOCOL-IES ::= {
        ...
}

ECNMarkingAtRANRequest ::= ENUMERATED {ul, dl, both, stop, ...}

ECNMarkingAtUPFRequest ::= ENUMERATED {ul, dl, both, stop, ...}

CongestionInformationRequest ::= ENUMERATED {ul, dl, both, stop, ...}

ECNMarkingorCongestionInformationReportingStatus ::= SEQUENCE (SIZE (1..maxnoofQosFlows)) OF ECNMarkingorCongestionInformationReportingStatus-Item

ECNMarkingorCongestionInformationReportingStatus-Item ::= SEQUENCE {
        qosFlowIdentifier                               QosFlowIdentifier,
        activationStatus                                ActivationStatus,
        iE-Extension                                    ProtocolExtensionContainer { { ECNMarkingorCongestionInformationReportingStatus-Item-ExtIEs} }  OPTIONAL,
        ...
}

ECNMarkingorCongestionInformationReportingStatus-Item-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

ActivationStatus        ::= ENUMERATED {
        active,
        not-active,
        ...
}

EDT-Session ::= ENUMERATED {
        true,
        ...
}

EmergencyAreaID ::= OCTET STRING (SIZE(3))

EmergencyAreaIDBroadcastEUTRA ::= SEQUENCE (SIZE(1..maxnoofEmergencyAreaID)) OF EmergencyAreaIDBroadcastEUTRA-Item

EmergencyAreaIDBroadcastEUTRA-Item ::= SEQUENCE {
        emergencyAreaID                                 EmergencyAreaID,
        completedCellsInEAI-EUTRA               CompletedCellsInEAI-EUTRA,
        iE-Extensions           ProtocolExtensionContainer { {EmergencyAreaIDBroadcastEUTRA-Item-ExtIEs} } OPTIONAL,
        ...
}

EmergencyAreaIDBroadcastEUTRA-Item-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

EmergencyAreaIDBroadcastNR ::= SEQUENCE (SIZE(1..maxnoofEmergencyAreaID)) OF EmergencyAreaIDBroadcastNR-Item

EmergencyAreaIDBroadcastNR-Item ::= SEQUENCE {
        emergencyAreaID                         EmergencyAreaID,
        completedCellsInEAI-NR          CompletedCellsInEAI-NR,
        iE-Extensions           ProtocolExtensionContainer { {EmergencyAreaIDBroadcastNR-Item-ExtIEs} } OPTIONAL,
        ...
}

EmergencyAreaIDBroadcastNR-Item-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

EmergencyAreaIDCancelledEUTRA ::= SEQUENCE (SIZE(1..maxnoofEmergencyAreaID)) OF EmergencyAreaIDCancelledEUTRA-Item

EmergencyAreaIDCancelledEUTRA-Item ::= SEQUENCE {
        emergencyAreaID                                 EmergencyAreaID,
        cancelledCellsInEAI-EUTRA               CancelledCellsInEAI-EUTRA,
        iE-Extensions           ProtocolExtensionContainer { {EmergencyAreaIDCancelledEUTRA-Item-ExtIEs} } OPTIONAL,
        ...
}

EmergencyAreaIDCancelledEUTRA-Item-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

EmergencyAreaIDCancelledNR ::= SEQUENCE (SIZE(1..maxnoofEmergencyAreaID)) OF EmergencyAreaIDCancelledNR-Item

EmergencyAreaIDCancelledNR-Item ::= SEQUENCE {
        emergencyAreaID                         EmergencyAreaID,
        cancelledCellsInEAI-NR          CancelledCellsInEAI-NR,
        iE-Extensions           ProtocolExtensionContainer { {EmergencyAreaIDCancelledNR-Item-ExtIEs} } OPTIONAL,
        ...
}

EmergencyAreaIDCancelledNR-Item-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

EmergencyAreaIDList ::= SEQUENCE (SIZE(1..maxnoofEmergencyAreaID)) OF EmergencyAreaID

EmergencyAreaIDListForRestart ::= SEQUENCE (SIZE(1..maxnoofEAIforRestart)) OF EmergencyAreaID

EmergencyFallbackIndicator ::= SEQUENCE {
        emergencyFallbackRequestIndicator               EmergencyFallbackRequestIndicator,
        emergencyServiceTargetCN                                EmergencyServiceTargetCN                                                OPTIONAL,
        iE-Extensions           ProtocolExtensionContainer { {EmergencyFallbackIndicator-ExtIEs} }      OPTIONAL,
        ...
}

EmergencyFallbackIndicator-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

EmergencyFallbackRequestIndicator ::= ENUMERATED {
        emergency-fallback-requested,
        ...
}

EmergencyServiceTargetCN ::= ENUMERATED {
        fiveGC,
        epc,
        ...
}

ENB-ID ::= CHOICE {
        macroENB-ID                             BIT STRING (SIZE(20)),
        homeENB-ID                              BIT STRING (SIZE(28)),
        short-macroENB-ID               BIT STRING (SIZE(18)),
        long-macroENB-ID                BIT STRING (SIZE(21)),
        choice-Extensions               ProtocolIE-SingleContainer { { ENB-ID-ExtIEs} }
}

ENB-ID-ExtIEs NGAP-PROTOCOL-IES ::= {
        ...
}


Enhanced-CoverageRestriction ::= ENUMERATED {restricted, ... }


Extended-ConnectedTime ::= INTEGER (0..255)

EN-DCSONConfigurationTransfer ::= OCTET STRING

EndpointIPAddressAndPort ::=SEQUENCE {
        endpointIPAddress TransportLayerAddress,
        portNumber                      PortNumber,
        iE-Extensions           ProtocolExtensionContainer { { EndpointIPAddressAndPort-ExtIEs} } OPTIONAL
}

EndIndication ::= ENUMERATED {
        no-further-data,
        further-data-exists,
        ...
}

EndpointIPAddressAndPort-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

EquivalentPLMNs ::= SEQUENCE (SIZE(1..maxnoofEPLMNs)) OF PLMNIdentity

EPS-TAC ::= OCTET STRING (SIZE(2))

EPS-TAI ::= SEQUENCE {
        pLMNIdentity            PLMNIdentity,
        ePS-TAC                         EPS-TAC,
        iE-Extensions           ProtocolExtensionContainer { {EPS-TAI-ExtIEs} } OPTIONAL,
        ...
}

EPS-TAI-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

E-RAB-ID ::= INTEGER (0..15, ...)

E-RABInformationList ::= SEQUENCE (SIZE(1..maxnoofE-RABs)) OF E-RABInformationItem

E-RABInformationItem ::= SEQUENCE {
        e-RAB-ID                        E-RAB-ID,
        dLForwarding            DLForwarding                                                                                                    OPTIONAL,
        iE-Extensions           ProtocolExtensionContainer { {E-RABInformationItem-ExtIEs} }    OPTIONAL,
        ...
}

E-RABInformationItem-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        {ID id-SourceTNLAddrInfo                CRITICALITY ignore      EXTENSION TransportLayerAddress PRESENCE optional}|
        {ID id-SourceNodeTNLAddrInfo    CRITICALITY ignore      EXTENSION TransportLayerAddress PRESENCE optional},
        ...
}

ERedCapIndication ::= ENUMERATED {
        true,
        ...
}

EUTRACellIdentity ::= BIT STRING (SIZE(28))

EUTRA-CGI ::= SEQUENCE {
        pLMNIdentity                    PLMNIdentity,
        eUTRACellIdentity               EUTRACellIdentity,
        iE-Extensions           ProtocolExtensionContainer { {EUTRA-CGI-ExtIEs} } OPTIONAL,
        ...
}

EUTRA-CGI-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

EUTRA-CGIList ::= SEQUENCE (SIZE(1..maxnoofCellsinngeNB)) OF EUTRA-CGI

EUTRA-CGIListForWarning ::= SEQUENCE (SIZE(1..maxnoofCellIDforWarning)) OF EUTRA-CGI

EUTRA-PagingeDRXInformation ::= SEQUENCE {
        eUTRA-paging-eDRX-Cycle         EUTRA-Paging-eDRX-Cycle,
        eUTRA-paging-Time-Window        EUTRA-Paging-Time-Window                                        OPTIONAL,
        iE-Extensions           ProtocolExtensionContainer { {EUTRA-PagingeDRXInformation-ExtIEs} }     OPTIONAL,
        ...
}

EUTRA-PagingeDRXInformation-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

EUTRA-Paging-eDRX-Cycle ::= ENUMERATED {
        hfhalf, hf1, hf2, hf4, hf6,
        hf8, hf10, hf12, hf14, hf16,
        hf32, hf64, hf128, hf256,
        ...
}

EUTRA-Paging-Time-Window ::= ENUMERATED {
        s1, s2, s3, s4, s5,
        s6, s7, s8, s9, s10,
        s11, s12, s13, s14, s15, s16,
        ...
}

EUTRAencryptionAlgorithms ::= BIT STRING (SIZE(16, ...))

EUTRAintegrityProtectionAlgorithms ::= BIT STRING (SIZE(16, ...))

EventType ::= ENUMERATED {
        direct,
        change-of-serve-cell,
        ue-presence-in-area-of-interest,
        stop-change-of-serve-cell,
        stop-ue-presence-in-area-of-interest,
        cancel-location-reporting-for-the-ue,
        ...,
        change-of-serving-cell-and-UE-presence-in-the-Area-of-Interest
}

ExcessPacketDelayThresholdConfiguration ::= SEQUENCE (SIZE(1..maxnoofThresholdsForExcessPacketDelay)) OF ExcessPacketDelayThresholdItem

ExcessPacketDelayThresholdItem ::= SEQUENCE {
        fiveQi          FiveQI,
        excessPacketDelayThresholdValue                 ExcessPacketDelayThresholdValue,
        iE-Extensions           ProtocolExtensionContainer { { ExcessPacketDelayThresholdItem-ExtIEs} } OPTIONAL,
        ...
}

ExcessPacketDelayThresholdItem-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

ExcessPacketDelayThresholdValue ::= ENUMERATED {
ms0dot25, ms0dot5, ms1, ms2, ms4, ms5, ms10, ms20, ms30, ms40, ms50, ms60, ms70, ms80, ms90, ms100, ms150, ms300, ms500,
        ...
}

ExpectedActivityPeriod ::= INTEGER (1..30|40|50|60|80|100|120|150|180|181, ...)

ExpectedHOInterval ::= ENUMERATED {
        sec15, sec30, sec60, sec90, sec120, sec180, long-time,
        ...
}

ExpectedIdlePeriod ::= INTEGER (1..30|40|50|60|80|100|120|150|180|181, ...)

ExpectedUEActivityBehaviour ::= SEQUENCE {
        expectedActivityPeriod                                          ExpectedActivityPeriod                                          OPTIONAL,
        expectedIdlePeriod                                                      ExpectedIdlePeriod                                                      OPTIONAL,
        sourceOfUEActivityBehaviourInformation          SourceOfUEActivityBehaviourInformation          OPTIONAL,
        iE-Extensions           ProtocolExtensionContainer { {ExpectedUEActivityBehaviour-ExtIEs} }     OPTIONAL,
        ...
}

ExpectedUEActivityBehaviour-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

ExpectedUEBehaviour ::= SEQUENCE {
        expectedUEActivityBehaviour             ExpectedUEActivityBehaviour                                     OPTIONAL,
        expectedHOInterval                              ExpectedHOInterval                                                              OPTIONAL,
        expectedUEMobility                              ExpectedUEMobility                                                              OPTIONAL,
        expectedUEMovingTrajectory              ExpectedUEMovingTrajectory                                              OPTIONAL,
        iE-Extensions           ProtocolExtensionContainer { {ExpectedUEBehaviour-ExtIEs} }     OPTIONAL,
        ...
}

ExpectedUEBehaviour-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

ExpectedUEMobility ::= ENUMERATED {
        stationary,
        mobile,
        ...
}

ExpectedUEMovingTrajectory ::= SEQUENCE (SIZE(1..maxnoofCellsUEMovingTrajectory)) OF ExpectedUEMovingTrajectoryItem

ExpectedUEMovingTrajectoryItem ::= SEQUENCE {
        nGRAN-CGI                               NGRAN-CGI,
        timeStayedInCell                INTEGER (0..4095)                                                                                                       OPTIONAL,
        iE-Extensions           ProtocolExtensionContainer { {ExpectedUEMovingTrajectoryItem-ExtIEs} }  OPTIONAL,
        ...
}

ExpectedUEMovingTrajectoryItem-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

Extended-AMFName         ::= SEQUENCE {
        aMFNameVisibleString            AMFNameVisibleString                            OPTIONAL,
        aMFNameUTF8String                       AMFNameUTF8String                                       OPTIONAL,
        iE-Extensions                           ProtocolExtensionContainer { { Extended-AMFName-ExtIEs } } OPTIONAL,
        ...
}

Extended-AMFName-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

ExtendedPacketDelayBudget ::= INTEGER (1..65535, ..., 65536..109999)


Extended-RANNodeName     ::= SEQUENCE {
        rANNodeNameVisibleString                RANNodeNameVisibleString                                        OPTIONAL,
        rANNodeNameUTF8String                   RANNodeNameUTF8String                                           OPTIONAL,
        iE-Extensions                                   ProtocolExtensionContainer { { Extended-RANNodeName-ExtIEs } } OPTIONAL,
        ...
}

Extended-RANNodeName-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

ExtendedRATRestrictionInformation ::= SEQUENCE {
        primaryRATRestriction           BIT STRING (SIZE(8, ..., 16)),
        secondaryRATRestriction         BIT STRING (SIZE(8, ...)),
        iE-Extensions           ProtocolExtensionContainer { {ExtendedRATRestrictionInformation-ExtIEs} }       OPTIONAL,
        ...
}

ExtendedRATRestrictionInformation-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

ExtendedRNC-ID                                  ::= INTEGER (4096..65535)

ExtendedSliceSupportList ::= SEQUENCE (SIZE(1..maxnoofExtSliceItems)) OF SliceSupportItem

ExtendedUEIdentityIndexValue ::= BIT STRING (SIZE(16))

EventTrigger::= CHOICE {
        outOfCoverage                           ENUMERATED {true, ...},
        eventL1LoggedMDTConfig          EventL1LoggedMDTConfig,
        choice-Extensions               ProtocolIE-SingleContainer { { EventTrigger-ExtIEs} }
}

EventTrigger-ExtIEs NGAP-PROTOCOL-IES ::= {
        ...
}

EventL1LoggedMDTConfig ::= SEQUENCE {
        l1Threshold                                     MeasurementThresholdL1LoggedMDT,
        hysteresis                                      Hysteresis,
        timeToTrigger                           TimeToTrigger,
        iE-Extensions                           ProtocolExtensionContainer { { EventL1LoggedMDTConfig-ExtIEs} } OPTIONAL,
        ...
}

EventL1LoggedMDTConfig-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

MeasurementThresholdL1LoggedMDT ::= CHOICE {
        threshold-RSRP                          Threshold-RSRP,
        threshold-RSRQ                          Threshold-RSRQ,
        choice-Extensions               ProtocolIE-SingleContainer { { MeasurementThresholdL1LoggedMDT-ExtIEs} }
}

MeasurementThresholdL1LoggedMDT-ExtIEs NGAP-PROTOCOL-IES ::= {
        ...
}

EquivalentSNPNsList ::= SEQUENCE (SIZE(1..maxnoofESNPNs)) OF EquivalentSNPNsItem

EquivalentSNPNsItem ::= SEQUENCE {
        plmnIdentity            PLMNIdentity,
        nID                                     NID,
        iE-Extensions           ProtocolExtensionContainer { {EquivalentSNPNsItem-ExtIEs} }     OPTIONAL,
        ...
}

EquivalentSNPNsItem-ExtIEs NGAP-PROTOCOL-EXTENSION ::={
        ...
}

-- F

FailureIndication ::= SEQUENCE {
        uERLFReportContainer    UERLFReportContainer,
        iE-Extensions           ProtocolExtensionContainer { { FailureIndication-ExtIEs} }      OPTIONAL,
        ...
}

FailureIndication-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

FiveGCAction ::= CHOICE {
        hLComActivate                   HLComActivate,
        hLComDeactivate                 HLComDeactivate,
        choice-Extensions               ProtocolIE-SingleContainer { {FiveGCAction-ExtIEs} }
}

FiveGCAction-ExtIEs NGAP-PROTOCOL-IES ::= {
        ...
}

FiveG-ProSeAuthorized ::= SEQUENCE {
        fiveGProSeDirectDiscovery                               FiveGProSeDirectDiscovery                                               OPTIONAL,
        fiveGProSeDirectCommunication                   FiveGProSeDirectCommunication                                   OPTIONAL,
        fiveGProSeLayer2UEtoNetworkRelay                FiveGProSeLayer2UEtoNetworkRelay                                OPTIONAL,
        fiveGProSeLayer3UEtoNetworkRelay                FiveGProSeLayer3UEtoNetworkRelay                                OPTIONAL,
        fiveGProSeLayer2RemoteUE                                FiveGProSeLayer2RemoteUE                                                OPTIONAL,
        iE-Extensions           ProtocolExtensionContainer { {FiveG-ProSeAuthorized-ExtIEs} }           OPTIONAL,
        ...
}

FiveG-ProSeAuthorized-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        { ID id-FiveGProSeLayer2Multipath               CRITICALITY ignore      EXTENSION FiveGProSeLayer2Multipath                     PRESENCE optional               }|
        { ID id-FiveGProSeLayer2UEtoUERelay             CRITICALITY ignore      EXTENSION FiveGProSeLayer2UEtoUERelay           PRESENCE optional               }|
        { ID id-FiveGProSeLayer2UEtoUERemote    CRITICALITY ignore      EXTENSION FiveGProSeLayer2UEtoUERemote          PRESENCE optional               },
        ...
}

FiveGProSeDirectDiscovery ::= ENUMERATED {
        authorized,
        not-authorized,
        ...
}

FiveGProSeDirectCommunication ::= ENUMERATED {
        authorized,
        not-authorized,
        ...
}

FiveGProSeLayer2UEtoNetworkRelay ::= ENUMERATED {
        authorized,
        not-authorized,
        ...
}

FiveGProSeLayer3UEtoNetworkRelay ::= ENUMERATED {
        authorized,
        not-authorized,
        ...
}

FiveGProSeLayer2RemoteUE ::= ENUMERATED {
        authorized,
        not-authorized,
        ...
}

FiveGProSeLayer2Multipath ::= ENUMERATED {
        authorized,
        not-authorized,
        ...
}

FiveGProSeLayer2UEtoUERelay ::= ENUMERATED {
        authorized,
        not-authorized,
        ...
}

FiveGProSeLayer2UEtoUERemote ::= ENUMERATED {
        authorized,
        not-authorized,
        ...
}

FiveG-ProSePC5QoSParameters ::= SEQUENCE {
        fiveGProSepc5QoSFlowList                                        FiveGProSePC5QoSFlowList,
        fiveGProSepc5LinkAggregateBitRates              BitRate                                                                                         OPTIONAL,
        iE-Extensions           ProtocolExtensionContainer { { FiveG-ProSePC5QoSParameters-ExtIEs} }    OPTIONAL,
        ...
}

FiveG-ProSePC5QoSParameters-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

FiveGProSePC5QoSFlowList ::= SEQUENCE (SIZE(1..maxnoofPC5QoSFlows)) OF FiveGProSePC5QoSFlowItem

FiveGProSePC5QoSFlowItem ::= SEQUENCE {
        fiveGproSepQI                           FiveQI,
        fiveGproSepc5FlowBitRates       FiveGProSePC5FlowBitRates                               OPTIONAL,
        fiveGproSerange                         Range                                                                   OPTIONAL,
        iE-Extensions           ProtocolExtensionContainer { { FiveGProSePC5QoSFlowItem-ExtIEs} }       OPTIONAL,
        ...
}

FiveGProSePC5QoSFlowItem-ExtIEs  NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

FiveGProSePC5FlowBitRates ::= SEQUENCE {
        fiveGproSeguaranteedFlowBitRate         BitRate,
        fiveGproSemaximumFlowBitRate            BitRate,
        iE-Extensions           ProtocolExtensionContainer { { FiveGProSePC5FlowBitRates-ExtIEs} }      OPTIONAL,
        ...
}

FiveGProSePC5FlowBitRates-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}


FiveG-S-TMSI ::= SEQUENCE {
        aMFSetID                        AMFSetID,
        aMFPointer                      AMFPointer,
        fiveG-TMSI                      FiveG-TMSI,
        iE-Extensions           ProtocolExtensionContainer { {FiveG-S-TMSI-ExtIEs} }    OPTIONAL,
        ...
}

FiveG-S-TMSI-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

FiveG-TMSI ::= OCTET STRING (SIZE(4))

FiveQI ::= INTEGER (0..255, ...)

ForbiddenAreaInformation ::= SEQUENCE (SIZE(1.. maxnoofEPLMNsPlusOne)) OF ForbiddenAreaInformation-Item

ForbiddenAreaInformation-Item ::= SEQUENCE {
        pLMNIdentity            PLMNIdentity,
        forbiddenTACs           ForbiddenTACs,
        iE-Extensions           ProtocolExtensionContainer { {ForbiddenAreaInformation-Item-ExtIEs} } OPTIONAL,
        ...
}

ForbiddenAreaInformation-Item-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

ForbiddenTACs ::= SEQUENCE (SIZE(1..maxnoofForbTACs)) OF TAC

FromEUTRANtoNGRAN ::= SEQUENCE {
        sourceeNBID                             IntersystemSONeNBID,
        targetNGRANnodeID               IntersystemSONNGRANnodeID,
        iE-Extensions                   ProtocolExtensionContainer { { FromEUTRANtoNGRAN-ExtIEs} }                      OPTIONAL
}

FromEUTRANtoNGRAN-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

FromNGRANtoEUTRAN ::= SEQUENCE {
        sourceNGRANnodeID               IntersystemSONNGRANnodeID,
        targeteNBID                             IntersystemSONeNBID,
        iE-Extensions                   ProtocolExtensionContainer { { FromNGRANtoEUTRAN-ExtIEs} }                      OPTIONAL
}

FromNGRANtoEUTRAN-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

-- G

GBR-QosInformation ::= SEQUENCE {
        maximumFlowBitRateDL            BitRate,
        maximumFlowBitRateUL            BitRate,
        guaranteedFlowBitRateDL         BitRate,
        guaranteedFlowBitRateUL         BitRate,
        notificationControl                     NotificationControl                                                                     OPTIONAL,
        maximumPacketLossRateDL         PacketLossRate                                                                          OPTIONAL,
        maximumPacketLossRateUL         PacketLossRate                                                                          OPTIONAL,
        iE-Extensions           ProtocolExtensionContainer { {GBR-QosInformation-ExtIEs} }      OPTIONAL,
        ...
}

GBR-QosInformation-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        { ID id-AlternativeQoSParaSetList       CRITICALITY ignore      EXTENSION AlternativeQoSParaSetList     PRESENCE optional       },
        ...
}

GlobalCable-ID ::= OCTET STRING

GlobalCable-ID-new ::= SEQUENCE {
        globalCable-ID                  GlobalCable-ID,
        tAI                                             TAI,
        iE-Extensions                   ProtocolExtensionContainer { { GlobalCable-ID-new-ExtIEs} }             OPTIONAL,
        ...
}

GlobalCable-ID-new-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

GlobalENB-ID ::= SEQUENCE {
        pLMNidentity                    PLMNIdentity,
        eNB-ID                                  ENB-ID,
        iE-Extensions                   ProtocolExtensionContainer { {GlobalENB-ID-ExtIEs} }            OPTIONAL,
        ...
}

GlobalENB-ID-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}


GlobalGNB-ID ::= SEQUENCE {
        pLMNIdentity            PLMNIdentity,
        gNB-ID                          GNB-ID,
        iE-Extensions           ProtocolExtensionContainer { {GlobalGNB-ID-ExtIEs} } OPTIONAL,
        ...
}

GlobalGNB-ID-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

GlobalN3IWF-ID ::= SEQUENCE {
        pLMNIdentity            PLMNIdentity,
        n3IWF-ID                        N3IWF-ID,
        iE-Extensions           ProtocolExtensionContainer { {GlobalN3IWF-ID-ExtIEs} } OPTIONAL,
        ...
}

GlobalN3IWF-ID-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

GlobalLine-ID ::= SEQUENCE {
        globalLineIdentity              GlobalLineIdentity,
        lineType                        LineType                                                                        OPTIONAL,
        iE-Extensions           ProtocolExtensionContainer { {GlobalLine-ID-ExtIEs} }           OPTIONAL,
        ...
}

GlobalLine-ID-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        { ID id-TAI                             CRITICALITY ignore      EXTENSION TAI                                                   PRESENCE optional       },
        ...
}

GlobalLineIdentity ::= OCTET STRING

GlobalNgENB-ID ::= SEQUENCE {
        pLMNIdentity            PLMNIdentity,
        ngENB-ID                        NgENB-ID,
        iE-Extensions           ProtocolExtensionContainer { {GlobalNgENB-ID-ExtIEs} } OPTIONAL,
        ...
}

GlobalNgENB-ID-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

GlobalRANNodeID ::= CHOICE {
        globalGNB-ID                    GlobalGNB-ID,
        globalNgENB-ID                  GlobalNgENB-ID,
        globalN3IWF-ID                  GlobalN3IWF-ID,
        choice-Extensions               ProtocolIE-SingleContainer { {GlobalRANNodeID-ExtIEs} }
}

GlobalRANNodeID-ExtIEs NGAP-PROTOCOL-IES ::= {
        { ID id-GlobalTNGF-ID           CRITICALITY reject      TYPE GlobalTNGF-ID                      PRESENCE mandatory      }|
        { ID id-GlobalTWIF-ID           CRITICALITY reject      TYPE GlobalTWIF-ID                      PRESENCE mandatory      }|
        { ID id-GlobalW-AGF-ID          CRITICALITY reject      TYPE GlobalW-AGF-ID                     PRESENCE mandatory      },
        ...
}

GlobalTNGF-ID ::= SEQUENCE {
        pLMNIdentity            PLMNIdentity,
        tNGF-ID                         TNGF-ID,
        iE-Extensions           ProtocolExtensionContainer { { GlobalTNGF-ID-ExtIEs} } OPTIONAL,
        ...
}

GlobalTNGF-ID-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}


GlobalTWIF-ID ::= SEQUENCE {
        pLMNIdentity            PLMNIdentity,
        tWIF-ID                         TWIF-ID,
        iE-Extensions           ProtocolExtensionContainer { { GlobalTWIF-ID-ExtIEs} } OPTIONAL,
        ...
}

GlobalTWIF-ID-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}


GlobalW-AGF-ID ::= SEQUENCE {
        pLMNIdentity                    PLMNIdentity,
        w-AGF-ID                                W-AGF-ID,
        iE-Extensions                   ProtocolExtensionContainer { { GlobalW-AGF-ID-ExtIEs} } OPTIONAL,
        ...
}

GlobalW-AGF-ID-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

GNB-ID ::= CHOICE {
        gNB-ID          BIT STRING (SIZE(22..32)),
        choice-Extensions               ProtocolIE-SingleContainer { {GNB-ID-ExtIEs} }
}

GNB-ID-ExtIEs NGAP-PROTOCOL-IES ::= {
        ...
}

GTP-TEID ::= OCTET STRING (SIZE(4))

GTPTunnel ::= SEQUENCE {
        transportLayerAddress           TransportLayerAddress,
        gTP-TEID                                        GTP-TEID,
        iE-Extensions           ProtocolExtensionContainer { {GTPTunnel-ExtIEs} } OPTIONAL,
        ...
}

GTPTunnel-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

GUAMI ::= SEQUENCE {
        pLMNIdentity            PLMNIdentity,
        aMFRegionID                     AMFRegionID,
        aMFSetID                        AMFSetID,
        aMFPointer                      AMFPointer,
        iE-Extensions           ProtocolExtensionContainer { {GUAMI-ExtIEs} } OPTIONAL,
        ...
}

GUAMI-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

GUAMIType ::= ENUMERATED {native, mapped, ...}

-- H

HandoverCommandTransfer ::= SEQUENCE {
        dLForwardingUP-TNLInformation           UPTransportLayerInformation                                             OPTIONAL,
        qosFlowToBeForwardedList                        QosFlowToBeForwardedList                                                OPTIONAL,
        dataForwardingResponseDRBList           DataForwardingResponseDRBList                                   OPTIONAL,
        iE-Extensions           ProtocolExtensionContainer { {HandoverCommandTransfer-ExtIEs} } OPTIONAL,
        ...
}

HandoverCommandTransfer-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        { ID id-AdditionalDLForwardingUPTNLInformation          CRITICALITY ignore      EXTENSION QosFlowPerTNLInformationList                  PRESENCE optional               }|
        { ID id-ULForwardingUP-TNLInformation                           CRITICALITY reject      EXTENSION UPTransportLayerInformation                   PRESENCE optional               }|
        { ID id-AdditionalULForwardingUPTNLInformation          CRITICALITY reject      EXTENSION UPTransportLayerInformationList               PRESENCE optional               }|
        { ID id-DataForwardingResponseERABList                          CRITICALITY ignore      EXTENSION DataForwardingResponseERABList                PRESENCE optional               }|
        { ID id-QosFlowFailedToSetupList                                        CRITICALITY ignore      EXTENSION QosFlowListWithCause                                          PRESENCE optional               },
        ...
}

HandoverFlag ::= ENUMERATED {
        handover-preparation,
        ...
}

HandoverPreparationUnsuccessfulTransfer ::= SEQUENCE {
        cause                           Cause,
        iE-Extensions           ProtocolExtensionContainer { {HandoverPreparationUnsuccessfulTransfer-ExtIEs} } OPTIONAL,
        ...
}

HandoverPreparationUnsuccessfulTransfer-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

HandoverRequestAcknowledgeTransfer ::= SEQUENCE {
        dL-NGU-UP-TNLInformation                        UPTransportLayerInformation,
        dLForwardingUP-TNLInformation           UPTransportLayerInformation                                                                             OPTIONAL,
        securityResult                                          SecurityResult                                                                                                  OPTIONAL,
        qosFlowSetupResponseList                        QosFlowListWithDataForwarding,
        qosFlowFailedToSetupList                        QosFlowListWithCause                                                                                    OPTIONAL,
        dataForwardingResponseDRBList           DataForwardingResponseDRBList                                                                   OPTIONAL,
        iE-Extensions           ProtocolExtensionContainer { {HandoverRequestAcknowledgeTransfer-ExtIEs} }      OPTIONAL,
        ...
}

HandoverRequestAcknowledgeTransfer-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        { ID id-AdditionalDLUPTNLInformationForHOList           CRITICALITY ignore      EXTENSION AdditionalDLUPTNLInformationForHOList         PRESENCE optional       }|
        { ID id-ULForwardingUP-TNLInformation                           CRITICALITY reject      EXTENSION UPTransportLayerInformation                                   PRESENCE optional       }|
        { ID id-AdditionalULForwardingUPTNLInformation          CRITICALITY reject      EXTENSION UPTransportLayerInformationList                               PRESENCE optional       }|
        { ID id-DataForwardingResponseERABList                          CRITICALITY ignore      EXTENSION DataForwardingResponseERABList                                PRESENCE optional       }|
        { ID id-RedundantDL-NGU-UP-TNLInformation                       CRITICALITY ignore      EXTENSION UPTransportLayerInformation                                   PRESENCE optional       }|
        { ID id-UsedRSNInformation                                                      CRITICALITY ignore      EXTENSION RedundantPDUSessionInformation                                PRESENCE optional       }|
        { ID id-GlobalRANNodeID                                                         CRITICALITY ignore      EXTENSION GlobalRANNodeID                                                                       PRESENCE optional       }|
        { ID id-MBS-SupportIndicator                                            CRITICALITY ignore      EXTENSION MBS-SupportIndicator                                                          PRESENCE optional       }|
        { ID id-PDUSetbasedHandlingIndicator                            CRITICALITY ignore      EXTENSION PDUSetbasedHandlingIndicator                                  PRESENCE optional }|
        { ID id-ECNMarkingorCongestionInformationReportingStatus        CRITICALITY ignore      EXTENSION ECNMarkingorCongestionInformationReportingStatus              PRESENCE optional },
        ...
}

HandoverRequiredTransfer ::= SEQUENCE {
        directForwardingPathAvailability                DirectForwardingPathAvailability                                OPTIONAL,
        iE-Extensions           ProtocolExtensionContainer { {HandoverRequiredTransfer-ExtIEs} }        OPTIONAL,
        ...
}

HandoverRequiredTransfer-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

HandoverResourceAllocationUnsuccessfulTransfer ::= SEQUENCE {
        cause                                           Cause,
        criticalityDiagnostics          CriticalityDiagnostics                                                                                                                                  OPTIONAL,
        iE-Extensions           ProtocolExtensionContainer { {HandoverResourceAllocationUnsuccessfulTransfer-ExtIEs} }  OPTIONAL,
        ...
}

HandoverResourceAllocationUnsuccessfulTransfer-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

HandoverType ::= ENUMERATED {
        intra5gs,
        fivegs-to-eps,
        eps-to-5gs,
        ...,
        fivegs-to-utran
}

HashedUEIdentityIndexValue ::= BIT STRING (SIZE(13, ...))


HFCNode-ID ::= OCTET STRING

HFCNode-ID-new ::= SEQUENCE {
        hFCNode-ID                      HFCNode-ID,
        tAI                                     TAI,
        iE-Extensions           ProtocolExtensionContainer { { HFCNode-ID-new-ExtIEs} } OPTIONAL,
        ...
}

HFCNode-ID-new-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        { ID id-GlobalCable-ID                          CRITICALITY ignore      EXTENSION GlobalCable-ID                                PRESENCE optional               },
        ...
}

HLComActivate ::= SEQUENCE {
        nR-Paging-Long-eDRX-Information-for-RRC-INACTIVE                        NR-Paging-Long-eDRX-Information-for-RRC-INACTIVE,
        iE-Extensions                                                                                           ProtocolExtensionContainer { { HLComActivate-ExtIEs} }  OPTIONAL,
        ...
}

HLComActivate-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

HLComDeactivate ::= SEQUENCE {
        uEReachabilityIndication                ENUMERATED {true, ...},
        iE-Extensions           ProtocolExtensionContainer { { HLComDeactivate-ExtIEs} }        OPTIONAL,
        ...
}

HLComDeactivate-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

HOReport::= SEQUENCE {
        handoverReportType                      ENUMERATED {ho-too-early, ho-to-wrong-cell, intersystem-ping-pong, ...},
        handoverCause                           Cause,
        sourcecellCGI                           NGRAN-CGI,
        targetcellCGI                           NGRAN-CGI,
        reestablishmentcellCGI          NGRAN-CGI                                                                       OPTIONAL,
-- The above IE shall be present if the Handover Report Type IE is set to the value “HO to wrong cell”
        sourcecellC-RNTI                        BIT STRING (SIZE(16))                                           OPTIONAL,
        targetcellinE-UTRAN                     EUTRA-CGI                                                                       OPTIONAL,
-- The above IE shall be present if the Handover Report Type IE is set to the value “Inter System ping-pong”
        mobilityInformation                     MobilityInformation                                                     OPTIONAL,
        uERLFReportContainer            UERLFReportContainer                                            OPTIONAL,
        iE-Extensions           ProtocolExtensionContainer { { HOReport-ExtIEs} }       OPTIONAL,
        ...
}

HOReport-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        { ID id-ExtendedMobilityInformation                             CRITICALITY ignore      EXTENSION ExtendedMobilityInformation                           PRESENCE optional               }|
        { ID id-TargetCellCRNTI                                                         CRITICALITY ignore      EXTENSION C-RNTI                                                                                PRESENCE optional               }|
        { ID id-TimeSinceFailure                                                CRITICALITY ignore      EXTENSION TimeSinceFailure                                                      PRESENCE optional               },
        ...
}


Hysteresis ::=                      INTEGER (0..30)

-- I

IAB-Authorized ::= ENUMERATED {
        authorized,
        not-authorized,
        ...
}

MobileIAB-MTUserLocationInformation ::= SEQUENCE {
        nRCGI                                                   NR-CGI,
        tAI                                                             TAI,
        iE-Extensions                                   ProtocolExtensionContainer { { MobileIAB-MTUserLocationInformation-ExtIEs} }    OPTIONAL,
        ...
}

MobileIAB-MTUserLocationInformation-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

IAB-Supported ::= ENUMERATED {
        true,
        ...
}

IABNodeIndication ::= ENUMERATED {
        true,
        ...
}

IMSVoiceSupportIndicator ::= ENUMERATED {
        supported,
        not-supported,
        ...
}

IndexToRFSP ::= INTEGER (1..256, ...)

InfoOnRecommendedCellsAndRANNodesForPaging ::= SEQUENCE {
        recommendedCellsForPaging               RecommendedCellsForPaging,
        recommendRANNodesForPaging              RecommendedRANNodesForPaging,
        iE-Extensions           ProtocolExtensionContainer { {InfoOnRecommendedCellsAndRANNodesForPaging-ExtIEs} }      OPTIONAL,
        ...
}

InfoOnRecommendedCellsAndRANNodesForPaging-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}


IntegrityProtectionIndication ::= ENUMERATED {
        required,
        preferred,
        not-needed,
        ...
}

IntegrityProtectionResult ::= ENUMERATED {
        performed,
        not-performed,
        ...
}

IntendedNumberOfPagingAttempts ::= INTEGER (1..16, ...)

InterfacesToTrace ::= BIT STRING (SIZE(8))

ImmediateMDTNr ::= SEQUENCE {
        measurementsToActivate                                  MeasurementsToActivate,
        m1Configuration                                                 M1Configuration                                         OPTIONAL,
-- The above IE shall be present if the Measurements to Activate IE has the first bit set to “1”
        m4Configuration                                                 M4Configuration                                         OPTIONAL,
-- The above IE shall be present if the Measurements to Activate IE has the third bit set to “1”
        m5Configuration                                                 M5Configuration                                         OPTIONAL,
-- The above IE shall be present if the Measurements to Activate IE has the fourth bit set to “1”
        m6Configuration                                                 M6Configuration                                         OPTIONAL,
-- The above IE shall be present if the Measurements to Activate IE has the fifth bit set to “1”
        m7Configuration                                                 M7Configuration                                         OPTIONAL,
-- The above IE shall be present if the Measurements to Activate IE has the sixth bit set to “1”
        bluetoothMeasurementConfiguration               BluetoothMeasurementConfiguration       OPTIONAL,
        wLANMeasurementConfiguration                    WLANMeasurementConfiguration            OPTIONAL,
        mDT-Location-Info                                               MDT-Location-Info                                       OPTIONAL,
        sensorMeasurementConfiguration                  SensorMeasurementConfiguration          OPTIONAL,
        iE-Extensions           ProtocolExtensionContainer { { ImmediateMDTNr-ExtIEs} } OPTIONAL,
        ...
}

ImmediateMDTNr-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

InterSystemFailureIndication ::= SEQUENCE {
        uERLFReportContainer            UERLFReportContainer    OPTIONAL,
        iE-Extensions                   ProtocolExtensionContainer { { InterSystemFailureIndication-ExtIEs} }                   OPTIONAL,
        ...
}

InterSystemFailureIndication-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

IntersystemSONConfigurationTransfer ::= SEQUENCE {
        transferType                            IntersystemSONTransferType,
        intersystemSONInformation       IntersystemSONInformation,
        iE-Extensions                   ProtocolExtensionContainer { { IntersystemSONConfigurationTransfer-ExtIEs} }                    OPTIONAL,
        ...
}

IntersystemSONConfigurationTransfer-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

IntersystemSONTransferType ::= CHOICE {
        fromEUTRANtoNGRAN                               FromEUTRANtoNGRAN,
        fromNGRANtoEUTRAN                               FromNGRANtoEUTRAN,
        choice-Extensions               ProtocolIE-SingleContainer { { IntersystemSONTransferType-ExtIEs} }
}

IntersystemSONTransferType-ExtIEs NGAP-PROTOCOL-IES ::= {
        ...
}

IntersystemSONeNBID ::= SEQUENCE {
        globaleNBID                             GlobalENB-ID,
        selectedEPSTAI                  EPS-TAI,
        iE-Extensions                   ProtocolExtensionContainer { { IntersystemSONeNBID-ExtIEs} }                    OPTIONAL,
        ...
}

IntersystemSONeNBID-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

IntersystemSONNGRANnodeID ::= SEQUENCE {
        globalRANNodeID         GlobalRANNodeID,
        selectedTAI                     TAI,
        iE-Extensions           ProtocolExtensionContainer { { IntersystemSONNGRANnodeID-ExtIEs} }                      OPTIONAL,
        ...
}

IntersystemSONNGRANnodeID-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

IntersystemSONInformation ::= CHOICE {
        intersystemSONInformationReport         IntersystemSONInformationReport,
        choice-Extensions               ProtocolIE-SingleContainer { { IntersystemSONInformation-ExtIEs} }
}

IntersystemSONInformation-ExtIEs NGAP-PROTOCOL-IES ::= {
        { ID id-IntersystemSONInformationRequest                CRITICALITY ignore      TYPE IntersystemSONInformationRequest                   PRESENCE mandatory }|
        { ID id-IntersystemSONInformationReply                  CRITICALITY ignore      TYPE IntersystemSONInformationReply                     PRESENCE mandatory },
        ...
}

-- --------------------------------------------------------------------
-- INTER SYSTEM SON INFORMATION REQUEST
-- --------------------------------------------------------------------

IntersystemSONInformationRequest ::= CHOICE {
        nGRAN-CellActivation            IntersystemCellActivationRequest,
        resourceStatus                          IntersystemResourceStatusRequest,
        choice-Extensions               ProtocolIE-SingleContainer { { IntersystemSONInformationRequest-ExtIEs} }
}

IntersystemSONInformationRequest-ExtIEs NGAP-PROTOCOL-IES ::= {
        ...
}

IntersystemCellActivationRequest ::= SEQUENCE {
        activationID                    INTEGER (0..16384, ...),
        cellsToActivateList             CellsToActivateList,
        iE-Extensions           ProtocolExtensionContainer { { IntersystemCellActivationRequest-ExtIEs} } OPTIONAL,
        ...
}

IntersystemCellActivationRequest-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

CellsToActivateList ::= SEQUENCE (SIZE(1..maxnoofCellsinNGRANNode)) OF NGRAN-CGI


-- --------------------------------------------------------------------
-- Inter System Resource Status Request
-- --------------------------------------------------------------------

IntersystemResourceStatusRequest ::= SEQUENCE {
        reportingSystem                         ReportingSystem,
        reportCharacteristics           ReportCharacteristics,
        reportType                                      ReportType,
        iE-Extensions           ProtocolExtensionContainer { { IntersystemResourceStatusRequest-ExtIEs} }       OPTIONAL,
        ...
}

IntersystemResourceStatusRequest-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

ReportingSystem ::= CHOICE {
        eUTRAN                  EUTRAN-ReportingSystemIEs,
        nGRAN                   NGRAN-ReportingSystemIEs,
        noReporting             NULL,
        choice-Extensions               ProtocolIE-SingleContainer { { ReportingSystem-ExtIEs}}
}

ReportingSystem-ExtIEs NGAP-PROTOCOL-IES ::= {
        ...
}

EUTRAN-ReportingSystemIEs::= SEQUENCE {
        eUTRAN-CellToReportList                         EUTRAN-CellToReportList,
        iE-Extensions           ProtocolExtensionContainer { {EUTRAN-ReportingSystemIEs-ExtIEs} } OPTIONAL,
        ...
}

EUTRAN-ReportingSystemIEs-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

NGRAN-ReportingSystemIEs ::= SEQUENCE {
        nGRAN-CellToReportList                          NGRAN-CellToReportList,
        iE-Extensions           ProtocolExtensionContainer { {NGRAN-ReportingSystemIEs-ExtIEs} } OPTIONAL,
        ...
}

NGRAN-ReportingSystemIEs-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

EUTRAN-CellToReportList ::= SEQUENCE (SIZE(1..maxnoofReportedCells)) OF EUTRAN-CellToReportItem

EUTRAN-CellToReportItem::= SEQUENCE {
        eCGI                            EUTRA-CGI,
        iE-Extensions           ProtocolExtensionContainer { {EUTRAN-CellToReportItem-ExtIEs} } OPTIONAL,
        ...
}

EUTRAN-CellToReportItem-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}


NGRAN-CellToReportList ::= SEQUENCE (SIZE(1.. maxnoofReportedCells)) OF NGRAN-CellToReportItem

NGRAN-CellToReportItem::= SEQUENCE {
        nGRAN-CGI                               NGRAN-CGI,
        iE-Extensions           ProtocolExtensionContainer { {NGRAN-CellToReportItem-ExtIEs} } OPTIONAL,
        ...
}

NGRAN-CellToReportItem-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

ReportCharacteristics ::=  BIT STRING(SIZE(32))

ReportType ::= CHOICE {
        eventBasedReporting             EventBasedReportingIEs,
        periodicReporting               PeriodicReportingIEs,
        choice-Extensions               ProtocolIE-SingleContainer { { ReportType-ExtIEs}}
}

ReportType-ExtIEs NGAP-PROTOCOL-IES ::= {
        ...
}

EventBasedReportingIEs ::= SEQUENCE {
        intersystemResourceThresholdLow                         IntersystemResourceThreshold,
        intersystemResourceThresholdHigh                                IntersystemResourceThreshold,
        numberOfMeasurementReportingLevels                              NumberOfMeasurementReportingLevels,
        iE-Extensions           ProtocolExtensionContainer { {EventBasedReportingIEs-ExtIEs} } OPTIONAL,
        ...
}

EventBasedReportingIEs-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

IntersystemResourceThreshold ::= INTEGER(0..100)

NumberOfMeasurementReportingLevels ::= ENUMERATED {n2, n3, n4, n5, n10, ..., n0}

PeriodicReportingIEs ::= SEQUENCE {
        reportingPeriodicity                    ReportingPeriodicity,
        iE-Extensions           ProtocolExtensionContainer { {PeriodicReportingIEs-ExtIEs} } OPTIONAL,
        ...
}

PeriodicReportingIEs-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

ReportingPeriodicity ::= ENUMERATED {
        stop,
        single,
        ms1000,
        ms2000,
        ms5000,
        ms10000,
        ...
}


-- --------------------------------------------------------------------
-- INTER SYSTEM SON INFORMATION REPLY
-- --------------------------------------------------------------------

IntersystemSONInformationReply ::= CHOICE {
        nGRAN-CellActivation            IntersystemCellActivationReply,
        resourceStatus                          IntersystemResourceStatusReply,
        choice-Extensions               ProtocolIE-SingleContainer { { IntersystemSONInformationReply-ExtIEs} }
}

IntersystemSONInformationReply-ExtIEs NGAP-PROTOCOL-IES ::= {
        ...
}

IntersystemCellActivationReply ::= SEQUENCE {
        activatedCellList               ActivatedCellList,
        activation-ID                   INTEGER(0..16384, ...),
        iE-Extensions                   ProtocolExtensionContainer { { IntersystemCellActivationReply-ExtIEs} } OPTIONAL,
        ...
}

IntersystemCellActivationReply-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

ActivatedCellList ::= SEQUENCE (SIZE(1..maxnoofCellsinNGRANNode)) OF NGRAN-CGI


-- --------------------------------------------------------------------
-- Inter System Resource Status Reply
-- --------------------------------------------------------------------

IntersystemResourceStatusReply ::= SEQUENCE {
        reportingsystem                         ReportingSystem,
        iE-Extensions           ProtocolExtensionContainer { { IntersystemResourceStatusReply-ExtIEs} }         OPTIONAL,
        ...
}

IntersystemResourceStatusReply-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}


-- --------------------------------------------------------------------
-- INTER SYSTEM SON INFORMATION REPORT
-- --------------------------------------------------------------------

IntersystemSONInformationReport::= CHOICE {
        hOReportInformation                             InterSystemHOReport,
        failureIndicationInformation    InterSystemFailureIndication,
        choice-Extensions               ProtocolIE-SingleContainer { { IntersystemSONInformationReport-ExtIEs} }
}

IntersystemSONInformationReport-ExtIEs NGAP-PROTOCOL-IES ::= {
        { ID id-EnergySavingIndication                          CRITICALITY ignore      TYPE IntersystemCellStateIndication                                             PRESENCE mandatory }|
        { ID id-IntersystemResourceStatusUpdate         CRITICALITY ignore      TYPE IntersystemResourceStatusReport                                    PRESENCE mandatory },
        ...
}

IntersystemCellStateIndication ::= SEQUENCE {
        notificationCellList    NotificationCellList,
        iE-Extensions           ProtocolExtensionContainer { { IntersystemCellStateIndication-ExtIEs} } OPTIONAL,
        ...
}

IntersystemCellStateIndication-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

NotificationCellList ::= SEQUENCE (SIZE(1.. maxnoofCellsinNGRANNode)) OF NotificationCell-Item

NotificationCell-Item ::= SEQUENCE {
        nGRAN-CGI                               NGRAN-CGI,
        notifyFlag                              ENUMERATED {activated, deactivated, ...},
        iE-Extensions           ProtocolExtensionContainer { { NotificationCell-Item-ExtIEs} } OPTIONAL,
        ...
}

NotificationCell-Item-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

-- --------------------------------------------------------------------
-- Inter System Resource Status Report
-- --------------------------------------------------------------------

IntersystemResourceStatusReport ::= SEQUENCE {
        reportingSystem         ResourceStatusReportingSystem,
        iE-Extensions                                   ProtocolExtensionContainer { { IntersystemResourceStatusReport-ExtIEs} }                OPTIONAL,
        ...
}

IntersystemResourceStatusReport-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

ResourceStatusReportingSystem ::= CHOICE {
        eUTRAN-ReportingStatus          EUTRAN-ReportingStatusIEs,
        nGRAN-ReportingStatus           NGRAN-ReportingStatusIEs,
        choice-Extensions                       ProtocolIE-SingleContainer { { ResourceStatusReportingSystem-ExtIEs}}
}

ResourceStatusReportingSystem-ExtIEs NGAP-PROTOCOL-IES ::= {
        ...
}

EUTRAN-ReportingStatusIEs::= SEQUENCE {
        eUTRAN-CellReportList                                           EUTRAN-CellReportList,
        iE-Extensions           ProtocolExtensionContainer { {EUTRAN-ReportingStatusIEs-ExtIEs} }       OPTIONAL,
        ...
}

EUTRAN-ReportingStatusIEs-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

EUTRAN-CellReportList ::= SEQUENCE (SIZE(1..maxnoofReportedCells)) OF EUTRAN-CellReportItem

EUTRAN-CellReportItem ::= SEQUENCE {
        eCGI                                                                            EUTRA-CGI,
        eUTRAN-CompositeAvailableCapacityGroup          EUTRAN-CompositeAvailableCapacityGroup,
        eUTRAN-NumberOfActiveUEs                                        EUTRAN-NumberOfActiveUEs                                        OPTIONAL,
        eUTRAN-NoofRRCConnections                                       NGRAN-NoofRRCConnections                                        OPTIONAL,
        eUTRAN-RadioResourceStatus                                      EUTRAN-RadioResourceStatus                                      OPTIONAL,
        iE-Extensions           ProtocolExtensionContainer { {EUTRAN-CellReportItem-ExtIEs} }           OPTIONAL,
        ...
}

EUTRAN-CellReportItem-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}


EUTRAN-CompositeAvailableCapacityGroup  ::= SEQUENCE {
        dL-CompositeAvailableCapacity                                   CompositeAvailableCapacity,
        uL-CompositeAvailableCapacity                                   CompositeAvailableCapacity,
        iE-Extensions           ProtocolExtensionContainer { { EUTRAN-CompositeAvailableCapacityGroup-ExtIEs} }         OPTIONAL,
        ...
}

EUTRAN-CompositeAvailableCapacityGroup-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

CompositeAvailableCapacity ::= SEQUENCE {
        cellCapacityClassValue          INTEGER (1..100, ...)                           OPTIONAL,
        capacityValue                           INTEGER (0..100),
        iE-Extensions           ProtocolExtensionContainer { {CompositeAvailableCapacity-ExtIEs} } OPTIONAL,
        ...
}

CompositeAvailableCapacity-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

EUTRAN-NumberOfActiveUEs ::= INTEGER (0..16777215, ...)

EUTRAN-RadioResourceStatus ::= SEQUENCE {
        dL-GBR-PRB-usage                                                        INTEGER (0..100),
        uL-GBR-PRB-usage                                                        INTEGER (0..100),
        dL-non-GBR-PRB-usage                                            INTEGER (0..100),
        uL-non-GBR-PRB-usage                                            INTEGER (0..100),
        dL-Total-PRB-usage                                                      INTEGER (0..100),
        uL-Total-PRB-usage                                                      INTEGER (0..100),
        dL-scheduling-PDCCH-CCE-usage                           INTEGER (0..100)        OPTIONAL,
        uL-scheduling-PDCCH-CCE-usage                           INTEGER (0..100)        OPTIONAL,
        iE-Extensions                                                           ProtocolExtensionContainer { {EUTRAN-RadioResourceStatus-ExtIEs} } OPTIONAL,
        ...
}

EUTRAN-RadioResourceStatus-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

NGRAN-ReportingStatusIEs ::= SEQUENCE {
        nGRAN-CellReportList                                            NGRAN-CellReportList,
        iE-Extensions           ProtocolExtensionContainer { {NGRAN-ReportingStatusIEs-ExtIEs} }        OPTIONAL,
        ...
}

NGRAN-ReportingStatusIEs-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

NGRAN-CellReportList ::= SEQUENCE (SIZE(1..maxnoofReportedCells)) OF NGRAN-CellReportItem

NGRAN-CellReportItem ::= SEQUENCE {
        nGRAN-CGI                                                                       NGRAN-CGI,
        nGRAN-CompositeAvailableCapacityGroup           EUTRAN-CompositeAvailableCapacityGroup,
        nGRAN-NumberOfActiveUEs                                         NGRAN-NumberOfActiveUEs                                         OPTIONAL,
        nGRAN-NoofRRCConnections                                        NGRAN-NoofRRCConnections                                        OPTIONAL,
        nGRAN-RadioResourceStatus                                       NGRAN-RadioResourceStatus                                       OPTIONAL,
        iE-Extensions           ProtocolExtensionContainer { {NGRAN-CellReportItem-ExtIEs} }            OPTIONAL,
        ...
}

NGRAN-CellReportItem-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}


NGRAN-NumberOfActiveUEs ::= INTEGER (0..16777215, ...)

NGRAN-NoofRRCConnections ::= INTEGER (1..65536, ...)

NGRAN-RadioResourceStatus       ::= SEQUENCE {
        dL-GBR-PRB-usage-for-MIMO                               INTEGER (0..100),
        uL-GBR-PRB-usage-for-MIMO                               INTEGER (0..100),
        dL-non-GBR-PRB-usage-for-MIMO                   INTEGER (0..100),
        uL-non-GBR-PRB-usage-for-MIMO                   INTEGER (0..100),
        dL-Total-PRB-usage-for-MIMO                             INTEGER (0..100),
        uL-Total-PRB-usage-for-MIMO                             INTEGER (0..100),
        iE-Extensions                                                   ProtocolExtensionContainer { { NGRAN-RadioResourceStatus-ExtIEs} }      OPTIONAL,
        ...
}

NGRAN-RadioResourceStatus-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

InterSystemHOReport ::= SEQUENCE {
        handoverReportType              InterSystemHandoverReportType,
        iE-Extensions                   ProtocolExtensionContainer { { InterSystemHOReport-ExtIEs} }                    OPTIONAL,
        ...
}

InterSystemHOReport-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

InterSystemHandoverReportType ::= CHOICE {
        tooearlyIntersystemHO                           TooearlyIntersystemHO,
        intersystemUnnecessaryHO                        IntersystemUnnecessaryHO,
        choice-Extensions               ProtocolIE-SingleContainer { { InterSystemHandoverReportType-ExtIEs} }
}

InterSystemHandoverReportType-ExtIEs NGAP-PROTOCOL-IES ::= {
        { ID id-IntersystemMobilityFailureforVoiceFallback  CRITICALITY ignore  TYPE  IntersystemMobilityFailureforVoiceFallback        PRESENCE mandatory },
        ...
}

IntersystemMobilityFailureforVoiceFallback ::= SEQUENCE {
        sourcecellID                            NGRAN-CGI,
        targetcellID                            EUTRA-CGI,
        reconnectCellID                 EUTRA-CGI                                               OPTIONAL,
        uERLFReportContainer            UERLFReportContainer                            OPTIONAL,
        iE-Extensions                   ProtocolExtensionContainer { { IntersystemMobilityFailureforVoiceFallback-ExtIEs} }                     OPTIONAL,
        ...
}

IntersystemMobilityFailureforVoiceFallback-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

IntersystemUnnecessaryHO ::= SEQUENCE {
        sourcecellID                    NGRAN-CGI,
        targetcellID                    EUTRA-CGI,
        earlyIRATHO                             ENUMERATED {true, false, ...},
        candidateCellList               CandidateCellList,
        iE-Extensions                   ProtocolExtensionContainer { { IntersystemUnnecessaryHO-ExtIEs} }                       OPTIONAL,
        ...
}

IntersystemUnnecessaryHO-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

-- J
-- K
-- L

LAC     ::= OCTET STRING (SIZE (2))

LAI ::= SEQUENCE {
        pLMNidentity            PLMNIdentity,
        lAC                                     LAC,
        iE-Extensions           ProtocolExtensionContainer { {LAI-ExtIEs} } OPTIONAL,
        ...
}

LAI-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

LastVisitedCellInformation ::= CHOICE {
        nGRANCell               LastVisitedNGRANCellInformation,
        eUTRANCell              LastVisitedEUTRANCellInformation,
        uTRANCell               LastVisitedUTRANCellInformation,
        gERANCell               LastVisitedGERANCellInformation,
        choice-Extensions               ProtocolIE-SingleContainer { {LastVisitedCellInformation-ExtIEs} }
}

LastVisitedCellInformation-ExtIEs NGAP-PROTOCOL-IES ::= {
        ...
}

LastVisitedCellItem ::= SEQUENCE {
        lastVisitedCellInformation              LastVisitedCellInformation,
        iE-Extensions           ProtocolExtensionContainer { {LastVisitedCellItem-ExtIEs} }     OPTIONAL,
        ...
}

LastVisitedCellItem-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

LastVisitedEUTRANCellInformation ::= OCTET STRING

LastVisitedGERANCellInformation ::= OCTET STRING

LastVisitedNGRANCellInformation::= SEQUENCE {
        globalCellID                                                            NGRAN-CGI,
        cellType                                                                        CellType,
        timeUEStayedInCell                                                      TimeUEStayedInCell,
        timeUEStayedInCellEnhancedGranularity           TimeUEStayedInCellEnhancedGranularity                   OPTIONAL,
        hOCauseValue                                                            Cause                                                                                   OPTIONAL,
        iE-Extensions           ProtocolExtensionContainer { {LastVisitedNGRANCellInformation-ExtIEs} } OPTIONAL,
        ...
}

LastVisitedNGRANCellInformation-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        { ID id-LastVisitedPSCellList   CRITICALITY ignore      EXTENSION LastVisitedPSCellList PRESENCE optional },
        ...
}

LastVisitedPSCellList ::= SEQUENCE (SIZE(1..maxnoofPSCellsPerPrimaryCellinUEHistoryInfo)) OF LastVisitedPSCellInformation

LastVisitedPSCellInformation ::= SEQUENCE {
        pSCellID                        NGRAN-CGI                               OPTIONAL,
        timeStay                        INTEGER (0..40950),
        iE-Extensions           ProtocolExtensionContainer { {LastVisitedPSCellInformation-ExtIEs} }    OPTIONAL,
        ...
}

LastVisitedPSCellInformation-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

LastVisitedUTRANCellInformation ::= OCTET STRING

LineType ::= ENUMERATED {
        dsl,
        pon,
        ...
}


LocationReportingAdditionalInfo ::= ENUMERATED {
        includePSCell,
        ...
}

LocationReportingReferenceID ::= INTEGER (1..64, ...)

LocationReportingRequestType ::= SEQUENCE {
        eventType                                                                               EventType,
        reportArea                                                                              ReportArea,
        areaOfInterestList                                                              AreaOfInterestList                                                              OPTIONAL,
        locationReportingReferenceIDToBeCancelled               LocationReportingReferenceID                                    OPTIONAL,
-- The above IE shall be present if the Event Type IE is set to the value “stop UE presence in the area of interest”
        iE-Extensions           ProtocolExtensionContainer { {LocationReportingRequestType-ExtIEs} }            OPTIONAL,
        ...
}

LocationReportingRequestType-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        { ID id-LocationReportingAdditionalInfo CRITICALITY ignore      EXTENSION LocationReportingAdditionalInfo               PRESENCE optional }|
        { ID id-AdditionalCancelledlocationReportingReferenceIDList     CRITICALITY reject      EXTENSION AdditionalCancelledlocationReportingReferenceIDList  PRESENCE optional },
        ...
}

LoggedMDTNr ::= SEQUENCE {
        loggingInterval                                         LoggingInterval,
        loggingDuration                                         LoggingDuration,
        loggedMDTTrigger                                        LoggedMDTTrigger,
        bluetoothMeasurementConfiguration       BluetoothMeasurementConfiguration       OPTIONAL,
        wLANMeasurementConfiguration            WLANMeasurementConfiguration            OPTIONAL,
        sensorMeasurementConfiguration          SensorMeasurementConfiguration          OPTIONAL,
        areaScopeOfNeighCellsList                       AreaScopeOfNeighCellsList                       OPTIONAL,
        iE-Extensions           ProtocolExtensionContainer { {LoggedMDTNr-ExtIEs} } OPTIONAL,
        ...
}

LoggedMDTNr-ExtIEs      NGAP-PROTOCOL-EXTENSION ::= {
        { ID id-EarlyMeasurement                CRITICALITY ignore      EXTENSION EarlyMeasurement              PRESENCE optional       },
        ...
}

LoggingInterval ::= ENUMERATED {
        ms320, ms640, ms1280, ms2560, ms5120, ms10240, ms20480, ms30720, ms40960, ms61440,
        infinity,
        ...
}

LoggingDuration ::= ENUMERATED {m10, m20, m40, m60, m90, m120, ...}

Links-to-log ::= ENUMERATED {
        uplink,
        downlink,
        both-uplink-and-downlink,
        ...
}

LoggedMDTTrigger ::= CHOICE{
        periodical                      NULL,
        eventTrigger                    EventTrigger,
        choice-Extensions               ProtocolIE-SingleContainer { {LoggedMDTTrigger-ExtIEs} }
}

LoggedMDTTrigger-ExtIEs NGAP-PROTOCOL-IES ::= {
        ...
}

LTEM-Indication ::= ENUMERATED {lte-m,...}

LTEUERLFReportContainer ::= OCTET STRING

LTEV2XServicesAuthorized ::= SEQUENCE {
        vehicleUE                       VehicleUE                                                                                                                       OPTIONAL,
        pedestrianUE            PedestrianUE                                                                                                            OPTIONAL,
        iE-Extensions           ProtocolExtensionContainer { {LTEV2XServicesAuthorized-ExtIEs} }        OPTIONAL,
        ...
}

LTEV2XServicesAuthorized-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

LTEUESidelinkAggregateMaximumBitrate ::= SEQUENCE {
        uESidelinkAggregateMaximumBitRate               BitRate,
        iE-Extensions           ProtocolExtensionContainer { {LTEUE-Sidelink-Aggregate-MaximumBitrates-ExtIEs} } OPTIONAL,
        ...
}

LTEUE-Sidelink-Aggregate-MaximumBitrates-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

LTE-A2X-ServicesAuthorized ::= SEQUENCE {
        aerialUE                                                                ENUMERATED {authorized, not-authorized, ...}            OPTIONAL,
        aerialControllerUE                                              ENUMERATED {authorized, not-authorized, ...}            OPTIONAL,
        iE-Extensions           ProtocolExtensionContainer { {LTE-A2X-ServicesAuthorized-ExtIEs} }              OPTIONAL,
        ...
}

LTE-A2X-ServicesAuthorized-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

-- M

MaskedIMEISV ::= BIT STRING (SIZE(64))

MaximumDataBurstVolume ::= INTEGER (0..4095, ..., 4096.. 2000000)

MessageIdentifier ::= BIT STRING (SIZE(16))

MaximumIntegrityProtectedDataRate ::= ENUMERATED {
        bitrate64kbs,
        maximum-UE-rate,
        ...
}


MBS-AreaSessionID ::= INTEGER (0..65535, ...)

MBSCommServiceType ::= ENUMERATED {broadcast, multicast, ...}

MBS-DataForwardingResponseMRBList ::= SEQUENCE (SIZE(1..maxnoofMRBs)) OF MBS-DataForwardingResponseMRBItem

MBS-DataForwardingResponseMRBItem ::= SEQUENCE {
        mRB-ID                                                          MRB-ID,
        dL-Forwarding-UPTNLInformation          UPTransportLayerInformation,
        mRB-ProgressInformation                         MRB-ProgressInformation                 OPTIONAL,
        iE-Extensions                                           ProtocolExtensionContainer { { MBS-DataForwardingResponseMRBItem-ExtIEs} }      OPTIONAL,
        ...
}

MBS-DataForwardingResponseMRBItem-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

MBS-MappingandDataForwardingRequestList ::= SEQUENCE (SIZE(1..maxnoofMRBs)) OF MBS-MappingandDataForwardingRequestItem

MBS-MappingandDataForwardingRequestItem ::= SEQUENCE {
        mRB-ID                                                          MRB-ID,
        mBS-QoSFlowList                                         MBS-QoSFlowList,
        mRB-ProgressInformation                         MRB-ProgressInformation                         OPTIONAL,
        iE-Extensions           ProtocolExtensionContainer { { MBS-MappingandDataForwardingRequestItem-ExtIEs} }        OPTIONAL,
        ...
}

MBS-MappingandDataForwardingRequestItem-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

MBS-QoSFlowList ::= SEQUENCE (SIZE(1..maxnoofMBSQoSFlows)) OF QosFlowIdentifier

MRB-ProgressInformation ::= CHOICE {
        pDCP-SN-Length12                                INTEGER (0..4095),
        pDCP-SN-Length18                                INTEGER (0..262143),
        choice-Extensions               ProtocolIE-SingleContainer { { MRB-ProgressInformation-ExtIEs} }
}

MRB-ProgressInformation-ExtIEs NGAP-PROTOCOL-IES ::= {
        ...
}

MBS-QoSFlowsToBeSetupList ::= SEQUENCE (SIZE(1.. maxnoofMBSQoSFlows)) OF MBS-QoSFlowsToBeSetupItem

MBS-QoSFlowsToBeSetupItem ::= SEQUENCE {
        mBSqosFlowIdentifier                            QosFlowIdentifier,
        mBSqosFlowLevelQosParameters            QosFlowLevelQosParameters,
        iE-Extensions                                           ProtocolExtensionContainer { {MBS-QoSFlowsToBeSetupItem-ExtIEs} }       OPTIONAL,
        ...
}

MBS-QoSFlowsToBeSetupItem-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}


MBS-ServiceArea ::= CHOICE {
        locationindependent             MBS-ServiceAreaInformation,
        locationdependent               MBS-ServiceAreaInformationList,
        choice-Extensions               ProtocolIE-SingleContainer { {MBS-ServiceArea-ExtIEs} }
}

MBS-ServiceArea-ExtIEs NGAP-PROTOCOL-IES ::= {
        ...
}

MBS-ServiceAreaInformationList ::= SEQUENCE (SIZE(1..maxnoofMBSServiceAreaInformation)) OF MBS-ServiceAreaInformationItem


MBS-ServiceAreaInformationItem ::= SEQUENCE {
        mBS-AreaSessionID                               MBS-AreaSessionID,
        mBS-ServiceAreaInformation              MBS-ServiceAreaInformation,
        iE-Extensions                                   ProtocolExtensionContainer { {MBS-ServiceAreaInformationItem-ExtIEs} }  OPTIONAL,
        ...
}

MBS-ServiceAreaInformationItem-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

MBS-ServiceAreaInformation ::= SEQUENCE {
        mBS-ServiceAreaCellList         MBS-ServiceAreaCellList                                                                                                                         OPTIONAL,
        mBS-ServiceAreaTAIList          MBS-ServiceAreaTAIList                                                                                                                          OPTIONAL,
        iE-Extensions                                   ProtocolExtensionContainer { {MBS-ServiceAreaInformation-ExtIEs} }      OPTIONAL,
        ...
}

MBS-ServiceAreaInformation-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

MBS-ServiceAreaCellList ::= SEQUENCE (SIZE(1.. maxnoofCellsforMBS)) OF NR-CGI

MBS-ServiceAreaTAIList ::= SEQUENCE (SIZE(1.. maxnoofTAIforMBS)) OF TAI

MBS-SessionID ::= SEQUENCE {
        tMGI                                                            TMGI,
        nID                                                             NID                                                                                                                                                     OPTIONAL,
        iE-Extensions                                   ProtocolExtensionContainer { {MBS-SessionID-ExtIEs} }           OPTIONAL,
        ...
}

MBS-SessionID-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

MBSSessionFailedtoSetupList ::= SEQUENCE (SIZE(1.. maxnoofMBSSessions)) OF MBSSessionFailedtoSetupItem

MBSSessionFailedtoSetupItem ::= SEQUENCE {
        mBS-SessionID                   MBS-SessionID,
        mBS-AreaSessionID               MBS-AreaSessionID                                                                                                                       OPTIONAL,
        cause                                   Cause,
        iE-Extensions                   ProtocolExtensionContainer { { MBSSessionFailedtoSetupItem-ExtIEs} }            OPTIONAL,
        ...
}

MBSSessionFailedtoSetupItem-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

MBS-ActiveSessionInformation-SourcetoTargetList ::= SEQUENCE (SIZE(1..maxnoofMBSSessionsofUE)) OF MBS-ActiveSessionInformation-SourcetoTargetItem

MBS-ActiveSessionInformation-SourcetoTargetItem ::= SEQUENCE {
        mBS-SessionID                                                           MBS-SessionID,
        mBS-AreaSessionID                                                       MBS-AreaSessionID                                                       OPTIONAL,
        mBS-ServiceArea                                                         MBS-ServiceArea                                                         OPTIONAL,
        mBS-QoSFlowsToBeSetupList                                       MBS-QoSFlowsToBeSetupList,
        mBS-MappingandDataForwardingRequestList         MBS-MappingandDataForwardingRequestList         OPTIONAL,
        iE-Extensions           ProtocolExtensionContainer { { MBS-ActiveSessionInformation-SourcetoTargetItem-ExtIEs} }        OPTIONAL,
        ...
}

MBS-ActiveSessionInformation-SourcetoTargetItem-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

MBS-ActiveSessionInformation-TargettoSourceList ::= SEQUENCE (SIZE(1..maxnoofMBSSessionsofUE)) OF MBS-ActiveSessionInformation-TargettoSourceItem

MBS-ActiveSessionInformation-TargettoSourceItem ::= SEQUENCE {
        mBS-SessionID                                           MBS-SessionID,
        mBS-DataForwardingResponseMRBList       MBS-DataForwardingResponseMRBList                                                                                                       OPTIONAL,
        iE-Extensions           ProtocolExtensionContainer { { MBS-ActiveSessionInformation-TargettoSourceItem-ExtIEs} }                OPTIONAL,
        ...
}

MBS-ActiveSessionInformation-TargettoSourceItem-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

MBS-AssistanceInformation ::= ENUMERATED {true, ...}

MBSSessionSetupOrModFailureTransfer ::= SEQUENCE {
        cause                                           Cause,
        criticalityDiagnostics          CriticalityDiagnostics          OPTIONAL,
        iE-Extensions           ProtocolExtensionContainer { { MBSSessionSetupOrModFailureTransfer-ExtIEs} }    OPTIONAL,
        ...
}

MBSSessionSetupOrModFailureTransfer-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

MBSSessionSetupResponseList ::= SEQUENCE (SIZE(1.. maxnoofMBSSessions)) OF MBSSessionSetupResponseItem

MBSSessionSetupResponseItem ::= SEQUENCE {
        mBS-SessionID                   MBS-SessionID,
        mBS-AreaSessionID               MBS-AreaSessionID                                                                                                       OPTIONAL,
        iE-Extensions           ProtocolExtensionContainer { { MBSSessionSetupResponseItem-ExtIEs} }    OPTIONAL,
        ...
}

MBSSessionSetupResponseItem-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

MBSSessionSetupOrModRequestTransfer ::= SEQUENCE {
        protocolIEs             ProtocolIE-Container            { {MBSSessionSetupOrModRequestTransferIEs} },
        ...
}

MBSSessionSetupOrModRequestTransferIEs NGAP-PROTOCOL-IES ::= {
        { ID id-MBS-SessionTNLInfo5GC                           CRITICALITY reject      TYPE MBS-SessionTNLInfo5GC                              PRESENCE        optional                }|
        { ID id-MBS-QoSFlowsToBeSetupModList            CRITICALITY reject      TYPE MBS-QoSFlowsToBeSetupList          PRESENCE        mandatory       }|
        { ID id-MBS-SessionFSAIDList                            CRITICALITY ignore      TYPE MBS-SessionFSAIDList                               PRESENCE        optional                }|
        { ID id-SupportedUETypeList                                     CRITICALITY ignore      TYPE SupportedUETypeList                                PRESENCE        optional                }|
        { ID id-MBS-NGUFailureIndication                        CRITICALITY reject      TYPE MBS-NGUFailureIndication                   PRESENCE        optional                },
        ...
}
SupportedUETypeList ::= SEQUENCE (SIZE(1.. maxnoofUETypes)) OF SupportedUEType

SupportedUEType ::= ENUMERATED {non-RedCap-UE, redCap-UE, ...}

MBS-SessionFSAIDList ::= SEQUENCE (SIZE(1.. maxnoofMBSFSAs)) OF MBS-SessionFSAID

MBS-SessionFSAID ::= OCTET STRING (SIZE(3))

MBSSessionReleaseResponseTransfer ::= SEQUENCE {
        mBS-SessionTNLInfoNGRAN         MBS-SessionTNLInfoNGRAN                         OPTIONAL,
        iE-Extensions           ProtocolExtensionContainer { {MBSSessionReleaseResponseTransfer-ExtIEs} }       OPTIONAL,
        ...
}

MBSSessionReleaseResponseTransfer-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

MBSSessionSetupOrModResponseTransfer ::= SEQUENCE {
        mBS-SessionTNLInfoNGRAN         MBS-SessionTNLInfoNGRAN                                                                                                         OPTIONAL,
        iE-Extensions           ProtocolExtensionContainer { {MBSSessionSetupOrModResponseTransfer-ExtIEs} }            OPTIONAL,
        ...
}

MBSSessionSetupOrModResponseTransfer-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

MBS-SupportIndicator ::= ENUMERATED {
        multicast-supported,
        ...,
        multicast-supported-with-reception-in-RRC-inactive
}

MBS-SessionTNLInfo5GC ::= CHOICE {
        locationindependent                     SharedNGU-MulticastTNLInformation,
        locationdependent                       MBS-SessionTNLInfo5GCList,
        choice-Extensions               ProtocolIE-SingleContainer { {MBS-SessionTNLInfo5GC-ExtIEs} }
}

MBS-SessionTNLInfo5GC-ExtIEs NGAP-PROTOCOL-IES ::= {
        ...
}

MBS-SessionTNLInfo5GCList ::= SEQUENCE (SIZE(1..maxnoofMBSServiceAreaInformation)) OF MBS-SessionTNLInfo5GCItem

MBS-SessionTNLInfo5GCItem ::= SEQUENCE {
        mBS-AreaSessionID                                               MBS-AreaSessionID,
        sharedNGU-MulticastTNLInformation               SharedNGU-MulticastTNLInformation,
        iE-Extensions           ProtocolExtensionContainer { {MBS-SessionTNLInfo5GCItem-ExtIEs} }       OPTIONAL,
        ...
}

MBS-SessionTNLInfo5GCItem-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

MBS-SessionTNLInfoNGRAN ::= CHOICE {
        locationindependent                     UPTransportLayerInformation,
        locationdependent                       MBS-SessionTNLInfoNGRANList,
        choice-Extensions               ProtocolIE-SingleContainer { {MBS-SessionTNLInfoNGRAN-ExtIEs} }
}

MBS-SessionTNLInfoNGRAN-ExtIEs NGAP-PROTOCOL-IES ::= {
        ...
}

MBS-SessionTNLInfoNGRANList ::= SEQUENCE (SIZE(1..maxnoofMBSServiceAreaInformation)) OF MBS-SessionTNLInfoNGRANItem

MBS-SessionTNLInfoNGRANItem ::= SEQUENCE {
        mBS-AreaSessionID                                       MBS-AreaSessionID,
        sharedNGU-UnicastTNLInformation         UPTransportLayerInformation                                                             OPTIONAL,
        iE-Extensions           ProtocolExtensionContainer { {MBS-SessionTNLInfoNGRANItem-ExtIEs} }     OPTIONAL,
        ...
}

MBS-SessionTNLInfoNGRANItem-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

MBS-DistributionReleaseRequestTransfer ::= SEQUENCE {
        mBS-SessionID                                                   MBS-SessionID,
        mBS-AreaSessionID                                               MBS-AreaSessionID                                                                                               OPTIONAL,
        sharedNGU-UnicastTNLInformation                 UPTransportLayerInformation                                                                             OPTIONAL,
        cause                                                                   Cause,
        iE-Extensions           ProtocolExtensionContainer { { MBS-DistributionReleaseRequesTransfer-ExtIEs} }  OPTIONAL,
        ...
}

MBS-DistributionReleaseRequesTransfer-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

MBS-DistributionSetupRequestTransfer ::= SEQUENCE {
        mBS-SessionID                                                   MBS-SessionID,
        mBS-AreaSessionID                                               MBS-AreaSessionID                                                                                               OPTIONAL,
        sharedNGU-UnicastTNLInformation                 UPTransportLayerInformation                                                                             OPTIONAL,
        iE-Extensions           ProtocolExtensionContainer { { MBS-DistributionSetupRequestTransfer-ExtIEs} }   OPTIONAL,
        ...
}

MBS-DistributionSetupRequestTransfer-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

MBS-DistributionSetupResponseTransfer ::= SEQUENCE {
        mBS-SessionID                                                           MBS-SessionID,
        mBS-AreaSessionID                                                       MBS-AreaSessionID                                               OPTIONAL,
        sharedNGU-MulticastTNLInformation                       SharedNGU-MulticastTNLInformation               OPTIONAL,
        mBS-QoSFlowsToBeSetupList                                       MBS-QoSFlowsToBeSetupList,
        mBSSessionStatus                                                        MBSSessionStatus,
        mBS-ServiceArea                                                         MBS-ServiceArea                                                 OPTIONAL,
        iE-Extensions           ProtocolExtensionContainer { {MBS-DistributionSetupResponseTransfer-ExtIEs} }   OPTIONAL,
        ...
}

MBS-DistributionSetupResponseTransfer-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}


MBS-DistributionSetupUnsuccessfulTransfer ::= SEQUENCE {
        mBS-SessionID                           MBS-SessionID,
        mBS-AreaSessionID                       MBS-AreaSessionID                                                                                                                                       OPTIONAL,
        cause                                           Cause,
        criticalityDiagnostics          CriticalityDiagnostics                                                                                                                          OPTIONAL,
        iE-Extensions           ProtocolExtensionContainer { { MBS-DistributionSetupUnsuccessfulTransfer-ExtIEs} }      OPTIONAL,
        ...
}

MBS-DistributionSetupUnsuccessfulTransfer-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

MBS-NGUFailureIndication ::= CHOICE {
        locationindependent                     MBS-UP-FailureIndication,
        locationdependent                       MBS-UP-FailureIndicationList,
        choice-Extensions               ProtocolIE-SingleContainer { {MBS-NGUFailureIndication-ExtIEs} }
}

MBS-NGUFailureIndication-ExtIEs NGAP-PROTOCOL-IES ::= {
        ...
}

MBS-UP-FailureIndicationList ::= SEQUENCE (SIZE(1..maxnoofMBSServiceAreaInformation)) OF MBS-UP-FailureIndicationItem

MBS-UP-FailureIndicationItem ::= SEQUENCE {
        mBS-AreaSessionID                                       MBS-AreaSessionID,
        mBS-UP-FailureIndication                        MBS-UP-FailureIndication,
        iE-Extensions           ProtocolExtensionContainer { {MBS-UP-FailureIndicationItem-ExtIEs} }    OPTIONAL,
        ...
}

MBS-UP-FailureIndicationItem-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

MBS-UP-FailureIndication ::= ENUMERATED {ng-u-path-failure-detected, ...}

MBSSessionSetupRequestList ::= SEQUENCE (SIZE(1..maxnoofMBSSessions)) OF MBSSessionSetupRequestItem

MBSSessionSetupRequestItem ::= SEQUENCE {
        mBS-SessionID                                                                   MBS-SessionID,
        mBS-AreaSessionID                                                               MBS-AreaSessionID                                                                                                                                       OPTIONAL,
        associatedMBSQosFlowSetupRequestList                    AssociatedMBSQosFlowSetupRequestList                                                                                            OPTIONAL,
        iE-Extensions                                                                   ProtocolExtensionContainer { { MBSSessionSetupRequestItem-ExtIEs} }             OPTIONAL,
        ...
}

MBSSessionSetupRequestItem-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        { ID id-MBS-AssistanceInformation                       CRITICALITY ignore      EXTENSION MBS-AssistanceInformation             PRESENCE        optional                },
        ...
}

MBSSessionSetuporModifyRequestList ::= SEQUENCE (SIZE(1..maxnoofMBSSessions)) OF MBSSessionSetuporModifyRequestItem

MBSSessionSetuporModifyRequestItem ::= SEQUENCE {
        mBS-SessionID                                                                           MBS-SessionID,
        mBS-AreaSessionID                                                                       MBS-AreaSessionID                                                                       OPTIONAL,
        associatedMBSQosFlowSetuporModifyRequestList            AssociatedMBSQosFlowSetuporModifyRequestList            OPTIONAL,
        mBS-QosFlowToReleaseList                                                        QosFlowListWithCause                                                            OPTIONAL,
        iE-Extensions           ProtocolExtensionContainer {{MBSSessionSetuporModifyRequestItem-ExtIEs}}                        OPTIONAL,
        ...
}

MBSSessionSetuporModifyRequestItem-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        { ID id-MBS-AssistanceInformation                       CRITICALITY ignore      EXTENSION MBS-AssistanceInformation             PRESENCE        optional                },
        ...
}


MBSSessionToReleaseList ::= SEQUENCE (SIZE(1..maxnoofMBSSessions)) OF MBSSessionToReleaseItem

MBSSessionToReleaseItem ::= SEQUENCE {
        mBS-SessionID           MBS-SessionID,
        cause                           Cause,
        iE-Extensions           ProtocolExtensionContainer { { MBSSessionToReleaseItem-ExtIEs} }        OPTIONAL,
        ...
}

MBSSessionToReleaseItem-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

MBSSessionStatus ::= ENUMERATED {
        activated,
        deactivated,
        ...
}

MicoAllPLMN ::= ENUMERATED {
        true,
        ...
}


MICOModeIndication ::= ENUMERATED {
        true,
        ...
}

MobilityInformation ::= BIT STRING (SIZE(16))

ExtendedMobilityInformation ::= BIT STRING (SIZE(32))

MobilityRestrictionList ::= SEQUENCE {
        servingPLMN                                     PLMNIdentity,
        equivalentPLMNs                         EquivalentPLMNs                                                                                 OPTIONAL,
        rATRestrictions                         RATRestrictions                                                                                 OPTIONAL,
        forbiddenAreaInformation        ForbiddenAreaInformation                                                                OPTIONAL,
        serviceAreaInformation          ServiceAreaInformation                                                                  OPTIONAL,
        iE-Extensions           ProtocolExtensionContainer { {MobilityRestrictionList-ExtIEs} } OPTIONAL,
        ...
}

MobilityRestrictionList-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        { ID id-LastEUTRAN-PLMNIdentity                         CRITICALITY ignore      EXTENSION PLMNIdentity                                                          PRESENCE optional               }|
        { ID id-CNTypeRestrictionsForServing            CRITICALITY ignore      EXTENSION CNTypeRestrictionsForServing                  PRESENCE optional               }|
        { ID id-CNTypeRestrictionsForEquivalent         CRITICALITY ignore      EXTENSION CNTypeRestrictionsForEquivalent               PRESENCE optional               }|
        { ID id-NPN-MobilityInformation                         CRITICALITY reject      EXTENSION NPN-MobilityInformation                               PRESENCE optional               },
        ...
}

MDT-AlignmentInfo ::= CHOICE {
        s-basedMDT                              NGRANTraceID,
        choice-Extensions               ProtocolIE-SingleContainer { { MDT-AlignmentInfo-ExtIEs} }
}

MDT-AlignmentInfo-ExtIEs NGAP-PROTOCOL-IES ::= {
        ...
}

MDTPLMNList ::= SEQUENCE (SIZE(1..maxnoofMDTPLMNs)) OF PLMNIdentity

MDTPLMNModificationList ::= SEQUENCE (SIZE(0..maxnoofMDTPLMNs)) OF PLMNIdentity

MDT-Configuration ::= SEQUENCE {
        mdt-Config-NR           MDT-Configuration-NR            OPTIONAL,
        mdt-Config-EUTRA        MDT-Configuration-EUTRA         OPTIONAL,
        iE-Extensions           ProtocolExtensionContainer { { MDT-Configuration-ExtIEs} } OPTIONAL,
        ...
}

MDT-Configuration-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        { ID id-MN-only-MDT-collection          CRITICALITY ignore      EXTENSION MN-only-MDT-collection                PRESENCE optional               },
        ...
}

MN-only-MDT-collection ::= ENUMERATED {mn-only, ...}

MDT-Configuration-NR ::= SEQUENCE {
        mdt-Activation                          MDT-Activation,
        areaScopeOfMDT                          AreaScopeOfMDT-NR,
        mDTModeNr                                       MDTModeNr,
        signallingBasedMDTPLMNList      MDTPLMNList                                                                                             OPTIONAL,
        iE-Extensions           ProtocolExtensionContainer { { MDT-Configuration-NR-ExtIEs} }   OPTIONAL,
        ...
}

MDT-Configuration-NR-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        { ID id-PNI-NPN-AreaScopeofMDT          CRITICALITY ignore      EXTENSION PNI-NPN-AreaScopeofMDT                PRESENCE optional               },
        ...
}

MDT-Configuration-EUTRA ::= SEQUENCE {
        mdt-Activation                          MDT-Activation,
        areaScopeOfMDT                          AreaScopeOfMDT-EUTRA,
        mDTMode                                         MDTModeEutra,
        signallingBasedMDTPLMNList      MDTPLMNList                                                                                                     OPTIONAL,
        iE-Extensions           ProtocolExtensionContainer { { MDT-Configuration-EUTRA-ExtIEs} }        OPTIONAL,
        ...
}

MDT-Configuration-EUTRA-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

MDT-Activation  ::= ENUMERATED {
        immediate-MDT-only,
        logged-MDT-only,
        immediate-MDT-and-Trace,
        ...
}

MDTModeNr ::= CHOICE {
        immediateMDTNr                          ImmediateMDTNr,
        loggedMDTNr                                     LoggedMDTNr,
        choice-Extensions               ProtocolIE-SingleContainer { {MDTModeNr-ExtIEs} }
}

MDTModeNr-ExtIEs NGAP-PROTOCOL-IES ::= {
        ...
}

MDTModeEutra ::= OCTET STRING

MeasurementsToActivate ::= BIT STRING(SIZE(8))

MobileIAB-Authorized ::= ENUMERATED {
        authorized,
        not-authorized,
        ...
}

MobileIABNodeIndication ::= ENUMERATED {
        true,
        ...
}

MobileIAB-Supported ::= ENUMERATED {
        true,
        ...
}

MRB-ID ::= INTEGER (1..512, ...)

MulticastSessionActivationRequestTransfer ::= SEQUENCE {
        mBS-SessionID                           MBS-SessionID,
        iE-Extensions                           ProtocolExtensionContainer { { MulticastSessionActivationRequestTransfer-ExtIEs} }      OPTIONAL,
        ...
}

MulticastSessionActivationRequestTransfer-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

MulticastSessionDeactivationRequestTransfer ::= SEQUENCE {
        mBS-SessionID                           MBS-SessionID,
        iE-Extensions                           ProtocolExtensionContainer { { MulticastSessionDeactivationRequestTransfer-ExtIEs} }    OPTIONAL,
        ...
}

MulticastSessionDeactivationRequestTransfer-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

MulticastSessionUpdateRequestTransfer ::= SEQUENCE {
        protocolIEs             ProtocolIE-Container            { {MulticastSessionUpdateRequestTransferIEs} },
        ...
}

MulticastSessionUpdateRequestTransferIEs NGAP-PROTOCOL-IES ::= {
        { ID id-MBS-SessionID                                           CRITICALITY reject      TYPE MBS-SessionID                                              PRESENCE mandatory      }|
        { ID id-MBS-ServiceArea                                         CRITICALITY reject      TYPE MBS-ServiceArea                                    PRESENCE        optional                }|
        { ID id-MBS-QoSFlowsToBeSetupModList            CRITICALITY reject      TYPE MBS-QoSFlowsToBeSetupList          PRESENCE        optional                }|
        { ID id-MBS-QoSFlowToReleaseList                        CRITICALITY reject      TYPE QosFlowListWithCause                               PRESENCE        optional                }|
        { ID id-MBS-SessionTNLInfo5GC                           CRITICALITY reject      TYPE MBS-SessionTNLInfo5GC                              PRESENCE        optional                },
        ...
}


MulticastGroupPagingAreaList ::= SEQUENCE (SIZE(1..maxnoofPagingAreas)) OF MulticastGroupPagingAreaItem

MulticastGroupPagingAreaItem ::= SEQUENCE {
        multicastGroupPagingArea                MulticastGroupPagingArea,
        uE-PagingList                                   UE-PagingList                                                                                           OPTIONAL,
        iE-Extensions           ProtocolExtensionContainer { { MulticastGroupPagingAreaItem-ExtIEs} }   OPTIONAL,
        ...
}

MulticastGroupPagingAreaItem-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

MBS-AreaTAIList ::= SEQUENCE (SIZE(1..maxnoofTAIforPaging)) OF TAI

MulticastGroupPagingArea ::= SEQUENCE {
        mBS-AreaTAIList         MBS-AreaTAIList,
        iE-Extensions           ProtocolExtensionContainer { { MulticastGroupPagingArea-ExtIEs} } OPTIONAL,
        ...
}

MulticastGroupPagingArea-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

UE-PagingList ::= SEQUENCE (SIZE(1..maxnoofUEsforPaging)) OF UE-PagingItem

UE-PagingItem ::= SEQUENCE {
        uEIdentityIndexValue            UEIdentityIndexValue,
        pagingDRX                                       PagingDRX                                                                               OPTIONAL,
        iE-Extensions           ProtocolExtensionContainer { { UE-PagingItem-ExtIEs} }  OPTIONAL,
        ...
}

UE-PagingItem-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

M1Configuration ::= SEQUENCE {
        m1reportingTrigger                      M1ReportingTrigger,
        m1thresholdEventA2                      M1ThresholdEventA2                                                                      OPTIONAL,
--      The above IE shall be present if the M1 Reporting Trigger IE is set to the value “A2event-triggered” or “A2event-triggered periodic”
        m1periodicReporting                     M1PeriodicReporting                                                                     OPTIONAL,
--      The above IE shall be present if the M1 Reporting Trigger IE is set to the value “periodic” or “A2event-triggered periodic”
        iE-Extensions           ProtocolExtensionContainer { { M1Configuration-ExtIEs} }        OPTIONAL,
        ...
}

M1Configuration-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        { ID id-IncludeBeamMeasurementsIndication               CRITICALITY ignore      EXTENSION IncludeBeamMeasurementsIndication             PRESENCE optional                       }|
        { ID id-BeamMeasurementsReportConfiguration             CRITICALITY ignore      EXTENSION BeamMeasurementsReportConfiguration   PRESENCE conditional            },
-- The above IE shall be present if the Include Beam Measurements Indication IE is set to the value “true”
        ...
}

IncludeBeamMeasurementsIndication ::= ENUMERATED {
        true,
        ...
}

MaxNrofRS-IndexesToReport ::= INTEGER (1..64, ...)

M1ReportingTrigger ::= ENUMERATED {
        periodic,
        a2eventtriggered,
        a2eventtriggered-periodic,
        ...
}

M1ThresholdEventA2 ::= SEQUENCE {
        m1ThresholdType         M1ThresholdType,
        iE-Extensions           ProtocolExtensionContainer { { M1ThresholdEventA2-ExtIEs} } OPTIONAL,
        ...
}

M1ThresholdEventA2-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

M1ThresholdType ::= CHOICE {
        threshold-RSRP                          Threshold-RSRP,
        threshold-RSRQ                          Threshold-RSRQ,
        threshold-SINR                          Threshold-SINR,
        choice-Extensions               ProtocolIE-SingleContainer { {M1ThresholdType-ExtIEs} }
}

M1ThresholdType-ExtIEs NGAP-PROTOCOL-IES ::= {
        ...
}

M1PeriodicReporting ::= SEQUENCE {
        reportInterval                          ReportIntervalMDT,
        reportAmount                            ReportAmountMDT,
        iE-Extensions           ProtocolExtensionContainer { { M1PeriodicReporting-ExtIEs} } OPTIONAL,
        ...
}

M1PeriodicReporting-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        {ID id-ExtendedReportIntervalMDT                CRITICALITY ignore      EXTENSION ExtendedReportIntervalMDT             PRESENCE optional},
        ...
}

M4Configuration ::= SEQUENCE {
        m4period                        M4period,
        m4-links-to-log         Links-to-log,
        iE-Extensions           ProtocolExtensionContainer { { M4Configuration-ExtIEs} } OPTIONAL,
        ...
}

M4Configuration-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        { ID id-M4ReportAmount          CRITICALITY ignore      EXTENSION M4ReportAmountMDT             PRESENCE optional               },
        ...
}

M4ReportAmountMDT ::= ENUMERATED {r1, r2, r4, r8, r16, r32, r64, infinity, ...}

M4period ::= ENUMERATED {ms1024, ms2048, ms5120, ms10240, min1, ... }

M5Configuration ::= SEQUENCE {
        m5period                        M5period,
        m5-links-to-log         Links-to-log,
        iE-Extensions           ProtocolExtensionContainer { { M5Configuration-ExtIEs} } OPTIONAL,
        ...
}

M5Configuration-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        { ID id-M5ReportAmount          CRITICALITY ignore      EXTENSION M5ReportAmountMDT             PRESENCE optional               },
        ...
}

M5ReportAmountMDT ::= ENUMERATED {r1, r2, r4, r8, r16, r32, r64, infinity, ...}


M5period ::= ENUMERATED {ms1024, ms2048, ms5120, ms10240, min1, ... }

M6Configuration ::= SEQUENCE {
        m6report-Interval       M6report-Interval,
        m6-links-to-log         Links-to-log,
        iE-Extensions           ProtocolExtensionContainer { { M6Configuration-ExtIEs} } OPTIONAL,
        ...
}

M6Configuration-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        { ID id-M6ReportAmount          CRITICALITY ignore      EXTENSION M6ReportAmountMDT             PRESENCE optional               }|
        { ID id-ExcessPacketDelayThresholdConfiguration CRITICALITY ignore      EXTENSION ExcessPacketDelayThresholdConfiguration               PRESENCE optional               },
        ...
}


M6ReportAmountMDT ::= ENUMERATED {r1, r2, r4, r8, r16, r32, r64, infinity, ...}

M6report-Interval ::= ENUMERATED {
        ms120, ms240, ms480, ms640, ms1024, ms2048, ms5120, ms10240, ms20480, ms40960, min1, min6, min12, min30,
        ...
}


M7Configuration ::= SEQUENCE {
        m7period                        M7period,
        m7-links-to-log         Links-to-log,
        iE-Extensions           ProtocolExtensionContainer { { M7Configuration-ExtIEs} } OPTIONAL,
        ...
}

M7Configuration-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        { ID id-M7ReportAmount          CRITICALITY ignore      EXTENSION M7ReportAmountMDT             PRESENCE optional               },
        ...
}

M7ReportAmountMDT ::= ENUMERATED {r1, r2, r4, r8, r16, r32, r64, infinity, ...}

M7period ::= INTEGER(1..60, ...)

MDT-Location-Info ::= SEQUENCE {
        mDT-Location-Information        MDT-Location-Information,
        iE-Extensions           ProtocolExtensionContainer { { MDT-Location-Info-ExtIEs} } OPTIONAL,
        ...
}

MDT-Location-Info-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

MDT-Location-Information::= BIT STRING (SIZE (8))

-- N

N3IWF-ID ::= CHOICE {
        n3IWF-ID                                BIT STRING (SIZE(16)),
        choice-Extensions               ProtocolIE-SingleContainer { {N3IWF-ID-ExtIEs} }
}

N3IWF-ID-ExtIEs NGAP-PROTOCOL-IES ::= {
        ...
}

N6JitterInformation ::= SEQUENCE {
        n6JitterLowerBound              INTEGER (-127..127),
        n6JitterUpperBound              INTEGER (-127..127),
        iE-Extensions                   ProtocolExtensionContainer { { N6JitterInformation-ExtIEs} }    OPTIONAL,
        ...
}

N6JitterInformation-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

NAS-PDU ::= OCTET STRING

NASSecurityParametersFromNGRAN ::= OCTET STRING

NB-IoT-DefaultPagingDRX ::= ENUMERATED {
        rf128, rf256, rf512, rf1024,
        ...
}

NB-IoT-PagingDRX ::= ENUMERATED {
        rf32, rf64, rf128, rf256, rf512, rf1024,
        ...
}

NB-IoT-Paging-eDRXCycle ::= ENUMERATED {
        hf2, hf4, hf6, hf8, hf10, hf12, hf14, hf16, hf32, hf64, hf128, hf256, hf512, hf1024,
        ...
}

NB-IoT-Paging-TimeWindow ::= ENUMERATED {
        s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15, s16,
        ...
}

NB-IoT-Paging-eDRXInfo ::= SEQUENCE {
        nB-IoT-Paging-eDRXCycle         NB-IoT-Paging-eDRXCycle,
        nB-IoT-Paging-TimeWindow        NB-IoT-Paging-TimeWindow                                                                OPTIONAL,
        iE-Extensions           ProtocolExtensionContainer { { NB-IoT-Paging-eDRXInfo-ExtIEs} } OPTIONAL,
        ...
}

NB-IoT-Paging-eDRXInfo-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

NB-IoT-UEPriority ::= INTEGER (0..255, ...)

NetworkControlledRepeaterAuthorized ::= ENUMERATED {authorized, not-authorized, ...}

NetworkInstance ::= INTEGER (1..256, ...)

NewSecurityContextInd ::= ENUMERATED {
        true,
        ...
}

NextHopChainingCount ::= INTEGER (0..7)

NextPagingAreaScope ::= ENUMERATED {
        same,
        changed,
        ...
}

NGAPIESupportInformationRequestList ::= SEQUENCE (SIZE(1.. maxnoofNGAPIESupportInfo)) OF NGAPIESupportInformationRequestItem

NGAPIESupportInformationRequestItem ::= SEQUENCE {
        ngap-ProtocolIE-Id              ProtocolIE-ID,
        iE-Extensions           ProtocolExtensionContainer { { NGAPIESupportInformationRequestItem-ExtIEs} }    OPTIONAL,
        ...
}

NGAPIESupportInformationRequestItem-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

NGAPIESupportInformationResponseList ::= SEQUENCE (SIZE(1.. maxnoofNGAPIESupportInfo)) OF NGAPIESupportInformationResponseItem

NGAPIESupportInformationResponseItem ::= SEQUENCE {
        ngap-ProtocolIE-Id                              ProtocolIE-ID,
        ngap-ProtocolIESupportInfo              ENUMERATED {supported, not-supported, ...},
        ngap-ProtocolIEPresenceInfo             ENUMERATED {present, not-present, ...},
        iE-Extensions           ProtocolExtensionContainer { { NGAPIESupportInformationResponseItem-ExtIEs} }   OPTIONAL,
        ...
}

NGAPIESupportInformationResponseItem-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

NgENB-ID ::= CHOICE {
        macroNgENB-ID                   BIT STRING (SIZE(20)),
        shortMacroNgENB-ID              BIT STRING (SIZE(18)),
        longMacroNgENB-ID               BIT STRING (SIZE(21)),
        choice-Extensions               ProtocolIE-SingleContainer { {NgENB-ID-ExtIEs} }
}

NgENB-ID-ExtIEs NGAP-PROTOCOL-IES ::= {
        ...
}

NotifySourceNGRANNode ::= ENUMERATED {
        notifySource,
        ...
}

NGRAN-CGI ::= CHOICE {
        nR-CGI                  NR-CGI,
        eUTRA-CGI               EUTRA-CGI,
        choice-Extensions               ProtocolIE-SingleContainer { {NGRAN-CGI-ExtIEs} }
}

NGRAN-CGI-ExtIEs NGAP-PROTOCOL-IES ::= {
        ...
}

NGRAN-TNLAssociationToRemoveList ::= SEQUENCE (SIZE(1..maxnoofTNLAssociations)) OF NGRAN-TNLAssociationToRemoveItem

NGRAN-TNLAssociationToRemoveItem::= SEQUENCE {
        tNLAssociationTransportLayerAddress                     CPTransportLayerInformation,
        tNLAssociationTransportLayerAddressAMF          CPTransportLayerInformation                                                             OPTIONAL,
        iE-Extensions           ProtocolExtensionContainer { { NGRAN-TNLAssociationToRemoveItem-ExtIEs} }       OPTIONAL
}

NGRAN-TNLAssociationToRemoveItem-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

NGRANTraceID ::= OCTET STRING (SIZE(8))

NID ::= BIT STRING (SIZE(44))

NonDynamic5QIDescriptor ::= SEQUENCE {
        fiveQI                                          FiveQI,
        priorityLevelQos                        PriorityLevelQos                                                                                OPTIONAL,
        averagingWindow                         AveragingWindow                                                                                 OPTIONAL,
        maximumDataBurstVolume          MaximumDataBurstVolume                                                                  OPTIONAL,
        iE-Extensions   ProtocolExtensionContainer { {NonDynamic5QIDescriptor-ExtIEs} } OPTIONAL,
        ...
}

NonDynamic5QIDescriptor-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        { ID id-CNPacketDelayBudgetDL   CRITICALITY ignore      EXTENSION ExtendedPacketDelayBudget             PRESENCE optional               }|
        { ID id-CNPacketDelayBudgetUL   CRITICALITY ignore      EXTENSION ExtendedPacketDelayBudget             PRESENCE optional               },
        ...
}

NoPDUSessionIndication ::= ENUMERATED {true, ...}

NotAllowedTACs ::= SEQUENCE (SIZE(1..maxnoofAllowedAreas)) OF TAC

NotificationCause ::= ENUMERATED {
        fulfilled,
        not-fulfilled,
        ...
}

NotificationControl ::= ENUMERATED {
        notification-requested,
        ...
}

NPN-AccessInformation ::= CHOICE {
        pNI-NPN-Access-Information              CellCAGList,
        choice-Extensions                               ProtocolIE-SingleContainer { {NPN-AccessInformation-ExtIEs} }
}

NPN-AccessInformation-ExtIEs NGAP-PROTOCOL-IES ::= {
        ...
}

NPN-MobilityInformation ::= CHOICE {
        sNPN-MobilityInformation                SNPN-MobilityInformation,
        pNI-NPN-MobilityInformation             PNI-NPN-MobilityInformation,
        choice-Extensions                               ProtocolIE-SingleContainer { {NPN-MobilityInformation-ExtIEs} }
}

NPN-MobilityInformation-ExtIEs NGAP-PROTOCOL-IES ::= {
        ...
}


NPN-PagingAssistanceInformation ::= CHOICE {
        pNI-NPN-PagingAssistance                Allowed-PNI-NPN-List,
        choice-Extensions                               ProtocolIE-SingleContainer { {NPN-PagingAssistanceInformation-ExtIEs} }
}

NPN-PagingAssistanceInformation-ExtIEs NGAP-PROTOCOL-IES ::= {
        ...
}

NPN-Support ::= CHOICE {
        sNPN                                    NID,
        choice-Extensions               ProtocolIE-SingleContainer { {NPN-Support-ExtIEs} }
}

NPN-Support-ExtIEs NGAP-PROTOCOL-IES ::= {
        ...
}

NRCellIdentity ::= BIT STRING (SIZE(36))

NR-CGI ::= SEQUENCE {
        pLMNIdentity            PLMNIdentity,
        nRCellIdentity          NRCellIdentity,
        iE-Extensions           ProtocolExtensionContainer { {NR-CGI-ExtIEs} } OPTIONAL,
        ...
}

NR-CGI-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

NR-CGIList ::= SEQUENCE (SIZE(1..maxnoofCellsingNB)) OF NR-CGI

NR-CGIListForWarning ::= SEQUENCE (SIZE(1..maxnoofCellIDforWarning)) OF NR-CGI

NR-PagingeDRXInformation ::= SEQUENCE {
        nR-paging-eDRX-Cycle            NR-Paging-eDRX-Cycle,
        nR-paging-Time-Window           NR-Paging-Time-Window                                   OPTIONAL,
        iE-Extensions           ProtocolExtensionContainer { {NR-PagingeDRXInformation-ExtIEs} }        OPTIONAL,
        ...
}

NR-PagingeDRXInformation-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

NR-Paging-eDRX-Cycle ::= ENUMERATED {
        hfquarter, hfhalf, hf1, hf2, hf4, hf8, hf16,
        hf32, hf64, hf128, hf256, hf512, hf1024,
        ...
}

NR-Paging-Long-eDRX-Information-for-RRC-INACTIVE ::= SEQUENCE {
        nR-paging-Long-eDRX-Cycle-for-RRC-INACTIVE              NR-Paging-Long-eDRX-Cycle-for-RRC-INACTIVE,
        nR-paging-Time-Window-for-RRC-INACTIVE                  NR-Paging-Time-Window-for-RRC-INACTIVE,
        iE-Extensions           ProtocolExtensionContainer { {NR-Paging-Long-eDRX-Information-for-RRC-INACTIVE-ExtIEs} }        OPTIONAL,
        ...
}

NR-Paging-Long-eDRX-Information-for-RRC-INACTIVE-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

NR-Paging-Long-eDRX-Cycle-for-RRC-INACTIVE      ::= ENUMERATED {
        hf2, hf4, hf8, hf16,
        hf32, hf64, hf128, hf256, hf512, hf1024,
        ...
}

NR-Paging-Time-Window ::= ENUMERATED {
        s1, s2, s3, s4, s5,
        s6, s7, s8, s9, s10,
        s11, s12, s13, s14, s15, s16,
        ...,
        s17, s18, s19, s20, s21, s22, s23, s24,
        s25, s26, s27, s28, s29, s30, s31, s32
}

NR-Paging-Time-Window-for-RRC-INACTIVE ::= ENUMERATED {
        s1, s2, s3, s4, s5,
        s6, s7, s8, s9, s10,
        s11, s12, s13, s14, s15, s16,
        s17, s18, s19, s20, s21, s22, s23, s24,
        s25, s26, s27, s28, s29, s30, s31, s32,
        ...
}

NRencryptionAlgorithms ::= BIT STRING (SIZE(16, ...))

NRintegrityProtectionAlgorithms ::= BIT STRING (SIZE(16, ...))

NRMobilityHistoryReport ::= OCTET STRING

NRPPa-PDU ::= OCTET STRING

NRUERLFReportContainer ::= OCTET STRING

NRNTNTAIInformation     ::= SEQUENCE {
        servingPLMN                                                     PLMNIdentity,
        tACListInNRNTN                                          TACListInNRNTN,
        uELocationDerivedTACInNRNTN                     TAC                                                     OPTIONAL,
        iE-Extensions           ProtocolExtensionContainer { { NRNTNTAIInformation-ExtIEs} } OPTIONAL,
        ...
}

NRNTNTAIInformation-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}


NumberOfBroadcasts ::= INTEGER (0..65535)

NumberOfBroadcastsRequested ::= INTEGER (0..65535)

NRARFCN ::= INTEGER (0.. maxNRARFCN)

NRFrequencyBand ::= INTEGER (1..1024, ...)

NRFrequencyBand-List ::= SEQUENCE (SIZE(1..maxnoofNRCellBands)) OF NRFrequencyBandItem

NRFrequencyBandItem ::= SEQUENCE {
        nr-frequency-band                       NRFrequencyBand,
        iE-Extension            ProtocolExtensionContainer { {NRFrequencyBandItem-ExtIEs} }     OPTIONAL,
        ...
}

NRFrequencyBandItem-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

NRFrequencyInfo ::= SEQUENCE {
        nrARFCN                         NRARFCN,
        frequencyBand-List              NRFrequencyBand-List,
        iE-Extension            ProtocolExtensionContainer { {NRFrequencyInfo-ExtIEs} }         OPTIONAL,
        ...
}

NRFrequencyInfo-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

NR-PCI ::= INTEGER (0..1007, ...)

NRV2XServicesAuthorized ::= SEQUENCE {
        vehicleUE                       VehicleUE                                                                                                               OPTIONAL,
        pedestrianUE            PedestrianUE                                                                                                    OPTIONAL,
        iE-Extensions           ProtocolExtensionContainer { {NRV2XServicesAuthorized-ExtIEs} } OPTIONAL,
        ...
}

NRV2XServicesAuthorized-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

VehicleUE ::= ENUMERATED {
        authorized,
        not-authorized,
        ...
}

PedestrianUE ::= ENUMERATED {
        authorized,
        not-authorized,
        ...
}

NRUESidelinkAggregateMaximumBitrate ::= SEQUENCE {
        uESidelinkAggregateMaximumBitRate               BitRate,
        iE-Extensions           ProtocolExtensionContainer { {NRUESidelinkAggregateMaximumBitrate-ExtIEs} } OPTIONAL,
        ...
}

NRUESidelinkAggregateMaximumBitrate-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

NSAG-ID ::= INTEGER (0..255, ...)

NR-A2X-ServicesAuthorized ::= SEQUENCE {
        aerialUE                                                                ENUMERATED {authorized, not-authorized, ...}            OPTIONAL,
        aerialControllerUE                                              ENUMERATED {authorized, not-authorized, ...}            OPTIONAL,
        iE-Extensions           ProtocolExtensionContainer { {NR-A2X-ServicesAuthorized-ExtIEs} }               OPTIONAL,
        ...
}

NR-A2X-ServicesAuthorized-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

-- O

OnboardingSupport ::= ENUMERATED {
        true,
        ...
}

OverloadAction ::= ENUMERATED {
        reject-non-emergency-mo-dt,
        reject-rrc-cr-signalling,
        permit-emergency-sessions-and-mobile-terminated-services-only,
        permit-high-priority-sessions-and-mobile-terminated-services-only,
        ...
}

OverloadResponse ::= CHOICE {
        overloadAction                  OverloadAction,
        choice-Extensions               ProtocolIE-SingleContainer { {OverloadResponse-ExtIEs} }
}

OverloadResponse-ExtIEs NGAP-PROTOCOL-IES ::= {
        ...
}

OverloadStartNSSAIList ::= SEQUENCE (SIZE (1..maxnoofSliceItems)) OF OverloadStartNSSAIItem

OverloadStartNSSAIItem ::= SEQUENCE {
        sliceOverloadList                                               SliceOverloadList,
        sliceOverloadResponse                                   OverloadResponse                                                        OPTIONAL,
        sliceTrafficLoadReductionIndication             TrafficLoadReductionIndication                          OPTIONAL,
        iE-Extensions           ProtocolExtensionContainer { {OverloadStartNSSAIItem-ExtIEs} }  OPTIONAL,
        ...
}

OverloadStartNSSAIItem-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

-- P

PacketDelayBudget ::= INTEGER (0..1023, ...)

PacketErrorRate ::= SEQUENCE {
        pERScalar               INTEGER (0..9, ...),
        pERExponent             INTEGER (0..9, ...),
        iE-Extensions           ProtocolExtensionContainer { {PacketErrorRate-ExtIEs} } OPTIONAL,
        ...
}

PacketErrorRate-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

PacketLossRate ::= INTEGER (0..1000, ...)

PagingAssisDataforCEcapabUE ::= SEQUENCE {
        eUTRA-CGI                                                       EUTRA-CGI,
        coverageEnhancementLevel                        CoverageEnhancementLevel,
        iE-Extensions                                           ProtocolExtensionContainer { { PagingAssisDataforCEcapabUE-ExtIEs} } OPTIONAL,
        ...
}

PagingAssisDataforCEcapabUE-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

PagingAttemptInformation ::= SEQUENCE {
        pagingAttemptCount                                      PagingAttemptCount,
        intendedNumberOfPagingAttempts          IntendedNumberOfPagingAttempts,
        nextPagingAreaScope                                     NextPagingAreaScope                                                                     OPTIONAL,
        iE-Extensions           ProtocolExtensionContainer { {PagingAttemptInformation-ExtIEs} }        OPTIONAL,
        ...
}

PagingAttemptInformation-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

PagingAttemptCount ::= INTEGER (1..16, ...)

PagingCause ::= ENUMERATED {
        voice,
        ...
}

PagingCauseIndicationForVoiceService ::= ENUMERATED {
        supported,
        ...
}

PagingDRX ::= ENUMERATED {
        v32,
        v64,
        v128,
        v256,
        ...
}

PagingOrigin ::= ENUMERATED {
        non-3gpp,
        ...
}


PagingPolicyDifferentiation ::= SEQUENCE {
        pDUSessionForPagingList                 PDUSessionForPagingList,
        iE-Extensions                                   ProtocolExtensionContainer { { PagingPolicyDifferentiation-ExtIEs} }    OPTIONAL,
        ...
}

PagingPolicyDifferentiation-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

PDUSessionForPagingList ::= SEQUENCE (SIZE(1..maxnoofPDUSessions)) OF PDUSessionForPagingItem

PDUSessionForPagingItem ::= SEQUENCE {
        pDUSessionID                                            PDUSessionID,
        pagingPolicyDifferentiationList         PagingPolicyDifferentiationList,
        iE-Extensions                                           ProtocolExtensionContainer { { PDUSessionForPagingItem-ExtIEs} }        OPTIONAL,
        ...
}

PDUSessionForPagingItem-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

PagingPolicyDifferentiationList ::= SEQUENCE (SIZE(1..maxnoofQosFlows)) OF PagingPolicyDifferentiationItem

PagingPolicyDifferentiationItem ::= SEQUENCE {
        qosFlowIdentifier                                       QosFlowIdentifier                                       OPTIONAL,
        pagingPolicyIndicator                           PagingPolicyIndicator                           OPTIONAL,
        allocationAndRetentionPriority          AllocationAndRetentionPriority          OPTIONAL,
        fiveQI                                                          FiveQI                                                          OPTIONAL,
        dl-DataSize                                             INTEGER (0..96000, ...)                         OPTIONAL,
        iE-Extensions                                           ProtocolExtensionContainer { { PagingPolicyDifferentiationItem-ExtIEs} }        OPTIONAL,
        ...
}

PagingPolicyDifferentiationItem-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

PagingPolicyIndicator ::= INTEGER (0..7, ...)

PagingPriority ::= ENUMERATED {
        priolevel1,
        priolevel2,
        priolevel3,
        priolevel4,
        priolevel5,
        priolevel6,
        priolevel7,
        priolevel8,
        ...
}

PagingProbabilityInformation ::= ENUMERATED {
        p00, p05, p10, p15, p20, p25, p30, p35, p40, p45, p50, p55, p60, p65, p70, p75, p80, p85, p90, p95, p100,
        ...
}

ParentTImeSource ::= ENUMERATED {synce, ptp, gnss, atomicclock, terrestrialradio, serialtimecode, ntp, handset, other, ...}

Partially-Allowed-NSSAI ::= SEQUENCE (SIZE(1.. maxnoofPartiallyAllowedS-NSSAIs)) OF PartiallyAllowedNSSAI-Item

PartiallyAllowedNSSAI-Item ::= SEQUENCE {
        s-NSSAI                         S-NSSAI,
        iE-Extensions           ProtocolExtensionContainer { {PartiallyAllowedNSSAI-Item-ExtIEs} }      OPTIONAL,
        ...
}

PartiallyAllowedNSSAI-Item-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

PathSwitchRequestAcknowledgeTransfer ::= SEQUENCE {
        uL-NGU-UP-TNLInformation                UPTransportLayerInformation                                                                                     OPTIONAL,
        securityIndication                              SecurityIndication                                                                                                      OPTIONAL,
        iE-Extensions           ProtocolExtensionContainer { {PathSwitchRequestAcknowledgeTransfer-ExtIEs} }    OPTIONAL,
        ...
}

PathSwitchRequestAcknowledgeTransfer-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        { ID id-AdditionalNGU-UP-TNLInformation                         CRITICALITY ignore      EXTENSION UPTransportLayerInformationPairList           PRESENCE optional       }|
        { ID id-RedundantUL-NGU-UP-TNLInformation                       CRITICALITY ignore      EXTENSION UPTransportLayerInformation                           PRESENCE optional       }|
        { ID id-AdditionalRedundantNGU-UP-TNLInformation        CRITICALITY ignore      EXTENSION UPTransportLayerInformationPairList           PRESENCE optional       }|
        { ID id-QosFlowParametersList                                           CRITICALITY ignore      EXTENSION QosFlowParametersList                                         PRESENCE optional },
        ...
}

PathSwitchRequestSetupFailedTransfer ::= SEQUENCE {
        cause                           Cause,
        iE-Extensions           ProtocolExtensionContainer { {PathSwitchRequestSetupFailedTransfer-ExtIEs} }    OPTIONAL,
        ...
}

PathSwitchRequestSetupFailedTransfer-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

PathSwitchRequestTransfer ::= SEQUENCE {
        dL-NGU-UP-TNLInformation                        UPTransportLayerInformation,
        dL-NGU-TNLInformationReused                     DL-NGU-TNLInformationReused                                                     OPTIONAL,
        userPlaneSecurityInformation            UserPlaneSecurityInformation                                            OPTIONAL,
        qosFlowAcceptedList                                     QosFlowAcceptedList,
        iE-Extensions           ProtocolExtensionContainer { {PathSwitchRequestTransfer-ExtIEs} }       OPTIONAL,
        ...
}

PathSwitchRequestTransfer-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        { ID id-AdditionalDLQosFlowPerTNLInformation                            CRITICALITY ignore      EXTENSION QosFlowPerTNLInformationList          PRESENCE optional       }|
        { ID id-RedundantDL-NGU-UP-TNLInformation                                       CRITICALITY ignore      EXTENSION UPTransportLayerInformation                   PRESENCE optional       }|
        { ID id-RedundantDL-NGU-TNLInformationReused                            CRITICALITY ignore      EXTENSION DL-NGU-TNLInformationReused                   PRESENCE optional       }|
        { ID id-AdditionalRedundantDLQosFlowPerTNLInformation           CRITICALITY ignore      EXTENSION QosFlowPerTNLInformationList          PRESENCE optional       }|
        { ID id-UsedRSNInformation                                                                      CRITICALITY ignore      EXTENSION RedundantPDUSessionInformation                PRESENCE optional       }|
        { ID id-GlobalRANNodeID                                                                         CRITICALITY ignore      EXTENSION GlobalRANNodeID                                                       PRESENCE optional       }|
        { ID id-MBS-SupportIndicator                                                            CRITICALITY ignore      EXTENSION MBS-SupportIndicator                                  PRESENCE optional       }|
        { ID id-PDUSetbasedHandlingIndicator                                            CRITICALITY ignore      EXTENSION PDUSetbasedHandlingIndicator          PRESENCE optional }|
        { ID id-ECNMarkingorCongestionInformationReportingStatus        CRITICALITY ignore      EXTENSION ECNMarkingorCongestionInformationReportingStatus              PRESENCE optional },
        ...
}

PathSwitchRequestUnsuccessfulTransfer ::= SEQUENCE {
        cause                           Cause,
        iE-Extensions           ProtocolExtensionContainer { {PathSwitchRequestUnsuccessfulTransfer-ExtIEs} }   OPTIONAL,
        ...
}

PathSwitchRequestUnsuccessfulTransfer-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

PC5QoSParameters ::= SEQUENCE {
        pc5QoSFlowList                          PC5QoSFlowList,
        pc5LinkAggregateBitRates        BitRate                                                                                         OPTIONAL,
        iE-Extensions           ProtocolExtensionContainer { { PC5QoSParameters-ExtIEs} }       OPTIONAL,
        ...
}

PC5QoSParameters-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

PC5QoSFlowList ::= SEQUENCE (SIZE(1..maxnoofPC5QoSFlows)) OF PC5QoSFlowItem

PC5QoSFlowItem::= SEQUENCE {
        pQI                                     FiveQI,
        pc5FlowBitRates         PC5FlowBitRates                                                                                 OPTIONAL,
        range                           Range                                                                                                   OPTIONAL,
        iE-Extensions           ProtocolExtensionContainer { { PC5QoSFlowItem-ExtIEs} } OPTIONAL,
        ...
}

PC5QoSFlowItem-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

PC5FlowBitRates ::= SEQUENCE {
        guaranteedFlowBitRate           BitRate,
        maximumFlowBitRate                      BitRate,
        iE-Extensions           ProtocolExtensionContainer { { PC5FlowBitRates-ExtIEs} }        OPTIONAL,
        ...
}

PC5FlowBitRates-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}


PCIListForMDT ::= SEQUENCE (SIZE(1.. maxnoofNeighPCIforMDT)) OF NR-PCI

PrivacyIndicator ::= ENUMERATED {
        immediate-MDT,
        logged-MDT,
        ...
}

PDUSessionAggregateMaximumBitRate ::= SEQUENCE {
        pDUSessionAggregateMaximumBitRateDL             BitRate,
        pDUSessionAggregateMaximumBitRateUL             BitRate,
        iE-Extensions           ProtocolExtensionContainer { {PDUSessionAggregateMaximumBitRate-ExtIEs} } OPTIONAL,
        ...
}

PDUSessionAggregateMaximumBitRate-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

PDUSessionID ::= INTEGER (0..255)

PDUSessionPairID ::= INTEGER (0..255, ...)

PDUSessionResourceAdmittedList ::= SEQUENCE (SIZE(1..maxnoofPDUSessions)) OF PDUSessionResourceAdmittedItem

PDUSessionResourceAdmittedItem ::= SEQUENCE {
        pDUSessionID                                                    PDUSessionID,
        handoverRequestAcknowledgeTransfer              OCTET STRING (CONTAINING HandoverRequestAcknowledgeTransfer),
        iE-Extensions           ProtocolExtensionContainer { {PDUSessionResourceAdmittedItem-ExtIEs} }  OPTIONAL,
        ...
}

PDUSessionResourceAdmittedItem-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

PDUSessionResourceFailedToModifyListModCfm ::= SEQUENCE (SIZE(1..maxnoofPDUSessions)) OF PDUSessionResourceFailedToModifyItemModCfm

PDUSessionResourceFailedToModifyItemModCfm ::= SEQUENCE {
        pDUSessionID                                                                                            PDUSessionID,
        pDUSessionResourceModifyIndicationUnsuccessfulTransfer          OCTET STRING (CONTAINING PDUSessionResourceModifyIndicationUnsuccessfulTransfer),
        iE-Extensions           ProtocolExtensionContainer { {PDUSessionResourceFailedToModifyItemModCfm-ExtIEs} }      OPTIONAL,
        ...
}

PDUSessionResourceFailedToModifyItemModCfm-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

PDUSessionResourceFailedToModifyListModRes ::= SEQUENCE (SIZE(1..maxnoofPDUSessions)) OF PDUSessionResourceFailedToModifyItemModRes

PDUSessionResourceFailedToModifyItemModRes ::= SEQUENCE {
        pDUSessionID                                                                            PDUSessionID,
        pDUSessionResourceModifyUnsuccessfulTransfer            OCTET STRING (CONTAINING PDUSessionResourceModifyUnsuccessfulTransfer),
        iE-Extensions           ProtocolExtensionContainer { {PDUSessionResourceFailedToModifyItemModRes-ExtIEs} }      OPTIONAL,
        ...
}

PDUSessionResourceFailedToModifyItemModRes-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

PDUSessionResourceFailedToResumeListRESReq ::= SEQUENCE (SIZE(1..maxnoofPDUSessions)) OF PDUSessionResourceFailedToResumeItemRESReq

PDUSessionResourceFailedToResumeItemRESReq ::= SEQUENCE {
        pDUSessionID                                            PDUSessionID,
        cause                                                           Cause,
        iE-Extensions           ProtocolExtensionContainer { {PDUSessionResourceFailedToResumeItemRESReq-ExtIEs} }      OPTIONAL,
        ...
}

PDUSessionResourceFailedToResumeItemRESReq-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}


PDUSessionResourceFailedToResumeListRESRes ::= SEQUENCE (SIZE(1..maxnoofPDUSessions)) OF PDUSessionResourceFailedToResumeItemRESRes

PDUSessionResourceFailedToResumeItemRESRes ::= SEQUENCE {
        pDUSessionID                                            PDUSessionID,
        cause                                                           Cause,
        iE-Extensions           ProtocolExtensionContainer { {PDUSessionResourceFailedToResumeItemRESRes-ExtIEs} }      OPTIONAL,
        ...
}

PDUSessionResourceFailedToResumeItemRESRes-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

PDUSessionResourceFailedToSetupListCxtFail ::= SEQUENCE (SIZE(1..maxnoofPDUSessions)) OF PDUSessionResourceFailedToSetupItemCxtFail

PDUSessionResourceFailedToSetupItemCxtFail ::= SEQUENCE {
        pDUSessionID                                                                    PDUSessionID,
        pDUSessionResourceSetupUnsuccessfulTransfer             OCTET STRING (CONTAINING PDUSessionResourceSetupUnsuccessfulTransfer),
        iE-Extensions           ProtocolExtensionContainer { {PDUSessionResourceFailedToSetupItemCxtFail-ExtIEs} }      OPTIONAL,
        ...
}

PDUSessionResourceFailedToSetupItemCxtFail-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

PDUSessionResourceFailedToSetupListCxtRes ::= SEQUENCE (SIZE(1..maxnoofPDUSessions)) OF PDUSessionResourceFailedToSetupItemCxtRes

PDUSessionResourceFailedToSetupItemCxtRes ::= SEQUENCE {
        pDUSessionID                                                                    PDUSessionID,
        pDUSessionResourceSetupUnsuccessfulTransfer             OCTET STRING (CONTAINING PDUSessionResourceSetupUnsuccessfulTransfer),
        iE-Extensions           ProtocolExtensionContainer { {PDUSessionResourceFailedToSetupItemCxtRes-ExtIEs} }       OPTIONAL,
        ...
}

PDUSessionResourceFailedToSetupItemCxtRes-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

PDUSessionResourceFailedToSetupListHOAck ::= SEQUENCE (SIZE(1..maxnoofPDUSessions)) OF PDUSessionResourceFailedToSetupItemHOAck

PDUSessionResourceFailedToSetupItemHOAck ::= SEQUENCE {
        pDUSessionID                                                                            PDUSessionID,
        handoverResourceAllocationUnsuccessfulTransfer          OCTET STRING (CONTAINING HandoverResourceAllocationUnsuccessfulTransfer),
        iE-Extensions           ProtocolExtensionContainer { {PDUSessionResourceFailedToSetupItemHOAck-ExtIEs} }        OPTIONAL,
        ...
}

PDUSessionResourceFailedToSetupItemHOAck-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

PDUSessionResourceFailedToSetupListPSReq ::= SEQUENCE (SIZE(1..maxnoofPDUSessions)) OF PDUSessionResourceFailedToSetupItemPSReq

PDUSessionResourceFailedToSetupItemPSReq ::= SEQUENCE {
        pDUSessionID                                                            PDUSessionID,
        pathSwitchRequestSetupFailedTransfer            OCTET STRING (CONTAINING PathSwitchRequestSetupFailedTransfer),
        iE-Extensions           ProtocolExtensionContainer { {PDUSessionResourceFailedToSetupItemPSReq-ExtIEs} }        OPTIONAL,
        ...
}

PDUSessionResourceFailedToSetupItemPSReq-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

PDUSessionResourceFailedToSetupListSURes ::= SEQUENCE (SIZE(1..maxnoofPDUSessions)) OF PDUSessionResourceFailedToSetupItemSURes

PDUSessionResourceFailedToSetupItemSURes ::= SEQUENCE {
        pDUSessionID                                                                    PDUSessionID,
        pDUSessionResourceSetupUnsuccessfulTransfer             OCTET STRING (CONTAINING PDUSessionResourceSetupUnsuccessfulTransfer),
        iE-Extensions           ProtocolExtensionContainer { {PDUSessionResourceFailedToSetupItemSURes-ExtIEs} }        OPTIONAL,
        ...
}

PDUSessionResourceFailedToSetupItemSURes-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

PDUSessionResourceHandoverList ::= SEQUENCE (SIZE(1..maxnoofPDUSessions)) OF PDUSessionResourceHandoverItem

PDUSessionResourceHandoverItem ::= SEQUENCE {
        pDUSessionID                                            PDUSessionID,
        handoverCommandTransfer                         OCTET STRING (CONTAINING HandoverCommandTransfer),
        iE-Extensions           ProtocolExtensionContainer { {PDUSessionResourceHandoverItem-ExtIEs} }  OPTIONAL,
        ...
}

PDUSessionResourceHandoverItem-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

PDUSessionResourceInformationList ::= SEQUENCE (SIZE(1..maxnoofPDUSessions)) OF PDUSessionResourceInformationItem

PDUSessionResourceInformationItem ::= SEQUENCE {
        pDUSessionID                                    PDUSessionID,
        qosFlowInformationList                  QosFlowInformationList,
        dRBsToQosFlowsMappingList               DRBsToQosFlowsMappingList                                                                               OPTIONAL,
        iE-Extensions           ProtocolExtensionContainer { {PDUSessionResourceInformationItem-ExtIEs} }       OPTIONAL,
        ...
}

PDUSessionResourceInformationItem-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

PDUSessionResourceListCxtRelCpl ::= SEQUENCE (SIZE(1..maxnoofPDUSessions)) OF PDUSessionResourceItemCxtRelCpl

PDUSessionResourceItemCxtRelCpl ::= SEQUENCE {
        pDUSessionID            PDUSessionID,
        iE-Extensions           ProtocolExtensionContainer { {PDUSessionResourceItemCxtRelCpl-ExtIEs} } OPTIONAL,
        ...
}

-- WS modification: define a dedicated type
PDUSessionResourceReleaseResponseTransfer-OCTET-STRING ::= OCTET STRING (CONTAINING PDUSessionResourceReleaseResponseTransfer)

PDUSessionResourceItemCxtRelCpl-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
-- WS modification: define a dedicated type
--      { ID id-PDUSessionResourceReleaseResponseTransfer       CRITICALITY ignore      EXTENSION OCTET STRING (CONTAINING PDUSessionResourceReleaseResponseTransfer)   PRESENCE optional       },
        { ID id-PDUSessionResourceReleaseResponseTransfer       CRITICALITY ignore      EXTENSION PDUSessionResourceReleaseResponseTransfer-OCTET-STRING        PRESENCE optional       },
        ...
}

PDUSessionResourceListCxtRelReq ::= SEQUENCE (SIZE(1..maxnoofPDUSessions)) OF PDUSessionResourceItemCxtRelReq

PDUSessionResourceItemCxtRelReq ::= SEQUENCE {
        pDUSessionID            PDUSessionID,
        iE-Extensions           ProtocolExtensionContainer { {PDUSessionResourceItemCxtRelReq-ExtIEs} } OPTIONAL,
        ...
}

PDUSessionResourceItemCxtRelReq-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

PDUSessionResourceListHORqd ::= SEQUENCE (SIZE(1..maxnoofPDUSessions)) OF PDUSessionResourceItemHORqd

PDUSessionResourceItemHORqd ::= SEQUENCE {
        pDUSessionID                                                    PDUSessionID,
        handoverRequiredTransfer                                OCTET STRING (CONTAINING HandoverRequiredTransfer),
        iE-Extensions           ProtocolExtensionContainer { {PDUSessionResourceItemHORqd-ExtIEs} }     OPTIONAL,
        ...
}

PDUSessionResourceItemHORqd-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

PDUSessionListMTCommHReq ::= SEQUENCE (SIZE(1..maxnoofPDUSessions)) OF PDUSessionListMTCommHReq-Item

PDUSessionListMTCommHReq-Item ::= SEQUENCE {
        pDUSessionID                                                    PDUSessionID,
        iE-Extensions           ProtocolExtensionContainer { { PDUSessionListMTCommHReq-Item-ExtIEs} }  OPTIONAL,
        ...
}

PDUSessionListMTCommHReq-Item-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

PDUSessionResourceModifyConfirmTransfer ::= SEQUENCE {
        qosFlowModifyConfirmList                        QosFlowModifyConfirmList,
        uLNGU-UP-TNLInformation                         UPTransportLayerInformation,
        additionalNG-UUPTNLInformation          UPTransportLayerInformationPairList                                                                     OPTIONAL,
        qosFlowFailedToModifyList                       QosFlowListWithCause                                                                                            OPTIONAL,
        iE-Extensions           ProtocolExtensionContainer { {PDUSessionResourceModifyConfirmTransfer-ExtIEs} } OPTIONAL,
        ...
}

PDUSessionResourceModifyConfirmTransfer-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        { ID id-RedundantUL-NGU-UP-TNLInformation                       CRITICALITY ignore      EXTENSION UPTransportLayerInformation                           PRESENCE optional       }|
        { ID id-AdditionalRedundantNGU-UP-TNLInformation        CRITICALITY ignore      EXTENSION UPTransportLayerInformationPairList           PRESENCE optional       },
        ...
}

PDUSessionResourceModifyIndicationUnsuccessfulTransfer ::= SEQUENCE {
        cause                           Cause,
        iE-Extensions           ProtocolExtensionContainer { {PDUSessionResourceModifyIndicationUnsuccessfulTransfer-ExtIEs} }          OPTIONAL,
        ...
}

PDUSessionResourceModifyIndicationUnsuccessfulTransfer-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

PDUSessionResourceModifyRequestTransfer ::= SEQUENCE {
        protocolIEs             ProtocolIE-Container            { {PDUSessionResourceModifyRequestTransferIEs} },
        ...
}

PDUSessionResourceModifyRequestTransferIEs NGAP-PROTOCOL-IES ::= {
        { ID id-PDUSessionAggregateMaximumBitRate                       CRITICALITY reject      TYPE PDUSessionAggregateMaximumBitRate          PRESENCE        optional                }|
        { ID id-UL-NGU-UP-TNLModifyList                                         CRITICALITY reject      TYPE UL-NGU-UP-TNLModifyList                                    PRESENCE        optional                }|
        { ID id-NetworkInstance                                                         CRITICALITY reject      TYPE NetworkInstance                                                            PRESENCE optional               }|
        { ID id-QosFlowAddOrModifyRequestList                           CRITICALITY reject      TYPE QosFlowAddOrModifyRequestList                      PRESENCE optional               }|
        { ID id-QosFlowToReleaseList                                            CRITICALITY reject      TYPE QosFlowListWithCause                                               PRESENCE optional               }|
        { ID id-AdditionalUL-NGU-UP-TNLInformation                      CRITICALITY reject      TYPE UPTransportLayerInformationList                    PRESENCE optional               }|
        { ID id-CommonNetworkInstance                                           CRITICALITY ignore      TYPE CommonNetworkInstance                                              PRESENCE optional               }|
        { ID id-AdditionalRedundantUL-NGU-UP-TNLInformation     CRITICALITY ignore      TYPE UPTransportLayerInformationList                    PRESENCE optional               }|
        { ID id-RedundantCommonNetworkInstance                          CRITICALITY ignore      TYPE CommonNetworkInstance                                              PRESENCE optional               }|
        { ID id-RedundantUL-NGU-UP-TNLInformation                       CRITICALITY ignore      TYPE UPTransportLayerInformation                                PRESENCE optional               }|
        { ID id-SecurityIndication                                                      CRITICALITY ignore      TYPE SecurityIndication                                                 PRESENCE optional               }|
        { ID id-MBSSessionSetuporModifyRequestList                      CRITICALITY ignore      TYPE MBSSessionSetuporModifyRequestList         PRESENCE optional               }|
        { ID id-MBSSessionToReleaseList                                         CRITICALITY ignore      TYPE MBSSessionToReleaseList                                    PRESENCE optional               }|
        { ID id-UserPlaneFailureIndication                                      CRITICALITY ignore      TYPE UserPlaneFailureIndication                         PRESENCE optional               },
        ...
}

PDUSessionResourceModifyResponseTransfer ::= SEQUENCE {
        dL-NGU-UP-TNLInformation                                UPTransportLayerInformation                                                                                     OPTIONAL,
        uL-NGU-UP-TNLInformation                                UPTransportLayerInformation                                                                                     OPTIONAL,
        qosFlowAddOrModifyResponseList                  QosFlowAddOrModifyResponseList                                                                          OPTIONAL,
        additionalDLQosFlowPerTNLInformation    QosFlowPerTNLInformationList                                                                            OPTIONAL,
        qosFlowFailedToAddOrModifyList                  QosFlowListWithCause                                                                                            OPTIONAL,
        iE-Extensions           ProtocolExtensionContainer { {PDUSessionResourceModifyResponseTransfer-ExtIEs} }        OPTIONAL,
        ...
}

PDUSessionResourceModifyResponseTransfer-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        { ID id-AdditionalNGU-UP-TNLInformation                                 CRITICALITY ignore      EXTENSION UPTransportLayerInformationPairList   PRESENCE optional       }|
        { ID id-RedundantDL-NGU-UP-TNLInformation                               CRITICALITY ignore      EXTENSION UPTransportLayerInformation                           PRESENCE optional       }|
        { ID id-RedundantUL-NGU-UP-TNLInformation                               CRITICALITY ignore      EXTENSION UPTransportLayerInformation                           PRESENCE optional       }|
        { ID id-AdditionalRedundantDLQosFlowPerTNLInformation   CRITICALITY ignore      EXTENSION QosFlowPerTNLInformationList                          PRESENCE optional       }|
        { ID id-AdditionalRedundantNGU-UP-TNLInformation                CRITICALITY ignore      EXTENSION UPTransportLayerInformationPairList   PRESENCE optional       }|
        { ID id-SecondaryRATUsageInformation                                    CRITICALITY ignore      EXTENSION SecondaryRATUsageInformation                          PRESENCE optional       }|
        { ID id-MBS-SupportIndicator                                                    CRITICALITY ignore      EXTENSION MBS-SupportIndicator                                          PRESENCE optional       }|
        { ID id-MBSSessionSetuporModifyResponseList                             CRITICALITY ignore      EXTENSION MBSSessionSetupResponseList                           PRESENCE optional       }|
        { ID id-MBSSessionFailedtoSetuporModifyList                             CRITICALITY ignore      EXTENSION MBSSessionFailedtoSetupList                           PRESENCE optional       }|
        { ID id-ECNMarkingorCongestionInformationReportingStatus        CRITICALITY ignore      EXTENSION ECNMarkingorCongestionInformationReportingStatus              PRESENCE optional }|
        { ID id-PDUSetbasedHandlingIndicator                                    CRITICALITY ignore      EXTENSION PDUSetbasedHandlingIndicator                  PRESENCE optional }|
        { ID id-UserPlaneFailureIndicationReport                                CRITICALITY ignore      EXTENSION UserPlaneFailureIndicationReport              PRESENCE optional       },
        ...
}

PDUSessionResourceModifyIndicationTransfer ::= SEQUENCE {
        dLQosFlowPerTNLInformation                                      QosFlowPerTNLInformation,
        additionalDLQosFlowPerTNLInformation            QosFlowPerTNLInformationList                                                                    OPTIONAL,
        iE-Extensions           ProtocolExtensionContainer { {PDUSessionResourceModifyIndicationTransfer-ExtIEs} }      OPTIONAL,
        ...
}

PDUSessionResourceModifyIndicationTransfer-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        { ID id-SecondaryRATUsageInformation                                    CRITICALITY ignore      EXTENSION SecondaryRATUsageInformation          PRESENCE optional       }|
        { ID id-SecurityResult                                                                  CRITICALITY ignore      EXTENSION SecurityResult                                                PRESENCE optional       }|
        { ID id-RedundantDLQosFlowPerTNLInformation                             CRITICALITY ignore      EXTENSION QosFlowPerTNLInformation                      PRESENCE optional       }|
        { ID id-AdditionalRedundantDLQosFlowPerTNLInformation   CRITICALITY ignore      EXTENSION QosFlowPerTNLInformationList          PRESENCE optional       }|
        { ID id-GlobalRANNodeID                                                                 CRITICALITY ignore      EXTENSION GlobalRANNodeID                                               PRESENCE optional       }|
        { ID id-ECNMarkingorCongestionInformationReportingStatus        CRITICALITY ignore      EXTENSION ECNMarkingorCongestionInformationReportingStatus              PRESENCE optional },
        ...
}

PDUSessionResourceModifyListModCfm ::= SEQUENCE (SIZE(1..maxnoofPDUSessions)) OF PDUSessionResourceModifyItemModCfm

PDUSessionResourceModifyItemModCfm ::= SEQUENCE {
        pDUSessionID                                                            PDUSessionID,
        pDUSessionResourceModifyConfirmTransfer         OCTET STRING (CONTAINING PDUSessionResourceModifyConfirmTransfer),
        iE-Extensions           ProtocolExtensionContainer { {PDUSessionResourceModifyItemModCfm-ExtIEs} }      OPTIONAL,
        ...
}

PDUSessionResourceModifyItemModCfm-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

PDUSessionResourceModifyListModInd ::= SEQUENCE (SIZE(1..maxnoofPDUSessions)) OF PDUSessionResourceModifyItemModInd

PDUSessionResourceModifyItemModInd ::= SEQUENCE {
        pDUSessionID                                                                    PDUSessionID,
        pDUSessionResourceModifyIndicationTransfer              OCTET STRING (CONTAINING PDUSessionResourceModifyIndicationTransfer),
        iE-Extensions           ProtocolExtensionContainer { {PDUSessionResourceModifyItemModInd-ExtIEs} }      OPTIONAL,
        ...
}

PDUSessionResourceModifyItemModInd-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

PDUSessionResourceModifyListModReq ::= SEQUENCE (SIZE(1..maxnoofPDUSessions)) OF PDUSessionResourceModifyItemModReq

PDUSessionResourceModifyItemModReq ::= SEQUENCE {
        pDUSessionID                                                            PDUSessionID,
        nAS-PDU                                                                         NAS-PDU                                                                                                 OPTIONAL,
        pDUSessionResourceModifyRequestTransfer         OCTET STRING (CONTAINING PDUSessionResourceModifyRequestTransfer),
        iE-Extensions           ProtocolExtensionContainer { {PDUSessionResourceModifyItemModReq-ExtIEs} }      OPTIONAL,
        ...
}

PDUSessionResourceModifyItemModReq-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        { ID id-S-NSSAI                                                                                 CRITICALITY reject      EXTENSION S-NSSAI                                               PRESENCE optional       }|
        { ID id-PduSessionExpectedUEActivityBehaviour                   CRITICALITY ignore      EXTENSION ExpectedUEActivityBehaviour   PRESENCE optional       },
        ...
}

PDUSessionResourceModifyListModRes ::= SEQUENCE (SIZE(1..maxnoofPDUSessions)) OF PDUSessionResourceModifyItemModRes

PDUSessionResourceModifyItemModRes ::= SEQUENCE {
        pDUSessionID                                                                    PDUSessionID,
        pDUSessionResourceModifyResponseTransfer                OCTET STRING (CONTAINING PDUSessionResourceModifyResponseTransfer),
        iE-Extensions           ProtocolExtensionContainer { {PDUSessionResourceModifyItemModRes-ExtIEs} }      OPTIONAL,
        ...
}

PDUSessionResourceModifyItemModRes-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

PDUSessionResourceModifyUnsuccessfulTransfer ::= SEQUENCE {
        cause                                           Cause,
        criticalityDiagnostics          CriticalityDiagnostics                                                                                                                          OPTIONAL,
        iE-Extensions           ProtocolExtensionContainer { {PDUSessionResourceModifyUnsuccessfulTransfer-ExtIEs} }    OPTIONAL,
        ...
}

PDUSessionResourceModifyUnsuccessfulTransfer-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

PDUSessionResourceNotifyList ::= SEQUENCE (SIZE(1..maxnoofPDUSessions)) OF PDUSessionResourceNotifyItem

PDUSessionResourceNotifyItem ::= SEQUENCE {
        pDUSessionID                                            PDUSessionID,
        pDUSessionResourceNotifyTransfer        OCTET STRING (CONTAINING PDUSessionResourceNotifyTransfer),
        iE-Extensions           ProtocolExtensionContainer { {PDUSessionResourceNotifyItem-ExtIEs} }    OPTIONAL,
        ...
}

PDUSessionResourceNotifyItem-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

PDUSessionResourceNotifyReleasedTransfer ::= SEQUENCE {
        cause                           Cause,
        iE-Extensions           ProtocolExtensionContainer { {PDUSessionResourceNotifyReleasedTransfer-ExtIEs} }        OPTIONAL,
        ...
}

PDUSessionResourceNotifyReleasedTransfer-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        { ID id-SecondaryRATUsageInformation            CRITICALITY ignore      EXTENSION SecondaryRATUsageInformation          PRESENCE optional       }|
        { ID id-UserPlaneErrorIndicator                         CRITICALITY ignore      EXTENSION UserPlaneErrorIndicator                       PRESENCE optional       },
        ...
}

UserPlaneErrorIndicator ::= ENUMERATED {
        gTP-U-error-indication-received,
        ...
}

PDUSessionResourceNotifyTransfer ::= SEQUENCE {
        qosFlowNotifyList               QosFlowNotifyList                                                                                                               OPTIONAL,
        qosFlowReleasedList             QosFlowListWithCause                                                                                                    OPTIONAL,
        iE-Extensions           ProtocolExtensionContainer { {PDUSessionResourceNotifyTransfer-ExtIEs} }        OPTIONAL,
        ...
}

PDUSessionResourceNotifyTransfer-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        { ID id-SecondaryRATUsageInformation            CRITICALITY ignore      EXTENSION SecondaryRATUsageInformation          PRESENCE optional       }|
        { ID id-QosFlowFeedbackList                                     CRITICALITY ignore      EXTENSION QosFlowFeedbackList                                   PRESENCE optional       },
        ...
}

PDUSessionResourceReleaseCommandTransfer ::= SEQUENCE {
        cause                           Cause,
        iE-Extensions           ProtocolExtensionContainer { {PDUSessionResourceReleaseCommandTransfer-ExtIEs} }        OPTIONAL,
        ...
}

PDUSessionResourceReleaseCommandTransfer-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        { ID id-QosFlowAdditionalInfoList               CRITICALITY ignore      EXTENSION QosFlowAdditionalInfoListRelCom               PRESENCE optional       },
        ...
}

PDUSessionResourceReleasedListNot ::= SEQUENCE (SIZE(1..maxnoofPDUSessions)) OF PDUSessionResourceReleasedItemNot

PDUSessionResourceReleasedItemNot ::= SEQUENCE {
        pDUSessionID                                                                    PDUSessionID,
        pDUSessionResourceNotifyReleasedTransfer                OCTET STRING (CONTAINING PDUSessionResourceNotifyReleasedTransfer),
        iE-Extensions           ProtocolExtensionContainer { {PDUSessionResourceReleasedItemNot-ExtIEs} }       OPTIONAL,
        ...
}

PDUSessionResourceReleasedItemNot-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

PDUSessionResourceReleasedListPSAck ::= SEQUENCE (SIZE(1..maxnoofPDUSessions)) OF PDUSessionResourceReleasedItemPSAck

PDUSessionResourceReleasedItemPSAck ::= SEQUENCE {
        pDUSessionID                                                            PDUSessionID,
        pathSwitchRequestUnsuccessfulTransfer           OCTET STRING (CONTAINING PathSwitchRequestUnsuccessfulTransfer),
        iE-Extensions           ProtocolExtensionContainer { {PDUSessionResourceReleasedItemPSAck-ExtIEs} }     OPTIONAL,
        ...
}

PDUSessionResourceReleasedItemPSAck-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

PDUSessionResourceReleasedListPSFail ::= SEQUENCE (SIZE(1..maxnoofPDUSessions)) OF PDUSessionResourceReleasedItemPSFail

PDUSessionResourceReleasedItemPSFail ::= SEQUENCE {
        pDUSessionID                                                            PDUSessionID,
        pathSwitchRequestUnsuccessfulTransfer           OCTET STRING (CONTAINING PathSwitchRequestUnsuccessfulTransfer),
        iE-Extensions           ProtocolExtensionContainer { {PDUSessionResourceReleasedItemPSFail-ExtIEs} }    OPTIONAL,
        ...
}

PDUSessionResourceReleasedItemPSFail-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

PDUSessionResourceReleasedListRelRes ::= SEQUENCE (SIZE(1..maxnoofPDUSessions)) OF PDUSessionResourceReleasedItemRelRes

PDUSessionResourceReleasedItemRelRes ::= SEQUENCE {
        pDUSessionID                                                                    PDUSessionID,
        pDUSessionResourceReleaseResponseTransfer               OCTET STRING (CONTAINING PDUSessionResourceReleaseResponseTransfer),
        iE-Extensions           ProtocolExtensionContainer { {PDUSessionResourceReleasedItemRelRes-ExtIEs} }    OPTIONAL,
        ...
}

PDUSessionResourceReleasedItemRelRes-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

PDUSessionResourceReleaseResponseTransfer ::= SEQUENCE {
        iE-Extensions           ProtocolExtensionContainer { {PDUSessionResourceReleaseResponseTransfer-ExtIEs} }       OPTIONAL,
        ...
}

PDUSessionResourceReleaseResponseTransfer-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        { ID id-SecondaryRATUsageInformation            CRITICALITY ignore      EXTENSION SecondaryRATUsageInformation          PRESENCE optional       }|
        { ID id-QosFlowAdditionalInfoList               CRITICALITY ignore      EXTENSION QosFlowAdditionalInfoListRelRes               PRESENCE optional       },
        ...
}

PDUSessionResourceResumeListRESReq ::= SEQUENCE (SIZE(1..maxnoofPDUSessions)) OF PDUSessionResourceResumeItemRESReq

PDUSessionResourceResumeItemRESReq ::= SEQUENCE {
        pDUSessionID                                            PDUSessionID,
        uEContextResumeRequestTransfer          OCTET STRING (CONTAINING UEContextResumeRequestTransfer),
        iE-Extensions           ProtocolExtensionContainer { {PDUSessionResourceResumeItemRESReq-ExtIEs} }      OPTIONAL,
        ...
}

PDUSessionResourceResumeItemRESReq-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

PDUSessionResourceResumeListRESRes ::= SEQUENCE (SIZE(1..maxnoofPDUSessions)) OF PDUSessionResourceResumeItemRESRes

PDUSessionResourceResumeItemRESRes ::= SEQUENCE {
        pDUSessionID                                            PDUSessionID,
        uEContextResumeResponseTransfer         OCTET STRING (CONTAINING UEContextResumeResponseTransfer),
        iE-Extensions           ProtocolExtensionContainer { {PDUSessionResourceResumeItemRESRes-ExtIEs} }      OPTIONAL,
        ...
}

PDUSessionResourceResumeItemRESRes-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

PDUSessionResourceSecondaryRATUsageList ::= SEQUENCE (SIZE(1..maxnoofPDUSessions)) OF PDUSessionResourceSecondaryRATUsageItem

PDUSessionResourceSecondaryRATUsageItem ::= SEQUENCE {
        pDUSessionID                                                    PDUSessionID,
        secondaryRATDataUsageReportTransfer             OCTET STRING (CONTAINING SecondaryRATDataUsageReportTransfer),
        iE-Extensions           ProtocolExtensionContainer { {PDUSessionResourceSecondaryRATUsageItem-ExtIEs} } OPTIONAL,
        ...
}

PDUSessionResourceSecondaryRATUsageItem-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

PDUSessionResourceSetupListCxtReq ::= SEQUENCE (SIZE(1..maxnoofPDUSessions)) OF PDUSessionResourceSetupItemCxtReq

PDUSessionResourceSetupItemCxtReq ::= SEQUENCE {
        pDUSessionID                                                            PDUSessionID,
        nAS-PDU                                                                         NAS-PDU                                                                                         OPTIONAL,
        s-NSSAI                                                                         S-NSSAI,
        pDUSessionResourceSetupRequestTransfer          OCTET STRING (CONTAINING PDUSessionResourceSetupRequestTransfer),
        iE-Extensions           ProtocolExtensionContainer { {PDUSessionResourceSetupItemCxtReq-ExtIEs} }       OPTIONAL,
        ...
}

PDUSessionResourceSetupItemCxtReq-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        { ID id-PduSessionExpectedUEActivityBehaviour                   CRITICALITY ignore      EXTENSION ExpectedUEActivityBehaviour   PRESENCE optional       },
        ...
}

PDUSessionResourceSetupListCxtRes ::= SEQUENCE (SIZE(1..maxnoofPDUSessions)) OF PDUSessionResourceSetupItemCxtRes

PDUSessionResourceSetupItemCxtRes ::= SEQUENCE {
        pDUSessionID                                                            PDUSessionID,
        pDUSessionResourceSetupResponseTransfer         OCTET STRING (CONTAINING PDUSessionResourceSetupResponseTransfer),
        iE-Extensions           ProtocolExtensionContainer { {PDUSessionResourceSetupItemCxtRes-ExtIEs} }       OPTIONAL,
        ...
}

PDUSessionResourceSetupItemCxtRes-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

PDUSessionResourceSetupListHOReq ::= SEQUENCE (SIZE(1..maxnoofPDUSessions)) OF PDUSessionResourceSetupItemHOReq

PDUSessionResourceSetupItemHOReq ::= SEQUENCE {
        pDUSessionID                            PDUSessionID,
        s-NSSAI                                         S-NSSAI,
        handoverRequestTransfer         OCTET STRING (CONTAINING PDUSessionResourceSetupRequestTransfer),
        iE-Extensions           ProtocolExtensionContainer { {PDUSessionResourceSetupItemHOReq-ExtIEs} }        OPTIONAL,
        ...
}

PDUSessionResourceSetupItemHOReq-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        { ID id-PduSessionExpectedUEActivityBehaviour                   CRITICALITY ignore      EXTENSION ExpectedUEActivityBehaviour   PRESENCE optional       },
        ...
}

PDUSessionResourceSetupListSUReq ::= SEQUENCE (SIZE(1..maxnoofPDUSessions)) OF PDUSessionResourceSetupItemSUReq

PDUSessionResourceSetupItemSUReq ::= SEQUENCE {
        pDUSessionID                                                            PDUSessionID,
        pDUSessionNAS-PDU                                                       NAS-PDU                                                                                         OPTIONAL,
        s-NSSAI                                                                         S-NSSAI,
        pDUSessionResourceSetupRequestTransfer          OCTET STRING (CONTAINING PDUSessionResourceSetupRequestTransfer),
        iE-Extensions           ProtocolExtensionContainer { {PDUSessionResourceSetupItemSUReq-ExtIEs} }        OPTIONAL,
        ...
}

PDUSessionResourceSetupItemSUReq-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        { ID id-PduSessionExpectedUEActivityBehaviour                   CRITICALITY ignore      EXTENSION ExpectedUEActivityBehaviour   PRESENCE optional       },
        ...
}

PDUSessionResourceSetupListSURes ::= SEQUENCE (SIZE(1..maxnoofPDUSessions)) OF PDUSessionResourceSetupItemSURes

PDUSessionResourceSetupItemSURes ::= SEQUENCE {
        pDUSessionID                                                                                    PDUSessionID,
        pDUSessionResourceSetupResponseTransfer                                 OCTET STRING (CONTAINING PDUSessionResourceSetupResponseTransfer),
        iE-Extensions           ProtocolExtensionContainer { {PDUSessionResourceSetupItemSURes-ExtIEs} }        OPTIONAL,
        ...
}

PDUSessionResourceSetupItemSURes-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

PDUSessionResourceSetupRequestTransfer ::= SEQUENCE {
        protocolIEs             ProtocolIE-Container            { {PDUSessionResourceSetupRequestTransferIEs} },
        ...
}

PDUSessionResourceSetupRequestTransferIEs NGAP-PROTOCOL-IES ::= {
        { ID id-PDUSessionAggregateMaximumBitRate                       CRITICALITY reject      TYPE PDUSessionAggregateMaximumBitRate          PRESENCE optional               }|
        { ID id-UL-NGU-UP-TNLInformation                                        CRITICALITY reject      TYPE UPTransportLayerInformation                                PRESENCE mandatory      }|
        { ID id-AdditionalUL-NGU-UP-TNLInformation                      CRITICALITY reject      TYPE UPTransportLayerInformationList                    PRESENCE optional               }|
        { ID id-DataForwardingNotPossible                                       CRITICALITY reject      TYPE DataForwardingNotPossible                                  PRESENCE optional               }|
        { ID id-PDUSessionType                                                          CRITICALITY reject      TYPE PDUSessionType                                                                     PRESENCE mandatory      }|
        { ID id-SecurityIndication                                                      CRITICALITY reject      TYPE SecurityIndication                                                 PRESENCE optional               }|
        { ID id-NetworkInstance                                                         CRITICALITY reject      TYPE NetworkInstance                                                            PRESENCE optional               }|
        { ID id-QosFlowSetupRequestList                                         CRITICALITY reject      TYPE QosFlowSetupRequestList                                    PRESENCE mandatory      }|
        { ID id-CommonNetworkInstance                                           CRITICALITY ignore      TYPE CommonNetworkInstance                                              PRESENCE optional               }|
        { ID id-DirectForwardingPathAvailability                        CRITICALITY ignore      TYPE DirectForwardingPathAvailability           PRESENCE optional               }|
        { ID id-RedundantUL-NGU-UP-TNLInformation                       CRITICALITY ignore      TYPE UPTransportLayerInformation                                PRESENCE optional               }|
        { ID id-AdditionalRedundantUL-NGU-UP-TNLInformation     CRITICALITY ignore      TYPE UPTransportLayerInformationList                    PRESENCE optional               }|
        { ID id-RedundantCommonNetworkInstance                          CRITICALITY ignore      TYPE CommonNetworkInstance                                              PRESENCE optional               }|
        { ID id-RedundantPDUSessionInformation                          CRITICALITY ignore      TYPE RedundantPDUSessionInformation                     PRESENCE optional               }|
        { ID id-MBSSessionSetupRequestList                                      CRITICALITY ignore      TYPE MBSSessionSetupRequestList                         PRESENCE optional               }|
        { ID id-DownlinkTLContainer                                                     CRITICALITY ignore      TYPE TLContainer                                                                        PRESENCE optional               },
        ...
}

PDUSessionResourceSetupResponseTransfer ::= SEQUENCE {
        dLQosFlowPerTNLInformation                              QosFlowPerTNLInformation,
        additionalDLQosFlowPerTNLInformation    QosFlowPerTNLInformationList                                                                            OPTIONAL,
        securityResult                                                  SecurityResult                                                                                                          OPTIONAL,
        qosFlowFailedToSetupList                                QosFlowListWithCause                                                                                            OPTIONAL,
        iE-Extensions           ProtocolExtensionContainer { {PDUSessionResourceSetupResponseTransfer-ExtIEs} }         OPTIONAL,
        ...
}

PDUSessionResourceSetupResponseTransfer-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        { ID id-RedundantDLQosFlowPerTNLInformation                             CRITICALITY ignore      EXTENSION QosFlowPerTNLInformation                      PRESENCE optional               }|
        { ID id-AdditionalRedundantDLQosFlowPerTNLInformation   CRITICALITY ignore      EXTENSION QosFlowPerTNLInformationList          PRESENCE optional               }|
        { ID id-UsedRSNInformation                                                              CRITICALITY ignore      EXTENSION RedundantPDUSessionInformation        PRESENCE optional               }|
        { ID id-GlobalRANNodeID                                                                 CRITICALITY ignore      EXTENSION GlobalRANNodeID                                               PRESENCE optional               }|
        { ID id-MBS-SupportIndicator                                                    CRITICALITY ignore      EXTENSION MBS-SupportIndicator                          PRESENCE optional               }|
        { ID id-MBSSessionSetupResponseList                                             CRITICALITY ignore      EXTENSION MBSSessionSetupResponseList           PRESENCE optional               }|
        { ID id-MBSSessionFailedtoSetupList                                             CRITICALITY ignore      EXTENSION MBSSessionFailedtoSetupList           PRESENCE optional               }|
        { ID id-QoSFlowTSCList                                                                  CRITICALITY ignore      EXTENSION QoSFlowTSCList                                                PRESENCE optional               }|
        { ID id-UplinkTLContainer                                                               CRITICALITY ignore      EXTENSION TLContainer                                                   PRESENCE optional               }|
        { ID id-ECNMarkingorCongestionInformationReportingStatus        CRITICALITY ignore      EXTENSION ECNMarkingorCongestionInformationReportingStatus              PRESENCE optional }|
        { ID id-PDUSetbasedHandlingIndicator                                    CRITICALITY ignore      EXTENSION PDUSetbasedHandlingIndicator  PRESENCE optional       },
        ...
}

PDUSessionResourceSetupUnsuccessfulTransfer ::= SEQUENCE {
        cause                                           Cause,
        criticalityDiagnostics          CriticalityDiagnostics                                                                                                                          OPTIONAL,
        iE-Extensions           ProtocolExtensionContainer { {PDUSessionResourceSetupUnsuccessfulTransfer-ExtIEs} }     OPTIONAL,
        ...
}

PDUSessionResourceSetupUnsuccessfulTransfer-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

PDUSessionResourceSuspendListSUSReq ::= SEQUENCE (SIZE(1..maxnoofPDUSessions)) OF PDUSessionResourceSuspendItemSUSReq

PDUSessionResourceSuspendItemSUSReq ::= SEQUENCE {
        pDUSessionID                                            PDUSessionID,
        uEContextSuspendRequestTransfer         OCTET STRING (CONTAINING UEContextSuspendRequestTransfer),
        iE-Extensions           ProtocolExtensionContainer { {PDUSessionResourceSuspendItemSUSReq-ExtIEs} }     OPTIONAL,
        ...
}

PDUSessionResourceSuspendItemSUSReq-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

PDUSessionResourceSwitchedList ::= SEQUENCE (SIZE(1..maxnoofPDUSessions)) OF PDUSessionResourceSwitchedItem

PDUSessionResourceSwitchedItem ::= SEQUENCE {
        pDUSessionID                                                            PDUSessionID,
        pathSwitchRequestAcknowledgeTransfer            OCTET STRING (CONTAINING PathSwitchRequestAcknowledgeTransfer),
        iE-Extensions           ProtocolExtensionContainer { { PDUSessionResourceSwitchedItem-ExtIEs} } OPTIONAL,
        ...
}

PDUSessionResourceSwitchedItem-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        { ID id-PduSessionExpectedUEActivityBehaviour                   CRITICALITY ignore      EXTENSION ExpectedUEActivityBehaviour   PRESENCE optional       },
        ...
}

PDUSessionResourceToBeSwitchedDLList ::= SEQUENCE (SIZE(1..maxnoofPDUSessions)) OF PDUSessionResourceToBeSwitchedDLItem

PDUSessionResourceToBeSwitchedDLItem ::= SEQUENCE {
        pDUSessionID                                    PDUSessionID,
        pathSwitchRequestTransfer               OCTET STRING (CONTAINING PathSwitchRequestTransfer),
        iE-Extensions           ProtocolExtensionContainer { { PDUSessionResourceToBeSwitchedDLItem-ExtIEs} }   OPTIONAL,
        ...
}

PDUSessionResourceToBeSwitchedDLItem-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

PDUSessionResourceToReleaseListHOCmd ::= SEQUENCE (SIZE(1..maxnoofPDUSessions)) OF PDUSessionResourceToReleaseItemHOCmd

PDUSessionResourceToReleaseItemHOCmd ::= SEQUENCE {
        pDUSessionID                                                            PDUSessionID,
        handoverPreparationUnsuccessfulTransfer         OCTET STRING (CONTAINING HandoverPreparationUnsuccessfulTransfer),
        iE-Extensions           ProtocolExtensionContainer { {PDUSessionResourceToReleaseItemHOCmd-ExtIEs} }    OPTIONAL,
        ...
}

PDUSessionResourceToReleaseItemHOCmd-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

PDUSessionResourceToReleaseListRelCmd ::= SEQUENCE (SIZE(1..maxnoofPDUSessions)) OF PDUSessionResourceToReleaseItemRelCmd

PDUSessionResourceToReleaseItemRelCmd ::= SEQUENCE {
        pDUSessionID                                                                    PDUSessionID,
        pDUSessionResourceReleaseCommandTransfer                OCTET STRING (CONTAINING PDUSessionResourceReleaseCommandTransfer),
        iE-Extensions           ProtocolExtensionContainer { {PDUSessionResourceToReleaseItemRelCmd-ExtIEs} }   OPTIONAL,
        ...
}

PDUSessionResourceToReleaseItemRelCmd-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

PDUSessionType ::= ENUMERATED {
        ipv4,
        ipv6,
        ipv4v6,
        ethernet,
        unstructured,
        ...
}

PDUSessionUsageReport ::= SEQUENCE {
        rATType                                                         ENUMERATED {nr, eutra, ..., nr-unlicensed, e-utra-unlicensed},
        pDUSessionTimedReportList                       VolumeTimedReportList,
        iE-Extensions           ProtocolExtensionContainer { {PDUSessionUsageReport-ExtIEs} } OPTIONAL,
        ...
}

PDUSessionUsageReport-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

PDUsetQoSParameters ::= SEQUENCE {
        ulPDUSetQoSInformation  PDUsetQoSInformation    OPTIONAL,
        dlPDUSetQoSInformation  PDUsetQoSInformation    OPTIONAL,
        iE-Extensions                   ProtocolExtensionContainer { { PDUsetQoSParameters-ExtIEs } }   OPTIONAL,
        ...
}

PDUsetQoSParameters-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

PDUsetQoSInformation    ::= SEQUENCE {
        pduSetDelayBudget                                               ExtendedPacketDelayBudget               OPTIONAL,
        pduSetErrorRate                                                 PacketErrorRate                                 OPTIONAL,
        pduSetIntegratedHandlingInformation             ENUMERATED {true, false, ...}   OPTIONAL,
        iE-Extensions                                                   ProtocolExtensionContainer { { PDUsetQoSInformation-ExtIEs } }  OPTIONAL,
        ...
}

PDUsetQoSInformation-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

PDUSetbasedHandlingIndicator ::= ENUMERATED {supported, ...}

PEIPSassistanceInformation ::= SEQUENCE {
        cNsubgroupID                    CNsubgroupID,
        iE-Extensions           ProtocolExtensionContainer { {PEIPSassistanceInformation-ExtIEs} } OPTIONAL,
        ...
}

PEIPSassistanceInformation-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

Periodicity ::= INTEGER (0..640000, ...)

PeriodicityBound ::= SEQUENCE {
        periodicityLowerBound                                   Periodicity,
        periodicityUpperBound                                   Periodicity,
        iE-Extensions                           ProtocolExtensionContainer { {PeriodicityBound-ExtIEs} } OPTIONAL,
        ...
}

PeriodicityBound-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

PeriodicityList ::= SEQUENCE {
        allowedPeriodicityList                  AllowedPeriodicityList,
        iE-Extensions                                   ProtocolExtensionContainer { {PeriodicityList-ExtIEs} } OPTIONAL,
        ...
}

PeriodicityList-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

AllowedPeriodicityList ::= SEQUENCE (SIZE(1..maxnoofPeriodicities)) OF Periodicity

PeriodicityRange ::= CHOICE {
        periodicityBound                                PeriodicityBound,
        periodicityList                                 AllowedPeriodicityList,
        choice-extensions                               ProtocolIE-SingleContainer { {PeriodicityRange-ExtIEs} }
}

PeriodicityRange-ExtIEs NGAP-PROTOCOL-IES ::= {
        ...
}

PeriodicRegistrationUpdateTimer ::= BIT STRING (SIZE(8))

PLMNIdentity ::= OCTET STRING (SIZE(3))

PLMNAreaBasedQMC ::= SEQUENCE {
        plmnListforQMC          PLMNListforQMC,
        iE-Extensions           ProtocolExtensionContainer { {PLMNAreaBasedQMC-ExtIEs} } OPTIONAL,
        ...
}

PLMNAreaBasedQMC-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

PLMNListforQMC ::= SEQUENCE (SIZE(1..maxnoofPLMNforQMC)) OF PLMNIdentity

PLMNSupportList ::= SEQUENCE (SIZE(1..maxnoofPLMNs)) OF PLMNSupportItem

PLMNSupportItem ::= SEQUENCE {
        pLMNIdentity                    PLMNIdentity,
        sliceSupportList                SliceSupportList,
        iE-Extensions           ProtocolExtensionContainer { {PLMNSupportItem-ExtIEs} } OPTIONAL,
        ...
}

PLMNSupportItem-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        { ID id-NPN-Support                                             CRITICALITY reject      EXTENSION NPN-Support                                   PRESENCE optional       }|
        { ID id-ExtendedSliceSupportList                CRITICALITY reject      EXTENSION ExtendedSliceSupportList      PRESENCE optional       }|
        { ID id-OnboardingSupport                               CRITICALITY ignore      EXTENSION OnboardingSupport                     PRESENCE optional       },
        ...
}

PNI-NPN-MobilityInformation ::= SEQUENCE {
        allowed-PNI-NPI-List            Allowed-PNI-NPN-List,
        iE-Extensions                           ProtocolExtensionContainer { {PNI-NPN-MobilityInformation-ExtIEs} }     OPTIONAL,
        ...
}

PNI-NPN-MobilityInformation-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

PortNumber ::= OCTET STRING (SIZE(2))

Pre-emptionCapability ::= ENUMERATED {
        shall-not-trigger-pre-emption,
        may-trigger-pre-emption,
        ...
}

Pre-emptionVulnerability ::= ENUMERATED {
        not-pre-emptable,
        pre-emptable,
        ...
}

PriorityLevelARP ::= INTEGER (1..15)

PriorityLevelQos ::= INTEGER (1..127, ...)

PWSFailedCellIDList ::= CHOICE {
        eUTRA-CGI-PWSFailedList         EUTRA-CGIList,
        nR-CGI-PWSFailedList            NR-CGIList,
        choice-Extensions               ProtocolIE-SingleContainer { {PWSFailedCellIDList-ExtIEs} }
}

PWSFailedCellIDList-ExtIEs NGAP-PROTOCOL-IES ::= {
        ...
}

PNI-NPN-AreaScopeofMDT ::= SEQUENCE {
        cAGListforMDT           CAGListforMDT,
        iE-Extensions           ProtocolExtensionContainer { {PNI-NPN-AreaScopeofMDT-ExtIEs} } OPTIONAL,
        ...
}

PNI-NPN-AreaScopeofMDT-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

PNI-NPNBasedMDT::= SEQUENCE {
        cAGListforMDT           CAGListforMDT,
        iE-Extensions           ProtocolExtensionContainer { {PNI-NPNBasedMDT-ExtIEs} } OPTIONAL,
        ...
}

PNI-NPNBasedMDT-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

-- Q

QMCConfigInfo ::= SEQUENCE {
        uEAppLayerMeasInfoList                          UEAppLayerMeasInfoList,
        iE-Extensions           ProtocolExtensionContainer { { QMCConfigInfo-ExtIEs} } OPTIONAL,
        ...
}

QMCConfigInfo-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

QMCDeactivation ::= SEQUENCE {
        qoEReferenceList                                QoEReferenceList,
        iE-Extensions           ProtocolExtensionContainer { { QMCDeactivation-ExtIEs} } OPTIONAL,
        ...
}

QMCDeactivation-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

QoEReferenceList ::= SEQUENCE (SIZE(1..maxnoofUEAppLayerMeas)) OF QoEReference

QoEReference ::= OCTET STRING (SIZE(6))

QoERVQoEReportingPaths ::= SEQUENCE {
        qoEReportingPath                                        ENUMERATED{srb4, srb5, ...}     OPTIONAL,
        rVQoEReportingPath                                      ENUMERATED{srb4, srb5, ...}     OPTIONAL,
        iE-Extensions                                           ProtocolExtensionContainer { {QoERVQoEReportingPaths-ExtIEs} }          OPTIONAL,
        ...
}

QoERVQoEReportingPaths-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}


QosCharacteristics ::= CHOICE {
        nonDynamic5QI           NonDynamic5QIDescriptor,
        dynamic5QI                      Dynamic5QIDescriptor,
        choice-Extensions               ProtocolIE-SingleContainer { {QosCharacteristics-ExtIEs} }
}

QosCharacteristics-ExtIEs NGAP-PROTOCOL-IES ::= {
        ...
}

QosFlowAcceptedList ::= SEQUENCE (SIZE(1..maxnoofQosFlows)) OF QosFlowAcceptedItem

QosFlowAcceptedItem ::= SEQUENCE {
        qosFlowIdentifier               QosFlowIdentifier,
        iE-Extensions           ProtocolExtensionContainer { {QosFlowAcceptedItem-ExtIEs} } OPTIONAL,
        ...
}

QosFlowAcceptedItem-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        { ID id-CurrentQoSParaSetIndex  CRITICALITY ignore      EXTENSION AlternativeQoSParaSetIndex    PRESENCE optional       },
        ...
}

QosFlowAdditionalInfoListRelCom ::= SEQUENCE (SIZE(1..maxnoofQosFlows)) OF QosFlowAdditionalInfoItemRelCom

QosFlowAdditionalInfoItemRelCom ::= SEQUENCE {
        qosFlowIdentifier                               QosFlowIdentifier,
        downlinkTLContainer                             TLContainer                                                                     OPTIONAL,
        iE-Extensions           ProtocolExtensionContainer { {QosFlowAdditionalInfoItemRelCom-ExtIEs} } OPTIONAL,
        ...
}

QosFlowAdditionalInfoItemRelCom-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

QosFlowAdditionalInfoListRelRes ::= SEQUENCE (SIZE(1..maxnoofQosFlows)) OF QosFlowAdditionalInfoItemRelRes

QosFlowAdditionalInfoItemRelRes ::= SEQUENCE {
        qosFlowIdentifier                               QosFlowIdentifier,
        uplinkTLContainer                               TLContainer                                                                     OPTIONAL,
        iE-Extensions           ProtocolExtensionContainer { {QosFlowAdditionalInfoItemRelRes-ExtIEs} } OPTIONAL,
        ...
}

QosFlowAdditionalInfoItemRelRes-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}


QosFlowAddOrModifyRequestList ::= SEQUENCE (SIZE(1..maxnoofQosFlows)) OF QosFlowAddOrModifyRequestItem

QosFlowAddOrModifyRequestItem ::= SEQUENCE {
        qosFlowIdentifier                               QosFlowIdentifier,
        qosFlowLevelQosParameters               QosFlowLevelQosParameters                                                                       OPTIONAL,
        e-RAB-ID                                                E-RAB-ID                                                                                                        OPTIONAL,
        iE-Extensions           ProtocolExtensionContainer { {QosFlowAddOrModifyRequestItem-ExtIEs} }   OPTIONAL,
        ...
}

QosFlowAddOrModifyRequestItem-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        {ID id-TSCTrafficCharacteristics        CRITICALITY ignore      EXTENSION TSCTrafficCharacteristics                     PRESENCE optional }|
        {ID id-RedundantQosFlowIndicator        CRITICALITY ignore      EXTENSION RedundantQosFlowIndicator                     PRESENCE optional }|
        {ID id-UL-NGU-UP-TNLInformation         CRITICALITY ignore      EXTENSION UPTransportLayerInformation           PRESENCE optional       }|
        {ID id-DownlinkTLContainer                      CRITICALITY ignore      EXTENSION TLContainer                                           PRESENCE optional }|
        {ID id-ECNMarkingorCongestionInformationReportingRequest        CRITICALITY ignore      EXTENSION ECNMarkingorCongestionInformationReportingRequest             PRESENCE optional },
        ...
}

QosFlowAddOrModifyResponseList ::= SEQUENCE (SIZE(1..maxnoofQosFlows)) OF QosFlowAddOrModifyResponseItem

QosFlowAddOrModifyResponseItem ::= SEQUENCE {
        qosFlowIdentifier               QosFlowIdentifier,
        iE-Extensions           ProtocolExtensionContainer { {QosFlowAddOrModifyResponseItem-ExtIEs} }  OPTIONAL,
        ...
}

QosFlowAddOrModifyResponseItem-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        { ID id-CurrentQoSParaSetIndex                          CRITICALITY ignore      EXTENSION AlternativeQoSParaSetIndex                            PRESENCE optional       }|
        { ID id-TSCTrafficCharacteristicsFeedback       CRITICALITY ignore      EXTENSION TSCTrafficCharacteristicsFeedback             PRESENCE optional       }|
        { ID id-UplinkTLContainer                                       CRITICALITY ignore      EXTENSION TLContainer                                                                   PRESENCE optional       }|
        { ID id-DL-NGU-UP-TNLInformation                        CRITICALITY ignore      EXTENSION UPTransportLayerInformation                           PRESENCE optional }|
        { ID id-ANPacketDelayBudgetUL                           CRITICALITY ignore      EXTENSION ExtendedPacketDelayBudget                                     PRESENCE optional },
        ...
}

QosFlowFeedbackList ::= SEQUENCE (SIZE(1..maxnoofQosFlows)) OF QosFlowFeedbackItem

QosFlowFeedbackItem ::= SEQUENCE {
        qosFlowIdentifier                       QosFlowIdentifier,
        updateFeedback                          UpdateFeedback                                                          OPTIONAL,
        cNpacketDelayBudgetDL           ExtendedPacketDelayBudget                                       OPTIONAL,
        cNpacketDelayBudgetUL           ExtendedPacketDelayBudget                                       OPTIONAL,
        iE-Extensions           ProtocolExtensionContainer { {QosFlowFeedbackItem-ExtIEs} }     OPTIONAL,
        ...
}

QosFlowFeedbackItem-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

QosFlowIdentifier ::= INTEGER (0..63, ...)

QosFlowInformationList ::= SEQUENCE (SIZE(1..maxnoofQosFlows)) OF QosFlowInformationItem

QosFlowInformationItem ::= SEQUENCE {
        qosFlowIdentifier       QosFlowIdentifier,
        dLForwarding            DLForwarding                                                                                                    OPTIONAL,
        iE-Extensions           ProtocolExtensionContainer { {QosFlowInformationItem-ExtIEs} }  OPTIONAL,
        ...
}

QosFlowInformationItem-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        {ID id-ULForwarding                             CRITICALITY ignore      EXTENSION ULForwarding                  PRESENCE optional}|
        {ID id-SourceTNLAddrInfo                CRITICALITY ignore      EXTENSION TransportLayerAddress PRESENCE optional}|
        {ID id-SourceNodeTNLAddrInfo    CRITICALITY ignore      EXTENSION TransportLayerAddress PRESENCE optional},
        ...
}

QosFlowLevelQosParameters ::= SEQUENCE {
        qosCharacteristics                                      QosCharacteristics,
        allocationAndRetentionPriority          AllocationAndRetentionPriority,
        gBR-QosInformation                                      GBR-QosInformation                                                                      OPTIONAL,
        reflectiveQosAttribute                          ReflectiveQosAttribute                                                          OPTIONAL,
        additionalQosFlowInformation            AdditionalQosFlowInformation                                            OPTIONAL,
        iE-Extensions           ProtocolExtensionContainer { {QosFlowLevelQosParameters-ExtIEs} }       OPTIONAL,
        ...
}

QosFlowLevelQosParameters-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        {ID id-QosMonitoringRequest                             CRITICALITY ignore      EXTENSION QosMonitoringRequest                                  PRESENCE optional}|
        {ID id-QosMonitoringReportingFrequency  CRITICALITY ignore      EXTENSION QosMonitoringReportingFrequency       PRESENCE optional}|
        {ID id-PDUsetQoSParameters                              CRITICALITY     ignore  EXTENSION PDUsetQoSParameters                                   PRESENCE optional},
        ...
}


QosMonitoringRequest ::= ENUMERATED {ul, dl, both, ..., stop}

QosMonitoringReportingFrequency ::= INTEGER (1..1800, ...)

QoSFlowList ::= SEQUENCE (SIZE(1..maxnoofQosFlows)) OF QosFlowIdentifier

QosFlowListWithCause ::= SEQUENCE (SIZE(1..maxnoofQosFlows)) OF QosFlowWithCauseItem

QosFlowWithCauseItem ::= SEQUENCE {
        qosFlowIdentifier               QosFlowIdentifier,
        cause                                   Cause,
        iE-Extensions           ProtocolExtensionContainer { {QosFlowWithCauseItem-ExtIEs} } OPTIONAL,
        ...
}

QosFlowWithCauseItem-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

QosFlowModifyConfirmList ::= SEQUENCE (SIZE(1..maxnoofQosFlows)) OF QosFlowModifyConfirmItem

QosFlowModifyConfirmItem ::= SEQUENCE {
        qosFlowIdentifier               QosFlowIdentifier,
        iE-Extensions           ProtocolExtensionContainer { {QosFlowModifyConfirmItem-ExtIEs} }        OPTIONAL,
        ...
}

QosFlowModifyConfirmItem-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

QosFlowNotifyList ::= SEQUENCE (SIZE(1..maxnoofQosFlows)) OF QosFlowNotifyItem

QosFlowNotifyItem ::= SEQUENCE {
        qosFlowIdentifier                       QosFlowIdentifier,
        notificationCause                       NotificationCause,
        iE-Extensions           ProtocolExtensionContainer { {QosFlowNotifyItem-ExtIEs} }       OPTIONAL,
        ...
}

QosFlowNotifyItem-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        { ID id-CurrentQoSParaSetIndex                          CRITICALITY ignore      EXTENSION AlternativeQoSParaSetNotifyIndex      PRESENCE optional       }|
        { ID id-TSCTrafficCharacteristicsFeedback       CRITICALITY ignore      EXTENSION TSCTrafficCharacteristicsFeedback     PRESENCE optional       },
        ...
}
QosFlowParametersList ::= SEQUENCE (SIZE(1..maxnoofQosFlows)) OF QosFlowParametersItem

QosFlowParametersItem ::= SEQUENCE {
        qosFlowIdentifier                               QosFlowIdentifier,
        alternativeQoSParaSetList               AlternativeQoSParaSetList                                                       OPTIONAL,
        iE-Extensions           ProtocolExtensionContainer { {QosFlowParametersItem-ExtIEs} }   OPTIONAL,
        ...
}

QosFlowParametersItem-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        { ID id-CNPacketDelayBudgetDL                   CRITICALITY ignore      EXTENSION ExtendedPacketDelayBudget             PRESENCE optional       }|
        { ID id-CNPacketDelayBudgetUL                   CRITICALITY ignore      EXTENSION ExtendedPacketDelayBudget             PRESENCE optional       }|
        { ID id-BurstArrivalTimeDownlink                CRITICALITY ignore      EXTENSION BurstArrivalTime                                      PRESENCE optional       },
        ...
}

QosFlowPerTNLInformation ::= SEQUENCE {
        uPTransportLayerInformation             UPTransportLayerInformation,
        associatedQosFlowList                   AssociatedQosFlowList,
        iE-Extensions           ProtocolExtensionContainer { { QosFlowPerTNLInformation-ExtIEs} }       OPTIONAL,
        ...
}

QosFlowPerTNLInformation-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

QosFlowPerTNLInformationList ::= SEQUENCE (SIZE(1..maxnoofMultiConnectivityMinusOne)) OF QosFlowPerTNLInformationItem

QosFlowPerTNLInformationItem ::= SEQUENCE {
        qosFlowPerTNLInformation                                QosFlowPerTNLInformation,
        iE-Extensions           ProtocolExtensionContainer { { QosFlowPerTNLInformationItem-ExtIEs} }   OPTIONAL,
        ...
}

QosFlowPerTNLInformationItem-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

QosFlowSetupRequestList ::= SEQUENCE (SIZE(1..maxnoofQosFlows)) OF QosFlowSetupRequestItem

QosFlowSetupRequestItem ::= SEQUENCE {
        qosFlowIdentifier                               QosFlowIdentifier,
        qosFlowLevelQosParameters               QosFlowLevelQosParameters,
        e-RAB-ID                                                E-RAB-ID                                                                                        OPTIONAL,
        iE-Extensions           ProtocolExtensionContainer { {QosFlowSetupRequestItem-ExtIEs} } OPTIONAL,
        ...
}

QosFlowSetupRequestItem-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        {ID id-TSCTrafficCharacteristics        CRITICALITY ignore      EXTENSION TSCTrafficCharacteristics             PRESENCE optional }|
        {ID id-RedundantQosFlowIndicator        CRITICALITY ignore      EXTENSION RedundantQosFlowIndicator             PRESENCE optional }|
        {ID id-ECNMarkingorCongestionInformationReportingRequest        CRITICALITY ignore      EXTENSION ECNMarkingorCongestionInformationReportingRequest             PRESENCE optional },
        ...
}

QosFlowListWithDataForwarding ::= SEQUENCE (SIZE(1..maxnoofQosFlows)) OF QosFlowItemWithDataForwarding

QosFlowItemWithDataForwarding ::= SEQUENCE {
        qosFlowIdentifier                       QosFlowIdentifier,
        dataForwardingAccepted          DataForwardingAccepted                                                                                  OPTIONAL,
        iE-Extensions           ProtocolExtensionContainer { {QosFlowItemWithDataForwarding-ExtIEs} }   OPTIONAL,
        ...
}

QosFlowItemWithDataForwarding-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        { ID id-CurrentQoSParaSetIndex  CRITICALITY ignore      EXTENSION AlternativeQoSParaSetIndex    PRESENCE optional       },
        ...
}

QosFlowToBeForwardedList ::= SEQUENCE (SIZE(1..maxnoofQosFlows)) OF QosFlowToBeForwardedItem

QosFlowToBeForwardedItem ::= SEQUENCE {
        qosFlowIdentifier               QosFlowIdentifier,
        iE-Extensions           ProtocolExtensionContainer { {QosFlowToBeForwardedItem-ExtIEs} }        OPTIONAL,
        ...
}

QosFlowToBeForwardedItem-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

QoSFlowTSCList ::= SEQUENCE (SIZE(1..maxnoofQosFlows)) OF QoSFlowTSCItem

QoSFlowTSCItem ::= SEQUENCE {
        qosFlowIdentifier                                               QosFlowIdentifier,
        tSCTrafficCharacteristicsFeedback               TSCTrafficCharacteristicsFeedback       OPTIONAL,
        aNPacketDelayBudgetUL                                   ExtendedPacketDelayBudget                       OPTIONAL,
        iE-Extensions           ProtocolExtensionContainer { {QoSFlowTSCItem-ExtIEs} }  OPTIONAL,
        ...
}

QoSFlowTSCItem-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

QoSFlowsUsageReportList ::= SEQUENCE (SIZE(1..maxnoofQosFlows)) OF QoSFlowsUsageReport-Item

QoSFlowsUsageReport-Item ::= SEQUENCE {
        qosFlowIdentifier                                       QosFlowIdentifier,
        rATType                                                         ENUMERATED {nr, eutra, ..., nr-unlicensed, e-utra-unlicensed},
        qoSFlowsTimedReportList                         VolumeTimedReportList,
        iE-Extensions           ProtocolExtensionContainer { {QoSFlowsUsageReport-Item-ExtIEs} } OPTIONAL,
        ...
}

QoSFlowsUsageReport-Item-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

-- R

RANfeedbacktype ::= CHOICE {
        proactive                                       RANfeedbacktype-proactive,
        reactive                                        RANfeedbacktype-reactive,
        choice-extensions                       ProtocolIE-SingleContainer { {RANfeedbacktype-ExtIEs} }
}

RANfeedbacktype-ExtIEs NGAP-PROTOCOL-IES ::= {
        ...
}

RANfeedbacktype-proactive ::= SEQUENCE {
        burstArrivalTimeWindow  BurstArrivalTimeWindow,
        periodicityRange                PeriodicityRange                        OPTIONAL,
        iE-Extension                    ProtocolExtensionContainer { {RANfeedbacktype-proactive-ExtIEs} }       OPTIONAL,
        ...
}

RANfeedbacktype-proactive-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

RANfeedbacktype-reactive ::= SEQUENCE {
        capabilityForBATAdaptation      ENUMERATED {true, ...},
        iE-Extension                    ProtocolExtensionContainer { {RANfeedbacktype-reactive-ExtIEs} }        OPTIONAL,
        ...
}

RANfeedbacktype-reactive-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

Range ::= ENUMERATED {m50, m80, m180, m200, m350, m400, m500, m700, m1000, ...}

RANNodeName ::= PrintableString (SIZE(1..150, ...))

RANNodeNameVisibleString ::= VisibleString (SIZE(1..150, ...))

RANNodeNameUTF8String ::= UTF8String (SIZE(1..150, ...))

RANPagingPriority ::= INTEGER (1..256)

RANStatusTransfer-TransparentContainer ::= SEQUENCE {
        dRBsSubjectToStatusTransferList         DRBsSubjectToStatusTransferList,
        iE-Extensions           ProtocolExtensionContainer { {RANStatusTransfer-TransparentContainer-ExtIEs} }  OPTIONAL,
        ...
}

RANStatusTransfer-TransparentContainer-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

RANTimingSynchronisationStatusInfo      ::= SEQUENCE {
        synchronisationState                    ENUMERATED {locked, holdover, freerun, ...}                                             OPTIONAL,
        traceabletoUTC                                  ENUMERATED {true, false, ...}                                                                   OPTIONAL,
        traceabletoGNSS                                 ENUMERATED {true, false, ...}                                                                   OPTIONAL,
        clockFrequencyStability                 BIT STRING (SIZE(16))                                                                                   OPTIONAL,
        clockAccuracy                                   ClockAccuracy                                                                                                   OPTIONAL,
        parentTImeSource                                ParentTImeSource                                                                                                OPTIONAL,
        iE-Extensions           ProtocolExtensionContainer { {RANTimingSynchronisationStatusInfo-ExtIEs} }      OPTIONAL,
        ...
}

RANTimingSynchronisationStatusInfo-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

RAN-TSSRequestType ::= ENUMERATED {start, stop, ...}


RAN-TSSScope    ::= CHOICE {
        rANNodeLevel                    GlobalGNB-ID,
        cellListLevel                   RANTSSCellList,
        choice-Extensions               ProtocolIE-SingleContainer { { RAN-TSSScope-ExtIEs} }
}

RAN-TSSScope-ExtIEs NGAP-PROTOCOL-IES ::= {
        ...
}

RANTSSCellList ::= SEQUENCE (SIZE(1..maxnoofCellsTSS)) OF RANTSSCellItem

RANTSSCellItem ::= SEQUENCE {
        nRCGI                           NR-CGI,
        iE-Extensions           ProtocolExtensionContainer { {RANTSSCellItem-ExtIEs} }  OPTIONAL,
        ...
}

RANTSSCellItem-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

RAN-UE-NGAP-ID ::= INTEGER (0..4294967295)

RAT-Information ::= ENUMERATED {
        unlicensed,
        nb-IoT,
        ...,
        nR-LEO,
        nR-MEO,
        nR-GEO,
        nR-OTHERSAT
}

RATRestrictions ::= SEQUENCE (SIZE(1..maxnoofEPLMNsPlusOne)) OF RATRestrictions-Item

RATRestrictions-Item ::= SEQUENCE {
        pLMNIdentity                                    PLMNIdentity,
        rATRestrictionInformation               RATRestrictionInformation,
        iE-Extensions           ProtocolExtensionContainer { {RATRestrictions-Item-ExtIEs} }            OPTIONAL,
        ...
}

RATRestrictions-Item-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        { ID id-ExtendedRATRestrictionInformation               CRITICALITY ignore      EXTENSION ExtendedRATRestrictionInformation             PRESENCE optional       },
        ...
}

RATRestrictionInformation ::= BIT STRING (SIZE(8, ...))

RecommendedCellsForPaging ::= SEQUENCE {
        recommendedCellList                     RecommendedCellList,
        iE-Extensions           ProtocolExtensionContainer { {RecommendedCellsForPaging-ExtIEs} }       OPTIONAL,
        ...
}

RecommendedCellsForPaging-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

RecommendedCellList ::= SEQUENCE (SIZE(1..maxnoofRecommendedCells)) OF RecommendedCellItem

RecommendedCellItem ::= SEQUENCE {
        nGRAN-CGI                               NGRAN-CGI,
        timeStayedInCell                INTEGER (0..4095)               OPTIONAL,
        iE-Extensions           ProtocolExtensionContainer { {RecommendedCellItem-ExtIEs} }     OPTIONAL,
        ...
}

RecommendedCellItem-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

RecommendedRANNodesForPaging ::= SEQUENCE {
        recommendedRANNodeList          RecommendedRANNodeList,
        iE-Extensions           ProtocolExtensionContainer { {RecommendedRANNodesForPaging-ExtIEs} }    OPTIONAL,
        ...
}

RecommendedRANNodesForPaging-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

RecommendedRANNodeList::= SEQUENCE (SIZE(1..maxnoofRecommendedRANNodes)) OF RecommendedRANNodeItem

RecommendedRANNodeItem ::= SEQUENCE {
        aMFPagingTarget         AMFPagingTarget,
        iE-Extensions           ProtocolExtensionContainer { {RecommendedRANNodeItem-ExtIEs} }  OPTIONAL,
        ...
}

RecommendedRANNodeItem-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

RedCapIndication ::= ENUMERATED {
        redcap,
        ...
}

RedirectionVoiceFallback ::= ENUMERATED {
        possible,
        not-possible,
        ...
}

RedundantPDUSessionInformation ::= SEQUENCE {
        rSN                                     RSN,
        iE-Extensions           ProtocolExtensionContainer { {RedundantPDUSessionInformation-ExtIEs} }  OPTIONAL,
        ...
}

RedundantPDUSessionInformation-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        { ID id-PDUSessionPairID        CRITICALITY ignore      EXTENSION PDUSessionPairID      PRESENCE optional       },
        ...
}

RedundantQosFlowIndicator ::= ENUMERATED {true, false}

ReflectiveQosAttribute ::= ENUMERATED {
        subject-to,
        ...
}

RelativeAMFCapacity ::= INTEGER (0..255)

ReportArea ::= ENUMERATED {
        cell,
        ...
}

RepetitionPeriod ::= INTEGER (0..131071)

ResetAll ::= ENUMERATED {
        reset-all,
        ...
}

ReportAmountMDT ::= ENUMERATED {
        r1, r2, r4, r8, r16, r32, r64, rinfinity
}

ReportIntervalMDT ::= ENUMERATED {
        ms120, ms240, ms480, ms640, ms1024, ms2048, ms5120, ms10240, min1, min6, min12, min30, min60
}

ExtendedReportIntervalMDT ::= ENUMERATED {
        ms20480, ms40960, ...
}

ResetType ::= CHOICE {
        nG-Interface                    ResetAll,
        partOfNG-Interface              UE-associatedLogicalNG-connectionList,
        choice-Extensions               ProtocolIE-SingleContainer { {ResetType-ExtIEs} }
}

ResetType-ExtIEs NGAP-PROTOCOL-IES ::= {
        ...
}

RGLevelWirelineAccessCharacteristics ::= OCTET STRING

RNC-ID ::= INTEGER (0..4095)

RoutingID ::= OCTET STRING

RRCContainer ::= OCTET STRING

RRCEstablishmentCause ::= ENUMERATED {
        emergency,
        highPriorityAccess,
        mt-Access,
        mo-Signalling,
        mo-Data,
        mo-VoiceCall,
        mo-VideoCall,
        mo-SMS,
        mps-PriorityAccess,
        mcs-PriorityAccess,
        ...,
        notAvailable,
        mo-ExceptionData
}

RRCInactiveTransitionReportRequest ::= ENUMERATED {
        subsequent-state-transition-report,
        single-rrc-connected-state-report,
        cancel-report,
        ...
}

RRCState ::= ENUMERATED {
        inactive,
        connected,
        ...
}

RSN ::= ENUMERATED {v1, v2, ...}

RIMInformationTransfer ::= SEQUENCE {
        targetRANNodeID-RIM                     TargetRANNodeID-RIM,
        sourceRANNodeID                         SourceRANNodeID,
        rIMInformation                          RIMInformation,
        iE-Extensions                           ProtocolExtensionContainer { {RIMInformationTransfer-ExtIEs} }  OPTIONAL,
        ...
}

RIMInformationTransfer-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}


RIMInformation  ::= SEQUENCE            {
        targetgNBSetID                  GNBSetID,
        rIM-RSDetection                 ENUMERATED      {rs-detected, rs-disappeared, ...},
        iE-Extensions                   ProtocolExtensionContainer { {RIMInformation-ExtIEs} }  OPTIONAL,
        ...
}

RIMInformation-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

GNBSetID ::= BIT STRING (SIZE(22))

RSPPQoSFlowList ::= SEQUENCE (SIZE(1..maxnoofRSPPQoSFlows)) OF RSPPQoSFlowItem

RSPPQoSFlowItem ::= SEQUENCE {
        pQI                                     FiveQI,
        rSPPFlowBitRates        RSPPFlowBitRates                                                                                        OPTIONAL,
        range                           Range                                                                                                           OPTIONAL,
        iE-Extensions           ProtocolExtensionContainer { { RSPPQoSFlowItem-ExtIEs} }        OPTIONAL,
        ...
}

RSPPQoSFlowItem-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

RSPPFlowBitRates ::= SEQUENCE {
        guaranteedFlowBitRate           BitRate,
        maximumFlowBitRate                      BitRate,
        iE-Extensions           ProtocolExtensionContainer { { RSPPFlowBitRates-ExtIEs} }       OPTIONAL,
        ...
}

RSPPFlowBitRates-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}


-- S

ScheduledCommunicationTime ::= SEQUENCE {
        dayofWeek                       BIT STRING (SIZE(7))                                                                                            OPTIONAL,
        timeofDayStart          INTEGER (0..86399, ...)                                                                                         OPTIONAL,
        timeofDayEnd            INTEGER (0..86399, ...)                                                                                         OPTIONAL,
        iE-Extensions           ProtocolExtensionContainer { { ScheduledCommunicationTime-ExtIEs}}      OPTIONAL,
        ...
}

ScheduledCommunicationTime-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

SCTP-TLAs       ::= SEQUENCE (SIZE(1..maxnoofXnTLAs)) OF TransportLayerAddress

SD ::= OCTET STRING (SIZE(3))

SecondaryRATUsageInformation ::= SEQUENCE {
        pDUSessionUsageReport           PDUSessionUsageReport                                                                                   OPTIONAL,
        qosFlowsUsageReportList         QoSFlowsUsageReportList                                                                                 OPTIONAL,
        iE-Extension            ProtocolExtensionContainer { {SecondaryRATUsageInformation-ExtIEs} }    OPTIONAL,
        ...
}

SecondaryRATUsageInformation-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

SecondaryRATDataUsageReportTransfer ::= SEQUENCE {
        secondaryRATUsageInformation            SecondaryRATUsageInformation                                                                    OPTIONAL,
        iE-Extensions           ProtocolExtensionContainer { {SecondaryRATDataUsageReportTransfer-ExtIEs} }     OPTIONAL,
        ...
}

SecondaryRATDataUsageReportTransfer-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

SecurityContext ::= SEQUENCE {
        nextHopChainingCount            NextHopChainingCount,
        nextHopNH                                       SecurityKey,
        iE-Extensions           ProtocolExtensionContainer { {SecurityContext-ExtIEs} } OPTIONAL,
        ...
}

SecurityContext-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

SecurityIndication ::= SEQUENCE {
        integrityProtectionIndication                           IntegrityProtectionIndication,
        confidentialityProtectionIndication                     ConfidentialityProtectionIndication,
        maximumIntegrityProtectedDataRate-UL            MaximumIntegrityProtectedDataRate               OPTIONAL,
-- The above IE shall be present if the Integrity Protection Indication IE is set to the value “required” or “preferred”
        iE-Extensions           ProtocolExtensionContainer { {SecurityIndication-ExtIEs} }              OPTIONAL,
        ...
}

SecurityIndication-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        { ID id-MaximumIntegrityProtectedDataRate-DL    CRITICALITY ignore      EXTENSION MaximumIntegrityProtectedDataRate     PRESENCE optional       },
        ...
}

SecurityKey     ::= BIT STRING (SIZE(256))

SecurityResult ::= SEQUENCE {
        integrityProtectionResult                       IntegrityProtectionResult,
        confidentialityProtectionResult         ConfidentialityProtectionResult,
        iE-Extensions           ProtocolExtensionContainer { {SecurityResult-ExtIEs} }  OPTIONAL,
        ...
}

SecurityResult-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

SensorMeasurementConfiguration ::=      SEQUENCE {
        sensorMeasConfig            SensorMeasConfig,
        sensorMeasConfigNameList        SensorMeasConfigNameList                                                                OPTIONAL,
        iE-Extensions           ProtocolExtensionContainer { {SensorMeasurementConfiguration-ExtIEs} }  OPTIONAL,
        ...
}

SensorMeasurementConfiguration-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

SensorMeasConfigNameList ::= SEQUENCE (SIZE(1..maxnoofSensorName)) OF SensorMeasConfigNameItem

SensorMeasConfigNameItem ::= SEQUENCE {
        sensorNameConfig                SensorNameConfig,
        iE-Extensions           ProtocolExtensionContainer { { SensorMeasConfigNameItem-ExtIEs } }      OPTIONAL,
        ...
}

SensorMeasConfigNameItem-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

SensorMeasConfig::= ENUMERATED {setup,...}

SensorNameConfig ::= CHOICE {
        uncompensatedBarometricConfig           ENUMERATED {true, ...},
        ueSpeedConfig                                           ENUMERATED {true, ...},
        ueOrientationConfig                                     ENUMERATED {true, ...},
        choice-Extensions               ProtocolIE-SingleContainer { {SensorNameConfig-ExtIEs} }
}

SensorNameConfig-ExtIEs NGAP-PROTOCOL-IES ::= {
        ...
}

SerialNumber ::= BIT STRING (SIZE(16))

ServedGUAMIList ::= SEQUENCE (SIZE(1..maxnoofServedGUAMIs)) OF ServedGUAMIItem

ServedGUAMIItem ::= SEQUENCE {
        gUAMI                           GUAMI,
        backupAMFName           AMFName                                                                                                 OPTIONAL,
        iE-Extensions           ProtocolExtensionContainer { {ServedGUAMIItem-ExtIEs} } OPTIONAL,
        ...
}

ServedGUAMIItem-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        {ID id-GUAMIType                CRITICALITY ignore      EXTENSION GUAMIType             PRESENCE optional       },
        ...
}

ServiceAreaInformation ::= SEQUENCE (SIZE(1.. maxnoofEPLMNsPlusOne)) OF ServiceAreaInformation-Item

ServiceAreaInformation-Item ::= SEQUENCE {
        pLMNIdentity            PLMNIdentity,
        allowedTACs                     AllowedTACs                                                                                                                             OPTIONAL,
        notAllowedTACs          NotAllowedTACs                                                                                                                  OPTIONAL,
        iE-Extensions           ProtocolExtensionContainer { {ServiceAreaInformation-Item-ExtIEs} }             OPTIONAL,
        ...
}

ServiceAreaInformation-Item-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

ServiceType ::=  ENUMERATED {streaming, mTSI, vR, ...}

SgNB-UE-X2AP-ID ::= INTEGER (0..4294967295)

SharedNGU-MulticastTNLInformation ::= SEQUENCE {
        iP-MulticastAddress             TransportLayerAddress,
        iP-SourceAddress                        TransportLayerAddress,
        gTP-TEID                                                GTP-TEID,
        iE-Extensions                           ProtocolExtensionContainer { {SharedNGU-MulticastTNLInformation-ExtIEs} }       OPTIONAL,
        ...
}

SharedNGU-MulticastTNLInformation-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

SliceOverloadList ::= SEQUENCE (SIZE(1..maxnoofSliceItems)) OF SliceOverloadItem

SliceOverloadItem ::= SEQUENCE {
        s-NSSAI                         S-NSSAI,
        iE-Extensions           ProtocolExtensionContainer { {SliceOverloadItem-ExtIEs} }       OPTIONAL,
        ...
}

SliceOverloadItem-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

SliceSupportList ::= SEQUENCE (SIZE(1..maxnoofSliceItems)) OF SliceSupportItem

SliceSupportItem ::= SEQUENCE {
        s-NSSAI                         S-NSSAI,
        iE-Extensions           ProtocolExtensionContainer { {SliceSupportItem-ExtIEs} }        OPTIONAL,
        ...
}

SliceSupportItem-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

SliceSupportListQMC ::= SEQUENCE (SIZE(1..maxnoofSNSSAIforQMC)) OF SliceSupportQMC-Item

SliceSupportQMC-Item ::= SEQUENCE {
        s-NSSAI                         S-NSSAI,
        iE-Extensions           ProtocolExtensionContainer { {SliceSupportQMC-Item-ExtIEs} }            OPTIONAL,
        ...
}

SliceSupportQMC-Item-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

SNPN-MobilityInformation ::= SEQUENCE {
        serving-NID                     NID,
        iE-Extensions           ProtocolExtensionContainer { {SNPN-MobilityInformation-ExtIEs} }        OPTIONAL,
        ...
}

SNPN-MobilityInformation-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        {ID id-EquivalentSNPNsList CRITICALITY reject EXTENSION EquivalentSNPNsList             PRESENCE optional},
        ...
}

S-NSSAI ::= SEQUENCE {
        sST                                     SST,
        sD                                      SD                                                                                                      OPTIONAL,
        iE-Extensions           ProtocolExtensionContainer { { S-NSSAI-ExtIEs} }        OPTIONAL,
        ...
}

S-NSSAI-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

SONConfigurationTransfer ::= SEQUENCE {
        targetRANNodeID-SON                     TargetRANNodeID-SON,
        sourceRANNodeID                         SourceRANNodeID,
        sONInformation                          SONInformation,
        xnTNLConfigurationInfo          XnTNLConfigurationInfo                                                                          OPTIONAL,
-- The above IE shall be present if the SON Information IE contains the SON Information Request IE set to the value “Xn TNL Configuration Info”
        iE-Extensions           ProtocolExtensionContainer { {SONConfigurationTransfer-ExtIEs} }        OPTIONAL,
        ...
}

SONConfigurationTransfer-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

SONInformation ::= CHOICE {
        sONInformationRequest           SONInformationRequest,
        sONInformationReply                     SONInformationReply,
        choice-Extensions               ProtocolIE-SingleContainer { {SONInformation-ExtIEs} }
}

SONInformation-ExtIEs NGAP-PROTOCOL-IES ::= {
        { ID id-SONInformationReport            CRITICALITY ignore      TYPE SONInformationReport               PRESENCE mandatory      },
        ...
}

SONInformationReply ::= SEQUENCE {
        xnTNLConfigurationInfo          XnTNLConfigurationInfo                                                                  OPTIONAL,
        iE-Extensions           ProtocolExtensionContainer { {SONInformationReply-ExtIEs} }             OPTIONAL,
        ...
}

SONInformationReply-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

SONInformationReport::= CHOICE {
        failureIndicationInformation    FailureIndication,
        hOReportInformation                             HOReport,
        choice-Extensions               ProtocolIE-SingleContainer { { SONInformationReport-ExtIEs} }
}

SONInformationReport-ExtIEs NGAP-PROTOCOL-IES ::= {
        { ID id-SuccessfulHandoverReportList                        CRITICALITY ignore  TYPE SuccessfulHandoverReportList                       PRESENCE mandatory }|
        { ID id-SuccessfulPSCellChangeReportList                    CRITICALITY ignore  TYPE SuccessfulPSCellChangeReportList   PRESENCE mandatory },
        ...
}

SNPN-CellBasedMDT::= SEQUENCE {
        sNPNcellIdListforMDT    SNPNCellIdListforMDT,
        iE-Extensions           ProtocolExtensionContainer { {SNPN-CellBasedMDT-ExtIEs} } OPTIONAL,
        ...
}

SNPN-CellBasedMDT-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

SNPNCellIdListforMDT ::= SEQUENCE (SIZE(1..maxnoofCellIDforMDT)) OF SNPNCellIdListforMDTItem

SNPNCellIdListforMDTItem ::= SEQUENCE {
        nR-CGI                                                          NR-CGI,
        nID                                                                     NID,
        iE-Extensions           ProtocolExtensionContainer {{ SNPNCellIdListforMDTItem-ExtIEs}}         OPTIONAL,
        ...
}

SNPNCellIdListforMDTItem-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}


SNPN-TAIBasedMDT::= SEQUENCE {
        sNPNTAIListforMDT       SNPNTAIListforMDT,
        iE-Extensions           ProtocolExtensionContainer { {SNPN-TAIBasedMDT-ExtIEs} } OPTIONAL,
        ...
}

SNPN-TAIBasedMDT-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

SNPNTAIListforMDT ::= SEQUENCE (SIZE(1.. maxnoofTAforMDT)) OF SNPNTAIListforMDTItem

SNPNTAIListforMDTItem ::= SEQUENCE {
        tAI                                                                     TAI,
        nID                                                                     NID,
        iE-Extensions           ProtocolExtensionContainer {{ SNPNTAIListforMDTItem-ExtIEs}}            OPTIONAL,
        ...
}

SNPNTAIListforMDTItem-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

SNPN-BasedMDT::= SEQUENCE {
        sNPNListforMDT          SNPNListforMDT,
        iE-Extensions           ProtocolExtensionContainer { {SNPN-BasedMDT-ExtIEs} } OPTIONAL,
        ...
}

SNPN-BasedMDT-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

SNPNListforMDT ::= SEQUENCE (SIZE(1.. maxnoofMDTSNPNs)) OF SNPNListforMDTItem

SNPNListforMDTItem ::= SEQUENCE {
        pLMNIdentity                                            PLMNIdentity,
        nID                                                                     NID,
        iE-Extensions           ProtocolExtensionContainer {{ SNPNListforMDTItem-ExtIEs}}               OPTIONAL,
        ...
}

SNPNListforMDTItem-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

-- --------------------------------------------------------------------
-- SON Information Report
-- --------------------------------------------------------------------

SuccessfulHandoverReportList ::= SEQUENCE (SIZE(1..maxnoofSuccessfulHOReports)) OF SuccessfulHandoverReport-Item

SuccessfulHandoverReport-Item ::= SEQUENCE {
        successfulHOReportContainer                     OCTET STRING,
        iE-Extensions           ProtocolExtensionContainer { { SuccessfulHandoverReport-Item-ExtIEs} } OPTIONAL,
        ...
}

SuccessfulHandoverReport-Item-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

SuccessfulPSCellChangeReportList ::= SEQUENCE (SIZE(1..maxnoofSuccessfulPSCellChangeReports)) OF SuccessfulPSCellChangeReport-Item

SuccessfulPSCellChangeReport-Item ::= SEQUENCE {
        successfulPSCellChangeReportContainer                   OCTET STRING,
        iE-Extensions           ProtocolExtensionContainer { { SuccessfulPSCellChangeReport-Item-ExtIEs} } OPTIONAL,
        ...
}

SuccessfulPSCellChangeReport-Item-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

SONInformationRequest ::= ENUMERATED {
        xn-TNL-configuration-info,
        ...
}

SourceNGRANNode-ToTargetNGRANNode-TransparentContainer ::= SEQUENCE {
        rRCContainer                                                    RRCContainer,
        pDUSessionResourceInformationList               PDUSessionResourceInformationList                                                                                                       OPTIONAL,
        e-RABInformationList                                    E-RABInformationList                                                                                                                            OPTIONAL,
        targetCell-ID                                                   NGRAN-CGI,
        indexToRFSP                                                             IndexToRFSP                                                                                                                                                     OPTIONAL,
        uEHistoryInformation                                    UEHistoryInformation,
        iE-Extensions           ProtocolExtensionContainer { {SourceNGRANNode-ToTargetNGRANNode-TransparentContainer-ExtIEs} }  OPTIONAL,
        ...
}

SourceNGRANNode-ToTargetNGRANNode-TransparentContainer-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        { ID id-SgNB-UE-X2AP-ID                                                         CRITICALITY ignore      EXTENSION SgNB-UE-X2AP-ID                                                       PRESENCE optional               }|
        { ID id-UEHistoryInformationFromTheUE                           CRITICALITY ignore      EXTENSION UEHistoryInformationFromTheUE                 PRESENCE optional               }|
        { ID id-SourceNodeID                                                            CRITICALITY ignore      EXTENSION SourceNodeID                                                          PRESENCE optional               }|
        { ID id-UEContextReferenceAtSource                                      CRITICALITY ignore      EXTENSION RAN-UE-NGAP-ID                                                                PRESENCE optional               }|
        { ID id-MBS-ActiveSessionInformation-SourcetoTargetList CRITICALITY ignore      EXTENSION MBS-ActiveSessionInformation-SourcetoTargetList               PRESENCE optional               }|
        { ID id-QMCConfigInfo                                                           CRITICALITY ignore      EXTENSION QMCConfigInfo                                                         PRESENCE optional               }|
        { ID id-NGAPIESupportInformationRequestList                     CRITICALITY ignore      EXTENSION NGAPIESupportInformationRequestList   PRESENCE optional               }|
        { ID id-CandidateRelayUEInformationList                         CRITICALITY reject      EXTENSION CandidateRelayUEInformationList               PRESENCE optional               }|
        { ID id-TimeBasedHandoverInformation                            CRITICALITY ignore      EXTENSION TimeBasedHandoverInformation                  PRESENCE optional               }|
        { ID id-SourceSN-to-TargetSN-QMCInfo                            CRITICALITY ignore      EXTENSION QMCConfigInfo                                                         PRESENCE optional       },
        ...
}

SourceNodeID ::= CHOICE {
        sourceengNB-ID                  GlobalGNB-ID,
        choice-Extensions               ProtocolIE-SingleContainer { { SourceNodeID-ExtIEs} }
}

SourceNodeID-ExtIEs NGAP-PROTOCOL-IES ::= {
        ...
}

SourceOfUEActivityBehaviourInformation ::= ENUMERATED {
        subscription-information,
        statistics,
        ...
}

SourceRANNodeID ::= SEQUENCE {
        globalRANNodeID         GlobalRANNodeID,
        selectedTAI                     TAI,
        iE-Extensions           ProtocolExtensionContainer { {SourceRANNodeID-ExtIEs} } OPTIONAL,
        ...
}

SourceRANNodeID-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

SourceToTarget-TransparentContainer ::= OCTET STRING
-- This IE includes a transparent container from the source RAN node to the target RAN node.
-- The octets of the OCTET STRING are encoded according to the specifications of the target system.

SourceToTarget-AMFInformationReroute ::= SEQUENCE {
        configuredNSSAI                                 ConfiguredNSSAI                                                                                                         OPTIONAL,
        rejectedNSSAIinPLMN                             RejectedNSSAIinPLMN                                                                                                     OPTIONAL,
        rejectedNSSAIinTA                               RejectedNSSAIinTA                                                                                                       OPTIONAL,
        iE-Extensions           ProtocolExtensionContainer { {SourceToTarget-AMFInformationReroute-ExtIEs} }    OPTIONAL,
        ...
}

SourceToTarget-AMFInformationReroute-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

-- This IE includes information from the source Core node to the target Core node for reroute information provide by NSSF.
-- The octets of the OCTET STRING are encoded according to the specifications of the Core network.

SRVCCOperationPossible ::= ENUMERATED {
        possible,
        notPossible,
        ...
}

ConfiguredNSSAI  ::=  OCTET STRING (SIZE(128))

RejectedNSSAIinPLMN ::= OCTET STRING (SIZE(32))

RejectedNSSAIinTA ::= OCTET STRING (SIZE(32))

SST ::= OCTET STRING (SIZE(1))

SupportedTAList ::= SEQUENCE (SIZE(1..maxnoofTACs)) OF SupportedTAItem

SupportedTAItem ::= SEQUENCE {
        tAC                                             TAC,
        broadcastPLMNList               BroadcastPLMNList,
        iE-Extensions           ProtocolExtensionContainer { {SupportedTAItem-ExtIEs} } OPTIONAL,
        ...
}

SupportedTAItem-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        {ID id-ConfiguredTACIndication          CRITICALITY ignore      EXTENSION ConfiguredTACIndication       PRESENCE optional       }|
        {ID id-RAT-Information                          CRITICALITY reject      EXTENSION RAT-Information                       PRESENCE optional       },
        ...
}

SuspendIndicator ::= ENUMERATED {
        true,
        ...
}

Suspend-Request-Indication ::= ENUMERATED {
        suspend-requested,
        ...
}

Suspend-Response-Indication ::= ENUMERATED {
        suspend-indicated,
        ...
}

SurvivalTime ::= INTEGER (0..1920000, ...)

SLPositioningRangingServiceInfo ::= SEQUENCE{
        sLPositioningRangingAuthorized          SLPositioningRangingAuthorized,
        sLPositioningRangingQoSParameters       SLPositioningRangingQoSParameters       OPTIONAL,
        iE-Extensions           ProtocolExtensionContainer { {SLPositioningRangingServiceInfo-ExtIEs} } OPTIONAL,
        ...
}

SLPositioningRangingServiceInfo-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}


SLPositioningRangingAuthorized ::= ENUMERATED {
        authorized,
        not-authorized,
        ...
}

SLPositioningRangingQoSParameters ::= SEQUENCE {
        rSPPQoSFlowList                         RSPPQoSFlowList,
        rSPPLinkAggregateBitRates       BitRate                                                                                         OPTIONAL,
        iE-Extensions           ProtocolExtensionContainer { { SLPositioningRangingQoSParameters-ExtIEs} }      OPTIONAL,
        ...
}

SLPositioningRangingQoSParameters-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}


-- T

TAC ::= OCTET STRING (SIZE(3))

TACListInNRNTN ::= SEQUENCE (SIZE(1..maxnoofTACsinNTN)) OF TAC

TAI ::= SEQUENCE {
        pLMNIdentity            PLMNIdentity,
        tAC                                     TAC,
        iE-Extensions           ProtocolExtensionContainer { {TAI-ExtIEs} } OPTIONAL,
        ...
}

TAI-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

TAIBroadcastEUTRA ::= SEQUENCE (SIZE(1..maxnoofTAIforWarning)) OF TAIBroadcastEUTRA-Item

TAIBroadcastEUTRA-Item ::= SEQUENCE {
        tAI                                                             TAI,
        completedCellsInTAI-EUTRA               CompletedCellsInTAI-EUTRA,
        iE-Extensions           ProtocolExtensionContainer { {TAIBroadcastEUTRA-Item-ExtIEs} } OPTIONAL,
        ...
}

TAIBroadcastEUTRA-Item-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

TAIBroadcastNR ::= SEQUENCE (SIZE(1..maxnoofTAIforWarning)) OF TAIBroadcastNR-Item

TAIBroadcastNR-Item ::= SEQUENCE {
        tAI                                                     TAI,
        completedCellsInTAI-NR          CompletedCellsInTAI-NR,
        iE-Extensions           ProtocolExtensionContainer { {TAIBroadcastNR-Item-ExtIEs} } OPTIONAL,
        ...
}

TAIBroadcastNR-Item-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

TAICancelledEUTRA ::= SEQUENCE (SIZE(1..maxnoofTAIforWarning)) OF TAICancelledEUTRA-Item

TAICancelledEUTRA-Item ::= SEQUENCE {
        tAI                                                             TAI,
        cancelledCellsInTAI-EUTRA               CancelledCellsInTAI-EUTRA,
        iE-Extensions           ProtocolExtensionContainer { {TAICancelledEUTRA-Item-ExtIEs} } OPTIONAL,
        ...
}

TAICancelledEUTRA-Item-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

TAICancelledNR ::= SEQUENCE (SIZE(1..maxnoofTAIforWarning)) OF TAICancelledNR-Item

TAICancelledNR-Item ::= SEQUENCE {
        tAI                                                     TAI,
        cancelledCellsInTAI-NR          CancelledCellsInTAI-NR,
        iE-Extensions           ProtocolExtensionContainer { {TAICancelledNR-Item-ExtIEs} } OPTIONAL,
        ...
}

TAICancelledNR-Item-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

TAIListForInactive ::= SEQUENCE (SIZE(1..maxnoofTAIforInactive)) OF TAIListForInactiveItem

TAIListForInactiveItem ::= SEQUENCE {
        tAI                                     TAI,
        iE-Extensions           ProtocolExtensionContainer { {TAIListForInactiveItem-ExtIEs} } OPTIONAL,
        ...
}

TAIListForInactiveItem-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

TAIListForPaging ::= SEQUENCE (SIZE(1..maxnoofTAIforPaging)) OF TAIListForPagingItem

TAIListForPagingItem ::= SEQUENCE {
        tAI                                     TAI,
        iE-Extensions           ProtocolExtensionContainer { {TAIListForPagingItem-ExtIEs} } OPTIONAL,
        ...
}

TAIListForPagingItem-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

TAIListForRestart ::= SEQUENCE (SIZE(1..maxnoofTAIforRestart)) OF TAI

TAIListForWarning ::= SEQUENCE (SIZE(1..maxnoofTAIforWarning)) OF TAI

TAINSAGSupportList ::= SEQUENCE (SIZE(1..maxnoofNSAGs)) OF TAINSAGSupportItem

TAINSAGSupportItem ::= SEQUENCE {
        nSAG-ID                                         NSAG-ID,
        nSAGSliceSupportList            ExtendedSliceSupportList,
        iE-Extensions           ProtocolExtensionContainer { {TAINSAGSupportItem-ExtIEs} } OPTIONAL,
        ...
}

TAINSAGSupportItem-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

TargeteNB-ID ::= SEQUENCE {
        globalENB-ID            GlobalNgENB-ID,
        selected-EPS-TAI        EPS-TAI,
        iE-Extensions           ProtocolExtensionContainer { {TargeteNB-ID-ExtIEs} } OPTIONAL,
        ...
}

TargeteNB-ID-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

TargetHomeENB-ID ::= SEQUENCE {
        pLMNidentity            PLMNIdentity,
        homeENB-ID                      BIT STRING (SIZE(28)),
        selected-EPS-TAI        EPS-TAI,
        iE-Extensions           ProtocolExtensionContainer { {TargetHomeENB-ID-ExtIEs} } OPTIONAL,
        ...
}

TargetHomeENB-ID-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

TargetID ::= CHOICE {
        targetRANNodeID                 TargetRANNodeID,
        targeteNB-ID                    TargeteNB-ID,
        choice-Extensions               ProtocolIE-SingleContainer { {TargetID-ExtIEs} }
}

TargetID-ExtIEs NGAP-PROTOCOL-IES ::= {
        {ID id-TargetRNC-ID                     CRITICALITY reject      TYPE TargetRNC-ID               PRESENCE mandatory }|
        {ID id-TargetHomeENB-ID         CRITICALITY reject      TYPE TargetHomeENB-ID   PRESENCE mandatory },
        ...
}

TargetNGRANNode-ToSourceNGRANNode-TransparentContainer ::= SEQUENCE {
        rRCContainer            RRCContainer,
        iE-Extensions           ProtocolExtensionContainer { {TargetNGRANNode-ToSourceNGRANNode-TransparentContainer-ExtIEs} } OPTIONAL,
        ...
}

TargetNGRANNode-ToSourceNGRANNode-TransparentContainer-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        { ID id-DAPSResponseInfoList                                            CRITICALITY ignore      EXTENSION DAPSResponseInfoList                                                                  PRESENCE optional }|
        { ID id-DirectForwardingPathAvailability                        CRITICALITY ignore      EXTENSION DirectForwardingPathAvailability                                      PRESENCE optional }|
        { ID id-MBS-ActiveSessionInformation-TargettoSourceList CRITICALITY ignore      EXTENSION MBS-ActiveSessionInformation-TargettoSourceList               PRESENCE optional }|
        { ID id-NGAPIESupportInformationResponseList            CRITICALITY ignore      EXTENSION NGAPIESupportInformationResponseList                  PRESENCE optional },
        ...
}

TargetNGRANNode-ToSourceNGRANNode-FailureTransparentContainer ::= SEQUENCE {
        cell-CAGInformation             Cell-CAGInformation                     OPTIONAL,
        iE-Extensions                   ProtocolExtensionContainer { {TargetNGRANNode-ToSourceNGRANNode-FailureTransparentContainer-ExtIEs} } OPTIONAL,
        ...
}

TargetNGRANNode-ToSourceNGRANNode-FailureTransparentContainer-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        { ID id-NGAPIESupportInformationResponseList    CRITICALITY ignore      EXTENSION NGAPIESupportInformationResponseList          PRESENCE optional },
        ...
}

TargetNSSAI ::= SEQUENCE (SIZE(1..maxnoofTargetS-NSSAIs)) OF TargetNSSAI-Item

TargetNSSAI-Item ::= SEQUENCE {
        s-NSSAI                         S-NSSAI,
        iE-Extensions           ProtocolExtensionContainer { {TargetNSSAI-Item-ExtIEs} } OPTIONAL,
        ...
}

TargetNSSAI-Item-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

TargetNSSAIInformation ::= SEQUENCE {
        targetNSSAI                     TargetNSSAI,
        indexToRFSP                     IndexToRFSP,
        iE-Extensions           ProtocolExtensionContainer { {TargetNSSAIInformation-Item-ExtIEs} } OPTIONAL,
        ...
}

TargetNSSAIInformation-Item-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

TargetRANNodeID ::= SEQUENCE {
        globalRANNodeID         GlobalRANNodeID,
        selectedTAI                     TAI,
        iE-Extensions           ProtocolExtensionContainer { {TargetRANNodeID-ExtIEs} } OPTIONAL,
        ...
}

TargetRANNodeID-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        {ID id-Selected-Target-SNPN-Identity CRITICALITY reject EXTENSION NID PRESENCE optional },
        ...
}

TargetRANNodeID-RIM ::= SEQUENCE {
        globalRANNodeID         GlobalRANNodeID,
        selectedTAI                     TAI,
        iE-Extensions           ProtocolExtensionContainer { {TargetRANNodeID-RIM-ExtIEs} } OPTIONAL,
        ...
}

TargetRANNodeID-RIM-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

TargetRANNodeID-SON ::= SEQUENCE {
        globalRANNodeID         GlobalRANNodeID,
        selectedTAI                     TAI,
        iE-Extensions           ProtocolExtensionContainer { {TargetRANNodeID-SON-ExtIEs} } OPTIONAL,
        ...
}

TargetRANNodeID-SON-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        {ID id-NR-CGI   CRITICALITY ignore      EXTENSION NR-CGI PRESENCE optional },
        ...
}

TargetRNC-ID ::= SEQUENCE {
        lAI                                     LAI,
        rNC-ID                          RNC-ID,
        extendedRNC-ID          ExtendedRNC-ID                                                                                  OPTIONAL,
        iE-Extensions           ProtocolExtensionContainer { {TargetRNC-ID-ExtIEs} }    OPTIONAL,
        ...
}

TargetRNC-ID-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

TargetToSource-TransparentContainer ::= OCTET STRING
-- This IE includes a transparent container from the target RAN node to the source RAN node.
-- The octets of the OCTET STRING are encoded according to the specifications of the target system.

TargettoSource-Failure-TransparentContainer ::= OCTET STRING
-- This IE includes a transparent container from the target RAN node to the source RAN node.
-- The octets of the OCTET STRING are encoded according to the specifications of the target system (if applicable).

TimeBasedHandoverInformation ::= SEQUENCE {
        hOWindowStart                   HandoverWindowStart,
        hOWindowDuration                HandoverWindowDuration,
        iE-Extensions                   ProtocolExtensionContainer { {TimeBasedHandoverInformation-ExtIEs} }    OPTIONAL,
        ...
}

TimeBasedHandoverInformation-ExtIEs     NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

HandoverWindowStart ::= INTEGER (0..549755813887)

HandoverWindowDuration ::= INTEGER (1..6000)

TimerApproachForGUAMIRemoval ::= ENUMERATED {
        apply-timer,
        ...
}

TimeSinceFailure ::= INTEGER (0..172800, ...)

TimeStamp ::= OCTET STRING (SIZE(4))

TimeSyncAssistanceInfo ::= SEQUENCE {
        timeDistributionIndication              ENUMERATED {enabled, disabled, ...},
        uUTimeSyncErrorBudget                   INTEGER (1..1000000, ...)                                                       OPTIONAL,
-- The above IE shall be present if the Time Distribution Indication IE is set to the value “enabled”
        iE-Extensions           ProtocolExtensionContainer { {TimeSyncAssistanceInfo-ExtIEs} }  OPTIONAL,
        ...
}

TimeSyncAssistanceInfo-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        { ID id-ClockQualityReportingControlInfo        CRITICALITY ignore      EXTENSION ClockQualityReportingControlInfo              PRESENCE optional},
        ...
}

TimeToWait ::= ENUMERATED {v1s, v2s, v5s, v10s, v20s, v60s, ...}

TimeUEStayedInCell ::= INTEGER (0..4095)

TimeUEStayedInCellEnhancedGranularity ::= INTEGER (0..40950)

TMGI ::=  OCTET STRING (SIZE(6))

TNAP-ID ::= OCTET STRING

TNGF-ID ::= CHOICE {
        tNGF-ID                                 BIT STRING (SIZE(32, ...)),
        choice-Extensions               ProtocolIE-SingleContainer { {TNGF-ID-ExtIEs} }
}

TNGF-ID-ExtIEs NGAP-PROTOCOL-IES ::= {
        ...
}

TNLAddressWeightFactor ::= INTEGER (0..255)

TNLAssociationList ::= SEQUENCE (SIZE(1..maxnoofTNLAssociations)) OF TNLAssociationItem

TNLAssociationItem ::= SEQUENCE {
        tNLAssociationAddress           CPTransportLayerInformation,
        cause                                           Cause,
        iE-Extensions           ProtocolExtensionContainer { {TNLAssociationItem-ExtIEs} } OPTIONAL,
        ...
}

TNLAssociationItem-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

TNLAssociationUsage ::= ENUMERATED {
        ue,
        non-ue,
        both,
        ...
}

TooearlyIntersystemHO::= SEQUENCE {
        sourcecellID                    EUTRA-CGI,
        failurecellID                   NGRAN-CGI,
        uERLFReportContainer    UERLFReportContainer            OPTIONAL,
        iE-Extensions                   ProtocolExtensionContainer { { TooearlyIntersystemHO-ExtIEs} }                  OPTIONAL,
        ...
}

TooearlyIntersystemHO-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

TraceActivation ::= SEQUENCE {
        nGRANTraceID                                            NGRANTraceID,
        interfacesToTrace                                       InterfacesToTrace,
        traceDepth                                                      TraceDepth,
        traceCollectionEntityIPAddress          TransportLayerAddress,
        iE-Extensions           ProtocolExtensionContainer { {TraceActivation-ExtIEs} } OPTIONAL,
        ...
}

TraceActivation-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        { ID id-MDTConfiguration                        CRITICALITY ignore      EXTENSION MDT-Configuration             PRESENCE optional       }|
        { ID id-TraceCollectionEntityURI        CRITICALITY ignore      EXTENSION URI-address                   PRESENCE optional               },
        ...
}

TraceDepth ::= ENUMERATED {
        minimum,
        medium,
        maximum,
        minimumWithoutVendorSpecificExtension,
        mediumWithoutVendorSpecificExtension,
        maximumWithoutVendorSpecificExtension,
        ...
}

TrafficLoadReductionIndication ::= INTEGER (1..99)

TransportLayerAddress ::= BIT STRING (SIZE(1..160, ...))

TypeOfError ::= ENUMERATED {
        not-understood,
        missing,
        ...
}

TAIBasedMDT ::= SEQUENCE {
        tAIListforMDT                   TAIListforMDT,
        iE-Extensions                   ProtocolExtensionContainer { {TAIBasedMDT-ExtIEs} } OPTIONAL,
        ...
}

TAIBasedMDT-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

TAIListforMDT ::= SEQUENCE (SIZE(1..maxnoofTAforMDT)) OF TAI

TAIBasedQMC ::= SEQUENCE {
        tAIListforQMC                   TAIListforQMC,
        iE-Extensions                   ProtocolExtensionContainer { {TAIBasedQMC-ExtIEs} } OPTIONAL,
        ...
}

TAIBasedQMC-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

TAIListforQMC ::= SEQUENCE (SIZE(1..maxnoofTAforQMC)) OF TAI

TABasedQMC ::= SEQUENCE {
        tAListforQMC                    TAListforQMC,
        iE-Extensions           ProtocolExtensionContainer { {TABasedQMC-ExtIEs} } OPTIONAL,
        ...
}

TABasedQMC-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

TAListforQMC ::= SEQUENCE (SIZE(1..maxnoofTAforQMC)) OF TAC


TABasedMDT ::= SEQUENCE {
        tAListforMDT            TAListforMDT,
        iE-Extensions           ProtocolExtensionContainer { {TABasedMDT-ExtIEs} } OPTIONAL,
        ...
}

TABasedMDT-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

TAListforMDT ::= SEQUENCE (SIZE(1..maxnoofTAforMDT)) OF TAC

Threshold-RSRP ::= INTEGER(0..127)

Threshold-RSRQ ::= INTEGER(0..127)

Threshold-SINR ::= INTEGER(0..127)

TimeToTrigger ::= ENUMERATED {ms0, ms40, ms64, ms80, ms100, ms128, ms160, ms256, ms320, ms480, ms512, ms640, ms1024, ms1280, ms2560, ms5120}

TLContainer ::= OCTET STRING


TWAP-ID ::= OCTET STRING

TWIF-ID ::= CHOICE {
        tWIF-ID                                 BIT STRING (SIZE(32, ...)),
        choice-Extensions               ProtocolIE-SingleContainer { {TWIF-ID-ExtIEs} }
}

TWIF-ID-ExtIEs NGAP-PROTOCOL-IES ::= {
        ...
}

TSCAssistanceInformation ::= SEQUENCE {
        periodicity                             Periodicity,
        burstArrivalTime                BurstArrivalTime                                                                                                OPTIONAL,
        iE-Extensions           ProtocolExtensionContainer { {TSCAssistanceInformation-ExtIEs} }        OPTIONAL,
        ...
}

TSCAssistanceInformation-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        { ID id-SurvivalTime            CRITICALITY ignore      EXTENSION SurvivalTime                  PRESENCE optional}|
        { ID id-RANfeedbacktype         CRITICALITY ignore      EXTENSION RANfeedbacktype               PRESENCE optional}|
        { ID id-N6JitterInformation     CRITICALITY ignore      EXTENSION N6JitterInformation   PRESENCE optional},
        ...
}

TSCTrafficCharacteristics ::= SEQUENCE {
        tSCAssistanceInformationDL              TSCAssistanceInformation                                                                OPTIONAL,
        tSCAssistanceInformationUL              TSCAssistanceInformation                                                                OPTIONAL,
        iE-Extensions           ProtocolExtensionContainer { {TSCTrafficCharacteristics-ExtIEs} }       OPTIONAL,
        ...
}

TSCTrafficCharacteristics-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

TSCTrafficCharacteristicsFeedback ::= SEQUENCE {
        tSCFeedbackInformationDL                TSCFeedbackInformation                                                          OPTIONAL,
        tSCFeedbackInformationUL                TSCFeedbackInformation                                                          OPTIONAL,
        iE-Extensions           ProtocolExtensionContainer { { TSCTrafficCharacteristicsFeedback-ExtIEs} }      OPTIONAL,
        ...
}

TSCTrafficCharacteristicsFeedback-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

TSCFeedbackInformation ::= SEQUENCE {
        burstArrivalTimeOffset                                                  INTEGER (-640000..640000, ...),
        adjustedPeriodicity                                                             Periodicity                                                     OPTIONAL,
        iE-Extensions           ProtocolExtensionContainer { { TSCFeedbackInformation-ExtIEs} } OPTIONAL,
        ...
}

TSCFeedbackInformation-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

-- U

UEAggregateMaximumBitRate ::= SEQUENCE {
        uEAggregateMaximumBitRateDL             BitRate,
        uEAggregateMaximumBitRateUL             BitRate,
        iE-Extensions           ProtocolExtensionContainer { {UEAggregateMaximumBitRate-ExtIEs} } OPTIONAL,
        ...
}

UEAggregateMaximumBitRate-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

UEAppLayerMeasInfoList ::= SEQUENCE (SIZE(1..maxnoofUEAppLayerMeas)) OF UEAppLayerMeasInfoItem

UEAppLayerMeasInfoItem ::= SEQUENCE {
        uEAppLayerMeasConfigInfo                UEAppLayerMeasConfigInfo,
        iE-Extensions           ProtocolExtensionContainer { { UEAppLayerMeasInfoItem-ExtIEs} } OPTIONAL,
        ...
}

UEAppLayerMeasInfoItem-ExtIEs NGAP-PROTOCOL-EXTENSION::= {
        ...
}

UEAppLayerMeasConfigInfo ::= SEQUENCE {
        qoEReference                                                            QoEReference,
        serviceType                                                             ServiceType,
        areaScopeOfQMC                                                  AreaScopeOfQMC                                                          OPTIONAL,
        measCollEntityIPAddress                                 TransportLayerAddress,
        qoEMeasurementStatus                                    ENUMERATED {ongoing,...}                                        OPTIONAL,
        containerForAppLayerMeasConfig                  OCTET STRING (SIZE(1..8000))                            OPTIONAL,
        measConfigAppLayerID                                    INTEGER (0..15, ...)                                            OPTIONAL,
        sliceSupportListQMC                                             SliceSupportListQMC                                             OPTIONAL,
        mDT-AlignmentInfo                                               MDT-AlignmentInfo                                                       OPTIONAL,
        availableRANVisibleQoEMetrics                   AvailableRANVisibleQoEMetrics                           OPTIONAL,
        iE-Extensions   ProtocolExtensionContainer { { UEAppLayerMeasConfigInfo-ExtIEs} }               OPTIONAL,
        ...
}

UEAppLayerMeasConfigInfo-ExtIEs NGAP-PROTOCOL-EXTENSION::= {
        { ID id-AssistanceInformationQoE-Meas           CRITICALITY ignore      EXTENSION AssistanceInformationQoE-Meas         PRESENCE optional       }|
        { ID id-MBSCommServiceType                                      CRITICALITY ignore      EXTENSION MBSCommServiceType                                            PRESENCE optional       }|
        { ID id-QoERVQoEReportingPaths                          CRITICALITY ignore      EXTENSION QoERVQoEReportingPaths                                        PRESENCE optional },
        ...
}

UE-associatedLogicalNG-connectionList ::= SEQUENCE (SIZE(1..maxnoofNGConnectionsToReset)) OF UE-associatedLogicalNG-connectionItem

UE-associatedLogicalNG-connectionItem ::= SEQUENCE {
        aMF-UE-NGAP-ID          AMF-UE-NGAP-ID                                                                                                                                          OPTIONAL,
        rAN-UE-NGAP-ID          RAN-UE-NGAP-ID                                                                                                                                          OPTIONAL,
        iE-Extensions           ProtocolExtensionContainer { {UE-associatedLogicalNG-connectionItem-ExtIEs} }   OPTIONAL,
        ...
}

UE-associatedLogicalNG-connectionItem-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

UECapabilityInfoRequest ::= ENUMERATED {
        requested,
        ...
}

UEContextRequest ::= ENUMERATED {requested, ...}


UEContextResumeRequestTransfer ::= SEQUENCE {
        qosFlowFailedToResumeList                               QosFlowListWithCause                                                                    OPTIONAL,
        iE-Extensions           ProtocolExtensionContainer { {UEContextResumeRequestTransfer-ExtIEs} }          OPTIONAL,
        ...
}

UEContextResumeRequestTransfer-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

UEContextResumeResponseTransfer ::= SEQUENCE {
        qosFlowFailedToResumeList                               QosFlowListWithCause                                                                    OPTIONAL,
        iE-Extensions           ProtocolExtensionContainer { {UEContextResumeResponseTransfer-ExtIEs} }         OPTIONAL,
        ...
}

UEContextResumeResponseTransfer-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

UEContextSuspendRequestTransfer ::= SEQUENCE {
        suspendIndicator                                SuspendIndicator                                                                                                OPTIONAL,
        iE-Extensions           ProtocolExtensionContainer { {UEContextSuspendRequestTransfer-ExtIEs} }         OPTIONAL,
        ...
}

UEContextSuspendRequestTransfer-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

UE-DifferentiationInfo ::= SEQUENCE {
        periodicCommunicationIndicator  ENUMERATED {periodically, ondemand, ... }                                                       OPTIONAL,
        periodicTime                                    INTEGER (1..3600, ...)                                                                                          OPTIONAL,
        scheduledCommunicationTime              ScheduledCommunicationTime                                                                                      OPTIONAL,
        stationaryIndication                    ENUMERATED {stationary, mobile, ...}                                                            OPTIONAL,
        trafficProfile                                  ENUMERATED {single-packet, dual-packets, multiple-packets, ...} OPTIONAL,
        batteryIndication                               ENUMERATED {battery-powered, battery-powered-not-rechargeable-or-replaceable, not-battery-powered, ...}         OPTIONAL,
        iE-Extensions           ProtocolExtensionContainer { { UE-DifferentiationInfo-ExtIEs} } OPTIONAL,
        ...
}

UE-DifferentiationInfo-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

UEHistoryInformation ::= SEQUENCE (SIZE(1..maxnoofCellsinUEHistoryInfo)) OF LastVisitedCellItem

UEHistoryInformationFromTheUE ::= CHOICE {
        nR                                              NRMobilityHistoryReport,
        choice-Extensions               ProtocolIE-SingleContainer { {UEHistoryInformationFromTheUE-ExtIEs} }
}

UEHistoryInformationFromTheUE-ExtIEs NGAP-PROTOCOL-IES ::= {
        ...
}

UEIdentityIndexValue ::= CHOICE {
        indexLength10                   BIT STRING (SIZE(10)),
        choice-Extensions               ProtocolIE-SingleContainer { {UEIdentityIndexValue-ExtIEs} }
}

UEIdentityIndexValue-ExtIEs NGAP-PROTOCOL-IES ::= {
        ...
}

UE-NGAP-IDs ::= CHOICE {
        uE-NGAP-ID-pair         UE-NGAP-ID-pair,
        aMF-UE-NGAP-ID          AMF-UE-NGAP-ID,
        choice-Extensions               ProtocolIE-SingleContainer { {UE-NGAP-IDs-ExtIEs} }
}

UE-NGAP-IDs-ExtIEs NGAP-PROTOCOL-IES ::= {
        ...
}

UE-NGAP-ID-pair ::= SEQUENCE{
        aMF-UE-NGAP-ID          AMF-UE-NGAP-ID,
        rAN-UE-NGAP-ID          RAN-UE-NGAP-ID,
        iE-Extensions           ProtocolExtensionContainer { {UE-NGAP-ID-pair-ExtIEs} } OPTIONAL,
        ...
}

UE-NGAP-ID-pair-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

UEPagingIdentity ::= CHOICE {
        fiveG-S-TMSI            FiveG-S-TMSI,
        choice-Extensions               ProtocolIE-SingleContainer { {UEPagingIdentity-ExtIEs} }
        }

UEPagingIdentity-ExtIEs NGAP-PROTOCOL-IES ::= {
        ...
}

UEPresence ::= ENUMERATED {in, out, unknown, ...}

UEPresenceInAreaOfInterestList ::= SEQUENCE (SIZE(1..maxnoofAoI)) OF UEPresenceInAreaOfInterestItem

UEPresenceInAreaOfInterestItem ::= SEQUENCE {
        locationReportingReferenceID            LocationReportingReferenceID,
        uEPresence                                                      UEPresence,
        iE-Extensions           ProtocolExtensionContainer { {UEPresenceInAreaOfInterestItem-ExtIEs} }  OPTIONAL,
        ...
}

UEPresenceInAreaOfInterestItem-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

UERadioCapability ::= OCTET STRING

UERadioCapabilityForPaging ::= SEQUENCE {
        uERadioCapabilityForPagingOfNR          UERadioCapabilityForPagingOfNR                                  OPTIONAL,
        uERadioCapabilityForPagingOfEUTRA               UERadioCapabilityForPagingOfEUTRA                               OPTIONAL,
        iE-Extensions           ProtocolExtensionContainer { {UERadioCapabilityForPaging-ExtIEs} }      OPTIONAL,
        ...
}

UERadioCapabilityForPaging-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        { ID id-UERadioCapabilityForPagingOfNB-IoT              CRITICALITY ignore      EXTENSION UERadioCapabilityForPagingOfNB-IoT            PRESENCE optional       },
        ...
}

UERadioCapabilityForPagingOfNB-IoT ::= OCTET STRING

UERadioCapabilityForPagingOfNR ::= OCTET STRING

UERadioCapabilityForPagingOfEUTRA ::= OCTET STRING

UERadioCapabilityID ::= OCTET STRING

UERetentionInformation ::= ENUMERATED {
        ues-retained,
        ...
}

UERLFReportContainer ::= CHOICE {
        nR                      NRUERLFReportContainer,
        lTE                     LTEUERLFReportContainer,
        choice-Extensions               ProtocolIE-SingleContainer { {UERLFReportContainer-ExtIEs} }
}

UERLFReportContainer-ExtIEs NGAP-PROTOCOL-IES ::= {
        ...
}

UESecurityCapabilities ::= SEQUENCE {
        nRencryptionAlgorithms                                  NRencryptionAlgorithms,
        nRintegrityProtectionAlgorithms                 NRintegrityProtectionAlgorithms,
        eUTRAencryptionAlgorithms                               EUTRAencryptionAlgorithms,
        eUTRAintegrityProtectionAlgorithms              EUTRAintegrityProtectionAlgorithms,
        iE-Extensions           ProtocolExtensionContainer { {UESecurityCapabilities-ExtIEs} }  OPTIONAL,
        ...
}

UESecurityCapabilities-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

UESliceMaximumBitRateList ::= SEQUENCE (SIZE(1..maxnoofAllowedS-NSSAIs)) OF UESliceMaximumBitRateItem

UESliceMaximumBitRateItem ::= SEQUENCE {
        s-NSSAI                                         S-NSSAI,
        uESliceMaximumBitRateDL         BitRate,
        uESliceMaximumBitRateUL         BitRate,
        iE-Extensions           ProtocolExtensionContainer { { UESliceMaximumBitRateItem-ExtIEs} } OPTIONAL,
        ...
}

UESliceMaximumBitRateItem-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}


UE-UP-CIoT-Support ::= ENUMERATED {supported, ...}

UL-CP-SecurityInformation ::= SEQUENCE {
        ul-NAS-MAC                              UL-NAS-MAC,
        ul-NAS-Count                    UL-NAS-Count,
        iE-Extensions                   ProtocolExtensionContainer { { UL-CP-SecurityInformation-ExtIEs} }      OPTIONAL,
        ...
}

UL-CP-SecurityInformation-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

UL-NAS-MAC ::= BIT STRING (SIZE (16))

UL-NAS-Count ::= BIT STRING (SIZE (5))

UL-NGU-UP-TNLModifyList ::= SEQUENCE (SIZE(1..maxnoofMultiConnectivity)) OF UL-NGU-UP-TNLModifyItem

UL-NGU-UP-TNLModifyItem ::= SEQUENCE {
        uL-NGU-UP-TNLInformation                UPTransportLayerInformation,
        dL-NGU-UP-TNLInformation                UPTransportLayerInformation,
        iE-Extensions           ProtocolExtensionContainer { {UL-NGU-UP-TNLModifyItem-ExtIEs} } OPTIONAL,
        ...
}

UL-NGU-UP-TNLModifyItem-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        { ID id-RedundantUL-NGU-UP-TNLInformation       CRITICALITY ignore      EXTENSION UPTransportLayerInformation           PRESENCE optional               }|
        { ID id-RedundantDL-NGU-UP-TNLInformation       CRITICALITY ignore      EXTENSION UPTransportLayerInformation           PRESENCE optional               },
        ...
}

UnavailableGUAMIList ::= SEQUENCE (SIZE(1..maxnoofServedGUAMIs)) OF UnavailableGUAMIItem

UnavailableGUAMIItem ::= SEQUENCE {
        gUAMI                                                           GUAMI,
        timerApproachForGUAMIRemoval            TimerApproachForGUAMIRemoval                                    OPTIONAL,
        backupAMFName                                           AMFName                                                                                 OPTIONAL,
        iE-Extensions           ProtocolExtensionContainer { {UnavailableGUAMIItem-ExtIEs} }    OPTIONAL,
        ...
}

UnavailableGUAMIItem-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

ULForwarding ::= ENUMERATED {
        ul-forwarding-proposed,
        ...
}

UpdateFeedback ::= BIT STRING (SIZE(8, ...))

UPTransportLayerInformation ::= CHOICE {
        gTPTunnel                               GTPTunnel,
        choice-Extensions               ProtocolIE-SingleContainer { {UPTransportLayerInformation-ExtIEs} }
}

UPTransportLayerInformation-ExtIEs NGAP-PROTOCOL-IES ::= {
        ...
}

UPTransportLayerInformationList ::= SEQUENCE (SIZE(1..maxnoofMultiConnectivityMinusOne)) OF UPTransportLayerInformationItem

UPTransportLayerInformationItem ::= SEQUENCE {
        nGU-UP-TNLInformation           UPTransportLayerInformation,
        iE-Extensions           ProtocolExtensionContainer { {UPTransportLayerInformationItem-ExtIEs} } OPTIONAL,
        ...
}

UPTransportLayerInformationItem-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        { ID id-CommonNetworkInstance                           CRITICALITY ignore      EXTENSION  CommonNetworkInstance                                                PRESENCE optional               },
        ...
}


UPTransportLayerInformationPairList ::= SEQUENCE (SIZE(1..maxnoofMultiConnectivityMinusOne)) OF UPTransportLayerInformationPairItem

UPTransportLayerInformationPairItem ::= SEQUENCE {
        uL-NGU-UP-TNLInformation                UPTransportLayerInformation,
        dL-NGU-UP-TNLInformation                UPTransportLayerInformation,
        iE-Extensions           ProtocolExtensionContainer { {UPTransportLayerInformationPairItem-ExtIEs} } OPTIONAL,
        ...
}

UPTransportLayerInformationPairItem-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

URI-address ::= VisibleString

UserLocationInformation ::= CHOICE {
        userLocationInformationEUTRA    UserLocationInformationEUTRA,
        userLocationInformationNR               UserLocationInformationNR,
        userLocationInformationN3IWF    UserLocationInformationN3IWF,
        choice-Extensions               ProtocolIE-SingleContainer { {UserLocationInformation-ExtIEs} }
}

UserLocationInformation-ExtIEs NGAP-PROTOCOL-IES ::= {
        { ID id-UserLocationInformationTNGF             CRITICALITY ignore      TYPE UserLocationInformationTNGF                PRESENCE mandatory      }|
        { ID id-UserLocationInformationTWIF             CRITICALITY ignore      TYPE UserLocationInformationTWIF                PRESENCE mandatory      }|
        { ID id-UserLocationInformationW-AGF    CRITICALITY ignore      TYPE UserLocationInformationW-AGF               PRESENCE mandatory      },
        ...
}

UserLocationInformationEUTRA ::= SEQUENCE {
        eUTRA-CGI                       EUTRA-CGI,
        tAI                                     TAI,
        timeStamp                       TimeStamp                                                                                                                               OPTIONAL,
        iE-Extensions           ProtocolExtensionContainer { {UserLocationInformationEUTRA-ExtIEs} }    OPTIONAL,
        ...
}

UserLocationInformationEUTRA-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        { ID id-PSCellInformation       CRITICALITY ignore      EXTENSION NGRAN-CGI                             PRESENCE optional},
        ...
}

UserLocationInformationN3IWF ::= SEQUENCE {
        iPAddress                       TransportLayerAddress,
        portNumber                      PortNumber,
        iE-Extensions           ProtocolExtensionContainer { {UserLocationInformationN3IWF-ExtIEs} }    OPTIONAL,
        ...
}

UserLocationInformationN3IWF-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        { ID id-TAI                     CRITICALITY ignore      EXTENSION TAI                                                   PRESENCE optional       },
        ...
}

UserLocationInformationTNGF ::= SEQUENCE {
        tNAP-ID                         TNAP-ID,
        iPAddress                       TransportLayerAddress,
        portNumber                      PortNumber                                                                                                                      OPTIONAL,
        iE-Extensions           ProtocolExtensionContainer { {UserLocationInformationTNGF-ExtIEs} }     OPTIONAL,
        ...
}

UserLocationInformationTNGF-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        { ID id-TAI                     CRITICALITY ignore      EXTENSION TAI                                                   PRESENCE optional       },
        ...
}

UserLocationInformationTWIF ::= SEQUENCE {
        tWAP-ID                         TWAP-ID,
        iPAddress                       TransportLayerAddress,
        portNumber                      PortNumber                                                                                                                      OPTIONAL,
        iE-Extensions           ProtocolExtensionContainer { {UserLocationInformationTWIF-ExtIEs} }     OPTIONAL,
        ...
}

UserLocationInformationTWIF-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        { ID id-TAI                     CRITICALITY ignore      EXTENSION TAI                                                   PRESENCE optional       },
        ...
}

UserLocationInformationW-AGF ::= CHOICE {
        globalLine-ID   GlobalLine-ID,
        hFCNode-ID              HFCNode-ID,
        choice-Extensions               ProtocolIE-SingleContainer { { UserLocationInformationW-AGF-ExtIEs} }
}

UserLocationInformationW-AGF-ExtIEs NGAP-PROTOCOL-IES ::= {
        { ID id-GlobalCable-ID  CRITICALITY     ignore  TYPE    GlobalCable-ID          PRESENCE        mandatory }|
        { ID id-HFCNode-ID-new  CRITICALITY     ignore  TYPE    HFCNode-ID-new          PRESENCE        mandatory }|
        { ID id-GlobalCable-ID-new      CRITICALITY ignore      TYPE    GlobalCable-ID-new      PRESENCE        mandatory },
        ...
}

UserLocationInformationNR ::= SEQUENCE {
        nR-CGI                          NR-CGI,
        tAI                                     TAI,
        timeStamp                       TimeStamp                                                                                                                       OPTIONAL,
        iE-Extensions           ProtocolExtensionContainer { {UserLocationInformationNR-ExtIEs} }       OPTIONAL,
        ...
}

UserLocationInformationNR-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        { ID id-PSCellInformation                                               CRITICALITY ignore      EXTENSION NGRAN-CGI                                                                                     PRESENCE optional       }|
        { ID id-NID                                                                             CRITICALITY reject      EXTENSION NID                                                                                           PRESENCE optional       }|
        { ID id-NRNTNTAIInformation                                             CRITICALITY ignore      EXTENSION NRNTNTAIInformation                                                   PRESENCE optional       }|
        { ID id-MobileIAB-MTUserLocationInformation             CRITICALITY ignore      EXTENSION MobileIAB-MTUserLocationInformation           PRESENCE optional       },
        ...
}

UserPlaneFailureIndication ::= SEQUENCE {
        userPlaneFailureType                            UserPlaneFailureType,
        uL-NGU-UP-TNLInformation                        UPTransportLayerInformation,
        dL-NGU-UP-TNLInformation                        UPTransportLayerInformation,
        iE-Extensions           ProtocolExtensionContainer { { UserPlaneFailureIndication-ExtIEs} }     OPTIONAL,
        ...
}

UserPlaneFailureIndication-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

UserPlaneFailureIndicationReport ::= ENUMERATED {
        qos-flows-and-tunnel-to-be-released,
        qoS-flows-to-be-moved,
        new-transport-address-allocated,
        ...
}


UserPlaneFailureType ::= ENUMERATED {
        gtp-u-error-indication-received,
        up-path-failure,
        ...
}

UserPlaneSecurityInformation ::= SEQUENCE {
        securityResult                  SecurityResult,
        securityIndication              SecurityIndication,
        iE-Extensions           ProtocolExtensionContainer { {UserPlaneSecurityInformation-ExtIEs} }    OPTIONAL,
        ...
}

UserPlaneSecurityInformation-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

-- V

VolumeTimedReportList ::= SEQUENCE (SIZE(1..maxnoofTimePeriods)) OF VolumeTimedReport-Item

VolumeTimedReport-Item ::= SEQUENCE {
        startTimeStamp                          OCTET STRING (SIZE(4)),
        endTimeStamp                            OCTET STRING (SIZE(4)),
        usageCountUL                            INTEGER (0..18446744073709551615),
        usageCountDL                            INTEGER (0..18446744073709551615),
        iE-Extensions           ProtocolExtensionContainer { {VolumeTimedReport-Item-ExtIEs} } OPTIONAL,
        ...
}

VolumeTimedReport-Item-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

-- W

W-AGF-ID ::= CHOICE {
        w-AGF-ID                                BIT STRING (SIZE(16, ...)),
        choice-Extensions               ProtocolIE-SingleContainer { {W-AGF-ID-ExtIEs} }
}

W-AGF-ID-ExtIEs NGAP-PROTOCOL-IES ::= {
        ...
}

WarningAreaCoordinates ::= OCTET STRING (SIZE(1..1024))

WarningAreaList ::= CHOICE {
        eUTRA-CGIListForWarning                 EUTRA-CGIListForWarning,
        nR-CGIListForWarning                    NR-CGIListForWarning,
        tAIListForWarning                               TAIListForWarning,
        emergencyAreaIDList                             EmergencyAreaIDList,
        choice-Extensions               ProtocolIE-SingleContainer { {WarningAreaList-ExtIEs} }
}

WarningAreaList-ExtIEs NGAP-PROTOCOL-IES ::= {
        ...
}

WarningMessageContents ::= OCTET STRING (SIZE(1..9600))

WarningSecurityInfo ::= OCTET STRING (SIZE(50))

WarningType ::= OCTET STRING (SIZE(2))

WLANMeasurementConfiguration ::= SEQUENCE {
        wlanMeasConfig                  WLANMeasConfig,
        wlanMeasConfigNameList          WLANMeasConfigNameList                                                                          OPTIONAL,
        wlan-rssi                       ENUMERATED {true, ...}                                                                          OPTIONAL,
        wlan-rtt                        ENUMERATED {true, ...}                                                                          OPTIONAL,
        iE-Extensions           ProtocolExtensionContainer { { WLANMeasurementConfiguration-ExtIEs } }  OPTIONAL,
        ...
}

WLANMeasurementConfiguration-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

WLANMeasConfigNameList ::= SEQUENCE (SIZE(1..maxnoofWLANName)) OF WLANMeasConfigNameItem

WLANMeasConfigNameItem ::= SEQUENCE {
        wLANName                        WLANName,
        iE-Extensions           ProtocolExtensionContainer { { WLANMeasConfigNameItem-ExtIEs } }        OPTIONAL,
        ...
}

WLANMeasConfigNameItem-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

WLANMeasConfig::= ENUMERATED {setup,...}

WLANName ::= OCTET STRING (SIZE (1..32))

WUS-Assistance-Information  ::= SEQUENCE {
        pagingProbabilityInformation             PagingProbabilityInformation,
        iE-Extensions           ProtocolExtensionContainer { { WUS-Assistance-Information-ExtIEs } } OPTIONAL,
        ...
}

WUS-Assistance-Information-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

-- X

XnExtTLAs ::= SEQUENCE (SIZE(1..maxnoofXnExtTLAs)) OF XnExtTLA-Item

XnExtTLA-Item ::= SEQUENCE {
        iPsecTLA                                        TransportLayerAddress                                                   OPTIONAL,
        gTP-TLAs                                        XnGTP-TLAs                                                                              OPTIONAL,
        iE-Extensions           ProtocolExtensionContainer { {XnExtTLA-Item-ExtIEs} }   OPTIONAL,
        ...
}

XnExtTLA-Item-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        { ID id-SCTP-TLAs               CRITICALITY ignore      EXTENSION SCTP-TLAs             PRESENCE optional },
        ...
}

XnGTP-TLAs ::= SEQUENCE (SIZE(1..maxnoofXnGTP-TLAs)) OF TransportLayerAddress

XnTLAs ::= SEQUENCE (SIZE(1..maxnoofXnTLAs)) OF TransportLayerAddress

XnTNLConfigurationInfo ::= SEQUENCE {
        xnTransportLayerAddresses                       XnTLAs,
        xnExtendedTransportLayerAddresses       XnExtTLAs                                                                               OPTIONAL,
        iE-Extensions           ProtocolExtensionContainer { {XnTNLConfigurationInfo-ExtIEs} }  OPTIONAL,
        ...
}

XnTNLConfigurationInfo-ExtIEs NGAP-PROTOCOL-EXTENSION ::= {
        ...
}

XrDeviceWith2Rx ::= ENUMERATED {true, ...}

-- Y
-- Z

END