From b7bdc91498a3faa77afdd07b427d98726ebc1872 Mon Sep 17 00:00:00 2001 From: "Arrobo, Gabriel" Date: Thu, 28 Sep 2023 16:34:25 -0700 Subject: [PATCH 1/2] Add structs related to the O-RAN CCC service model --- build/bin/compile-protos.sh | 11 + docs/onos/ccc/ccc.md | 259 + go/onos/ccc/ccc.pb.go | 2483 +++++ go/onos/topo/ran.pb.go | 19327 +++++++++++++++++++++------------ proto/onos/ccc/ccc.proto | 87 + proto/onos/topo/ran.proto | 147 +- protoset/onos-topo.protoset | Bin 35329 -> 38953 bytes python/onos/ccc/__init__.py | 144 + python/onos/topo/__init__.py | 218 + 9 files changed, 15619 insertions(+), 7057 deletions(-) create mode 100644 docs/onos/ccc/ccc.md create mode 100644 go/onos/ccc/ccc.pb.go create mode 100644 proto/onos/ccc/ccc.proto create mode 100644 python/onos/ccc/__init__.py diff --git a/build/bin/compile-protos.sh b/build/bin/compile-protos.sh index 4f9b5270..6d3db527 100755 --- a/build/bin/compile-protos.sh +++ b/build/bin/compile-protos.sh @@ -121,6 +121,12 @@ protoc --proto_path=$proto_path \ --doc_opt=markdown,a1.md \ proto/onos/a1t/admin/*.proto +# ccc +protoc --proto_path=$proto_path \ + --doc_out=docs/onos/ccc \ + --doc_opt=markdown,ccc.md \ + proto/onos/ccc/ccc.proto + # kpimon protoc --proto_path=$proto_path \ --doc_out=docs/onos/kpimon \ @@ -271,6 +277,11 @@ protoc --proto_path=$proto_path \ --gogofaster_out=$go_import_paths,import_path=onos/o1t,plugins=grpc:./go \ proto/onos/o1t/*.proto +# ccc +protoc --proto_path=$proto_path \ + --gogofaster_out=$go_import_paths,import_path=onos/ccc,plugins=grpc:./go \ + proto/onos/ccc/*.proto + # kpimon protoc --proto_path=$proto_path \ --gogofaster_out=$go_import_paths,import_path=onos/kpimon,plugins=grpc:./go \ diff --git a/docs/onos/ccc/ccc.md b/docs/onos/ccc/ccc.md new file mode 100644 index 00000000..92dfd72b --- /dev/null +++ b/docs/onos/ccc/ccc.md @@ -0,0 +1,259 @@ +# Protocol Documentation + + +## Table of Contents + +- [onos/ccc/ccc.proto](#onos_ccc_ccc-proto) + - [Ack](#onos-ccc-Ack) + - [ORRmpolicyRatio](#onos-ccc-ORRmpolicyRatio) + - [Plmnidentity](#onos-ccc-Plmnidentity) + - [RrmPolicyMember](#onos-ccc-RrmPolicyMember) + - [RrmPolicyMemberList](#onos-ccc-RrmPolicyMemberList) + - [SNSsai](#onos-ccc-SNSsai) + - [Sd](#onos-ccc-Sd) + - [Sst](#onos-ccc-Sst) + - [UpdateSliceRequest](#onos-ccc-UpdateSliceRequest) + - [UpdateSliceResponse](#onos-ccc-UpdateSliceResponse) + + - [ResourceType](#onos-ccc-ResourceType) + - [SchedulerType](#onos-ccc-SchedulerType) + + - [Ccc](#onos-ccc-Ccc) + +- [Scalar Value Types](#scalar-value-types) + + + + +

Top

+ +## onos/ccc/ccc.proto + + + + + +### Ack + + + +| Field | Type | Label | Description | +| ----- | ---- | ----- | ----------- | +| success | [bool](#bool) | | | +| cause | [string](#string) | | | + + + + + + + + +### ORRmpolicyRatio +sequence from e2sm_ccc.asn1:229 +{O-RRMPolicyRatio} + + +| Field | Type | Label | Description | +| ----- | ---- | ----- | ----------- | +| resource_type | [ResourceType](#onos-ccc-ResourceType) | | | +| scheduler_type | [SchedulerType](#onos-ccc-SchedulerType) | | | +| rrm_policy_member_list | [RrmPolicyMemberList](#onos-ccc-RrmPolicyMemberList) | | | +| rrm_policy_max_ratio | [int32](#int32) | | | +| rrm_policy_min_ratio | [int32](#int32) | | | +| rrm_policy_dedicated_ratio | [int32](#int32) | | | + + + + + + + + +### Plmnidentity +range of Integer from e2sm_common_ies.asn1:444 + + +| Field | Type | Label | Description | +| ----- | ---- | ----- | ----------- | +| value | [bytes](#bytes) | | | + + + + + + + + +### RrmPolicyMember +sequence from e2sm_ccc.asn1:161 + + +| Field | Type | Label | Description | +| ----- | ---- | ----- | ----------- | +| plmn_id | [Plmnidentity](#onos-ccc-Plmnidentity) | | | +| snssai | [SNSsai](#onos-ccc-SNSsai) | | | + + + + + + + + +### RrmPolicyMemberList +sequence from e2sm_ccc.asn1:167 + + +| Field | Type | Label | Description | +| ----- | ---- | ----- | ----------- | +| rrm_policy_member | [RrmPolicyMember](#onos-ccc-RrmPolicyMember) | repeated | | + + + + + + + + +### SNSsai +sequence from e2sm_common_ies.asn1:454 + + +| Field | Type | Label | Description | +| ----- | ---- | ----- | ----------- | +| sst | [Sst](#onos-ccc-Sst) | | | +| sd | [Sd](#onos-ccc-Sd) | | | + + + + + + + + +### Sd +range of Integer from e2sm_common_ies.asn1:450 + + +| Field | Type | Label | Description | +| ----- | ---- | ----- | ----------- | +| value | [bytes](#bytes) | | | + + + + + + + + +### Sst +range of Integer from e2sm_common_ies.asn1:460 + + +| Field | Type | Label | Description | +| ----- | ---- | ----- | ----------- | +| value | [bytes](#bytes) | | | + + + + + + + + +### UpdateSliceRequest + + + +| Field | Type | Label | Description | +| ----- | ---- | ----- | ----------- | +| e2_node_id | [string](#string) | | | +| rrm_policy_ratio | [ORRmpolicyRatio](#onos-ccc-ORRmpolicyRatio) | | | + + + + + + + + +### UpdateSliceResponse + + + +| Field | Type | Label | Description | +| ----- | ---- | ----- | ----------- | +| ack | [Ack](#onos-ccc-Ack) | | | + + + + + + + + + + +### ResourceType +enumerated from e2sm_ccc.asn1:141 + +| Name | Number | Description | +| ---- | ------ | ----------- | +| RESOURCE_TYPE_PRB_UL | 0 | | +| RESOURCE_TYPE_PRB_DL | 1 | | +| RESOURCE_TYPE_DRB | 2 | | +| RESOURCE_TYPE_RRC | 3 | | + + + + + +### SchedulerType +enumerated from e2sm_ccc.asn1:143 + +| Name | Number | Description | +| ---- | ------ | ----------- | +| SCHEDULER_TYPE_ROUND_ROBIN | 0 | | +| SCHEDULER_TYPE_PROPORTIONALLY_FAIR | 1 | | +| SCHEDULER_TYPE_QOS_BASED | 2 | | + + + + + + + + + +### Ccc + + +| Method Name | Request Type | Response Type | Description | +| ----------- | ------------ | ------------- | ------------| +| UpdateSlice | [UpdateSliceRequest](#onos-ccc-UpdateSliceRequest) | [UpdateSliceResponse](#onos-ccc-UpdateSliceResponse) | Slice management | + + + + + +## Scalar Value Types + +| .proto Type | Notes | C++ | Java | Python | Go | C# | PHP | Ruby | +| ----------- | ----- | --- | ---- | ------ | -- | -- | --- | ---- | +| double | | double | double | float | float64 | double | float | Float | +| float | | float | float | float | float32 | float | float | Float | +| int32 | Uses variable-length encoding. Inefficient for encoding negative numbers – if your field is likely to have negative values, use sint32 instead. | int32 | int | int | int32 | int | integer | Bignum or Fixnum (as required) | +| int64 | Uses variable-length encoding. Inefficient for encoding negative numbers – if your field is likely to have negative values, use sint64 instead. | int64 | long | int/long | int64 | long | integer/string | Bignum | +| uint32 | Uses variable-length encoding. | uint32 | int | int/long | uint32 | uint | integer | Bignum or Fixnum (as required) | +| uint64 | Uses variable-length encoding. | uint64 | long | int/long | uint64 | ulong | integer/string | Bignum or Fixnum (as required) | +| sint32 | Uses variable-length encoding. Signed int value. These more efficiently encode negative numbers than regular int32s. | int32 | int | int | int32 | int | integer | Bignum or Fixnum (as required) | +| sint64 | Uses variable-length encoding. Signed int value. These more efficiently encode negative numbers than regular int64s. | int64 | long | int/long | int64 | long | integer/string | Bignum | +| fixed32 | Always four bytes. More efficient than uint32 if values are often greater than 2^28. | uint32 | int | int | uint32 | uint | integer | Bignum or Fixnum (as required) | +| fixed64 | Always eight bytes. More efficient than uint64 if values are often greater than 2^56. | uint64 | long | int/long | uint64 | ulong | integer/string | Bignum | +| sfixed32 | Always four bytes. | int32 | int | int | int32 | int | integer | Bignum or Fixnum (as required) | +| sfixed64 | Always eight bytes. | int64 | long | int/long | int64 | long | integer/string | Bignum | +| bool | | bool | boolean | boolean | bool | bool | boolean | TrueClass/FalseClass | +| string | A string must always contain UTF-8 encoded or 7-bit ASCII text. | string | String | str/unicode | string | string | string | String (UTF-8) | +| bytes | May contain any arbitrary sequence of bytes. | string | ByteString | str | []byte | ByteString | string | String (ASCII-8BIT) | + diff --git a/go/onos/ccc/ccc.pb.go b/go/onos/ccc/ccc.pb.go new file mode 100644 index 00000000..10c91759 --- /dev/null +++ b/go/onos/ccc/ccc.pb.go @@ -0,0 +1,2483 @@ +// Code generated by protoc-gen-gogo. DO NOT EDIT. +// source: onos/ccc/ccc.proto + +package ccc + +import ( + context "context" + fmt "fmt" + proto "github.com/gogo/protobuf/proto" + grpc "google.golang.org/grpc" + codes "google.golang.org/grpc/codes" + status "google.golang.org/grpc/status" + io "io" + math "math" + math_bits "math/bits" +) + +// 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.GoGoProtoPackageIsVersion3 // please upgrade the proto package + +// enumerated from e2sm_ccc.asn1:141 +type ResourceType int32 + +const ( + ResourceType_RESOURCE_TYPE_PRB_UL ResourceType = 0 + ResourceType_RESOURCE_TYPE_PRB_DL ResourceType = 1 + ResourceType_RESOURCE_TYPE_DRB ResourceType = 2 + ResourceType_RESOURCE_TYPE_RRC ResourceType = 3 +) + +var ResourceType_name = map[int32]string{ + 0: "RESOURCE_TYPE_PRB_UL", + 1: "RESOURCE_TYPE_PRB_DL", + 2: "RESOURCE_TYPE_DRB", + 3: "RESOURCE_TYPE_RRC", +} + +var ResourceType_value = map[string]int32{ + "RESOURCE_TYPE_PRB_UL": 0, + "RESOURCE_TYPE_PRB_DL": 1, + "RESOURCE_TYPE_DRB": 2, + "RESOURCE_TYPE_RRC": 3, +} + +func (x ResourceType) String() string { + return proto.EnumName(ResourceType_name, int32(x)) +} + +func (ResourceType) EnumDescriptor() ([]byte, []int) { + return fileDescriptor_99b4db736b908a6a, []int{0} +} + +// enumerated from e2sm_ccc.asn1:143 +type SchedulerType int32 + +const ( + SchedulerType_SCHEDULER_TYPE_ROUND_ROBIN SchedulerType = 0 + SchedulerType_SCHEDULER_TYPE_PROPORTIONALLY_FAIR SchedulerType = 1 + SchedulerType_SCHEDULER_TYPE_QOS_BASED SchedulerType = 2 +) + +var SchedulerType_name = map[int32]string{ + 0: "SCHEDULER_TYPE_ROUND_ROBIN", + 1: "SCHEDULER_TYPE_PROPORTIONALLY_FAIR", + 2: "SCHEDULER_TYPE_QOS_BASED", +} + +var SchedulerType_value = map[string]int32{ + "SCHEDULER_TYPE_ROUND_ROBIN": 0, + "SCHEDULER_TYPE_PROPORTIONALLY_FAIR": 1, + "SCHEDULER_TYPE_QOS_BASED": 2, +} + +func (x SchedulerType) String() string { + return proto.EnumName(SchedulerType_name, int32(x)) +} + +func (SchedulerType) EnumDescriptor() ([]byte, []int) { + return fileDescriptor_99b4db736b908a6a, []int{1} +} + +// range of Integer from e2sm_common_ies.asn1:444 +type Plmnidentity struct { + Value []byte `protobuf:"bytes,1,opt,name=value,proto3" json:"value,omitempty"` +} + +func (m *Plmnidentity) Reset() { *m = Plmnidentity{} } +func (m *Plmnidentity) String() string { return proto.CompactTextString(m) } +func (*Plmnidentity) ProtoMessage() {} +func (*Plmnidentity) Descriptor() ([]byte, []int) { + return fileDescriptor_99b4db736b908a6a, []int{0} +} +func (m *Plmnidentity) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *Plmnidentity) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_Plmnidentity.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *Plmnidentity) XXX_Merge(src proto.Message) { + xxx_messageInfo_Plmnidentity.Merge(m, src) +} +func (m *Plmnidentity) XXX_Size() int { + return m.Size() +} +func (m *Plmnidentity) XXX_DiscardUnknown() { + xxx_messageInfo_Plmnidentity.DiscardUnknown(m) +} + +var xxx_messageInfo_Plmnidentity proto.InternalMessageInfo + +func (m *Plmnidentity) GetValue() []byte { + if m != nil { + return m.Value + } + return nil +} + +// range of Integer from e2sm_common_ies.asn1:450 +type Sd struct { + Value []byte `protobuf:"bytes,1,opt,name=value,proto3" json:"value,omitempty"` +} + +func (m *Sd) Reset() { *m = Sd{} } +func (m *Sd) String() string { return proto.CompactTextString(m) } +func (*Sd) ProtoMessage() {} +func (*Sd) Descriptor() ([]byte, []int) { + return fileDescriptor_99b4db736b908a6a, []int{1} +} +func (m *Sd) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *Sd) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_Sd.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *Sd) XXX_Merge(src proto.Message) { + xxx_messageInfo_Sd.Merge(m, src) +} +func (m *Sd) XXX_Size() int { + return m.Size() +} +func (m *Sd) XXX_DiscardUnknown() { + xxx_messageInfo_Sd.DiscardUnknown(m) +} + +var xxx_messageInfo_Sd proto.InternalMessageInfo + +func (m *Sd) GetValue() []byte { + if m != nil { + return m.Value + } + return nil +} + +// sequence from e2sm_common_ies.asn1:454 +type SNSsai struct { + Sst *Sst `protobuf:"bytes,1,opt,name=sst,proto3" json:"sst,omitempty"` + Sd *Sd `protobuf:"bytes,2,opt,name=sd,proto3" json:"sd,omitempty"` +} + +func (m *SNSsai) Reset() { *m = SNSsai{} } +func (m *SNSsai) String() string { return proto.CompactTextString(m) } +func (*SNSsai) ProtoMessage() {} +func (*SNSsai) Descriptor() ([]byte, []int) { + return fileDescriptor_99b4db736b908a6a, []int{2} +} +func (m *SNSsai) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *SNSsai) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_SNSsai.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *SNSsai) XXX_Merge(src proto.Message) { + xxx_messageInfo_SNSsai.Merge(m, src) +} +func (m *SNSsai) XXX_Size() int { + return m.Size() +} +func (m *SNSsai) XXX_DiscardUnknown() { + xxx_messageInfo_SNSsai.DiscardUnknown(m) +} + +var xxx_messageInfo_SNSsai proto.InternalMessageInfo + +func (m *SNSsai) GetSst() *Sst { + if m != nil { + return m.Sst + } + return nil +} + +func (m *SNSsai) GetSd() *Sd { + if m != nil { + return m.Sd + } + return nil +} + +// range of Integer from e2sm_common_ies.asn1:460 +type Sst struct { + Value []byte `protobuf:"bytes,1,opt,name=value,proto3" json:"value,omitempty"` +} + +func (m *Sst) Reset() { *m = Sst{} } +func (m *Sst) String() string { return proto.CompactTextString(m) } +func (*Sst) ProtoMessage() {} +func (*Sst) Descriptor() ([]byte, []int) { + return fileDescriptor_99b4db736b908a6a, []int{3} +} +func (m *Sst) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *Sst) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_Sst.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *Sst) XXX_Merge(src proto.Message) { + xxx_messageInfo_Sst.Merge(m, src) +} +func (m *Sst) XXX_Size() int { + return m.Size() +} +func (m *Sst) XXX_DiscardUnknown() { + xxx_messageInfo_Sst.DiscardUnknown(m) +} + +var xxx_messageInfo_Sst proto.InternalMessageInfo + +func (m *Sst) GetValue() []byte { + if m != nil { + return m.Value + } + return nil +} + +// sequence from e2sm_ccc.asn1:161 +type RrmPolicyMember struct { + PlmnId *Plmnidentity `protobuf:"bytes,1,opt,name=plmn_id,json=plmnId,proto3" json:"plmn_id,omitempty"` + Snssai *SNSsai `protobuf:"bytes,2,opt,name=snssai,proto3" json:"snssai,omitempty"` +} + +func (m *RrmPolicyMember) Reset() { *m = RrmPolicyMember{} } +func (m *RrmPolicyMember) String() string { return proto.CompactTextString(m) } +func (*RrmPolicyMember) ProtoMessage() {} +func (*RrmPolicyMember) Descriptor() ([]byte, []int) { + return fileDescriptor_99b4db736b908a6a, []int{4} +} +func (m *RrmPolicyMember) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *RrmPolicyMember) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_RrmPolicyMember.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *RrmPolicyMember) XXX_Merge(src proto.Message) { + xxx_messageInfo_RrmPolicyMember.Merge(m, src) +} +func (m *RrmPolicyMember) XXX_Size() int { + return m.Size() +} +func (m *RrmPolicyMember) XXX_DiscardUnknown() { + xxx_messageInfo_RrmPolicyMember.DiscardUnknown(m) +} + +var xxx_messageInfo_RrmPolicyMember proto.InternalMessageInfo + +func (m *RrmPolicyMember) GetPlmnId() *Plmnidentity { + if m != nil { + return m.PlmnId + } + return nil +} + +func (m *RrmPolicyMember) GetSnssai() *SNSsai { + if m != nil { + return m.Snssai + } + return nil +} + +// sequence from e2sm_ccc.asn1:167 +type RrmPolicyMemberList struct { + RrmPolicyMember []*RrmPolicyMember `protobuf:"bytes,1,rep,name=rrm_policy_member,json=rrmPolicyMember,proto3" json:"rrm_policy_member,omitempty"` +} + +func (m *RrmPolicyMemberList) Reset() { *m = RrmPolicyMemberList{} } +func (m *RrmPolicyMemberList) String() string { return proto.CompactTextString(m) } +func (*RrmPolicyMemberList) ProtoMessage() {} +func (*RrmPolicyMemberList) Descriptor() ([]byte, []int) { + return fileDescriptor_99b4db736b908a6a, []int{5} +} +func (m *RrmPolicyMemberList) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *RrmPolicyMemberList) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_RrmPolicyMemberList.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *RrmPolicyMemberList) XXX_Merge(src proto.Message) { + xxx_messageInfo_RrmPolicyMemberList.Merge(m, src) +} +func (m *RrmPolicyMemberList) XXX_Size() int { + return m.Size() +} +func (m *RrmPolicyMemberList) XXX_DiscardUnknown() { + xxx_messageInfo_RrmPolicyMemberList.DiscardUnknown(m) +} + +var xxx_messageInfo_RrmPolicyMemberList proto.InternalMessageInfo + +func (m *RrmPolicyMemberList) GetRrmPolicyMember() []*RrmPolicyMember { + if m != nil { + return m.RrmPolicyMember + } + return nil +} + +// sequence from e2sm_ccc.asn1:229 +// {O-RRMPolicyRatio} +type ORRmpolicyRatio struct { + ResourceType ResourceType `protobuf:"varint,1,opt,name=resource_type,json=resourceType,proto3,enum=onos.ccc.ResourceType" json:"resource_type,omitempty"` + SchedulerType SchedulerType `protobuf:"varint,2,opt,name=scheduler_type,json=schedulerType,proto3,enum=onos.ccc.SchedulerType" json:"scheduler_type,omitempty"` + RrmPolicyMemberList *RrmPolicyMemberList `protobuf:"bytes,3,opt,name=rrm_policy_member_list,json=rrmPolicyMemberList,proto3" json:"rrm_policy_member_list,omitempty"` + RrmPolicyMaxRatio int32 `protobuf:"varint,4,opt,name=rrm_policy_max_ratio,json=rrmPolicyMaxRatio,proto3" json:"rrm_policy_max_ratio,omitempty"` + RrmPolicyMinRatio int32 `protobuf:"varint,5,opt,name=rrm_policy_min_ratio,json=rrmPolicyMinRatio,proto3" json:"rrm_policy_min_ratio,omitempty"` + RrmPolicyDedicatedRatio int32 `protobuf:"varint,6,opt,name=rrm_policy_dedicated_ratio,json=rrmPolicyDedicatedRatio,proto3" json:"rrm_policy_dedicated_ratio,omitempty"` +} + +func (m *ORRmpolicyRatio) Reset() { *m = ORRmpolicyRatio{} } +func (m *ORRmpolicyRatio) String() string { return proto.CompactTextString(m) } +func (*ORRmpolicyRatio) ProtoMessage() {} +func (*ORRmpolicyRatio) Descriptor() ([]byte, []int) { + return fileDescriptor_99b4db736b908a6a, []int{6} +} +func (m *ORRmpolicyRatio) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ORRmpolicyRatio) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_ORRmpolicyRatio.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *ORRmpolicyRatio) XXX_Merge(src proto.Message) { + xxx_messageInfo_ORRmpolicyRatio.Merge(m, src) +} +func (m *ORRmpolicyRatio) XXX_Size() int { + return m.Size() +} +func (m *ORRmpolicyRatio) XXX_DiscardUnknown() { + xxx_messageInfo_ORRmpolicyRatio.DiscardUnknown(m) +} + +var xxx_messageInfo_ORRmpolicyRatio proto.InternalMessageInfo + +func (m *ORRmpolicyRatio) GetResourceType() ResourceType { + if m != nil { + return m.ResourceType + } + return ResourceType_RESOURCE_TYPE_PRB_UL +} + +func (m *ORRmpolicyRatio) GetSchedulerType() SchedulerType { + if m != nil { + return m.SchedulerType + } + return SchedulerType_SCHEDULER_TYPE_ROUND_ROBIN +} + +func (m *ORRmpolicyRatio) GetRrmPolicyMemberList() *RrmPolicyMemberList { + if m != nil { + return m.RrmPolicyMemberList + } + return nil +} + +func (m *ORRmpolicyRatio) GetRrmPolicyMaxRatio() int32 { + if m != nil { + return m.RrmPolicyMaxRatio + } + return 0 +} + +func (m *ORRmpolicyRatio) GetRrmPolicyMinRatio() int32 { + if m != nil { + return m.RrmPolicyMinRatio + } + return 0 +} + +func (m *ORRmpolicyRatio) GetRrmPolicyDedicatedRatio() int32 { + if m != nil { + return m.RrmPolicyDedicatedRatio + } + return 0 +} + +type Ack struct { + Success bool `protobuf:"varint,1,opt,name=success,proto3" json:"success,omitempty"` + Cause string `protobuf:"bytes,2,opt,name=cause,proto3" json:"cause,omitempty"` +} + +func (m *Ack) Reset() { *m = Ack{} } +func (m *Ack) String() string { return proto.CompactTextString(m) } +func (*Ack) ProtoMessage() {} +func (*Ack) Descriptor() ([]byte, []int) { + return fileDescriptor_99b4db736b908a6a, []int{7} +} +func (m *Ack) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *Ack) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_Ack.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *Ack) XXX_Merge(src proto.Message) { + xxx_messageInfo_Ack.Merge(m, src) +} +func (m *Ack) XXX_Size() int { + return m.Size() +} +func (m *Ack) XXX_DiscardUnknown() { + xxx_messageInfo_Ack.DiscardUnknown(m) +} + +var xxx_messageInfo_Ack proto.InternalMessageInfo + +func (m *Ack) GetSuccess() bool { + if m != nil { + return m.Success + } + return false +} + +func (m *Ack) GetCause() string { + if m != nil { + return m.Cause + } + return "" +} + +type UpdateSliceRequest struct { + E2NodeId string `protobuf:"bytes,1,opt,name=e2_node_id,json=e2NodeId,proto3" json:"e2_node_id,omitempty"` + RrmPolicyRatio *ORRmpolicyRatio `protobuf:"bytes,2,opt,name=rrm_policy_ratio,json=rrmPolicyRatio,proto3" json:"rrm_policy_ratio,omitempty"` +} + +func (m *UpdateSliceRequest) Reset() { *m = UpdateSliceRequest{} } +func (m *UpdateSliceRequest) String() string { return proto.CompactTextString(m) } +func (*UpdateSliceRequest) ProtoMessage() {} +func (*UpdateSliceRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_99b4db736b908a6a, []int{8} +} +func (m *UpdateSliceRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *UpdateSliceRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_UpdateSliceRequest.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *UpdateSliceRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_UpdateSliceRequest.Merge(m, src) +} +func (m *UpdateSliceRequest) XXX_Size() int { + return m.Size() +} +func (m *UpdateSliceRequest) XXX_DiscardUnknown() { + xxx_messageInfo_UpdateSliceRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_UpdateSliceRequest proto.InternalMessageInfo + +func (m *UpdateSliceRequest) GetE2NodeId() string { + if m != nil { + return m.E2NodeId + } + return "" +} + +func (m *UpdateSliceRequest) GetRrmPolicyRatio() *ORRmpolicyRatio { + if m != nil { + return m.RrmPolicyRatio + } + return nil +} + +type UpdateSliceResponse struct { + Ack *Ack `protobuf:"bytes,1,opt,name=ack,proto3" json:"ack,omitempty"` +} + +func (m *UpdateSliceResponse) Reset() { *m = UpdateSliceResponse{} } +func (m *UpdateSliceResponse) String() string { return proto.CompactTextString(m) } +func (*UpdateSliceResponse) ProtoMessage() {} +func (*UpdateSliceResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_99b4db736b908a6a, []int{9} +} +func (m *UpdateSliceResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *UpdateSliceResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_UpdateSliceResponse.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *UpdateSliceResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_UpdateSliceResponse.Merge(m, src) +} +func (m *UpdateSliceResponse) XXX_Size() int { + return m.Size() +} +func (m *UpdateSliceResponse) XXX_DiscardUnknown() { + xxx_messageInfo_UpdateSliceResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_UpdateSliceResponse proto.InternalMessageInfo + +func (m *UpdateSliceResponse) GetAck() *Ack { + if m != nil { + return m.Ack + } + return nil +} + +func init() { + proto.RegisterEnum("onos.ccc.ResourceType", ResourceType_name, ResourceType_value) + proto.RegisterEnum("onos.ccc.SchedulerType", SchedulerType_name, SchedulerType_value) + proto.RegisterType((*Plmnidentity)(nil), "onos.ccc.Plmnidentity") + proto.RegisterType((*Sd)(nil), "onos.ccc.Sd") + proto.RegisterType((*SNSsai)(nil), "onos.ccc.SNSsai") + proto.RegisterType((*Sst)(nil), "onos.ccc.Sst") + proto.RegisterType((*RrmPolicyMember)(nil), "onos.ccc.RrmPolicyMember") + proto.RegisterType((*RrmPolicyMemberList)(nil), "onos.ccc.RrmPolicyMemberList") + proto.RegisterType((*ORRmpolicyRatio)(nil), "onos.ccc.ORRmpolicyRatio") + proto.RegisterType((*Ack)(nil), "onos.ccc.Ack") + proto.RegisterType((*UpdateSliceRequest)(nil), "onos.ccc.UpdateSliceRequest") + proto.RegisterType((*UpdateSliceResponse)(nil), "onos.ccc.UpdateSliceResponse") +} + +func init() { proto.RegisterFile("onos/ccc/ccc.proto", fileDescriptor_99b4db736b908a6a) } + +var fileDescriptor_99b4db736b908a6a = []byte{ + // 681 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x74, 0x54, 0x4d, 0x6f, 0xd3, 0x40, + 0x10, 0x8d, 0x63, 0x9a, 0xb6, 0xd3, 0xa4, 0x75, 0xb7, 0xa5, 0x35, 0xa1, 0x0d, 0x95, 0x85, 0x50, + 0xd4, 0x43, 0x2a, 0x05, 0xc1, 0x05, 0x09, 0x29, 0x5f, 0x40, 0x50, 0x88, 0xd3, 0x71, 0x73, 0xa8, + 0x84, 0x64, 0xb9, 0xbb, 0x2b, 0x61, 0xd5, 0xb1, 0x8d, 0xd7, 0x81, 0xe6, 0xc8, 0x3f, 0xe0, 0x67, + 0x71, 0xec, 0x91, 0x23, 0x6a, 0xff, 0x08, 0xb2, 0x9d, 0x34, 0x8e, 0xd3, 0x1c, 0x72, 0x98, 0x7d, + 0xfb, 0x66, 0xe6, 0xbd, 0xbc, 0x35, 0x10, 0xcf, 0xf5, 0xc4, 0x19, 0xa5, 0x34, 0xfa, 0xd5, 0xfc, + 0xc0, 0x0b, 0x3d, 0xb2, 0x11, 0x9d, 0xd5, 0x28, 0xa5, 0xda, 0x4b, 0x28, 0x0e, 0x9c, 0x91, 0x6b, + 0x33, 0xee, 0x86, 0x76, 0x38, 0x21, 0xfb, 0xb0, 0xf6, 0xc3, 0x72, 0xc6, 0x5c, 0x95, 0x4e, 0xa4, + 0x6a, 0x11, 0x93, 0x42, 0x2b, 0x43, 0xde, 0x60, 0x2b, 0xb0, 0x8f, 0x50, 0x30, 0xfa, 0x86, 0xb0, + 0x6c, 0xf2, 0x02, 0x64, 0x21, 0xc2, 0x18, 0xdd, 0xaa, 0x97, 0x6a, 0xb3, 0x19, 0x35, 0x43, 0x84, + 0x18, 0x21, 0xe4, 0x08, 0xf2, 0x82, 0xa9, 0xf9, 0x18, 0x2f, 0xa6, 0x70, 0x86, 0x79, 0xc1, 0xb4, + 0xe7, 0x20, 0x1b, 0x22, 0x5c, 0x31, 0xc5, 0x81, 0x1d, 0x0c, 0x46, 0x03, 0xcf, 0xb1, 0xe9, 0xe4, + 0x0b, 0x1f, 0x5d, 0xf1, 0x80, 0x9c, 0xc1, 0xba, 0xef, 0x8c, 0x5c, 0xd3, 0x66, 0xd3, 0x91, 0x07, + 0xf3, 0x96, 0x69, 0x4d, 0x58, 0x88, 0xae, 0x75, 0x19, 0xa9, 0x42, 0x41, 0xb8, 0x42, 0x58, 0xf6, + 0x74, 0x05, 0x25, 0xb5, 0x42, 0xac, 0x00, 0xa7, 0xb8, 0xf6, 0x15, 0xf6, 0x32, 0xd3, 0x7a, 0xb6, + 0x08, 0x49, 0x07, 0x76, 0x83, 0x60, 0x64, 0xfa, 0xf1, 0xb9, 0x39, 0x8a, 0x01, 0x55, 0x3a, 0x91, + 0xab, 0x5b, 0xf5, 0x67, 0xf3, 0x5e, 0x19, 0x26, 0xee, 0x04, 0x8b, 0x07, 0xda, 0x2f, 0x19, 0x76, + 0x74, 0xc4, 0x51, 0xd2, 0x07, 0xad, 0xd0, 0xf6, 0xc8, 0x3b, 0x28, 0x05, 0x5c, 0x78, 0xe3, 0x80, + 0x72, 0x33, 0x9c, 0xf8, 0x89, 0xfa, 0xed, 0xb4, 0x24, 0x9c, 0xc2, 0x17, 0x13, 0x9f, 0x63, 0x31, + 0x48, 0x55, 0xe4, 0x3d, 0x6c, 0x0b, 0xfa, 0x8d, 0xb3, 0xb1, 0xc3, 0x83, 0x84, 0x9d, 0x8f, 0xd9, + 0x87, 0x29, 0x81, 0x33, 0x3c, 0xa6, 0x97, 0x44, 0xba, 0x24, 0x08, 0x07, 0x4b, 0xba, 0x4c, 0xc7, + 0x16, 0xa1, 0x2a, 0xc7, 0x46, 0x1d, 0xaf, 0x14, 0x17, 0xd9, 0x82, 0x7b, 0xc1, 0x23, 0x5e, 0x9d, + 0xc1, 0x7e, 0xba, 0xa7, 0x75, 0x63, 0x06, 0x91, 0x50, 0xf5, 0xc9, 0x89, 0x54, 0x5d, 0xc3, 0xdd, + 0x39, 0xc5, 0xba, 0x49, 0x1c, 0xc8, 0x10, 0x6c, 0x77, 0x4a, 0x58, 0xcb, 0x12, 0x6c, 0x77, 0x66, + 0x59, 0x39, 0x45, 0x60, 0x9c, 0xd9, 0xd4, 0x0a, 0x39, 0x9b, 0xd2, 0x0a, 0x31, 0xed, 0xf0, 0x81, + 0xd6, 0x9e, 0xe1, 0x31, 0x59, 0x7b, 0x03, 0x72, 0x83, 0x5e, 0x13, 0x15, 0xd6, 0xc5, 0x98, 0x52, + 0x2e, 0x44, 0x6c, 0xf8, 0x06, 0xce, 0xca, 0x28, 0x86, 0xd4, 0x1a, 0x8b, 0xc4, 0xca, 0x4d, 0x4c, + 0x0a, 0xed, 0x27, 0x90, 0xa1, 0xcf, 0xac, 0x90, 0x1b, 0x8e, 0x4d, 0x39, 0xf2, 0xef, 0x63, 0x1e, + 0xe7, 0x1a, 0x78, 0xdd, 0x74, 0x3d, 0xc6, 0x67, 0x61, 0xdc, 0xc4, 0x0d, 0x5e, 0xef, 0x7b, 0x8c, + 0x77, 0x19, 0x69, 0x81, 0x92, 0xda, 0x33, 0xd9, 0x2e, 0x09, 0x60, 0x2a, 0x34, 0x99, 0x3c, 0xe0, + 0xf6, 0xc3, 0xe2, 0xc9, 0xbe, 0x6f, 0x61, 0x6f, 0x61, 0xb0, 0xf0, 0x3d, 0x57, 0xf0, 0xe8, 0xc9, + 0x59, 0xf4, 0x7a, 0xf9, 0xc9, 0x35, 0xe8, 0x35, 0x46, 0xc8, 0xa9, 0x0f, 0xc5, 0x74, 0x70, 0x88, + 0x0a, 0xfb, 0xd8, 0x31, 0xf4, 0x21, 0xb6, 0x3a, 0xe6, 0xc5, 0xe5, 0xa0, 0x63, 0x0e, 0xb0, 0x69, + 0x0e, 0x7b, 0x4a, 0xee, 0x71, 0xa4, 0xdd, 0x53, 0x24, 0xf2, 0x14, 0x76, 0x17, 0x91, 0x36, 0x36, + 0x95, 0xfc, 0xf2, 0x31, 0x62, 0x4b, 0x91, 0x4f, 0xc7, 0x50, 0x5a, 0x08, 0x1b, 0xa9, 0x40, 0xd9, + 0x68, 0x7d, 0xea, 0xb4, 0x87, 0xbd, 0x0e, 0x4e, 0x2f, 0xea, 0xc3, 0x7e, 0xdb, 0x44, 0xbd, 0xd9, + 0xed, 0x2b, 0x39, 0xf2, 0x0a, 0xb4, 0x0c, 0x3e, 0x40, 0x7d, 0xa0, 0xe3, 0x45, 0x57, 0xef, 0x37, + 0x7a, 0xbd, 0x4b, 0xf3, 0x43, 0xa3, 0x8b, 0x8a, 0x44, 0x8e, 0x40, 0xcd, 0xdc, 0x3b, 0xd7, 0x0d, + 0xb3, 0xd9, 0x30, 0x3a, 0x6d, 0x25, 0x5f, 0x3f, 0x07, 0xb9, 0x45, 0x29, 0xf9, 0x0c, 0x5b, 0x29, + 0x9f, 0xc8, 0xd1, 0xdc, 0x92, 0xe5, 0xff, 0xad, 0x7c, 0xbc, 0x02, 0x4d, 0xcc, 0x6d, 0xaa, 0x7f, + 0xee, 0x2a, 0xd2, 0xed, 0x5d, 0x45, 0xfa, 0x77, 0x57, 0x91, 0x7e, 0xdf, 0x57, 0x72, 0xb7, 0xf7, + 0x95, 0xdc, 0xdf, 0xfb, 0x4a, 0xee, 0xaa, 0x10, 0x7f, 0x46, 0x5f, 0xff, 0x0f, 0x00, 0x00, 0xff, + 0xff, 0x48, 0x1b, 0xa2, 0x0c, 0x5c, 0x05, 0x00, 0x00, +} + +// Reference imports to suppress errors if they are not otherwise used. +var _ context.Context +var _ grpc.ClientConn + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the grpc package it is being compiled against. +const _ = grpc.SupportPackageIsVersion4 + +// CccClient is the client API for Ccc service. +// +// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream. +type CccClient interface { + // Slice management + UpdateSlice(ctx context.Context, in *UpdateSliceRequest, opts ...grpc.CallOption) (*UpdateSliceResponse, error) +} + +type cccClient struct { + cc *grpc.ClientConn +} + +func NewCccClient(cc *grpc.ClientConn) CccClient { + return &cccClient{cc} +} + +func (c *cccClient) UpdateSlice(ctx context.Context, in *UpdateSliceRequest, opts ...grpc.CallOption) (*UpdateSliceResponse, error) { + out := new(UpdateSliceResponse) + err := c.cc.Invoke(ctx, "/onos.ccc.Ccc/UpdateSlice", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +// CccServer is the server API for Ccc service. +type CccServer interface { + // Slice management + UpdateSlice(context.Context, *UpdateSliceRequest) (*UpdateSliceResponse, error) +} + +// UnimplementedCccServer can be embedded to have forward compatible implementations. +type UnimplementedCccServer struct { +} + +func (*UnimplementedCccServer) UpdateSlice(ctx context.Context, req *UpdateSliceRequest) (*UpdateSliceResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method UpdateSlice not implemented") +} + +func RegisterCccServer(s *grpc.Server, srv CccServer) { + s.RegisterService(&_Ccc_serviceDesc, srv) +} + +func _Ccc_UpdateSlice_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(UpdateSliceRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(CccServer).UpdateSlice(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/onos.ccc.Ccc/UpdateSlice", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(CccServer).UpdateSlice(ctx, req.(*UpdateSliceRequest)) + } + return interceptor(ctx, in, info, handler) +} + +var _Ccc_serviceDesc = grpc.ServiceDesc{ + ServiceName: "onos.ccc.Ccc", + HandlerType: (*CccServer)(nil), + Methods: []grpc.MethodDesc{ + { + MethodName: "UpdateSlice", + Handler: _Ccc_UpdateSlice_Handler, + }, + }, + Streams: []grpc.StreamDesc{}, + Metadata: "onos/ccc/ccc.proto", +} + +func (m *Plmnidentity) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *Plmnidentity) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *Plmnidentity) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Value) > 0 { + i -= len(m.Value) + copy(dAtA[i:], m.Value) + i = encodeVarintCcc(dAtA, i, uint64(len(m.Value))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *Sd) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *Sd) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *Sd) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Value) > 0 { + i -= len(m.Value) + copy(dAtA[i:], m.Value) + i = encodeVarintCcc(dAtA, i, uint64(len(m.Value))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *SNSsai) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *SNSsai) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *SNSsai) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Sd != nil { + { + size, err := m.Sd.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintCcc(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + if m.Sst != nil { + { + size, err := m.Sst.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintCcc(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *Sst) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *Sst) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *Sst) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Value) > 0 { + i -= len(m.Value) + copy(dAtA[i:], m.Value) + i = encodeVarintCcc(dAtA, i, uint64(len(m.Value))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *RrmPolicyMember) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *RrmPolicyMember) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *RrmPolicyMember) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Snssai != nil { + { + size, err := m.Snssai.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintCcc(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + if m.PlmnId != nil { + { + size, err := m.PlmnId.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintCcc(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *RrmPolicyMemberList) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *RrmPolicyMemberList) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *RrmPolicyMemberList) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.RrmPolicyMember) > 0 { + for iNdEx := len(m.RrmPolicyMember) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.RrmPolicyMember[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintCcc(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + } + return len(dAtA) - i, nil +} + +func (m *ORRmpolicyRatio) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ORRmpolicyRatio) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ORRmpolicyRatio) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.RrmPolicyDedicatedRatio != 0 { + i = encodeVarintCcc(dAtA, i, uint64(m.RrmPolicyDedicatedRatio)) + i-- + dAtA[i] = 0x30 + } + if m.RrmPolicyMinRatio != 0 { + i = encodeVarintCcc(dAtA, i, uint64(m.RrmPolicyMinRatio)) + i-- + dAtA[i] = 0x28 + } + if m.RrmPolicyMaxRatio != 0 { + i = encodeVarintCcc(dAtA, i, uint64(m.RrmPolicyMaxRatio)) + i-- + dAtA[i] = 0x20 + } + if m.RrmPolicyMemberList != nil { + { + size, err := m.RrmPolicyMemberList.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintCcc(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + } + if m.SchedulerType != 0 { + i = encodeVarintCcc(dAtA, i, uint64(m.SchedulerType)) + i-- + dAtA[i] = 0x10 + } + if m.ResourceType != 0 { + i = encodeVarintCcc(dAtA, i, uint64(m.ResourceType)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *Ack) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *Ack) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *Ack) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Cause) > 0 { + i -= len(m.Cause) + copy(dAtA[i:], m.Cause) + i = encodeVarintCcc(dAtA, i, uint64(len(m.Cause))) + i-- + dAtA[i] = 0x12 + } + if m.Success { + i-- + if m.Success { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *UpdateSliceRequest) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *UpdateSliceRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *UpdateSliceRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.RrmPolicyRatio != nil { + { + size, err := m.RrmPolicyRatio.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintCcc(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + if len(m.E2NodeId) > 0 { + i -= len(m.E2NodeId) + copy(dAtA[i:], m.E2NodeId) + i = encodeVarintCcc(dAtA, i, uint64(len(m.E2NodeId))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *UpdateSliceResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *UpdateSliceResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *UpdateSliceResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Ack != nil { + { + size, err := m.Ack.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintCcc(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func encodeVarintCcc(dAtA []byte, offset int, v uint64) int { + offset -= sovCcc(v) + base := offset + for v >= 1<<7 { + dAtA[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + dAtA[offset] = uint8(v) + return base +} +func (m *Plmnidentity) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Value) + if l > 0 { + n += 1 + l + sovCcc(uint64(l)) + } + return n +} + +func (m *Sd) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Value) + if l > 0 { + n += 1 + l + sovCcc(uint64(l)) + } + return n +} + +func (m *SNSsai) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Sst != nil { + l = m.Sst.Size() + n += 1 + l + sovCcc(uint64(l)) + } + if m.Sd != nil { + l = m.Sd.Size() + n += 1 + l + sovCcc(uint64(l)) + } + return n +} + +func (m *Sst) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Value) + if l > 0 { + n += 1 + l + sovCcc(uint64(l)) + } + return n +} + +func (m *RrmPolicyMember) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.PlmnId != nil { + l = m.PlmnId.Size() + n += 1 + l + sovCcc(uint64(l)) + } + if m.Snssai != nil { + l = m.Snssai.Size() + n += 1 + l + sovCcc(uint64(l)) + } + return n +} + +func (m *RrmPolicyMemberList) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.RrmPolicyMember) > 0 { + for _, e := range m.RrmPolicyMember { + l = e.Size() + n += 1 + l + sovCcc(uint64(l)) + } + } + return n +} + +func (m *ORRmpolicyRatio) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.ResourceType != 0 { + n += 1 + sovCcc(uint64(m.ResourceType)) + } + if m.SchedulerType != 0 { + n += 1 + sovCcc(uint64(m.SchedulerType)) + } + if m.RrmPolicyMemberList != nil { + l = m.RrmPolicyMemberList.Size() + n += 1 + l + sovCcc(uint64(l)) + } + if m.RrmPolicyMaxRatio != 0 { + n += 1 + sovCcc(uint64(m.RrmPolicyMaxRatio)) + } + if m.RrmPolicyMinRatio != 0 { + n += 1 + sovCcc(uint64(m.RrmPolicyMinRatio)) + } + if m.RrmPolicyDedicatedRatio != 0 { + n += 1 + sovCcc(uint64(m.RrmPolicyDedicatedRatio)) + } + return n +} + +func (m *Ack) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Success { + n += 2 + } + l = len(m.Cause) + if l > 0 { + n += 1 + l + sovCcc(uint64(l)) + } + return n +} + +func (m *UpdateSliceRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.E2NodeId) + if l > 0 { + n += 1 + l + sovCcc(uint64(l)) + } + if m.RrmPolicyRatio != nil { + l = m.RrmPolicyRatio.Size() + n += 1 + l + sovCcc(uint64(l)) + } + return n +} + +func (m *UpdateSliceResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Ack != nil { + l = m.Ack.Size() + n += 1 + l + sovCcc(uint64(l)) + } + return n +} + +func sovCcc(x uint64) (n int) { + return (math_bits.Len64(x|1) + 6) / 7 +} +func sozCcc(x uint64) (n int) { + return sovCcc(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (m *Plmnidentity) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowCcc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: Plmnidentity: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Plmnidentity: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowCcc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthCcc + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthCcc + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Value = append(m.Value[:0], dAtA[iNdEx:postIndex]...) + if m.Value == nil { + m.Value = []byte{} + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipCcc(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthCcc + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *Sd) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowCcc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: Sd: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Sd: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowCcc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthCcc + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthCcc + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Value = append(m.Value[:0], dAtA[iNdEx:postIndex]...) + if m.Value == nil { + m.Value = []byte{} + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipCcc(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthCcc + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *SNSsai) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowCcc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: SNSsai: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: SNSsai: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Sst", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowCcc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthCcc + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthCcc + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Sst == nil { + m.Sst = &Sst{} + } + if err := m.Sst.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Sd", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowCcc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthCcc + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthCcc + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Sd == nil { + m.Sd = &Sd{} + } + if err := m.Sd.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipCcc(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthCcc + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *Sst) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowCcc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: Sst: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Sst: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowCcc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthCcc + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthCcc + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Value = append(m.Value[:0], dAtA[iNdEx:postIndex]...) + if m.Value == nil { + m.Value = []byte{} + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipCcc(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthCcc + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *RrmPolicyMember) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowCcc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: RrmPolicyMember: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: RrmPolicyMember: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field PlmnId", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowCcc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthCcc + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthCcc + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.PlmnId == nil { + m.PlmnId = &Plmnidentity{} + } + if err := m.PlmnId.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Snssai", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowCcc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthCcc + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthCcc + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Snssai == nil { + m.Snssai = &SNSsai{} + } + if err := m.Snssai.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipCcc(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthCcc + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *RrmPolicyMemberList) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowCcc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: RrmPolicyMemberList: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: RrmPolicyMemberList: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field RrmPolicyMember", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowCcc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthCcc + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthCcc + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.RrmPolicyMember = append(m.RrmPolicyMember, &RrmPolicyMember{}) + if err := m.RrmPolicyMember[len(m.RrmPolicyMember)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipCcc(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthCcc + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ORRmpolicyRatio) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowCcc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ORRmpolicyRatio: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ORRmpolicyRatio: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field ResourceType", wireType) + } + m.ResourceType = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowCcc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.ResourceType |= ResourceType(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field SchedulerType", wireType) + } + m.SchedulerType = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowCcc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.SchedulerType |= SchedulerType(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field RrmPolicyMemberList", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowCcc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthCcc + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthCcc + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.RrmPolicyMemberList == nil { + m.RrmPolicyMemberList = &RrmPolicyMemberList{} + } + if err := m.RrmPolicyMemberList.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field RrmPolicyMaxRatio", wireType) + } + m.RrmPolicyMaxRatio = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowCcc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.RrmPolicyMaxRatio |= int32(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 5: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field RrmPolicyMinRatio", wireType) + } + m.RrmPolicyMinRatio = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowCcc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.RrmPolicyMinRatio |= int32(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 6: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field RrmPolicyDedicatedRatio", wireType) + } + m.RrmPolicyDedicatedRatio = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowCcc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.RrmPolicyDedicatedRatio |= int32(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := skipCcc(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthCcc + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *Ack) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowCcc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: Ack: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Ack: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Success", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowCcc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.Success = bool(v != 0) + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Cause", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowCcc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthCcc + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthCcc + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Cause = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipCcc(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthCcc + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *UpdateSliceRequest) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowCcc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: UpdateSliceRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: UpdateSliceRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field E2NodeId", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowCcc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthCcc + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthCcc + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.E2NodeId = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field RrmPolicyRatio", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowCcc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthCcc + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthCcc + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.RrmPolicyRatio == nil { + m.RrmPolicyRatio = &ORRmpolicyRatio{} + } + if err := m.RrmPolicyRatio.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipCcc(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthCcc + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *UpdateSliceResponse) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowCcc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: UpdateSliceResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: UpdateSliceResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Ack", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowCcc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthCcc + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthCcc + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Ack == nil { + m.Ack = &Ack{} + } + if err := m.Ack.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipCcc(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthCcc + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipCcc(dAtA []byte) (n int, err error) { + l := len(dAtA) + iNdEx := 0 + depth := 0 + for iNdEx < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowCcc + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + wireType := int(wire & 0x7) + switch wireType { + case 0: + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowCcc + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + iNdEx++ + if dAtA[iNdEx-1] < 0x80 { + break + } + } + case 1: + iNdEx += 8 + case 2: + var length int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowCcc + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + length |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if length < 0 { + return 0, ErrInvalidLengthCcc + } + iNdEx += length + case 3: + depth++ + case 4: + if depth == 0 { + return 0, ErrUnexpectedEndOfGroupCcc + } + depth-- + case 5: + iNdEx += 4 + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + if iNdEx < 0 { + return 0, ErrInvalidLengthCcc + } + if depth == 0 { + return iNdEx, nil + } + } + return 0, io.ErrUnexpectedEOF +} + +var ( + ErrInvalidLengthCcc = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowCcc = fmt.Errorf("proto: integer overflow") + ErrUnexpectedEndOfGroupCcc = fmt.Errorf("proto: unexpected end of group") +) diff --git a/go/onos/topo/ran.pb.go b/go/onos/topo/ran.pb.go index 798aebdb..e211ab2f 100644 --- a/go/onos/topo/ran.pb.go +++ b/go/onos/topo/ran.pb.go @@ -189,6 +189,99 @@ func (ComponentType) EnumDescriptor() ([]byte, []int) { return fileDescriptor_23cc5f935e05bbb6, []int{4} } +// enumerated from e2sm_ccc.asn1:141 +type ResourceType int32 + +const ( + ResourceType_RESOURCE_TYPE_PRB_UL ResourceType = 0 + ResourceType_RESOURCE_TYPE_PRB_DL ResourceType = 1 + ResourceType_RESOURCE_TYPE_DRB ResourceType = 2 + ResourceType_RESOURCE_TYPE_RRC ResourceType = 3 +) + +var ResourceType_name = map[int32]string{ + 0: "RESOURCE_TYPE_PRB_UL", + 1: "RESOURCE_TYPE_PRB_DL", + 2: "RESOURCE_TYPE_DRB", + 3: "RESOURCE_TYPE_RRC", +} + +var ResourceType_value = map[string]int32{ + "RESOURCE_TYPE_PRB_UL": 0, + "RESOURCE_TYPE_PRB_DL": 1, + "RESOURCE_TYPE_DRB": 2, + "RESOURCE_TYPE_RRC": 3, +} + +func (x ResourceType) String() string { + return proto.EnumName(ResourceType_name, int32(x)) +} + +func (ResourceType) EnumDescriptor() ([]byte, []int) { + return fileDescriptor_23cc5f935e05bbb6, []int{5} +} + +// enumerated from e2sm_ccc.asn1:143 +type SchedulerType int32 + +const ( + SchedulerType_CCC_SCHEDULER_TYPE_ROUND_ROBIN SchedulerType = 0 + SchedulerType_CCC_SCHEDULER_TYPE_PROPORTIONALLY_FAIR SchedulerType = 1 + SchedulerType_CCC_SCHEDULER_TYPE_QOS_BASED SchedulerType = 2 +) + +var SchedulerType_name = map[int32]string{ + 0: "CCC_SCHEDULER_TYPE_ROUND_ROBIN", + 1: "CCC_SCHEDULER_TYPE_PROPORTIONALLY_FAIR", + 2: "CCC_SCHEDULER_TYPE_QOS_BASED", +} + +var SchedulerType_value = map[string]int32{ + "CCC_SCHEDULER_TYPE_ROUND_ROBIN": 0, + "CCC_SCHEDULER_TYPE_PROPORTIONALLY_FAIR": 1, + "CCC_SCHEDULER_TYPE_QOS_BASED": 2, +} + +func (x SchedulerType) String() string { + return proto.EnumName(SchedulerType_name, int32(x)) +} + +func (SchedulerType) EnumDescriptor() ([]byte, []int) { + return fileDescriptor_23cc5f935e05bbb6, []int{6} +} + +// enumerated from e2sm_ccc.asn1:137 +type ChangeType int32 + +const ( + ChangeType_CHANGE_TYPE_NONE ChangeType = 0 + ChangeType_CHANGE_TYPE_MODIFICATION ChangeType = 1 + ChangeType_CHANGE_TYPE_ADDITION ChangeType = 2 + ChangeType_CHANGE_TYPE_DELETION ChangeType = 3 +) + +var ChangeType_name = map[int32]string{ + 0: "CHANGE_TYPE_NONE", + 1: "CHANGE_TYPE_MODIFICATION", + 2: "CHANGE_TYPE_ADDITION", + 3: "CHANGE_TYPE_DELETION", +} + +var ChangeType_value = map[string]int32{ + "CHANGE_TYPE_NONE": 0, + "CHANGE_TYPE_MODIFICATION": 1, + "CHANGE_TYPE_ADDITION": 2, + "CHANGE_TYPE_DELETION": 3, +} + +func (x ChangeType) String() string { + return proto.EnumName(ChangeType_name, int32(x)) +} + +func (ChangeType) EnumDescriptor() ([]byte, []int) { + return fileDescriptor_23cc5f935e05bbb6, []int{7} +} + type E2SmRsmCommand int32 const ( @@ -220,7 +313,7 @@ func (x E2SmRsmCommand) String() string { } func (E2SmRsmCommand) EnumDescriptor() ([]byte, []int) { - return fileDescriptor_23cc5f935e05bbb6, []int{5} + return fileDescriptor_23cc5f935e05bbb6, []int{8} } type RSMSlicingType int32 @@ -245,7 +338,7 @@ func (x RSMSlicingType) String() string { } func (RSMSlicingType) EnumDescriptor() ([]byte, []int) { - return fileDescriptor_23cc5f935e05bbb6, []int{6} + return fileDescriptor_23cc5f935e05bbb6, []int{9} } type RSMSchedulerType int32 @@ -273,7 +366,7 @@ func (x RSMSchedulerType) String() string { } func (RSMSchedulerType) EnumDescriptor() ([]byte, []int) { - return fileDescriptor_23cc5f935e05bbb6, []int{7} + return fileDescriptor_23cc5f935e05bbb6, []int{10} } type RSMSliceType int32 @@ -298,7 +391,7 @@ func (x RSMSliceType) String() string { } func (RSMSliceType) EnumDescriptor() ([]byte, []int) { - return fileDescriptor_23cc5f935e05bbb6, []int{8} + return fileDescriptor_23cc5f935e05bbb6, []int{11} } type UeIdType int32 @@ -332,7 +425,7 @@ func (x UeIdType) String() string { } func (UeIdType) EnumDescriptor() ([]byte, []int) { - return fileDescriptor_23cc5f935e05bbb6, []int{9} + return fileDescriptor_23cc5f935e05bbb6, []int{12} } type NrScs int32 @@ -366,7 +459,7 @@ func (x NrScs) String() string { } func (NrScs) EnumDescriptor() ([]byte, []int) { - return fileDescriptor_23cc5f935e05bbb6, []int{10} + return fileDescriptor_23cc5f935e05bbb6, []int{13} } type Nrb int32 @@ -475,7 +568,7 @@ func (x Nrb) String() string { } func (Nrb) EnumDescriptor() ([]byte, []int) { - return fileDescriptor_23cc5f935e05bbb6, []int{11} + return fileDescriptor_23cc5f935e05bbb6, []int{14} } type EnDcSupport int32 @@ -503,7 +596,7 @@ func (x EnDcSupport) String() string { } func (EnDcSupport) EnumDescriptor() ([]byte, []int) { - return fileDescriptor_23cc5f935e05bbb6, []int{12} + return fileDescriptor_23cc5f935e05bbb6, []int{15} } type Interface_Type int32 @@ -3417,6 +3510,66 @@ func (m *MHORanFunction) GetReportStyles() []*MHOReportStyle { return nil } +type CCCRanFunction struct { + ID string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` + RanStructures []*RanconfigurationStructure `protobuf:"bytes,2,rep,name=ran_structures,json=ranStructures,proto3" json:"ran_structures,omitempty"` + CellsRanDefinition []*CellsForRanfunctionDefinition `protobuf:"bytes,3,rep,name=cells_ran_definition,json=cellsRanDefinition,proto3" json:"cells_ran_definition,omitempty"` +} + +func (m *CCCRanFunction) Reset() { *m = CCCRanFunction{} } +func (m *CCCRanFunction) String() string { return proto.CompactTextString(m) } +func (*CCCRanFunction) ProtoMessage() {} +func (*CCCRanFunction) Descriptor() ([]byte, []int) { + return fileDescriptor_23cc5f935e05bbb6, []int{44} +} +func (m *CCCRanFunction) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *CCCRanFunction) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_CCCRanFunction.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *CCCRanFunction) XXX_Merge(src proto.Message) { + xxx_messageInfo_CCCRanFunction.Merge(m, src) +} +func (m *CCCRanFunction) XXX_Size() int { + return m.Size() +} +func (m *CCCRanFunction) XXX_DiscardUnknown() { + xxx_messageInfo_CCCRanFunction.DiscardUnknown(m) +} + +var xxx_messageInfo_CCCRanFunction proto.InternalMessageInfo + +func (m *CCCRanFunction) GetID() string { + if m != nil { + return m.ID + } + return "" +} + +func (m *CCCRanFunction) GetRanStructures() []*RanconfigurationStructure { + if m != nil { + return m.RanStructures + } + return nil +} + +func (m *CCCRanFunction) GetCellsRanDefinition() []*CellsForRanfunctionDefinition { + if m != nil { + return m.CellsRanDefinition + } + return nil +} + type KPMRanFunction struct { ID string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` ReportStyles []*KPMReportStyle `protobuf:"bytes,2,rep,name=report_styles,json=reportStyles,proto3" json:"report_styles,omitempty"` @@ -3426,7 +3579,7 @@ func (m *KPMRanFunction) Reset() { *m = KPMRanFunction{} } func (m *KPMRanFunction) String() string { return proto.CompactTextString(m) } func (*KPMRanFunction) ProtoMessage() {} func (*KPMRanFunction) Descriptor() ([]byte, []int) { - return fileDescriptor_23cc5f935e05bbb6, []int{44} + return fileDescriptor_23cc5f935e05bbb6, []int{45} } func (m *KPMRanFunction) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3478,7 +3631,7 @@ func (m *RSMRanFunction) Reset() { *m = RSMRanFunction{} } func (m *RSMRanFunction) String() string { return proto.CompactTextString(m) } func (*RSMRanFunction) ProtoMessage() {} func (*RSMRanFunction) Descriptor() ([]byte, []int) { - return fileDescriptor_23cc5f935e05bbb6, []int{45} + return fileDescriptor_23cc5f935e05bbb6, []int{46} } func (m *RSMRanFunction) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3531,7 +3684,7 @@ func (m *RCEventTriggerStyle) Reset() { *m = RCEventTriggerStyle{} } func (m *RCEventTriggerStyle) String() string { return proto.CompactTextString(m) } func (*RCEventTriggerStyle) ProtoMessage() {} func (*RCEventTriggerStyle) Descriptor() ([]byte, []int) { - return fileDescriptor_23cc5f935e05bbb6, []int{46} + return fileDescriptor_23cc5f935e05bbb6, []int{47} } func (m *RCEventTriggerStyle) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3591,7 +3744,7 @@ func (m *RCReportStyle) Reset() { *m = RCReportStyle{} } func (m *RCReportStyle) String() string { return proto.CompactTextString(m) } func (*RCReportStyle) ProtoMessage() {} func (*RCReportStyle) Descriptor() ([]byte, []int) { - return fileDescriptor_23cc5f935e05bbb6, []int{47} + return fileDescriptor_23cc5f935e05bbb6, []int{48} } func (m *RCReportStyle) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3651,7 +3804,7 @@ func (m *RCInsertStyle) Reset() { *m = RCInsertStyle{} } func (m *RCInsertStyle) String() string { return proto.CompactTextString(m) } func (*RCInsertStyle) ProtoMessage() {} func (*RCInsertStyle) Descriptor() ([]byte, []int) { - return fileDescriptor_23cc5f935e05bbb6, []int{48} + return fileDescriptor_23cc5f935e05bbb6, []int{49} } func (m *RCInsertStyle) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3711,7 +3864,7 @@ func (m *RCPolicyStyle) Reset() { *m = RCPolicyStyle{} } func (m *RCPolicyStyle) String() string { return proto.CompactTextString(m) } func (*RCPolicyStyle) ProtoMessage() {} func (*RCPolicyStyle) Descriptor() ([]byte, []int) { - return fileDescriptor_23cc5f935e05bbb6, []int{49} + return fileDescriptor_23cc5f935e05bbb6, []int{50} } func (m *RCPolicyStyle) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3772,7 +3925,7 @@ func (m *PolicyAction) Reset() { *m = PolicyAction{} } func (m *PolicyAction) String() string { return proto.CompactTextString(m) } func (*PolicyAction) ProtoMessage() {} func (*PolicyAction) Descriptor() ([]byte, []int) { - return fileDescriptor_23cc5f935e05bbb6, []int{50} + return fileDescriptor_23cc5f935e05bbb6, []int{51} } func (m *PolicyAction) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3842,7 +3995,7 @@ func (m *RCControlStyle) Reset() { *m = RCControlStyle{} } func (m *RCControlStyle) String() string { return proto.CompactTextString(m) } func (*RCControlStyle) ProtoMessage() {} func (*RCControlStyle) Descriptor() ([]byte, []int) { - return fileDescriptor_23cc5f935e05bbb6, []int{51} + return fileDescriptor_23cc5f935e05bbb6, []int{52} } func (m *RCControlStyle) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3923,7 +4076,7 @@ func (m *ControlAction) Reset() { *m = ControlAction{} } func (m *ControlAction) String() string { return proto.CompactTextString(m) } func (*ControlAction) ProtoMessage() {} func (*ControlAction) Descriptor() ([]byte, []int) { - return fileDescriptor_23cc5f935e05bbb6, []int{52} + return fileDescriptor_23cc5f935e05bbb6, []int{53} } func (m *ControlAction) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3983,7 +4136,7 @@ func (m *InsertIndication) Reset() { *m = InsertIndication{} } func (m *InsertIndication) String() string { return proto.CompactTextString(m) } func (*InsertIndication) ProtoMessage() {} func (*InsertIndication) Descriptor() ([]byte, []int) { - return fileDescriptor_23cc5f935e05bbb6, []int{53} + return fileDescriptor_23cc5f935e05bbb6, []int{54} } func (m *InsertIndication) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -4042,7 +4195,7 @@ func (m *RANParameter) Reset() { *m = RANParameter{} } func (m *RANParameter) String() string { return proto.CompactTextString(m) } func (*RANParameter) ProtoMessage() {} func (*RANParameter) Descriptor() ([]byte, []int) { - return fileDescriptor_23cc5f935e05bbb6, []int{54} + return fileDescriptor_23cc5f935e05bbb6, []int{55} } func (m *RANParameter) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -4085,24 +4238,23 @@ func (m *RANParameter) GetName() string { return "" } -type KPMReportStyle struct { - Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` - Type int32 `protobuf:"varint,2,opt,name=type,proto3" json:"type,omitempty"` - Measurements []*KPMMeasurement `protobuf:"bytes,3,rep,name=measurements,proto3" json:"measurements,omitempty"` +type RanconfigurationStructure struct { + Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` + Attribute []*Attribute `protobuf:"bytes,2,rep,name=attribute,proto3" json:"attribute,omitempty"` } -func (m *KPMReportStyle) Reset() { *m = KPMReportStyle{} } -func (m *KPMReportStyle) String() string { return proto.CompactTextString(m) } -func (*KPMReportStyle) ProtoMessage() {} -func (*KPMReportStyle) Descriptor() ([]byte, []int) { - return fileDescriptor_23cc5f935e05bbb6, []int{55} +func (m *RanconfigurationStructure) Reset() { *m = RanconfigurationStructure{} } +func (m *RanconfigurationStructure) String() string { return proto.CompactTextString(m) } +func (*RanconfigurationStructure) ProtoMessage() {} +func (*RanconfigurationStructure) Descriptor() ([]byte, []int) { + return fileDescriptor_23cc5f935e05bbb6, []int{56} } -func (m *KPMReportStyle) XXX_Unmarshal(b []byte) error { +func (m *RanconfigurationStructure) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } -func (m *KPMReportStyle) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { +func (m *RanconfigurationStructure) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { - return xxx_messageInfo_KPMReportStyle.Marshal(b, m, deterministic) + return xxx_messageInfo_RanconfigurationStructure.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) @@ -4112,56 +4264,49 @@ func (m *KPMReportStyle) XXX_Marshal(b []byte, deterministic bool) ([]byte, erro return b[:n], nil } } -func (m *KPMReportStyle) XXX_Merge(src proto.Message) { - xxx_messageInfo_KPMReportStyle.Merge(m, src) +func (m *RanconfigurationStructure) XXX_Merge(src proto.Message) { + xxx_messageInfo_RanconfigurationStructure.Merge(m, src) } -func (m *KPMReportStyle) XXX_Size() int { +func (m *RanconfigurationStructure) XXX_Size() int { return m.Size() } -func (m *KPMReportStyle) XXX_DiscardUnknown() { - xxx_messageInfo_KPMReportStyle.DiscardUnknown(m) +func (m *RanconfigurationStructure) XXX_DiscardUnknown() { + xxx_messageInfo_RanconfigurationStructure.DiscardUnknown(m) } -var xxx_messageInfo_KPMReportStyle proto.InternalMessageInfo +var xxx_messageInfo_RanconfigurationStructure proto.InternalMessageInfo -func (m *KPMReportStyle) GetName() string { +func (m *RanconfigurationStructure) GetName() string { if m != nil { return m.Name } return "" } -func (m *KPMReportStyle) GetType() int32 { - if m != nil { - return m.Type - } - return 0 -} - -func (m *KPMReportStyle) GetMeasurements() []*KPMMeasurement { +func (m *RanconfigurationStructure) GetAttribute() []*Attribute { if m != nil { - return m.Measurements + return m.Attribute } return nil } -type MHOReportStyle struct { - Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` - Type int32 `protobuf:"varint,2,opt,name=type,proto3" json:"type,omitempty"` +type Attribute struct { + Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` + RicServices *RICServices `protobuf:"bytes,2,opt,name=ric_services,json=ricServices,proto3" json:"ric_services,omitempty"` } -func (m *MHOReportStyle) Reset() { *m = MHOReportStyle{} } -func (m *MHOReportStyle) String() string { return proto.CompactTextString(m) } -func (*MHOReportStyle) ProtoMessage() {} -func (*MHOReportStyle) Descriptor() ([]byte, []int) { - return fileDescriptor_23cc5f935e05bbb6, []int{56} +func (m *Attribute) Reset() { *m = Attribute{} } +func (m *Attribute) String() string { return proto.CompactTextString(m) } +func (*Attribute) ProtoMessage() {} +func (*Attribute) Descriptor() ([]byte, []int) { + return fileDescriptor_23cc5f935e05bbb6, []int{57} } -func (m *MHOReportStyle) XXX_Unmarshal(b []byte) error { +func (m *Attribute) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } -func (m *MHOReportStyle) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { +func (m *Attribute) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { - return xxx_messageInfo_MHOReportStyle.Marshal(b, m, deterministic) + return xxx_messageInfo_Attribute.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) @@ -4171,49 +4316,52 @@ func (m *MHOReportStyle) XXX_Marshal(b []byte, deterministic bool) ([]byte, erro return b[:n], nil } } -func (m *MHOReportStyle) XXX_Merge(src proto.Message) { - xxx_messageInfo_MHOReportStyle.Merge(m, src) +func (m *Attribute) XXX_Merge(src proto.Message) { + xxx_messageInfo_Attribute.Merge(m, src) } -func (m *MHOReportStyle) XXX_Size() int { +func (m *Attribute) XXX_Size() int { return m.Size() } -func (m *MHOReportStyle) XXX_DiscardUnknown() { - xxx_messageInfo_MHOReportStyle.DiscardUnknown(m) +func (m *Attribute) XXX_DiscardUnknown() { + xxx_messageInfo_Attribute.DiscardUnknown(m) } -var xxx_messageInfo_MHOReportStyle proto.InternalMessageInfo +var xxx_messageInfo_Attribute proto.InternalMessageInfo -func (m *MHOReportStyle) GetName() string { +func (m *Attribute) GetName() string { if m != nil { return m.Name } return "" } -func (m *MHOReportStyle) GetType() int32 { +func (m *Attribute) GetRicServices() *RICServices { if m != nil { - return m.Type + return m.RicServices } - return 0 + return nil } -type KPMMeasurement struct { - ID string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` - Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"` +type RICServices struct { + EventTriggerStyles []*CCCEventTriggerStyle `protobuf:"bytes,1,rep,name=event_trigger_styles,json=eventTriggerStyles,proto3" json:"event_trigger_styles,omitempty"` + ReportStyles []*CCCReportStyle `protobuf:"bytes,2,rep,name=report_styles,json=reportStyles,proto3" json:"report_styles,omitempty"` + InsertStyles []*CCCInsertStyle `protobuf:"bytes,3,rep,name=insert_styles,json=insertStyles,proto3" json:"insert_styles,omitempty"` + ControlStyles []*CCCControlStyle `protobuf:"bytes,4,rep,name=control_styles,json=controlStyles,proto3" json:"control_styles,omitempty"` + PolicyStyles []*CCCPolicyStyle `protobuf:"bytes,5,rep,name=policy_styles,json=policyStyles,proto3" json:"policy_styles,omitempty"` } -func (m *KPMMeasurement) Reset() { *m = KPMMeasurement{} } -func (m *KPMMeasurement) String() string { return proto.CompactTextString(m) } -func (*KPMMeasurement) ProtoMessage() {} -func (*KPMMeasurement) Descriptor() ([]byte, []int) { - return fileDescriptor_23cc5f935e05bbb6, []int{57} +func (m *RICServices) Reset() { *m = RICServices{} } +func (m *RICServices) String() string { return proto.CompactTextString(m) } +func (*RICServices) ProtoMessage() {} +func (*RICServices) Descriptor() ([]byte, []int) { + return fileDescriptor_23cc5f935e05bbb6, []int{58} } -func (m *KPMMeasurement) XXX_Unmarshal(b []byte) error { +func (m *RICServices) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } -func (m *KPMMeasurement) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { +func (m *RICServices) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { - return xxx_messageInfo_KPMMeasurement.Marshal(b, m, deterministic) + return xxx_messageInfo_RICServices.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) @@ -4223,52 +4371,70 @@ func (m *KPMMeasurement) XXX_Marshal(b []byte, deterministic bool) ([]byte, erro return b[:n], nil } } -func (m *KPMMeasurement) XXX_Merge(src proto.Message) { - xxx_messageInfo_KPMMeasurement.Merge(m, src) +func (m *RICServices) XXX_Merge(src proto.Message) { + xxx_messageInfo_RICServices.Merge(m, src) } -func (m *KPMMeasurement) XXX_Size() int { +func (m *RICServices) XXX_Size() int { return m.Size() } -func (m *KPMMeasurement) XXX_DiscardUnknown() { - xxx_messageInfo_KPMMeasurement.DiscardUnknown(m) +func (m *RICServices) XXX_DiscardUnknown() { + xxx_messageInfo_RICServices.DiscardUnknown(m) } -var xxx_messageInfo_KPMMeasurement proto.InternalMessageInfo +var xxx_messageInfo_RICServices proto.InternalMessageInfo -func (m *KPMMeasurement) GetID() string { +func (m *RICServices) GetEventTriggerStyles() []*CCCEventTriggerStyle { if m != nil { - return m.ID + return m.EventTriggerStyles } - return "" + return nil } -func (m *KPMMeasurement) GetName() string { +func (m *RICServices) GetReportStyles() []*CCCReportStyle { if m != nil { - return m.Name + return m.ReportStyles } - return "" + return nil } -type RSMNodeSlicingCapabilityItem struct { - MaxNumberOfSlicesDl int32 `protobuf:"varint,1,opt,name=max_number_of_slices_dl,json=maxNumberOfSlicesDl,proto3" json:"max_number_of_slices_dl,omitempty"` - MaxNumberOfSlicesUl int32 `protobuf:"varint,2,opt,name=max_number_of_slices_ul,json=maxNumberOfSlicesUl,proto3" json:"max_number_of_slices_ul,omitempty"` - SlicingType RSMSlicingType `protobuf:"varint,3,opt,name=slicing_type,json=slicingType,proto3,enum=onos.topo.RSMSlicingType" json:"slicing_type,omitempty"` - MaxNumberOfUesPerSlice int32 `protobuf:"varint,4,opt,name=max_number_of_ues_per_slice,json=maxNumberOfUesPerSlice,proto3" json:"max_number_of_ues_per_slice,omitempty"` - SupportedConfig []*RSMSupportedSlicingConfigItem `protobuf:"bytes,5,rep,name=supported_config,json=supportedConfig,proto3" json:"supported_config,omitempty"` +func (m *RICServices) GetInsertStyles() []*CCCInsertStyle { + if m != nil { + return m.InsertStyles + } + return nil } -func (m *RSMNodeSlicingCapabilityItem) Reset() { *m = RSMNodeSlicingCapabilityItem{} } -func (m *RSMNodeSlicingCapabilityItem) String() string { return proto.CompactTextString(m) } -func (*RSMNodeSlicingCapabilityItem) ProtoMessage() {} -func (*RSMNodeSlicingCapabilityItem) Descriptor() ([]byte, []int) { - return fileDescriptor_23cc5f935e05bbb6, []int{58} +func (m *RICServices) GetControlStyles() []*CCCControlStyle { + if m != nil { + return m.ControlStyles + } + return nil } -func (m *RSMNodeSlicingCapabilityItem) XXX_Unmarshal(b []byte) error { + +func (m *RICServices) GetPolicyStyles() []*CCCPolicyStyle { + if m != nil { + return m.PolicyStyles + } + return nil +} + +type CellsForRanfunctionDefinition struct { + CellGlobalId *CellGlobalID `protobuf:"bytes,1,opt,name=cell_global_id,json=cellGlobalId,proto3" json:"cell_global_id,omitempty"` + CellFunctionDefinition []*CellForRanfunctionDefinition `protobuf:"bytes,2,rep,name=cell_function_definition,json=cellFunctionDefinition,proto3" json:"cell_function_definition,omitempty"` +} + +func (m *CellsForRanfunctionDefinition) Reset() { *m = CellsForRanfunctionDefinition{} } +func (m *CellsForRanfunctionDefinition) String() string { return proto.CompactTextString(m) } +func (*CellsForRanfunctionDefinition) ProtoMessage() {} +func (*CellsForRanfunctionDefinition) Descriptor() ([]byte, []int) { + return fileDescriptor_23cc5f935e05bbb6, []int{59} +} +func (m *CellsForRanfunctionDefinition) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } -func (m *RSMNodeSlicingCapabilityItem) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { +func (m *CellsForRanfunctionDefinition) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { - return xxx_messageInfo_RSMNodeSlicingCapabilityItem.Marshal(b, m, deterministic) + return xxx_messageInfo_CellsForRanfunctionDefinition.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) @@ -4278,69 +4444,49 @@ func (m *RSMNodeSlicingCapabilityItem) XXX_Marshal(b []byte, deterministic bool) return b[:n], nil } } -func (m *RSMNodeSlicingCapabilityItem) XXX_Merge(src proto.Message) { - xxx_messageInfo_RSMNodeSlicingCapabilityItem.Merge(m, src) +func (m *CellsForRanfunctionDefinition) XXX_Merge(src proto.Message) { + xxx_messageInfo_CellsForRanfunctionDefinition.Merge(m, src) } -func (m *RSMNodeSlicingCapabilityItem) XXX_Size() int { +func (m *CellsForRanfunctionDefinition) XXX_Size() int { return m.Size() } -func (m *RSMNodeSlicingCapabilityItem) XXX_DiscardUnknown() { - xxx_messageInfo_RSMNodeSlicingCapabilityItem.DiscardUnknown(m) +func (m *CellsForRanfunctionDefinition) XXX_DiscardUnknown() { + xxx_messageInfo_CellsForRanfunctionDefinition.DiscardUnknown(m) } -var xxx_messageInfo_RSMNodeSlicingCapabilityItem proto.InternalMessageInfo +var xxx_messageInfo_CellsForRanfunctionDefinition proto.InternalMessageInfo -func (m *RSMNodeSlicingCapabilityItem) GetMaxNumberOfSlicesDl() int32 { +func (m *CellsForRanfunctionDefinition) GetCellGlobalId() *CellGlobalID { if m != nil { - return m.MaxNumberOfSlicesDl + return m.CellGlobalId } - return 0 + return nil } -func (m *RSMNodeSlicingCapabilityItem) GetMaxNumberOfSlicesUl() int32 { +func (m *CellsForRanfunctionDefinition) GetCellFunctionDefinition() []*CellForRanfunctionDefinition { if m != nil { - return m.MaxNumberOfSlicesUl + return m.CellFunctionDefinition } - return 0 + return nil } -func (m *RSMNodeSlicingCapabilityItem) GetSlicingType() RSMSlicingType { - if m != nil { - return m.SlicingType - } - return RSMSlicingType_SLICING_TYPE_STATIC +type CellForRanfunctionDefinition struct { + Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` + Attribute []*Attribute `protobuf:"bytes,2,rep,name=attribute,proto3" json:"attribute,omitempty"` } -func (m *RSMNodeSlicingCapabilityItem) GetMaxNumberOfUesPerSlice() int32 { - if m != nil { - return m.MaxNumberOfUesPerSlice - } - return 0 +func (m *CellForRanfunctionDefinition) Reset() { *m = CellForRanfunctionDefinition{} } +func (m *CellForRanfunctionDefinition) String() string { return proto.CompactTextString(m) } +func (*CellForRanfunctionDefinition) ProtoMessage() {} +func (*CellForRanfunctionDefinition) Descriptor() ([]byte, []int) { + return fileDescriptor_23cc5f935e05bbb6, []int{60} } - -func (m *RSMNodeSlicingCapabilityItem) GetSupportedConfig() []*RSMSupportedSlicingConfigItem { - if m != nil { - return m.SupportedConfig - } - return nil -} - -type RSMSupportedSlicingConfigItem struct { - SlicingConfigType E2SmRsmCommand `protobuf:"varint,1,opt,name=slicing_config_type,json=slicingConfigType,proto3,enum=onos.topo.E2SmRsmCommand" json:"slicing_config_type,omitempty"` -} - -func (m *RSMSupportedSlicingConfigItem) Reset() { *m = RSMSupportedSlicingConfigItem{} } -func (m *RSMSupportedSlicingConfigItem) String() string { return proto.CompactTextString(m) } -func (*RSMSupportedSlicingConfigItem) ProtoMessage() {} -func (*RSMSupportedSlicingConfigItem) Descriptor() ([]byte, []int) { - return fileDescriptor_23cc5f935e05bbb6, []int{59} -} -func (m *RSMSupportedSlicingConfigItem) XXX_Unmarshal(b []byte) error { +func (m *CellForRanfunctionDefinition) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } -func (m *RSMSupportedSlicingConfigItem) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { +func (m *CellForRanfunctionDefinition) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { - return xxx_messageInfo_RSMSupportedSlicingConfigItem.Marshal(b, m, deterministic) + return xxx_messageInfo_CellForRanfunctionDefinition.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) @@ -4350,41 +4496,50 @@ func (m *RSMSupportedSlicingConfigItem) XXX_Marshal(b []byte, deterministic bool return b[:n], nil } } -func (m *RSMSupportedSlicingConfigItem) XXX_Merge(src proto.Message) { - xxx_messageInfo_RSMSupportedSlicingConfigItem.Merge(m, src) +func (m *CellForRanfunctionDefinition) XXX_Merge(src proto.Message) { + xxx_messageInfo_CellForRanfunctionDefinition.Merge(m, src) } -func (m *RSMSupportedSlicingConfigItem) XXX_Size() int { +func (m *CellForRanfunctionDefinition) XXX_Size() int { return m.Size() } -func (m *RSMSupportedSlicingConfigItem) XXX_DiscardUnknown() { - xxx_messageInfo_RSMSupportedSlicingConfigItem.DiscardUnknown(m) +func (m *CellForRanfunctionDefinition) XXX_DiscardUnknown() { + xxx_messageInfo_CellForRanfunctionDefinition.DiscardUnknown(m) } -var xxx_messageInfo_RSMSupportedSlicingConfigItem proto.InternalMessageInfo +var xxx_messageInfo_CellForRanfunctionDefinition proto.InternalMessageInfo -func (m *RSMSupportedSlicingConfigItem) GetSlicingConfigType() E2SmRsmCommand { +func (m *CellForRanfunctionDefinition) GetName() string { if m != nil { - return m.SlicingConfigType + return m.Name } - return E2SmRsmCommand_E2_SM_RSM_COMMAND_SLICE_CREATE + return "" } -type RSMSliceItemList struct { - RsmSliceList []*RSMSlicingItem `protobuf:"bytes,1,rep,name=rsm_slice_list,json=rsmSliceList,proto3" json:"rsm_slice_list,omitempty"` +func (m *CellForRanfunctionDefinition) GetAttribute() []*Attribute { + if m != nil { + return m.Attribute + } + return nil } -func (m *RSMSliceItemList) Reset() { *m = RSMSliceItemList{} } -func (m *RSMSliceItemList) String() string { return proto.CompactTextString(m) } -func (*RSMSliceItemList) ProtoMessage() {} -func (*RSMSliceItemList) Descriptor() ([]byte, []int) { - return fileDescriptor_23cc5f935e05bbb6, []int{60} +type CCCEventTriggerStyle struct { + Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` + Type int32 `protobuf:"varint,2,opt,name=type,proto3" json:"type,omitempty"` + FormatType int32 `protobuf:"varint,3,opt,name=format_type,json=formatType,proto3" json:"format_type,omitempty"` } -func (m *RSMSliceItemList) XXX_Unmarshal(b []byte) error { + +func (m *CCCEventTriggerStyle) Reset() { *m = CCCEventTriggerStyle{} } +func (m *CCCEventTriggerStyle) String() string { return proto.CompactTextString(m) } +func (*CCCEventTriggerStyle) ProtoMessage() {} +func (*CCCEventTriggerStyle) Descriptor() ([]byte, []int) { + return fileDescriptor_23cc5f935e05bbb6, []int{61} +} +func (m *CCCEventTriggerStyle) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } -func (m *RSMSliceItemList) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { +func (m *CCCEventTriggerStyle) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { - return xxx_messageInfo_RSMSliceItemList.Marshal(b, m, deterministic) + return xxx_messageInfo_CCCEventTriggerStyle.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) @@ -4394,45 +4549,60 @@ func (m *RSMSliceItemList) XXX_Marshal(b []byte, deterministic bool) ([]byte, er return b[:n], nil } } -func (m *RSMSliceItemList) XXX_Merge(src proto.Message) { - xxx_messageInfo_RSMSliceItemList.Merge(m, src) +func (m *CCCEventTriggerStyle) XXX_Merge(src proto.Message) { + xxx_messageInfo_CCCEventTriggerStyle.Merge(m, src) } -func (m *RSMSliceItemList) XXX_Size() int { +func (m *CCCEventTriggerStyle) XXX_Size() int { return m.Size() } -func (m *RSMSliceItemList) XXX_DiscardUnknown() { - xxx_messageInfo_RSMSliceItemList.DiscardUnknown(m) +func (m *CCCEventTriggerStyle) XXX_DiscardUnknown() { + xxx_messageInfo_CCCEventTriggerStyle.DiscardUnknown(m) } -var xxx_messageInfo_RSMSliceItemList proto.InternalMessageInfo +var xxx_messageInfo_CCCEventTriggerStyle proto.InternalMessageInfo -func (m *RSMSliceItemList) GetRsmSliceList() []*RSMSlicingItem { +func (m *CCCEventTriggerStyle) GetName() string { if m != nil { - return m.RsmSliceList + return m.Name } - return nil + return "" } -type RSMSlicingItem struct { - ID string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` - SliceDesc string `protobuf:"bytes,2,opt,name=slice_desc,json=sliceDesc,proto3" json:"slice_desc,omitempty"` - SliceParameters *RSMSliceParameters `protobuf:"bytes,3,opt,name=slice_parameters,json=sliceParameters,proto3" json:"slice_parameters,omitempty"` - SliceType RSMSliceType `protobuf:"varint,4,opt,name=slice_type,json=sliceType,proto3,enum=onos.topo.RSMSliceType" json:"slice_type,omitempty"` - UeIdList []*UeIdentity `protobuf:"bytes,5,rep,name=ue_id_list,json=ueIdList,proto3" json:"ue_id_list,omitempty"` +func (m *CCCEventTriggerStyle) GetType() int32 { + if m != nil { + return m.Type + } + return 0 } -func (m *RSMSlicingItem) Reset() { *m = RSMSlicingItem{} } -func (m *RSMSlicingItem) String() string { return proto.CompactTextString(m) } -func (*RSMSlicingItem) ProtoMessage() {} -func (*RSMSlicingItem) Descriptor() ([]byte, []int) { - return fileDescriptor_23cc5f935e05bbb6, []int{61} +func (m *CCCEventTriggerStyle) GetFormatType() int32 { + if m != nil { + return m.FormatType + } + return 0 } -func (m *RSMSlicingItem) XXX_Unmarshal(b []byte) error { + +type CCCReportStyle struct { + Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` + Type int32 `protobuf:"varint,2,opt,name=type,proto3" json:"type,omitempty"` + EventTriggerStyleForReport []int32 `protobuf:"varint,3,rep,packed,name=event_trigger_style_for_report,json=eventTriggerStyleForReport,proto3" json:"event_trigger_style_for_report,omitempty"` + ActionDefinitionFormatType int32 `protobuf:"varint,4,opt,name=action_definition_format_type,json=actionDefinitionFormatType,proto3" json:"action_definition_format_type,omitempty"` + IndicationHeaderFormatType int32 `protobuf:"varint,5,opt,name=indication_header_format_type,json=indicationHeaderFormatType,proto3" json:"indication_header_format_type,omitempty"` + IndicationMessageFormatType int32 `protobuf:"varint,6,opt,name=indication_message_format_type,json=indicationMessageFormatType,proto3" json:"indication_message_format_type,omitempty"` +} + +func (m *CCCReportStyle) Reset() { *m = CCCReportStyle{} } +func (m *CCCReportStyle) String() string { return proto.CompactTextString(m) } +func (*CCCReportStyle) ProtoMessage() {} +func (*CCCReportStyle) Descriptor() ([]byte, []int) { + return fileDescriptor_23cc5f935e05bbb6, []int{62} +} +func (m *CCCReportStyle) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } -func (m *RSMSlicingItem) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { +func (m *CCCReportStyle) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { - return xxx_messageInfo_RSMSlicingItem.Marshal(b, m, deterministic) + return xxx_messageInfo_CCCReportStyle.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) @@ -4442,71 +4612,76 @@ func (m *RSMSlicingItem) XXX_Marshal(b []byte, deterministic bool) ([]byte, erro return b[:n], nil } } -func (m *RSMSlicingItem) XXX_Merge(src proto.Message) { - xxx_messageInfo_RSMSlicingItem.Merge(m, src) +func (m *CCCReportStyle) XXX_Merge(src proto.Message) { + xxx_messageInfo_CCCReportStyle.Merge(m, src) } -func (m *RSMSlicingItem) XXX_Size() int { +func (m *CCCReportStyle) XXX_Size() int { return m.Size() } -func (m *RSMSlicingItem) XXX_DiscardUnknown() { - xxx_messageInfo_RSMSlicingItem.DiscardUnknown(m) +func (m *CCCReportStyle) XXX_DiscardUnknown() { + xxx_messageInfo_CCCReportStyle.DiscardUnknown(m) } -var xxx_messageInfo_RSMSlicingItem proto.InternalMessageInfo +var xxx_messageInfo_CCCReportStyle proto.InternalMessageInfo -func (m *RSMSlicingItem) GetID() string { +func (m *CCCReportStyle) GetName() string { if m != nil { - return m.ID + return m.Name } return "" } -func (m *RSMSlicingItem) GetSliceDesc() string { +func (m *CCCReportStyle) GetType() int32 { if m != nil { - return m.SliceDesc + return m.Type } - return "" + return 0 } -func (m *RSMSlicingItem) GetSliceParameters() *RSMSliceParameters { +func (m *CCCReportStyle) GetEventTriggerStyleForReport() []int32 { if m != nil { - return m.SliceParameters + return m.EventTriggerStyleForReport } return nil } -func (m *RSMSlicingItem) GetSliceType() RSMSliceType { +func (m *CCCReportStyle) GetActionDefinitionFormatType() int32 { if m != nil { - return m.SliceType + return m.ActionDefinitionFormatType } - return RSMSliceType_SLICE_TYPE_DL_SLICE + return 0 } -func (m *RSMSlicingItem) GetUeIdList() []*UeIdentity { +func (m *CCCReportStyle) GetIndicationHeaderFormatType() int32 { if m != nil { - return m.UeIdList + return m.IndicationHeaderFormatType } - return nil + return 0 } -type RSMSliceParameters struct { - SchedulerType RSMSchedulerType `protobuf:"varint,1,opt,name=scheduler_type,json=schedulerType,proto3,enum=onos.topo.RSMSchedulerType" json:"scheduler_type,omitempty"` - Weight int32 `protobuf:"varint,2,opt,name=weight,proto3" json:"weight,omitempty"` - QosLevel int32 `protobuf:"varint,3,opt,name=qos_level,json=qosLevel,proto3" json:"qos_level,omitempty"` +func (m *CCCReportStyle) GetIndicationMessageFormatType() int32 { + if m != nil { + return m.IndicationMessageFormatType + } + return 0 } -func (m *RSMSliceParameters) Reset() { *m = RSMSliceParameters{} } -func (m *RSMSliceParameters) String() string { return proto.CompactTextString(m) } -func (*RSMSliceParameters) ProtoMessage() {} -func (*RSMSliceParameters) Descriptor() ([]byte, []int) { - return fileDescriptor_23cc5f935e05bbb6, []int{62} +type CCCInsertStyle struct { + Value *types.Empty `protobuf:"bytes,1,opt,name=value,proto3" json:"value,omitempty"` } -func (m *RSMSliceParameters) XXX_Unmarshal(b []byte) error { + +func (m *CCCInsertStyle) Reset() { *m = CCCInsertStyle{} } +func (m *CCCInsertStyle) String() string { return proto.CompactTextString(m) } +func (*CCCInsertStyle) ProtoMessage() {} +func (*CCCInsertStyle) Descriptor() ([]byte, []int) { + return fileDescriptor_23cc5f935e05bbb6, []int{63} +} +func (m *CCCInsertStyle) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } -func (m *RSMSliceParameters) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { +func (m *CCCInsertStyle) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { - return xxx_messageInfo_RSMSliceParameters.Marshal(b, m, deterministic) + return xxx_messageInfo_CCCInsertStyle.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) @@ -4516,55 +4691,46 @@ func (m *RSMSliceParameters) XXX_Marshal(b []byte, deterministic bool) ([]byte, return b[:n], nil } } -func (m *RSMSliceParameters) XXX_Merge(src proto.Message) { - xxx_messageInfo_RSMSliceParameters.Merge(m, src) +func (m *CCCInsertStyle) XXX_Merge(src proto.Message) { + xxx_messageInfo_CCCInsertStyle.Merge(m, src) } -func (m *RSMSliceParameters) XXX_Size() int { +func (m *CCCInsertStyle) XXX_Size() int { return m.Size() } -func (m *RSMSliceParameters) XXX_DiscardUnknown() { - xxx_messageInfo_RSMSliceParameters.DiscardUnknown(m) -} - -var xxx_messageInfo_RSMSliceParameters proto.InternalMessageInfo - -func (m *RSMSliceParameters) GetSchedulerType() RSMSchedulerType { - if m != nil { - return m.SchedulerType - } - return RSMSchedulerType_SCHEDULER_TYPE_ROUND_ROBIN +func (m *CCCInsertStyle) XXX_DiscardUnknown() { + xxx_messageInfo_CCCInsertStyle.DiscardUnknown(m) } -func (m *RSMSliceParameters) GetWeight() int32 { - if m != nil { - return m.Weight - } - return 0 -} +var xxx_messageInfo_CCCInsertStyle proto.InternalMessageInfo -func (m *RSMSliceParameters) GetQosLevel() int32 { +func (m *CCCInsertStyle) GetValue() *types.Empty { if m != nil { - return m.QosLevel + return m.Value } - return 0 + return nil } -type DuUeF1ApID struct { - Value int64 `protobuf:"varint,1,opt,name=value,proto3" json:"value,omitempty"` +type CCCControlStyle struct { + Type int32 `protobuf:"varint,1,opt,name=type,proto3" json:"type,omitempty"` + Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"` + ControlHeaderFormatType int32 `protobuf:"varint,3,opt,name=control_header_format_type,json=controlHeaderFormatType,proto3" json:"control_header_format_type,omitempty"` + ControlMessageFormatType int32 `protobuf:"varint,4,opt,name=control_message_format_type,json=controlMessageFormatType,proto3" json:"control_message_format_type,omitempty"` + RicProcessIdFormatType int32 `protobuf:"varint,5,opt,name=ric_process_id_format_type,json=ricProcessIdFormatType,proto3" json:"ric_process_id_format_type,omitempty"` + ControlOutcomeFormatType int32 `protobuf:"varint,6,opt,name=control_outcome_format_type,json=controlOutcomeFormatType,proto3" json:"control_outcome_format_type,omitempty"` } -func (m *DuUeF1ApID) Reset() { *m = DuUeF1ApID{} } -func (m *DuUeF1ApID) String() string { return proto.CompactTextString(m) } -func (*DuUeF1ApID) ProtoMessage() {} -func (*DuUeF1ApID) Descriptor() ([]byte, []int) { - return fileDescriptor_23cc5f935e05bbb6, []int{63} +func (m *CCCControlStyle) Reset() { *m = CCCControlStyle{} } +func (m *CCCControlStyle) String() string { return proto.CompactTextString(m) } +func (*CCCControlStyle) ProtoMessage() {} +func (*CCCControlStyle) Descriptor() ([]byte, []int) { + return fileDescriptor_23cc5f935e05bbb6, []int{64} } -func (m *DuUeF1ApID) XXX_Unmarshal(b []byte) error { +func (m *CCCControlStyle) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } -func (m *DuUeF1ApID) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { +func (m *CCCControlStyle) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { - return xxx_messageInfo_DuUeF1ApID.Marshal(b, m, deterministic) + return xxx_messageInfo_CCCControlStyle.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) @@ -4574,41 +4740,76 @@ func (m *DuUeF1ApID) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { return b[:n], nil } } -func (m *DuUeF1ApID) XXX_Merge(src proto.Message) { - xxx_messageInfo_DuUeF1ApID.Merge(m, src) +func (m *CCCControlStyle) XXX_Merge(src proto.Message) { + xxx_messageInfo_CCCControlStyle.Merge(m, src) } -func (m *DuUeF1ApID) XXX_Size() int { +func (m *CCCControlStyle) XXX_Size() int { return m.Size() } -func (m *DuUeF1ApID) XXX_DiscardUnknown() { - xxx_messageInfo_DuUeF1ApID.DiscardUnknown(m) +func (m *CCCControlStyle) XXX_DiscardUnknown() { + xxx_messageInfo_CCCControlStyle.DiscardUnknown(m) } -var xxx_messageInfo_DuUeF1ApID proto.InternalMessageInfo +var xxx_messageInfo_CCCControlStyle proto.InternalMessageInfo -func (m *DuUeF1ApID) GetValue() int64 { +func (m *CCCControlStyle) GetType() int32 { if m != nil { - return m.Value + return m.Type } return 0 } -type CuUeF1ApID struct { - Value int64 `protobuf:"varint,1,opt,name=value,proto3" json:"value,omitempty"` +func (m *CCCControlStyle) GetName() string { + if m != nil { + return m.Name + } + return "" } -func (m *CuUeF1ApID) Reset() { *m = CuUeF1ApID{} } -func (m *CuUeF1ApID) String() string { return proto.CompactTextString(m) } -func (*CuUeF1ApID) ProtoMessage() {} -func (*CuUeF1ApID) Descriptor() ([]byte, []int) { - return fileDescriptor_23cc5f935e05bbb6, []int{64} +func (m *CCCControlStyle) GetControlHeaderFormatType() int32 { + if m != nil { + return m.ControlHeaderFormatType + } + return 0 } -func (m *CuUeF1ApID) XXX_Unmarshal(b []byte) error { + +func (m *CCCControlStyle) GetControlMessageFormatType() int32 { + if m != nil { + return m.ControlMessageFormatType + } + return 0 +} + +func (m *CCCControlStyle) GetRicProcessIdFormatType() int32 { + if m != nil { + return m.RicProcessIdFormatType + } + return 0 +} + +func (m *CCCControlStyle) GetControlOutcomeFormatType() int32 { + if m != nil { + return m.ControlOutcomeFormatType + } + return 0 +} + +type CCCPolicyStyle struct { + Value *types.Empty `protobuf:"bytes,1,opt,name=value,proto3" json:"value,omitempty"` +} + +func (m *CCCPolicyStyle) Reset() { *m = CCCPolicyStyle{} } +func (m *CCCPolicyStyle) String() string { return proto.CompactTextString(m) } +func (*CCCPolicyStyle) ProtoMessage() {} +func (*CCCPolicyStyle) Descriptor() ([]byte, []int) { + return fileDescriptor_23cc5f935e05bbb6, []int{65} +} +func (m *CCCPolicyStyle) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } -func (m *CuUeF1ApID) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { +func (m *CCCPolicyStyle) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { - return xxx_messageInfo_CuUeF1ApID.Marshal(b, m, deterministic) + return xxx_messageInfo_CCCPolicyStyle.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) @@ -4618,41 +4819,42 @@ func (m *CuUeF1ApID) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { return b[:n], nil } } -func (m *CuUeF1ApID) XXX_Merge(src proto.Message) { - xxx_messageInfo_CuUeF1ApID.Merge(m, src) +func (m *CCCPolicyStyle) XXX_Merge(src proto.Message) { + xxx_messageInfo_CCCPolicyStyle.Merge(m, src) } -func (m *CuUeF1ApID) XXX_Size() int { +func (m *CCCPolicyStyle) XXX_Size() int { return m.Size() } -func (m *CuUeF1ApID) XXX_DiscardUnknown() { - xxx_messageInfo_CuUeF1ApID.DiscardUnknown(m) +func (m *CCCPolicyStyle) XXX_DiscardUnknown() { + xxx_messageInfo_CCCPolicyStyle.DiscardUnknown(m) } -var xxx_messageInfo_CuUeF1ApID proto.InternalMessageInfo +var xxx_messageInfo_CCCPolicyStyle proto.InternalMessageInfo -func (m *CuUeF1ApID) GetValue() int64 { +func (m *CCCPolicyStyle) GetValue() *types.Empty { if m != nil { return m.Value } - return 0 + return nil } -type RanUeNgapID struct { - Value int64 `protobuf:"varint,1,opt,name=value,proto3" json:"value,omitempty"` +// range of Integer from e2sm_common_ies.asn1:444 +type Plmnidentity struct { + Value []byte `protobuf:"bytes,1,opt,name=value,proto3" json:"value,omitempty"` } -func (m *RanUeNgapID) Reset() { *m = RanUeNgapID{} } -func (m *RanUeNgapID) String() string { return proto.CompactTextString(m) } -func (*RanUeNgapID) ProtoMessage() {} -func (*RanUeNgapID) Descriptor() ([]byte, []int) { - return fileDescriptor_23cc5f935e05bbb6, []int{65} +func (m *Plmnidentity) Reset() { *m = Plmnidentity{} } +func (m *Plmnidentity) String() string { return proto.CompactTextString(m) } +func (*Plmnidentity) ProtoMessage() {} +func (*Plmnidentity) Descriptor() ([]byte, []int) { + return fileDescriptor_23cc5f935e05bbb6, []int{66} } -func (m *RanUeNgapID) XXX_Unmarshal(b []byte) error { +func (m *Plmnidentity) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } -func (m *RanUeNgapID) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { +func (m *Plmnidentity) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { - return xxx_messageInfo_RanUeNgapID.Marshal(b, m, deterministic) + return xxx_messageInfo_Plmnidentity.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) @@ -4662,41 +4864,42 @@ func (m *RanUeNgapID) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) return b[:n], nil } } -func (m *RanUeNgapID) XXX_Merge(src proto.Message) { - xxx_messageInfo_RanUeNgapID.Merge(m, src) +func (m *Plmnidentity) XXX_Merge(src proto.Message) { + xxx_messageInfo_Plmnidentity.Merge(m, src) } -func (m *RanUeNgapID) XXX_Size() int { +func (m *Plmnidentity) XXX_Size() int { return m.Size() } -func (m *RanUeNgapID) XXX_DiscardUnknown() { - xxx_messageInfo_RanUeNgapID.DiscardUnknown(m) +func (m *Plmnidentity) XXX_DiscardUnknown() { + xxx_messageInfo_Plmnidentity.DiscardUnknown(m) } -var xxx_messageInfo_RanUeNgapID proto.InternalMessageInfo +var xxx_messageInfo_Plmnidentity proto.InternalMessageInfo -func (m *RanUeNgapID) GetValue() int64 { +func (m *Plmnidentity) GetValue() []byte { if m != nil { return m.Value } - return 0 + return nil } -type EnbUeS1ApID struct { - Value int32 `protobuf:"varint,1,opt,name=value,proto3" json:"value,omitempty"` +// range of Integer from e2sm_common_ies.asn1:460 +type Sst struct { + Value []byte `protobuf:"bytes,1,opt,name=value,proto3" json:"value,omitempty"` } -func (m *EnbUeS1ApID) Reset() { *m = EnbUeS1ApID{} } -func (m *EnbUeS1ApID) String() string { return proto.CompactTextString(m) } -func (*EnbUeS1ApID) ProtoMessage() {} -func (*EnbUeS1ApID) Descriptor() ([]byte, []int) { - return fileDescriptor_23cc5f935e05bbb6, []int{66} +func (m *Sst) Reset() { *m = Sst{} } +func (m *Sst) String() string { return proto.CompactTextString(m) } +func (*Sst) ProtoMessage() {} +func (*Sst) Descriptor() ([]byte, []int) { + return fileDescriptor_23cc5f935e05bbb6, []int{67} } -func (m *EnbUeS1ApID) XXX_Unmarshal(b []byte) error { +func (m *Sst) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } -func (m *EnbUeS1ApID) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { +func (m *Sst) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { - return xxx_messageInfo_EnbUeS1ApID.Marshal(b, m, deterministic) + return xxx_messageInfo_Sst.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) @@ -4706,41 +4909,42 @@ func (m *EnbUeS1ApID) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) return b[:n], nil } } -func (m *EnbUeS1ApID) XXX_Merge(src proto.Message) { - xxx_messageInfo_EnbUeS1ApID.Merge(m, src) +func (m *Sst) XXX_Merge(src proto.Message) { + xxx_messageInfo_Sst.Merge(m, src) } -func (m *EnbUeS1ApID) XXX_Size() int { +func (m *Sst) XXX_Size() int { return m.Size() } -func (m *EnbUeS1ApID) XXX_DiscardUnknown() { - xxx_messageInfo_EnbUeS1ApID.DiscardUnknown(m) +func (m *Sst) XXX_DiscardUnknown() { + xxx_messageInfo_Sst.DiscardUnknown(m) } -var xxx_messageInfo_EnbUeS1ApID proto.InternalMessageInfo +var xxx_messageInfo_Sst proto.InternalMessageInfo -func (m *EnbUeS1ApID) GetValue() int32 { +func (m *Sst) GetValue() []byte { if m != nil { return m.Value } - return 0 + return nil } -type AmfUeNgapID struct { - Value int64 `protobuf:"varint,1,opt,name=value,proto3" json:"value,omitempty"` +// range of Integer from e2sm_common_ies.asn1:450 +type Sd struct { + Value []byte `protobuf:"bytes,1,opt,name=value,proto3" json:"value,omitempty"` } -func (m *AmfUeNgapID) Reset() { *m = AmfUeNgapID{} } -func (m *AmfUeNgapID) String() string { return proto.CompactTextString(m) } -func (*AmfUeNgapID) ProtoMessage() {} -func (*AmfUeNgapID) Descriptor() ([]byte, []int) { - return fileDescriptor_23cc5f935e05bbb6, []int{67} +func (m *Sd) Reset() { *m = Sd{} } +func (m *Sd) String() string { return proto.CompactTextString(m) } +func (*Sd) ProtoMessage() {} +func (*Sd) Descriptor() ([]byte, []int) { + return fileDescriptor_23cc5f935e05bbb6, []int{68} } -func (m *AmfUeNgapID) XXX_Unmarshal(b []byte) error { +func (m *Sd) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } -func (m *AmfUeNgapID) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { +func (m *Sd) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { - return xxx_messageInfo_AmfUeNgapID.Marshal(b, m, deterministic) + return xxx_messageInfo_Sd.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) @@ -4750,47 +4954,43 @@ func (m *AmfUeNgapID) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) return b[:n], nil } } -func (m *AmfUeNgapID) XXX_Merge(src proto.Message) { - xxx_messageInfo_AmfUeNgapID.Merge(m, src) +func (m *Sd) XXX_Merge(src proto.Message) { + xxx_messageInfo_Sd.Merge(m, src) } -func (m *AmfUeNgapID) XXX_Size() int { +func (m *Sd) XXX_Size() int { return m.Size() } -func (m *AmfUeNgapID) XXX_DiscardUnknown() { - xxx_messageInfo_AmfUeNgapID.DiscardUnknown(m) +func (m *Sd) XXX_DiscardUnknown() { + xxx_messageInfo_Sd.DiscardUnknown(m) } -var xxx_messageInfo_AmfUeNgapID proto.InternalMessageInfo +var xxx_messageInfo_Sd proto.InternalMessageInfo -func (m *AmfUeNgapID) GetValue() int64 { +func (m *Sd) GetValue() []byte { if m != nil { return m.Value } - return 0 + return nil } -type UeIdentity struct { - DuUeF1apID *DuUeF1ApID `protobuf:"bytes,1,opt,name=du_ue_f1ap_id,json=duUeF1apId,proto3" json:"du_ue_f1ap_id,omitempty"` - CuUeF1apID *CuUeF1ApID `protobuf:"bytes,2,opt,name=cu_ue_f1ap_id,json=cuUeF1apId,proto3" json:"cu_ue_f1ap_id,omitempty"` - RANUeNgapID *RanUeNgapID `protobuf:"bytes,3,opt,name=ran_ue_ngap_id,json=ranUeNgapId,proto3" json:"ran_ue_ngap_id,omitempty"` - EnbUeS1apID *EnbUeS1ApID `protobuf:"bytes,4,opt,name=enb_ue_s1ap_id,json=enbUeS1apId,proto3" json:"enb_ue_s1ap_id,omitempty"` - AMFUeNgapID *AmfUeNgapID `protobuf:"bytes,5,opt,name=amf_ue_ngap_id,json=amfUeNgapId,proto3" json:"amf_ue_ngap_id,omitempty"` - PreferredIDType UeIdType `protobuf:"varint,6,opt,name=preferred_id_type,json=preferredIdType,proto3,enum=onos.topo.UeIdType" json:"preferred_id_type,omitempty"` - DrbId *DrbId `protobuf:"bytes,7,opt,name=drb_id,json=drbId,proto3" json:"drb_id,omitempty"` +// sequence from e2sm_common_ies.asn1:454 +type SNSsai struct { + Sst *Sst `protobuf:"bytes,1,opt,name=sst,proto3" json:"sst,omitempty"` + Sd *Sd `protobuf:"bytes,2,opt,name=sd,proto3" json:"sd,omitempty"` } -func (m *UeIdentity) Reset() { *m = UeIdentity{} } -func (m *UeIdentity) String() string { return proto.CompactTextString(m) } -func (*UeIdentity) ProtoMessage() {} -func (*UeIdentity) Descriptor() ([]byte, []int) { - return fileDescriptor_23cc5f935e05bbb6, []int{68} +func (m *SNSsai) Reset() { *m = SNSsai{} } +func (m *SNSsai) String() string { return proto.CompactTextString(m) } +func (*SNSsai) ProtoMessage() {} +func (*SNSsai) Descriptor() ([]byte, []int) { + return fileDescriptor_23cc5f935e05bbb6, []int{69} } -func (m *UeIdentity) XXX_Unmarshal(b []byte) error { +func (m *SNSsai) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } -func (m *UeIdentity) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { +func (m *SNSsai) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { - return xxx_messageInfo_UeIdentity.Marshal(b, m, deterministic) + return xxx_messageInfo_SNSsai.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) @@ -4800,87 +5000,153 @@ func (m *UeIdentity) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { return b[:n], nil } } -func (m *UeIdentity) XXX_Merge(src proto.Message) { - xxx_messageInfo_UeIdentity.Merge(m, src) +func (m *SNSsai) XXX_Merge(src proto.Message) { + xxx_messageInfo_SNSsai.Merge(m, src) } -func (m *UeIdentity) XXX_Size() int { +func (m *SNSsai) XXX_Size() int { return m.Size() } -func (m *UeIdentity) XXX_DiscardUnknown() { - xxx_messageInfo_UeIdentity.DiscardUnknown(m) +func (m *SNSsai) XXX_DiscardUnknown() { + xxx_messageInfo_SNSsai.DiscardUnknown(m) } -var xxx_messageInfo_UeIdentity proto.InternalMessageInfo +var xxx_messageInfo_SNSsai proto.InternalMessageInfo -func (m *UeIdentity) GetDuUeF1apID() *DuUeF1ApID { +func (m *SNSsai) GetSst() *Sst { if m != nil { - return m.DuUeF1apID + return m.Sst } return nil } -func (m *UeIdentity) GetCuUeF1apID() *CuUeF1ApID { +func (m *SNSsai) GetSd() *Sd { if m != nil { - return m.CuUeF1apID + return m.Sd } return nil } -func (m *UeIdentity) GetRANUeNgapID() *RanUeNgapID { - if m != nil { - return m.RANUeNgapID +// sequence from e2sm_ccc.asn1:161 +type RrmPolicyMember struct { + PlmnId *Plmnidentity `protobuf:"bytes,1,opt,name=plmn_id,json=plmnId,proto3" json:"plmn_id,omitempty"` + Snssai *SNSsai `protobuf:"bytes,2,opt,name=snssai,proto3" json:"snssai,omitempty"` +} + +func (m *RrmPolicyMember) Reset() { *m = RrmPolicyMember{} } +func (m *RrmPolicyMember) String() string { return proto.CompactTextString(m) } +func (*RrmPolicyMember) ProtoMessage() {} +func (*RrmPolicyMember) Descriptor() ([]byte, []int) { + return fileDescriptor_23cc5f935e05bbb6, []int{70} +} +func (m *RrmPolicyMember) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *RrmPolicyMember) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_RrmPolicyMember.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil } - return nil +} +func (m *RrmPolicyMember) XXX_Merge(src proto.Message) { + xxx_messageInfo_RrmPolicyMember.Merge(m, src) +} +func (m *RrmPolicyMember) XXX_Size() int { + return m.Size() +} +func (m *RrmPolicyMember) XXX_DiscardUnknown() { + xxx_messageInfo_RrmPolicyMember.DiscardUnknown(m) } -func (m *UeIdentity) GetEnbUeS1apID() *EnbUeS1ApID { +var xxx_messageInfo_RrmPolicyMember proto.InternalMessageInfo + +func (m *RrmPolicyMember) GetPlmnId() *Plmnidentity { if m != nil { - return m.EnbUeS1apID + return m.PlmnId } return nil } -func (m *UeIdentity) GetAMFUeNgapID() *AmfUeNgapID { +func (m *RrmPolicyMember) GetSnssai() *SNSsai { if m != nil { - return m.AMFUeNgapID + return m.Snssai } return nil } -func (m *UeIdentity) GetPreferredIDType() UeIdType { - if m != nil { - return m.PreferredIDType +// sequence from e2sm_ccc.asn1:167 +type RrmPolicyMemberList struct { + RrmPolicyMember []*RrmPolicyMember `protobuf:"bytes,1,rep,name=rrm_policy_member,json=rrmPolicyMember,proto3" json:"rrm_policy_member,omitempty"` +} + +func (m *RrmPolicyMemberList) Reset() { *m = RrmPolicyMemberList{} } +func (m *RrmPolicyMemberList) String() string { return proto.CompactTextString(m) } +func (*RrmPolicyMemberList) ProtoMessage() {} +func (*RrmPolicyMemberList) Descriptor() ([]byte, []int) { + return fileDescriptor_23cc5f935e05bbb6, []int{71} +} +func (m *RrmPolicyMemberList) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *RrmPolicyMemberList) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_RrmPolicyMemberList.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil } - return UeIdType_UE_ID_TYPE_CU_UE_F1_AP_ID +} +func (m *RrmPolicyMemberList) XXX_Merge(src proto.Message) { + xxx_messageInfo_RrmPolicyMemberList.Merge(m, src) +} +func (m *RrmPolicyMemberList) XXX_Size() int { + return m.Size() +} +func (m *RrmPolicyMemberList) XXX_DiscardUnknown() { + xxx_messageInfo_RrmPolicyMemberList.DiscardUnknown(m) } -func (m *UeIdentity) GetDrbId() *DrbId { +var xxx_messageInfo_RrmPolicyMemberList proto.InternalMessageInfo + +func (m *RrmPolicyMemberList) GetRrmPolicyMember() []*RrmPolicyMember { if m != nil { - return m.DrbId + return m.RrmPolicyMember } return nil } -type DrbId struct { - // Types that are valid to be assigned to DrbId: - // - // *DrbId_FourGdrbId - // *DrbId_FiveGdrbId - DrbId isDrbId_DrbId `protobuf_oneof:"drb_id"` +// sequence from e2sm_ccc.asn1:229 +// {O-RRMPolicyRatio} +type ORRmpolicyRatio struct { + ResourceType ResourceType `protobuf:"varint,1,opt,name=resource_type,json=resourceType,proto3,enum=onos.topo.ResourceType" json:"resource_type,omitempty"` + SchedulerType SchedulerType `protobuf:"varint,2,opt,name=scheduler_type,json=schedulerType,proto3,enum=onos.topo.SchedulerType" json:"scheduler_type,omitempty"` + RrmPolicyMemberList *RrmPolicyMemberList `protobuf:"bytes,3,opt,name=rrm_policy_member_list,json=rrmPolicyMemberList,proto3" json:"rrm_policy_member_list,omitempty"` + RrmPolicyMaxRatio int32 `protobuf:"varint,4,opt,name=rrm_policy_max_ratio,json=rrmPolicyMaxRatio,proto3" json:"rrm_policy_max_ratio,omitempty"` + RrmPolicyMinRatio int32 `protobuf:"varint,5,opt,name=rrm_policy_min_ratio,json=rrmPolicyMinRatio,proto3" json:"rrm_policy_min_ratio,omitempty"` + RrmPolicyDedicatedRatio int32 `protobuf:"varint,6,opt,name=rrm_policy_dedicated_ratio,json=rrmPolicyDedicatedRatio,proto3" json:"rrm_policy_dedicated_ratio,omitempty"` } -func (m *DrbId) Reset() { *m = DrbId{} } -func (m *DrbId) String() string { return proto.CompactTextString(m) } -func (*DrbId) ProtoMessage() {} -func (*DrbId) Descriptor() ([]byte, []int) { - return fileDescriptor_23cc5f935e05bbb6, []int{69} +func (m *ORRmpolicyRatio) Reset() { *m = ORRmpolicyRatio{} } +func (m *ORRmpolicyRatio) String() string { return proto.CompactTextString(m) } +func (*ORRmpolicyRatio) ProtoMessage() {} +func (*ORRmpolicyRatio) Descriptor() ([]byte, []int) { + return fileDescriptor_23cc5f935e05bbb6, []int{72} } -func (m *DrbId) XXX_Unmarshal(b []byte) error { +func (m *ORRmpolicyRatio) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } -func (m *DrbId) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { +func (m *ORRmpolicyRatio) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { - return xxx_messageInfo_DrbId.Marshal(b, m, deterministic) + return xxx_messageInfo_ORRmpolicyRatio.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) @@ -4890,81 +5156,79 @@ func (m *DrbId) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { return b[:n], nil } } -func (m *DrbId) XXX_Merge(src proto.Message) { - xxx_messageInfo_DrbId.Merge(m, src) +func (m *ORRmpolicyRatio) XXX_Merge(src proto.Message) { + xxx_messageInfo_ORRmpolicyRatio.Merge(m, src) } -func (m *DrbId) XXX_Size() int { +func (m *ORRmpolicyRatio) XXX_Size() int { return m.Size() } -func (m *DrbId) XXX_DiscardUnknown() { - xxx_messageInfo_DrbId.DiscardUnknown(m) +func (m *ORRmpolicyRatio) XXX_DiscardUnknown() { + xxx_messageInfo_ORRmpolicyRatio.DiscardUnknown(m) } -var xxx_messageInfo_DrbId proto.InternalMessageInfo +var xxx_messageInfo_ORRmpolicyRatio proto.InternalMessageInfo -type isDrbId_DrbId interface { - isDrbId_DrbId() - MarshalTo([]byte) (int, error) - Size() int +func (m *ORRmpolicyRatio) GetResourceType() ResourceType { + if m != nil { + return m.ResourceType + } + return ResourceType_RESOURCE_TYPE_PRB_UL } -type DrbId_FourGdrbId struct { - FourGdrbId *FourGDrbId `protobuf:"bytes,1,opt,name=four_gdrb_id,json=fourGDrbID,proto3,oneof" json:"four_gdrb_id,omitempty"` -} -type DrbId_FiveGdrbId struct { - FiveGdrbId *FiveGDrbId `protobuf:"bytes,2,opt,name=five_gdrb_id,json=fiveGDrbID,proto3,oneof" json:"five_gdrb_id,omitempty"` +func (m *ORRmpolicyRatio) GetSchedulerType() SchedulerType { + if m != nil { + return m.SchedulerType + } + return SchedulerType_CCC_SCHEDULER_TYPE_ROUND_ROBIN } -func (*DrbId_FourGdrbId) isDrbId_DrbId() {} -func (*DrbId_FiveGdrbId) isDrbId_DrbId() {} - -func (m *DrbId) GetDrbId() isDrbId_DrbId { +func (m *ORRmpolicyRatio) GetRrmPolicyMemberList() *RrmPolicyMemberList { if m != nil { - return m.DrbId + return m.RrmPolicyMemberList } return nil } -func (m *DrbId) GetFourGdrbId() *FourGDrbId { - if x, ok := m.GetDrbId().(*DrbId_FourGdrbId); ok { - return x.FourGdrbId +func (m *ORRmpolicyRatio) GetRrmPolicyMaxRatio() int32 { + if m != nil { + return m.RrmPolicyMaxRatio } - return nil + return 0 } -func (m *DrbId) GetFiveGdrbId() *FiveGDrbId { - if x, ok := m.GetDrbId().(*DrbId_FiveGdrbId); ok { - return x.FiveGdrbId +func (m *ORRmpolicyRatio) GetRrmPolicyMinRatio() int32 { + if m != nil { + return m.RrmPolicyMinRatio } - return nil + return 0 } -// XXX_OneofWrappers is for the internal use of the proto package. -func (*DrbId) XXX_OneofWrappers() []interface{} { - return []interface{}{ - (*DrbId_FourGdrbId)(nil), - (*DrbId_FiveGdrbId)(nil), +func (m *ORRmpolicyRatio) GetRrmPolicyDedicatedRatio() int32 { + if m != nil { + return m.RrmPolicyDedicatedRatio } + return 0 } -type FiveGDrbId struct { - Value int32 `protobuf:"varint,1,opt,name=value,proto3" json:"value,omitempty"` - Qfi *Qfi `protobuf:"bytes,2,opt,name=qfi,proto3" json:"qfi,omitempty"` - FlowsMapToDrb []*QoSflowLevelParameters `protobuf:"bytes,3,rep,name=flows_map_to_drb,json=flowsMapToDrb,proto3" json:"flows_map_to_drb,omitempty"` +type ConfigurationStructure struct { + ChangeType ChangeType `protobuf:"varint,1,opt,name=change_type,json=changeType,proto3,enum=onos.topo.ChangeType" json:"change_type,omitempty"` + ConfigurationName string `protobuf:"bytes,2,opt,name=configuration_name,json=configurationName,proto3" json:"configuration_name,omitempty"` + PolicyRatio *ORRmpolicyRatio `protobuf:"bytes,3,opt,name=policy_ratio,json=policyRatio,proto3" json:"policy_ratio,omitempty"` + OldPolicyRatio *ORRmpolicyRatio `protobuf:"bytes,4,opt,name=old_policy_ratio,json=oldPolicyRatio,proto3" json:"old_policy_ratio,omitempty"` } -func (m *FiveGDrbId) Reset() { *m = FiveGDrbId{} } -func (m *FiveGDrbId) String() string { return proto.CompactTextString(m) } -func (*FiveGDrbId) ProtoMessage() {} -func (*FiveGDrbId) Descriptor() ([]byte, []int) { - return fileDescriptor_23cc5f935e05bbb6, []int{70} +func (m *ConfigurationStructure) Reset() { *m = ConfigurationStructure{} } +func (m *ConfigurationStructure) String() string { return proto.CompactTextString(m) } +func (*ConfigurationStructure) ProtoMessage() {} +func (*ConfigurationStructure) Descriptor() ([]byte, []int) { + return fileDescriptor_23cc5f935e05bbb6, []int{73} } -func (m *FiveGDrbId) XXX_Unmarshal(b []byte) error { +func (m *ConfigurationStructure) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } -func (m *FiveGDrbId) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { +func (m *ConfigurationStructure) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { - return xxx_messageInfo_FiveGDrbId.Marshal(b, m, deterministic) + return xxx_messageInfo_ConfigurationStructure.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) @@ -4974,55 +5238,62 @@ func (m *FiveGDrbId) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { return b[:n], nil } } -func (m *FiveGDrbId) XXX_Merge(src proto.Message) { - xxx_messageInfo_FiveGDrbId.Merge(m, src) +func (m *ConfigurationStructure) XXX_Merge(src proto.Message) { + xxx_messageInfo_ConfigurationStructure.Merge(m, src) } -func (m *FiveGDrbId) XXX_Size() int { +func (m *ConfigurationStructure) XXX_Size() int { return m.Size() } -func (m *FiveGDrbId) XXX_DiscardUnknown() { - xxx_messageInfo_FiveGDrbId.DiscardUnknown(m) +func (m *ConfigurationStructure) XXX_DiscardUnknown() { + xxx_messageInfo_ConfigurationStructure.DiscardUnknown(m) } -var xxx_messageInfo_FiveGDrbId proto.InternalMessageInfo +var xxx_messageInfo_ConfigurationStructure proto.InternalMessageInfo -func (m *FiveGDrbId) GetValue() int32 { +func (m *ConfigurationStructure) GetChangeType() ChangeType { if m != nil { - return m.Value + return m.ChangeType } - return 0 + return ChangeType_CHANGE_TYPE_NONE } -func (m *FiveGDrbId) GetQfi() *Qfi { +func (m *ConfigurationStructure) GetConfigurationName() string { if m != nil { - return m.Qfi + return m.ConfigurationName + } + return "" +} + +func (m *ConfigurationStructure) GetPolicyRatio() *ORRmpolicyRatio { + if m != nil { + return m.PolicyRatio } return nil } -func (m *FiveGDrbId) GetFlowsMapToDrb() []*QoSflowLevelParameters { +func (m *ConfigurationStructure) GetOldPolicyRatio() *ORRmpolicyRatio { if m != nil { - return m.FlowsMapToDrb + return m.OldPolicyRatio } return nil } -type Qfi struct { - Value int32 `protobuf:"varint,1,opt,name=value,proto3" json:"value,omitempty"` +type ConfigurationStructureList struct { + ConfigurationStructure []*ConfigurationStructure `protobuf:"bytes,1,rep,name=configuration_structure,json=configurationStructure,proto3" json:"configuration_structure,omitempty"` } -func (m *Qfi) Reset() { *m = Qfi{} } -func (m *Qfi) String() string { return proto.CompactTextString(m) } -func (*Qfi) ProtoMessage() {} -func (*Qfi) Descriptor() ([]byte, []int) { - return fileDescriptor_23cc5f935e05bbb6, []int{71} +func (m *ConfigurationStructureList) Reset() { *m = ConfigurationStructureList{} } +func (m *ConfigurationStructureList) String() string { return proto.CompactTextString(m) } +func (*ConfigurationStructureList) ProtoMessage() {} +func (*ConfigurationStructureList) Descriptor() ([]byte, []int) { + return fileDescriptor_23cc5f935e05bbb6, []int{74} } -func (m *Qfi) XXX_Unmarshal(b []byte) error { +func (m *ConfigurationStructureList) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } -func (m *Qfi) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { +func (m *ConfigurationStructureList) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { - return xxx_messageInfo_Qfi.Marshal(b, m, deterministic) + return xxx_messageInfo_ConfigurationStructureList.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) @@ -5032,45 +5303,43 @@ func (m *Qfi) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { return b[:n], nil } } -func (m *Qfi) XXX_Merge(src proto.Message) { - xxx_messageInfo_Qfi.Merge(m, src) +func (m *ConfigurationStructureList) XXX_Merge(src proto.Message) { + xxx_messageInfo_ConfigurationStructureList.Merge(m, src) } -func (m *Qfi) XXX_Size() int { +func (m *ConfigurationStructureList) XXX_Size() int { return m.Size() } -func (m *Qfi) XXX_DiscardUnknown() { - xxx_messageInfo_Qfi.DiscardUnknown(m) +func (m *ConfigurationStructureList) XXX_DiscardUnknown() { + xxx_messageInfo_ConfigurationStructureList.DiscardUnknown(m) } -var xxx_messageInfo_Qfi proto.InternalMessageInfo +var xxx_messageInfo_ConfigurationStructureList proto.InternalMessageInfo -func (m *Qfi) GetValue() int32 { +func (m *ConfigurationStructureList) GetConfigurationStructure() []*ConfigurationStructure { if m != nil { - return m.Value + return m.ConfigurationStructure } - return 0 + return nil } -type QoSflowLevelParameters struct { - // Types that are valid to be assigned to QosFlowLevelParameters: - // - // *QoSflowLevelParameters_DynamicFiveQi - // *QoSflowLevelParameters_NonDynamicFiveQi - QosFlowLevelParameters isQoSflowLevelParameters_QosFlowLevelParameters `protobuf_oneof:"qos_flow_level_parameters"` +type KPMReportStyle struct { + Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` + Type int32 `protobuf:"varint,2,opt,name=type,proto3" json:"type,omitempty"` + Measurements []*KPMMeasurement `protobuf:"bytes,3,rep,name=measurements,proto3" json:"measurements,omitempty"` } -func (m *QoSflowLevelParameters) Reset() { *m = QoSflowLevelParameters{} } -func (m *QoSflowLevelParameters) String() string { return proto.CompactTextString(m) } -func (*QoSflowLevelParameters) ProtoMessage() {} -func (*QoSflowLevelParameters) Descriptor() ([]byte, []int) { - return fileDescriptor_23cc5f935e05bbb6, []int{72} +func (m *KPMReportStyle) Reset() { *m = KPMReportStyle{} } +func (m *KPMReportStyle) String() string { return proto.CompactTextString(m) } +func (*KPMReportStyle) ProtoMessage() {} +func (*KPMReportStyle) Descriptor() ([]byte, []int) { + return fileDescriptor_23cc5f935e05bbb6, []int{75} } -func (m *QoSflowLevelParameters) XXX_Unmarshal(b []byte) error { +func (m *KPMReportStyle) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } -func (m *QoSflowLevelParameters) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { +func (m *KPMReportStyle) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { - return xxx_messageInfo_QoSflowLevelParameters.Marshal(b, m, deterministic) + return xxx_messageInfo_KPMReportStyle.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) @@ -5080,81 +5349,56 @@ func (m *QoSflowLevelParameters) XXX_Marshal(b []byte, deterministic bool) ([]by return b[:n], nil } } -func (m *QoSflowLevelParameters) XXX_Merge(src proto.Message) { - xxx_messageInfo_QoSflowLevelParameters.Merge(m, src) +func (m *KPMReportStyle) XXX_Merge(src proto.Message) { + xxx_messageInfo_KPMReportStyle.Merge(m, src) } -func (m *QoSflowLevelParameters) XXX_Size() int { +func (m *KPMReportStyle) XXX_Size() int { return m.Size() } -func (m *QoSflowLevelParameters) XXX_DiscardUnknown() { - xxx_messageInfo_QoSflowLevelParameters.DiscardUnknown(m) +func (m *KPMReportStyle) XXX_DiscardUnknown() { + xxx_messageInfo_KPMReportStyle.DiscardUnknown(m) } -var xxx_messageInfo_QoSflowLevelParameters proto.InternalMessageInfo +var xxx_messageInfo_KPMReportStyle proto.InternalMessageInfo -type isQoSflowLevelParameters_QosFlowLevelParameters interface { - isQoSflowLevelParameters_QosFlowLevelParameters() - MarshalTo([]byte) (int, error) - Size() int -} - -type QoSflowLevelParameters_DynamicFiveQi struct { - DynamicFiveQi *DynamicFiveQi `protobuf:"bytes,1,opt,name=dynamic_five_qi,json=dynamicFiveQi,proto3,oneof" json:"dynamic_five_qi,omitempty"` -} -type QoSflowLevelParameters_NonDynamicFiveQi struct { - NonDynamicFiveQi *NonDynamicFiveQi `protobuf:"bytes,2,opt,name=non_dynamic_five_qi,json=nonDynamicFiveQi,proto3,oneof" json:"non_dynamic_five_qi,omitempty"` -} - -func (*QoSflowLevelParameters_DynamicFiveQi) isQoSflowLevelParameters_QosFlowLevelParameters() {} -func (*QoSflowLevelParameters_NonDynamicFiveQi) isQoSflowLevelParameters_QosFlowLevelParameters() {} - -func (m *QoSflowLevelParameters) GetQosFlowLevelParameters() isQoSflowLevelParameters_QosFlowLevelParameters { +func (m *KPMReportStyle) GetName() string { if m != nil { - return m.QosFlowLevelParameters + return m.Name } - return nil + return "" } -func (m *QoSflowLevelParameters) GetDynamicFiveQi() *DynamicFiveQi { - if x, ok := m.GetQosFlowLevelParameters().(*QoSflowLevelParameters_DynamicFiveQi); ok { - return x.DynamicFiveQi +func (m *KPMReportStyle) GetType() int32 { + if m != nil { + return m.Type } - return nil + return 0 } -func (m *QoSflowLevelParameters) GetNonDynamicFiveQi() *NonDynamicFiveQi { - if x, ok := m.GetQosFlowLevelParameters().(*QoSflowLevelParameters_NonDynamicFiveQi); ok { - return x.NonDynamicFiveQi +func (m *KPMReportStyle) GetMeasurements() []*KPMMeasurement { + if m != nil { + return m.Measurements } return nil } -// XXX_OneofWrappers is for the internal use of the proto package. -func (*QoSflowLevelParameters) XXX_OneofWrappers() []interface{} { - return []interface{}{ - (*QoSflowLevelParameters_DynamicFiveQi)(nil), - (*QoSflowLevelParameters_NonDynamicFiveQi)(nil), - } -} - -type DynamicFiveQi struct { - PriorityLevel int32 `protobuf:"varint,1,opt,name=priority_level,json=priorityLevel,proto3" json:"priority_level,omitempty"` - PacketDelayBudge int32 `protobuf:"varint,2,opt,name=packet_delay_budge,json=packetDelayBudge,proto3" json:"packet_delay_budge,omitempty"` - PacketErrorRate int32 `protobuf:"varint,3,opt,name=packet_error_rate,json=packetErrorRate,proto3" json:"packet_error_rate,omitempty"` +type MHOReportStyle struct { + Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` + Type int32 `protobuf:"varint,2,opt,name=type,proto3" json:"type,omitempty"` } -func (m *DynamicFiveQi) Reset() { *m = DynamicFiveQi{} } -func (m *DynamicFiveQi) String() string { return proto.CompactTextString(m) } -func (*DynamicFiveQi) ProtoMessage() {} -func (*DynamicFiveQi) Descriptor() ([]byte, []int) { - return fileDescriptor_23cc5f935e05bbb6, []int{73} +func (m *MHOReportStyle) Reset() { *m = MHOReportStyle{} } +func (m *MHOReportStyle) String() string { return proto.CompactTextString(m) } +func (*MHOReportStyle) ProtoMessage() {} +func (*MHOReportStyle) Descriptor() ([]byte, []int) { + return fileDescriptor_23cc5f935e05bbb6, []int{76} } -func (m *DynamicFiveQi) XXX_Unmarshal(b []byte) error { +func (m *MHOReportStyle) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } -func (m *DynamicFiveQi) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { +func (m *MHOReportStyle) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { - return xxx_messageInfo_DynamicFiveQi.Marshal(b, m, deterministic) + return xxx_messageInfo_MHOReportStyle.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) @@ -5164,55 +5408,49 @@ func (m *DynamicFiveQi) XXX_Marshal(b []byte, deterministic bool) ([]byte, error return b[:n], nil } } -func (m *DynamicFiveQi) XXX_Merge(src proto.Message) { - xxx_messageInfo_DynamicFiveQi.Merge(m, src) +func (m *MHOReportStyle) XXX_Merge(src proto.Message) { + xxx_messageInfo_MHOReportStyle.Merge(m, src) } -func (m *DynamicFiveQi) XXX_Size() int { +func (m *MHOReportStyle) XXX_Size() int { return m.Size() } -func (m *DynamicFiveQi) XXX_DiscardUnknown() { - xxx_messageInfo_DynamicFiveQi.DiscardUnknown(m) +func (m *MHOReportStyle) XXX_DiscardUnknown() { + xxx_messageInfo_MHOReportStyle.DiscardUnknown(m) } -var xxx_messageInfo_DynamicFiveQi proto.InternalMessageInfo - -func (m *DynamicFiveQi) GetPriorityLevel() int32 { - if m != nil { - return m.PriorityLevel - } - return 0 -} +var xxx_messageInfo_MHOReportStyle proto.InternalMessageInfo -func (m *DynamicFiveQi) GetPacketDelayBudge() int32 { +func (m *MHOReportStyle) GetName() string { if m != nil { - return m.PacketDelayBudge + return m.Name } - return 0 + return "" } -func (m *DynamicFiveQi) GetPacketErrorRate() int32 { +func (m *MHOReportStyle) GetType() int32 { if m != nil { - return m.PacketErrorRate + return m.Type } return 0 } -type NonDynamicFiveQi struct { - FiveQi *FiveQi `protobuf:"bytes,1,opt,name=five_qi,json=fiveQi,proto3" json:"five_qi,omitempty"` +type KPMMeasurement struct { + ID string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` + Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"` } -func (m *NonDynamicFiveQi) Reset() { *m = NonDynamicFiveQi{} } -func (m *NonDynamicFiveQi) String() string { return proto.CompactTextString(m) } -func (*NonDynamicFiveQi) ProtoMessage() {} -func (*NonDynamicFiveQi) Descriptor() ([]byte, []int) { - return fileDescriptor_23cc5f935e05bbb6, []int{74} +func (m *KPMMeasurement) Reset() { *m = KPMMeasurement{} } +func (m *KPMMeasurement) String() string { return proto.CompactTextString(m) } +func (*KPMMeasurement) ProtoMessage() {} +func (*KPMMeasurement) Descriptor() ([]byte, []int) { + return fileDescriptor_23cc5f935e05bbb6, []int{77} } -func (m *NonDynamicFiveQi) XXX_Unmarshal(b []byte) error { +func (m *KPMMeasurement) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } -func (m *NonDynamicFiveQi) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { +func (m *KPMMeasurement) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { - return xxx_messageInfo_NonDynamicFiveQi.Marshal(b, m, deterministic) + return xxx_messageInfo_KPMMeasurement.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) @@ -5222,41 +5460,52 @@ func (m *NonDynamicFiveQi) XXX_Marshal(b []byte, deterministic bool) ([]byte, er return b[:n], nil } } -func (m *NonDynamicFiveQi) XXX_Merge(src proto.Message) { - xxx_messageInfo_NonDynamicFiveQi.Merge(m, src) +func (m *KPMMeasurement) XXX_Merge(src proto.Message) { + xxx_messageInfo_KPMMeasurement.Merge(m, src) } -func (m *NonDynamicFiveQi) XXX_Size() int { +func (m *KPMMeasurement) XXX_Size() int { return m.Size() } -func (m *NonDynamicFiveQi) XXX_DiscardUnknown() { - xxx_messageInfo_NonDynamicFiveQi.DiscardUnknown(m) +func (m *KPMMeasurement) XXX_DiscardUnknown() { + xxx_messageInfo_KPMMeasurement.DiscardUnknown(m) } -var xxx_messageInfo_NonDynamicFiveQi proto.InternalMessageInfo +var xxx_messageInfo_KPMMeasurement proto.InternalMessageInfo -func (m *NonDynamicFiveQi) GetFiveQi() *FiveQi { +func (m *KPMMeasurement) GetID() string { if m != nil { - return m.FiveQi + return m.ID } - return nil + return "" } -type FiveQi struct { - Value int32 `protobuf:"varint,1,opt,name=value,proto3" json:"value,omitempty"` +func (m *KPMMeasurement) GetName() string { + if m != nil { + return m.Name + } + return "" } -func (m *FiveQi) Reset() { *m = FiveQi{} } -func (m *FiveQi) String() string { return proto.CompactTextString(m) } -func (*FiveQi) ProtoMessage() {} -func (*FiveQi) Descriptor() ([]byte, []int) { - return fileDescriptor_23cc5f935e05bbb6, []int{75} +type RSMNodeSlicingCapabilityItem struct { + MaxNumberOfSlicesDl int32 `protobuf:"varint,1,opt,name=max_number_of_slices_dl,json=maxNumberOfSlicesDl,proto3" json:"max_number_of_slices_dl,omitempty"` + MaxNumberOfSlicesUl int32 `protobuf:"varint,2,opt,name=max_number_of_slices_ul,json=maxNumberOfSlicesUl,proto3" json:"max_number_of_slices_ul,omitempty"` + SlicingType RSMSlicingType `protobuf:"varint,3,opt,name=slicing_type,json=slicingType,proto3,enum=onos.topo.RSMSlicingType" json:"slicing_type,omitempty"` + MaxNumberOfUesPerSlice int32 `protobuf:"varint,4,opt,name=max_number_of_ues_per_slice,json=maxNumberOfUesPerSlice,proto3" json:"max_number_of_ues_per_slice,omitempty"` + SupportedConfig []*RSMSupportedSlicingConfigItem `protobuf:"bytes,5,rep,name=supported_config,json=supportedConfig,proto3" json:"supported_config,omitempty"` } -func (m *FiveQi) XXX_Unmarshal(b []byte) error { + +func (m *RSMNodeSlicingCapabilityItem) Reset() { *m = RSMNodeSlicingCapabilityItem{} } +func (m *RSMNodeSlicingCapabilityItem) String() string { return proto.CompactTextString(m) } +func (*RSMNodeSlicingCapabilityItem) ProtoMessage() {} +func (*RSMNodeSlicingCapabilityItem) Descriptor() ([]byte, []int) { + return fileDescriptor_23cc5f935e05bbb6, []int{78} +} +func (m *RSMNodeSlicingCapabilityItem) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } -func (m *FiveQi) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { +func (m *RSMNodeSlicingCapabilityItem) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { - return xxx_messageInfo_FiveQi.Marshal(b, m, deterministic) + return xxx_messageInfo_RSMNodeSlicingCapabilityItem.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) @@ -5266,93 +5515,69 @@ func (m *FiveQi) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { return b[:n], nil } } -func (m *FiveQi) XXX_Merge(src proto.Message) { - xxx_messageInfo_FiveQi.Merge(m, src) +func (m *RSMNodeSlicingCapabilityItem) XXX_Merge(src proto.Message) { + xxx_messageInfo_RSMNodeSlicingCapabilityItem.Merge(m, src) } -func (m *FiveQi) XXX_Size() int { +func (m *RSMNodeSlicingCapabilityItem) XXX_Size() int { return m.Size() } -func (m *FiveQi) XXX_DiscardUnknown() { - xxx_messageInfo_FiveQi.DiscardUnknown(m) +func (m *RSMNodeSlicingCapabilityItem) XXX_DiscardUnknown() { + xxx_messageInfo_RSMNodeSlicingCapabilityItem.DiscardUnknown(m) } -var xxx_messageInfo_FiveQi proto.InternalMessageInfo +var xxx_messageInfo_RSMNodeSlicingCapabilityItem proto.InternalMessageInfo -func (m *FiveQi) GetValue() int32 { +func (m *RSMNodeSlicingCapabilityItem) GetMaxNumberOfSlicesDl() int32 { if m != nil { - return m.Value + return m.MaxNumberOfSlicesDl } return 0 } -type FourGDrbId struct { - Value int32 `protobuf:"varint,1,opt,name=value,proto3" json:"value,omitempty"` - Qci *Qci `protobuf:"bytes,2,opt,name=qci,proto3" json:"qci,omitempty"` +func (m *RSMNodeSlicingCapabilityItem) GetMaxNumberOfSlicesUl() int32 { + if m != nil { + return m.MaxNumberOfSlicesUl + } + return 0 } -func (m *FourGDrbId) Reset() { *m = FourGDrbId{} } -func (m *FourGDrbId) String() string { return proto.CompactTextString(m) } -func (*FourGDrbId) ProtoMessage() {} -func (*FourGDrbId) Descriptor() ([]byte, []int) { - return fileDescriptor_23cc5f935e05bbb6, []int{76} -} -func (m *FourGDrbId) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *FourGDrbId) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_FourGDrbId.Marshal(b, m, deterministic) - } else { - b = b[:cap(b)] - n, err := m.MarshalToSizedBuffer(b) - if err != nil { - return nil, err - } - return b[:n], nil +func (m *RSMNodeSlicingCapabilityItem) GetSlicingType() RSMSlicingType { + if m != nil { + return m.SlicingType } -} -func (m *FourGDrbId) XXX_Merge(src proto.Message) { - xxx_messageInfo_FourGDrbId.Merge(m, src) -} -func (m *FourGDrbId) XXX_Size() int { - return m.Size() -} -func (m *FourGDrbId) XXX_DiscardUnknown() { - xxx_messageInfo_FourGDrbId.DiscardUnknown(m) + return RSMSlicingType_SLICING_TYPE_STATIC } -var xxx_messageInfo_FourGDrbId proto.InternalMessageInfo - -func (m *FourGDrbId) GetValue() int32 { +func (m *RSMNodeSlicingCapabilityItem) GetMaxNumberOfUesPerSlice() int32 { if m != nil { - return m.Value + return m.MaxNumberOfUesPerSlice } return 0 } -func (m *FourGDrbId) GetQci() *Qci { +func (m *RSMNodeSlicingCapabilityItem) GetSupportedConfig() []*RSMSupportedSlicingConfigItem { if m != nil { - return m.Qci + return m.SupportedConfig } return nil } -type Qci struct { - Value int32 `protobuf:"varint,1,opt,name=value,proto3" json:"value,omitempty"` +type RSMSupportedSlicingConfigItem struct { + SlicingConfigType E2SmRsmCommand `protobuf:"varint,1,opt,name=slicing_config_type,json=slicingConfigType,proto3,enum=onos.topo.E2SmRsmCommand" json:"slicing_config_type,omitempty"` } -func (m *Qci) Reset() { *m = Qci{} } -func (m *Qci) String() string { return proto.CompactTextString(m) } -func (*Qci) ProtoMessage() {} -func (*Qci) Descriptor() ([]byte, []int) { - return fileDescriptor_23cc5f935e05bbb6, []int{77} +func (m *RSMSupportedSlicingConfigItem) Reset() { *m = RSMSupportedSlicingConfigItem{} } +func (m *RSMSupportedSlicingConfigItem) String() string { return proto.CompactTextString(m) } +func (*RSMSupportedSlicingConfigItem) ProtoMessage() {} +func (*RSMSupportedSlicingConfigItem) Descriptor() ([]byte, []int) { + return fileDescriptor_23cc5f935e05bbb6, []int{79} } -func (m *Qci) XXX_Unmarshal(b []byte) error { +func (m *RSMSupportedSlicingConfigItem) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } -func (m *Qci) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { +func (m *RSMSupportedSlicingConfigItem) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { - return xxx_messageInfo_Qci.Marshal(b, m, deterministic) + return xxx_messageInfo_RSMSupportedSlicingConfigItem.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) @@ -5362,1819 +5587,1522 @@ func (m *Qci) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { return b[:n], nil } } -func (m *Qci) XXX_Merge(src proto.Message) { - xxx_messageInfo_Qci.Merge(m, src) +func (m *RSMSupportedSlicingConfigItem) XXX_Merge(src proto.Message) { + xxx_messageInfo_RSMSupportedSlicingConfigItem.Merge(m, src) } -func (m *Qci) XXX_Size() int { +func (m *RSMSupportedSlicingConfigItem) XXX_Size() int { return m.Size() } -func (m *Qci) XXX_DiscardUnknown() { - xxx_messageInfo_Qci.DiscardUnknown(m) +func (m *RSMSupportedSlicingConfigItem) XXX_DiscardUnknown() { + xxx_messageInfo_RSMSupportedSlicingConfigItem.DiscardUnknown(m) } -var xxx_messageInfo_Qci proto.InternalMessageInfo +var xxx_messageInfo_RSMSupportedSlicingConfigItem proto.InternalMessageInfo -func (m *Qci) GetValue() int32 { +func (m *RSMSupportedSlicingConfigItem) GetSlicingConfigType() E2SmRsmCommand { if m != nil { - return m.Value + return m.SlicingConfigType } - return 0 + return E2SmRsmCommand_E2_SM_RSM_COMMAND_SLICE_CREATE } -func init() { - proto.RegisterEnum("onos.topo.RANEntityKinds", RANEntityKinds_name, RANEntityKinds_value) - proto.RegisterEnum("onos.topo.RANRelationKinds", RANRelationKinds_name, RANRelationKinds_value) - proto.RegisterEnum("onos.topo.CellGlobalIDType", CellGlobalIDType_name, CellGlobalIDType_value) - proto.RegisterEnum("onos.topo.NodeType", NodeType_name, NodeType_value) - proto.RegisterEnum("onos.topo.ComponentType", ComponentType_name, ComponentType_value) - proto.RegisterEnum("onos.topo.E2SmRsmCommand", E2SmRsmCommand_name, E2SmRsmCommand_value) - proto.RegisterEnum("onos.topo.RSMSlicingType", RSMSlicingType_name, RSMSlicingType_value) - proto.RegisterEnum("onos.topo.RSMSchedulerType", RSMSchedulerType_name, RSMSchedulerType_value) - proto.RegisterEnum("onos.topo.RSMSliceType", RSMSliceType_name, RSMSliceType_value) - proto.RegisterEnum("onos.topo.UeIdType", UeIdType_name, UeIdType_value) - proto.RegisterEnum("onos.topo.NrScs", NrScs_name, NrScs_value) - proto.RegisterEnum("onos.topo.Nrb", Nrb_name, Nrb_value) - proto.RegisterEnum("onos.topo.EnDcSupport", EnDcSupport_name, EnDcSupport_value) - proto.RegisterEnum("onos.topo.Interface_Type", Interface_Type_name, Interface_Type_value) - proto.RegisterType((*Location)(nil), "onos.topo.Location") - proto.RegisterType((*Wgs84Location)(nil), "onos.topo.Wgs84Location") - proto.RegisterType((*CartesianLocation)(nil), "onos.topo.CartesianLocation") - proto.RegisterType((*AzElOrientation)(nil), "onos.topo.AzElOrientation") - proto.RegisterType((*YprOrientation)(nil), "onos.topo.YprOrientation") - proto.RegisterType((*Orientation)(nil), "onos.topo.Orientation") - proto.RegisterType((*Waypoint)(nil), "onos.topo.Waypoint") - proto.RegisterType((*Waypoints)(nil), "onos.topo.Waypoints") - proto.RegisterType((*OrbitData)(nil), "onos.topo.OrbitData") - proto.RegisterType((*Motion)(nil), "onos.topo.Motion") - proto.RegisterType((*Coverage)(nil), "onos.topo.Coverage") - proto.RegisterType((*E2Node)(nil), "onos.topo.E2Node") - proto.RegisterMapType((map[string]*ServiceModelInfo)(nil), "onos.topo.E2Node.ServiceModelsEntry") - proto.RegisterType((*E2NodeConfig)(nil), "onos.topo.E2NodeConfig") - proto.RegisterType((*Lease)(nil), "onos.topo.Lease") - proto.RegisterType((*Interface)(nil), "onos.topo.Interface") - proto.RegisterType((*E2TInfo)(nil), "onos.topo.E2TInfo") - proto.RegisterType((*XAppInfo)(nil), "onos.topo.XAppInfo") - proto.RegisterType((*A1PolicyType)(nil), "onos.topo.A1PolicyType") - proto.RegisterType((*A1TInfo)(nil), "onos.topo.A1TInfo") - proto.RegisterType((*CellGlobalID)(nil), "onos.topo.CellGlobalID") - proto.RegisterType((*NeighborCellID)(nil), "onos.topo.NeighborCellID") - proto.RegisterType((*E2Cell)(nil), "onos.topo.E2Cell") - proto.RegisterMapType((map[string]uint32)(nil), "onos.topo.E2Cell.KpiReportsEntry") - proto.RegisterType((*ConnectivitySupport)(nil), "onos.topo.ConnectivitySupport") - proto.RegisterType((*FDDInfo)(nil), "onos.topo.FDDInfo") - proto.RegisterType((*TDDInfo)(nil), "onos.topo.TDDInfo") - proto.RegisterType((*FrequencyInfo)(nil), "onos.topo.FrequencyInfo") - proto.RegisterType((*TransmissionBandwidth)(nil), "onos.topo.TransmissionBandwidth") - proto.RegisterType((*FrequencyBandList)(nil), "onos.topo.FrequencyBandList") - proto.RegisterType((*FrequencyBandItem)(nil), "onos.topo.FrequencyBandItem") - proto.RegisterType((*GlobalNgRanNodeID)(nil), "onos.topo.GlobalNgRanNodeID") - proto.RegisterType((*GlobalGnbID)(nil), "onos.topo.GlobalGnbID") - proto.RegisterType((*GlobalNgEnbID)(nil), "onos.topo.GlobalNgEnbID") - proto.RegisterType((*TaiSupportList)(nil), "onos.topo.TaiSupportList") - proto.RegisterType((*TaiSupportItem)(nil), "onos.topo.TaiSupportItem") - proto.RegisterType((*XnBroadcastPlmn)(nil), "onos.topo.XnBroadcastPlmn") - proto.RegisterType((*TaiSliceSupportList)(nil), "onos.topo.TaiSliceSupportList") - proto.RegisterType((*SliceSupportItem)(nil), "onos.topo.SliceSupportItem") - proto.RegisterType((*SNssai)(nil), "onos.topo.SNssai") - proto.RegisterType((*AmfRegionInformation)(nil), "onos.topo.AmfRegionInformation") - proto.RegisterType((*GlobalAmfRegionInformationItem)(nil), "onos.topo.GlobalAmfRegionInformationItem") - proto.RegisterType((*NeighborInformationNr)(nil), "onos.topo.NeighborInformationNr") - proto.RegisterType((*ServiceModelInfo)(nil), "onos.topo.ServiceModelInfo") - proto.RegisterType((*RCRanFunction)(nil), "onos.topo.RCRanFunction") - proto.RegisterType((*MHORanFunction)(nil), "onos.topo.MHORanFunction") - proto.RegisterType((*KPMRanFunction)(nil), "onos.topo.KPMRanFunction") - proto.RegisterType((*RSMRanFunction)(nil), "onos.topo.RSMRanFunction") - proto.RegisterType((*RCEventTriggerStyle)(nil), "onos.topo.RCEventTriggerStyle") - proto.RegisterType((*RCReportStyle)(nil), "onos.topo.RCReportStyle") - proto.RegisterType((*RCInsertStyle)(nil), "onos.topo.RCInsertStyle") - proto.RegisterType((*RCPolicyStyle)(nil), "onos.topo.RCPolicyStyle") - proto.RegisterType((*PolicyAction)(nil), "onos.topo.PolicyAction") - proto.RegisterType((*RCControlStyle)(nil), "onos.topo.RCControlStyle") - proto.RegisterType((*ControlAction)(nil), "onos.topo.ControlAction") - proto.RegisterType((*InsertIndication)(nil), "onos.topo.InsertIndication") - proto.RegisterType((*RANParameter)(nil), "onos.topo.RANParameter") - proto.RegisterType((*KPMReportStyle)(nil), "onos.topo.KPMReportStyle") - proto.RegisterType((*MHOReportStyle)(nil), "onos.topo.MHOReportStyle") - proto.RegisterType((*KPMMeasurement)(nil), "onos.topo.KPMMeasurement") - proto.RegisterType((*RSMNodeSlicingCapabilityItem)(nil), "onos.topo.RSMNodeSlicingCapabilityItem") - proto.RegisterType((*RSMSupportedSlicingConfigItem)(nil), "onos.topo.RSMSupportedSlicingConfigItem") - proto.RegisterType((*RSMSliceItemList)(nil), "onos.topo.RSMSliceItemList") - proto.RegisterType((*RSMSlicingItem)(nil), "onos.topo.RSMSlicingItem") - proto.RegisterType((*RSMSliceParameters)(nil), "onos.topo.RSMSliceParameters") - proto.RegisterType((*DuUeF1ApID)(nil), "onos.topo.DuUeF1apID") - proto.RegisterType((*CuUeF1ApID)(nil), "onos.topo.CuUeF1apID") - proto.RegisterType((*RanUeNgapID)(nil), "onos.topo.RanUeNgapID") - proto.RegisterType((*EnbUeS1ApID)(nil), "onos.topo.EnbUeS1apID") - proto.RegisterType((*AmfUeNgapID)(nil), "onos.topo.AmfUeNgapID") - proto.RegisterType((*UeIdentity)(nil), "onos.topo.UeIdentity") - proto.RegisterType((*DrbId)(nil), "onos.topo.DrbId") - proto.RegisterType((*FiveGDrbId)(nil), "onos.topo.FiveGDrbId") - proto.RegisterType((*Qfi)(nil), "onos.topo.Qfi") - proto.RegisterType((*QoSflowLevelParameters)(nil), "onos.topo.QoSflowLevelParameters") - proto.RegisterType((*DynamicFiveQi)(nil), "onos.topo.DynamicFiveQi") - proto.RegisterType((*NonDynamicFiveQi)(nil), "onos.topo.NonDynamicFiveQi") - proto.RegisterType((*FiveQi)(nil), "onos.topo.FiveQi") - proto.RegisterType((*FourGDrbId)(nil), "onos.topo.FourGDrbId") - proto.RegisterType((*Qci)(nil), "onos.topo.Qci") +type RSMSliceItemList struct { + RsmSliceList []*RSMSlicingItem `protobuf:"bytes,1,rep,name=rsm_slice_list,json=rsmSliceList,proto3" json:"rsm_slice_list,omitempty"` } -func init() { proto.RegisterFile("onos/topo/ran.proto", fileDescriptor_23cc5f935e05bbb6) } - -var fileDescriptor_23cc5f935e05bbb6 = []byte{ - // 4812 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x5a, 0x4d, 0x6c, 0x1b, 0x49, - 0x76, 0x56, 0xf3, 0x47, 0x3f, 0x8f, 0x3f, 0x6a, 0x95, 0x64, 0x59, 0xb6, 0x6c, 0xd1, 0xd3, 0xb3, - 0x19, 0x4f, 0x84, 0x59, 0x5b, 0x92, 0x7f, 0xc6, 0x33, 0xf1, 0xfc, 0xf0, 0x4f, 0x16, 0xc7, 0x12, - 0x25, 0x17, 0xa9, 0xf5, 0xcc, 0x26, 0xbb, 0x8d, 0x66, 0x77, 0x91, 0xee, 0x1d, 0xb2, 0x9b, 0xee, - 0x6e, 0xda, 0x96, 0x83, 0x24, 0x58, 0x04, 0x48, 0xb0, 0x87, 0x20, 0x73, 0x4c, 0x2e, 0x39, 0x05, - 0xb9, 0x05, 0xb9, 0xe4, 0x9a, 0x5b, 0x90, 0xec, 0x71, 0x8f, 0x41, 0x02, 0x28, 0x81, 0xe6, 0x9e, - 0x43, 0xb0, 0x87, 0x60, 0x10, 0x04, 0x41, 0xfd, 0x74, 0x77, 0x35, 0x49, 0x79, 0xec, 0x99, 0x60, - 0x4f, 0xac, 0x7a, 0xef, 0x7b, 0xaf, 0x5e, 0xbd, 0x7a, 0xaf, 0xea, 0x55, 0x35, 0x61, 0xd9, 0x75, - 0x5c, 0xff, 0x66, 0xe0, 0x0e, 0xdd, 0x9b, 0x9e, 0xe1, 0xdc, 0x18, 0x7a, 0x6e, 0xe0, 0xa2, 0x05, - 0x4a, 0xbc, 0x41, 0x89, 0x97, 0x2f, 0xf5, 0x5c, 0xb7, 0xd7, 0x27, 0x37, 0x19, 0xa3, 0x33, 0xea, - 0xde, 0x34, 0x9c, 0x13, 0x8e, 0xba, 0xbc, 0xd2, 0x73, 0x7b, 0x2e, 0x6b, 0xde, 0xa4, 0x2d, 0x41, - 0x2d, 0x8d, 0x0b, 0x04, 0xf6, 0x80, 0xf8, 0x81, 0x31, 0x18, 0x72, 0x80, 0xf6, 0xb7, 0x0a, 0xcc, - 0xef, 0xbb, 0xa6, 0x11, 0xd8, 0xae, 0x83, 0x56, 0x20, 0xdd, 0x37, 0x82, 0x35, 0xe5, 0x9a, 0xf2, - 0xae, 0x52, 0x49, 0xad, 0x29, 0x98, 0x76, 0x19, 0xd5, 0xe9, 0xad, 0xa5, 0x24, 0xaa, 0xd3, 0x43, - 0x5b, 0x90, 0x7d, 0xde, 0xf3, 0xef, 0xdd, 0x5e, 0x4b, 0x5f, 0x53, 0xde, 0xcd, 0xed, 0xac, 0xdd, - 0x88, 0xac, 0xbc, 0xf1, 0x98, 0xd2, 0x43, 0xa5, 0x7b, 0x33, 0x98, 0x03, 0xd1, 0x7d, 0x58, 0x30, - 0x0d, 0x2f, 0x20, 0xbe, 0x6d, 0x38, 0x6b, 0x19, 0x26, 0x75, 0x45, 0x92, 0xaa, 0x86, 0x3c, 0x49, - 0x32, 0x16, 0xa8, 0x64, 0x21, 0x4d, 0x5e, 0x04, 0xda, 0x33, 0x28, 0x24, 0xd4, 0xa3, 0xb7, 0x20, - 0xdf, 0x37, 0x02, 0x3b, 0x18, 0x59, 0x44, 0xb7, 0x48, 0x8f, 0x1b, 0x8f, 0x73, 0x21, 0xad, 0x46, - 0x7a, 0xe8, 0x6d, 0x28, 0xf4, 0x5d, 0xa7, 0x17, 0x63, 0xd8, 0x54, 0x70, 0x3e, 0x22, 0x52, 0xd0, - 0x55, 0x00, 0xa3, 0x2f, 0xf4, 0x0c, 0xd8, 0xa4, 0x14, 0xbc, 0x10, 0x52, 0x0e, 0xb4, 0x5d, 0x58, - 0x9a, 0x30, 0x10, 0x2d, 0x42, 0xfa, 0x85, 0x3e, 0x10, 0x43, 0xa6, 0x5e, 0x1c, 0x50, 0xc2, 0x89, - 0x3e, 0x10, 0xfa, 0x53, 0x27, 0x8c, 0xf0, 0x32, 0x52, 0x97, 0x7a, 0x79, 0xa0, 0xbd, 0x84, 0xc5, - 0xf2, 0xcb, 0x7a, 0xff, 0xd0, 0xb3, 0x89, 0x13, 0x70, 0x2d, 0x25, 0xc8, 0x19, 0x2f, 0xed, 0xc1, - 0x28, 0x78, 0x22, 0x4d, 0x00, 0x04, 0x49, 0xd8, 0x4f, 0xfa, 0xe4, 0x19, 0x43, 0xcb, 0xf6, 0x47, - 0x44, 0x0a, 0x7a, 0x0b, 0xf2, 0x9e, 0x1b, 0xc4, 0x18, 0x3e, 0x64, 0x2e, 0xa4, 0xd5, 0x48, 0x4f, - 0x33, 0xa0, 0xf8, 0xc5, 0xd0, 0x93, 0x87, 0xbe, 0x08, 0x73, 0x27, 0xc6, 0x73, 0x69, 0xd8, 0xd9, - 0x13, 0xe3, 0x39, 0xd5, 0xb6, 0x0e, 0x0b, 0x43, 0x3b, 0x30, 0x9f, 0x48, 0xc3, 0xcd, 0x33, 0x02, - 0x65, 0x5e, 0x82, 0x79, 0xcf, 0xed, 0xf7, 0xa5, 0x61, 0xe6, 0x68, 0x9f, 0x0e, 0xf1, 0x07, 0x90, - 0x93, 0xf5, 0x6f, 0x41, 0xc6, 0x78, 0x49, 0xfa, 0x4c, 0x79, 0x6e, 0xe7, 0xb2, 0xb4, 0xda, 0x63, - 0x4e, 0xd8, 0x9b, 0xc1, 0x0c, 0x89, 0x7e, 0x08, 0xe9, 0x93, 0xa1, 0xc7, 0x86, 0xcc, 0xed, 0x5c, - 0x92, 0x04, 0x92, 0x96, 0xef, 0xcd, 0x60, 0x8a, 0xab, 0x14, 0x20, 0xe7, 0xc6, 0x54, 0xed, 0x4b, - 0x98, 0x7f, 0x6c, 0x9c, 0x0c, 0x5d, 0xdb, 0x09, 0xd0, 0x0d, 0xc8, 0xd0, 0x60, 0x8f, 0xc6, 0xe6, - 0x99, 0x70, 0x23, 0xcc, 0x84, 0x1b, 0xed, 0x30, 0x13, 0x30, 0xc3, 0xa1, 0x9b, 0x30, 0xdf, 0x17, - 0x0b, 0x2b, 0x86, 0x5f, 0x96, 0x86, 0x0f, 0xd7, 0x1c, 0x47, 0x20, 0xed, 0x3e, 0x2c, 0x84, 0x83, - 0xf9, 0x54, 0xfa, 0xb9, 0xe8, 0xac, 0x29, 0xd7, 0xd2, 0x63, 0xd2, 0x21, 0x0e, 0x47, 0x20, 0xed, - 0xd7, 0x0a, 0x2c, 0x1c, 0x7a, 0x1d, 0x3b, 0xa8, 0x19, 0x81, 0x41, 0xb3, 0x89, 0x0c, 0x5d, 0xf3, - 0xc9, 0x6b, 0x58, 0xcb, 0x81, 0xe8, 0x3a, 0x2c, 0xda, 0x8e, 0xd9, 0xb7, 0x9d, 0xf1, 0xb0, 0x28, - 0x4a, 0xe4, 0x70, 0xb5, 0x0c, 0xc3, 0x49, 0xac, 0x96, 0x61, 0x30, 0x56, 0x1e, 0x14, 0xc2, 0x32, - 0x51, 0xc1, 0x0a, 0xa1, 0x11, 0x64, 0x78, 0xbd, 0xd1, 0x80, 0x38, 0x01, 0x03, 0x67, 0x79, 0x04, - 0x85, 0x34, 0x2a, 0x40, 0x43, 0xd5, 0x71, 0x07, 0x46, 0xff, 0x84, 0x21, 0x66, 0x45, 0xa8, 0x72, - 0x92, 0x00, 0x0c, 0x88, 0xe1, 0xe8, 0x03, 0x97, 0xf9, 0x71, 0x8e, 0x03, 0x28, 0xe9, 0x80, 0x51, - 0xb4, 0xbf, 0x57, 0x60, 0x96, 0x37, 0xd1, 0x7d, 0x28, 0x76, 0xed, 0x17, 0xc4, 0xd2, 0x23, 0xb7, - 0x2b, 0xe7, 0xba, 0x7d, 0x6f, 0x06, 0x17, 0x18, 0x38, 0xca, 0xbd, 0xdb, 0xb0, 0x10, 0xfa, 0xd2, - 0x17, 0xeb, 0xb5, 0x32, 0xc5, 0xe3, 0x3e, 0xdd, 0x45, 0x22, 0x20, 0x7a, 0x0f, 0xb2, 0x2e, 0x75, - 0xba, 0xd8, 0xb5, 0x64, 0x89, 0x68, 0x31, 0xe8, 0x8e, 0xc5, 0x40, 0x95, 0x79, 0x98, 0xe5, 0x13, - 0xd1, 0x06, 0x30, 0x5f, 0x75, 0x9f, 0x11, 0xcf, 0xe8, 0x11, 0xb4, 0x0a, 0xb3, 0x4f, 0x88, 0xdd, - 0x7b, 0xc2, 0x37, 0xca, 0x2c, 0x16, 0x3d, 0x9a, 0x33, 0x86, 0x67, 0xea, 0xcf, 0x6d, 0x2b, 0x78, - 0xc2, 0x2c, 0xca, 0xe2, 0x79, 0xc3, 0x33, 0x1f, 0xd3, 0x3e, 0x5a, 0x83, 0x39, 0x91, 0xd1, 0x6c, - 0xe8, 0x2c, 0x0e, 0xbb, 0x08, 0xd1, 0x38, 0xed, 0x07, 0x6c, 0x1d, 0xb2, 0x98, 0xb5, 0x99, 0x97, - 0xea, 0x3b, 0x4d, 0xd7, 0x22, 0xe8, 0x21, 0x14, 0x7d, 0xe2, 0x3d, 0xb3, 0x4d, 0xa2, 0x0f, 0x5c, - 0x8b, 0xf4, 0x7d, 0x11, 0x5e, 0x3f, 0x90, 0x4c, 0xe7, 0xd0, 0x1b, 0x2d, 0x8e, 0x3b, 0x60, 0xb0, - 0xba, 0x13, 0x78, 0x27, 0xb8, 0xe0, 0xcb, 0xb4, 0xcb, 0x3f, 0x01, 0x34, 0x09, 0x42, 0x2a, 0xa4, - 0xbf, 0x24, 0x27, 0x6c, 0x36, 0x0b, 0x98, 0x36, 0xd1, 0x36, 0x64, 0x9f, 0x19, 0xfd, 0x11, 0x11, - 0x8e, 0x5d, 0x97, 0xc6, 0x92, 0xe5, 0x1b, 0x4e, 0xd7, 0xc5, 0x1c, 0xf9, 0x61, 0xea, 0x9e, 0xa2, - 0x75, 0x21, 0xcf, 0x4d, 0xa9, 0xba, 0x4e, 0xd7, 0xee, 0xa1, 0xfb, 0x90, 0x33, 0x5d, 0xc7, 0x21, - 0x26, 0xf5, 0x61, 0x68, 0xb8, 0xec, 0xf3, 0x86, 0x13, 0x10, 0xaf, 0x6b, 0x98, 0xa4, 0x92, 0xf9, - 0xe5, 0x69, 0x69, 0x06, 0xcb, 0x70, 0xea, 0xb2, 0x67, 0xc4, 0xf3, 0xc3, 0x7c, 0xcc, 0xe0, 0xb0, - 0xab, 0x35, 0x20, 0xbb, 0x4f, 0x0c, 0x9f, 0xa0, 0x4f, 0x01, 0xc8, 0x8b, 0xa1, 0xed, 0xc9, 0xe1, - 0xf3, 0x8a, 0xdc, 0xa9, 0x64, 0xbe, 0xfa, 0xf7, 0x92, 0x82, 0x25, 0x19, 0xed, 0xbf, 0x14, 0x58, - 0x88, 0xac, 0x40, 0x3f, 0x84, 0x4c, 0x70, 0x32, 0xe4, 0x7b, 0x46, 0x31, 0xb1, 0xfd, 0x44, 0x98, - 0x1b, 0xed, 0x93, 0x21, 0xc1, 0x0c, 0x86, 0x56, 0x21, 0x65, 0x0f, 0x99, 0x71, 0x0b, 0x95, 0xd9, - 0xb3, 0xd3, 0x52, 0xaa, 0x71, 0x84, 0x53, 0xf6, 0x90, 0x2e, 0xe9, 0xd0, 0xf5, 0x78, 0x90, 0x15, - 0x30, 0x6b, 0x6b, 0xbf, 0x50, 0x20, 0x43, 0x45, 0xd1, 0x05, 0x58, 0x6a, 0x34, 0xdb, 0x75, 0xbc, - 0x5b, 0xae, 0xd6, 0xf5, 0xe3, 0xe6, 0xc3, 0xe6, 0xe1, 0xe3, 0xa6, 0x3a, 0x83, 0x96, 0xa0, 0x10, - 0x93, 0xeb, 0x3b, 0x6d, 0x55, 0x49, 0x22, 0xeb, 0x3b, 0xe5, 0xa3, 0xed, 0xad, 0x6d, 0x35, 0x35, - 0x49, 0xde, 0xd9, 0xda, 0x52, 0xd3, 0x49, 0x72, 0x79, 0x5b, 0xff, 0xbc, 0x7c, 0x74, 0xa4, 0x66, - 0x10, 0x82, 0xa2, 0x4c, 0x2e, 0x1f, 0xa9, 0x59, 0xed, 0x13, 0x98, 0xab, 0xef, 0xb4, 0xe9, 0xea, - 0xa1, 0xdb, 0x00, 0x76, 0x38, 0xb5, 0x57, 0xae, 0x10, 0x96, 0x70, 0xda, 0xcf, 0x15, 0x98, 0xff, - 0xbc, 0x3c, 0x1c, 0x7e, 0x77, 0x15, 0xe8, 0x13, 0x58, 0x34, 0xb6, 0xf5, 0xa1, 0xdb, 0xb7, 0xcd, - 0x13, 0x9d, 0x7a, 0x93, 0x66, 0x31, 0x15, 0xbd, 0x28, 0x9f, 0x12, 0xdb, 0x47, 0x0c, 0xc0, 0x7c, - 0x5e, 0x30, 0xa4, 0x9e, 0xaf, 0xfd, 0xa7, 0x02, 0x79, 0x99, 0x8f, 0xde, 0x81, 0x94, 0x6d, 0xf1, - 0x28, 0xae, 0xac, 0xb2, 0xd5, 0xa8, 0x7d, 0x73, 0x5a, 0xca, 0xc7, 0x88, 0x46, 0x0d, 0xa7, 0x6c, - 0x8b, 0x1e, 0x0c, 0x8e, 0x31, 0x20, 0x62, 0xdd, 0x2e, 0x9f, 0x9d, 0x96, 0x32, 0x4d, 0x63, 0x40, - 0xbe, 0x39, 0x2d, 0x15, 0x63, 0x2c, 0xa5, 0x60, 0x86, 0x43, 0x1f, 0xc6, 0x71, 0x98, 0x66, 0x22, - 0xd7, 0xce, 0x4e, 0x4b, 0x73, 0x3f, 0xe2, 0xa4, 0x6f, 0x4e, 0x4b, 0x4b, 0xb1, 0x94, 0x20, 0x46, - 0x91, 0x8a, 0x3e, 0x83, 0x9c, 0x45, 0x7c, 0xd3, 0xb3, 0x87, 0x2c, 0x42, 0x33, 0x4c, 0xfe, 0xdd, - 0xb3, 0xd3, 0x52, 0xae, 0x16, 0x93, 0xbf, 0x39, 0x2d, 0x5d, 0x88, 0x75, 0x48, 0x0c, 0x2c, 0x0b, - 0xd3, 0x55, 0x2b, 0x6f, 0x7f, 0x9f, 0x55, 0x3b, 0x86, 0x7c, 0x95, 0xf4, 0xfb, 0x0f, 0xfa, 0x6e, - 0xc7, 0xe8, 0x37, 0x6a, 0x68, 0x25, 0xcc, 0x72, 0x9e, 0xf9, 0xbc, 0x83, 0x6e, 0x8a, 0x1c, 0x48, - 0xb1, 0x1c, 0x90, 0x53, 0x5f, 0x16, 0x8e, 0xb3, 0x40, 0xfb, 0x13, 0x05, 0x8a, 0x4d, 0xba, 0x05, - 0x76, 0x5c, 0x8f, 0x42, 0x1a, 0x35, 0x74, 0x08, 0x45, 0x93, 0xf4, 0xfb, 0x7a, 0x8f, 0xa1, 0x75, - 0xb1, 0x2c, 0xc9, 0xb5, 0x95, 0xb5, 0x55, 0xd4, 0xb3, 0xd3, 0x52, 0xc2, 0x38, 0x9c, 0x37, 0xe3, - 0x9e, 0x85, 0xde, 0x86, 0xb9, 0x61, 0x7f, 0xe0, 0x50, 0x4d, 0x7c, 0xd9, 0xe0, 0xec, 0xb4, 0x34, - 0x7b, 0xd4, 0x1f, 0x38, 0x8d, 0x1a, 0x9e, 0xa5, 0xac, 0x86, 0xa5, 0xfd, 0xdb, 0x02, 0xdd, 0x35, - 0xa9, 0x16, 0x74, 0x57, 0x18, 0xe0, 0x76, 0x7e, 0x46, 0xcc, 0x40, 0x8f, 0xe2, 0x22, 0x1a, 0xe7, - 0x90, 0x31, 0xc2, 0x71, 0x44, 0xcf, 0x9a, 0x62, 0x78, 0xea, 0xfb, 0x1a, 0x5e, 0x30, 0x9c, 0x80, - 0x38, 0x8e, 0xa1, 0x9b, 0xee, 0xc8, 0x09, 0xf7, 0x84, 0xbc, 0x20, 0x56, 0x29, 0x0d, 0x95, 0x20, - 0x6b, 0x78, 0x5d, 0x93, 0xc7, 0x47, 0xa1, 0xb2, 0x70, 0x76, 0x5a, 0xca, 0x96, 0xf1, 0x6e, 0xb5, - 0x89, 0x39, 0x9d, 0x1e, 0x2d, 0xcc, 0x2c, 0xb6, 0x30, 0x59, 0xb6, 0x5a, 0xf3, 0x94, 0xc0, 0xe2, - 0xfe, 0x12, 0xa4, 0x87, 0xa6, 0xcd, 0x0e, 0xe3, 0x42, 0x65, 0xee, 0xec, 0xb4, 0x94, 0x3e, 0xaa, - 0x36, 0x30, 0xa5, 0x21, 0x0c, 0xb9, 0x2f, 0x87, 0xb6, 0xee, 0x11, 0xba, 0x05, 0xf9, 0x6b, 0x73, - 0x2c, 0x50, 0xde, 0x4a, 0x9c, 0x1c, 0xd4, 0xf6, 0x1b, 0x0f, 0x87, 0x36, 0xe6, 0x18, 0x76, 0x22, - 0x54, 0x8a, 0x67, 0xa7, 0x25, 0x88, 0x89, 0x18, 0xbe, 0x8c, 0xda, 0xe8, 0xc7, 0xb0, 0xe4, 0x88, - 0xd5, 0xd6, 0x99, 0x51, 0xb6, 0xe5, 0xaf, 0xcd, 0x33, 0xcd, 0xf2, 0x86, 0x99, 0x8c, 0x88, 0xca, - 0xf2, 0xd9, 0x69, 0x69, 0x31, 0x49, 0xf3, 0xf1, 0xa2, 0x23, 0x13, 0x2c, 0x1f, 0x5d, 0x86, 0x85, - 0x9e, 0xd3, 0xd1, 0xad, 0x11, 0xf5, 0xfc, 0x02, 0xf3, 0xd4, 0x5c, 0xcf, 0xe9, 0xd4, 0x46, 0x0d, - 0x0b, 0xbd, 0x07, 0xa8, 0x6f, 0x04, 0xc4, 0x0f, 0x74, 0xcf, 0x33, 0xf5, 0x30, 0x23, 0x81, 0x81, - 0x54, 0xce, 0xc1, 0x9e, 0x29, 0x32, 0x90, 0x56, 0xb6, 0x61, 0xc0, 0xe4, 0x18, 0x44, 0x04, 0x09, - 0xad, 0x72, 0xe8, 0x99, 0x48, 0x2c, 0x9d, 0x12, 0xfc, 0xb5, 0xfc, 0xb5, 0xf4, 0xbb, 0x05, 0x9c, - 0xe3, 0x34, 0x1a, 0x50, 0xac, 0x96, 0xeb, 0x5a, 0x96, 0x6e, 0x3b, 0x5d, 0x77, 0xad, 0xc0, 0x96, - 0x1f, 0x49, 0x13, 0xdb, 0xad, 0xd5, 0x68, 0x0e, 0xee, 0xcd, 0xe0, 0xb9, 0xae, 0x65, 0xb1, 0x74, - 0xbc, 0x09, 0xf3, 0x41, 0x28, 0x50, 0x9c, 0x10, 0x68, 0xc7, 0x02, 0x81, 0x10, 0xd8, 0x83, 0x6b, - 0x03, 0x62, 0xf8, 0x23, 0x8f, 0xb0, 0x6a, 0x2b, 0xb0, 0x07, 0xb6, 0xd3, 0xd3, 0x4d, 0x76, 0x6a, - 0x8e, 0xc4, 0x69, 0xb6, 0xc8, 0xcc, 0xde, 0x90, 0x70, 0x6d, 0x06, 0xab, 0xca, 0x28, 0xd4, 0x84, - 0x0b, 0x22, 0x56, 0x9d, 0x9e, 0xee, 0x19, 0x8e, 0xee, 0xb8, 0x16, 0xa1, 0xb3, 0x56, 0x27, 0x2e, - 0x58, 0x3c, 0x26, 0x9b, 0x3d, 0x6c, 0x38, 0xf4, 0x8c, 0x6e, 0xd4, 0xf0, 0x52, 0x6f, 0x8c, 0x64, - 0xa1, 0x2a, 0xa8, 0x81, 0x61, 0xeb, 0xfe, 0x68, 0x48, 0x57, 0x5b, 0xef, 0xdb, 0x7e, 0xb0, 0xb6, - 0x34, 0x51, 0x8c, 0xb7, 0x0d, 0xbb, 0xc5, 0x11, 0xfb, 0xb6, 0x1f, 0xe0, 0x62, 0x90, 0xe8, 0xa3, - 0x63, 0x58, 0x35, 0x06, 0x5d, 0xdd, 0x23, 0x3d, 0x5a, 0x9a, 0x52, 0xb7, 0x78, 0x03, 0x3e, 0x29, - 0xc4, 0x54, 0x95, 0xe4, 0x2d, 0x7e, 0xd0, 0xc5, 0x0c, 0xd7, 0x88, 0x61, 0x78, 0xc5, 0x98, 0x42, - 0x45, 0x8f, 0x60, 0x25, 0xac, 0x0f, 0x9e, 0xd9, 0xc1, 0x49, 0x68, 0xe4, 0xda, 0x32, 0x53, 0xba, - 0x21, 0xa7, 0xa8, 0x04, 0x13, 0x86, 0xe1, 0x65, 0x73, 0x92, 0x88, 0x7e, 0x0c, 0x6b, 0x51, 0x30, - 0x4b, 0x76, 0xea, 0x8e, 0xe7, 0xaf, 0xad, 0xb0, 0x98, 0xbe, 0x36, 0x25, 0xa6, 0x25, 0xa3, 0x9a, - 0x1e, 0x5e, 0x75, 0xa6, 0x91, 0xfd, 0xcb, 0x1f, 0xc1, 0xe2, 0x58, 0x5e, 0x4d, 0xa9, 0xb4, 0x56, - 0xe4, 0x4a, 0xab, 0x20, 0x15, 0x53, 0x95, 0x22, 0xe4, 0x1d, 0x8f, 0xd5, 0x7c, 0xcc, 0x32, 0xed, - 0x11, 0x2c, 0x4f, 0x99, 0x16, 0xfa, 0x10, 0x0a, 0xc4, 0xd1, 0x2d, 0x33, 0xf2, 0x06, 0xaf, 0x5d, - 0x56, 0xe5, 0x24, 0x77, 0x6a, 0x66, 0xe8, 0x85, 0x1c, 0x89, 0x3b, 0xda, 0x3f, 0xa4, 0x60, 0x4e, - 0x84, 0x33, 0xfa, 0x10, 0xf2, 0xa3, 0xbe, 0xde, 0xf5, 0xc8, 0x53, 0x1e, 0xc7, 0xca, 0xc4, 0xb5, - 0x7e, 0xd7, 0x23, 0x4f, 0x47, 0xc4, 0x31, 0x4f, 0x58, 0xd9, 0x07, 0xa3, 0x3e, 0x25, 0x84, 0xb2, - 0x96, 0x2c, 0x9b, 0xfa, 0x36, 0x59, 0x2b, 0x96, 0xfd, 0x3d, 0xb8, 0x34, 0xea, 0xeb, 0x81, 0x67, - 0x38, 0xfe, 0xc0, 0xf6, 0x69, 0xee, 0xea, 0x1d, 0xc3, 0xb1, 0x78, 0x15, 0xcd, 0xab, 0x74, 0x79, - 0x09, 0xda, 0x12, 0xb0, 0x12, 0xe2, 0xf0, 0xc5, 0x51, 0x7f, 0x2a, 0x83, 0x6a, 0xb7, 0xce, 0xd5, - 0x9e, 0x79, 0x5d, 0xed, 0xd6, 0x74, 0xed, 0xda, 0x5f, 0x29, 0x30, 0xd7, 0x8e, 0xfd, 0xe7, 0x78, - 0x6f, 0xe2, 0x3f, 0xc7, 0x8b, 0x7c, 0xf0, 0x18, 0x56, 0xcf, 0x31, 0x31, 0xf5, 0x9a, 0x26, 0x5e, - 0x08, 0xa6, 0x1a, 0xf8, 0x02, 0x0a, 0x89, 0x51, 0xe9, 0x65, 0xd0, 0xf1, 0x74, 0x7e, 0xd8, 0x28, - 0x7c, 0x7f, 0x75, 0xbc, 0x32, 0x3b, 0x63, 0xf6, 0x61, 0xb9, 0x1b, 0x62, 0x99, 0x05, 0x3c, 0xf9, - 0x53, 0x13, 0xfb, 0x48, 0xa4, 0x91, 0x8e, 0xc3, 0xf2, 0x7f, 0xa9, 0x3b, 0x4e, 0xd2, 0x3a, 0x70, - 0x61, 0xfa, 0x8a, 0x5c, 0x87, 0x59, 0xc7, 0xd3, 0x7d, 0xd3, 0x17, 0x81, 0xaa, 0xca, 0xf9, 0xe5, - 0xb5, 0x4c, 0x1f, 0x67, 0x1d, 0xfa, 0x83, 0xae, 0x41, 0xda, 0xf1, 0x3a, 0xa2, 0x0c, 0x29, 0x26, - 0x50, 0x1d, 0x4c, 0x59, 0x9a, 0x09, 0x4b, 0x13, 0xb6, 0xa0, 0x26, 0xac, 0x8c, 0x4d, 0xc3, 0x0e, - 0xc8, 0x20, 0x2c, 0x92, 0xce, 0x9d, 0x47, 0x23, 0x20, 0x03, 0x8c, 0xba, 0xe3, 0x24, 0x5f, 0xfb, - 0x64, 0x6c, 0x10, 0x4a, 0x45, 0x9b, 0xb0, 0x24, 0x16, 0x3b, 0x1e, 0x47, 0xf8, 0x73, 0x91, 0xaf, - 0x6b, 0x84, 0xd7, 0xfe, 0x4e, 0x81, 0xa5, 0x89, 0xad, 0x17, 0xdd, 0x87, 0x82, 0xd8, 0xb7, 0xe9, - 0x81, 0x17, 0x15, 0x48, 0xab, 0x13, 0xfb, 0xf5, 0x03, 0xa7, 0xd3, 0xa8, 0xed, 0xcd, 0xe0, 0x5c, - 0x2f, 0xea, 0xb2, 0x5d, 0x3a, 0xde, 0xf5, 0x09, 0x57, 0x30, 0x99, 0x74, 0xe1, 0xa8, 0x75, 0xa1, - 0xa2, 0xd0, 0x93, 0x08, 0x56, 0xe5, 0xe2, 0x39, 0x47, 0x87, 0xf6, 0xbb, 0x90, 0x93, 0xc6, 0x96, - 0x8f, 0x52, 0x25, 0x71, 0x94, 0x5e, 0x80, 0xd9, 0x5e, 0x3c, 0x76, 0x01, 0x67, 0x7b, 0xcc, 0xb8, - 0x2b, 0x00, 0x9c, 0xac, 0xf7, 0x89, 0x23, 0xea, 0x9d, 0x79, 0xc6, 0xda, 0x27, 0x8e, 0xf6, 0x8f, - 0x0a, 0x14, 0x12, 0x86, 0x9d, 0xaf, 0xff, 0x3a, 0x2c, 0x0e, 0x0c, 0xd3, 0x73, 0xc7, 0x26, 0x59, - 0xd8, 0x9b, 0xc1, 0x79, 0xc6, 0x10, 0x33, 0x41, 0x3b, 0x70, 0xc1, 0x7f, 0x42, 0x8f, 0xab, 0x71, - 0x78, 0x5a, 0xc0, 0x97, 0x18, 0xfb, 0x40, 0x96, 0xd9, 0x82, 0x95, 0xbe, 0xeb, 0xf4, 0x26, 0x44, - 0x32, 0x42, 0x44, 0xa5, 0x5c, 0x59, 0xa2, 0x92, 0x83, 0x85, 0x08, 0xa6, 0x3d, 0x86, 0x62, 0xf2, - 0x10, 0x44, 0x75, 0x58, 0x92, 0x4f, 0x4e, 0x39, 0xea, 0xa6, 0x1f, 0x9d, 0x2c, 0xe4, 0x16, 0x83, - 0x44, 0xdf, 0xd7, 0x7a, 0xb2, 0x62, 0x16, 0x6c, 0x2a, 0xa4, 0x03, 0xc3, 0x14, 0xbe, 0xa1, 0x4d, - 0x54, 0x85, 0xc5, 0x8e, 0xe7, 0x1a, 0x96, 0x69, 0xf8, 0x81, 0x28, 0x63, 0xf8, 0xdd, 0x49, 0x7e, - 0x61, 0xfb, 0xdc, 0xa9, 0x84, 0x18, 0x5a, 0xd6, 0xe0, 0x62, 0x47, 0xee, 0xfa, 0xda, 0x1f, 0xc1, - 0xe2, 0x18, 0xe4, 0xfc, 0x95, 0x68, 0xc1, 0x2a, 0x9b, 0x5b, 0xdf, 0x36, 0x49, 0xb2, 0x36, 0x48, - 0x4d, 0x9c, 0xbd, 0xd4, 0x7a, 0x8a, 0x93, 0x0b, 0x84, 0xe5, 0x60, 0x92, 0xa8, 0x75, 0x60, 0x79, - 0x0a, 0x16, 0x3d, 0x84, 0xe5, 0xe4, 0x38, 0xb2, 0x27, 0x13, 0x2f, 0x11, 0x92, 0x24, 0xf3, 0xe5, - 0x92, 0x3f, 0x46, 0xf1, 0xb5, 0x8f, 0x41, 0x1d, 0x87, 0xa1, 0x4d, 0x98, 0xf3, 0x75, 0xc7, 0xf7, - 0x0d, 0x5b, 0x24, 0xdd, 0x92, 0xac, 0xb4, 0x49, 0x19, 0x78, 0xd6, 0x67, 0xbf, 0xda, 0x26, 0xcc, - 0x72, 0x0a, 0x5d, 0x05, 0xdf, 0x0f, 0xc2, 0x55, 0xf0, 0xfd, 0x00, 0x15, 0x21, 0xe5, 0x87, 0xa1, - 0x9f, 0xf2, 0x2d, 0xed, 0xcf, 0x15, 0x58, 0x99, 0x56, 0xcd, 0xa0, 0xe7, 0xf0, 0xb6, 0x48, 0xb4, - 0xe9, 0x55, 0x51, 0x62, 0x86, 0xbf, 0x3d, 0x91, 0xc0, 0xd3, 0x74, 0xb2, 0xf9, 0x96, 0x7a, 0xaf, - 0xe4, 0xfb, 0xda, 0x4f, 0x60, 0xe3, 0xd5, 0x2a, 0xce, 0x5f, 0x71, 0x0d, 0x0a, 0xb2, 0xb1, 0xe1, - 0x3c, 0x73, 0x71, 0x61, 0x66, 0x69, 0xff, 0x93, 0x82, 0x0b, 0x53, 0x4b, 0x22, 0xea, 0x2c, 0x7a, - 0x25, 0x11, 0xce, 0xa2, 0x37, 0x91, 0x2d, 0xb6, 0xed, 0x9b, 0x3d, 0x7b, 0xca, 0xd3, 0x6e, 0xf2, - 0x5a, 0x40, 0xf7, 0xff, 0x6a, 0xcf, 0x0e, 0xc3, 0x3e, 0x1d, 0x87, 0xbd, 0x5c, 0x97, 0x67, 0xde, - 0xb4, 0x2e, 0xcf, 0xbe, 0x4e, 0x5d, 0x7e, 0x5e, 0x85, 0x39, 0xfb, 0xdd, 0x2b, 0xcc, 0xd7, 0x29, - 0xf5, 0xe7, 0x5e, 0xa7, 0xd4, 0x9f, 0x28, 0x08, 0xff, 0x5a, 0x01, 0x75, 0xfc, 0x35, 0x8e, 0x5e, - 0x06, 0xdd, 0xe8, 0xb6, 0xcb, 0x2e, 0x83, 0x87, 0x8d, 0x1a, 0xa6, 0x34, 0x84, 0xe4, 0x77, 0x0f, - 0xf1, 0xb6, 0xf1, 0x01, 0x14, 0xe8, 0xce, 0xdf, 0x1d, 0x39, 0xe2, 0x8d, 0x2e, 0x2d, 0xde, 0x12, - 0xc6, 0xdf, 0xd0, 0xca, 0xce, 0x09, 0xce, 0x7b, 0x86, 0xb3, 0x1b, 0x22, 0xd1, 0x3b, 0x50, 0x94, - 0xfa, 0x8d, 0x9a, 0xbf, 0x96, 0x61, 0x57, 0xa9, 0x31, 0xaa, 0xf6, 0xdf, 0x29, 0x28, 0xe0, 0x2a, - 0x8e, 0x89, 0xec, 0xd9, 0x2c, 0x34, 0x91, 0x3f, 0x9b, 0xf1, 0x87, 0x99, 0x8f, 0xa0, 0xc0, 0x6f, - 0xaa, 0xba, 0x1f, 0x9c, 0xf4, 0xa3, 0x07, 0x21, 0xf9, 0x48, 0xc3, 0x55, 0x5e, 0x4f, 0xb7, 0x28, - 0x00, 0xe7, 0xbd, 0xb8, 0xe3, 0x53, 0x71, 0xdb, 0xf1, 0x49, 0x2c, 0x9e, 0x9e, 0x22, 0xde, 0x60, - 0x08, 0x21, 0x6e, 0xc7, 0x1d, 0x1f, 0x1d, 0xc1, 0x0a, 0x79, 0xc6, 0x96, 0xc8, 0xb3, 0x7b, 0x3d, - 0xe2, 0x85, 0x5a, 0x32, 0x4c, 0xcb, 0x46, 0x42, 0x4b, 0x9d, 0x02, 0xdb, 0x1c, 0xc7, 0x75, 0x21, - 0x32, 0x4e, 0x62, 0x06, 0x89, 0xf7, 0x2d, 0xa1, 0x2a, 0x3b, 0xc5, 0x20, 0xfe, 0xf0, 0x23, 0x0c, - 0x1a, 0xc6, 0x1d, 0x1f, 0x7d, 0x0a, 0x45, 0xd3, 0x75, 0x02, 0xcf, 0xed, 0x87, 0xf2, 0xb3, 0x13, - 0xa7, 0x09, 0xae, 0x56, 0x39, 0x84, 0x2b, 0x28, 0x98, 0x52, 0xcf, 0xd7, 0x9e, 0x40, 0xf1, 0x60, - 0xef, 0xf0, 0x75, 0x5c, 0xff, 0xf1, 0x74, 0xd7, 0xcb, 0x43, 0x51, 0x4d, 0xe7, 0xf9, 0x9e, 0x8e, - 0xf4, 0xf0, 0xe8, 0xe0, 0xff, 0x69, 0x24, 0xaa, 0xe9, 0xdc, 0x91, 0xfe, 0x52, 0x81, 0x22, 0x6e, - 0xbd, 0xd6, 0x50, 0x2e, 0x5c, 0xf3, 0x6c, 0x93, 0x9d, 0x5a, 0x34, 0xe7, 0x58, 0x79, 0x63, 0x1a, - 0x43, 0xa3, 0x63, 0xf7, 0x69, 0x72, 0x8b, 0xf3, 0x8b, 0x8e, 0x7e, 0x5d, 0x76, 0x69, 0xeb, 0x80, - 0xd6, 0x68, 0x2d, 0x2e, 0x55, 0x8d, 0xf0, 0x6c, 0xcb, 0xbd, 0xe2, 0xd9, 0xa6, 0xe0, 0xb0, 0x77, - 0xee, 0x88, 0xcb, 0x4e, 0xb4, 0x9f, 0xc2, 0xf2, 0x94, 0xd8, 0x88, 0x12, 0x4f, 0x91, 0x12, 0x0f, - 0x49, 0xaf, 0x6c, 0x59, 0xf1, 0x9c, 0x5c, 0x82, 0x1c, 0xdf, 0x44, 0xf9, 0x3b, 0x0f, 0xff, 0x4e, - 0x00, 0x9c, 0xd4, 0x3e, 0x19, 0x12, 0xed, 0x39, 0xcb, 0xa4, 0xd8, 0x1b, 0xaf, 0xad, 0xf9, 0x63, - 0x96, 0xab, 0xfa, 0xd0, 0xf0, 0x8c, 0x01, 0x09, 0x88, 0x17, 0xe6, 0x86, 0xfc, 0xac, 0x85, 0xcb, - 0xcd, 0xa3, 0x90, 0x8f, 0xe9, 0xae, 0x10, 0xf5, 0x7c, 0xed, 0x8f, 0x15, 0x3a, 0xb2, 0x94, 0x3b, - 0xaf, 0x3d, 0xf2, 0x67, 0x80, 0x44, 0x52, 0xda, 0x8e, 0x65, 0xf3, 0x6f, 0x37, 0xe1, 0xe8, 0xeb, - 0x89, 0x17, 0x4b, 0x0a, 0x6a, 0x44, 0x18, 0xbc, 0x64, 0x8f, 0x51, 0x7c, 0x3e, 0x7d, 0x29, 0x5f, - 0xde, 0x64, 0xfa, 0x22, 0x11, 0x8d, 0xc4, 0x36, 0x27, 0x4f, 0x9f, 0xeb, 0x2d, 0x33, 0x3e, 0x16, - 0x79, 0xcb, 0x7b, 0xbe, 0xf6, 0x6b, 0x05, 0xf2, 0x32, 0x5f, 0x8a, 0xb8, 0x6c, 0x22, 0xe2, 0xa6, - 0x6d, 0xb1, 0x9f, 0xc3, 0x95, 0xc4, 0xe0, 0xfa, 0x9b, 0xad, 0xc4, 0x25, 0xd9, 0x14, 0x2c, 0xaf, - 0x0a, 0xfa, 0x29, 0x94, 0x84, 0x66, 0xd3, 0x75, 0x2c, 0x7b, 0x9a, 0xf2, 0xcc, 0xab, 0x95, 0x0b, - 0xcb, 0xaa, 0xa1, 0x78, 0x42, 0xbf, 0xf6, 0x17, 0x29, 0x28, 0x26, 0x37, 0x98, 0xd7, 0xf6, 0xf8, - 0x7b, 0x80, 0x9e, 0x10, 0xc3, 0x22, 0x9e, 0x3e, 0x19, 0xd1, 0x2a, 0xe7, 0xec, 0x46, 0x71, 0x8d, - 0x6e, 0xc0, 0xf2, 0x80, 0xf8, 0xbe, 0xd1, 0x23, 0x09, 0x38, 0xff, 0x22, 0xb6, 0x24, 0x58, 0x12, - 0xfe, 0x23, 0x58, 0x0f, 0x77, 0x46, 0x77, 0x14, 0x98, 0xee, 0x20, 0x29, 0x97, 0x65, 0x72, 0x6b, - 0x02, 0x72, 0xc8, 0x11, 0x92, 0x78, 0x19, 0x16, 0x43, 0xf1, 0x30, 0x1e, 0x66, 0x27, 0x76, 0x66, - 0x31, 0x6d, 0xe1, 0xf7, 0x70, 0x27, 0x0e, 0x23, 0xe2, 0xf7, 0xa1, 0x90, 0x00, 0xbc, 0x51, 0x44, - 0x7c, 0xdf, 0x6c, 0xfc, 0x43, 0x50, 0xc7, 0xd3, 0xe5, 0x37, 0x3a, 0xfe, 0x87, 0x90, 0x97, 0xd9, - 0xd2, 0xd8, 0xe9, 0x6f, 0x1b, 0x5b, 0x7b, 0xce, 0x0f, 0x8a, 0xef, 0xb0, 0x87, 0x7d, 0x04, 0x79, - 0xa9, 0x40, 0x0a, 0x6d, 0x1e, 0x3b, 0x37, 0x0e, 0x62, 0x04, 0x4e, 0xc0, 0xb5, 0x7b, 0xfc, 0x2c, - 0x7c, 0xf3, 0x81, 0xb5, 0xfb, 0xcc, 0x64, 0x49, 0xf3, 0xb9, 0x07, 0xce, 0xb4, 0x09, 0xff, 0x6b, - 0x0a, 0xae, 0xbc, 0xea, 0x48, 0x41, 0xb7, 0xe1, 0xe2, 0xc0, 0x78, 0xa1, 0x3b, 0xa3, 0x41, 0x87, - 0x78, 0xba, 0xdb, 0xe5, 0xb7, 0x2c, 0x5f, 0xb7, 0xfa, 0xe2, 0xfb, 0xf2, 0xf2, 0xc0, 0x78, 0xd1, - 0x64, 0xdc, 0xc3, 0x2e, 0xbb, 0xcc, 0xf8, 0xb5, 0xfe, 0xb9, 0x52, 0xa3, 0xbe, 0xb0, 0x7d, 0x52, - 0xea, 0xb8, 0x8f, 0xee, 0x43, 0x3e, 0x3c, 0x0d, 0xa3, 0x84, 0x4c, 0x7e, 0xe7, 0xc4, 0xad, 0x03, - 0x61, 0x26, 0xfb, 0xc2, 0x93, 0xf3, 0xe3, 0x0e, 0xfa, 0x1d, 0x58, 0x4f, 0x8e, 0x39, 0x22, 0xbe, - 0x3e, 0xa4, 0x95, 0x12, 0xd5, 0x2f, 0xd2, 0x75, 0x55, 0x1a, 0xf7, 0x98, 0xf8, 0x47, 0xc4, 0x63, - 0xa3, 0xa3, 0x16, 0xa8, 0xa2, 0x9a, 0x26, 0x96, 0x28, 0x7f, 0x45, 0x3d, 0xf4, 0xee, 0xd8, 0xf0, - 0x21, 0x2a, 0x74, 0x17, 0xc3, 0xf2, 0xcb, 0x72, 0xa4, 0x81, 0x13, 0xb5, 0x9f, 0xc1, 0xd5, 0x57, - 0x4a, 0xa0, 0x06, 0xbf, 0x4c, 0xc6, 0x25, 0xb7, 0x7e, 0xce, 0xf7, 0xdd, 0xfa, 0x4e, 0x6b, 0x80, - 0xfd, 0x41, 0xd5, 0x1d, 0x0c, 0x0c, 0xc7, 0xe2, 0x57, 0xc9, 0x48, 0x15, 0x3b, 0x7c, 0x5b, 0xa0, - 0x0a, 0xe7, 0x10, 0xaa, 0x9a, 0xdd, 0x55, 0x3f, 0x81, 0xa2, 0xe7, 0x0f, 0xc4, 0xbd, 0x98, 0xd5, - 0x13, 0x93, 0x17, 0xfe, 0xd8, 0xa3, 0x6c, 0x0e, 0x79, 0xcf, 0x1f, 0x30, 0x25, 0xac, 0x62, 0xf8, - 0x5f, 0x5e, 0xcd, 0x48, 0x80, 0x73, 0x83, 0xeb, 0x2a, 0x00, 0x1f, 0xc7, 0x22, 0xbe, 0x29, 0x42, - 0x6c, 0x81, 0x51, 0x6a, 0xc4, 0x37, 0xd1, 0x1e, 0xa8, 0x9c, 0x9d, 0x48, 0x6b, 0x7a, 0x6d, 0xb9, - 0x3a, 0x69, 0x0c, 0x89, 0xb3, 0x19, 0x2f, 0xfa, 0x49, 0x02, 0xba, 0x1b, 0x0e, 0x14, 0x6d, 0xc2, - 0xc5, 0xe4, 0xd6, 0x20, 0x74, 0xb0, 0x00, 0xe1, 0x16, 0xb0, 0xf0, 0xb8, 0x05, 0x30, 0x22, 0xec, - 0xd9, 0x87, 0x3a, 0x82, 0xaf, 0xed, 0x05, 0x49, 0xee, 0x98, 0x34, 0x2c, 0xe2, 0x04, 0x76, 0x70, - 0x82, 0xe7, 0x47, 0xa4, 0xc1, 0xdf, 0x09, 0xff, 0x4c, 0x01, 0x34, 0x69, 0x14, 0xaa, 0x40, 0xd1, - 0x37, 0x9f, 0x10, 0x6b, 0xd4, 0x27, 0x9e, 0xbc, 0x64, 0xeb, 0x63, 0x76, 0x84, 0x18, 0xfe, 0x81, - 0xd8, 0x97, 0xbb, 0x68, 0x15, 0x66, 0x9f, 0xf3, 0xff, 0x69, 0xf0, 0x8c, 0x10, 0x3d, 0xb4, 0x0e, - 0x0b, 0x4f, 0x5d, 0x5f, 0xef, 0x93, 0x67, 0xa4, 0x2f, 0x8e, 0xa4, 0xf9, 0xa7, 0xae, 0xbf, 0x4f, - 0xfb, 0x9a, 0x06, 0x50, 0x1b, 0x1d, 0x93, 0xdd, 0x6d, 0x63, 0x38, 0xfe, 0x85, 0x34, 0x2d, 0x5e, - 0xe7, 0x29, 0xa6, 0xfa, 0x6d, 0x98, 0xb7, 0x21, 0x87, 0x0d, 0xe7, 0x98, 0x34, 0x7b, 0xaf, 0x06, - 0xd5, 0x9d, 0xce, 0x31, 0x69, 0x4d, 0xd1, 0x94, 0x95, 0x40, 0xe5, 0x41, 0xf7, 0x5b, 0x34, 0xfd, - 0x22, 0x03, 0x10, 0xfb, 0x17, 0xed, 0x41, 0xc1, 0x1a, 0xe9, 0x23, 0xa2, 0x77, 0xb7, 0x8d, 0x61, - 0xfc, 0xba, 0x28, 0xaf, 0x46, 0x3c, 0x4b, 0xfe, 0xb5, 0x2f, 0xee, 0x63, 0xb0, 0xc2, 0xb6, 0x45, - 0x35, 0x99, 0x09, 0x4d, 0xa9, 0x09, 0x4d, 0xd5, 0x31, 0x4d, 0x55, 0x49, 0x93, 0x19, 0x6b, 0xda, - 0xe7, 0xa7, 0xce, 0x88, 0xe8, 0x4e, 0x8f, 0xab, 0x4a, 0x4f, 0x3c, 0x79, 0x4a, 0x2e, 0xab, 0x2c, - 0x9e, 0x9d, 0x96, 0x72, 0xb8, 0xdc, 0x0c, 0x09, 0x38, 0xe7, 0x45, 0x5c, 0xa6, 0x8d, 0x38, 0x1d, - 0xaa, 0xcd, 0x17, 0x86, 0x65, 0x26, 0xb4, 0x49, 0xbe, 0xe5, 0xda, 0x24, 0x02, 0xce, 0x91, 0xa8, - 0xc3, 0xb4, 0x19, 0x83, 0xae, 0x6c, 0x5b, 0x76, 0x42, 0x9b, 0xb4, 0x08, 0x5c, 0x5b, 0xf9, 0x60, - 0x37, 0xb6, 0xcd, 0x88, 0xb8, 0x16, 0x6a, 0xc3, 0xd2, 0xd0, 0x23, 0x5d, 0xe2, 0x79, 0xc4, 0xa2, - 0xf9, 0xc0, 0xe2, 0x77, 0x96, 0xc5, 0xef, 0xf2, 0x58, 0x3e, 0xd0, 0x40, 0xe5, 0xdf, 0x46, 0x8f, - 0x42, 0x09, 0xf1, 0x6d, 0x7d, 0x31, 0x52, 0xc1, 0x51, 0xe8, 0x3a, 0xcc, 0x5a, 0x1e, 0x7b, 0xa2, - 0x9c, 0x63, 0xb6, 0xc9, 0x0f, 0xe7, 0x35, 0xaf, 0xd3, 0xb0, 0x70, 0xd6, 0xa2, 0x3f, 0xda, 0x9f, - 0x2a, 0x90, 0x65, 0x04, 0xf4, 0x01, 0xe4, 0xbb, 0xee, 0xc8, 0xd3, 0x7b, 0x42, 0x70, 0x32, 0x0a, - 0x76, 0xdd, 0x91, 0xf7, 0x80, 0x81, 0xf7, 0x66, 0xe8, 0x55, 0x43, 0xf4, 0x6a, 0x4c, 0xd4, 0x7e, - 0x46, 0x22, 0xd1, 0xc9, 0x65, 0xdf, 0xb5, 0x9f, 0x11, 0x49, 0x34, 0xec, 0xd5, 0x2a, 0xf3, 0xa1, - 0xa1, 0xda, 0x57, 0x0a, 0x40, 0x0c, 0x9b, 0x1e, 0xdf, 0xe8, 0x1a, 0xa4, 0x9f, 0x76, 0xc3, 0x67, - 0x21, 0xf9, 0x9d, 0xff, 0x51, 0xd7, 0xc6, 0x94, 0x85, 0x3e, 0x03, 0xb5, 0xdb, 0x77, 0x9f, 0xfb, - 0xfa, 0xc0, 0x18, 0xea, 0x81, 0xab, 0x5b, 0x5e, 0x47, 0x9c, 0xfe, 0xf2, 0xa7, 0xec, 0x47, 0x6e, - 0x8b, 0xa2, 0x58, 0x1a, 0x4b, 0xdb, 0x5b, 0x81, 0x89, 0x1e, 0x18, 0xc3, 0xb6, 0x5b, 0xf3, 0x3a, - 0xda, 0x3a, 0xa4, 0x1f, 0x75, 0xed, 0x73, 0x52, 0xed, 0x9f, 0x15, 0x58, 0x9d, 0xae, 0x06, 0x55, - 0x60, 0xd1, 0x3a, 0x71, 0x8c, 0x81, 0x6d, 0xea, 0xcc, 0x2f, 0x4f, 0xed, 0x29, 0x5f, 0x78, 0x6a, - 0x1c, 0x41, 0xa7, 0xfc, 0xc8, 0xde, 0x9b, 0xc1, 0x05, 0x4b, 0x26, 0xa0, 0x7d, 0x58, 0x76, 0x5c, - 0x47, 0x1f, 0xd7, 0x33, 0xf9, 0x1f, 0xab, 0xa6, 0xeb, 0x8c, 0xab, 0x52, 0x9d, 0x31, 0x5a, 0x65, - 0x1d, 0x2e, 0xd1, 0x6d, 0x8c, 0x1a, 0xcb, 0xf7, 0x32, 0x69, 0xe7, 0xa7, 0x9e, 0x2f, 0x24, 0xe0, - 0xe8, 0xb7, 0xa0, 0x38, 0xf4, 0x6c, 0xd7, 0x63, 0x37, 0x5f, 0xb6, 0xf5, 0xf1, 0xa9, 0x17, 0x42, - 0x2a, 0x9b, 0x31, 0x2d, 0xdc, 0x87, 0x86, 0xf9, 0x25, 0x09, 0x74, 0x8b, 0xf4, 0x8d, 0x13, 0xbd, - 0x33, 0xb2, 0x7a, 0x61, 0x39, 0xa4, 0x72, 0x4e, 0x8d, 0x32, 0x2a, 0x94, 0x8e, 0x36, 0x61, 0x49, - 0xa0, 0x89, 0xe7, 0xb9, 0x9e, 0xee, 0x19, 0x41, 0x58, 0xe5, 0x2f, 0x72, 0x46, 0x9d, 0xd2, 0xb1, - 0x11, 0x10, 0xed, 0x63, 0x50, 0xc7, 0xe7, 0x85, 0x36, 0x61, 0x2e, 0xe9, 0xcd, 0xa5, 0xb1, 0x00, - 0x7b, 0x64, 0xe3, 0xd9, 0x2e, 0xfb, 0xd5, 0x36, 0x60, 0x56, 0x48, 0x4d, 0x5f, 0xbc, 0x1a, 0x40, - 0x1c, 0xcd, 0xaf, 0x88, 0x35, 0x73, 0x6a, 0xac, 0x99, 0x34, 0xd6, 0x4c, 0x9b, 0xc5, 0x87, 0x79, - 0xce, 0x10, 0x9b, 0x35, 0x28, 0xe2, 0x72, 0xb3, 0xce, 0xf6, 0xd8, 0x87, 0xb6, 0x63, 0xf9, 0x08, - 0xd8, 0xff, 0xf4, 0x0e, 0x6b, 0x75, 0x75, 0x86, 0xb7, 0xab, 0xf5, 0xfd, 0x7d, 0x55, 0x41, 0x73, - 0x90, 0xae, 0xef, 0xb4, 0xd5, 0x34, 0x9a, 0x87, 0x8c, 0xf8, 0x23, 0xd6, 0x1c, 0xa4, 0xcb, 0xdb, - 0x6d, 0x35, 0xbb, 0xf9, 0x11, 0xa8, 0xb8, 0xdc, 0xc4, 0xa4, 0xcf, 0x2a, 0x77, 0xae, 0x27, 0x0f, - 0xf3, 0xd5, 0xc3, 0x66, 0x1b, 0x1f, 0xee, 0xb7, 0xd4, 0x99, 0xb0, 0x57, 0x6e, 0x34, 0x5b, 0xaa, - 0x82, 0x0a, 0xb0, 0xd0, 0xac, 0x37, 0x1e, 0xec, 0x55, 0x0e, 0x71, 0x4b, 0x4d, 0x6d, 0x5e, 0x07, - 0x75, 0xfc, 0x8f, 0x38, 0x68, 0x01, 0xb2, 0x4d, 0x5c, 0x7d, 0xd0, 0x50, 0x67, 0xe8, 0x80, 0x75, - 0xda, 0x52, 0x36, 0x0f, 0x60, 0x9e, 0x56, 0x9d, 0x0c, 0x90, 0x83, 0xb9, 0x66, 0x5b, 0x6f, 0x1e, - 0x36, 0x85, 0xa1, 0xcd, 0xb6, 0xfe, 0xa0, 0x59, 0x11, 0xca, 0xdb, 0x7a, 0xbd, 0xc9, 0xba, 0x29, - 0xd1, 0x6d, 0x3e, 0xd0, 0xeb, 0xcd, 0x8a, 0x9a, 0x16, 0x48, 0xda, 0xce, 0x6c, 0xee, 0xd3, 0x2b, - 0xcf, 0x60, 0xe8, 0x3a, 0xc4, 0x09, 0x42, 0x9d, 0xd5, 0x48, 0xe7, 0x02, 0x64, 0xab, 0x6d, 0xbd, - 0x7a, 0xac, 0x2a, 0xcc, 0x7a, 0xda, 0xd4, 0x8f, 0x8f, 0xd4, 0x94, 0x60, 0xd4, 0x8e, 0xb9, 0xb6, - 0x6a, 0xa8, 0xed, 0x9f, 0x14, 0x28, 0x26, 0x6b, 0x2e, 0xa4, 0xc1, 0x46, 0x7d, 0x47, 0x6f, 0x1d, - 0xe8, 0xb8, 0x75, 0xa0, 0x57, 0x0f, 0x0f, 0x0e, 0xca, 0xcd, 0x9a, 0xde, 0xda, 0x6f, 0x54, 0xeb, - 0x7a, 0x15, 0xd7, 0xcb, 0x6d, 0x3a, 0xcc, 0x2b, 0x30, 0xc7, 0x47, 0x35, 0x8a, 0x51, 0x5e, 0x85, - 0xa9, 0xd5, 0xf7, 0xeb, 0xed, 0xba, 0x9a, 0x9a, 0x8e, 0x39, 0xae, 0xeb, 0xe5, 0x56, 0xeb, 0xb0, - 0xda, 0xa0, 0x7a, 0xd2, 0xe8, 0x07, 0x70, 0x6d, 0x12, 0x53, 0xff, 0x51, 0xbd, 0xd9, 0xd6, 0xdb, - 0xb8, 0xf1, 0xe0, 0x41, 0x1d, 0xb7, 0xd4, 0xcc, 0x66, 0x55, 0x2e, 0xe0, 0x98, 0x5f, 0x2e, 0xc2, - 0x32, 0x1d, 0xad, 0xd1, 0x7c, 0xa0, 0xb7, 0xbf, 0x38, 0xaa, 0xeb, 0xad, 0x76, 0xb9, 0xdd, 0xa8, - 0xaa, 0x33, 0x68, 0x0d, 0x56, 0x12, 0x8c, 0xda, 0x17, 0xcd, 0xf2, 0x41, 0xa3, 0xaa, 0x2a, 0x9b, - 0x2f, 0x78, 0x6d, 0x99, 0x28, 0x5f, 0x36, 0xe0, 0x72, 0xab, 0xba, 0x57, 0xaf, 0x1d, 0xef, 0xd7, - 0x31, 0xc7, 0xe3, 0xc3, 0xe3, 0x66, 0x4d, 0xc7, 0x87, 0x95, 0x46, 0x53, 0x9d, 0x41, 0xef, 0x80, - 0x36, 0xc6, 0x3f, 0xc2, 0x87, 0x47, 0x87, 0xb8, 0xdd, 0x38, 0x6c, 0x96, 0xf7, 0xf7, 0xbf, 0xd0, - 0x77, 0xcb, 0x0d, 0xac, 0x2a, 0xe8, 0x0a, 0xac, 0x8d, 0xe1, 0x1e, 0x1d, 0xb6, 0xf4, 0x4a, 0xb9, - 0x55, 0xaf, 0xa9, 0xa9, 0xcd, 0x4f, 0x21, 0x2f, 0xd7, 0x73, 0xa1, 0xf1, 0x75, 0x61, 0xe1, 0x3e, - 0x77, 0x9c, 0x3a, 0x33, 0xc6, 0x38, 0x0e, 0x19, 0xca, 0xe6, 0xdf, 0x28, 0x30, 0x1f, 0x1e, 0x65, - 0xe8, 0x2a, 0x5c, 0x3a, 0xae, 0xeb, 0x8d, 0x1a, 0x47, 0xd1, 0x18, 0xa8, 0xeb, 0xbb, 0xdb, 0x7a, - 0xf9, 0x48, 0x6f, 0xd4, 0xd4, 0x99, 0x31, 0x76, 0x2d, 0xc9, 0x56, 0xc6, 0xd8, 0xb8, 0xdc, 0xa4, - 0xfc, 0xe6, 0x03, 0xce, 0x4e, 0x8d, 0xb1, 0xcb, 0x07, 0xbb, 0x32, 0x3b, 0x4d, 0x1d, 0x26, 0xb1, - 0xeb, 0xcd, 0x0a, 0x65, 0xb7, 0x42, 0xed, 0x99, 0xcd, 0x06, 0x64, 0xd9, 0x07, 0x66, 0xb4, 0x08, - 0xb9, 0x56, 0xb5, 0x25, 0xfd, 0xf7, 0x12, 0x60, 0x96, 0x12, 0xb6, 0xef, 0xa8, 0x4a, 0xd8, 0xbe, - 0xb5, 0xa5, 0xa6, 0xc2, 0xf6, 0x9d, 0x2d, 0x35, 0x4d, 0xa3, 0x9d, 0x61, 0x76, 0xb6, 0xd4, 0xcc, - 0xe6, 0xcf, 0xd3, 0x90, 0x6e, 0x7a, 0x1d, 0xaa, 0xa9, 0x89, 0x2b, 0x49, 0x4d, 0x94, 0xb0, 0xbd, - 0xcd, 0x35, 0xb1, 0xf6, 0x3d, 0xae, 0x89, 0xb6, 0x77, 0x6e, 0x8b, 0xa4, 0xa2, 0xed, 0x3b, 0x6a, - 0x26, 0x6c, 0xdf, 0xda, 0x56, 0xb3, 0x51, 0x7b, 0x47, 0x9d, 0x8d, 0xda, 0xf7, 0xd4, 0xb9, 0xb0, - 0x7d, 0x67, 0x5b, 0x9d, 0x8f, 0xda, 0x3b, 0xea, 0x42, 0xd8, 0xbe, 0x7b, 0x47, 0x85, 0xa8, 0x7d, - 0x57, 0xcd, 0x85, 0xed, 0xf7, 0xef, 0xa9, 0xf9, 0xa8, 0xfd, 0x81, 0x5a, 0x08, 0xdb, 0x1f, 0xdc, - 0x52, 0x8b, 0x6c, 0x3f, 0xa0, 0xb6, 0x6d, 0xdd, 0x55, 0x17, 0xe3, 0xce, 0xfb, 0xaa, 0x1a, 0x75, - 0x76, 0xb6, 0xd5, 0xa5, 0xa8, 0x73, 0x6b, 0x47, 0x45, 0x71, 0xe7, 0x96, 0xba, 0x1c, 0x77, 0xee, - 0xa8, 0x2b, 0x51, 0xe7, 0xee, 0x96, 0x7a, 0x21, 0xee, 0xec, 0xa8, 0xab, 0x51, 0xe7, 0xde, 0x07, - 0xea, 0xc5, 0xb0, 0xb3, 0xb3, 0x7d, 0x57, 0x5d, 0x8b, 0x3b, 0xef, 0xab, 0x97, 0xa2, 0xce, 0xed, - 0x3b, 0xea, 0xe5, 0xa8, 0x73, 0xf7, 0xb6, 0xba, 0x1e, 0x75, 0xde, 0xdf, 0x52, 0xaf, 0xc4, 0x9d, - 0x5b, 0xea, 0xd5, 0xcd, 0x2e, 0x2d, 0x9e, 0xa3, 0xff, 0xb2, 0xa0, 0x4b, 0x70, 0xa1, 0xde, 0xd4, - 0x6b, 0x55, 0xbd, 0x75, 0x7c, 0x44, 0xb3, 0x40, 0x5a, 0x94, 0x75, 0xb8, 0x98, 0x64, 0x89, 0xdf, - 0x3a, 0x8d, 0xb9, 0x12, 0xac, 0x27, 0x99, 0xcd, 0x43, 0x19, 0x90, 0xaa, 0xac, 0xfd, 0xf2, 0x6c, - 0x43, 0xf9, 0xd5, 0xd9, 0x86, 0xf2, 0x1f, 0x67, 0x1b, 0xca, 0x57, 0x5f, 0x6f, 0xcc, 0xfc, 0xea, - 0xeb, 0x8d, 0x99, 0x7f, 0xf9, 0x7a, 0x63, 0xa6, 0x33, 0xcb, 0xbe, 0x8e, 0xdc, 0xfa, 0xbf, 0x00, - 0x00, 0x00, 0xff, 0xff, 0xc5, 0x8f, 0x73, 0x09, 0xb6, 0x33, 0x00, 0x00, +func (m *RSMSliceItemList) Reset() { *m = RSMSliceItemList{} } +func (m *RSMSliceItemList) String() string { return proto.CompactTextString(m) } +func (*RSMSliceItemList) ProtoMessage() {} +func (*RSMSliceItemList) Descriptor() ([]byte, []int) { + return fileDescriptor_23cc5f935e05bbb6, []int{80} } - -func (m *Location) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { - return nil, err +func (m *RSMSliceItemList) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *RSMSliceItemList) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_RSMSliceItemList.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil } - return dAtA[:n], nil } - -func (m *Location) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) +func (m *RSMSliceItemList) XXX_Merge(src proto.Message) { + xxx_messageInfo_RSMSliceItemList.Merge(m, src) +} +func (m *RSMSliceItemList) XXX_Size() int { + return m.Size() +} +func (m *RSMSliceItemList) XXX_DiscardUnknown() { + xxx_messageInfo_RSMSliceItemList.DiscardUnknown(m) } -func (m *Location) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if m.Ext != nil { - { - size := m.Ext.Size() - i -= size - if _, err := m.Ext.MarshalTo(dAtA[i:]); err != nil { - return 0, err - } - } - } - if m.Lng != 0 { - i -= 8 - encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.Lng)))) - i-- - dAtA[i] = 0x11 - } - if m.Lat != 0 { - i -= 8 - encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.Lat)))) - i-- - dAtA[i] = 0x9 +var xxx_messageInfo_RSMSliceItemList proto.InternalMessageInfo + +func (m *RSMSliceItemList) GetRsmSliceList() []*RSMSlicingItem { + if m != nil { + return m.RsmSliceList } - return len(dAtA) - i, nil + return nil } -func (m *Location_Wgs84) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) +type RSMSlicingItem struct { + ID string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` + SliceDesc string `protobuf:"bytes,2,opt,name=slice_desc,json=sliceDesc,proto3" json:"slice_desc,omitempty"` + SliceParameters *RSMSliceParameters `protobuf:"bytes,3,opt,name=slice_parameters,json=sliceParameters,proto3" json:"slice_parameters,omitempty"` + SliceType RSMSliceType `protobuf:"varint,4,opt,name=slice_type,json=sliceType,proto3,enum=onos.topo.RSMSliceType" json:"slice_type,omitempty"` + UeIdList []*UeIdentity `protobuf:"bytes,5,rep,name=ue_id_list,json=ueIdList,proto3" json:"ue_id_list,omitempty"` } -func (m *Location_Wgs84) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - if m.Wgs84 != nil { - { - size, err := m.Wgs84.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintRan(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x1a - } - return len(dAtA) - i, nil +func (m *RSMSlicingItem) Reset() { *m = RSMSlicingItem{} } +func (m *RSMSlicingItem) String() string { return proto.CompactTextString(m) } +func (*RSMSlicingItem) ProtoMessage() {} +func (*RSMSlicingItem) Descriptor() ([]byte, []int) { + return fileDescriptor_23cc5f935e05bbb6, []int{81} } -func (m *Location_Cartesian) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) +func (m *RSMSlicingItem) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) } - -func (m *Location_Cartesian) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - if m.Cartesian != nil { - { - size, err := m.Cartesian.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintRan(dAtA, i, uint64(size)) +func (m *RSMSlicingItem) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_RSMSlicingItem.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err } - i-- - dAtA[i] = 0x22 + return b[:n], nil } - return len(dAtA) - i, nil } -func (m *Wgs84Location) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { - return nil, err - } - return dAtA[:n], nil +func (m *RSMSlicingItem) XXX_Merge(src proto.Message) { + xxx_messageInfo_RSMSlicingItem.Merge(m, src) } - -func (m *Wgs84Location) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) +func (m *RSMSlicingItem) XXX_Size() int { + return m.Size() +} +func (m *RSMSlicingItem) XXX_DiscardUnknown() { + xxx_messageInfo_RSMSlicingItem.DiscardUnknown(m) } -func (m *Wgs84Location) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if m.AltitudeM != 0 { - i -= 8 - encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.AltitudeM)))) - i-- - dAtA[i] = 0x19 - } - if m.LongitudeDeg != 0 { - i -= 8 - encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.LongitudeDeg)))) - i-- - dAtA[i] = 0x11 - } - if m.LatitudeDeg != 0 { - i -= 8 - encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.LatitudeDeg)))) - i-- - dAtA[i] = 0x9 +var xxx_messageInfo_RSMSlicingItem proto.InternalMessageInfo + +func (m *RSMSlicingItem) GetID() string { + if m != nil { + return m.ID } - return len(dAtA) - i, nil + return "" } -func (m *CartesianLocation) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { - return nil, err +func (m *RSMSlicingItem) GetSliceDesc() string { + if m != nil { + return m.SliceDesc } - return dAtA[:n], nil + return "" } -func (m *CartesianLocation) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) +func (m *RSMSlicingItem) GetSliceParameters() *RSMSliceParameters { + if m != nil { + return m.SliceParameters + } + return nil } -func (m *CartesianLocation) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if m.ZM != 0 { - i -= 8 - encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.ZM)))) - i-- - dAtA[i] = 0x19 - } - if m.YM != 0 { - i -= 8 - encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.YM)))) - i-- - dAtA[i] = 0x11 - } - if m.XM != 0 { - i -= 8 - encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.XM)))) - i-- - dAtA[i] = 0x9 +func (m *RSMSlicingItem) GetSliceType() RSMSliceType { + if m != nil { + return m.SliceType } - return len(dAtA) - i, nil + return RSMSliceType_SLICE_TYPE_DL_SLICE } -func (m *AzElOrientation) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { - return nil, err +func (m *RSMSlicingItem) GetUeIdList() []*UeIdentity { + if m != nil { + return m.UeIdList } - return dAtA[:n], nil + return nil } -func (m *AzElOrientation) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) +type RSMSliceParameters struct { + SchedulerType RSMSchedulerType `protobuf:"varint,1,opt,name=scheduler_type,json=schedulerType,proto3,enum=onos.topo.RSMSchedulerType" json:"scheduler_type,omitempty"` + Weight int32 `protobuf:"varint,2,opt,name=weight,proto3" json:"weight,omitempty"` + QosLevel int32 `protobuf:"varint,3,opt,name=qos_level,json=qosLevel,proto3" json:"qos_level,omitempty"` } -func (m *AzElOrientation) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if m.RotationDeg != 0 { - i -= 8 - encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.RotationDeg)))) - i-- - dAtA[i] = 0x19 - } - if m.ElevationDeg != 0 { - i -= 8 - encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.ElevationDeg)))) - i-- - dAtA[i] = 0x11 - } - if m.AzimuthDeg != 0 { - i -= 8 - encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.AzimuthDeg)))) - i-- - dAtA[i] = 0x9 - } - return len(dAtA) - i, nil +func (m *RSMSliceParameters) Reset() { *m = RSMSliceParameters{} } +func (m *RSMSliceParameters) String() string { return proto.CompactTextString(m) } +func (*RSMSliceParameters) ProtoMessage() {} +func (*RSMSliceParameters) Descriptor() ([]byte, []int) { + return fileDescriptor_23cc5f935e05bbb6, []int{82} } - -func (m *YprOrientation) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { - return nil, err +func (m *RSMSliceParameters) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *RSMSliceParameters) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_RSMSliceParameters.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil } - return dAtA[:n], nil } - -func (m *YprOrientation) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) +func (m *RSMSliceParameters) XXX_Merge(src proto.Message) { + xxx_messageInfo_RSMSliceParameters.Merge(m, src) } - -func (m *YprOrientation) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if m.RollDeg != 0 { - i -= 8 - encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.RollDeg)))) - i-- - dAtA[i] = 0x19 - } - if m.PitchDeg != 0 { - i -= 8 - encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.PitchDeg)))) - i-- - dAtA[i] = 0x11 - } - if m.YawDeg != 0 { - i -= 8 - encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.YawDeg)))) - i-- - dAtA[i] = 0x9 - } - return len(dAtA) - i, nil +func (m *RSMSliceParameters) XXX_Size() int { + return m.Size() +} +func (m *RSMSliceParameters) XXX_DiscardUnknown() { + xxx_messageInfo_RSMSliceParameters.DiscardUnknown(m) } -func (m *Orientation) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { - return nil, err +var xxx_messageInfo_RSMSliceParameters proto.InternalMessageInfo + +func (m *RSMSliceParameters) GetSchedulerType() RSMSchedulerType { + if m != nil { + return m.SchedulerType } - return dAtA[:n], nil + return RSMSchedulerType_SCHEDULER_TYPE_ROUND_ROBIN } -func (m *Orientation) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) +func (m *RSMSliceParameters) GetWeight() int32 { + if m != nil { + return m.Weight + } + return 0 } -func (m *Orientation) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if m.Orientation != nil { - { - size := m.Orientation.Size() - i -= size - if _, err := m.Orientation.MarshalTo(dAtA[i:]); err != nil { - return 0, err - } - } +func (m *RSMSliceParameters) GetQosLevel() int32 { + if m != nil { + return m.QosLevel } - return len(dAtA) - i, nil + return 0 } -func (m *Orientation_Azel) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) +type DuUeF1ApID struct { + Value int64 `protobuf:"varint,1,opt,name=value,proto3" json:"value,omitempty"` } -func (m *Orientation_Azel) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - if m.Azel != nil { - { - size, err := m.Azel.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintRan(dAtA, i, uint64(size)) +func (m *DuUeF1ApID) Reset() { *m = DuUeF1ApID{} } +func (m *DuUeF1ApID) String() string { return proto.CompactTextString(m) } +func (*DuUeF1ApID) ProtoMessage() {} +func (*DuUeF1ApID) Descriptor() ([]byte, []int) { + return fileDescriptor_23cc5f935e05bbb6, []int{83} +} +func (m *DuUeF1ApID) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *DuUeF1ApID) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_DuUeF1ApID.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err } - i-- - dAtA[i] = 0xa + return b[:n], nil } - return len(dAtA) - i, nil } -func (m *Orientation_Ypr) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) +func (m *DuUeF1ApID) XXX_Merge(src proto.Message) { + xxx_messageInfo_DuUeF1ApID.Merge(m, src) } - -func (m *Orientation_Ypr) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - if m.Ypr != nil { - { - size, err := m.Ypr.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintRan(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x12 - } - return len(dAtA) - i, nil +func (m *DuUeF1ApID) XXX_Size() int { + return m.Size() } -func (m *Waypoint) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { - return nil, err - } - return dAtA[:n], nil +func (m *DuUeF1ApID) XXX_DiscardUnknown() { + xxx_messageInfo_DuUeF1ApID.DiscardUnknown(m) } -func (m *Waypoint) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} +var xxx_messageInfo_DuUeF1ApID proto.InternalMessageInfo -func (m *Waypoint) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if m.Location != nil { - { - size, err := m.Location.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintRan(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x12 - } - if m.Time != nil { - { - size, err := m.Time.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintRan(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0xa +func (m *DuUeF1ApID) GetValue() int64 { + if m != nil { + return m.Value } - return len(dAtA) - i, nil + return 0 } -func (m *Waypoints) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { - return nil, err - } - return dAtA[:n], nil +type CuUeF1ApID struct { + Value int64 `protobuf:"varint,1,opt,name=value,proto3" json:"value,omitempty"` } -func (m *Waypoints) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) +func (m *CuUeF1ApID) Reset() { *m = CuUeF1ApID{} } +func (m *CuUeF1ApID) String() string { return proto.CompactTextString(m) } +func (*CuUeF1ApID) ProtoMessage() {} +func (*CuUeF1ApID) Descriptor() ([]byte, []int) { + return fileDescriptor_23cc5f935e05bbb6, []int{84} } - -func (m *Waypoints) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if len(m.Waypoint) > 0 { - for iNdEx := len(m.Waypoint) - 1; iNdEx >= 0; iNdEx-- { - { - size, err := m.Waypoint[iNdEx].MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintRan(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0xa +func (m *CuUeF1ApID) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *CuUeF1ApID) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_CuUeF1ApID.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err } + return b[:n], nil } - return len(dAtA) - i, nil +} +func (m *CuUeF1ApID) XXX_Merge(src proto.Message) { + xxx_messageInfo_CuUeF1ApID.Merge(m, src) +} +func (m *CuUeF1ApID) XXX_Size() int { + return m.Size() +} +func (m *CuUeF1ApID) XXX_DiscardUnknown() { + xxx_messageInfo_CuUeF1ApID.DiscardUnknown(m) } -func (m *OrbitData) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { - return nil, err +var xxx_messageInfo_CuUeF1ApID proto.InternalMessageInfo + +func (m *CuUeF1ApID) GetValue() int64 { + if m != nil { + return m.Value } - return dAtA[:n], nil + return 0 } -func (m *OrbitData) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) +type RanUeNgapID struct { + Value int64 `protobuf:"varint,1,opt,name=value,proto3" json:"value,omitempty"` } -func (m *OrbitData) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if m.MeanMotion != 0 { - i -= 8 - encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.MeanMotion)))) - i-- - dAtA[i] = 0x39 - } - if m.AnomalyDeg != 0 { - i -= 8 - encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.AnomalyDeg)))) - i-- - dAtA[i] = 0x31 - } - if m.ArgumentDeg != 0 { - i -= 8 - encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.ArgumentDeg)))) - i-- - dAtA[i] = 0x29 - } - if m.E != 0 { - i -= 8 - encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.E)))) - i-- - dAtA[i] = 0x21 - } - if m.RaanDeg != 0 { - i -= 8 - encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.RaanDeg)))) - i-- - dAtA[i] = 0x19 - } - if m.InclinationDeg != 0 { - i -= 8 - encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.InclinationDeg)))) - i-- - dAtA[i] = 0x11 - } - if m.Epoch != nil { - { - size, err := m.Epoch.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintRan(dAtA, i, uint64(size)) +func (m *RanUeNgapID) Reset() { *m = RanUeNgapID{} } +func (m *RanUeNgapID) String() string { return proto.CompactTextString(m) } +func (*RanUeNgapID) ProtoMessage() {} +func (*RanUeNgapID) Descriptor() ([]byte, []int) { + return fileDescriptor_23cc5f935e05bbb6, []int{85} +} +func (m *RanUeNgapID) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *RanUeNgapID) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_RanUeNgapID.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err } - i-- - dAtA[i] = 0xa + return b[:n], nil } - return len(dAtA) - i, nil } - -func (m *Motion) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { - return nil, err - } - return dAtA[:n], nil +func (m *RanUeNgapID) XXX_Merge(src proto.Message) { + xxx_messageInfo_RanUeNgapID.Merge(m, src) } - -func (m *Motion) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) +func (m *RanUeNgapID) XXX_Size() int { + return m.Size() +} +func (m *RanUeNgapID) XXX_DiscardUnknown() { + xxx_messageInfo_RanUeNgapID.DiscardUnknown(m) } -func (m *Motion) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if m.Motion != nil { - { - size := m.Motion.Size() - i -= size - if _, err := m.Motion.MarshalTo(dAtA[i:]); err != nil { - return 0, err - } - } +var xxx_messageInfo_RanUeNgapID proto.InternalMessageInfo + +func (m *RanUeNgapID) GetValue() int64 { + if m != nil { + return m.Value } - return len(dAtA) - i, nil + return 0 } -func (m *Motion_FixedLocation) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) +type EnbUeS1ApID struct { + Value int32 `protobuf:"varint,1,opt,name=value,proto3" json:"value,omitempty"` } -func (m *Motion_FixedLocation) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - if m.FixedLocation != nil { - { - size, err := m.FixedLocation.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintRan(dAtA, i, uint64(size)) +func (m *EnbUeS1ApID) Reset() { *m = EnbUeS1ApID{} } +func (m *EnbUeS1ApID) String() string { return proto.CompactTextString(m) } +func (*EnbUeS1ApID) ProtoMessage() {} +func (*EnbUeS1ApID) Descriptor() ([]byte, []int) { + return fileDescriptor_23cc5f935e05bbb6, []int{86} +} +func (m *EnbUeS1ApID) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *EnbUeS1ApID) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_EnbUeS1ApID.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err } - i-- - dAtA[i] = 0xa + return b[:n], nil } - return len(dAtA) - i, nil } -func (m *Motion_Waypoints) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) +func (m *EnbUeS1ApID) XXX_Merge(src proto.Message) { + xxx_messageInfo_EnbUeS1ApID.Merge(m, src) +} +func (m *EnbUeS1ApID) XXX_Size() int { + return m.Size() +} +func (m *EnbUeS1ApID) XXX_DiscardUnknown() { + xxx_messageInfo_EnbUeS1ApID.DiscardUnknown(m) } -func (m *Motion_Waypoints) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - if m.Waypoints != nil { - { - size, err := m.Waypoints.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintRan(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x12 +var xxx_messageInfo_EnbUeS1ApID proto.InternalMessageInfo + +func (m *EnbUeS1ApID) GetValue() int32 { + if m != nil { + return m.Value } - return len(dAtA) - i, nil + return 0 } -func (m *Motion_Orbit) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) + +type AmfUeNgapID struct { + Value int64 `protobuf:"varint,1,opt,name=value,proto3" json:"value,omitempty"` } -func (m *Motion_Orbit) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - if m.Orbit != nil { - { - size, err := m.Orbit.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintRan(dAtA, i, uint64(size)) +func (m *AmfUeNgapID) Reset() { *m = AmfUeNgapID{} } +func (m *AmfUeNgapID) String() string { return proto.CompactTextString(m) } +func (*AmfUeNgapID) ProtoMessage() {} +func (*AmfUeNgapID) Descriptor() ([]byte, []int) { + return fileDescriptor_23cc5f935e05bbb6, []int{87} +} +func (m *AmfUeNgapID) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *AmfUeNgapID) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_AmfUeNgapID.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err } - i-- - dAtA[i] = 0x1a + return b[:n], nil } - return len(dAtA) - i, nil } -func (m *Coverage) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { - return nil, err +func (m *AmfUeNgapID) XXX_Merge(src proto.Message) { + xxx_messageInfo_AmfUeNgapID.Merge(m, src) +} +func (m *AmfUeNgapID) XXX_Size() int { + return m.Size() +} +func (m *AmfUeNgapID) XXX_DiscardUnknown() { + xxx_messageInfo_AmfUeNgapID.DiscardUnknown(m) +} + +var xxx_messageInfo_AmfUeNgapID proto.InternalMessageInfo + +func (m *AmfUeNgapID) GetValue() int64 { + if m != nil { + return m.Value } - return dAtA[:n], nil + return 0 } -func (m *Coverage) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) +type UeIdentity struct { + DuUeF1apID *DuUeF1ApID `protobuf:"bytes,1,opt,name=du_ue_f1ap_id,json=duUeF1apId,proto3" json:"du_ue_f1ap_id,omitempty"` + CuUeF1apID *CuUeF1ApID `protobuf:"bytes,2,opt,name=cu_ue_f1ap_id,json=cuUeF1apId,proto3" json:"cu_ue_f1ap_id,omitempty"` + RANUeNgapID *RanUeNgapID `protobuf:"bytes,3,opt,name=ran_ue_ngap_id,json=ranUeNgapId,proto3" json:"ran_ue_ngap_id,omitempty"` + EnbUeS1apID *EnbUeS1ApID `protobuf:"bytes,4,opt,name=enb_ue_s1ap_id,json=enbUeS1apId,proto3" json:"enb_ue_s1ap_id,omitempty"` + AMFUeNgapID *AmfUeNgapID `protobuf:"bytes,5,opt,name=amf_ue_ngap_id,json=amfUeNgapId,proto3" json:"amf_ue_ngap_id,omitempty"` + PreferredIDType UeIdType `protobuf:"varint,6,opt,name=preferred_id_type,json=preferredIdType,proto3,enum=onos.topo.UeIdType" json:"preferred_id_type,omitempty"` + DrbId *DrbId `protobuf:"bytes,7,opt,name=drb_id,json=drbId,proto3" json:"drb_id,omitempty"` } -func (m *Coverage) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if m.Tilt != 0 { - i = encodeVarintRan(dAtA, i, uint64(m.Tilt)) - i-- - dAtA[i] = 0x20 - } - if m.Azimuth != 0 { - i = encodeVarintRan(dAtA, i, uint64(m.Azimuth)) - i-- - dAtA[i] = 0x18 - } - if m.ArcWidth != 0 { - i = encodeVarintRan(dAtA, i, uint64(m.ArcWidth)) - i-- - dAtA[i] = 0x10 +func (m *UeIdentity) Reset() { *m = UeIdentity{} } +func (m *UeIdentity) String() string { return proto.CompactTextString(m) } +func (*UeIdentity) ProtoMessage() {} +func (*UeIdentity) Descriptor() ([]byte, []int) { + return fileDescriptor_23cc5f935e05bbb6, []int{88} +} +func (m *UeIdentity) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *UeIdentity) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_UeIdentity.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil } - if m.Height != 0 { - i = encodeVarintRan(dAtA, i, uint64(m.Height)) - i-- - dAtA[i] = 0x8 +} +func (m *UeIdentity) XXX_Merge(src proto.Message) { + xxx_messageInfo_UeIdentity.Merge(m, src) +} +func (m *UeIdentity) XXX_Size() int { + return m.Size() +} +func (m *UeIdentity) XXX_DiscardUnknown() { + xxx_messageInfo_UeIdentity.DiscardUnknown(m) +} + +var xxx_messageInfo_UeIdentity proto.InternalMessageInfo + +func (m *UeIdentity) GetDuUeF1apID() *DuUeF1ApID { + if m != nil { + return m.DuUeF1apID } - return len(dAtA) - i, nil + return nil } -func (m *E2Node) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { - return nil, err +func (m *UeIdentity) GetCuUeF1apID() *CuUeF1ApID { + if m != nil { + return m.CuUeF1apID } - return dAtA[:n], nil + return nil } -func (m *E2Node) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) +func (m *UeIdentity) GetRANUeNgapID() *RanUeNgapID { + if m != nil { + return m.RANUeNgapID + } + return nil } -func (m *E2Node) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if len(m.ServiceModels) > 0 { - for k := range m.ServiceModels { - v := m.ServiceModels[k] - baseI := i - if v != nil { - { - size, err := v.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintRan(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x12 - } - i -= len(k) - copy(dAtA[i:], k) - i = encodeVarintRan(dAtA, i, uint64(len(k))) - i-- - dAtA[i] = 0xa - i = encodeVarintRan(dAtA, i, uint64(baseI-i)) - i-- - dAtA[i] = 0xa - } +func (m *UeIdentity) GetEnbUeS1apID() *EnbUeS1ApID { + if m != nil { + return m.EnbUeS1apID } - return len(dAtA) - i, nil + return nil } -func (m *E2NodeConfig) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { - return nil, err +func (m *UeIdentity) GetAMFUeNgapID() *AmfUeNgapID { + if m != nil { + return m.AMFUeNgapID } - return dAtA[:n], nil + return nil } -func (m *E2NodeConfig) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *E2NodeConfig) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if m.Version != 0 { - i = encodeVarintRan(dAtA, i, uint64(m.Version)) - i-- - dAtA[i] = 0x10 - } - if len(m.Connections) > 0 { - for iNdEx := len(m.Connections) - 1; iNdEx >= 0; iNdEx-- { - { - size, err := m.Connections[iNdEx].MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintRan(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0xa - } +func (m *UeIdentity) GetPreferredIDType() UeIdType { + if m != nil { + return m.PreferredIDType } - return len(dAtA) - i, nil + return UeIdType_UE_ID_TYPE_CU_UE_F1_AP_ID } -func (m *Lease) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { - return nil, err +func (m *UeIdentity) GetDrbId() *DrbId { + if m != nil { + return m.DrbId } - return dAtA[:n], nil + return nil } -func (m *Lease) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) +type DrbId struct { + // Types that are valid to be assigned to DrbId: + // + // *DrbId_FourGdrbId + // *DrbId_FiveGdrbId + DrbId isDrbId_DrbId `protobuf_oneof:"drb_id"` } -func (m *Lease) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if m.Expiration != nil { - n12, err12 := github_com_gogo_protobuf_types.StdTimeMarshalTo(*m.Expiration, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(*m.Expiration):]) - if err12 != nil { - return 0, err12 +func (m *DrbId) Reset() { *m = DrbId{} } +func (m *DrbId) String() string { return proto.CompactTextString(m) } +func (*DrbId) ProtoMessage() {} +func (*DrbId) Descriptor() ([]byte, []int) { + return fileDescriptor_23cc5f935e05bbb6, []int{89} +} +func (m *DrbId) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *DrbId) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_DrbId.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err } - i -= n12 - i = encodeVarintRan(dAtA, i, uint64(n12)) - i-- - dAtA[i] = 0xa + return b[:n], nil } - return len(dAtA) - i, nil +} +func (m *DrbId) XXX_Merge(src proto.Message) { + xxx_messageInfo_DrbId.Merge(m, src) +} +func (m *DrbId) XXX_Size() int { + return m.Size() +} +func (m *DrbId) XXX_DiscardUnknown() { + xxx_messageInfo_DrbId.DiscardUnknown(m) } -func (m *Interface) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { - return nil, err - } - return dAtA[:n], nil +var xxx_messageInfo_DrbId proto.InternalMessageInfo + +type isDrbId_DrbId interface { + isDrbId_DrbId() + MarshalTo([]byte) (int, error) + Size() int } -func (m *Interface) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) +type DrbId_FourGdrbId struct { + FourGdrbId *FourGDrbId `protobuf:"bytes,1,opt,name=four_gdrb_id,json=fourGDrbID,proto3,oneof" json:"four_gdrb_id,omitempty"` +} +type DrbId_FiveGdrbId struct { + FiveGdrbId *FiveGDrbId `protobuf:"bytes,2,opt,name=five_gdrb_id,json=fiveGDrbID,proto3,oneof" json:"five_gdrb_id,omitempty"` } -func (m *Interface) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if m.Port != 0 { - i = encodeVarintRan(dAtA, i, uint64(m.Port)) - i-- - dAtA[i] = 0x18 +func (*DrbId_FourGdrbId) isDrbId_DrbId() {} +func (*DrbId_FiveGdrbId) isDrbId_DrbId() {} + +func (m *DrbId) GetDrbId() isDrbId_DrbId { + if m != nil { + return m.DrbId } - if len(m.IP) > 0 { - i -= len(m.IP) - copy(dAtA[i:], m.IP) - i = encodeVarintRan(dAtA, i, uint64(len(m.IP))) - i-- - dAtA[i] = 0x12 + return nil +} + +func (m *DrbId) GetFourGdrbId() *FourGDrbId { + if x, ok := m.GetDrbId().(*DrbId_FourGdrbId); ok { + return x.FourGdrbId } - if m.Type != 0 { - i = encodeVarintRan(dAtA, i, uint64(m.Type)) - i-- - dAtA[i] = 0x8 + return nil +} + +func (m *DrbId) GetFiveGdrbId() *FiveGDrbId { + if x, ok := m.GetDrbId().(*DrbId_FiveGdrbId); ok { + return x.FiveGdrbId } - return len(dAtA) - i, nil + return nil } -func (m *E2TInfo) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { - return nil, err +// XXX_OneofWrappers is for the internal use of the proto package. +func (*DrbId) XXX_OneofWrappers() []interface{} { + return []interface{}{ + (*DrbId_FourGdrbId)(nil), + (*DrbId_FiveGdrbId)(nil), } - return dAtA[:n], nil } -func (m *E2TInfo) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) +type FiveGDrbId struct { + Value int32 `protobuf:"varint,1,opt,name=value,proto3" json:"value,omitempty"` + Qfi *Qfi `protobuf:"bytes,2,opt,name=qfi,proto3" json:"qfi,omitempty"` + FlowsMapToDrb []*QoSflowLevelParameters `protobuf:"bytes,3,rep,name=flows_map_to_drb,json=flowsMapToDrb,proto3" json:"flows_map_to_drb,omitempty"` } -func (m *E2TInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if len(m.Interfaces) > 0 { - for iNdEx := len(m.Interfaces) - 1; iNdEx >= 0; iNdEx-- { - { - size, err := m.Interfaces[iNdEx].MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintRan(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0xa +func (m *FiveGDrbId) Reset() { *m = FiveGDrbId{} } +func (m *FiveGDrbId) String() string { return proto.CompactTextString(m) } +func (*FiveGDrbId) ProtoMessage() {} +func (*FiveGDrbId) Descriptor() ([]byte, []int) { + return fileDescriptor_23cc5f935e05bbb6, []int{90} +} +func (m *FiveGDrbId) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *FiveGDrbId) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_FiveGDrbId.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err } + return b[:n], nil } - return len(dAtA) - i, nil +} +func (m *FiveGDrbId) XXX_Merge(src proto.Message) { + xxx_messageInfo_FiveGDrbId.Merge(m, src) +} +func (m *FiveGDrbId) XXX_Size() int { + return m.Size() +} +func (m *FiveGDrbId) XXX_DiscardUnknown() { + xxx_messageInfo_FiveGDrbId.DiscardUnknown(m) } -func (m *XAppInfo) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { - return nil, err +var xxx_messageInfo_FiveGDrbId proto.InternalMessageInfo + +func (m *FiveGDrbId) GetValue() int32 { + if m != nil { + return m.Value } - return dAtA[:n], nil + return 0 } -func (m *XAppInfo) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) +func (m *FiveGDrbId) GetQfi() *Qfi { + if m != nil { + return m.Qfi + } + return nil } -func (m *XAppInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if len(m.A1PolicyTypes) > 0 { - for iNdEx := len(m.A1PolicyTypes) - 1; iNdEx >= 0; iNdEx-- { - { - size, err := m.A1PolicyTypes[iNdEx].MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintRan(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x12 - } - } - if len(m.Interfaces) > 0 { - for iNdEx := len(m.Interfaces) - 1; iNdEx >= 0; iNdEx-- { - { - size, err := m.Interfaces[iNdEx].MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintRan(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0xa - } +func (m *FiveGDrbId) GetFlowsMapToDrb() []*QoSflowLevelParameters { + if m != nil { + return m.FlowsMapToDrb } - return len(dAtA) - i, nil + return nil } -func (m *A1PolicyType) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { - return nil, err - } - return dAtA[:n], nil +type Qfi struct { + Value int32 `protobuf:"varint,1,opt,name=value,proto3" json:"value,omitempty"` } -func (m *A1PolicyType) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) +func (m *Qfi) Reset() { *m = Qfi{} } +func (m *Qfi) String() string { return proto.CompactTextString(m) } +func (*Qfi) ProtoMessage() {} +func (*Qfi) Descriptor() ([]byte, []int) { + return fileDescriptor_23cc5f935e05bbb6, []int{91} } - -func (m *A1PolicyType) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if len(m.Description) > 0 { - i -= len(m.Description) - copy(dAtA[i:], m.Description) - i = encodeVarintRan(dAtA, i, uint64(len(m.Description))) - i-- - dAtA[i] = 0x22 - } - if len(m.Version) > 0 { - i -= len(m.Version) - copy(dAtA[i:], m.Version) - i = encodeVarintRan(dAtA, i, uint64(len(m.Version))) - i-- - dAtA[i] = 0x1a - } - if len(m.Name) > 0 { - i -= len(m.Name) - copy(dAtA[i:], m.Name) - i = encodeVarintRan(dAtA, i, uint64(len(m.Name))) - i-- - dAtA[i] = 0x12 - } - if len(m.ID) > 0 { - i -= len(m.ID) - copy(dAtA[i:], m.ID) - i = encodeVarintRan(dAtA, i, uint64(len(m.ID))) - i-- - dAtA[i] = 0xa +func (m *Qfi) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *Qfi) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_Qfi.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil } - return len(dAtA) - i, nil +} +func (m *Qfi) XXX_Merge(src proto.Message) { + xxx_messageInfo_Qfi.Merge(m, src) +} +func (m *Qfi) XXX_Size() int { + return m.Size() +} +func (m *Qfi) XXX_DiscardUnknown() { + xxx_messageInfo_Qfi.DiscardUnknown(m) } -func (m *A1TInfo) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { - return nil, err +var xxx_messageInfo_Qfi proto.InternalMessageInfo + +func (m *Qfi) GetValue() int32 { + if m != nil { + return m.Value } - return dAtA[:n], nil + return 0 } -func (m *A1TInfo) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) +type QoSflowLevelParameters struct { + // Types that are valid to be assigned to QosFlowLevelParameters: + // + // *QoSflowLevelParameters_DynamicFiveQi + // *QoSflowLevelParameters_NonDynamicFiveQi + QosFlowLevelParameters isQoSflowLevelParameters_QosFlowLevelParameters `protobuf_oneof:"qos_flow_level_parameters"` } -func (m *A1TInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if len(m.Interfaces) > 0 { - for iNdEx := len(m.Interfaces) - 1; iNdEx >= 0; iNdEx-- { - { - size, err := m.Interfaces[iNdEx].MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintRan(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0xa +func (m *QoSflowLevelParameters) Reset() { *m = QoSflowLevelParameters{} } +func (m *QoSflowLevelParameters) String() string { return proto.CompactTextString(m) } +func (*QoSflowLevelParameters) ProtoMessage() {} +func (*QoSflowLevelParameters) Descriptor() ([]byte, []int) { + return fileDescriptor_23cc5f935e05bbb6, []int{92} +} +func (m *QoSflowLevelParameters) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *QoSflowLevelParameters) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_QoSflowLevelParameters.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err } + return b[:n], nil } - return len(dAtA) - i, nil +} +func (m *QoSflowLevelParameters) XXX_Merge(src proto.Message) { + xxx_messageInfo_QoSflowLevelParameters.Merge(m, src) +} +func (m *QoSflowLevelParameters) XXX_Size() int { + return m.Size() +} +func (m *QoSflowLevelParameters) XXX_DiscardUnknown() { + xxx_messageInfo_QoSflowLevelParameters.DiscardUnknown(m) } -func (m *CellGlobalID) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { - return nil, err - } - return dAtA[:n], nil +var xxx_messageInfo_QoSflowLevelParameters proto.InternalMessageInfo + +type isQoSflowLevelParameters_QosFlowLevelParameters interface { + isQoSflowLevelParameters_QosFlowLevelParameters() + MarshalTo([]byte) (int, error) + Size() int } -func (m *CellGlobalID) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) +type QoSflowLevelParameters_DynamicFiveQi struct { + DynamicFiveQi *DynamicFiveQi `protobuf:"bytes,1,opt,name=dynamic_five_qi,json=dynamicFiveQi,proto3,oneof" json:"dynamic_five_qi,omitempty"` +} +type QoSflowLevelParameters_NonDynamicFiveQi struct { + NonDynamicFiveQi *NonDynamicFiveQi `protobuf:"bytes,2,opt,name=non_dynamic_five_qi,json=nonDynamicFiveQi,proto3,oneof" json:"non_dynamic_five_qi,omitempty"` } -func (m *CellGlobalID) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if m.Type != 0 { - i = encodeVarintRan(dAtA, i, uint64(m.Type)) - i-- - dAtA[i] = 0x10 - } - if len(m.Value) > 0 { - i -= len(m.Value) - copy(dAtA[i:], m.Value) - i = encodeVarintRan(dAtA, i, uint64(len(m.Value))) - i-- - dAtA[i] = 0xa +func (*QoSflowLevelParameters_DynamicFiveQi) isQoSflowLevelParameters_QosFlowLevelParameters() {} +func (*QoSflowLevelParameters_NonDynamicFiveQi) isQoSflowLevelParameters_QosFlowLevelParameters() {} + +func (m *QoSflowLevelParameters) GetQosFlowLevelParameters() isQoSflowLevelParameters_QosFlowLevelParameters { + if m != nil { + return m.QosFlowLevelParameters } - return len(dAtA) - i, nil + return nil } -func (m *NeighborCellID) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { - return nil, err +func (m *QoSflowLevelParameters) GetDynamicFiveQi() *DynamicFiveQi { + if x, ok := m.GetQosFlowLevelParameters().(*QoSflowLevelParameters_DynamicFiveQi); ok { + return x.DynamicFiveQi } - return dAtA[:n], nil + return nil } -func (m *NeighborCellID) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) +func (m *QoSflowLevelParameters) GetNonDynamicFiveQi() *NonDynamicFiveQi { + if x, ok := m.GetQosFlowLevelParameters().(*QoSflowLevelParameters_NonDynamicFiveQi); ok { + return x.NonDynamicFiveQi + } + return nil } -func (m *NeighborCellID) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if len(m.PlmnID) > 0 { - i -= len(m.PlmnID) - copy(dAtA[i:], m.PlmnID) - i = encodeVarintRan(dAtA, i, uint64(len(m.PlmnID))) - i-- - dAtA[i] = 0x12 - } - if m.CellGlobalID != nil { - { - size, err := m.CellGlobalID.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintRan(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0xa +// XXX_OneofWrappers is for the internal use of the proto package. +func (*QoSflowLevelParameters) XXX_OneofWrappers() []interface{} { + return []interface{}{ + (*QoSflowLevelParameters_DynamicFiveQi)(nil), + (*QoSflowLevelParameters_NonDynamicFiveQi)(nil), } - return len(dAtA) - i, nil } -func (m *E2Cell) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { - return nil, err +type DynamicFiveQi struct { + PriorityLevel int32 `protobuf:"varint,1,opt,name=priority_level,json=priorityLevel,proto3" json:"priority_level,omitempty"` + PacketDelayBudge int32 `protobuf:"varint,2,opt,name=packet_delay_budge,json=packetDelayBudge,proto3" json:"packet_delay_budge,omitempty"` + PacketErrorRate int32 `protobuf:"varint,3,opt,name=packet_error_rate,json=packetErrorRate,proto3" json:"packet_error_rate,omitempty"` +} + +func (m *DynamicFiveQi) Reset() { *m = DynamicFiveQi{} } +func (m *DynamicFiveQi) String() string { return proto.CompactTextString(m) } +func (*DynamicFiveQi) ProtoMessage() {} +func (*DynamicFiveQi) Descriptor() ([]byte, []int) { + return fileDescriptor_23cc5f935e05bbb6, []int{93} +} +func (m *DynamicFiveQi) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *DynamicFiveQi) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_DynamicFiveQi.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil } - return dAtA[:n], nil +} +func (m *DynamicFiveQi) XXX_Merge(src proto.Message) { + xxx_messageInfo_DynamicFiveQi.Merge(m, src) +} +func (m *DynamicFiveQi) XXX_Size() int { + return m.Size() +} +func (m *DynamicFiveQi) XXX_DiscardUnknown() { + xxx_messageInfo_DynamicFiveQi.DiscardUnknown(m) } -func (m *E2Cell) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) +var xxx_messageInfo_DynamicFiveQi proto.InternalMessageInfo + +func (m *DynamicFiveQi) GetPriorityLevel() int32 { + if m != nil { + return m.PriorityLevel + } + return 0 } -func (m *E2Cell) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if len(m.NeighborInformationNrs) > 0 { - for iNdEx := len(m.NeighborInformationNrs) - 1; iNdEx >= 0; iNdEx-- { - { - size, err := m.NeighborInformationNrs[iNdEx].MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintRan(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x1 - i-- - dAtA[i] = 0xa2 - } +func (m *DynamicFiveQi) GetPacketDelayBudge() int32 { + if m != nil { + return m.PacketDelayBudge } - if m.ConnectivitySupport != nil { - { - size, err := m.ConnectivitySupport.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintRan(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x1 - i-- - dAtA[i] = 0x9a + return 0 +} + +func (m *DynamicFiveQi) GetPacketErrorRate() int32 { + if m != nil { + return m.PacketErrorRate } - if m.AmfRegionInformation != nil { - { - size, err := m.AmfRegionInformation.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintRan(dAtA, i, uint64(size)) + return 0 +} + +type NonDynamicFiveQi struct { + FiveQi *FiveQi `protobuf:"bytes,1,opt,name=five_qi,json=fiveQi,proto3" json:"five_qi,omitempty"` +} + +func (m *NonDynamicFiveQi) Reset() { *m = NonDynamicFiveQi{} } +func (m *NonDynamicFiveQi) String() string { return proto.CompactTextString(m) } +func (*NonDynamicFiveQi) ProtoMessage() {} +func (*NonDynamicFiveQi) Descriptor() ([]byte, []int) { + return fileDescriptor_23cc5f935e05bbb6, []int{94} +} +func (m *NonDynamicFiveQi) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *NonDynamicFiveQi) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_NonDynamicFiveQi.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err } - i-- - dAtA[i] = 0x1 - i-- - dAtA[i] = 0x92 + return b[:n], nil } - if m.TaiSupportList != nil { - { - size, err := m.TaiSupportList.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintRan(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x1 - i-- - dAtA[i] = 0x8a +} +func (m *NonDynamicFiveQi) XXX_Merge(src proto.Message) { + xxx_messageInfo_NonDynamicFiveQi.Merge(m, src) +} +func (m *NonDynamicFiveQi) XXX_Size() int { + return m.Size() +} +func (m *NonDynamicFiveQi) XXX_DiscardUnknown() { + xxx_messageInfo_NonDynamicFiveQi.DiscardUnknown(m) +} + +var xxx_messageInfo_NonDynamicFiveQi proto.InternalMessageInfo + +func (m *NonDynamicFiveQi) GetFiveQi() *FiveQi { + if m != nil { + return m.FiveQi } - if m.GlobalNgRanNodeId != nil { - { - size, err := m.GlobalNgRanNodeId.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintRan(dAtA, i, uint64(size)) + return nil +} + +type FiveQi struct { + Value int32 `protobuf:"varint,1,opt,name=value,proto3" json:"value,omitempty"` +} + +func (m *FiveQi) Reset() { *m = FiveQi{} } +func (m *FiveQi) String() string { return proto.CompactTextString(m) } +func (*FiveQi) ProtoMessage() {} +func (*FiveQi) Descriptor() ([]byte, []int) { + return fileDescriptor_23cc5f935e05bbb6, []int{95} +} +func (m *FiveQi) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *FiveQi) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_FiveQi.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err } - i-- - dAtA[i] = 0x1 - i-- - dAtA[i] = 0x82 + return b[:n], nil } - if m.MeasurementTimingConfiguration != 0 { - i = encodeVarintRan(dAtA, i, uint64(m.MeasurementTimingConfiguration)) - i-- - dAtA[i] = 0x78 +} +func (m *FiveQi) XXX_Merge(src proto.Message) { + xxx_messageInfo_FiveQi.Merge(m, src) +} +func (m *FiveQi) XXX_Size() int { + return m.Size() +} +func (m *FiveQi) XXX_DiscardUnknown() { + xxx_messageInfo_FiveQi.DiscardUnknown(m) +} + +var xxx_messageInfo_FiveQi proto.InternalMessageInfo + +func (m *FiveQi) GetValue() int32 { + if m != nil { + return m.Value } - if m.NrModeInfo != nil { - { - size := m.NrModeInfo.Size() - i -= size - if _, err := m.NrModeInfo.MarshalTo(dAtA[i:]); err != nil { - return 0, err - } + return 0 +} + +type FourGDrbId struct { + Value int32 `protobuf:"varint,1,opt,name=value,proto3" json:"value,omitempty"` + Qci *Qci `protobuf:"bytes,2,opt,name=qci,proto3" json:"qci,omitempty"` +} + +func (m *FourGDrbId) Reset() { *m = FourGDrbId{} } +func (m *FourGDrbId) String() string { return proto.CompactTextString(m) } +func (*FourGDrbId) ProtoMessage() {} +func (*FourGDrbId) Descriptor() ([]byte, []int) { + return fileDescriptor_23cc5f935e05bbb6, []int{96} +} +func (m *FourGDrbId) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *FourGDrbId) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_FourGDrbId.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err } + return b[:n], nil } - if len(m.ServedPlmns) > 0 { - dAtA19 := make([]byte, len(m.ServedPlmns)*10) - var j18 int - for _, num := range m.ServedPlmns { - for num >= 1<<7 { - dAtA19[j18] = uint8(uint64(num)&0x7f | 0x80) - num >>= 7 - j18++ - } - dAtA19[j18] = uint8(num) - j18++ - } - i -= j18 - copy(dAtA[i:], dAtA19[:j18]) - i = encodeVarintRan(dAtA, i, uint64(j18)) - i-- - dAtA[i] = 0x62 - } - if m.PlmnId != 0 { - i = encodeVarintRan(dAtA, i, uint64(m.PlmnId)) - i-- - dAtA[i] = 0x58 - } - if m.LatestRrcVersion != 0 { - i = encodeVarintRan(dAtA, i, uint64(m.LatestRrcVersion)) - i-- - dAtA[i] = 0x50 - } - if m.GnbDuId != 0 { - i = encodeVarintRan(dAtA, i, uint64(m.GnbDuId)) - i-- - dAtA[i] = 0x48 - } - if len(m.NeighborCellIDs) > 0 { - for iNdEx := len(m.NeighborCellIDs) - 1; iNdEx >= 0; iNdEx-- { - { - size, err := m.NeighborCellIDs[iNdEx].MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintRan(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x42 - } - } - if len(m.KpiReports) > 0 { - for k := range m.KpiReports { - v := m.KpiReports[k] - baseI := i - i = encodeVarintRan(dAtA, i, uint64(v)) - i-- - dAtA[i] = 0x10 - i -= len(k) - copy(dAtA[i:], k) - i = encodeVarintRan(dAtA, i, uint64(len(k))) - i-- - dAtA[i] = 0xa - i = encodeVarintRan(dAtA, i, uint64(baseI-i)) - i-- - dAtA[i] = 0x3a - } - } - if m.PCI != 0 { - i = encodeVarintRan(dAtA, i, uint64(m.PCI)) - i-- - dAtA[i] = 0x30 - } - if len(m.CellType) > 0 { - i -= len(m.CellType) - copy(dAtA[i:], m.CellType) - i = encodeVarintRan(dAtA, i, uint64(len(m.CellType))) - i-- - dAtA[i] = 0x2a - } - if m.ARFCN != 0 { - i = encodeVarintRan(dAtA, i, uint64(m.ARFCN)) - i-- - dAtA[i] = 0x20 - } - if m.AntennaCount != 0 { - i = encodeVarintRan(dAtA, i, uint64(m.AntennaCount)) - i-- - dAtA[i] = 0x18 - } - if m.CellGlobalID != nil { - { - size, err := m.CellGlobalID.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintRan(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x12 - } - if len(m.CellObjectID) > 0 { - i -= len(m.CellObjectID) - copy(dAtA[i:], m.CellObjectID) - i = encodeVarintRan(dAtA, i, uint64(len(m.CellObjectID))) - i-- - dAtA[i] = 0xa - } - return len(dAtA) - i, nil } - -func (m *E2Cell_FddInfo) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) +func (m *FourGDrbId) XXX_Merge(src proto.Message) { + xxx_messageInfo_FourGDrbId.Merge(m, src) } - -func (m *E2Cell_FddInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - if m.FddInfo != nil { - { - size, err := m.FddInfo.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintRan(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x6a - } - return len(dAtA) - i, nil +func (m *FourGDrbId) XXX_Size() int { + return m.Size() } -func (m *E2Cell_TddInfo) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) +func (m *FourGDrbId) XXX_DiscardUnknown() { + xxx_messageInfo_FourGDrbId.DiscardUnknown(m) } -func (m *E2Cell_TddInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - if m.TddInfo != nil { - { - size, err := m.TddInfo.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintRan(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x72 +var xxx_messageInfo_FourGDrbId proto.InternalMessageInfo + +func (m *FourGDrbId) GetValue() int32 { + if m != nil { + return m.Value } - return len(dAtA) - i, nil + return 0 } -func (m *ConnectivitySupport) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { - return nil, err + +func (m *FourGDrbId) GetQci() *Qci { + if m != nil { + return m.Qci } - return dAtA[:n], nil + return nil } -func (m *ConnectivitySupport) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) +type Qci struct { + Value int32 `protobuf:"varint,1,opt,name=value,proto3" json:"value,omitempty"` } -func (m *ConnectivitySupport) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if m.EnDcSupport != 0 { - i = encodeVarintRan(dAtA, i, uint64(m.EnDcSupport)) - i-- - dAtA[i] = 0x8 - } - return len(dAtA) - i, nil +func (m *Qci) Reset() { *m = Qci{} } +func (m *Qci) String() string { return proto.CompactTextString(m) } +func (*Qci) ProtoMessage() {} +func (*Qci) Descriptor() ([]byte, []int) { + return fileDescriptor_23cc5f935e05bbb6, []int{97} } - -func (m *FDDInfo) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { - return nil, err +func (m *Qci) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *Qci) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_Qci.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil } - return dAtA[:n], nil } - -func (m *FDDInfo) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) +func (m *Qci) XXX_Merge(src proto.Message) { + xxx_messageInfo_Qci.Merge(m, src) +} +func (m *Qci) XXX_Size() int { + return m.Size() +} +func (m *Qci) XXX_DiscardUnknown() { + xxx_messageInfo_Qci.DiscardUnknown(m) } -func (m *FDDInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if m.DlTransmissionBandwidth != nil { - { - size, err := m.DlTransmissionBandwidth.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintRan(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x22 - } - if m.UlTransmissionBandwidth != nil { - { - size, err := m.UlTransmissionBandwidth.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintRan(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x1a - } - if m.DlFreqInfo != nil { - { - size, err := m.DlFreqInfo.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintRan(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x12 +var xxx_messageInfo_Qci proto.InternalMessageInfo + +func (m *Qci) GetValue() int32 { + if m != nil { + return m.Value } - if m.UlFreqInfo != nil { - { - size, err := m.UlFreqInfo.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintRan(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0xa - } - return len(dAtA) - i, nil + return 0 } -func (m *TDDInfo) Marshal() (dAtA []byte, err error) { +func init() { + proto.RegisterEnum("onos.topo.RANEntityKinds", RANEntityKinds_name, RANEntityKinds_value) + proto.RegisterEnum("onos.topo.RANRelationKinds", RANRelationKinds_name, RANRelationKinds_value) + proto.RegisterEnum("onos.topo.CellGlobalIDType", CellGlobalIDType_name, CellGlobalIDType_value) + proto.RegisterEnum("onos.topo.NodeType", NodeType_name, NodeType_value) + proto.RegisterEnum("onos.topo.ComponentType", ComponentType_name, ComponentType_value) + proto.RegisterEnum("onos.topo.ResourceType", ResourceType_name, ResourceType_value) + proto.RegisterEnum("onos.topo.SchedulerType", SchedulerType_name, SchedulerType_value) + proto.RegisterEnum("onos.topo.ChangeType", ChangeType_name, ChangeType_value) + proto.RegisterEnum("onos.topo.E2SmRsmCommand", E2SmRsmCommand_name, E2SmRsmCommand_value) + proto.RegisterEnum("onos.topo.RSMSlicingType", RSMSlicingType_name, RSMSlicingType_value) + proto.RegisterEnum("onos.topo.RSMSchedulerType", RSMSchedulerType_name, RSMSchedulerType_value) + proto.RegisterEnum("onos.topo.RSMSliceType", RSMSliceType_name, RSMSliceType_value) + proto.RegisterEnum("onos.topo.UeIdType", UeIdType_name, UeIdType_value) + proto.RegisterEnum("onos.topo.NrScs", NrScs_name, NrScs_value) + proto.RegisterEnum("onos.topo.Nrb", Nrb_name, Nrb_value) + proto.RegisterEnum("onos.topo.EnDcSupport", EnDcSupport_name, EnDcSupport_value) + proto.RegisterEnum("onos.topo.Interface_Type", Interface_Type_name, Interface_Type_value) + proto.RegisterType((*Location)(nil), "onos.topo.Location") + proto.RegisterType((*Wgs84Location)(nil), "onos.topo.Wgs84Location") + proto.RegisterType((*CartesianLocation)(nil), "onos.topo.CartesianLocation") + proto.RegisterType((*AzElOrientation)(nil), "onos.topo.AzElOrientation") + proto.RegisterType((*YprOrientation)(nil), "onos.topo.YprOrientation") + proto.RegisterType((*Orientation)(nil), "onos.topo.Orientation") + proto.RegisterType((*Waypoint)(nil), "onos.topo.Waypoint") + proto.RegisterType((*Waypoints)(nil), "onos.topo.Waypoints") + proto.RegisterType((*OrbitData)(nil), "onos.topo.OrbitData") + proto.RegisterType((*Motion)(nil), "onos.topo.Motion") + proto.RegisterType((*Coverage)(nil), "onos.topo.Coverage") + proto.RegisterType((*E2Node)(nil), "onos.topo.E2Node") + proto.RegisterMapType((map[string]*ServiceModelInfo)(nil), "onos.topo.E2Node.ServiceModelsEntry") + proto.RegisterType((*E2NodeConfig)(nil), "onos.topo.E2NodeConfig") + proto.RegisterType((*Lease)(nil), "onos.topo.Lease") + proto.RegisterType((*Interface)(nil), "onos.topo.Interface") + proto.RegisterType((*E2TInfo)(nil), "onos.topo.E2TInfo") + proto.RegisterType((*XAppInfo)(nil), "onos.topo.XAppInfo") + proto.RegisterType((*A1PolicyType)(nil), "onos.topo.A1PolicyType") + proto.RegisterType((*A1TInfo)(nil), "onos.topo.A1TInfo") + proto.RegisterType((*CellGlobalID)(nil), "onos.topo.CellGlobalID") + proto.RegisterType((*NeighborCellID)(nil), "onos.topo.NeighborCellID") + proto.RegisterType((*E2Cell)(nil), "onos.topo.E2Cell") + proto.RegisterMapType((map[string]uint32)(nil), "onos.topo.E2Cell.KpiReportsEntry") + proto.RegisterType((*ConnectivitySupport)(nil), "onos.topo.ConnectivitySupport") + proto.RegisterType((*FDDInfo)(nil), "onos.topo.FDDInfo") + proto.RegisterType((*TDDInfo)(nil), "onos.topo.TDDInfo") + proto.RegisterType((*FrequencyInfo)(nil), "onos.topo.FrequencyInfo") + proto.RegisterType((*TransmissionBandwidth)(nil), "onos.topo.TransmissionBandwidth") + proto.RegisterType((*FrequencyBandList)(nil), "onos.topo.FrequencyBandList") + proto.RegisterType((*FrequencyBandItem)(nil), "onos.topo.FrequencyBandItem") + proto.RegisterType((*GlobalNgRanNodeID)(nil), "onos.topo.GlobalNgRanNodeID") + proto.RegisterType((*GlobalGnbID)(nil), "onos.topo.GlobalGnbID") + proto.RegisterType((*GlobalNgEnbID)(nil), "onos.topo.GlobalNgEnbID") + proto.RegisterType((*TaiSupportList)(nil), "onos.topo.TaiSupportList") + proto.RegisterType((*TaiSupportItem)(nil), "onos.topo.TaiSupportItem") + proto.RegisterType((*XnBroadcastPlmn)(nil), "onos.topo.XnBroadcastPlmn") + proto.RegisterType((*TaiSliceSupportList)(nil), "onos.topo.TaiSliceSupportList") + proto.RegisterType((*SliceSupportItem)(nil), "onos.topo.SliceSupportItem") + proto.RegisterType((*SNssai)(nil), "onos.topo.SNssai") + proto.RegisterType((*AmfRegionInformation)(nil), "onos.topo.AmfRegionInformation") + proto.RegisterType((*GlobalAmfRegionInformationItem)(nil), "onos.topo.GlobalAmfRegionInformationItem") + proto.RegisterType((*NeighborInformationNr)(nil), "onos.topo.NeighborInformationNr") + proto.RegisterType((*ServiceModelInfo)(nil), "onos.topo.ServiceModelInfo") + proto.RegisterType((*RCRanFunction)(nil), "onos.topo.RCRanFunction") + proto.RegisterType((*MHORanFunction)(nil), "onos.topo.MHORanFunction") + proto.RegisterType((*CCCRanFunction)(nil), "onos.topo.CCCRanFunction") + proto.RegisterType((*KPMRanFunction)(nil), "onos.topo.KPMRanFunction") + proto.RegisterType((*RSMRanFunction)(nil), "onos.topo.RSMRanFunction") + proto.RegisterType((*RCEventTriggerStyle)(nil), "onos.topo.RCEventTriggerStyle") + proto.RegisterType((*RCReportStyle)(nil), "onos.topo.RCReportStyle") + proto.RegisterType((*RCInsertStyle)(nil), "onos.topo.RCInsertStyle") + proto.RegisterType((*RCPolicyStyle)(nil), "onos.topo.RCPolicyStyle") + proto.RegisterType((*PolicyAction)(nil), "onos.topo.PolicyAction") + proto.RegisterType((*RCControlStyle)(nil), "onos.topo.RCControlStyle") + proto.RegisterType((*ControlAction)(nil), "onos.topo.ControlAction") + proto.RegisterType((*InsertIndication)(nil), "onos.topo.InsertIndication") + proto.RegisterType((*RANParameter)(nil), "onos.topo.RANParameter") + proto.RegisterType((*RanconfigurationStructure)(nil), "onos.topo.RanconfigurationStructure") + proto.RegisterType((*Attribute)(nil), "onos.topo.Attribute") + proto.RegisterType((*RICServices)(nil), "onos.topo.RICServices") + proto.RegisterType((*CellsForRanfunctionDefinition)(nil), "onos.topo.CellsForRanfunctionDefinition") + proto.RegisterType((*CellForRanfunctionDefinition)(nil), "onos.topo.CellForRanfunctionDefinition") + proto.RegisterType((*CCCEventTriggerStyle)(nil), "onos.topo.CCCEventTriggerStyle") + proto.RegisterType((*CCCReportStyle)(nil), "onos.topo.CCCReportStyle") + proto.RegisterType((*CCCInsertStyle)(nil), "onos.topo.CCCInsertStyle") + proto.RegisterType((*CCCControlStyle)(nil), "onos.topo.CCCControlStyle") + proto.RegisterType((*CCCPolicyStyle)(nil), "onos.topo.CCCPolicyStyle") + proto.RegisterType((*Plmnidentity)(nil), "onos.topo.Plmnidentity") + proto.RegisterType((*Sst)(nil), "onos.topo.Sst") + proto.RegisterType((*Sd)(nil), "onos.topo.Sd") + proto.RegisterType((*SNSsai)(nil), "onos.topo.SNSsai") + proto.RegisterType((*RrmPolicyMember)(nil), "onos.topo.RrmPolicyMember") + proto.RegisterType((*RrmPolicyMemberList)(nil), "onos.topo.RrmPolicyMemberList") + proto.RegisterType((*ORRmpolicyRatio)(nil), "onos.topo.ORRmpolicyRatio") + proto.RegisterType((*ConfigurationStructure)(nil), "onos.topo.ConfigurationStructure") + proto.RegisterType((*ConfigurationStructureList)(nil), "onos.topo.ConfigurationStructureList") + proto.RegisterType((*KPMReportStyle)(nil), "onos.topo.KPMReportStyle") + proto.RegisterType((*MHOReportStyle)(nil), "onos.topo.MHOReportStyle") + proto.RegisterType((*KPMMeasurement)(nil), "onos.topo.KPMMeasurement") + proto.RegisterType((*RSMNodeSlicingCapabilityItem)(nil), "onos.topo.RSMNodeSlicingCapabilityItem") + proto.RegisterType((*RSMSupportedSlicingConfigItem)(nil), "onos.topo.RSMSupportedSlicingConfigItem") + proto.RegisterType((*RSMSliceItemList)(nil), "onos.topo.RSMSliceItemList") + proto.RegisterType((*RSMSlicingItem)(nil), "onos.topo.RSMSlicingItem") + proto.RegisterType((*RSMSliceParameters)(nil), "onos.topo.RSMSliceParameters") + proto.RegisterType((*DuUeF1ApID)(nil), "onos.topo.DuUeF1apID") + proto.RegisterType((*CuUeF1ApID)(nil), "onos.topo.CuUeF1apID") + proto.RegisterType((*RanUeNgapID)(nil), "onos.topo.RanUeNgapID") + proto.RegisterType((*EnbUeS1ApID)(nil), "onos.topo.EnbUeS1apID") + proto.RegisterType((*AmfUeNgapID)(nil), "onos.topo.AmfUeNgapID") + proto.RegisterType((*UeIdentity)(nil), "onos.topo.UeIdentity") + proto.RegisterType((*DrbId)(nil), "onos.topo.DrbId") + proto.RegisterType((*FiveGDrbId)(nil), "onos.topo.FiveGDrbId") + proto.RegisterType((*Qfi)(nil), "onos.topo.Qfi") + proto.RegisterType((*QoSflowLevelParameters)(nil), "onos.topo.QoSflowLevelParameters") + proto.RegisterType((*DynamicFiveQi)(nil), "onos.topo.DynamicFiveQi") + proto.RegisterType((*NonDynamicFiveQi)(nil), "onos.topo.NonDynamicFiveQi") + proto.RegisterType((*FiveQi)(nil), "onos.topo.FiveQi") + proto.RegisterType((*FourGDrbId)(nil), "onos.topo.FourGDrbId") + proto.RegisterType((*Qci)(nil), "onos.topo.Qci") +} + +func init() { proto.RegisterFile("onos/topo/ran.proto", fileDescriptor_23cc5f935e05bbb6) } + +var fileDescriptor_23cc5f935e05bbb6 = []byte{ + // 5724 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x7b, 0x4d, 0x6c, 0x1b, 0x49, + 0x76, 0xbf, 0x9a, 0x14, 0xf5, 0xf1, 0xf8, 0xa1, 0x56, 0x49, 0x96, 0x65, 0xd9, 0x96, 0x3c, 0x3d, + 0xfb, 0x9f, 0x99, 0x15, 0x66, 0x6d, 0x4b, 0x9e, 0xf1, 0x7c, 0xac, 0x3d, 0xb3, 0x64, 0x93, 0xb2, + 0xb8, 0x96, 0x28, 0xb9, 0x48, 0xed, 0x7c, 0xfc, 0xff, 0xbb, 0x8d, 0x56, 0x77, 0x91, 0xee, 0x1d, + 0xb2, 0x9b, 0xd3, 0xdd, 0xb4, 0xad, 0xf9, 0x23, 0x09, 0x16, 0x59, 0x24, 0xd8, 0x43, 0x90, 0x3d, + 0x26, 0x97, 0x9c, 0x82, 0xdc, 0x82, 0xe4, 0x90, 0x6b, 0x0e, 0x01, 0x82, 0xec, 0x1e, 0x37, 0xb7, + 0x20, 0x01, 0x94, 0x40, 0x73, 0xcf, 0x21, 0xd8, 0x43, 0x30, 0x08, 0x82, 0xa0, 0x3e, 0xba, 0xbb, + 0x9a, 0x6c, 0x69, 0xe4, 0xd9, 0x45, 0x4e, 0xec, 0x7a, 0xef, 0xf7, 0x5e, 0xbd, 0x7a, 0xf5, 0xaa, + 0xde, 0xab, 0xea, 0x26, 0x2c, 0x79, 0xae, 0x17, 0xdc, 0x09, 0xbd, 0xa1, 0x77, 0xc7, 0x37, 0xdd, + 0xdb, 0x43, 0xdf, 0x0b, 0x3d, 0x34, 0x4f, 0x89, 0xb7, 0x29, 0x71, 0xed, 0x5a, 0xcf, 0xf3, 0x7a, + 0x7d, 0x72, 0x87, 0x31, 0x8e, 0x47, 0xdd, 0x3b, 0xa6, 0x7b, 0xc2, 0x51, 0x6b, 0xcb, 0x3d, 0xaf, + 0xe7, 0xb1, 0xc7, 0x3b, 0xf4, 0x49, 0x50, 0x37, 0xc6, 0x05, 0x42, 0x67, 0x40, 0x82, 0xd0, 0x1c, + 0x0c, 0x05, 0xe0, 0xfa, 0x38, 0x80, 0x0c, 0x86, 0xa1, 0xd0, 0xa9, 0xfd, 0xa5, 0x02, 0x73, 0x7b, + 0x9e, 0x65, 0x86, 0x8e, 0xe7, 0xa2, 0x65, 0xc8, 0xf7, 0xcd, 0x70, 0x55, 0xb9, 0xa5, 0xbc, 0xa1, + 0xd4, 0x72, 0xab, 0x0a, 0xa6, 0x4d, 0x46, 0x75, 0x7b, 0xab, 0x39, 0x89, 0xea, 0xf6, 0xd0, 0x5d, + 0x28, 0x3c, 0xef, 0x05, 0xef, 0xbe, 0xb5, 0x9a, 0xbf, 0xa5, 0xbc, 0x51, 0xdc, 0x5e, 0xbd, 0x1d, + 0x0f, 0xe1, 0xf6, 0x47, 0x94, 0x1e, 0x29, 0xdd, 0x9d, 0xc2, 0x1c, 0x88, 0x1e, 0xc0, 0xbc, 0x65, + 0xfa, 0x21, 0x09, 0x1c, 0xd3, 0x5d, 0x9d, 0x66, 0x52, 0x37, 0x24, 0x29, 0x3d, 0xe2, 0x49, 0x92, + 0x89, 0x40, 0xad, 0x00, 0x79, 0xf2, 0x22, 0xd4, 0x9e, 0x41, 0x39, 0xa5, 0x1e, 0xbd, 0x02, 0xa5, + 0xbe, 0x19, 0x3a, 0xe1, 0xc8, 0x26, 0x86, 0x4d, 0x7a, 0xdc, 0x78, 0x5c, 0x8c, 0x68, 0x75, 0xd2, + 0x43, 0xaf, 0x42, 0xb9, 0xef, 0xb9, 0xbd, 0x04, 0xc3, 0x86, 0x82, 0x4b, 0x31, 0x91, 0x82, 0x6e, + 0x02, 0x98, 0x7d, 0xa1, 0x67, 0xc0, 0x06, 0xa5, 0xe0, 0xf9, 0x88, 0xb2, 0xaf, 0xed, 0xc0, 0xe2, + 0x84, 0x81, 0x68, 0x01, 0xf2, 0x2f, 0x8c, 0x81, 0xe8, 0x32, 0xf7, 0x62, 0x9f, 0x12, 0x4e, 0x8c, + 0x81, 0xd0, 0x9f, 0x3b, 0x61, 0x84, 0x2f, 0x62, 0x75, 0xb9, 0x2f, 0xf6, 0xb5, 0x2f, 0x60, 0xa1, + 0xfa, 0x45, 0xa3, 0x7f, 0xe0, 0x3b, 0xc4, 0x0d, 0xb9, 0x96, 0x0d, 0x28, 0x9a, 0x5f, 0x38, 0x83, + 0x51, 0xf8, 0x54, 0x1a, 0x00, 0x08, 0x92, 0xb0, 0x9f, 0xf4, 0xc9, 0x33, 0x86, 0x96, 0xed, 0x8f, + 0x89, 0x14, 0xf4, 0x0a, 0x94, 0x7c, 0x2f, 0x4c, 0x30, 0xbc, 0xcb, 0x62, 0x44, 0xab, 0x93, 0x9e, + 0x66, 0x42, 0xe5, 0x93, 0xa1, 0x2f, 0x77, 0x7d, 0x15, 0x66, 0x4f, 0xcc, 0xe7, 0x52, 0xb7, 0x33, + 0x27, 0xe6, 0x73, 0xaa, 0xed, 0x3a, 0xcc, 0x0f, 0x9d, 0xd0, 0x7a, 0x2a, 0x75, 0x37, 0xc7, 0x08, + 0x94, 0x79, 0x0d, 0xe6, 0x7c, 0xaf, 0xdf, 0x97, 0xba, 0x99, 0xa5, 0x6d, 0xda, 0xc5, 0xef, 0x40, + 0x51, 0xd6, 0x7f, 0x17, 0xa6, 0xcd, 0x2f, 0x48, 0x9f, 0x29, 0x2f, 0x6e, 0xaf, 0x49, 0xb3, 0x3d, + 0xe6, 0x84, 0xdd, 0x29, 0xcc, 0x90, 0xe8, 0x3b, 0x90, 0x3f, 0x19, 0xfa, 0xac, 0xcb, 0xe2, 0xf6, + 0x35, 0x49, 0x20, 0x6d, 0xf9, 0xee, 0x14, 0xa6, 0xb8, 0x5a, 0x19, 0x8a, 0x5e, 0x42, 0xd5, 0x3e, + 0x83, 0xb9, 0x8f, 0xcc, 0x93, 0xa1, 0xe7, 0xb8, 0x21, 0xba, 0x0d, 0xd3, 0x74, 0x25, 0xc4, 0x7d, + 0xf3, 0x55, 0x70, 0x3b, 0x5a, 0x05, 0xb7, 0x3b, 0xd1, 0x32, 0xc1, 0x0c, 0x87, 0xee, 0xc0, 0x5c, + 0x5f, 0x4c, 0xac, 0xe8, 0x7e, 0x49, 0xea, 0x3e, 0x9a, 0x73, 0x1c, 0x83, 0xb4, 0x07, 0x30, 0x1f, + 0x75, 0x16, 0x50, 0xe9, 0xe7, 0xa2, 0xb1, 0xaa, 0xdc, 0xca, 0x8f, 0x49, 0x47, 0x38, 0x1c, 0x83, + 0xb4, 0x5f, 0x2b, 0x30, 0x7f, 0xe0, 0x1f, 0x3b, 0x61, 0xdd, 0x0c, 0x4d, 0xba, 0x9a, 0xc8, 0xd0, + 0xb3, 0x9e, 0x5e, 0xc2, 0x5a, 0x0e, 0x44, 0xaf, 0xc3, 0x82, 0xe3, 0x5a, 0x7d, 0xc7, 0x1d, 0x0f, + 0x8b, 0x8a, 0x44, 0x8e, 0x66, 0xcb, 0x34, 0xdd, 0xd4, 0x6c, 0x99, 0x26, 0x63, 0x95, 0x40, 0x21, + 0x6c, 0x25, 0x2a, 0x58, 0x21, 0x34, 0x82, 0x4c, 0xbf, 0x37, 0x1a, 0x10, 0x37, 0x64, 0xe0, 0x02, + 0x8f, 0xa0, 0x88, 0x46, 0x05, 0x68, 0xa8, 0xba, 0xde, 0xc0, 0xec, 0x9f, 0x30, 0xc4, 0x8c, 0x08, + 0x55, 0x4e, 0x12, 0x80, 0x01, 0x31, 0x5d, 0x63, 0xe0, 0x31, 0x3f, 0xce, 0x72, 0x00, 0x25, 0xed, + 0x33, 0x8a, 0xf6, 0x37, 0x0a, 0xcc, 0xf0, 0x47, 0xf4, 0x00, 0x2a, 0x5d, 0xe7, 0x05, 0xb1, 0x8d, + 0xd8, 0xed, 0xca, 0xb9, 0x6e, 0xdf, 0x9d, 0xc2, 0x65, 0x06, 0x8e, 0xd7, 0xde, 0x5b, 0x30, 0x1f, + 0xf9, 0x32, 0x10, 0xf3, 0xb5, 0x9c, 0xe1, 0xf1, 0x80, 0xee, 0x22, 0x31, 0x10, 0xbd, 0x09, 0x05, + 0x8f, 0x3a, 0x5d, 0xec, 0x5a, 0xb2, 0x44, 0x3c, 0x19, 0x74, 0xc7, 0x62, 0xa0, 0xda, 0x1c, 0xcc, + 0xf0, 0x81, 0x68, 0x03, 0x98, 0xd3, 0xbd, 0x67, 0xc4, 0x37, 0x7b, 0x04, 0xad, 0xc0, 0xcc, 0x53, + 0xe2, 0xf4, 0x9e, 0xf2, 0x8d, 0xb2, 0x80, 0x45, 0x8b, 0xae, 0x19, 0xd3, 0xb7, 0x8c, 0xe7, 0x8e, + 0x1d, 0x3e, 0x65, 0x16, 0x15, 0xf0, 0x9c, 0xe9, 0x5b, 0x1f, 0xd1, 0x36, 0x5a, 0x85, 0x59, 0xb1, + 0xa2, 0x59, 0xd7, 0x05, 0x1c, 0x35, 0x11, 0xa2, 0x71, 0xda, 0x0f, 0xd9, 0x3c, 0x14, 0x30, 0x7b, + 0x66, 0x5e, 0x6a, 0x6c, 0xb7, 0x3c, 0x9b, 0xa0, 0xc7, 0x50, 0x09, 0x88, 0xff, 0xcc, 0xb1, 0x88, + 0x31, 0xf0, 0x6c, 0xd2, 0x0f, 0x44, 0x78, 0x7d, 0x4b, 0x32, 0x9d, 0x43, 0x6f, 0xb7, 0x39, 0x6e, + 0x9f, 0xc1, 0x1a, 0x6e, 0xe8, 0x9f, 0xe0, 0x72, 0x20, 0xd3, 0xd6, 0x7e, 0x08, 0x68, 0x12, 0x84, + 0x54, 0xc8, 0x7f, 0x46, 0x4e, 0xd8, 0x68, 0xe6, 0x31, 0x7d, 0x44, 0x5b, 0x50, 0x78, 0x66, 0xf6, + 0x47, 0x44, 0x38, 0xf6, 0xba, 0xd4, 0x97, 0x2c, 0xdf, 0x74, 0xbb, 0x1e, 0xe6, 0xc8, 0xf7, 0x73, + 0xef, 0x2a, 0x5a, 0x17, 0x4a, 0xdc, 0x14, 0xdd, 0x73, 0xbb, 0x4e, 0x0f, 0x3d, 0x80, 0xa2, 0xe5, + 0xb9, 0x2e, 0xb1, 0xa8, 0x0f, 0x23, 0xc3, 0x65, 0x9f, 0x37, 0xdd, 0x90, 0xf8, 0x5d, 0xd3, 0x22, + 0xb5, 0xe9, 0x5f, 0x9e, 0x6e, 0x4c, 0x61, 0x19, 0x4e, 0x5d, 0xf6, 0x8c, 0xf8, 0x41, 0xb4, 0x1e, + 0xa7, 0x71, 0xd4, 0xd4, 0x9a, 0x50, 0xd8, 0x23, 0x66, 0x40, 0xd0, 0xf7, 0x00, 0xc8, 0x8b, 0xa1, + 0xe3, 0xcb, 0xe1, 0x73, 0xc1, 0xda, 0xa9, 0x4d, 0xff, 0xfc, 0x5f, 0x37, 0x14, 0x2c, 0xc9, 0x68, + 0xff, 0xa1, 0xc0, 0x7c, 0x6c, 0x05, 0xfa, 0x0e, 0x4c, 0x87, 0x27, 0x43, 0xbe, 0x67, 0x54, 0x52, + 0xdb, 0x4f, 0x8c, 0xb9, 0xdd, 0x39, 0x19, 0x12, 0xcc, 0x60, 0x68, 0x05, 0x72, 0xce, 0x90, 0x19, + 0x37, 0x5f, 0x9b, 0x39, 0x3b, 0xdd, 0xc8, 0x35, 0x0f, 0x71, 0xce, 0x19, 0xd2, 0x29, 0x1d, 0x7a, + 0x3e, 0x0f, 0xb2, 0x32, 0x66, 0xcf, 0xda, 0xcf, 0x14, 0x98, 0xa6, 0xa2, 0xe8, 0x0a, 0x2c, 0x36, + 0x5b, 0x9d, 0x06, 0xde, 0xa9, 0xea, 0x0d, 0xe3, 0xa8, 0xf5, 0xb8, 0x75, 0xf0, 0x51, 0x4b, 0x9d, + 0x42, 0x8b, 0x50, 0x4e, 0xc8, 0x8d, 0xed, 0x8e, 0xaa, 0xa4, 0x91, 0x8d, 0xed, 0xea, 0xe1, 0xd6, + 0xdd, 0x2d, 0x35, 0x37, 0x49, 0xde, 0xbe, 0x7b, 0x57, 0xcd, 0xa7, 0xc9, 0xd5, 0x2d, 0xe3, 0xe3, + 0xea, 0xe1, 0xa1, 0x3a, 0x8d, 0x10, 0x54, 0x64, 0x72, 0xf5, 0x50, 0x2d, 0x68, 0x1f, 0xc2, 0x6c, + 0x63, 0xbb, 0x43, 0x67, 0x0f, 0xbd, 0x05, 0xe0, 0x44, 0x43, 0xbb, 0x70, 0x86, 0xb0, 0x84, 0xd3, + 0x7e, 0xa2, 0xc0, 0xdc, 0xc7, 0xd5, 0xe1, 0xf0, 0x9b, 0xab, 0x40, 0x1f, 0xc2, 0x82, 0xb9, 0x65, + 0x0c, 0xbd, 0xbe, 0x63, 0x9d, 0x18, 0xd4, 0x9b, 0x74, 0x15, 0x53, 0xd1, 0xab, 0x72, 0x96, 0xd8, + 0x3a, 0x64, 0x00, 0xe6, 0xf3, 0xb2, 0x29, 0xb5, 0x02, 0xed, 0xdf, 0x15, 0x28, 0xc9, 0x7c, 0xf4, + 0x1a, 0xe4, 0x1c, 0x9b, 0x47, 0x71, 0x6d, 0x85, 0xcd, 0x46, 0xfd, 0xab, 0xd3, 0x8d, 0x52, 0x82, + 0x68, 0xd6, 0x71, 0xce, 0xb1, 0x69, 0x62, 0x70, 0xcd, 0x01, 0x11, 0xf3, 0xb6, 0x76, 0x76, 0xba, + 0x31, 0xdd, 0x32, 0x07, 0xe4, 0xab, 0xd3, 0x8d, 0x4a, 0x82, 0xa5, 0x14, 0xcc, 0x70, 0xe8, 0xfd, + 0x24, 0x0e, 0xf3, 0x4c, 0xe4, 0xd6, 0xd9, 0xe9, 0xc6, 0xec, 0x0f, 0x38, 0xe9, 0xab, 0xd3, 0x8d, + 0xc5, 0x44, 0x4a, 0x10, 0xe3, 0x48, 0x45, 0xdf, 0x87, 0xa2, 0x4d, 0x02, 0xcb, 0x77, 0x86, 0x2c, + 0x42, 0xa7, 0x99, 0xfc, 0x1b, 0x67, 0xa7, 0x1b, 0xc5, 0x7a, 0x42, 0xfe, 0xea, 0x74, 0xe3, 0x4a, + 0xa2, 0x43, 0x62, 0x60, 0x59, 0x98, 0xce, 0x5a, 0x75, 0xeb, 0x37, 0x99, 0xb5, 0x23, 0x28, 0xe9, + 0xa4, 0xdf, 0x7f, 0xd4, 0xf7, 0x8e, 0xcd, 0x7e, 0xb3, 0x8e, 0x96, 0xa3, 0x55, 0xce, 0x57, 0x3e, + 0x6f, 0xa0, 0x3b, 0x62, 0x0d, 0xe4, 0xd8, 0x1a, 0x90, 0x97, 0xbe, 0x2c, 0x9c, 0xac, 0x02, 0xed, + 0x0f, 0x14, 0xa8, 0xb4, 0xe8, 0x16, 0x78, 0xec, 0xf9, 0x14, 0xd2, 0xac, 0xa3, 0x03, 0xa8, 0x58, + 0xa4, 0xdf, 0x37, 0x7a, 0x0c, 0x6d, 0x88, 0x69, 0x49, 0xcf, 0xad, 0xac, 0xad, 0xa6, 0x9e, 0x9d, + 0x6e, 0xa4, 0x8c, 0xc3, 0x25, 0x2b, 0x69, 0xd9, 0xe8, 0x55, 0x98, 0x1d, 0xf6, 0x07, 0x2e, 0xd5, + 0xc4, 0xa7, 0x0d, 0xce, 0x4e, 0x37, 0x66, 0x0e, 0xfb, 0x03, 0xb7, 0x59, 0xc7, 0x33, 0x94, 0xd5, + 0xb4, 0xb5, 0x7f, 0x99, 0xa7, 0xbb, 0x26, 0xd5, 0x82, 0xee, 0x0b, 0x03, 0xbc, 0xe3, 0x1f, 0x13, + 0x2b, 0x34, 0xe2, 0xb8, 0x88, 0xfb, 0x39, 0x60, 0x8c, 0xa8, 0x1f, 0xd1, 0xb2, 0x33, 0x0c, 0xcf, + 0xfd, 0xa6, 0x86, 0x97, 0x4d, 0x37, 0x24, 0xae, 0x6b, 0x1a, 0x96, 0x37, 0x72, 0xa3, 0x3d, 0xa1, + 0x24, 0x88, 0x3a, 0xa5, 0xa1, 0x0d, 0x28, 0x98, 0x7e, 0xd7, 0xe2, 0xf1, 0x51, 0xae, 0xcd, 0x9f, + 0x9d, 0x6e, 0x14, 0xaa, 0x78, 0x47, 0x6f, 0x61, 0x4e, 0xa7, 0xa9, 0x85, 0x99, 0xc5, 0x26, 0xa6, + 0xc0, 0x66, 0x6b, 0x8e, 0x12, 0x58, 0xdc, 0x5f, 0x83, 0xfc, 0xd0, 0x72, 0x58, 0x32, 0x2e, 0xd7, + 0x66, 0xcf, 0x4e, 0x37, 0xf2, 0x87, 0x7a, 0x13, 0x53, 0x1a, 0xc2, 0x50, 0xfc, 0x6c, 0xe8, 0x18, + 0x3e, 0xa1, 0x5b, 0x50, 0xb0, 0x3a, 0xcb, 0x02, 0xe5, 0x95, 0x54, 0xe6, 0xa0, 0xb6, 0xdf, 0x7e, + 0x3c, 0x74, 0x30, 0xc7, 0xb0, 0x8c, 0x50, 0xab, 0x9c, 0x9d, 0x6e, 0x40, 0x42, 0xc4, 0xf0, 0x59, + 0xfc, 0x8c, 0x3e, 0x85, 0x45, 0x57, 0xcc, 0xb6, 0xc1, 0x8c, 0x72, 0xec, 0x60, 0x75, 0x8e, 0x69, + 0x96, 0x37, 0xcc, 0x74, 0x44, 0xd4, 0x96, 0xce, 0x4e, 0x37, 0x16, 0xd2, 0xb4, 0x00, 0x2f, 0xb8, + 0x32, 0xc1, 0x0e, 0xd0, 0x1a, 0xcc, 0xf7, 0xdc, 0x63, 0xc3, 0x1e, 0x51, 0xcf, 0xcf, 0x33, 0x4f, + 0xcd, 0xf6, 0xdc, 0xe3, 0xfa, 0xa8, 0x69, 0xa3, 0x37, 0x01, 0xf5, 0xcd, 0x90, 0x04, 0xa1, 0xe1, + 0xfb, 0x96, 0x11, 0xad, 0x48, 0x60, 0x20, 0x95, 0x73, 0xb0, 0x6f, 0x89, 0x15, 0x48, 0x2b, 0xdb, + 0x28, 0x60, 0x8a, 0x0c, 0x22, 0x82, 0x84, 0x56, 0x39, 0x34, 0x27, 0x12, 0xdb, 0xa0, 0x84, 0x60, + 0xb5, 0x74, 0x2b, 0xff, 0x46, 0x19, 0x17, 0x39, 0x8d, 0x06, 0x14, 0xab, 0xe5, 0xba, 0xb6, 0x6d, + 0x38, 0x6e, 0xd7, 0x5b, 0x2d, 0xb3, 0xe9, 0x47, 0xd2, 0xc0, 0x76, 0xea, 0x75, 0xba, 0x06, 0x77, + 0xa7, 0xf0, 0x6c, 0xd7, 0xb6, 0xd9, 0x72, 0xbc, 0x03, 0x73, 0x61, 0x24, 0x50, 0x99, 0x10, 0xe8, + 0x24, 0x02, 0xa1, 0x10, 0xd8, 0x85, 0x5b, 0x03, 0x62, 0x06, 0x23, 0x9f, 0xb0, 0x6a, 0x2b, 0x74, + 0x06, 0x8e, 0xdb, 0x33, 0x2c, 0x96, 0x35, 0x47, 0x22, 0x9b, 0x2d, 0x30, 0xb3, 0xd7, 0x25, 0x5c, + 0x87, 0xc1, 0x74, 0x19, 0x85, 0x5a, 0x70, 0x45, 0xc4, 0xaa, 0xdb, 0x33, 0x7c, 0xd3, 0x35, 0x5c, + 0xcf, 0x26, 0x74, 0xd4, 0xea, 0xc4, 0x01, 0x8b, 0xc7, 0x64, 0xab, 0x87, 0x4d, 0x97, 0xe6, 0xe8, + 0x66, 0x1d, 0x2f, 0xf6, 0xc6, 0x48, 0x36, 0xd2, 0x41, 0x0d, 0x4d, 0xc7, 0x08, 0x46, 0x43, 0x3a, + 0xdb, 0x46, 0xdf, 0x09, 0xc2, 0xd5, 0xc5, 0x89, 0x62, 0xbc, 0x63, 0x3a, 0x6d, 0x8e, 0xd8, 0x73, + 0x82, 0x10, 0x57, 0xc2, 0x54, 0x1b, 0x1d, 0xc1, 0x8a, 0x39, 0xe8, 0x1a, 0x3e, 0xe9, 0xd1, 0xd2, + 0x94, 0xba, 0xc5, 0x1f, 0xf0, 0x41, 0x21, 0xa6, 0x6a, 0x43, 0xde, 0xe2, 0x07, 0x5d, 0xcc, 0x70, + 0xcd, 0x04, 0x86, 0x97, 0xcd, 0x0c, 0x2a, 0x7a, 0x02, 0xcb, 0x51, 0x7d, 0xf0, 0xcc, 0x09, 0x4f, + 0x22, 0x23, 0x57, 0x97, 0x98, 0xd2, 0x75, 0x79, 0x89, 0x4a, 0x30, 0x61, 0x18, 0x5e, 0xb2, 0x26, + 0x89, 0xe8, 0x53, 0x58, 0x8d, 0x83, 0x59, 0xb2, 0xd3, 0x70, 0xfd, 0x60, 0x75, 0x99, 0xc5, 0xf4, + 0xad, 0x8c, 0x98, 0x96, 0x8c, 0x6a, 0xf9, 0x78, 0xc5, 0xcd, 0x22, 0x07, 0x6b, 0x0f, 0x61, 0x61, + 0x6c, 0x5d, 0x65, 0x54, 0x5a, 0xcb, 0x72, 0xa5, 0x55, 0x96, 0x8a, 0xa9, 0x5a, 0x05, 0x4a, 0xae, + 0xcf, 0x6a, 0x3e, 0x66, 0x99, 0xf6, 0x04, 0x96, 0x32, 0x86, 0x85, 0xde, 0x87, 0x32, 0x71, 0x0d, + 0xdb, 0x8a, 0xbd, 0xc1, 0x6b, 0x97, 0x15, 0x79, 0x91, 0xbb, 0x75, 0x2b, 0xf2, 0x42, 0x91, 0x24, + 0x0d, 0xed, 0x6f, 0x73, 0x30, 0x2b, 0xc2, 0x19, 0xbd, 0x0f, 0xa5, 0x51, 0xdf, 0xe8, 0xfa, 0xe4, + 0x73, 0x1e, 0xc7, 0xca, 0xc4, 0xb1, 0x7e, 0xc7, 0x27, 0x9f, 0x8f, 0x88, 0x6b, 0x9d, 0xb0, 0xb2, + 0x0f, 0x46, 0x7d, 0x4a, 0x88, 0x64, 0x6d, 0x59, 0x36, 0xf7, 0x75, 0xb2, 0x76, 0x22, 0xfb, 0xff, + 0xe0, 0xda, 0xa8, 0x6f, 0x84, 0xbe, 0xe9, 0x06, 0x03, 0x27, 0xa0, 0x6b, 0xd7, 0x38, 0x36, 0x5d, + 0x9b, 0x57, 0xd1, 0xbc, 0x4a, 0x97, 0xa7, 0xa0, 0x23, 0x01, 0x6b, 0x11, 0x0e, 0x5f, 0x1d, 0xf5, + 0x33, 0x19, 0x54, 0xbb, 0x7d, 0xae, 0xf6, 0xe9, 0xcb, 0x6a, 0xb7, 0xb3, 0xb5, 0x6b, 0x7f, 0xa6, + 0xc0, 0x6c, 0x27, 0xf1, 0x9f, 0xeb, 0xbf, 0x8c, 0xff, 0x5c, 0x3f, 0xf6, 0xc1, 0x47, 0xb0, 0x72, + 0x8e, 0x89, 0xb9, 0x4b, 0x9a, 0x78, 0x25, 0xcc, 0x34, 0xf0, 0x05, 0x94, 0x53, 0xbd, 0xd2, 0xc3, + 0xa0, 0xeb, 0x1b, 0x3c, 0xd9, 0x28, 0x7c, 0x7f, 0x75, 0xfd, 0x2a, 0xcb, 0x31, 0x7b, 0xb0, 0xd4, + 0x8d, 0xb0, 0xcc, 0x02, 0xbe, 0xf8, 0x73, 0x13, 0xfb, 0x48, 0xac, 0x91, 0xf6, 0xc3, 0xd6, 0xff, + 0x62, 0x77, 0x9c, 0xa4, 0x1d, 0xc3, 0x95, 0xec, 0x19, 0x79, 0x1d, 0x66, 0x5c, 0xdf, 0x08, 0xac, + 0x40, 0x04, 0xaa, 0x2a, 0xaf, 0x2f, 0xbf, 0x6d, 0x05, 0xb8, 0xe0, 0xd2, 0x1f, 0x74, 0x0b, 0xf2, + 0xae, 0x7f, 0x2c, 0xca, 0x90, 0x4a, 0x0a, 0x75, 0x8c, 0x29, 0x4b, 0xb3, 0x60, 0x71, 0xc2, 0x16, + 0xd4, 0x82, 0xe5, 0xb1, 0x61, 0x38, 0x21, 0x19, 0x44, 0x45, 0xd2, 0xb9, 0xe3, 0x68, 0x86, 0x64, + 0x80, 0x51, 0x77, 0x9c, 0x14, 0x68, 0x1f, 0x8e, 0x75, 0x42, 0xa9, 0x68, 0x13, 0x16, 0xc5, 0x64, + 0x27, 0xfd, 0x08, 0x7f, 0x2e, 0xf0, 0x79, 0x8d, 0xf1, 0xda, 0x5f, 0x29, 0xb0, 0x38, 0xb1, 0xf5, + 0xa2, 0x07, 0x50, 0x16, 0xfb, 0x36, 0x4d, 0x78, 0x71, 0x81, 0xb4, 0x32, 0xb1, 0x5f, 0x3f, 0x72, + 0x8f, 0x9b, 0xf5, 0xdd, 0x29, 0x5c, 0xec, 0xc5, 0x4d, 0xb6, 0x4b, 0x27, 0xbb, 0x3e, 0xe1, 0x0a, + 0x26, 0x17, 0x5d, 0xd4, 0x6b, 0x43, 0xa8, 0x28, 0xf7, 0x24, 0x82, 0x5d, 0xbb, 0x7a, 0x4e, 0xea, + 0xd0, 0xfe, 0x2f, 0x14, 0xa5, 0xbe, 0xe5, 0x54, 0xaa, 0xa4, 0x52, 0xe9, 0x15, 0x98, 0xe9, 0x25, + 0x7d, 0x97, 0x71, 0xa1, 0xc7, 0x8c, 0xbb, 0x01, 0xc0, 0xc9, 0x46, 0x9f, 0xb8, 0xa2, 0xde, 0x99, + 0x63, 0xac, 0x3d, 0xe2, 0x6a, 0x7f, 0xaf, 0x40, 0x39, 0x65, 0xd8, 0xf9, 0xfa, 0x5f, 0x87, 0x85, + 0x81, 0x69, 0xf9, 0xde, 0xd8, 0x20, 0xcb, 0xbb, 0x53, 0xb8, 0xc4, 0x18, 0x62, 0x24, 0x68, 0x1b, + 0xae, 0x04, 0x4f, 0x69, 0xba, 0x1a, 0x87, 0xe7, 0x05, 0x7c, 0x91, 0xb1, 0xf7, 0x65, 0x99, 0xbb, + 0xb0, 0xdc, 0xf7, 0xdc, 0xde, 0x84, 0xc8, 0xb4, 0x10, 0x51, 0x29, 0x57, 0x96, 0xa8, 0x15, 0x61, + 0x3e, 0x86, 0x69, 0x1f, 0x41, 0x25, 0x9d, 0x04, 0x51, 0x03, 0x16, 0xe5, 0xcc, 0x29, 0x47, 0x5d, + 0x76, 0xea, 0x64, 0x21, 0xb7, 0x10, 0xa6, 0xda, 0x81, 0xd6, 0x93, 0x15, 0xb3, 0x60, 0x53, 0x21, + 0x1f, 0x9a, 0x96, 0xf0, 0x0d, 0x7d, 0x44, 0x3a, 0x2c, 0x1c, 0xfb, 0x9e, 0x69, 0x5b, 0x66, 0x10, + 0x8a, 0x32, 0x86, 0x9f, 0x9d, 0xe4, 0x1b, 0xb6, 0x8f, 0xdd, 0x5a, 0x84, 0xa1, 0x65, 0x0d, 0xae, + 0x1c, 0xcb, 0xcd, 0x40, 0xfb, 0x3d, 0x58, 0x18, 0x83, 0x9c, 0x3f, 0x13, 0x6d, 0x58, 0x61, 0x63, + 0xeb, 0x3b, 0x16, 0x49, 0xd7, 0x06, 0xb9, 0x89, 0xdc, 0x4b, 0xad, 0xa7, 0x38, 0xb9, 0x40, 0x58, + 0x0a, 0x27, 0x89, 0xda, 0x31, 0x2c, 0x65, 0x60, 0xd1, 0x63, 0x58, 0x4a, 0xf7, 0x23, 0x7b, 0x32, + 0x75, 0x13, 0x21, 0x49, 0x32, 0x5f, 0x2e, 0x06, 0x63, 0x94, 0x40, 0xfb, 0x00, 0xd4, 0x71, 0x18, + 0xda, 0x84, 0xd9, 0xc0, 0x70, 0x83, 0xc0, 0x74, 0xc4, 0xa2, 0x5b, 0x94, 0x95, 0xb6, 0x28, 0x03, + 0xcf, 0x04, 0xec, 0x57, 0xdb, 0x84, 0x19, 0x4e, 0xa1, 0xb3, 0x10, 0x04, 0x61, 0x34, 0x0b, 0x41, + 0x10, 0xa2, 0x0a, 0xe4, 0x82, 0x28, 0xf4, 0x73, 0x81, 0xad, 0xfd, 0xb1, 0x02, 0xcb, 0x59, 0xd5, + 0x0c, 0x7a, 0x0e, 0xaf, 0x8a, 0x85, 0x96, 0x5d, 0x15, 0xa5, 0x46, 0xf8, 0xed, 0x89, 0x05, 0x9c, + 0xa5, 0x93, 0x8d, 0x77, 0xa3, 0x77, 0x21, 0x3f, 0xd0, 0x7e, 0x08, 0xeb, 0x17, 0xab, 0x38, 0x7f, + 0xc6, 0x35, 0x28, 0xcb, 0xc6, 0x46, 0xe3, 0x2c, 0x26, 0x85, 0x99, 0xad, 0xfd, 0x57, 0x0e, 0xae, + 0x64, 0x96, 0x44, 0xd4, 0x59, 0xf4, 0x48, 0x22, 0x9c, 0x45, 0x4f, 0x22, 0x77, 0xd9, 0xb6, 0x6f, + 0xf5, 0x9c, 0x8c, 0xab, 0xdd, 0xf4, 0xb1, 0x80, 0xee, 0xff, 0x7a, 0xcf, 0x89, 0xc2, 0x3e, 0x9f, + 0x84, 0xbd, 0x5c, 0x97, 0x4f, 0xbf, 0x6c, 0x5d, 0x5e, 0xb8, 0x4c, 0x5d, 0x7e, 0x5e, 0x85, 0x39, + 0xf3, 0xcd, 0x2b, 0xcc, 0xcb, 0x94, 0xfa, 0xb3, 0x97, 0x29, 0xf5, 0x27, 0x0a, 0xc2, 0x3f, 0x57, + 0x40, 0x1d, 0xbf, 0x8d, 0xa3, 0x87, 0x41, 0x2f, 0x3e, 0xed, 0xb2, 0xc3, 0xe0, 0x41, 0xb3, 0x8e, + 0x29, 0x0d, 0x21, 0xf9, 0xde, 0x43, 0xdc, 0x6d, 0xbc, 0x07, 0x65, 0xba, 0xf3, 0x77, 0x47, 0xae, + 0xb8, 0xa3, 0xcb, 0x8b, 0xbb, 0x84, 0xf1, 0x3b, 0xb4, 0xaa, 0x7b, 0x82, 0x4b, 0xbe, 0xe9, 0xee, + 0x44, 0x48, 0xf4, 0x1a, 0x54, 0xa4, 0x76, 0xb3, 0x1e, 0xac, 0x4e, 0xb3, 0xa3, 0xd4, 0x18, 0x55, + 0xfb, 0xcf, 0x1c, 0x94, 0xb1, 0x8e, 0x13, 0x22, 0xbb, 0x36, 0x8b, 0x4c, 0xe4, 0xd7, 0x66, 0xfc, + 0x62, 0xe6, 0x21, 0x94, 0xf9, 0x49, 0xd5, 0x08, 0xc2, 0x93, 0x7e, 0x7c, 0x21, 0x24, 0xa7, 0x34, + 0xac, 0xf3, 0x7a, 0xba, 0x4d, 0x01, 0xb8, 0xe4, 0x27, 0x8d, 0x80, 0x8a, 0x3b, 0x6e, 0x40, 0x12, + 0xf1, 0x7c, 0x86, 0x78, 0x93, 0x21, 0x84, 0xb8, 0x93, 0x34, 0x02, 0x74, 0x08, 0xcb, 0xe4, 0x19, + 0x9b, 0x22, 0xdf, 0xe9, 0xf5, 0x88, 0x1f, 0x69, 0x99, 0x66, 0x5a, 0xd6, 0x53, 0x5a, 0x1a, 0x14, + 0xd8, 0xe1, 0x38, 0xae, 0x0b, 0x91, 0x71, 0x12, 0x33, 0x48, 0xdc, 0x6f, 0x09, 0x55, 0x85, 0x0c, + 0x83, 0xf8, 0xc5, 0x8f, 0x30, 0x68, 0x98, 0x34, 0x02, 0xf4, 0x3d, 0xa8, 0x58, 0x9e, 0x1b, 0xfa, + 0x5e, 0x3f, 0x92, 0x9f, 0x99, 0xc8, 0x26, 0x58, 0xd7, 0x39, 0x84, 0x2b, 0x28, 0x5b, 0x52, 0x2b, + 0xd0, 0x9e, 0x42, 0x65, 0x7f, 0xf7, 0xe0, 0x32, 0xae, 0xff, 0x20, 0xdb, 0xf5, 0x72, 0x57, 0x54, + 0xd3, 0x79, 0xbe, 0xd7, 0xfe, 0x51, 0x81, 0x8a, 0xae, 0x5f, 0x6a, 0x96, 0x1f, 0xb3, 0xb8, 0x31, + 0x82, 0xd0, 0x1f, 0x59, 0xe1, 0xc8, 0x8f, 0xfb, 0x92, 0x2f, 0xb4, 0xb1, 0xe9, 0xa6, 0x56, 0x48, + 0x3b, 0x02, 0x63, 0x1a, 0xae, 0x71, 0x2b, 0x40, 0x9f, 0xc2, 0xb2, 0x45, 0xfa, 0xfd, 0x80, 0xd5, + 0x2f, 0x36, 0xe9, 0x3a, 0xae, 0x13, 0xf2, 0x8b, 0x3a, 0xaa, 0xf2, 0x8d, 0xb1, 0x5b, 0x9b, 0x60, + 0xc7, 0xf3, 0xb1, 0xe9, 0x46, 0xd1, 0x5e, 0x8f, 0xf1, 0x18, 0x31, 0x2d, 0xd8, 0x94, 0x68, 0xd4, + 0x7b, 0x8f, 0x0f, 0xf7, 0x7f, 0x4b, 0xde, 0xa3, 0x9a, 0xce, 0xf5, 0xde, 0x9f, 0x2a, 0x50, 0xc1, + 0xed, 0x4b, 0x75, 0xe5, 0xc1, 0x2d, 0xdf, 0xb1, 0x58, 0x26, 0xa6, 0xfb, 0x08, 0x2b, 0xd9, 0x2c, + 0x73, 0x68, 0x1e, 0x3b, 0x7d, 0xba, 0x61, 0x89, 0x9c, 0x4c, 0x7b, 0x7f, 0x5d, 0xf6, 0x67, 0x7b, + 0x9f, 0xd6, 0x9d, 0x6d, 0x2e, 0xa5, 0xc7, 0x78, 0x96, 0x46, 0x6e, 0xf8, 0x8e, 0x25, 0x38, 0xec, + 0xee, 0x3e, 0xe6, 0xb2, 0x2c, 0xfd, 0x23, 0x58, 0xca, 0x88, 0xf7, 0x78, 0x33, 0x51, 0xa4, 0xcd, + 0x04, 0x49, 0x37, 0x87, 0x05, 0x71, 0x45, 0xbe, 0x01, 0x45, 0x9e, 0x18, 0xf8, 0xdd, 0x15, 0x7f, + 0xf7, 0x01, 0x9c, 0xd4, 0x39, 0x19, 0x12, 0xed, 0x39, 0xdb, 0x1d, 0x12, 0x6f, 0x5c, 0x5a, 0xf3, + 0x07, 0x3c, 0x8e, 0x86, 0xa6, 0x6f, 0x0e, 0x48, 0x48, 0xfc, 0x68, 0xbd, 0xcb, 0x57, 0x75, 0xb8, + 0xda, 0x3a, 0x8c, 0xf8, 0x2c, 0x74, 0xe2, 0x56, 0xa0, 0xfd, 0xbe, 0x42, 0x7b, 0x96, 0xf6, 0x83, + 0x4b, 0xf7, 0xfc, 0x7d, 0x40, 0x62, 0xa3, 0x71, 0x5c, 0xdb, 0xe1, 0xef, 0xa3, 0xa2, 0xde, 0xaf, + 0xa7, 0x6e, 0x61, 0x29, 0xa8, 0x19, 0x63, 0xf0, 0xa2, 0x33, 0x46, 0x09, 0xf8, 0xf0, 0xa5, 0x3d, + 0xe0, 0x65, 0x86, 0x2f, 0x36, 0x17, 0x33, 0xb5, 0x75, 0xcb, 0xc3, 0xe7, 0x7a, 0xab, 0x8c, 0x8f, + 0xc5, 0x5e, 0xc4, 0x5b, 0x81, 0xf6, 0x6b, 0x05, 0x4a, 0x32, 0x5f, 0x8a, 0xb8, 0x42, 0x2a, 0xe2, + 0xb2, 0xd2, 0xc6, 0xc7, 0x70, 0x23, 0xd5, 0xb9, 0xf1, 0x72, 0x33, 0x71, 0x4d, 0x36, 0x05, 0xcb, + 0xb3, 0x82, 0x7e, 0x04, 0x1b, 0x42, 0xb3, 0xe5, 0xb9, 0xb6, 0x93, 0xa5, 0x7c, 0xfa, 0x62, 0xe5, + 0xc2, 0x32, 0x3d, 0x12, 0x4f, 0xe9, 0xd7, 0xfe, 0x24, 0x07, 0x95, 0xf4, 0xa6, 0x79, 0x69, 0x8f, + 0xbf, 0x09, 0xe8, 0x29, 0x31, 0x6d, 0xe2, 0x1b, 0x93, 0x11, 0xad, 0x72, 0xce, 0x4e, 0x1c, 0xd7, + 0xe8, 0x36, 0x2c, 0x0d, 0x48, 0x10, 0x98, 0x3d, 0x92, 0x82, 0xf3, 0xb7, 0x7c, 0x8b, 0x82, 0x25, + 0xe1, 0x1f, 0xc2, 0xf5, 0x68, 0xb7, 0xf7, 0x46, 0xa1, 0xe5, 0x0d, 0xd2, 0x72, 0x05, 0x26, 0xb7, + 0x2a, 0x20, 0x07, 0x1c, 0x21, 0x89, 0x57, 0x61, 0x21, 0x12, 0x8f, 0xe2, 0x61, 0x66, 0x22, 0xdb, + 0x88, 0x61, 0x0b, 0xbf, 0x47, 0xd9, 0x25, 0x8a, 0x88, 0xff, 0x0f, 0xe5, 0x14, 0xe0, 0xa5, 0x22, + 0xe2, 0x37, 0x5d, 0x8d, 0xbf, 0x0b, 0xea, 0xf8, 0x72, 0xf9, 0x5f, 0xed, 0xff, 0x7d, 0x28, 0xc9, + 0x6c, 0xa9, 0xef, 0xfc, 0xd7, 0xf5, 0xad, 0x59, 0x70, 0xed, 0xdc, 0x84, 0x95, 0x19, 0x5d, 0xdb, + 0x30, 0x6f, 0x86, 0xa1, 0xef, 0x1c, 0x8f, 0x42, 0x22, 0x76, 0x6b, 0xf9, 0xed, 0x4d, 0x35, 0xe2, + 0xe1, 0x04, 0xa6, 0x7d, 0x0a, 0xf3, 0x31, 0x3d, 0x53, 0xe9, 0x7b, 0x50, 0x62, 0x99, 0x81, 0x57, + 0x84, 0xd1, 0x3b, 0x71, 0xf9, 0x42, 0x01, 0x37, 0x75, 0x51, 0x2f, 0x06, 0xb8, 0x48, 0x37, 0x7d, + 0xd1, 0xd0, 0xbe, 0xcc, 0x41, 0x51, 0x62, 0xd2, 0x32, 0x38, 0xb3, 0x14, 0xe2, 0x27, 0x14, 0xf9, + 0xf6, 0x56, 0xd7, 0x2f, 0x59, 0x0b, 0x5d, 0x22, 0x45, 0xd2, 0xfa, 0xe1, 0xdc, 0xe2, 0xee, 0x83, + 0xec, 0xe2, 0x6e, 0x4c, 0xfe, 0xfc, 0xea, 0xae, 0x3a, 0x51, 0x4c, 0x4d, 0x4f, 0x9c, 0x98, 0x75, + 0xfd, 0xa2, 0x6a, 0x8a, 0x9a, 0x90, 0x55, 0xce, 0x8d, 0x99, 0x70, 0x6e, 0x3d, 0xa7, 0xfd, 0x9d, + 0x02, 0x37, 0x2f, 0xac, 0x42, 0xd0, 0xc3, 0x97, 0x7c, 0x6d, 0x36, 0xf6, 0xae, 0xc9, 0x84, 0x55, + 0x26, 0x1e, 0x69, 0x96, 0x0b, 0xa2, 0xc9, 0x9a, 0x80, 0x2a, 0x3a, 0xb7, 0x1e, 0x5a, 0xa1, 0x8a, + 0x76, 0x26, 0xe8, 0x5a, 0x17, 0x6e, 0x5c, 0x24, 0xf7, 0x5b, 0x8b, 0x76, 0x03, 0x96, 0xb3, 0x42, + 0xeb, 0xb7, 0x57, 0x76, 0xfc, 0x22, 0xc7, 0x0b, 0xd6, 0x6f, 0x50, 0x78, 0xd4, 0x60, 0x3d, 0x63, + 0x75, 0xd0, 0xdd, 0x5a, 0xbc, 0x68, 0x63, 0xb1, 0x59, 0xc0, 0x6b, 0x13, 0xcb, 0x80, 0xba, 0x8d, + 0x21, 0x50, 0x15, 0x6e, 0x9a, 0xe3, 0x73, 0x94, 0x91, 0x27, 0xd6, 0xcc, 0x31, 0x07, 0xa7, 0x76, + 0xfc, 0x9b, 0x49, 0xf9, 0x61, 0x64, 0x64, 0x26, 0x9e, 0x32, 0xd6, 0x12, 0xd0, 0xee, 0x78, 0x8e, + 0xd2, 0x61, 0x5d, 0x52, 0x91, 0x95, 0xae, 0x66, 0x98, 0x8e, 0xeb, 0x09, 0x6a, 0x7f, 0x3c, 0x71, + 0x69, 0x1f, 0x30, 0x47, 0xca, 0x75, 0xd4, 0x9b, 0xf2, 0x7b, 0x65, 0xba, 0x05, 0x8d, 0x1f, 0x26, + 0x1b, 0x83, 0x61, 0x78, 0x22, 0xde, 0x75, 0x68, 0x7f, 0x9d, 0x83, 0x85, 0xb1, 0x95, 0x17, 0xbb, + 0x5d, 0x91, 0xdc, 0x9e, 0xb5, 0xeb, 0x7f, 0x17, 0xd6, 0xa2, 0x55, 0x7d, 0x6e, 0x6a, 0xbe, 0x2a, + 0x10, 0x13, 0xa3, 0x97, 0x32, 0xee, 0xf9, 0x99, 0x3a, 0xca, 0xb8, 0x13, 0xe3, 0x46, 0xef, 0xc3, + 0x1a, 0xdd, 0x6f, 0x87, 0xbe, 0x67, 0x91, 0x20, 0x30, 0x1c, 0x3b, 0xc3, 0xf9, 0x2b, 0xbe, 0x63, + 0x1d, 0x72, 0x40, 0xd3, 0xbe, 0x7c, 0xb2, 0x9f, 0xb9, 0x38, 0xd9, 0x0b, 0x97, 0xcb, 0x55, 0xe3, + 0xcb, 0xb9, 0xfc, 0x5b, 0x50, 0x3a, 0xec, 0x0f, 0x5c, 0xc7, 0x26, 0x6e, 0xe8, 0x84, 0x27, 0xe9, + 0x0f, 0x01, 0x4a, 0x11, 0xea, 0x3a, 0xe4, 0xdb, 0x41, 0x78, 0x0e, 0x73, 0x0d, 0x72, 0x6d, 0xfb, + 0x1c, 0x5e, 0x13, 0x66, 0xda, 0xad, 0x76, 0x60, 0x3a, 0xe8, 0x56, 0x72, 0x69, 0x56, 0x4c, 0xdd, + 0xe1, 0xb7, 0x83, 0x90, 0x5f, 0xa2, 0xdd, 0x8c, 0x2f, 0xd1, 0x8a, 0xdb, 0x65, 0x19, 0x60, 0xb3, + 0x3b, 0x35, 0x17, 0x16, 0xb0, 0x3f, 0xe0, 0x23, 0xdd, 0x27, 0x83, 0x63, 0xe2, 0xa3, 0xbb, 0xe9, + 0x2b, 0xab, 0xb1, 0x8a, 0x57, 0x1a, 0x56, 0x7c, 0x97, 0xf5, 0x6d, 0x98, 0x09, 0xf8, 0x7d, 0x5f, + 0x2e, 0xe3, 0xbe, 0xaf, 0xcd, 0xef, 0xfb, 0x18, 0x40, 0xfb, 0x21, 0x2c, 0x8d, 0xf5, 0xc7, 0xee, + 0x24, 0x77, 0x60, 0xd1, 0xf7, 0x07, 0xd1, 0xd7, 0x2a, 0x03, 0xc6, 0x10, 0xd9, 0x50, 0x4e, 0x20, + 0x63, 0xa2, 0x78, 0xc1, 0x4f, 0x13, 0xb4, 0x9f, 0xe6, 0x61, 0xe1, 0x00, 0xe3, 0x01, 0x57, 0x84, + 0xe9, 0x8a, 0x42, 0x0f, 0x68, 0x66, 0x0c, 0xbc, 0x91, 0x6f, 0x11, 0x43, 0xfa, 0xf8, 0x28, 0x55, + 0xb8, 0x08, 0x3e, 0xfb, 0xe8, 0xa2, 0xe4, 0x4b, 0x2d, 0xf4, 0x21, 0x54, 0x02, 0xeb, 0x29, 0xb1, + 0x47, 0x7d, 0xe2, 0x1b, 0xd2, 0x77, 0x1b, 0x72, 0xd9, 0xd7, 0x8e, 0x00, 0xfc, 0x33, 0x9a, 0x40, + 0x6e, 0xa2, 0x36, 0xac, 0x4c, 0x0c, 0x8d, 0x1f, 0x23, 0xf3, 0x13, 0x97, 0x5e, 0x19, 0xae, 0xc1, + 0x4b, 0x7e, 0x86, 0xbf, 0xee, 0xc0, 0xb2, 0xac, 0xd4, 0x7c, 0x61, 0xb0, 0xb2, 0x28, 0xaa, 0x7e, + 0x13, 0x11, 0xf3, 0x05, 0x77, 0xc2, 0x98, 0x80, 0xe3, 0x0a, 0x81, 0xc2, 0xb8, 0x80, 0xe3, 0x72, + 0x81, 0xef, 0xc2, 0x9a, 0x24, 0x60, 0x13, 0xb6, 0x3f, 0x11, 0x5b, 0x88, 0xf1, 0x05, 0x74, 0x35, + 0x16, 0xab, 0x47, 0x7c, 0x26, 0xac, 0xfd, 0x34, 0x07, 0x2b, 0x7a, 0x76, 0xb9, 0x76, 0x1f, 0x8a, + 0xd6, 0x53, 0xd3, 0xed, 0xa5, 0xe6, 0xe2, 0x8a, 0x9c, 0x36, 0x19, 0x97, 0x79, 0x12, 0xac, 0xf8, + 0x19, 0x7d, 0x07, 0x50, 0xaa, 0x00, 0x34, 0xa4, 0xbd, 0x6a, 0x31, 0xc5, 0x69, 0xd1, 0x8d, 0xeb, + 0x21, 0x88, 0xda, 0x40, 0x18, 0x9c, 0x9f, 0xf8, 0x40, 0x76, 0x2c, 0x4c, 0x70, 0x51, 0x8e, 0x99, + 0x3a, 0xa8, 0x5e, 0xdf, 0x36, 0x52, 0x2a, 0xa6, 0xbf, 0x56, 0x45, 0xc5, 0xeb, 0xdb, 0x87, 0x49, + 0x5b, 0x7b, 0x01, 0x6b, 0xd9, 0x5e, 0x60, 0x73, 0xf8, 0x29, 0x5c, 0x4d, 0x8f, 0x28, 0xbe, 0xb1, + 0x11, 0x91, 0xff, 0x4a, 0xfa, 0x64, 0x91, 0x75, 0x5b, 0xb3, 0x92, 0x5d, 0x14, 0x6b, 0xcf, 0xf9, + 0xd5, 0xca, 0x37, 0x48, 0xbe, 0x0f, 0xa1, 0x24, 0x5d, 0x93, 0x66, 0x95, 0x81, 0x8f, 0x0f, 0xf7, + 0xf7, 0x13, 0x04, 0x4e, 0xc1, 0xb5, 0x77, 0xf9, 0x8d, 0xd8, 0xcb, 0x77, 0xac, 0x3d, 0x60, 0x26, + 0x4b, 0x9a, 0xcf, 0xbd, 0xa2, 0xc9, 0x3a, 0x22, 0xfc, 0x73, 0x0e, 0x6e, 0x5c, 0x74, 0x09, 0x83, + 0xde, 0x82, 0xab, 0x74, 0x99, 0xb8, 0x23, 0xb6, 0xfe, 0xbc, 0x2e, 0x7f, 0xd7, 0x12, 0x18, 0x76, + 0x5f, 0x24, 0xc1, 0xa5, 0x81, 0xf9, 0xa2, 0xc5, 0xb8, 0x07, 0x5d, 0xf6, 0x4a, 0x23, 0xa8, 0xf7, + 0xcf, 0x95, 0x1a, 0xf5, 0x85, 0xed, 0x93, 0x52, 0x47, 0x7d, 0xf4, 0x00, 0x4a, 0xd1, 0xfd, 0x51, + 0x9c, 0x27, 0xd3, 0x5f, 0x3b, 0xe2, 0xf6, 0xbe, 0x30, 0x93, 0x05, 0x7a, 0x31, 0x48, 0x1a, 0xe8, + 0xbb, 0x70, 0x3d, 0xdd, 0xe7, 0x88, 0x04, 0xc6, 0x90, 0x96, 0x41, 0x54, 0xbf, 0x58, 0xe2, 0x2b, + 0x52, 0xbf, 0x47, 0x24, 0x38, 0x24, 0x3e, 0xeb, 0x1d, 0xb5, 0x41, 0x15, 0x77, 0xea, 0xc4, 0x16, + 0x97, 0xe0, 0xa2, 0x8c, 0x7e, 0x63, 0xac, 0xfb, 0x08, 0x15, 0xb9, 0x8b, 0x61, 0xf9, 0x2b, 0xb3, + 0x58, 0x03, 0x27, 0x6a, 0x3f, 0x86, 0x9b, 0x17, 0x4a, 0xa0, 0x26, 0x7f, 0xa5, 0x94, 0x5c, 0xbc, + 0x1b, 0xe7, 0x7c, 0xe5, 0xd9, 0xd8, 0x6e, 0x0f, 0x70, 0x30, 0xd0, 0xbd, 0xc1, 0xc0, 0x74, 0x6d, + 0xfe, 0x42, 0x29, 0x56, 0xc5, 0x52, 0x6f, 0x1b, 0x54, 0xe1, 0x1c, 0x42, 0x55, 0xb3, 0x95, 0xf2, + 0x21, 0x54, 0xfc, 0x60, 0x20, 0xde, 0x8e, 0xb1, 0xad, 0x73, 0xf2, 0xb5, 0x5f, 0xe2, 0x51, 0x36, + 0x86, 0x92, 0x1f, 0x0c, 0x98, 0x12, 0x76, 0xc7, 0xf6, 0xdf, 0xfc, 0xfe, 0x4f, 0x02, 0x9c, 0x1b, + 0x5c, 0x37, 0x01, 0x78, 0x3f, 0x36, 0x09, 0x2c, 0x11, 0x62, 0xf3, 0x8c, 0x52, 0x27, 0x81, 0x85, + 0x76, 0x41, 0xe5, 0xec, 0xd4, 0x41, 0x98, 0x6e, 0x0c, 0x37, 0x27, 0x8d, 0x21, 0xc9, 0xf9, 0x17, + 0x2f, 0x04, 0x69, 0x02, 0xba, 0x1f, 0x75, 0x14, 0x17, 0x43, 0x63, 0x39, 0x49, 0xe8, 0x60, 0x01, + 0xc2, 0x2d, 0x60, 0xe1, 0x71, 0x0f, 0x60, 0x44, 0xd8, 0xcb, 0x5f, 0xea, 0x08, 0x3e, 0xb7, 0xf2, + 0xfe, 0x79, 0x44, 0x9a, 0x51, 0x7e, 0x9e, 0x1b, 0x91, 0x26, 0xff, 0x5a, 0xe0, 0x8f, 0x14, 0x40, + 0x93, 0x46, 0xa1, 0xda, 0x44, 0x72, 0x53, 0x26, 0x3e, 0x4a, 0xa4, 0x62, 0x17, 0xe5, 0xb7, 0x15, + 0x98, 0x79, 0xce, 0xbf, 0xd6, 0xe6, 0x2b, 0x42, 0xb4, 0xd0, 0x75, 0x98, 0xff, 0xdc, 0x0b, 0x8c, + 0x3e, 0x79, 0x46, 0xfa, 0xa2, 0x52, 0x9c, 0xfb, 0xdc, 0x0b, 0xf6, 0x68, 0x5b, 0xd3, 0x00, 0xea, + 0xa3, 0x23, 0xb2, 0xb3, 0x65, 0x0e, 0xc7, 0xbf, 0x93, 0xcc, 0x47, 0x55, 0x8e, 0x06, 0xa0, 0x7f, + 0x1d, 0xe6, 0x55, 0x28, 0x62, 0xd3, 0x3d, 0x22, 0xad, 0xde, 0xc5, 0xa0, 0x86, 0x7b, 0x7c, 0x44, + 0xda, 0x19, 0x9a, 0x0a, 0x12, 0xa8, 0x3a, 0xe8, 0x7e, 0x8d, 0xa6, 0x9f, 0x4d, 0x03, 0x24, 0xfe, + 0x45, 0xbb, 0x50, 0xb6, 0x47, 0xc6, 0x88, 0x18, 0xdd, 0x2d, 0x73, 0x98, 0xd4, 0x4b, 0xf2, 0x6c, + 0x24, 0xa3, 0xe4, 0xdf, 0xfc, 0x25, 0x6d, 0x0c, 0x76, 0xf4, 0x6c, 0x53, 0x4d, 0x56, 0x4a, 0x53, + 0x6e, 0x42, 0x93, 0x3e, 0xa6, 0x49, 0x97, 0x34, 0x59, 0x89, 0xa6, 0x3d, 0x7e, 0x4f, 0x33, 0x22, + 0x86, 0xdb, 0xe3, 0xaa, 0xf2, 0x93, 0xf7, 0x14, 0x89, 0xcb, 0x6a, 0x0b, 0x67, 0xa7, 0x1b, 0x45, + 0x5c, 0x6d, 0x45, 0x04, 0x5c, 0xf4, 0x63, 0x2e, 0xd3, 0x46, 0xdc, 0x63, 0xaa, 0x2d, 0x10, 0x86, + 0x4d, 0x4f, 0x68, 0x93, 0x7c, 0xcb, 0xb5, 0x49, 0x04, 0x5c, 0x24, 0x71, 0x83, 0x69, 0x33, 0x07, + 0x5d, 0xd9, 0xb6, 0xc2, 0x84, 0x36, 0x69, 0x12, 0xb8, 0xb6, 0xea, 0xfe, 0x4e, 0x62, 0x9b, 0x19, + 0x73, 0x6d, 0xd4, 0x81, 0xc5, 0xa1, 0x4f, 0xba, 0xc4, 0xf7, 0x89, 0x4d, 0xd7, 0x43, 0x5c, 0xd9, + 0x57, 0x52, 0xff, 0x70, 0xa0, 0xf3, 0x45, 0x03, 0x95, 0x7f, 0x21, 0x79, 0x18, 0x49, 0x88, 0x2f, + 0x6c, 0x17, 0x62, 0x15, 0x1c, 0x85, 0x5e, 0x87, 0x19, 0xdb, 0x67, 0x1f, 0x2a, 0xcc, 0x32, 0xdb, + 0xe4, 0xcf, 0x67, 0xea, 0xfe, 0x71, 0xd3, 0xc6, 0x05, 0x9b, 0xfe, 0x68, 0x7f, 0xa8, 0x40, 0x81, + 0x11, 0xd0, 0x7b, 0x50, 0xea, 0x7a, 0x23, 0xdf, 0xe8, 0x09, 0xc1, 0xc9, 0x28, 0xd8, 0xf1, 0x46, + 0xfe, 0x23, 0x06, 0xde, 0x9d, 0xa2, 0xa7, 0x64, 0xd1, 0xaa, 0x33, 0x51, 0xe7, 0x19, 0x89, 0x45, + 0x27, 0xa7, 0x7d, 0xc7, 0x79, 0x46, 0x24, 0xd1, 0xa8, 0x55, 0xaf, 0xcd, 0x45, 0x86, 0x6a, 0x3f, + 0x57, 0x00, 0x12, 0x58, 0x76, 0x7c, 0xd3, 0x93, 0xc2, 0xe7, 0xdd, 0xa8, 0x40, 0x97, 0x4f, 0x0a, + 0x4f, 0xba, 0x0e, 0xa6, 0x2c, 0xf4, 0x7d, 0x50, 0xbb, 0x7d, 0xef, 0x79, 0x60, 0x0c, 0xcc, 0xa1, + 0x11, 0x7a, 0x86, 0xed, 0x1f, 0x8b, 0xec, 0x2f, 0x17, 0x22, 0x4f, 0xbc, 0x36, 0x45, 0xb1, 0x65, + 0x2c, 0x6d, 0x6f, 0x65, 0x26, 0xba, 0x6f, 0x0e, 0x3b, 0x5e, 0xdd, 0x3f, 0xa6, 0x47, 0x9b, 0x27, + 0x5d, 0xe7, 0x9c, 0xa5, 0xf6, 0x0b, 0x05, 0x56, 0xb2, 0xd5, 0xa0, 0x1a, 0x2c, 0xd8, 0x27, 0xae, + 0x39, 0x70, 0x2c, 0x83, 0xf9, 0xe5, 0x73, 0x27, 0xe3, 0x3b, 0xaf, 0x3a, 0x47, 0xd0, 0x21, 0x3f, + 0x71, 0x76, 0xa7, 0x70, 0xd9, 0x96, 0x09, 0x68, 0x0f, 0x96, 0x5c, 0x7a, 0xee, 0x1f, 0xd3, 0x33, + 0xf9, 0x4f, 0x8b, 0x96, 0xe7, 0x8e, 0xab, 0x52, 0xdd, 0x31, 0x5a, 0xed, 0x3a, 0x5c, 0xa3, 0xdb, + 0x18, 0x35, 0x96, 0xef, 0x65, 0xd2, 0xce, 0x4f, 0x3d, 0x5f, 0x4e, 0xc1, 0xd1, 0xff, 0x81, 0xca, + 0xd0, 0x77, 0x3c, 0x9f, 0xbd, 0x2b, 0x62, 0x5b, 0x1f, 0x1f, 0x7a, 0x39, 0xa2, 0xb2, 0x11, 0xa3, + 0x37, 0x01, 0x0d, 0x4d, 0xeb, 0x33, 0x12, 0x1a, 0x36, 0xe9, 0x9b, 0x27, 0xc6, 0xf1, 0xc8, 0xee, + 0x45, 0xe5, 0x90, 0xca, 0x39, 0x75, 0xca, 0xa8, 0x51, 0x3a, 0xda, 0x84, 0x45, 0x81, 0x26, 0xbe, + 0xef, 0xf9, 0xb4, 0x1e, 0x8d, 0x0e, 0xdf, 0x0b, 0x9c, 0xd1, 0xa0, 0x74, 0x6c, 0x86, 0xf4, 0xe8, + 0xaa, 0x8e, 0x8f, 0x0b, 0x6d, 0xc2, 0x6c, 0xda, 0x9b, 0x8b, 0x63, 0x01, 0xf6, 0xc4, 0xc1, 0x33, + 0x5d, 0xf6, 0xab, 0xad, 0xc3, 0x8c, 0x90, 0xca, 0x9e, 0xbc, 0x3a, 0x40, 0x12, 0xcd, 0x17, 0xc4, + 0x9a, 0x95, 0x19, 0x6b, 0x16, 0x8d, 0x35, 0xcb, 0x61, 0xf1, 0x61, 0x9d, 0xd3, 0xc5, 0x66, 0x1d, + 0x2a, 0xb8, 0xda, 0x6a, 0xb0, 0x3d, 0xf6, 0xb1, 0xe3, 0xda, 0x01, 0x02, 0xf6, 0x6f, 0x9d, 0x83, + 0x7a, 0x43, 0x9d, 0xe2, 0xcf, 0x7a, 0x63, 0x6f, 0x4f, 0x55, 0xd0, 0x2c, 0xe4, 0x1b, 0xdb, 0x1d, + 0x35, 0x8f, 0xe6, 0x60, 0x5a, 0xfc, 0x1d, 0x63, 0x16, 0xf2, 0xd5, 0xad, 0x8e, 0x5a, 0xd8, 0x7c, + 0x08, 0x2a, 0xae, 0xb6, 0x30, 0xe9, 0xb3, 0xd2, 0x98, 0xeb, 0x29, 0xc1, 0x9c, 0x7e, 0xd0, 0xea, + 0xe0, 0x83, 0xbd, 0xb6, 0x3a, 0x15, 0xb5, 0xaa, 0xcd, 0x56, 0x5b, 0x55, 0x50, 0x19, 0xe6, 0x5b, + 0x8d, 0xe6, 0xa3, 0xdd, 0xda, 0x01, 0x6e, 0xab, 0xb9, 0xcd, 0xd7, 0x41, 0x1d, 0xff, 0x1c, 0x1f, + 0xcd, 0x43, 0xa1, 0x85, 0xf5, 0x47, 0x4d, 0x75, 0x8a, 0x76, 0xd8, 0xa0, 0x4f, 0xca, 0xe6, 0x3e, + 0xcc, 0xd1, 0xaa, 0x93, 0x01, 0x8a, 0x30, 0xdb, 0xea, 0x18, 0xad, 0x83, 0x96, 0x30, 0xb4, 0xd5, + 0x31, 0x1e, 0xb5, 0x6a, 0x42, 0x79, 0xc7, 0x68, 0xb4, 0x58, 0x33, 0x27, 0x9a, 0xad, 0x47, 0x46, + 0xa3, 0x55, 0x53, 0xf3, 0x02, 0x49, 0x9f, 0xa7, 0x37, 0xf7, 0xa0, 0xac, 0x7b, 0x83, 0xa1, 0xe7, + 0x12, 0x37, 0x8c, 0x74, 0xea, 0xb1, 0xce, 0x79, 0x28, 0xe8, 0x1d, 0x43, 0x3f, 0x52, 0x15, 0x66, + 0x3d, 0x7d, 0x34, 0x8e, 0x0e, 0xd5, 0x9c, 0x60, 0xd4, 0x8f, 0xb8, 0x36, 0x3d, 0xd2, 0x36, 0x84, + 0x92, 0x7c, 0xb6, 0x45, 0xab, 0xb0, 0x8c, 0x1b, 0xed, 0x83, 0x23, 0xac, 0x37, 0x8c, 0xce, 0x27, + 0x87, 0x0d, 0xe3, 0x10, 0xd7, 0x8c, 0xa3, 0x3d, 0x75, 0x2a, 0x9b, 0x53, 0xdf, 0xe3, 0xff, 0x92, + 0x49, 0x73, 0xea, 0xb8, 0xc6, 0xff, 0x25, 0x93, 0x26, 0x63, 0xac, 0xab, 0xf9, 0xcd, 0x9f, 0x28, + 0x50, 0x4e, 0xd5, 0x0b, 0x48, 0x83, 0x75, 0x5d, 0xd7, 0x8d, 0xb6, 0xbe, 0xdb, 0xa8, 0x1f, 0xed, + 0x35, 0xb0, 0x40, 0x1f, 0x1c, 0xb5, 0xea, 0x06, 0x3e, 0xa8, 0x35, 0x5b, 0xea, 0x14, 0xda, 0x84, + 0xd7, 0x32, 0x30, 0x87, 0xf8, 0xe0, 0xf0, 0x00, 0x77, 0x9a, 0x07, 0xad, 0xea, 0xde, 0xde, 0x27, + 0xc6, 0x4e, 0xb5, 0x89, 0x55, 0x05, 0xdd, 0x82, 0x1b, 0x19, 0xd8, 0x27, 0x07, 0x6d, 0xa3, 0x56, + 0x6d, 0x37, 0xea, 0x6a, 0x6e, 0x33, 0x04, 0x48, 0x4e, 0x91, 0x68, 0x19, 0x54, 0x7d, 0xb7, 0xda, + 0x7a, 0x24, 0xcc, 0x14, 0x9e, 0xbc, 0x01, 0xab, 0x32, 0x75, 0xff, 0xa0, 0xde, 0xdc, 0x69, 0xea, + 0x55, 0xda, 0x99, 0xaa, 0x50, 0x6f, 0xc8, 0xdc, 0x6a, 0xbd, 0xde, 0x64, 0x9c, 0xdc, 0x38, 0xa7, + 0xde, 0xd8, 0x6b, 0x30, 0x4e, 0x7e, 0xf3, 0x1f, 0x14, 0xa8, 0xa4, 0xeb, 0x5b, 0x3a, 0xf4, 0xc6, + 0xb6, 0xd1, 0xde, 0x37, 0x70, 0x7b, 0xdf, 0xd0, 0x0f, 0xf6, 0xf7, 0xab, 0xad, 0xba, 0xd1, 0xde, + 0x6b, 0xea, 0x0d, 0x43, 0xc7, 0x8d, 0x6a, 0x87, 0x1a, 0x72, 0x01, 0xe6, 0xe8, 0xb0, 0x4e, 0x31, + 0xca, 0x45, 0x18, 0x66, 0x40, 0x43, 0xcd, 0x65, 0x63, 0x8e, 0x1a, 0x46, 0xb5, 0xdd, 0x3e, 0xd0, + 0x9b, 0x54, 0x4f, 0x1e, 0x7d, 0x0b, 0x6e, 0x4d, 0x62, 0x1a, 0x3f, 0x68, 0xb4, 0x3a, 0x46, 0x07, + 0x37, 0x1f, 0x3d, 0x6a, 0xe0, 0xb6, 0x3a, 0xbd, 0xa9, 0xcb, 0xc5, 0x32, 0x73, 0xe1, 0x55, 0x58, + 0xa2, 0xbd, 0x35, 0x5b, 0x8f, 0xf8, 0xa8, 0xdb, 0x9d, 0x6a, 0xa7, 0xa9, 0xf3, 0xa8, 0x49, 0x31, + 0xea, 0x9f, 0xb4, 0xaa, 0xfb, 0x4d, 0x5d, 0x55, 0x36, 0x5f, 0xf0, 0x3a, 0x3e, 0x15, 0x09, 0xeb, + 0xb0, 0x76, 0x61, 0x14, 0xbc, 0x06, 0xda, 0xa5, 0x22, 0xe0, 0x06, 0xac, 0x5e, 0x30, 0xfb, 0xdf, + 0x83, 0x92, 0x5c, 0x3b, 0x47, 0xc6, 0x47, 0x13, 0xb6, 0xc7, 0x1d, 0xa7, 0x4e, 0x8d, 0x31, 0x8e, + 0x22, 0x86, 0xb2, 0xf9, 0x17, 0x0a, 0xcc, 0x45, 0x65, 0x03, 0xba, 0x09, 0xd7, 0x8e, 0x1a, 0x46, + 0xb3, 0xce, 0x51, 0x74, 0xbd, 0x35, 0x8c, 0x9d, 0x2d, 0xa3, 0x7a, 0x68, 0x34, 0xeb, 0xea, 0xd4, + 0x18, 0xbb, 0x9e, 0x66, 0x2b, 0x63, 0x6c, 0x5c, 0x6d, 0x51, 0x7e, 0xeb, 0x11, 0x67, 0xe7, 0xc6, + 0xd8, 0xd5, 0xfd, 0x1d, 0x99, 0x9d, 0xa7, 0x0e, 0x93, 0xd8, 0x8d, 0x56, 0x8d, 0xb2, 0xdb, 0x91, + 0xf6, 0xe9, 0xcd, 0x26, 0x14, 0xd8, 0x27, 0xbd, 0x68, 0x01, 0x8a, 0x6d, 0xbd, 0x2d, 0xfd, 0xdb, + 0x0d, 0x60, 0x86, 0x12, 0xb6, 0xde, 0x56, 0x95, 0xe8, 0xf9, 0xde, 0x5d, 0x35, 0x17, 0x3d, 0xbf, + 0x7d, 0x57, 0xcd, 0xd3, 0x9d, 0x85, 0x61, 0xb6, 0xef, 0xaa, 0xd3, 0x9b, 0x3f, 0xc9, 0x43, 0xbe, + 0xe5, 0x1f, 0x53, 0x4d, 0x2d, 0xba, 0x27, 0xc8, 0x9a, 0x28, 0x61, 0x6b, 0x8b, 0x6b, 0x62, 0xcf, + 0xef, 0x72, 0x4d, 0xf4, 0x79, 0xfb, 0x2d, 0xb1, 0x81, 0xd1, 0xe7, 0xb7, 0xd5, 0xe9, 0xe8, 0xf9, + 0xde, 0x96, 0x5a, 0x88, 0x9f, 0xb7, 0xd5, 0x99, 0xf8, 0xf9, 0x5d, 0x75, 0x36, 0x7a, 0x7e, 0x7b, + 0x4b, 0x9d, 0x8b, 0x9f, 0xb7, 0xd5, 0xf9, 0xe8, 0xf9, 0xfe, 0xdb, 0x2a, 0xc4, 0xcf, 0xf7, 0xd5, + 0x62, 0xf4, 0xfc, 0xce, 0xbb, 0x6a, 0x29, 0x7e, 0x7e, 0x4f, 0x2d, 0x47, 0xcf, 0xef, 0xdd, 0x53, + 0x2b, 0x6c, 0xef, 0xa5, 0xb6, 0xdd, 0xbd, 0xaf, 0x2e, 0x24, 0x8d, 0x77, 0x54, 0x35, 0x6e, 0x6c, + 0x6f, 0xa9, 0x8b, 0x71, 0xe3, 0xde, 0xb6, 0x8a, 0x92, 0xc6, 0x3d, 0x75, 0x29, 0x69, 0xbc, 0xad, + 0x2e, 0xc7, 0x8d, 0xfb, 0x77, 0xd5, 0x2b, 0x49, 0x63, 0x5b, 0x5d, 0x89, 0x1b, 0xef, 0xbe, 0xa7, + 0x5e, 0x8d, 0x1a, 0xdb, 0x5b, 0xf7, 0xd5, 0xd5, 0xa4, 0xf1, 0x8e, 0x7a, 0x2d, 0x6e, 0xbc, 0xf5, + 0xb6, 0xba, 0x16, 0x37, 0xee, 0xbf, 0xa5, 0x5e, 0x8f, 0x1b, 0xef, 0xdc, 0x55, 0x6f, 0x24, 0x8d, + 0x7b, 0xea, 0xcd, 0xcd, 0x2e, 0x3d, 0xa8, 0xc4, 0xff, 0x1e, 0x40, 0xd7, 0xe0, 0x4a, 0xa3, 0x65, + 0xd4, 0x75, 0xa3, 0x7d, 0x74, 0x48, 0x57, 0x81, 0x34, 0x29, 0xd7, 0xe1, 0x6a, 0x9a, 0x25, 0x7e, + 0x1b, 0x34, 0xe6, 0x36, 0xe0, 0x7a, 0x9a, 0xd9, 0x3a, 0x90, 0x01, 0xb9, 0xda, 0xea, 0x2f, 0xcf, + 0xd6, 0x95, 0x5f, 0x9d, 0xad, 0x2b, 0xff, 0x76, 0xb6, 0xae, 0xfc, 0xfc, 0xcb, 0xf5, 0xa9, 0x5f, + 0x7d, 0xb9, 0x3e, 0xf5, 0x4f, 0x5f, 0xae, 0x4f, 0x1d, 0xcf, 0xb0, 0xfb, 0xec, 0x7b, 0xff, 0x13, + 0x00, 0x00, 0xff, 0xff, 0x83, 0x02, 0x14, 0xe9, 0x45, 0x41, 0x00, 0x00, +} + +func (m *Location) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -7184,31 +7112,50 @@ func (m *TDDInfo) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *TDDInfo) MarshalTo(dAtA []byte) (int, error) { +func (m *Location) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *TDDInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *Location) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l - if m.TransmissionBandwidth != nil { + if m.Ext != nil { { - size, err := m.TransmissionBandwidth.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { + size := m.Ext.Size() + i -= size + if _, err := m.Ext.MarshalTo(dAtA[i:]); err != nil { return 0, err } - i -= size - i = encodeVarintRan(dAtA, i, uint64(size)) } + } + if m.Lng != 0 { + i -= 8 + encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.Lng)))) i-- - dAtA[i] = 0x12 + dAtA[i] = 0x11 } - if m.NrFreqInfo != nil { + if m.Lat != 0 { + i -= 8 + encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.Lat)))) + i-- + dAtA[i] = 0x9 + } + return len(dAtA) - i, nil +} + +func (m *Location_Wgs84) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *Location_Wgs84) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + if m.Wgs84 != nil { { - size, err := m.NrFreqInfo.MarshalToSizedBuffer(dAtA[:i]) + size, err := m.Wgs84.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } @@ -7216,34 +7163,20 @@ func (m *TDDInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) { i = encodeVarintRan(dAtA, i, uint64(size)) } i-- - dAtA[i] = 0xa + dAtA[i] = 0x1a } return len(dAtA) - i, nil } - -func (m *FrequencyInfo) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { - return nil, err - } - return dAtA[:n], nil -} - -func (m *FrequencyInfo) MarshalTo(dAtA []byte) (int, error) { +func (m *Location_Cartesian) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *FrequencyInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *Location_Cartesian) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) - _ = i - var l int - _ = l - if m.FrequencyBandList != nil { + if m.Cartesian != nil { { - size, err := m.FrequencyBandList.MarshalToSizedBuffer(dAtA[:i]) + size, err := m.Cartesian.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } @@ -7251,17 +7184,11 @@ func (m *FrequencyInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) { i = encodeVarintRan(dAtA, i, uint64(size)) } i-- - dAtA[i] = 0x12 - } - if m.NrArfcn != 0 { - i = encodeVarintRan(dAtA, i, uint64(m.NrArfcn)) - i-- - dAtA[i] = 0x8 + dAtA[i] = 0x22 } return len(dAtA) - i, nil } - -func (m *TransmissionBandwidth) Marshal() (dAtA []byte, err error) { +func (m *Wgs84Location) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -7271,30 +7198,38 @@ func (m *TransmissionBandwidth) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *TransmissionBandwidth) MarshalTo(dAtA []byte) (int, error) { +func (m *Wgs84Location) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *TransmissionBandwidth) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *Wgs84Location) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l - if m.Nrb != 0 { - i = encodeVarintRan(dAtA, i, uint64(m.Nrb)) + if m.AltitudeM != 0 { + i -= 8 + encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.AltitudeM)))) i-- - dAtA[i] = 0x10 + dAtA[i] = 0x19 } - if m.NrScs != 0 { - i = encodeVarintRan(dAtA, i, uint64(m.NrScs)) + if m.LongitudeDeg != 0 { + i -= 8 + encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.LongitudeDeg)))) i-- - dAtA[i] = 0x8 + dAtA[i] = 0x11 + } + if m.LatitudeDeg != 0 { + i -= 8 + encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.LatitudeDeg)))) + i-- + dAtA[i] = 0x9 } return len(dAtA) - i, nil } -func (m *FrequencyBandList) Marshal() (dAtA []byte, err error) { +func (m *CartesianLocation) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -7304,34 +7239,38 @@ func (m *FrequencyBandList) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *FrequencyBandList) MarshalTo(dAtA []byte) (int, error) { +func (m *CartesianLocation) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *FrequencyBandList) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *CartesianLocation) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l - if len(m.FrequencyBandItems) > 0 { - for iNdEx := len(m.FrequencyBandItems) - 1; iNdEx >= 0; iNdEx-- { - { - size, err := m.FrequencyBandItems[iNdEx].MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintRan(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0xa - } + if m.ZM != 0 { + i -= 8 + encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.ZM)))) + i-- + dAtA[i] = 0x19 + } + if m.YM != 0 { + i -= 8 + encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.YM)))) + i-- + dAtA[i] = 0x11 + } + if m.XM != 0 { + i -= 8 + encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.XM)))) + i-- + dAtA[i] = 0x9 } return len(dAtA) - i, nil } -func (m *FrequencyBandItem) Marshal() (dAtA []byte, err error) { +func (m *AzElOrientation) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -7341,25 +7280,38 @@ func (m *FrequencyBandItem) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *FrequencyBandItem) MarshalTo(dAtA []byte) (int, error) { +func (m *AzElOrientation) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *FrequencyBandItem) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *AzElOrientation) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l - if m.NrFrequencyBand != 0 { - i = encodeVarintRan(dAtA, i, uint64(m.NrFrequencyBand)) + if m.RotationDeg != 0 { + i -= 8 + encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.RotationDeg)))) i-- - dAtA[i] = 0x8 + dAtA[i] = 0x19 + } + if m.ElevationDeg != 0 { + i -= 8 + encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.ElevationDeg)))) + i-- + dAtA[i] = 0x11 + } + if m.AzimuthDeg != 0 { + i -= 8 + encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.AzimuthDeg)))) + i-- + dAtA[i] = 0x9 } return len(dAtA) - i, nil } -func (m *GlobalNgRanNodeID) Marshal() (dAtA []byte, err error) { +func (m *YprOrientation) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -7369,21 +7321,62 @@ func (m *GlobalNgRanNodeID) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *GlobalNgRanNodeID) MarshalTo(dAtA []byte) (int, error) { +func (m *YprOrientation) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *GlobalNgRanNodeID) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *YprOrientation) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l - if m.GlobalNgRanNodeId != nil { + if m.RollDeg != 0 { + i -= 8 + encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.RollDeg)))) + i-- + dAtA[i] = 0x19 + } + if m.PitchDeg != 0 { + i -= 8 + encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.PitchDeg)))) + i-- + dAtA[i] = 0x11 + } + if m.YawDeg != 0 { + i -= 8 + encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.YawDeg)))) + i-- + dAtA[i] = 0x9 + } + return len(dAtA) - i, nil +} + +func (m *Orientation) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *Orientation) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *Orientation) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Orientation != nil { { - size := m.GlobalNgRanNodeId.Size() + size := m.Orientation.Size() i -= size - if _, err := m.GlobalNgRanNodeId.MarshalTo(dAtA[i:]); err != nil { + if _, err := m.Orientation.MarshalTo(dAtA[i:]); err != nil { return 0, err } } @@ -7391,16 +7384,16 @@ func (m *GlobalNgRanNodeID) MarshalToSizedBuffer(dAtA []byte) (int, error) { return len(dAtA) - i, nil } -func (m *GlobalNgRanNodeID_GlobalGnbId) MarshalTo(dAtA []byte) (int, error) { +func (m *Orientation_Azel) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *GlobalNgRanNodeID_GlobalGnbId) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *Orientation_Azel) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) - if m.GlobalGnbId != nil { + if m.Azel != nil { { - size, err := m.GlobalGnbId.MarshalToSizedBuffer(dAtA[:i]) + size, err := m.Azel.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } @@ -7412,16 +7405,16 @@ func (m *GlobalNgRanNodeID_GlobalGnbId) MarshalToSizedBuffer(dAtA []byte) (int, } return len(dAtA) - i, nil } -func (m *GlobalNgRanNodeID_GlobalNgEnbId) MarshalTo(dAtA []byte) (int, error) { +func (m *Orientation_Ypr) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *GlobalNgRanNodeID_GlobalNgEnbId) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *Orientation_Ypr) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) - if m.GlobalNgEnbId != nil { + if m.Ypr != nil { { - size, err := m.GlobalNgEnbId.MarshalToSizedBuffer(dAtA[:i]) + size, err := m.Ypr.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } @@ -7433,7 +7426,7 @@ func (m *GlobalNgRanNodeID_GlobalNgEnbId) MarshalToSizedBuffer(dAtA []byte) (int } return len(dAtA) - i, nil } -func (m *GlobalGnbID) Marshal() (dAtA []byte, err error) { +func (m *Waypoint) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -7443,35 +7436,44 @@ func (m *GlobalGnbID) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *GlobalGnbID) MarshalTo(dAtA []byte) (int, error) { +func (m *Waypoint) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *GlobalGnbID) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *Waypoint) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l - if m.GnbIdLen != 0 { - i = encodeVarintRan(dAtA, i, uint64(m.GnbIdLen)) - i-- - dAtA[i] = 0x18 - } - if m.GnbId != 0 { - i = encodeVarintRan(dAtA, i, uint64(m.GnbId)) + if m.Location != nil { + { + size, err := m.Location.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintRan(dAtA, i, uint64(size)) + } i-- - dAtA[i] = 0x10 + dAtA[i] = 0x12 } - if m.PlmnId != 0 { - i = encodeVarintRan(dAtA, i, uint64(m.PlmnId)) + if m.Time != nil { + { + size, err := m.Time.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintRan(dAtA, i, uint64(size)) + } i-- - dAtA[i] = 0x8 + dAtA[i] = 0xa } return len(dAtA) - i, nil } -func (m *GlobalNgEnbID) Marshal() (dAtA []byte, err error) { +func (m *Waypoints) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -7481,70 +7483,34 @@ func (m *GlobalNgEnbID) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *GlobalNgEnbID) MarshalTo(dAtA []byte) (int, error) { +func (m *Waypoints) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *GlobalNgEnbID) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *Waypoints) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l - if m.NgEnbId != nil { - { - size := m.NgEnbId.Size() - i -= size - if _, err := m.NgEnbId.MarshalTo(dAtA[i:]); err != nil { - return 0, err + if len(m.Waypoint) > 0 { + for iNdEx := len(m.Waypoint) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.Waypoint[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintRan(dAtA, i, uint64(size)) } + i-- + dAtA[i] = 0xa } } - if m.PlmnId != 0 { - i = encodeVarintRan(dAtA, i, uint64(m.PlmnId)) - i-- - dAtA[i] = 0x8 - } - return len(dAtA) - i, nil -} - -func (m *GlobalNgEnbID_MacroNgEnbId) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *GlobalNgEnbID_MacroNgEnbId) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - i = encodeVarintRan(dAtA, i, uint64(m.MacroNgEnbId)) - i-- - dAtA[i] = 0x10 - return len(dAtA) - i, nil -} -func (m *GlobalNgEnbID_ShortMacroNgEnbId) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *GlobalNgEnbID_ShortMacroNgEnbId) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - i = encodeVarintRan(dAtA, i, uint64(m.ShortMacroNgEnbId)) - i-- - dAtA[i] = 0x18 return len(dAtA) - i, nil } -func (m *GlobalNgEnbID_LongMacroNgEnbId) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} -func (m *GlobalNgEnbID_LongMacroNgEnbId) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - i = encodeVarintRan(dAtA, i, uint64(m.LongMacroNgEnbId)) - i-- - dAtA[i] = 0x20 - return len(dAtA) - i, nil -} -func (m *TaiSupportList) Marshal() (dAtA []byte, err error) { +func (m *OrbitData) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -7554,34 +7520,68 @@ func (m *TaiSupportList) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *TaiSupportList) MarshalTo(dAtA []byte) (int, error) { +func (m *OrbitData) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *TaiSupportList) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *OrbitData) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l - if len(m.TaiSupportItems) > 0 { - for iNdEx := len(m.TaiSupportItems) - 1; iNdEx >= 0; iNdEx-- { - { - size, err := m.TaiSupportItems[iNdEx].MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintRan(dAtA, i, uint64(size)) + if m.MeanMotion != 0 { + i -= 8 + encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.MeanMotion)))) + i-- + dAtA[i] = 0x39 + } + if m.AnomalyDeg != 0 { + i -= 8 + encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.AnomalyDeg)))) + i-- + dAtA[i] = 0x31 + } + if m.ArgumentDeg != 0 { + i -= 8 + encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.ArgumentDeg)))) + i-- + dAtA[i] = 0x29 + } + if m.E != 0 { + i -= 8 + encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.E)))) + i-- + dAtA[i] = 0x21 + } + if m.RaanDeg != 0 { + i -= 8 + encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.RaanDeg)))) + i-- + dAtA[i] = 0x19 + } + if m.InclinationDeg != 0 { + i -= 8 + encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.InclinationDeg)))) + i-- + dAtA[i] = 0x11 + } + if m.Epoch != nil { + { + size, err := m.Epoch.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err } - i-- - dAtA[i] = 0xa + i -= size + i = encodeVarintRan(dAtA, i, uint64(size)) } + i-- + dAtA[i] = 0xa } return len(dAtA) - i, nil } -func (m *TaiSupportItem) Marshal() (dAtA []byte, err error) { +func (m *Motion) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -7591,61 +7591,59 @@ func (m *TaiSupportItem) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *TaiSupportItem) MarshalTo(dAtA []byte) (int, error) { +func (m *Motion) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *TaiSupportItem) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *Motion) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l - if len(m.BroadcastPlmns) > 0 { - for iNdEx := len(m.BroadcastPlmns) - 1; iNdEx >= 0; iNdEx-- { - { - size, err := m.BroadcastPlmns[iNdEx].MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintRan(dAtA, i, uint64(size)) + if m.Motion != nil { + { + size := m.Motion.Size() + i -= size + if _, err := m.Motion.MarshalTo(dAtA[i:]); err != nil { + return 0, err } - i-- - dAtA[i] = 0x12 } } - if m.Tac != 0 { - i = encodeVarintRan(dAtA, i, uint64(m.Tac)) - i-- - dAtA[i] = 0x8 - } return len(dAtA) - i, nil } -func (m *XnBroadcastPlmn) Marshal() (dAtA []byte, err error) { +func (m *Motion_FixedLocation) MarshalTo(dAtA []byte) (int, error) { size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { - return nil, err - } - return dAtA[:n], nil + return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *XnBroadcastPlmn) MarshalTo(dAtA []byte) (int, error) { +func (m *Motion_FixedLocation) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + if m.FixedLocation != nil { + { + size, err := m.FixedLocation.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintRan(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} +func (m *Motion_Waypoints) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *XnBroadcastPlmn) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *Motion_Waypoints) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) - _ = i - var l int - _ = l - if m.TaiSliceSupportList != nil { + if m.Waypoints != nil { { - size, err := m.TaiSliceSupportList.MarshalToSizedBuffer(dAtA[:i]) + size, err := m.Waypoints.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } @@ -7655,15 +7653,30 @@ func (m *XnBroadcastPlmn) MarshalToSizedBuffer(dAtA []byte) (int, error) { i-- dAtA[i] = 0x12 } - if m.PlmnId != 0 { - i = encodeVarintRan(dAtA, i, uint64(m.PlmnId)) + return len(dAtA) - i, nil +} +func (m *Motion_Orbit) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *Motion_Orbit) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + if m.Orbit != nil { + { + size, err := m.Orbit.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintRan(dAtA, i, uint64(size)) + } i-- - dAtA[i] = 0x8 + dAtA[i] = 0x1a } return len(dAtA) - i, nil } - -func (m *TaiSliceSupportList) Marshal() (dAtA []byte, err error) { +func (m *Coverage) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -7673,34 +7686,40 @@ func (m *TaiSliceSupportList) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *TaiSliceSupportList) MarshalTo(dAtA []byte) (int, error) { +func (m *Coverage) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *TaiSliceSupportList) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *Coverage) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l - if len(m.SliceSupportItems) > 0 { - for iNdEx := len(m.SliceSupportItems) - 1; iNdEx >= 0; iNdEx-- { - { - size, err := m.SliceSupportItems[iNdEx].MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintRan(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0xa - } + if m.Tilt != 0 { + i = encodeVarintRan(dAtA, i, uint64(m.Tilt)) + i-- + dAtA[i] = 0x20 + } + if m.Azimuth != 0 { + i = encodeVarintRan(dAtA, i, uint64(m.Azimuth)) + i-- + dAtA[i] = 0x18 + } + if m.ArcWidth != 0 { + i = encodeVarintRan(dAtA, i, uint64(m.ArcWidth)) + i-- + dAtA[i] = 0x10 + } + if m.Height != 0 { + i = encodeVarintRan(dAtA, i, uint64(m.Height)) + i-- + dAtA[i] = 0x8 } return len(dAtA) - i, nil } -func (m *SliceSupportItem) Marshal() (dAtA []byte, err error) { +func (m *E2Node) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -7710,32 +7729,46 @@ func (m *SliceSupportItem) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *SliceSupportItem) MarshalTo(dAtA []byte) (int, error) { +func (m *E2Node) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *SliceSupportItem) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *E2Node) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l - if m.SNssai != nil { - { - size, err := m.SNssai.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err + if len(m.ServiceModels) > 0 { + for k := range m.ServiceModels { + v := m.ServiceModels[k] + baseI := i + if v != nil { + { + size, err := v.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintRan(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 } - i -= size - i = encodeVarintRan(dAtA, i, uint64(size)) + i -= len(k) + copy(dAtA[i:], k) + i = encodeVarintRan(dAtA, i, uint64(len(k))) + i-- + dAtA[i] = 0xa + i = encodeVarintRan(dAtA, i, uint64(baseI-i)) + i-- + dAtA[i] = 0xa } - i-- - dAtA[i] = 0xa } return len(dAtA) - i, nil } -func (m *SNssai) Marshal() (dAtA []byte, err error) { +func (m *E2NodeConfig) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -7745,30 +7778,39 @@ func (m *SNssai) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *SNssai) MarshalTo(dAtA []byte) (int, error) { +func (m *E2NodeConfig) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *SNssai) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *E2NodeConfig) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l - if m.Sd != 0 { - i = encodeVarintRan(dAtA, i, uint64(m.Sd)) + if m.Version != 0 { + i = encodeVarintRan(dAtA, i, uint64(m.Version)) i-- dAtA[i] = 0x10 } - if m.Sst != 0 { - i = encodeVarintRan(dAtA, i, uint64(m.Sst)) - i-- - dAtA[i] = 0x8 + if len(m.Connections) > 0 { + for iNdEx := len(m.Connections) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.Connections[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintRan(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } } return len(dAtA) - i, nil } -func (m *AmfRegionInformation) Marshal() (dAtA []byte, err error) { +func (m *Lease) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -7778,34 +7820,30 @@ func (m *AmfRegionInformation) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *AmfRegionInformation) MarshalTo(dAtA []byte) (int, error) { +func (m *Lease) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *AmfRegionInformation) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *Lease) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l - if len(m.GlobalAmfRegionInformationItems) > 0 { - for iNdEx := len(m.GlobalAmfRegionInformationItems) - 1; iNdEx >= 0; iNdEx-- { - { - size, err := m.GlobalAmfRegionInformationItems[iNdEx].MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintRan(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0xa + if m.Expiration != nil { + n12, err12 := github_com_gogo_protobuf_types.StdTimeMarshalTo(*m.Expiration, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(*m.Expiration):]) + if err12 != nil { + return 0, err12 } + i -= n12 + i = encodeVarintRan(dAtA, i, uint64(n12)) + i-- + dAtA[i] = 0xa } return len(dAtA) - i, nil } -func (m *GlobalAmfRegionInformationItem) Marshal() (dAtA []byte, err error) { +func (m *Interface) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -7815,30 +7853,37 @@ func (m *GlobalAmfRegionInformationItem) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *GlobalAmfRegionInformationItem) MarshalTo(dAtA []byte) (int, error) { +func (m *Interface) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *GlobalAmfRegionInformationItem) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *Interface) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l - if m.AmfRegionId != 0 { - i = encodeVarintRan(dAtA, i, uint64(m.AmfRegionId)) + if m.Port != 0 { + i = encodeVarintRan(dAtA, i, uint64(m.Port)) i-- - dAtA[i] = 0x10 + dAtA[i] = 0x18 } - if m.PlmnId != 0 { - i = encodeVarintRan(dAtA, i, uint64(m.PlmnId)) + if len(m.IP) > 0 { + i -= len(m.IP) + copy(dAtA[i:], m.IP) + i = encodeVarintRan(dAtA, i, uint64(len(m.IP))) + i-- + dAtA[i] = 0x12 + } + if m.Type != 0 { + i = encodeVarintRan(dAtA, i, uint64(m.Type)) i-- dAtA[i] = 0x8 } return len(dAtA) - i, nil } -func (m *NeighborInformationNr) Marshal() (dAtA []byte, err error) { +func (m *E2TInfo) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -7848,110 +7893,34 @@ func (m *NeighborInformationNr) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *NeighborInformationNr) MarshalTo(dAtA []byte) (int, error) { +func (m *E2TInfo) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *NeighborInformationNr) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *E2TInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l - if m.MeasurementTimingConfiguration != 0 { - i = encodeVarintRan(dAtA, i, uint64(m.MeasurementTimingConfiguration)) - i-- - dAtA[i] = 0x38 - } - if m.ConnectivitySupport != nil { - { - size, err := m.ConnectivitySupport.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err + if len(m.Interfaces) > 0 { + for iNdEx := len(m.Interfaces) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.Interfaces[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintRan(dAtA, i, uint64(size)) } - i -= size - i = encodeVarintRan(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa } - i-- - dAtA[i] = 0x32 - } - if m.NrModeInfo != nil { - { - size := m.NrModeInfo.Size() - i -= size - if _, err := m.NrModeInfo.MarshalTo(dAtA[i:]); err != nil { - return 0, err - } - } - } - if m.Tac != 0 { - i = encodeVarintRan(dAtA, i, uint64(m.Tac)) - i-- - dAtA[i] = 0x18 - } - if m.NrCgi != nil { - { - size, err := m.NrCgi.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintRan(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x12 - } - if m.Pci != 0 { - i = encodeVarintRan(dAtA, i, uint64(m.Pci)) - i-- - dAtA[i] = 0x8 - } - return len(dAtA) - i, nil -} - -func (m *NeighborInformationNr_FddInfo) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *NeighborInformationNr_FddInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - if m.FddInfo != nil { - { - size, err := m.FddInfo.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintRan(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x22 } return len(dAtA) - i, nil } -func (m *NeighborInformationNr_TddInfo) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} -func (m *NeighborInformationNr_TddInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - if m.TddInfo != nil { - { - size, err := m.TddInfo.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintRan(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x2a - } - return len(dAtA) - i, nil -} -func (m *ServiceModelInfo) Marshal() (dAtA []byte, err error) { +func (m *XAppInfo) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -7961,38 +7930,34 @@ func (m *ServiceModelInfo) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *ServiceModelInfo) MarshalTo(dAtA []byte) (int, error) { +func (m *XAppInfo) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *ServiceModelInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *XAppInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l - if len(m.RanFunctionIDs) > 0 { - dAtA39 := make([]byte, len(m.RanFunctionIDs)*10) - var j38 int - for _, num := range m.RanFunctionIDs { - for num >= 1<<7 { - dAtA39[j38] = uint8(uint64(num)&0x7f | 0x80) - num >>= 7 - j38++ + if len(m.A1PolicyTypes) > 0 { + for iNdEx := len(m.A1PolicyTypes) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.A1PolicyTypes[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintRan(dAtA, i, uint64(size)) } - dAtA39[j38] = uint8(num) - j38++ + i-- + dAtA[i] = 0x12 } - i -= j38 - copy(dAtA[i:], dAtA39[:j38]) - i = encodeVarintRan(dAtA, i, uint64(j38)) - i-- - dAtA[i] = 0x22 } - if len(m.RanFunctions) > 0 { - for iNdEx := len(m.RanFunctions) - 1; iNdEx >= 0; iNdEx-- { + if len(m.Interfaces) > 0 { + for iNdEx := len(m.Interfaces) - 1; iNdEx >= 0; iNdEx-- { { - size, err := m.RanFunctions[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + size, err := m.Interfaces[iNdEx].MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } @@ -8000,27 +7965,13 @@ func (m *ServiceModelInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) { i = encodeVarintRan(dAtA, i, uint64(size)) } i-- - dAtA[i] = 0x1a + dAtA[i] = 0xa } } - if len(m.Name) > 0 { - i -= len(m.Name) - copy(dAtA[i:], m.Name) - i = encodeVarintRan(dAtA, i, uint64(len(m.Name))) - i-- - dAtA[i] = 0x12 - } - if len(m.OID) > 0 { - i -= len(m.OID) - copy(dAtA[i:], m.OID) - i = encodeVarintRan(dAtA, i, uint64(len(m.OID))) - i-- - dAtA[i] = 0xa - } return len(dAtA) - i, nil } -func (m *RCRanFunction) Marshal() (dAtA []byte, err error) { +func (m *A1PolicyType) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -8030,85 +7981,36 @@ func (m *RCRanFunction) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *RCRanFunction) MarshalTo(dAtA []byte) (int, error) { +func (m *A1PolicyType) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *RCRanFunction) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *A1PolicyType) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l - if len(m.ControlStyles) > 0 { - for iNdEx := len(m.ControlStyles) - 1; iNdEx >= 0; iNdEx-- { - { - size, err := m.ControlStyles[iNdEx].MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintRan(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x32 - } - } - if len(m.PolicyStyles) > 0 { - for iNdEx := len(m.PolicyStyles) - 1; iNdEx >= 0; iNdEx-- { - { - size, err := m.PolicyStyles[iNdEx].MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintRan(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x2a - } - } - if len(m.EventTriggerStyles) > 0 { - for iNdEx := len(m.EventTriggerStyles) - 1; iNdEx >= 0; iNdEx-- { - { - size, err := m.EventTriggerStyles[iNdEx].MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintRan(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x22 - } + if len(m.Description) > 0 { + i -= len(m.Description) + copy(dAtA[i:], m.Description) + i = encodeVarintRan(dAtA, i, uint64(len(m.Description))) + i-- + dAtA[i] = 0x22 } - if len(m.InsertStyles) > 0 { - for iNdEx := len(m.InsertStyles) - 1; iNdEx >= 0; iNdEx-- { - { - size, err := m.InsertStyles[iNdEx].MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintRan(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x1a - } + if len(m.Version) > 0 { + i -= len(m.Version) + copy(dAtA[i:], m.Version) + i = encodeVarintRan(dAtA, i, uint64(len(m.Version))) + i-- + dAtA[i] = 0x1a } - if len(m.ReportStyles) > 0 { - for iNdEx := len(m.ReportStyles) - 1; iNdEx >= 0; iNdEx-- { - { - size, err := m.ReportStyles[iNdEx].MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintRan(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x12 - } + if len(m.Name) > 0 { + i -= len(m.Name) + copy(dAtA[i:], m.Name) + i = encodeVarintRan(dAtA, i, uint64(len(m.Name))) + i-- + dAtA[i] = 0x12 } if len(m.ID) > 0 { i -= len(m.ID) @@ -8120,7 +8022,7 @@ func (m *RCRanFunction) MarshalToSizedBuffer(dAtA []byte) (int, error) { return len(dAtA) - i, nil } -func (m *MHORanFunction) Marshal() (dAtA []byte, err error) { +func (m *A1TInfo) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -8130,20 +8032,20 @@ func (m *MHORanFunction) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *MHORanFunction) MarshalTo(dAtA []byte) (int, error) { +func (m *A1TInfo) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *MHORanFunction) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *A1TInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l - if len(m.ReportStyles) > 0 { - for iNdEx := len(m.ReportStyles) - 1; iNdEx >= 0; iNdEx-- { + if len(m.Interfaces) > 0 { + for iNdEx := len(m.Interfaces) - 1; iNdEx >= 0; iNdEx-- { { - size, err := m.ReportStyles[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + size, err := m.Interfaces[iNdEx].MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } @@ -8151,20 +8053,13 @@ func (m *MHORanFunction) MarshalToSizedBuffer(dAtA []byte) (int, error) { i = encodeVarintRan(dAtA, i, uint64(size)) } i-- - dAtA[i] = 0x12 + dAtA[i] = 0xa } } - if len(m.ID) > 0 { - i -= len(m.ID) - copy(dAtA[i:], m.ID) - i = encodeVarintRan(dAtA, i, uint64(len(m.ID))) - i-- - dAtA[i] = 0xa - } return len(dAtA) - i, nil } -func (m *KPMRanFunction) Marshal() (dAtA []byte, err error) { +func (m *CellGlobalID) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -8174,85 +8069,32 @@ func (m *KPMRanFunction) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *KPMRanFunction) MarshalTo(dAtA []byte) (int, error) { +func (m *CellGlobalID) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *KPMRanFunction) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *CellGlobalID) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l - if len(m.ReportStyles) > 0 { - for iNdEx := len(m.ReportStyles) - 1; iNdEx >= 0; iNdEx-- { - { - size, err := m.ReportStyles[iNdEx].MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintRan(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x12 - } - } - if len(m.ID) > 0 { - i -= len(m.ID) - copy(dAtA[i:], m.ID) - i = encodeVarintRan(dAtA, i, uint64(len(m.ID))) + if m.Type != 0 { + i = encodeVarintRan(dAtA, i, uint64(m.Type)) i-- - dAtA[i] = 0xa - } - return len(dAtA) - i, nil -} - -func (m *RSMRanFunction) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { - return nil, err - } - return dAtA[:n], nil -} - -func (m *RSMRanFunction) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *RSMRanFunction) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if len(m.RicSlicingNodeCapabilityList) > 0 { - for iNdEx := len(m.RicSlicingNodeCapabilityList) - 1; iNdEx >= 0; iNdEx-- { - { - size, err := m.RicSlicingNodeCapabilityList[iNdEx].MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintRan(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x12 - } + dAtA[i] = 0x10 } - if len(m.ID) > 0 { - i -= len(m.ID) - copy(dAtA[i:], m.ID) - i = encodeVarintRan(dAtA, i, uint64(len(m.ID))) + if len(m.Value) > 0 { + i -= len(m.Value) + copy(dAtA[i:], m.Value) + i = encodeVarintRan(dAtA, i, uint64(len(m.Value))) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } -func (m *RCEventTriggerStyle) Marshal() (dAtA []byte, err error) { +func (m *NeighborCellID) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -8262,37 +8104,39 @@ func (m *RCEventTriggerStyle) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *RCEventTriggerStyle) MarshalTo(dAtA []byte) (int, error) { +func (m *NeighborCellID) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *RCEventTriggerStyle) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *NeighborCellID) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l - if m.FormatType != 0 { - i = encodeVarintRan(dAtA, i, uint64(m.FormatType)) - i-- - dAtA[i] = 0x18 - } - if m.Type != 0 { - i = encodeVarintRan(dAtA, i, uint64(m.Type)) + if len(m.PlmnID) > 0 { + i -= len(m.PlmnID) + copy(dAtA[i:], m.PlmnID) + i = encodeVarintRan(dAtA, i, uint64(len(m.PlmnID))) i-- - dAtA[i] = 0x10 + dAtA[i] = 0x12 } - if len(m.Name) > 0 { - i -= len(m.Name) - copy(dAtA[i:], m.Name) - i = encodeVarintRan(dAtA, i, uint64(len(m.Name))) + if m.CellGlobalID != nil { + { + size, err := m.CellGlobalID.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintRan(dAtA, i, uint64(size)) + } i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } -func (m *RCReportStyle) Marshal() (dAtA []byte, err error) { +func (m *E2Cell) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -8302,20 +8146,20 @@ func (m *RCReportStyle) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *RCReportStyle) MarshalTo(dAtA []byte) (int, error) { +func (m *E2Cell) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *RCReportStyle) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *E2Cell) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l - if len(m.RanParameters) > 0 { - for iNdEx := len(m.RanParameters) - 1; iNdEx >= 0; iNdEx-- { + if len(m.NeighborInformationNrs) > 0 { + for iNdEx := len(m.NeighborInformationNrs) - 1; iNdEx >= 0; iNdEx-- { { - size, err := m.RanParameters[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + size, err := m.NeighborInformationNrs[iNdEx].MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } @@ -8323,209 +8167,118 @@ func (m *RCReportStyle) MarshalToSizedBuffer(dAtA []byte) (int, error) { i = encodeVarintRan(dAtA, i, uint64(size)) } i-- - dAtA[i] = 0x1a + dAtA[i] = 0x1 + i-- + dAtA[i] = 0xa2 } } - if m.Type != 0 { - i = encodeVarintRan(dAtA, i, uint64(m.Type)) + if m.ConnectivitySupport != nil { + { + size, err := m.ConnectivitySupport.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintRan(dAtA, i, uint64(size)) + } i-- - dAtA[i] = 0x10 - } - if len(m.Name) > 0 { - i -= len(m.Name) - copy(dAtA[i:], m.Name) - i = encodeVarintRan(dAtA, i, uint64(len(m.Name))) + dAtA[i] = 0x1 i-- - dAtA[i] = 0xa - } - return len(dAtA) - i, nil -} - -func (m *RCInsertStyle) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { - return nil, err + dAtA[i] = 0x9a } - return dAtA[:n], nil -} - -func (m *RCInsertStyle) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *RCInsertStyle) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if len(m.InsertIndications) > 0 { - for iNdEx := len(m.InsertIndications) - 1; iNdEx >= 0; iNdEx-- { - { - size, err := m.InsertIndications[iNdEx].MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintRan(dAtA, i, uint64(size)) + if m.AmfRegionInformation != nil { + { + size, err := m.AmfRegionInformation.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err } - i-- - dAtA[i] = 0x1a + i -= size + i = encodeVarintRan(dAtA, i, uint64(size)) } - } - if m.Type != 0 { - i = encodeVarintRan(dAtA, i, uint64(m.Type)) i-- - dAtA[i] = 0x10 - } - if len(m.Name) > 0 { - i -= len(m.Name) - copy(dAtA[i:], m.Name) - i = encodeVarintRan(dAtA, i, uint64(len(m.Name))) + dAtA[i] = 0x1 i-- - dAtA[i] = 0xa - } - return len(dAtA) - i, nil -} - -func (m *RCPolicyStyle) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { - return nil, err + dAtA[i] = 0x92 } - return dAtA[:n], nil -} - -func (m *RCPolicyStyle) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *RCPolicyStyle) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if len(m.PolicyActions) > 0 { - for iNdEx := len(m.PolicyActions) - 1; iNdEx >= 0; iNdEx-- { - { - size, err := m.PolicyActions[iNdEx].MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintRan(dAtA, i, uint64(size)) + if m.TaiSupportList != nil { + { + size, err := m.TaiSupportList.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err } - i-- - dAtA[i] = 0x1a + i -= size + i = encodeVarintRan(dAtA, i, uint64(size)) } + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0x8a } - if m.Type != 0 { - i = encodeVarintRan(dAtA, i, uint64(m.Type)) + if m.GlobalNgRanNodeId != nil { + { + size, err := m.GlobalNgRanNodeId.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintRan(dAtA, i, uint64(size)) + } i-- - dAtA[i] = 0x10 + dAtA[i] = 0x1 + i-- + dAtA[i] = 0x82 } - if len(m.Name) > 0 { - i -= len(m.Name) - copy(dAtA[i:], m.Name) - i = encodeVarintRan(dAtA, i, uint64(len(m.Name))) + if m.MeasurementTimingConfiguration != 0 { + i = encodeVarintRan(dAtA, i, uint64(m.MeasurementTimingConfiguration)) i-- - dAtA[i] = 0xa + dAtA[i] = 0x78 } - return len(dAtA) - i, nil -} - -func (m *PolicyAction) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { - return nil, err - } - return dAtA[:n], nil -} - -func (m *PolicyAction) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *PolicyAction) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if len(m.PolicyConditionRanParameters) > 0 { - for iNdEx := len(m.PolicyConditionRanParameters) - 1; iNdEx >= 0; iNdEx-- { - { - size, err := m.PolicyConditionRanParameters[iNdEx].MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintRan(dAtA, i, uint64(size)) + if m.NrModeInfo != nil { + { + size := m.NrModeInfo.Size() + i -= size + if _, err := m.NrModeInfo.MarshalTo(dAtA[i:]); err != nil { + return 0, err } - i-- - dAtA[i] = 0x22 } } - if len(m.PolicyActionRanParameters) > 0 { - for iNdEx := len(m.PolicyActionRanParameters) - 1; iNdEx >= 0; iNdEx-- { - { - size, err := m.PolicyActionRanParameters[iNdEx].MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintRan(dAtA, i, uint64(size)) + if len(m.ServedPlmns) > 0 { + dAtA19 := make([]byte, len(m.ServedPlmns)*10) + var j18 int + for _, num := range m.ServedPlmns { + for num >= 1<<7 { + dAtA19[j18] = uint8(uint64(num)&0x7f | 0x80) + num >>= 7 + j18++ } - i-- - dAtA[i] = 0x1a + dAtA19[j18] = uint8(num) + j18++ } + i -= j18 + copy(dAtA[i:], dAtA19[:j18]) + i = encodeVarintRan(dAtA, i, uint64(j18)) + i-- + dAtA[i] = 0x62 } - if len(m.Name) > 0 { - i -= len(m.Name) - copy(dAtA[i:], m.Name) - i = encodeVarintRan(dAtA, i, uint64(len(m.Name))) + if m.PlmnId != 0 { + i = encodeVarintRan(dAtA, i, uint64(m.PlmnId)) i-- - dAtA[i] = 0x12 + dAtA[i] = 0x58 } - if m.ID != 0 { - i = encodeVarintRan(dAtA, i, uint64(m.ID)) + if m.LatestRrcVersion != 0 { + i = encodeVarintRan(dAtA, i, uint64(m.LatestRrcVersion)) i-- - dAtA[i] = 0x8 + dAtA[i] = 0x50 } - return len(dAtA) - i, nil -} - -func (m *RCControlStyle) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { - return nil, err + if m.GnbDuId != 0 { + i = encodeVarintRan(dAtA, i, uint64(m.GnbDuId)) + i-- + dAtA[i] = 0x48 } - return dAtA[:n], nil -} - -func (m *RCControlStyle) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *RCControlStyle) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if len(m.ControlActions) > 0 { - for iNdEx := len(m.ControlActions) - 1; iNdEx >= 0; iNdEx-- { + if len(m.NeighborCellIDs) > 0 { + for iNdEx := len(m.NeighborCellIDs) - 1; iNdEx >= 0; iNdEx-- { { - size, err := m.ControlActions[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + size, err := m.NeighborCellIDs[iNdEx].MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } @@ -8533,40 +8286,113 @@ func (m *RCControlStyle) MarshalToSizedBuffer(dAtA []byte) (int, error) { i = encodeVarintRan(dAtA, i, uint64(size)) } i-- - dAtA[i] = 0x32 + dAtA[i] = 0x42 } } - if m.ControlOutcomeFormatType != 0 { - i = encodeVarintRan(dAtA, i, uint64(m.ControlOutcomeFormatType)) + if len(m.KpiReports) > 0 { + for k := range m.KpiReports { + v := m.KpiReports[k] + baseI := i + i = encodeVarintRan(dAtA, i, uint64(v)) + i-- + dAtA[i] = 0x10 + i -= len(k) + copy(dAtA[i:], k) + i = encodeVarintRan(dAtA, i, uint64(len(k))) + i-- + dAtA[i] = 0xa + i = encodeVarintRan(dAtA, i, uint64(baseI-i)) + i-- + dAtA[i] = 0x3a + } + } + if m.PCI != 0 { + i = encodeVarintRan(dAtA, i, uint64(m.PCI)) i-- - dAtA[i] = 0x28 + dAtA[i] = 0x30 } - if m.MessageFormatType != 0 { - i = encodeVarintRan(dAtA, i, uint64(m.MessageFormatType)) + if len(m.CellType) > 0 { + i -= len(m.CellType) + copy(dAtA[i:], m.CellType) + i = encodeVarintRan(dAtA, i, uint64(len(m.CellType))) + i-- + dAtA[i] = 0x2a + } + if m.ARFCN != 0 { + i = encodeVarintRan(dAtA, i, uint64(m.ARFCN)) i-- dAtA[i] = 0x20 } - if m.HeaderFormatType != 0 { - i = encodeVarintRan(dAtA, i, uint64(m.HeaderFormatType)) + if m.AntennaCount != 0 { + i = encodeVarintRan(dAtA, i, uint64(m.AntennaCount)) i-- dAtA[i] = 0x18 } - if m.Type != 0 { - i = encodeVarintRan(dAtA, i, uint64(m.Type)) + if m.CellGlobalID != nil { + { + size, err := m.CellGlobalID.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintRan(dAtA, i, uint64(size)) + } i-- - dAtA[i] = 0x10 + dAtA[i] = 0x12 } - if len(m.Name) > 0 { - i -= len(m.Name) - copy(dAtA[i:], m.Name) - i = encodeVarintRan(dAtA, i, uint64(len(m.Name))) + if len(m.CellObjectID) > 0 { + i -= len(m.CellObjectID) + copy(dAtA[i:], m.CellObjectID) + i = encodeVarintRan(dAtA, i, uint64(len(m.CellObjectID))) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } -func (m *ControlAction) Marshal() (dAtA []byte, err error) { +func (m *E2Cell_FddInfo) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *E2Cell_FddInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + if m.FddInfo != nil { + { + size, err := m.FddInfo.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintRan(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x6a + } + return len(dAtA) - i, nil +} +func (m *E2Cell_TddInfo) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *E2Cell_TddInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + if m.TddInfo != nil { + { + size, err := m.TddInfo.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintRan(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x72 + } + return len(dAtA) - i, nil +} +func (m *ConnectivitySupport) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -8576,46 +8402,25 @@ func (m *ControlAction) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *ControlAction) MarshalTo(dAtA []byte) (int, error) { +func (m *ConnectivitySupport) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *ControlAction) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *ConnectivitySupport) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l - if len(m.RanParameters) > 0 { - for iNdEx := len(m.RanParameters) - 1; iNdEx >= 0; iNdEx-- { - { - size, err := m.RanParameters[iNdEx].MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintRan(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x1a - } - } - if len(m.Name) > 0 { - i -= len(m.Name) - copy(dAtA[i:], m.Name) - i = encodeVarintRan(dAtA, i, uint64(len(m.Name))) - i-- - dAtA[i] = 0x12 - } - if m.ID != 0 { - i = encodeVarintRan(dAtA, i, uint64(m.ID)) + if m.EnDcSupport != 0 { + i = encodeVarintRan(dAtA, i, uint64(m.EnDcSupport)) i-- dAtA[i] = 0x8 } return len(dAtA) - i, nil } -func (m *InsertIndication) Marshal() (dAtA []byte, err error) { +func (m *FDDInfo) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -8625,81 +8430,68 @@ func (m *InsertIndication) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *InsertIndication) MarshalTo(dAtA []byte) (int, error) { +func (m *FDDInfo) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *InsertIndication) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *FDDInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l - if len(m.RanParameters) > 0 { - for iNdEx := len(m.RanParameters) - 1; iNdEx >= 0; iNdEx-- { - { - size, err := m.RanParameters[iNdEx].MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintRan(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x1a - } - } - if len(m.Name) > 0 { - i -= len(m.Name) - copy(dAtA[i:], m.Name) - i = encodeVarintRan(dAtA, i, uint64(len(m.Name))) + if m.DlTransmissionBandwidth != nil { + { + size, err := m.DlTransmissionBandwidth.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintRan(dAtA, i, uint64(size)) + } i-- - dAtA[i] = 0x12 + dAtA[i] = 0x22 } - if m.ID != 0 { - i = encodeVarintRan(dAtA, i, uint64(m.ID)) + if m.UlTransmissionBandwidth != nil { + { + size, err := m.UlTransmissionBandwidth.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintRan(dAtA, i, uint64(size)) + } i-- - dAtA[i] = 0x8 - } - return len(dAtA) - i, nil -} - -func (m *RANParameter) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { - return nil, err + dAtA[i] = 0x1a } - return dAtA[:n], nil -} - -func (m *RANParameter) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *RANParameter) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if len(m.Name) > 0 { - i -= len(m.Name) - copy(dAtA[i:], m.Name) - i = encodeVarintRan(dAtA, i, uint64(len(m.Name))) + if m.DlFreqInfo != nil { + { + size, err := m.DlFreqInfo.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintRan(dAtA, i, uint64(size)) + } i-- dAtA[i] = 0x12 } - if m.ID != 0 { - i = encodeVarintRan(dAtA, i, uint64(m.ID)) + if m.UlFreqInfo != nil { + { + size, err := m.UlFreqInfo.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintRan(dAtA, i, uint64(size)) + } i-- - dAtA[i] = 0x8 + dAtA[i] = 0xa } return len(dAtA) - i, nil } -func (m *KPMReportStyle) Marshal() (dAtA []byte, err error) { +func (m *TDDInfo) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -8709,46 +8501,44 @@ func (m *KPMReportStyle) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *KPMReportStyle) MarshalTo(dAtA []byte) (int, error) { +func (m *TDDInfo) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *KPMReportStyle) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *TDDInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l - if len(m.Measurements) > 0 { - for iNdEx := len(m.Measurements) - 1; iNdEx >= 0; iNdEx-- { - { - size, err := m.Measurements[iNdEx].MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintRan(dAtA, i, uint64(size)) + if m.TransmissionBandwidth != nil { + { + size, err := m.TransmissionBandwidth.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err } - i-- - dAtA[i] = 0x1a + i -= size + i = encodeVarintRan(dAtA, i, uint64(size)) } - } - if m.Type != 0 { - i = encodeVarintRan(dAtA, i, uint64(m.Type)) i-- - dAtA[i] = 0x10 + dAtA[i] = 0x12 } - if len(m.Name) > 0 { - i -= len(m.Name) - copy(dAtA[i:], m.Name) - i = encodeVarintRan(dAtA, i, uint64(len(m.Name))) + if m.NrFreqInfo != nil { + { + size, err := m.NrFreqInfo.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintRan(dAtA, i, uint64(size)) + } i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } -func (m *MHOReportStyle) Marshal() (dAtA []byte, err error) { +func (m *FrequencyInfo) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -8758,32 +8548,37 @@ func (m *MHOReportStyle) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *MHOReportStyle) MarshalTo(dAtA []byte) (int, error) { +func (m *FrequencyInfo) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *MHOReportStyle) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *FrequencyInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l - if m.Type != 0 { - i = encodeVarintRan(dAtA, i, uint64(m.Type)) + if m.FrequencyBandList != nil { + { + size, err := m.FrequencyBandList.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintRan(dAtA, i, uint64(size)) + } i-- - dAtA[i] = 0x10 + dAtA[i] = 0x12 } - if len(m.Name) > 0 { - i -= len(m.Name) - copy(dAtA[i:], m.Name) - i = encodeVarintRan(dAtA, i, uint64(len(m.Name))) + if m.NrArfcn != 0 { + i = encodeVarintRan(dAtA, i, uint64(m.NrArfcn)) i-- - dAtA[i] = 0xa + dAtA[i] = 0x8 } return len(dAtA) - i, nil } -func (m *KPMMeasurement) Marshal() (dAtA []byte, err error) { +func (m *TransmissionBandwidth) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -8793,34 +8588,30 @@ func (m *KPMMeasurement) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *KPMMeasurement) MarshalTo(dAtA []byte) (int, error) { +func (m *TransmissionBandwidth) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *KPMMeasurement) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *TransmissionBandwidth) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l - if len(m.Name) > 0 { - i -= len(m.Name) - copy(dAtA[i:], m.Name) - i = encodeVarintRan(dAtA, i, uint64(len(m.Name))) + if m.Nrb != 0 { + i = encodeVarintRan(dAtA, i, uint64(m.Nrb)) i-- - dAtA[i] = 0x12 + dAtA[i] = 0x10 } - if len(m.ID) > 0 { - i -= len(m.ID) - copy(dAtA[i:], m.ID) - i = encodeVarintRan(dAtA, i, uint64(len(m.ID))) + if m.NrScs != 0 { + i = encodeVarintRan(dAtA, i, uint64(m.NrScs)) i-- - dAtA[i] = 0xa + dAtA[i] = 0x8 } return len(dAtA) - i, nil } -func (m *RSMNodeSlicingCapabilityItem) Marshal() (dAtA []byte, err error) { +func (m *FrequencyBandList) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -8830,20 +8621,20 @@ func (m *RSMNodeSlicingCapabilityItem) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *RSMNodeSlicingCapabilityItem) MarshalTo(dAtA []byte) (int, error) { +func (m *FrequencyBandList) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *RSMNodeSlicingCapabilityItem) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *FrequencyBandList) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l - if len(m.SupportedConfig) > 0 { - for iNdEx := len(m.SupportedConfig) - 1; iNdEx >= 0; iNdEx-- { + if len(m.FrequencyBandItems) > 0 { + for iNdEx := len(m.FrequencyBandItems) - 1; iNdEx >= 0; iNdEx-- { { - size, err := m.SupportedConfig[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + size, err := m.FrequencyBandItems[iNdEx].MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } @@ -8851,33 +8642,13 @@ func (m *RSMNodeSlicingCapabilityItem) MarshalToSizedBuffer(dAtA []byte) (int, e i = encodeVarintRan(dAtA, i, uint64(size)) } i-- - dAtA[i] = 0x2a + dAtA[i] = 0xa } } - if m.MaxNumberOfUesPerSlice != 0 { - i = encodeVarintRan(dAtA, i, uint64(m.MaxNumberOfUesPerSlice)) - i-- - dAtA[i] = 0x20 - } - if m.SlicingType != 0 { - i = encodeVarintRan(dAtA, i, uint64(m.SlicingType)) - i-- - dAtA[i] = 0x18 - } - if m.MaxNumberOfSlicesUl != 0 { - i = encodeVarintRan(dAtA, i, uint64(m.MaxNumberOfSlicesUl)) - i-- - dAtA[i] = 0x10 - } - if m.MaxNumberOfSlicesDl != 0 { - i = encodeVarintRan(dAtA, i, uint64(m.MaxNumberOfSlicesDl)) - i-- - dAtA[i] = 0x8 - } return len(dAtA) - i, nil } -func (m *RSMSupportedSlicingConfigItem) Marshal() (dAtA []byte, err error) { +func (m *FrequencyBandItem) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -8887,25 +8658,25 @@ func (m *RSMSupportedSlicingConfigItem) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *RSMSupportedSlicingConfigItem) MarshalTo(dAtA []byte) (int, error) { +func (m *FrequencyBandItem) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *RSMSupportedSlicingConfigItem) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *FrequencyBandItem) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l - if m.SlicingConfigType != 0 { - i = encodeVarintRan(dAtA, i, uint64(m.SlicingConfigType)) + if m.NrFrequencyBand != 0 { + i = encodeVarintRan(dAtA, i, uint64(m.NrFrequencyBand)) i-- dAtA[i] = 0x8 } return len(dAtA) - i, nil } -func (m *RSMSliceItemList) Marshal() (dAtA []byte, err error) { +func (m *GlobalNgRanNodeID) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -8915,75 +8686,59 @@ func (m *RSMSliceItemList) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *RSMSliceItemList) MarshalTo(dAtA []byte) (int, error) { +func (m *GlobalNgRanNodeID) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *RSMSliceItemList) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *GlobalNgRanNodeID) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l - if len(m.RsmSliceList) > 0 { - for iNdEx := len(m.RsmSliceList) - 1; iNdEx >= 0; iNdEx-- { - { - size, err := m.RsmSliceList[iNdEx].MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintRan(dAtA, i, uint64(size)) + if m.GlobalNgRanNodeId != nil { + { + size := m.GlobalNgRanNodeId.Size() + i -= size + if _, err := m.GlobalNgRanNodeId.MarshalTo(dAtA[i:]); err != nil { + return 0, err } - i-- - dAtA[i] = 0xa } } return len(dAtA) - i, nil } -func (m *RSMSlicingItem) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { - return nil, err - } - return dAtA[:n], nil -} - -func (m *RSMSlicingItem) MarshalTo(dAtA []byte) (int, error) { +func (m *GlobalNgRanNodeID_GlobalGnbId) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *RSMSlicingItem) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *GlobalNgRanNodeID_GlobalGnbId) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) - _ = i - var l int - _ = l - if len(m.UeIdList) > 0 { - for iNdEx := len(m.UeIdList) - 1; iNdEx >= 0; iNdEx-- { - { - size, err := m.UeIdList[iNdEx].MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintRan(dAtA, i, uint64(size)) + if m.GlobalGnbId != nil { + { + size, err := m.GlobalGnbId.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err } - i-- - dAtA[i] = 0x2a + i -= size + i = encodeVarintRan(dAtA, i, uint64(size)) } - } - if m.SliceType != 0 { - i = encodeVarintRan(dAtA, i, uint64(m.SliceType)) i-- - dAtA[i] = 0x20 + dAtA[i] = 0xa } - if m.SliceParameters != nil { + return len(dAtA) - i, nil +} +func (m *GlobalNgRanNodeID_GlobalNgEnbId) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *GlobalNgRanNodeID_GlobalNgEnbId) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + if m.GlobalNgEnbId != nil { { - size, err := m.SliceParameters.MarshalToSizedBuffer(dAtA[:i]) + size, err := m.GlobalNgEnbId.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } @@ -8991,26 +8746,11 @@ func (m *RSMSlicingItem) MarshalToSizedBuffer(dAtA []byte) (int, error) { i = encodeVarintRan(dAtA, i, uint64(size)) } i-- - dAtA[i] = 0x1a - } - if len(m.SliceDesc) > 0 { - i -= len(m.SliceDesc) - copy(dAtA[i:], m.SliceDesc) - i = encodeVarintRan(dAtA, i, uint64(len(m.SliceDesc))) - i-- dAtA[i] = 0x12 } - if len(m.ID) > 0 { - i -= len(m.ID) - copy(dAtA[i:], m.ID) - i = encodeVarintRan(dAtA, i, uint64(len(m.ID))) - i-- - dAtA[i] = 0xa - } return len(dAtA) - i, nil } - -func (m *RSMSliceParameters) Marshal() (dAtA []byte, err error) { +func (m *GlobalGnbID) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -9020,35 +8760,35 @@ func (m *RSMSliceParameters) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *RSMSliceParameters) MarshalTo(dAtA []byte) (int, error) { +func (m *GlobalGnbID) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *RSMSliceParameters) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *GlobalGnbID) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l - if m.QosLevel != 0 { - i = encodeVarintRan(dAtA, i, uint64(m.QosLevel)) + if m.GnbIdLen != 0 { + i = encodeVarintRan(dAtA, i, uint64(m.GnbIdLen)) i-- dAtA[i] = 0x18 } - if m.Weight != 0 { - i = encodeVarintRan(dAtA, i, uint64(m.Weight)) + if m.GnbId != 0 { + i = encodeVarintRan(dAtA, i, uint64(m.GnbId)) i-- dAtA[i] = 0x10 } - if m.SchedulerType != 0 { - i = encodeVarintRan(dAtA, i, uint64(m.SchedulerType)) + if m.PlmnId != 0 { + i = encodeVarintRan(dAtA, i, uint64(m.PlmnId)) i-- dAtA[i] = 0x8 } return len(dAtA) - i, nil } -func (m *DuUeF1ApID) Marshal() (dAtA []byte, err error) { +func (m *GlobalNgEnbID) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -9058,25 +8798,70 @@ func (m *DuUeF1ApID) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *DuUeF1ApID) MarshalTo(dAtA []byte) (int, error) { +func (m *GlobalNgEnbID) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *DuUeF1ApID) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *GlobalNgEnbID) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l - if m.Value != 0 { - i = encodeVarintRan(dAtA, i, uint64(m.Value)) + if m.NgEnbId != nil { + { + size := m.NgEnbId.Size() + i -= size + if _, err := m.NgEnbId.MarshalTo(dAtA[i:]); err != nil { + return 0, err + } + } + } + if m.PlmnId != 0 { + i = encodeVarintRan(dAtA, i, uint64(m.PlmnId)) i-- dAtA[i] = 0x8 } return len(dAtA) - i, nil } -func (m *CuUeF1ApID) Marshal() (dAtA []byte, err error) { +func (m *GlobalNgEnbID_MacroNgEnbId) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *GlobalNgEnbID_MacroNgEnbId) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + i = encodeVarintRan(dAtA, i, uint64(m.MacroNgEnbId)) + i-- + dAtA[i] = 0x10 + return len(dAtA) - i, nil +} +func (m *GlobalNgEnbID_ShortMacroNgEnbId) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *GlobalNgEnbID_ShortMacroNgEnbId) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + i = encodeVarintRan(dAtA, i, uint64(m.ShortMacroNgEnbId)) + i-- + dAtA[i] = 0x18 + return len(dAtA) - i, nil +} +func (m *GlobalNgEnbID_LongMacroNgEnbId) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *GlobalNgEnbID_LongMacroNgEnbId) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + i = encodeVarintRan(dAtA, i, uint64(m.LongMacroNgEnbId)) + i-- + dAtA[i] = 0x20 + return len(dAtA) - i, nil +} +func (m *TaiSupportList) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -9086,25 +8871,34 @@ func (m *CuUeF1ApID) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *CuUeF1ApID) MarshalTo(dAtA []byte) (int, error) { +func (m *TaiSupportList) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *CuUeF1ApID) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *TaiSupportList) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l - if m.Value != 0 { - i = encodeVarintRan(dAtA, i, uint64(m.Value)) - i-- - dAtA[i] = 0x8 + if len(m.TaiSupportItems) > 0 { + for iNdEx := len(m.TaiSupportItems) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.TaiSupportItems[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintRan(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } } return len(dAtA) - i, nil } -func (m *RanUeNgapID) Marshal() (dAtA []byte, err error) { +func (m *TaiSupportItem) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -9114,25 +8908,39 @@ func (m *RanUeNgapID) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *RanUeNgapID) MarshalTo(dAtA []byte) (int, error) { +func (m *TaiSupportItem) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *RanUeNgapID) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *TaiSupportItem) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l - if m.Value != 0 { - i = encodeVarintRan(dAtA, i, uint64(m.Value)) + if len(m.BroadcastPlmns) > 0 { + for iNdEx := len(m.BroadcastPlmns) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.BroadcastPlmns[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintRan(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + } + if m.Tac != 0 { + i = encodeVarintRan(dAtA, i, uint64(m.Tac)) i-- dAtA[i] = 0x8 } return len(dAtA) - i, nil } -func (m *EnbUeS1ApID) Marshal() (dAtA []byte, err error) { +func (m *XnBroadcastPlmn) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -9142,25 +8950,37 @@ func (m *EnbUeS1ApID) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *EnbUeS1ApID) MarshalTo(dAtA []byte) (int, error) { +func (m *XnBroadcastPlmn) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *EnbUeS1ApID) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *XnBroadcastPlmn) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l - if m.Value != 0 { - i = encodeVarintRan(dAtA, i, uint64(m.Value)) + if m.TaiSliceSupportList != nil { + { + size, err := m.TaiSliceSupportList.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintRan(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + if m.PlmnId != 0 { + i = encodeVarintRan(dAtA, i, uint64(m.PlmnId)) i-- dAtA[i] = 0x8 } return len(dAtA) - i, nil } -func (m *AmfUeNgapID) Marshal() (dAtA []byte, err error) { +func (m *TaiSliceSupportList) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -9170,25 +8990,34 @@ func (m *AmfUeNgapID) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *AmfUeNgapID) MarshalTo(dAtA []byte) (int, error) { +func (m *TaiSliceSupportList) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *AmfUeNgapID) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *TaiSliceSupportList) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l - if m.Value != 0 { - i = encodeVarintRan(dAtA, i, uint64(m.Value)) - i-- - dAtA[i] = 0x8 + if len(m.SliceSupportItems) > 0 { + for iNdEx := len(m.SliceSupportItems) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.SliceSupportItems[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintRan(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } } return len(dAtA) - i, nil } -func (m *UeIdentity) Marshal() (dAtA []byte, err error) { +func (m *SliceSupportItem) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -9198,19 +9027,19 @@ func (m *UeIdentity) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *UeIdentity) MarshalTo(dAtA []byte) (int, error) { +func (m *SliceSupportItem) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *UeIdentity) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *SliceSupportItem) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l - if m.DrbId != nil { + if m.SNssai != nil { { - size, err := m.DrbId.MarshalToSizedBuffer(dAtA[:i]) + size, err := m.SNssai.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } @@ -9218,151 +9047,45 @@ func (m *UeIdentity) MarshalToSizedBuffer(dAtA []byte) (int, error) { i = encodeVarintRan(dAtA, i, uint64(size)) } i-- - dAtA[i] = 0x3a + dAtA[i] = 0xa } - if m.PreferredIDType != 0 { - i = encodeVarintRan(dAtA, i, uint64(m.PreferredIDType)) + return len(dAtA) - i, nil +} + +func (m *SNssai) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *SNssai) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *SNssai) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Sd != 0 { + i = encodeVarintRan(dAtA, i, uint64(m.Sd)) i-- - dAtA[i] = 0x30 + dAtA[i] = 0x10 } - if m.AMFUeNgapID != nil { - { - size, err := m.AMFUeNgapID.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintRan(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x2a - } - if m.EnbUeS1apID != nil { - { - size, err := m.EnbUeS1apID.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintRan(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x22 - } - if m.RANUeNgapID != nil { - { - size, err := m.RANUeNgapID.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintRan(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x1a - } - if m.CuUeF1apID != nil { - { - size, err := m.CuUeF1apID.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintRan(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x12 - } - if m.DuUeF1apID != nil { - { - size, err := m.DuUeF1apID.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintRan(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0xa - } - return len(dAtA) - i, nil -} - -func (m *DrbId) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { - return nil, err - } - return dAtA[:n], nil -} - -func (m *DrbId) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *DrbId) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if m.DrbId != nil { - { - size := m.DrbId.Size() - i -= size - if _, err := m.DrbId.MarshalTo(dAtA[i:]); err != nil { - return 0, err - } - } - } - return len(dAtA) - i, nil -} - -func (m *DrbId_FourGdrbId) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *DrbId_FourGdrbId) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - if m.FourGdrbId != nil { - { - size, err := m.FourGdrbId.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintRan(dAtA, i, uint64(size)) - } + if m.Sst != 0 { + i = encodeVarintRan(dAtA, i, uint64(m.Sst)) i-- - dAtA[i] = 0xa + dAtA[i] = 0x8 } return len(dAtA) - i, nil } -func (m *DrbId_FiveGdrbId) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} -func (m *DrbId_FiveGdrbId) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - if m.FiveGdrbId != nil { - { - size, err := m.FiveGdrbId.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintRan(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x12 - } - return len(dAtA) - i, nil -} -func (m *FiveGDrbId) Marshal() (dAtA []byte, err error) { +func (m *AmfRegionInformation) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -9372,20 +9095,20 @@ func (m *FiveGDrbId) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *FiveGDrbId) MarshalTo(dAtA []byte) (int, error) { +func (m *AmfRegionInformation) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *FiveGDrbId) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *AmfRegionInformation) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l - if len(m.FlowsMapToDrb) > 0 { - for iNdEx := len(m.FlowsMapToDrb) - 1; iNdEx >= 0; iNdEx-- { + if len(m.GlobalAmfRegionInformationItems) > 0 { + for iNdEx := len(m.GlobalAmfRegionInformationItems) - 1; iNdEx >= 0; iNdEx-- { { - size, err := m.FlowsMapToDrb[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + size, err := m.GlobalAmfRegionInformationItems[iNdEx].MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } @@ -9393,30 +9116,13 @@ func (m *FiveGDrbId) MarshalToSizedBuffer(dAtA []byte) (int, error) { i = encodeVarintRan(dAtA, i, uint64(size)) } i-- - dAtA[i] = 0x1a - } - } - if m.Qfi != nil { - { - size, err := m.Qfi.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintRan(dAtA, i, uint64(size)) + dAtA[i] = 0xa } - i-- - dAtA[i] = 0x12 - } - if m.Value != 0 { - i = encodeVarintRan(dAtA, i, uint64(m.Value)) - i-- - dAtA[i] = 0x8 } return len(dAtA) - i, nil } -func (m *Qfi) Marshal() (dAtA []byte, err error) { +func (m *GlobalAmfRegionInformationItem) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -9426,25 +9132,30 @@ func (m *Qfi) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *Qfi) MarshalTo(dAtA []byte) (int, error) { +func (m *GlobalAmfRegionInformationItem) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *Qfi) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *GlobalAmfRegionInformationItem) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l - if m.Value != 0 { - i = encodeVarintRan(dAtA, i, uint64(m.Value)) + if m.AmfRegionId != 0 { + i = encodeVarintRan(dAtA, i, uint64(m.AmfRegionId)) + i-- + dAtA[i] = 0x10 + } + if m.PlmnId != 0 { + i = encodeVarintRan(dAtA, i, uint64(m.PlmnId)) i-- dAtA[i] = 0x8 } return len(dAtA) - i, nil } -func (m *QoSflowLevelParameters) Marshal() (dAtA []byte, err error) { +func (m *NeighborInformationNr) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -9454,38 +9165,77 @@ func (m *QoSflowLevelParameters) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *QoSflowLevelParameters) MarshalTo(dAtA []byte) (int, error) { +func (m *NeighborInformationNr) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *QoSflowLevelParameters) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *NeighborInformationNr) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l - if m.QosFlowLevelParameters != nil { + if m.MeasurementTimingConfiguration != 0 { + i = encodeVarintRan(dAtA, i, uint64(m.MeasurementTimingConfiguration)) + i-- + dAtA[i] = 0x38 + } + if m.ConnectivitySupport != nil { { - size := m.QosFlowLevelParameters.Size() + size, err := m.ConnectivitySupport.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } i -= size - if _, err := m.QosFlowLevelParameters.MarshalTo(dAtA[i:]); err != nil { + i = encodeVarintRan(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x32 + } + if m.NrModeInfo != nil { + { + size := m.NrModeInfo.Size() + i -= size + if _, err := m.NrModeInfo.MarshalTo(dAtA[i:]); err != nil { return 0, err } } } + if m.Tac != 0 { + i = encodeVarintRan(dAtA, i, uint64(m.Tac)) + i-- + dAtA[i] = 0x18 + } + if m.NrCgi != nil { + { + size, err := m.NrCgi.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintRan(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + if m.Pci != 0 { + i = encodeVarintRan(dAtA, i, uint64(m.Pci)) + i-- + dAtA[i] = 0x8 + } return len(dAtA) - i, nil } -func (m *QoSflowLevelParameters_DynamicFiveQi) MarshalTo(dAtA []byte) (int, error) { +func (m *NeighborInformationNr_FddInfo) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *QoSflowLevelParameters_DynamicFiveQi) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *NeighborInformationNr_FddInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) - if m.DynamicFiveQi != nil { + if m.FddInfo != nil { { - size, err := m.DynamicFiveQi.MarshalToSizedBuffer(dAtA[:i]) + size, err := m.FddInfo.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } @@ -9493,20 +9243,20 @@ func (m *QoSflowLevelParameters_DynamicFiveQi) MarshalToSizedBuffer(dAtA []byte) i = encodeVarintRan(dAtA, i, uint64(size)) } i-- - dAtA[i] = 0xa + dAtA[i] = 0x22 } return len(dAtA) - i, nil } -func (m *QoSflowLevelParameters_NonDynamicFiveQi) MarshalTo(dAtA []byte) (int, error) { +func (m *NeighborInformationNr_TddInfo) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *QoSflowLevelParameters_NonDynamicFiveQi) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *NeighborInformationNr_TddInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) - if m.NonDynamicFiveQi != nil { + if m.TddInfo != nil { { - size, err := m.NonDynamicFiveQi.MarshalToSizedBuffer(dAtA[:i]) + size, err := m.TddInfo.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } @@ -9514,11 +9264,11 @@ func (m *QoSflowLevelParameters_NonDynamicFiveQi) MarshalToSizedBuffer(dAtA []by i = encodeVarintRan(dAtA, i, uint64(size)) } i-- - dAtA[i] = 0x12 + dAtA[i] = 0x2a } return len(dAtA) - i, nil } -func (m *DynamicFiveQi) Marshal() (dAtA []byte, err error) { +func (m *ServiceModelInfo) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -9528,35 +9278,66 @@ func (m *DynamicFiveQi) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *DynamicFiveQi) MarshalTo(dAtA []byte) (int, error) { +func (m *ServiceModelInfo) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *DynamicFiveQi) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *ServiceModelInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l - if m.PacketErrorRate != 0 { - i = encodeVarintRan(dAtA, i, uint64(m.PacketErrorRate)) + if len(m.RanFunctionIDs) > 0 { + dAtA39 := make([]byte, len(m.RanFunctionIDs)*10) + var j38 int + for _, num := range m.RanFunctionIDs { + for num >= 1<<7 { + dAtA39[j38] = uint8(uint64(num)&0x7f | 0x80) + num >>= 7 + j38++ + } + dAtA39[j38] = uint8(num) + j38++ + } + i -= j38 + copy(dAtA[i:], dAtA39[:j38]) + i = encodeVarintRan(dAtA, i, uint64(j38)) i-- - dAtA[i] = 0x18 + dAtA[i] = 0x22 } - if m.PacketDelayBudge != 0 { - i = encodeVarintRan(dAtA, i, uint64(m.PacketDelayBudge)) + if len(m.RanFunctions) > 0 { + for iNdEx := len(m.RanFunctions) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.RanFunctions[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintRan(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + } + } + if len(m.Name) > 0 { + i -= len(m.Name) + copy(dAtA[i:], m.Name) + i = encodeVarintRan(dAtA, i, uint64(len(m.Name))) i-- - dAtA[i] = 0x10 + dAtA[i] = 0x12 } - if m.PriorityLevel != 0 { - i = encodeVarintRan(dAtA, i, uint64(m.PriorityLevel)) + if len(m.OID) > 0 { + i -= len(m.OID) + copy(dAtA[i:], m.OID) + i = encodeVarintRan(dAtA, i, uint64(len(m.OID))) i-- - dAtA[i] = 0x8 + dAtA[i] = 0xa } return len(dAtA) - i, nil } -func (m *NonDynamicFiveQi) Marshal() (dAtA []byte, err error) { +func (m *RCRanFunction) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -9566,32 +9347,97 @@ func (m *NonDynamicFiveQi) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *NonDynamicFiveQi) MarshalTo(dAtA []byte) (int, error) { +func (m *RCRanFunction) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *NonDynamicFiveQi) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *RCRanFunction) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l - if m.FiveQi != nil { - { - size, err := m.FiveQi.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err + if len(m.ControlStyles) > 0 { + for iNdEx := len(m.ControlStyles) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.ControlStyles[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintRan(dAtA, i, uint64(size)) } - i -= size - i = encodeVarintRan(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x32 + } + } + if len(m.PolicyStyles) > 0 { + for iNdEx := len(m.PolicyStyles) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.PolicyStyles[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintRan(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x2a + } + } + if len(m.EventTriggerStyles) > 0 { + for iNdEx := len(m.EventTriggerStyles) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.EventTriggerStyles[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintRan(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x22 + } + } + if len(m.InsertStyles) > 0 { + for iNdEx := len(m.InsertStyles) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.InsertStyles[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintRan(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + } + } + if len(m.ReportStyles) > 0 { + for iNdEx := len(m.ReportStyles) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.ReportStyles[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintRan(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 } + } + if len(m.ID) > 0 { + i -= len(m.ID) + copy(dAtA[i:], m.ID) + i = encodeVarintRan(dAtA, i, uint64(len(m.ID))) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } -func (m *FiveQi) Marshal() (dAtA []byte, err error) { +func (m *MHORanFunction) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -9601,25 +9447,41 @@ func (m *FiveQi) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *FiveQi) MarshalTo(dAtA []byte) (int, error) { +func (m *MHORanFunction) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *FiveQi) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *MHORanFunction) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l - if m.Value != 0 { - i = encodeVarintRan(dAtA, i, uint64(m.Value)) + if len(m.ReportStyles) > 0 { + for iNdEx := len(m.ReportStyles) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.ReportStyles[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintRan(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + } + if len(m.ID) > 0 { + i -= len(m.ID) + copy(dAtA[i:], m.ID) + i = encodeVarintRan(dAtA, i, uint64(len(m.ID))) i-- - dAtA[i] = 0x8 + dAtA[i] = 0xa } return len(dAtA) - i, nil } -func (m *FourGDrbId) Marshal() (dAtA []byte, err error) { +func (m *CCCRanFunction) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -9629,37 +9491,55 @@ func (m *FourGDrbId) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *FourGDrbId) MarshalTo(dAtA []byte) (int, error) { +func (m *CCCRanFunction) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *FourGDrbId) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *CCCRanFunction) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l - if m.Qci != nil { - { - size, err := m.Qci.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err + if len(m.CellsRanDefinition) > 0 { + for iNdEx := len(m.CellsRanDefinition) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.CellsRanDefinition[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintRan(dAtA, i, uint64(size)) } - i -= size - i = encodeVarintRan(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x1a } - i-- - dAtA[i] = 0x12 } - if m.Value != 0 { - i = encodeVarintRan(dAtA, i, uint64(m.Value)) + if len(m.RanStructures) > 0 { + for iNdEx := len(m.RanStructures) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.RanStructures[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintRan(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + } + if len(m.ID) > 0 { + i -= len(m.ID) + copy(dAtA[i:], m.ID) + i = encodeVarintRan(dAtA, i, uint64(len(m.ID))) i-- - dAtA[i] = 0x8 + dAtA[i] = 0xa } return len(dAtA) - i, nil } -func (m *Qci) Marshal() (dAtA []byte, err error) { +func (m *KPMRanFunction) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -9669,1764 +9549,6463 @@ func (m *Qci) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *Qci) MarshalTo(dAtA []byte) (int, error) { +func (m *KPMRanFunction) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *Qci) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *KPMRanFunction) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l - if m.Value != 0 { - i = encodeVarintRan(dAtA, i, uint64(m.Value)) + if len(m.ReportStyles) > 0 { + for iNdEx := len(m.ReportStyles) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.ReportStyles[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintRan(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + } + if len(m.ID) > 0 { + i -= len(m.ID) + copy(dAtA[i:], m.ID) + i = encodeVarintRan(dAtA, i, uint64(len(m.ID))) i-- - dAtA[i] = 0x8 + dAtA[i] = 0xa } return len(dAtA) - i, nil } -func encodeVarintRan(dAtA []byte, offset int, v uint64) int { - offset -= sovRan(v) - base := offset - for v >= 1<<7 { - dAtA[offset] = uint8(v&0x7f | 0x80) - v >>= 7 - offset++ +func (m *RSMRanFunction) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err } - dAtA[offset] = uint8(v) - return base + return dAtA[:n], nil } -func (m *Location) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.Lat != 0 { - n += 9 - } - if m.Lng != 0 { - n += 9 - } - if m.Ext != nil { - n += m.Ext.Size() - } - return n + +func (m *RSMRanFunction) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *Location_Wgs84) Size() (n int) { - if m == nil { - return 0 - } +func (m *RSMRanFunction) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i var l int _ = l - if m.Wgs84 != nil { - l = m.Wgs84.Size() - n += 1 + l + sovRan(uint64(l)) - } - return n -} -func (m *Location_Cartesian) Size() (n int) { - if m == nil { - return 0 + if len(m.RicSlicingNodeCapabilityList) > 0 { + for iNdEx := len(m.RicSlicingNodeCapabilityList) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.RicSlicingNodeCapabilityList[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintRan(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } } - var l int - _ = l - if m.Cartesian != nil { - l = m.Cartesian.Size() - n += 1 + l + sovRan(uint64(l)) + if len(m.ID) > 0 { + i -= len(m.ID) + copy(dAtA[i:], m.ID) + i = encodeVarintRan(dAtA, i, uint64(len(m.ID))) + i-- + dAtA[i] = 0xa } - return n + return len(dAtA) - i, nil } -func (m *Wgs84Location) Size() (n int) { - if m == nil { - return 0 + +func (m *RCEventTriggerStyle) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err } + return dAtA[:n], nil +} + +func (m *RCEventTriggerStyle) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *RCEventTriggerStyle) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i var l int _ = l - if m.LatitudeDeg != 0 { - n += 9 + if m.FormatType != 0 { + i = encodeVarintRan(dAtA, i, uint64(m.FormatType)) + i-- + dAtA[i] = 0x18 } - if m.LongitudeDeg != 0 { - n += 9 + if m.Type != 0 { + i = encodeVarintRan(dAtA, i, uint64(m.Type)) + i-- + dAtA[i] = 0x10 } - if m.AltitudeM != 0 { - n += 9 + if len(m.Name) > 0 { + i -= len(m.Name) + copy(dAtA[i:], m.Name) + i = encodeVarintRan(dAtA, i, uint64(len(m.Name))) + i-- + dAtA[i] = 0xa } - return n + return len(dAtA) - i, nil } -func (m *CartesianLocation) Size() (n int) { - if m == nil { - return 0 +func (m *RCReportStyle) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err } + return dAtA[:n], nil +} + +func (m *RCReportStyle) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *RCReportStyle) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i var l int _ = l - if m.XM != 0 { - n += 9 + if len(m.RanParameters) > 0 { + for iNdEx := len(m.RanParameters) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.RanParameters[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintRan(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + } } - if m.YM != 0 { - n += 9 + if m.Type != 0 { + i = encodeVarintRan(dAtA, i, uint64(m.Type)) + i-- + dAtA[i] = 0x10 } - if m.ZM != 0 { - n += 9 + if len(m.Name) > 0 { + i -= len(m.Name) + copy(dAtA[i:], m.Name) + i = encodeVarintRan(dAtA, i, uint64(len(m.Name))) + i-- + dAtA[i] = 0xa } - return n + return len(dAtA) - i, nil } -func (m *AzElOrientation) Size() (n int) { - if m == nil { - return 0 +func (m *RCInsertStyle) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err } + return dAtA[:n], nil +} + +func (m *RCInsertStyle) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *RCInsertStyle) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i var l int _ = l - if m.AzimuthDeg != 0 { - n += 9 + if len(m.InsertIndications) > 0 { + for iNdEx := len(m.InsertIndications) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.InsertIndications[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintRan(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + } } - if m.ElevationDeg != 0 { - n += 9 + if m.Type != 0 { + i = encodeVarintRan(dAtA, i, uint64(m.Type)) + i-- + dAtA[i] = 0x10 } - if m.RotationDeg != 0 { - n += 9 + if len(m.Name) > 0 { + i -= len(m.Name) + copy(dAtA[i:], m.Name) + i = encodeVarintRan(dAtA, i, uint64(len(m.Name))) + i-- + dAtA[i] = 0xa } - return n + return len(dAtA) - i, nil } -func (m *YprOrientation) Size() (n int) { - if m == nil { - return 0 +func (m *RCPolicyStyle) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err } + return dAtA[:n], nil +} + +func (m *RCPolicyStyle) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *RCPolicyStyle) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i var l int _ = l - if m.YawDeg != 0 { - n += 9 + if len(m.PolicyActions) > 0 { + for iNdEx := len(m.PolicyActions) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.PolicyActions[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintRan(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + } } - if m.PitchDeg != 0 { - n += 9 + if m.Type != 0 { + i = encodeVarintRan(dAtA, i, uint64(m.Type)) + i-- + dAtA[i] = 0x10 } - if m.RollDeg != 0 { - n += 9 + if len(m.Name) > 0 { + i -= len(m.Name) + copy(dAtA[i:], m.Name) + i = encodeVarintRan(dAtA, i, uint64(len(m.Name))) + i-- + dAtA[i] = 0xa } - return n + return len(dAtA) - i, nil } -func (m *Orientation) Size() (n int) { - if m == nil { - return 0 +func (m *PolicyAction) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err } - var l int - _ = l - if m.Orientation != nil { - n += m.Orientation.Size() - } - return n + return dAtA[:n], nil } -func (m *Orientation_Azel) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.Azel != nil { - l = m.Azel.Size() - n += 1 + l + sovRan(uint64(l)) - } - return n +func (m *PolicyAction) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *Orientation_Ypr) Size() (n int) { - if m == nil { - return 0 - } + +func (m *PolicyAction) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i var l int _ = l - if m.Ypr != nil { - l = m.Ypr.Size() - n += 1 + l + sovRan(uint64(l)) + if len(m.PolicyConditionRanParameters) > 0 { + for iNdEx := len(m.PolicyConditionRanParameters) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.PolicyConditionRanParameters[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintRan(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x22 + } } - return n -} -func (m *Waypoint) Size() (n int) { - if m == nil { - return 0 + if len(m.PolicyActionRanParameters) > 0 { + for iNdEx := len(m.PolicyActionRanParameters) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.PolicyActionRanParameters[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintRan(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + } } - var l int - _ = l - if m.Time != nil { - l = m.Time.Size() - n += 1 + l + sovRan(uint64(l)) + if len(m.Name) > 0 { + i -= len(m.Name) + copy(dAtA[i:], m.Name) + i = encodeVarintRan(dAtA, i, uint64(len(m.Name))) + i-- + dAtA[i] = 0x12 } - if m.Location != nil { - l = m.Location.Size() - n += 1 + l + sovRan(uint64(l)) + if m.ID != 0 { + i = encodeVarintRan(dAtA, i, uint64(m.ID)) + i-- + dAtA[i] = 0x8 } - return n + return len(dAtA) - i, nil } -func (m *Waypoints) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if len(m.Waypoint) > 0 { - for _, e := range m.Waypoint { - l = e.Size() - n += 1 + l + sovRan(uint64(l)) - } +func (m *RCControlStyle) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err } - return n + return dAtA[:n], nil } -func (m *OrbitData) Size() (n int) { - if m == nil { - return 0 - } +func (m *RCControlStyle) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *RCControlStyle) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i var l int _ = l - if m.Epoch != nil { - l = m.Epoch.Size() - n += 1 + l + sovRan(uint64(l)) - } - if m.InclinationDeg != 0 { - n += 9 + if len(m.ControlActions) > 0 { + for iNdEx := len(m.ControlActions) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.ControlActions[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintRan(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x32 + } } - if m.RaanDeg != 0 { - n += 9 + if m.ControlOutcomeFormatType != 0 { + i = encodeVarintRan(dAtA, i, uint64(m.ControlOutcomeFormatType)) + i-- + dAtA[i] = 0x28 } - if m.E != 0 { - n += 9 + if m.MessageFormatType != 0 { + i = encodeVarintRan(dAtA, i, uint64(m.MessageFormatType)) + i-- + dAtA[i] = 0x20 } - if m.ArgumentDeg != 0 { - n += 9 + if m.HeaderFormatType != 0 { + i = encodeVarintRan(dAtA, i, uint64(m.HeaderFormatType)) + i-- + dAtA[i] = 0x18 } - if m.AnomalyDeg != 0 { - n += 9 + if m.Type != 0 { + i = encodeVarintRan(dAtA, i, uint64(m.Type)) + i-- + dAtA[i] = 0x10 } - if m.MeanMotion != 0 { - n += 9 + if len(m.Name) > 0 { + i -= len(m.Name) + copy(dAtA[i:], m.Name) + i = encodeVarintRan(dAtA, i, uint64(len(m.Name))) + i-- + dAtA[i] = 0xa } - return n + return len(dAtA) - i, nil } -func (m *Motion) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.Motion != nil { - n += m.Motion.Size() +func (m *ControlAction) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err } - return n + return dAtA[:n], nil } -func (m *Motion_FixedLocation) Size() (n int) { - if m == nil { - return 0 - } +func (m *ControlAction) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ControlAction) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i var l int _ = l - if m.FixedLocation != nil { - l = m.FixedLocation.Size() - n += 1 + l + sovRan(uint64(l)) + if len(m.RanParameters) > 0 { + for iNdEx := len(m.RanParameters) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.RanParameters[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintRan(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + } } - return n -} -func (m *Motion_Waypoints) Size() (n int) { - if m == nil { - return 0 + if len(m.Name) > 0 { + i -= len(m.Name) + copy(dAtA[i:], m.Name) + i = encodeVarintRan(dAtA, i, uint64(len(m.Name))) + i-- + dAtA[i] = 0x12 } - var l int - _ = l - if m.Waypoints != nil { - l = m.Waypoints.Size() - n += 1 + l + sovRan(uint64(l)) + if m.ID != 0 { + i = encodeVarintRan(dAtA, i, uint64(m.ID)) + i-- + dAtA[i] = 0x8 } - return n + return len(dAtA) - i, nil } -func (m *Motion_Orbit) Size() (n int) { - if m == nil { - return 0 + +func (m *InsertIndication) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err } + return dAtA[:n], nil +} + +func (m *InsertIndication) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *InsertIndication) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i var l int _ = l - if m.Orbit != nil { - l = m.Orbit.Size() - n += 1 + l + sovRan(uint64(l)) - } - return n -} -func (m *Coverage) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.Height != 0 { - n += 1 + sovRan(uint64(m.Height)) - } - if m.ArcWidth != 0 { - n += 1 + sovRan(uint64(m.ArcWidth)) + if len(m.RanParameters) > 0 { + for iNdEx := len(m.RanParameters) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.RanParameters[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintRan(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + } } - if m.Azimuth != 0 { - n += 1 + sovRan(uint64(m.Azimuth)) + if len(m.Name) > 0 { + i -= len(m.Name) + copy(dAtA[i:], m.Name) + i = encodeVarintRan(dAtA, i, uint64(len(m.Name))) + i-- + dAtA[i] = 0x12 } - if m.Tilt != 0 { - n += 1 + sovRan(uint64(m.Tilt)) + if m.ID != 0 { + i = encodeVarintRan(dAtA, i, uint64(m.ID)) + i-- + dAtA[i] = 0x8 } - return n + return len(dAtA) - i, nil } -func (m *E2Node) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if len(m.ServiceModels) > 0 { - for k, v := range m.ServiceModels { - _ = k - _ = v - l = 0 - if v != nil { - l = v.Size() - l += 1 + sovRan(uint64(l)) - } - mapEntrySize := 1 + len(k) + sovRan(uint64(len(k))) + l - n += mapEntrySize + 1 + sovRan(uint64(mapEntrySize)) - } +func (m *RANParameter) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err } - return n + return dAtA[:n], nil } -func (m *E2NodeConfig) Size() (n int) { - if m == nil { - return 0 - } +func (m *RANParameter) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *RANParameter) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i var l int _ = l - if len(m.Connections) > 0 { - for _, e := range m.Connections { - l = e.Size() - n += 1 + l + sovRan(uint64(l)) - } + if len(m.Name) > 0 { + i -= len(m.Name) + copy(dAtA[i:], m.Name) + i = encodeVarintRan(dAtA, i, uint64(len(m.Name))) + i-- + dAtA[i] = 0x12 } - if m.Version != 0 { - n += 1 + sovRan(uint64(m.Version)) + if m.ID != 0 { + i = encodeVarintRan(dAtA, i, uint64(m.ID)) + i-- + dAtA[i] = 0x8 } - return n + return len(dAtA) - i, nil } -func (m *Lease) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.Expiration != nil { - l = github_com_gogo_protobuf_types.SizeOfStdTime(*m.Expiration) - n += 1 + l + sovRan(uint64(l)) +func (m *RanconfigurationStructure) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err } - return n + return dAtA[:n], nil } -func (m *Interface) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.Type != 0 { - n += 1 + sovRan(uint64(m.Type)) - } - l = len(m.IP) - if l > 0 { - n += 1 + l + sovRan(uint64(l)) - } - if m.Port != 0 { - n += 1 + sovRan(uint64(m.Port)) - } - return n +func (m *RanconfigurationStructure) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *E2TInfo) Size() (n int) { - if m == nil { - return 0 - } +func (m *RanconfigurationStructure) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i var l int _ = l - if len(m.Interfaces) > 0 { - for _, e := range m.Interfaces { - l = e.Size() - n += 1 + l + sovRan(uint64(l)) + if len(m.Attribute) > 0 { + for iNdEx := len(m.Attribute) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.Attribute[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintRan(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 } } - return n + if len(m.Name) > 0 { + i -= len(m.Name) + copy(dAtA[i:], m.Name) + i = encodeVarintRan(dAtA, i, uint64(len(m.Name))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil } -func (m *XAppInfo) Size() (n int) { - if m == nil { - return 0 +func (m *Attribute) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err } + return dAtA[:n], nil +} + +func (m *Attribute) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *Attribute) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i var l int _ = l - if len(m.Interfaces) > 0 { - for _, e := range m.Interfaces { - l = e.Size() - n += 1 + l + sovRan(uint64(l)) + if m.RicServices != nil { + { + size, err := m.RicServices.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintRan(dAtA, i, uint64(size)) } + i-- + dAtA[i] = 0x12 } - if len(m.A1PolicyTypes) > 0 { - for _, e := range m.A1PolicyTypes { - l = e.Size() - n += 1 + l + sovRan(uint64(l)) - } + if len(m.Name) > 0 { + i -= len(m.Name) + copy(dAtA[i:], m.Name) + i = encodeVarintRan(dAtA, i, uint64(len(m.Name))) + i-- + dAtA[i] = 0xa } - return n + return len(dAtA) - i, nil } -func (m *A1PolicyType) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - l = len(m.ID) - if l > 0 { - n += 1 + l + sovRan(uint64(l)) - } - l = len(m.Name) - if l > 0 { - n += 1 + l + sovRan(uint64(l)) - } - l = len(m.Version) - if l > 0 { - n += 1 + l + sovRan(uint64(l)) - } - l = len(m.Description) - if l > 0 { - n += 1 + l + sovRan(uint64(l)) +func (m *RICServices) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err } - return n + return dAtA[:n], nil } -func (m *A1TInfo) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if len(m.Interfaces) > 0 { - for _, e := range m.Interfaces { - l = e.Size() - n += 1 + l + sovRan(uint64(l)) - } - } - return n +func (m *RICServices) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *CellGlobalID) Size() (n int) { - if m == nil { - return 0 - } +func (m *RICServices) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i var l int _ = l - l = len(m.Value) - if l > 0 { - n += 1 + l + sovRan(uint64(l)) + if len(m.PolicyStyles) > 0 { + for iNdEx := len(m.PolicyStyles) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.PolicyStyles[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintRan(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x2a + } } - if m.Type != 0 { - n += 1 + sovRan(uint64(m.Type)) + if len(m.ControlStyles) > 0 { + for iNdEx := len(m.ControlStyles) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.ControlStyles[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintRan(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x22 + } } - return n + if len(m.InsertStyles) > 0 { + for iNdEx := len(m.InsertStyles) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.InsertStyles[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintRan(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + } + } + if len(m.ReportStyles) > 0 { + for iNdEx := len(m.ReportStyles) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.ReportStyles[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintRan(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + } + if len(m.EventTriggerStyles) > 0 { + for iNdEx := len(m.EventTriggerStyles) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.EventTriggerStyles[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintRan(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + } + return len(dAtA) - i, nil } -func (m *NeighborCellID) Size() (n int) { - if m == nil { - return 0 +func (m *CellsForRanfunctionDefinition) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err } + return dAtA[:n], nil +} + +func (m *CellsForRanfunctionDefinition) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *CellsForRanfunctionDefinition) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i var l int _ = l - if m.CellGlobalID != nil { - l = m.CellGlobalID.Size() - n += 1 + l + sovRan(uint64(l)) + if len(m.CellFunctionDefinition) > 0 { + for iNdEx := len(m.CellFunctionDefinition) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.CellFunctionDefinition[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintRan(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } } - l = len(m.PlmnID) - if l > 0 { - n += 1 + l + sovRan(uint64(l)) + if m.CellGlobalId != nil { + { + size, err := m.CellGlobalId.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintRan(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa } - return n + return len(dAtA) - i, nil } -func (m *E2Cell) Size() (n int) { - if m == nil { - return 0 +func (m *CellForRanfunctionDefinition) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err } + return dAtA[:n], nil +} + +func (m *CellForRanfunctionDefinition) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *CellForRanfunctionDefinition) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i var l int _ = l - l = len(m.CellObjectID) - if l > 0 { - n += 1 + l + sovRan(uint64(l)) - } - if m.CellGlobalID != nil { - l = m.CellGlobalID.Size() - n += 1 + l + sovRan(uint64(l)) + if len(m.Attribute) > 0 { + for iNdEx := len(m.Attribute) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.Attribute[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintRan(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } } - if m.AntennaCount != 0 { - n += 1 + sovRan(uint64(m.AntennaCount)) + if len(m.Name) > 0 { + i -= len(m.Name) + copy(dAtA[i:], m.Name) + i = encodeVarintRan(dAtA, i, uint64(len(m.Name))) + i-- + dAtA[i] = 0xa } - if m.ARFCN != 0 { - n += 1 + sovRan(uint64(m.ARFCN)) + return len(dAtA) - i, nil +} + +func (m *CCCEventTriggerStyle) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err } - l = len(m.CellType) - if l > 0 { - n += 1 + l + sovRan(uint64(l)) + return dAtA[:n], nil +} + +func (m *CCCEventTriggerStyle) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *CCCEventTriggerStyle) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.FormatType != 0 { + i = encodeVarintRan(dAtA, i, uint64(m.FormatType)) + i-- + dAtA[i] = 0x18 } - if m.PCI != 0 { - n += 1 + sovRan(uint64(m.PCI)) + if m.Type != 0 { + i = encodeVarintRan(dAtA, i, uint64(m.Type)) + i-- + dAtA[i] = 0x10 } - if len(m.KpiReports) > 0 { - for k, v := range m.KpiReports { - _ = k - _ = v - mapEntrySize := 1 + len(k) + sovRan(uint64(len(k))) + 1 + sovRan(uint64(v)) - n += mapEntrySize + 1 + sovRan(uint64(mapEntrySize)) - } + if len(m.Name) > 0 { + i -= len(m.Name) + copy(dAtA[i:], m.Name) + i = encodeVarintRan(dAtA, i, uint64(len(m.Name))) + i-- + dAtA[i] = 0xa } - if len(m.NeighborCellIDs) > 0 { - for _, e := range m.NeighborCellIDs { - l = e.Size() - n += 1 + l + sovRan(uint64(l)) - } + return len(dAtA) - i, nil +} + +func (m *CCCReportStyle) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err } - if m.GnbDuId != 0 { - n += 1 + sovRan(uint64(m.GnbDuId)) + return dAtA[:n], nil +} + +func (m *CCCReportStyle) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *CCCReportStyle) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.IndicationMessageFormatType != 0 { + i = encodeVarintRan(dAtA, i, uint64(m.IndicationMessageFormatType)) + i-- + dAtA[i] = 0x30 } - if m.LatestRrcVersion != 0 { - n += 1 + sovRan(uint64(m.LatestRrcVersion)) + if m.IndicationHeaderFormatType != 0 { + i = encodeVarintRan(dAtA, i, uint64(m.IndicationHeaderFormatType)) + i-- + dAtA[i] = 0x28 } - if m.PlmnId != 0 { - n += 1 + sovRan(uint64(m.PlmnId)) + if m.ActionDefinitionFormatType != 0 { + i = encodeVarintRan(dAtA, i, uint64(m.ActionDefinitionFormatType)) + i-- + dAtA[i] = 0x20 } - if len(m.ServedPlmns) > 0 { - l = 0 - for _, e := range m.ServedPlmns { - l += sovRan(uint64(e)) + if len(m.EventTriggerStyleForReport) > 0 { + dAtA43 := make([]byte, len(m.EventTriggerStyleForReport)*10) + var j42 int + for _, num1 := range m.EventTriggerStyleForReport { + num := uint64(num1) + for num >= 1<<7 { + dAtA43[j42] = uint8(uint64(num)&0x7f | 0x80) + num >>= 7 + j42++ + } + dAtA43[j42] = uint8(num) + j42++ } - n += 1 + sovRan(uint64(l)) + l - } - if m.NrModeInfo != nil { - n += m.NrModeInfo.Size() + i -= j42 + copy(dAtA[i:], dAtA43[:j42]) + i = encodeVarintRan(dAtA, i, uint64(j42)) + i-- + dAtA[i] = 0x1a } - if m.MeasurementTimingConfiguration != 0 { - n += 1 + sovRan(uint64(m.MeasurementTimingConfiguration)) - } - if m.GlobalNgRanNodeId != nil { - l = m.GlobalNgRanNodeId.Size() - n += 2 + l + sovRan(uint64(l)) - } - if m.TaiSupportList != nil { - l = m.TaiSupportList.Size() - n += 2 + l + sovRan(uint64(l)) - } - if m.AmfRegionInformation != nil { - l = m.AmfRegionInformation.Size() - n += 2 + l + sovRan(uint64(l)) - } - if m.ConnectivitySupport != nil { - l = m.ConnectivitySupport.Size() - n += 2 + l + sovRan(uint64(l)) + if m.Type != 0 { + i = encodeVarintRan(dAtA, i, uint64(m.Type)) + i-- + dAtA[i] = 0x10 } - if len(m.NeighborInformationNrs) > 0 { - for _, e := range m.NeighborInformationNrs { - l = e.Size() - n += 2 + l + sovRan(uint64(l)) - } + if len(m.Name) > 0 { + i -= len(m.Name) + copy(dAtA[i:], m.Name) + i = encodeVarintRan(dAtA, i, uint64(len(m.Name))) + i-- + dAtA[i] = 0xa } - return n + return len(dAtA) - i, nil } -func (m *E2Cell_FddInfo) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.FddInfo != nil { - l = m.FddInfo.Size() - n += 1 + l + sovRan(uint64(l)) +func (m *CCCInsertStyle) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err } - return n + return dAtA[:n], nil } -func (m *E2Cell_TddInfo) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.TddInfo != nil { - l = m.TddInfo.Size() - n += 1 + l + sovRan(uint64(l)) - } - return n + +func (m *CCCInsertStyle) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *ConnectivitySupport) Size() (n int) { - if m == nil { - return 0 - } + +func (m *CCCInsertStyle) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i var l int _ = l - if m.EnDcSupport != 0 { - n += 1 + sovRan(uint64(m.EnDcSupport)) + if m.Value != nil { + { + size, err := m.Value.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintRan(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa } - return n + return len(dAtA) - i, nil } -func (m *FDDInfo) Size() (n int) { - if m == nil { - return 0 +func (m *CCCControlStyle) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err } + return dAtA[:n], nil +} + +func (m *CCCControlStyle) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *CCCControlStyle) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i var l int _ = l - if m.UlFreqInfo != nil { - l = m.UlFreqInfo.Size() - n += 1 + l + sovRan(uint64(l)) - } - if m.DlFreqInfo != nil { - l = m.DlFreqInfo.Size() - n += 1 + l + sovRan(uint64(l)) + if m.ControlOutcomeFormatType != 0 { + i = encodeVarintRan(dAtA, i, uint64(m.ControlOutcomeFormatType)) + i-- + dAtA[i] = 0x30 } - if m.UlTransmissionBandwidth != nil { - l = m.UlTransmissionBandwidth.Size() - n += 1 + l + sovRan(uint64(l)) + if m.RicProcessIdFormatType != 0 { + i = encodeVarintRan(dAtA, i, uint64(m.RicProcessIdFormatType)) + i-- + dAtA[i] = 0x28 } - if m.DlTransmissionBandwidth != nil { - l = m.DlTransmissionBandwidth.Size() - n += 1 + l + sovRan(uint64(l)) + if m.ControlMessageFormatType != 0 { + i = encodeVarintRan(dAtA, i, uint64(m.ControlMessageFormatType)) + i-- + dAtA[i] = 0x20 } - return n -} - -func (m *TDDInfo) Size() (n int) { - if m == nil { - return 0 + if m.ControlHeaderFormatType != 0 { + i = encodeVarintRan(dAtA, i, uint64(m.ControlHeaderFormatType)) + i-- + dAtA[i] = 0x18 } - var l int - _ = l - if m.NrFreqInfo != nil { - l = m.NrFreqInfo.Size() - n += 1 + l + sovRan(uint64(l)) + if len(m.Name) > 0 { + i -= len(m.Name) + copy(dAtA[i:], m.Name) + i = encodeVarintRan(dAtA, i, uint64(len(m.Name))) + i-- + dAtA[i] = 0x12 } - if m.TransmissionBandwidth != nil { - l = m.TransmissionBandwidth.Size() - n += 1 + l + sovRan(uint64(l)) + if m.Type != 0 { + i = encodeVarintRan(dAtA, i, uint64(m.Type)) + i-- + dAtA[i] = 0x8 } - return n + return len(dAtA) - i, nil } -func (m *FrequencyInfo) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.NrArfcn != 0 { - n += 1 + sovRan(uint64(m.NrArfcn)) - } - if m.FrequencyBandList != nil { - l = m.FrequencyBandList.Size() - n += 1 + l + sovRan(uint64(l)) +func (m *CCCPolicyStyle) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err } - return n + return dAtA[:n], nil } -func (m *TransmissionBandwidth) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.NrScs != 0 { - n += 1 + sovRan(uint64(m.NrScs)) - } - if m.Nrb != 0 { - n += 1 + sovRan(uint64(m.Nrb)) - } - return n +func (m *CCCPolicyStyle) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *FrequencyBandList) Size() (n int) { - if m == nil { - return 0 - } +func (m *CCCPolicyStyle) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i var l int _ = l - if len(m.FrequencyBandItems) > 0 { - for _, e := range m.FrequencyBandItems { - l = e.Size() - n += 1 + l + sovRan(uint64(l)) + if m.Value != nil { + { + size, err := m.Value.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintRan(dAtA, i, uint64(size)) } + i-- + dAtA[i] = 0xa } - return n + return len(dAtA) - i, nil } -func (m *FrequencyBandItem) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.NrFrequencyBand != 0 { - n += 1 + sovRan(uint64(m.NrFrequencyBand)) +func (m *Plmnidentity) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err } - return n + return dAtA[:n], nil } -func (m *GlobalNgRanNodeID) Size() (n int) { - if m == nil { - return 0 - } +func (m *Plmnidentity) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *Plmnidentity) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i var l int _ = l - if m.GlobalNgRanNodeId != nil { - n += m.GlobalNgRanNodeId.Size() + if len(m.Value) > 0 { + i -= len(m.Value) + copy(dAtA[i:], m.Value) + i = encodeVarintRan(dAtA, i, uint64(len(m.Value))) + i-- + dAtA[i] = 0xa } - return n + return len(dAtA) - i, nil } -func (m *GlobalNgRanNodeID_GlobalGnbId) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.GlobalGnbId != nil { - l = m.GlobalGnbId.Size() - n += 1 + l + sovRan(uint64(l)) +func (m *Sst) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err } - return n + return dAtA[:n], nil } -func (m *GlobalNgRanNodeID_GlobalNgEnbId) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.GlobalNgEnbId != nil { - l = m.GlobalNgEnbId.Size() - n += 1 + l + sovRan(uint64(l)) - } - return n + +func (m *Sst) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *GlobalGnbID) Size() (n int) { - if m == nil { - return 0 - } + +func (m *Sst) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i var l int _ = l - if m.PlmnId != 0 { - n += 1 + sovRan(uint64(m.PlmnId)) - } - if m.GnbId != 0 { - n += 1 + sovRan(uint64(m.GnbId)) - } - if m.GnbIdLen != 0 { - n += 1 + sovRan(uint64(m.GnbIdLen)) + if len(m.Value) > 0 { + i -= len(m.Value) + copy(dAtA[i:], m.Value) + i = encodeVarintRan(dAtA, i, uint64(len(m.Value))) + i-- + dAtA[i] = 0xa } - return n + return len(dAtA) - i, nil } -func (m *GlobalNgEnbID) Size() (n int) { - if m == nil { - return 0 +func (m *Sd) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err } + return dAtA[:n], nil +} + +func (m *Sd) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *Sd) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i var l int _ = l - if m.PlmnId != 0 { - n += 1 + sovRan(uint64(m.PlmnId)) - } - if m.NgEnbId != nil { - n += m.NgEnbId.Size() + if len(m.Value) > 0 { + i -= len(m.Value) + copy(dAtA[i:], m.Value) + i = encodeVarintRan(dAtA, i, uint64(len(m.Value))) + i-- + dAtA[i] = 0xa } - return n + return len(dAtA) - i, nil } -func (m *GlobalNgEnbID_MacroNgEnbId) Size() (n int) { - if m == nil { - return 0 +func (m *SNSsai) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err } - var l int - _ = l - n += 1 + sovRan(uint64(m.MacroNgEnbId)) - return n + return dAtA[:n], nil } -func (m *GlobalNgEnbID_ShortMacroNgEnbId) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - n += 1 + sovRan(uint64(m.ShortMacroNgEnbId)) - return n + +func (m *SNSsai) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *GlobalNgEnbID_LongMacroNgEnbId) Size() (n int) { - if m == nil { - return 0 - } + +func (m *SNSsai) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i var l int _ = l - n += 1 + sovRan(uint64(m.LongMacroNgEnbId)) - return n -} -func (m *TaiSupportList) Size() (n int) { - if m == nil { - return 0 + if m.Sd != nil { + { + size, err := m.Sd.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintRan(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 } - var l int - _ = l - if len(m.TaiSupportItems) > 0 { - for _, e := range m.TaiSupportItems { - l = e.Size() - n += 1 + l + sovRan(uint64(l)) + if m.Sst != nil { + { + size, err := m.Sst.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintRan(dAtA, i, uint64(size)) } + i-- + dAtA[i] = 0xa } - return n + return len(dAtA) - i, nil } -func (m *TaiSupportItem) Size() (n int) { - if m == nil { - return 0 +func (m *RrmPolicyMember) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err } + return dAtA[:n], nil +} + +func (m *RrmPolicyMember) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *RrmPolicyMember) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i var l int _ = l - if m.Tac != 0 { - n += 1 + sovRan(uint64(m.Tac)) + if m.Snssai != nil { + { + size, err := m.Snssai.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintRan(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 } - if len(m.BroadcastPlmns) > 0 { - for _, e := range m.BroadcastPlmns { - l = e.Size() - n += 1 + l + sovRan(uint64(l)) + if m.PlmnId != nil { + { + size, err := m.PlmnId.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintRan(dAtA, i, uint64(size)) } + i-- + dAtA[i] = 0xa } - return n + return len(dAtA) - i, nil } -func (m *XnBroadcastPlmn) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.PlmnId != 0 { - n += 1 + sovRan(uint64(m.PlmnId)) - } - if m.TaiSliceSupportList != nil { - l = m.TaiSliceSupportList.Size() - n += 1 + l + sovRan(uint64(l)) +func (m *RrmPolicyMemberList) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err } - return n + return dAtA[:n], nil } -func (m *TaiSliceSupportList) Size() (n int) { - if m == nil { - return 0 - } +func (m *RrmPolicyMemberList) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *RrmPolicyMemberList) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i var l int _ = l - if len(m.SliceSupportItems) > 0 { - for _, e := range m.SliceSupportItems { - l = e.Size() - n += 1 + l + sovRan(uint64(l)) + if len(m.RrmPolicyMember) > 0 { + for iNdEx := len(m.RrmPolicyMember) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.RrmPolicyMember[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintRan(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa } } - return n + return len(dAtA) - i, nil } -func (m *SliceSupportItem) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.SNssai != nil { - l = m.SNssai.Size() - n += 1 + l + sovRan(uint64(l)) +func (m *ORRmpolicyRatio) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err } - return n + return dAtA[:n], nil } -func (m *SNssai) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.Sst != 0 { - n += 1 + sovRan(uint64(m.Sst)) - } - if m.Sd != 0 { - n += 1 + sovRan(uint64(m.Sd)) - } - return n +func (m *ORRmpolicyRatio) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *AmfRegionInformation) Size() (n int) { - if m == nil { - return 0 - } +func (m *ORRmpolicyRatio) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i var l int _ = l - if len(m.GlobalAmfRegionInformationItems) > 0 { - for _, e := range m.GlobalAmfRegionInformationItems { - l = e.Size() - n += 1 + l + sovRan(uint64(l)) - } + if m.RrmPolicyDedicatedRatio != 0 { + i = encodeVarintRan(dAtA, i, uint64(m.RrmPolicyDedicatedRatio)) + i-- + dAtA[i] = 0x30 } - return n -} - -func (m *GlobalAmfRegionInformationItem) Size() (n int) { - if m == nil { - return 0 + if m.RrmPolicyMinRatio != 0 { + i = encodeVarintRan(dAtA, i, uint64(m.RrmPolicyMinRatio)) + i-- + dAtA[i] = 0x28 } - var l int - _ = l - if m.PlmnId != 0 { - n += 1 + sovRan(uint64(m.PlmnId)) + if m.RrmPolicyMaxRatio != 0 { + i = encodeVarintRan(dAtA, i, uint64(m.RrmPolicyMaxRatio)) + i-- + dAtA[i] = 0x20 } - if m.AmfRegionId != 0 { - n += 1 + sovRan(uint64(m.AmfRegionId)) + if m.RrmPolicyMemberList != nil { + { + size, err := m.RrmPolicyMemberList.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintRan(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a } - return n + if m.SchedulerType != 0 { + i = encodeVarintRan(dAtA, i, uint64(m.SchedulerType)) + i-- + dAtA[i] = 0x10 + } + if m.ResourceType != 0 { + i = encodeVarintRan(dAtA, i, uint64(m.ResourceType)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil } -func (m *NeighborInformationNr) Size() (n int) { - if m == nil { - return 0 +func (m *ConfigurationStructure) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err } + return dAtA[:n], nil +} + +func (m *ConfigurationStructure) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ConfigurationStructure) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i var l int _ = l - if m.Pci != 0 { - n += 1 + sovRan(uint64(m.Pci)) - } - if m.NrCgi != nil { - l = m.NrCgi.Size() - n += 1 + l + sovRan(uint64(l)) - } - if m.Tac != 0 { - n += 1 + sovRan(uint64(m.Tac)) + if m.OldPolicyRatio != nil { + { + size, err := m.OldPolicyRatio.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintRan(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x22 } - if m.NrModeInfo != nil { - n += m.NrModeInfo.Size() + if m.PolicyRatio != nil { + { + size, err := m.PolicyRatio.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintRan(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a } - if m.ConnectivitySupport != nil { - l = m.ConnectivitySupport.Size() - n += 1 + l + sovRan(uint64(l)) + if len(m.ConfigurationName) > 0 { + i -= len(m.ConfigurationName) + copy(dAtA[i:], m.ConfigurationName) + i = encodeVarintRan(dAtA, i, uint64(len(m.ConfigurationName))) + i-- + dAtA[i] = 0x12 } - if m.MeasurementTimingConfiguration != 0 { - n += 1 + sovRan(uint64(m.MeasurementTimingConfiguration)) + if m.ChangeType != 0 { + i = encodeVarintRan(dAtA, i, uint64(m.ChangeType)) + i-- + dAtA[i] = 0x8 } - return n + return len(dAtA) - i, nil } -func (m *NeighborInformationNr_FddInfo) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.FddInfo != nil { - l = m.FddInfo.Size() - n += 1 + l + sovRan(uint64(l)) +func (m *ConfigurationStructureList) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err } - return n + return dAtA[:n], nil } -func (m *NeighborInformationNr_TddInfo) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.TddInfo != nil { - l = m.TddInfo.Size() - n += 1 + l + sovRan(uint64(l)) - } - return n + +func (m *ConfigurationStructureList) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *ServiceModelInfo) Size() (n int) { - if m == nil { - return 0 - } + +func (m *ConfigurationStructureList) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i var l int _ = l - l = len(m.OID) - if l > 0 { - n += 1 + l + sovRan(uint64(l)) - } - l = len(m.Name) - if l > 0 { - n += 1 + l + sovRan(uint64(l)) - } - if len(m.RanFunctions) > 0 { - for _, e := range m.RanFunctions { - l = e.Size() - n += 1 + l + sovRan(uint64(l)) - } - } - if len(m.RanFunctionIDs) > 0 { - l = 0 - for _, e := range m.RanFunctionIDs { - l += sovRan(uint64(e)) + if len(m.ConfigurationStructure) > 0 { + for iNdEx := len(m.ConfigurationStructure) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.ConfigurationStructure[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintRan(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa } - n += 1 + sovRan(uint64(l)) + l } - return n + return len(dAtA) - i, nil } -func (m *RCRanFunction) Size() (n int) { - if m == nil { - return 0 +func (m *KPMReportStyle) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err } + return dAtA[:n], nil +} + +func (m *KPMReportStyle) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *KPMReportStyle) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i var l int _ = l - l = len(m.ID) - if l > 0 { - n += 1 + l + sovRan(uint64(l)) - } - if len(m.ReportStyles) > 0 { - for _, e := range m.ReportStyles { - l = e.Size() - n += 1 + l + sovRan(uint64(l)) - } - } - if len(m.InsertStyles) > 0 { - for _, e := range m.InsertStyles { - l = e.Size() - n += 1 + l + sovRan(uint64(l)) - } - } - if len(m.EventTriggerStyles) > 0 { - for _, e := range m.EventTriggerStyles { - l = e.Size() - n += 1 + l + sovRan(uint64(l)) + if len(m.Measurements) > 0 { + for iNdEx := len(m.Measurements) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.Measurements[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintRan(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a } } - if len(m.PolicyStyles) > 0 { - for _, e := range m.PolicyStyles { - l = e.Size() - n += 1 + l + sovRan(uint64(l)) - } + if m.Type != 0 { + i = encodeVarintRan(dAtA, i, uint64(m.Type)) + i-- + dAtA[i] = 0x10 } - if len(m.ControlStyles) > 0 { - for _, e := range m.ControlStyles { - l = e.Size() - n += 1 + l + sovRan(uint64(l)) - } + if len(m.Name) > 0 { + i -= len(m.Name) + copy(dAtA[i:], m.Name) + i = encodeVarintRan(dAtA, i, uint64(len(m.Name))) + i-- + dAtA[i] = 0xa } - return n + return len(dAtA) - i, nil } -func (m *MHORanFunction) Size() (n int) { - if m == nil { - return 0 +func (m *MHOReportStyle) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err } + return dAtA[:n], nil +} + +func (m *MHOReportStyle) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MHOReportStyle) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i var l int _ = l - l = len(m.ID) - if l > 0 { - n += 1 + l + sovRan(uint64(l)) + if m.Type != 0 { + i = encodeVarintRan(dAtA, i, uint64(m.Type)) + i-- + dAtA[i] = 0x10 } - if len(m.ReportStyles) > 0 { - for _, e := range m.ReportStyles { - l = e.Size() - n += 1 + l + sovRan(uint64(l)) - } + if len(m.Name) > 0 { + i -= len(m.Name) + copy(dAtA[i:], m.Name) + i = encodeVarintRan(dAtA, i, uint64(len(m.Name))) + i-- + dAtA[i] = 0xa } - return n + return len(dAtA) - i, nil } -func (m *KPMRanFunction) Size() (n int) { - if m == nil { - return 0 +func (m *KPMMeasurement) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err } + return dAtA[:n], nil +} + +func (m *KPMMeasurement) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *KPMMeasurement) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i var l int _ = l - l = len(m.ID) - if l > 0 { - n += 1 + l + sovRan(uint64(l)) + if len(m.Name) > 0 { + i -= len(m.Name) + copy(dAtA[i:], m.Name) + i = encodeVarintRan(dAtA, i, uint64(len(m.Name))) + i-- + dAtA[i] = 0x12 } - if len(m.ReportStyles) > 0 { - for _, e := range m.ReportStyles { - l = e.Size() - n += 1 + l + sovRan(uint64(l)) - } + if len(m.ID) > 0 { + i -= len(m.ID) + copy(dAtA[i:], m.ID) + i = encodeVarintRan(dAtA, i, uint64(len(m.ID))) + i-- + dAtA[i] = 0xa } - return n + return len(dAtA) - i, nil } -func (m *RSMRanFunction) Size() (n int) { - if m == nil { - return 0 +func (m *RSMNodeSlicingCapabilityItem) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err } + return dAtA[:n], nil +} + +func (m *RSMNodeSlicingCapabilityItem) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *RSMNodeSlicingCapabilityItem) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i var l int _ = l - l = len(m.ID) - if l > 0 { - n += 1 + l + sovRan(uint64(l)) - } - if len(m.RicSlicingNodeCapabilityList) > 0 { - for _, e := range m.RicSlicingNodeCapabilityList { - l = e.Size() - n += 1 + l + sovRan(uint64(l)) + if len(m.SupportedConfig) > 0 { + for iNdEx := len(m.SupportedConfig) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.SupportedConfig[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintRan(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x2a } } - return n -} - -func (m *RCEventTriggerStyle) Size() (n int) { - if m == nil { - return 0 + if m.MaxNumberOfUesPerSlice != 0 { + i = encodeVarintRan(dAtA, i, uint64(m.MaxNumberOfUesPerSlice)) + i-- + dAtA[i] = 0x20 } - var l int - _ = l - l = len(m.Name) - if l > 0 { - n += 1 + l + sovRan(uint64(l)) + if m.SlicingType != 0 { + i = encodeVarintRan(dAtA, i, uint64(m.SlicingType)) + i-- + dAtA[i] = 0x18 } - if m.Type != 0 { - n += 1 + sovRan(uint64(m.Type)) + if m.MaxNumberOfSlicesUl != 0 { + i = encodeVarintRan(dAtA, i, uint64(m.MaxNumberOfSlicesUl)) + i-- + dAtA[i] = 0x10 } - if m.FormatType != 0 { - n += 1 + sovRan(uint64(m.FormatType)) + if m.MaxNumberOfSlicesDl != 0 { + i = encodeVarintRan(dAtA, i, uint64(m.MaxNumberOfSlicesDl)) + i-- + dAtA[i] = 0x8 } - return n + return len(dAtA) - i, nil } -func (m *RCReportStyle) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - l = len(m.Name) - if l > 0 { - n += 1 + l + sovRan(uint64(l)) - } - if m.Type != 0 { - n += 1 + sovRan(uint64(m.Type)) - } - if len(m.RanParameters) > 0 { - for _, e := range m.RanParameters { - l = e.Size() - n += 1 + l + sovRan(uint64(l)) - } +func (m *RSMSupportedSlicingConfigItem) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err } - return n + return dAtA[:n], nil } -func (m *RCInsertStyle) Size() (n int) { - if m == nil { - return 0 - } +func (m *RSMSupportedSlicingConfigItem) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *RSMSupportedSlicingConfigItem) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i var l int _ = l - l = len(m.Name) - if l > 0 { - n += 1 + l + sovRan(uint64(l)) - } - if m.Type != 0 { - n += 1 + sovRan(uint64(m.Type)) - } - if len(m.InsertIndications) > 0 { - for _, e := range m.InsertIndications { - l = e.Size() - n += 1 + l + sovRan(uint64(l)) - } + if m.SlicingConfigType != 0 { + i = encodeVarintRan(dAtA, i, uint64(m.SlicingConfigType)) + i-- + dAtA[i] = 0x8 } - return n + return len(dAtA) - i, nil } -func (m *RCPolicyStyle) Size() (n int) { - if m == nil { - return 0 +func (m *RSMSliceItemList) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err } + return dAtA[:n], nil +} + +func (m *RSMSliceItemList) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *RSMSliceItemList) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i var l int _ = l - l = len(m.Name) - if l > 0 { - n += 1 + l + sovRan(uint64(l)) - } - if m.Type != 0 { - n += 1 + sovRan(uint64(m.Type)) - } - if len(m.PolicyActions) > 0 { - for _, e := range m.PolicyActions { - l = e.Size() - n += 1 + l + sovRan(uint64(l)) + if len(m.RsmSliceList) > 0 { + for iNdEx := len(m.RsmSliceList) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.RsmSliceList[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintRan(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa } } - return n + return len(dAtA) - i, nil } -func (m *PolicyAction) Size() (n int) { - if m == nil { - return 0 +func (m *RSMSlicingItem) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err } + return dAtA[:n], nil +} + +func (m *RSMSlicingItem) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *RSMSlicingItem) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i var l int _ = l - if m.ID != 0 { - n += 1 + sovRan(uint64(m.ID)) + if len(m.UeIdList) > 0 { + for iNdEx := len(m.UeIdList) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.UeIdList[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintRan(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x2a + } } - l = len(m.Name) - if l > 0 { - n += 1 + l + sovRan(uint64(l)) + if m.SliceType != 0 { + i = encodeVarintRan(dAtA, i, uint64(m.SliceType)) + i-- + dAtA[i] = 0x20 } - if len(m.PolicyActionRanParameters) > 0 { - for _, e := range m.PolicyActionRanParameters { - l = e.Size() - n += 1 + l + sovRan(uint64(l)) + if m.SliceParameters != nil { + { + size, err := m.SliceParameters.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintRan(dAtA, i, uint64(size)) } + i-- + dAtA[i] = 0x1a } - if len(m.PolicyConditionRanParameters) > 0 { - for _, e := range m.PolicyConditionRanParameters { - l = e.Size() - n += 1 + l + sovRan(uint64(l)) - } + if len(m.SliceDesc) > 0 { + i -= len(m.SliceDesc) + copy(dAtA[i:], m.SliceDesc) + i = encodeVarintRan(dAtA, i, uint64(len(m.SliceDesc))) + i-- + dAtA[i] = 0x12 } - return n + if len(m.ID) > 0 { + i -= len(m.ID) + copy(dAtA[i:], m.ID) + i = encodeVarintRan(dAtA, i, uint64(len(m.ID))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil } -func (m *RCControlStyle) Size() (n int) { - if m == nil { - return 0 +func (m *RSMSliceParameters) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err } + return dAtA[:n], nil +} + +func (m *RSMSliceParameters) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *RSMSliceParameters) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i var l int _ = l - l = len(m.Name) - if l > 0 { - n += 1 + l + sovRan(uint64(l)) - } - if m.Type != 0 { - n += 1 + sovRan(uint64(m.Type)) - } - if m.HeaderFormatType != 0 { - n += 1 + sovRan(uint64(m.HeaderFormatType)) - } - if m.MessageFormatType != 0 { - n += 1 + sovRan(uint64(m.MessageFormatType)) + if m.QosLevel != 0 { + i = encodeVarintRan(dAtA, i, uint64(m.QosLevel)) + i-- + dAtA[i] = 0x18 } - if m.ControlOutcomeFormatType != 0 { - n += 1 + sovRan(uint64(m.ControlOutcomeFormatType)) + if m.Weight != 0 { + i = encodeVarintRan(dAtA, i, uint64(m.Weight)) + i-- + dAtA[i] = 0x10 } - if len(m.ControlActions) > 0 { - for _, e := range m.ControlActions { - l = e.Size() - n += 1 + l + sovRan(uint64(l)) - } + if m.SchedulerType != 0 { + i = encodeVarintRan(dAtA, i, uint64(m.SchedulerType)) + i-- + dAtA[i] = 0x8 } - return n + return len(dAtA) - i, nil } -func (m *ControlAction) Size() (n int) { - if m == nil { - return 0 +func (m *DuUeF1ApID) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err } + return dAtA[:n], nil +} + +func (m *DuUeF1ApID) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *DuUeF1ApID) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i var l int _ = l - if m.ID != 0 { - n += 1 + sovRan(uint64(m.ID)) - } - l = len(m.Name) - if l > 0 { - n += 1 + l + sovRan(uint64(l)) - } - if len(m.RanParameters) > 0 { - for _, e := range m.RanParameters { - l = e.Size() - n += 1 + l + sovRan(uint64(l)) - } + if m.Value != 0 { + i = encodeVarintRan(dAtA, i, uint64(m.Value)) + i-- + dAtA[i] = 0x8 } - return n + return len(dAtA) - i, nil } -func (m *InsertIndication) Size() (n int) { - if m == nil { - return 0 +func (m *CuUeF1ApID) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err } + return dAtA[:n], nil +} + +func (m *CuUeF1ApID) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *CuUeF1ApID) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i var l int _ = l - if m.ID != 0 { - n += 1 + sovRan(uint64(m.ID)) - } - l = len(m.Name) - if l > 0 { - n += 1 + l + sovRan(uint64(l)) - } - if len(m.RanParameters) > 0 { - for _, e := range m.RanParameters { - l = e.Size() - n += 1 + l + sovRan(uint64(l)) - } + if m.Value != 0 { + i = encodeVarintRan(dAtA, i, uint64(m.Value)) + i-- + dAtA[i] = 0x8 } - return n + return len(dAtA) - i, nil } -func (m *RANParameter) Size() (n int) { - if m == nil { - return 0 +func (m *RanUeNgapID) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err } + return dAtA[:n], nil +} + +func (m *RanUeNgapID) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *RanUeNgapID) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i var l int _ = l - if m.ID != 0 { - n += 1 + sovRan(uint64(m.ID)) - } - l = len(m.Name) - if l > 0 { - n += 1 + l + sovRan(uint64(l)) + if m.Value != 0 { + i = encodeVarintRan(dAtA, i, uint64(m.Value)) + i-- + dAtA[i] = 0x8 } - return n + return len(dAtA) - i, nil } -func (m *KPMReportStyle) Size() (n int) { - if m == nil { - return 0 +func (m *EnbUeS1ApID) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err } + return dAtA[:n], nil +} + +func (m *EnbUeS1ApID) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *EnbUeS1ApID) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i var l int _ = l - l = len(m.Name) - if l > 0 { - n += 1 + l + sovRan(uint64(l)) - } - if m.Type != 0 { - n += 1 + sovRan(uint64(m.Type)) - } - if len(m.Measurements) > 0 { - for _, e := range m.Measurements { - l = e.Size() - n += 1 + l + sovRan(uint64(l)) - } + if m.Value != 0 { + i = encodeVarintRan(dAtA, i, uint64(m.Value)) + i-- + dAtA[i] = 0x8 } - return n + return len(dAtA) - i, nil } -func (m *MHOReportStyle) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - l = len(m.Name) - if l > 0 { - n += 1 + l + sovRan(uint64(l)) - } - if m.Type != 0 { - n += 1 + sovRan(uint64(m.Type)) +func (m *AmfUeNgapID) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err } - return n + return dAtA[:n], nil } -func (m *KPMMeasurement) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - l = len(m.ID) - if l > 0 { - n += 1 + l + sovRan(uint64(l)) - } - l = len(m.Name) - if l > 0 { - n += 1 + l + sovRan(uint64(l)) - } - return n +func (m *AmfUeNgapID) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *RSMNodeSlicingCapabilityItem) Size() (n int) { - if m == nil { - return 0 - } +func (m *AmfUeNgapID) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i var l int _ = l - if m.MaxNumberOfSlicesDl != 0 { - n += 1 + sovRan(uint64(m.MaxNumberOfSlicesDl)) - } - if m.MaxNumberOfSlicesUl != 0 { - n += 1 + sovRan(uint64(m.MaxNumberOfSlicesUl)) - } - if m.SlicingType != 0 { - n += 1 + sovRan(uint64(m.SlicingType)) - } - if m.MaxNumberOfUesPerSlice != 0 { - n += 1 + sovRan(uint64(m.MaxNumberOfUesPerSlice)) - } - if len(m.SupportedConfig) > 0 { - for _, e := range m.SupportedConfig { - l = e.Size() - n += 1 + l + sovRan(uint64(l)) - } + if m.Value != 0 { + i = encodeVarintRan(dAtA, i, uint64(m.Value)) + i-- + dAtA[i] = 0x8 } - return n + return len(dAtA) - i, nil } -func (m *RSMSupportedSlicingConfigItem) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.SlicingConfigType != 0 { - n += 1 + sovRan(uint64(m.SlicingConfigType)) +func (m *UeIdentity) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err } - return n + return dAtA[:n], nil } -func (m *RSMSliceItemList) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if len(m.RsmSliceList) > 0 { - for _, e := range m.RsmSliceList { - l = e.Size() - n += 1 + l + sovRan(uint64(l)) - } - } - return n +func (m *UeIdentity) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *RSMSlicingItem) Size() (n int) { - if m == nil { - return 0 - } +func (m *UeIdentity) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i var l int _ = l - l = len(m.ID) - if l > 0 { - n += 1 + l + sovRan(uint64(l)) - } - l = len(m.SliceDesc) - if l > 0 { - n += 1 + l + sovRan(uint64(l)) - } - if m.SliceParameters != nil { - l = m.SliceParameters.Size() - n += 1 + l + sovRan(uint64(l)) + if m.DrbId != nil { + { + size, err := m.DrbId.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintRan(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x3a } - if m.SliceType != 0 { - n += 1 + sovRan(uint64(m.SliceType)) + if m.PreferredIDType != 0 { + i = encodeVarintRan(dAtA, i, uint64(m.PreferredIDType)) + i-- + dAtA[i] = 0x30 } - if len(m.UeIdList) > 0 { - for _, e := range m.UeIdList { - l = e.Size() - n += 1 + l + sovRan(uint64(l)) + if m.AMFUeNgapID != nil { + { + size, err := m.AMFUeNgapID.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintRan(dAtA, i, uint64(size)) } + i-- + dAtA[i] = 0x2a } - return n -} - -func (m *RSMSliceParameters) Size() (n int) { - if m == nil { - return 0 + if m.EnbUeS1apID != nil { + { + size, err := m.EnbUeS1apID.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintRan(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x22 } - var l int - _ = l - if m.SchedulerType != 0 { - n += 1 + sovRan(uint64(m.SchedulerType)) + if m.RANUeNgapID != nil { + { + size, err := m.RANUeNgapID.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintRan(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a } - if m.Weight != 0 { - n += 1 + sovRan(uint64(m.Weight)) + if m.CuUeF1apID != nil { + { + size, err := m.CuUeF1apID.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintRan(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 } - if m.QosLevel != 0 { - n += 1 + sovRan(uint64(m.QosLevel)) + if m.DuUeF1apID != nil { + { + size, err := m.DuUeF1apID.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintRan(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa } - return n + return len(dAtA) - i, nil } -func (m *DuUeF1ApID) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.Value != 0 { - n += 1 + sovRan(uint64(m.Value)) +func (m *DrbId) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err } - return n + return dAtA[:n], nil } -func (m *CuUeF1ApID) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.Value != 0 { - n += 1 + sovRan(uint64(m.Value)) - } - return n +func (m *DrbId) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *RanUeNgapID) Size() (n int) { - if m == nil { - return 0 - } +func (m *DrbId) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i var l int _ = l - if m.Value != 0 { - n += 1 + sovRan(uint64(m.Value)) + if m.DrbId != nil { + { + size := m.DrbId.Size() + i -= size + if _, err := m.DrbId.MarshalTo(dAtA[i:]); err != nil { + return 0, err + } + } } - return n + return len(dAtA) - i, nil } -func (m *EnbUeS1ApID) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.Value != 0 { - n += 1 + sovRan(uint64(m.Value)) - } - return n +func (m *DrbId_FourGdrbId) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *AmfUeNgapID) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.Value != 0 { - n += 1 + sovRan(uint64(m.Value)) +func (m *DrbId_FourGdrbId) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + if m.FourGdrbId != nil { + { + size, err := m.FourGdrbId.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintRan(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa } - return n + return len(dAtA) - i, nil } - -func (m *UeIdentity) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.DuUeF1apID != nil { - l = m.DuUeF1apID.Size() - n += 1 + l + sovRan(uint64(l)) - } - if m.CuUeF1apID != nil { - l = m.CuUeF1apID.Size() - n += 1 + l + sovRan(uint64(l)) - } - if m.RANUeNgapID != nil { - l = m.RANUeNgapID.Size() - n += 1 + l + sovRan(uint64(l)) - } - if m.EnbUeS1apID != nil { - l = m.EnbUeS1apID.Size() - n += 1 + l + sovRan(uint64(l)) - } - if m.AMFUeNgapID != nil { - l = m.AMFUeNgapID.Size() - n += 1 + l + sovRan(uint64(l)) - } - if m.PreferredIDType != 0 { - n += 1 + sovRan(uint64(m.PreferredIDType)) - } - if m.DrbId != nil { - l = m.DrbId.Size() - n += 1 + l + sovRan(uint64(l)) - } - return n +func (m *DrbId_FiveGdrbId) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *DrbId) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.DrbId != nil { - n += m.DrbId.Size() +func (m *DrbId_FiveGdrbId) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + if m.FiveGdrbId != nil { + { + size, err := m.FiveGdrbId.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintRan(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 } - return n + return len(dAtA) - i, nil } - -func (m *DrbId_FourGdrbId) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.FourGdrbId != nil { - l = m.FourGdrbId.Size() - n += 1 + l + sovRan(uint64(l)) +func (m *FiveGDrbId) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err } - return n + return dAtA[:n], nil } -func (m *DrbId_FiveGdrbId) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.FiveGdrbId != nil { - l = m.FiveGdrbId.Size() - n += 1 + l + sovRan(uint64(l)) - } - return n + +func (m *FiveGDrbId) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *FiveGDrbId) Size() (n int) { - if m == nil { - return 0 - } + +func (m *FiveGDrbId) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i var l int _ = l - if m.Value != 0 { - n += 1 + sovRan(uint64(m.Value)) + if len(m.FlowsMapToDrb) > 0 { + for iNdEx := len(m.FlowsMapToDrb) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.FlowsMapToDrb[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintRan(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + } } if m.Qfi != nil { - l = m.Qfi.Size() - n += 1 + l + sovRan(uint64(l)) - } - if len(m.FlowsMapToDrb) > 0 { - for _, e := range m.FlowsMapToDrb { - l = e.Size() - n += 1 + l + sovRan(uint64(l)) + { + size, err := m.Qfi.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintRan(dAtA, i, uint64(size)) } + i-- + dAtA[i] = 0x12 } - return n + if m.Value != 0 { + i = encodeVarintRan(dAtA, i, uint64(m.Value)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil } -func (m *Qfi) Size() (n int) { - if m == nil { - return 0 +func (m *Qfi) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err } + return dAtA[:n], nil +} + +func (m *Qfi) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *Qfi) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i var l int _ = l if m.Value != 0 { - n += 1 + sovRan(uint64(m.Value)) + i = encodeVarintRan(dAtA, i, uint64(m.Value)) + i-- + dAtA[i] = 0x8 } - return n + return len(dAtA) - i, nil } -func (m *QoSflowLevelParameters) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.QosFlowLevelParameters != nil { - n += m.QosFlowLevelParameters.Size() +func (m *QoSflowLevelParameters) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err } - return n + return dAtA[:n], nil } -func (m *QoSflowLevelParameters_DynamicFiveQi) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.DynamicFiveQi != nil { - l = m.DynamicFiveQi.Size() - n += 1 + l + sovRan(uint64(l)) - } - return n +func (m *QoSflowLevelParameters) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *QoSflowLevelParameters_NonDynamicFiveQi) Size() (n int) { - if m == nil { - return 0 - } + +func (m *QoSflowLevelParameters) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i var l int _ = l - if m.NonDynamicFiveQi != nil { - l = m.NonDynamicFiveQi.Size() - n += 1 + l + sovRan(uint64(l)) + if m.QosFlowLevelParameters != nil { + { + size := m.QosFlowLevelParameters.Size() + i -= size + if _, err := m.QosFlowLevelParameters.MarshalTo(dAtA[i:]); err != nil { + return 0, err + } + } } - return n + return len(dAtA) - i, nil } -func (m *DynamicFiveQi) Size() (n int) { - if m == nil { - return 0 + +func (m *QoSflowLevelParameters_DynamicFiveQi) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *QoSflowLevelParameters_DynamicFiveQi) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + if m.DynamicFiveQi != nil { + { + size, err := m.DynamicFiveQi.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintRan(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} +func (m *QoSflowLevelParameters_NonDynamicFiveQi) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *QoSflowLevelParameters_NonDynamicFiveQi) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + if m.NonDynamicFiveQi != nil { + { + size, err := m.NonDynamicFiveQi.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintRan(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + return len(dAtA) - i, nil +} +func (m *DynamicFiveQi) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err } + return dAtA[:n], nil +} + +func (m *DynamicFiveQi) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *DynamicFiveQi) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i var l int _ = l - if m.PriorityLevel != 0 { - n += 1 + sovRan(uint64(m.PriorityLevel)) + if m.PacketErrorRate != 0 { + i = encodeVarintRan(dAtA, i, uint64(m.PacketErrorRate)) + i-- + dAtA[i] = 0x18 } if m.PacketDelayBudge != 0 { - n += 1 + sovRan(uint64(m.PacketDelayBudge)) + i = encodeVarintRan(dAtA, i, uint64(m.PacketDelayBudge)) + i-- + dAtA[i] = 0x10 } - if m.PacketErrorRate != 0 { - n += 1 + sovRan(uint64(m.PacketErrorRate)) + if m.PriorityLevel != 0 { + i = encodeVarintRan(dAtA, i, uint64(m.PriorityLevel)) + i-- + dAtA[i] = 0x8 } - return n + return len(dAtA) - i, nil } -func (m *NonDynamicFiveQi) Size() (n int) { - if m == nil { - return 0 +func (m *NonDynamicFiveQi) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err } + return dAtA[:n], nil +} + +func (m *NonDynamicFiveQi) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *NonDynamicFiveQi) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i var l int _ = l if m.FiveQi != nil { - l = m.FiveQi.Size() - n += 1 + l + sovRan(uint64(l)) + { + size, err := m.FiveQi.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintRan(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa } - return n + return len(dAtA) - i, nil } -func (m *FiveQi) Size() (n int) { +func (m *FiveQi) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *FiveQi) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *FiveQi) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Value != 0 { + i = encodeVarintRan(dAtA, i, uint64(m.Value)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *FourGDrbId) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *FourGDrbId) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *FourGDrbId) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Qci != nil { + { + size, err := m.Qci.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintRan(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + if m.Value != 0 { + i = encodeVarintRan(dAtA, i, uint64(m.Value)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *Qci) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *Qci) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *Qci) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Value != 0 { + i = encodeVarintRan(dAtA, i, uint64(m.Value)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func encodeVarintRan(dAtA []byte, offset int, v uint64) int { + offset -= sovRan(v) + base := offset + for v >= 1<<7 { + dAtA[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + dAtA[offset] = uint8(v) + return base +} +func (m *Location) Size() (n int) { if m == nil { return 0 } var l int _ = l - if m.Value != 0 { - n += 1 + sovRan(uint64(m.Value)) + if m.Lat != 0 { + n += 9 + } + if m.Lng != 0 { + n += 9 + } + if m.Ext != nil { + n += m.Ext.Size() } return n } -func (m *FourGDrbId) Size() (n int) { +func (m *Location_Wgs84) Size() (n int) { if m == nil { return 0 } var l int _ = l - if m.Value != 0 { - n += 1 + sovRan(uint64(m.Value)) + if m.Wgs84 != nil { + l = m.Wgs84.Size() + n += 1 + l + sovRan(uint64(l)) } - if m.Qci != nil { - l = m.Qci.Size() + return n +} +func (m *Location_Cartesian) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Cartesian != nil { + l = m.Cartesian.Size() n += 1 + l + sovRan(uint64(l)) } - return n -} + return n +} +func (m *Wgs84Location) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.LatitudeDeg != 0 { + n += 9 + } + if m.LongitudeDeg != 0 { + n += 9 + } + if m.AltitudeM != 0 { + n += 9 + } + return n +} + +func (m *CartesianLocation) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.XM != 0 { + n += 9 + } + if m.YM != 0 { + n += 9 + } + if m.ZM != 0 { + n += 9 + } + return n +} + +func (m *AzElOrientation) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.AzimuthDeg != 0 { + n += 9 + } + if m.ElevationDeg != 0 { + n += 9 + } + if m.RotationDeg != 0 { + n += 9 + } + return n +} + +func (m *YprOrientation) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.YawDeg != 0 { + n += 9 + } + if m.PitchDeg != 0 { + n += 9 + } + if m.RollDeg != 0 { + n += 9 + } + return n +} + +func (m *Orientation) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Orientation != nil { + n += m.Orientation.Size() + } + return n +} + +func (m *Orientation_Azel) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Azel != nil { + l = m.Azel.Size() + n += 1 + l + sovRan(uint64(l)) + } + return n +} +func (m *Orientation_Ypr) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Ypr != nil { + l = m.Ypr.Size() + n += 1 + l + sovRan(uint64(l)) + } + return n +} +func (m *Waypoint) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Time != nil { + l = m.Time.Size() + n += 1 + l + sovRan(uint64(l)) + } + if m.Location != nil { + l = m.Location.Size() + n += 1 + l + sovRan(uint64(l)) + } + return n +} + +func (m *Waypoints) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.Waypoint) > 0 { + for _, e := range m.Waypoint { + l = e.Size() + n += 1 + l + sovRan(uint64(l)) + } + } + return n +} + +func (m *OrbitData) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Epoch != nil { + l = m.Epoch.Size() + n += 1 + l + sovRan(uint64(l)) + } + if m.InclinationDeg != 0 { + n += 9 + } + if m.RaanDeg != 0 { + n += 9 + } + if m.E != 0 { + n += 9 + } + if m.ArgumentDeg != 0 { + n += 9 + } + if m.AnomalyDeg != 0 { + n += 9 + } + if m.MeanMotion != 0 { + n += 9 + } + return n +} + +func (m *Motion) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Motion != nil { + n += m.Motion.Size() + } + return n +} + +func (m *Motion_FixedLocation) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.FixedLocation != nil { + l = m.FixedLocation.Size() + n += 1 + l + sovRan(uint64(l)) + } + return n +} +func (m *Motion_Waypoints) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Waypoints != nil { + l = m.Waypoints.Size() + n += 1 + l + sovRan(uint64(l)) + } + return n +} +func (m *Motion_Orbit) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Orbit != nil { + l = m.Orbit.Size() + n += 1 + l + sovRan(uint64(l)) + } + return n +} +func (m *Coverage) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Height != 0 { + n += 1 + sovRan(uint64(m.Height)) + } + if m.ArcWidth != 0 { + n += 1 + sovRan(uint64(m.ArcWidth)) + } + if m.Azimuth != 0 { + n += 1 + sovRan(uint64(m.Azimuth)) + } + if m.Tilt != 0 { + n += 1 + sovRan(uint64(m.Tilt)) + } + return n +} + +func (m *E2Node) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.ServiceModels) > 0 { + for k, v := range m.ServiceModels { + _ = k + _ = v + l = 0 + if v != nil { + l = v.Size() + l += 1 + sovRan(uint64(l)) + } + mapEntrySize := 1 + len(k) + sovRan(uint64(len(k))) + l + n += mapEntrySize + 1 + sovRan(uint64(mapEntrySize)) + } + } + return n +} + +func (m *E2NodeConfig) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.Connections) > 0 { + for _, e := range m.Connections { + l = e.Size() + n += 1 + l + sovRan(uint64(l)) + } + } + if m.Version != 0 { + n += 1 + sovRan(uint64(m.Version)) + } + return n +} + +func (m *Lease) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Expiration != nil { + l = github_com_gogo_protobuf_types.SizeOfStdTime(*m.Expiration) + n += 1 + l + sovRan(uint64(l)) + } + return n +} + +func (m *Interface) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Type != 0 { + n += 1 + sovRan(uint64(m.Type)) + } + l = len(m.IP) + if l > 0 { + n += 1 + l + sovRan(uint64(l)) + } + if m.Port != 0 { + n += 1 + sovRan(uint64(m.Port)) + } + return n +} + +func (m *E2TInfo) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.Interfaces) > 0 { + for _, e := range m.Interfaces { + l = e.Size() + n += 1 + l + sovRan(uint64(l)) + } + } + return n +} + +func (m *XAppInfo) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.Interfaces) > 0 { + for _, e := range m.Interfaces { + l = e.Size() + n += 1 + l + sovRan(uint64(l)) + } + } + if len(m.A1PolicyTypes) > 0 { + for _, e := range m.A1PolicyTypes { + l = e.Size() + n += 1 + l + sovRan(uint64(l)) + } + } + return n +} + +func (m *A1PolicyType) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.ID) + if l > 0 { + n += 1 + l + sovRan(uint64(l)) + } + l = len(m.Name) + if l > 0 { + n += 1 + l + sovRan(uint64(l)) + } + l = len(m.Version) + if l > 0 { + n += 1 + l + sovRan(uint64(l)) + } + l = len(m.Description) + if l > 0 { + n += 1 + l + sovRan(uint64(l)) + } + return n +} + +func (m *A1TInfo) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.Interfaces) > 0 { + for _, e := range m.Interfaces { + l = e.Size() + n += 1 + l + sovRan(uint64(l)) + } + } + return n +} + +func (m *CellGlobalID) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Value) + if l > 0 { + n += 1 + l + sovRan(uint64(l)) + } + if m.Type != 0 { + n += 1 + sovRan(uint64(m.Type)) + } + return n +} + +func (m *NeighborCellID) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.CellGlobalID != nil { + l = m.CellGlobalID.Size() + n += 1 + l + sovRan(uint64(l)) + } + l = len(m.PlmnID) + if l > 0 { + n += 1 + l + sovRan(uint64(l)) + } + return n +} + +func (m *E2Cell) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.CellObjectID) + if l > 0 { + n += 1 + l + sovRan(uint64(l)) + } + if m.CellGlobalID != nil { + l = m.CellGlobalID.Size() + n += 1 + l + sovRan(uint64(l)) + } + if m.AntennaCount != 0 { + n += 1 + sovRan(uint64(m.AntennaCount)) + } + if m.ARFCN != 0 { + n += 1 + sovRan(uint64(m.ARFCN)) + } + l = len(m.CellType) + if l > 0 { + n += 1 + l + sovRan(uint64(l)) + } + if m.PCI != 0 { + n += 1 + sovRan(uint64(m.PCI)) + } + if len(m.KpiReports) > 0 { + for k, v := range m.KpiReports { + _ = k + _ = v + mapEntrySize := 1 + len(k) + sovRan(uint64(len(k))) + 1 + sovRan(uint64(v)) + n += mapEntrySize + 1 + sovRan(uint64(mapEntrySize)) + } + } + if len(m.NeighborCellIDs) > 0 { + for _, e := range m.NeighborCellIDs { + l = e.Size() + n += 1 + l + sovRan(uint64(l)) + } + } + if m.GnbDuId != 0 { + n += 1 + sovRan(uint64(m.GnbDuId)) + } + if m.LatestRrcVersion != 0 { + n += 1 + sovRan(uint64(m.LatestRrcVersion)) + } + if m.PlmnId != 0 { + n += 1 + sovRan(uint64(m.PlmnId)) + } + if len(m.ServedPlmns) > 0 { + l = 0 + for _, e := range m.ServedPlmns { + l += sovRan(uint64(e)) + } + n += 1 + sovRan(uint64(l)) + l + } + if m.NrModeInfo != nil { + n += m.NrModeInfo.Size() + } + if m.MeasurementTimingConfiguration != 0 { + n += 1 + sovRan(uint64(m.MeasurementTimingConfiguration)) + } + if m.GlobalNgRanNodeId != nil { + l = m.GlobalNgRanNodeId.Size() + n += 2 + l + sovRan(uint64(l)) + } + if m.TaiSupportList != nil { + l = m.TaiSupportList.Size() + n += 2 + l + sovRan(uint64(l)) + } + if m.AmfRegionInformation != nil { + l = m.AmfRegionInformation.Size() + n += 2 + l + sovRan(uint64(l)) + } + if m.ConnectivitySupport != nil { + l = m.ConnectivitySupport.Size() + n += 2 + l + sovRan(uint64(l)) + } + if len(m.NeighborInformationNrs) > 0 { + for _, e := range m.NeighborInformationNrs { + l = e.Size() + n += 2 + l + sovRan(uint64(l)) + } + } + return n +} + +func (m *E2Cell_FddInfo) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.FddInfo != nil { + l = m.FddInfo.Size() + n += 1 + l + sovRan(uint64(l)) + } + return n +} +func (m *E2Cell_TddInfo) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.TddInfo != nil { + l = m.TddInfo.Size() + n += 1 + l + sovRan(uint64(l)) + } + return n +} +func (m *ConnectivitySupport) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.EnDcSupport != 0 { + n += 1 + sovRan(uint64(m.EnDcSupport)) + } + return n +} + +func (m *FDDInfo) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.UlFreqInfo != nil { + l = m.UlFreqInfo.Size() + n += 1 + l + sovRan(uint64(l)) + } + if m.DlFreqInfo != nil { + l = m.DlFreqInfo.Size() + n += 1 + l + sovRan(uint64(l)) + } + if m.UlTransmissionBandwidth != nil { + l = m.UlTransmissionBandwidth.Size() + n += 1 + l + sovRan(uint64(l)) + } + if m.DlTransmissionBandwidth != nil { + l = m.DlTransmissionBandwidth.Size() + n += 1 + l + sovRan(uint64(l)) + } + return n +} + +func (m *TDDInfo) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.NrFreqInfo != nil { + l = m.NrFreqInfo.Size() + n += 1 + l + sovRan(uint64(l)) + } + if m.TransmissionBandwidth != nil { + l = m.TransmissionBandwidth.Size() + n += 1 + l + sovRan(uint64(l)) + } + return n +} + +func (m *FrequencyInfo) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.NrArfcn != 0 { + n += 1 + sovRan(uint64(m.NrArfcn)) + } + if m.FrequencyBandList != nil { + l = m.FrequencyBandList.Size() + n += 1 + l + sovRan(uint64(l)) + } + return n +} + +func (m *TransmissionBandwidth) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.NrScs != 0 { + n += 1 + sovRan(uint64(m.NrScs)) + } + if m.Nrb != 0 { + n += 1 + sovRan(uint64(m.Nrb)) + } + return n +} + +func (m *FrequencyBandList) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.FrequencyBandItems) > 0 { + for _, e := range m.FrequencyBandItems { + l = e.Size() + n += 1 + l + sovRan(uint64(l)) + } + } + return n +} + +func (m *FrequencyBandItem) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.NrFrequencyBand != 0 { + n += 1 + sovRan(uint64(m.NrFrequencyBand)) + } + return n +} + +func (m *GlobalNgRanNodeID) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.GlobalNgRanNodeId != nil { + n += m.GlobalNgRanNodeId.Size() + } + return n +} + +func (m *GlobalNgRanNodeID_GlobalGnbId) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.GlobalGnbId != nil { + l = m.GlobalGnbId.Size() + n += 1 + l + sovRan(uint64(l)) + } + return n +} +func (m *GlobalNgRanNodeID_GlobalNgEnbId) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.GlobalNgEnbId != nil { + l = m.GlobalNgEnbId.Size() + n += 1 + l + sovRan(uint64(l)) + } + return n +} +func (m *GlobalGnbID) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.PlmnId != 0 { + n += 1 + sovRan(uint64(m.PlmnId)) + } + if m.GnbId != 0 { + n += 1 + sovRan(uint64(m.GnbId)) + } + if m.GnbIdLen != 0 { + n += 1 + sovRan(uint64(m.GnbIdLen)) + } + return n +} + +func (m *GlobalNgEnbID) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.PlmnId != 0 { + n += 1 + sovRan(uint64(m.PlmnId)) + } + if m.NgEnbId != nil { + n += m.NgEnbId.Size() + } + return n +} + +func (m *GlobalNgEnbID_MacroNgEnbId) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + n += 1 + sovRan(uint64(m.MacroNgEnbId)) + return n +} +func (m *GlobalNgEnbID_ShortMacroNgEnbId) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + n += 1 + sovRan(uint64(m.ShortMacroNgEnbId)) + return n +} +func (m *GlobalNgEnbID_LongMacroNgEnbId) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + n += 1 + sovRan(uint64(m.LongMacroNgEnbId)) + return n +} +func (m *TaiSupportList) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.TaiSupportItems) > 0 { + for _, e := range m.TaiSupportItems { + l = e.Size() + n += 1 + l + sovRan(uint64(l)) + } + } + return n +} + +func (m *TaiSupportItem) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Tac != 0 { + n += 1 + sovRan(uint64(m.Tac)) + } + if len(m.BroadcastPlmns) > 0 { + for _, e := range m.BroadcastPlmns { + l = e.Size() + n += 1 + l + sovRan(uint64(l)) + } + } + return n +} + +func (m *XnBroadcastPlmn) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.PlmnId != 0 { + n += 1 + sovRan(uint64(m.PlmnId)) + } + if m.TaiSliceSupportList != nil { + l = m.TaiSliceSupportList.Size() + n += 1 + l + sovRan(uint64(l)) + } + return n +} + +func (m *TaiSliceSupportList) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.SliceSupportItems) > 0 { + for _, e := range m.SliceSupportItems { + l = e.Size() + n += 1 + l + sovRan(uint64(l)) + } + } + return n +} + +func (m *SliceSupportItem) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.SNssai != nil { + l = m.SNssai.Size() + n += 1 + l + sovRan(uint64(l)) + } + return n +} + +func (m *SNssai) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Sst != 0 { + n += 1 + sovRan(uint64(m.Sst)) + } + if m.Sd != 0 { + n += 1 + sovRan(uint64(m.Sd)) + } + return n +} + +func (m *AmfRegionInformation) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.GlobalAmfRegionInformationItems) > 0 { + for _, e := range m.GlobalAmfRegionInformationItems { + l = e.Size() + n += 1 + l + sovRan(uint64(l)) + } + } + return n +} + +func (m *GlobalAmfRegionInformationItem) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.PlmnId != 0 { + n += 1 + sovRan(uint64(m.PlmnId)) + } + if m.AmfRegionId != 0 { + n += 1 + sovRan(uint64(m.AmfRegionId)) + } + return n +} + +func (m *NeighborInformationNr) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Pci != 0 { + n += 1 + sovRan(uint64(m.Pci)) + } + if m.NrCgi != nil { + l = m.NrCgi.Size() + n += 1 + l + sovRan(uint64(l)) + } + if m.Tac != 0 { + n += 1 + sovRan(uint64(m.Tac)) + } + if m.NrModeInfo != nil { + n += m.NrModeInfo.Size() + } + if m.ConnectivitySupport != nil { + l = m.ConnectivitySupport.Size() + n += 1 + l + sovRan(uint64(l)) + } + if m.MeasurementTimingConfiguration != 0 { + n += 1 + sovRan(uint64(m.MeasurementTimingConfiguration)) + } + return n +} + +func (m *NeighborInformationNr_FddInfo) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.FddInfo != nil { + l = m.FddInfo.Size() + n += 1 + l + sovRan(uint64(l)) + } + return n +} +func (m *NeighborInformationNr_TddInfo) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.TddInfo != nil { + l = m.TddInfo.Size() + n += 1 + l + sovRan(uint64(l)) + } + return n +} +func (m *ServiceModelInfo) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.OID) + if l > 0 { + n += 1 + l + sovRan(uint64(l)) + } + l = len(m.Name) + if l > 0 { + n += 1 + l + sovRan(uint64(l)) + } + if len(m.RanFunctions) > 0 { + for _, e := range m.RanFunctions { + l = e.Size() + n += 1 + l + sovRan(uint64(l)) + } + } + if len(m.RanFunctionIDs) > 0 { + l = 0 + for _, e := range m.RanFunctionIDs { + l += sovRan(uint64(e)) + } + n += 1 + sovRan(uint64(l)) + l + } + return n +} + +func (m *RCRanFunction) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.ID) + if l > 0 { + n += 1 + l + sovRan(uint64(l)) + } + if len(m.ReportStyles) > 0 { + for _, e := range m.ReportStyles { + l = e.Size() + n += 1 + l + sovRan(uint64(l)) + } + } + if len(m.InsertStyles) > 0 { + for _, e := range m.InsertStyles { + l = e.Size() + n += 1 + l + sovRan(uint64(l)) + } + } + if len(m.EventTriggerStyles) > 0 { + for _, e := range m.EventTriggerStyles { + l = e.Size() + n += 1 + l + sovRan(uint64(l)) + } + } + if len(m.PolicyStyles) > 0 { + for _, e := range m.PolicyStyles { + l = e.Size() + n += 1 + l + sovRan(uint64(l)) + } + } + if len(m.ControlStyles) > 0 { + for _, e := range m.ControlStyles { + l = e.Size() + n += 1 + l + sovRan(uint64(l)) + } + } + return n +} + +func (m *MHORanFunction) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.ID) + if l > 0 { + n += 1 + l + sovRan(uint64(l)) + } + if len(m.ReportStyles) > 0 { + for _, e := range m.ReportStyles { + l = e.Size() + n += 1 + l + sovRan(uint64(l)) + } + } + return n +} + +func (m *CCCRanFunction) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.ID) + if l > 0 { + n += 1 + l + sovRan(uint64(l)) + } + if len(m.RanStructures) > 0 { + for _, e := range m.RanStructures { + l = e.Size() + n += 1 + l + sovRan(uint64(l)) + } + } + if len(m.CellsRanDefinition) > 0 { + for _, e := range m.CellsRanDefinition { + l = e.Size() + n += 1 + l + sovRan(uint64(l)) + } + } + return n +} + +func (m *KPMRanFunction) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.ID) + if l > 0 { + n += 1 + l + sovRan(uint64(l)) + } + if len(m.ReportStyles) > 0 { + for _, e := range m.ReportStyles { + l = e.Size() + n += 1 + l + sovRan(uint64(l)) + } + } + return n +} + +func (m *RSMRanFunction) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.ID) + if l > 0 { + n += 1 + l + sovRan(uint64(l)) + } + if len(m.RicSlicingNodeCapabilityList) > 0 { + for _, e := range m.RicSlicingNodeCapabilityList { + l = e.Size() + n += 1 + l + sovRan(uint64(l)) + } + } + return n +} + +func (m *RCEventTriggerStyle) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Name) + if l > 0 { + n += 1 + l + sovRan(uint64(l)) + } + if m.Type != 0 { + n += 1 + sovRan(uint64(m.Type)) + } + if m.FormatType != 0 { + n += 1 + sovRan(uint64(m.FormatType)) + } + return n +} + +func (m *RCReportStyle) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Name) + if l > 0 { + n += 1 + l + sovRan(uint64(l)) + } + if m.Type != 0 { + n += 1 + sovRan(uint64(m.Type)) + } + if len(m.RanParameters) > 0 { + for _, e := range m.RanParameters { + l = e.Size() + n += 1 + l + sovRan(uint64(l)) + } + } + return n +} + +func (m *RCInsertStyle) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Name) + if l > 0 { + n += 1 + l + sovRan(uint64(l)) + } + if m.Type != 0 { + n += 1 + sovRan(uint64(m.Type)) + } + if len(m.InsertIndications) > 0 { + for _, e := range m.InsertIndications { + l = e.Size() + n += 1 + l + sovRan(uint64(l)) + } + } + return n +} + +func (m *RCPolicyStyle) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Name) + if l > 0 { + n += 1 + l + sovRan(uint64(l)) + } + if m.Type != 0 { + n += 1 + sovRan(uint64(m.Type)) + } + if len(m.PolicyActions) > 0 { + for _, e := range m.PolicyActions { + l = e.Size() + n += 1 + l + sovRan(uint64(l)) + } + } + return n +} + +func (m *PolicyAction) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.ID != 0 { + n += 1 + sovRan(uint64(m.ID)) + } + l = len(m.Name) + if l > 0 { + n += 1 + l + sovRan(uint64(l)) + } + if len(m.PolicyActionRanParameters) > 0 { + for _, e := range m.PolicyActionRanParameters { + l = e.Size() + n += 1 + l + sovRan(uint64(l)) + } + } + if len(m.PolicyConditionRanParameters) > 0 { + for _, e := range m.PolicyConditionRanParameters { + l = e.Size() + n += 1 + l + sovRan(uint64(l)) + } + } + return n +} + +func (m *RCControlStyle) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Name) + if l > 0 { + n += 1 + l + sovRan(uint64(l)) + } + if m.Type != 0 { + n += 1 + sovRan(uint64(m.Type)) + } + if m.HeaderFormatType != 0 { + n += 1 + sovRan(uint64(m.HeaderFormatType)) + } + if m.MessageFormatType != 0 { + n += 1 + sovRan(uint64(m.MessageFormatType)) + } + if m.ControlOutcomeFormatType != 0 { + n += 1 + sovRan(uint64(m.ControlOutcomeFormatType)) + } + if len(m.ControlActions) > 0 { + for _, e := range m.ControlActions { + l = e.Size() + n += 1 + l + sovRan(uint64(l)) + } + } + return n +} + +func (m *ControlAction) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.ID != 0 { + n += 1 + sovRan(uint64(m.ID)) + } + l = len(m.Name) + if l > 0 { + n += 1 + l + sovRan(uint64(l)) + } + if len(m.RanParameters) > 0 { + for _, e := range m.RanParameters { + l = e.Size() + n += 1 + l + sovRan(uint64(l)) + } + } + return n +} + +func (m *InsertIndication) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.ID != 0 { + n += 1 + sovRan(uint64(m.ID)) + } + l = len(m.Name) + if l > 0 { + n += 1 + l + sovRan(uint64(l)) + } + if len(m.RanParameters) > 0 { + for _, e := range m.RanParameters { + l = e.Size() + n += 1 + l + sovRan(uint64(l)) + } + } + return n +} + +func (m *RANParameter) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.ID != 0 { + n += 1 + sovRan(uint64(m.ID)) + } + l = len(m.Name) + if l > 0 { + n += 1 + l + sovRan(uint64(l)) + } + return n +} + +func (m *RanconfigurationStructure) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Name) + if l > 0 { + n += 1 + l + sovRan(uint64(l)) + } + if len(m.Attribute) > 0 { + for _, e := range m.Attribute { + l = e.Size() + n += 1 + l + sovRan(uint64(l)) + } + } + return n +} + +func (m *Attribute) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Name) + if l > 0 { + n += 1 + l + sovRan(uint64(l)) + } + if m.RicServices != nil { + l = m.RicServices.Size() + n += 1 + l + sovRan(uint64(l)) + } + return n +} + +func (m *RICServices) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.EventTriggerStyles) > 0 { + for _, e := range m.EventTriggerStyles { + l = e.Size() + n += 1 + l + sovRan(uint64(l)) + } + } + if len(m.ReportStyles) > 0 { + for _, e := range m.ReportStyles { + l = e.Size() + n += 1 + l + sovRan(uint64(l)) + } + } + if len(m.InsertStyles) > 0 { + for _, e := range m.InsertStyles { + l = e.Size() + n += 1 + l + sovRan(uint64(l)) + } + } + if len(m.ControlStyles) > 0 { + for _, e := range m.ControlStyles { + l = e.Size() + n += 1 + l + sovRan(uint64(l)) + } + } + if len(m.PolicyStyles) > 0 { + for _, e := range m.PolicyStyles { + l = e.Size() + n += 1 + l + sovRan(uint64(l)) + } + } + return n +} + +func (m *CellsForRanfunctionDefinition) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.CellGlobalId != nil { + l = m.CellGlobalId.Size() + n += 1 + l + sovRan(uint64(l)) + } + if len(m.CellFunctionDefinition) > 0 { + for _, e := range m.CellFunctionDefinition { + l = e.Size() + n += 1 + l + sovRan(uint64(l)) + } + } + return n +} + +func (m *CellForRanfunctionDefinition) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Name) + if l > 0 { + n += 1 + l + sovRan(uint64(l)) + } + if len(m.Attribute) > 0 { + for _, e := range m.Attribute { + l = e.Size() + n += 1 + l + sovRan(uint64(l)) + } + } + return n +} + +func (m *CCCEventTriggerStyle) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Name) + if l > 0 { + n += 1 + l + sovRan(uint64(l)) + } + if m.Type != 0 { + n += 1 + sovRan(uint64(m.Type)) + } + if m.FormatType != 0 { + n += 1 + sovRan(uint64(m.FormatType)) + } + return n +} + +func (m *CCCReportStyle) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Name) + if l > 0 { + n += 1 + l + sovRan(uint64(l)) + } + if m.Type != 0 { + n += 1 + sovRan(uint64(m.Type)) + } + if len(m.EventTriggerStyleForReport) > 0 { + l = 0 + for _, e := range m.EventTriggerStyleForReport { + l += sovRan(uint64(e)) + } + n += 1 + sovRan(uint64(l)) + l + } + if m.ActionDefinitionFormatType != 0 { + n += 1 + sovRan(uint64(m.ActionDefinitionFormatType)) + } + if m.IndicationHeaderFormatType != 0 { + n += 1 + sovRan(uint64(m.IndicationHeaderFormatType)) + } + if m.IndicationMessageFormatType != 0 { + n += 1 + sovRan(uint64(m.IndicationMessageFormatType)) + } + return n +} + +func (m *CCCInsertStyle) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Value != nil { + l = m.Value.Size() + n += 1 + l + sovRan(uint64(l)) + } + return n +} + +func (m *CCCControlStyle) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Type != 0 { + n += 1 + sovRan(uint64(m.Type)) + } + l = len(m.Name) + if l > 0 { + n += 1 + l + sovRan(uint64(l)) + } + if m.ControlHeaderFormatType != 0 { + n += 1 + sovRan(uint64(m.ControlHeaderFormatType)) + } + if m.ControlMessageFormatType != 0 { + n += 1 + sovRan(uint64(m.ControlMessageFormatType)) + } + if m.RicProcessIdFormatType != 0 { + n += 1 + sovRan(uint64(m.RicProcessIdFormatType)) + } + if m.ControlOutcomeFormatType != 0 { + n += 1 + sovRan(uint64(m.ControlOutcomeFormatType)) + } + return n +} + +func (m *CCCPolicyStyle) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Value != nil { + l = m.Value.Size() + n += 1 + l + sovRan(uint64(l)) + } + return n +} + +func (m *Plmnidentity) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Value) + if l > 0 { + n += 1 + l + sovRan(uint64(l)) + } + return n +} + +func (m *Sst) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Value) + if l > 0 { + n += 1 + l + sovRan(uint64(l)) + } + return n +} + +func (m *Sd) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Value) + if l > 0 { + n += 1 + l + sovRan(uint64(l)) + } + return n +} + +func (m *SNSsai) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Sst != nil { + l = m.Sst.Size() + n += 1 + l + sovRan(uint64(l)) + } + if m.Sd != nil { + l = m.Sd.Size() + n += 1 + l + sovRan(uint64(l)) + } + return n +} + +func (m *RrmPolicyMember) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.PlmnId != nil { + l = m.PlmnId.Size() + n += 1 + l + sovRan(uint64(l)) + } + if m.Snssai != nil { + l = m.Snssai.Size() + n += 1 + l + sovRan(uint64(l)) + } + return n +} + +func (m *RrmPolicyMemberList) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.RrmPolicyMember) > 0 { + for _, e := range m.RrmPolicyMember { + l = e.Size() + n += 1 + l + sovRan(uint64(l)) + } + } + return n +} + +func (m *ORRmpolicyRatio) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.ResourceType != 0 { + n += 1 + sovRan(uint64(m.ResourceType)) + } + if m.SchedulerType != 0 { + n += 1 + sovRan(uint64(m.SchedulerType)) + } + if m.RrmPolicyMemberList != nil { + l = m.RrmPolicyMemberList.Size() + n += 1 + l + sovRan(uint64(l)) + } + if m.RrmPolicyMaxRatio != 0 { + n += 1 + sovRan(uint64(m.RrmPolicyMaxRatio)) + } + if m.RrmPolicyMinRatio != 0 { + n += 1 + sovRan(uint64(m.RrmPolicyMinRatio)) + } + if m.RrmPolicyDedicatedRatio != 0 { + n += 1 + sovRan(uint64(m.RrmPolicyDedicatedRatio)) + } + return n +} + +func (m *ConfigurationStructure) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.ChangeType != 0 { + n += 1 + sovRan(uint64(m.ChangeType)) + } + l = len(m.ConfigurationName) + if l > 0 { + n += 1 + l + sovRan(uint64(l)) + } + if m.PolicyRatio != nil { + l = m.PolicyRatio.Size() + n += 1 + l + sovRan(uint64(l)) + } + if m.OldPolicyRatio != nil { + l = m.OldPolicyRatio.Size() + n += 1 + l + sovRan(uint64(l)) + } + return n +} + +func (m *ConfigurationStructureList) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.ConfigurationStructure) > 0 { + for _, e := range m.ConfigurationStructure { + l = e.Size() + n += 1 + l + sovRan(uint64(l)) + } + } + return n +} + +func (m *KPMReportStyle) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Name) + if l > 0 { + n += 1 + l + sovRan(uint64(l)) + } + if m.Type != 0 { + n += 1 + sovRan(uint64(m.Type)) + } + if len(m.Measurements) > 0 { + for _, e := range m.Measurements { + l = e.Size() + n += 1 + l + sovRan(uint64(l)) + } + } + return n +} + +func (m *MHOReportStyle) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Name) + if l > 0 { + n += 1 + l + sovRan(uint64(l)) + } + if m.Type != 0 { + n += 1 + sovRan(uint64(m.Type)) + } + return n +} + +func (m *KPMMeasurement) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.ID) + if l > 0 { + n += 1 + l + sovRan(uint64(l)) + } + l = len(m.Name) + if l > 0 { + n += 1 + l + sovRan(uint64(l)) + } + return n +} + +func (m *RSMNodeSlicingCapabilityItem) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.MaxNumberOfSlicesDl != 0 { + n += 1 + sovRan(uint64(m.MaxNumberOfSlicesDl)) + } + if m.MaxNumberOfSlicesUl != 0 { + n += 1 + sovRan(uint64(m.MaxNumberOfSlicesUl)) + } + if m.SlicingType != 0 { + n += 1 + sovRan(uint64(m.SlicingType)) + } + if m.MaxNumberOfUesPerSlice != 0 { + n += 1 + sovRan(uint64(m.MaxNumberOfUesPerSlice)) + } + if len(m.SupportedConfig) > 0 { + for _, e := range m.SupportedConfig { + l = e.Size() + n += 1 + l + sovRan(uint64(l)) + } + } + return n +} + +func (m *RSMSupportedSlicingConfigItem) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.SlicingConfigType != 0 { + n += 1 + sovRan(uint64(m.SlicingConfigType)) + } + return n +} + +func (m *RSMSliceItemList) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.RsmSliceList) > 0 { + for _, e := range m.RsmSliceList { + l = e.Size() + n += 1 + l + sovRan(uint64(l)) + } + } + return n +} + +func (m *RSMSlicingItem) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.ID) + if l > 0 { + n += 1 + l + sovRan(uint64(l)) + } + l = len(m.SliceDesc) + if l > 0 { + n += 1 + l + sovRan(uint64(l)) + } + if m.SliceParameters != nil { + l = m.SliceParameters.Size() + n += 1 + l + sovRan(uint64(l)) + } + if m.SliceType != 0 { + n += 1 + sovRan(uint64(m.SliceType)) + } + if len(m.UeIdList) > 0 { + for _, e := range m.UeIdList { + l = e.Size() + n += 1 + l + sovRan(uint64(l)) + } + } + return n +} + +func (m *RSMSliceParameters) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.SchedulerType != 0 { + n += 1 + sovRan(uint64(m.SchedulerType)) + } + if m.Weight != 0 { + n += 1 + sovRan(uint64(m.Weight)) + } + if m.QosLevel != 0 { + n += 1 + sovRan(uint64(m.QosLevel)) + } + return n +} + +func (m *DuUeF1ApID) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Value != 0 { + n += 1 + sovRan(uint64(m.Value)) + } + return n +} + +func (m *CuUeF1ApID) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Value != 0 { + n += 1 + sovRan(uint64(m.Value)) + } + return n +} + +func (m *RanUeNgapID) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Value != 0 { + n += 1 + sovRan(uint64(m.Value)) + } + return n +} + +func (m *EnbUeS1ApID) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Value != 0 { + n += 1 + sovRan(uint64(m.Value)) + } + return n +} + +func (m *AmfUeNgapID) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Value != 0 { + n += 1 + sovRan(uint64(m.Value)) + } + return n +} + +func (m *UeIdentity) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.DuUeF1apID != nil { + l = m.DuUeF1apID.Size() + n += 1 + l + sovRan(uint64(l)) + } + if m.CuUeF1apID != nil { + l = m.CuUeF1apID.Size() + n += 1 + l + sovRan(uint64(l)) + } + if m.RANUeNgapID != nil { + l = m.RANUeNgapID.Size() + n += 1 + l + sovRan(uint64(l)) + } + if m.EnbUeS1apID != nil { + l = m.EnbUeS1apID.Size() + n += 1 + l + sovRan(uint64(l)) + } + if m.AMFUeNgapID != nil { + l = m.AMFUeNgapID.Size() + n += 1 + l + sovRan(uint64(l)) + } + if m.PreferredIDType != 0 { + n += 1 + sovRan(uint64(m.PreferredIDType)) + } + if m.DrbId != nil { + l = m.DrbId.Size() + n += 1 + l + sovRan(uint64(l)) + } + return n +} + +func (m *DrbId) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.DrbId != nil { + n += m.DrbId.Size() + } + return n +} + +func (m *DrbId_FourGdrbId) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.FourGdrbId != nil { + l = m.FourGdrbId.Size() + n += 1 + l + sovRan(uint64(l)) + } + return n +} +func (m *DrbId_FiveGdrbId) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.FiveGdrbId != nil { + l = m.FiveGdrbId.Size() + n += 1 + l + sovRan(uint64(l)) + } + return n +} +func (m *FiveGDrbId) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Value != 0 { + n += 1 + sovRan(uint64(m.Value)) + } + if m.Qfi != nil { + l = m.Qfi.Size() + n += 1 + l + sovRan(uint64(l)) + } + if len(m.FlowsMapToDrb) > 0 { + for _, e := range m.FlowsMapToDrb { + l = e.Size() + n += 1 + l + sovRan(uint64(l)) + } + } + return n +} + +func (m *Qfi) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Value != 0 { + n += 1 + sovRan(uint64(m.Value)) + } + return n +} + +func (m *QoSflowLevelParameters) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.QosFlowLevelParameters != nil { + n += m.QosFlowLevelParameters.Size() + } + return n +} + +func (m *QoSflowLevelParameters_DynamicFiveQi) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.DynamicFiveQi != nil { + l = m.DynamicFiveQi.Size() + n += 1 + l + sovRan(uint64(l)) + } + return n +} +func (m *QoSflowLevelParameters_NonDynamicFiveQi) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.NonDynamicFiveQi != nil { + l = m.NonDynamicFiveQi.Size() + n += 1 + l + sovRan(uint64(l)) + } + return n +} +func (m *DynamicFiveQi) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.PriorityLevel != 0 { + n += 1 + sovRan(uint64(m.PriorityLevel)) + } + if m.PacketDelayBudge != 0 { + n += 1 + sovRan(uint64(m.PacketDelayBudge)) + } + if m.PacketErrorRate != 0 { + n += 1 + sovRan(uint64(m.PacketErrorRate)) + } + return n +} + +func (m *NonDynamicFiveQi) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.FiveQi != nil { + l = m.FiveQi.Size() + n += 1 + l + sovRan(uint64(l)) + } + return n +} + +func (m *FiveQi) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Value != 0 { + n += 1 + sovRan(uint64(m.Value)) + } + return n +} + +func (m *FourGDrbId) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Value != 0 { + n += 1 + sovRan(uint64(m.Value)) + } + if m.Qci != nil { + l = m.Qci.Size() + n += 1 + l + sovRan(uint64(l)) + } + return n +} + +func (m *Qci) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Value != 0 { + n += 1 + sovRan(uint64(m.Value)) + } + return n +} + +func sovRan(x uint64) (n int) { + return (math_bits.Len64(x|1) + 6) / 7 +} +func sozRan(x uint64) (n int) { + return sovRan(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (m *Location) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRan + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: Location: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Location: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field Lat", wireType) + } + var v uint64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:])) + iNdEx += 8 + m.Lat = float64(math.Float64frombits(v)) + case 2: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field Lng", wireType) + } + var v uint64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:])) + iNdEx += 8 + m.Lng = float64(math.Float64frombits(v)) + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Wgs84", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRan + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthRan + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthRan + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + v := &Wgs84Location{} + if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Ext = &Location_Wgs84{v} + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Cartesian", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRan + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthRan + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthRan + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + v := &CartesianLocation{} + if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Ext = &Location_Cartesian{v} + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipRan(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthRan + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *Wgs84Location) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRan + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: Wgs84Location: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Wgs84Location: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field LatitudeDeg", wireType) + } + var v uint64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:])) + iNdEx += 8 + m.LatitudeDeg = float64(math.Float64frombits(v)) + case 2: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field LongitudeDeg", wireType) + } + var v uint64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:])) + iNdEx += 8 + m.LongitudeDeg = float64(math.Float64frombits(v)) + case 3: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field AltitudeM", wireType) + } + var v uint64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:])) + iNdEx += 8 + m.AltitudeM = float64(math.Float64frombits(v)) + default: + iNdEx = preIndex + skippy, err := skipRan(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthRan + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *CartesianLocation) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRan + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: CartesianLocation: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: CartesianLocation: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field XM", wireType) + } + var v uint64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:])) + iNdEx += 8 + m.XM = float64(math.Float64frombits(v)) + case 2: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field YM", wireType) + } + var v uint64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:])) + iNdEx += 8 + m.YM = float64(math.Float64frombits(v)) + case 3: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field ZM", wireType) + } + var v uint64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:])) + iNdEx += 8 + m.ZM = float64(math.Float64frombits(v)) + default: + iNdEx = preIndex + skippy, err := skipRan(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthRan + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *AzElOrientation) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRan + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: AzElOrientation: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: AzElOrientation: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field AzimuthDeg", wireType) + } + var v uint64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:])) + iNdEx += 8 + m.AzimuthDeg = float64(math.Float64frombits(v)) + case 2: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field ElevationDeg", wireType) + } + var v uint64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:])) + iNdEx += 8 + m.ElevationDeg = float64(math.Float64frombits(v)) + case 3: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field RotationDeg", wireType) + } + var v uint64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:])) + iNdEx += 8 + m.RotationDeg = float64(math.Float64frombits(v)) + default: + iNdEx = preIndex + skippy, err := skipRan(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthRan + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *YprOrientation) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRan + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: YprOrientation: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: YprOrientation: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field YawDeg", wireType) + } + var v uint64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:])) + iNdEx += 8 + m.YawDeg = float64(math.Float64frombits(v)) + case 2: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field PitchDeg", wireType) + } + var v uint64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:])) + iNdEx += 8 + m.PitchDeg = float64(math.Float64frombits(v)) + case 3: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field RollDeg", wireType) + } + var v uint64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:])) + iNdEx += 8 + m.RollDeg = float64(math.Float64frombits(v)) + default: + iNdEx = preIndex + skippy, err := skipRan(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthRan + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *Orientation) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRan + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: Orientation: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Orientation: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Azel", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRan + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthRan + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthRan + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + v := &AzElOrientation{} + if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Orientation = &Orientation_Azel{v} + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Ypr", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRan + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthRan + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthRan + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + v := &YprOrientation{} + if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Orientation = &Orientation_Ypr{v} + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipRan(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthRan + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *Waypoint) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRan + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: Waypoint: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Waypoint: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Time", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRan + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthRan + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthRan + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Time == nil { + m.Time = &types.Timestamp{} + } + if err := m.Time.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Location", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRan + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthRan + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthRan + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Location == nil { + m.Location = &Location{} + } + if err := m.Location.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipRan(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthRan + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *Waypoints) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRan + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: Waypoints: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Waypoints: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Waypoint", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRan + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthRan + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthRan + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Waypoint = append(m.Waypoint, &Waypoint{}) + if err := m.Waypoint[len(m.Waypoint)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipRan(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthRan + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *OrbitData) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRan + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: OrbitData: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: OrbitData: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Epoch", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRan + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthRan + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthRan + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Epoch == nil { + m.Epoch = &types.Timestamp{} + } + if err := m.Epoch.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field InclinationDeg", wireType) + } + var v uint64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:])) + iNdEx += 8 + m.InclinationDeg = float64(math.Float64frombits(v)) + case 3: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field RaanDeg", wireType) + } + var v uint64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:])) + iNdEx += 8 + m.RaanDeg = float64(math.Float64frombits(v)) + case 4: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field E", wireType) + } + var v uint64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:])) + iNdEx += 8 + m.E = float64(math.Float64frombits(v)) + case 5: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field ArgumentDeg", wireType) + } + var v uint64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:])) + iNdEx += 8 + m.ArgumentDeg = float64(math.Float64frombits(v)) + case 6: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field AnomalyDeg", wireType) + } + var v uint64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:])) + iNdEx += 8 + m.AnomalyDeg = float64(math.Float64frombits(v)) + case 7: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field MeanMotion", wireType) + } + var v uint64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:])) + iNdEx += 8 + m.MeanMotion = float64(math.Float64frombits(v)) + default: + iNdEx = preIndex + skippy, err := skipRan(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthRan + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *Motion) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRan + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: Motion: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Motion: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field FixedLocation", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRan + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthRan + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthRan + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + v := &Location{} + if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Motion = &Motion_FixedLocation{v} + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Waypoints", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRan + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthRan + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthRan + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + v := &Waypoints{} + if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Motion = &Motion_Waypoints{v} + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Orbit", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRan + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthRan + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthRan + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + v := &OrbitData{} + if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Motion = &Motion_Orbit{v} + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipRan(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthRan + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *Coverage) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRan + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: Coverage: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Coverage: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Height", wireType) + } + m.Height = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRan + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Height |= int32(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field ArcWidth", wireType) + } + m.ArcWidth = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRan + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.ArcWidth |= int32(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Azimuth", wireType) + } + m.Azimuth = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRan + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Azimuth |= int32(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Tilt", wireType) + } + m.Tilt = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRan + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Tilt |= int32(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := skipRan(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthRan + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *E2Node) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRan + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: E2Node: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: E2Node: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ServiceModels", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRan + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthRan + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthRan + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.ServiceModels == nil { + m.ServiceModels = make(map[string]*ServiceModelInfo) + } + var mapkey string + var mapvalue *ServiceModelInfo + for iNdEx < postIndex { + entryPreIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRan + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + if fieldNum == 1 { + var stringLenmapkey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRan + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLenmapkey |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLenmapkey := int(stringLenmapkey) + if intStringLenmapkey < 0 { + return ErrInvalidLengthRan + } + postStringIndexmapkey := iNdEx + intStringLenmapkey + if postStringIndexmapkey < 0 { + return ErrInvalidLengthRan + } + if postStringIndexmapkey > l { + return io.ErrUnexpectedEOF + } + mapkey = string(dAtA[iNdEx:postStringIndexmapkey]) + iNdEx = postStringIndexmapkey + } else if fieldNum == 2 { + var mapmsglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRan + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + mapmsglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if mapmsglen < 0 { + return ErrInvalidLengthRan + } + postmsgIndex := iNdEx + mapmsglen + if postmsgIndex < 0 { + return ErrInvalidLengthRan + } + if postmsgIndex > l { + return io.ErrUnexpectedEOF + } + mapvalue = &ServiceModelInfo{} + if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil { + return err + } + iNdEx = postmsgIndex + } else { + iNdEx = entryPreIndex + skippy, err := skipRan(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthRan + } + if (iNdEx + skippy) > postIndex { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + m.ServiceModels[mapkey] = mapvalue + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipRan(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthRan + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *E2NodeConfig) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRan + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: E2NodeConfig: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: E2NodeConfig: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Connections", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRan + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthRan + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthRan + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Connections = append(m.Connections, Interface{}) + if err := m.Connections[len(m.Connections)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType) + } + m.Version = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRan + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Version |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := skipRan(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthRan + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *Lease) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRan + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: Lease: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Lease: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Expiration", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRan + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthRan + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthRan + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Expiration == nil { + m.Expiration = new(time.Time) + } + if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(m.Expiration, dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipRan(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthRan + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *Interface) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRan + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: Interface: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Interface: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType) + } + m.Type = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRan + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Type |= Interface_Type(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field IP", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRan + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthRan + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthRan + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.IP = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Port", wireType) + } + m.Port = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRan + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Port |= uint32(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := skipRan(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthRan + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *E2TInfo) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRan + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: E2TInfo: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: E2TInfo: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Interfaces", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRan + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthRan + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthRan + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Interfaces = append(m.Interfaces, &Interface{}) + if err := m.Interfaces[len(m.Interfaces)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipRan(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthRan + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *XAppInfo) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRan + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: XAppInfo: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: XAppInfo: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Interfaces", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRan + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthRan + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthRan + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Interfaces = append(m.Interfaces, &Interface{}) + if err := m.Interfaces[len(m.Interfaces)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field A1PolicyTypes", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRan + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthRan + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthRan + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.A1PolicyTypes = append(m.A1PolicyTypes, &A1PolicyType{}) + if err := m.A1PolicyTypes[len(m.A1PolicyTypes)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipRan(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthRan + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } -func (m *Qci) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.Value != 0 { - n += 1 + sovRan(uint64(m.Value)) + if iNdEx > l { + return io.ErrUnexpectedEOF } - return n -} - -func sovRan(x uint64) (n int) { - return (math_bits.Len64(x|1) + 6) / 7 -} -func sozRan(x uint64) (n int) { - return sovRan(uint64((x << 1) ^ uint64((int64(x) >> 63)))) + return nil } -func (m *Location) Unmarshal(dAtA []byte) error { +func (m *A1PolicyType) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -11449,39 +16028,81 @@ func (m *Location) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: Location: wiretype end group for non-group") + return fmt.Errorf("proto: A1PolicyType: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: Location: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: A1PolicyType: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: - if wireType != 1 { - return fmt.Errorf("proto: wrong wireType = %d for field Lat", wireType) + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType) } - var v uint64 - if (iNdEx + 8) > l { + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRan + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthRan + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthRan + } + if postIndex > l { return io.ErrUnexpectedEOF } - v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:])) - iNdEx += 8 - m.Lat = float64(math.Float64frombits(v)) + m.ID = PolicyTypeID(dAtA[iNdEx:postIndex]) + iNdEx = postIndex case 2: - if wireType != 1 { - return fmt.Errorf("proto: wrong wireType = %d for field Lng", wireType) + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) } - var v uint64 - if (iNdEx + 8) > l { + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRan + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthRan + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthRan + } + if postIndex > l { return io.ErrUnexpectedEOF } - v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:])) - iNdEx += 8 - m.Lng = float64(math.Float64frombits(v)) + m.Name = PolicyTypeName(dAtA[iNdEx:postIndex]) + iNdEx = postIndex case 3: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Wgs84", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType) } - var msglen int + var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRan @@ -11491,30 +16112,109 @@ func (m *Location) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= int(b&0x7F) << shift + stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } - if msglen < 0 { + intStringLen := int(stringLen) + if intStringLen < 0 { return ErrInvalidLengthRan } - postIndex := iNdEx + msglen + postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthRan } if postIndex > l { return io.ErrUnexpectedEOF } - v := &Wgs84Location{} - if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - m.Ext = &Location_Wgs84{v} + m.Version = PolicyTypeVersion(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 4: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Cartesian", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRan + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthRan + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthRan + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Description = PolicyTypeDescription(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipRan(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthRan + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *A1TInfo) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRan + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: A1TInfo: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: A1TInfo: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Interfaces", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -11541,11 +16241,10 @@ func (m *Location) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - v := &CartesianLocation{} - if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + m.Interfaces = append(m.Interfaces, &Interface{}) + if err := m.Interfaces[len(m.Interfaces)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } - m.Ext = &Location_Cartesian{v} iNdEx = postIndex default: iNdEx = preIndex @@ -11568,7 +16267,7 @@ func (m *Location) Unmarshal(dAtA []byte) error { } return nil } -func (m *Wgs84Location) Unmarshal(dAtA []byte) error { +func (m *CellGlobalID) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -11591,45 +16290,63 @@ func (m *Wgs84Location) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: Wgs84Location: wiretype end group for non-group") + return fmt.Errorf("proto: CellGlobalID: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: Wgs84Location: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: CellGlobalID: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: - if wireType != 1 { - return fmt.Errorf("proto: wrong wireType = %d for field LatitudeDeg", wireType) - } - var v uint64 - if (iNdEx + 8) > l { - return io.ErrUnexpectedEOF + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType) } - v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:])) - iNdEx += 8 - m.LatitudeDeg = float64(math.Float64frombits(v)) - case 2: - if wireType != 1 { - return fmt.Errorf("proto: wrong wireType = %d for field LongitudeDeg", wireType) + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRan + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } } - var v uint64 - if (iNdEx + 8) > l { - return io.ErrUnexpectedEOF + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthRan } - v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:])) - iNdEx += 8 - m.LongitudeDeg = float64(math.Float64frombits(v)) - case 3: - if wireType != 1 { - return fmt.Errorf("proto: wrong wireType = %d for field AltitudeM", wireType) + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthRan } - var v uint64 - if (iNdEx + 8) > l { + if postIndex > l { return io.ErrUnexpectedEOF } - v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:])) - iNdEx += 8 - m.AltitudeM = float64(math.Float64frombits(v)) + m.Value = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType) + } + m.Type = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRan + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Type |= CellGlobalIDType(b&0x7F) << shift + if b < 0x80 { + break + } + } default: iNdEx = preIndex skippy, err := skipRan(dAtA[iNdEx:]) @@ -11651,7 +16368,7 @@ func (m *Wgs84Location) Unmarshal(dAtA []byte) error { } return nil } -func (m *CartesianLocation) Unmarshal(dAtA []byte) error { +func (m *NeighborCellID) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -11674,45 +16391,80 @@ func (m *CartesianLocation) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: CartesianLocation: wiretype end group for non-group") + return fmt.Errorf("proto: NeighborCellID: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: CartesianLocation: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: NeighborCellID: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: - if wireType != 1 { - return fmt.Errorf("proto: wrong wireType = %d for field XM", wireType) + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field CellGlobalID", wireType) } - var v uint64 - if (iNdEx + 8) > l { + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRan + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthRan + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthRan + } + if postIndex > l { return io.ErrUnexpectedEOF } - v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:])) - iNdEx += 8 - m.XM = float64(math.Float64frombits(v)) + if m.CellGlobalID == nil { + m.CellGlobalID = &CellGlobalID{} + } + if err := m.CellGlobalID.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex case 2: - if wireType != 1 { - return fmt.Errorf("proto: wrong wireType = %d for field YM", wireType) + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field PlmnID", wireType) } - var v uint64 - if (iNdEx + 8) > l { - return io.ErrUnexpectedEOF + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRan + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } } - v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:])) - iNdEx += 8 - m.YM = float64(math.Float64frombits(v)) - case 3: - if wireType != 1 { - return fmt.Errorf("proto: wrong wireType = %d for field ZM", wireType) + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthRan } - var v uint64 - if (iNdEx + 8) > l { + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthRan + } + if postIndex > l { return io.ErrUnexpectedEOF } - v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:])) - iNdEx += 8 - m.ZM = float64(math.Float64frombits(v)) + m.PlmnID = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipRan(dAtA[iNdEx:]) @@ -11734,7 +16486,7 @@ func (m *CartesianLocation) Unmarshal(dAtA []byte) error { } return nil } -func (m *AzElOrientation) Unmarshal(dAtA []byte) error { +func (m *E2Cell) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -11757,181 +16509,452 @@ func (m *AzElOrientation) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: AzElOrientation: wiretype end group for non-group") + return fmt.Errorf("proto: E2Cell: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: AzElOrientation: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: E2Cell: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: - if wireType != 1 { - return fmt.Errorf("proto: wrong wireType = %d for field AzimuthDeg", wireType) + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field CellObjectID", wireType) } - var v uint64 - if (iNdEx + 8) > l { + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRan + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthRan + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthRan + } + if postIndex > l { return io.ErrUnexpectedEOF } - v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:])) - iNdEx += 8 - m.AzimuthDeg = float64(math.Float64frombits(v)) + m.CellObjectID = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex case 2: - if wireType != 1 { - return fmt.Errorf("proto: wrong wireType = %d for field ElevationDeg", wireType) + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field CellGlobalID", wireType) } - var v uint64 - if (iNdEx + 8) > l { + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRan + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthRan + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthRan + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.CellGlobalID == nil { + m.CellGlobalID = &CellGlobalID{} + } + if err := m.CellGlobalID.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field AntennaCount", wireType) + } + m.AntennaCount = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRan + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.AntennaCount |= uint32(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field ARFCN", wireType) + } + m.ARFCN = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRan + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.ARFCN |= uint32(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field CellType", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRan + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthRan + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthRan + } + if postIndex > l { return io.ErrUnexpectedEOF } - v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:])) - iNdEx += 8 - m.ElevationDeg = float64(math.Float64frombits(v)) - case 3: - if wireType != 1 { - return fmt.Errorf("proto: wrong wireType = %d for field RotationDeg", wireType) + m.CellType = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 6: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field PCI", wireType) } - var v uint64 - if (iNdEx + 8) > l { - return io.ErrUnexpectedEOF + m.PCI = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRan + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.PCI |= uint32(b&0x7F) << shift + if b < 0x80 { + break + } } - v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:])) - iNdEx += 8 - m.RotationDeg = float64(math.Float64frombits(v)) - default: - iNdEx = preIndex - skippy, err := skipRan(dAtA[iNdEx:]) - if err != nil { - return err + case 7: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field KpiReports", wireType) } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthRan + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRan + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF + if msglen < 0 { + return ErrInvalidLengthRan } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *YprOrientation) Unmarshal(dAtA []byte) error { - l := len(dAtA) - iNdEx := 0 - for iNdEx < l { - preIndex := iNdEx - var wire uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowRan + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthRan } - if iNdEx >= l { + if postIndex > l { return io.ErrUnexpectedEOF } - b := dAtA[iNdEx] - iNdEx++ - wire |= uint64(b&0x7F) << shift - if b < 0x80 { - break + if m.KpiReports == nil { + m.KpiReports = make(map[string]uint32) } - } - fieldNum := int32(wire >> 3) - wireType := int(wire & 0x7) - if wireType == 4 { - return fmt.Errorf("proto: YprOrientation: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: YprOrientation: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 1 { - return fmt.Errorf("proto: wrong wireType = %d for field YawDeg", wireType) + var mapkey string + var mapvalue uint32 + for iNdEx < postIndex { + entryPreIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRan + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + if fieldNum == 1 { + var stringLenmapkey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRan + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLenmapkey |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLenmapkey := int(stringLenmapkey) + if intStringLenmapkey < 0 { + return ErrInvalidLengthRan + } + postStringIndexmapkey := iNdEx + intStringLenmapkey + if postStringIndexmapkey < 0 { + return ErrInvalidLengthRan + } + if postStringIndexmapkey > l { + return io.ErrUnexpectedEOF + } + mapkey = string(dAtA[iNdEx:postStringIndexmapkey]) + iNdEx = postStringIndexmapkey + } else if fieldNum == 2 { + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRan + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + mapvalue |= uint32(b&0x7F) << shift + if b < 0x80 { + break + } + } + } else { + iNdEx = entryPreIndex + skippy, err := skipRan(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthRan + } + if (iNdEx + skippy) > postIndex { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } } - var v uint64 - if (iNdEx + 8) > l { - return io.ErrUnexpectedEOF + m.KpiReports[mapkey] = mapvalue + iNdEx = postIndex + case 8: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field NeighborCellIDs", wireType) } - v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:])) - iNdEx += 8 - m.YawDeg = float64(math.Float64frombits(v)) - case 2: - if wireType != 1 { - return fmt.Errorf("proto: wrong wireType = %d for field PitchDeg", wireType) + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRan + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } } - var v uint64 - if (iNdEx + 8) > l { - return io.ErrUnexpectedEOF + if msglen < 0 { + return ErrInvalidLengthRan } - v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:])) - iNdEx += 8 - m.PitchDeg = float64(math.Float64frombits(v)) - case 3: - if wireType != 1 { - return fmt.Errorf("proto: wrong wireType = %d for field RollDeg", wireType) + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthRan } - var v uint64 - if (iNdEx + 8) > l { + if postIndex > l { return io.ErrUnexpectedEOF } - v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:])) - iNdEx += 8 - m.RollDeg = float64(math.Float64frombits(v)) - default: - iNdEx = preIndex - skippy, err := skipRan(dAtA[iNdEx:]) - if err != nil { + m.NeighborCellIDs = append(m.NeighborCellIDs, &NeighborCellID{}) + if err := m.NeighborCellIDs[len(m.NeighborCellIDs)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthRan + iNdEx = postIndex + case 9: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field GnbDuId", wireType) + } + m.GnbDuId = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRan + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.GnbDuId |= uint32(b&0x7F) << shift + if b < 0x80 { + break + } } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF + case 10: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field LatestRrcVersion", wireType) } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *Orientation) Unmarshal(dAtA []byte) error { - l := len(dAtA) - iNdEx := 0 - for iNdEx < l { - preIndex := iNdEx - var wire uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowRan + m.LatestRrcVersion = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRan + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.LatestRrcVersion |= uint32(b&0x7F) << shift + if b < 0x80 { + break + } } - if iNdEx >= l { - return io.ErrUnexpectedEOF + case 11: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field PlmnId", wireType) } - b := dAtA[iNdEx] - iNdEx++ - wire |= uint64(b&0x7F) << shift - if b < 0x80 { - break + m.PlmnId = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRan + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.PlmnId |= uint32(b&0x7F) << shift + if b < 0x80 { + break + } } - } - fieldNum := int32(wire >> 3) - wireType := int(wire & 0x7) - if wireType == 4 { - return fmt.Errorf("proto: Orientation: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: Orientation: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: + case 12: + if wireType == 0 { + var v uint32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRan + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= uint32(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.ServedPlmns = append(m.ServedPlmns, v) + } else if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRan + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + packedLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return ErrInvalidLengthRan + } + postIndex := iNdEx + packedLen + if postIndex < 0 { + return ErrInvalidLengthRan + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + var elementCount int + var count int + for _, integer := range dAtA[iNdEx:postIndex] { + if integer < 128 { + count++ + } + } + elementCount = count + if elementCount != 0 && len(m.ServedPlmns) == 0 { + m.ServedPlmns = make([]uint32, 0, elementCount) + } + for iNdEx < postIndex { + var v uint32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRan + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= uint32(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.ServedPlmns = append(m.ServedPlmns, v) + } + } else { + return fmt.Errorf("proto: wrong wireType = %d for field ServedPlmns", wireType) + } + case 13: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Azel", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field FddInfo", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -11958,15 +16981,15 @@ func (m *Orientation) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - v := &AzElOrientation{} + v := &FDDInfo{} if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } - m.Orientation = &Orientation_Azel{v} + m.NrModeInfo = &E2Cell_FddInfo{v} iNdEx = postIndex - case 2: + case 14: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Ypr", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field TddInfo", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -11993,65 +17016,70 @@ func (m *Orientation) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - v := &YprOrientation{} + v := &TDDInfo{} if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } - m.Orientation = &Orientation_Ypr{v} + m.NrModeInfo = &E2Cell_TddInfo{v} iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipRan(dAtA[iNdEx:]) - if err != nil { - return err + case 15: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field MeasurementTimingConfiguration", wireType) } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthRan + m.MeasurementTimingConfiguration = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRan + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.MeasurementTimingConfiguration |= uint32(b&0x7F) << shift + if b < 0x80 { + break + } } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF + case 16: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field GlobalNgRanNodeId", wireType) } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *Waypoint) Unmarshal(dAtA []byte) error { - l := len(dAtA) - iNdEx := 0 - for iNdEx < l { - preIndex := iNdEx - var wire uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowRan + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRan + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } } - if iNdEx >= l { + if msglen < 0 { + return ErrInvalidLengthRan + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthRan + } + if postIndex > l { return io.ErrUnexpectedEOF } - b := dAtA[iNdEx] - iNdEx++ - wire |= uint64(b&0x7F) << shift - if b < 0x80 { - break + if m.GlobalNgRanNodeId == nil { + m.GlobalNgRanNodeId = &GlobalNgRanNodeID{} } - } - fieldNum := int32(wire >> 3) - wireType := int(wire & 0x7) - if wireType == 4 { - return fmt.Errorf("proto: Waypoint: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: Waypoint: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: + if err := m.GlobalNgRanNodeId.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 17: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Time", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field TaiSupportList", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -12078,16 +17106,16 @@ func (m *Waypoint) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.Time == nil { - m.Time = &types.Timestamp{} + if m.TaiSupportList == nil { + m.TaiSupportList = &TaiSupportList{} } - if err := m.Time.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if err := m.TaiSupportList.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex - case 2: + case 18: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Location", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field AmfRegionInformation", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -12114,66 +17142,52 @@ func (m *Waypoint) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.Location == nil { - m.Location = &Location{} + if m.AmfRegionInformation == nil { + m.AmfRegionInformation = &AmfRegionInformation{} } - if err := m.Location.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if err := m.AmfRegionInformation.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipRan(dAtA[iNdEx:]) - if err != nil { - return err + case 19: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ConnectivitySupport", wireType) } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthRan + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRan + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF + if msglen < 0 { + return ErrInvalidLengthRan } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *Waypoints) Unmarshal(dAtA []byte) error { - l := len(dAtA) - iNdEx := 0 - for iNdEx < l { - preIndex := iNdEx - var wire uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowRan + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthRan } - if iNdEx >= l { + if postIndex > l { return io.ErrUnexpectedEOF } - b := dAtA[iNdEx] - iNdEx++ - wire |= uint64(b&0x7F) << shift - if b < 0x80 { - break + if m.ConnectivitySupport == nil { + m.ConnectivitySupport = &ConnectivitySupport{} } - } - fieldNum := int32(wire >> 3) - wireType := int(wire & 0x7) - if wireType == 4 { - return fmt.Errorf("proto: Waypoints: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: Waypoints: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: + if err := m.ConnectivitySupport.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 20: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Waypoint", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field NeighborInformationNrs", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -12200,8 +17214,8 @@ func (m *Waypoints) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.Waypoint = append(m.Waypoint, &Waypoint{}) - if err := m.Waypoint[len(m.Waypoint)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + m.NeighborInformationNrs = append(m.NeighborInformationNrs, &NeighborInformationNr{}) + if err := m.NeighborInformationNrs[len(m.NeighborInformationNrs)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex @@ -12226,7 +17240,7 @@ func (m *Waypoints) Unmarshal(dAtA []byte) error { } return nil } -func (m *OrbitData) Unmarshal(dAtA []byte) error { +func (m *ConnectivitySupport) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -12249,17 +17263,17 @@ func (m *OrbitData) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: OrbitData: wiretype end group for non-group") + return fmt.Errorf("proto: ConnectivitySupport: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: OrbitData: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: ConnectivitySupport: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Epoch", wireType) + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field EnDcSupport", wireType) } - var msglen int + m.EnDcSupport = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRan @@ -12269,94 +17283,11 @@ func (m *OrbitData) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= int(b&0x7F) << shift + m.EnDcSupport |= EnDcSupport(b&0x7F) << shift if b < 0x80 { break } } - if msglen < 0 { - return ErrInvalidLengthRan - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthRan - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.Epoch == nil { - m.Epoch = &types.Timestamp{} - } - if err := m.Epoch.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 2: - if wireType != 1 { - return fmt.Errorf("proto: wrong wireType = %d for field InclinationDeg", wireType) - } - var v uint64 - if (iNdEx + 8) > l { - return io.ErrUnexpectedEOF - } - v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:])) - iNdEx += 8 - m.InclinationDeg = float64(math.Float64frombits(v)) - case 3: - if wireType != 1 { - return fmt.Errorf("proto: wrong wireType = %d for field RaanDeg", wireType) - } - var v uint64 - if (iNdEx + 8) > l { - return io.ErrUnexpectedEOF - } - v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:])) - iNdEx += 8 - m.RaanDeg = float64(math.Float64frombits(v)) - case 4: - if wireType != 1 { - return fmt.Errorf("proto: wrong wireType = %d for field E", wireType) - } - var v uint64 - if (iNdEx + 8) > l { - return io.ErrUnexpectedEOF - } - v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:])) - iNdEx += 8 - m.E = float64(math.Float64frombits(v)) - case 5: - if wireType != 1 { - return fmt.Errorf("proto: wrong wireType = %d for field ArgumentDeg", wireType) - } - var v uint64 - if (iNdEx + 8) > l { - return io.ErrUnexpectedEOF - } - v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:])) - iNdEx += 8 - m.ArgumentDeg = float64(math.Float64frombits(v)) - case 6: - if wireType != 1 { - return fmt.Errorf("proto: wrong wireType = %d for field AnomalyDeg", wireType) - } - var v uint64 - if (iNdEx + 8) > l { - return io.ErrUnexpectedEOF - } - v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:])) - iNdEx += 8 - m.AnomalyDeg = float64(math.Float64frombits(v)) - case 7: - if wireType != 1 { - return fmt.Errorf("proto: wrong wireType = %d for field MeanMotion", wireType) - } - var v uint64 - if (iNdEx + 8) > l { - return io.ErrUnexpectedEOF - } - v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:])) - iNdEx += 8 - m.MeanMotion = float64(math.Float64frombits(v)) default: iNdEx = preIndex skippy, err := skipRan(dAtA[iNdEx:]) @@ -12378,7 +17309,7 @@ func (m *OrbitData) Unmarshal(dAtA []byte) error { } return nil } -func (m *Motion) Unmarshal(dAtA []byte) error { +func (m *FDDInfo) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -12401,15 +17332,15 @@ func (m *Motion) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: Motion: wiretype end group for non-group") + return fmt.Errorf("proto: FDDInfo: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: Motion: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: FDDInfo: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field FixedLocation", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field UlFreqInfo", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -12436,15 +17367,16 @@ func (m *Motion) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - v := &Location{} - if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if m.UlFreqInfo == nil { + m.UlFreqInfo = &FrequencyInfo{} + } + if err := m.UlFreqInfo.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } - m.Motion = &Motion_FixedLocation{v} iNdEx = postIndex case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Waypoints", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field DlFreqInfo", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -12471,15 +17403,52 @@ func (m *Motion) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - v := &Waypoints{} - if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if m.DlFreqInfo == nil { + m.DlFreqInfo = &FrequencyInfo{} + } + if err := m.DlFreqInfo.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } - m.Motion = &Motion_Waypoints{v} iNdEx = postIndex case 3: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Orbit", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field UlTransmissionBandwidth", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRan + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthRan + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthRan + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.UlTransmissionBandwidth == nil { + m.UlTransmissionBandwidth = &TransmissionBandwidth{} + } + if err := m.UlTransmissionBandwidth.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field DlTransmissionBandwidth", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -12506,11 +17475,12 @@ func (m *Motion) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - v := &OrbitData{} - if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if m.DlTransmissionBandwidth == nil { + m.DlTransmissionBandwidth = &TransmissionBandwidth{} + } + if err := m.DlTransmissionBandwidth.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } - m.Motion = &Motion_Orbit{v} iNdEx = postIndex default: iNdEx = preIndex @@ -12533,7 +17503,7 @@ func (m *Motion) Unmarshal(dAtA []byte) error { } return nil } -func (m *Coverage) Unmarshal(dAtA []byte) error { +func (m *TDDInfo) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -12556,17 +17526,17 @@ func (m *Coverage) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: Coverage: wiretype end group for non-group") + return fmt.Errorf("proto: TDDInfo: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: Coverage: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: TDDInfo: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field Height", wireType) + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field NrFreqInfo", wireType) } - m.Height = 0 + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRan @@ -12576,16 +17546,33 @@ func (m *Coverage) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.Height |= int32(b&0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } } + if msglen < 0 { + return ErrInvalidLengthRan + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthRan + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.NrFreqInfo == nil { + m.NrFreqInfo = &FrequencyInfo{} + } + if err := m.NrFreqInfo.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex case 2: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field ArcWidth", wireType) + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field TransmissionBandwidth", wireType) } - m.ArcWidth = 0 + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRan @@ -12595,49 +17582,28 @@ func (m *Coverage) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.ArcWidth |= int32(b&0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } } - case 3: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field Azimuth", wireType) + if msglen < 0 { + return ErrInvalidLengthRan } - m.Azimuth = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowRan - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.Azimuth |= int32(b&0x7F) << shift - if b < 0x80 { - break - } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthRan } - case 4: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field Tilt", wireType) + if postIndex > l { + return io.ErrUnexpectedEOF } - m.Tilt = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowRan - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.Tilt |= int32(b&0x7F) << shift - if b < 0x80 { - break - } + if m.TransmissionBandwidth == nil { + m.TransmissionBandwidth = &TransmissionBandwidth{} + } + if err := m.TransmissionBandwidth.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err } + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipRan(dAtA[iNdEx:]) @@ -12659,7 +17625,7 @@ func (m *Coverage) Unmarshal(dAtA []byte) error { } return nil } -func (m *E2Node) Unmarshal(dAtA []byte) error { +func (m *FrequencyInfo) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -12682,15 +17648,34 @@ func (m *E2Node) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: E2Node: wiretype end group for non-group") + return fmt.Errorf("proto: FrequencyInfo: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: E2Node: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: FrequencyInfo: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field NrArfcn", wireType) + } + m.NrArfcn = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRan + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.NrArfcn |= uint32(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field ServiceModels", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field FrequencyBandList", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -12717,105 +17702,12 @@ func (m *E2Node) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.ServiceModels == nil { - m.ServiceModels = make(map[string]*ServiceModelInfo) + if m.FrequencyBandList == nil { + m.FrequencyBandList = &FrequencyBandList{} } - var mapkey string - var mapvalue *ServiceModelInfo - for iNdEx < postIndex { - entryPreIndex := iNdEx - var wire uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowRan - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - wire |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - fieldNum := int32(wire >> 3) - if fieldNum == 1 { - var stringLenmapkey uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowRan - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - stringLenmapkey |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - intStringLenmapkey := int(stringLenmapkey) - if intStringLenmapkey < 0 { - return ErrInvalidLengthRan - } - postStringIndexmapkey := iNdEx + intStringLenmapkey - if postStringIndexmapkey < 0 { - return ErrInvalidLengthRan - } - if postStringIndexmapkey > l { - return io.ErrUnexpectedEOF - } - mapkey = string(dAtA[iNdEx:postStringIndexmapkey]) - iNdEx = postStringIndexmapkey - } else if fieldNum == 2 { - var mapmsglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowRan - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - mapmsglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if mapmsglen < 0 { - return ErrInvalidLengthRan - } - postmsgIndex := iNdEx + mapmsglen - if postmsgIndex < 0 { - return ErrInvalidLengthRan - } - if postmsgIndex > l { - return io.ErrUnexpectedEOF - } - mapvalue = &ServiceModelInfo{} - if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil { - return err - } - iNdEx = postmsgIndex - } else { - iNdEx = entryPreIndex - skippy, err := skipRan(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthRan - } - if (iNdEx + skippy) > postIndex { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } + if err := m.FrequencyBandList.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err } - m.ServiceModels[mapkey] = mapvalue iNdEx = postIndex default: iNdEx = preIndex @@ -12838,7 +17730,7 @@ func (m *E2Node) Unmarshal(dAtA []byte) error { } return nil } -func (m *E2NodeConfig) Unmarshal(dAtA []byte) error { +func (m *TransmissionBandwidth) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -12861,17 +17753,17 @@ func (m *E2NodeConfig) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: E2NodeConfig: wiretype end group for non-group") + return fmt.Errorf("proto: TransmissionBandwidth: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: E2NodeConfig: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: TransmissionBandwidth: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Connections", wireType) + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field NrScs", wireType) } - var msglen int + m.NrScs = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRan @@ -12881,31 +17773,16 @@ func (m *E2NodeConfig) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= int(b&0x7F) << shift + m.NrScs |= NrScs(b&0x7F) << shift if b < 0x80 { break } } - if msglen < 0 { - return ErrInvalidLengthRan - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthRan - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.Connections = append(m.Connections, Interface{}) - if err := m.Connections[len(m.Connections)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex case 2: if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Nrb", wireType) } - m.Version = 0 + m.Nrb = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRan @@ -12915,7 +17792,7 @@ func (m *E2NodeConfig) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.Version |= uint64(b&0x7F) << shift + m.Nrb |= Nrb(b&0x7F) << shift if b < 0x80 { break } @@ -12941,7 +17818,7 @@ func (m *E2NodeConfig) Unmarshal(dAtA []byte) error { } return nil } -func (m *Lease) Unmarshal(dAtA []byte) error { +func (m *FrequencyBandList) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -12964,15 +17841,15 @@ func (m *Lease) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: Lease: wiretype end group for non-group") + return fmt.Errorf("proto: FrequencyBandList: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: Lease: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: FrequencyBandList: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Expiration", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field FrequencyBandItems", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -12999,10 +17876,8 @@ func (m *Lease) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.Expiration == nil { - m.Expiration = new(time.Time) - } - if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(m.Expiration, dAtA[iNdEx:postIndex]); err != nil { + m.FrequencyBandItems = append(m.FrequencyBandItems, &FrequencyBandItem{}) + if err := m.FrequencyBandItems[len(m.FrequencyBandItems)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex @@ -13027,7 +17902,7 @@ func (m *Lease) Unmarshal(dAtA []byte) error { } return nil } -func (m *Interface) Unmarshal(dAtA []byte) error { +func (m *FrequencyBandItem) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -13050,68 +17925,17 @@ func (m *Interface) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: Interface: wiretype end group for non-group") + return fmt.Errorf("proto: FrequencyBandItem: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: Interface: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: FrequencyBandItem: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType) - } - m.Type = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowRan - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.Type |= Interface_Type(b&0x7F) << shift - if b < 0x80 { - break - } - } - case 2: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field IP", wireType) - } - var stringLen uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowRan - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - stringLen |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - intStringLen := int(stringLen) - if intStringLen < 0 { - return ErrInvalidLengthRan - } - postIndex := iNdEx + intStringLen - if postIndex < 0 { - return ErrInvalidLengthRan - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.IP = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex - case 3: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field Port", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field NrFrequencyBand", wireType) } - m.Port = 0 + m.NrFrequencyBand = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRan @@ -13121,7 +17945,7 @@ func (m *Interface) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.Port |= uint32(b&0x7F) << shift + m.NrFrequencyBand |= uint32(b&0x7F) << shift if b < 0x80 { break } @@ -13147,7 +17971,7 @@ func (m *Interface) Unmarshal(dAtA []byte) error { } return nil } -func (m *E2TInfo) Unmarshal(dAtA []byte) error { +func (m *GlobalNgRanNodeID) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -13170,15 +17994,15 @@ func (m *E2TInfo) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: E2TInfo: wiretype end group for non-group") + return fmt.Errorf("proto: GlobalNgRanNodeID: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: E2TInfo: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: GlobalNgRanNodeID: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Interfaces", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field GlobalGnbId", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -13205,10 +18029,46 @@ func (m *E2TInfo) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.Interfaces = append(m.Interfaces, &Interface{}) - if err := m.Interfaces[len(m.Interfaces)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + v := &GlobalGnbID{} + if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.GlobalNgRanNodeId = &GlobalNgRanNodeID_GlobalGnbId{v} + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field GlobalNgEnbId", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRan + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthRan + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthRan + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + v := &GlobalNgEnbID{} + if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } + m.GlobalNgRanNodeId = &GlobalNgRanNodeID_GlobalNgEnbId{v} iNdEx = postIndex default: iNdEx = preIndex @@ -13231,7 +18091,7 @@ func (m *E2TInfo) Unmarshal(dAtA []byte) error { } return nil } -func (m *XAppInfo) Unmarshal(dAtA []byte) error { +func (m *GlobalGnbID) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -13254,17 +18114,17 @@ func (m *XAppInfo) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: XAppInfo: wiretype end group for non-group") + return fmt.Errorf("proto: GlobalGnbID: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: XAppInfo: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: GlobalGnbID: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Interfaces", wireType) + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field PlmnId", wireType) } - var msglen int + m.PlmnId = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRan @@ -13274,31 +18134,16 @@ func (m *XAppInfo) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= int(b&0x7F) << shift + m.PlmnId |= uint32(b&0x7F) << shift if b < 0x80 { break } } - if msglen < 0 { - return ErrInvalidLengthRan - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthRan - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.Interfaces = append(m.Interfaces, &Interface{}) - if err := m.Interfaces[len(m.Interfaces)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex case 2: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field A1PolicyTypes", wireType) + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field GnbId", wireType) } - var msglen int + m.GnbId = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRan @@ -13308,26 +18153,30 @@ func (m *XAppInfo) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= int(b&0x7F) << shift + m.GnbId |= uint32(b&0x7F) << shift if b < 0x80 { break } } - if msglen < 0 { - return ErrInvalidLengthRan - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthRan - } - if postIndex > l { - return io.ErrUnexpectedEOF + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field GnbIdLen", wireType) } - m.A1PolicyTypes = append(m.A1PolicyTypes, &A1PolicyType{}) - if err := m.A1PolicyTypes[len(m.A1PolicyTypes)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err + m.GnbIdLen = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRan + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.GnbIdLen |= uint32(b&0x7F) << shift + if b < 0x80 { + break + } } - iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipRan(dAtA[iNdEx:]) @@ -13349,7 +18198,7 @@ func (m *XAppInfo) Unmarshal(dAtA []byte) error { } return nil } -func (m *A1PolicyType) Unmarshal(dAtA []byte) error { +func (m *GlobalNgEnbID) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -13372,17 +18221,17 @@ func (m *A1PolicyType) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: A1PolicyType: wiretype end group for non-group") + return fmt.Errorf("proto: GlobalNgEnbID: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: A1PolicyType: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: GlobalNgEnbID: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType) + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field PlmnId", wireType) } - var stringLen uint64 + m.PlmnId = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRan @@ -13392,61 +18241,16 @@ func (m *A1PolicyType) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - stringLen |= uint64(b&0x7F) << shift + m.PlmnId |= uint32(b&0x7F) << shift if b < 0x80 { break } } - intStringLen := int(stringLen) - if intStringLen < 0 { - return ErrInvalidLengthRan - } - postIndex := iNdEx + intStringLen - if postIndex < 0 { - return ErrInvalidLengthRan - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.ID = PolicyTypeID(dAtA[iNdEx:postIndex]) - iNdEx = postIndex case 2: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) - } - var stringLen uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowRan - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - stringLen |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - intStringLen := int(stringLen) - if intStringLen < 0 { - return ErrInvalidLengthRan - } - postIndex := iNdEx + intStringLen - if postIndex < 0 { - return ErrInvalidLengthRan - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.Name = PolicyTypeName(dAtA[iNdEx:postIndex]) - iNdEx = postIndex - case 3: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType) + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field MacroNgEnbId", wireType) } - var stringLen uint64 + var v uint32 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRan @@ -13456,29 +18260,37 @@ func (m *A1PolicyType) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - stringLen |= uint64(b&0x7F) << shift + v |= uint32(b&0x7F) << shift if b < 0x80 { break } } - intStringLen := int(stringLen) - if intStringLen < 0 { - return ErrInvalidLengthRan - } - postIndex := iNdEx + intStringLen - if postIndex < 0 { - return ErrInvalidLengthRan + m.NgEnbId = &GlobalNgEnbID_MacroNgEnbId{v} + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field ShortMacroNgEnbId", wireType) } - if postIndex > l { - return io.ErrUnexpectedEOF + var v uint32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRan + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= uint32(b&0x7F) << shift + if b < 0x80 { + break + } } - m.Version = PolicyTypeVersion(dAtA[iNdEx:postIndex]) - iNdEx = postIndex + m.NgEnbId = &GlobalNgEnbID_ShortMacroNgEnbId{v} case 4: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType) + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field LongMacroNgEnbId", wireType) } - var stringLen uint64 + var v uint32 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRan @@ -13488,24 +18300,12 @@ func (m *A1PolicyType) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - stringLen |= uint64(b&0x7F) << shift + v |= uint32(b&0x7F) << shift if b < 0x80 { break } } - intStringLen := int(stringLen) - if intStringLen < 0 { - return ErrInvalidLengthRan - } - postIndex := iNdEx + intStringLen - if postIndex < 0 { - return ErrInvalidLengthRan - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.Description = PolicyTypeDescription(dAtA[iNdEx:postIndex]) - iNdEx = postIndex + m.NgEnbId = &GlobalNgEnbID_LongMacroNgEnbId{v} default: iNdEx = preIndex skippy, err := skipRan(dAtA[iNdEx:]) @@ -13527,7 +18327,7 @@ func (m *A1PolicyType) Unmarshal(dAtA []byte) error { } return nil } -func (m *A1TInfo) Unmarshal(dAtA []byte) error { +func (m *TaiSupportList) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -13550,15 +18350,15 @@ func (m *A1TInfo) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: A1TInfo: wiretype end group for non-group") + return fmt.Errorf("proto: TaiSupportList: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: A1TInfo: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: TaiSupportList: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Interfaces", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field TaiSupportItems", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -13585,8 +18385,8 @@ func (m *A1TInfo) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.Interfaces = append(m.Interfaces, &Interface{}) - if err := m.Interfaces[len(m.Interfaces)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + m.TaiSupportItems = append(m.TaiSupportItems, &TaiSupportItem{}) + if err := m.TaiSupportItems[len(m.TaiSupportItems)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex @@ -13611,7 +18411,7 @@ func (m *A1TInfo) Unmarshal(dAtA []byte) error { } return nil } -func (m *CellGlobalID) Unmarshal(dAtA []byte) error { +func (m *TaiSupportItem) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -13634,17 +18434,17 @@ func (m *CellGlobalID) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: CellGlobalID: wiretype end group for non-group") + return fmt.Errorf("proto: TaiSupportItem: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: CellGlobalID: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: TaiSupportItem: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType) + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Tac", wireType) } - var stringLen uint64 + m.Tac = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRan @@ -13654,29 +18454,16 @@ func (m *CellGlobalID) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - stringLen |= uint64(b&0x7F) << shift + m.Tac |= uint32(b&0x7F) << shift if b < 0x80 { break } } - intStringLen := int(stringLen) - if intStringLen < 0 { - return ErrInvalidLengthRan - } - postIndex := iNdEx + intStringLen - if postIndex < 0 { - return ErrInvalidLengthRan - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.Value = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex case 2: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType) + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BroadcastPlmns", wireType) } - m.Type = 0 + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRan @@ -13686,11 +18473,26 @@ func (m *CellGlobalID) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.Type |= CellGlobalIDType(b&0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } } + if msglen < 0 { + return ErrInvalidLengthRan + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthRan + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.BroadcastPlmns = append(m.BroadcastPlmns, &XnBroadcastPlmn{}) + if err := m.BroadcastPlmns[len(m.BroadcastPlmns)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipRan(dAtA[iNdEx:]) @@ -13712,7 +18514,7 @@ func (m *CellGlobalID) Unmarshal(dAtA []byte) error { } return nil } -func (m *NeighborCellID) Unmarshal(dAtA []byte) error { +func (m *XnBroadcastPlmn) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -13735,17 +18537,17 @@ func (m *NeighborCellID) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: NeighborCellID: wiretype end group for non-group") + return fmt.Errorf("proto: XnBroadcastPlmn: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: NeighborCellID: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: XnBroadcastPlmn: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field CellGlobalID", wireType) + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field PlmnId", wireType) } - var msglen int + m.PlmnId = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRan @@ -13755,33 +18557,16 @@ func (m *NeighborCellID) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= int(b&0x7F) << shift + m.PlmnId |= uint32(b&0x7F) << shift if b < 0x80 { break } } - if msglen < 0 { - return ErrInvalidLengthRan - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthRan - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.CellGlobalID == nil { - m.CellGlobalID = &CellGlobalID{} - } - if err := m.CellGlobalID.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field PlmnID", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field TaiSliceSupportList", wireType) } - var stringLen uint64 + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRan @@ -13791,23 +18576,27 @@ func (m *NeighborCellID) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - stringLen |= uint64(b&0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } } - intStringLen := int(stringLen) - if intStringLen < 0 { + if msglen < 0 { return ErrInvalidLengthRan } - postIndex := iNdEx + intStringLen + postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthRan } if postIndex > l { return io.ErrUnexpectedEOF } - m.PlmnID = string(dAtA[iNdEx:postIndex]) + if m.TaiSliceSupportList == nil { + m.TaiSliceSupportList = &TaiSliceSupportList{} + } + if err := m.TaiSliceSupportList.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } iNdEx = postIndex default: iNdEx = preIndex @@ -13830,7 +18619,7 @@ func (m *NeighborCellID) Unmarshal(dAtA []byte) error { } return nil } -func (m *E2Cell) Unmarshal(dAtA []byte) error { +func (m *TaiSliceSupportList) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -13853,47 +18642,15 @@ func (m *E2Cell) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: E2Cell: wiretype end group for non-group") + return fmt.Errorf("proto: TaiSliceSupportList: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: E2Cell: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: TaiSliceSupportList: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field CellObjectID", wireType) - } - var stringLen uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowRan - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - stringLen |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - intStringLen := int(stringLen) - if intStringLen < 0 { - return ErrInvalidLengthRan - } - postIndex := iNdEx + intStringLen - if postIndex < 0 { - return ErrInvalidLengthRan - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.CellObjectID = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex - case 2: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field CellGlobalID", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field SliceSupportItems", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -13920,56 +18677,66 @@ func (m *E2Cell) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.CellGlobalID == nil { - m.CellGlobalID = &CellGlobalID{} - } - if err := m.CellGlobalID.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + m.SliceSupportItems = append(m.SliceSupportItems, &SliceSupportItem{}) + if err := m.SliceSupportItems[len(m.SliceSupportItems)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex - case 3: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field AntennaCount", wireType) + default: + iNdEx = preIndex + skippy, err := skipRan(dAtA[iNdEx:]) + if err != nil { + return err } - m.AntennaCount = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowRan - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.AntennaCount |= uint32(b&0x7F) << shift - if b < 0x80 { - break - } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthRan + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *SliceSupportItem) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRan } - case 4: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field ARFCN", wireType) + if iNdEx >= l { + return io.ErrUnexpectedEOF } - m.ARFCN = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowRan - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.ARFCN |= uint32(b&0x7F) << shift - if b < 0x80 { - break - } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break } - case 5: + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: SliceSupportItem: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: SliceSupportItem: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field CellType", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field SNssai", wireType) } - var stringLen uint64 + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRan @@ -13979,29 +18746,83 @@ func (m *E2Cell) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - stringLen |= uint64(b&0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } } - intStringLen := int(stringLen) - if intStringLen < 0 { + if msglen < 0 { return ErrInvalidLengthRan } - postIndex := iNdEx + intStringLen + postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthRan } if postIndex > l { return io.ErrUnexpectedEOF } - m.CellType = string(dAtA[iNdEx:postIndex]) + if m.SNssai == nil { + m.SNssai = &SNssai{} + } + if err := m.SNssai.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } iNdEx = postIndex - case 6: + default: + iNdEx = preIndex + skippy, err := skipRan(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthRan + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *SNssai) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRan + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: SNssai: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: SNssai: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field PCI", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Sst", wireType) } - m.PCI = 0 + m.Sst = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRan @@ -14011,16 +18832,16 @@ func (m *E2Cell) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.PCI |= uint32(b&0x7F) << shift + m.Sst |= uint32(b&0x7F) << shift if b < 0x80 { break } } - case 7: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field KpiReports", wireType) + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Sd", wireType) } - var msglen int + m.Sd = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRan @@ -14030,108 +18851,64 @@ func (m *E2Cell) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= int(b&0x7F) << shift + m.Sd |= uint32(b&0x7F) << shift if b < 0x80 { break } } - if msglen < 0 { - return ErrInvalidLengthRan + default: + iNdEx = preIndex + skippy, err := skipRan(dAtA[iNdEx:]) + if err != nil { + return err } - postIndex := iNdEx + msglen - if postIndex < 0 { + if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthRan } - if postIndex > l { + if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } - if m.KpiReports == nil { - m.KpiReports = make(map[string]uint32) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *AmfRegionInformation) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRan } - var mapkey string - var mapvalue uint32 - for iNdEx < postIndex { - entryPreIndex := iNdEx - var wire uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowRan - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - wire |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - fieldNum := int32(wire >> 3) - if fieldNum == 1 { - var stringLenmapkey uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowRan - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - stringLenmapkey |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - intStringLenmapkey := int(stringLenmapkey) - if intStringLenmapkey < 0 { - return ErrInvalidLengthRan - } - postStringIndexmapkey := iNdEx + intStringLenmapkey - if postStringIndexmapkey < 0 { - return ErrInvalidLengthRan - } - if postStringIndexmapkey > l { - return io.ErrUnexpectedEOF - } - mapkey = string(dAtA[iNdEx:postStringIndexmapkey]) - iNdEx = postStringIndexmapkey - } else if fieldNum == 2 { - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowRan - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - mapvalue |= uint32(b&0x7F) << shift - if b < 0x80 { - break - } - } - } else { - iNdEx = entryPreIndex - skippy, err := skipRan(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthRan - } - if (iNdEx + skippy) > postIndex { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } + if iNdEx >= l { + return io.ErrUnexpectedEOF } - m.KpiReports[mapkey] = mapvalue - iNdEx = postIndex - case 8: + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: AmfRegionInformation: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: AmfRegionInformation: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field NeighborCellIDs", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field GlobalAmfRegionInformationItems", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -14158,50 +18935,62 @@ func (m *E2Cell) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.NeighborCellIDs = append(m.NeighborCellIDs, &NeighborCellID{}) - if err := m.NeighborCellIDs[len(m.NeighborCellIDs)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + m.GlobalAmfRegionInformationItems = append(m.GlobalAmfRegionInformationItems, &GlobalAmfRegionInformationItem{}) + if err := m.GlobalAmfRegionInformationItems[len(m.GlobalAmfRegionInformationItems)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex - case 9: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field GnbDuId", wireType) + default: + iNdEx = preIndex + skippy, err := skipRan(dAtA[iNdEx:]) + if err != nil { + return err } - m.GnbDuId = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowRan - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.GnbDuId |= uint32(b&0x7F) << shift - if b < 0x80 { - break - } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthRan } - case 10: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field LatestRrcVersion", wireType) + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF } - m.LatestRrcVersion = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowRan - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.LatestRrcVersion |= uint32(b&0x7F) << shift - if b < 0x80 { - break - } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *GlobalAmfRegionInformationItem) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRan } - case 11: + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: GlobalAmfRegionInformationItem: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: GlobalAmfRegionInformationItem: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field PlmnId", wireType) } @@ -14220,87 +19009,11 @@ func (m *E2Cell) Unmarshal(dAtA []byte) error { break } } - case 12: - if wireType == 0 { - var v uint32 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowRan - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - v |= uint32(b&0x7F) << shift - if b < 0x80 { - break - } - } - m.ServedPlmns = append(m.ServedPlmns, v) - } else if wireType == 2 { - var packedLen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowRan - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - packedLen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if packedLen < 0 { - return ErrInvalidLengthRan - } - postIndex := iNdEx + packedLen - if postIndex < 0 { - return ErrInvalidLengthRan - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - var elementCount int - var count int - for _, integer := range dAtA[iNdEx:postIndex] { - if integer < 128 { - count++ - } - } - elementCount = count - if elementCount != 0 && len(m.ServedPlmns) == 0 { - m.ServedPlmns = make([]uint32, 0, elementCount) - } - for iNdEx < postIndex { - var v uint32 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowRan - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - v |= uint32(b&0x7F) << shift - if b < 0x80 { - break - } - } - m.ServedPlmns = append(m.ServedPlmns, v) - } - } else { - return fmt.Errorf("proto: wrong wireType = %d for field ServedPlmns", wireType) - } - case 13: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field FddInfo", wireType) + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field AmfRegionId", wireType) } - var msglen int + m.AmfRegionId = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRan @@ -14310,67 +19023,66 @@ func (m *E2Cell) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= int(b&0x7F) << shift + m.AmfRegionId |= uint32(b&0x7F) << shift if b < 0x80 { break } } - if msglen < 0 { - return ErrInvalidLengthRan + default: + iNdEx = preIndex + skippy, err := skipRan(dAtA[iNdEx:]) + if err != nil { + return err } - postIndex := iNdEx + msglen - if postIndex < 0 { + if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthRan } - if postIndex > l { + if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } - v := &FDDInfo{} - if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - m.NrModeInfo = &E2Cell_FddInfo{v} - iNdEx = postIndex - case 14: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field TddInfo", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowRan - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthRan - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthRan + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *NeighborInformationNr) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRan } - if postIndex > l { + if iNdEx >= l { return io.ErrUnexpectedEOF } - v := &TDDInfo{} - if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break } - m.NrModeInfo = &E2Cell_TddInfo{v} - iNdEx = postIndex - case 15: + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: NeighborInformationNr: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: NeighborInformationNr: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field MeasurementTimingConfiguration", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Pci", wireType) } - m.MeasurementTimingConfiguration = 0 + m.Pci = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRan @@ -14380,14 +19092,14 @@ func (m *E2Cell) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.MeasurementTimingConfiguration |= uint32(b&0x7F) << shift + m.Pci |= uint32(b&0x7F) << shift if b < 0x80 { break } } - case 16: + case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field GlobalNgRanNodeId", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field NrCgi", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -14414,16 +19126,35 @@ func (m *E2Cell) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.GlobalNgRanNodeId == nil { - m.GlobalNgRanNodeId = &GlobalNgRanNodeID{} + if m.NrCgi == nil { + m.NrCgi = &NeighborCellID{} } - if err := m.GlobalNgRanNodeId.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if err := m.NrCgi.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex - case 17: + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Tac", wireType) + } + m.Tac = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRan + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Tac |= uint32(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 4: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field TaiSupportList", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field FddInfo", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -14450,16 +19181,15 @@ func (m *E2Cell) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.TaiSupportList == nil { - m.TaiSupportList = &TaiSupportList{} - } - if err := m.TaiSupportList.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + v := &FDDInfo{} + if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } + m.NrModeInfo = &NeighborInformationNr_FddInfo{v} iNdEx = postIndex - case 18: + case 5: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field AmfRegionInformation", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field TddInfo", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -14486,14 +19216,13 @@ func (m *E2Cell) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.AmfRegionInformation == nil { - m.AmfRegionInformation = &AmfRegionInformation{} - } - if err := m.AmfRegionInformation.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + v := &TDDInfo{} + if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } + m.NrModeInfo = &NeighborInformationNr_TddInfo{v} iNdEx = postIndex - case 19: + case 6: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field ConnectivitySupport", wireType) } @@ -14529,11 +19258,11 @@ func (m *E2Cell) Unmarshal(dAtA []byte) error { return err } iNdEx = postIndex - case 20: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field NeighborInformationNrs", wireType) + case 7: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field MeasurementTimingConfiguration", wireType) } - var msglen int + m.MeasurementTimingConfiguration = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRan @@ -14543,26 +19272,11 @@ func (m *E2Cell) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= int(b&0x7F) << shift + m.MeasurementTimingConfiguration |= uint32(b&0x7F) << shift if b < 0x80 { break } } - if msglen < 0 { - return ErrInvalidLengthRan - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthRan - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.NeighborInformationNrs = append(m.NeighborInformationNrs, &NeighborInformationNr{}) - if err := m.NeighborInformationNrs[len(m.NeighborInformationNrs)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipRan(dAtA[iNdEx:]) @@ -14584,7 +19298,7 @@ func (m *E2Cell) Unmarshal(dAtA []byte) error { } return nil } -func (m *ConnectivitySupport) Unmarshal(dAtA []byte) error { +func (m *ServiceModelInfo) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -14607,17 +19321,17 @@ func (m *ConnectivitySupport) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: ConnectivitySupport: wiretype end group for non-group") + return fmt.Errorf("proto: ServiceModelInfo: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: ConnectivitySupport: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: ServiceModelInfo: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field EnDcSupport", wireType) + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field OID", wireType) } - m.EnDcSupport = 0 + var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRan @@ -14627,11 +19341,166 @@ func (m *ConnectivitySupport) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.EnDcSupport |= EnDcSupport(b&0x7F) << shift + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthRan + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthRan + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.OID = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRan + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthRan + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthRan + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Name = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field RanFunctions", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRan + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift if b < 0x80 { break } } + if msglen < 0 { + return ErrInvalidLengthRan + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthRan + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.RanFunctions = append(m.RanFunctions, &types.Any{}) + if err := m.RanFunctions[len(m.RanFunctions)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType == 0 { + var v uint32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRan + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= uint32(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.RanFunctionIDs = append(m.RanFunctionIDs, v) + } else if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRan + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + packedLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return ErrInvalidLengthRan + } + postIndex := iNdEx + packedLen + if postIndex < 0 { + return ErrInvalidLengthRan + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + var elementCount int + var count int + for _, integer := range dAtA[iNdEx:postIndex] { + if integer < 128 { + count++ + } + } + elementCount = count + if elementCount != 0 && len(m.RanFunctionIDs) == 0 { + m.RanFunctionIDs = make([]uint32, 0, elementCount) + } + for iNdEx < postIndex { + var v uint32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRan + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= uint32(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.RanFunctionIDs = append(m.RanFunctionIDs, v) + } + } else { + return fmt.Errorf("proto: wrong wireType = %d for field RanFunctionIDs", wireType) + } default: iNdEx = preIndex skippy, err := skipRan(dAtA[iNdEx:]) @@ -14653,7 +19522,7 @@ func (m *ConnectivitySupport) Unmarshal(dAtA []byte) error { } return nil } -func (m *FDDInfo) Unmarshal(dAtA []byte) error { +func (m *RCRanFunction) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -14676,17 +19545,17 @@ func (m *FDDInfo) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: FDDInfo: wiretype end group for non-group") + return fmt.Errorf("proto: RCRanFunction: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: FDDInfo: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: RCRanFunction: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field UlFreqInfo", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType) } - var msglen int + var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRan @@ -14696,31 +19565,27 @@ func (m *FDDInfo) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= int(b&0x7F) << shift + stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } - if msglen < 0 { + intStringLen := int(stringLen) + if intStringLen < 0 { return ErrInvalidLengthRan } - postIndex := iNdEx + msglen + postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthRan } if postIndex > l { return io.ErrUnexpectedEOF } - if m.UlFreqInfo == nil { - m.UlFreqInfo = &FrequencyInfo{} - } - if err := m.UlFreqInfo.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } + m.ID = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field DlFreqInfo", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field ReportStyles", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -14747,16 +19612,14 @@ func (m *FDDInfo) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.DlFreqInfo == nil { - m.DlFreqInfo = &FrequencyInfo{} - } - if err := m.DlFreqInfo.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + m.ReportStyles = append(m.ReportStyles, &RCReportStyle{}) + if err := m.ReportStyles[len(m.ReportStyles)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 3: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field UlTransmissionBandwidth", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field InsertStyles", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -14783,16 +19646,14 @@ func (m *FDDInfo) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.UlTransmissionBandwidth == nil { - m.UlTransmissionBandwidth = &TransmissionBandwidth{} - } - if err := m.UlTransmissionBandwidth.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + m.InsertStyles = append(m.InsertStyles, &RCInsertStyle{}) + if err := m.InsertStyles[len(m.InsertStyles)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 4: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field DlTransmissionBandwidth", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field EventTriggerStyles", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -14819,66 +19680,14 @@ func (m *FDDInfo) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.DlTransmissionBandwidth == nil { - m.DlTransmissionBandwidth = &TransmissionBandwidth{} - } - if err := m.DlTransmissionBandwidth.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + m.EventTriggerStyles = append(m.EventTriggerStyles, &RCEventTriggerStyle{}) + if err := m.EventTriggerStyles[len(m.EventTriggerStyles)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipRan(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthRan - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *TDDInfo) Unmarshal(dAtA []byte) error { - l := len(dAtA) - iNdEx := 0 - for iNdEx < l { - preIndex := iNdEx - var wire uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowRan - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - wire |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - fieldNum := int32(wire >> 3) - wireType := int(wire & 0x7) - if wireType == 4 { - return fmt.Errorf("proto: TDDInfo: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: TDDInfo: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: + case 5: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field NrFreqInfo", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field PolicyStyles", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -14905,16 +19714,14 @@ func (m *TDDInfo) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.NrFreqInfo == nil { - m.NrFreqInfo = &FrequencyInfo{} - } - if err := m.NrFreqInfo.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + m.PolicyStyles = append(m.PolicyStyles, &RCPolicyStyle{}) + if err := m.PolicyStyles[len(m.PolicyStyles)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex - case 2: + case 6: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field TransmissionBandwidth", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field ControlStyles", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -14941,10 +19748,8 @@ func (m *TDDInfo) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.TransmissionBandwidth == nil { - m.TransmissionBandwidth = &TransmissionBandwidth{} - } - if err := m.TransmissionBandwidth.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + m.ControlStyles = append(m.ControlStyles, &RCControlStyle{}) + if err := m.ControlStyles[len(m.ControlStyles)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex @@ -14969,7 +19774,7 @@ func (m *TDDInfo) Unmarshal(dAtA []byte) error { } return nil } -func (m *FrequencyInfo) Unmarshal(dAtA []byte) error { +func (m *MHORanFunction) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -14992,17 +19797,17 @@ func (m *FrequencyInfo) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: FrequencyInfo: wiretype end group for non-group") + return fmt.Errorf("proto: MHORanFunction: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: FrequencyInfo: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: MHORanFunction: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field NrArfcn", wireType) + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType) } - m.NrArfcn = 0 + var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRan @@ -15012,14 +19817,27 @@ func (m *FrequencyInfo) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.NrArfcn |= uint32(b&0x7F) << shift + stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthRan + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthRan + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ID = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field FrequencyBandList", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field ReportStyles", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -15046,10 +19864,8 @@ func (m *FrequencyInfo) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.FrequencyBandList == nil { - m.FrequencyBandList = &FrequencyBandList{} - } - if err := m.FrequencyBandList.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + m.ReportStyles = append(m.ReportStyles, &MHOReportStyle{}) + if err := m.ReportStyles[len(m.ReportStyles)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex @@ -15074,7 +19890,7 @@ func (m *FrequencyInfo) Unmarshal(dAtA []byte) error { } return nil } -func (m *TransmissionBandwidth) Unmarshal(dAtA []byte) error { +func (m *CCCRanFunction) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -15097,17 +19913,17 @@ func (m *TransmissionBandwidth) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: TransmissionBandwidth: wiretype end group for non-group") + return fmt.Errorf("proto: CCCRanFunction: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: TransmissionBandwidth: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: CCCRanFunction: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field NrScs", wireType) + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType) } - m.NrScs = 0 + var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRan @@ -15117,16 +19933,29 @@ func (m *TransmissionBandwidth) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.NrScs |= NrScs(b&0x7F) << shift + stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthRan + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthRan + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ID = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex case 2: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field Nrb", wireType) + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field RanStructures", wireType) } - m.Nrb = 0 + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRan @@ -15136,11 +19965,60 @@ func (m *TransmissionBandwidth) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.Nrb |= Nrb(b&0x7F) << shift + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthRan + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthRan + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.RanStructures = append(m.RanStructures, &RanconfigurationStructure{}) + if err := m.RanStructures[len(m.RanStructures)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field CellsRanDefinition", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRan + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift if b < 0x80 { break } } + if msglen < 0 { + return ErrInvalidLengthRan + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthRan + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.CellsRanDefinition = append(m.CellsRanDefinition, &CellsForRanfunctionDefinition{}) + if err := m.CellsRanDefinition[len(m.CellsRanDefinition)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipRan(dAtA[iNdEx:]) @@ -15162,7 +20040,7 @@ func (m *TransmissionBandwidth) Unmarshal(dAtA []byte) error { } return nil } -func (m *FrequencyBandList) Unmarshal(dAtA []byte) error { +func (m *KPMRanFunction) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -15185,15 +20063,47 @@ func (m *FrequencyBandList) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: FrequencyBandList: wiretype end group for non-group") + return fmt.Errorf("proto: KPMRanFunction: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: FrequencyBandList: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: KPMRanFunction: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field FrequencyBandItems", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRan + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthRan + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthRan + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ID = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ReportStyles", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -15220,8 +20130,8 @@ func (m *FrequencyBandList) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.FrequencyBandItems = append(m.FrequencyBandItems, &FrequencyBandItem{}) - if err := m.FrequencyBandItems[len(m.FrequencyBandItems)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + m.ReportStyles = append(m.ReportStyles, &KPMReportStyle{}) + if err := m.ReportStyles[len(m.ReportStyles)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex @@ -15246,7 +20156,7 @@ func (m *FrequencyBandList) Unmarshal(dAtA []byte) error { } return nil } -func (m *FrequencyBandItem) Unmarshal(dAtA []byte) error { +func (m *RSMRanFunction) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -15269,17 +20179,17 @@ func (m *FrequencyBandItem) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: FrequencyBandItem: wiretype end group for non-group") + return fmt.Errorf("proto: RSMRanFunction: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: FrequencyBandItem: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: RSMRanFunction: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field NrFrequencyBand", wireType) + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType) } - m.NrFrequencyBand = 0 + var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRan @@ -15289,11 +20199,58 @@ func (m *FrequencyBandItem) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.NrFrequencyBand |= uint32(b&0x7F) << shift + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthRan + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthRan + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ID = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field RicSlicingNodeCapabilityList", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRan + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift if b < 0x80 { break } } + if msglen < 0 { + return ErrInvalidLengthRan + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthRan + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.RicSlicingNodeCapabilityList = append(m.RicSlicingNodeCapabilityList, &RSMNodeSlicingCapabilityItem{}) + if err := m.RicSlicingNodeCapabilityList[len(m.RicSlicingNodeCapabilityList)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipRan(dAtA[iNdEx:]) @@ -15315,7 +20272,7 @@ func (m *FrequencyBandItem) Unmarshal(dAtA []byte) error { } return nil } -func (m *GlobalNgRanNodeID) Unmarshal(dAtA []byte) error { +func (m *RCEventTriggerStyle) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -15338,17 +20295,17 @@ func (m *GlobalNgRanNodeID) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: GlobalNgRanNodeID: wiretype end group for non-group") + return fmt.Errorf("proto: RCEventTriggerStyle: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: GlobalNgRanNodeID: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: RCEventTriggerStyle: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field GlobalGnbId", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) } - var msglen int + var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRan @@ -15358,32 +20315,29 @@ func (m *GlobalNgRanNodeID) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= int(b&0x7F) << shift + stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } - if msglen < 0 { + intStringLen := int(stringLen) + if intStringLen < 0 { return ErrInvalidLengthRan } - postIndex := iNdEx + msglen + postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthRan } if postIndex > l { return io.ErrUnexpectedEOF } - v := &GlobalGnbID{} - if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - m.GlobalNgRanNodeId = &GlobalNgRanNodeID_GlobalGnbId{v} + m.Name = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field GlobalNgEnbId", wireType) + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType) } - var msglen int + m.Type = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRan @@ -15393,27 +20347,30 @@ func (m *GlobalNgRanNodeID) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= int(b&0x7F) << shift + m.Type |= int32(b&0x7F) << shift if b < 0x80 { break } } - if msglen < 0 { - return ErrInvalidLengthRan - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthRan - } - if postIndex > l { - return io.ErrUnexpectedEOF + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field FormatType", wireType) } - v := &GlobalNgEnbID{} - if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err + m.FormatType = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRan + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.FormatType |= int32(b&0x7F) << shift + if b < 0x80 { + break + } } - m.GlobalNgRanNodeId = &GlobalNgRanNodeID_GlobalNgEnbId{v} - iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipRan(dAtA[iNdEx:]) @@ -15435,7 +20392,7 @@ func (m *GlobalNgRanNodeID) Unmarshal(dAtA []byte) error { } return nil } -func (m *GlobalGnbID) Unmarshal(dAtA []byte) error { +func (m *RCReportStyle) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -15458,17 +20415,17 @@ func (m *GlobalGnbID) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: GlobalGnbID: wiretype end group for non-group") + return fmt.Errorf("proto: RCReportStyle: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: GlobalGnbID: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: RCReportStyle: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field PlmnId", wireType) + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) } - m.PlmnId = 0 + var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRan @@ -15478,16 +20435,29 @@ func (m *GlobalGnbID) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.PlmnId |= uint32(b&0x7F) << shift + stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthRan + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthRan + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Name = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex case 2: if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field GnbId", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType) } - m.GnbId = 0 + m.Type = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRan @@ -15497,16 +20467,16 @@ func (m *GlobalGnbID) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.GnbId |= uint32(b&0x7F) << shift + m.Type |= int32(b&0x7F) << shift if b < 0x80 { break } } case 3: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field GnbIdLen", wireType) + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field RanParameters", wireType) } - m.GnbIdLen = 0 + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRan @@ -15516,11 +20486,26 @@ func (m *GlobalGnbID) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.GnbIdLen |= uint32(b&0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } } + if msglen < 0 { + return ErrInvalidLengthRan + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthRan + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.RanParameters = append(m.RanParameters, &RANParameter{}) + if err := m.RanParameters[len(m.RanParameters)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipRan(dAtA[iNdEx:]) @@ -15542,7 +20527,7 @@ func (m *GlobalGnbID) Unmarshal(dAtA []byte) error { } return nil } -func (m *GlobalNgEnbID) Unmarshal(dAtA []byte) error { +func (m *RCInsertStyle) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -15565,17 +20550,17 @@ func (m *GlobalNgEnbID) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: GlobalNgEnbID: wiretype end group for non-group") + return fmt.Errorf("proto: RCInsertStyle: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: GlobalNgEnbID: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: RCInsertStyle: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field PlmnId", wireType) + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) } - m.PlmnId = 0 + var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRan @@ -15585,36 +20570,29 @@ func (m *GlobalNgEnbID) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.PlmnId |= uint32(b&0x7F) << shift + stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } - case 2: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field MacroNgEnbId", wireType) + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthRan } - var v uint32 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowRan - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - v |= uint32(b&0x7F) << shift - if b < 0x80 { - break - } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthRan } - m.NgEnbId = &GlobalNgEnbID_MacroNgEnbId{v} - case 3: + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Name = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field ShortMacroNgEnbId", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType) } - var v uint32 + m.Type = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRan @@ -15624,17 +20602,16 @@ func (m *GlobalNgEnbID) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - v |= uint32(b&0x7F) << shift + m.Type |= int32(b&0x7F) << shift if b < 0x80 { break } } - m.NgEnbId = &GlobalNgEnbID_ShortMacroNgEnbId{v} - case 4: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field LongMacroNgEnbId", wireType) + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field InsertIndications", wireType) } - var v uint32 + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRan @@ -15644,12 +20621,26 @@ func (m *GlobalNgEnbID) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - v |= uint32(b&0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } } - m.NgEnbId = &GlobalNgEnbID_LongMacroNgEnbId{v} + if msglen < 0 { + return ErrInvalidLengthRan + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthRan + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.InsertIndications = append(m.InsertIndications, &InsertIndication{}) + if err := m.InsertIndications[len(m.InsertIndications)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipRan(dAtA[iNdEx:]) @@ -15671,7 +20662,7 @@ func (m *GlobalNgEnbID) Unmarshal(dAtA []byte) error { } return nil } -func (m *TaiSupportList) Unmarshal(dAtA []byte) error { +func (m *RCPolicyStyle) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -15694,15 +20685,66 @@ func (m *TaiSupportList) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: TaiSupportList: wiretype end group for non-group") + return fmt.Errorf("proto: RCPolicyStyle: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: TaiSupportList: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: RCPolicyStyle: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field TaiSupportItems", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRan + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthRan + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthRan + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Name = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType) + } + m.Type = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRan + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Type |= int32(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field PolicyActions", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -15729,8 +20771,8 @@ func (m *TaiSupportList) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.TaiSupportItems = append(m.TaiSupportItems, &TaiSupportItem{}) - if err := m.TaiSupportItems[len(m.TaiSupportItems)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + m.PolicyActions = append(m.PolicyActions, &PolicyAction{}) + if err := m.PolicyActions[len(m.PolicyActions)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex @@ -15755,7 +20797,7 @@ func (m *TaiSupportList) Unmarshal(dAtA []byte) error { } return nil } -func (m *TaiSupportItem) Unmarshal(dAtA []byte) error { +func (m *PolicyAction) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -15778,17 +20820,17 @@ func (m *TaiSupportItem) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: TaiSupportItem: wiretype end group for non-group") + return fmt.Errorf("proto: PolicyAction: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: TaiSupportItem: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: PolicyAction: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field Tac", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType) } - m.Tac = 0 + m.ID = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRan @@ -15798,14 +20840,46 @@ func (m *TaiSupportItem) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.Tac |= uint32(b&0x7F) << shift + m.ID |= int32(b&0x7F) << shift if b < 0x80 { break } } case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field BroadcastPlmns", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRan + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthRan + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthRan + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Name = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field PolicyActionRanParameters", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -15832,8 +20906,42 @@ func (m *TaiSupportItem) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.BroadcastPlmns = append(m.BroadcastPlmns, &XnBroadcastPlmn{}) - if err := m.BroadcastPlmns[len(m.BroadcastPlmns)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + m.PolicyActionRanParameters = append(m.PolicyActionRanParameters, &RANParameter{}) + if err := m.PolicyActionRanParameters[len(m.PolicyActionRanParameters)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field PolicyConditionRanParameters", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRan + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthRan + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthRan + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.PolicyConditionRanParameters = append(m.PolicyConditionRanParameters, &RANParameter{}) + if err := m.PolicyConditionRanParameters[len(m.PolicyConditionRanParameters)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex @@ -15858,7 +20966,7 @@ func (m *TaiSupportItem) Unmarshal(dAtA []byte) error { } return nil } -func (m *XnBroadcastPlmn) Unmarshal(dAtA []byte) error { +func (m *RCControlStyle) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -15881,17 +20989,106 @@ func (m *XnBroadcastPlmn) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: XnBroadcastPlmn: wiretype end group for non-group") + return fmt.Errorf("proto: RCControlStyle: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: XnBroadcastPlmn: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: RCControlStyle: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRan + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthRan + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthRan + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Name = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType) + } + m.Type = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRan + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Type |= int32(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field HeaderFormatType", wireType) + } + m.HeaderFormatType = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRan + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.HeaderFormatType |= int32(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field MessageFormatType", wireType) + } + m.MessageFormatType = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRan + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.MessageFormatType |= int32(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 5: if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field PlmnId", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field ControlOutcomeFormatType", wireType) } - m.PlmnId = 0 + m.ControlOutcomeFormatType = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRan @@ -15901,14 +21098,14 @@ func (m *XnBroadcastPlmn) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.PlmnId |= uint32(b&0x7F) << shift + m.ControlOutcomeFormatType |= int32(b&0x7F) << shift if b < 0x80 { break } } - case 2: + case 6: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field TaiSliceSupportList", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field ControlActions", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -15935,10 +21132,8 @@ func (m *XnBroadcastPlmn) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.TaiSliceSupportList == nil { - m.TaiSliceSupportList = &TaiSliceSupportList{} - } - if err := m.TaiSliceSupportList.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + m.ControlActions = append(m.ControlActions, &ControlAction{}) + if err := m.ControlActions[len(m.ControlActions)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex @@ -15963,7 +21158,7 @@ func (m *XnBroadcastPlmn) Unmarshal(dAtA []byte) error { } return nil } -func (m *TaiSliceSupportList) Unmarshal(dAtA []byte) error { +func (m *ControlAction) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -15986,15 +21181,66 @@ func (m *TaiSliceSupportList) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: TaiSliceSupportList: wiretype end group for non-group") + return fmt.Errorf("proto: ControlAction: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: TaiSliceSupportList: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: ControlAction: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType) + } + m.ID = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRan + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.ID |= int32(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field SliceSupportItems", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRan + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthRan + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthRan + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Name = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field RanParameters", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -16021,8 +21267,8 @@ func (m *TaiSliceSupportList) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.SliceSupportItems = append(m.SliceSupportItems, &SliceSupportItem{}) - if err := m.SliceSupportItems[len(m.SliceSupportItems)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + m.RanParameters = append(m.RanParameters, &RANParameter{}) + if err := m.RanParameters[len(m.RanParameters)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex @@ -16047,7 +21293,7 @@ func (m *TaiSliceSupportList) Unmarshal(dAtA []byte) error { } return nil } -func (m *SliceSupportItem) Unmarshal(dAtA []byte) error { +func (m *InsertIndication) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -16070,15 +21316,66 @@ func (m *SliceSupportItem) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: SliceSupportItem: wiretype end group for non-group") + return fmt.Errorf("proto: InsertIndication: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: SliceSupportItem: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: InsertIndication: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType) + } + m.ID = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRan + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.ID |= int32(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field SNssai", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRan + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthRan + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthRan + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Name = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field RanParameters", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -16105,10 +21402,8 @@ func (m *SliceSupportItem) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.SNssai == nil { - m.SNssai = &SNssai{} - } - if err := m.SNssai.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + m.RanParameters = append(m.RanParameters, &RANParameter{}) + if err := m.RanParameters[len(m.RanParameters)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex @@ -16133,7 +21428,7 @@ func (m *SliceSupportItem) Unmarshal(dAtA []byte) error { } return nil } -func (m *SNssai) Unmarshal(dAtA []byte) error { +func (m *RANParameter) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -16156,17 +21451,17 @@ func (m *SNssai) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: SNssai: wiretype end group for non-group") + return fmt.Errorf("proto: RANParameter: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: SNssai: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: RANParameter: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field Sst", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType) } - m.Sst = 0 + m.ID = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRan @@ -16176,16 +21471,16 @@ func (m *SNssai) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.Sst |= uint32(b&0x7F) << shift + m.ID |= int64(b&0x7F) << shift if b < 0x80 { break } } case 2: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field Sd", wireType) + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) } - m.Sd = 0 + var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRan @@ -16195,11 +21490,24 @@ func (m *SNssai) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.Sd |= uint32(b&0x7F) << shift + stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthRan + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthRan + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Name = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipRan(dAtA[iNdEx:]) @@ -16221,7 +21529,7 @@ func (m *SNssai) Unmarshal(dAtA []byte) error { } return nil } -func (m *AmfRegionInformation) Unmarshal(dAtA []byte) error { +func (m *RanconfigurationStructure) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -16244,15 +21552,47 @@ func (m *AmfRegionInformation) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: AmfRegionInformation: wiretype end group for non-group") + return fmt.Errorf("proto: RanconfigurationStructure: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: AmfRegionInformation: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: RanconfigurationStructure: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field GlobalAmfRegionInformationItems", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRan + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthRan + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthRan + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Name = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Attribute", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -16279,8 +21619,8 @@ func (m *AmfRegionInformation) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.GlobalAmfRegionInformationItems = append(m.GlobalAmfRegionInformationItems, &GlobalAmfRegionInformationItem{}) - if err := m.GlobalAmfRegionInformationItems[len(m.GlobalAmfRegionInformationItems)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + m.Attribute = append(m.Attribute, &Attribute{}) + if err := m.Attribute[len(m.Attribute)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex @@ -16305,7 +21645,7 @@ func (m *AmfRegionInformation) Unmarshal(dAtA []byte) error { } return nil } -func (m *GlobalAmfRegionInformationItem) Unmarshal(dAtA []byte) error { +func (m *Attribute) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -16328,17 +21668,17 @@ func (m *GlobalAmfRegionInformationItem) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: GlobalAmfRegionInformationItem: wiretype end group for non-group") + return fmt.Errorf("proto: Attribute: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: GlobalAmfRegionInformationItem: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: Attribute: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field PlmnId", wireType) + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) } - m.PlmnId = 0 + var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRan @@ -16348,16 +21688,29 @@ func (m *GlobalAmfRegionInformationItem) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.PlmnId |= uint32(b&0x7F) << shift + stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthRan + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthRan + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Name = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex case 2: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field AmfRegionId", wireType) + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field RicServices", wireType) } - m.AmfRegionId = 0 + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRan @@ -16367,11 +21720,28 @@ func (m *GlobalAmfRegionInformationItem) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.AmfRegionId |= uint32(b&0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } } + if msglen < 0 { + return ErrInvalidLengthRan + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthRan + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.RicServices == nil { + m.RicServices = &RICServices{} + } + if err := m.RicServices.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipRan(dAtA[iNdEx:]) @@ -16393,7 +21763,7 @@ func (m *GlobalAmfRegionInformationItem) Unmarshal(dAtA []byte) error { } return nil } -func (m *NeighborInformationNr) Unmarshal(dAtA []byte) error { +func (m *RICServices) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -16416,17 +21786,17 @@ func (m *NeighborInformationNr) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: NeighborInformationNr: wiretype end group for non-group") + return fmt.Errorf("proto: RICServices: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: NeighborInformationNr: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: RICServices: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field Pci", wireType) + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field EventTriggerStyles", wireType) } - m.Pci = 0 + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRan @@ -16436,14 +21806,29 @@ func (m *NeighborInformationNr) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.Pci |= uint32(b&0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } } + if msglen < 0 { + return ErrInvalidLengthRan + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthRan + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.EventTriggerStyles = append(m.EventTriggerStyles, &CCCEventTriggerStyle{}) + if err := m.EventTriggerStyles[len(m.EventTriggerStyles)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field NrCgi", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field ReportStyles", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -16470,35 +21855,14 @@ func (m *NeighborInformationNr) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.NrCgi == nil { - m.NrCgi = &NeighborCellID{} - } - if err := m.NrCgi.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + m.ReportStyles = append(m.ReportStyles, &CCCReportStyle{}) + if err := m.ReportStyles[len(m.ReportStyles)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 3: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field Tac", wireType) - } - m.Tac = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowRan - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.Tac |= uint32(b&0x7F) << shift - if b < 0x80 { - break - } - } - case 4: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field FddInfo", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field InsertStyles", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -16525,15 +21889,14 @@ func (m *NeighborInformationNr) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - v := &FDDInfo{} - if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + m.InsertStyles = append(m.InsertStyles, &CCCInsertStyle{}) + if err := m.InsertStyles[len(m.InsertStyles)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } - m.NrModeInfo = &NeighborInformationNr_FddInfo{v} iNdEx = postIndex - case 5: + case 4: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field TddInfo", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field ControlStyles", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -16560,15 +21923,14 @@ func (m *NeighborInformationNr) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - v := &TDDInfo{} - if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + m.ControlStyles = append(m.ControlStyles, &CCCControlStyle{}) + if err := m.ControlStyles[len(m.ControlStyles)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } - m.NrModeInfo = &NeighborInformationNr_TddInfo{v} iNdEx = postIndex - case 6: + case 5: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field ConnectivitySupport", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field PolicyStyles", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -16595,32 +21957,11 @@ func (m *NeighborInformationNr) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.ConnectivitySupport == nil { - m.ConnectivitySupport = &ConnectivitySupport{} - } - if err := m.ConnectivitySupport.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + m.PolicyStyles = append(m.PolicyStyles, &CCCPolicyStyle{}) + if err := m.PolicyStyles[len(m.PolicyStyles)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex - case 7: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field MeasurementTimingConfiguration", wireType) - } - m.MeasurementTimingConfiguration = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowRan - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.MeasurementTimingConfiguration |= uint32(b&0x7F) << shift - if b < 0x80 { - break - } - } default: iNdEx = preIndex skippy, err := skipRan(dAtA[iNdEx:]) @@ -16642,7 +21983,7 @@ func (m *NeighborInformationNr) Unmarshal(dAtA []byte) error { } return nil } -func (m *ServiceModelInfo) Unmarshal(dAtA []byte) error { +func (m *CellsForRanfunctionDefinition) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -16665,17 +22006,17 @@ func (m *ServiceModelInfo) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: ServiceModelInfo: wiretype end group for non-group") + return fmt.Errorf("proto: CellsForRanfunctionDefinition: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: ServiceModelInfo: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: CellsForRanfunctionDefinition: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field OID", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field CellGlobalId", wireType) } - var stringLen uint64 + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRan @@ -16685,29 +22026,33 @@ func (m *ServiceModelInfo) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - stringLen |= uint64(b&0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } } - intStringLen := int(stringLen) - if intStringLen < 0 { + if msglen < 0 { return ErrInvalidLengthRan } - postIndex := iNdEx + intStringLen + postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthRan } if postIndex > l { return io.ErrUnexpectedEOF } - m.OID = string(dAtA[iNdEx:postIndex]) + if m.CellGlobalId == nil { + m.CellGlobalId = &CellGlobalID{} + } + if err := m.CellGlobalId.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } iNdEx = postIndex case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field CellFunctionDefinition", wireType) } - var stringLen uint64 + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRan @@ -16717,29 +22062,81 @@ func (m *ServiceModelInfo) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - stringLen |= uint64(b&0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } } - intStringLen := int(stringLen) - if intStringLen < 0 { + if msglen < 0 { return ErrInvalidLengthRan } - postIndex := iNdEx + intStringLen + postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthRan } if postIndex > l { return io.ErrUnexpectedEOF } - m.Name = string(dAtA[iNdEx:postIndex]) + m.CellFunctionDefinition = append(m.CellFunctionDefinition, &CellForRanfunctionDefinition{}) + if err := m.CellFunctionDefinition[len(m.CellFunctionDefinition)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } iNdEx = postIndex - case 3: + default: + iNdEx = preIndex + skippy, err := skipRan(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthRan + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *CellForRanfunctionDefinition) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRan + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: CellForRanfunctionDefinition: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: CellForRanfunctionDefinition: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field RanFunctions", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) } - var msglen int + var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRan @@ -16749,102 +22146,58 @@ func (m *ServiceModelInfo) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= int(b&0x7F) << shift + stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } - if msglen < 0 { + intStringLen := int(stringLen) + if intStringLen < 0 { return ErrInvalidLengthRan } - postIndex := iNdEx + msglen + postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthRan } if postIndex > l { return io.ErrUnexpectedEOF } - m.RanFunctions = append(m.RanFunctions, &types.Any{}) - if err := m.RanFunctions[len(m.RanFunctions)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } + m.Name = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex - case 4: - if wireType == 0 { - var v uint32 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowRan - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - v |= uint32(b&0x7F) << shift - if b < 0x80 { - break - } - } - m.RanFunctionIDs = append(m.RanFunctionIDs, v) - } else if wireType == 2 { - var packedLen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowRan - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - packedLen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if packedLen < 0 { - return ErrInvalidLengthRan - } - postIndex := iNdEx + packedLen - if postIndex < 0 { - return ErrInvalidLengthRan - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - var elementCount int - var count int - for _, integer := range dAtA[iNdEx:postIndex] { - if integer < 128 { - count++ - } + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Attribute", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRan } - elementCount = count - if elementCount != 0 && len(m.RanFunctionIDs) == 0 { - m.RanFunctionIDs = make([]uint32, 0, elementCount) + if iNdEx >= l { + return io.ErrUnexpectedEOF } - for iNdEx < postIndex { - var v uint32 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowRan - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - v |= uint32(b&0x7F) << shift - if b < 0x80 { - break - } - } - m.RanFunctionIDs = append(m.RanFunctionIDs, v) + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break } - } else { - return fmt.Errorf("proto: wrong wireType = %d for field RanFunctionIDs", wireType) } + if msglen < 0 { + return ErrInvalidLengthRan + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthRan + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Attribute = append(m.Attribute, &Attribute{}) + if err := m.Attribute[len(m.Attribute)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipRan(dAtA[iNdEx:]) @@ -16866,7 +22219,7 @@ func (m *ServiceModelInfo) Unmarshal(dAtA []byte) error { } return nil } -func (m *RCRanFunction) Unmarshal(dAtA []byte) error { +func (m *CCCEventTriggerStyle) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -16889,15 +22242,15 @@ func (m *RCRanFunction) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: RCRanFunction: wiretype end group for non-group") + return fmt.Errorf("proto: CCCEventTriggerStyle: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: RCRanFunction: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: CCCEventTriggerStyle: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -16925,13 +22278,13 @@ func (m *RCRanFunction) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.ID = string(dAtA[iNdEx:postIndex]) + m.Name = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field ReportStyles", wireType) + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType) } - var msglen int + m.Type = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRan @@ -16941,31 +22294,16 @@ func (m *RCRanFunction) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= int(b&0x7F) << shift + m.Type |= int32(b&0x7F) << shift if b < 0x80 { break } } - if msglen < 0 { - return ErrInvalidLengthRan - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthRan - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.ReportStyles = append(m.ReportStyles, &RCReportStyle{}) - if err := m.ReportStyles[len(m.ReportStyles)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex case 3: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field InsertStyles", wireType) + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field FormatType", wireType) } - var msglen int + m.FormatType = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRan @@ -16975,31 +22313,66 @@ func (m *RCRanFunction) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= int(b&0x7F) << shift + m.FormatType |= int32(b&0x7F) << shift if b < 0x80 { break } } - if msglen < 0 { - return ErrInvalidLengthRan + default: + iNdEx = preIndex + skippy, err := skipRan(dAtA[iNdEx:]) + if err != nil { + return err } - postIndex := iNdEx + msglen - if postIndex < 0 { + if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthRan } - if postIndex > l { + if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } - m.InsertStyles = append(m.InsertStyles, &RCInsertStyle{}) - if err := m.InsertStyles[len(m.InsertStyles)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *CCCReportStyle) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRan } - iNdEx = postIndex - case 4: + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: CCCReportStyle: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: CCCReportStyle: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field EventTriggerStyles", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) } - var msglen int + var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRan @@ -17009,31 +22382,29 @@ func (m *RCRanFunction) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= int(b&0x7F) << shift + stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } - if msglen < 0 { + intStringLen := int(stringLen) + if intStringLen < 0 { return ErrInvalidLengthRan } - postIndex := iNdEx + msglen + postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthRan } if postIndex > l { return io.ErrUnexpectedEOF } - m.EventTriggerStyles = append(m.EventTriggerStyles, &RCEventTriggerStyle{}) - if err := m.EventTriggerStyles[len(m.EventTriggerStyles)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } + m.Name = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex - case 5: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field PolicyStyles", wireType) + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType) } - var msglen int + m.Type = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRan @@ -17043,31 +22414,130 @@ func (m *RCRanFunction) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= int(b&0x7F) << shift + m.Type |= int32(b&0x7F) << shift if b < 0x80 { break } } - if msglen < 0 { - return ErrInvalidLengthRan + case 3: + if wireType == 0 { + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRan + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int32(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.EventTriggerStyleForReport = append(m.EventTriggerStyleForReport, v) + } else if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRan + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + packedLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return ErrInvalidLengthRan + } + postIndex := iNdEx + packedLen + if postIndex < 0 { + return ErrInvalidLengthRan + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + var elementCount int + var count int + for _, integer := range dAtA[iNdEx:postIndex] { + if integer < 128 { + count++ + } + } + elementCount = count + if elementCount != 0 && len(m.EventTriggerStyleForReport) == 0 { + m.EventTriggerStyleForReport = make([]int32, 0, elementCount) + } + for iNdEx < postIndex { + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRan + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int32(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.EventTriggerStyleForReport = append(m.EventTriggerStyleForReport, v) + } + } else { + return fmt.Errorf("proto: wrong wireType = %d for field EventTriggerStyleForReport", wireType) } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthRan + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field ActionDefinitionFormatType", wireType) } - if postIndex > l { - return io.ErrUnexpectedEOF + m.ActionDefinitionFormatType = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRan + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.ActionDefinitionFormatType |= int32(b&0x7F) << shift + if b < 0x80 { + break + } } - m.PolicyStyles = append(m.PolicyStyles, &RCPolicyStyle{}) - if err := m.PolicyStyles[len(m.PolicyStyles)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err + case 5: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field IndicationHeaderFormatType", wireType) + } + m.IndicationHeaderFormatType = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRan + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.IndicationHeaderFormatType |= int32(b&0x7F) << shift + if b < 0x80 { + break + } } - iNdEx = postIndex case 6: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field ControlStyles", wireType) + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field IndicationMessageFormatType", wireType) } - var msglen int + m.IndicationMessageFormatType = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRan @@ -17077,26 +22547,11 @@ func (m *RCRanFunction) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= int(b&0x7F) << shift + m.IndicationMessageFormatType |= int32(b&0x7F) << shift if b < 0x80 { break } } - if msglen < 0 { - return ErrInvalidLengthRan - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthRan - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.ControlStyles = append(m.ControlStyles, &RCControlStyle{}) - if err := m.ControlStyles[len(m.ControlStyles)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipRan(dAtA[iNdEx:]) @@ -17118,7 +22573,7 @@ func (m *RCRanFunction) Unmarshal(dAtA []byte) error { } return nil } -func (m *MHORanFunction) Unmarshal(dAtA []byte) error { +func (m *CCCInsertStyle) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -17141,47 +22596,15 @@ func (m *MHORanFunction) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: MHORanFunction: wiretype end group for non-group") + return fmt.Errorf("proto: CCCInsertStyle: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: MHORanFunction: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: CCCInsertStyle: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType) - } - var stringLen uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowRan - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - stringLen |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - intStringLen := int(stringLen) - if intStringLen < 0 { - return ErrInvalidLengthRan - } - postIndex := iNdEx + intStringLen - if postIndex < 0 { - return ErrInvalidLengthRan - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.ID = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex - case 2: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field ReportStyles", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -17208,8 +22631,10 @@ func (m *MHORanFunction) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.ReportStyles = append(m.ReportStyles, &MHOReportStyle{}) - if err := m.ReportStyles[len(m.ReportStyles)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if m.Value == nil { + m.Value = &types.Empty{} + } + if err := m.Value.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex @@ -17234,7 +22659,7 @@ func (m *MHORanFunction) Unmarshal(dAtA []byte) error { } return nil } -func (m *KPMRanFunction) Unmarshal(dAtA []byte) error { +func (m *CCCControlStyle) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -17257,15 +22682,34 @@ func (m *KPMRanFunction) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: KPMRanFunction: wiretype end group for non-group") + return fmt.Errorf("proto: CCCControlStyle: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: KPMRanFunction: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: CCCControlStyle: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType) + } + m.Type = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRan + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Type |= int32(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -17293,13 +22737,13 @@ func (m *KPMRanFunction) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.ID = string(dAtA[iNdEx:postIndex]) + m.Name = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex - case 2: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field ReportStyles", wireType) + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field ControlHeaderFormatType", wireType) } - var msglen int + m.ControlHeaderFormatType = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRan @@ -17309,26 +22753,68 @@ func (m *KPMRanFunction) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= int(b&0x7F) << shift + m.ControlHeaderFormatType |= int32(b&0x7F) << shift if b < 0x80 { break } } - if msglen < 0 { - return ErrInvalidLengthRan + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field ControlMessageFormatType", wireType) } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthRan + m.ControlMessageFormatType = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRan + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.ControlMessageFormatType |= int32(b&0x7F) << shift + if b < 0x80 { + break + } } - if postIndex > l { - return io.ErrUnexpectedEOF + case 5: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field RicProcessIdFormatType", wireType) } - m.ReportStyles = append(m.ReportStyles, &KPMReportStyle{}) - if err := m.ReportStyles[len(m.ReportStyles)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err + m.RicProcessIdFormatType = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRan + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.RicProcessIdFormatType |= int32(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 6: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field ControlOutcomeFormatType", wireType) + } + m.ControlOutcomeFormatType = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRan + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.ControlOutcomeFormatType |= int32(b&0x7F) << shift + if b < 0x80 { + break + } } - iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipRan(dAtA[iNdEx:]) @@ -17350,7 +22836,7 @@ func (m *KPMRanFunction) Unmarshal(dAtA []byte) error { } return nil } -func (m *RSMRanFunction) Unmarshal(dAtA []byte) error { +func (m *CCCPolicyStyle) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -17373,47 +22859,15 @@ func (m *RSMRanFunction) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: RSMRanFunction: wiretype end group for non-group") + return fmt.Errorf("proto: CCCPolicyStyle: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: RSMRanFunction: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: CCCPolicyStyle: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType) - } - var stringLen uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowRan - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - stringLen |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - intStringLen := int(stringLen) - if intStringLen < 0 { - return ErrInvalidLengthRan - } - postIndex := iNdEx + intStringLen - if postIndex < 0 { - return ErrInvalidLengthRan - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.ID = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex - case 2: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field RicSlicingNodeCapabilityList", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -17440,8 +22894,10 @@ func (m *RSMRanFunction) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.RicSlicingNodeCapabilityList = append(m.RicSlicingNodeCapabilityList, &RSMNodeSlicingCapabilityItem{}) - if err := m.RicSlicingNodeCapabilityList[len(m.RicSlicingNodeCapabilityList)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if m.Value == nil { + m.Value = &types.Empty{} + } + if err := m.Value.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex @@ -17466,7 +22922,7 @@ func (m *RSMRanFunction) Unmarshal(dAtA []byte) error { } return nil } -func (m *RCEventTriggerStyle) Unmarshal(dAtA []byte) error { +func (m *Plmnidentity) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -17489,68 +22945,17 @@ func (m *RCEventTriggerStyle) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: RCEventTriggerStyle: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: RCEventTriggerStyle: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: Plmnidentity: wiretype end group for non-group") } - switch fieldNum { - case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) - } - var stringLen uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowRan - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - stringLen |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - intStringLen := int(stringLen) - if intStringLen < 0 { - return ErrInvalidLengthRan - } - postIndex := iNdEx + intStringLen - if postIndex < 0 { - return ErrInvalidLengthRan - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.Name = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex - case 2: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType) - } - m.Type = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowRan - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.Type |= int32(b&0x7F) << shift - if b < 0x80 { - break - } - } - case 3: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field FormatType", wireType) + if fieldNum <= 0 { + return fmt.Errorf("proto: Plmnidentity: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType) } - m.FormatType = 0 + var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRan @@ -17560,11 +22965,26 @@ func (m *RCEventTriggerStyle) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.FormatType |= int32(b&0x7F) << shift + byteLen |= int(b&0x7F) << shift if b < 0x80 { break } } + if byteLen < 0 { + return ErrInvalidLengthRan + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthRan + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Value = append(m.Value[:0], dAtA[iNdEx:postIndex]...) + if m.Value == nil { + m.Value = []byte{} + } + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipRan(dAtA[iNdEx:]) @@ -17586,7 +23006,7 @@ func (m *RCEventTriggerStyle) Unmarshal(dAtA []byte) error { } return nil } -func (m *RCReportStyle) Unmarshal(dAtA []byte) error { +func (m *Sst) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -17609,68 +23029,17 @@ func (m *RCReportStyle) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: RCReportStyle: wiretype end group for non-group") + return fmt.Errorf("proto: Sst: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: RCReportStyle: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: Sst: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) - } - var stringLen uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowRan - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - stringLen |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - intStringLen := int(stringLen) - if intStringLen < 0 { - return ErrInvalidLengthRan - } - postIndex := iNdEx + intStringLen - if postIndex < 0 { - return ErrInvalidLengthRan - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.Name = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex - case 2: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType) - } - m.Type = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowRan - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.Type |= int32(b&0x7F) << shift - if b < 0x80 { - break - } - } - case 3: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field RanParameters", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType) } - var msglen int + var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRan @@ -17680,24 +23049,24 @@ func (m *RCReportStyle) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= int(b&0x7F) << shift + byteLen |= int(b&0x7F) << shift if b < 0x80 { break } } - if msglen < 0 { + if byteLen < 0 { return ErrInvalidLengthRan } - postIndex := iNdEx + msglen + postIndex := iNdEx + byteLen if postIndex < 0 { return ErrInvalidLengthRan } if postIndex > l { return io.ErrUnexpectedEOF } - m.RanParameters = append(m.RanParameters, &RANParameter{}) - if err := m.RanParameters[len(m.RanParameters)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err + m.Value = append(m.Value[:0], dAtA[iNdEx:postIndex]...) + if m.Value == nil { + m.Value = []byte{} } iNdEx = postIndex default: @@ -17721,7 +23090,7 @@ func (m *RCReportStyle) Unmarshal(dAtA []byte) error { } return nil } -func (m *RCInsertStyle) Unmarshal(dAtA []byte) error { +func (m *Sd) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -17744,68 +23113,17 @@ func (m *RCInsertStyle) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: RCInsertStyle: wiretype end group for non-group") + return fmt.Errorf("proto: Sd: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: RCInsertStyle: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: Sd: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) - } - var stringLen uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowRan - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - stringLen |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - intStringLen := int(stringLen) - if intStringLen < 0 { - return ErrInvalidLengthRan - } - postIndex := iNdEx + intStringLen - if postIndex < 0 { - return ErrInvalidLengthRan - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.Name = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex - case 2: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType) - } - m.Type = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowRan - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.Type |= int32(b&0x7F) << shift - if b < 0x80 { - break - } - } - case 3: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field InsertIndications", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType) } - var msglen int + var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRan @@ -17815,24 +23133,24 @@ func (m *RCInsertStyle) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= int(b&0x7F) << shift + byteLen |= int(b&0x7F) << shift if b < 0x80 { break } } - if msglen < 0 { + if byteLen < 0 { return ErrInvalidLengthRan } - postIndex := iNdEx + msglen + postIndex := iNdEx + byteLen if postIndex < 0 { return ErrInvalidLengthRan } if postIndex > l { return io.ErrUnexpectedEOF } - m.InsertIndications = append(m.InsertIndications, &InsertIndication{}) - if err := m.InsertIndications[len(m.InsertIndications)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err + m.Value = append(m.Value[:0], dAtA[iNdEx:postIndex]...) + if m.Value == nil { + m.Value = []byte{} } iNdEx = postIndex default: @@ -17856,7 +23174,7 @@ func (m *RCInsertStyle) Unmarshal(dAtA []byte) error { } return nil } -func (m *RCPolicyStyle) Unmarshal(dAtA []byte) error { +func (m *SNSsai) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -17879,17 +23197,17 @@ func (m *RCPolicyStyle) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: RCPolicyStyle: wiretype end group for non-group") + return fmt.Errorf("proto: SNSsai: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: RCPolicyStyle: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: SNSsai: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Sst", wireType) } - var stringLen uint64 + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRan @@ -17899,46 +23217,31 @@ func (m *RCPolicyStyle) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - stringLen |= uint64(b&0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } } - intStringLen := int(stringLen) - if intStringLen < 0 { + if msglen < 0 { return ErrInvalidLengthRan } - postIndex := iNdEx + intStringLen + postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthRan } if postIndex > l { return io.ErrUnexpectedEOF } - m.Name = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex - case 2: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType) + if m.Sst == nil { + m.Sst = &Sst{} } - m.Type = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowRan - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.Type |= int32(b&0x7F) << shift - if b < 0x80 { - break - } + if err := m.Sst.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err } - case 3: + iNdEx = postIndex + case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field PolicyActions", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Sd", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -17965,8 +23268,10 @@ func (m *RCPolicyStyle) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.PolicyActions = append(m.PolicyActions, &PolicyAction{}) - if err := m.PolicyActions[len(m.PolicyActions)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if m.Sd == nil { + m.Sd = &Sd{} + } + if err := m.Sd.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex @@ -17991,7 +23296,7 @@ func (m *RCPolicyStyle) Unmarshal(dAtA []byte) error { } return nil } -func (m *PolicyAction) Unmarshal(dAtA []byte) error { +func (m *RrmPolicyMember) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -18014,36 +23319,17 @@ func (m *PolicyAction) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: PolicyAction: wiretype end group for non-group") + return fmt.Errorf("proto: RrmPolicyMember: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: PolicyAction: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: RrmPolicyMember: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType) - } - m.ID = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowRan - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.ID |= int32(b&0x7F) << shift - if b < 0x80 { - break - } - } - case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field PlmnId", wireType) } - var stringLen uint64 + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRan @@ -18053,27 +23339,31 @@ func (m *PolicyAction) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - stringLen |= uint64(b&0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } } - intStringLen := int(stringLen) - if intStringLen < 0 { + if msglen < 0 { return ErrInvalidLengthRan } - postIndex := iNdEx + intStringLen + postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthRan } if postIndex > l { return io.ErrUnexpectedEOF } - m.Name = string(dAtA[iNdEx:postIndex]) + if m.PlmnId == nil { + m.PlmnId = &Plmnidentity{} + } + if err := m.PlmnId.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } iNdEx = postIndex - case 3: + case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field PolicyActionRanParameters", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Snssai", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -18097,17 +23387,69 @@ func (m *PolicyAction) Unmarshal(dAtA []byte) error { if postIndex < 0 { return ErrInvalidLengthRan } - if postIndex > l { + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Snssai == nil { + m.Snssai = &SNSsai{} + } + if err := m.Snssai.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipRan(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthRan + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *RrmPolicyMemberList) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRan + } + if iNdEx >= l { return io.ErrUnexpectedEOF } - m.PolicyActionRanParameters = append(m.PolicyActionRanParameters, &RANParameter{}) - if err := m.PolicyActionRanParameters[len(m.PolicyActionRanParameters)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break } - iNdEx = postIndex - case 4: + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: RrmPolicyMemberList: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: RrmPolicyMemberList: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field PolicyConditionRanParameters", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field RrmPolicyMember", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -18134,8 +23476,8 @@ func (m *PolicyAction) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.PolicyConditionRanParameters = append(m.PolicyConditionRanParameters, &RANParameter{}) - if err := m.PolicyConditionRanParameters[len(m.PolicyConditionRanParameters)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + m.RrmPolicyMember = append(m.RrmPolicyMember, &RrmPolicyMember{}) + if err := m.RrmPolicyMember[len(m.RrmPolicyMember)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex @@ -18160,7 +23502,7 @@ func (m *PolicyAction) Unmarshal(dAtA []byte) error { } return nil } -func (m *RCControlStyle) Unmarshal(dAtA []byte) error { +func (m *ORRmpolicyRatio) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -18183,17 +23525,17 @@ func (m *RCControlStyle) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: RCControlStyle: wiretype end group for non-group") + return fmt.Errorf("proto: ORRmpolicyRatio: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: RCControlStyle: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: ORRmpolicyRatio: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field ResourceType", wireType) } - var stringLen uint64 + m.ResourceType = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRan @@ -18203,29 +23545,16 @@ func (m *RCControlStyle) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - stringLen |= uint64(b&0x7F) << shift + m.ResourceType |= ResourceType(b&0x7F) << shift if b < 0x80 { break } } - intStringLen := int(stringLen) - if intStringLen < 0 { - return ErrInvalidLengthRan - } - postIndex := iNdEx + intStringLen - if postIndex < 0 { - return ErrInvalidLengthRan - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.Name = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex case 2: if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field SchedulerType", wireType) } - m.Type = 0 + m.SchedulerType = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRan @@ -18235,16 +23564,16 @@ func (m *RCControlStyle) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.Type |= int32(b&0x7F) << shift + m.SchedulerType |= SchedulerType(b&0x7F) << shift if b < 0x80 { break } } case 3: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field HeaderFormatType", wireType) + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field RrmPolicyMemberList", wireType) } - m.HeaderFormatType = 0 + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRan @@ -18254,16 +23583,33 @@ func (m *RCControlStyle) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.HeaderFormatType |= int32(b&0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } } + if msglen < 0 { + return ErrInvalidLengthRan + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthRan + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.RrmPolicyMemberList == nil { + m.RrmPolicyMemberList = &RrmPolicyMemberList{} + } + if err := m.RrmPolicyMemberList.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex case 4: if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field MessageFormatType", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field RrmPolicyMaxRatio", wireType) } - m.MessageFormatType = 0 + m.RrmPolicyMaxRatio = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRan @@ -18273,16 +23619,16 @@ func (m *RCControlStyle) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.MessageFormatType |= int32(b&0x7F) << shift + m.RrmPolicyMaxRatio |= int32(b&0x7F) << shift if b < 0x80 { break } } case 5: if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field ControlOutcomeFormatType", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field RrmPolicyMinRatio", wireType) } - m.ControlOutcomeFormatType = 0 + m.RrmPolicyMinRatio = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRan @@ -18292,16 +23638,16 @@ func (m *RCControlStyle) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.ControlOutcomeFormatType |= int32(b&0x7F) << shift + m.RrmPolicyMinRatio |= int32(b&0x7F) << shift if b < 0x80 { break } } case 6: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field ControlActions", wireType) + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field RrmPolicyDedicatedRatio", wireType) } - var msglen int + m.RrmPolicyDedicatedRatio = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRan @@ -18311,26 +23657,11 @@ func (m *RCControlStyle) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= int(b&0x7F) << shift + m.RrmPolicyDedicatedRatio |= int32(b&0x7F) << shift if b < 0x80 { break } } - if msglen < 0 { - return ErrInvalidLengthRan - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthRan - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.ControlActions = append(m.ControlActions, &ControlAction{}) - if err := m.ControlActions[len(m.ControlActions)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipRan(dAtA[iNdEx:]) @@ -18352,7 +23683,7 @@ func (m *RCControlStyle) Unmarshal(dAtA []byte) error { } return nil } -func (m *ControlAction) Unmarshal(dAtA []byte) error { +func (m *ConfigurationStructure) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -18375,17 +23706,17 @@ func (m *ControlAction) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: ControlAction: wiretype end group for non-group") + return fmt.Errorf("proto: ConfigurationStructure: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: ControlAction: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: ConfigurationStructure: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field ChangeType", wireType) } - m.ID = 0 + m.ChangeType = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRan @@ -18395,14 +23726,14 @@ func (m *ControlAction) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.ID |= int32(b&0x7F) << shift + m.ChangeType |= ChangeType(b&0x7F) << shift if b < 0x80 { break } } case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field ConfigurationName", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -18430,11 +23761,11 @@ func (m *ControlAction) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.Name = string(dAtA[iNdEx:postIndex]) + m.ConfigurationName = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 3: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field RanParameters", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field PolicyRatio", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -18461,115 +23792,16 @@ func (m *ControlAction) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.RanParameters = append(m.RanParameters, &RANParameter{}) - if err := m.RanParameters[len(m.RanParameters)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err + if m.PolicyRatio == nil { + m.PolicyRatio = &ORRmpolicyRatio{} } - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipRan(dAtA[iNdEx:]) - if err != nil { + if err := m.PolicyRatio.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthRan - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *InsertIndication) Unmarshal(dAtA []byte) error { - l := len(dAtA) - iNdEx := 0 - for iNdEx < l { - preIndex := iNdEx - var wire uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowRan - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - wire |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - fieldNum := int32(wire >> 3) - wireType := int(wire & 0x7) - if wireType == 4 { - return fmt.Errorf("proto: InsertIndication: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: InsertIndication: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType) - } - m.ID = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowRan - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.ID |= int32(b&0x7F) << shift - if b < 0x80 { - break - } - } - case 2: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) - } - var stringLen uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowRan - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - stringLen |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - intStringLen := int(stringLen) - if intStringLen < 0 { - return ErrInvalidLengthRan - } - postIndex := iNdEx + intStringLen - if postIndex < 0 { - return ErrInvalidLengthRan - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.Name = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex - case 3: + case 4: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field RanParameters", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field OldPolicyRatio", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -18596,8 +23828,10 @@ func (m *InsertIndication) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.RanParameters = append(m.RanParameters, &RANParameter{}) - if err := m.RanParameters[len(m.RanParameters)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if m.OldPolicyRatio == nil { + m.OldPolicyRatio = &ORRmpolicyRatio{} + } + if err := m.OldPolicyRatio.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex @@ -18622,7 +23856,7 @@ func (m *InsertIndication) Unmarshal(dAtA []byte) error { } return nil } -func (m *RANParameter) Unmarshal(dAtA []byte) error { +func (m *ConfigurationStructureList) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -18645,36 +23879,17 @@ func (m *RANParameter) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: RANParameter: wiretype end group for non-group") + return fmt.Errorf("proto: ConfigurationStructureList: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: RANParameter: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: ConfigurationStructureList: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType) - } - m.ID = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowRan - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.ID |= int64(b&0x7F) << shift - if b < 0x80 { - break - } - } - case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field ConfigurationStructure", wireType) } - var stringLen uint64 + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRan @@ -18684,23 +23899,25 @@ func (m *RANParameter) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - stringLen |= uint64(b&0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } } - intStringLen := int(stringLen) - if intStringLen < 0 { + if msglen < 0 { return ErrInvalidLengthRan } - postIndex := iNdEx + intStringLen + postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthRan } if postIndex > l { return io.ErrUnexpectedEOF } - m.Name = string(dAtA[iNdEx:postIndex]) + m.ConfigurationStructure = append(m.ConfigurationStructure, &ConfigurationStructure{}) + if err := m.ConfigurationStructure[len(m.ConfigurationStructure)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } iNdEx = postIndex default: iNdEx = preIndex diff --git a/proto/onos/ccc/ccc.proto b/proto/onos/ccc/ccc.proto new file mode 100644 index 00000000..c167d0f4 --- /dev/null +++ b/proto/onos/ccc/ccc.proto @@ -0,0 +1,87 @@ +// SPDX-FileCopyrightText: 2023-present Intel Corporation +// +// SPDX-License-Identifier: Apache-2.0 + +syntax = "proto3"; + +package onos.ccc; + +service Ccc { + // Slice management + rpc UpdateSlice (UpdateSliceRequest) returns (UpdateSliceResponse); +} + +// enumerated from e2sm_ccc.asn1:141 +enum ResourceType { + RESOURCE_TYPE_PRB_UL = 0; + RESOURCE_TYPE_PRB_DL = 1; + RESOURCE_TYPE_DRB = 2; + RESOURCE_TYPE_RRC = 3; +} + +// enumerated from e2sm_ccc.asn1:143 +enum SchedulerType { + SCHEDULER_TYPE_ROUND_ROBIN = 0; + SCHEDULER_TYPE_PROPORTIONALLY_FAIR = 1; + SCHEDULER_TYPE_QOS_BASED = 2; +}; + +// range of Integer from e2sm_common_ies.asn1:444 +message Plmnidentity { + bytes value = 1; +}; + +// range of Integer from e2sm_common_ies.asn1:450 +message Sd { + bytes value = 1; +}; + +// sequence from e2sm_common_ies.asn1:454 +message SNSsai { + Sst sst = 1; + Sd sd = 2; +}; + +// range of Integer from e2sm_common_ies.asn1:460 +message Sst { + bytes value = 1; +}; + +// sequence from e2sm_ccc.asn1:161 +message RrmPolicyMember { + Plmnidentity plmn_id = 1; + SNSsai snssai = 2; +}; + +// sequence from e2sm_ccc.asn1:167 +message RrmPolicyMemberList { + repeated RrmPolicyMember rrm_policy_member = 1; +}; + +// sequence from e2sm_ccc.asn1:229 +// {O-RRMPolicyRatio} +message ORRmpolicyRatio { + ResourceType resource_type = 1; + SchedulerType scheduler_type = 2; + RrmPolicyMemberList rrm_policy_member_list = 3; + int32 rrm_policy_max_ratio = 4; + int32 rrm_policy_min_ratio = 5; + int32 rrm_policy_dedicated_ratio = 6; +}; + +// ===================== +// Non-standard messages + +message Ack { + bool success = 1; + string cause = 2; +} + +message UpdateSliceRequest { + string e2_node_id = 1; + ORRmpolicyRatio rrm_policy_ratio = 2; +} + +message UpdateSliceResponse { + Ack ack = 1; +} diff --git a/proto/onos/topo/ran.proto b/proto/onos/topo/ran.proto index 7ad2a058..345abd07 100644 --- a/proto/onos/topo/ran.proto +++ b/proto/onos/topo/ran.proto @@ -10,6 +10,7 @@ package onos.topo; import "google/protobuf/any.proto"; import "gogoproto/gogo.proto"; import "google/protobuf/timestamp.proto"; +import "google/protobuf/empty.proto"; // TODO: Deprecate! Use language specific constant definitions instead. // Kinds of RAN entities @@ -372,6 +373,12 @@ message MHORanFunction { repeated MHOReportStyle report_styles = 2; } +message CCCRanFunction { + string id = 1 [(gogoproto.customname) = "ID"]; + repeated RanconfigurationStructure ran_structures = 2; + repeated CellsForRanfunctionDefinition cells_ran_definition = 3; +} + message KPMRanFunction { string id = 1 [(gogoproto.customname) = "ID"]; repeated KPMReportStyle report_styles = 2; @@ -440,11 +447,147 @@ message RANParameter { string name = 2; } +message RanconfigurationStructure { + string name = 1; + repeated Attribute attribute = 2; +} + +message Attribute { + string name = 1; + RICServices ric_services = 2; +} + +message RICServices { + repeated CCCEventTriggerStyle event_trigger_styles = 1; + repeated CCCReportStyle report_styles = 2; + repeated CCCInsertStyle insert_styles = 3; + repeated CCCControlStyle control_styles = 4; + repeated CCCPolicyStyle policy_styles = 5; +} + +message CellsForRanfunctionDefinition { + CellGlobalID cell_global_id = 1; + repeated CellForRanfunctionDefinition cell_function_definition = 2; +} + +message CellForRanfunctionDefinition { + string name = 1; + repeated Attribute attribute = 2; +} + +message CCCEventTriggerStyle { + string name = 1; + int32 type = 2; + int32 format_type = 3; +} + +message CCCReportStyle { + string name = 1; + int32 type = 2; + repeated int32 event_trigger_style_for_report = 3; + int32 action_definition_format_type = 4; + int32 indication_header_format_type = 5; + int32 indication_message_format_type = 6; +} + +message CCCInsertStyle { + google.protobuf.Empty value = 1; +} + +message CCCControlStyle { + int32 type = 1; + string name = 2; + int32 control_header_format_type = 3; + int32 control_message_format_type = 4; + int32 ric_process_id_format_type = 5; + int32 control_outcome_format_type = 6; +} + +message CCCPolicyStyle { + google.protobuf.Empty value = 1; +} + +// enumerated from e2sm_ccc.asn1:141 +enum ResourceType { + RESOURCE_TYPE_PRB_UL = 0; + RESOURCE_TYPE_PRB_DL = 1; + RESOURCE_TYPE_DRB = 2; + RESOURCE_TYPE_RRC = 3; +} + +// enumerated from e2sm_ccc.asn1:143 +enum SchedulerType { + CCC_SCHEDULER_TYPE_ROUND_ROBIN = 0; + CCC_SCHEDULER_TYPE_PROPORTIONALLY_FAIR = 1; + CCC_SCHEDULER_TYPE_QOS_BASED = 2; +} + +// enumerated from e2sm_ccc.asn1:137 +enum ChangeType { + CHANGE_TYPE_NONE = 0; + CHANGE_TYPE_MODIFICATION = 1; + CHANGE_TYPE_ADDITION = 2; + CHANGE_TYPE_DELETION = 3; +} + +// range of Integer from e2sm_common_ies.asn1:444 +message Plmnidentity { + bytes value = 1; +} + +// range of Integer from e2sm_common_ies.asn1:460 +message Sst { + bytes value = 1; +} + +// range of Integer from e2sm_common_ies.asn1:450 +message Sd { + bytes value = 1; +} + +// sequence from e2sm_common_ies.asn1:454 +message SNSsai { + Sst sst = 1; + Sd sd = 2; +} + +// sequence from e2sm_ccc.asn1:161 +message RrmPolicyMember { + Plmnidentity plmn_id = 1; + SNSsai snssai = 2; +} + +// sequence from e2sm_ccc.asn1:167 +message RrmPolicyMemberList { + repeated RrmPolicyMember rrm_policy_member = 1; +} + +// sequence from e2sm_ccc.asn1:229 +// {O-RRMPolicyRatio} +message ORRmpolicyRatio { + ResourceType resource_type = 1; + SchedulerType scheduler_type = 2; + RrmPolicyMemberList rrm_policy_member_list = 3; + int32 rrm_policy_max_ratio = 4; + int32 rrm_policy_min_ratio = 5; + int32 rrm_policy_dedicated_ratio = 6; +} + +message ConfigurationStructure { + ChangeType change_type = 1; + string configuration_name = 2; + ORRmpolicyRatio policy_ratio = 3; + ORRmpolicyRatio old_policy_ratio = 4; +} + +message ConfigurationStructureList { + repeated ConfigurationStructure configuration_structure = 1; +} + message KPMReportStyle { string name = 1; int32 type = 2; repeated KPMMeasurement measurements = 3; - } message MHOReportStyle { @@ -641,4 +784,4 @@ enum EnDcSupport { EN_DC_SUPPORT_UNKNOWN = 0; EN_DC_SUPPORT_SUPPORTED = 1; EN_DC_SUPPORT_NOT_SUPPORTED = 2; -} \ No newline at end of file +} diff --git a/protoset/onos-topo.protoset b/protoset/onos-topo.protoset index d8a893fa68390a6ebbdeee7031f8af98b697c2e7..1fa8b9ee3d597440f8c3caae1e96a32f71736d00 100644 GIT binary patch delta 2995 zcmbVOzi-<{6t1XPMxJF^W)xYLe>4@`#xYtuFoG6I>ohVY*Meo)IXXj(76e0{Y$6gV zkW^x$1Dhgihk)(gPDRn70lak0)H!>%?nVEEzB^LVN!HSCJihOJ_ult@kT1TMet9ju zws+@$NWj90-PSzc?HYd9rCve0kzAeHTv>N)$6NQEjirb<%Zp-*RlV2PV_#+dp~oG2{%|YIz!?G-=baEru^7IpwNAsW8}%@I&k0yMZy#8PluIj$;T2Hz@jZ?`9_m+D$GJuti;cEXq zBdOnov}+lfN8M+Z!6iwcBzb{{)D$(gk}1UY4yC^&m=cWg!|-ooE|=f}yekl(`~~x7 z;(pjM^5IjOPO^ez>AWQ04}UZA?fD_BQnN7_U-i#hl%%b}!IR67K{=mx? z%ZkGUN`#3RrehC&^6PGmrIuqzn zV5QW0H5R)fYP6eToCw9H7)wg>jA-Xluaugw$f6nRm&CSW6}|g^+CqaI*5pp}%jrKP zJ}`uK9M=!a&Gld#mgzHU`x>^|$q98M?X{-kYA#3do}VB^jyj4!Tuc@xM_}cabl&)a zD2$=4Bkg&IVj&Z&ND+YslYk5XVvZ2PI4s+=3_h3IDb-DkMdX->I0m3yjzNwdg#yb1 ztJbETr=QRvjuhuu7@+op2sL0S-RBAkZ7P2V6VLQkmlhJ}&ZZ~YX6wCew$7Ipi9n^- z63pNTh;1s%aE0r@2qp-BX76mh9e#3}nferpz0MD}tofC>_;e}5Em-ISpIXJeLVVgE z%|gBhMK<^tB96VMS>})qk(PNx97cee8GdK2B~sz<)^ZR_Ak58wlwbwYhpo14nb=pB ze=g@l0nk34UT?B*kzwQ@#Z$&&GDM;)`Yl zhbU4K14>`PwUGFjMEldx02-AOAa2QF1i9oK6B*T^2fSgFGpW!zdlZtl=Q!UP456+@= zM?5S$_K3P(@UZO20q0M+!lZl+Q8RXnmd0HFqDs%sol7qz$SeG(A{hOvkUxeg<5ahC z3-!l8vw2-mLE%=WGJy!m75@liob17WiiVql{RAXduaemzO9Kt^7NmQP6KNC4E%wbw zOOPqCKPr%QS|)EktXo9ER`zh~jZ$RLCz3uA;w*q-B*dr=ypG4f)|!x0|4%J$^Y=tu zL}dTJ48NRX-t# iquN0OgU5tLYq?UXaf>7uMog7zy~<6=i{s}%%l`stJlt6T delta 51 zcmV-30L=fXumXXU0 None: + super().__post_init__() + + +@dataclass(eq=False, repr=False) +class Sd(betterproto.Message): + """range of Integer from e2sm_common_ies.asn1:450""" + + value: bytes = betterproto.bytes_field(1) + + def __post_init__(self) -> None: + super().__post_init__() + + +@dataclass(eq=False, repr=False) +class SnSsai(betterproto.Message): + """sequence from e2sm_common_ies.asn1:454""" + + sst: "Sst" = betterproto.message_field(1) + sd: "Sd" = betterproto.message_field(2) + + def __post_init__(self) -> None: + super().__post_init__() + + +@dataclass(eq=False, repr=False) +class Sst(betterproto.Message): + """range of Integer from e2sm_common_ies.asn1:460""" + + value: bytes = betterproto.bytes_field(1) + + def __post_init__(self) -> None: + super().__post_init__() + + +@dataclass(eq=False, repr=False) +class RrmPolicyMember(betterproto.Message): + """sequence from e2sm_ccc.asn1:161""" + + plmn_id: "Plmnidentity" = betterproto.message_field(1) + snssai: "SnSsai" = betterproto.message_field(2) + + def __post_init__(self) -> None: + super().__post_init__() + + +@dataclass(eq=False, repr=False) +class RrmPolicyMemberList(betterproto.Message): + """sequence from e2sm_ccc.asn1:167""" + + rrm_policy_member: List["RrmPolicyMember"] = betterproto.message_field(1) + + def __post_init__(self) -> None: + super().__post_init__() + + +@dataclass(eq=False, repr=False) +class OrRmpolicyRatio(betterproto.Message): + """sequence from e2sm_ccc.asn1:229 {O-RRMPolicyRatio}""" + + resource_type: "ResourceType" = betterproto.enum_field(1) + scheduler_type: "SchedulerType" = betterproto.enum_field(2) + rrm_policy_member_list: "RrmPolicyMemberList" = betterproto.message_field(3) + rrm_policy_max_ratio: int = betterproto.int32_field(4) + rrm_policy_min_ratio: int = betterproto.int32_field(5) + rrm_policy_dedicated_ratio: int = betterproto.int32_field(6) + + def __post_init__(self) -> None: + super().__post_init__() + + +@dataclass(eq=False, repr=False) +class Ack(betterproto.Message): + success: bool = betterproto.bool_field(1) + cause: str = betterproto.string_field(2) + + def __post_init__(self) -> None: + super().__post_init__() + + +@dataclass(eq=False, repr=False) +class UpdateSliceRequest(betterproto.Message): + e2_node_id: str = betterproto.string_field(1) + rrm_policy_ratio: "OrRmpolicyRatio" = betterproto.message_field(2) + + def __post_init__(self) -> None: + super().__post_init__() + + +@dataclass(eq=False, repr=False) +class UpdateSliceResponse(betterproto.Message): + ack: "Ack" = betterproto.message_field(1) + + def __post_init__(self) -> None: + super().__post_init__() + + +class CccStub(betterproto.ServiceStub): + async def update_slice( + self, *, e2_node_id: str = "", rrm_policy_ratio: "OrRmpolicyRatio" = None + ) -> "UpdateSliceResponse": + """Slice management""" + + request = UpdateSliceRequest() + request.e2_node_id = e2_node_id + if rrm_policy_ratio is not None: + request.rrm_policy_ratio = rrm_policy_ratio + + return await self._unary_unary( + "/onos.ccc.Ccc/UpdateSlice", request, UpdateSliceResponse + ) diff --git a/python/onos/topo/__init__.py b/python/onos/topo/__init__.py index 67044625..09d3cc00 100644 --- a/python/onos/topo/__init__.py +++ b/python/onos/topo/__init__.py @@ -172,6 +172,26 @@ class ComponentType(betterproto.Enum): CT_ENB = 4 +class ResourceType(betterproto.Enum): + RESOURCE_TYPE_PRB_UL = 0 + RESOURCE_TYPE_PRB_DL = 1 + RESOURCE_TYPE_DRB = 2 + RESOURCE_TYPE_RRC = 3 + + +class SchedulerType(betterproto.Enum): + CCC_SCHEDULER_TYPE_ROUND_ROBIN = 0 + CCC_SCHEDULER_TYPE_PROPORTIONALLY_FAIR = 1 + CCC_SCHEDULER_TYPE_QOS_BASED = 2 + + +class ChangeType(betterproto.Enum): + CHANGE_TYPE_NONE = 0 + CHANGE_TYPE_MODIFICATION = 1 + CHANGE_TYPE_ADDITION = 2 + CHANGE_TYPE_DELETION = 3 + + class E2SmRsmCommand(betterproto.Enum): E2_SM_RSM_COMMAND_SLICE_CREATE = 0 E2_SM_RSM_COMMAND_SLICE_UPDATE = 1 @@ -1114,6 +1134,18 @@ def __post_init__(self) -> None: super().__post_init__() +@dataclass(eq=False, repr=False) +class CccRanFunction(betterproto.Message): + id: str = betterproto.string_field(1) + ran_structures: List["RanconfigurationStructure"] = betterproto.message_field(2) + cells_ran_definition: List[ + "CellsForRanfunctionDefinition" + ] = betterproto.message_field(3) + + def __post_init__(self) -> None: + super().__post_init__() + + @dataclass(eq=False, repr=False) class KpmRanFunction(betterproto.Message): id: str = betterproto.string_field(1) @@ -1227,6 +1259,192 @@ def __post_init__(self) -> None: super().__post_init__() +@dataclass(eq=False, repr=False) +class RanconfigurationStructure(betterproto.Message): + name: str = betterproto.string_field(1) + attribute: List["Attribute"] = betterproto.message_field(2) + + def __post_init__(self) -> None: + super().__post_init__() + + +@dataclass(eq=False, repr=False) +class Attribute(betterproto.Message): + name: str = betterproto.string_field(1) + ric_services: "RicServices" = betterproto.message_field(2) + + def __post_init__(self) -> None: + super().__post_init__() + + +@dataclass(eq=False, repr=False) +class RicServices(betterproto.Message): + event_trigger_styles: List["CccEventTriggerStyle"] = betterproto.message_field(1) + report_styles: List["CccReportStyle"] = betterproto.message_field(2) + insert_styles: List["CccInsertStyle"] = betterproto.message_field(3) + control_styles: List["CccControlStyle"] = betterproto.message_field(4) + policy_styles: List["CccPolicyStyle"] = betterproto.message_field(5) + + def __post_init__(self) -> None: + super().__post_init__() + + +@dataclass(eq=False, repr=False) +class CellsForRanfunctionDefinition(betterproto.Message): + cell_global_id: "CellGlobalId" = betterproto.message_field(1) + cell_function_definition: List[ + "CellForRanfunctionDefinition" + ] = betterproto.message_field(2) + + def __post_init__(self) -> None: + super().__post_init__() + + +@dataclass(eq=False, repr=False) +class CellForRanfunctionDefinition(betterproto.Message): + name: str = betterproto.string_field(1) + attribute: List["Attribute"] = betterproto.message_field(2) + + def __post_init__(self) -> None: + super().__post_init__() + + +@dataclass(eq=False, repr=False) +class CccEventTriggerStyle(betterproto.Message): + name: str = betterproto.string_field(1) + type: int = betterproto.int32_field(2) + format_type: int = betterproto.int32_field(3) + + def __post_init__(self) -> None: + super().__post_init__() + + +@dataclass(eq=False, repr=False) +class CccReportStyle(betterproto.Message): + name: str = betterproto.string_field(1) + type: int = betterproto.int32_field(2) + event_trigger_style_for_report: List[int] = betterproto.int32_field(3) + action_definition_format_type: int = betterproto.int32_field(4) + indication_header_format_type: int = betterproto.int32_field(5) + indication_message_format_type: int = betterproto.int32_field(6) + + def __post_init__(self) -> None: + super().__post_init__() + + +@dataclass(eq=False, repr=False) +class CccInsertStyle(betterproto.Message): + value: "betterproto_lib_google_protobuf.Empty" = betterproto.message_field(1) + + def __post_init__(self) -> None: + super().__post_init__() + + +@dataclass(eq=False, repr=False) +class CccControlStyle(betterproto.Message): + type: int = betterproto.int32_field(1) + name: str = betterproto.string_field(2) + control_header_format_type: int = betterproto.int32_field(3) + control_message_format_type: int = betterproto.int32_field(4) + ric_process_id_format_type: int = betterproto.int32_field(5) + control_outcome_format_type: int = betterproto.int32_field(6) + + def __post_init__(self) -> None: + super().__post_init__() + + +@dataclass(eq=False, repr=False) +class CccPolicyStyle(betterproto.Message): + value: "betterproto_lib_google_protobuf.Empty" = betterproto.message_field(1) + + def __post_init__(self) -> None: + super().__post_init__() + + +@dataclass(eq=False, repr=False) +class Plmnidentity(betterproto.Message): + value: bytes = betterproto.bytes_field(1) + + def __post_init__(self) -> None: + super().__post_init__() + + +@dataclass(eq=False, repr=False) +class Sst(betterproto.Message): + value: bytes = betterproto.bytes_field(1) + + def __post_init__(self) -> None: + super().__post_init__() + + +@dataclass(eq=False, repr=False) +class Sd(betterproto.Message): + value: bytes = betterproto.bytes_field(1) + + def __post_init__(self) -> None: + super().__post_init__() + + +@dataclass(eq=False, repr=False) +class SnSsai(betterproto.Message): + sst: "Sst" = betterproto.message_field(1) + sd: "Sd" = betterproto.message_field(2) + + def __post_init__(self) -> None: + super().__post_init__() + + +@dataclass(eq=False, repr=False) +class RrmPolicyMember(betterproto.Message): + plmn_id: "Plmnidentity" = betterproto.message_field(1) + snssai: "SnSsai" = betterproto.message_field(2) + + def __post_init__(self) -> None: + super().__post_init__() + + +@dataclass(eq=False, repr=False) +class RrmPolicyMemberList(betterproto.Message): + rrm_policy_member: List["RrmPolicyMember"] = betterproto.message_field(1) + + def __post_init__(self) -> None: + super().__post_init__() + + +@dataclass(eq=False, repr=False) +class OrRmpolicyRatio(betterproto.Message): + resource_type: "ResourceType" = betterproto.enum_field(1) + scheduler_type: "SchedulerType" = betterproto.enum_field(2) + rrm_policy_member_list: "RrmPolicyMemberList" = betterproto.message_field(3) + rrm_policy_max_ratio: int = betterproto.int32_field(4) + rrm_policy_min_ratio: int = betterproto.int32_field(5) + rrm_policy_dedicated_ratio: int = betterproto.int32_field(6) + + def __post_init__(self) -> None: + super().__post_init__() + + +@dataclass(eq=False, repr=False) +class ConfigurationStructure(betterproto.Message): + change_type: "ChangeType" = betterproto.enum_field(1) + configuration_name: str = betterproto.string_field(2) + policy_ratio: "OrRmpolicyRatio" = betterproto.message_field(3) + old_policy_ratio: "OrRmpolicyRatio" = betterproto.message_field(4) + + def __post_init__(self) -> None: + super().__post_init__() + + +@dataclass(eq=False, repr=False) +class ConfigurationStructureList(betterproto.Message): + configuration_structure: List["ConfigurationStructure"] = betterproto.message_field( + 1 + ) + + def __post_init__(self) -> None: + super().__post_init__() + + @dataclass(eq=False, repr=False) class KpmReportStyle(betterproto.Message): name: str = betterproto.string_field(1) From 491805b4e152ce3380fb98c8dd7e74e0aa525952 Mon Sep 17 00:00:00 2001 From: Open Networking Foundation Bot <39204139+onf-bot@users.noreply.github.com> Date: Thu, 12 Oct 2023 16:49:16 -0700 Subject: [PATCH 2/2] Added null line to commit to try and kick PR builder --- build/bin/compile-protos.sh | 1 + 1 file changed, 1 insertion(+) diff --git a/build/bin/compile-protos.sh b/build/bin/compile-protos.sh index 6d3db527..852d9cd5 100755 --- a/build/bin/compile-protos.sh +++ b/build/bin/compile-protos.sh @@ -1,6 +1,7 @@ #!/bin/sh # SPDX-FileCopyrightText: 2020-present Open Networking Foundation # +# # SPDX-License-Identifier: Apache-2.0 # remove the old code and regenerate,