Repository: kubernetes-sigs/node-feature-discovery
Pull request #908 (2022-10-06 07:53:27)

pkg/api/feature: rename types
Sync type names with NFD documentation. Aims at making the codebase
easier to follow. No functional changes, just a rename.

Split out from #903

netlify[bot]: ### <span aria-hidden="true">👷</span> Deploy Preview for *kubernetes-sigs-nfd* processing.


|  Name | Link |
|---------------------------------|------------------------|
|<span aria-hidden="true">🔨</span> Latest commit | 011b3a77597374654ea255945866810aab35b933 |
|<span aria-hidden="true">🔍</span> Latest deploy log | https://app.netlify.com/sites/kubernetes-sigs-nfd/deploys/633e89797657120008184ba4 |
k8s-ci-robot: [APPROVALNOTIFIER] This PR is **APPROVED**

This pull-request has been approved by: *<a href="https://github.com/kubernetes-sigs/node-feature-discovery/pull/908#" title="Author self-approved">marquiz</a>*

The full list of commands accepted by this bot can be found [here](https://go.k8s.io/bot-commands?repo=kubernetes-sigs%2Fnode-feature-discovery).

The pull request process is described [here](https://git.k8s.io/community/contributors/guide/owners.md#the-code-review-process)

<details >
Needs approval from an approver in each of these files:

- ~~[OWNERS](https://github.com/kubernetes-sigs/node-feature-discovery/blob/master/OWNERS)~~ [marquiz]

Approvers can indicate their approval by writing `/approve` in a comment
Approvers can cancel approval by writing `/approve cancel` in a comment
</details>
<!-- META={"approvers":[]} -->

Patch:
diff --git a/pkg/api/feature/feature.go b/pkg/api/feature/feature.go
index 15eacef44..bd23af277 100644
--- a/pkg/api/feature/feature.go
+++ b/pkg/api/feature/feature.go
@@ -20,26 +20,26 @@ package feature
 // features to empty values
 func NewDomainFeatures() *DomainFeatures {
 	return &DomainFeatures{
-		Keys:      make(map[string]KeyFeatureSet),
-		Values:    make(map[string]ValueFeatureSet),
-		Instances: make(map[string]InstanceFeatureSet)}
+		Flags:      make(map[string]FlagFeatureSet),
+		Attributes: make(map[string]AttributeFeatureSet),
+		Instances:  make(map[string]InstanceFeatureSet)}
 }
 
-// NewKeyFeatures creates a new instance of KeyFeatureSet.
-func NewKeyFeatures(keys ...string) KeyFeatureSet {
+// NewFlagFeatures creates a new instance of KeyFeatureSet.
+func NewFlagFeatures(keys ...string) FlagFeatureSet {
 	e := make(map[string]Nil, len(keys))
 	for _, k := range keys {
 		e[k] = Nil{}
 	}
-	return KeyFeatureSet{Elements: e}
+	return FlagFeatureSet{Elements: e}
 }
 
-// NewValueFeatures creates a new instance of ValueFeatureSet.
-func NewValueFeatures(values map[string]string) ValueFeatureSet {
+// NewAttributeFeatures creates a new instance of ValueFeatureSet.
+func NewAttributeFeatures(values map[string]string) AttributeFeatureSet {
 	if values == nil {
 		values = make(map[string]string)
 	}
-	return ValueFeatureSet{Elements: values}
+	return AttributeFeatureSet{Elements: values}
 }
 
 // NewInstanceFeatures creates a new instance of InstanceFeatureSet.
@@ -55,17 +55,17 @@ func NewInstanceFeature(attrs map[string]string) *InstanceFeature {
 	return &InstanceFeature{Attributes: attrs}
 }
 
-// InsertFeatureValues inserts new values into a specific feature.
-func InsertFeatureValues(f Features, domain, feature string, values map[string]string) {
+// InsertAttributeFeatures inserts new values into a specific feature.
+func InsertAttributeFeatures(f Features, domain, feature string, values map[string]string) {
 	if _, ok := f[domain]; !ok {
 		f[domain] = NewDomainFeatures()
 	}
-	if _, ok := f[domain].Values[feature]; !ok {
-		f[domain].Values[feature] = NewValueFeatures(values)
+	if _, ok := f[domain].Attributes[feature]; !ok {
+		f[domain].Attributes[feature] = NewAttributeFeatures(values)
 		return
 	}
 
 	for k, v := range values {
-		f[domain].Values[feature].Elements[k] = v
+		f[domain].Attributes[feature].Elements[k] = v
 	}
 }
diff --git a/pkg/api/feature/generated.pb.go b/pkg/api/feature/generated.pb.go
index 4b9c8556b..642c1b4c2 100644
--- a/pkg/api/feature/generated.pb.go
+++ b/pkg/api/feature/generated.pb.go
@@ -43,10 +43,38 @@ var _ = math.Inf
 // proto package needs to be updated.
 const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
 
+func (m *AttributeFeatureSet) Reset()      { *m = AttributeFeatureSet{} }
+func (*AttributeFeatureSet) ProtoMessage() {}
+func (*AttributeFeatureSet) Descriptor() ([]byte, []int) {
+	return fileDescriptor_870e6eafce4d2482, []int{0}
+}
+func (m *AttributeFeatureSet) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *AttributeFeatureSet) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	b = b[:cap(b)]
+	n, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b[:n], nil
+}
+func (m *AttributeFeatureSet) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_AttributeFeatureSet.Merge(m, src)
+}
+func (m *AttributeFeatureSet) XXX_Size() int {
+	return m.Size()
+}
+func (m *AttributeFeatureSet) XXX_DiscardUnknown() {
+	xxx_messageInfo_AttributeFeatureSet.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_AttributeFeatureSet proto.InternalMessageInfo
+
 func (m *DomainFeatures) Reset()      { *m = DomainFeatures{} }
 func (*DomainFeatures) ProtoMessage() {}
 func (*DomainFeatures) Descriptor() ([]byte, []int) {
-	return fileDescriptor_870e6eafce4d2482, []int{0}
+	return fileDescriptor_870e6eafce4d2482, []int{1}
 }
 func (m *DomainFeatures) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -71,10 +99,38 @@ func (m *DomainFeatures) XXX_DiscardUnknown() {
 
 var xxx_messageInfo_DomainFeatures proto.InternalMessageInfo
 
+func (m *FlagFeatureSet) Reset()      { *m = FlagFeatureSet{} }
+func (*FlagFeatureSet) ProtoMessage() {}
+func (*FlagFeatureSet) Descriptor() ([]byte, []int) {
+	return fileDescriptor_870e6eafce4d2482, []int{2}
+}
+func (m *FlagFeatureSet) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *FlagFeatureSet) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	b = b[:cap(b)]
+	n, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b[:n], nil
+}
+func (m *FlagFeatureSet) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_FlagFeatureSet.Merge(m, src)
+}
+func (m *FlagFeatureSet) XXX_Size() int {
+	return m.Size()
+}
+func (m *FlagFeatureSet) XXX_DiscardUnknown() {
+	xxx_messageInfo_FlagFeatureSet.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_FlagFeatureSet proto.InternalMessageInfo
+
 func (m *InstanceFeature) Reset()      { *m = InstanceFeature{} }
 func (*InstanceFeature) ProtoMessage() {}
 func (*InstanceFeature) Descriptor() ([]byte, []int) {
-	return fileDescriptor_870e6eafce4d2482, []int{1}
+	return fileDescriptor_870e6eafce4d2482, []int{3}
 }
 func (m *InstanceFeature) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -102,7 +158,7 @@ var xxx_messageInfo_InstanceFeature proto.InternalMessageInfo
 func (m *InstanceFeatureSet) Reset()      { *m = InstanceFeatureSet{} }
 func (*InstanceFeatureSet) ProtoMessage() {}
 func (*InstanceFeatureSet) Descriptor() ([]byte, []int) {
-	return fileDescriptor_870e6eafce4d2482, []int{2}
+	return fileDescriptor_870e6eafce4d2482, []int{4}
 }
 func (m *InstanceFeatureSet) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -127,38 +183,10 @@ func (m *InstanceFeatureSet) XXX_DiscardUnknown() {
 
 var xxx_messageInfo_InstanceFeatureSet proto.InternalMessageInfo
 
-func (m *KeyFeatureSet) Reset()      { *m = KeyFeatureSet{} }
-func (*KeyFeatureSet) ProtoMessage() {}
-func (*KeyFeatureSet) Descriptor() ([]byte, []int) {
-	return fileDescriptor_870e6eafce4d2482, []int{3}
-}
-func (m *KeyFeatureSet) XXX_Unmarshal(b []byte) error {
-	return m.Unmarshal(b)
-}
-func (m *KeyFeatureSet) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	b = b[:cap(b)]
-	n, err := m.MarshalToSizedBuffer(b)
-	if err != nil {
-		return nil, err
-	}
-	return b[:n], nil
-}
-func (m *KeyFeatureSet) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_KeyFeatureSet.Merge(m, src)
-}
-func (m *KeyFeatureSet) XXX_Size() int {
-	return m.Size()
-}
-func (m *KeyFeatureSet) XXX_DiscardUnknown() {
-	xxx_messageInfo_KeyFeatureSet.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_KeyFeatureSet proto.InternalMessageInfo
-
 func (m *Nil) Reset()      { *m = Nil{} }
 func (*Nil) ProtoMessage() {}
 func (*Nil) Descriptor() ([]byte, []int) {
-	return fileDescriptor_870e6eafce4d2482, []int{4}
+	return fileDescriptor_870e6eafce4d2482, []int{5}
 }
 func (m *Nil) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -183,85 +211,104 @@ func (m *Nil) XXX_DiscardUnknown() {
 
 var xxx_messageInfo_Nil proto.InternalMessageInfo
 
-func (m *ValueFeatureSet) Reset()      { *m = ValueFeatureSet{} }
-func (*ValueFeatureSet) ProtoMessage() {}
-func (*ValueFeatureSet) Descriptor() ([]byte, []int) {
-	return fileDescriptor_870e6eafce4d2482, []int{5}
-}
-func (m *ValueFeatureSet) XXX_Unmarshal(b []byte) error {
-	return m.Unmarshal(b)
-}
-func (m *ValueFeatureSet) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	b = b[:cap(b)]
-	n, err := m.MarshalToSizedBuffer(b)
-	if err != nil {
-		return nil, err
-	}
-	return b[:n], nil
-}
-func (m *ValueFeatureSet) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_ValueFeatureSet.Merge(m, src)
-}
-func (m *ValueFeatureSet) XXX_Size() int {
-	return m.Size()
-}
-func (m *ValueFeatureSet) XXX_DiscardUnknown() {
-	xxx_messageInfo_ValueFeatureSet.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_ValueFeatureSet proto.InternalMessageInfo
-
 func init() {
+	proto.RegisterType((*AttributeFeatureSet)(nil), "feature.AttributeFeatureSet")
+	proto.RegisterMapType((map[string]string)(nil), "feature.AttributeFeatureSet.ElementsEntry")
 	proto.RegisterType((*DomainFeatures)(nil), "feature.DomainFeatures")
+	proto.RegisterMapType((map[string]FlagFeatureSet)(nil), "feature.DomainFeatures.FlagsEntry")
 	proto.RegisterMapType((map[string]InstanceFeatureSet)(nil), "feature.DomainFeatures.InstancesEntry")
-	proto.RegisterMapType((map[string]KeyFeatureSet)(nil), "feature.DomainFeatures.KeysEntry")
-	proto.RegisterMapType((map[string]ValueFeatureSet)(nil), "feature.DomainFeatures.ValuesEntry")
+	proto.RegisterMapType((map[string]AttributeFeatureSet)(nil), "feature.DomainFeatures.VattributesEntry")
+	proto.RegisterType((*FlagFeatureSet)(nil), "feature.FlagFeatureSet")
+	proto.RegisterMapType((map[string]Nil)(nil), "feature.FlagFeatureSet.ElementsEntry")
 	proto.RegisterType((*InstanceFeature)(nil), "feature.InstanceFeature")
 	proto.RegisterMapType((map[string]string)(nil), "feature.InstanceFeature.AttributesEntry")
 	proto.RegisterType((*InstanceFeatureSet)(nil), "feature.InstanceFeatureSet")
-	proto.RegisterType((*KeyFeatureSet)(nil), "feature.KeyFeatureSet")
-	proto.RegisterMapType((map[string]Nil)(nil), "feature.KeyFeatureSet.ElementsEntry")
 	proto.RegisterType((*Nil)(nil), "feature.Nil")
-	proto.RegisterType((*ValueFeatureSet)(nil), "feature.ValueFeatureSet")
-	proto.RegisterMapType((map[string]string)(nil), "feature.ValueFeatureSet.ElementsEntry")
 }
 
 func init() { proto.RegisterFile("feature/generated.proto", fileDescriptor_870e6eafce4d2482) }
 
 var fileDescriptor_870e6eafce4d2482 = []byte{
-	// 503 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x92, 0xc1, 0x6e, 0xd3, 0x40,
-	0x10, 0x86, 0xbd, 0x71, 0x5b, 0xea, 0x49, 0x9b, 0x94, 0x15, 0x02, 0xcb, 0x48, 0xdb, 0x10, 0x50,
-	0x95, 0x03, 0xac, 0x45, 0x4f, 0x08, 0xc4, 0x81, 0x40, 0x2b, 0x55, 0x91, 0x8a, 0xe4, 0x22, 0x10,
-	0xa8, 0x17, 0xa7, 0x6c, 0x83, 0xd5, 0xc4, 0x46, 0xf6, 0x1a, 0xc9, 0x37, 0x1e, 0x81, 0x87, 0xe0,
-	0xcc, 0x73, 0xe4, 0xd8, 0x63, 0x4f, 0x15, 0x31, 0xaf, 0xc1, 0x01, 0x65, 0xbd, 0xde, 0xd8, 0x89,
-	0x0d, 0xe2, 0x66, 0xef, 0xfe, 0xff, 0x37, 0xff, 0xcc, 0x0e, 0xdc, 0x39, 0x67, 0x2e, 0x8f, 0x43,
-	0x66, 0x8f, 0x98, 0xcf, 0x42, 0x97, 0xb3, 0x8f, 0xf4, 0x73, 0x18, 0xf0, 0x00, 0xdf, 0x90, 0x17,
-	0xd6, 0xa3, 0x91, 0xc7, 0x3f, 0xc5, 0x43, 0x7a, 0x16, 0x4c, 0xec, 0x51, 0x30, 0x0a, 0x6c, 0x71,
-	0x3f, 0x8c, 0xcf, 0xc5, 0x9f, 0xf8, 0x11, 0x5f, 0x99, 0xaf, 0xfb, 0x5b, 0x87, 0xd6, 0xab, 0x60,
-	0xe2, 0x7a, 0xfe, 0x61, 0x06, 0x88, 0xf0, 0x4b, 0x58, 0xbb, 0x60, 0x49, 0x64, 0xa2, 0x8e, 0xde,
-	0x6b, 0xee, 0xdf, 0xa3, 0x92, 0x4c, 0xcb, 0x32, 0x3a, 0x60, 0x49, 0x74, 0xe0, 0xf3, 0x30, 0xe9,
-	0x6f, 0x4d, 0xaf, 0x77, 0xb5, 0xf4, 0x7a, 0x77, 0x6d, 0x7e, 0xe4, 0x08, 0x33, 0x1e, 0xc0, 0xc6,
-	0x17, 0x77, 0x1c, 0xb3, 0xc8, 0x6c, 0x08, 0xcc, 0xfd, 0x3a, 0xcc, 0x5b, 0xa1, 0xca, 0x40, 0x2d,
-	0x09, 0xda, 0xc8, 0x0e, 0x1d, 0x89, 0xc0, 0xef, 0xc0, 0xf0, 0xfc, 0x88, 0xbb, 0xfe, 0x19, 0x8b,
-	0x4c, 0x5d, 0xf0, 0xf6, 0xea, 0x78, 0x47, 0xb9, 0x30, 0x43, 0xde, 0x94, 0x48, 0x43, 0x9d, 0x3b,
-	0x0b, 0x96, 0xf5, 0x1a, 0x0c, 0xd5, 0x06, 0xde, 0x01, 0xfd, 0x82, 0x25, 0x26, 0xea, 0xa0, 0x9e,
-	0xe1, 0xcc, 0x3f, 0xf1, 0x43, 0x58, 0x17, 0x09, 0xcc, 0x46, 0x07, 0xf5, 0x9a, 0xfb, 0xb7, 0x55,
-	0xcd, 0x01, 0x4b, 0x64, 0xc1, 0x13, 0xc6, 0x9d, 0x4c, 0xf4, 0xb4, 0xf1, 0x04, 0x59, 0x27, 0xd0,
-	0x2c, 0x34, 0x54, 0x81, 0xa4, 0x65, 0xa4, 0xa9, 0x90, 0xc2, 0x56, 0x0d, 0x7d, 0x0f, 0xad, 0x72,
-	0x57, 0x15, 0xdc, 0xc7, 0x65, 0xee, 0x5d, 0xc5, 0xcd, 0x9d, 0x95, 0xe8, 0xee, 0x0f, 0x04, 0xed,
-	0x25, 0x05, 0x3e, 0x05, 0x70, 0x39, 0x0f, 0xbd, 0x61, 0xcc, 0x59, 0xbe, 0x05, 0xbd, 0x3a, 0x1e,
-	0x7d, 0xa1, 0xa4, 0xd9, 0xc0, 0xb1, 0x1c, 0x38, 0x2c, 0x2e, 0x9c, 0x02, 0xcf, 0x7a, 0x0e, 0xed,
-	0x25, 0x4b, 0x45, 0x37, 0xb7, 0x8a, 0xdd, 0x18, 0xc5, 0xc0, 0xa7, 0x80, 0x57, 0x3b, 0xc2, 0x87,
-	0xb0, 0xc9, 0xc6, 0x6c, 0xc2, 0x7c, 0x9e, 0x07, 0x36, 0xeb, 0x02, 0xf7, 0x77, 0x64, 0xc0, 0xcd,
-	0x03, 0xe9, 0x70, 0x94, 0x77, 0x3e, 0x8e, 0xed, 0xd2, 0xdb, 0x62, 0x67, 0x85, 0xfc, 0xa0, 0x7a,
-	0x0b, 0x68, 0x8e, 0xcb, 0xc6, 0xf0, 0x97, 0x2a, 0xd6, 0x11, 0x6c, 0x97, 0xc4, 0x15, 0x03, 0xe8,
-	0x96, 0x9f, 0x73, 0x4b, 0xd5, 0x3c, 0xf6, 0xc6, 0xc5, 0x71, 0xac, 0x83, 0x7e, 0xec, 0x8d, 0xbb,
-	0xdf, 0x11, 0xb4, 0x97, 0x16, 0x08, 0xbf, 0x59, 0x49, 0xbe, 0x57, 0xb7, 0x6c, 0xff, 0x91, 0xfd,
-	0xd9, 0xbf, 0xb3, 0xd7, 0x3e, 0x5e, 0xdf, 0x9e, 0xce, 0x88, 0x76, 0x39, 0x23, 0xda, 0xd5, 0x8c,
-	0x68, 0x5f, 0x53, 0x82, 0xa6, 0x29, 0x41, 0x97, 0x29, 0x41, 0x57, 0x29, 0x41, 0x3f, 0x53, 0x82,
-	0xbe, 0xfd, 0x22, 0xda, 0x07, 0x83, 0xda, 0x32, 0xe7, 0x9f, 0x00, 0x00, 0x00, 0xff, 0xff, 0x83,
-	0x7e, 0xe5, 0x1f, 0xef, 0x04, 0x00, 0x00,
+	// 501 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x93, 0xdd, 0x6a, 0xd4, 0x40,
+	0x14, 0xc7, 0x33, 0xbb, 0x2e, 0x36, 0x67, 0xed, 0x76, 0x1d, 0x85, 0x86, 0x28, 0xd3, 0x12, 0x50,
+	0x16, 0xa1, 0x09, 0xee, 0x95, 0x28, 0x5e, 0xb4, 0xd8, 0x95, 0xde, 0x14, 0x4c, 0xc1, 0x2f, 0x16,
+	0x21, 0x5b, 0x67, 0x63, 0x30, 0x9b, 0x48, 0x32, 0x29, 0xf4, 0xce, 0x47, 0xf0, 0x09, 0x7c, 0x02,
+	0x11, 0x1f, 0x63, 0x2f, 0x7b, 0xd9, 0xab, 0xe2, 0xc6, 0x17, 0x91, 0x9d, 0x4c, 0x3e, 0x37, 0xd9,
+	0xd2, 0xbb, 0xcc, 0x99, 0xff, 0xf9, 0x9d, 0x73, 0xfe, 0x73, 0x02, 0xdb, 0x53, 0x6a, 0xb1, 0x28,
+	0xa0, 0x86, 0x4d, 0x3d, 0x1a, 0x58, 0x8c, 0x7e, 0xd6, 0xbf, 0x05, 0x3e, 0xf3, 0xf1, 0x6d, 0x71,
+	0xa1, 0xee, 0xd9, 0x0e, 0xfb, 0x12, 0x4d, 0xf4, 0x53, 0x7f, 0x66, 0xd8, 0xbe, 0xed, 0x1b, 0xfc,
+	0x7e, 0x12, 0x4d, 0xf9, 0x89, 0x1f, 0xf8, 0x57, 0x92, 0xa7, 0xfd, 0x42, 0x70, 0x6f, 0x9f, 0xb1,
+	0xc0, 0x99, 0x44, 0x8c, 0x8e, 0x12, 0xc6, 0x09, 0x65, 0xf8, 0x3d, 0x6c, 0x50, 0x97, 0xce, 0xa8,
+	0xc7, 0x42, 0x05, 0xed, 0xb6, 0x07, 0xdd, 0xe1, 0x13, 0x5d, 0x94, 0xd0, 0x6b, 0xf4, 0xfa, 0xa1,
+	0x10, 0x1f, 0x7a, 0x2c, 0x38, 0x3f, 0xe8, 0xcf, 0xaf, 0x76, 0xa4, 0xf8, 0x6a, 0x67, 0x23, 0x0d,
+	0x9b, 0x19, 0x4d, 0x7d, 0x01, 0x9b, 0x25, 0x31, 0xee, 0x43, 0xfb, 0x2b, 0x3d, 0x57, 0xd0, 0x2e,
+	0x1a, 0xc8, 0xe6, 0xf2, 0x13, 0xdf, 0x87, 0xce, 0x99, 0xe5, 0x46, 0x54, 0x69, 0xf1, 0x58, 0x72,
+	0x78, 0xde, 0x7a, 0x86, 0xb4, 0x9f, 0xb7, 0xa0, 0xf7, 0xca, 0x9f, 0x59, 0x8e, 0x27, 0x6a, 0x87,
+	0xf8, 0x35, 0x74, 0xa6, 0xae, 0x65, 0xa7, 0x6d, 0x6a, 0x59, 0x9b, 0x65, 0x9d, 0x3e, 0x5a, 0x8a,
+	0x92, 0xf6, 0x36, 0x45, 0x7b, 0x1d, 0x1e, 0x33, 0x93, 0x7c, 0xfc, 0x09, 0xba, 0x67, 0x56, 0x3a,
+	0x5a, 0xa8, 0xb4, 0x38, 0x6e, 0xd0, 0x84, 0x7b, 0x9b, 0x4b, 0x13, 0x28, 0x16, 0x50, 0xc8, 0xec,
+	0x09, 0xcd, 0x22, 0x10, 0xbf, 0x03, 0xd9, 0xf1, 0x42, 0x66, 0x79, 0xa7, 0x34, 0x54, 0xda, 0x9c,
+	0xfe, 0xb8, 0x89, 0x7e, 0x94, 0x0a, 0x13, 0xf6, 0x5d, 0xc1, 0x96, 0xb3, 0xb8, 0x99, 0xb3, 0xd4,
+	0x37, 0x00, 0xf9, 0x70, 0x35, 0x76, 0xee, 0x15, 0xed, 0xec, 0x0e, 0xb7, 0xb3, 0xa2, 0xcb, 0xac,
+	0xfc, 0x0d, 0x0b, 0x3e, 0xab, 0x63, 0xe8, 0x57, 0x07, 0xac, 0x01, 0x0f, 0xcb, 0xe0, 0x87, 0xeb,
+	0x36, 0xa4, 0x48, 0xff, 0x00, 0xbd, 0xf2, 0x80, 0x35, 0xec, 0xa7, 0x65, 0xf6, 0x83, 0x8c, 0x9d,
+	0x66, 0xd6, 0xa2, 0xb5, 0x3f, 0x08, 0x7a, 0xe5, 0xb1, 0xf0, 0xc9, 0xca, 0x2a, 0x3f, 0x6a, 0x70,
+	0xe0, 0x06, 0x5b, 0x7c, 0x74, 0xfd, 0x16, 0x6b, 0xe5, 0x09, 0xee, 0x64, 0x45, 0x8f, 0x1d, 0xb7,
+	0xd8, 0xf2, 0x6f, 0x04, 0x5b, 0x95, 0xa1, 0xf0, 0x18, 0xa0, 0xb0, 0x8a, 0xa8, 0xb2, 0x8a, 0x15,
+	0x75, 0x6e, 0xf7, 0x9a, 0x55, 0x2c, 0xf0, 0xd4, 0x97, 0xb0, 0xb5, 0x7f, 0xed, 0xe3, 0x36, 0xff,
+	0x84, 0x63, 0xc0, 0xab, 0x8f, 0x80, 0x47, 0x2b, 0x36, 0x2b, 0x4d, 0x0d, 0xaf, 0x73, 0x56, 0xeb,
+	0x40, 0xfb, 0xd8, 0x71, 0x0f, 0x8c, 0xf9, 0x82, 0x48, 0x17, 0x0b, 0x22, 0x5d, 0x2e, 0x88, 0xf4,
+	0x3d, 0x26, 0x68, 0x1e, 0x13, 0x74, 0x11, 0x13, 0x74, 0x19, 0x13, 0xf4, 0x37, 0x26, 0xe8, 0xc7,
+	0x3f, 0x22, 0x7d, 0x94, 0x75, 0x43, 0xd4, 0xf8, 0x1f, 0x00, 0x00, 0xff, 0xff, 0x3a, 0x32, 0x3a,
+	0xd7, 0x1b, 0x05, 0x00, 0x00,
+}
+
+func (m *AttributeFeatureSet) 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 *AttributeFeatureSet) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *AttributeFeatureSet) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if len(m.Elements) > 0 {
+		keysForElements := make([]string, 0, len(m.Elements))
+		for k := range m.Elements {
+			keysForElements = append(keysForElements, string(k))
+		}
+		github_com_gogo_protobuf_sortkeys.Strings(keysForElements)
+		for iNdEx := len(keysForElements) - 1; iNdEx >= 0; iNdEx-- {
+			v := m.Elements[string(keysForElements[iNdEx])]
+			baseI := i
+			i -= len(v)
+			copy(dAtA[i:], v)
+			i = encodeVarintGenerated(dAtA, i, uint64(len(v)))
+			i--
+			dAtA[i] = 0x12
+			i -= len(keysForElements[iNdEx])
+			copy(dAtA[i:], keysForElements[iNdEx])
+			i = encodeVarintGenerated(dAtA, i, uint64(len(keysForElements[iNdEx])))
+			i--
+			dAtA[i] = 0xa
+			i = encodeVarintGenerated(dAtA, i, uint64(baseI-i))
+			i--
+			dAtA[i] = 0xa
+		}
+	}
+	return len(dAtA) - i, nil
 }
 
 func (m *DomainFeatures) Marshal() (dAtA []byte, err error) {
@@ -313,14 +360,14 @@ func (m *DomainFeatures) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 			dAtA[i] = 0x1a
 		}
 	}
