X-Git-Url: https://gerrit.o-ran-sc.org/r/gitweb?a=blobdiff_plain;f=protogen%2Fgopb%2Fx2ap_common_types.pb.go;fp=protogen%2Fgopb%2Fx2ap_common_types.pb.go;h=8cd246bdabe436438e4a4fda39f3c6aa18e65a9c;hb=ddc4d67d57e952b8476e44d7a101798b2fdf4eae;hp=0000000000000000000000000000000000000000;hpb=01e651a425e83b914a4b30e19a3a843ce86154d1;p=ric-plt%2Fstreaming-protobufs.git diff --git a/protogen/gopb/x2ap_common_types.pb.go b/protogen/gopb/x2ap_common_types.pb.go new file mode 100644 index 0000000..8cd246b --- /dev/null +++ b/protogen/gopb/x2ap_common_types.pb.go @@ -0,0 +1,4376 @@ +// Code generated by protoc-gen-go. DO NOT EDIT. +// source: x2ap_common_types.proto + +package streaming_protobufs + +import ( + fmt "fmt" + proto "github.com/golang/protobuf/proto" + wrappers "github.com/golang/protobuf/ptypes/wrappers" + math "math" +) + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the proto package it is being compiled against. +// A compilation error at this line likely means your copy of the +// proto package needs to be updated. +const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package + +type EN_DC_ResourceConfiguration_Status int32 + +const ( + EN_DC_ResourceConfiguration_protobuf_unspecified EN_DC_ResourceConfiguration_Status = 0 + EN_DC_ResourceConfiguration_present EN_DC_ResourceConfiguration_Status = 1 + EN_DC_ResourceConfiguration_not_present EN_DC_ResourceConfiguration_Status = 2 +) + +var EN_DC_ResourceConfiguration_Status_name = map[int32]string{ + 0: "protobuf_unspecified", + 1: "present", + 2: "not_present", +} + +var EN_DC_ResourceConfiguration_Status_value = map[string]int32{ + "protobuf_unspecified": 0, + "present": 1, + "not_present": 2, +} + +func (x EN_DC_ResourceConfiguration_Status) String() string { + return proto.EnumName(EN_DC_ResourceConfiguration_Status_name, int32(x)) +} + +func (EN_DC_ResourceConfiguration_Status) EnumDescriptor() ([]byte, []int) { + return fileDescriptor_e082a304e8406c6c, []int{0, 0} +} + +type PreEmptionVulnerability_Value int32 + +const ( + PreEmptionVulnerability_protobuf_unspecified PreEmptionVulnerability_Value = 0 + PreEmptionVulnerability_not_pre_emptable PreEmptionVulnerability_Value = 1 + PreEmptionVulnerability_pre_emptable PreEmptionVulnerability_Value = 2 +) + +var PreEmptionVulnerability_Value_name = map[int32]string{ + 0: "protobuf_unspecified", + 1: "not_pre_emptable", + 2: "pre_emptable", +} + +var PreEmptionVulnerability_Value_value = map[string]int32{ + "protobuf_unspecified": 0, + "not_pre_emptable": 1, + "pre_emptable": 2, +} + +func (x PreEmptionVulnerability_Value) String() string { + return proto.EnumName(PreEmptionVulnerability_Value_name, int32(x)) +} + +func (PreEmptionVulnerability_Value) EnumDescriptor() ([]byte, []int) { + return fileDescriptor_e082a304e8406c6c, []int{3, 0} +} + +type PreEmptionCapability_Value int32 + +const ( + PreEmptionCapability_protobuf_unspecified PreEmptionCapability_Value = 0 + PreEmptionCapability_shall_not_trigger_pre_emption PreEmptionCapability_Value = 1 + PreEmptionCapability_may_trigger_pre_emption PreEmptionCapability_Value = 2 +) + +var PreEmptionCapability_Value_name = map[int32]string{ + 0: "protobuf_unspecified", + 1: "shall_not_trigger_pre_emption", + 2: "may_trigger_pre_emption", +} + +var PreEmptionCapability_Value_value = map[string]int32{ + "protobuf_unspecified": 0, + "shall_not_trigger_pre_emption": 1, + "may_trigger_pre_emption": 2, +} + +func (x PreEmptionCapability_Value) String() string { + return proto.EnumName(PreEmptionCapability_Value_name, int32(x)) +} + +func (PreEmptionCapability_Value) EnumDescriptor() ([]byte, []int) { + return fileDescriptor_e082a304e8406c6c, []int{4, 0} +} + +type RLCMode_Value int32 + +const ( + RLCMode_protobuf_unspecified RLCMode_Value = 0 + RLCMode_rlc_am RLCMode_Value = 1 + RLCMode_rlc_um_bidirectional RLCMode_Value = 2 + RLCMode_rlc_um_unidirectional_ul RLCMode_Value = 3 + RLCMode_rlc_um_unidirectional_dl RLCMode_Value = 4 +) + +var RLCMode_Value_name = map[int32]string{ + 0: "protobuf_unspecified", + 1: "rlc_am", + 2: "rlc_um_bidirectional", + 3: "rlc_um_unidirectional_ul", + 4: "rlc_um_unidirectional_dl", +} + +var RLCMode_Value_value = map[string]int32{ + "protobuf_unspecified": 0, + "rlc_am": 1, + "rlc_um_bidirectional": 2, + "rlc_um_unidirectional_ul": 3, + "rlc_um_unidirectional_dl": 4, +} + +func (x RLCMode_Value) String() string { + return proto.EnumName(RLCMode_Value_name, int32(x)) +} + +func (RLCMode_Value) EnumDescriptor() ([]byte, []int) { + return fileDescriptor_e082a304e8406c6c, []int{13, 0} +} + +type RLC_Status_Reestablishment_Indication int32 + +const ( + RLC_Status_protobuf_unspecified RLC_Status_Reestablishment_Indication = 0 + RLC_Status_reestablished RLC_Status_Reestablishment_Indication = 1 +) + +var RLC_Status_Reestablishment_Indication_name = map[int32]string{ + 0: "protobuf_unspecified", + 1: "reestablished", +} + +var RLC_Status_Reestablishment_Indication_value = map[string]int32{ + "protobuf_unspecified": 0, + "reestablished": 1, +} + +func (x RLC_Status_Reestablishment_Indication) String() string { + return proto.EnumName(RLC_Status_Reestablishment_Indication_name, int32(x)) +} + +func (RLC_Status_Reestablishment_Indication) EnumDescriptor() ([]byte, []int) { + return fileDescriptor_e082a304e8406c6c, []int{14, 0} +} + +type ULConfiguration_UL_UE_Configuration int32 + +const ( + ULConfiguration_protobuf_unspecified ULConfiguration_UL_UE_Configuration = 0 + ULConfiguration_no_data ULConfiguration_UL_UE_Configuration = 1 + ULConfiguration_shared ULConfiguration_UL_UE_Configuration = 2 + ULConfiguration_only ULConfiguration_UL_UE_Configuration = 3 +) + +var ULConfiguration_UL_UE_Configuration_name = map[int32]string{ + 0: "protobuf_unspecified", + 1: "no_data", + 2: "shared", + 3: "only", +} + +var ULConfiguration_UL_UE_Configuration_value = map[string]int32{ + "protobuf_unspecified": 0, + "no_data": 1, + "shared": 2, + "only": 3, +} + +func (x ULConfiguration_UL_UE_Configuration) String() string { + return proto.EnumName(ULConfiguration_UL_UE_Configuration_name, int32(x)) +} + +func (ULConfiguration_UL_UE_Configuration) EnumDescriptor() ([]byte, []int) { + return fileDescriptor_e082a304e8406c6c, []int{15, 0} +} + +type PDCPSnLength_Value int32 + +const ( + PDCPSnLength_protobuf_unspecified PDCPSnLength_Value = 0 + PDCPSnLength_twelve_bits PDCPSnLength_Value = 1 + PDCPSnLength_eighteen_bits PDCPSnLength_Value = 2 +) + +var PDCPSnLength_Value_name = map[int32]string{ + 0: "protobuf_unspecified", + 1: "twelve_bits", + 2: "eighteen_bits", +} + +var PDCPSnLength_Value_value = map[string]int32{ + "protobuf_unspecified": 0, + "twelve_bits": 1, + "eighteen_bits": 2, +} + +func (x PDCPSnLength_Value) String() string { + return proto.EnumName(PDCPSnLength_Value_name, int32(x)) +} + +func (PDCPSnLength_Value) EnumDescriptor() ([]byte, []int) { + return fileDescriptor_e082a304e8406c6c, []int{16, 0} +} + +type PDCPChangeIndication_Value int32 + +const ( + PDCPChangeIndication_protobuf_unspecified PDCPChangeIndication_Value = 0 + PDCPChangeIndication_s_KgNB_update_required PDCPChangeIndication_Value = 1 + PDCPChangeIndication_pDCP_data_recovery_required PDCPChangeIndication_Value = 2 +) + +var PDCPChangeIndication_Value_name = map[int32]string{ + 0: "protobuf_unspecified", + 1: "s_KgNB_update_required", + 2: "pDCP_data_recovery_required", +} + +var PDCPChangeIndication_Value_value = map[string]int32{ + "protobuf_unspecified": 0, + "s_KgNB_update_required": 1, + "pDCP_data_recovery_required": 2, +} + +func (x PDCPChangeIndication_Value) String() string { + return proto.EnumName(PDCPChangeIndication_Value_name, int32(x)) +} + +func (PDCPChangeIndication_Value) EnumDescriptor() ([]byte, []int) { + return fileDescriptor_e082a304e8406c6c, []int{17, 0} +} + +type SplitSRBs_Value int32 + +const ( + SplitSRBs_protobuf_unspecified SplitSRBs_Value = 0 + SplitSRBs_srb1 SplitSRBs_Value = 1 + SplitSRBs_srb2 SplitSRBs_Value = 2 + SplitSRBs_srb1and2 SplitSRBs_Value = 3 +) + +var SplitSRBs_Value_name = map[int32]string{ + 0: "protobuf_unspecified", + 1: "srb1", + 2: "srb2", + 3: "srb1and2", +} + +var SplitSRBs_Value_value = map[string]int32{ + "protobuf_unspecified": 0, + "srb1": 1, + "srb2": 2, + "srb1and2": 3, +} + +func (x SplitSRBs_Value) String() string { + return proto.EnumName(SplitSRBs_Value_name, int32(x)) +} + +func (SplitSRBs_Value) EnumDescriptor() ([]byte, []int) { + return fileDescriptor_e082a304e8406c6c, []int{18, 0} +} + +type UserPlaneTrafficActivityReport_Value int32 + +const ( + UserPlaneTrafficActivityReport_protobuf_unspecified UserPlaneTrafficActivityReport_Value = 0 + UserPlaneTrafficActivityReport_inactive UserPlaneTrafficActivityReport_Value = 1 + UserPlaneTrafficActivityReport_re_activated UserPlaneTrafficActivityReport_Value = 2 +) + +var UserPlaneTrafficActivityReport_Value_name = map[int32]string{ + 0: "protobuf_unspecified", + 1: "inactive", + 2: "re_activated", +} + +var UserPlaneTrafficActivityReport_Value_value = map[string]int32{ + "protobuf_unspecified": 0, + "inactive": 1, + "re_activated": 2, +} + +func (x UserPlaneTrafficActivityReport_Value) String() string { + return proto.EnumName(UserPlaneTrafficActivityReport_Value_name, int32(x)) +} + +func (UserPlaneTrafficActivityReport_Value) EnumDescriptor() ([]byte, []int) { + return fileDescriptor_e082a304e8406c6c, []int{28, 0} +} + +type GNBOverloadInformation_Value int32 + +const ( + GNBOverloadInformation_protobuf_unspecified GNBOverloadInformation_Value = 0 + GNBOverloadInformation_overloaded GNBOverloadInformation_Value = 1 + GNBOverloadInformation_not_overloaded GNBOverloadInformation_Value = 2 +) + +var GNBOverloadInformation_Value_name = map[int32]string{ + 0: "protobuf_unspecified", + 1: "overloaded", + 2: "not_overloaded", +} + +var GNBOverloadInformation_Value_value = map[string]int32{ + "protobuf_unspecified": 0, + "overloaded": 1, + "not_overloaded": 2, +} + +func (x GNBOverloadInformation_Value) String() string { + return proto.EnumName(GNBOverloadInformation_Value_name, int32(x)) +} + +func (GNBOverloadInformation_Value) EnumDescriptor() ([]byte, []int) { + return fileDescriptor_e082a304e8406c6c, []int{29, 0} +} + +type TriggeringMessage_Value int32 + +const ( + TriggeringMessage_protobuf_unspecified TriggeringMessage_Value = 0 + TriggeringMessage_initiating_message TriggeringMessage_Value = 1 + TriggeringMessage_successful_outcome TriggeringMessage_Value = 2 + TriggeringMessage_unsuccessful_outcome TriggeringMessage_Value = 3 +) + +var TriggeringMessage_Value_name = map[int32]string{ + 0: "protobuf_unspecified", + 1: "initiating_message", + 2: "successful_outcome", + 3: "unsuccessful_outcome", +} + +var TriggeringMessage_Value_value = map[string]int32{ + "protobuf_unspecified": 0, + "initiating_message": 1, + "successful_outcome": 2, + "unsuccessful_outcome": 3, +} + +func (x TriggeringMessage_Value) String() string { + return proto.EnumName(TriggeringMessage_Value_name, int32(x)) +} + +func (TriggeringMessage_Value) EnumDescriptor() ([]byte, []int) { + return fileDescriptor_e082a304e8406c6c, []int{31, 0} +} + +type Criticality_Value int32 + +const ( + Criticality_protobuf_unspecified Criticality_Value = 0 + Criticality_reject Criticality_Value = 1 + Criticality_ignore Criticality_Value = 2 + Criticality_notify Criticality_Value = 3 +) + +var Criticality_Value_name = map[int32]string{ + 0: "protobuf_unspecified", + 1: "reject", + 2: "ignore", + 3: "notify", +} + +var Criticality_Value_value = map[string]int32{ + "protobuf_unspecified": 0, + "reject": 1, + "ignore": 2, + "notify": 3, +} + +func (x Criticality_Value) String() string { + return proto.EnumName(Criticality_Value_name, int32(x)) +} + +func (Criticality_Value) EnumDescriptor() ([]byte, []int) { + return fileDescriptor_e082a304e8406c6c, []int{32, 0} +} + +type TypeOfError_Value int32 + +const ( + TypeOfError_protobuf_unspecified TypeOfError_Value = 0 + TypeOfError_not_understood TypeOfError_Value = 1 + TypeOfError_missing TypeOfError_Value = 2 +) + +var TypeOfError_Value_name = map[int32]string{ + 0: "protobuf_unspecified", + 1: "not_understood", + 2: "missing", +} + +var TypeOfError_Value_value = map[string]int32{ + "protobuf_unspecified": 0, + "not_understood": 1, + "missing": 2, +} + +func (x TypeOfError_Value) String() string { + return proto.EnumName(TypeOfError_Value_name, int32(x)) +} + +func (TypeOfError_Value) EnumDescriptor() ([]byte, []int) { + return fileDescriptor_e082a304e8406c6c, []int{35, 0} +} + +type SgNBCoordinationAssistanceInformation_Value int32 + +const ( + SgNBCoordinationAssistanceInformation_protobuf_unspecified SgNBCoordinationAssistanceInformation_Value = 0 + SgNBCoordinationAssistanceInformation_coordination_not_required SgNBCoordinationAssistanceInformation_Value = 1 +) + +var SgNBCoordinationAssistanceInformation_Value_name = map[int32]string{ + 0: "protobuf_unspecified", + 1: "coordination_not_required", +} + +var SgNBCoordinationAssistanceInformation_Value_value = map[string]int32{ + "protobuf_unspecified": 0, + "coordination_not_required": 1, +} + +func (x SgNBCoordinationAssistanceInformation_Value) String() string { + return proto.EnumName(SgNBCoordinationAssistanceInformation_Value_name, int32(x)) +} + +func (SgNBCoordinationAssistanceInformation_Value) EnumDescriptor() ([]byte, []int) { + return fileDescriptor_e082a304e8406c6c, []int{39, 0} +} + +type RRC_Config_Ind_Value int32 + +const ( + RRC_Config_Ind_protobuf_unspecified RRC_Config_Ind_Value = 0 + RRC_Config_Ind_full_config RRC_Config_Ind_Value = 1 + RRC_Config_Ind_delta_config RRC_Config_Ind_Value = 2 +) + +var RRC_Config_Ind_Value_name = map[int32]string{ + 0: "protobuf_unspecified", + 1: "full_config", + 2: "delta_config", +} + +var RRC_Config_Ind_Value_value = map[string]int32{ + "protobuf_unspecified": 0, + "full_config": 1, + "delta_config": 2, +} + +func (x RRC_Config_Ind_Value) String() string { + return proto.EnumName(RRC_Config_Ind_Value_name, int32(x)) +} + +func (RRC_Config_Ind_Value) EnumDescriptor() ([]byte, []int) { + return fileDescriptor_e082a304e8406c6c, []int{40, 0} +} + +type ForbiddenInterRATs_Value int32 + +const ( + ForbiddenInterRATs_protobuf_unspecified ForbiddenInterRATs_Value = 0 + ForbiddenInterRATs_all ForbiddenInterRATs_Value = 1 + ForbiddenInterRATs_geran ForbiddenInterRATs_Value = 2 + ForbiddenInterRATs_utran ForbiddenInterRATs_Value = 3 + ForbiddenInterRATs_cdma2000 ForbiddenInterRATs_Value = 4 + ForbiddenInterRATs_geranandutran ForbiddenInterRATs_Value = 5 + ForbiddenInterRATs_cdma2000andutran ForbiddenInterRATs_Value = 6 +) + +var ForbiddenInterRATs_Value_name = map[int32]string{ + 0: "protobuf_unspecified", + 1: "all", + 2: "geran", + 3: "utran", + 4: "cdma2000", + 5: "geranandutran", + 6: "cdma2000andutran", +} + +var ForbiddenInterRATs_Value_value = map[string]int32{ + "protobuf_unspecified": 0, + "all": 1, + "geran": 2, + "utran": 3, + "cdma2000": 4, + "geranandutran": 5, + "cdma2000andutran": 6, +} + +func (x ForbiddenInterRATs_Value) String() string { + return proto.EnumName(ForbiddenInterRATs_Value_name, int32(x)) +} + +func (ForbiddenInterRATs_Value) EnumDescriptor() ([]byte, []int) { + return fileDescriptor_e082a304e8406c6c, []int{49, 0} +} + +type NRrestrictioninEPSasSecondaryRAT_Value int32 + +const ( + NRrestrictioninEPSasSecondaryRAT_protobuf_unspecified NRrestrictioninEPSasSecondaryRAT_Value = 0 + NRrestrictioninEPSasSecondaryRAT_nRrestrictedinEPSasSecondaryRAT NRrestrictioninEPSasSecondaryRAT_Value = 1 +) + +var NRrestrictioninEPSasSecondaryRAT_Value_name = map[int32]string{ + 0: "protobuf_unspecified", + 1: "nRrestrictedinEPSasSecondaryRAT", +} + +var NRrestrictioninEPSasSecondaryRAT_Value_value = map[string]int32{ + "protobuf_unspecified": 0, + "nRrestrictedinEPSasSecondaryRAT": 1, +} + +func (x NRrestrictioninEPSasSecondaryRAT_Value) String() string { + return proto.EnumName(NRrestrictioninEPSasSecondaryRAT_Value_name, int32(x)) +} + +func (NRrestrictioninEPSasSecondaryRAT_Value) EnumDescriptor() ([]byte, []int) { + return fileDescriptor_e082a304e8406c6c, []int{51, 0} +} + +type CNTypeRestrictionsItem_CNType int32 + +const ( + CNTypeRestrictionsItem_protobuf_unspecified CNTypeRestrictionsItem_CNType = 0 + CNTypeRestrictionsItem_fiveGC_forbidden CNTypeRestrictionsItem_CNType = 1 +) + +var CNTypeRestrictionsItem_CNType_name = map[int32]string{ + 0: "protobuf_unspecified", + 1: "fiveGC_forbidden", +} + +var CNTypeRestrictionsItem_CNType_value = map[string]int32{ + "protobuf_unspecified": 0, + "fiveGC_forbidden": 1, +} + +func (x CNTypeRestrictionsItem_CNType) String() string { + return proto.EnumName(CNTypeRestrictionsItem_CNType_name, int32(x)) +} + +func (CNTypeRestrictionsItem_CNType) EnumDescriptor() ([]byte, []int) { + return fileDescriptor_e082a304e8406c6c, []int{53, 0} +} + +type NRrestrictionin5GS_Value int32 + +const ( + NRrestrictionin5GS_protobuf_unspecified NRrestrictionin5GS_Value = 0 + NRrestrictionin5GS_nRrestrictedin5GS NRrestrictionin5GS_Value = 1 +) + +var NRrestrictionin5GS_Value_name = map[int32]string{ + 0: "protobuf_unspecified", + 1: "nRrestrictedin5GS", +} + +var NRrestrictionin5GS_Value_value = map[string]int32{ + "protobuf_unspecified": 0, + "nRrestrictedin5GS": 1, +} + +func (x NRrestrictionin5GS_Value) String() string { + return proto.EnumName(NRrestrictionin5GS_Value_name, int32(x)) +} + +func (NRrestrictionin5GS_Value) EnumDescriptor() ([]byte, []int) { + return fileDescriptor_e082a304e8406c6c, []int{54, 0} +} + +type DL_Forwarding_Value int32 + +const ( + DL_Forwarding_protobuf_unspecified DL_Forwarding_Value = 0 + DL_Forwarding_dL_forwardingProposed DL_Forwarding_Value = 1 +) + +var DL_Forwarding_Value_name = map[int32]string{ + 0: "protobuf_unspecified", + 1: "dL_forwardingProposed", +} + +var DL_Forwarding_Value_value = map[string]int32{ + "protobuf_unspecified": 0, + "dL_forwardingProposed": 1, +} + +func (x DL_Forwarding_Value) String() string { + return proto.EnumName(DL_Forwarding_Value_name, int32(x)) +} + +func (DL_Forwarding_Value) EnumDescriptor() ([]byte, []int) { + return fileDescriptor_e082a304e8406c6c, []int{58, 0} +} + +type DuplicationActivation_Value int32 + +const ( + DuplicationActivation_protobuf_unspecified DuplicationActivation_Value = 0 + DuplicationActivation_active DuplicationActivation_Value = 1 + DuplicationActivation_inactive DuplicationActivation_Value = 2 +) + +var DuplicationActivation_Value_name = map[int32]string{ + 0: "protobuf_unspecified", + 1: "active", + 2: "inactive", +} + +var DuplicationActivation_Value_value = map[string]int32{ + "protobuf_unspecified": 0, + "active": 1, + "inactive": 2, +} + +func (x DuplicationActivation_Value) String() string { + return proto.EnumName(DuplicationActivation_Value_name, int32(x)) +} + +func (DuplicationActivation_Value) EnumDescriptor() ([]byte, []int) { + return fileDescriptor_e082a304e8406c6c, []int{59, 0} +} + +type MeNBCoordinationAssistanceInformation_Value int32 + +const ( + MeNBCoordinationAssistanceInformation_protobuf_unspecified MeNBCoordinationAssistanceInformation_Value = 0 + MeNBCoordinationAssistanceInformation_coordination_not_required MeNBCoordinationAssistanceInformation_Value = 1 +) + +var MeNBCoordinationAssistanceInformation_Value_name = map[int32]string{ + 0: "protobuf_unspecified", + 1: "coordination_not_required", +} + +var MeNBCoordinationAssistanceInformation_Value_value = map[string]int32{ + "protobuf_unspecified": 0, + "coordination_not_required": 1, +} + +func (x MeNBCoordinationAssistanceInformation_Value) String() string { + return proto.EnumName(MeNBCoordinationAssistanceInformation_Value_name, int32(x)) +} + +func (MeNBCoordinationAssistanceInformation_Value) EnumDescriptor() ([]byte, []int) { + return fileDescriptor_e082a304e8406c6c, []int{62, 0} +} + +type ExpectedHOInterval_Value int32 + +const ( + ExpectedHOInterval_protobuf_unspecified ExpectedHOInterval_Value = 0 + ExpectedHOInterval_sec15 ExpectedHOInterval_Value = 1 + ExpectedHOInterval_sec30 ExpectedHOInterval_Value = 2 + ExpectedHOInterval_sec60 ExpectedHOInterval_Value = 3 + ExpectedHOInterval_sec90 ExpectedHOInterval_Value = 4 + ExpectedHOInterval_sec120 ExpectedHOInterval_Value = 5 + ExpectedHOInterval_sec180 ExpectedHOInterval_Value = 6 + ExpectedHOInterval_long_time ExpectedHOInterval_Value = 7 +) + +var ExpectedHOInterval_Value_name = map[int32]string{ + 0: "protobuf_unspecified", + 1: "sec15", + 2: "sec30", + 3: "sec60", + 4: "sec90", + 5: "sec120", + 6: "sec180", + 7: "long_time", +} + +var ExpectedHOInterval_Value_value = map[string]int32{ + "protobuf_unspecified": 0, + "sec15": 1, + "sec30": 2, + "sec60": 3, + "sec90": 4, + "sec120": 5, + "sec180": 6, + "long_time": 7, +} + +func (x ExpectedHOInterval_Value) String() string { + return proto.EnumName(ExpectedHOInterval_Value_name, int32(x)) +} + +func (ExpectedHOInterval_Value) EnumDescriptor() ([]byte, []int) { + return fileDescriptor_e082a304e8406c6c, []int{69, 0} +} + +type SourceOfUEActivityBehaviourInformation_Value int32 + +const ( + SourceOfUEActivityBehaviourInformation_protobuf_unspecified SourceOfUEActivityBehaviourInformation_Value = 0 + SourceOfUEActivityBehaviourInformation_subscription_information SourceOfUEActivityBehaviourInformation_Value = 1 + SourceOfUEActivityBehaviourInformation_statistics SourceOfUEActivityBehaviourInformation_Value = 2 +) + +var SourceOfUEActivityBehaviourInformation_Value_name = map[int32]string{ + 0: "protobuf_unspecified", + 1: "subscription_information", + 2: "statistics", +} + +var SourceOfUEActivityBehaviourInformation_Value_value = map[string]int32{ + "protobuf_unspecified": 0, + "subscription_information": 1, + "statistics": 2, +} + +func (x SourceOfUEActivityBehaviourInformation_Value) String() string { + return proto.EnumName(SourceOfUEActivityBehaviourInformation_Value_name, int32(x)) +} + +func (SourceOfUEActivityBehaviourInformation_Value) EnumDescriptor() ([]byte, []int) { + return fileDescriptor_e082a304e8406c6c, []int{70, 0} +} + +type SGNB_Addition_Trigger_Ind_Value int32 + +const ( + SGNB_Addition_Trigger_Ind_protobuf_unspecified SGNB_Addition_Trigger_Ind_Value = 0 + SGNB_Addition_Trigger_Ind_sn_change SGNB_Addition_Trigger_Ind_Value = 1 + SGNB_Addition_Trigger_Ind_inter_eNB_HO SGNB_Addition_Trigger_Ind_Value = 2 + SGNB_Addition_Trigger_Ind_intra_eNB_HO SGNB_Addition_Trigger_Ind_Value = 3 +) + +var SGNB_Addition_Trigger_Ind_Value_name = map[int32]string{ + 0: "protobuf_unspecified", + 1: "sn_change", + 2: "inter_eNB_HO", + 3: "intra_eNB_HO", +} + +var SGNB_Addition_Trigger_Ind_Value_value = map[string]int32{ + "protobuf_unspecified": 0, + "sn_change": 1, + "inter_eNB_HO": 2, + "intra_eNB_HO": 3, +} + +func (x SGNB_Addition_Trigger_Ind_Value) String() string { + return proto.EnumName(SGNB_Addition_Trigger_Ind_Value_name, int32(x)) +} + +func (SGNB_Addition_Trigger_Ind_Value) EnumDescriptor() ([]byte, []int) { + return fileDescriptor_e082a304e8406c6c, []int{71, 0} +} + +type EN_DC_ResourceConfiguration struct { + PDCPatSgNB EN_DC_ResourceConfiguration_Status `protobuf:"varint,1,opt,name=pDCPatSgNB,proto3,enum=streaming_protobufs.EN_DC_ResourceConfiguration_Status" json:"pDCPatSgNB,omitempty"` + MCGresources EN_DC_ResourceConfiguration_Status `protobuf:"varint,2,opt,name=mCGresources,proto3,enum=streaming_protobufs.EN_DC_ResourceConfiguration_Status" json:"mCGresources,omitempty"` + SCGresources EN_DC_ResourceConfiguration_Status `protobuf:"varint,3,opt,name=sCGresources,proto3,enum=streaming_protobufs.EN_DC_ResourceConfiguration_Status" json:"sCGresources,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *EN_DC_ResourceConfiguration) Reset() { *m = EN_DC_ResourceConfiguration{} } +func (m *EN_DC_ResourceConfiguration) String() string { return proto.CompactTextString(m) } +func (*EN_DC_ResourceConfiguration) ProtoMessage() {} +func (*EN_DC_ResourceConfiguration) Descriptor() ([]byte, []int) { + return fileDescriptor_e082a304e8406c6c, []int{0} +} + +func (m *EN_DC_ResourceConfiguration) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_EN_DC_ResourceConfiguration.Unmarshal(m, b) +} +func (m *EN_DC_ResourceConfiguration) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_EN_DC_ResourceConfiguration.Marshal(b, m, deterministic) +} +func (m *EN_DC_ResourceConfiguration) XXX_Merge(src proto.Message) { + xxx_messageInfo_EN_DC_ResourceConfiguration.Merge(m, src) +} +func (m *EN_DC_ResourceConfiguration) XXX_Size() int { + return xxx_messageInfo_EN_DC_ResourceConfiguration.Size(m) +} +func (m *EN_DC_ResourceConfiguration) XXX_DiscardUnknown() { + xxx_messageInfo_EN_DC_ResourceConfiguration.DiscardUnknown(m) +} + +var xxx_messageInfo_EN_DC_ResourceConfiguration proto.InternalMessageInfo + +func (m *EN_DC_ResourceConfiguration) GetPDCPatSgNB() EN_DC_ResourceConfiguration_Status { + if m != nil { + return m.PDCPatSgNB + } + return EN_DC_ResourceConfiguration_protobuf_unspecified +} + +func (m *EN_DC_ResourceConfiguration) GetMCGresources() EN_DC_ResourceConfiguration_Status { + if m != nil { + return m.MCGresources + } + return EN_DC_ResourceConfiguration_protobuf_unspecified +} + +func (m *EN_DC_ResourceConfiguration) GetSCGresources() EN_DC_ResourceConfiguration_Status { + if m != nil { + return m.SCGresources + } + return EN_DC_ResourceConfiguration_protobuf_unspecified +} + +type E_RAB_Level_QoS_Parameters struct { + QCI uint32 `protobuf:"varint,1,opt,name=qCI,proto3" json:"qCI,omitempty"` + AllocationAndRetentionPriority *AllocationAndRetentionPriority `protobuf:"bytes,2,opt,name=allocationAndRetentionPriority,proto3" json:"allocationAndRetentionPriority,omitempty"` + GbrQosInformation *GBR_QosInformation `protobuf:"bytes,3,opt,name=gbrQosInformation,proto3" json:"gbrQosInformation,omitempty"` + IE_Extensions []*E_RAB_Level_QoS_Parameters_ExtIEs `protobuf:"bytes,4,rep,name=iE_Extensions,json=iEExtensions,proto3" json:"iE_Extensions,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *E_RAB_Level_QoS_Parameters) Reset() { *m = E_RAB_Level_QoS_Parameters{} } +func (m *E_RAB_Level_QoS_Parameters) String() string { return proto.CompactTextString(m) } +func (*E_RAB_Level_QoS_Parameters) ProtoMessage() {} +func (*E_RAB_Level_QoS_Parameters) Descriptor() ([]byte, []int) { + return fileDescriptor_e082a304e8406c6c, []int{1} +} + +func (m *E_RAB_Level_QoS_Parameters) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_E_RAB_Level_QoS_Parameters.Unmarshal(m, b) +} +func (m *E_RAB_Level_QoS_Parameters) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_E_RAB_Level_QoS_Parameters.Marshal(b, m, deterministic) +} +func (m *E_RAB_Level_QoS_Parameters) XXX_Merge(src proto.Message) { + xxx_messageInfo_E_RAB_Level_QoS_Parameters.Merge(m, src) +} +func (m *E_RAB_Level_QoS_Parameters) XXX_Size() int { + return xxx_messageInfo_E_RAB_Level_QoS_Parameters.Size(m) +} +func (m *E_RAB_Level_QoS_Parameters) XXX_DiscardUnknown() { + xxx_messageInfo_E_RAB_Level_QoS_Parameters.DiscardUnknown(m) +} + +var xxx_messageInfo_E_RAB_Level_QoS_Parameters proto.InternalMessageInfo + +func (m *E_RAB_Level_QoS_Parameters) GetQCI() uint32 { + if m != nil { + return m.QCI + } + return 0 +} + +func (m *E_RAB_Level_QoS_Parameters) GetAllocationAndRetentionPriority() *AllocationAndRetentionPriority { + if m != nil { + return m.AllocationAndRetentionPriority + } + return nil +} + +func (m *E_RAB_Level_QoS_Parameters) GetGbrQosInformation() *GBR_QosInformation { + if m != nil { + return m.GbrQosInformation + } + return nil +} + +func (m *E_RAB_Level_QoS_Parameters) GetIE_Extensions() []*E_RAB_Level_QoS_Parameters_ExtIEs { + if m != nil { + return m.IE_Extensions + } + return nil +} + +type AllocationAndRetentionPriority struct { + PriorityLevel uint32 `protobuf:"varint,1,opt,name=priorityLevel,proto3" json:"priorityLevel,omitempty"` + PreEmptionCapability *PreEmptionCapability `protobuf:"bytes,2,opt,name=pre_emptionCapability,json=preEmptionCapability,proto3" json:"pre_emptionCapability,omitempty"` + PreEmptionVulnerability *PreEmptionVulnerability `protobuf:"bytes,3,opt,name=pre_emptionVulnerability,json=preEmptionVulnerability,proto3" json:"pre_emptionVulnerability,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *AllocationAndRetentionPriority) Reset() { *m = AllocationAndRetentionPriority{} } +func (m *AllocationAndRetentionPriority) String() string { return proto.CompactTextString(m) } +func (*AllocationAndRetentionPriority) ProtoMessage() {} +func (*AllocationAndRetentionPriority) Descriptor() ([]byte, []int) { + return fileDescriptor_e082a304e8406c6c, []int{2} +} + +func (m *AllocationAndRetentionPriority) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_AllocationAndRetentionPriority.Unmarshal(m, b) +} +func (m *AllocationAndRetentionPriority) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_AllocationAndRetentionPriority.Marshal(b, m, deterministic) +} +func (m *AllocationAndRetentionPriority) XXX_Merge(src proto.Message) { + xxx_messageInfo_AllocationAndRetentionPriority.Merge(m, src) +} +func (m *AllocationAndRetentionPriority) XXX_Size() int { + return xxx_messageInfo_AllocationAndRetentionPriority.Size(m) +} +func (m *AllocationAndRetentionPriority) XXX_DiscardUnknown() { + xxx_messageInfo_AllocationAndRetentionPriority.DiscardUnknown(m) +} + +var xxx_messageInfo_AllocationAndRetentionPriority proto.InternalMessageInfo + +func (m *AllocationAndRetentionPriority) GetPriorityLevel() uint32 { + if m != nil { + return m.PriorityLevel + } + return 0 +} + +func (m *AllocationAndRetentionPriority) GetPreEmptionCapability() *PreEmptionCapability { + if m != nil { + return m.PreEmptionCapability + } + return nil +} + +func (m *AllocationAndRetentionPriority) GetPreEmptionVulnerability() *PreEmptionVulnerability { + if m != nil { + return m.PreEmptionVulnerability + } + return nil +} + +type PreEmptionVulnerability struct { + Value PreEmptionVulnerability_Value `protobuf:"varint,1,opt,name=value,proto3,enum=streaming_protobufs.PreEmptionVulnerability_Value" json:"value,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *PreEmptionVulnerability) Reset() { *m = PreEmptionVulnerability{} } +func (m *PreEmptionVulnerability) String() string { return proto.CompactTextString(m) } +func (*PreEmptionVulnerability) ProtoMessage() {} +func (*PreEmptionVulnerability) Descriptor() ([]byte, []int) { + return fileDescriptor_e082a304e8406c6c, []int{3} +} + +func (m *PreEmptionVulnerability) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_PreEmptionVulnerability.Unmarshal(m, b) +} +func (m *PreEmptionVulnerability) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_PreEmptionVulnerability.Marshal(b, m, deterministic) +} +func (m *PreEmptionVulnerability) XXX_Merge(src proto.Message) { + xxx_messageInfo_PreEmptionVulnerability.Merge(m, src) +} +func (m *PreEmptionVulnerability) XXX_Size() int { + return xxx_messageInfo_PreEmptionVulnerability.Size(m) +} +func (m *PreEmptionVulnerability) XXX_DiscardUnknown() { + xxx_messageInfo_PreEmptionVulnerability.DiscardUnknown(m) +} + +var xxx_messageInfo_PreEmptionVulnerability proto.InternalMessageInfo + +func (m *PreEmptionVulnerability) GetValue() PreEmptionVulnerability_Value { + if m != nil { + return m.Value + } + return PreEmptionVulnerability_protobuf_unspecified +} + +type PreEmptionCapability struct { + Value PreEmptionCapability_Value `protobuf:"varint,1,opt,name=value,proto3,enum=streaming_protobufs.PreEmptionCapability_Value" json:"value,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *PreEmptionCapability) Reset() { *m = PreEmptionCapability{} } +func (m *PreEmptionCapability) String() string { return proto.CompactTextString(m) } +func (*PreEmptionCapability) ProtoMessage() {} +func (*PreEmptionCapability) Descriptor() ([]byte, []int) { + return fileDescriptor_e082a304e8406c6c, []int{4} +} + +func (m *PreEmptionCapability) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_PreEmptionCapability.Unmarshal(m, b) +} +func (m *PreEmptionCapability) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_PreEmptionCapability.Marshal(b, m, deterministic) +} +func (m *PreEmptionCapability) XXX_Merge(src proto.Message) { + xxx_messageInfo_PreEmptionCapability.Merge(m, src) +} +func (m *PreEmptionCapability) XXX_Size() int { + return xxx_messageInfo_PreEmptionCapability.Size(m) +} +func (m *PreEmptionCapability) XXX_DiscardUnknown() { + xxx_messageInfo_PreEmptionCapability.DiscardUnknown(m) +} + +var xxx_messageInfo_PreEmptionCapability proto.InternalMessageInfo + +func (m *PreEmptionCapability) GetValue() PreEmptionCapability_Value { + if m != nil { + return m.Value + } + return PreEmptionCapability_protobuf_unspecified +} + +type E_RAB_Level_QoS_Parameters_ExtIEs struct { + Id_DownlinkPacketLossRate *wrappers.UInt32Value `protobuf:"bytes,1,opt,name=id_DownlinkPacketLossRate,json=idDownlinkPacketLossRate,proto3" json:"id_DownlinkPacketLossRate,omitempty"` + Id_UplinkPacketLossRate *wrappers.UInt32Value `protobuf:"bytes,2,opt,name=id_UplinkPacketLossRate,json=idUplinkPacketLossRate,proto3" json:"id_UplinkPacketLossRate,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *E_RAB_Level_QoS_Parameters_ExtIEs) Reset() { *m = E_RAB_Level_QoS_Parameters_ExtIEs{} } +func (m *E_RAB_Level_QoS_Parameters_ExtIEs) String() string { return proto.CompactTextString(m) } +func (*E_RAB_Level_QoS_Parameters_ExtIEs) ProtoMessage() {} +func (*E_RAB_Level_QoS_Parameters_ExtIEs) Descriptor() ([]byte, []int) { + return fileDescriptor_e082a304e8406c6c, []int{5} +} + +func (m *E_RAB_Level_QoS_Parameters_ExtIEs) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_E_RAB_Level_QoS_Parameters_ExtIEs.Unmarshal(m, b) +} +func (m *E_RAB_Level_QoS_Parameters_ExtIEs) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_E_RAB_Level_QoS_Parameters_ExtIEs.Marshal(b, m, deterministic) +} +func (m *E_RAB_Level_QoS_Parameters_ExtIEs) XXX_Merge(src proto.Message) { + xxx_messageInfo_E_RAB_Level_QoS_Parameters_ExtIEs.Merge(m, src) +} +func (m *E_RAB_Level_QoS_Parameters_ExtIEs) XXX_Size() int { + return xxx_messageInfo_E_RAB_Level_QoS_Parameters_ExtIEs.Size(m) +} +func (m *E_RAB_Level_QoS_Parameters_ExtIEs) XXX_DiscardUnknown() { + xxx_messageInfo_E_RAB_Level_QoS_Parameters_ExtIEs.DiscardUnknown(m) +} + +var xxx_messageInfo_E_RAB_Level_QoS_Parameters_ExtIEs proto.InternalMessageInfo + +func (m *E_RAB_Level_QoS_Parameters_ExtIEs) GetId_DownlinkPacketLossRate() *wrappers.UInt32Value { + if m != nil { + return m.Id_DownlinkPacketLossRate + } + return nil +} + +func (m *E_RAB_Level_QoS_Parameters_ExtIEs) GetId_UplinkPacketLossRate() *wrappers.UInt32Value { + if m != nil { + return m.Id_UplinkPacketLossRate + } + return nil +} + +type GBR_QosInformation struct { + E_RAB_MaximumBitrateDL uint64 `protobuf:"varint,1,opt,name=e_RAB_MaximumBitrateDL,json=eRABMaximumBitrateDL,proto3" json:"e_RAB_MaximumBitrateDL,omitempty"` + E_RAB_MaximumBitrateUL uint64 `protobuf:"varint,2,opt,name=e_RAB_MaximumBitrateUL,json=eRABMaximumBitrateUL,proto3" json:"e_RAB_MaximumBitrateUL,omitempty"` + E_RAB_GuaranteedBitrateDL uint64 `protobuf:"varint,3,opt,name=e_RAB_GuaranteedBitrateDL,json=eRABGuaranteedBitrateDL,proto3" json:"e_RAB_GuaranteedBitrateDL,omitempty"` + E_RAB_GuaranteedBitrateUL uint64 `protobuf:"varint,4,opt,name=e_RAB_GuaranteedBitrateUL,json=eRABGuaranteedBitrateUL,proto3" json:"e_RAB_GuaranteedBitrateUL,omitempty"` + IE_Extensions []*GBR_QosInformation_ExtIEs `protobuf:"bytes,5,rep,name=iE_Extensions,json=iEExtensions,proto3" json:"iE_Extensions,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *GBR_QosInformation) Reset() { *m = GBR_QosInformation{} } +func (m *GBR_QosInformation) String() string { return proto.CompactTextString(m) } +func (*GBR_QosInformation) ProtoMessage() {} +func (*GBR_QosInformation) Descriptor() ([]byte, []int) { + return fileDescriptor_e082a304e8406c6c, []int{6} +} + +func (m *GBR_QosInformation) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_GBR_QosInformation.Unmarshal(m, b) +} +func (m *GBR_QosInformation) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_GBR_QosInformation.Marshal(b, m, deterministic) +} +func (m *GBR_QosInformation) XXX_Merge(src proto.Message) { + xxx_messageInfo_GBR_QosInformation.Merge(m, src) +} +func (m *GBR_QosInformation) XXX_Size() int { + return xxx_messageInfo_GBR_QosInformation.Size(m) +} +func (m *GBR_QosInformation) XXX_DiscardUnknown() { + xxx_messageInfo_GBR_QosInformation.DiscardUnknown(m) +} + +var xxx_messageInfo_GBR_QosInformation proto.InternalMessageInfo + +func (m *GBR_QosInformation) GetE_RAB_MaximumBitrateDL() uint64 { + if m != nil { + return m.E_RAB_MaximumBitrateDL + } + return 0 +} + +func (m *GBR_QosInformation) GetE_RAB_MaximumBitrateUL() uint64 { + if m != nil { + return m.E_RAB_MaximumBitrateUL + } + return 0 +} + +func (m *GBR_QosInformation) GetE_RAB_GuaranteedBitrateDL() uint64 { + if m != nil { + return m.E_RAB_GuaranteedBitrateDL + } + return 0 +} + +func (m *GBR_QosInformation) GetE_RAB_GuaranteedBitrateUL() uint64 { + if m != nil { + return m.E_RAB_GuaranteedBitrateUL + } + return 0 +} + +func (m *GBR_QosInformation) GetIE_Extensions() []*GBR_QosInformation_ExtIEs { + if m != nil { + return m.IE_Extensions + } + return nil +} + +type GBR_QosInformation_ExtIEs struct { + IdExtendedE_RAB_MaximumBitrateDL *wrappers.UInt64Value `protobuf:"bytes,1,opt,name=id_extended_e_RAB_MaximumBitrateDL,json=idExtendedERABMaximumBitrateDL,proto3" json:"id_extended_e_RAB_MaximumBitrateDL,omitempty"` + IdExtendedE_RAB_MaximumBitrateUL *wrappers.UInt64Value `protobuf:"bytes,2,opt,name=id_extended_e_RAB_MaximumBitrateUL,json=idExtendedERABMaximumBitrateUL,proto3" json:"id_extended_e_RAB_MaximumBitrateUL,omitempty"` + IdExtendedE_RAB_GuaranteedBitrateDL *wrappers.UInt64Value `protobuf:"bytes,3,opt,name=id_extended_e_RAB_GuaranteedBitrateDL,json=idExtendedERABGuaranteedBitrateDL,proto3" json:"id_extended_e_RAB_GuaranteedBitrateDL,omitempty"` + IdExtendedE_RAB_GuaranteedBitrateUL *wrappers.UInt64Value `protobuf:"bytes,4,opt,name=id_extended_e_RAB_GuaranteedBitrateUL,json=idExtendedERABGuaranteedBitrateUL,proto3" json:"id_extended_e_RAB_GuaranteedBitrateUL,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *GBR_QosInformation_ExtIEs) Reset() { *m = GBR_QosInformation_ExtIEs{} } +func (m *GBR_QosInformation_ExtIEs) String() string { return proto.CompactTextString(m) } +func (*GBR_QosInformation_ExtIEs) ProtoMessage() {} +func (*GBR_QosInformation_ExtIEs) Descriptor() ([]byte, []int) { + return fileDescriptor_e082a304e8406c6c, []int{7} +} + +func (m *GBR_QosInformation_ExtIEs) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_GBR_QosInformation_ExtIEs.Unmarshal(m, b) +} +func (m *GBR_QosInformation_ExtIEs) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_GBR_QosInformation_ExtIEs.Marshal(b, m, deterministic) +} +func (m *GBR_QosInformation_ExtIEs) XXX_Merge(src proto.Message) { + xxx_messageInfo_GBR_QosInformation_ExtIEs.Merge(m, src) +} +func (m *GBR_QosInformation_ExtIEs) XXX_Size() int { + return xxx_messageInfo_GBR_QosInformation_ExtIEs.Size(m) +} +func (m *GBR_QosInformation_ExtIEs) XXX_DiscardUnknown() { + xxx_messageInfo_GBR_QosInformation_ExtIEs.DiscardUnknown(m) +} + +var xxx_messageInfo_GBR_QosInformation_ExtIEs proto.InternalMessageInfo + +func (m *GBR_QosInformation_ExtIEs) GetIdExtendedE_RAB_MaximumBitrateDL() *wrappers.UInt64Value { + if m != nil { + return m.IdExtendedE_RAB_MaximumBitrateDL + } + return nil +} + +func (m *GBR_QosInformation_ExtIEs) GetIdExtendedE_RAB_MaximumBitrateUL() *wrappers.UInt64Value { + if m != nil { + return m.IdExtendedE_RAB_MaximumBitrateUL + } + return nil +} + +func (m *GBR_QosInformation_ExtIEs) GetIdExtendedE_RAB_GuaranteedBitrateDL() *wrappers.UInt64Value { + if m != nil { + return m.IdExtendedE_RAB_GuaranteedBitrateDL + } + return nil +} + +func (m *GBR_QosInformation_ExtIEs) GetIdExtendedE_RAB_GuaranteedBitrateUL() *wrappers.UInt64Value { + if m != nil { + return m.IdExtendedE_RAB_GuaranteedBitrateUL + } + return nil +} + +type GlobalGNB_ID struct { + PLMN_Identity []byte `protobuf:"bytes,1,opt,name=pLMN_Identity,json=pLMNIdentity,proto3" json:"pLMN_Identity,omitempty"` + GNB_ID *GNB_ID `protobuf:"bytes,2,opt,name=gNB_ID,json=gNBID,proto3" json:"gNB_ID,omitempty"` + IE_Extensions []*GlobalGNB_ID_ExtIEs `protobuf:"bytes,3,rep,name=iE_Extensions,json=iEExtensions,proto3" json:"iE_Extensions,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *GlobalGNB_ID) Reset() { *m = GlobalGNB_ID{} } +func (m *GlobalGNB_ID) String() string { return proto.CompactTextString(m) } +func (*GlobalGNB_ID) ProtoMessage() {} +func (*GlobalGNB_ID) Descriptor() ([]byte, []int) { + return fileDescriptor_e082a304e8406c6c, []int{8} +} + +func (m *GlobalGNB_ID) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_GlobalGNB_ID.Unmarshal(m, b) +} +func (m *GlobalGNB_ID) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_GlobalGNB_ID.Marshal(b, m, deterministic) +} +func (m *GlobalGNB_ID) XXX_Merge(src proto.Message) { + xxx_messageInfo_GlobalGNB_ID.Merge(m, src) +} +func (m *GlobalGNB_ID) XXX_Size() int { + return xxx_messageInfo_GlobalGNB_ID.Size(m) +} +func (m *GlobalGNB_ID) XXX_DiscardUnknown() { + xxx_messageInfo_GlobalGNB_ID.DiscardUnknown(m) +} + +var xxx_messageInfo_GlobalGNB_ID proto.InternalMessageInfo + +func (m *GlobalGNB_ID) GetPLMN_Identity() []byte { + if m != nil { + return m.PLMN_Identity + } + return nil +} + +func (m *GlobalGNB_ID) GetGNB_ID() *GNB_ID { + if m != nil { + return m.GNB_ID + } + return nil +} + +func (m *GlobalGNB_ID) GetIE_Extensions() []*GlobalGNB_ID_ExtIEs { + if m != nil { + return m.IE_Extensions + } + return nil +} + +type GNB_ID struct { + // Types that are valid to be assigned to C: + // *GNB_ID_GNB_ID + C isGNB_ID_C `protobuf_oneof:"c"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *GNB_ID) Reset() { *m = GNB_ID{} } +func (m *GNB_ID) String() string { return proto.CompactTextString(m) } +func (*GNB_ID) ProtoMessage() {} +func (*GNB_ID) Descriptor() ([]byte, []int) { + return fileDescriptor_e082a304e8406c6c, []int{9} +} + +func (m *GNB_ID) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_GNB_ID.Unmarshal(m, b) +} +func (m *GNB_ID) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_GNB_ID.Marshal(b, m, deterministic) +} +func (m *GNB_ID) XXX_Merge(src proto.Message) { + xxx_messageInfo_GNB_ID.Merge(m, src) +} +func (m *GNB_ID) XXX_Size() int { + return xxx_messageInfo_GNB_ID.Size(m) +} +func (m *GNB_ID) XXX_DiscardUnknown() { + xxx_messageInfo_GNB_ID.DiscardUnknown(m) +} + +var xxx_messageInfo_GNB_ID proto.InternalMessageInfo + +type isGNB_ID_C interface { + isGNB_ID_C() +} + +type GNB_ID_GNB_ID struct { + GNB_ID []byte `protobuf:"bytes,1,opt,name=gNB_ID,json=gNBID,proto3,oneof"` +} + +func (*GNB_ID_GNB_ID) isGNB_ID_C() {} + +func (m *GNB_ID) GetC() isGNB_ID_C { + if m != nil { + return m.C + } + return nil +} + +func (m *GNB_ID) GetGNB_ID() []byte { + if x, ok := m.GetC().(*GNB_ID_GNB_ID); ok { + return x.GNB_ID + } + return nil +} + +// XXX_OneofWrappers is for the internal use of the proto package. +func (*GNB_ID) XXX_OneofWrappers() []interface{} { + return []interface{}{ + (*GNB_ID_GNB_ID)(nil), + } +} + +type GlobalGNB_ID_ExtIEs struct { + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *GlobalGNB_ID_ExtIEs) Reset() { *m = GlobalGNB_ID_ExtIEs{} } +func (m *GlobalGNB_ID_ExtIEs) String() string { return proto.CompactTextString(m) } +func (*GlobalGNB_ID_ExtIEs) ProtoMessage() {} +func (*GlobalGNB_ID_ExtIEs) Descriptor() ([]byte, []int) { + return fileDescriptor_e082a304e8406c6c, []int{10} +} + +func (m *GlobalGNB_ID_ExtIEs) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_GlobalGNB_ID_ExtIEs.Unmarshal(m, b) +} +func (m *GlobalGNB_ID_ExtIEs) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_GlobalGNB_ID_ExtIEs.Marshal(b, m, deterministic) +} +func (m *GlobalGNB_ID_ExtIEs) XXX_Merge(src proto.Message) { + xxx_messageInfo_GlobalGNB_ID_ExtIEs.Merge(m, src) +} +func (m *GlobalGNB_ID_ExtIEs) XXX_Size() int { + return xxx_messageInfo_GlobalGNB_ID_ExtIEs.Size(m) +} +func (m *GlobalGNB_ID_ExtIEs) XXX_DiscardUnknown() { + xxx_messageInfo_GlobalGNB_ID_ExtIEs.DiscardUnknown(m) +} + +var xxx_messageInfo_GlobalGNB_ID_ExtIEs proto.InternalMessageInfo + +type GTPtunnelEndpoint struct { + TransportLayerAddress []byte `protobuf:"bytes,1,opt,name=transportLayerAddress,proto3" json:"transportLayerAddress,omitempty"` + GTP_TEID []byte `protobuf:"bytes,2,opt,name=gTP_TEID,json=gTPTEID,proto3" json:"gTP_TEID,omitempty"` + IE_Extensions []*GTPtunnelEndpoint_ExtIEs `protobuf:"bytes,3,rep,name=iE_Extensions,json=iEExtensions,proto3" json:"iE_Extensions,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *GTPtunnelEndpoint) Reset() { *m = GTPtunnelEndpoint{} } +func (m *GTPtunnelEndpoint) String() string { return proto.CompactTextString(m) } +func (*GTPtunnelEndpoint) ProtoMessage() {} +func (*GTPtunnelEndpoint) Descriptor() ([]byte, []int) { + return fileDescriptor_e082a304e8406c6c, []int{11} +} + +func (m *GTPtunnelEndpoint) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_GTPtunnelEndpoint.Unmarshal(m, b) +} +func (m *GTPtunnelEndpoint) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_GTPtunnelEndpoint.Marshal(b, m, deterministic) +} +func (m *GTPtunnelEndpoint) XXX_Merge(src proto.Message) { + xxx_messageInfo_GTPtunnelEndpoint.Merge(m, src) +} +func (m *GTPtunnelEndpoint) XXX_Size() int { + return xxx_messageInfo_GTPtunnelEndpoint.Size(m) +} +func (m *GTPtunnelEndpoint) XXX_DiscardUnknown() { + xxx_messageInfo_GTPtunnelEndpoint.DiscardUnknown(m) +} + +var xxx_messageInfo_GTPtunnelEndpoint proto.InternalMessageInfo + +func (m *GTPtunnelEndpoint) GetTransportLayerAddress() []byte { + if m != nil { + return m.TransportLayerAddress + } + return nil +} + +func (m *GTPtunnelEndpoint) GetGTP_TEID() []byte { + if m != nil { + return m.GTP_TEID + } + return nil +} + +func (m *GTPtunnelEndpoint) GetIE_Extensions() []*GTPtunnelEndpoint_ExtIEs { + if m != nil { + return m.IE_Extensions + } + return nil +} + +type GTPtunnelEndpoint_ExtIEs struct { + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *GTPtunnelEndpoint_ExtIEs) Reset() { *m = GTPtunnelEndpoint_ExtIEs{} } +func (m *GTPtunnelEndpoint_ExtIEs) String() string { return proto.CompactTextString(m) } +func (*GTPtunnelEndpoint_ExtIEs) ProtoMessage() {} +func (*GTPtunnelEndpoint_ExtIEs) Descriptor() ([]byte, []int) { + return fileDescriptor_e082a304e8406c6c, []int{12} +} + +func (m *GTPtunnelEndpoint_ExtIEs) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_GTPtunnelEndpoint_ExtIEs.Unmarshal(m, b) +} +func (m *GTPtunnelEndpoint_ExtIEs) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_GTPtunnelEndpoint_ExtIEs.Marshal(b, m, deterministic) +} +func (m *GTPtunnelEndpoint_ExtIEs) XXX_Merge(src proto.Message) { + xxx_messageInfo_GTPtunnelEndpoint_ExtIEs.Merge(m, src) +} +func (m *GTPtunnelEndpoint_ExtIEs) XXX_Size() int { + return xxx_messageInfo_GTPtunnelEndpoint_ExtIEs.Size(m) +} +func (m *GTPtunnelEndpoint_ExtIEs) XXX_DiscardUnknown() { + xxx_messageInfo_GTPtunnelEndpoint_ExtIEs.DiscardUnknown(m) +} + +var xxx_messageInfo_GTPtunnelEndpoint_ExtIEs proto.InternalMessageInfo + +type RLCMode struct { + Value RLCMode_Value `protobuf:"varint,1,opt,name=value,proto3,enum=streaming_protobufs.RLCMode_Value" json:"value,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *RLCMode) Reset() { *m = RLCMode{} } +func (m *RLCMode) String() string { return proto.CompactTextString(m) } +func (*RLCMode) ProtoMessage() {} +func (*RLCMode) Descriptor() ([]byte, []int) { + return fileDescriptor_e082a304e8406c6c, []int{13} +} + +func (m *RLCMode) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_RLCMode.Unmarshal(m, b) +} +func (m *RLCMode) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_RLCMode.Marshal(b, m, deterministic) +} +func (m *RLCMode) XXX_Merge(src proto.Message) { + xxx_messageInfo_RLCMode.Merge(m, src) +} +func (m *RLCMode) XXX_Size() int { + return xxx_messageInfo_RLCMode.Size(m) +} +func (m *RLCMode) XXX_DiscardUnknown() { + xxx_messageInfo_RLCMode.DiscardUnknown(m) +} + +var xxx_messageInfo_RLCMode proto.InternalMessageInfo + +func (m *RLCMode) GetValue() RLCMode_Value { + if m != nil { + return m.Value + } + return RLCMode_protobuf_unspecified +} + +type RLC_Status struct { + Reestablishment_Indication RLC_Status_Reestablishment_Indication `protobuf:"varint,1,opt,name=reestablishment_Indication,json=reestablishmentIndication,proto3,enum=streaming_protobufs.RLC_Status_Reestablishment_Indication" json:"reestablishment_Indication,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *RLC_Status) Reset() { *m = RLC_Status{} } +func (m *RLC_Status) String() string { return proto.CompactTextString(m) } +func (*RLC_Status) ProtoMessage() {} +func (*RLC_Status) Descriptor() ([]byte, []int) { + return fileDescriptor_e082a304e8406c6c, []int{14} +} + +func (m *RLC_Status) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_RLC_Status.Unmarshal(m, b) +} +func (m *RLC_Status) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_RLC_Status.Marshal(b, m, deterministic) +} +func (m *RLC_Status) XXX_Merge(src proto.Message) { + xxx_messageInfo_RLC_Status.Merge(m, src) +} +func (m *RLC_Status) XXX_Size() int { + return xxx_messageInfo_RLC_Status.Size(m) +} +func (m *RLC_Status) XXX_DiscardUnknown() { + xxx_messageInfo_RLC_Status.DiscardUnknown(m) +} + +var xxx_messageInfo_RLC_Status proto.InternalMessageInfo + +func (m *RLC_Status) GetReestablishment_Indication() RLC_Status_Reestablishment_Indication { + if m != nil { + return m.Reestablishment_Indication + } + return RLC_Status_protobuf_unspecified +} + +type ULConfiguration struct { + UL_PDCP ULConfiguration_UL_UE_Configuration `protobuf:"varint,1,opt,name=uL_PDCP,json=uLPDCP,proto3,enum=streaming_protobufs.ULConfiguration_UL_UE_Configuration" json:"uL_PDCP,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *ULConfiguration) Reset() { *m = ULConfiguration{} } +func (m *ULConfiguration) String() string { return proto.CompactTextString(m) } +func (*ULConfiguration) ProtoMessage() {} +func (*ULConfiguration) Descriptor() ([]byte, []int) { + return fileDescriptor_e082a304e8406c6c, []int{15} +} + +func (m *ULConfiguration) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_ULConfiguration.Unmarshal(m, b) +} +func (m *ULConfiguration) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_ULConfiguration.Marshal(b, m, deterministic) +} +func (m *ULConfiguration) XXX_Merge(src proto.Message) { + xxx_messageInfo_ULConfiguration.Merge(m, src) +} +func (m *ULConfiguration) XXX_Size() int { + return xxx_messageInfo_ULConfiguration.Size(m) +} +func (m *ULConfiguration) XXX_DiscardUnknown() { + xxx_messageInfo_ULConfiguration.DiscardUnknown(m) +} + +var xxx_messageInfo_ULConfiguration proto.InternalMessageInfo + +func (m *ULConfiguration) GetUL_PDCP() ULConfiguration_UL_UE_Configuration { + if m != nil { + return m.UL_PDCP + } + return ULConfiguration_protobuf_unspecified +} + +type PDCPSnLength struct { + Value PDCPSnLength_Value `protobuf:"varint,1,opt,name=value,proto3,enum=streaming_protobufs.PDCPSnLength_Value" json:"value,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *PDCPSnLength) Reset() { *m = PDCPSnLength{} } +func (m *PDCPSnLength) String() string { return proto.CompactTextString(m) } +func (*PDCPSnLength) ProtoMessage() {} +func (*PDCPSnLength) Descriptor() ([]byte, []int) { + return fileDescriptor_e082a304e8406c6c, []int{16} +} + +func (m *PDCPSnLength) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_PDCPSnLength.Unmarshal(m, b) +} +func (m *PDCPSnLength) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_PDCPSnLength.Marshal(b, m, deterministic) +} +func (m *PDCPSnLength) XXX_Merge(src proto.Message) { + xxx_messageInfo_PDCPSnLength.Merge(m, src) +} +func (m *PDCPSnLength) XXX_Size() int { + return xxx_messageInfo_PDCPSnLength.Size(m) +} +func (m *PDCPSnLength) XXX_DiscardUnknown() { + xxx_messageInfo_PDCPSnLength.DiscardUnknown(m) +} + +var xxx_messageInfo_PDCPSnLength proto.InternalMessageInfo + +func (m *PDCPSnLength) GetValue() PDCPSnLength_Value { + if m != nil { + return m.Value + } + return PDCPSnLength_protobuf_unspecified +} + +type PDCPChangeIndication struct { + Value PDCPChangeIndication_Value `protobuf:"varint,1,opt,name=value,proto3,enum=streaming_protobufs.PDCPChangeIndication_Value" json:"value,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *PDCPChangeIndication) Reset() { *m = PDCPChangeIndication{} } +func (m *PDCPChangeIndication) String() string { return proto.CompactTextString(m) } +func (*PDCPChangeIndication) ProtoMessage() {} +func (*PDCPChangeIndication) Descriptor() ([]byte, []int) { + return fileDescriptor_e082a304e8406c6c, []int{17} +} + +func (m *PDCPChangeIndication) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_PDCPChangeIndication.Unmarshal(m, b) +} +func (m *PDCPChangeIndication) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_PDCPChangeIndication.Marshal(b, m, deterministic) +} +func (m *PDCPChangeIndication) XXX_Merge(src proto.Message) { + xxx_messageInfo_PDCPChangeIndication.Merge(m, src) +} +func (m *PDCPChangeIndication) XXX_Size() int { + return xxx_messageInfo_PDCPChangeIndication.Size(m) +} +func (m *PDCPChangeIndication) XXX_DiscardUnknown() { + xxx_messageInfo_PDCPChangeIndication.DiscardUnknown(m) +} + +var xxx_messageInfo_PDCPChangeIndication proto.InternalMessageInfo + +func (m *PDCPChangeIndication) GetValue() PDCPChangeIndication_Value { + if m != nil { + return m.Value + } + return PDCPChangeIndication_protobuf_unspecified +} + +type SplitSRBs struct { + Value SplitSRBs_Value `protobuf:"varint,1,opt,name=value,proto3,enum=streaming_protobufs.SplitSRBs_Value" json:"value,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *SplitSRBs) Reset() { *m = SplitSRBs{} } +func (m *SplitSRBs) String() string { return proto.CompactTextString(m) } +func (*SplitSRBs) ProtoMessage() {} +func (*SplitSRBs) Descriptor() ([]byte, []int) { + return fileDescriptor_e082a304e8406c6c, []int{18} +} + +func (m *SplitSRBs) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_SplitSRBs.Unmarshal(m, b) +} +func (m *SplitSRBs) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_SplitSRBs.Marshal(b, m, deterministic) +} +func (m *SplitSRBs) XXX_Merge(src proto.Message) { + xxx_messageInfo_SplitSRBs.Merge(m, src) +} +func (m *SplitSRBs) XXX_Size() int { + return xxx_messageInfo_SplitSRBs.Size(m) +} +func (m *SplitSRBs) XXX_DiscardUnknown() { + xxx_messageInfo_SplitSRBs.DiscardUnknown(m) +} + +var xxx_messageInfo_SplitSRBs proto.InternalMessageInfo + +func (m *SplitSRBs) GetValue() SplitSRBs_Value { + if m != nil { + return m.Value + } + return SplitSRBs_protobuf_unspecified +} + +type NRCGI struct { + PLMN_Identity []byte `protobuf:"bytes,1,opt,name=pLMN_Identity,json=pLMNIdentity,proto3" json:"pLMN_Identity,omitempty"` + NRcellIdentifier []byte `protobuf:"bytes,2,opt,name=nRcellIdentifier,proto3" json:"nRcellIdentifier,omitempty"` + IE_Extensions []*NRCGI_ExtIEs `protobuf:"bytes,3,rep,name=iE_Extensions,json=iEExtensions,proto3" json:"iE_Extensions,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *NRCGI) Reset() { *m = NRCGI{} } +func (m *NRCGI) String() string { return proto.CompactTextString(m) } +func (*NRCGI) ProtoMessage() {} +func (*NRCGI) Descriptor() ([]byte, []int) { + return fileDescriptor_e082a304e8406c6c, []int{19} +} + +func (m *NRCGI) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_NRCGI.Unmarshal(m, b) +} +func (m *NRCGI) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_NRCGI.Marshal(b, m, deterministic) +} +func (m *NRCGI) XXX_Merge(src proto.Message) { + xxx_messageInfo_NRCGI.Merge(m, src) +} +func (m *NRCGI) XXX_Size() int { + return xxx_messageInfo_NRCGI.Size(m) +} +func (m *NRCGI) XXX_DiscardUnknown() { + xxx_messageInfo_NRCGI.DiscardUnknown(m) +} + +var xxx_messageInfo_NRCGI proto.InternalMessageInfo + +func (m *NRCGI) GetPLMN_Identity() []byte { + if m != nil { + return m.PLMN_Identity + } + return nil +} + +func (m *NRCGI) GetNRcellIdentifier() []byte { + if m != nil { + return m.NRcellIdentifier + } + return nil +} + +func (m *NRCGI) GetIE_Extensions() []*NRCGI_ExtIEs { + if m != nil { + return m.IE_Extensions + } + return nil +} + +type NRCGI_ExtIEs struct { + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *NRCGI_ExtIEs) Reset() { *m = NRCGI_ExtIEs{} } +func (m *NRCGI_ExtIEs) String() string { return proto.CompactTextString(m) } +func (*NRCGI_ExtIEs) ProtoMessage() {} +func (*NRCGI_ExtIEs) Descriptor() ([]byte, []int) { + return fileDescriptor_e082a304e8406c6c, []int{20} +} + +func (m *NRCGI_ExtIEs) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_NRCGI_ExtIEs.Unmarshal(m, b) +} +func (m *NRCGI_ExtIEs) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_NRCGI_ExtIEs.Marshal(b, m, deterministic) +} +func (m *NRCGI_ExtIEs) XXX_Merge(src proto.Message) { + xxx_messageInfo_NRCGI_ExtIEs.Merge(m, src) +} +func (m *NRCGI_ExtIEs) XXX_Size() int { + return xxx_messageInfo_NRCGI_ExtIEs.Size(m) +} +func (m *NRCGI_ExtIEs) XXX_DiscardUnknown() { + xxx_messageInfo_NRCGI_ExtIEs.DiscardUnknown(m) +} + +var xxx_messageInfo_NRCGI_ExtIEs proto.InternalMessageInfo + +type ECGI struct { + PLMN_Identity []byte `protobuf:"bytes,1,opt,name=pLMN_Identity,json=pLMNIdentity,proto3" json:"pLMN_Identity,omitempty"` + EUTRANcellIdentifier []byte `protobuf:"bytes,2,opt,name=eUTRANcellIdentifier,proto3" json:"eUTRANcellIdentifier,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *ECGI) Reset() { *m = ECGI{} } +func (m *ECGI) String() string { return proto.CompactTextString(m) } +func (*ECGI) ProtoMessage() {} +func (*ECGI) Descriptor() ([]byte, []int) { + return fileDescriptor_e082a304e8406c6c, []int{21} +} + +func (m *ECGI) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_ECGI.Unmarshal(m, b) +} +func (m *ECGI) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_ECGI.Marshal(b, m, deterministic) +} +func (m *ECGI) XXX_Merge(src proto.Message) { + xxx_messageInfo_ECGI.Merge(m, src) +} +func (m *ECGI) XXX_Size() int { + return xxx_messageInfo_ECGI.Size(m) +} +func (m *ECGI) XXX_DiscardUnknown() { + xxx_messageInfo_ECGI.DiscardUnknown(m) +} + +var xxx_messageInfo_ECGI proto.InternalMessageInfo + +func (m *ECGI) GetPLMN_Identity() []byte { + if m != nil { + return m.PLMN_Identity + } + return nil +} + +func (m *ECGI) GetEUTRANcellIdentifier() []byte { + if m != nil { + return m.EUTRANcellIdentifier + } + return nil +} + +type E_RAB_List struct { + Items []*E_RAB_ItemIEs `protobuf:"bytes,1,rep,name=items,proto3" json:"items,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *E_RAB_List) Reset() { *m = E_RAB_List{} } +func (m *E_RAB_List) String() string { return proto.CompactTextString(m) } +func (*E_RAB_List) ProtoMessage() {} +func (*E_RAB_List) Descriptor() ([]byte, []int) { + return fileDescriptor_e082a304e8406c6c, []int{22} +} + +func (m *E_RAB_List) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_E_RAB_List.Unmarshal(m, b) +} +func (m *E_RAB_List) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_E_RAB_List.Marshal(b, m, deterministic) +} +func (m *E_RAB_List) XXX_Merge(src proto.Message) { + xxx_messageInfo_E_RAB_List.Merge(m, src) +} +func (m *E_RAB_List) XXX_Size() int { + return xxx_messageInfo_E_RAB_List.Size(m) +} +func (m *E_RAB_List) XXX_DiscardUnknown() { + xxx_messageInfo_E_RAB_List.DiscardUnknown(m) +} + +var xxx_messageInfo_E_RAB_List proto.InternalMessageInfo + +func (m *E_RAB_List) GetItems() []*E_RAB_ItemIEs { + if m != nil { + return m.Items + } + return nil +} + +type E_RAB_ItemIEs struct { + Id_E_RAB_Item *E_RAB_Item `protobuf:"bytes,1,opt,name=id_E_RAB_Item,json=idERABItem,proto3" json:"id_E_RAB_Item,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *E_RAB_ItemIEs) Reset() { *m = E_RAB_ItemIEs{} } +func (m *E_RAB_ItemIEs) String() string { return proto.CompactTextString(m) } +func (*E_RAB_ItemIEs) ProtoMessage() {} +func (*E_RAB_ItemIEs) Descriptor() ([]byte, []int) { + return fileDescriptor_e082a304e8406c6c, []int{23} +} + +func (m *E_RAB_ItemIEs) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_E_RAB_ItemIEs.Unmarshal(m, b) +} +func (m *E_RAB_ItemIEs) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_E_RAB_ItemIEs.Marshal(b, m, deterministic) +} +func (m *E_RAB_ItemIEs) XXX_Merge(src proto.Message) { + xxx_messageInfo_E_RAB_ItemIEs.Merge(m, src) +} +func (m *E_RAB_ItemIEs) XXX_Size() int { + return xxx_messageInfo_E_RAB_ItemIEs.Size(m) +} +func (m *E_RAB_ItemIEs) XXX_DiscardUnknown() { + xxx_messageInfo_E_RAB_ItemIEs.DiscardUnknown(m) +} + +var xxx_messageInfo_E_RAB_ItemIEs proto.InternalMessageInfo + +func (m *E_RAB_ItemIEs) GetId_E_RAB_Item() *E_RAB_Item { + if m != nil { + return m.Id_E_RAB_Item + } + return nil +} + +type E_RAB_Item struct { + E_RAB_ID uint32 `protobuf:"varint,1,opt,name=e_RAB_ID,json=eRABID,proto3" json:"e_RAB_ID,omitempty"` + Cause *Cause `protobuf:"bytes,2,opt,name=cause,proto3" json:"cause,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *E_RAB_Item) Reset() { *m = E_RAB_Item{} } +func (m *E_RAB_Item) String() string { return proto.CompactTextString(m) } +func (*E_RAB_Item) ProtoMessage() {} +func (*E_RAB_Item) Descriptor() ([]byte, []int) { + return fileDescriptor_e082a304e8406c6c, []int{24} +} + +func (m *E_RAB_Item) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_E_RAB_Item.Unmarshal(m, b) +} +func (m *E_RAB_Item) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_E_RAB_Item.Marshal(b, m, deterministic) +} +func (m *E_RAB_Item) XXX_Merge(src proto.Message) { + xxx_messageInfo_E_RAB_Item.Merge(m, src) +} +func (m *E_RAB_Item) XXX_Size() int { + return xxx_messageInfo_E_RAB_Item.Size(m) +} +func (m *E_RAB_Item) XXX_DiscardUnknown() { + xxx_messageInfo_E_RAB_Item.DiscardUnknown(m) +} + +var xxx_messageInfo_E_RAB_Item proto.InternalMessageInfo + +func (m *E_RAB_Item) GetE_RAB_ID() uint32 { + if m != nil { + return m.E_RAB_ID + } + return 0 +} + +func (m *E_RAB_Item) GetCause() *Cause { + if m != nil { + return m.Cause + } + return nil +} + +type ERABActivityNotifyItemList struct { + Items []*ERABActivityNotifyItem `protobuf:"bytes,1,rep,name=items,proto3" json:"items,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *ERABActivityNotifyItemList) Reset() { *m = ERABActivityNotifyItemList{} } +func (m *ERABActivityNotifyItemList) String() string { return proto.CompactTextString(m) } +func (*ERABActivityNotifyItemList) ProtoMessage() {} +func (*ERABActivityNotifyItemList) Descriptor() ([]byte, []int) { + return fileDescriptor_e082a304e8406c6c, []int{25} +} + +func (m *ERABActivityNotifyItemList) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_ERABActivityNotifyItemList.Unmarshal(m, b) +} +func (m *ERABActivityNotifyItemList) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_ERABActivityNotifyItemList.Marshal(b, m, deterministic) +} +func (m *ERABActivityNotifyItemList) XXX_Merge(src proto.Message) { + xxx_messageInfo_ERABActivityNotifyItemList.Merge(m, src) +} +func (m *ERABActivityNotifyItemList) XXX_Size() int { + return xxx_messageInfo_ERABActivityNotifyItemList.Size(m) +} +func (m *ERABActivityNotifyItemList) XXX_DiscardUnknown() { + xxx_messageInfo_ERABActivityNotifyItemList.DiscardUnknown(m) +} + +var xxx_messageInfo_ERABActivityNotifyItemList proto.InternalMessageInfo + +func (m *ERABActivityNotifyItemList) GetItems() []*ERABActivityNotifyItem { + if m != nil { + return m.Items + } + return nil +} + +type ERABActivityNotifyItem struct { + E_RAB_ID uint32 `protobuf:"varint,1,opt,name=e_RAB_ID,json=eRABID,proto3" json:"e_RAB_ID,omitempty"` + ActivityReport *UserPlaneTrafficActivityReport `protobuf:"bytes,2,opt,name=activityReport,proto3" json:"activityReport,omitempty"` + IE_Extensions *ERABActivityNotifyItem_ExtIEs `protobuf:"bytes,3,opt,name=iE_Extensions,json=iEExtensions,proto3" json:"iE_Extensions,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *ERABActivityNotifyItem) Reset() { *m = ERABActivityNotifyItem{} } +func (m *ERABActivityNotifyItem) String() string { return proto.CompactTextString(m) } +func (*ERABActivityNotifyItem) ProtoMessage() {} +func (*ERABActivityNotifyItem) Descriptor() ([]byte, []int) { + return fileDescriptor_e082a304e8406c6c, []int{26} +} + +func (m *ERABActivityNotifyItem) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_ERABActivityNotifyItem.Unmarshal(m, b) +} +func (m *ERABActivityNotifyItem) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_ERABActivityNotifyItem.Marshal(b, m, deterministic) +} +func (m *ERABActivityNotifyItem) XXX_Merge(src proto.Message) { + xxx_messageInfo_ERABActivityNotifyItem.Merge(m, src) +} +func (m *ERABActivityNotifyItem) XXX_Size() int { + return xxx_messageInfo_ERABActivityNotifyItem.Size(m) +} +func (m *ERABActivityNotifyItem) XXX_DiscardUnknown() { + xxx_messageInfo_ERABActivityNotifyItem.DiscardUnknown(m) +} + +var xxx_messageInfo_ERABActivityNotifyItem proto.InternalMessageInfo + +func (m *ERABActivityNotifyItem) GetE_RAB_ID() uint32 { + if m != nil { + return m.E_RAB_ID + } + return 0 +} + +func (m *ERABActivityNotifyItem) GetActivityReport() *UserPlaneTrafficActivityReport { + if m != nil { + return m.ActivityReport + } + return nil +} + +func (m *ERABActivityNotifyItem) GetIE_Extensions() *ERABActivityNotifyItem_ExtIEs { + if m != nil { + return m.IE_Extensions + } + return nil +} + +type ERABActivityNotifyItem_ExtIEs struct { + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *ERABActivityNotifyItem_ExtIEs) Reset() { *m = ERABActivityNotifyItem_ExtIEs{} } +func (m *ERABActivityNotifyItem_ExtIEs) String() string { return proto.CompactTextString(m) } +func (*ERABActivityNotifyItem_ExtIEs) ProtoMessage() {} +func (*ERABActivityNotifyItem_ExtIEs) Descriptor() ([]byte, []int) { + return fileDescriptor_e082a304e8406c6c, []int{27} +} + +func (m *ERABActivityNotifyItem_ExtIEs) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_ERABActivityNotifyItem_ExtIEs.Unmarshal(m, b) +} +func (m *ERABActivityNotifyItem_ExtIEs) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_ERABActivityNotifyItem_ExtIEs.Marshal(b, m, deterministic) +} +func (m *ERABActivityNotifyItem_ExtIEs) XXX_Merge(src proto.Message) { + xxx_messageInfo_ERABActivityNotifyItem_ExtIEs.Merge(m, src) +} +func (m *ERABActivityNotifyItem_ExtIEs) XXX_Size() int { + return xxx_messageInfo_ERABActivityNotifyItem_ExtIEs.Size(m) +} +func (m *ERABActivityNotifyItem_ExtIEs) XXX_DiscardUnknown() { + xxx_messageInfo_ERABActivityNotifyItem_ExtIEs.DiscardUnknown(m) +} + +var xxx_messageInfo_ERABActivityNotifyItem_ExtIEs proto.InternalMessageInfo + +type UserPlaneTrafficActivityReport struct { + Value UserPlaneTrafficActivityReport_Value `protobuf:"varint,1,opt,name=value,proto3,enum=streaming_protobufs.UserPlaneTrafficActivityReport_Value" json:"value,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *UserPlaneTrafficActivityReport) Reset() { *m = UserPlaneTrafficActivityReport{} } +func (m *UserPlaneTrafficActivityReport) String() string { return proto.CompactTextString(m) } +func (*UserPlaneTrafficActivityReport) ProtoMessage() {} +func (*UserPlaneTrafficActivityReport) Descriptor() ([]byte, []int) { + return fileDescriptor_e082a304e8406c6c, []int{28} +} + +func (m *UserPlaneTrafficActivityReport) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_UserPlaneTrafficActivityReport.Unmarshal(m, b) +} +func (m *UserPlaneTrafficActivityReport) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_UserPlaneTrafficActivityReport.Marshal(b, m, deterministic) +} +func (m *UserPlaneTrafficActivityReport) XXX_Merge(src proto.Message) { + xxx_messageInfo_UserPlaneTrafficActivityReport.Merge(m, src) +} +func (m *UserPlaneTrafficActivityReport) XXX_Size() int { + return xxx_messageInfo_UserPlaneTrafficActivityReport.Size(m) +} +func (m *UserPlaneTrafficActivityReport) XXX_DiscardUnknown() { + xxx_messageInfo_UserPlaneTrafficActivityReport.DiscardUnknown(m) +} + +var xxx_messageInfo_UserPlaneTrafficActivityReport proto.InternalMessageInfo + +func (m *UserPlaneTrafficActivityReport) GetValue() UserPlaneTrafficActivityReport_Value { + if m != nil { + return m.Value + } + return UserPlaneTrafficActivityReport_protobuf_unspecified +} + +type GNBOverloadInformation struct { + Value GNBOverloadInformation_Value `protobuf:"varint,1,opt,name=value,proto3,enum=streaming_protobufs.GNBOverloadInformation_Value" json:"value,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *GNBOverloadInformation) Reset() { *m = GNBOverloadInformation{} } +func (m *GNBOverloadInformation) String() string { return proto.CompactTextString(m) } +func (*GNBOverloadInformation) ProtoMessage() {} +func (*GNBOverloadInformation) Descriptor() ([]byte, []int) { + return fileDescriptor_e082a304e8406c6c, []int{29} +} + +func (m *GNBOverloadInformation) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_GNBOverloadInformation.Unmarshal(m, b) +} +func (m *GNBOverloadInformation) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_GNBOverloadInformation.Marshal(b, m, deterministic) +} +func (m *GNBOverloadInformation) XXX_Merge(src proto.Message) { + xxx_messageInfo_GNBOverloadInformation.Merge(m, src) +} +func (m *GNBOverloadInformation) XXX_Size() int { + return xxx_messageInfo_GNBOverloadInformation.Size(m) +} +func (m *GNBOverloadInformation) XXX_DiscardUnknown() { + xxx_messageInfo_GNBOverloadInformation.DiscardUnknown(m) +} + +var xxx_messageInfo_GNBOverloadInformation proto.InternalMessageInfo + +func (m *GNBOverloadInformation) GetValue() GNBOverloadInformation_Value { + if m != nil { + return m.Value + } + return GNBOverloadInformation_protobuf_unspecified +} + +type CriticalityDiagnostics struct { + ProcedureCode *wrappers.UInt32Value `protobuf:"bytes,1,opt,name=procedureCode,proto3" json:"procedureCode,omitempty"` + TriggeringMessage *TriggeringMessage `protobuf:"bytes,2,opt,name=triggeringMessage,proto3" json:"triggeringMessage,omitempty"` + ProcedureCriticality *Criticality `protobuf:"bytes,3,opt,name=procedureCriticality,proto3" json:"procedureCriticality,omitempty"` + IEsCriticalityDiagnostics *CriticalityDiagnostics_IE_List `protobuf:"bytes,4,opt,name=iEsCriticalityDiagnostics,proto3" json:"iEsCriticalityDiagnostics,omitempty"` + IE_Extensions []*CriticalityDiagnostics_ExtIEs `protobuf:"bytes,5,rep,name=iE_Extensions,json=iEExtensions,proto3" json:"iE_Extensions,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *CriticalityDiagnostics) Reset() { *m = CriticalityDiagnostics{} } +func (m *CriticalityDiagnostics) String() string { return proto.CompactTextString(m) } +func (*CriticalityDiagnostics) ProtoMessage() {} +func (*CriticalityDiagnostics) Descriptor() ([]byte, []int) { + return fileDescriptor_e082a304e8406c6c, []int{30} +} + +func (m *CriticalityDiagnostics) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_CriticalityDiagnostics.Unmarshal(m, b) +} +func (m *CriticalityDiagnostics) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_CriticalityDiagnostics.Marshal(b, m, deterministic) +} +func (m *CriticalityDiagnostics) XXX_Merge(src proto.Message) { + xxx_messageInfo_CriticalityDiagnostics.Merge(m, src) +} +func (m *CriticalityDiagnostics) XXX_Size() int { + return xxx_messageInfo_CriticalityDiagnostics.Size(m) +} +func (m *CriticalityDiagnostics) XXX_DiscardUnknown() { + xxx_messageInfo_CriticalityDiagnostics.DiscardUnknown(m) +} + +var xxx_messageInfo_CriticalityDiagnostics proto.InternalMessageInfo + +func (m *CriticalityDiagnostics) GetProcedureCode() *wrappers.UInt32Value { + if m != nil { + return m.ProcedureCode + } + return nil +} + +func (m *CriticalityDiagnostics) GetTriggeringMessage() *TriggeringMessage { + if m != nil { + return m.TriggeringMessage + } + return nil +} + +func (m *CriticalityDiagnostics) GetProcedureCriticality() *Criticality { + if m != nil { + return m.ProcedureCriticality + } + return nil +} + +func (m *CriticalityDiagnostics) GetIEsCriticalityDiagnostics() *CriticalityDiagnostics_IE_List { + if m != nil { + return m.IEsCriticalityDiagnostics + } + return nil +} + +func (m *CriticalityDiagnostics) GetIE_Extensions() []*CriticalityDiagnostics_ExtIEs { + if m != nil { + return m.IE_Extensions + } + return nil +} + +type TriggeringMessage struct { + Value TriggeringMessage_Value `protobuf:"varint,1,opt,name=value,proto3,enum=streaming_protobufs.TriggeringMessage_Value" json:"value,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *TriggeringMessage) Reset() { *m = TriggeringMessage{} } +func (m *TriggeringMessage) String() string { return proto.CompactTextString(m) } +func (*TriggeringMessage) ProtoMessage() {} +func (*TriggeringMessage) Descriptor() ([]byte, []int) { + return fileDescriptor_e082a304e8406c6c, []int{31} +} + +func (m *TriggeringMessage) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_TriggeringMessage.Unmarshal(m, b) +} +func (m *TriggeringMessage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_TriggeringMessage.Marshal(b, m, deterministic) +} +func (m *TriggeringMessage) XXX_Merge(src proto.Message) { + xxx_messageInfo_TriggeringMessage.Merge(m, src) +} +func (m *TriggeringMessage) XXX_Size() int { + return xxx_messageInfo_TriggeringMessage.Size(m) +} +func (m *TriggeringMessage) XXX_DiscardUnknown() { + xxx_messageInfo_TriggeringMessage.DiscardUnknown(m) +} + +var xxx_messageInfo_TriggeringMessage proto.InternalMessageInfo + +func (m *TriggeringMessage) GetValue() TriggeringMessage_Value { + if m != nil { + return m.Value + } + return TriggeringMessage_protobuf_unspecified +} + +type Criticality struct { + Value Criticality_Value `protobuf:"varint,1,opt,name=value,proto3,enum=streaming_protobufs.Criticality_Value" json:"value,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *Criticality) Reset() { *m = Criticality{} } +func (m *Criticality) String() string { return proto.CompactTextString(m) } +func (*Criticality) ProtoMessage() {} +func (*Criticality) Descriptor() ([]byte, []int) { + return fileDescriptor_e082a304e8406c6c, []int{32} +} + +func (m *Criticality) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_Criticality.Unmarshal(m, b) +} +func (m *Criticality) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_Criticality.Marshal(b, m, deterministic) +} +func (m *Criticality) XXX_Merge(src proto.Message) { + xxx_messageInfo_Criticality.Merge(m, src) +} +func (m *Criticality) XXX_Size() int { + return xxx_messageInfo_Criticality.Size(m) +} +func (m *Criticality) XXX_DiscardUnknown() { + xxx_messageInfo_Criticality.DiscardUnknown(m) +} + +var xxx_messageInfo_Criticality proto.InternalMessageInfo + +func (m *Criticality) GetValue() Criticality_Value { + if m != nil { + return m.Value + } + return Criticality_protobuf_unspecified +} + +type CriticalityDiagnostics_IE_List struct { + Items []*CriticalityDiagnostics_IE_List_Item `protobuf:"bytes,1,rep,name=items,proto3" json:"items,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *CriticalityDiagnostics_IE_List) Reset() { *m = CriticalityDiagnostics_IE_List{} } +func (m *CriticalityDiagnostics_IE_List) String() string { return proto.CompactTextString(m) } +func (*CriticalityDiagnostics_IE_List) ProtoMessage() {} +func (*CriticalityDiagnostics_IE_List) Descriptor() ([]byte, []int) { + return fileDescriptor_e082a304e8406c6c, []int{33} +} + +func (m *CriticalityDiagnostics_IE_List) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_CriticalityDiagnostics_IE_List.Unmarshal(m, b) +} +func (m *CriticalityDiagnostics_IE_List) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_CriticalityDiagnostics_IE_List.Marshal(b, m, deterministic) +} +func (m *CriticalityDiagnostics_IE_List) XXX_Merge(src proto.Message) { + xxx_messageInfo_CriticalityDiagnostics_IE_List.Merge(m, src) +} +func (m *CriticalityDiagnostics_IE_List) XXX_Size() int { + return xxx_messageInfo_CriticalityDiagnostics_IE_List.Size(m) +} +func (m *CriticalityDiagnostics_IE_List) XXX_DiscardUnknown() { + xxx_messageInfo_CriticalityDiagnostics_IE_List.DiscardUnknown(m) +} + +var xxx_messageInfo_CriticalityDiagnostics_IE_List proto.InternalMessageInfo + +func (m *CriticalityDiagnostics_IE_List) GetItems() []*CriticalityDiagnostics_IE_List_Item { + if m != nil { + return m.Items + } + return nil +} + +type CriticalityDiagnostics_IE_List_Item struct { + IECriticality *Criticality `protobuf:"bytes,1,opt,name=iECriticality,proto3" json:"iECriticality,omitempty"` + IE_ID uint32 `protobuf:"varint,2,opt,name=iE_ID,json=iEID,proto3" json:"iE_ID,omitempty"` + TypeOfError *TypeOfError `protobuf:"bytes,3,opt,name=typeOfError,proto3" json:"typeOfError,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *CriticalityDiagnostics_IE_List_Item) Reset() { *m = CriticalityDiagnostics_IE_List_Item{} } +func (m *CriticalityDiagnostics_IE_List_Item) String() string { return proto.CompactTextString(m) } +func (*CriticalityDiagnostics_IE_List_Item) ProtoMessage() {} +func (*CriticalityDiagnostics_IE_List_Item) Descriptor() ([]byte, []int) { + return fileDescriptor_e082a304e8406c6c, []int{34} +} + +func (m *CriticalityDiagnostics_IE_List_Item) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_CriticalityDiagnostics_IE_List_Item.Unmarshal(m, b) +} +func (m *CriticalityDiagnostics_IE_List_Item) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_CriticalityDiagnostics_IE_List_Item.Marshal(b, m, deterministic) +} +func (m *CriticalityDiagnostics_IE_List_Item) XXX_Merge(src proto.Message) { + xxx_messageInfo_CriticalityDiagnostics_IE_List_Item.Merge(m, src) +} +func (m *CriticalityDiagnostics_IE_List_Item) XXX_Size() int { + return xxx_messageInfo_CriticalityDiagnostics_IE_List_Item.Size(m) +} +func (m *CriticalityDiagnostics_IE_List_Item) XXX_DiscardUnknown() { + xxx_messageInfo_CriticalityDiagnostics_IE_List_Item.DiscardUnknown(m) +} + +var xxx_messageInfo_CriticalityDiagnostics_IE_List_Item proto.InternalMessageInfo + +func (m *CriticalityDiagnostics_IE_List_Item) GetIECriticality() *Criticality { + if m != nil { + return m.IECriticality + } + return nil +} + +func (m *CriticalityDiagnostics_IE_List_Item) GetIE_ID() uint32 { + if m != nil { + return m.IE_ID + } + return 0 +} + +func (m *CriticalityDiagnostics_IE_List_Item) GetTypeOfError() *TypeOfError { + if m != nil { + return m.TypeOfError + } + return nil +} + +type TypeOfError struct { + Value TypeOfError_Value `protobuf:"varint,1,opt,name=value,proto3,enum=streaming_protobufs.TypeOfError_Value" json:"value,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *TypeOfError) Reset() { *m = TypeOfError{} } +func (m *TypeOfError) String() string { return proto.CompactTextString(m) } +func (*TypeOfError) ProtoMessage() {} +func (*TypeOfError) Descriptor() ([]byte, []int) { + return fileDescriptor_e082a304e8406c6c, []int{35} +} + +func (m *TypeOfError) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_TypeOfError.Unmarshal(m, b) +} +func (m *TypeOfError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_TypeOfError.Marshal(b, m, deterministic) +} +func (m *TypeOfError) XXX_Merge(src proto.Message) { + xxx_messageInfo_TypeOfError.Merge(m, src) +} +func (m *TypeOfError) XXX_Size() int { + return xxx_messageInfo_TypeOfError.Size(m) +} +func (m *TypeOfError) XXX_DiscardUnknown() { + xxx_messageInfo_TypeOfError.DiscardUnknown(m) +} + +var xxx_messageInfo_TypeOfError proto.InternalMessageInfo + +func (m *TypeOfError) GetValue() TypeOfError_Value { + if m != nil { + return m.Value + } + return TypeOfError_protobuf_unspecified +} + +type CriticalityDiagnostics_ExtIEs struct { + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *CriticalityDiagnostics_ExtIEs) Reset() { *m = CriticalityDiagnostics_ExtIEs{} } +func (m *CriticalityDiagnostics_ExtIEs) String() string { return proto.CompactTextString(m) } +func (*CriticalityDiagnostics_ExtIEs) ProtoMessage() {} +func (*CriticalityDiagnostics_ExtIEs) Descriptor() ([]byte, []int) { + return fileDescriptor_e082a304e8406c6c, []int{36} +} + +func (m *CriticalityDiagnostics_ExtIEs) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_CriticalityDiagnostics_ExtIEs.Unmarshal(m, b) +} +func (m *CriticalityDiagnostics_ExtIEs) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_CriticalityDiagnostics_ExtIEs.Marshal(b, m, deterministic) +} +func (m *CriticalityDiagnostics_ExtIEs) XXX_Merge(src proto.Message) { + xxx_messageInfo_CriticalityDiagnostics_ExtIEs.Merge(m, src) +} +func (m *CriticalityDiagnostics_ExtIEs) XXX_Size() int { + return xxx_messageInfo_CriticalityDiagnostics_ExtIEs.Size(m) +} +func (m *CriticalityDiagnostics_ExtIEs) XXX_DiscardUnknown() { + xxx_messageInfo_CriticalityDiagnostics_ExtIEs.DiscardUnknown(m) +} + +var xxx_messageInfo_CriticalityDiagnostics_ExtIEs proto.InternalMessageInfo + +type SgNBResourceCoordinationInformation struct { + NR_CGI *NRCGI `protobuf:"bytes,1,opt,name=nR_CGI,json=nRCGI,proto3" json:"nR_CGI,omitempty"` + ULCoordinationInformation []byte `protobuf:"bytes,2,opt,name=uLCoordinationInformation,proto3" json:"uLCoordinationInformation,omitempty"` + DLCoordinationInformation *wrappers.BytesValue `protobuf:"bytes,3,opt,name=dLCoordinationInformation,proto3" json:"dLCoordinationInformation,omitempty"` + IE_Extensions []*SgNBResourceCoordinationInformationExtIEs `protobuf:"bytes,4,rep,name=iE_Extensions,json=iEExtensions,proto3" json:"iE_Extensions,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *SgNBResourceCoordinationInformation) Reset() { *m = SgNBResourceCoordinationInformation{} } +func (m *SgNBResourceCoordinationInformation) String() string { return proto.CompactTextString(m) } +func (*SgNBResourceCoordinationInformation) ProtoMessage() {} +func (*SgNBResourceCoordinationInformation) Descriptor() ([]byte, []int) { + return fileDescriptor_e082a304e8406c6c, []int{37} +} + +func (m *SgNBResourceCoordinationInformation) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_SgNBResourceCoordinationInformation.Unmarshal(m, b) +} +func (m *SgNBResourceCoordinationInformation) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_SgNBResourceCoordinationInformation.Marshal(b, m, deterministic) +} +func (m *SgNBResourceCoordinationInformation) XXX_Merge(src proto.Message) { + xxx_messageInfo_SgNBResourceCoordinationInformation.Merge(m, src) +} +func (m *SgNBResourceCoordinationInformation) XXX_Size() int { + return xxx_messageInfo_SgNBResourceCoordinationInformation.Size(m) +} +func (m *SgNBResourceCoordinationInformation) XXX_DiscardUnknown() { + xxx_messageInfo_SgNBResourceCoordinationInformation.DiscardUnknown(m) +} + +var xxx_messageInfo_SgNBResourceCoordinationInformation proto.InternalMessageInfo + +func (m *SgNBResourceCoordinationInformation) GetNR_CGI() *NRCGI { + if m != nil { + return m.NR_CGI + } + return nil +} + +func (m *SgNBResourceCoordinationInformation) GetULCoordinationInformation() []byte { + if m != nil { + return m.ULCoordinationInformation + } + return nil +} + +func (m *SgNBResourceCoordinationInformation) GetDLCoordinationInformation() *wrappers.BytesValue { + if m != nil { + return m.DLCoordinationInformation + } + return nil +} + +func (m *SgNBResourceCoordinationInformation) GetIE_Extensions() []*SgNBResourceCoordinationInformationExtIEs { + if m != nil { + return m.IE_Extensions + } + return nil +} + +type SgNBResourceCoordinationInformationExtIEs struct { + Id_ECGI *ECGI `protobuf:"bytes,1,opt,name=id_ECGI,json=idECGI,proto3" json:"id_ECGI,omitempty"` + Id_SgNBCoordinationAssistanceInformation *SgNBCoordinationAssistanceInformation `protobuf:"bytes,2,opt,name=id_SgNBCoordinationAssistanceInformation,json=idSgNBCoordinationAssistanceInformation,proto3" json:"id_SgNBCoordinationAssistanceInformation,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *SgNBResourceCoordinationInformationExtIEs) Reset() { + *m = SgNBResourceCoordinationInformationExtIEs{} +} +func (m *SgNBResourceCoordinationInformationExtIEs) String() string { return proto.CompactTextString(m) } +func (*SgNBResourceCoordinationInformationExtIEs) ProtoMessage() {} +func (*SgNBResourceCoordinationInformationExtIEs) Descriptor() ([]byte, []int) { + return fileDescriptor_e082a304e8406c6c, []int{38} +} + +func (m *SgNBResourceCoordinationInformationExtIEs) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_SgNBResourceCoordinationInformationExtIEs.Unmarshal(m, b) +} +func (m *SgNBResourceCoordinationInformationExtIEs) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_SgNBResourceCoordinationInformationExtIEs.Marshal(b, m, deterministic) +} +func (m *SgNBResourceCoordinationInformationExtIEs) XXX_Merge(src proto.Message) { + xxx_messageInfo_SgNBResourceCoordinationInformationExtIEs.Merge(m, src) +} +func (m *SgNBResourceCoordinationInformationExtIEs) XXX_Size() int { + return xxx_messageInfo_SgNBResourceCoordinationInformationExtIEs.Size(m) +} +func (m *SgNBResourceCoordinationInformationExtIEs) XXX_DiscardUnknown() { + xxx_messageInfo_SgNBResourceCoordinationInformationExtIEs.DiscardUnknown(m) +} + +var xxx_messageInfo_SgNBResourceCoordinationInformationExtIEs proto.InternalMessageInfo + +func (m *SgNBResourceCoordinationInformationExtIEs) GetId_ECGI() *ECGI { + if m != nil { + return m.Id_ECGI + } + return nil +} + +func (m *SgNBResourceCoordinationInformationExtIEs) GetId_SgNBCoordinationAssistanceInformation() *SgNBCoordinationAssistanceInformation { + if m != nil { + return m.Id_SgNBCoordinationAssistanceInformation + } + return nil +} + +type SgNBCoordinationAssistanceInformation struct { + Value SgNBCoordinationAssistanceInformation_Value `protobuf:"varint,1,opt,name=value,proto3,enum=streaming_protobufs.SgNBCoordinationAssistanceInformation_Value" json:"value,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *SgNBCoordinationAssistanceInformation) Reset() { *m = SgNBCoordinationAssistanceInformation{} } +func (m *SgNBCoordinationAssistanceInformation) String() string { return proto.CompactTextString(m) } +func (*SgNBCoordinationAssistanceInformation) ProtoMessage() {} +func (*SgNBCoordinationAssistanceInformation) Descriptor() ([]byte, []int) { + return fileDescriptor_e082a304e8406c6c, []int{39} +} + +func (m *SgNBCoordinationAssistanceInformation) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_SgNBCoordinationAssistanceInformation.Unmarshal(m, b) +} +func (m *SgNBCoordinationAssistanceInformation) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_SgNBCoordinationAssistanceInformation.Marshal(b, m, deterministic) +} +func (m *SgNBCoordinationAssistanceInformation) XXX_Merge(src proto.Message) { + xxx_messageInfo_SgNBCoordinationAssistanceInformation.Merge(m, src) +} +func (m *SgNBCoordinationAssistanceInformation) XXX_Size() int { + return xxx_messageInfo_SgNBCoordinationAssistanceInformation.Size(m) +} +func (m *SgNBCoordinationAssistanceInformation) XXX_DiscardUnknown() { + xxx_messageInfo_SgNBCoordinationAssistanceInformation.DiscardUnknown(m) +} + +var xxx_messageInfo_SgNBCoordinationAssistanceInformation proto.InternalMessageInfo + +func (m *SgNBCoordinationAssistanceInformation) GetValue() SgNBCoordinationAssistanceInformation_Value { + if m != nil { + return m.Value + } + return SgNBCoordinationAssistanceInformation_protobuf_unspecified +} + +type RRC_Config_Ind struct { + Value RRC_Config_Ind_Value `protobuf:"varint,1,opt,name=value,proto3,enum=streaming_protobufs.RRC_Config_Ind_Value" json:"value,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *RRC_Config_Ind) Reset() { *m = RRC_Config_Ind{} } +func (m *RRC_Config_Ind) String() string { return proto.CompactTextString(m) } +func (*RRC_Config_Ind) ProtoMessage() {} +func (*RRC_Config_Ind) Descriptor() ([]byte, []int) { + return fileDescriptor_e082a304e8406c6c, []int{40} +} + +func (m *RRC_Config_Ind) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_RRC_Config_Ind.Unmarshal(m, b) +} +func (m *RRC_Config_Ind) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_RRC_Config_Ind.Marshal(b, m, deterministic) +} +func (m *RRC_Config_Ind) XXX_Merge(src proto.Message) { + xxx_messageInfo_RRC_Config_Ind.Merge(m, src) +} +func (m *RRC_Config_Ind) XXX_Size() int { + return xxx_messageInfo_RRC_Config_Ind.Size(m) +} +func (m *RRC_Config_Ind) XXX_DiscardUnknown() { + xxx_messageInfo_RRC_Config_Ind.DiscardUnknown(m) +} + +var xxx_messageInfo_RRC_Config_Ind proto.InternalMessageInfo + +func (m *RRC_Config_Ind) GetValue() RRC_Config_Ind_Value { + if m != nil { + return m.Value + } + return RRC_Config_Ind_protobuf_unspecified +} + +type HandoverRestrictionList struct { + ServingPLMN []byte `protobuf:"bytes,1,opt,name=servingPLMN,proto3" json:"servingPLMN,omitempty"` + EquivalentPLMNs *EPLMNs `protobuf:"bytes,2,opt,name=equivalentPLMNs,proto3" json:"equivalentPLMNs,omitempty"` + ForbiddenTAs *ForbiddenTAs `protobuf:"bytes,3,opt,name=forbiddenTAs,proto3" json:"forbiddenTAs,omitempty"` + ForbiddenLAs *ForbiddenLAs `protobuf:"bytes,4,opt,name=forbiddenLAs,proto3" json:"forbiddenLAs,omitempty"` + ForbiddenInterRATs *ForbiddenInterRATs `protobuf:"bytes,5,opt,name=forbiddenInterRATs,proto3" json:"forbiddenInterRATs,omitempty"` + IE_Extensions []*HandoverRestrictionList_ExtIEs `protobuf:"bytes,6,rep,name=iE_Extensions,json=iEExtensions,proto3" json:"iE_Extensions,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *HandoverRestrictionList) Reset() { *m = HandoverRestrictionList{} } +func (m *HandoverRestrictionList) String() string { return proto.CompactTextString(m) } +func (*HandoverRestrictionList) ProtoMessage() {} +func (*HandoverRestrictionList) Descriptor() ([]byte, []int) { + return fileDescriptor_e082a304e8406c6c, []int{41} +} + +func (m *HandoverRestrictionList) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_HandoverRestrictionList.Unmarshal(m, b) +} +func (m *HandoverRestrictionList) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_HandoverRestrictionList.Marshal(b, m, deterministic) +} +func (m *HandoverRestrictionList) XXX_Merge(src proto.Message) { + xxx_messageInfo_HandoverRestrictionList.Merge(m, src) +} +func (m *HandoverRestrictionList) XXX_Size() int { + return xxx_messageInfo_HandoverRestrictionList.Size(m) +} +func (m *HandoverRestrictionList) XXX_DiscardUnknown() { + xxx_messageInfo_HandoverRestrictionList.DiscardUnknown(m) +} + +var xxx_messageInfo_HandoverRestrictionList proto.InternalMessageInfo + +func (m *HandoverRestrictionList) GetServingPLMN() []byte { + if m != nil { + return m.ServingPLMN + } + return nil +} + +func (m *HandoverRestrictionList) GetEquivalentPLMNs() *EPLMNs { + if m != nil { + return m.EquivalentPLMNs + } + return nil +} + +func (m *HandoverRestrictionList) GetForbiddenTAs() *ForbiddenTAs { + if m != nil { + return m.ForbiddenTAs + } + return nil +} + +func (m *HandoverRestrictionList) GetForbiddenLAs() *ForbiddenLAs { + if m != nil { + return m.ForbiddenLAs + } + return nil +} + +func (m *HandoverRestrictionList) GetForbiddenInterRATs() *ForbiddenInterRATs { + if m != nil { + return m.ForbiddenInterRATs + } + return nil +} + +func (m *HandoverRestrictionList) GetIE_Extensions() []*HandoverRestrictionList_ExtIEs { + if m != nil { + return m.IE_Extensions + } + return nil +} + +type EPLMNs struct { + Items [][]byte `protobuf:"bytes,1,rep,name=items,proto3" json:"items,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *EPLMNs) Reset() { *m = EPLMNs{} } +func (m *EPLMNs) String() string { return proto.CompactTextString(m) } +func (*EPLMNs) ProtoMessage() {} +func (*EPLMNs) Descriptor() ([]byte, []int) { + return fileDescriptor_e082a304e8406c6c, []int{42} +} + +func (m *EPLMNs) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_EPLMNs.Unmarshal(m, b) +} +func (m *EPLMNs) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_EPLMNs.Marshal(b, m, deterministic) +} +func (m *EPLMNs) XXX_Merge(src proto.Message) { + xxx_messageInfo_EPLMNs.Merge(m, src) +} +func (m *EPLMNs) XXX_Size() int { + return xxx_messageInfo_EPLMNs.Size(m) +} +func (m *EPLMNs) XXX_DiscardUnknown() { + xxx_messageInfo_EPLMNs.DiscardUnknown(m) +} + +var xxx_messageInfo_EPLMNs proto.InternalMessageInfo + +func (m *EPLMNs) GetItems() [][]byte { + if m != nil { + return m.Items + } + return nil +} + +type ForbiddenTAs struct { + Items []*ForbiddenTAs_Item `protobuf:"bytes,1,rep,name=items,proto3" json:"items,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *ForbiddenTAs) Reset() { *m = ForbiddenTAs{} } +func (m *ForbiddenTAs) String() string { return proto.CompactTextString(m) } +func (*ForbiddenTAs) ProtoMessage() {} +func (*ForbiddenTAs) Descriptor() ([]byte, []int) { + return fileDescriptor_e082a304e8406c6c, []int{43} +} + +func (m *ForbiddenTAs) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_ForbiddenTAs.Unmarshal(m, b) +} +func (m *ForbiddenTAs) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_ForbiddenTAs.Marshal(b, m, deterministic) +} +func (m *ForbiddenTAs) XXX_Merge(src proto.Message) { + xxx_messageInfo_ForbiddenTAs.Merge(m, src) +} +func (m *ForbiddenTAs) XXX_Size() int { + return xxx_messageInfo_ForbiddenTAs.Size(m) +} +func (m *ForbiddenTAs) XXX_DiscardUnknown() { + xxx_messageInfo_ForbiddenTAs.DiscardUnknown(m) +} + +var xxx_messageInfo_ForbiddenTAs proto.InternalMessageInfo + +func (m *ForbiddenTAs) GetItems() []*ForbiddenTAs_Item { + if m != nil { + return m.Items + } + return nil +} + +type ForbiddenTAs_Item struct { + PLMN_Identity []byte `protobuf:"bytes,1,opt,name=pLMN_Identity,json=pLMNIdentity,proto3" json:"pLMN_Identity,omitempty"` + ForbiddenTACs *ForbiddenTACs `protobuf:"bytes,2,opt,name=forbiddenTACs,proto3" json:"forbiddenTACs,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *ForbiddenTAs_Item) Reset() { *m = ForbiddenTAs_Item{} } +func (m *ForbiddenTAs_Item) String() string { return proto.CompactTextString(m) } +func (*ForbiddenTAs_Item) ProtoMessage() {} +func (*ForbiddenTAs_Item) Descriptor() ([]byte, []int) { + return fileDescriptor_e082a304e8406c6c, []int{44} +} + +func (m *ForbiddenTAs_Item) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_ForbiddenTAs_Item.Unmarshal(m, b) +} +func (m *ForbiddenTAs_Item) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_ForbiddenTAs_Item.Marshal(b, m, deterministic) +} +func (m *ForbiddenTAs_Item) XXX_Merge(src proto.Message) { + xxx_messageInfo_ForbiddenTAs_Item.Merge(m, src) +} +func (m *ForbiddenTAs_Item) XXX_Size() int { + return xxx_messageInfo_ForbiddenTAs_Item.Size(m) +} +func (m *ForbiddenTAs_Item) XXX_DiscardUnknown() { + xxx_messageInfo_ForbiddenTAs_Item.DiscardUnknown(m) +} + +var xxx_messageInfo_ForbiddenTAs_Item proto.InternalMessageInfo + +func (m *ForbiddenTAs_Item) GetPLMN_Identity() []byte { + if m != nil { + return m.PLMN_Identity + } + return nil +} + +func (m *ForbiddenTAs_Item) GetForbiddenTACs() *ForbiddenTACs { + if m != nil { + return m.ForbiddenTACs + } + return nil +} + +type ForbiddenTACs struct { + Items [][]byte `protobuf:"bytes,1,rep,name=items,proto3" json:"items,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *ForbiddenTACs) Reset() { *m = ForbiddenTACs{} } +func (m *ForbiddenTACs) String() string { return proto.CompactTextString(m) } +func (*ForbiddenTACs) ProtoMessage() {} +func (*ForbiddenTACs) Descriptor() ([]byte, []int) { + return fileDescriptor_e082a304e8406c6c, []int{45} +} + +func (m *ForbiddenTACs) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_ForbiddenTACs.Unmarshal(m, b) +} +func (m *ForbiddenTACs) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_ForbiddenTACs.Marshal(b, m, deterministic) +} +func (m *ForbiddenTACs) XXX_Merge(src proto.Message) { + xxx_messageInfo_ForbiddenTACs.Merge(m, src) +} +func (m *ForbiddenTACs) XXX_Size() int { + return xxx_messageInfo_ForbiddenTACs.Size(m) +} +func (m *ForbiddenTACs) XXX_DiscardUnknown() { + xxx_messageInfo_ForbiddenTACs.DiscardUnknown(m) +} + +var xxx_messageInfo_ForbiddenTACs proto.InternalMessageInfo + +func (m *ForbiddenTACs) GetItems() [][]byte { + if m != nil { + return m.Items + } + return nil +} + +type ForbiddenLAs struct { + Items []*ForbiddenLAs_Item `protobuf:"bytes,1,rep,name=items,proto3" json:"items,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *ForbiddenLAs) Reset() { *m = ForbiddenLAs{} } +func (m *ForbiddenLAs) String() string { return proto.CompactTextString(m) } +func (*ForbiddenLAs) ProtoMessage() {} +func (*ForbiddenLAs) Descriptor() ([]byte, []int) { + return fileDescriptor_e082a304e8406c6c, []int{46} +} + +func (m *ForbiddenLAs) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_ForbiddenLAs.Unmarshal(m, b) +} +func (m *ForbiddenLAs) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_ForbiddenLAs.Marshal(b, m, deterministic) +} +func (m *ForbiddenLAs) XXX_Merge(src proto.Message) { + xxx_messageInfo_ForbiddenLAs.Merge(m, src) +} +func (m *ForbiddenLAs) XXX_Size() int { + return xxx_messageInfo_ForbiddenLAs.Size(m) +} +func (m *ForbiddenLAs) XXX_DiscardUnknown() { + xxx_messageInfo_ForbiddenLAs.DiscardUnknown(m) +} + +var xxx_messageInfo_ForbiddenLAs proto.InternalMessageInfo + +func (m *ForbiddenLAs) GetItems() []*ForbiddenLAs_Item { + if m != nil { + return m.Items + } + return nil +} + +type ForbiddenLAs_Item struct { + PLMN_Identity []byte `protobuf:"bytes,1,opt,name=pLMN_Identity,json=pLMNIdentity,proto3" json:"pLMN_Identity,omitempty"` + ForbiddenLACs *ForbiddenLACs `protobuf:"bytes,2,opt,name=forbiddenLACs,proto3" json:"forbiddenLACs,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *ForbiddenLAs_Item) Reset() { *m = ForbiddenLAs_Item{} } +func (m *ForbiddenLAs_Item) String() string { return proto.CompactTextString(m) } +func (*ForbiddenLAs_Item) ProtoMessage() {} +func (*ForbiddenLAs_Item) Descriptor() ([]byte, []int) { + return fileDescriptor_e082a304e8406c6c, []int{47} +} + +func (m *ForbiddenLAs_Item) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_ForbiddenLAs_Item.Unmarshal(m, b) +} +func (m *ForbiddenLAs_Item) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_ForbiddenLAs_Item.Marshal(b, m, deterministic) +} +func (m *ForbiddenLAs_Item) XXX_Merge(src proto.Message) { + xxx_messageInfo_ForbiddenLAs_Item.Merge(m, src) +} +func (m *ForbiddenLAs_Item) XXX_Size() int { + return xxx_messageInfo_ForbiddenLAs_Item.Size(m) +} +func (m *ForbiddenLAs_Item) XXX_DiscardUnknown() { + xxx_messageInfo_ForbiddenLAs_Item.DiscardUnknown(m) +} + +var xxx_messageInfo_ForbiddenLAs_Item proto.InternalMessageInfo + +func (m *ForbiddenLAs_Item) GetPLMN_Identity() []byte { + if m != nil { + return m.PLMN_Identity + } + return nil +} + +func (m *ForbiddenLAs_Item) GetForbiddenLACs() *ForbiddenLACs { + if m != nil { + return m.ForbiddenLACs + } + return nil +} + +type ForbiddenLACs struct { + Items [][]byte `protobuf:"bytes,1,rep,name=items,proto3" json:"items,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *ForbiddenLACs) Reset() { *m = ForbiddenLACs{} } +func (m *ForbiddenLACs) String() string { return proto.CompactTextString(m) } +func (*ForbiddenLACs) ProtoMessage() {} +func (*ForbiddenLACs) Descriptor() ([]byte, []int) { + return fileDescriptor_e082a304e8406c6c, []int{48} +} + +func (m *ForbiddenLACs) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_ForbiddenLACs.Unmarshal(m, b) +} +func (m *ForbiddenLACs) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_ForbiddenLACs.Marshal(b, m, deterministic) +} +func (m *ForbiddenLACs) XXX_Merge(src proto.Message) { + xxx_messageInfo_ForbiddenLACs.Merge(m, src) +} +func (m *ForbiddenLACs) XXX_Size() int { + return xxx_messageInfo_ForbiddenLACs.Size(m) +} +func (m *ForbiddenLACs) XXX_DiscardUnknown() { + xxx_messageInfo_ForbiddenLACs.DiscardUnknown(m) +} + +var xxx_messageInfo_ForbiddenLACs proto.InternalMessageInfo + +func (m *ForbiddenLACs) GetItems() [][]byte { + if m != nil { + return m.Items + } + return nil +} + +type ForbiddenInterRATs struct { + Value ForbiddenInterRATs_Value `protobuf:"varint,1,opt,name=value,proto3,enum=streaming_protobufs.ForbiddenInterRATs_Value" json:"value,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *ForbiddenInterRATs) Reset() { *m = ForbiddenInterRATs{} } +func (m *ForbiddenInterRATs) String() string { return proto.CompactTextString(m) } +func (*ForbiddenInterRATs) ProtoMessage() {} +func (*ForbiddenInterRATs) Descriptor() ([]byte, []int) { + return fileDescriptor_e082a304e8406c6c, []int{49} +} + +func (m *ForbiddenInterRATs) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_ForbiddenInterRATs.Unmarshal(m, b) +} +func (m *ForbiddenInterRATs) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_ForbiddenInterRATs.Marshal(b, m, deterministic) +} +func (m *ForbiddenInterRATs) XXX_Merge(src proto.Message) { + xxx_messageInfo_ForbiddenInterRATs.Merge(m, src) +} +func (m *ForbiddenInterRATs) XXX_Size() int { + return xxx_messageInfo_ForbiddenInterRATs.Size(m) +} +func (m *ForbiddenInterRATs) XXX_DiscardUnknown() { + xxx_messageInfo_ForbiddenInterRATs.DiscardUnknown(m) +} + +var xxx_messageInfo_ForbiddenInterRATs proto.InternalMessageInfo + +func (m *ForbiddenInterRATs) GetValue() ForbiddenInterRATs_Value { + if m != nil { + return m.Value + } + return ForbiddenInterRATs_protobuf_unspecified +} + +type HandoverRestrictionList_ExtIEs struct { + Id_NRrestrictioninEPSasSecondaryRAT *NRrestrictioninEPSasSecondaryRAT `protobuf:"bytes,1,opt,name=id_NRrestrictioninEPSasSecondaryRAT,json=idNRrestrictioninEPSasSecondaryRAT,proto3" json:"id_NRrestrictioninEPSasSecondaryRAT,omitempty"` + Id_CNTypeRestrictions *CNTypeRestrictions `protobuf:"bytes,2,opt,name=id_CNTypeRestrictions,json=idCNTypeRestrictions,proto3" json:"id_CNTypeRestrictions,omitempty"` + Id_NRrestrictionin5GS *NRrestrictionin5GS `protobuf:"bytes,3,opt,name=id_NRrestrictionin5GS,json=idNRrestrictionin5GS,proto3" json:"id_NRrestrictionin5GS,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *HandoverRestrictionList_ExtIEs) Reset() { *m = HandoverRestrictionList_ExtIEs{} } +func (m *HandoverRestrictionList_ExtIEs) String() string { return proto.CompactTextString(m) } +func (*HandoverRestrictionList_ExtIEs) ProtoMessage() {} +func (*HandoverRestrictionList_ExtIEs) Descriptor() ([]byte, []int) { + return fileDescriptor_e082a304e8406c6c, []int{50} +} + +func (m *HandoverRestrictionList_ExtIEs) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_HandoverRestrictionList_ExtIEs.Unmarshal(m, b) +} +func (m *HandoverRestrictionList_ExtIEs) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_HandoverRestrictionList_ExtIEs.Marshal(b, m, deterministic) +} +func (m *HandoverRestrictionList_ExtIEs) XXX_Merge(src proto.Message) { + xxx_messageInfo_HandoverRestrictionList_ExtIEs.Merge(m, src) +} +func (m *HandoverRestrictionList_ExtIEs) XXX_Size() int { + return xxx_messageInfo_HandoverRestrictionList_ExtIEs.Size(m) +} +func (m *HandoverRestrictionList_ExtIEs) XXX_DiscardUnknown() { + xxx_messageInfo_HandoverRestrictionList_ExtIEs.DiscardUnknown(m) +} + +var xxx_messageInfo_HandoverRestrictionList_ExtIEs proto.InternalMessageInfo + +func (m *HandoverRestrictionList_ExtIEs) GetId_NRrestrictioninEPSasSecondaryRAT() *NRrestrictioninEPSasSecondaryRAT { + if m != nil { + return m.Id_NRrestrictioninEPSasSecondaryRAT + } + return nil +} + +func (m *HandoverRestrictionList_ExtIEs) GetId_CNTypeRestrictions() *CNTypeRestrictions { + if m != nil { + return m.Id_CNTypeRestrictions + } + return nil +} + +func (m *HandoverRestrictionList_ExtIEs) GetId_NRrestrictionin5GS() *NRrestrictionin5GS { + if m != nil { + return m.Id_NRrestrictionin5GS + } + return nil +} + +type NRrestrictioninEPSasSecondaryRAT struct { + Value NRrestrictioninEPSasSecondaryRAT_Value `protobuf:"varint,1,opt,name=value,proto3,enum=streaming_protobufs.NRrestrictioninEPSasSecondaryRAT_Value" json:"value,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *NRrestrictioninEPSasSecondaryRAT) Reset() { *m = NRrestrictioninEPSasSecondaryRAT{} } +func (m *NRrestrictioninEPSasSecondaryRAT) String() string { return proto.CompactTextString(m) } +func (*NRrestrictioninEPSasSecondaryRAT) ProtoMessage() {} +func (*NRrestrictioninEPSasSecondaryRAT) Descriptor() ([]byte, []int) { + return fileDescriptor_e082a304e8406c6c, []int{51} +} + +func (m *NRrestrictioninEPSasSecondaryRAT) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_NRrestrictioninEPSasSecondaryRAT.Unmarshal(m, b) +} +func (m *NRrestrictioninEPSasSecondaryRAT) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_NRrestrictioninEPSasSecondaryRAT.Marshal(b, m, deterministic) +} +func (m *NRrestrictioninEPSasSecondaryRAT) XXX_Merge(src proto.Message) { + xxx_messageInfo_NRrestrictioninEPSasSecondaryRAT.Merge(m, src) +} +func (m *NRrestrictioninEPSasSecondaryRAT) XXX_Size() int { + return xxx_messageInfo_NRrestrictioninEPSasSecondaryRAT.Size(m) +} +func (m *NRrestrictioninEPSasSecondaryRAT) XXX_DiscardUnknown() { + xxx_messageInfo_NRrestrictioninEPSasSecondaryRAT.DiscardUnknown(m) +} + +var xxx_messageInfo_NRrestrictioninEPSasSecondaryRAT proto.InternalMessageInfo + +func (m *NRrestrictioninEPSasSecondaryRAT) GetValue() NRrestrictioninEPSasSecondaryRAT_Value { + if m != nil { + return m.Value + } + return NRrestrictioninEPSasSecondaryRAT_protobuf_unspecified +} + +type CNTypeRestrictions struct { + Items []*CNTypeRestrictionsItem `protobuf:"bytes,1,rep,name=items,proto3" json:"items,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *CNTypeRestrictions) Reset() { *m = CNTypeRestrictions{} } +func (m *CNTypeRestrictions) String() string { return proto.CompactTextString(m) } +func (*CNTypeRestrictions) ProtoMessage() {} +func (*CNTypeRestrictions) Descriptor() ([]byte, []int) { + return fileDescriptor_e082a304e8406c6c, []int{52} +} + +func (m *CNTypeRestrictions) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_CNTypeRestrictions.Unmarshal(m, b) +} +func (m *CNTypeRestrictions) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_CNTypeRestrictions.Marshal(b, m, deterministic) +} +func (m *CNTypeRestrictions) XXX_Merge(src proto.Message) { + xxx_messageInfo_CNTypeRestrictions.Merge(m, src) +} +func (m *CNTypeRestrictions) XXX_Size() int { + return xxx_messageInfo_CNTypeRestrictions.Size(m) +} +func (m *CNTypeRestrictions) XXX_DiscardUnknown() { + xxx_messageInfo_CNTypeRestrictions.DiscardUnknown(m) +} + +var xxx_messageInfo_CNTypeRestrictions proto.InternalMessageInfo + +func (m *CNTypeRestrictions) GetItems() []*CNTypeRestrictionsItem { + if m != nil { + return m.Items + } + return nil +} + +type CNTypeRestrictionsItem struct { + Plmn_Id []byte `protobuf:"bytes,1,opt,name=plmn_Id,json=plmnId,proto3" json:"plmn_Id,omitempty"` + CnType CNTypeRestrictionsItem_CNType `protobuf:"varint,2,opt,name=cn_type,json=cnType,proto3,enum=streaming_protobufs.CNTypeRestrictionsItem_CNType" json:"cn_type,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *CNTypeRestrictionsItem) Reset() { *m = CNTypeRestrictionsItem{} } +func (m *CNTypeRestrictionsItem) String() string { return proto.CompactTextString(m) } +func (*CNTypeRestrictionsItem) ProtoMessage() {} +func (*CNTypeRestrictionsItem) Descriptor() ([]byte, []int) { + return fileDescriptor_e082a304e8406c6c, []int{53} +} + +func (m *CNTypeRestrictionsItem) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_CNTypeRestrictionsItem.Unmarshal(m, b) +} +func (m *CNTypeRestrictionsItem) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_CNTypeRestrictionsItem.Marshal(b, m, deterministic) +} +func (m *CNTypeRestrictionsItem) XXX_Merge(src proto.Message) { + xxx_messageInfo_CNTypeRestrictionsItem.Merge(m, src) +} +func (m *CNTypeRestrictionsItem) XXX_Size() int { + return xxx_messageInfo_CNTypeRestrictionsItem.Size(m) +} +func (m *CNTypeRestrictionsItem) XXX_DiscardUnknown() { + xxx_messageInfo_CNTypeRestrictionsItem.DiscardUnknown(m) +} + +var xxx_messageInfo_CNTypeRestrictionsItem proto.InternalMessageInfo + +func (m *CNTypeRestrictionsItem) GetPlmn_Id() []byte { + if m != nil { + return m.Plmn_Id + } + return nil +} + +func (m *CNTypeRestrictionsItem) GetCnType() CNTypeRestrictionsItem_CNType { + if m != nil { + return m.CnType + } + return CNTypeRestrictionsItem_protobuf_unspecified +} + +type NRrestrictionin5GS struct { + Value NRrestrictionin5GS_Value `protobuf:"varint,1,opt,name=value,proto3,enum=streaming_protobufs.NRrestrictionin5GS_Value" json:"value,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *NRrestrictionin5GS) Reset() { *m = NRrestrictionin5GS{} } +func (m *NRrestrictionin5GS) String() string { return proto.CompactTextString(m) } +func (*NRrestrictionin5GS) ProtoMessage() {} +func (*NRrestrictionin5GS) Descriptor() ([]byte, []int) { + return fileDescriptor_e082a304e8406c6c, []int{54} +} + +func (m *NRrestrictionin5GS) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_NRrestrictionin5GS.Unmarshal(m, b) +} +func (m *NRrestrictionin5GS) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_NRrestrictionin5GS.Marshal(b, m, deterministic) +} +func (m *NRrestrictionin5GS) XXX_Merge(src proto.Message) { + xxx_messageInfo_NRrestrictionin5GS.Merge(m, src) +} +func (m *NRrestrictionin5GS) XXX_Size() int { + return xxx_messageInfo_NRrestrictionin5GS.Size(m) +} +func (m *NRrestrictionin5GS) XXX_DiscardUnknown() { + xxx_messageInfo_NRrestrictionin5GS.DiscardUnknown(m) +} + +var xxx_messageInfo_NRrestrictionin5GS proto.InternalMessageInfo + +func (m *NRrestrictionin5GS) GetValue() NRrestrictionin5GS_Value { + if m != nil { + return m.Value + } + return NRrestrictionin5GS_protobuf_unspecified +} + +type NRUESecurityCapabilities struct { + NRencryptionAlgorithms []byte `protobuf:"bytes,1,opt,name=nRencryptionAlgorithms,proto3" json:"nRencryptionAlgorithms,omitempty"` + NRintegrityProtectionAlgorithms []byte `protobuf:"bytes,2,opt,name=nRintegrityProtectionAlgorithms,proto3" json:"nRintegrityProtectionAlgorithms,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *NRUESecurityCapabilities) Reset() { *m = NRUESecurityCapabilities{} } +func (m *NRUESecurityCapabilities) String() string { return proto.CompactTextString(m) } +func (*NRUESecurityCapabilities) ProtoMessage() {} +func (*NRUESecurityCapabilities) Descriptor() ([]byte, []int) { + return fileDescriptor_e082a304e8406c6c, []int{55} +} + +func (m *NRUESecurityCapabilities) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_NRUESecurityCapabilities.Unmarshal(m, b) +} +func (m *NRUESecurityCapabilities) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_NRUESecurityCapabilities.Marshal(b, m, deterministic) +} +func (m *NRUESecurityCapabilities) XXX_Merge(src proto.Message) { + xxx_messageInfo_NRUESecurityCapabilities.Merge(m, src) +} +func (m *NRUESecurityCapabilities) XXX_Size() int { + return xxx_messageInfo_NRUESecurityCapabilities.Size(m) +} +func (m *NRUESecurityCapabilities) XXX_DiscardUnknown() { + xxx_messageInfo_NRUESecurityCapabilities.DiscardUnknown(m) +} + +var xxx_messageInfo_NRUESecurityCapabilities proto.InternalMessageInfo + +func (m *NRUESecurityCapabilities) GetNRencryptionAlgorithms() []byte { + if m != nil { + return m.NRencryptionAlgorithms + } + return nil +} + +func (m *NRUESecurityCapabilities) GetNRintegrityProtectionAlgorithms() []byte { + if m != nil { + return m.NRintegrityProtectionAlgorithms + } + return nil +} + +type UEAggregateMaximumBitRate struct { + UEaggregateMaximumBitRateDownlink uint64 `protobuf:"varint,1,opt,name=uEaggregateMaximumBitRateDownlink,proto3" json:"uEaggregateMaximumBitRateDownlink,omitempty"` + UEaggregateMaximumBitRateUplink uint64 `protobuf:"varint,2,opt,name=uEaggregateMaximumBitRateUplink,proto3" json:"uEaggregateMaximumBitRateUplink,omitempty"` + IE_Extensions []*UEAggregate_MaximumBitrate_ExtIEs `protobuf:"bytes,3,rep,name=iE_Extensions,json=iEExtensions,proto3" json:"iE_Extensions,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *UEAggregateMaximumBitRate) Reset() { *m = UEAggregateMaximumBitRate{} } +func (m *UEAggregateMaximumBitRate) String() string { return proto.CompactTextString(m) } +func (*UEAggregateMaximumBitRate) ProtoMessage() {} +func (*UEAggregateMaximumBitRate) Descriptor() ([]byte, []int) { + return fileDescriptor_e082a304e8406c6c, []int{56} +} + +func (m *UEAggregateMaximumBitRate) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_UEAggregateMaximumBitRate.Unmarshal(m, b) +} +func (m *UEAggregateMaximumBitRate) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_UEAggregateMaximumBitRate.Marshal(b, m, deterministic) +} +func (m *UEAggregateMaximumBitRate) XXX_Merge(src proto.Message) { + xxx_messageInfo_UEAggregateMaximumBitRate.Merge(m, src) +} +func (m *UEAggregateMaximumBitRate) XXX_Size() int { + return xxx_messageInfo_UEAggregateMaximumBitRate.Size(m) +} +func (m *UEAggregateMaximumBitRate) XXX_DiscardUnknown() { + xxx_messageInfo_UEAggregateMaximumBitRate.DiscardUnknown(m) +} + +var xxx_messageInfo_UEAggregateMaximumBitRate proto.InternalMessageInfo + +func (m *UEAggregateMaximumBitRate) GetUEaggregateMaximumBitRateDownlink() uint64 { + if m != nil { + return m.UEaggregateMaximumBitRateDownlink + } + return 0 +} + +func (m *UEAggregateMaximumBitRate) GetUEaggregateMaximumBitRateUplink() uint64 { + if m != nil { + return m.UEaggregateMaximumBitRateUplink + } + return 0 +} + +func (m *UEAggregateMaximumBitRate) GetIE_Extensions() []*UEAggregate_MaximumBitrate_ExtIEs { + if m != nil { + return m.IE_Extensions + } + return nil +} + +type UEAggregate_MaximumBitrate_ExtIEs struct { + IdExtendedUEaggregateMaximumBitRateDownlink *wrappers.UInt64Value `protobuf:"bytes,1,opt,name=id_extended_uEaggregateMaximumBitRateDownlink,json=idExtendedUEaggregateMaximumBitRateDownlink,proto3" json:"id_extended_uEaggregateMaximumBitRateDownlink,omitempty"` + IdExtendedUEaggregateMaximumBitRateUplink *wrappers.UInt64Value `protobuf:"bytes,2,opt,name=id_extended_uEaggregateMaximumBitRateUplink,json=idExtendedUEaggregateMaximumBitRateUplink,proto3" json:"id_extended_uEaggregateMaximumBitRateUplink,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *UEAggregate_MaximumBitrate_ExtIEs) Reset() { *m = UEAggregate_MaximumBitrate_ExtIEs{} } +func (m *UEAggregate_MaximumBitrate_ExtIEs) String() string { return proto.CompactTextString(m) } +func (*UEAggregate_MaximumBitrate_ExtIEs) ProtoMessage() {} +func (*UEAggregate_MaximumBitrate_ExtIEs) Descriptor() ([]byte, []int) { + return fileDescriptor_e082a304e8406c6c, []int{57} +} + +func (m *UEAggregate_MaximumBitrate_ExtIEs) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_UEAggregate_MaximumBitrate_ExtIEs.Unmarshal(m, b) +} +func (m *UEAggregate_MaximumBitrate_ExtIEs) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_UEAggregate_MaximumBitrate_ExtIEs.Marshal(b, m, deterministic) +} +func (m *UEAggregate_MaximumBitrate_ExtIEs) XXX_Merge(src proto.Message) { + xxx_messageInfo_UEAggregate_MaximumBitrate_ExtIEs.Merge(m, src) +} +func (m *UEAggregate_MaximumBitrate_ExtIEs) XXX_Size() int { + return xxx_messageInfo_UEAggregate_MaximumBitrate_ExtIEs.Size(m) +} +func (m *UEAggregate_MaximumBitrate_ExtIEs) XXX_DiscardUnknown() { + xxx_messageInfo_UEAggregate_MaximumBitrate_ExtIEs.DiscardUnknown(m) +} + +var xxx_messageInfo_UEAggregate_MaximumBitrate_ExtIEs proto.InternalMessageInfo + +func (m *UEAggregate_MaximumBitrate_ExtIEs) GetIdExtendedUEaggregateMaximumBitRateDownlink() *wrappers.UInt64Value { + if m != nil { + return m.IdExtendedUEaggregateMaximumBitRateDownlink + } + return nil +} + +func (m *UEAggregate_MaximumBitrate_ExtIEs) GetIdExtendedUEaggregateMaximumBitRateUplink() *wrappers.UInt64Value { + if m != nil { + return m.IdExtendedUEaggregateMaximumBitRateUplink + } + return nil +} + +type DL_Forwarding struct { + Value DL_Forwarding_Value `protobuf:"varint,1,opt,name=value,proto3,enum=streaming_protobufs.DL_Forwarding_Value" json:"value,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *DL_Forwarding) Reset() { *m = DL_Forwarding{} } +func (m *DL_Forwarding) String() string { return proto.CompactTextString(m) } +func (*DL_Forwarding) ProtoMessage() {} +func (*DL_Forwarding) Descriptor() ([]byte, []int) { + return fileDescriptor_e082a304e8406c6c, []int{58} +} + +func (m *DL_Forwarding) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_DL_Forwarding.Unmarshal(m, b) +} +func (m *DL_Forwarding) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_DL_Forwarding.Marshal(b, m, deterministic) +} +func (m *DL_Forwarding) XXX_Merge(src proto.Message) { + xxx_messageInfo_DL_Forwarding.Merge(m, src) +} +func (m *DL_Forwarding) XXX_Size() int { + return xxx_messageInfo_DL_Forwarding.Size(m) +} +func (m *DL_Forwarding) XXX_DiscardUnknown() { + xxx_messageInfo_DL_Forwarding.DiscardUnknown(m) +} + +var xxx_messageInfo_DL_Forwarding proto.InternalMessageInfo + +func (m *DL_Forwarding) GetValue() DL_Forwarding_Value { + if m != nil { + return m.Value + } + return DL_Forwarding_protobuf_unspecified +} + +type DuplicationActivation struct { + Value DuplicationActivation_Value `protobuf:"varint,1,opt,name=value,proto3,enum=streaming_protobufs.DuplicationActivation_Value" json:"value,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *DuplicationActivation) Reset() { *m = DuplicationActivation{} } +func (m *DuplicationActivation) String() string { return proto.CompactTextString(m) } +func (*DuplicationActivation) ProtoMessage() {} +func (*DuplicationActivation) Descriptor() ([]byte, []int) { + return fileDescriptor_e082a304e8406c6c, []int{59} +} + +func (m *DuplicationActivation) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_DuplicationActivation.Unmarshal(m, b) +} +func (m *DuplicationActivation) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_DuplicationActivation.Marshal(b, m, deterministic) +} +func (m *DuplicationActivation) XXX_Merge(src proto.Message) { + xxx_messageInfo_DuplicationActivation.Merge(m, src) +} +func (m *DuplicationActivation) XXX_Size() int { + return xxx_messageInfo_DuplicationActivation.Size(m) +} +func (m *DuplicationActivation) XXX_DiscardUnknown() { + xxx_messageInfo_DuplicationActivation.DiscardUnknown(m) +} + +var xxx_messageInfo_DuplicationActivation proto.InternalMessageInfo + +func (m *DuplicationActivation) GetValue() DuplicationActivation_Value { + if m != nil { + return m.Value + } + return DuplicationActivation_protobuf_unspecified +} + +type MeNBResourceCoordinationInformation struct { + EUTRA_Cell_ID *ECGI `protobuf:"bytes,1,opt,name=eUTRA_Cell_ID,json=eUTRACellID,proto3" json:"eUTRA_Cell_ID,omitempty"` + ULCoordinationInformation []byte `protobuf:"bytes,2,opt,name=uLCoordinationInformation,proto3" json:"uLCoordinationInformation,omitempty"` + DLCoordinationInformation *wrappers.BytesValue `protobuf:"bytes,3,opt,name=dLCoordinationInformation,proto3" json:"dLCoordinationInformation,omitempty"` + IE_Extensions []*MeNBResourceCoordinationInformationExtIEs `protobuf:"bytes,4,rep,name=iE_Extensions,json=iEExtensions,proto3" json:"iE_Extensions,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *MeNBResourceCoordinationInformation) Reset() { *m = MeNBResourceCoordinationInformation{} } +func (m *MeNBResourceCoordinationInformation) String() string { return proto.CompactTextString(m) } +func (*MeNBResourceCoordinationInformation) ProtoMessage() {} +func (*MeNBResourceCoordinationInformation) Descriptor() ([]byte, []int) { + return fileDescriptor_e082a304e8406c6c, []int{60} +} + +func (m *MeNBResourceCoordinationInformation) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_MeNBResourceCoordinationInformation.Unmarshal(m, b) +} +func (m *MeNBResourceCoordinationInformation) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_MeNBResourceCoordinationInformation.Marshal(b, m, deterministic) +} +func (m *MeNBResourceCoordinationInformation) XXX_Merge(src proto.Message) { + xxx_messageInfo_MeNBResourceCoordinationInformation.Merge(m, src) +} +func (m *MeNBResourceCoordinationInformation) XXX_Size() int { + return xxx_messageInfo_MeNBResourceCoordinationInformation.Size(m) +} +func (m *MeNBResourceCoordinationInformation) XXX_DiscardUnknown() { + xxx_messageInfo_MeNBResourceCoordinationInformation.DiscardUnknown(m) +} + +var xxx_messageInfo_MeNBResourceCoordinationInformation proto.InternalMessageInfo + +func (m *MeNBResourceCoordinationInformation) GetEUTRA_Cell_ID() *ECGI { + if m != nil { + return m.EUTRA_Cell_ID + } + return nil +} + +func (m *MeNBResourceCoordinationInformation) GetULCoordinationInformation() []byte { + if m != nil { + return m.ULCoordinationInformation + } + return nil +} + +func (m *MeNBResourceCoordinationInformation) GetDLCoordinationInformation() *wrappers.BytesValue { + if m != nil { + return m.DLCoordinationInformation + } + return nil +} + +func (m *MeNBResourceCoordinationInformation) GetIE_Extensions() []*MeNBResourceCoordinationInformationExtIEs { + if m != nil { + return m.IE_Extensions + } + return nil +} + +type MeNBResourceCoordinationInformationExtIEs struct { + Id_NRCGI *NRCGI `protobuf:"bytes,1,opt,name=id_NRCGI,json=idNRCGI,proto3" json:"id_NRCGI,omitempty"` + Id_MeNBCoordinationAssistanceInformation *MeNBCoordinationAssistanceInformation `protobuf:"bytes,2,opt,name=id_MeNBCoordinationAssistanceInformation,json=idMeNBCoordinationAssistanceInformation,proto3" json:"id_MeNBCoordinationAssistanceInformation,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *MeNBResourceCoordinationInformationExtIEs) Reset() { + *m = MeNBResourceCoordinationInformationExtIEs{} +} +func (m *MeNBResourceCoordinationInformationExtIEs) String() string { return proto.CompactTextString(m) } +func (*MeNBResourceCoordinationInformationExtIEs) ProtoMessage() {} +func (*MeNBResourceCoordinationInformationExtIEs) Descriptor() ([]byte, []int) { + return fileDescriptor_e082a304e8406c6c, []int{61} +} + +func (m *MeNBResourceCoordinationInformationExtIEs) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_MeNBResourceCoordinationInformationExtIEs.Unmarshal(m, b) +} +func (m *MeNBResourceCoordinationInformationExtIEs) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_MeNBResourceCoordinationInformationExtIEs.Marshal(b, m, deterministic) +} +func (m *MeNBResourceCoordinationInformationExtIEs) XXX_Merge(src proto.Message) { + xxx_messageInfo_MeNBResourceCoordinationInformationExtIEs.Merge(m, src) +} +func (m *MeNBResourceCoordinationInformationExtIEs) XXX_Size() int { + return xxx_messageInfo_MeNBResourceCoordinationInformationExtIEs.Size(m) +} +func (m *MeNBResourceCoordinationInformationExtIEs) XXX_DiscardUnknown() { + xxx_messageInfo_MeNBResourceCoordinationInformationExtIEs.DiscardUnknown(m) +} + +var xxx_messageInfo_MeNBResourceCoordinationInformationExtIEs proto.InternalMessageInfo + +func (m *MeNBResourceCoordinationInformationExtIEs) GetId_NRCGI() *NRCGI { + if m != nil { + return m.Id_NRCGI + } + return nil +} + +func (m *MeNBResourceCoordinationInformationExtIEs) GetId_MeNBCoordinationAssistanceInformation() *MeNBCoordinationAssistanceInformation { + if m != nil { + return m.Id_MeNBCoordinationAssistanceInformation + } + return nil +} + +type MeNBCoordinationAssistanceInformation struct { + Value MeNBCoordinationAssistanceInformation_Value `protobuf:"varint,1,opt,name=value,proto3,enum=streaming_protobufs.MeNBCoordinationAssistanceInformation_Value" json:"value,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *MeNBCoordinationAssistanceInformation) Reset() { *m = MeNBCoordinationAssistanceInformation{} } +func (m *MeNBCoordinationAssistanceInformation) String() string { return proto.CompactTextString(m) } +func (*MeNBCoordinationAssistanceInformation) ProtoMessage() {} +func (*MeNBCoordinationAssistanceInformation) Descriptor() ([]byte, []int) { + return fileDescriptor_e082a304e8406c6c, []int{62} +} + +func (m *MeNBCoordinationAssistanceInformation) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_MeNBCoordinationAssistanceInformation.Unmarshal(m, b) +} +func (m *MeNBCoordinationAssistanceInformation) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_MeNBCoordinationAssistanceInformation.Marshal(b, m, deterministic) +} +func (m *MeNBCoordinationAssistanceInformation) XXX_Merge(src proto.Message) { + xxx_messageInfo_MeNBCoordinationAssistanceInformation.Merge(m, src) +} +func (m *MeNBCoordinationAssistanceInformation) XXX_Size() int { + return xxx_messageInfo_MeNBCoordinationAssistanceInformation.Size(m) +} +func (m *MeNBCoordinationAssistanceInformation) XXX_DiscardUnknown() { + xxx_messageInfo_MeNBCoordinationAssistanceInformation.DiscardUnknown(m) +} + +var xxx_messageInfo_MeNBCoordinationAssistanceInformation proto.InternalMessageInfo + +func (m *MeNBCoordinationAssistanceInformation) GetValue() MeNBCoordinationAssistanceInformation_Value { + if m != nil { + return m.Value + } + return MeNBCoordinationAssistanceInformation_protobuf_unspecified +} + +type COUNTvalue struct { + PDCP_SN uint32 `protobuf:"varint,1,opt,name=pDCP_SN,json=pDCPSN,proto3" json:"pDCP_SN,omitempty"` + HFN uint32 `protobuf:"varint,2,opt,name=hFN,proto3" json:"hFN,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *COUNTvalue) Reset() { *m = COUNTvalue{} } +func (m *COUNTvalue) String() string { return proto.CompactTextString(m) } +func (*COUNTvalue) ProtoMessage() {} +func (*COUNTvalue) Descriptor() ([]byte, []int) { + return fileDescriptor_e082a304e8406c6c, []int{63} +} + +func (m *COUNTvalue) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_COUNTvalue.Unmarshal(m, b) +} +func (m *COUNTvalue) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_COUNTvalue.Marshal(b, m, deterministic) +} +func (m *COUNTvalue) XXX_Merge(src proto.Message) { + xxx_messageInfo_COUNTvalue.Merge(m, src) +} +func (m *COUNTvalue) XXX_Size() int { + return xxx_messageInfo_COUNTvalue.Size(m) +} +func (m *COUNTvalue) XXX_DiscardUnknown() { + xxx_messageInfo_COUNTvalue.DiscardUnknown(m) +} + +var xxx_messageInfo_COUNTvalue proto.InternalMessageInfo + +func (m *COUNTvalue) GetPDCP_SN() uint32 { + if m != nil { + return m.PDCP_SN + } + return 0 +} + +func (m *COUNTvalue) GetHFN() uint32 { + if m != nil { + return m.HFN + } + return 0 +} + +type COUNTValueExtended struct { + PDCP_SNExtended uint32 `protobuf:"varint,1,opt,name=pDCP_SNExtended,json=pDCPSNExtended,proto3" json:"pDCP_SNExtended,omitempty"` + HFNModified uint32 `protobuf:"varint,2,opt,name=hFNModified,proto3" json:"hFNModified,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *COUNTValueExtended) Reset() { *m = COUNTValueExtended{} } +func (m *COUNTValueExtended) String() string { return proto.CompactTextString(m) } +func (*COUNTValueExtended) ProtoMessage() {} +func (*COUNTValueExtended) Descriptor() ([]byte, []int) { + return fileDescriptor_e082a304e8406c6c, []int{64} +} + +func (m *COUNTValueExtended) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_COUNTValueExtended.Unmarshal(m, b) +} +func (m *COUNTValueExtended) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_COUNTValueExtended.Marshal(b, m, deterministic) +} +func (m *COUNTValueExtended) XXX_Merge(src proto.Message) { + xxx_messageInfo_COUNTValueExtended.Merge(m, src) +} +func (m *COUNTValueExtended) XXX_Size() int { + return xxx_messageInfo_COUNTValueExtended.Size(m) +} +func (m *COUNTValueExtended) XXX_DiscardUnknown() { + xxx_messageInfo_COUNTValueExtended.DiscardUnknown(m) +} + +var xxx_messageInfo_COUNTValueExtended proto.InternalMessageInfo + +func (m *COUNTValueExtended) GetPDCP_SNExtended() uint32 { + if m != nil { + return m.PDCP_SNExtended + } + return 0 +} + +func (m *COUNTValueExtended) GetHFNModified() uint32 { + if m != nil { + return m.HFNModified + } + return 0 +} + +type COUNTvaluePDCP_SNlength18 struct { + PDCP_SNlength18 uint32 `protobuf:"varint,1,opt,name=pDCP_SNlength18,json=pDCPSNlength18,proto3" json:"pDCP_SNlength18,omitempty"` + HFNforPDCP_SNlength18 uint32 `protobuf:"varint,2,opt,name=hFNforPDCP_SNlength18,json=hFNforPDCPSNlength18,proto3" json:"hFNforPDCP_SNlength18,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *COUNTvaluePDCP_SNlength18) Reset() { *m = COUNTvaluePDCP_SNlength18{} } +func (m *COUNTvaluePDCP_SNlength18) String() string { return proto.CompactTextString(m) } +func (*COUNTvaluePDCP_SNlength18) ProtoMessage() {} +func (*COUNTvaluePDCP_SNlength18) Descriptor() ([]byte, []int) { + return fileDescriptor_e082a304e8406c6c, []int{65} +} + +func (m *COUNTvaluePDCP_SNlength18) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_COUNTvaluePDCP_SNlength18.Unmarshal(m, b) +} +func (m *COUNTvaluePDCP_SNlength18) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_COUNTvaluePDCP_SNlength18.Marshal(b, m, deterministic) +} +func (m *COUNTvaluePDCP_SNlength18) XXX_Merge(src proto.Message) { + xxx_messageInfo_COUNTvaluePDCP_SNlength18.Merge(m, src) +} +func (m *COUNTvaluePDCP_SNlength18) XXX_Size() int { + return xxx_messageInfo_COUNTvaluePDCP_SNlength18.Size(m) +} +func (m *COUNTvaluePDCP_SNlength18) XXX_DiscardUnknown() { + xxx_messageInfo_COUNTvaluePDCP_SNlength18.DiscardUnknown(m) +} + +var xxx_messageInfo_COUNTvaluePDCP_SNlength18 proto.InternalMessageInfo + +func (m *COUNTvaluePDCP_SNlength18) GetPDCP_SNlength18() uint32 { + if m != nil { + return m.PDCP_SNlength18 + } + return 0 +} + +func (m *COUNTvaluePDCP_SNlength18) GetHFNforPDCP_SNlength18() uint32 { + if m != nil { + return m.HFNforPDCP_SNlength18 + } + return 0 +} + +type ExpectedUEBehaviour struct { + ExpectedActivity *ExpectedUEActivityBehaviour `protobuf:"bytes,1,opt,name=expectedActivity,proto3" json:"expectedActivity,omitempty"` + ExpectedHOInterval *ExpectedHOInterval `protobuf:"bytes,2,opt,name=expectedHOInterval,proto3" json:"expectedHOInterval,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *ExpectedUEBehaviour) Reset() { *m = ExpectedUEBehaviour{} } +func (m *ExpectedUEBehaviour) String() string { return proto.CompactTextString(m) } +func (*ExpectedUEBehaviour) ProtoMessage() {} +func (*ExpectedUEBehaviour) Descriptor() ([]byte, []int) { + return fileDescriptor_e082a304e8406c6c, []int{66} +} + +func (m *ExpectedUEBehaviour) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_ExpectedUEBehaviour.Unmarshal(m, b) +} +func (m *ExpectedUEBehaviour) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_ExpectedUEBehaviour.Marshal(b, m, deterministic) +} +func (m *ExpectedUEBehaviour) XXX_Merge(src proto.Message) { + xxx_messageInfo_ExpectedUEBehaviour.Merge(m, src) +} +func (m *ExpectedUEBehaviour) XXX_Size() int { + return xxx_messageInfo_ExpectedUEBehaviour.Size(m) +} +func (m *ExpectedUEBehaviour) XXX_DiscardUnknown() { + xxx_messageInfo_ExpectedUEBehaviour.DiscardUnknown(m) +} + +var xxx_messageInfo_ExpectedUEBehaviour proto.InternalMessageInfo + +func (m *ExpectedUEBehaviour) GetExpectedActivity() *ExpectedUEActivityBehaviour { + if m != nil { + return m.ExpectedActivity + } + return nil +} + +func (m *ExpectedUEBehaviour) GetExpectedHOInterval() *ExpectedHOInterval { + if m != nil { + return m.ExpectedHOInterval + } + return nil +} + +type ExpectedUEActivityBehaviour struct { + ExpectedActivityPeriod *wrappers.UInt32Value `protobuf:"bytes,1,opt,name=expectedActivityPeriod,proto3" json:"expectedActivityPeriod,omitempty"` + ExpectedIdlePeriod *wrappers.UInt32Value `protobuf:"bytes,2,opt,name=expectedIdlePeriod,proto3" json:"expectedIdlePeriod,omitempty"` + SourceOfUEActivityBehaviourInformation *SourceOfUEActivityBehaviourInformation `protobuf:"bytes,3,opt,name=sourceOfUEActivityBehaviourInformation,proto3" json:"sourceOfUEActivityBehaviourInformation,omitempty"` + IE_Extensions []*ExpectedUEActivityBehaviour_ExtIEs `protobuf:"bytes,4,rep,name=iE_Extensions,json=iEExtensions,proto3" json:"iE_Extensions,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *ExpectedUEActivityBehaviour) Reset() { *m = ExpectedUEActivityBehaviour{} } +func (m *ExpectedUEActivityBehaviour) String() string { return proto.CompactTextString(m) } +func (*ExpectedUEActivityBehaviour) ProtoMessage() {} +func (*ExpectedUEActivityBehaviour) Descriptor() ([]byte, []int) { + return fileDescriptor_e082a304e8406c6c, []int{67} +} + +func (m *ExpectedUEActivityBehaviour) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_ExpectedUEActivityBehaviour.Unmarshal(m, b) +} +func (m *ExpectedUEActivityBehaviour) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_ExpectedUEActivityBehaviour.Marshal(b, m, deterministic) +} +func (m *ExpectedUEActivityBehaviour) XXX_Merge(src proto.Message) { + xxx_messageInfo_ExpectedUEActivityBehaviour.Merge(m, src) +} +func (m *ExpectedUEActivityBehaviour) XXX_Size() int { + return xxx_messageInfo_ExpectedUEActivityBehaviour.Size(m) +} +func (m *ExpectedUEActivityBehaviour) XXX_DiscardUnknown() { + xxx_messageInfo_ExpectedUEActivityBehaviour.DiscardUnknown(m) +} + +var xxx_messageInfo_ExpectedUEActivityBehaviour proto.InternalMessageInfo + +func (m *ExpectedUEActivityBehaviour) GetExpectedActivityPeriod() *wrappers.UInt32Value { + if m != nil { + return m.ExpectedActivityPeriod + } + return nil +} + +func (m *ExpectedUEActivityBehaviour) GetExpectedIdlePeriod() *wrappers.UInt32Value { + if m != nil { + return m.ExpectedIdlePeriod + } + return nil +} + +func (m *ExpectedUEActivityBehaviour) GetSourceOfUEActivityBehaviourInformation() *SourceOfUEActivityBehaviourInformation { + if m != nil { + return m.SourceOfUEActivityBehaviourInformation + } + return nil +} + +func (m *ExpectedUEActivityBehaviour) GetIE_Extensions() []*ExpectedUEActivityBehaviour_ExtIEs { + if m != nil { + return m.IE_Extensions + } + return nil +} + +type ExpectedUEActivityBehaviour_ExtIEs struct { + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *ExpectedUEActivityBehaviour_ExtIEs) Reset() { *m = ExpectedUEActivityBehaviour_ExtIEs{} } +func (m *ExpectedUEActivityBehaviour_ExtIEs) String() string { return proto.CompactTextString(m) } +func (*ExpectedUEActivityBehaviour_ExtIEs) ProtoMessage() {} +func (*ExpectedUEActivityBehaviour_ExtIEs) Descriptor() ([]byte, []int) { + return fileDescriptor_e082a304e8406c6c, []int{68} +} + +func (m *ExpectedUEActivityBehaviour_ExtIEs) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_ExpectedUEActivityBehaviour_ExtIEs.Unmarshal(m, b) +} +func (m *ExpectedUEActivityBehaviour_ExtIEs) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_ExpectedUEActivityBehaviour_ExtIEs.Marshal(b, m, deterministic) +} +func (m *ExpectedUEActivityBehaviour_ExtIEs) XXX_Merge(src proto.Message) { + xxx_messageInfo_ExpectedUEActivityBehaviour_ExtIEs.Merge(m, src) +} +func (m *ExpectedUEActivityBehaviour_ExtIEs) XXX_Size() int { + return xxx_messageInfo_ExpectedUEActivityBehaviour_ExtIEs.Size(m) +} +func (m *ExpectedUEActivityBehaviour_ExtIEs) XXX_DiscardUnknown() { + xxx_messageInfo_ExpectedUEActivityBehaviour_ExtIEs.DiscardUnknown(m) +} + +var xxx_messageInfo_ExpectedUEActivityBehaviour_ExtIEs proto.InternalMessageInfo + +type ExpectedHOInterval struct { + Value ExpectedHOInterval_Value `protobuf:"varint,1,opt,name=value,proto3,enum=streaming_protobufs.ExpectedHOInterval_Value" json:"value,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *ExpectedHOInterval) Reset() { *m = ExpectedHOInterval{} } +func (m *ExpectedHOInterval) String() string { return proto.CompactTextString(m) } +func (*ExpectedHOInterval) ProtoMessage() {} +func (*ExpectedHOInterval) Descriptor() ([]byte, []int) { + return fileDescriptor_e082a304e8406c6c, []int{69} +} + +func (m *ExpectedHOInterval) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_ExpectedHOInterval.Unmarshal(m, b) +} +func (m *ExpectedHOInterval) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_ExpectedHOInterval.Marshal(b, m, deterministic) +} +func (m *ExpectedHOInterval) XXX_Merge(src proto.Message) { + xxx_messageInfo_ExpectedHOInterval.Merge(m, src) +} +func (m *ExpectedHOInterval) XXX_Size() int { + return xxx_messageInfo_ExpectedHOInterval.Size(m) +} +func (m *ExpectedHOInterval) XXX_DiscardUnknown() { + xxx_messageInfo_ExpectedHOInterval.DiscardUnknown(m) +} + +var xxx_messageInfo_ExpectedHOInterval proto.InternalMessageInfo + +func (m *ExpectedHOInterval) GetValue() ExpectedHOInterval_Value { + if m != nil { + return m.Value + } + return ExpectedHOInterval_protobuf_unspecified +} + +type SourceOfUEActivityBehaviourInformation struct { + Value SourceOfUEActivityBehaviourInformation_Value `protobuf:"varint,1,opt,name=value,proto3,enum=streaming_protobufs.SourceOfUEActivityBehaviourInformation_Value" json:"value,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *SourceOfUEActivityBehaviourInformation) Reset() { + *m = SourceOfUEActivityBehaviourInformation{} +} +func (m *SourceOfUEActivityBehaviourInformation) String() string { return proto.CompactTextString(m) } +func (*SourceOfUEActivityBehaviourInformation) ProtoMessage() {} +func (*SourceOfUEActivityBehaviourInformation) Descriptor() ([]byte, []int) { + return fileDescriptor_e082a304e8406c6c, []int{70} +} + +func (m *SourceOfUEActivityBehaviourInformation) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_SourceOfUEActivityBehaviourInformation.Unmarshal(m, b) +} +func (m *SourceOfUEActivityBehaviourInformation) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_SourceOfUEActivityBehaviourInformation.Marshal(b, m, deterministic) +} +func (m *SourceOfUEActivityBehaviourInformation) XXX_Merge(src proto.Message) { + xxx_messageInfo_SourceOfUEActivityBehaviourInformation.Merge(m, src) +} +func (m *SourceOfUEActivityBehaviourInformation) XXX_Size() int { + return xxx_messageInfo_SourceOfUEActivityBehaviourInformation.Size(m) +} +func (m *SourceOfUEActivityBehaviourInformation) XXX_DiscardUnknown() { + xxx_messageInfo_SourceOfUEActivityBehaviourInformation.DiscardUnknown(m) +} + +var xxx_messageInfo_SourceOfUEActivityBehaviourInformation proto.InternalMessageInfo + +func (m *SourceOfUEActivityBehaviourInformation) GetValue() SourceOfUEActivityBehaviourInformation_Value { + if m != nil { + return m.Value + } + return SourceOfUEActivityBehaviourInformation_protobuf_unspecified +} + +type SGNB_Addition_Trigger_Ind struct { + Value SGNB_Addition_Trigger_Ind_Value `protobuf:"varint,1,opt,name=value,proto3,enum=streaming_protobufs.SGNB_Addition_Trigger_Ind_Value" json:"value,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *SGNB_Addition_Trigger_Ind) Reset() { *m = SGNB_Addition_Trigger_Ind{} } +func (m *SGNB_Addition_Trigger_Ind) String() string { return proto.CompactTextString(m) } +func (*SGNB_Addition_Trigger_Ind) ProtoMessage() {} +func (*SGNB_Addition_Trigger_Ind) Descriptor() ([]byte, []int) { + return fileDescriptor_e082a304e8406c6c, []int{71} +} + +func (m *SGNB_Addition_Trigger_Ind) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_SGNB_Addition_Trigger_Ind.Unmarshal(m, b) +} +func (m *SGNB_Addition_Trigger_Ind) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_SGNB_Addition_Trigger_Ind.Marshal(b, m, deterministic) +} +func (m *SGNB_Addition_Trigger_Ind) XXX_Merge(src proto.Message) { + xxx_messageInfo_SGNB_Addition_Trigger_Ind.Merge(m, src) +} +func (m *SGNB_Addition_Trigger_Ind) XXX_Size() int { + return xxx_messageInfo_SGNB_Addition_Trigger_Ind.Size(m) +} +func (m *SGNB_Addition_Trigger_Ind) XXX_DiscardUnknown() { + xxx_messageInfo_SGNB_Addition_Trigger_Ind.DiscardUnknown(m) +} + +var xxx_messageInfo_SGNB_Addition_Trigger_Ind proto.InternalMessageInfo + +func (m *SGNB_Addition_Trigger_Ind) GetValue() SGNB_Addition_Trigger_Ind_Value { + if m != nil { + return m.Value + } + return SGNB_Addition_Trigger_Ind_protobuf_unspecified +} + +func init() { + proto.RegisterEnum("streaming_protobufs.EN_DC_ResourceConfiguration_Status", EN_DC_ResourceConfiguration_Status_name, EN_DC_ResourceConfiguration_Status_value) + proto.RegisterEnum("streaming_protobufs.PreEmptionVulnerability_Value", PreEmptionVulnerability_Value_name, PreEmptionVulnerability_Value_value) + proto.RegisterEnum("streaming_protobufs.PreEmptionCapability_Value", PreEmptionCapability_Value_name, PreEmptionCapability_Value_value) + proto.RegisterEnum("streaming_protobufs.RLCMode_Value", RLCMode_Value_name, RLCMode_Value_value) + proto.RegisterEnum("streaming_protobufs.RLC_Status_Reestablishment_Indication", RLC_Status_Reestablishment_Indication_name, RLC_Status_Reestablishment_Indication_value) + proto.RegisterEnum("streaming_protobufs.ULConfiguration_UL_UE_Configuration", ULConfiguration_UL_UE_Configuration_name, ULConfiguration_UL_UE_Configuration_value) + proto.RegisterEnum("streaming_protobufs.PDCPSnLength_Value", PDCPSnLength_Value_name, PDCPSnLength_Value_value) + proto.RegisterEnum("streaming_protobufs.PDCPChangeIndication_Value", PDCPChangeIndication_Value_name, PDCPChangeIndication_Value_value) + proto.RegisterEnum("streaming_protobufs.SplitSRBs_Value", SplitSRBs_Value_name, SplitSRBs_Value_value) + proto.RegisterEnum("streaming_protobufs.UserPlaneTrafficActivityReport_Value", UserPlaneTrafficActivityReport_Value_name, UserPlaneTrafficActivityReport_Value_value) + proto.RegisterEnum("streaming_protobufs.GNBOverloadInformation_Value", GNBOverloadInformation_Value_name, GNBOverloadInformation_Value_value) + proto.RegisterEnum("streaming_protobufs.TriggeringMessage_Value", TriggeringMessage_Value_name, TriggeringMessage_Value_value) + proto.RegisterEnum("streaming_protobufs.Criticality_Value", Criticality_Value_name, Criticality_Value_value) + proto.RegisterEnum("streaming_protobufs.TypeOfError_Value", TypeOfError_Value_name, TypeOfError_Value_value) + proto.RegisterEnum("streaming_protobufs.SgNBCoordinationAssistanceInformation_Value", SgNBCoordinationAssistanceInformation_Value_name, SgNBCoordinationAssistanceInformation_Value_value) + proto.RegisterEnum("streaming_protobufs.RRC_Config_Ind_Value", RRC_Config_Ind_Value_name, RRC_Config_Ind_Value_value) + proto.RegisterEnum("streaming_protobufs.ForbiddenInterRATs_Value", ForbiddenInterRATs_Value_name, ForbiddenInterRATs_Value_value) + proto.RegisterEnum("streaming_protobufs.NRrestrictioninEPSasSecondaryRAT_Value", NRrestrictioninEPSasSecondaryRAT_Value_name, NRrestrictioninEPSasSecondaryRAT_Value_value) + proto.RegisterEnum("streaming_protobufs.CNTypeRestrictionsItem_CNType", CNTypeRestrictionsItem_CNType_name, CNTypeRestrictionsItem_CNType_value) + proto.RegisterEnum("streaming_protobufs.NRrestrictionin5GS_Value", NRrestrictionin5GS_Value_name, NRrestrictionin5GS_Value_value) + proto.RegisterEnum("streaming_protobufs.DL_Forwarding_Value", DL_Forwarding_Value_name, DL_Forwarding_Value_value) + proto.RegisterEnum("streaming_protobufs.DuplicationActivation_Value", DuplicationActivation_Value_name, DuplicationActivation_Value_value) + proto.RegisterEnum("streaming_protobufs.MeNBCoordinationAssistanceInformation_Value", MeNBCoordinationAssistanceInformation_Value_name, MeNBCoordinationAssistanceInformation_Value_value) + proto.RegisterEnum("streaming_protobufs.ExpectedHOInterval_Value", ExpectedHOInterval_Value_name, ExpectedHOInterval_Value_value) + proto.RegisterEnum("streaming_protobufs.SourceOfUEActivityBehaviourInformation_Value", SourceOfUEActivityBehaviourInformation_Value_name, SourceOfUEActivityBehaviourInformation_Value_value) + proto.RegisterEnum("streaming_protobufs.SGNB_Addition_Trigger_Ind_Value", SGNB_Addition_Trigger_Ind_Value_name, SGNB_Addition_Trigger_Ind_Value_value) + proto.RegisterType((*EN_DC_ResourceConfiguration)(nil), "streaming_protobufs.EN_DC_ResourceConfiguration") + proto.RegisterType((*E_RAB_Level_QoS_Parameters)(nil), "streaming_protobufs.E_RAB_Level_QoS_Parameters") + proto.RegisterType((*AllocationAndRetentionPriority)(nil), "streaming_protobufs.AllocationAndRetentionPriority") + proto.RegisterType((*PreEmptionVulnerability)(nil), "streaming_protobufs.Pre_emptionVulnerability") + proto.RegisterType((*PreEmptionCapability)(nil), "streaming_protobufs.Pre_emptionCapability") + proto.RegisterType((*E_RAB_Level_QoS_Parameters_ExtIEs)(nil), "streaming_protobufs.E_RAB_Level_QoS_Parameters_ExtIEs") + proto.RegisterType((*GBR_QosInformation)(nil), "streaming_protobufs.GBR_QosInformation") + proto.RegisterType((*GBR_QosInformation_ExtIEs)(nil), "streaming_protobufs.GBR_QosInformation_ExtIEs") + proto.RegisterType((*GlobalGNB_ID)(nil), "streaming_protobufs.GlobalGNB_ID") + proto.RegisterType((*GNB_ID)(nil), "streaming_protobufs.GNB_ID") + proto.RegisterType((*GlobalGNB_ID_ExtIEs)(nil), "streaming_protobufs.GlobalGNB_ID_ExtIEs") + proto.RegisterType((*GTPtunnelEndpoint)(nil), "streaming_protobufs.GTPtunnelEndpoint") + proto.RegisterType((*GTPtunnelEndpoint_ExtIEs)(nil), "streaming_protobufs.GTPtunnelEndpoint_ExtIEs") + proto.RegisterType((*RLCMode)(nil), "streaming_protobufs.RLCMode") + proto.RegisterType((*RLC_Status)(nil), "streaming_protobufs.RLC_Status") + proto.RegisterType((*ULConfiguration)(nil), "streaming_protobufs.ULConfiguration") + proto.RegisterType((*PDCPSnLength)(nil), "streaming_protobufs.PDCPSnLength") + proto.RegisterType((*PDCPChangeIndication)(nil), "streaming_protobufs.PDCPChangeIndication") + proto.RegisterType((*SplitSRBs)(nil), "streaming_protobufs.SplitSRBs") + proto.RegisterType((*NRCGI)(nil), "streaming_protobufs.NRCGI") + proto.RegisterType((*NRCGI_ExtIEs)(nil), "streaming_protobufs.NRCGI_ExtIEs") + proto.RegisterType((*ECGI)(nil), "streaming_protobufs.ECGI") + proto.RegisterType((*E_RAB_List)(nil), "streaming_protobufs.E_RAB_List") + proto.RegisterType((*E_RAB_ItemIEs)(nil), "streaming_protobufs.E_RAB_ItemIEs") + proto.RegisterType((*E_RAB_Item)(nil), "streaming_protobufs.E_RAB_Item") + proto.RegisterType((*ERABActivityNotifyItemList)(nil), "streaming_protobufs.ERABActivityNotifyItemList") + proto.RegisterType((*ERABActivityNotifyItem)(nil), "streaming_protobufs.ERABActivityNotifyItem") + proto.RegisterType((*ERABActivityNotifyItem_ExtIEs)(nil), "streaming_protobufs.ERABActivityNotifyItem_ExtIEs") + proto.RegisterType((*UserPlaneTrafficActivityReport)(nil), "streaming_protobufs.UserPlaneTrafficActivityReport") + proto.RegisterType((*GNBOverloadInformation)(nil), "streaming_protobufs.GNBOverloadInformation") + proto.RegisterType((*CriticalityDiagnostics)(nil), "streaming_protobufs.CriticalityDiagnostics") + proto.RegisterType((*TriggeringMessage)(nil), "streaming_protobufs.TriggeringMessage") + proto.RegisterType((*Criticality)(nil), "streaming_protobufs.Criticality") + proto.RegisterType((*CriticalityDiagnostics_IE_List)(nil), "streaming_protobufs.CriticalityDiagnostics_IE_List") + proto.RegisterType((*CriticalityDiagnostics_IE_List_Item)(nil), "streaming_protobufs.CriticalityDiagnostics_IE_List_Item") + proto.RegisterType((*TypeOfError)(nil), "streaming_protobufs.TypeOfError") + proto.RegisterType((*CriticalityDiagnostics_ExtIEs)(nil), "streaming_protobufs.CriticalityDiagnostics_ExtIEs") + proto.RegisterType((*SgNBResourceCoordinationInformation)(nil), "streaming_protobufs.SgNBResourceCoordinationInformation") + proto.RegisterType((*SgNBResourceCoordinationInformationExtIEs)(nil), "streaming_protobufs.SgNBResourceCoordinationInformationExtIEs") + proto.RegisterType((*SgNBCoordinationAssistanceInformation)(nil), "streaming_protobufs.SgNBCoordinationAssistanceInformation") + proto.RegisterType((*RRC_Config_Ind)(nil), "streaming_protobufs.RRC_Config_Ind") + proto.RegisterType((*HandoverRestrictionList)(nil), "streaming_protobufs.HandoverRestrictionList") + proto.RegisterType((*EPLMNs)(nil), "streaming_protobufs.EPLMNs") + proto.RegisterType((*ForbiddenTAs)(nil), "streaming_protobufs.ForbiddenTAs") + proto.RegisterType((*ForbiddenTAs_Item)(nil), "streaming_protobufs.ForbiddenTAs_Item") + proto.RegisterType((*ForbiddenTACs)(nil), "streaming_protobufs.ForbiddenTACs") + proto.RegisterType((*ForbiddenLAs)(nil), "streaming_protobufs.ForbiddenLAs") + proto.RegisterType((*ForbiddenLAs_Item)(nil), "streaming_protobufs.ForbiddenLAs_Item") + proto.RegisterType((*ForbiddenLACs)(nil), "streaming_protobufs.ForbiddenLACs") + proto.RegisterType((*ForbiddenInterRATs)(nil), "streaming_protobufs.ForbiddenInterRATs") + proto.RegisterType((*HandoverRestrictionList_ExtIEs)(nil), "streaming_protobufs.HandoverRestrictionList_ExtIEs") + proto.RegisterType((*NRrestrictioninEPSasSecondaryRAT)(nil), "streaming_protobufs.NRrestrictioninEPSasSecondaryRAT") + proto.RegisterType((*CNTypeRestrictions)(nil), "streaming_protobufs.CNTypeRestrictions") + proto.RegisterType((*CNTypeRestrictionsItem)(nil), "streaming_protobufs.CNTypeRestrictionsItem") + proto.RegisterType((*NRrestrictionin5GS)(nil), "streaming_protobufs.NRrestrictionin5GS") + proto.RegisterType((*NRUESecurityCapabilities)(nil), "streaming_protobufs.NRUESecurityCapabilities") + proto.RegisterType((*UEAggregateMaximumBitRate)(nil), "streaming_protobufs.UEAggregateMaximumBitRate") + proto.RegisterType((*UEAggregate_MaximumBitrate_ExtIEs)(nil), "streaming_protobufs.UEAggregate_MaximumBitrate_ExtIEs") + proto.RegisterType((*DL_Forwarding)(nil), "streaming_protobufs.DL_Forwarding") + proto.RegisterType((*DuplicationActivation)(nil), "streaming_protobufs.DuplicationActivation") + proto.RegisterType((*MeNBResourceCoordinationInformation)(nil), "streaming_protobufs.MeNBResourceCoordinationInformation") + proto.RegisterType((*MeNBResourceCoordinationInformationExtIEs)(nil), "streaming_protobufs.MeNBResourceCoordinationInformationExtIEs") + proto.RegisterType((*MeNBCoordinationAssistanceInformation)(nil), "streaming_protobufs.MeNBCoordinationAssistanceInformation") + proto.RegisterType((*COUNTvalue)(nil), "streaming_protobufs.COUNTvalue") + proto.RegisterType((*COUNTValueExtended)(nil), "streaming_protobufs.COUNTValueExtended") + proto.RegisterType((*COUNTvaluePDCP_SNlength18)(nil), "streaming_protobufs.COUNTvaluePDCP_SNlength18") + proto.RegisterType((*ExpectedUEBehaviour)(nil), "streaming_protobufs.ExpectedUEBehaviour") + proto.RegisterType((*ExpectedUEActivityBehaviour)(nil), "streaming_protobufs.ExpectedUEActivityBehaviour") + proto.RegisterType((*ExpectedUEActivityBehaviour_ExtIEs)(nil), "streaming_protobufs.ExpectedUEActivityBehaviour_ExtIEs") + proto.RegisterType((*ExpectedHOInterval)(nil), "streaming_protobufs.ExpectedHOInterval") + proto.RegisterType((*SourceOfUEActivityBehaviourInformation)(nil), "streaming_protobufs.SourceOfUEActivityBehaviourInformation") + proto.RegisterType((*SGNB_Addition_Trigger_Ind)(nil), "streaming_protobufs.SGNB_Addition_Trigger_Ind") +} + +func init() { proto.RegisterFile("x2ap_common_types.proto", fileDescriptor_e082a304e8406c6c) } + +var fileDescriptor_e082a304e8406c6c = []byte{ + // 3509 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xdc, 0x5a, 0x4f, 0x6c, 0xdc, 0xc6, + 0x7a, 0x7f, 0xdc, 0x95, 0x56, 0xf6, 0x27, 0xc9, 0xa6, 0xc6, 0x92, 0x2c, 0xc9, 0x89, 0x63, 0xd3, + 0x89, 0x93, 0xbc, 0xd4, 0xb2, 0x2c, 0xc5, 0x89, 0x93, 0x97, 0xf7, 0x9a, 0xdd, 0xd5, 0x4a, 0xde, + 0x96, 0x5e, 0x6f, 0xb8, 0xda, 0xf8, 0xbd, 0x26, 0x28, 0x41, 0x91, 0x23, 0x6a, 0x1a, 0xee, 0x70, + 0x33, 0x1c, 0xca, 0x5e, 0xb4, 0x87, 0xa2, 0x05, 0x7a, 0x6a, 0xd1, 0x3f, 0xaf, 0x45, 0x2f, 0xef, + 0xd0, 0x43, 0x0f, 0x3d, 0xf6, 0xd0, 0x16, 0x45, 0x81, 0x77, 0xe8, 0x1f, 0x14, 0x28, 0xd0, 0x22, + 0x40, 0xd0, 0xf6, 0x5a, 0xa0, 0x40, 0x81, 0x9e, 0x7b, 0x29, 0xd0, 0x53, 0x31, 0x24, 0x57, 0x4b, + 0xee, 0xce, 0x2e, 0x29, 0xbb, 0xa7, 0xde, 0xc8, 0x99, 0xef, 0xfb, 0x7d, 0x7f, 0x66, 0xe6, 0x9b, + 0xef, 0x9b, 0x19, 0xb8, 0xfe, 0x62, 0xd7, 0xea, 0x9b, 0xb6, 0xdf, 0xeb, 0xf9, 0xd4, 0xe4, 0x83, + 0x3e, 0x0e, 0xb6, 0xfb, 0xcc, 0xe7, 0x3e, 0xba, 0x16, 0x70, 0x86, 0xad, 0x1e, 0xa1, 0xae, 0x19, + 0x35, 0x1c, 0x87, 0x27, 0xc1, 0xd6, 0x4d, 0xd7, 0xf7, 0x5d, 0x0f, 0xdf, 0x1f, 0xb6, 0xdc, 0x7f, + 0xce, 0xac, 0x7e, 0x1f, 0xb3, 0x84, 0x69, 0x6b, 0x05, 0x33, 0xe6, 0x33, 0xd3, 0xb6, 0xc2, 0x00, + 0xc7, 0x4d, 0xda, 0x7f, 0x95, 0xe0, 0x46, 0xa3, 0x65, 0xee, 0xd7, 0x4d, 0x03, 0x07, 0x7e, 0xc8, + 0x6c, 0x5c, 0xf7, 0xe9, 0x09, 0x71, 0x43, 0x66, 0x71, 0xe2, 0x53, 0xf4, 0x0c, 0xa0, 0xbf, 0x5f, + 0x6f, 0x5b, 0xbc, 0xe3, 0xb6, 0x6a, 0x1b, 0xca, 0x2d, 0xe5, 0x9d, 0x2b, 0xbb, 0x1f, 0x6e, 0x4b, + 0x84, 0x6f, 0xcf, 0x40, 0xd9, 0xee, 0x70, 0x8b, 0x87, 0x81, 0x91, 0x82, 0x42, 0x5f, 0xc0, 0x52, + 0xaf, 0x7e, 0xc8, 0x12, 0xf2, 0x60, 0xa3, 0xf4, 0x6a, 0xd0, 0x19, 0x30, 0x01, 0x1e, 0xa4, 0xc1, + 0xcb, 0xaf, 0x08, 0x9e, 0x06, 0xd3, 0x3e, 0x85, 0x4a, 0xdc, 0x8e, 0x36, 0x60, 0x75, 0x88, 0x63, + 0x86, 0x34, 0xe8, 0x63, 0x9b, 0x9c, 0x10, 0xec, 0xa8, 0xdf, 0x41, 0x8b, 0xb0, 0xd0, 0x67, 0x38, + 0xc0, 0x94, 0xab, 0x0a, 0xba, 0x0a, 0x8b, 0xd4, 0xe7, 0xe6, 0xb0, 0xa1, 0xa4, 0xfd, 0x5b, 0x09, + 0xb6, 0x1a, 0xa6, 0x51, 0xad, 0x99, 0x3a, 0x3e, 0xc3, 0x9e, 0xf9, 0x99, 0xdf, 0x31, 0xdb, 0x16, + 0xb3, 0x7a, 0x98, 0x63, 0x16, 0x20, 0x15, 0xca, 0x5f, 0xd7, 0x9b, 0x91, 0xb3, 0x97, 0x0d, 0xf1, + 0x89, 0x7e, 0x19, 0x6e, 0x5a, 0x9e, 0xe7, 0xdb, 0x91, 0x56, 0x55, 0xea, 0x18, 0x98, 0x63, 0x2a, + 0xbe, 0xdb, 0x8c, 0xf8, 0x8c, 0xf0, 0x41, 0xe4, 0xbe, 0xc5, 0xdd, 0x3d, 0xa9, 0x85, 0xd5, 0x99, + 0xac, 0x46, 0x0e, 0x34, 0xea, 0xc2, 0x8a, 0x7b, 0xcc, 0x3e, 0xf3, 0x83, 0x26, 0x3d, 0xf1, 0x59, + 0x2f, 0x22, 0x8c, 0x3c, 0xba, 0xb8, 0xfb, 0xb6, 0x54, 0xde, 0x61, 0xcd, 0x30, 0xb3, 0xe4, 0xc6, + 0x24, 0x02, 0xfa, 0x02, 0x96, 0x49, 0xc3, 0x6c, 0xbc, 0xe0, 0x98, 0x06, 0xc4, 0xa7, 0xc1, 0xc6, + 0xdc, 0xad, 0xf2, 0x3b, 0x8b, 0xbb, 0x1f, 0xc8, 0x07, 0x69, 0xaa, 0xb7, 0x04, 0x42, 0xb3, 0x11, + 0x18, 0x4b, 0xa4, 0x31, 0xc2, 0xd2, 0x7e, 0xb7, 0x04, 0x37, 0x67, 0x9b, 0x8d, 0xde, 0x84, 0xe5, + 0x7e, 0xf2, 0x1d, 0xe1, 0x26, 0xfe, 0xce, 0x36, 0x22, 0x13, 0xd6, 0xfa, 0x0c, 0x9b, 0xb8, 0xd7, + 0x17, 0xcc, 0x75, 0xab, 0x6f, 0x1d, 0x13, 0x6f, 0xe4, 0xf0, 0xef, 0x4a, 0xb5, 0x6d, 0xcb, 0x38, + 0x8c, 0xd5, 0x3e, 0xc3, 0x8d, 0xf1, 0x56, 0x74, 0x0a, 0x1b, 0x29, 0x01, 0x9f, 0x87, 0x1e, 0xc5, + 0x6c, 0x28, 0x23, 0x76, 0xf2, 0xbd, 0x3c, 0x19, 0x19, 0x26, 0xe3, 0xfa, 0x48, 0x4c, 0xa6, 0x43, + 0xfb, 0x53, 0x05, 0x36, 0xa6, 0x71, 0xa1, 0x26, 0xcc, 0x9f, 0x59, 0x5e, 0x88, 0x93, 0x25, 0xbe, + 0x77, 0x21, 0x99, 0xdb, 0x9f, 0x0b, 0x56, 0x23, 0x46, 0xd0, 0x9a, 0x30, 0x1f, 0xfd, 0xcf, 0x58, + 0x1e, 0xab, 0xa0, 0x26, 0x2b, 0x22, 0xc2, 0xb3, 0x8e, 0x3d, 0xac, 0x2a, 0x48, 0x85, 0xa5, 0x4c, + 0x4b, 0x49, 0xfb, 0x1b, 0x05, 0xd6, 0xa4, 0xce, 0x44, 0x07, 0x59, 0x7d, 0x77, 0x8a, 0x8f, 0x43, + 0x56, 0x59, 0x2b, 0x5f, 0xd9, 0xdb, 0xf0, 0x7a, 0x70, 0x6a, 0x79, 0x9e, 0x29, 0x54, 0xe6, 0x8c, + 0xb8, 0x2e, 0x66, 0x66, 0x6a, 0xcc, 0x54, 0x05, 0xdd, 0x80, 0xeb, 0x3d, 0x6b, 0x20, 0xed, 0x2c, + 0x69, 0xff, 0xa2, 0xc0, 0xed, 0xdc, 0xf9, 0x8b, 0x7e, 0x04, 0x9b, 0xc4, 0x31, 0xf7, 0xfd, 0xe7, + 0xd4, 0x23, 0xf4, 0xab, 0xb6, 0x65, 0x7f, 0x85, 0xb9, 0xee, 0x07, 0x81, 0x61, 0xf1, 0xd8, 0xc8, + 0xc5, 0xdd, 0xd7, 0xb6, 0xe3, 0xf8, 0xbe, 0x3d, 0x54, 0x74, 0xbb, 0xdb, 0xa4, 0x7c, 0x6f, 0x37, + 0x36, 0x68, 0x83, 0x38, 0x72, 0x6e, 0xd4, 0x85, 0xeb, 0xc4, 0x31, 0xbb, 0x7d, 0x09, 0x70, 0xa9, + 0x00, 0xf0, 0x3a, 0x71, 0x64, 0xbc, 0xda, 0x3f, 0x95, 0x00, 0x4d, 0x2e, 0x75, 0xf4, 0x3e, 0xac, + 0xe3, 0xc8, 0xda, 0x27, 0xd6, 0x0b, 0xd2, 0x0b, 0x7b, 0x35, 0xc2, 0x99, 0xc5, 0xf1, 0xbe, 0x1e, + 0x59, 0x31, 0x67, 0xac, 0x62, 0xa3, 0x5a, 0x1b, 0xef, 0x9b, 0xc6, 0xd5, 0xd5, 0x23, 0x15, 0xa5, + 0x5c, 0x5d, 0x1d, 0x7d, 0x0c, 0x9b, 0x31, 0xd7, 0x61, 0x68, 0x31, 0x8b, 0x72, 0x8c, 0x9d, 0x91, + 0xb8, 0x72, 0xc4, 0x78, 0x5d, 0x30, 0x4a, 0xba, 0x67, 0xf0, 0x76, 0xf5, 0x8d, 0xb9, 0x19, 0xbc, + 0x5d, 0x1d, 0x75, 0xc6, 0x63, 0xd7, 0x7c, 0x14, 0xbb, 0xb6, 0x0b, 0x86, 0x43, 0x79, 0xcc, 0xfa, + 0xa6, 0x0c, 0x9b, 0x53, 0x69, 0xd1, 0x29, 0x68, 0xc4, 0x31, 0xb1, 0x20, 0x77, 0xb0, 0x63, 0xce, + 0x70, 0xf1, 0xb4, 0xf1, 0xfc, 0xe0, 0xfd, 0x78, 0x3c, 0x6f, 0x12, 0xa7, 0x91, 0xc0, 0x34, 0x64, + 0x43, 0x51, 0x40, 0x52, 0x32, 0x2c, 0xaf, 0x24, 0xa9, 0xab, 0x23, 0x0a, 0x6f, 0x4d, 0x4a, 0x9a, + 0x36, 0x94, 0x79, 0xc2, 0x6e, 0x67, 0x85, 0xc9, 0x86, 0xbc, 0x98, 0xbc, 0x64, 0xf8, 0x5f, 0x55, + 0x5e, 0x57, 0xd7, 0xfe, 0x42, 0x81, 0xa5, 0x43, 0xcf, 0x3f, 0xb6, 0xbc, 0xc3, 0x56, 0xcd, 0x6c, + 0xee, 0xa3, 0x3b, 0xb0, 0xdc, 0xd7, 0x9f, 0xb4, 0xcc, 0xa6, 0x23, 0x36, 0x23, 0x3e, 0x88, 0xc6, + 0x6b, 0xc9, 0x58, 0x12, 0x8d, 0xc3, 0x36, 0xb4, 0x0b, 0x15, 0x37, 0x22, 0x4f, 0x7c, 0x7c, 0x43, + 0x3e, 0xab, 0x22, 0x12, 0x63, 0xde, 0x6d, 0xd5, 0x9a, 0xfb, 0xe8, 0xc9, 0xf8, 0x84, 0x2c, 0x47, + 0x13, 0xf2, 0x1d, 0x39, 0x6b, 0x4a, 0x25, 0xf9, 0x54, 0xbc, 0x0b, 0x95, 0x44, 0xe3, 0xeb, 0xe7, + 0xca, 0x44, 0xaa, 0x3e, 0xfe, 0x4e, 0x22, 0xb1, 0x56, 0x06, 0xc5, 0xd6, 0xd6, 0xe0, 0x9a, 0x04, + 0x4c, 0xfb, 0x4b, 0x05, 0x56, 0x0e, 0x8f, 0xda, 0x3c, 0xa4, 0x14, 0x7b, 0x0d, 0xea, 0xf4, 0x7d, + 0x42, 0x39, 0x7a, 0x1f, 0xd6, 0x38, 0xb3, 0x68, 0xd0, 0xf7, 0x19, 0xd7, 0xad, 0x01, 0x66, 0x55, + 0xc7, 0x61, 0x38, 0x08, 0x12, 0x27, 0xc8, 0x3b, 0xd1, 0x26, 0x5c, 0x72, 0x8f, 0xda, 0xe6, 0x51, + 0x23, 0xf1, 0xc7, 0x92, 0xb1, 0xe0, 0x1e, 0xb5, 0xc5, 0x2f, 0x32, 0xe4, 0x46, 0xcb, 0xf7, 0xcb, + 0x09, 0x7d, 0xe4, 0x96, 0x6f, 0xc1, 0xc6, 0x34, 0x4a, 0xed, 0x1f, 0x14, 0x58, 0x30, 0xf4, 0xfa, + 0x13, 0xdf, 0xc1, 0xe8, 0x51, 0x76, 0xff, 0xd1, 0xa4, 0x32, 0x13, 0xe2, 0xec, 0x8e, 0xf3, 0xeb, + 0x4a, 0xfe, 0x96, 0x03, 0x50, 0x61, 0x9e, 0x6d, 0x5a, 0x3d, 0x55, 0x11, 0x54, 0xe2, 0x3b, 0xec, + 0x99, 0xc7, 0xc4, 0x21, 0x0c, 0xdb, 0x22, 0x2a, 0x58, 0x9e, 0x5a, 0x42, 0xaf, 0xc1, 0x46, 0xd2, + 0x13, 0xd2, 0x74, 0x97, 0x19, 0x7a, 0x6a, 0x79, 0x7a, 0xaf, 0xe3, 0xa9, 0x73, 0xda, 0xb7, 0x0a, + 0x80, 0xa1, 0xd7, 0xcd, 0x24, 0x93, 0x1d, 0xc0, 0x16, 0xc3, 0x38, 0x10, 0xfb, 0x2e, 0x09, 0x4e, + 0x7b, 0x98, 0x72, 0xb3, 0x49, 0x1d, 0x12, 0xa7, 0x4f, 0x89, 0x8d, 0x1f, 0x4f, 0xb3, 0x31, 0x01, + 0xd9, 0x36, 0xa6, 0x22, 0x18, 0x9b, 0x63, 0xe8, 0xa3, 0x2e, 0xad, 0x09, 0x5b, 0xd3, 0x19, 0x67, + 0xf8, 0x68, 0x05, 0x96, 0x53, 0xa0, 0xd8, 0x51, 0x15, 0x31, 0xef, 0xae, 0x76, 0xf5, 0x6c, 0x01, + 0xf3, 0x19, 0x2c, 0x84, 0xba, 0xd9, 0xde, 0xaf, 0xb7, 0x13, 0x33, 0x1e, 0x49, 0xcd, 0x18, 0x63, + 0xdb, 0xee, 0xea, 0x66, 0xb7, 0x61, 0x66, 0xda, 0x8c, 0x4a, 0xa8, 0x0b, 0x1c, 0xcd, 0x80, 0x6b, + 0x92, 0xee, 0xd9, 0xd5, 0x00, 0xf5, 0x4d, 0xc7, 0xe2, 0x96, 0xaa, 0x88, 0xb1, 0x0d, 0x4e, 0x2d, + 0x86, 0x1d, 0xb5, 0x84, 0x2e, 0xc1, 0x9c, 0x4f, 0xbd, 0x81, 0x5a, 0xd6, 0x7e, 0x5f, 0x81, 0x25, + 0x01, 0xde, 0xa1, 0x3a, 0xa6, 0x2e, 0x3f, 0x45, 0xdf, 0xcf, 0x4e, 0x30, 0x79, 0xa6, 0x9d, 0xe6, + 0xc8, 0xce, 0xb2, 0x46, 0xfe, 0x24, 0xbb, 0x0a, 0x8b, 0xfc, 0x39, 0xf6, 0xce, 0xb0, 0x79, 0x4c, + 0x78, 0xa0, 0x2a, 0xc2, 0xa3, 0x98, 0xb8, 0xa7, 0x1c, 0x63, 0x1a, 0x37, 0x95, 0xb4, 0x9f, 0x2a, + 0xb0, 0x2a, 0x84, 0xd4, 0x4f, 0x2d, 0xea, 0xe2, 0xd4, 0xb8, 0x34, 0xb2, 0xea, 0xdd, 0x9f, 0xaa, + 0xde, 0x38, 0x67, 0x56, 0xcd, 0x5f, 0xcc, 0x57, 0x73, 0x0b, 0xd6, 0x03, 0xf3, 0xe7, 0x45, 0x10, + 0x0a, 0xfb, 0x8e, 0xc5, 0xb1, 0xc9, 0xf0, 0xd7, 0x21, 0x11, 0xfe, 0x53, 0xd0, 0x1b, 0x70, 0x43, + 0x94, 0x94, 0x91, 0x6b, 0x4d, 0x86, 0x6d, 0xff, 0x0c, 0xb3, 0xc1, 0x88, 0xa0, 0xa4, 0xfd, 0xa6, + 0x02, 0x97, 0x3b, 0x7d, 0x8f, 0xf0, 0x8e, 0x51, 0x0b, 0xd0, 0xc7, 0x59, 0xa5, 0xdf, 0x94, 0x2a, + 0x7d, 0x4e, 0x9e, 0xd5, 0xb4, 0x9e, 0xaf, 0xe9, 0x25, 0x98, 0x0b, 0xd8, 0xf1, 0x03, 0x55, 0x49, + 0xbe, 0x76, 0xd5, 0x12, 0x5a, 0x82, 0x4b, 0xa2, 0xcd, 0xa2, 0xce, 0xae, 0x5a, 0xd6, 0xfe, 0x48, + 0x81, 0xf9, 0x96, 0x51, 0x3f, 0x6c, 0x16, 0xdb, 0x09, 0xbe, 0x0b, 0x2a, 0x35, 0x6c, 0xec, 0x79, + 0x71, 0xcb, 0x09, 0xc1, 0x2c, 0x89, 0x81, 0x13, 0xed, 0xe8, 0x40, 0x1e, 0x0c, 0x6f, 0x4b, 0x6d, + 0x8c, 0x74, 0x90, 0x07, 0xc0, 0x2b, 0xb0, 0x94, 0xee, 0xd5, 0x4c, 0x98, 0x6b, 0x14, 0x56, 0x78, + 0x17, 0x56, 0x71, 0xf7, 0xc8, 0xa8, 0xb6, 0xa4, 0x4a, 0x4b, 0xfb, 0xb4, 0x03, 0x80, 0x24, 0x3b, + 0x26, 0x01, 0x17, 0x71, 0x95, 0x70, 0xdc, 0x13, 0x9b, 0x82, 0x50, 0x5f, 0x9b, 0x51, 0x0d, 0x36, + 0x39, 0xee, 0x09, 0xfd, 0x63, 0x06, 0xad, 0x03, 0xcb, 0x99, 0x76, 0x54, 0x83, 0x65, 0xe2, 0x98, + 0xa3, 0xb6, 0x24, 0x39, 0x7a, 0x23, 0x07, 0xd2, 0x00, 0x12, 0x6d, 0xe8, 0xe2, 0x5b, 0xfb, 0xe1, + 0x50, 0x39, 0xf1, 0x87, 0x36, 0xe0, 0x52, 0x9c, 0x33, 0x24, 0xdb, 0xe1, 0xb2, 0x51, 0x11, 0x19, + 0x62, 0x73, 0x1f, 0xed, 0xc0, 0x7c, 0x74, 0xaa, 0x92, 0x6c, 0xd9, 0x5b, 0x52, 0x19, 0x75, 0x41, + 0x61, 0xc4, 0x84, 0x9a, 0x09, 0x5b, 0x42, 0x4a, 0xd5, 0xe6, 0xe4, 0x8c, 0xf0, 0x41, 0xcb, 0xe7, + 0xe4, 0x64, 0x20, 0xa4, 0x44, 0x6e, 0xa8, 0x66, 0xdd, 0xf0, 0x9e, 0x5c, 0x67, 0x29, 0xff, 0xd0, + 0x1f, 0xff, 0xa9, 0xc0, 0xba, 0x9c, 0x62, 0x86, 0x1d, 0x5f, 0xc0, 0x15, 0x2b, 0xa1, 0x37, 0xb0, + 0xd8, 0x8b, 0x67, 0x1e, 0x2c, 0x74, 0x03, 0xcc, 0xda, 0x9e, 0x45, 0xf1, 0x11, 0xb3, 0x4e, 0x4e, + 0x88, 0x5d, 0xcd, 0xb0, 0x1a, 0x63, 0x50, 0xe8, 0xd9, 0xe4, 0x14, 0x15, 0xd8, 0xbb, 0x17, 0x30, + 0x4e, 0x3e, 0x67, 0xdf, 0x80, 0xd7, 0x67, 0x92, 0x6b, 0x7f, 0xa6, 0xc0, 0xcd, 0xd9, 0xca, 0xa2, + 0xa7, 0xd9, 0xd8, 0xf0, 0xd1, 0x4b, 0x18, 0x9c, 0x0d, 0x18, 0xd5, 0xfc, 0x80, 0xb1, 0x04, 0x97, + 0x08, 0x8d, 0x9c, 0x94, 0x94, 0xbf, 0x0c, 0x9b, 0xd1, 0xaf, 0xc5, 0xa3, 0xe8, 0xf5, 0x27, 0x0a, + 0xac, 0x1f, 0xb6, 0x6a, 0x4f, 0xcf, 0x30, 0xf3, 0x7c, 0xcb, 0x49, 0x57, 0x59, 0x87, 0x59, 0x75, + 0x1f, 0x4c, 0xcb, 0x11, 0x25, 0xbc, 0x17, 0xde, 0x28, 0xae, 0x00, 0xf8, 0x09, 0x4c, 0x14, 0x75, + 0x11, 0x5c, 0x11, 0xa5, 0x70, 0xaa, 0xad, 0xa4, 0xfd, 0x73, 0x19, 0xd6, 0xeb, 0x8c, 0x70, 0x62, + 0x5b, 0xa2, 0xc8, 0xde, 0x27, 0x96, 0x4b, 0xfd, 0x80, 0x13, 0x3b, 0x5a, 0x87, 0x7d, 0xe6, 0xdb, + 0xd8, 0x09, 0x19, 0xae, 0xfb, 0x4e, 0xb1, 0x6a, 0x36, 0xcb, 0x82, 0x8e, 0x60, 0x25, 0x29, 0xae, + 0x09, 0x75, 0x9f, 0xe0, 0x20, 0xb0, 0xdc, 0xe1, 0x5a, 0xbb, 0x2b, 0x35, 0xfd, 0x68, 0x9c, 0xda, + 0x98, 0x04, 0x40, 0x47, 0x91, 0xc9, 0x89, 0x98, 0x91, 0xf2, 0xc9, 0xbc, 0xbc, 0x25, 0x5f, 0xc4, + 0x23, 0x3a, 0x43, 0xca, 0x8d, 0xbe, 0x86, 0x4d, 0xd2, 0x08, 0xe4, 0xce, 0x48, 0x2a, 0x8b, 0xbd, + 0x3c, 0xe8, 0x14, 0x8b, 0xd9, 0x6c, 0x44, 0xa1, 0xd1, 0x98, 0x8e, 0x3a, 0xb9, 0xb2, 0xe2, 0x7a, + 0x74, 0xf7, 0x22, 0x62, 0xa4, 0x2b, 0xeb, 0xef, 0x14, 0x58, 0x99, 0x70, 0x25, 0xaa, 0x65, 0x27, + 0xdf, 0xcf, 0x14, 0x1b, 0x81, 0xec, 0xbc, 0xfb, 0x2a, 0x7f, 0xde, 0xad, 0x03, 0x22, 0x94, 0x70, + 0x62, 0x71, 0x81, 0xdc, 0x8b, 0x51, 0x54, 0x45, 0xb4, 0x07, 0xa1, 0x6d, 0xe3, 0x20, 0x38, 0x09, + 0x3d, 0xd3, 0x0f, 0xb9, 0xed, 0xf7, 0xb0, 0x5a, 0x12, 0x48, 0x21, 0x95, 0xf4, 0x94, 0xb5, 0xdf, + 0x53, 0x60, 0x31, 0x3d, 0x44, 0x9f, 0x64, 0x0d, 0xb8, 0x9b, 0xe7, 0xa7, 0x0b, 0x2f, 0x19, 0x91, + 0xc0, 0xe3, 0x5f, 0xc2, 0x36, 0x8f, 0x13, 0x3e, 0xe2, 0x52, 0x9f, 0x09, 0x15, 0x01, 0x2a, 0x34, + 0x8a, 0x4e, 0x6a, 0x59, 0xeb, 0xc3, 0xcd, 0xd9, 0x23, 0x8e, 0x5a, 0xd9, 0x5d, 0xe0, 0xd1, 0x4b, + 0xcc, 0x1a, 0x33, 0xbd, 0x25, 0xfc, 0xbd, 0x02, 0x77, 0x0a, 0x90, 0xc7, 0xb9, 0x44, 0x7a, 0x41, + 0x28, 0x05, 0x17, 0x44, 0x96, 0x0d, 0x5d, 0x83, 0x79, 0xd2, 0x18, 0x16, 0xb2, 0xcb, 0xc6, 0x1c, + 0x11, 0x55, 0x5b, 0x0d, 0x16, 0xf9, 0xa0, 0x8f, 0x9f, 0x9e, 0x34, 0x18, 0xf3, 0xd9, 0xcc, 0xb5, + 0x76, 0x34, 0xa2, 0x33, 0xd2, 0x4c, 0xda, 0x6f, 0x2b, 0xb0, 0x98, 0xea, 0x2c, 0x36, 0x9e, 0x29, + 0x86, 0xec, 0x78, 0xd6, 0xf2, 0xc7, 0x33, 0x09, 0x79, 0x21, 0x75, 0x30, 0x0b, 0xb8, 0xef, 0x8b, + 0x30, 0xb8, 0x08, 0x0b, 0x3d, 0x12, 0x04, 0x84, 0xba, 0x6a, 0x49, 0x6c, 0x41, 0x33, 0xd7, 0x95, + 0xf6, 0xaf, 0x25, 0xb8, 0xd3, 0x71, 0x5b, 0xb5, 0xd1, 0x45, 0x83, 0xcf, 0x1c, 0x42, 0xa3, 0x88, + 0x9c, 0x0e, 0xec, 0x0f, 0xa0, 0x42, 0x0d, 0xb3, 0x7e, 0xd8, 0x4c, 0x9c, 0xbe, 0x35, 0x3d, 0x81, + 0x33, 0xe6, 0x69, 0x94, 0x4b, 0x7e, 0x02, 0x9b, 0xa1, 0x3e, 0x05, 0x2f, 0x49, 0xbd, 0xa6, 0x13, + 0xa0, 0x1f, 0xc1, 0xa6, 0x33, 0x95, 0xbb, 0x9c, 0x9c, 0x40, 0x8c, 0x87, 0xea, 0xda, 0x80, 0xe3, + 0x20, 0x76, 0xe2, 0x74, 0x6e, 0x64, 0xcb, 0x8f, 0xf8, 0x7f, 0x20, 0xcf, 0xbb, 0xf3, 0x9d, 0x23, + 0x0d, 0x51, 0xff, 0xad, 0xc0, 0xbb, 0x85, 0x79, 0xd1, 0x2e, 0x2c, 0x88, 0xa4, 0x70, 0xe4, 0xdf, + 0x4d, 0x79, 0xf6, 0x21, 0xdc, 0x5b, 0x21, 0x4e, 0x94, 0xfa, 0xfe, 0x81, 0x02, 0xef, 0x10, 0xc7, + 0x14, 0x42, 0xd2, 0xe0, 0xd5, 0x20, 0x20, 0x01, 0xb7, 0xa8, 0x8d, 0xc7, 0xfd, 0xbd, 0x38, 0xa5, + 0x56, 0x2e, 0x84, 0x60, 0xbc, 0x4d, 0x9c, 0x42, 0x84, 0xda, 0x5f, 0x2b, 0xf0, 0x56, 0x21, 0x4a, + 0xf4, 0x79, 0x76, 0x7d, 0x7c, 0xfa, 0xf2, 0xda, 0x65, 0x57, 0xce, 0xa7, 0xf9, 0x2b, 0xe7, 0x75, + 0xd8, 0xb4, 0x53, 0xa0, 0xd1, 0x21, 0xfa, 0xa8, 0x82, 0xd3, 0xfe, 0x50, 0x81, 0x2b, 0x86, 0x51, + 0x4f, 0x4a, 0x69, 0x51, 0xf9, 0xa3, 0x9f, 0xcd, 0x2a, 0xfb, 0xae, 0xfc, 0xd8, 0x21, 0xc3, 0x93, + 0xd5, 0x6a, 0xbf, 0x50, 0xed, 0x7b, 0x12, 0x7a, 0x9e, 0x69, 0x47, 0x10, 0x71, 0xf2, 0xe5, 0x60, + 0x8f, 0x5b, 0xc3, 0x96, 0x92, 0xf6, 0xb7, 0x65, 0xb8, 0xfe, 0xd8, 0xa2, 0x8e, 0x48, 0x73, 0x0c, + 0x1c, 0x70, 0x46, 0xa2, 0x03, 0x94, 0x28, 0x30, 0xdf, 0x82, 0xc5, 0x00, 0xb3, 0x33, 0x42, 0xdd, + 0xb6, 0xfe, 0xa4, 0x95, 0x94, 0x42, 0xe9, 0x26, 0xd4, 0x80, 0xab, 0xc2, 0xc8, 0x33, 0xcb, 0xc3, + 0x94, 0x8b, 0x96, 0x60, 0xe6, 0x69, 0x5e, 0x23, 0x22, 0x31, 0xc6, 0x79, 0x50, 0x03, 0x96, 0x4e, + 0x7c, 0x76, 0x4c, 0x1c, 0x07, 0xd3, 0xa3, 0xea, 0x30, 0x63, 0x96, 0x17, 0x75, 0x07, 0x29, 0x42, + 0x23, 0xc3, 0x96, 0x81, 0xd1, 0xab, 0xc3, 0x2c, 0x24, 0x07, 0x46, 0xcf, 0xc0, 0xe8, 0x55, 0x91, + 0x66, 0xa0, 0xf3, 0xff, 0x26, 0xe5, 0x98, 0x19, 0xd5, 0x23, 0x91, 0x6b, 0x4c, 0xbf, 0x0a, 0x3c, + 0x98, 0x20, 0x37, 0x24, 0x10, 0xe8, 0x87, 0xe3, 0x81, 0xa2, 0x12, 0x05, 0x0a, 0x79, 0x9a, 0x34, + 0x65, 0x50, 0xe4, 0x09, 0xcc, 0x4d, 0xa8, 0xc4, 0xbe, 0x45, 0xab, 0xe9, 0xcd, 0x74, 0x69, 0xb8, + 0x25, 0xea, 0xb0, 0x94, 0xf6, 0x9b, 0xd8, 0x49, 0xd2, 0x5b, 0xee, 0xdd, 0x5c, 0x4f, 0x67, 0x36, + 0xd8, 0x5f, 0x53, 0x60, 0x65, 0xa2, 0xb3, 0x58, 0xe9, 0xfc, 0x18, 0x96, 0x53, 0x43, 0x56, 0x1f, + 0x4e, 0x17, 0x2d, 0x4f, 0x81, 0x7a, 0x60, 0x64, 0x19, 0xb5, 0xb7, 0x60, 0x39, 0xd3, 0x5f, 0xc0, + 0x72, 0xfd, 0xc2, 0x96, 0xeb, 0xb3, 0x2c, 0xd7, 0x5f, 0xda, 0x72, 0xbd, 0xb0, 0xe5, 0x7a, 0xd6, + 0x72, 0x7d, 0xdc, 0x72, 0x7d, 0xba, 0xe5, 0xdf, 0x2a, 0x80, 0x26, 0x27, 0x26, 0xaa, 0x67, 0xe3, + 0xce, 0xbd, 0x82, 0x13, 0x3a, 0x1b, 0x7b, 0x9e, 0xe7, 0xc7, 0x9e, 0x05, 0x28, 0x5b, 0x9e, 0xa7, + 0x2a, 0xe8, 0x32, 0xcc, 0xbb, 0x98, 0x59, 0x54, 0x2d, 0x89, 0xcf, 0x90, 0x8b, 0xcf, 0xb2, 0x28, + 0x0a, 0x6d, 0xa7, 0x67, 0xed, 0xee, 0xec, 0xec, 0xa8, 0x73, 0x68, 0x05, 0x96, 0x23, 0x1a, 0x8b, + 0x3a, 0x31, 0xc1, 0x3c, 0x5a, 0x05, 0x75, 0x48, 0x70, 0xde, 0x5a, 0xd1, 0xfe, 0xa3, 0x04, 0x37, + 0x67, 0xaf, 0x0c, 0xf4, 0x1b, 0x0a, 0xdc, 0x21, 0x8e, 0xd9, 0x32, 0xd8, 0xa8, 0x9f, 0xd0, 0x46, + 0xbb, 0x63, 0x05, 0x1d, 0x6c, 0xfb, 0xd4, 0xb1, 0xd8, 0xc0, 0xa8, 0x1e, 0x25, 0x1b, 0xe3, 0xc3, + 0x29, 0x89, 0xc7, 0x6c, 0x66, 0x43, 0x23, 0x4e, 0x1e, 0x0d, 0xfa, 0x12, 0xd6, 0x88, 0x63, 0xd6, + 0x5b, 0x22, 0x23, 0x4b, 0xe9, 0x3a, 0x1c, 0x79, 0x79, 0x28, 0x99, 0x24, 0x37, 0x56, 0x89, 0x33, + 0xd9, 0x9a, 0xa0, 0x8f, 0x29, 0xf1, 0xf0, 0xb0, 0x33, 0xf3, 0xcd, 0xc2, 0x24, 0xb9, 0x40, 0x9f, + 0x6c, 0xd5, 0x7e, 0xaa, 0xc0, 0xad, 0x5c, 0x03, 0x3f, 0xcb, 0x4e, 0xa5, 0xef, 0xbd, 0x94, 0x2b, + 0xb3, 0x13, 0xeb, 0x20, 0x7f, 0x62, 0xdd, 0x81, 0x37, 0xe8, 0x39, 0x26, 0x76, 0x24, 0x90, 0xaa, + 0xa2, 0x3d, 0x03, 0x24, 0xf1, 0x59, 0xa1, 0xf3, 0xa6, 0x49, 0xbe, 0x74, 0x04, 0xf8, 0x2b, 0x05, + 0xd6, 0xe5, 0x14, 0xe8, 0x3a, 0x2c, 0xf4, 0xbd, 0x1e, 0x35, 0x9b, 0x4e, 0x12, 0x00, 0x2a, 0xe2, + 0xb7, 0xe9, 0x20, 0x1d, 0x16, 0xec, 0xf8, 0x5d, 0x53, 0xf2, 0xfe, 0x67, 0xef, 0x02, 0x82, 0xb7, + 0xeb, 0xad, 0x88, 0xd5, 0xa8, 0xd8, 0x54, 0xf4, 0x6b, 0x1f, 0xc1, 0x42, 0xd2, 0x34, 0xfb, 0xe9, + 0xc1, 0x09, 0x39, 0xc3, 0x87, 0x75, 0xf3, 0x3c, 0x76, 0xa8, 0x8a, 0xf6, 0x63, 0x05, 0xd0, 0xe4, + 0x60, 0x17, 0x0b, 0x09, 0x93, 0x7c, 0xd9, 0x91, 0x7b, 0x94, 0x3f, 0x72, 0x6b, 0xb0, 0x92, 0x1d, + 0xb9, 0x87, 0x87, 0x1d, 0x55, 0xd1, 0x7e, 0xa2, 0xc0, 0x46, 0xcb, 0xe8, 0x36, 0x3a, 0xd8, 0x0e, + 0x19, 0xe1, 0x83, 0xf3, 0x47, 0x0c, 0x04, 0x07, 0xe8, 0x03, 0x58, 0xa7, 0x06, 0xa6, 0x36, 0x1b, + 0x44, 0x0f, 0x0d, 0xaa, 0x9e, 0xeb, 0x33, 0xc2, 0x4f, 0x7b, 0xc3, 0xfb, 0xb4, 0x29, 0xbd, 0xe8, + 0xb1, 0x98, 0x25, 0x84, 0x72, 0xec, 0x0a, 0xc8, 0x36, 0xf3, 0x79, 0x7c, 0x33, 0x94, 0x02, 0x88, + 0x6b, 0x86, 0x3c, 0x32, 0xed, 0x77, 0x4a, 0xb0, 0xd9, 0x6d, 0x54, 0x5d, 0x97, 0x61, 0xd7, 0xe2, + 0x78, 0x74, 0xbd, 0x1b, 0xbd, 0x3a, 0xd0, 0xe1, 0x76, 0xd8, 0xb0, 0xe4, 0x9d, 0xc3, 0x87, 0x0a, + 0xc9, 0x93, 0x80, 0x7c, 0x42, 0xa1, 0xf5, 0x54, 0xa2, 0xf8, 0x75, 0x42, 0xf2, 0x50, 0x20, 0x8f, + 0x6c, 0xf2, 0xdd, 0x51, 0x79, 0xc6, 0xbb, 0xa3, 0x94, 0x79, 0x63, 0x57, 0xe0, 0xf2, 0x74, 0xe3, + 0x8f, 0x4b, 0x70, 0x3b, 0x97, 0x07, 0xfd, 0xaa, 0x02, 0xf7, 0xd2, 0x17, 0xd1, 0xc5, 0xfc, 0x94, + 0x77, 0x21, 0xfd, 0xde, 0xe8, 0x42, 0xba, 0x9b, 0xeb, 0xcf, 0x5f, 0x81, 0xf7, 0x0a, 0x69, 0x90, + 0xf2, 0x6d, 0x9e, 0xfc, 0x77, 0x0b, 0xc8, 0x8f, 0xe1, 0xb4, 0xdf, 0x52, 0x60, 0x79, 0x5f, 0x37, + 0x0f, 0x7c, 0xf6, 0xdc, 0x12, 0xa5, 0x81, 0x8b, 0x7e, 0x90, 0x5d, 0x69, 0xf2, 0x8b, 0xeb, 0x0c, + 0x4b, 0x76, 0x91, 0x7d, 0x92, 0xbf, 0xc8, 0x36, 0x61, 0xcd, 0xd1, 0xc5, 0xaa, 0x4f, 0x00, 0xda, + 0xcc, 0xef, 0xfb, 0x41, 0x54, 0x85, 0xfc, 0x44, 0x81, 0xb5, 0xfd, 0xb0, 0xef, 0x25, 0x77, 0x54, + 0xd5, 0xf8, 0x0c, 0x56, 0x54, 0x4e, 0x85, 0xde, 0x19, 0x49, 0x59, 0xb3, 0xfa, 0x7d, 0xaf, 0xd0, + 0x99, 0xd1, 0xf9, 0x59, 0x70, 0xfa, 0x64, 0xb8, 0xa4, 0xfd, 0x7b, 0x09, 0xee, 0x3c, 0xc1, 0xf9, + 0x67, 0x07, 0xdf, 0x87, 0xe5, 0xe8, 0x8a, 0xc5, 0xac, 0x63, 0xcf, 0x1b, 0x1e, 0xee, 0xcf, 0x2c, + 0x71, 0x17, 0x23, 0x7a, 0x41, 0xde, 0xdc, 0xff, 0x7f, 0x72, 0x8e, 0x50, 0xc0, 0x51, 0xd2, 0xa5, + 0xfb, 0x3f, 0x0a, 0xbc, 0x5b, 0x98, 0x17, 0x3d, 0x84, 0x4b, 0x51, 0x92, 0x51, 0xec, 0xa0, 0x66, + 0x41, 0xa4, 0x12, 0xa9, 0xa3, 0x04, 0x21, 0xe7, 0xd5, 0x8e, 0x12, 0x0a, 0x21, 0x18, 0x6f, 0x13, + 0xa7, 0x10, 0x61, 0x74, 0x94, 0x50, 0x88, 0xb2, 0xd8, 0x51, 0x42, 0x21, 0xa8, 0xff, 0xeb, 0xa3, + 0x84, 0x0f, 0x01, 0xea, 0x4f, 0xbb, 0xad, 0xa3, 0x08, 0x2f, 0xca, 0x39, 0xf6, 0xeb, 0x6d, 0xb3, + 0xd3, 0x1a, 0x5e, 0x71, 0x89, 0xdf, 0x4e, 0x0b, 0xa9, 0x50, 0x3e, 0x3d, 0x68, 0x25, 0x47, 0x92, + 0xe2, 0x53, 0x33, 0x01, 0x45, 0x8c, 0x91, 0xfc, 0x61, 0x08, 0x43, 0x6f, 0xc3, 0xd5, 0x04, 0x60, + 0xd8, 0x94, 0x00, 0x5d, 0x89, 0x81, 0xce, 0x09, 0x6f, 0xc1, 0xe2, 0xe9, 0x41, 0xeb, 0x89, 0xef, + 0x44, 0x7a, 0x26, 0xc0, 0xe9, 0x26, 0x6d, 0x00, 0x9b, 0x23, 0xcd, 0xda, 0x31, 0xa8, 0x17, 0x5d, + 0xda, 0x3f, 0x78, 0x94, 0x92, 0x33, 0x6c, 0xca, 0xca, 0x39, 0x27, 0xdc, 0x83, 0xb5, 0xd3, 0x83, + 0xd6, 0x89, 0xcf, 0xc6, 0x10, 0x12, 0x89, 0xab, 0xa3, 0xce, 0x51, 0x9f, 0xf6, 0x8f, 0x0a, 0x5c, + 0x6b, 0xbc, 0xe8, 0x63, 0x91, 0x56, 0x74, 0x1b, 0x35, 0x7c, 0x6a, 0x9d, 0x11, 0x3f, 0x64, 0xe8, + 0x4b, 0x50, 0x71, 0xd2, 0x3c, 0xbc, 0xc4, 0x4a, 0xe6, 0xb1, 0x3c, 0xc4, 0x8d, 0x30, 0x86, 0xe4, + 0xe7, 0x58, 0xc6, 0x04, 0x12, 0x7a, 0x06, 0x68, 0xd8, 0xf6, 0xf8, 0x69, 0x54, 0x29, 0x9d, 0x59, + 0xde, 0xcc, 0xec, 0xbe, 0x31, 0x41, 0x6e, 0x48, 0x20, 0xb4, 0x3f, 0x2f, 0xc3, 0x8d, 0x19, 0xaa, + 0xa0, 0x23, 0x58, 0x1f, 0x57, 0xa6, 0x8d, 0x19, 0xf1, 0x9d, 0x42, 0x97, 0x4e, 0x53, 0x78, 0x91, + 0x3e, 0x32, 0xa7, 0xe9, 0x78, 0x38, 0x41, 0x2c, 0xf2, 0x76, 0x52, 0xc2, 0x87, 0x7e, 0xac, 0xc0, + 0xdd, 0x38, 0xc4, 0x3c, 0x3d, 0x91, 0xd8, 0x30, 0x19, 0x36, 0xe5, 0xe5, 0x43, 0xa7, 0x10, 0x84, + 0x51, 0x50, 0x14, 0xfa, 0x52, 0x1e, 0x63, 0x3f, 0xbc, 0xe8, 0x6c, 0x90, 0xe7, 0x45, 0x6f, 0x82, + 0x96, 0xcf, 0xa3, 0x7d, 0xa3, 0x00, 0x9a, 0x9c, 0x08, 0xc5, 0xb2, 0xf0, 0x49, 0xbe, 0x6c, 0x7c, + 0xe1, 0xf9, 0xf1, 0xe5, 0x32, 0xcc, 0x07, 0xd8, 0x7e, 0xf0, 0x30, 0x2e, 0xcd, 0x03, 0x6c, 0xef, + 0xed, 0xc4, 0xa5, 0x79, 0x80, 0xed, 0x0f, 0x76, 0xd4, 0x72, 0xf2, 0xf9, 0x91, 0xa8, 0xcb, 0x01, + 0x2a, 0x82, 0x76, 0x77, 0x47, 0x9d, 0x1f, 0x7e, 0x3f, 0xda, 0x51, 0x2b, 0x68, 0x19, 0x2e, 0x7b, + 0x3e, 0x75, 0x4d, 0x4e, 0x7a, 0x58, 0x5d, 0xd0, 0xbe, 0x55, 0xe0, 0x6e, 0xb1, 0x81, 0x42, 0xcf, + 0xb2, 0x56, 0x56, 0x5f, 0x61, 0xd0, 0xb3, 0x96, 0x3f, 0xcd, 0xb7, 0xfc, 0x35, 0xd8, 0x08, 0xc2, + 0xe3, 0xc0, 0x66, 0x24, 0xaa, 0x16, 0x4c, 0x32, 0xc2, 0x52, 0x15, 0x74, 0x05, 0x20, 0xe0, 0x16, + 0x27, 0xd1, 0x7d, 0x46, 0xfc, 0x28, 0x68, 0xb3, 0x73, 0xd8, 0xaa, 0x99, 0x55, 0xc7, 0x21, 0x11, + 0x7d, 0x72, 0xd7, 0x17, 0x1d, 0xdf, 0xfe, 0x5c, 0xd6, 0x8e, 0xf7, 0xe5, 0x76, 0x4c, 0x63, 0xcf, + 0xaa, 0x7e, 0x94, 0xaf, 0xfa, 0x32, 0x5c, 0x0e, 0xa8, 0x69, 0x47, 0xaf, 0x8c, 0xe2, 0x73, 0x5c, + 0x51, 0xb4, 0x30, 0x13, 0xb7, 0x6a, 0xe6, 0xe3, 0xa7, 0x6a, 0x29, 0x69, 0x61, 0xd6, 0xb0, 0xa5, + 0x5c, 0xdb, 0xfb, 0x85, 0x07, 0x2e, 0x66, 0x8c, 0xf0, 0x6d, 0xff, 0x1e, 0xb3, 0xe8, 0xbd, 0xc0, + 0xde, 0xf6, 0x99, 0x7b, 0x9f, 0xdd, 0x67, 0xc4, 0xbe, 0xd7, 0xf7, 0xf8, 0xfd, 0x73, 0x8d, 0xef, + 0x9d, 0x6b, 0x7c, 0x5c, 0x89, 0x3e, 0xf7, 0xfe, 0x37, 0x00, 0x00, 0xff, 0xff, 0xdd, 0xfd, 0x24, + 0x20, 0x92, 0x33, 0x00, 0x00, +}