-	if len(m.Values) > 0 {
-		keysForValues := make([]string, 0, len(m.Values))
-		for k := range m.Values {
-			keysForValues = append(keysForValues, string(k))
+	if len(m.Attributes) > 0 {
+		keysForAttributes := make([]string, 0, len(m.Attributes))
+		for k := range m.Attributes {
+			keysForAttributes = append(keysForAttributes, string(k))
 		}
-		github_com_gogo_protobuf_sortkeys.Strings(keysForValues)
-		for iNdEx := len(keysForValues) - 1; iNdEx >= 0; iNdEx-- {
-			v := m.Values[string(keysForValues[iNdEx])]
+		github_com_gogo_protobuf_sortkeys.Strings(keysForAttributes)
+		for iNdEx := len(keysForAttributes) - 1; iNdEx >= 0; iNdEx-- {
+			v := m.Attributes[string(keysForAttributes[iNdEx])]
 			baseI := i
 			{
 				size, err := (&v).MarshalToSizedBuffer(dAtA[:i])
@@ -332,9 +379,9 @@ func (m *DomainFeatures) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 			}
 			i--
 			dAtA[i] = 0x12
-			i -= len(keysForValues[iNdEx])
-			copy(dAtA[i:], keysForValues[iNdEx])
-			i = encodeVarintGenerated(dAtA, i, uint64(len(keysForValues[iNdEx])))
+			i -= len(keysForAttributes[iNdEx])
+			copy(dAtA[i:], keysForAttributes[iNdEx])
+			i = encodeVarintGenerated(dAtA, i, uint64(len(keysForAttributes[iNdEx])))
 			i--
 			dAtA[i] = 0xa
 			i = encodeVarintGenerated(dAtA, i, uint64(baseI-i))
@@ -342,14 +389,14 @@ func (m *DomainFeatures) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 			dAtA[i] = 0x12
 		}
 	}
-	if len(m.Keys) > 0 {
-		keysForKeys := make([]string, 0, len(m.Keys))
-		for k := range m.Keys {
-			keysForKeys = append(keysForKeys, string(k))
+	if len(m.Flags) > 0 {
+		keysForFlags := make([]string, 0, len(m.Flags))
+		for k := range m.Flags {
+			keysForFlags = append(keysForFlags, string(k))
 		}
-		github_com_gogo_protobuf_sortkeys.Strings(keysForKeys)
-		for iNdEx := len(keysForKeys) - 1; iNdEx >= 0; iNdEx-- {
-			v := m.Keys[string(keysForKeys[iNdEx])]
+		github_com_gogo_protobuf_sortkeys.Strings(keysForFlags)
+		for iNdEx := len(keysForFlags) - 1; iNdEx >= 0; iNdEx-- {
+			v := m.Flags[string(keysForFlags[iNdEx])]
 			baseI := i
 			{
 				size, err := (&v).MarshalToSizedBuffer(dAtA[:i])
@@ -361,9 +408,9 @@ func (m *DomainFeatures) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 			}
 			i--
 			dAtA[i] = 0x12
-			i -= len(keysForKeys[iNdEx])
-			copy(dAtA[i:], keysForKeys[iNdEx])
-			i = encodeVarintGenerated(dAtA, i, uint64(len(keysForKeys[iNdEx])))
+			i -= len(keysForFlags[iNdEx])
+			copy(dAtA[i:], keysForFlags[iNdEx])
+			i = encodeVarintGenerated(dAtA, i, uint64(len(keysForFlags[iNdEx])))
 			i--
 			dAtA[i] = 0xa
 			i = encodeVarintGenerated(dAtA, i, uint64(baseI-i))
@@ -374,7 +421,7 @@ func (m *DomainFeatures) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	return len(dAtA) - i, nil
 }
 
-func (m *InstanceFeature) Marshal() (dAtA []byte, err error) {
+func (m *FlagFeatureSet) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
 	n, err := m.MarshalToSizedBuffer(dAtA[:size])
@@ -384,33 +431,38 @@ func (m *InstanceFeature) Marshal() (dAtA []byte, err error) {
 	return dAtA[:n], nil
 }
 
-func (m *InstanceFeature) MarshalTo(dAtA []byte) (int, error) {
+func (m *FlagFeatureSet) MarshalTo(dAtA []byte) (int, error) {
 	size := m.Size()
 	return m.MarshalToSizedBuffer(dAtA[:size])
 }
 
-func (m *InstanceFeature) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+func (m *FlagFeatureSet) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	i := len(dAtA)
 	_ = i
 	var l int
 	_ = l
-	if len(m.Attributes) > 0 {
-		keysForAttributes := make([]string, 0, len(m.Attributes))
-		for k := range m.Attributes {
-			keysForAttributes = append(keysForAttributes, string(k))
+	if len(m.Elements) > 0 {
+		keysForElements := make([]string, 0, len(m.Elements))
+		for k := range m.Elements {
+			keysForElements = append(keysForElements, string(k))
 		}
-		github_com_gogo_protobuf_sortkeys.Strings(keysForAttributes)
-		for iNdEx := len(keysForAttributes) - 1; iNdEx >= 0; iNdEx-- {
-			v := m.Attributes[string(keysForAttributes[iNdEx])]
+		github_com_gogo_protobuf_sortkeys.Strings(keysForElements)
+		for iNdEx := len(keysForElements) - 1; iNdEx >= 0; iNdEx-- {
+			v := m.Elements[string(keysForElements[iNdEx])]
 			baseI := i
-			i -= len(v)
-			copy(dAtA[i:], v)
-			i = encodeVarintGenerated(dAtA, i, uint64(len(v)))
+			{
+				size, err := (&v).MarshalToSizedBuffer(dAtA[:i])
+				if err != nil {
+					return 0, err
+				}
+				i -= size
+				i = encodeVarintGenerated(dAtA, i, uint64(size))
+			}
 			i--
 			dAtA[i] = 0x12
-			i -= len(keysForAttributes[iNdEx])
-			copy(dAtA[i:], keysForAttributes[iNdEx])
-			i = encodeVarintGenerated(dAtA, i, uint64(len(keysForAttributes[iNdEx])))
+			i -= len(keysForElements[iNdEx])
+			copy(dAtA[i:], keysForElements[iNdEx])
+			i = encodeVarintGenerated(dAtA, i, uint64(len(keysForElements[iNdEx])))
 			i--
 			dAtA[i] = 0xa
 			i = encodeVarintGenerated(dAtA, i, uint64(baseI-i))
@@ -421,7 +473,7 @@ func (m *InstanceFeature) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	return len(dAtA) - i, nil
 }
 
-func (m *InstanceFeatureSet) Marshal() (dAtA []byte, err error) {
+func (m *InstanceFeature) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
 	n, err := m.MarshalToSizedBuffer(dAtA[:size])
@@ -431,26 +483,36 @@ func (m *InstanceFeatureSet) Marshal() (dAtA []byte, err error) {
 	return dAtA[:n], nil
 }
 
-func (m *InstanceFeatureSet) MarshalTo(dAtA []byte) (int, error) {
+func (m *InstanceFeature) MarshalTo(dAtA []byte) (int, error) {
 	size := m.Size()
 	return m.MarshalToSizedBuffer(dAtA[:size])
 }
 
-func (m *InstanceFeatureSet) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+func (m *InstanceFeature) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	i := len(dAtA)
 	_ = i
 	var l int
 	_ = l
-	if len(m.Elements) > 0 {
-		for iNdEx := len(m.Elements) - 1; iNdEx >= 0; iNdEx-- {
-			{
-				size, err := m.Elements[iNdEx].MarshalToSizedBuffer(dAtA[:i])
-				if err != nil {
-					return 0, err
-				}
-				i -= size
-				i = encodeVarintGenerated(dAtA, i, uint64(size))
-			}
+	if len(m.Attributes) > 0 {
+		keysForAttributes := make([]string, 0, len(m.Attributes))
+		for k := range m.Attributes {
+			keysForAttributes = append(keysForAttributes, string(k))
+		}
+		github_com_gogo_protobuf_sortkeys.Strings(keysForAttributes)
+		for iNdEx := len(keysForAttributes) - 1; iNdEx >= 0; iNdEx-- {
+			v := m.Attributes[string(keysForAttributes[iNdEx])]
+			baseI := i
+			i -= len(v)
+			copy(dAtA[i:], v)
+			i = encodeVarintGenerated(dAtA, i, uint64(len(v)))
+			i--
+			dAtA[i] = 0x12
+			i -= len(keysForAttributes[iNdEx])
+			copy(dAtA[i:], keysForAttributes[iNdEx])
+			i = encodeVarintGenerated(dAtA, i, uint64(len(keysForAttributes[iNdEx])))
+			i--
+			dAtA[i] = 0xa
+			i = encodeVarintGenerated(dAtA, i, uint64(baseI-i))
 			i--
 			dAtA[i] = 0xa
 		}
@@ -458,7 +520,7 @@ func (m *InstanceFeatureSet) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	return len(dAtA) - i, nil
 }
 
-func (m *KeyFeatureSet) Marshal() (dAtA []byte, err error) {
+func (m *InstanceFeatureSet) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
 	n, err := m.MarshalToSizedBuffer(dAtA[:size])
@@ -468,27 +530,20 @@ func (m *KeyFeatureSet) Marshal() (dAtA []byte, err error) {
 	return dAtA[:n], nil
 }
 
-func (m *KeyFeatureSet) MarshalTo(dAtA []byte) (int, error) {
+func (m *InstanceFeatureSet) MarshalTo(dAtA []byte) (int, error) {
 	size := m.Size()
 	return m.MarshalToSizedBuffer(dAtA[:size])
 }
 
-func (m *KeyFeatureSet) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+func (m *InstanceFeatureSet) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	i := len(dAtA)
 	_ = i
 	var l int
 	_ = l
 	if len(m.Elements) > 0 {
-		keysForElements := make([]string, 0, len(m.Elements))
-		for k := range m.Elements {
-			keysForElements = append(keysForElements, string(k))
-		}
-		github_com_gogo_protobuf_sortkeys.Strings(keysForElements)
-		for iNdEx := len(keysForElements) - 1; iNdEx >= 0; iNdEx-- {
-			v := m.Elements[string(keysForElements[iNdEx])]
-			baseI := i
+		for iNdEx := len(m.Elements) - 1; iNdEx >= 0; iNdEx-- {
 			{
-				size, err := (&v).MarshalToSizedBuffer(dAtA[:i])
+				size, err := m.Elements[iNdEx].MarshalToSizedBuffer(dAtA[:i])
 				if err != nil {
 					return 0, err
 				}
@@ -496,14 +551,6 @@ func (m *KeyFeatureSet) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 				i = encodeVarintGenerated(dAtA, i, uint64(size))
 			}
 			i--
-			dAtA[i] = 0x12
-			i -= len(keysForElements[iNdEx])
-			copy(dAtA[i:], keysForElements[iNdEx])
-			i = encodeVarintGenerated(dAtA, i, uint64(len(keysForElements[iNdEx])))
-			i--
-			dAtA[i] = 0xa
-			i = encodeVarintGenerated(dAtA, i, uint64(baseI-i))
-			i--
 			dAtA[i] = 0xa
 		}
 	}
@@ -533,53 +580,6 @@ func (m *Nil) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	return len(dAtA) - i, nil
 }
 
-func (m *ValueFeatureSet) 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 *ValueFeatureSet) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *ValueFeatureSet) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
-	_ = i
-	var l int
-	_ = l
-	if len(m.Elements) > 0 {
-		keysForElements := make([]string, 0, len(m.Elements))
-		for k := range m.Elements {
-			keysForElements = append(keysForElements, string(k))
-		}
-		github_com_gogo_protobuf_sortkeys.Strings(keysForElements)
-		for iNdEx := len(keysForElements) - 1; iNdEx >= 0; iNdEx-- {
-			v := m.Elements[string(keysForElements[iNdEx])]
-			baseI := i
-			i -= len(v)
-			copy(dAtA[i:], v)
-			i = encodeVarintGenerated(dAtA, i, uint64(len(v)))
-			i--
-			dAtA[i] = 0x12
-			i -= len(keysForElements[iNdEx])
-			copy(dAtA[i:], keysForElements[iNdEx])
-			i = encodeVarintGenerated(dAtA, i, uint64(len(keysForElements[iNdEx])))
-			i--
-			dAtA[i] = 0xa
-			i = encodeVarintGenerated(dAtA, i, uint64(baseI-i))
-			i--
-			dAtA[i] = 0xa
-		}
-	}
-	return len(dAtA) - i, nil
-}
-
 func encodeVarintGenerated(dAtA []byte, offset int, v uint64) int {
 	offset -= sovGenerated(v)
 	base := offset
@@ -591,14 +591,31 @@ func encodeVarintGenerated(dAtA []byte, offset int, v uint64) int {
 	dAtA[offset] = uint8(v)
 	return base
 }
+func (m *AttributeFeatureSet) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if len(m.Elements) > 0 {
+		for k, v := range m.Elements {
+			_ = k
+			_ = v
+			mapEntrySize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + len(v) + sovGenerated(uint64(len(v)))
+			n += mapEntrySize + 1 + sovGenerated(uint64(mapEntrySize))
+		}
+	}
+	return n
+}
+
 func (m *DomainFeatures) Size() (n int) {
 	if m == nil {
 		return 0
 	}
 	var l int
 	_ = l
-	if len(m.Keys) > 0 {
-		for k, v := range m.Keys {
+	if len(m.Flags) > 0 {
+		for k, v := range m.Flags {
 			_ = k
 			_ = v
 			l = v.Size()
@@ -606,8 +623,8 @@ func (m *DomainFeatures) Size() (n int) {
 			n += mapEntrySize + 1 + sovGenerated(uint64(mapEntrySize))
 		}
 	}
-	if len(m.Values) > 0 {
-		for k, v := range m.Values {
+	if len(m.Attributes) > 0 {
+		for k, v := range m.Attributes {
 			_ = k
 			_ = v
 			l = v.Size()
@@ -627,51 +644,51 @@ func (m *DomainFeatures) Size() (n int) {
 	return n
 }
 
-func (m *InstanceFeature) Size() (n int) {
+func (m *FlagFeatureSet) Size() (n int) {
 	if m == nil {
 		return 0
 	}
 	var l int
 	_ = l
-	if len(m.Attributes) > 0 {
-		for k, v := range m.Attributes {
+	if len(m.Elements) > 0 {
+		for k, v := range m.Elements {
 			_ = k
 			_ = v
-			mapEntrySize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + len(v) + sovGenerated(uint64(len(v)))
+			l = v.Size()
+			mapEntrySize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + l + sovGenerated(uint64(l))
 			n += mapEntrySize + 1 + sovGenerated(uint64(mapEntrySize))
 		}
 	}
 	return n
 }
 
-func (m *InstanceFeatureSet) Size() (n int) {
+func (m *InstanceFeature) Size() (n int) {
 	if m == nil {
 		return 0
 	}
 	var l int
 	_ = l
-	if len(m.Elements) > 0 {
-		for _, e := range m.Elements {
-			l = e.Size()
-			n += 1 + l + sovGenerated(uint64(l))
+	if len(m.Attributes) > 0 {
+		for k, v := range m.Attributes {
+			_ = k
+			_ = v
+			mapEntrySize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + len(v) + sovGenerated(uint64(len(v)))
+			n += mapEntrySize + 1 + sovGenerated(uint64(mapEntrySize))
 		}
 	}
 	return n
 }
 
-func (m *KeyFeatureSet) Size() (n int) {
+func (m *InstanceFeatureSet) Size() (n int) {
 	if m == nil {
 		return 0
 	}
 	var l int
 	_ = l
 	if len(m.Elements) > 0 {
-		for k, v := range m.Elements {
-			_ = k
-			_ = v
-			l = v.Size()
-			mapEntrySize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + l + sovGenerated(uint64(l))
-			n += mapEntrySize + 1 + sovGenerated(uint64(mapEntrySize))
+		for _, e := range m.Elements {
+			l = e.Size()
+			n += 1 + l + sovGenerated(uint64(l))
 		}
 	}
 	return n
@@ -686,53 +703,56 @@ func (m *Nil) Size() (n int) {
 	return n
 }
 
-func (m *ValueFeatureSet) Size() (n int) {
-	if m == nil {
-		return 0
-	}
-	var l int
-	_ = l
-	if len(m.Elements) > 0 {
-		for k, v := range m.Elements {
-			_ = k
-			_ = v
-			mapEntrySize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + len(v) + sovGenerated(uint64(len(v)))
-			n += mapEntrySize + 1 + sovGenerated(uint64(mapEntrySize))
-		}
-	}
-	return n
-}
-
 func sovGenerated(x uint64) (n int) {
 	return (math_bits.Len64(x|1) + 6) / 7
 }
 func sozGenerated(x uint64) (n int) {
 	return sovGenerated(uint64((x << 1) ^ uint64((int64(x) >> 63))))
 }
+func (this *AttributeFeatureSet) String() string {
+	if this == nil {
+		return "nil"
+	}
+	keysForElements := make([]string, 0, len(this.Elements))
+	for k := range this.Elements {
+		keysForElements = append(keysForElements, k)
+	}
+	github_com_gogo_protobuf_sortkeys.Strings(keysForElements)
+	mapStringForElements := "map[string]string{"
+	for _, k := range keysForElements {
+		mapStringForElements += fmt.Sprintf("%v: %v,", k, this.Elements[k])
+	}
+	mapStringForElements += "}"
+	s := strings.Join([]string{`&AttributeFeatureSet{`,
+		`Elements:` + mapStringForElements + `,`,
+		`}`,
+	}, "")
+	return s
+}
 func (this *DomainFeatures) String() string {
 	if this == nil {
 		return "nil"
 	}
-	keysForKeys := make([]string, 0, len(this.Keys))
-	for k := range this.Keys {
-		keysForKeys = append(keysForKeys, k)
+	keysForFlags := make([]string, 0, len(this.Flags))
+	for k := range this.Flags {
+		keysForFlags = append(keysForFlags, k)
 	}
-	github_com_gogo_protobuf_sortkeys.Strings(keysForKeys)
-	mapStringForKeys := "map[string]KeyFeatureSet{"
-	for _, k := range keysForKeys {
-		mapStringForKeys += fmt.Sprintf("%v: %v,", k, this.Keys[k])
+	github_com_gogo_protobuf_sortkeys.Strings(keysForFlags)
+	mapStringForFlags := "map[string]FlagFeatureSet{"
+	for _, k := range keysForFlags {
+		mapStringForFlags += fmt.Sprintf("%v: %v,", k, this.Flags[k])
 	}
-	mapStringForKeys += "}"
-	keysForValues := make([]string, 0, len(this.Values))
-	for k := range this.Values {
-		keysForValues = append(keysForValues, k)
+	mapStringForFlags += "}"
+	keysForAttributes := make([]string, 0, len(this.Attributes))
+	for k := range this.Attributes {
+		keysForAttributes = append(keysForAttributes, k)
 	}
-	github_com_gogo_protobuf_sortkeys.Strings(keysForValues)
-	mapStringForValues := "map[string]ValueFeatureSet{"
-	for _, k := range keysForValues {
-		mapStringForValues += fmt.Sprintf("%v: %v,", k, this.Values[k])
+	github_com_gogo_protobuf_sortkeys.Strings(keysForAttributes)
+	mapStringForAttributes := "map[string]AttributeFeatureSet{"
+	for _, k := range keysForAttributes {
+		mapStringForAttributes += fmt.Sprintf("%v: %v,", k, this.Attributes[k])
 	}
-	mapStringForValues += "}"
+	mapStringForAttributes += "}"
 	keysForInstances := make([]string, 0, len(this.Instances))
 	for k := range this.Instances {
 		keysForInstances = append(keysForInstances, k)
@@ -744,13 +764,33 @@ func (this *DomainFeatures) String() string {
 	}
 	mapStringForInstances += "}"
 	s := strings.Join([]string{`&DomainFeatures{`,
-		`Keys:` + mapStringForKeys + `,`,
-		`Values:` + mapStringForValues + `,`,
+		`Flags:` + mapStringForFlags + `,`,
+		`Attributes:` + mapStringForAttributes + `,`,
 		`Instances:` + mapStringForInstances + `,`,
 		`}`,
 	}, "")
 	return s
 }
+func (this *FlagFeatureSet) String() string {
+	if this == nil {
+		return "nil"
+	}
+	keysForElements := make([]string, 0, len(this.Elements))
+	for k := range this.Elements {
+		keysForElements = append(keysForElements, k)
+	}
+	github_com_gogo_protobuf_sortkeys.Strings(keysForElements)
+	mapStringForElements := "map[string]Nil{"
+	for _, k := range keysForElements {
+		mapStringForElements += fmt.Sprintf("%v: %v,", k, this.Elements[k])
+	}
+	mapStringForElements += "}"
+	s := strings.Join([]string{`&FlagFeatureSet{`,
+		`Elements:` + mapStringForElements + `,`,
+		`}`,
+	}, "")
+	return s
+}
 func (this *InstanceFeature) String() string {
 	if this == nil {
 		return "nil"
@@ -786,26 +826,6 @@ func (this *InstanceFeatureSet) String() string {
 	}, "")
 	return s
 }
-func (this *KeyFeatureSet) String() string {
-	if this == nil {
-		return "nil"
-	}
-	keysForElements := make([]string, 0, len(this.Elements))
-	for k := range this.Elements {
-		keysForElements = append(keysForElements, k)
-	}
-	github_com_gogo_protobuf_sortkeys.Strings(keysForElements)
-	mapStringForElements := "map[string]Nil{"
-	for _, k := range keysForElements {
-		mapStringForElements += fmt.Sprintf("%v: %v,", k, this.Elements[k])
-	}
-	mapStringForElements += "}"
-	s := strings.Join([]string{`&KeyFeatureSet{`,
-		`Elements:` + mapStringForElements + `,`,
-		`}`,
-	}, "")
-	return s
-}
 func (this *Nil) String() string {
 	if this == nil {
 		return "nil"
@@ -815,26 +835,6 @@ func (this *Nil) String() string {
 	}, "")
 	return s
 }
-func (this *ValueFeatureSet) String() string {
-	if this == nil {
-		return "nil"
-	}
-	keysForElements := make([]string, 0, len(this.Elements))
-	for k := range this.Elements {
-		keysForElements = append(keysForElements, k)
-	}
-	github_com_gogo_protobuf_sortkeys.Strings(keysForElements)
-	mapStringForElements := "map[string]string{"
-	for _, k := range keysForElements {
-		mapStringForElements += fmt.Sprintf("%v: %v,", k, this.Elements[k])
-	}
-	mapStringForElements += "}"
-	s := strings.Join([]string{`&ValueFeatureSet{`,
-		`Elements:` + mapStringForElements + `,`,
-		`}`,
-	}, "")
-	return s
-}
 func valueToStringGenerated(v interface{}) string {
 	rv := reflect.ValueOf(v)
 	if rv.IsNil() {
@@ -843,7 +843,7 @@ func valueToStringGenerated(v interface{}) string {
 	pv := reflect.Indirect(rv).Interface()
 	return fmt.Sprintf("*%v", pv)
 }
-func (m *DomainFeatures) Unmarshal(dAtA []byte) error {
+func (m *AttributeFeatureSet) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -866,15 +866,15 @@ func (m *DomainFeatures) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: DomainFeatures: wiretype end group for non-group")
+			return fmt.Errorf("proto: AttributeFeatureSet: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: DomainFeatures: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: AttributeFeatureSet: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Keys", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Elements", wireType)
 			}
 			var msglen int
 			for shift := uint(0); ; shift += 7 {
@@ -901,11 +901,11 @@ func (m *DomainFeatures) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			if m.Keys == nil {
-				m.Keys = make(map[string]KeyFeatureSet)
+			if m.Elements == nil {
+				m.Elements = make(map[string]string)
 			}
 			var mapkey string
-			mapvalue := &KeyFeatureSet{}
+			var mapvalue string
 			for iNdEx < postIndex {
 				entryPreIndex := iNdEx
 				var wire uint64
@@ -954,7 +954,7 @@ func (m *DomainFeatures) Unmarshal(dAtA []byte) error {
 					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
 					iNdEx = postStringIndexmapkey
 				} else if fieldNum == 2 {
-					var mapmsglen int
+					var stringLenmapvalue uint64
 					for shift := uint(0); ; shift += 7 {
 						if shift >= 64 {
 							return ErrIntOverflowGenerated
@@ -964,26 +964,24 @@ func (m *DomainFeatures) Unmarshal(dAtA []byte) error {
 						}
 						b := dAtA[iNdEx]
 						iNdEx++
-						mapmsglen |= int(b&0x7F) << shift
+						stringLenmapvalue |= uint64(b&0x7F) << shift
 						if b < 0x80 {
 							break
 						}
 					}
-					if mapmsglen < 0 {
+					intStringLenmapvalue := int(stringLenmapvalue)
+					if intStringLenmapvalue < 0 {
 						return ErrInvalidLengthGenerated
 					}
-					postmsgIndex := iNdEx + mapmsglen
-					if postmsgIndex < 0 {
+					postStringIndexmapvalue := iNdEx + intStringLenmapvalue
+					if postStringIndexmapvalue < 0 {
 						return ErrInvalidLengthGenerated
 					}
-					if postmsgIndex > l {
+					if postStringIndexmapvalue > l {
 						return io.ErrUnexpectedEOF
 					}
-					mapvalue = &KeyFeatureSet{}
-					if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
-						return err
-					}
-					iNdEx = postmsgIndex
+					mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
+					iNdEx = postStringIndexmapvalue
 				} else {
 					iNdEx = entryPreIndex
 					skippy, err := skipGenerated(dAtA[iNdEx:])
@@ -999,11 +997,61 @@ func (m *DomainFeatures) Unmarshal(dAtA []byte) error {
 					iNdEx += skippy
 				}
 			}
-			m.Keys[mapkey] = *mapvalue
+			m.Elements[mapkey] = mapvalue
 			iNdEx = postIndex
-		case 2:
+		default:
+			iNdEx = preIndex
+			skippy, err := skipGenerated(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLengthGenerated
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *DomainFeatures) 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 ErrIntOverflowGenerated
+			}
+			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: DomainFeatures: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: DomainFeatures: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Values", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Flags", wireType)
 			}
 			var msglen int
 			for shift := uint(0); ; shift += 7 {
@@ -1030,11 +1078,11 @@ func (m *DomainFeatures) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			if m.Values == nil {
-				m.Values = make(map[string]ValueFeatureSet)
+			if m.Flags == nil {
+				m.Flags = make(map[string]FlagFeatureSet)
 			}
 			var mapkey string
-			mapvalue := &ValueFeatureSet{}
+			mapvalue := &FlagFeatureSet{}
 			for iNdEx < postIndex {
 				entryPreIndex := iNdEx
 				var wire uint64
@@ -1108,7 +1156,7 @@ func (m *DomainFeatures) Unmarshal(dAtA []byte) error {
 					if postmsgIndex > l {
 						return io.ErrUnexpectedEOF
 					}
-					mapvalue = &ValueFeatureSet{}
+					mapvalue = &FlagFeatureSet{}
 					if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
 						return err
 					}
@@ -1128,11 +1176,11 @@ func (m *DomainFeatures) Unmarshal(dAtA []byte) error {
 					iNdEx += skippy
 				}
 			}
-			m.Values[mapkey] = *mapvalue
+			m.Flags[mapkey] = *mapvalue
 			iNdEx = postIndex
-		case 3:
+		case 2:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Instances", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Attributes", wireType)
 			}
 			var msglen int
 			for shift := uint(0); ; shift += 7 {
@@ -1159,11 +1207,11 @@ func (m *DomainFeatures) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			if m.Instances == nil {
-				m.Instances = make(map[string]InstanceFeatureSet)
+			if m.Attributes == nil {
+				m.Attributes = make(map[string]AttributeFeatureSet)
 			}
 			var mapkey string
-			mapvalue := &InstanceFeatureSet{}
+			mapvalue := &AttributeFeatureSet{}
 			for iNdEx < postIndex {
 				entryPreIndex := iNdEx
 				var wire uint64
@@ -1237,7 +1285,7 @@ func (m *DomainFeatures) Unmarshal(dAtA []byte) error {
 					if postmsgIndex > l {
 						return io.ErrUnexpectedEOF
 					}
-					mapvalue = &InstanceFeatureSet{}
+					mapvalue = &AttributeFeatureSet{}
 					if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
 						return err
 					}
@@ -1257,61 +1305,11 @@ func (m *DomainFeatures) Unmarshal(dAtA []byte) error {
 					iNdEx += skippy
 				}
 			}
-			m.Instances[mapkey] = *mapvalue
+			m.Attributes[mapkey] = *mapvalue
 			iNdEx = postIndex
-		default:
-			iNdEx = preIndex
-			skippy, err := skipGenerated(dAtA[iNdEx:])
-			if err != nil {
-				return err
-			}
-			if (skippy < 0) || (iNdEx+skippy) < 0 {
-				return ErrInvalidLengthGenerated
-			}
-			if (iNdEx + skippy) > l {
-				return io.ErrUnexpectedEOF
-			}
-			iNdEx += skippy
-		}
-	}
-
-	if iNdEx > l {
-		return io.ErrUnexpectedEOF
-	}
-	return nil
-}
-func (m *InstanceFeature) 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 ErrIntOverflowGenerated
-			}
-			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: InstanceFeature: wiretype end group for non-group")
-		}
-		if fieldNum <= 0 {
-			return fmt.Errorf("proto: InstanceFeature: illegal tag %d (wire type %d)", fieldNum, wire)
-		}
-		switch fieldNum {
-		case 1:
+		case 3:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Attributes", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Instances", wireType)
 			}
 			var msglen int
 			for shift := uint(0); ; shift += 7 {
@@ -1338,11 +1336,11 @@ func (m *InstanceFeature) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			if m.Attributes == nil {
-				m.Attributes = make(map[string]string)
+			if m.Instances == nil {
+				m.Instances = make(map[string]InstanceFeatureSet)
 			}
 			var mapkey string
-			var mapvalue string
+			mapvalue := &InstanceFeatureSet{}
 			for iNdEx < postIndex {
 				entryPreIndex := iNdEx
 				var wire uint64
@@ -1388,137 +1386,55 @@ func (m *InstanceFeature) Unmarshal(dAtA []byte) error {
 					if postStringIndexmapkey > l {
 						return io.ErrUnexpectedEOF
 					}
-					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
-					iNdEx = postStringIndexmapkey
-				} else if fieldNum == 2 {
-					var stringLenmapvalue uint64
-					for shift := uint(0); ; shift += 7 {
-						if shift >= 64 {
-							return ErrIntOverflowGenerated
-						}
-						if iNdEx >= l {
-							return io.ErrUnexpectedEOF
-						}
-						b := dAtA[iNdEx]
-						iNdEx++
-						stringLenmapvalue |= uint64(b&0x7F) << shift
-						if b < 0x80 {
-							break
-						}
-					}
-					intStringLenmapvalue := int(stringLenmapvalue)
-					if intStringLenmapvalue < 0 {
-						return ErrInvalidLengthGenerated
-					}
-					postStringIndexmapvalue := iNdEx + intStringLenmapvalue
-					if postStringIndexmapvalue < 0 {
-						return ErrInvalidLengthGenerated
-					}
-					if postStringIndexmapvalue > l {
-						return io.ErrUnexpectedEOF
-					}
-					mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
-					iNdEx = postStringIndexmapvalue
-				} else {
-					iNdEx = entryPreIndex
-					skippy, err := skipGenerated(dAtA[iNdEx:])
-					if err != nil {
-						return err
-					}
-					if (skippy < 0) || (iNdEx+skippy) < 0 {
-						return ErrInvalidLengthGenerated
-					}
-					if (iNdEx + skippy) > postIndex {
-						return io.ErrUnexpectedEOF
-					}
-					iNdEx += skippy
-				}
-			}
-			m.Attributes[mapkey] = mapvalue
-			iNdEx = postIndex
-		default:
-			iNdEx = preIndex
-			skippy, err := skipGenerated(dAtA[iNdEx:])
-			if err != nil {
-				return err
-			}
-			if (skippy < 0) || (iNdEx+skippy) < 0 {
-				return ErrInvalidLengthGenerated
-			}
-			if (iNdEx + skippy) > l {
-				return io.ErrUnexpectedEOF
-			}
-			iNdEx += skippy
-		}
-	}
-
-	if iNdEx > l {
-		return io.ErrUnexpectedEOF
-	}
-	return nil
-}
-func (m *InstanceFeatureSet) 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 ErrIntOverflowGenerated
-			}
-			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: InstanceFeatureSet: wiretype end group for non-group")
-		}
-		if fieldNum <= 0 {
-			return fmt.Errorf("proto: InstanceFeatureSet: illegal tag %d (wire type %d)", fieldNum, wire)
-		}
-		switch fieldNum {
-		case 1:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Elements", wireType)
-			}
-			var msglen int
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowGenerated
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				msglen |= int(b&0x7F) << shift
-				if b < 0x80 {
-					break
+					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
+					iNdEx = postStringIndexmapkey
+				} else if fieldNum == 2 {
+					var mapmsglen int
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return ErrIntOverflowGenerated
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						mapmsglen |= int(b&0x7F) << shift
+						if b < 0x80 {
+							break
+						}
+					}
+					if mapmsglen < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					postmsgIndex := iNdEx + mapmsglen
+					if postmsgIndex < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					if postmsgIndex > l {
+						return io.ErrUnexpectedEOF
+					}
+					mapvalue = &InstanceFeatureSet{}
+					if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
+						return err
+					}
+					iNdEx = postmsgIndex
+				} else {
+					iNdEx = entryPreIndex
+					skippy, err := skipGenerated(dAtA[iNdEx:])
+					if err != nil {
+						return err
+					}
+					if (skippy < 0) || (iNdEx+skippy) < 0 {
+						return ErrInvalidLengthGenerated
+					}
+					if (iNdEx + skippy) > postIndex {
+						return io.ErrUnexpectedEOF
+					}
+					iNdEx += skippy
 				}
 			}
-			if msglen < 0 {
-				return ErrInvalidLengthGenerated
-			}
-			postIndex := iNdEx + msglen
-			if postIndex < 0 {
-				return ErrInvalidLengthGenerated
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			m.Elements = append(m.Elements, InstanceFeature{})
-			if err := m.Elements[len(m.Elements)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
-				return err
-			}
+			m.Instances[mapkey] = *mapvalue
 			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
@@ -1541,7 +1457,7 @@ func (m *InstanceFeatureSet) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *KeyFeatureSet) Unmarshal(dAtA []byte) error {
+func (m *FlagFeatureSet) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -1564,10 +1480,10 @@ func (m *KeyFeatureSet) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: KeyFeatureSet: wiretype end group for non-group")
+			return fmt.Errorf("proto: FlagFeatureSet: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: KeyFeatureSet: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: FlagFeatureSet: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
@@ -1720,57 +1636,7 @@ func (m *KeyFeatureSet) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *Nil) 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 ErrIntOverflowGenerated
-			}
-			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: Nil: wiretype end group for non-group")
-		}
-		if fieldNum <= 0 {
-			return fmt.Errorf("proto: Nil: illegal tag %d (wire type %d)", fieldNum, wire)
-		}
-		switch fieldNum {
-		default:
-			iNdEx = preIndex
-			skippy, err := skipGenerated(dAtA[iNdEx:])
-			if err != nil {
-				return err
-			}
-			if (skippy < 0) || (iNdEx+skippy) < 0 {
-				return ErrInvalidLengthGenerated
-			}
-			if (iNdEx + skippy) > l {
-				return io.ErrUnexpectedEOF
-			}
-			iNdEx += skippy
-		}
-	}
-
-	if iNdEx > l {
-		return io.ErrUnexpectedEOF
-	}
-	return nil
-}
-func (m *ValueFeatureSet) Unmarshal(dAtA []byte) error {
+func (m *InstanceFeature) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -1793,15 +1659,15 @@ func (m *ValueFeatureSet) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: ValueFeatureSet: wiretype end group for non-group")
+			return fmt.Errorf("proto: InstanceFeature: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: ValueFeatureSet: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: InstanceFeature: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Elements", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Attributes", wireType)
 			}
 			var msglen int
 			for shift := uint(0); ; shift += 7 {
@@ -1828,8 +1694,8 @@ func (m *ValueFeatureSet) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			if m.Elements == nil {
-				m.Elements = make(map[string]string)
+			if m.Attributes == nil {
+				m.Attributes = make(map[string]string)
 			}
 			var mapkey string
 			var mapvalue string
@@ -1924,7 +1790,91 @@ func (m *ValueFeatureSet) Unmarshal(dAtA []byte) error {
 					iNdEx += skippy
 				}
 			}
-			m.Elements[mapkey] = mapvalue
+			m.Attributes[mapkey] = mapvalue
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipGenerated(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLengthGenerated
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *InstanceFeatureSet) 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 ErrIntOverflowGenerated
+			}
+			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: InstanceFeatureSet: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: InstanceFeatureSet: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Elements", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowGenerated
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthGenerated
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthGenerated
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Elements = append(m.Elements, InstanceFeature{})
+			if err := m.Elements[len(m.Elements)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
 			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
@@ -1947,6 +1897,56 @@ func (m *ValueFeatureSet) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
+func (m *Nil) 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 ErrIntOverflowGenerated
+			}
+			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: Nil: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: Nil: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		default:
+			iNdEx = preIndex
+			skippy, err := skipGenerated(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLengthGenerated
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
 func skipGenerated(dAtA []byte) (n int, err error) {
 	l := len(dAtA)
 	iNdEx := 0
diff --git a/pkg/api/feature/generated.proto b/pkg/api/feature/generated.proto
index 9ab6b7ad4..810414854 100644
--- a/pkg/api/feature/generated.proto
+++ b/pkg/api/feature/generated.proto
@@ -24,15 +24,25 @@ package feature;
 // Package-wide variables from generator "generated".
 option go_package = "sigs.k8s.io/node-feature-discovery/pkg/api/feature";
 
+// AttributeFeatureSet is a set of features having string value.
+message AttributeFeatureSet {
+  map<string, string> elements = 1;
+}
+
 // DomainFeatures is the collection of all discovered features of one domain.
 message DomainFeatures {
-  map<string, KeyFeatureSet> keys = 1;
+  map<string, FlagFeatureSet> flags = 1;
 
-  map<string, ValueFeatureSet> values = 2;
+  map<string, AttributeFeatureSet> vattributes = 2;
 
   map<string, InstanceFeatureSet> instances = 3;
 }
 
+// FlagFeatureSet is a set of simple features only containing names without values.
+message FlagFeatureSet {
+  map<string, Nil> elements = 1;
+}
+
 // InstanceFeature represents one instance of a complex features, e.g. a device.
 message InstanceFeature {
   map<string, string> attributes = 1;
@@ -43,17 +53,7 @@ message InstanceFeatureSet {
   repeated InstanceFeature elements = 1;
 }
 
-// KeyFeatureSet is a set of simple features only containing names without values.
-message KeyFeatureSet {
-  map<string, Nil> elements = 1;
-}
-
 // Nil is a dummy empty struct for protobuf compatibility
 message Nil {
 }
 
-// ValueFeatureSet is a set of features having string value.
-message ValueFeatureSet {
-  map<string, string> elements = 1;
-}
-
diff --git a/pkg/api/feature/types.go b/pkg/api/feature/types.go
index 4665ad63d..505081414 100644
--- a/pkg/api/feature/types.go
+++ b/pkg/api/feature/types.go
@@ -24,18 +24,18 @@ type Features map[string]*DomainFeatures
 
 // DomainFeatures is the collection of all discovered features of one domain.
 type DomainFeatures struct {
-	Keys      map[string]KeyFeatureSet      `protobuf:"bytes,1,rep,name=keys"`
-	Values    map[string]ValueFeatureSet    `protobuf:"bytes,2,rep,name=values"`
-	Instances map[string]InstanceFeatureSet `protobuf:"bytes,3,rep,name=instances"`
+	Flags      map[string]FlagFeatureSet      `protobuf:"bytes,1,rep,name=flags"`
+	Attributes map[string]AttributeFeatureSet `protobuf:"bytes,2,rep,name=vattributes"`
+	Instances  map[string]InstanceFeatureSet  `protobuf:"bytes,3,rep,name=instances"`
 }
 
-// KeyFeatureSet is a set of simple features only containing names without values.
-type KeyFeatureSet struct {
+// FlagFeatureSet is a set of simple features only containing names without values.
+type FlagFeatureSet struct {
 	Elements map[string]Nil `protobuf:"bytes,1,rep,name=elements"`
 }
 
-// ValueFeatureSet is a set of features having string value.
-type ValueFeatureSet struct {
+// AttributeFeatureSet is a set of features having string value.
+type AttributeFeatureSet struct {
 	Elements map[string]string `protobuf:"bytes,1,rep,name=elements"`
 }
 
diff --git a/pkg/apis/nfd/v1alpha1/rule.go b/pkg/apis/nfd/v1alpha1/rule.go
index 1237a6f19..1ed930269 100644
--- a/pkg/apis/nfd/v1alpha1/rule.go
+++ b/pkg/apis/nfd/v1alpha1/rule.go
@@ -178,12 +178,12 @@ func (m *FeatureMatcher) match(features map[string]*feature.DomainFeatures) (boo
 
 		var isMatch bool
 		var err error
-		if f, ok := domainFeatures.Keys[featureName]; ok {
+		if f, ok := domainFeatures.Flags[featureName]; ok {
 			m, v, e := term.MatchExpressions.MatchGetKeys(f.Elements)
 			isMatch = m
 			err = e
 			matches[domain][featureName] = v
-		} else if f, ok := domainFeatures.Values[featureName]; ok {
+		} else if f, ok := domainFeatures.Attributes[featureName]; ok {
 			m, v, e := term.MatchExpressions.MatchGetValues(f.Elements)
 			isMatch = m
 			err = e
diff --git a/pkg/nfd-master/nfd-master.go b/pkg/nfd-master/nfd-master.go
index 8913e83a1..dd7339e68 100644
--- a/pkg/nfd-master/nfd-master.go
+++ b/pkg/nfd-master/nfd-master.go
@@ -534,8 +534,8 @@ func (m *nfdMaster) crLabels(r *pb.SetLabelsRequest) map[string]string {
 			}
 
 			// Feed back rule output to features map for subsequent rules to match
-			feature.InsertFeatureValues(r.Features, nfdv1alpha1.RuleBackrefDomain, nfdv1alpha1.RuleBackrefFeature, ruleOut.Labels)
-			feature.InsertFeatureValues(r.Features, nfdv1alpha1.RuleBackrefDomain, nfdv1alpha1.RuleBackrefFeature, ruleOut.Vars)
+			feature.InsertAttributeFeatures(r.Features, nfdv1alpha1.RuleBackrefDomain, nfdv1alpha1.RuleBackrefFeature, ruleOut.Labels)
+			feature.InsertAttributeFeatures(r.Features, nfdv1alpha1.RuleBackrefDomain, nfdv1alpha1.RuleBackrefFeature, ruleOut.Vars)
 		}
 	}
 
diff --git a/source/cpu/cpu.go b/source/cpu/cpu.go
index 29a1695f0..cc7f50a28 100644
--- a/source/cpu/cpu.go
+++ b/source/cpu/cpu.go
@@ -140,54 +140,54 @@ func (s *cpuSource) GetLabels() (source.FeatureLabels, error) {
 	features := s.GetFeatures()
 
 	// CPUID
-	for f := range features.Keys[CpuidFeature].Elements {
+	for f := range features.Flags[CpuidFeature].Elements {
 		if s.cpuidFilter.unmask(f) {
 			labels["cpuid."+f] = true
 		}
 	}
 
 	// CPU model
-	for k, v := range features.Values[Cpumodel].Elements {
+	for k, v := range features.Attributes[Cpumodel].Elements {
 		labels["model."+k] = v
 	}
 
 	// Cstate
-	for k, v := range features.Values[CstateFeature].Elements {
+	for k, v := range features.Attributes[CstateFeature].Elements {
 		labels["cstate."+k] = v
 	}
 
 	// Pstate
-	for k, v := range features.Values[PstateFeature].Elements {
+	for k, v := range features.Attributes[PstateFeature].Elements {
 		labels["pstate."+k] = v
 	}
 
 	// RDT
-	for k := range features.Keys[RdtFeature].Elements {
+	for k := range features.Flags[RdtFeature].Elements {
 		labels["rdt."+k] = true
 	}
 
 	// Security
-	for k, v := range features.Values[SecurityFeature].Elements {
+	for k, v := range features.Attributes[SecurityFeature].Elements {
 		labels["security."+k] = v
 	}
 
 	// SGX
-	for k, v := range features.Values[SgxFeature].Elements {
+	for k, v := range features.Attributes[SgxFeature].Elements {
 		labels["sgx."+k] = v
 	}
 
 	// Secure Execution
-	for k, v := range features.Values[SeFeature].Elements {
+	for k, v := range features.Attributes[SeFeature].Elements {
 		labels["se."+k] = v
 	}
 
 	// SST
-	for k, v := range features.Values[SstFeature].Elements {
+	for k, v := range features.Attributes[SstFeature].Elements {
 		labels["power.sst_"+k] = v
 	}
 
 	// Hyperthreading
-	if v, ok := features.Values[TopologyFeature].Elements["hardware_multithreading"]; ok {
+	if v, ok := features.Attributes[TopologyFeature].Elements["hardware_multithreading"]; ok {
 		labels["hardware_multithreading"] = v
 	}
 
@@ -199,17 +199,17 @@ func (s *cpuSource) Discover() error {
 	s.features = feature.NewDomainFeatures()
 
 	// Detect CPUID
-	s.features.Keys[CpuidFeature] = feature.NewKeyFeatures(getCpuidFlags()...)
+	s.features.Flags[CpuidFeature] = feature.NewFlagFeatures(getCpuidFlags()...)
 
 	// Detect CPU model
-	s.features.Values[Cpumodel] = feature.NewValueFeatures(getCPUModel())
+	s.features.Attributes[Cpumodel] = feature.NewAttributeFeatures(getCPUModel())
 
 	// Detect cstate configuration
 	cstate, err := detectCstate()
 	if err != nil {
 		klog.Errorf("failed to detect cstate: %v", err)
 	} else {
-		s.features.Values[CstateFeature] = feature.NewValueFeatures(cstate)
+		s.features.Attributes[CstateFeature] = feature.NewAttributeFeatures(cstate)
 	}
 
 	// Detect pstate features
@@ -217,33 +217,33 @@ func (s *cpuSource) Discover() error {
 	if err != nil {
 		klog.Error(err)
 	}
-	s.features.Values[PstateFeature] = feature.NewValueFeatures(pstate)
+	s.features.Attributes[PstateFeature] = feature.NewAttributeFeatures(pstate)
 
 	// Detect RDT features
-	s.features.Keys[RdtFeature] = feature.NewKeyFeatures(discoverRDT()...)
+	s.features.Flags[RdtFeature] = feature.NewFlagFeatures(discoverRDT()...)
 
 	// Detect SGX features
-	s.features.Values[SecurityFeature] = feature.NewValueFeatures(discoverSecurity())
+	s.features.Attributes[SecurityFeature] = feature.NewAttributeFeatures(discoverSecurity())
 
 	// Detect SGX features
 	//
 	// DEPRECATED in v0.12: will be removed in the future
-	if val, ok := s.features.Values[SecurityFeature].Elements["sgx.enabled"]; ok {
-		s.features.Values[SgxFeature] = feature.NewValueFeatures(map[string]string{"enabled": val})
+	if val, ok := s.features.Attributes[SecurityFeature].Elements["sgx.enabled"]; ok {
+		s.features.Attributes[SgxFeature] = feature.NewAttributeFeatures(map[string]string{"enabled": val})
 	}
 
 	// Detect Secure Execution features
 	//
 	// DEPRECATED in v0.12: will be removed in the future
-	if val, ok := s.features.Values[SecurityFeature].Elements["se.enabled"]; ok {
-		s.features.Values[SeFeature] = feature.NewValueFeatures(map[string]string{"enabled": val})
+	if val, ok := s.features.Attributes[SecurityFeature].Elements["se.enabled"]; ok {
+		s.features.Attributes[SeFeature] = feature.NewAttributeFeatures(map[string]string{"enabled": val})
 	}
 
 	// Detect SST features
-	s.features.Values[SstFeature] = feature.NewValueFeatures(discoverSST())
+	s.features.Attributes[SstFeature] = feature.NewAttributeFeatures(discoverSST())
 
 	// Detect hyper-threading
-	s.features.Values[TopologyFeature] = feature.NewValueFeatures(discoverTopology())
+	s.features.Attributes[TopologyFeature] = feature.NewAttributeFeatures(discoverTopology())
 
 	utils.KlogDump(3, "discovered cpu features:", "  ", s.features)
 
diff --git a/source/custom/custom.go b/source/custom/custom.go
index 854f94ce6..9b2484e95 100644
--- a/source/custom/custom.go
+++ b/source/custom/custom.go
@@ -129,8 +129,8 @@ func (s *customSource) GetLabels() (source.FeatureLabels, error) {
 			labels[n] = v
 		}
 		// Feed back rule output to features map for subsequent rules to match
-		feature.InsertFeatureValues(domainFeatures, nfdv1alpha1.RuleBackrefDomain, nfdv1alpha1.RuleBackrefFeature, ruleOut.Labels)
-		feature.InsertFeatureValues(domainFeatures, nfdv1alpha1.RuleBackrefDomain, nfdv1alpha1.RuleBackrefFeature, ruleOut.Vars)
+		feature.InsertAttributeFeatures(domainFeatures, nfdv1alpha1.RuleBackrefDomain, nfdv1alpha1.RuleBackrefFeature, ruleOut.Labels)
+		feature.InsertAttributeFeatures(domainFeatures, nfdv1alpha1.RuleBackrefDomain, nfdv1alpha1.RuleBackrefFeature, ruleOut.Vars)
 	}
 	return labels, nil
 }
diff --git a/source/custom/rules/cpuid_rule.go b/source/custom/rules/cpuid_rule.go
index 5c84330f2..85efebd2c 100644
--- a/source/custom/rules/cpuid_rule.go
+++ b/source/custom/rules/cpuid_rule.go
@@ -31,7 +31,7 @@ type CpuIDRule struct {
 
 // Match checks if CpuId rule matches.
 func (r *CpuIDRule) Match() (bool, error) {
-	flags, ok := source.GetFeatureSource("cpu").GetFeatures().Keys[cpu.CpuidFeature]
+	flags, ok := source.GetFeatureSource("cpu").GetFeatures().Flags[cpu.CpuidFeature]
 	if !ok {
 		return false, fmt.Errorf("cpuid information not available")
 	}
diff --git a/source/custom/rules/loaded_kmod_rule.go b/source/custom/rules/loaded_kmod_rule.go
index 54e616d4a..7558f4645 100644
--- a/source/custom/rules/loaded_kmod_rule.go
+++ b/source/custom/rules/loaded_kmod_rule.go
@@ -31,7 +31,7 @@ type LoadedKModRule struct {
 
 // Match loaded kernel modules on provided list of kernel modules
 func (r *LoadedKModRule) Match() (bool, error) {
-	modules, ok := source.GetFeatureSource("kernel").GetFeatures().Keys[kernel.LoadedModuleFeature]
+	modules, ok := source.GetFeatureSource("kernel").GetFeatures().Flags[kernel.LoadedModuleFeature]
 	if !ok {
 		return false, fmt.Errorf("info about loaded modules not available")
 	}
diff --git a/source/custom/rules/nodename_rule.go b/source/custom/rules/nodename_rule.go
index 639b4dac5..964c9206e 100644
--- a/source/custom/rules/nodename_rule.go
+++ b/source/custom/rules/nodename_rule.go
@@ -32,7 +32,7 @@ type NodenameRule struct {
 
 // Match checks if node name matches the rule.
 func (r *NodenameRule) Match() (bool, error) {
-	nodeName, ok := source.GetFeatureSource("system").GetFeatures().Values[system.NameFeature].Elements["nodename"]
+	nodeName, ok := source.GetFeatureSource("system").GetFeatures().Attributes[system.NameFeature].Elements["nodename"]
 	if !ok || nodeName == "" {
 		return false, fmt.Errorf("node name not available")
 	}
diff --git a/source/fake/fake.go b/source/fake/fake.go
index 7683c662f..d1d71393c 100644
--- a/source/fake/fake.go
+++ b/source/fake/fake.go
@@ -118,8 +118,8 @@ func (s *fakeSource) SetConfig(conf source.Config) {
 func (s *fakeSource) Discover() error {
 	s.features = feature.NewDomainFeatures()
 
-	s.features.Keys[FlagFeature] = feature.NewKeyFeatures(s.config.FlagFeatures...)
-	s.features.Values[AttributeFeature] = feature.NewValueFeatures(s.config.AttributeFeatures)
+	s.features.Flags[FlagFeature] = feature.NewFlagFeatures(s.config.FlagFeatures...)
+	s.features.Attributes[AttributeFeature] = feature.NewAttributeFeatures(s.config.AttributeFeatures)
 
 	instances := make([]feature.InstanceFeature, len(s.config.InstanceFeatures))
 	for i, instanceAttributes := range s.config.InstanceFeatures {
diff --git a/source/kernel/kernel.go b/source/kernel/kernel.go
index e19a46144..f2299e240 100644
--- a/source/kernel/kernel.go
+++ b/source/kernel/kernel.go
@@ -98,7 +98,7 @@ func (s *kernelSource) GetLabels() (source.FeatureLabels, error) {
 	labels := source.FeatureLabels{}
 	features := s.GetFeatures()
 
-	for k, v := range features.Values[VersionFeature].Elements {
+	for k, v := range features.Attributes[VersionFeature].Elements {
 		labels[VersionFeature+"."+k] = v
 	}
 
@@ -108,7 +108,7 @@ func (s *kernelSource) GetLabels() (source.FeatureLabels, error) {
 		}
 	}
 
-	if enabled, ok := features.Values[SelinuxFeature].Elements["enabled"]; ok && enabled == "true" {
+	if enabled, ok := features.Attributes[SelinuxFeature].Elements["enabled"]; ok && enabled == "true" {
 		labels["selinux.enabled"] = "true"
 	}
 
@@ -123,7 +123,7 @@ func (s *kernelSource) Discover() error {
 	if version, err := parseVersion(); err != nil {
 		klog.Errorf("failed to get kernel version: %s", err)
 	} else {
-		s.features.Values[VersionFeature] = feature.NewValueFeatures(version)
+		s.features.Attributes[VersionFeature] = feature.NewAttributeFeatures(version)
 	}
 
 	// Read kconfig
@@ -131,21 +131,21 @@ func (s *kernelSource) Discover() error {
 		s.legacyKconfig = nil
 		klog.Errorf("failed to read kconfig: %s", err)
 	} else {
-		s.features.Values[ConfigFeature] = feature.NewValueFeatures(realKconfig)
+		s.features.Attributes[ConfigFeature] = feature.NewAttributeFeatures(realKconfig)
 		s.legacyKconfig = legacyKconfig
 	}
 
 	if kmods, err := getLoadedModules(); err != nil {
 		klog.Errorf("failed to get loaded kernel modules: %v", err)
 	} else {
-		s.features.Keys[LoadedModuleFeature] = feature.NewKeyFeatures(kmods...)
+		s.features.Flags[LoadedModuleFeature] = feature.NewFlagFeatures(kmods...)
 	}
 
 	if selinux, err := SelinuxEnabled(); err != nil {
 		klog.Warning(err)
 	} else {
-		s.features.Values[SelinuxFeature] = feature.NewValueFeatures(nil)
-		s.features.Values[SelinuxFeature].Elements["enabled"] = strconv.FormatBool(selinux)
+		s.features.Attributes[SelinuxFeature] = feature.NewAttributeFeatures(nil)
+		s.features.Attributes[SelinuxFeature].Elements["enabled"] = strconv.FormatBool(selinux)
 	}
 
 	utils.KlogDump(3, "discovered kernel features:", "  ", s.features)
diff --git a/source/local/local.go b/source/local/local.go
index d9650ebbf..99ce32339 100644
--- a/source/local/local.go
+++ b/source/local/local.go
@@ -88,7 +88,7 @@ func (s *localSource) GetLabels() (source.FeatureLabels, error) {
 	labels := make(source.FeatureLabels)
 	features := s.GetFeatures()
 
-	for k, v := range features.Values[LabelFeature].Elements {
+	for k, v := range features.Attributes[LabelFeature].Elements {
 		labels[k] = v
 	}
 	return labels, nil
@@ -129,7 +129,7 @@ func (s *localSource) Discover() error {
 		}
 	}
 
-	s.features.Values[LabelFeature] = feature.NewValueFeatures(featuresFromFiles)
+	s.features.Attributes[LabelFeature] = feature.NewAttributeFeatures(featuresFromFiles)
 
 	utils.KlogDump(3, "discovered local features:", "  ", s.features)
 
diff --git a/source/memory/memory.go b/source/memory/memory.go
index 55fedbe67..9049e040f 100644
--- a/source/memory/memory.go
+++ b/source/memory/memory.go
@@ -63,7 +63,7 @@ func (s *memorySource) GetLabels() (source.FeatureLabels, error) {
 	features := s.GetFeatures()
 
 	// NUMA
-	if isNuma, ok := features.Values[NumaFeature].Elements["is_numa"]; ok && isNuma == "true" {
+	if isNuma, ok := features.Attributes[NumaFeature].Elements["is_numa"]; ok && isNuma == "true" {
 		labels["numa"] = true
 	}
 
@@ -89,7 +89,7 @@ func (s *memorySource) Discover() error {
 	if numa, err := detectNuma(); err != nil {
 		klog.Errorf("failed to detect NUMA nodes: %v", err)
 	} else {
-		s.features.Values[NumaFeature] = feature.ValueFeatureSet{Elements: numa}
+		s.features.Attributes[NumaFeature] = feature.AttributeFeatureSet{Elements: numa}
 	}
 
 	// Detect NVDIMM
diff --git a/source/system/system.go b/source/system/system.go
index aa9f33168..903cce35f 100644
--- a/source/system/system.go
+++ b/source/system/system.go
@@ -67,7 +67,7 @@ func (s *systemSource) GetLabels() (source.FeatureLabels, error) {
 	features := s.GetFeatures()
 
 	for _, key := range osReleaseFields {
-		if value, exists := features.Values[OsReleaseFeature].Elements[key]; exists {
+		if value, exists := features.Attributes[OsReleaseFeature].Elements[key]; exists {
 			feature := "os_release." + key
 			labels[feature] = value
 		}
@@ -80,21 +80,21 @@ func (s *systemSource) Discover() error {
 	s.features = feature.NewDomainFeatures()
 
 	// Get node name
-	s.features.Values[NameFeature] = feature.NewValueFeatures(nil)
-	s.features.Values[NameFeature].Elements["nodename"] = os.Getenv("NODE_NAME")
+	s.features.Attributes[NameFeature] = feature.NewAttributeFeatures(nil)
+	s.features.Attributes[NameFeature].Elements["nodename"] = os.Getenv("NODE_NAME")
 
 	// Get os-release information
 	release, err := parseOSRelease()
 	if err != nil {
 		klog.Errorf("failed to get os-release: %s", err)
 	} else {
-		s.features.Values[OsReleaseFeature] = feature.NewValueFeatures(release)
+		s.features.Attributes[OsReleaseFeature] = feature.NewAttributeFeatures(release)
 
 		if v, ok := release["VERSION_ID"]; ok {
 			versionComponents := splitVersion(v)
 			for subKey, subValue := range versionComponents {
 				if subValue != "" {
-					s.features.Values[OsReleaseFeature].Elements["VERSION_ID."+subKey] = subValue
+					s.features.Attributes[OsReleaseFeature].Elements["VERSION_ID."+subKey] = subValue
 				}
 			}
 		}


Test patch:
diff --git a/pkg/apis/nfd/v1alpha1/rule_test.go b/pkg/apis/nfd/v1alpha1/rule_test.go
index a13760c6c..35ec25b96 100644
--- a/pkg/apis/nfd/v1alpha1/rule_test.go
+++ b/pkg/apis/nfd/v1alpha1/rule_test.go
@@ -60,8 +60,8 @@ func TestRule(t *testing.T) {
 	assert.Error(t, err, "matching against a missing feature type should have returned an error")
 
 	// Test empty feature sets
-	d.Keys["kf-1"] = feature.NewKeyFeatures()
-	d.Values["vf-1"] = feature.NewValueFeatures(nil)
+	d.Flags["kf-1"] = feature.NewFlagFeatures()
+	d.Attributes["vf-1"] = feature.NewAttributeFeatures(nil)
 	d.Instances["if-1"] = feature.NewInstanceFeatures(nil)
 
 	m, err = r1.Execute(f)
@@ -73,8 +73,8 @@ func TestRule(t *testing.T) {
 	assert.Nil(t, m.Labels, "unexpected match")
 
 	// Test non-empty feature sets
-	d.Keys["kf-1"].Elements["key-x"] = feature.Nil{}
-	d.Values["vf-1"].Elements["key-1"] = "val-x"
+	d.Flags["kf-1"].Elements["key-x"] = feature.Nil{}
+	d.Attributes["vf-1"].Elements["key-1"] = "val-x"
 	d.Instances["if-1"] = feature.NewInstanceFeatures([]feature.InstanceFeature{
 		*feature.NewInstanceFeature(map[string]string{"attr-1": "val-x"})})
 
@@ -98,7 +98,7 @@ func TestRule(t *testing.T) {
 	assert.Nilf(t, err, "unexpected error: %v", err)
 	assert.Nil(t, m.Labels, "keys should not have matched")
 
-	d.Keys["kf-1"].Elements["key-1"] = feature.Nil{}
+	d.Flags["kf-1"].Elements["key-1"] = feature.Nil{}
 	m, err = r2.Execute(f)
 	assert.Nilf(t, err, "unexpected error: %v", err)
 	assert.Equal(t, r2.Labels, m.Labels, "keys should have matched")
@@ -120,7 +120,7 @@ func TestRule(t *testing.T) {
 	assert.Nilf(t, err, "unexpected error: %v", err)
 	assert.Nil(t, m.Labels, "values should not have matched")
 
-	d.Values["vf-1"].Elements["key-1"] = "val-1"
+	d.Attributes["vf-1"].Elements["key-1"] = "val-1"
 	m, err = r3.Execute(f)
 	assert.Nilf(t, err, "unexpected error: %v", err)
 	assert.Equal(t, r3.Labels, m.Labels, "values should have matched")
@@ -210,8 +210,8 @@ func TestRule(t *testing.T) {
 func TestTemplating(t *testing.T) {
 	f := map[string]*feature.DomainFeatures{
 		"domain_1": &feature.DomainFeatures{
-			Keys: map[string]feature.KeyFeatureSet{
-				"kf_1": feature.KeyFeatureSet{
+			Flags: map[string]feature.FlagFeatureSet{
+				"kf_1": feature.FlagFeatureSet{
 					Elements: map[string]feature.Nil{
 						"key-a": feature.Nil{},
 						"key-b": feature.Nil{},
@@ -219,8 +219,8 @@ func TestTemplating(t *testing.T) {
 					},
 				},
 			},
-			Values: map[string]feature.ValueFeatureSet{
-				"vf_1": feature.ValueFeatureSet{
+			Attributes: map[string]feature.AttributeFeatureSet{
+				"vf_1": feature.AttributeFeatureSet{
 					Elements: map[string]string{
 						"key-1": "val-1",
 						"keu-2": "val-2",
diff --git a/source/source_test.go b/source/source_test.go
index d825e2d65..6f8fbb544 100644
--- a/source/source_test.go
+++ b/source/source_test.go
@@ -73,8 +73,8 @@ func TestFeatureSources(t *testing.T) {
 
 		f := s.GetFeatures()
 		assert.NotNil(t, f, msg)
-		assert.Empty(t, (*f).Keys, msg)
-		assert.Empty(t, (*f).Values, msg)
+		assert.Empty(t, (*f).Flags, msg)
+		assert.Empty(t, (*f).Attributes, msg)
 		assert.Empty(t, (*f).Instances, msg)
 	}
 }