diff --git a/.vscode/typescript.code-snippets b/.vscode/typescript.code-snippets
index f34c2d33207..3689691504c 100644
--- a/.vscode/typescript.code-snippets
+++ b/.vscode/typescript.code-snippets
@@ -430,16 +430,20 @@
 		"prefix": "zwcc",
 		"body": [
 			"import {",
-			"\tCCCommand,",
 			"\tCommandClass,",
-			"\tcommandClass,",
-			"\texpectedCCResponse,",
-			"\timplementedVersion,",
 			"\tgotDeserializationOptions,",
 			"\ttype CCCommandOptions,",
 			"\ttype CommandClassDeserializationOptions,",
 			"} from \"../lib/CommandClass\";",
 			"import {",
+			"\tCCCommand,",
+			"\tccValue,",
+			"\tccValues,",
+			"\tcommandClass,",
+			"\texpectedCCResponse,",
+			"\timplementedVersion,",
+			"} from \"../lib/CommandClassDecorators\";",
+			"import {",
 			"\tCommandClasses,",
 			"\tMessageOrCCLogEntry,",
 			"\tMessagePriority,",
@@ -457,6 +461,7 @@
 			"",
 			"@commandClass(CommandClasses.${1})",
 			"@implementedVersion(${2:1})",
+			"@ccValues(${1}CCValues)",
 			"export class ${1}CC extends CommandClass {",
 			"\tdeclare ccCommand: ${1}Command;",
 			"}",
@@ -465,6 +470,91 @@
 		],
 		"description": "Z-Wave Command Class implementation"
 	},
+	"Z-Wave CC Values": {
+		"scope": "typescript",
+		"prefix": "zwccvalues",
+		"body": [
+			"export const ${1:${TM_FILENAME_BASE/(.*)CC$/$1/}}CCValues = Object.freeze({",
+			"\t...V${0}.defineStaticCCValues(CommandClasses.${2:${TM_FILENAME_BASE/(.*)CC$/$1/}}, {",
+			"\t\t// Static CC values go here",
+			"\t}),",
+			"",
+			"\t...V.defineDynamicCCValues(CommandClasses.${2}, {",
+			"\t\t// Dynamic CC values go here",
+			"\t}),",
+			"});",
+			""
+		],
+		"description": "Z-Wave Command Class values definition"
+	},
+	"Z-Wave CC Value (static, property only)": {
+		"scope": "typescript",
+		"prefix": "zwccvaluestatic",
+		"body": [
+			"...V.staticProperty(",
+			"\t\"${1:property}\",",
+			"\t${2:// undefined, // meta}",
+			"\t${3:// { internal: true \\}, // value options}",
+			"),"
+		],
+		"description": "Static CC value"
+	},
+	"Z-Wave CC Value (static, named property)": {
+		"scope": "typescript",
+		"prefix": "zwccvaluestaticname",
+		"body": [
+			"...V.staticPropertyWithName(",
+			"\t\"${1:valueName}\",",
+			"\t\"${2:property}\",",
+			"\t${3:// undefined, // meta}",
+			"\t${4:// { internal: true \\}, // value options}",
+			"),"
+		],
+		"description": "Static CC value with name"
+	},
+	"Z-Wave CC Value (static, named, property & key)": {
+		"scope": "typescript",
+		"prefix": "zwccvaluestaticpropkey",
+		"body": [
+			"...V.staticPropertyAndKeyWithName(",
+			"\t\"${1:valueName}\",",
+			"\t\"${2:property}\",",
+			"\t\"${3:propertyKey}\",",
+			"\t${4:// undefined, // meta}",
+			"\t${5:// { internal: true \\}, // value options}",
+			"),"
+		],
+		"description": "Static CC value with name, property and propertyKey"
+	},
+	"Z-Wave CC Value (dynamic, named property)": {
+		"scope": "typescript",
+		"prefix": "zwccvaluedynamicname",
+		"body": [
+			"...V.dynamicPropertyWithName(",
+			"\t\"${1:valueName}\",",
+			"\t(${2:arg1}: ${3:number}) => ${0:${2}},",
+			"\t({ property }) => typeof property === \"${3}\",",
+			"\t// (${2}: ${3}) => ({ ...ValueMetadata.Any }), // meta, can also be a static value",
+			"\t// (${2}: ${3}) => ({ internal: true }), // value options, can also be a static value",
+			"),"
+		],
+		"description": "Dynamic CC value with name"
+	},
+	"Z-Wave CC Value (dynamic, named, property & key)": {
+		"scope": "typescript",
+		"prefix": "zwccvaluedynamicpropkey",
+		"body": [
+			"...V.dynamicPropertyAndKeyWithName(",
+			"\t\"${1:valueName}\",",
+			"\t\"${1}\",",
+			"\t(${2:arg1}: ${3:number}) => ${0:${2}},",
+			"\t({ property, propertyKey }) => property === \"${1}\",",
+			"\t// (${2}: ${3}) => ({ ...ValueMetadata.Any }), // meta, can also be a static value",
+			"\t// (${2}: ${3}) => ({ internal: true }), // value options, can also be a static value",
+			"),"
+		],
+		"description": "Dynamic CC value with name, property and propertyKey"
+	},
 	"Z-Wave CC Command": {
 		"scope": "typescript",
 		"prefix": "zwcccmd",
diff --git a/docs/api/CCs/AlarmSensor.md b/docs/api/CCs/AlarmSensor.md
index b3aec380558..fd39038d077 100644
--- a/docs/api/CCs/AlarmSensor.md
+++ b/docs/api/CCs/AlarmSensor.md
@@ -21,3 +21,66 @@ Retrieves the current value from this sensor.
 ```ts
 async getSupportedSensorTypes(): Promise<readonly AlarmSensorType[] | undefined>;
 ```
+
+## Alarm Sensor CC values
+
+### `duration(sensorType: AlarmSensorType)`
+
+```ts
+{
+	commandClass: CommandClasses["Alarm Sensor"],
+	endpoint: number,
+	property: "duration",
+	propertyKey: AlarmSensorType,
+}
+```
+
+-   **label:** `${string} duration`
+-   **description:** For how long the alarm should be active
+-   **min. CC version:** 1
+-   **readable:** true
+-   **writeable:** false
+-   **stateful:** true
+-   **secret:** false
+-   **value type:** `"number"`
+
+### `severity(sensorType: AlarmSensorType)`
+
+```ts
+{
+	commandClass: CommandClasses["Alarm Sensor"],
+	endpoint: number,
+	property: "severity",
+	propertyKey: AlarmSensorType,
+}
+```
+
+-   **label:** `${string} severity`
+-   **min. CC version:** 1
+-   **readable:** true
+-   **writeable:** false
+-   **stateful:** true
+-   **secret:** false
+-   **value type:** `"number"`
+-   **min. value:** 1
+-   **max. value:** 100
+
+### `state(sensorType: AlarmSensorType)`
+
+```ts
+{
+	commandClass: CommandClasses["Alarm Sensor"],
+	endpoint: number,
+	property: "state",
+	propertyKey: AlarmSensorType,
+}
+```
+
+-   **label:** `${string} state`
+-   **description:** Whether the alarm is active
+-   **min. CC version:** 1
+-   **readable:** true
+-   **writeable:** false
+-   **stateful:** true
+-   **secret:** false
+-   **value type:** `"boolean"`
diff --git a/docs/api/CCs/BarrierOperator.md b/docs/api/CCs/BarrierOperator.md
index e37db169db8..83c44824bdc 100644
--- a/docs/api/CCs/BarrierOperator.md
+++ b/docs/api/CCs/BarrierOperator.md
@@ -42,3 +42,86 @@ async setEventSignaling(
 	subsystemState: SubsystemState,
 ): Promise<void>;
 ```
+
+## Barrier Operator CC values
+
+### `currentState`
+
+```ts
+{
+	commandClass: CommandClasses["Barrier Operator"],
+	endpoint: number,
+	property: "currentState",
+}
+```
+
+-   **label:** Current Barrier State
+-   **min. CC version:** 1
+-   **readable:** true
+-   **writeable:** false
+-   **stateful:** true
+-   **secret:** false
+-   **value type:** `"number"`
+-   **min. value:** 0
+-   **max. value:** 255
+
+### `position`
+
+```ts
+{
+	commandClass: CommandClasses["Barrier Operator"],
+	endpoint: number,
+	property: "position",
+}
+```
+
+-   **label:** Barrier Position
+-   **min. CC version:** 1
+-   **readable:** true
+-   **writeable:** false
+-   **stateful:** true
+-   **secret:** false
+-   **value type:** `"number"`
+-   **min. value:** 0
+-   **max. value:** 100
+
+### `signalingState(subsystemType: SubsystemType)`
+
+```ts
+{
+	commandClass: CommandClasses["Barrier Operator"],
+	endpoint: number,
+	property: "signalingState",
+	propertyKey: SubsystemType,
+}
+```
+
+-   **label:** `Signaling State (${string})`
+-   **min. CC version:** 1
+-   **readable:** true
+-   **writeable:** true
+-   **stateful:** true
+-   **secret:** false
+-   **value type:** `"number"`
+-   **min. value:** 0
+-   **max. value:** 255
+
+### `targetState`
+
+```ts
+{
+	commandClass: CommandClasses["Barrier Operator"],
+	endpoint: number,
+	property: "targetState",
+}
+```
+
+-   **label:** Target Barrier State
+-   **min. CC version:** 1
+-   **readable:** true
+-   **writeable:** true
+-   **stateful:** true
+-   **secret:** false
+-   **value type:** `"number"`
+-   **min. value:** 0
+-   **max. value:** 255
diff --git a/docs/api/CCs/Basic.md b/docs/api/CCs/Basic.md
index 99c1c3492b6..c6b55238a25 100644
--- a/docs/api/CCs/Basic.md
+++ b/docs/api/CCs/Basic.md
@@ -15,3 +15,83 @@ async get(): Promise<Pick<BasicCCReport, "currentValue" | "targetValue" | "durat
 ```ts
 async set(targetValue: number): Promise<void>;
 ```
+
+## Basic CC values
+
+### `compatEvent`
+
+```ts
+{
+	commandClass: CommandClasses.Basic,
+	endpoint: number,
+	property: "event",
+}
+```
+
+-   **label:** Event value
+-   **min. CC version:** 1
+-   **readable:** true
+-   **writeable:** false
+-   **stateful:** false
+-   **secret:** false
+-   **value type:** `"number"`
+-   **min. value:** 0
+-   **max. value:** 255
+
+### `currentValue`
+
+```ts
+{
+	commandClass: CommandClasses.Basic,
+	endpoint: number,
+	property: "currentValue",
+}
+```
+
+-   **label:** Current value
+-   **min. CC version:** 1
+-   **readable:** true
+-   **writeable:** false
+-   **stateful:** true
+-   **secret:** false
+-   **value type:** `"number"`
+-   **min. value:** 0
+-   **max. value:** 99
+
+### `duration`
+
+```ts
+{
+	commandClass: CommandClasses.Basic,
+	endpoint: number,
+	property: "duration",
+}
+```
+
+-   **label:** Remaining duration
+-   **min. CC version:** 1
+-   **readable:** true
+-   **writeable:** false
+-   **stateful:** true
+-   **secret:** false
+-   **value type:** `"duration"`
+
+### `targetValue`
+
+```ts
+{
+	commandClass: CommandClasses.Basic,
+	endpoint: number,
+	property: "targetValue",
+}
+```
+
+-   **label:** Target value
+-   **min. CC version:** 1
+-   **readable:** true
+-   **writeable:** true
+-   **stateful:** true
+-   **secret:** false
+-   **value type:** `"number"`
+-   **min. value:** 0
+-   **max. value:** 255
diff --git a/docs/api/CCs/Battery.md b/docs/api/CCs/Battery.md
index d4405ee5da9..8af1091831b 100644
--- a/docs/api/CCs/Battery.md
+++ b/docs/api/CCs/Battery.md
@@ -15,3 +15,231 @@ async get(): Promise<Pick<BatteryCCReport, "level" | "isLow" | "chargingStatus"
 ```ts
 async getHealth(): Promise<Pick<BatteryCCHealthReport, "maximumCapacity" | "temperature"> | undefined>;
 ```
+
+## Battery CC values
+
+### `backup`
+
+```ts
+{
+	commandClass: CommandClasses.Battery,
+	endpoint: number,
+	property: "backup",
+}
+```
+
+-   **label:** Used as backup
+-   **min. CC version:** 2
+-   **readable:** true
+-   **writeable:** false
+-   **stateful:** true
+-   **secret:** false
+-   **value type:** `"boolean"`
+
+### `chargingStatus`
+
+```ts
+{
+	commandClass: CommandClasses.Battery,
+	endpoint: number,
+	property: "chargingStatus",
+}
+```
+
+-   **label:** Charging status
+-   **min. CC version:** 2
+-   **readable:** true
+-   **writeable:** false
+-   **stateful:** true
+-   **secret:** false
+-   **value type:** `"number"`
+-   **min. value:** 0
+-   **max. value:** 255
+
+### `disconnected`
+
+```ts
+{
+	commandClass: CommandClasses.Battery,
+	endpoint: number,
+	property: "disconnected",
+}
+```
+
+-   **label:** Battery is disconnected
+-   **min. CC version:** 2
+-   **readable:** true
+-   **writeable:** false
+-   **stateful:** true
+-   **secret:** false
+-   **value type:** `"boolean"`
+
+### `isLow`
+
+```ts
+{
+	commandClass: CommandClasses.Battery,
+	endpoint: number,
+	property: "isLow",
+}
+```
+
+-   **label:** Low battery level
+-   **min. CC version:** 1
+-   **readable:** true
+-   **writeable:** false
+-   **stateful:** true
+-   **secret:** false
+-   **value type:** `"boolean"`
+
+### `level`
+
+```ts
+{
+	commandClass: CommandClasses.Battery,
+	endpoint: number,
+	property: "level",
+}
+```
+
+-   **label:** Battery level
+-   **min. CC version:** 1
+-   **readable:** true
+-   **writeable:** false
+-   **stateful:** true
+-   **secret:** false
+-   **value type:** `"number"`
+-   **min. value:** 0
+-   **max. value:** 100
+
+### `lowFluid`
+
+```ts
+{
+	commandClass: CommandClasses.Battery,
+	endpoint: number,
+	property: "lowFluid",
+}
+```
+
+-   **label:** Fluid is low
+-   **min. CC version:** 2
+-   **readable:** true
+-   **writeable:** false
+-   **stateful:** true
+-   **secret:** false
+-   **value type:** `"boolean"`
+
+### `lowTemperatureStatus`
+
+```ts
+{
+	commandClass: CommandClasses.Battery,
+	endpoint: number,
+	property: "lowTemperatureStatus",
+}
+```
+
+-   **label:** Battery temperature is low
+-   **min. CC version:** 3
+-   **readable:** true
+-   **writeable:** false
+-   **stateful:** true
+-   **secret:** false
+-   **value type:** `"boolean"`
+
+### `maximumCapacity`
+
+```ts
+{
+	commandClass: CommandClasses.Battery,
+	endpoint: number,
+	property: "maximumCapacity",
+}
+```
+
+-   **label:** Maximum capacity
+-   **min. CC version:** 2
+-   **readable:** true
+-   **writeable:** false
+-   **stateful:** true
+-   **secret:** false
+-   **value type:** `"number"`
+-   **min. value:** 0
+-   **max. value:** 100
+
+### `overheating`
+
+```ts
+{
+	commandClass: CommandClasses.Battery,
+	endpoint: number,
+	property: "overheating",
+}
+```
+
+-   **label:** Overheating
+-   **min. CC version:** 2
+-   **readable:** true
+-   **writeable:** false
+-   **stateful:** true
+-   **secret:** false
+-   **value type:** `"boolean"`
+
+### `rechargeable`
+
+```ts
+{
+	commandClass: CommandClasses.Battery,
+	endpoint: number,
+	property: "rechargeable",
+}
+```
+
+-   **label:** Rechargeable
+-   **min. CC version:** 2
+-   **readable:** true
+-   **writeable:** false
+-   **stateful:** true
+-   **secret:** false
+-   **value type:** `"boolean"`
+
+### `rechargeOrReplace`
+
+```ts
+{
+	commandClass: CommandClasses.Battery,
+	endpoint: number,
+	property: "rechargeOrReplace",
+}
+```
+
+-   **label:** Recharge or replace
+-   **min. CC version:** 2
+-   **readable:** true
+-   **writeable:** false
+-   **stateful:** true
+-   **secret:** false
+-   **value type:** `"number"`
+-   **min. value:** 0
+-   **max. value:** 255
+
+### `temperature`
+
+```ts
+{
+	commandClass: CommandClasses.Battery,
+	endpoint: number,
+	property: "temperature",
+}
+```
+
+-   **label:** Temperature
+-   **min. CC version:** 2
+-   **readable:** true
+-   **writeable:** false
+-   **stateful:** true
+-   **secret:** false
+-   **value type:** `"number"`
+-   **min. value:** -128
+-   **max. value:** 127
diff --git a/docs/api/CCs/BinarySensor.md b/docs/api/CCs/BinarySensor.md
index 3856ac8f55e..6126655cec0 100644
--- a/docs/api/CCs/BinarySensor.md
+++ b/docs/api/CCs/BinarySensor.md
@@ -23,3 +23,23 @@ Retrieves the current value from this sensor.
 ```ts
 async getSupportedSensorTypes(): Promise<readonly BinarySensorType[] | undefined>;
 ```
+
+## Binary Sensor CC values
+
+### `state(sensorType: BinarySensorType)`
+
+```ts
+{
+	commandClass: CommandClasses["Binary Sensor"],
+	endpoint: number,
+	property: string,
+}
+```
+
+-   **label:** `Sensor state (${string})`
+-   **min. CC version:** 1
+-   **readable:** true
+-   **writeable:** false
+-   **stateful:** true
+-   **secret:** false
+-   **value type:** `"boolean"`
diff --git a/docs/api/CCs/BinarySwitch.md b/docs/api/CCs/BinarySwitch.md
index d3f938a8d87..c9d1663de4b 100644
--- a/docs/api/CCs/BinarySwitch.md
+++ b/docs/api/CCs/BinarySwitch.md
@@ -25,3 +25,59 @@ Sets the switch to the given value.
 
 -   `targetValue`: The target value to set
 -   `duration`: The duration after which the target value should be reached. Can be a Duration instance or a user-friendly duration string like `"1m17s"`. Only supported in V2 and above.
+
+## Binary Switch CC values
+
+### `currentValue`
+
+```ts
+{
+	commandClass: CommandClasses["Binary Switch"],
+	endpoint: number,
+	property: "currentValue",
+}
+```
+
+-   **label:** Current value
+-   **min. CC version:** 1
+-   **readable:** true
+-   **writeable:** false
+-   **stateful:** true
+-   **secret:** false
+-   **value type:** `"boolean"`
+
+### `duration`
+
+```ts
+{
+	commandClass: CommandClasses["Binary Switch"],
+	endpoint: number,
+	property: "duration",
+}
+```
+
+-   **label:** Remaining duration
+-   **min. CC version:** 2
+-   **readable:** true
+-   **writeable:** false
+-   **stateful:** true
+-   **secret:** false
+-   **value type:** `"duration"`
+
+### `targetValue`
+
+```ts
+{
+	commandClass: CommandClasses["Binary Switch"],
+	endpoint: number,
+	property: "targetValue",
+}
+```
+
+-   **label:** Target value
+-   **min. CC version:** 1
+-   **readable:** true
+-   **writeable:** true
+-   **stateful:** true
+-   **secret:** false
+-   **value type:** `"boolean"`
diff --git a/docs/api/CCs/CentralScene.md b/docs/api/CCs/CentralScene.md
index 7ca8071d4c0..8b84d023291 100644
--- a/docs/api/CCs/CentralScene.md
+++ b/docs/api/CCs/CentralScene.md
@@ -21,3 +21,45 @@ async getConfiguration(): Promise<Pick<CentralSceneCCConfigurationReport, "slowR
 ```ts
 async setConfiguration(slowRefresh: boolean): Promise<void>;
 ```
+
+## Central Scene CC values
+
+### `scene(sceneNumber: number)`
+
+```ts
+{
+	commandClass: CommandClasses["Central Scene"],
+	endpoint: number,
+	property: "scene",
+	propertyKey: string,
+}
+```
+
+-   **label:** `Scene ${string}`
+-   **min. CC version:** 1
+-   **readable:** true
+-   **writeable:** false
+-   **stateful:** true
+-   **secret:** false
+-   **value type:** `"number"`
+-   **min. value:** 0
+-   **max. value:** 255
+
+### `slowRefresh`
+
+```ts
+{
+	commandClass: CommandClasses["Central Scene"],
+	endpoint: number,
+	property: "slowRefresh",
+}
+```
+
+-   **label:** Send held down notifications at a slow rate
+-   **description:** When this is true, KeyHeldDown notifications are sent every 55s. When this is false, the notifications are sent every 200ms.
+-   **min. CC version:** 1
+-   **readable:** true
+-   **writeable:** true
+-   **stateful:** true
+-   **secret:** false
+-   **value type:** `"boolean"`
diff --git a/docs/api/CCs/ClimateControlSchedule.md b/docs/api/CCs/ClimateControlSchedule.md
index 29ecc239f3f..b8931abea83 100644
--- a/docs/api/CCs/ClimateControlSchedule.md
+++ b/docs/api/CCs/ClimateControlSchedule.md
@@ -41,3 +41,61 @@ async setOverride(
 	state: SetbackState,
 ): Promise<void>;
 ```
+
+## Climate Control Schedule CC values
+
+### `overrideState`
+
+```ts
+{
+	commandClass: CommandClasses["Climate Control Schedule"],
+	endpoint: number,
+	property: "overrideState",
+}
+```
+
+-   **label:** Override state
+-   **min. CC version:** 1
+-   **readable:** true
+-   **writeable:** true
+-   **stateful:** true
+-   **secret:** false
+-   **value type:** `"number"`
+-   **min. value:** -12.8
+
+### `overrideType`
+
+```ts
+{
+	commandClass: CommandClasses["Climate Control Schedule"],
+	endpoint: number,
+	property: "overrideType",
+}
+```
+
+-   **label:** Override type
+-   **min. CC version:** 1
+-   **readable:** true
+-   **writeable:** true
+-   **stateful:** true
+-   **secret:** false
+-   **value type:** `"number"`
+
+### `schedule(weekday: Weekday)`
+
+```ts
+{
+	commandClass: CommandClasses["Climate Control Schedule"],
+	endpoint: number,
+	property: "schedule",
+	propertyKey: Weekday,
+}
+```
+
+-   **label:** `Schedule (${string})`
+-   **min. CC version:** 1
+-   **readable:** true
+-   **writeable:** true
+-   **stateful:** true
+-   **secret:** false
+-   **value type:** `"any"`
diff --git a/docs/api/CCs/ColorSwitch.md b/docs/api/CCs/ColorSwitch.md
index cde037ccf9e..b955a09f6bd 100644
--- a/docs/api/CCs/ColorSwitch.md
+++ b/docs/api/CCs/ColorSwitch.md
@@ -39,3 +39,123 @@ async stopLevelChange(
 	colorComponent: ColorComponent,
 ): Promise<void>;
 ```
+
+## Color Switch CC values
+
+### `currentColor`
+
+```ts
+{
+	commandClass: CommandClasses["Color Switch"],
+	endpoint: number,
+	property: "currentColor",
+}
+```
+
+-   **label:** Current color
+-   **min. CC version:** 1
+-   **readable:** true
+-   **writeable:** false
+-   **stateful:** true
+-   **secret:** false
+-   **value type:** `"any"`
+
+### `currentColorChannel(component: ColorComponent)`
+
+```ts
+{
+	commandClass: CommandClasses["Color Switch"],
+	endpoint: number,
+	property: "currentColor",
+	propertyKey: ColorComponent,
+}
+```
+
+-   **label:** `Current value (${string})`
+-   **description:** `The current value of the ${string} channel.`
+-   **min. CC version:** 1
+-   **readable:** true
+-   **writeable:** false
+-   **stateful:** true
+-   **secret:** false
+-   **value type:** `"number"`
+-   **min. value:** 0
+-   **max. value:** 255
+
+### `duration`
+
+```ts
+{
+	commandClass: CommandClasses["Color Switch"],
+	endpoint: number,
+	property: "duration",
+}
+```
+
+-   **label:** Remaining duration
+-   **min. CC version:** 1
+-   **readable:** true
+-   **writeable:** false
+-   **stateful:** true
+-   **secret:** false
+-   **value type:** `"duration"`
+
+### `hexColor`
+
+```ts
+{
+	commandClass: CommandClasses["Color Switch"],
+	endpoint: number,
+	property: "hexColor",
+}
+```
+
+-   **label:** RGB Color
+-   **min. CC version:** 1
+-   **readable:** true
+-   **writeable:** true
+-   **stateful:** true
+-   **secret:** false
+-   **value type:** `"color"`
+-   **min. length:** 6
+-   **max. length:** 7
+
+### `targetColor`
+
+```ts
+{
+	commandClass: CommandClasses["Color Switch"],
+	endpoint: number,
+	property: "targetColor",
+}
+```
+
+-   **label:** Target color
+-   **min. CC version:** 1
+-   **readable:** true
+-   **writeable:** true
+-   **stateful:** true
+-   **secret:** false
+-   **value type:** `"any"`
+
+### `targetColorChannel(component: ColorComponent)`
+
+```ts
+{
+	commandClass: CommandClasses["Color Switch"],
+	endpoint: number,
+	property: "targetColor",
+	propertyKey: ColorComponent,
+}
+```
+
+-   **label:** `Target value (${string})`
+-   **description:** `The target value of the ${string} channel.`
+-   **min. CC version:** 1
+-   **readable:** true
+-   **writeable:** true
+-   **stateful:** true
+-   **secret:** false
+-   **value type:** `"number"`
+-   **min. value:** 0
+-   **max. value:** 255
diff --git a/docs/api/CCs/Configuration.md b/docs/api/CCs/Configuration.md
index 93656dc3fd1..aecc8498ad0 100644
--- a/docs/api/CCs/Configuration.md
+++ b/docs/api/CCs/Configuration.md
@@ -124,3 +124,23 @@ WARNING: On nodes implementing V1 and V2, this process may take
 **up to an hour**, depending on the configured timeout.
 
 WARNING: On nodes implementing V2, all parameters after 255 will be ignored.
+
+## Configuration CC values
+
+### `paramInformation(parameter: number, bitMask?: number | undefined)`
+
+```ts
+{
+	commandClass: CommandClasses.Configuration,
+	endpoint: number,
+	property: number,
+	propertyKey: number | undefined,
+}
+```
+
+-   **min. CC version:** 1
+-   **readable:** true
+-   **writeable:** true
+-   **stateful:** true
+-   **secret:** false
+-   **value type:** `"any"`
diff --git a/docs/api/CCs/DoorLock.md b/docs/api/CCs/DoorLock.md
index c8c7b1d6d6f..c5f50b200d3 100644
--- a/docs/api/CCs/DoorLock.md
+++ b/docs/api/CCs/DoorLock.md
@@ -35,3 +35,325 @@ async setConfiguration(
 ```ts
 async getConfiguration(): Promise<Pick<DoorLockCCConfigurationReport, "operationType" | "outsideHandlesCanOpenDoorConfiguration" | "insideHandlesCanOpenDoorConfiguration" | "lockTimeoutConfiguration" | "autoRelockTime" | "holdAndReleaseTime" | "twistAssist" | "blockToBlock"> | undefined>;
 ```
+
+## Door Lock CC values
+
+### `autoRelockTime`
+
+```ts
+{
+	commandClass: CommandClasses["Door Lock"],
+	endpoint: number,
+	property: "autoRelockTime",
+}
+```
+
+-   **label:** Duration in seconds until lock returns to secure state
+-   **min. CC version:** 4
+-   **readable:** true
+-   **writeable:** true
+-   **stateful:** true
+-   **secret:** false
+-   **value type:** `"number"`
+-   **min. value:** 0
+-   **max. value:** 65535
+
+### `blockToBlock`
+
+```ts
+{
+	commandClass: CommandClasses["Door Lock"],
+	endpoint: number,
+	property: "blockToBlock",
+}
+```
+
+-   **label:** Block-to-block functionality enabled
+-   **min. CC version:** 4
+-   **readable:** true
+-   **writeable:** true
+-   **stateful:** true
+-   **secret:** false
+-   **value type:** `"boolean"`
+
+### `boltStatus`
+
+```ts
+{
+	commandClass: CommandClasses["Door Lock"],
+	endpoint: number,
+	property: "boltStatus",
+}
+```
+
+-   **label:** Current status of the bolt
+-   **min. CC version:** 1
+-   **readable:** true
+-   **writeable:** false
+-   **stateful:** true
+-   **secret:** false
+-   **value type:** `"any"`
+
+### `currentMode`
+
+```ts
+{
+	commandClass: CommandClasses["Door Lock"],
+	endpoint: number,
+	property: "currentMode",
+}
+```
+
+-   **label:** Current lock mode
+-   **min. CC version:** 1
+-   **readable:** true
+-   **writeable:** true
+-   **stateful:** true
+-   **secret:** false
+-   **value type:** `"number"`
+-   **min. value:** 0
+-   **max. value:** 255
+
+### `doorStatus`
+
+```ts
+{
+	commandClass: CommandClasses["Door Lock"],
+	endpoint: number,
+	property: "doorStatus",
+}
+```
+
+-   **label:** Current status of the door
+-   **min. CC version:** 1
+-   **readable:** true
+-   **writeable:** false
+-   **stateful:** true
+-   **secret:** false
+-   **value type:** `"any"`
+
+### `duration`
+
+```ts
+{
+	commandClass: CommandClasses["Door Lock"],
+	endpoint: number,
+	property: "duration",
+}
+```
+
+-   **label:** Remaining duration until target lock mode
+-   **min. CC version:** 3
+-   **readable:** true
+-   **writeable:** false
+-   **stateful:** true
+-   **secret:** false
+-   **value type:** `"duration"`
+
+### `holdAndReleaseTime`
+
+```ts
+{
+	commandClass: CommandClasses["Door Lock"],
+	endpoint: number,
+	property: "holdAndReleaseTime",
+}
+```
+
+-   **label:** Duration in seconds the latch stays retracted
+-   **min. CC version:** 4
+-   **readable:** true
+-   **writeable:** true
+-   **stateful:** true
+-   **secret:** false
+-   **value type:** `"number"`
+-   **min. value:** 0
+-   **max. value:** 65535
+
+### `insideHandlesCanOpenDoor`
+
+```ts
+{
+	commandClass: CommandClasses["Door Lock"],
+	endpoint: number,
+	property: "insideHandlesCanOpenDoor",
+}
+```
+
+-   **label:** Which inside handles can open the door (actual status)
+-   **min. CC version:** 1
+-   **readable:** true
+-   **writeable:** false
+-   **stateful:** true
+-   **secret:** false
+-   **value type:** `"any"`
+
+### `insideHandlesCanOpenDoorConfiguration`
+
+```ts
+{
+	commandClass: CommandClasses["Door Lock"],
+	endpoint: number,
+	property: "insideHandlesCanOpenDoorConfiguration",
+}
+```
+
+-   **label:** Which inside handles can open the door (configuration)
+-   **min. CC version:** 1
+-   **readable:** true
+-   **writeable:** true
+-   **stateful:** true
+-   **secret:** false
+-   **value type:** `"any"`
+
+### `latchStatus`
+
+```ts
+{
+	commandClass: CommandClasses["Door Lock"],
+	endpoint: number,
+	property: "latchStatus",
+}
+```
+
+-   **label:** Current status of the latch
+-   **min. CC version:** 1
+-   **readable:** true
+-   **writeable:** false
+-   **stateful:** true
+-   **secret:** false
+-   **value type:** `"any"`
+
+### `lockTimeout`
+
+```ts
+{
+	commandClass: CommandClasses["Door Lock"],
+	endpoint: number,
+	property: "lockTimeout",
+}
+```
+
+-   **label:** Seconds until lock mode times out
+-   **min. CC version:** 1
+-   **readable:** true
+-   **writeable:** false
+-   **stateful:** true
+-   **secret:** false
+-   **value type:** `"number"`
+-   **min. value:** 0
+-   **max. value:** 65535
+
+### `lockTimeoutConfiguration`
+
+```ts
+{
+	commandClass: CommandClasses["Door Lock"],
+	endpoint: number,
+	property: "lockTimeoutConfiguration",
+}
+```
+
+-   **label:** Duration of timed mode in seconds
+-   **min. CC version:** 1
+-   **readable:** true
+-   **writeable:** true
+-   **stateful:** true
+-   **secret:** false
+-   **value type:** `"number"`
+-   **min. value:** 0
+-   **max. value:** 65535
+
+### `operationType`
+
+```ts
+{
+	commandClass: CommandClasses["Door Lock"],
+	endpoint: number,
+	property: "operationType",
+}
+```
+
+-   **label:** Lock operation type
+-   **min. CC version:** 1
+-   **readable:** true
+-   **writeable:** true
+-   **stateful:** true
+-   **secret:** false
+-   **value type:** `"number"`
+-   **min. value:** 0
+-   **max. value:** 255
+
+### `outsideHandlesCanOpenDoor`
+
+```ts
+{
+	commandClass: CommandClasses["Door Lock"],
+	endpoint: number,
+	property: "outsideHandlesCanOpenDoor",
+}
+```
+
+-   **label:** Which outside handles can open the door (actual status)
+-   **min. CC version:** 1
+-   **readable:** true
+-   **writeable:** false
+-   **stateful:** true
+-   **secret:** false
+-   **value type:** `"any"`
+
+### `outsideHandlesCanOpenDoorConfiguration`
+
+```ts
+{
+	commandClass: CommandClasses["Door Lock"],
+	endpoint: number,
+	property: "outsideHandlesCanOpenDoorConfiguration",
+}
+```
+
+-   **label:** Which outside handles can open the door (configuration)
+-   **min. CC version:** 1
+-   **readable:** true
+-   **writeable:** true
+-   **stateful:** true
+-   **secret:** false
+-   **value type:** `"any"`
+
+### `targetMode`
+
+```ts
+{
+	commandClass: CommandClasses["Door Lock"],
+	endpoint: number,
+	property: "targetMode",
+}
+```
+
+-   **label:** Target lock mode
+-   **min. CC version:** 1
+-   **readable:** true
+-   **writeable:** true
+-   **stateful:** true
+-   **secret:** false
+-   **value type:** `"number"`
+-   **min. value:** 0
+-   **max. value:** 255
+
+### `twistAssist`
+
+```ts
+{
+	commandClass: CommandClasses["Door Lock"],
+	endpoint: number,
+	property: "twistAssist",
+}
+```
+
+-   **label:** Twist Assist enabled
+-   **min. CC version:** 4
+-   **readable:** true
+-   **writeable:** true
+-   **stateful:** true
+-   **secret:** false
+-   **value type:** `"boolean"`
diff --git a/docs/api/CCs/EntryControl.md b/docs/api/CCs/EntryControl.md
index e89b862c81b..673be3a4b13 100644
--- a/docs/api/CCs/EntryControl.md
+++ b/docs/api/CCs/EntryControl.md
@@ -30,3 +30,47 @@ async setConfiguration(
 	keyCacheTimeout: number,
 ): Promise<Pick<EntryControlCCConfigurationReport, "keyCacheSize" | "keyCacheTimeout"> | undefined>;
 ```
+
+## Entry Control CC values
+
+### `keyCacheSize`
+
+```ts
+{
+	commandClass: CommandClasses["Entry Control"],
+	endpoint: number,
+	property: "keyCacheSize",
+}
+```
+
+-   **label:** Key cache size
+-   **description:** Number of character that must be stored before sending
+-   **min. CC version:** 1
+-   **readable:** true
+-   **writeable:** true
+-   **stateful:** true
+-   **secret:** false
+-   **value type:** `"number"`
+-   **min. value:** 1
+-   **max. value:** 32
+
+### `keyCacheTimeout`
+
+```ts
+{
+	commandClass: CommandClasses["Entry Control"],
+	endpoint: number,
+	property: "keyCacheTimeout",
+}
+```
+
+-   **label:** Key cache timeout
+-   **description:** How long the key cache must wait for additional characters
+-   **min. CC version:** 1
+-   **readable:** true
+-   **writeable:** true
+-   **stateful:** true
+-   **secret:** false
+-   **value type:** `"number"`
+-   **min. value:** 1
+-   **max. value:** 10
diff --git a/docs/api/CCs/HumidityControlMode.md b/docs/api/CCs/HumidityControlMode.md
index b98628a114c..393a61fdb38 100644
--- a/docs/api/CCs/HumidityControlMode.md
+++ b/docs/api/CCs/HumidityControlMode.md
@@ -23,3 +23,25 @@ async getSupportedModes(): Promise<
 	readonly HumidityControlMode[] | undefined
 >;
 ```
+
+## Humidity Control Mode CC values
+
+### `mode`
+
+```ts
+{
+	commandClass: CommandClasses["Humidity Control Mode"],
+	endpoint: number,
+	property: "mode",
+}
+```
+
+-   **label:** Humidity control mode
+-   **min. CC version:** 1
+-   **readable:** true
+-   **writeable:** true
+-   **stateful:** true
+-   **secret:** false
+-   **value type:** `"number"`
+-   **min. value:** 0
+-   **max. value:** 255
diff --git a/docs/api/CCs/HumidityControlOperatingState.md b/docs/api/CCs/HumidityControlOperatingState.md
index 41c1b51e526..0c2c67c58d6 100644
--- a/docs/api/CCs/HumidityControlOperatingState.md
+++ b/docs/api/CCs/HumidityControlOperatingState.md
@@ -9,3 +9,25 @@
 ```ts
 async get(): Promise<HumidityControlOperatingState | undefined>;
 ```
+
+## Humidity Control Operating State CC values
+
+### `state`
+
+```ts
+{
+	commandClass: CommandClasses["Humidity Control Operating State"],
+	endpoint: number,
+	property: "state",
+}
+```
+
+-   **label:** Humidity control operating state
+-   **min. CC version:** 1
+-   **readable:** true
+-   **writeable:** false
+-   **stateful:** true
+-   **secret:** false
+-   **value type:** `"number"`
+-   **min. value:** 0
+-   **max. value:** 255
diff --git a/docs/api/CCs/HumidityControlSetpoint.md b/docs/api/CCs/HumidityControlSetpoint.md
index 3a6b0a1e337..4bfb46663ef 100644
--- a/docs/api/CCs/HumidityControlSetpoint.md
+++ b/docs/api/CCs/HumidityControlSetpoint.md
@@ -45,3 +45,45 @@ async getSupportedScales(
 	setpointType: HumidityControlSetpointType,
 ): Promise<readonly Scale[] | undefined>;
 ```
+
+## Humidity Control Setpoint CC values
+
+### `setpoint(setpointType: number)`
+
+```ts
+{
+	commandClass: CommandClasses["Humidity Control Setpoint"],
+	endpoint: number,
+	property: "setpoint",
+	propertyKey: number,
+}
+```
+
+-   **label:** `Setpoint (${string})`
+-   **min. CC version:** 1
+-   **readable:** true
+-   **writeable:** true
+-   **stateful:** true
+-   **secret:** false
+-   **value type:** `"number"`
+
+### `setpointScale(setpointType: number)`
+
+```ts
+{
+	commandClass: CommandClasses["Humidity Control Setpoint"],
+	endpoint: number,
+	property: "setpointScale",
+	propertyKey: number,
+}
+```
+
+-   **label:** `Setpoint scale (${string})`
+-   **min. CC version:** 1
+-   **readable:** true
+-   **writeable:** false
+-   **stateful:** true
+-   **secret:** false
+-   **value type:** `"number"`
+-   **min. value:** 0
+-   **max. value:** 255
diff --git a/docs/api/CCs/Indicator.md b/docs/api/CCs/Indicator.md
index 84af36f57c8..436b7f95751 100644
--- a/docs/api/CCs/Indicator.md
+++ b/docs/api/CCs/Indicator.md
@@ -38,3 +38,43 @@ async identify(): Promise<void>;
 ```
 
 Instructs the node to identify itself. Available starting with V3 of this CC.
+
+## Indicator CC values
+
+### `valueV1`
+
+```ts
+{
+	commandClass: CommandClasses.Indicator,
+	endpoint: number,
+	property: "value",
+}
+```
+
+-   **label:** Indicator value
+-   **min. CC version:** 1
+-   **readable:** true
+-   **writeable:** true
+-   **stateful:** true
+-   **secret:** false
+-   **value type:** `"number"`
+-   **min. value:** 0
+-   **max. value:** 255
+
+### `valueV2(indicatorId: number, propertyId: number)`
+
+```ts
+{
+	commandClass: CommandClasses.Indicator,
+	endpoint: number,
+	property: number,
+	propertyKey: number,
+}
+```
+
+-   **min. CC version:** 2
+-   **readable:** true
+-   **writeable:** true
+-   **stateful:** true
+-   **secret:** false
+-   **value type:** `"any"`
diff --git a/docs/api/CCs/Irrigation.md b/docs/api/CCs/Irrigation.md
index a1f9951132c..8e18663a236 100644
--- a/docs/api/CCs/Irrigation.md
+++ b/docs/api/CCs/Irrigation.md
@@ -104,3 +104,726 @@ shutoffSystemPermanently(): Promise<void>;
 ```
 
 Shuts off the entire system permanently and prevents schedules from running.
+
+## Irrigation CC values
+
+### `errorEmergencyShutdown`
+
+```ts
+{
+	commandClass: CommandClasses.Irrigation,
+	endpoint: number,
+	property: "errorEmergencyShutdown",
+}
+```
+
+-   **label:** Error: emergency shutdown
+-   **min. CC version:** 1
+-   **readable:** true
+-   **writeable:** false
+-   **stateful:** true
+-   **secret:** false
+-   **value type:** `"boolean"`
+
+### `errorHighCurrent(valveId: ValveId)`
+
+```ts
+{
+	commandClass: CommandClasses.Irrigation,
+	endpoint: number,
+	property: ValveId,
+	propertyKey: "errorHighCurrent",
+}
+```
+
+-   **label:** `${string}: Error - Current above high threshold`
+-   **min. CC version:** 1
+-   **readable:** true
+-   **writeable:** false
+-   **stateful:** true
+-   **secret:** false
+-   **value type:** `"boolean"`
+
+### `errorHighFlow(valveId: ValveId)`
+
+```ts
+{
+	commandClass: CommandClasses.Irrigation,
+	endpoint: number,
+	property: ValveId,
+	propertyKey: "errorHighFlow",
+}
+```
+
+-   **label:** `${string}: Error - Flow above high threshold`
+-   **min. CC version:** 1
+-   **readable:** true
+-   **writeable:** false
+-   **stateful:** true
+-   **secret:** false
+-   **value type:** `"boolean"`
+
+### `errorHighPressure`
+
+```ts
+{
+	commandClass: CommandClasses.Irrigation,
+	endpoint: number,
+	property: "errorHighPressure",
+}
+```
+
+-   **label:** Error: high pressure
+-   **min. CC version:** 1
+-   **readable:** true
+-   **writeable:** false
+-   **stateful:** true
+-   **secret:** false
+-   **value type:** `"boolean"`
+
+### `errorLowCurrent(valveId: ValveId)`
+
+```ts
+{
+	commandClass: CommandClasses.Irrigation,
+	endpoint: number,
+	property: ValveId,
+	propertyKey: "errorLowCurrent",
+}
+```
+
+-   **label:** `${string}: Error - Current below low threshold`
+-   **min. CC version:** 1
+-   **readable:** true
+-   **writeable:** false
+-   **stateful:** true
+-   **secret:** false
+-   **value type:** `"boolean"`
+
+### `errorLowFlow(valveId: ValveId)`
+
+```ts
+{
+	commandClass: CommandClasses.Irrigation,
+	endpoint: number,
+	property: ValveId,
+	propertyKey: "errorLowFlow",
+}
+```
+
+-   **label:** `${string}: Error - Flow below high threshold`
+-   **min. CC version:** 1
+-   **readable:** true
+-   **writeable:** false
+-   **stateful:** true
+-   **secret:** false
+-   **value type:** `"boolean"`
+
+### `errorLowPressure`
+
+```ts
+{
+	commandClass: CommandClasses.Irrigation,
+	endpoint: number,
+	property: "errorLowPressure",
+}
+```
+
+-   **label:** Error: low pressure
+-   **min. CC version:** 1
+-   **readable:** true
+-   **writeable:** false
+-   **stateful:** true
+-   **secret:** false
+-   **value type:** `"boolean"`
+
+### `errorMaximumFlow(valveId: ValveId)`
+
+```ts
+{
+	commandClass: CommandClasses.Irrigation,
+	endpoint: number,
+	property: ValveId,
+	propertyKey: "errorMaximumFlow",
+}
+```
+
+-   **label:** `${string}: Error - Maximum flow detected`
+-   **min. CC version:** 1
+-   **readable:** true
+-   **writeable:** false
+-   **stateful:** true
+-   **secret:** false
+-   **value type:** `"boolean"`
+
+### `errorNotProgrammed`
+
+```ts
+{
+	commandClass: CommandClasses.Irrigation,
+	endpoint: number,
+	property: "errorNotProgrammed",
+}
+```
+
+-   **label:** Error: device not programmed
+-   **min. CC version:** 1
+-   **readable:** true
+-   **writeable:** false
+-   **stateful:** true
+-   **secret:** false
+-   **value type:** `"boolean"`
+
+### `errorShortCircuit(valveId: ValveId)`
+
+```ts
+{
+	commandClass: CommandClasses.Irrigation,
+	endpoint: number,
+	property: ValveId,
+	propertyKey: "errorShortCircuit",
+}
+```
+
+-   **label:** `${string}: Error - Short circuit detected`
+-   **min. CC version:** 1
+-   **readable:** true
+-   **writeable:** false
+-   **stateful:** true
+-   **secret:** false
+-   **value type:** `"boolean"`
+
+### `errorValve`
+
+```ts
+{
+	commandClass: CommandClasses.Irrigation,
+	endpoint: number,
+	property: "errorValve",
+}
+```
+
+-   **label:** Error: valve reporting error
+-   **min. CC version:** 1
+-   **readable:** true
+-   **writeable:** false
+-   **stateful:** true
+-   **secret:** false
+-   **value type:** `"boolean"`
+
+### `firstOpenZoneId`
+
+```ts
+{
+	commandClass: CommandClasses.Irrigation,
+	endpoint: number,
+	property: "firstOpenZoneId",
+}
+```
+
+-   **label:** First open zone valve ID
+-   **min. CC version:** 1
+-   **readable:** true
+-   **writeable:** false
+-   **stateful:** true
+-   **secret:** false
+-   **value type:** `"number"`
+
+### `flow`
+
+```ts
+{
+	commandClass: CommandClasses.Irrigation,
+	endpoint: number,
+	property: "flow",
+}
+```
+
+-   **label:** Flow
+-   **min. CC version:** 1
+-   **readable:** true
+-   **writeable:** false
+-   **stateful:** true
+-   **secret:** false
+-   **value type:** `"number"`
+
+### `flowSensorActive`
+
+```ts
+{
+	commandClass: CommandClasses.Irrigation,
+	endpoint: number,
+	property: "flowSensorActive",
+}
+```
+
+-   **label:** Flow sensor active
+-   **min. CC version:** 1
+-   **readable:** true
+-   **writeable:** false
+-   **stateful:** true
+-   **secret:** false
+-   **value type:** `"boolean"`
+
+### `highFlowThreshold(valveId: ValveId)`
+
+```ts
+{
+	commandClass: CommandClasses.Irrigation,
+	endpoint: number,
+	property: ValveId,
+	propertyKey: "highFlowThreshold",
+}
+```
+
+-   **label:** `${string}: High flow threshold`
+-   **min. CC version:** 1
+-   **readable:** true
+-   **writeable:** true
+-   **stateful:** true
+-   **secret:** false
+-   **value type:** `"number"`
+-   **min. value:** 0
+
+### `highPressureThreshold`
+
+```ts
+{
+	commandClass: CommandClasses.Irrigation,
+	endpoint: number,
+	property: "highPressureThreshold",
+}
+```
+
+-   **label:** High pressure threshold
+-   **min. CC version:** 1
+-   **readable:** true
+-   **writeable:** true
+-   **stateful:** true
+-   **secret:** false
+-   **value type:** `"number"`
+
+### `lowFlowThreshold(valveId: ValveId)`
+
+```ts
+{
+	commandClass: CommandClasses.Irrigation,
+	endpoint: number,
+	property: ValveId,
+	propertyKey: "lowFlowThreshold",
+}
+```
+
+-   **label:** `${string}: Low flow threshold`
+-   **min. CC version:** 1
+-   **readable:** true
+-   **writeable:** true
+-   **stateful:** true
+-   **secret:** false
+-   **value type:** `"number"`
+-   **min. value:** 0
+
+### `lowPressureThreshold`
+
+```ts
+{
+	commandClass: CommandClasses.Irrigation,
+	endpoint: number,
+	property: "lowPressureThreshold",
+}
+```
+
+-   **label:** Low pressure threshold
+-   **min. CC version:** 1
+-   **readable:** true
+-   **writeable:** true
+-   **stateful:** true
+-   **secret:** false
+-   **value type:** `"number"`
+
+### `masterValveDelay`
+
+```ts
+{
+	commandClass: CommandClasses.Irrigation,
+	endpoint: number,
+	property: "masterValveDelay",
+}
+```
+
+-   **label:** Master valve delay
+-   **description:** The delay between turning on the master valve and turning on any zone valve
+-   **min. CC version:** 1
+-   **readable:** true
+-   **writeable:** true
+-   **stateful:** true
+-   **secret:** false
+-   **value type:** `"number"`
+-   **min. value:** 0
+-   **max. value:** 255
+
+### `masterValveOpen`
+
+```ts
+{
+	commandClass: CommandClasses.Irrigation,
+	endpoint: number,
+	property: "masterValveOpen",
+}
+```
+
+-   **label:** Master valve is open
+-   **min. CC version:** 1
+-   **readable:** true
+-   **writeable:** false
+-   **stateful:** true
+-   **secret:** false
+-   **value type:** `"boolean"`
+
+### `maximumFlow(valveId: ValveId)`
+
+```ts
+{
+	commandClass: CommandClasses.Irrigation,
+	endpoint: number,
+	property: ValveId,
+	propertyKey: "maximumFlow",
+}
+```
+
+-   **label:** `${string}: Maximum flow`
+-   **min. CC version:** 1
+-   **readable:** true
+-   **writeable:** true
+-   **stateful:** true
+-   **secret:** false
+-   **value type:** `"number"`
+-   **min. value:** 0
+
+### `moistureSensorActive`
+
+```ts
+{
+	commandClass: CommandClasses.Irrigation,
+	endpoint: number,
+	property: "moistureSensorActive",
+}
+```
+
+-   **label:** Moisture sensor attached and active
+-   **min. CC version:** 1
+-   **readable:** true
+-   **writeable:** false
+-   **stateful:** true
+-   **secret:** false
+-   **value type:** `"boolean"`
+
+### `moistureSensorPolarity`
+
+```ts
+{
+	commandClass: CommandClasses.Irrigation,
+	endpoint: number,
+	property: "moistureSensorPolarity",
+}
+```
+
+-   **label:** Moisture sensor polarity
+-   **min. CC version:** 1
+-   **readable:** true
+-   **writeable:** true
+-   **stateful:** true
+-   **secret:** false
+-   **value type:** `"number"`
+-   **min. value:** 0
+-   **max. value:** 1
+
+### `nominalCurrent(valveId: ValveId)`
+
+```ts
+{
+	commandClass: CommandClasses.Irrigation,
+	endpoint: number,
+	property: ValveId,
+	propertyKey: "nominalCurrent",
+}
+```
+
+-   **label:** `${string}: Nominal current`
+-   **min. CC version:** 1
+-   **readable:** true
+-   **writeable:** false
+-   **stateful:** true
+-   **secret:** false
+-   **value type:** `"boolean"`
+
+### `nominalCurrentHighThreshold(valveId: ValveId)`
+
+```ts
+{
+	commandClass: CommandClasses.Irrigation,
+	endpoint: number,
+	property: ValveId,
+	propertyKey: "nominalCurrentHighThreshold",
+}
+```
+
+-   **label:** `${string}: Nominal current - high threshold`
+-   **min. CC version:** 1
+-   **readable:** true
+-   **writeable:** true
+-   **stateful:** true
+-   **secret:** false
+-   **value type:** `"number"`
+-   **min. value:** 0
+-   **max. value:** 2550
+
+### `nominalCurrentLowThreshold(valveId: ValveId)`
+
+```ts
+{
+	commandClass: CommandClasses.Irrigation,
+	endpoint: number,
+	property: ValveId,
+	propertyKey: "nominalCurrentLowThreshold",
+}
+```
+
+-   **label:** `${string}: Nominal current - low threshold`
+-   **min. CC version:** 1
+-   **readable:** true
+-   **writeable:** true
+-   **stateful:** true
+-   **secret:** false
+-   **value type:** `"number"`
+-   **min. value:** 0
+-   **max. value:** 2550
+
+### `pressure`
+
+```ts
+{
+	commandClass: CommandClasses.Irrigation,
+	endpoint: number,
+	property: "pressure",
+}
+```
+
+-   **label:** Pressure
+-   **min. CC version:** 1
+-   **readable:** true
+-   **writeable:** false
+-   **stateful:** true
+-   **secret:** false
+-   **value type:** `"number"`
+
+### `pressureSensorActive`
+
+```ts
+{
+	commandClass: CommandClasses.Irrigation,
+	endpoint: number,
+	property: "pressureSensorActive",
+}
+```
+
+-   **label:** Pressure sensor active
+-   **min. CC version:** 1
+-   **readable:** true
+-   **writeable:** false
+-   **stateful:** true
+-   **secret:** false
+-   **value type:** `"boolean"`
+
+### `rainSensorActive`
+
+```ts
+{
+	commandClass: CommandClasses.Irrigation,
+	endpoint: number,
+	property: "rainSensorActive",
+}
+```
+
+-   **label:** Rain sensor attached and active
+-   **min. CC version:** 1
+-   **readable:** true
+-   **writeable:** false
+-   **stateful:** true
+-   **secret:** false
+-   **value type:** `"boolean"`
+
+### `rainSensorPolarity`
+
+```ts
+{
+	commandClass: CommandClasses.Irrigation,
+	endpoint: number,
+	property: "rainSensorPolarity",
+}
+```
+
+-   **label:** Rain sensor polarity
+-   **min. CC version:** 1
+-   **readable:** true
+-   **writeable:** true
+-   **stateful:** true
+-   **secret:** false
+-   **value type:** `"number"`
+-   **min. value:** 0
+-   **max. value:** 1
+
+### `shutoffDuration`
+
+```ts
+{
+	commandClass: CommandClasses.Irrigation,
+	endpoint: number,
+	property: "shutoffDuration",
+}
+```
+
+-   **label:** Remaining shutoff duration
+-   **min. CC version:** 1
+-   **readable:** true
+-   **writeable:** false
+-   **stateful:** true
+-   **secret:** false
+-   **value type:** `"number"`
+-   **min. value:** 0
+-   **max. value:** 255
+
+### `shutoffSystem`
+
+```ts
+{
+	commandClass: CommandClasses.Irrigation,
+	endpoint: number,
+	property: "shutoff",
+}
+```
+
+-   **label:** Shutoff system
+-   **min. CC version:** 1
+-   **readable:** false
+-   **writeable:** true
+-   **stateful:** true
+-   **secret:** false
+-   **value type:** `"boolean"`
+
+### `systemVoltage`
+
+```ts
+{
+	commandClass: CommandClasses.Irrigation,
+	endpoint: number,
+	property: "systemVoltage",
+}
+```
+
+-   **label:** System voltage
+-   **min. CC version:** 1
+-   **readable:** true
+-   **writeable:** false
+-   **stateful:** true
+-   **secret:** false
+-   **value type:** `"number"`
+-   **min. value:** 0
+-   **max. value:** 255
+
+### `useMoistureSensor(valveId: ValveId)`
+
+```ts
+{
+	commandClass: CommandClasses.Irrigation,
+	endpoint: number,
+	property: ValveId,
+	propertyKey: "useMoistureSensor",
+}
+```
+
+-   **label:** `${string}: Use moisture sensor`
+-   **min. CC version:** 1
+-   **readable:** true
+-   **writeable:** true
+-   **stateful:** true
+-   **secret:** false
+-   **value type:** `"boolean"`
+
+### `useRainSensor(valveId: ValveId)`
+
+```ts
+{
+	commandClass: CommandClasses.Irrigation,
+	endpoint: number,
+	property: ValveId,
+	propertyKey: "useRainSensor",
+}
+```
+
+-   **label:** `${string}: Use rain sensor`
+-   **min. CC version:** 1
+-   **readable:** true
+-   **writeable:** true
+-   **stateful:** true
+-   **secret:** false
+-   **value type:** `"boolean"`
+
+### `valveConnected(valveId: ValveId)`
+
+```ts
+{
+	commandClass: CommandClasses.Irrigation,
+	endpoint: number,
+	property: ValveId,
+	propertyKey: "valveConnected",
+}
+```
+
+-   **label:** `${string}: Connected`
+-   **min. CC version:** 1
+-   **readable:** true
+-   **writeable:** false
+-   **stateful:** true
+-   **secret:** false
+-   **value type:** `"boolean"`
+
+### `valveRunDuration(valveId: ValveId)`
+
+```ts
+{
+	commandClass: CommandClasses.Irrigation,
+	endpoint: number,
+	property: ValveId,
+	propertyKey: "duration",
+}
+```
+
+-   **label:** `${string}: Run duration`
+-   **min. CC version:** 1
+-   **readable:** true
+-   **writeable:** true
+-   **stateful:** true
+-   **secret:** false
+-   **value type:** `"number"`
+-   **min. value:** 1
+-   **max. value:** 65535
+
+### `valveRunStartStop(valveId: ValveId)`
+
+```ts
+{
+	commandClass: CommandClasses.Irrigation,
+	endpoint: number,
+	property: ValveId,
+	propertyKey: "startStop",
+}
+```
+
+-   **label:** `${string}: Start/Stop`
+-   **min. CC version:** 1
+-   **readable:** true
+-   **writeable:** true
+-   **stateful:** true
+-   **secret:** false
+-   **value type:** `"boolean"`
diff --git a/docs/api/CCs/Language.md b/docs/api/CCs/Language.md
index 26acbf7ce7a..37b20ad92e4 100644
--- a/docs/api/CCs/Language.md
+++ b/docs/api/CCs/Language.md
@@ -15,3 +15,41 @@ async get(): Promise<Pick<LanguageCCReport, "language" | "country"> | undefined>
 ```ts
 async set(language: string, country?: string): Promise<void>;
 ```
+
+## Language CC values
+
+### `country`
+
+```ts
+{
+	commandClass: CommandClasses.Language,
+	endpoint: number,
+	property: "country",
+}
+```
+
+-   **label:** Country code
+-   **min. CC version:** 1
+-   **readable:** true
+-   **writeable:** false
+-   **stateful:** true
+-   **secret:** false
+-   **value type:** `"string"`
+
+### `language`
+
+```ts
+{
+	commandClass: CommandClasses.Language,
+	endpoint: number,
+	property: "language",
+}
+```
+
+-   **label:** Language code
+-   **min. CC version:** 1
+-   **readable:** true
+-   **writeable:** false
+-   **stateful:** true
+-   **secret:** false
+-   **value type:** `"string"`
diff --git a/docs/api/CCs/Lock.md b/docs/api/CCs/Lock.md
index 39abe6957e7..65ff514485c 100644
--- a/docs/api/CCs/Lock.md
+++ b/docs/api/CCs/Lock.md
@@ -21,3 +21,24 @@ Locks or unlocks the lock.
 **Parameters:**
 
 -   `locked`: Whether the lock should be locked
+
+## Lock CC values
+
+### `locked`
+
+```ts
+{
+	commandClass: CommandClasses.Lock,
+	endpoint: number,
+	property: "locked",
+}
+```
+
+-   **label:** Locked
+-   **description:** Whether the lock is locked
+-   **min. CC version:** 1
+-   **readable:** true
+-   **writeable:** true
+-   **stateful:** true
+-   **secret:** false
+-   **value type:** `"boolean"`
diff --git a/docs/api/CCs/ManufacturerProprietary.md b/docs/api/CCs/ManufacturerProprietary.md
index 88c13556632..db1f28f1096 100644
--- a/docs/api/CCs/ManufacturerProprietary.md
+++ b/docs/api/CCs/ManufacturerProprietary.md
@@ -16,23 +16,5 @@ async sendData(
 ### `sendAndReceiveData`
 
 ```ts
-async sendAndReceiveData(manufacturerId: number, data?: Buffer): Promise<{ manufacturerId: number; data: Buffer; } | undefined>;
-```
-
-### `fibaroVenetianBlindsGet`
-
-```ts
-async fibaroVenetianBlindsGet(): Promise<Pick<FibaroVenetianBlindCCReport, "position" | "tilt"> | undefined>;
-```
-
-### `fibaroVenetianBlindsSetPosition`
-
-```ts
-async fibaroVenetianBlindsSetPosition(value: number): Promise<void>;
-```
-
-### `fibaroVenetianBlindsSetTilt`
-
-```ts
-async fibaroVenetianBlindsSetTilt(value: number): Promise<void>;
+async sendAndReceiveData(manufacturerId: number, data?: Buffer): Promise<{ manufacturerId: number | undefined; data: Buffer; } | undefined>;
 ```
diff --git a/docs/api/CCs/ManufacturerSpecific.md b/docs/api/CCs/ManufacturerSpecific.md
index 29729c059d2..8d8924d9df3 100644
--- a/docs/api/CCs/ManufacturerSpecific.md
+++ b/docs/api/CCs/ManufacturerSpecific.md
@@ -17,3 +17,65 @@ async deviceSpecificGet(
 	deviceIdType: DeviceIdType,
 ): Promise<string | undefined>;
 ```
+
+## Manufacturer Specific CC values
+
+### `manufacturerId`
+
+```ts
+{
+	commandClass: CommandClasses["Manufacturer Specific"],
+	endpoint: number,
+	property: "manufacturerId",
+}
+```
+
+-   **label:** Manufacturer ID
+-   **min. CC version:** 1
+-   **readable:** true
+-   **writeable:** false
+-   **stateful:** true
+-   **secret:** false
+-   **value type:** `"number"`
+-   **min. value:** 0
+-   **max. value:** 65535
+
+### `productId`
+
+```ts
+{
+	commandClass: CommandClasses["Manufacturer Specific"],
+	endpoint: number,
+	property: "productId",
+}
+```
+
+-   **label:** Product ID
+-   **min. CC version:** 1
+-   **readable:** true
+-   **writeable:** false
+-   **stateful:** true
+-   **secret:** false
+-   **value type:** `"number"`
+-   **min. value:** 0
+-   **max. value:** 65535
+
+### `productType`
+
+```ts
+{
+	commandClass: CommandClasses["Manufacturer Specific"],
+	endpoint: number,
+	property: "productType",
+}
+```
+
+-   **label:** Product type
+-   **min. CC version:** 1
+-   **readable:** true
+-   **writeable:** false
+-   **stateful:** true
+-   **secret:** false
+-   **value type:** `"number"`
+-   **min. value:** 0
+-   **max. value:** 65535
diff --git a/docs/api/CCs/Meter.md b/docs/api/CCs/Meter.md
index 35e7789d3aa..a22019b4442 100644
--- a/docs/api/CCs/Meter.md
+++ b/docs/api/CCs/Meter.md
@@ -13,7 +13,7 @@ async get(options?: MeterCCGetOptions): Promise<{ rateType: RateType; value: num
 ### `getAll`
 
 ```ts
-async getAll(): Promise<{ rateType: RateType; value: number; previousValue: number | undefined; deltaTime: Maybe<number>; type: number; scale: MeterScale; }[]>;
+async getAll(): Promise<{ value: number; rateType: RateType; previousValue: number | undefined; deltaTime: Maybe<number>; type: number; scale: MeterScale; }[]>;
 ```
 
 ### `getSupported`
@@ -27,3 +27,60 @@ async getSupported(): Promise<Pick<MeterCCSupportedReport, "type" | "supportsRes
 ```ts
 async reset(options?: MeterCCResetOptions): Promise<void>;
 ```
+
+## Meter CC values
+
+### `resetAll`
+
+```ts
+{
+	commandClass: CommandClasses.Meter,
+	endpoint: number,
+	property: "reset",
+}
+```
+
+-   **label:** Reset accumulated values
+-   **min. CC version:** 1
+-   **readable:** false
+-   **writeable:** true
+-   **stateful:** true
+-   **secret:** false
+-   **value type:** `"boolean"`
+
+### `resetSingle(meterType: number)`
+
+```ts
+{
+	commandClass: CommandClasses.Meter,
+	endpoint: number,
+	property: "reset",
+	propertyKey: number,
+}
+```
+
+-   **label:** `Reset (${string})`
+-   **min. CC version:** 1
+-   **readable:** false
+-   **writeable:** true
+-   **stateful:** true
+-   **secret:** false
+-   **value type:** `"boolean"`
+
+### `value(meterType: number, rateType: RateType, scale: number)`
+
+```ts
+{
+	commandClass: CommandClasses.Meter,
+	endpoint: number,
+	property: "value",
+	propertyKey: number,
+}
+```
+
+-   **min. CC version:** 1
+-   **readable:** true
+-   **writeable:** false
+-   **stateful:** true
+-   **secret:** false
+-   **value type:** `"number"`
diff --git a/docs/api/CCs/MultilevelSensor.md b/docs/api/CCs/MultilevelSensor.md
index afebbcba910..3ed2c9cb16e 100644
--- a/docs/api/CCs/MultilevelSensor.md
+++ b/docs/api/CCs/MultilevelSensor.md
@@ -46,3 +46,23 @@ async sendReport(
 	value: number,
 ): Promise<void>;
 ```
+
+## Multilevel Sensor CC values
+
+### `value(sensorTypeName: string)`
+
+```ts
+{
+	commandClass: CommandClasses["Multilevel Sensor"],
+	endpoint: number,
+	property: string,
+}
+```
+
+-   **label:** _(dynamic)_
+-   **min. CC version:** 1
+-   **readable:** true
+-   **writeable:** false
+-   **stateful:** true
+-   **secret:** false
+-   **value type:** `"number"`
diff --git a/docs/api/CCs/MultilevelSwitch.md b/docs/api/CCs/MultilevelSwitch.md
index f146b0e1d5e..9cd111c0062 100644
--- a/docs/api/CCs/MultilevelSwitch.md
+++ b/docs/api/CCs/MultilevelSwitch.md
@@ -45,3 +45,119 @@ async stopLevelChange(): Promise<void>;
 ```ts
 async getSupported(): Promise<SwitchType | undefined>;
 ```
+
+## Multilevel Switch CC values
+
+### `compatEvent`
+
+```ts
+{
+	commandClass: CommandClasses["Multilevel Switch"],
+	endpoint: number,
+	property: "event",
+}
+```
+
+-   **label:** Event value
+-   **min. CC version:** 1
+-   **readable:** true
+-   **writeable:** false
+-   **stateful:** false
+-   **secret:** false
+-   **value type:** `"number"`
+-   **min. value:** 0
+-   **max. value:** 255
+
+### `currentValue`
+
+```ts
+{
+	commandClass: CommandClasses["Multilevel Switch"],
+	endpoint: number,
+	property: "currentValue",
+}
+```
+
+-   **label:** Current value
+-   **min. CC version:** 1
+-   **readable:** true
+-   **writeable:** false
+-   **stateful:** true
+-   **secret:** false
+-   **value type:** `"number"`
+-   **min. value:** 0
+-   **max. value:** 99
+
+### `duration`
+
+```ts
+{
+	commandClass: CommandClasses["Multilevel Switch"],
+	endpoint: number,
+	property: "duration",
+}
+```
+
+-   **label:** Remaining duration
+-   **min. CC version:** 1
+-   **readable:** true
+-   **writeable:** false
+-   **stateful:** true
+-   **secret:** false
+-   **value type:** `"duration"`
+
+### `levelChangeDown(switchType: SwitchType)`
+
+```ts
+{
+	commandClass: CommandClasses["Multilevel Switch"],
+	endpoint: number,
+	property: string,
+}
+```
+
+-   **label:** `Perform a level change (${string})`
+-   **min. CC version:** 1
+-   **readable:** true
+-   **writeable:** true
+-   **stateful:** true
+-   **secret:** false
+-   **value type:** `"boolean"`
+
+### `levelChangeUp(switchType: SwitchType)`
+
+```ts
+{
+	commandClass: CommandClasses["Multilevel Switch"],
+	endpoint: number,
+	property: string,
+}
+```
+
+-   **label:** `Perform a level change (${string})`
+-   **min. CC version:** 1
+-   **readable:** true
+-   **writeable:** true
+-   **stateful:** true
+-   **secret:** false
+-   **value type:** `"boolean"`
+
+### `targetValue`
+
+```ts
+{
+	commandClass: CommandClasses["Multilevel Switch"],
+	endpoint: number,
+	property: "targetValue",
+}
+```
+
+-   **label:** Target value
+-   **min. CC version:** 1
+-   **readable:** true
+-   **writeable:** true
+-   **stateful:** true
+-   **secret:** false
+-   **value type:** `"number"`
+-   **min. value:** 0
+-   **max. value:** 99
diff --git a/docs/api/CCs/NodeNamingAndLocation.md b/docs/api/CCs/NodeNamingAndLocation.md
index 30bcca39010..c088f95cd35 100644
--- a/docs/api/CCs/NodeNamingAndLocation.md
+++ b/docs/api/CCs/NodeNamingAndLocation.md
@@ -27,3 +27,41 @@ async getLocation(): Promise<string | undefined>;
 ```ts
 async setLocation(location: string): Promise<void>;
 ```
+
+## Node Naming and Location CC values
+
+### `location`
+
+```ts
+{
+	commandClass: CommandClasses["Node Naming and Location"],
+	endpoint: number,
+	property: "location",
+}
+```
+
+-   **label:** Node location
+-   **min. CC version:** 1
+-   **readable:** true
+-   **writeable:** true
+-   **stateful:** true
+-   **secret:** false
+-   **value type:** `"string"`
+
+### `name`
+
+```ts
+{
+	commandClass: CommandClasses["Node Naming and Location"],
+	endpoint: number,
+	property: "name",
+}
+```
+
+-   **label:** Node name
+-   **min. CC version:** 1
+-   **readable:** true
+-   **writeable:** true
+-   **stateful:** true
+-   **secret:** false
+-   **value type:** `"string"`
diff --git a/docs/api/CCs/Notification.md b/docs/api/CCs/Notification.md
index 0aa5b2178bf..85b8b8f4225 100644
--- a/docs/api/CCs/Notification.md
+++ b/docs/api/CCs/Notification.md
@@ -50,3 +50,104 @@ async getSupportedEvents(
 	notificationType: number,
 ): Promise<readonly number[] | undefined>;
 ```
+
+## Notification CC values
+
+### `alarmLevel`
+
+```ts
+{
+	commandClass: CommandClasses.Notification,
+	endpoint: number,
+	property: "alarmLevel",
+}
+```
+
+-   **label:** Alarm Level
+-   **min. CC version:** 1
+-   **readable:** true
+-   **writeable:** false
+-   **stateful:** true
+-   **secret:** false
+-   **value type:** `"number"`
+-   **min. value:** 0
+-   **max. value:** 255
+
+### `alarmType`
+
+```ts
+{
+	commandClass: CommandClasses.Notification,
+	endpoint: number,
+	property: "alarmType",
+}
+```
+
+-   **label:** Alarm Type
+-   **min. CC version:** 1
+-   **readable:** true
+-   **writeable:** false
+-   **stateful:** true
+-   **secret:** false
+-   **value type:** `"number"`
+-   **min. value:** 0
+-   **max. value:** 255
+
+### `notificationVariable(notificationName: string, variableName: string)`
+
+```ts
+{
+	commandClass: CommandClasses.Notification,
+	endpoint: number,
+	property: string,
+	propertyKey: string,
+}
+```
+
+-   **min. CC version:** 1
+-   **readable:** true
+-   **writeable:** true
+-   **stateful:** true
+-   **secret:** false
+-   **value type:** `"any"`
+
+### `unknownNotificationType(notificationType: number)`
+
+```ts
+{
+	commandClass: CommandClasses.Notification,
+	endpoint: number,
+	property: string,
+}
+```
+
+-   **label:** `Unknown notification (${string})`
+-   **min. CC version:** 1
+-   **readable:** true
+-   **writeable:** false
+-   **stateful:** true
+-   **secret:** false
+-   **value type:** `"number"`
+-   **min. value:** 0
+-   **max. value:** 255
+
+### `unknownNotificationVariable(notificationType: number, notificationName: string)`
+
+```ts
+{
+	commandClass: CommandClasses.Notification,
+	endpoint: number,
+	property: string,
+	propertyKey: "unknown",
+}
+```
+
+-   **label:** `${string}: Unknown value`
+-   **min. CC version:** 1
+-   **readable:** true
+-   **writeable:** false
+-   **stateful:** true
+-   **secret:** false
+-   **value type:** `"number"`
+-   **min. value:** 0
+-   **max. value:** 255
diff --git a/docs/api/CCs/Protection.md b/docs/api/CCs/Protection.md
index dee540d2127..950a09f13d9 100644
--- a/docs/api/CCs/Protection.md
+++ b/docs/api/CCs/Protection.md
@@ -48,3 +48,81 @@ async getTimeout(): Promise<Timeout | undefined>;
 ```ts
 async setTimeout(timeout: Timeout): Promise<void>;
 ```
+
+## Protection CC values
+
+### `exclusiveControlNodeId`
+
+```ts
+{
+	commandClass: CommandClasses.Protection,
+	endpoint: number,
+	property: "exclusiveControlNodeId",
+}
+```
+
+-   **label:** Node ID with exclusive control
+-   **min. CC version:** 2
+-   **readable:** true
+-   **writeable:** true
+-   **stateful:** true
+-   **secret:** false
+-   **value type:** `"number"`
+-   **min. value:** 1
+-   **max. value:** 232
+
+### `localProtectionState`
+
+```ts
+{
+	commandClass: CommandClasses.Protection,
+	endpoint: number,
+	property: "local",
+}
+```
+
+-   **label:** Local protection state
+-   **min. CC version:** 1
+-   **readable:** true
+-   **writeable:** true
+-   **stateful:** true
+-   **secret:** false
+-   **value type:** `"number"`
+
+### `rfProtectionState`
+
+```ts
+{
+	commandClass: CommandClasses.Protection,
+	endpoint: number,
+	property: "rf",
+}
+```
+
+-   **label:** RF protection state
+-   **min. CC version:** 2
+-   **readable:** true
+-   **writeable:** true
+-   **stateful:** true
+-   **secret:** false
+-   **value type:** `"number"`
+
+### `timeout`
+
+```ts
+{
+	commandClass: CommandClasses.Protection,
+	endpoint: number,
+	property: "timeout",
+}
+```
+
+-   **label:** RF protection timeout
+-   **min. CC version:** 2
+-   **readable:** true
+-   **writeable:** true
+-   **stateful:** true
+-   **secret:** false
+-   **value type:** `"number"`
+-   **min. value:** 0
+-   **max. value:** 255
diff --git a/docs/api/CCs/SceneActivation.md b/docs/api/CCs/SceneActivation.md
index 1d002fd2955..3c6a274bace 100644
--- a/docs/api/CCs/SceneActivation.md
+++ b/docs/api/CCs/SceneActivation.md
@@ -18,3 +18,43 @@ Activates the Scene with the given ID.
 **Parameters:**
 
 -   `duration`: The duration specifying how long the transition should take. Can be a Duration instance or a user-friendly duration string like `"1m17s"`.
+
+## Scene Activation CC values
+
+### `dimmingDuration`
+
+```ts
+{
+	commandClass: CommandClasses["Scene Activation"],
+	endpoint: number,
+	property: "dimmingDuration",
+}
+```
+
+-   **label:** Dimming duration
+-   **min. CC version:** 1
+-   **readable:** true
+-   **writeable:** true
+-   **stateful:** true
+-   **secret:** false
+-   **value type:** `"duration"`
+
+### `sceneId`
+
+```ts
+{
+	commandClass: CommandClasses["Scene Activation"],
+	endpoint: number,
+	property: "sceneId",
+}
+```
+
+-   **label:** Scene ID
+-   **min. CC version:** 1
+-   **readable:** true
+-   **writeable:** true
+-   **stateful:** false
+-   **secret:** false
+-   **value type:** `"number"`
+-   **min. value:** 1
+-   **max. value:** 255
diff --git a/docs/api/CCs/SceneActuatorConfiguration.md b/docs/api/CCs/SceneActuatorConfiguration.md
index ca22fe4dcc6..0b6d68b4c71 100644
--- a/docs/api/CCs/SceneActuatorConfiguration.md
+++ b/docs/api/CCs/SceneActuatorConfiguration.md
@@ -36,3 +36,45 @@ async get(
 	| undefined
 >;
 ```
+
+## Scene Actuator Configuration CC values
+
+### `dimmingDuration(sceneId: number)`
+
+```ts
+{
+	commandClass: CommandClasses["Scene Actuator Configuration"],
+	endpoint: number,
+	property: "dimmingDuration",
+	propertyKey: number,
+}
+```
+
+-   **label:** `Dimming duration (${number})`
+-   **min. CC version:** 1
+-   **readable:** true
+-   **writeable:** true
+-   **stateful:** true
+-   **secret:** false
+-   **value type:** `"duration"`
+
+### `level(sceneId: number)`
+
+```ts
+{
+	commandClass: CommandClasses["Scene Actuator Configuration"],
+	endpoint: number,
+	property: "level",
+	propertyKey: number,
+}
+```
+
+-   **label:** `Level (${number})`
+-   **min. CC version:** 1
+-   **readable:** true
+-   **writeable:** true
+-   **stateful:** true
+-   **secret:** false
+-   **value type:** `"number"`
+-   **min. value:** 0
+-   **max. value:** 255
diff --git a/docs/api/CCs/SceneControllerConfiguration.md b/docs/api/CCs/SceneControllerConfiguration.md
index 08d649f4c35..747a9267d2e 100644
--- a/docs/api/CCs/SceneControllerConfiguration.md
+++ b/docs/api/CCs/SceneControllerConfiguration.md
@@ -45,3 +45,45 @@ async get(
 	| undefined
 >;
 ```
+
+## Scene Controller Configuration CC values
+
+### `dimmingDuration(groupId: number)`
+
+```ts
+{
+	commandClass: CommandClasses["Scene Controller Configuration"],
+	endpoint: number,
+	property: "dimmingDuration",
+	propertyKey: number,
+}
+```
+
+-   **label:** `Dimming duration (${number})`
+-   **min. CC version:** 1
+-   **readable:** true
+-   **writeable:** true
+-   **stateful:** true
+-   **secret:** false
+-   **value type:** `"duration"`
+
+### `sceneId(groupId: number)`
+
+```ts
+{
+	commandClass: CommandClasses["Scene Controller Configuration"],
+	endpoint: number,
+	property: "sceneId",
+	propertyKey: number,
+}
+```
+
+-   **label:** `Associated Scene ID (${number})`
+-   **min. CC version:** 1
+-   **readable:** true
+-   **writeable:** true
+-   **stateful:** true
+-   **secret:** false
+-   **value type:** `"number"`
+-   **min. value:** 0
+-   **max. value:** 255
diff --git a/docs/api/CCs/SoundSwitch.md b/docs/api/CCs/SoundSwitch.md
index c68b48e2864..a626fa20e61 100644
--- a/docs/api/CCs/SoundSwitch.md
+++ b/docs/api/CCs/SoundSwitch.md
@@ -48,3 +48,85 @@ async stopPlaying(): Promise<void>;
 ```ts
 async getPlaying(): Promise<Pick<SoundSwitchCCTonePlayReport, "toneId" | "volume"> | undefined>;
 ```
+
+## Sound Switch CC values
+
+### `defaultToneId`
+
+```ts
+{
+	commandClass: CommandClasses["Sound Switch"],
+	endpoint: number,
+	property: "defaultToneId",
+}
+```
+
+-   **label:** Default tone ID
+-   **min. CC version:** 1
+-   **readable:** true
+-   **writeable:** true
+-   **stateful:** true
+-   **secret:** false
+-   **value type:** `"number"`
+-   **min. value:** 0
+-   **max. value:** 254
+
+### `defaultVolume`
+
+```ts
+{
+	commandClass: CommandClasses["Sound Switch"],
+	endpoint: number,
+	property: "defaultVolume",
+}
+```
+
+-   **label:** Default volume
+-   **min. CC version:** 1
+-   **readable:** true
+-   **writeable:** true
+-   **stateful:** true
+-   **secret:** false
+-   **value type:** `"number"`
+-   **min. value:** 0
+-   **max. value:** 100
+
+### `toneId`
+
+```ts
+{
+	commandClass: CommandClasses["Sound Switch"],
+	endpoint: number,
+	property: "toneId",
+}
+```
+
+-   **label:** Play Tone
+-   **min. CC version:** 1
+-   **readable:** true
+-   **writeable:** true
+-   **stateful:** true
+-   **secret:** false
+-   **value type:** `"number"`
+-   **min. value:** 0
+-   **max. value:** 255
+
+### `volume`
+
+```ts
+{
+	commandClass: CommandClasses["Sound Switch"],
+	endpoint: number,
+	property: "volume",
+}
+```
+
+-   **label:** Volume
+-   **min. CC version:** 1
+-   **readable:** true
+-   **writeable:** true
+-   **stateful:** true
+-   **secret:** false
+-   **value type:** `"number"`
+-   **min. value:** 0
+-   **max. value:** 100
diff --git a/docs/api/CCs/ThermostatFanMode.md b/docs/api/CCs/ThermostatFanMode.md
index 3c778c7ed43..017ab2c93a8 100644
--- a/docs/api/CCs/ThermostatFanMode.md
+++ b/docs/api/CCs/ThermostatFanMode.md
@@ -23,3 +23,43 @@ async getSupportedModes(): Promise<
 	readonly ThermostatFanMode[] | undefined
 >;
 ```
+
+## Thermostat Fan Mode CC values
+
+### `fanMode`
+
+```ts
+{
+	commandClass: CommandClasses["Thermostat Fan Mode"],
+	endpoint: number,
+	property: "mode",
+}
+```
+
+-   **label:** Thermostat fan mode
+-   **min. CC version:** 1
+-   **readable:** true
+-   **writeable:** true
+-   **stateful:** true
+-   **secret:** false
+-   **value type:** `"number"`
+-   **min. value:** 0
+-   **max. value:** 255
+
+### `turnedOff`
+
+```ts
+{
+	commandClass: CommandClasses["Thermostat Fan Mode"],
+	endpoint: number,
+	property: "off",
+}
+```
+
+-   **label:** Thermostat fan turned off
+-   **min. CC version:** 3
+-   **readable:** true
+-   **writeable:** true
+-   **stateful:** true
+-   **secret:** false
+-   **value type:** `"boolean"`
diff --git a/docs/api/CCs/ThermostatFanState.md b/docs/api/CCs/ThermostatFanState.md
index 5cd35fa4d12..7b33618f625 100644
--- a/docs/api/CCs/ThermostatFanState.md
+++ b/docs/api/CCs/ThermostatFanState.md
@@ -9,3 +9,25 @@
 ```ts
 async get(): Promise<ThermostatFanState | undefined>;
 ```
+
+## Thermostat Fan State CC values
+
+### `fanState`
+
+```ts
+{
+	commandClass: CommandClasses["Thermostat Fan State"],
+	endpoint: number,
+	property: "state",
+}
+```
+
+-   **label:** Thermostat fan state
+-   **min. CC version:** 1
+-   **readable:** true
+-   **writeable:** false
+-   **stateful:** true
+-   **secret:** false
+-   **value type:** `"number"`
+-   **min. value:** 0
+-   **max. value:** 255
diff --git a/docs/api/CCs/ThermostatMode.md b/docs/api/CCs/ThermostatMode.md
index 8ec11902365..3b2ec87edb7 100644
--- a/docs/api/CCs/ThermostatMode.md
+++ b/docs/api/CCs/ThermostatMode.md
@@ -33,3 +33,43 @@ async getSupportedModes(): Promise<
 	readonly ThermostatMode[] | undefined
 >;
 ```
+
+## Thermostat Mode CC values
+
+### `manufacturerData`
+
+```ts
+{
+	commandClass: CommandClasses["Thermostat Mode"],
+	endpoint: number,
+	property: "manufacturerData",
+}
+```
+
+-   **label:** Manufacturer data
+-   **min. CC version:** 1
+-   **readable:** true
+-   **writeable:** false
+-   **stateful:** true
+-   **secret:** false
+-   **value type:** `"buffer"`
+
+### `thermostatMode`
+
+```ts
+{
+	commandClass: CommandClasses["Thermostat Mode"],
+	endpoint: number,
+	property: "mode",
+}
+```
+
+-   **label:** Thermostat mode
+-   **min. CC version:** 1
+-   **readable:** true
+-   **writeable:** true
+-   **stateful:** true
+-   **secret:** false
+-   **value type:** `"number"`
+-   **min. value:** 0
+-   **max. value:** 255
diff --git a/docs/api/CCs/ThermostatOperatingState.md b/docs/api/CCs/ThermostatOperatingState.md
index f1deeb4dc8a..a6239fbd2c0 100644
--- a/docs/api/CCs/ThermostatOperatingState.md
+++ b/docs/api/CCs/ThermostatOperatingState.md
@@ -9,3 +9,25 @@
 ```ts
 async get(): Promise<ThermostatOperatingState | undefined>;
 ```
+
+## Thermostat Operating State CC values
+
+### `operatingState`
+
+```ts
+{
+	commandClass: CommandClasses["Thermostat Operating State"],
+	endpoint: number,
+	property: "state",
+}
+```
+
+-   **label:** Operating state
+-   **min. CC version:** 1
+-   **readable:** true
+-   **writeable:** false
+-   **stateful:** true
+-   **secret:** false
+-   **value type:** `"number"`
+-   **min. value:** 0
+-   **max. value:** 255
diff --git a/docs/api/CCs/ThermostatSetback.md b/docs/api/CCs/ThermostatSetback.md
index a9fea5152e7..e74a956cc7e 100644
--- a/docs/api/CCs/ThermostatSetback.md
+++ b/docs/api/CCs/ThermostatSetback.md
@@ -18,3 +18,43 @@ async set(
 	setbackState: SetbackState,
 ): Promise<void>;
 ```
+
+## Thermostat Setback CC values
+
+### `setbackState`
+
+```ts
+{
+	commandClass: CommandClasses["Thermostat Setback"],
+	endpoint: number,
+	property: "setbackState",
+}
+```
+
+-   **label:** Setback state
+-   **min. CC version:** 1
+-   **readable:** true
+-   **writeable:** true
+-   **stateful:** true
+-   **secret:** false
+-   **value type:** `"number"`
+-   **min. value:** -12.8
+-   **max. value:** 12
+
+### `setbackType`
+
+```ts
+{
+	commandClass: CommandClasses["Thermostat Setback"],
+	endpoint: number,
+	property: "setbackType",
+}
+```
+
+-   **label:** Setback type
+-   **min. CC version:** 1
+-   **readable:** true
+-   **writeable:** true
+-   **stateful:** true
+-   **secret:** false
+-   **value type:** `"any"`
diff --git a/docs/api/CCs/ThermostatSetpoint.md b/docs/api/CCs/ThermostatSetpoint.md
index a8cadf5a8b9..0c65d5f1e4f 100644
--- a/docs/api/CCs/ThermostatSetpoint.md
+++ b/docs/api/CCs/ThermostatSetpoint.md
@@ -39,3 +39,24 @@ async getSupportedSetpointTypes(): Promise<
 Requests the supported setpoint types from the node. Due to inconsistencies it is NOT recommended
 to use this method on nodes with CC versions 1 and 2. Instead rely on the information determined
 during node interview.
+
+## Thermostat Setpoint CC values
+
+### `setpoint(setpointType: ThermostatSetpointType)`
+
+```ts
+{
+	commandClass: CommandClasses["Thermostat Setpoint"],
+	endpoint: number,
+	property: "setpoint",
+	propertyKey: ThermostatSetpointType,
+}
+```
+
+-   **label:** `Setpoint (${string})`
+-   **min. CC version:** 1
+-   **readable:** true
+-   **writeable:** true
+-   **stateful:** true
+-   **secret:** false
+-   **value type:** `"number"`
diff --git a/docs/api/CCs/TimeParameters.md b/docs/api/CCs/TimeParameters.md
index f29332e3245..5db75477460 100644
--- a/docs/api/CCs/TimeParameters.md
+++ b/docs/api/CCs/TimeParameters.md
@@ -15,3 +15,23 @@ async get(): Promise<Date | undefined>;
 ```ts
 async set(dateAndTime: Date): Promise<void>;
 ```
+
+## Time Parameters CC values
+
+### `dateAndTime`
+
+```ts
+{
+	commandClass: CommandClasses["Time Parameters"],
+	endpoint: number,
+	property: "dateAndTime",
+}
+```
+
+-   **label:** Date and Time
+-   **min. CC version:** 1
+-   **readable:** true
+-   **writeable:** true
+-   **stateful:** true
+-   **secret:** false
+-   **value type:** `"any"`
diff --git a/docs/api/CCs/UserCode.md b/docs/api/CCs/UserCode.md
index 378f5bdc29f..2b72a2ddc45 100644
--- a/docs/api/CCs/UserCode.md
+++ b/docs/api/CCs/UserCode.md
@@ -96,3 +96,80 @@ async setMasterCode(masterCode: string): Promise<void>;
 ```ts
 async getUserCodeChecksum(): Promise<number | undefined>;
 ```
+
+## User Code CC values
+
+### `keypadMode`
+
+```ts
+{
+	commandClass: CommandClasses["User Code"],
+	endpoint: number,
+	property: "keypadMode",
+}
+```
+
+-   **label:** Keypad Mode
+-   **min. CC version:** 2
+-   **readable:** true
+-   **writeable:** false
+-   **stateful:** true
+-   **secret:** false
+-   **value type:** `"number"`
+
+### `masterCode`
+
+```ts
+{
+	commandClass: CommandClasses["User Code"],
+	endpoint: number,
+	property: "masterCode",
+}
+```
+
+-   **label:** Master Code
+-   **min. CC version:** 2
+-   **readable:** true
+-   **writeable:** true
+-   **stateful:** true
+-   **secret:** true
+-   **value type:** `"string"`
+-   **min. length:** 4
+-   **max. length:** 10
+
+### `userCode(userId: number)`
+
+```ts
+{
+	commandClass: CommandClasses["User Code"],
+	endpoint: number,
+	property: "userCode",
+	propertyKey: number,
+}
+```
+
+-   **min. CC version:** 1
+-   **readable:** true
+-   **writeable:** true
+-   **stateful:** true
+-   **secret:** true
+-   **value type:** `"any"`
+
+### `userIdStatus(userId: number)`
+
+```ts
+{
+	commandClass: CommandClasses["User Code"],
+	endpoint: number,
+	property: "userIdStatus",
+	propertyKey: number,
+}
+```
+
+-   **label:** `User ID status (${number})`
+-   **min. CC version:** 1
+-   **readable:** true
+-   **writeable:** true
+-   **stateful:** true
+-   **secret:** false
+-   **value type:** `"number"`
diff --git a/docs/api/CCs/Version.md b/docs/api/CCs/Version.md
index 7b4fa8c1135..b0991fe61a4 100644
--- a/docs/api/CCs/Version.md
+++ b/docs/api/CCs/Version.md
@@ -29,3 +29,239 @@ async getCapabilities(): Promise<Pick<VersionCCCapabilitiesReport, "supportsZWav
 ```ts
 async getZWaveSoftware(): Promise<Pick<VersionCCZWaveSoftwareReport, "sdkVersion" | "applicationFrameworkAPIVersion" | "applicationFrameworkBuildNumber" | "hostInterfaceVersion" | "hostInterfaceBuildNumber" | "zWaveProtocolVersion" | "zWaveProtocolBuildNumber" | "applicationVersion" | "applicationBuildNumber"> | undefined>;
 ```
+
+## Version CC values
+
+### `applicationBuildNumber`
+
+```ts
+{
+	commandClass: CommandClasses.Version,
+	endpoint: number,
+	property: "applicationBuildNumber",
+}
+```
+
+-   **label:** Application build number
+-   **min. CC version:** 3
+-   **readable:** true
+-   **writeable:** false
+-   **stateful:** true
+-   **secret:** false
+-   **value type:** `"string"`
+
+### `applicationFrameworkAPIVersion`
+
+```ts
+{
+	commandClass: CommandClasses.Version,
+	endpoint: number,
+	property: "applicationFrameworkAPIVersion",
+}
+```
+
+-   **label:** Z-Wave application framework API version
+-   **min. CC version:** 3
+-   **readable:** true
+-   **writeable:** false
+-   **stateful:** true
+-   **secret:** false
+-   **value type:** `"string"`
+
+### `applicationFrameworkBuildNumber`
+
+```ts
+{
+	commandClass: CommandClasses.Version,
+	endpoint: number,
+	property: "applicationFrameworkBuildNumber",
+}
+```
+
+-   **label:** Z-Wave application framework API build number
+-   **min. CC version:** 3
+-   **readable:** true
+-   **writeable:** false
+-   **stateful:** true
+-   **secret:** false
+-   **value type:** `"string"`
+
+### `applicationVersion`
+
+```ts
+{
+	commandClass: CommandClasses.Version,
+	endpoint: number,
+	property: "applicationVersion",
+}
+```
+
+-   **label:** Application version
+-   **min. CC version:** 3
+-   **readable:** true
+-   **writeable:** false
+-   **stateful:** true
+-   **secret:** false
+-   **value type:** `"string"`
+
+### `firmwareVersions`
+
+```ts
+{
+	commandClass: CommandClasses.Version,
+	endpoint: number,
+	property: "firmwareVersions",
+}
+```
+
+-   **label:** Z-Wave chip firmware versions
+-   **min. CC version:** 1
+-   **readable:** true
+-   **writeable:** false
+-   **stateful:** true
+-   **secret:** false
+-   **value type:** `"string[]"`
+
+### `hardwareVersion`
+
+```ts
+{
+	commandClass: CommandClasses.Version,
+	endpoint: number,
+	property: "hardwareVersion",
+}
+```
+
+-   **label:** Z-Wave chip hardware version
+-   **min. CC version:** 2
+-   **readable:** true
+-   **writeable:** false
+-   **stateful:** true
+-   **secret:** false
+-   **value type:** `"number"`
+
+### `libraryType`
+
+```ts
+{
+	commandClass: CommandClasses.Version,
+	endpoint: number,
+	property: "libraryType",
+}
+```
+
+-   **label:** Library type
+-   **min. CC version:** 1
+-   **readable:** true
+-   **writeable:** false
+-   **stateful:** true
+-   **secret:** false
+-   **value type:** `"number"`
+
+### `protocolVersion`
+
+```ts
+{
+	commandClass: CommandClasses.Version,
+	endpoint: number,
+	property: "protocolVersion",
+}
+```
+
+-   **label:** Z-Wave protocol version
+-   **min. CC version:** 1
+-   **readable:** true
+-   **writeable:** false
+-   **stateful:** true
+-   **secret:** false
+-   **value type:** `"string"`
+
+### `sdkVersion`
+
+```ts
+{
+	commandClass: CommandClasses.Version,
+	endpoint: number,
+	property: "sdkVersion",
+}
+```
+
+-   **label:** SDK version
+-   **min. CC version:** 3
+-   **readable:** true
+-   **writeable:** false
+-   **stateful:** true
+-   **secret:** false
+-   **value type:** `"string"`
+
+### `serialAPIBuildNumber`
+
+```ts
+{
+	commandClass: CommandClasses.Version,
+	endpoint: number,
+	property: "hostInterfaceBuildNumber",
+}
+```
+
+-   **label:** Serial API build number
+-   **min. CC version:** 3
+-   **readable:** true
+-   **writeable:** false
+-   **stateful:** true
+-   **secret:** false
+-   **value type:** `"string"`
+
+### `serialAPIVersion`
+
+```ts
+{
+	commandClass: CommandClasses.Version,
+	endpoint: number,
+	property: "hostInterfaceVersion",
+}
+```
+
+-   **label:** Serial API version
+-   **min. CC version:** 3
+-   **readable:** true
+-   **writeable:** false
+-   **stateful:** true
+-   **secret:** false
+-   **value type:** `"string"`
+
+### `zWaveProtocolBuildNumber`
+
+```ts
+{
+	commandClass: CommandClasses.Version,
+	endpoint: number,
+	property: "zWaveProtocolBuildNumber",
+}
+```
+
+-   **label:** Z-Wave protocol build number
+-   **min. CC version:** 3
+-   **readable:** true
+-   **writeable:** false
+-   **stateful:** true
+-   **secret:** false
+-   **value type:** `"string"`
+
+### `zWaveProtocolVersion`
+
+```ts
+{
+	commandClass: CommandClasses.Version,
+	endpoint: number,
+	property: "zWaveProtocolVersion",
+}
+```
+
+-   **label:** Z-Wave protocol version
+-   **min. CC version:** 3
+-   **readable:** true
+-   **writeable:** false
+-   **stateful:** true
+-   **secret:** false
+-   **value type:** `"string"`
diff --git a/docs/api/CCs/WakeUp.md b/docs/api/CCs/WakeUp.md
index 15ff6838801..af645f46391 100644
--- a/docs/api/CCs/WakeUp.md
+++ b/docs/api/CCs/WakeUp.md
@@ -30,3 +30,43 @@ async setInterval(
 ```ts
 async sendNoMoreInformation(): Promise<void>;
 ```
+
+## Wake Up CC values
+
+### `controllerNodeId`
+
+```ts
+{
+	commandClass: CommandClasses["Wake Up"],
+	endpoint: number,
+	property: "controllerNodeId",
+}
+```
+
+-   **label:** Node ID of the controller
+-   **min. CC version:** 1
+-   **readable:** true
+-   **writeable:** false
+-   **stateful:** true
+-   **secret:** false
+-   **value type:** `"any"`
+
+### `wakeUpInterval`
+
+```ts
+{
+	commandClass: CommandClasses["Wake Up"],
+	endpoint: number,
+	property: "wakeUpInterval",
+}
+```
+
+-   **label:** Wake Up interval
+-   **min. CC version:** 1
+-   **readable:** true
+-   **writeable:** true
+-   **stateful:** true
+-   **secret:** false
+-   **value type:** `"number"`
+-   **min. value:** 0
+-   **max. value:** 16777215
diff --git a/packages/cc/maintenance/_build.ts b/packages/cc/maintenance/_build.ts
index 6707be0eeb5..769d1d775ad 100644
--- a/packages/cc/maintenance/_build.ts
+++ b/packages/cc/maintenance/_build.ts
@@ -1,6 +1,7 @@
 import { red } from "ansi-colors";
 import { generateCCAPIInterface } from "./generateCCAPIInterface";
 import { generateCCExports } from "./generateCCExports";
+import { generateCCValuesInterface } from "./generateCCValuesInterface";
 // import { lintCCConstructors } from "./lintCCConstructor";
 import { lintCCInterview } from "./lintCCInterview";
 import { lintCCValidateArgs } from "./lintCCValidateArgs";
@@ -14,7 +15,11 @@ const lint = () =>
 		lintCCValidateArgs(),
 	]);
 const prebuild = () =>
-	Promise.all([generateCCAPIInterface(), generateCCExports()]);
+	Promise.all([
+		generateCCAPIInterface(),
+		generateCCValuesInterface(),
+		generateCCExports(),
+	]);
 
 (async () => {
 	if (argv.includes("lint")) {
diff --git a/packages/cc/maintenance/generateCCAPIInterface.ts b/packages/cc/maintenance/generateCCAPIInterface.ts
index dfffa8ad19b..e91d51bced5 100644
--- a/packages/cc/maintenance/generateCCAPIInterface.ts
+++ b/packages/cc/maintenance/generateCCAPIInterface.ts
@@ -65,10 +65,9 @@ export async function generateCCAPIInterface(): Promise<void> {
 		"\n" +
 		CCsWithAPI.map(
 			({ name, className, file }) =>
-				`\t${name}: import("${path.relative(
-					libDir,
-					ccDir,
-				)}/${file}").${className};`,
+				`\t${name}: import("${path
+					.relative(libDir, ccDir)
+					.replace(/\\/g, "/")}/${file}").${className};`,
 		).join("\n") +
 		"\n" +
 		apiFileContent.slice(endTokenStart);
diff --git a/packages/cc/maintenance/generateCCExports.ts b/packages/cc/maintenance/generateCCExports.ts
index 044102adf34..7116ca89be4 100644
--- a/packages/cc/maintenance/generateCCExports.ts
+++ b/packages/cc/maintenance/generateCCExports.ts
@@ -140,7 +140,12 @@ function findExports() {
 				node.modifiers?.some(
 					(m) => m.kind === ts.SyntaxKind.ExportKeyword,
 				) &&
-				hasPublicAPIComment(node, sourceFile)
+				// Export consts marked with @publicAPI
+				(hasPublicAPIComment(node, sourceFile) ||
+					// and the xyzCCValues const
+					node.declarationList.declarations.some((d) =>
+						d.name.getText().endsWith("CCValues"),
+					))
 			) {
 				for (const variable of node.declarationList.declarations) {
 					if (ts.isIdentifier(variable.name)) {
diff --git a/packages/cc/maintenance/generateCCValuesInterface.ts b/packages/cc/maintenance/generateCCValuesInterface.ts
new file mode 100644
index 00000000000..6ba4bcd1650
--- /dev/null
+++ b/packages/cc/maintenance/generateCCValuesInterface.ts
@@ -0,0 +1,80 @@
+/*!
+ * This script generates the interface `CCAPIs` in `src/lib/commandclass/API.ts`
+ * which is used to strongly-type the simplified API exposed via
+ * `ZWaveNode.commandClasses.xyz`
+ */
+
+import { formatWithPrettier } from "@zwave-js/maintenance";
+import * as fs from "fs-extra";
+import * as path from "path";
+
+const apiRegex = /^@API\(CommandClasses(?:\.|\[)(.+?)(?:\])?\)/m;
+const valuesDefinitionRegex = /export const ([^\s]+CCValues) =/;
+const ccDir = path.join(__dirname, "..", "src/cc");
+const libDir = path.join(__dirname, "..", "src/lib");
+const valuesFile = path.join(libDir, "Values.ts");
+
+const startTokenInterface = "\t// AUTO GENERATION BELOW";
+const endTokenInterface = "}";
+
+process.on("unhandledRejection", (r) => {
+	throw r;
+});
+
+export async function generateCCValuesInterface(): Promise<void> {
+	const ccFiles = (await fs.readdir(ccDir)).filter(
+		(file) => file.endsWith(".ts") && !file.endsWith("test.ts"),
+	);
+
+	const CCsWithValues: { name: string; className: string; file: string }[] =
+		[];
+
+	for (const ccFile of ccFiles) {
+		const fileContent = await fs.readFile(path.join(ccDir, ccFile), "utf8");
+		// Extract the CC name from e.g. `@API(CommandClasses["Binary Sensor"])`
+		const apiMatch = apiRegex.exec(fileContent);
+		// Extract the class name from e.g. `export class BasicCCAPI extends CCAPI`
+		const classMatch = valuesDefinitionRegex.exec(fileContent);
+		if (apiMatch && classMatch) {
+			CCsWithValues.push({
+				file: ccFile.replace(/\.ts$/, ""),
+				name: apiMatch[1],
+				className: classMatch[1],
+			});
+		}
+	}
+
+	console.log(`Found ${CCsWithValues.length} CC value definitions...`);
+
+	const originalValuesFileContent = await fs.readFile(valuesFile, "utf8");
+	let valuesFileContent = originalValuesFileContent;
+
+	// Generate interface
+	const startTokenEnd =
+		valuesFileContent.indexOf(startTokenInterface) +
+		startTokenInterface.length;
+	const endTokenStart = valuesFileContent.indexOf(
+		endTokenInterface,
+		startTokenEnd,
+	);
+	valuesFileContent =
+		valuesFileContent.slice(0, startTokenEnd) +
+		"\n" +
+		CCsWithValues.map(
+			({ name, className, file }) =>
+				`\t${name}: typeof import("${path
+					.relative(libDir, ccDir)
+					.replace(/\\/g, "/")}/${file}").${className};`,
+		).join("\n") +
+		"\n" +
+		valuesFileContent.slice(endTokenStart);
+
+	valuesFileContent = formatWithPrettier(valuesFile, valuesFileContent);
+	// Only update file if necessary - this reduces build time
+	if (valuesFileContent !== originalValuesFileContent) {
+		console.log("API interface changed");
+		await fs.writeFile(valuesFile, valuesFileContent, "utf8");
+	}
+}
+
+if (require.main === module) void generateCCValuesInterface();
diff --git a/packages/cc/src/cc/AlarmSensorCC.ts b/packages/cc/src/cc/AlarmSensorCC.ts
index e943e36560b..cca1813e925 100644
--- a/packages/cc/src/cc/AlarmSensorCC.ts
+++ b/packages/cc/src/cc/AlarmSensorCC.ts
@@ -6,7 +6,6 @@ import {
 	MessageRecord,
 	parseBitMask,
 	validatePayload,
-	ValueID,
 	ValueMetadata,
 	ZWaveError,
 	ZWaveErrorCodes,
@@ -16,7 +15,6 @@ import { getEnumMemberName, pick } from "@zwave-js/shared/safe";
 import { validateArgs } from "@zwave-js/transformers";
 import { CCAPI, PhysicalCCAPI } from "../lib/API";
 import {
-	ccValue,
 	CommandClass,
 	gotDeserializationOptions,
 	type CCCommandOptions,
@@ -25,55 +23,84 @@ import {
 import {
 	API,
 	CCCommand,
+	ccValue,
+	ccValues,
 	commandClass,
 	expectedCCResponse,
 	implementedVersion,
 } from "../lib/CommandClassDecorators";
+import { V } from "../lib/Values";
 import { AlarmSensorCommand, AlarmSensorType } from "../lib/_Types";
 
-export function getAlarmSensorStateValueId(
-	endpointIndex: number | undefined,
-	sensorType: AlarmSensorType,
-): ValueID {
-	return {
-		commandClass: CommandClasses["Alarm Sensor"],
-		endpoint: endpointIndex,
-		property: "state",
-		propertyKey: sensorType,
-	};
-}
-
-export function getAlarmSensorSeverityValueId(
-	endpointIndex: number | undefined,
-	sensorType: AlarmSensorType,
-): ValueID {
-	return {
-		commandClass: CommandClasses["Alarm Sensor"],
-		endpoint: endpointIndex,
-		property: "severity",
-		propertyKey: sensorType,
-	};
-}
-
-export function getAlarmSensorDurationValueId(
-	endpointIndex: number | undefined,
-	sensorType: AlarmSensorType,
-): ValueID {
-	return {
-		commandClass: CommandClasses["Alarm Sensor"],
-		endpoint: endpointIndex,
-		property: "duration",
-		propertyKey: sensorType,
-	};
-}
-
-export function getSupportedSensorTypesValueId(endpointIndex: number): ValueID {
-	return {
-		commandClass: CommandClasses["Alarm Sensor"],
-		endpoint: endpointIndex,
-		property: "supportedSensorTypes",
-	};
-}
+export const AlarmSensorCCValues = Object.freeze({
+	...V.defineDynamicCCValues(CommandClasses["Alarm Sensor"], {
+		...V.dynamicPropertyAndKeyWithName(
+			"state",
+			"state",
+			(sensorType: AlarmSensorType) => sensorType,
+			({ property, propertyKey }) =>
+				property === "state" && typeof propertyKey === "number",
+			(sensorType: AlarmSensorType) => {
+				const alarmName = getEnumMemberName(
+					AlarmSensorType,
+					sensorType,
+				);
+				return {
+					...ValueMetadata.ReadOnlyBoolean,
+					label: `${alarmName} state`,
+					description: "Whether the alarm is active",
+					ccSpecific: { sensorType },
+				} as const;
+			},
+		),
+		...V.dynamicPropertyAndKeyWithName(
+			"severity",
+			"severity",
+			(sensorType: AlarmSensorType) => sensorType,
+			({ property, propertyKey }) =>
+				property === "severity" && typeof propertyKey === "number",
+			(sensorType: AlarmSensorType) => {
+				const alarmName = getEnumMemberName(
+					AlarmSensorType,
+					sensorType,
+				);
+				return {
+					...ValueMetadata.ReadOnlyNumber,
+					min: 1,
+					max: 100,
+					unit: "%",
+					label: `${alarmName} severity`,
+					ccSpecific: { sensorType },
+				} as const;
+			},
+		),
+		...V.dynamicPropertyAndKeyWithName(
+			"duration",
+			"duration",
+			(sensorType: AlarmSensorType) => sensorType,
+			({ property, propertyKey }) =>
+				property === "duration" && typeof propertyKey === "number",
+			(sensorType: AlarmSensorType) => {
+				const alarmName = getEnumMemberName(
+					AlarmSensorType,
+					sensorType,
+				);
+				return {
+					...ValueMetadata.ReadOnlyNumber,
+					unit: "s",
+					label: `${alarmName} duration`,
+					description: "For how long the alarm should be active",
+					ccSpecific: { sensorType },
+				} as const;
+			},
+		),
+	}),
+	...V.defineStaticCCValues(CommandClasses["Alarm Sensor"], {
+		...V.staticProperty("supportedSensorTypes", undefined, {
+			internal: true,
+		}),
+	}),
+});
 
 // @noSetValueAPI This CC is read-only
 
@@ -133,6 +160,7 @@ export class AlarmSensorCCAPI extends PhysicalCCAPI {
 
 @commandClass(CommandClasses["Alarm Sensor"])
 @implementedVersion(1)
+@ccValues(AlarmSensorCCValues)
 export class AlarmSensorCC extends CommandClass {
 	declare ccCommand: AlarmSensorCommand;
 
@@ -209,12 +237,10 @@ export class AlarmSensorCC extends CommandClass {
 		).withOptions({
 			priority: MessagePriority.NodeQuery,
 		});
-		const valueDB = this.getValueDB(applHost);
 
 		const supportedSensorTypes: readonly AlarmSensorType[] =
-			valueDB.getValue(
-				getSupportedSensorTypesValueId(this.endpointIndex),
-			) ?? [];
+			this.getValue(applHost, AlarmSensorCCValues.supportedSensorTypes) ??
+			[];
 
 		// Always query (all of) the sensor's current value(s)
 		for (const type of supportedSensorTypes) {
@@ -250,49 +276,14 @@ duration: ${currentValue.duration}`;
 		applHost: ZWaveApplicationHost,
 		sensorType: AlarmSensorType,
 	): void {
-		const stateValueId = getAlarmSensorStateValueId(
-			this.endpointIndex,
-			sensorType,
-		);
-		const severityValueId = getAlarmSensorSeverityValueId(
-			this.endpointIndex,
-			sensorType,
-		);
-		const durationValueId = getAlarmSensorDurationValueId(
-			this.endpointIndex,
-			sensorType,
-		);
-		const valueDB = this.getValueDB(applHost);
-		const alarmName = getEnumMemberName(AlarmSensorType, sensorType);
+		const stateValue = AlarmSensorCCValues.state(sensorType);
+		const severityValue = AlarmSensorCCValues.severity(sensorType);
+		const durationValue = AlarmSensorCCValues.duration(sensorType);
 
 		// Always create metadata if it does not exist
-		if (!valueDB.hasMetadata(stateValueId)) {
-			valueDB.setMetadata(stateValueId, {
-				...ValueMetadata.ReadOnlyBoolean,
-				label: `${alarmName} state`,
-				description: "Whether the alarm is active",
-				ccSpecific: { sensorType },
-			});
-		}
-		if (!valueDB.hasMetadata(severityValueId)) {
-			valueDB.setMetadata(severityValueId, {
-				...ValueMetadata.ReadOnlyNumber,
-				min: 1,
-				max: 100,
-				unit: "%",
-				label: `${alarmName} severity`,
-				ccSpecific: { sensorType },
-			});
-		}
-		if (!valueDB.hasMetadata(durationValueId)) {
-			valueDB.setMetadata(durationValueId, {
-				...ValueMetadata.ReadOnlyNumber,
-				unit: "s",
-				label: `${alarmName} duration`,
-				description: "For how long the alarm should be active",
-				ccSpecific: { sensorType },
-			});
-		}
+		this.ensureMetadata(applHost, stateValue);
+		this.ensureMetadata(applHost, severityValue);
+		this.ensureMetadata(applHost, durationValue);
 	}
 }
 
@@ -348,22 +339,13 @@ export class AlarmSensorCCReport extends AlarmSensorCC {
 		// Create metadata if it does not exist
 		this.createMetadataForSensorType(applHost, this.sensorType);
 
-		const stateValueId = getAlarmSensorStateValueId(
-			this.endpointIndex,
-			this.sensorType,
-		);
-		const severityValueId = getAlarmSensorSeverityValueId(
-			this.endpointIndex,
-			this.sensorType,
-		);
-		const durationValueId = getAlarmSensorDurationValueId(
-			this.endpointIndex,
-			this.sensorType,
-		);
-		const valueDB = this.getValueDB(applHost);
-		valueDB.setValue(stateValueId, this.state);
-		valueDB.setValue(severityValueId, this.severity);
-		valueDB.setValue(durationValueId, this.duration);
+		const stateValue = AlarmSensorCCValues.state(this.sensorType);
+		const severityValue = AlarmSensorCCValues.severity(this.sensorType);
+		const durationValue = AlarmSensorCCValues.duration(this.sensorType);
+
+		this.setValue(applHost, stateValue, this.state);
+		this.setValue(applHost, severityValue, this.severity);
+		this.setValue(applHost, durationValue, this.duration);
 
 		return true;
 	}
@@ -440,7 +422,7 @@ export class AlarmSensorCCSupportedReport extends AlarmSensorCC {
 	}
 
 	private _supportedSensorTypes: AlarmSensorType[];
-	@ccValue({ internal: true })
+	@ccValue(AlarmSensorCCValues.supportedSensorTypes)
 	public get supportedSensorTypes(): readonly AlarmSensorType[] {
 		return this._supportedSensorTypes;
 	}
diff --git a/packages/cc/src/cc/AssociationCC.ts b/packages/cc/src/cc/AssociationCC.ts
index dac6878e699..8e58fbb7313 100644
--- a/packages/cc/src/cc/AssociationCC.ts
+++ b/packages/cc/src/cc/AssociationCC.ts
@@ -4,7 +4,6 @@ import type {
 	IZWaveNode,
 	Maybe,
 	MessageRecord,
-	ValueID,
 } from "@zwave-js/core/safe";
 import {
 	CommandClasses,
@@ -20,66 +19,55 @@ import { validateArgs } from "@zwave-js/transformers";
 import { distinct } from "alcalzone-shared/arrays";
 import { CCAPI, PhysicalCCAPI } from "../lib/API";
 import {
-	ccValue,
 	CommandClass,
 	gotDeserializationOptions,
 	type CCCommandOptions,
 	type CommandClassDeserializationOptions,
-	type CommandClassOptions,
 } from "../lib/CommandClass";
 import {
 	API,
 	CCCommand,
+	ccValue,
+	ccValues,
 	commandClass,
 	expectedCCResponse,
 	implementedVersion,
 } from "../lib/CommandClassDecorators";
 import * as ccUtils from "../lib/utils";
+import { V } from "../lib/Values";
 import { AssociationCommand, type AssociationAddress } from "../lib/_Types";
 
-/** Returns the ValueID used to store the maximum number of nodes of an association group */
-export function getMaxNodesValueId(
-	endpointIndex: number,
-	groupId: number,
-): ValueID {
-	return {
-		commandClass: CommandClasses.Association,
-		endpoint: endpointIndex,
-		property: "maxNodes",
-		propertyKey: groupId,
-	};
-}
-
-/** Returns the ValueID used to store the node IDs of an association group */
-export function getNodeIdsValueId(
-	endpointIndex: number,
-	groupId: number,
-): ValueID {
-	return {
-		commandClass: CommandClasses.Association,
-		endpoint: endpointIndex,
-		property: "nodeIds",
-		propertyKey: groupId,
-	};
-}
-
-/** Returns the ValueID used to store the group count of an association group */
-export function getGroupCountValueId(endpointIndex?: number): ValueID {
-	return {
-		commandClass: CommandClasses.Association,
-		endpoint: endpointIndex,
-		property: "groupCount",
-	};
-}
-
-/** Returns the ValueID used to store whether a node has a lifeline association */
-export function getHasLifelineValueId(endpointIndex?: number): ValueID {
-	return {
-		commandClass: CommandClasses.Association,
-		endpoint: endpointIndex,
-		property: "hasLifeline",
-	};
-}
+export const AssociationCCValues = Object.freeze({
+	...V.defineStaticCCValues(CommandClasses.Association, {
+		/** Whether the node has a lifeline association */
+		...V.staticProperty("hasLifeline", undefined, { internal: true }),
+		/** How many association groups the node has */
+		...V.staticProperty("groupCount", undefined, { internal: true }),
+	}),
+
+	...V.defineDynamicCCValues(CommandClasses.Association, {
+		/** The maximum number of nodes in an association group */
+		...V.dynamicPropertyAndKeyWithName(
+			"maxNodes",
+			"maxNodes",
+			(groupId: number) => groupId,
+			({ property, propertyKey }) =>
+				property === "maxNodes" && typeof propertyKey === "number",
+			undefined,
+			{ internal: true },
+		),
+		/** The node IDs currently belonging to an association group */
+		...V.dynamicPropertyAndKeyWithName(
+			"nodeIds",
+			"nodeIds",
+			(groupId: number) => groupId,
+			({ property, propertyKey }) =>
+				property === "nodeIds" && typeof propertyKey === "number",
+			undefined,
+			{ internal: true },
+		),
+	}),
+});
 
 export function getLifelineGroupIds(
 	applHost: ZWaveApplicationHost,
@@ -245,7 +233,9 @@ export class AssociationCCAPI extends PhysicalCCAPI {
 			// We have to remove the node manually from all groups
 			const groupCount =
 				this.tryGetValueDB()?.getValue<number>(
-					getGroupCountValueId(this.endpoint.index),
+					AssociationCCValues.groupCount.endpoint(
+						this.endpoint.index,
+					),
 				) ?? 0;
 			for (let groupId = 1; groupId <= groupCount; groupId++) {
 				await this.removeNodeIds({ nodeIds, groupId });
@@ -256,16 +246,10 @@ export class AssociationCCAPI extends PhysicalCCAPI {
 
 @commandClass(CommandClasses.Association)
 @implementedVersion(3)
+@ccValues(AssociationCCValues)
 export class AssociationCC extends CommandClass {
 	declare ccCommand: AssociationCommand;
 
-	public constructor(host: ZWaveHost, options: CommandClassOptions) {
-		super(host, options);
-		this.registerValue(getHasLifelineValueId(0).property, {
-			internal: true,
-		});
-	}
-
 	public determineRequiredCCInterviews(): readonly CommandClasses[] {
 		// AssociationCC must be interviewed after Z-Wave+ if that is supported
 		return [
@@ -287,7 +271,9 @@ export class AssociationCC extends CommandClass {
 		return (
 			applHost
 				.getValueDB(endpoint.nodeId)
-				.getValue(getGroupCountValueId(endpoint.index)) || 0
+				.getValue(
+					AssociationCCValues.groupCount.endpoint(endpoint.index),
+				) || 0
 		);
 	}
 
@@ -303,7 +289,11 @@ export class AssociationCC extends CommandClass {
 		return (
 			applHost
 				.getValueDB(endpoint.nodeId)
-				.getValue(getMaxNodesValueId(endpoint.index, groupId)) ??
+				.getValue(
+					AssociationCCValues.maxNodes(groupId).endpoint(
+						endpoint.index,
+					),
+				) ??
 			// If the information is not available, fall back to the configuration file if possible
 			// This can happen on some legacy devices which have "hidden" association groups
 			applHost
@@ -329,7 +319,7 @@ export class AssociationCC extends CommandClass {
 			// Add all root destinations
 			const nodes =
 				valueDB.getValue<number[]>(
-					getNodeIdsValueId(endpoint.index, i),
+					AssociationCCValues.nodeIds(i).endpoint(endpoint.index),
 				) ?? [];
 
 			ret.set(
@@ -596,13 +586,19 @@ export class AssociationCCReport extends AssociationCC {
 	}
 
 	private _maxNodes: number;
-	@ccValue({ internal: true })
+	@ccValue(
+		AssociationCCValues.maxNodes,
+		(self: AssociationCCReport) => [self.groupId] as const,
+	)
 	public get maxNodes(): number {
 		return this._maxNodes;
 	}
 
 	private _nodeIds: number[];
-	@ccValue({ internal: true })
+	@ccValue(
+		AssociationCCValues.nodeIds,
+		(self: AssociationCCReport) => [self.groupId] as const,
+	)
 	public get nodeIds(): readonly number[] {
 		return this._nodeIds;
 	}
@@ -701,7 +697,7 @@ export class AssociationCCSupportedGroupingsReport extends AssociationCC {
 	}
 
 	private _groupCount: number;
-	@ccValue({ internal: true })
+	@ccValue(AssociationCCValues.groupCount)
 	public get groupCount(): number {
 		return this._groupCount;
 	}
diff --git a/packages/cc/src/cc/AssociationGroupInfoCC.ts b/packages/cc/src/cc/AssociationGroupInfoCC.ts
index 9ec0138ba6f..2cc23e47157 100644
--- a/packages/cc/src/cc/AssociationGroupInfoCC.ts
+++ b/packages/cc/src/cc/AssociationGroupInfoCC.ts
@@ -8,7 +8,6 @@ import {
 	MessageRecord,
 	parseCCId,
 	validatePayload,
-	ValueID,
 	ZWaveError,
 	ZWaveErrorCodes,
 } from "@zwave-js/core/safe";
@@ -17,21 +16,21 @@ import { cpp2js, getEnumMemberName, num2hex } from "@zwave-js/shared/safe";
 import { validateArgs } from "@zwave-js/transformers";
 import { CCAPI, PhysicalCCAPI } from "../lib/API";
 import {
-	ccKeyValuePair,
-	ccValue,
 	CommandClass,
 	gotDeserializationOptions,
 	type CCCommandOptions,
 	type CommandClassDeserializationOptions,
-	type CommandClassOptions,
 } from "../lib/CommandClass";
 import {
 	API,
 	CCCommand,
+	ccValue,
+	ccValues,
 	commandClass,
 	expectedCCResponse,
 	implementedVersion,
 } from "../lib/CommandClassDecorators";
+import { V } from "../lib/Values";
 import {
 	AssociationGroupInfoCommand,
 	AssociationGroupInfoProfile,
@@ -39,48 +38,49 @@ import {
 import { AssociationCC } from "./AssociationCC";
 import { MultiChannelAssociationCC } from "./MultiChannelAssociationCC";
 
-// @noSetValueAPI This CC only has get-type commands
-
-/** Returns the ValueID used to store the name of an association group */
-function getGroupNameValueID(endpointIndex: number, groupId: number): ValueID {
-	return {
-		commandClass: CommandClasses["Association Group Information"],
-		endpoint: endpointIndex,
-		property: "name",
-		propertyKey: groupId,
-	};
-}
-
-/** Returns the ValueID used to store info for an association group */
-function getGroupInfoValueID(endpointIndex: number, groupId: number): ValueID {
-	return {
-		commandClass: CommandClasses["Association Group Information"],
-		endpoint: endpointIndex,
-		property: "info",
-		propertyKey: groupId,
-	};
-}
+export const AssociationGroupInfoCCValues = Object.freeze({
+	// Defines values that do not depend on anything else
+	...V.defineStaticCCValues(CommandClasses["Association Group Information"], {
+		...V.staticProperty("hasDynamicInfo", undefined, { internal: true }),
+	}),
+
+	// Defines values that depend on one or more arguments and need to be called as a function
+	...V.defineDynamicCCValues(
+		CommandClasses["Association Group Information"],
+		{
+			...V.dynamicPropertyAndKeyWithName(
+				"groupName",
+				"name",
+				(groupId: number) => groupId,
+				({ property, propertyKey }) =>
+					property === "name" && typeof propertyKey === "number",
+				undefined,
+				{ internal: true },
+			),
+			...V.dynamicPropertyAndKeyWithName(
+				"groupInfo",
+				"info",
+				(groupId: number) => groupId,
+				({ property, propertyKey }) =>
+					property === "info" && typeof propertyKey === "number",
+				undefined,
+				{ internal: true },
+			),
+			...V.dynamicPropertyAndKeyWithName(
+				"commands",
+				"issuedCommands",
+				(groupId: number) => groupId,
+				({ property, propertyKey }) =>
+					property === "issuedCommands" &&
+					typeof propertyKey === "number",
+				undefined,
+				{ internal: true },
+			),
+		},
+	),
+});
 
-/** Returns the ValueID used to store info for an association group */
-function getIssuedCommandsValueID(
-	endpointIndex: number,
-	groupId: number,
-): ValueID {
-	return {
-		commandClass: CommandClasses["Association Group Information"],
-		endpoint: endpointIndex,
-		property: "issuedCommands",
-		propertyKey: groupId,
-	};
-}
-
-function getHasDynamicInfoValueID(endpointIndex: number): ValueID {
-	return {
-		commandClass: CommandClasses["Association Group Information"],
-		endpoint: endpointIndex,
-		property: "hasDynamicInfo",
-	};
-}
+// @noSetValueAPI This CC only has get-type commands
 
 @API(CommandClasses["Association Group Information"])
 export class AssociationGroupInfoCCAPI extends PhysicalCCAPI {
@@ -174,19 +174,10 @@ export class AssociationGroupInfoCCAPI extends PhysicalCCAPI {
 
 @commandClass(CommandClasses["Association Group Information"])
 @implementedVersion(3)
+@ccValues(AssociationGroupInfoCCValues)
 export class AssociationGroupInfoCC extends CommandClass {
 	declare ccCommand: AssociationGroupInfoCommand;
 
-	public constructor(host: ZWaveHost, options: CommandClassOptions) {
-		super(host, options);
-		this.registerValue(getGroupNameValueID(0, 0).property, {
-			internal: true,
-		});
-		this.registerValue(getGroupInfoValueID(0, 0).property, {
-			internal: true,
-		});
-	}
-
 	public determineRequiredCCInterviews(): readonly CommandClasses[] {
 		// AssociationCC must be interviewed after Z-Wave+ if that is supported
 		return [
@@ -204,7 +195,11 @@ export class AssociationGroupInfoCC extends CommandClass {
 	): string | undefined {
 		return applHost
 			.getValueDB(endpoint.nodeId)
-			.getValue(getGroupNameValueID(endpoint.index, groupId));
+			.getValue(
+				AssociationGroupInfoCCValues.groupName(groupId).endpoint(
+					endpoint.index,
+				),
+			);
 	}
 
 	/** Returns the association profile for an association group */
@@ -215,7 +210,8 @@ export class AssociationGroupInfoCC extends CommandClass {
 	): AssociationGroupInfoProfile | undefined {
 		return applHost.getValueDB(endpoint.nodeId).getValue<{
 			profile: AssociationGroupInfoProfile;
-		}>(getGroupInfoValueID(endpoint.index, groupId))?.profile;
+		}>(AssociationGroupInfoCCValues.groupInfo(groupId).endpoint(endpoint.index))
+			?.profile;
 	}
 
 	/** Returns the dictionary of all commands issued by the given association group */
@@ -226,7 +222,11 @@ export class AssociationGroupInfoCC extends CommandClass {
 	): ReadonlyMap<CommandClasses, readonly number[]> | undefined {
 		return applHost
 			.getValueDB(endpoint.nodeId)
-			.getValue(getIssuedCommandsValueID(endpoint.index, groupId));
+			.getValue(
+				AssociationGroupInfoCCValues.commands(groupId).endpoint(
+					endpoint.index,
+				),
+			);
 	}
 
 	public static findGroupsForIssuedCommand(
@@ -344,7 +344,6 @@ export class AssociationGroupInfoCC extends CommandClass {
 			applHost,
 			endpoint,
 		).withOptions({ priority: MessagePriority.NodeQuery });
-		const valueDB = this.getValueDB(applHost);
 
 		// Query the information for each group (this is the only thing that could be dynamic)
 		const associationGroupCount =
@@ -352,8 +351,9 @@ export class AssociationGroupInfoCC extends CommandClass {
 				applHost,
 				endpoint,
 			);
-		const hasDynamicInfo = valueDB.getValue(
-			getHasDynamicInfoValueID(this.endpointIndex),
+		const hasDynamicInfo = this.getValue<boolean>(
+			applHost,
+			AssociationGroupInfoCCValues.hasDynamicInfo,
 		);
 
 		for (let groupId = 1; groupId <= associationGroupCount; groupId++) {
@@ -402,8 +402,12 @@ export class AssociationGroupInfoCCNameReport extends AssociationGroupInfoCC {
 		if (!super.persistValues(applHost)) return false;
 		const valueDB = this.getValueDB(applHost);
 
-		const valueId = getGroupNameValueID(this.endpointIndex, this.groupId);
-		valueDB.setValue(valueId, this.name);
+		valueDB.setValue(
+			AssociationGroupInfoCCValues.groupName(this.groupId).endpoint(
+				this.endpointIndex,
+			),
+			this.name,
+		);
 
 		return true;
 	}
@@ -499,23 +503,25 @@ export class AssociationGroupInfoCCInfoReport extends AssociationGroupInfoCC {
 
 	public persistValues(applHost: ZWaveApplicationHost): boolean {
 		if (!super.persistValues(applHost)) return false;
-		const valueDB = this.getValueDB(applHost);
 
 		for (const group of this.groups) {
 			const { groupId, mode, profile, eventCode } = group;
-			const valueId = getGroupInfoValueID(this.endpointIndex, groupId);
-			valueDB.setValue(valueId, {
-				mode,
-				profile,
-				eventCode,
-			});
+			this.setValue(
+				applHost,
+				AssociationGroupInfoCCValues.groupInfo(groupId),
+				{
+					mode,
+					profile,
+					eventCode,
+				},
+			);
 		}
 		return true;
 	}
 
 	public readonly isListMode: boolean;
 
-	@ccValue({ internal: true })
+	@ccValue(AssociationGroupInfoCCValues.hasDynamicInfo)
 	public readonly hasDynamicInfo: boolean;
 
 	public readonly groups: readonly AssociationGroupInfo[];
@@ -614,7 +620,7 @@ export class AssociationGroupInfoCCCommandListReport extends AssociationGroupInf
 	) {
 		super(host, options);
 		validatePayload(this.payload.length >= 2);
-		const groupId = this.payload[0];
+		this.groupId = this.payload[0];
 		const listLength = this.payload[1];
 		validatePayload(this.payload.length >= 2 + listLength);
 		const listBytes = this.payload.slice(2, 2 + listLength);
@@ -629,19 +635,17 @@ export class AssociationGroupInfoCCCommandListReport extends AssociationGroupInf
 			offset += bytesRead + 1;
 		}
 
-		this.issuedCommands = [groupId, commands];
+		this.commands = commands;
 	}
 
-	@ccKeyValuePair({ internal: true })
-	private issuedCommands: [number, this["commands"]];
-
-	public get groupId(): number {
-		return this.issuedCommands[0];
-	}
+	public readonly groupId: number;
 
-	public get commands(): ReadonlyMap<CommandClasses, readonly number[]> {
-		return this.issuedCommands[1];
-	}
+	@ccValue(
+		AssociationGroupInfoCCValues.commands,
+		(self: AssociationGroupInfoCCCommandListReport) =>
+			[self.groupId] as const,
+	)
+	public readonly commands: ReadonlyMap<CommandClasses, readonly number[]>;
 
 	public toLogEntry(applHost: ZWaveApplicationHost): MessageOrCCLogEntry {
 		return {
diff --git a/packages/cc/src/cc/BarrierOperatorCC.ts b/packages/cc/src/cc/BarrierOperatorCC.ts
index 6ed81dfd59d..22907594691 100644
--- a/packages/cc/src/cc/BarrierOperatorCC.ts
+++ b/packages/cc/src/cc/BarrierOperatorCC.ts
@@ -1,4 +1,4 @@
-import type { Maybe, MessageOrCCLogEntry, ValueID } from "@zwave-js/core/safe";
+import type { Maybe, MessageOrCCLogEntry } from "@zwave-js/core/safe";
 import {
 	CommandClasses,
 	enumValuesToMetadataStates,
@@ -24,8 +24,6 @@ import {
 	throwWrongValueType,
 } from "../lib/API";
 import {
-	ccValue,
-	ccValueMetadata,
 	CommandClass,
 	gotDeserializationOptions,
 	type CCCommandOptions,
@@ -34,10 +32,13 @@ import {
 import {
 	API,
 	CCCommand,
+	ccValue,
+	ccValues,
 	commandClass,
 	expectedCCResponse,
 	implementedVersion,
 } from "../lib/CommandClassDecorators";
+import { V } from "../lib/Values";
 import {
 	BarrierOperatorCommand,
 	BarrierState,
@@ -45,46 +46,55 @@ import {
 	SubsystemType,
 } from "../lib/_Types";
 
-function getSignalingStateValueId(
-	endpoint: number | undefined,
-	subsystemType: SubsystemType,
-): ValueID {
-	return {
-		commandClass: CommandClasses["Barrier Operator"],
-		endpoint,
-		property: "signalingState",
-		propertyKey: subsystemType,
-	};
-}
-
-function getSignalingStateMetadata(
-	subsystemType: SubsystemType,
-): ValueMetadata {
-	return {
-		...ValueMetadata.UInt8,
-		label: `Signaling State (${getEnumMemberName(
-			SubsystemType,
-			subsystemType,
-		)})`,
-		states: enumValuesToMetadataStates(SubsystemState),
-	};
-}
-
-function getSupportedSubsystemTypesValueId(endpoint?: number): ValueID {
-	return {
-		commandClass: CommandClasses["Barrier Operator"],
-		endpoint,
-		property: "supportedSubsystemTypes",
-	};
-}
-
-function getTargetStateValueId(endpoint: number | undefined): ValueID {
-	return {
-		commandClass: CommandClasses["Barrier Operator"],
-		endpoint,
-		property: "targetState",
-	};
-}
+export const BarrierOperatorCCValues = Object.freeze({
+	...V.defineStaticCCValues(CommandClasses["Barrier Operator"], {
+		...V.staticProperty("supportedSubsystemTypes", undefined, {
+			internal: true,
+		}),
+
+		...V.staticProperty("position", {
+			...ValueMetadata.ReadOnlyUInt8,
+			label: "Barrier Position",
+			unit: "%",
+			max: 100,
+		} as const),
+
+		...V.staticProperty("targetState", {
+			...ValueMetadata.UInt8,
+			label: "Target Barrier State",
+			states: enumValuesToMetadataStates(BarrierState, [
+				BarrierState.Open,
+				BarrierState.Closed,
+			]),
+		} as const),
+
+		...V.staticProperty("currentState", {
+			...ValueMetadata.ReadOnlyUInt8,
+			label: "Current Barrier State",
+			states: enumValuesToMetadataStates(BarrierState),
+		} as const),
+	}),
+
+	...V.defineDynamicCCValues(CommandClasses["Barrier Operator"], {
+		...V.dynamicPropertyAndKeyWithName(
+			"signalingState",
+			"signalingState",
+			(subsystemType: SubsystemType) => subsystemType,
+			({ property, propertyKey }) =>
+				property === "signalingState" &&
+				typeof propertyKey === "number",
+			(subsystemType: SubsystemType) =>
+				({
+					...ValueMetadata.UInt8,
+					label: `Signaling State (${getEnumMemberName(
+						SubsystemType,
+						subsystemType,
+					)})`,
+					states: enumValuesToMetadataStates(SubsystemState),
+				} as const),
+		),
+	}),
+});
 
 @API(CommandClasses["Barrier Operator"])
 export class BarrierOperatorCCAPI extends CCAPI {
@@ -275,6 +285,7 @@ export class BarrierOperatorCCAPI extends CCAPI {
 
 @commandClass(CommandClasses["Barrier Operator"])
 @implementedVersion(1)
+@ccValues(BarrierOperatorCCValues)
 export class BarrierOperatorCC extends CommandClass {
 	declare ccCommand: BarrierOperatorCommand;
 
@@ -288,7 +299,6 @@ export class BarrierOperatorCC extends CommandClass {
 		).withOptions({
 			priority: MessagePriority.NodeQuery,
 		});
-		const valueDB = this.getValueDB(applHost);
 
 		applHost.controllerLog.logNode(node.id, {
 			endpoint: this.endpointIndex,
@@ -297,17 +307,7 @@ export class BarrierOperatorCC extends CommandClass {
 		});
 
 		// Create targetState value if it does not exist
-		const targetStateValueID = getTargetStateValueId(this.endpointIndex);
-		if (!valueDB.hasMetadata(targetStateValueID)) {
-			valueDB.setMetadata(targetStateValueID, {
-				...ValueMetadata.UInt8,
-				label: "Target Barrier State",
-				states: enumValuesToMetadataStates(BarrierState, [
-					BarrierState.Open,
-					BarrierState.Closed,
-				]),
-			});
-		}
+		this.ensureMetadata(applHost, BarrierOperatorCCValues.targetState);
 
 		applHost.controllerLog.logNode(node.id, {
 			message: "Querying signaling capabilities...",
@@ -339,11 +339,11 @@ export class BarrierOperatorCC extends CommandClass {
 		).withOptions({
 			priority: MessagePriority.NodeQuery,
 		});
-		const valueDB = this.getValueDB(applHost);
 
-		const supportedSubsystems =
-			valueDB.getValue<SubsystemType[]>(
-				getSupportedSubsystemTypesValueId(this.endpointIndex),
+		const supportedSubsystems: SubsystemType[] =
+			this.getValue(
+				applHost,
+				BarrierOperatorCCValues.supportedSubsystemTypes,
 			) ?? [];
 
 		for (const subsystemType of supportedSubsystems) {
@@ -441,21 +441,10 @@ export class BarrierOperatorCCReport extends BarrierOperatorCC {
 		}
 	}
 
-	@ccValue()
-	@ccValueMetadata({
-		...ValueMetadata.ReadOnlyUInt8,
-		label: "Current Barrier State",
-		states: enumValuesToMetadataStates(BarrierState),
-	})
+	@ccValue(BarrierOperatorCCValues.currentState)
 	public readonly currentState: BarrierState | undefined;
 
-	@ccValue()
-	@ccValueMetadata({
-		...ValueMetadata.ReadOnlyUInt8,
-		label: "Barrier Position",
-		unit: "%",
-		max: 100,
-	})
+	@ccValue(BarrierOperatorCCValues.position)
 	public readonly position: number | undefined;
 
 	public toLogEntry(applHost: ZWaveApplicationHost): MessageOrCCLogEntry {
@@ -484,17 +473,14 @@ export class BarrierOperatorCCSignalingCapabilitiesReport extends BarrierOperato
 	) {
 		super(host, options);
 
-		this._supportedsubsystemTypes = parseBitMask(
+		this.supportedSubsystemTypes = parseBitMask(
 			this.payload,
 			SubsystemType.Audible,
 		);
 	}
 
-	private _supportedsubsystemTypes: SubsystemType[];
-	@ccValue({ internal: true })
-	public get supportedSubsystemTypes(): readonly SubsystemType[] {
-		return this._supportedsubsystemTypes;
-	}
+	@ccValue(BarrierOperatorCCValues.supportedSubsystemTypes)
+	public readonly supportedSubsystemTypes: readonly SubsystemType[];
 
 	public toLogEntry(applHost: ZWaveApplicationHost): MessageOrCCLogEntry {
 		return {
@@ -578,21 +564,12 @@ export class BarrierOperatorCCEventSignalingReport extends BarrierOperatorCC {
 	public persistValues(applHost: ZWaveApplicationHost): boolean {
 		if (!super.persistValues(applHost)) return false;
 
-		const valueId = getSignalingStateValueId(
-			this.endpointIndex,
+		const signalingStateValue = BarrierOperatorCCValues.signalingState(
 			this.subsystemType,
 		);
-		const valueDB = this.getValueDB(applHost);
-
-		// Create metadata if it does not exist
-		if (!valueDB.hasMetadata(valueId)) {
-			valueDB.setMetadata(
-				valueId,
-				getSignalingStateMetadata(this.subsystemType),
-			);
-		}
 
-		valueDB.setValue(valueId, this.subsystemState);
+		this.ensureMetadata(applHost, signalingStateValue);
+		this.setValue(applHost, signalingStateValue, this.subsystemState);
 
 		return true;
 	}
diff --git a/packages/cc/src/cc/BasicCC.ts b/packages/cc/src/cc/BasicCC.ts
index 5ee2b090541..b89a1a43f49 100644
--- a/packages/cc/src/cc/BasicCC.ts
+++ b/packages/cc/src/cc/BasicCC.ts
@@ -9,7 +9,6 @@ import {
 	parseNumber,
 	unknownNumber,
 	validatePayload,
-	ValueID,
 	ValueMetadata,
 } from "@zwave-js/core/safe";
 import type { ZWaveApplicationHost, ZWaveHost } from "@zwave-js/host/safe";
@@ -25,8 +24,6 @@ import {
 	throwWrongValueType,
 } from "../lib/API";
 import {
-	ccValue,
-	ccValueMetadata,
 	CommandClass,
 	gotDeserializationOptions,
 	type CCCommandOptions,
@@ -35,35 +32,48 @@ import {
 import {
 	API,
 	CCCommand,
+	ccValue,
+	ccValues,
 	commandClass,
 	expectedCCResponse,
 	implementedVersion,
 } from "../lib/CommandClassDecorators";
+import { V } from "../lib/Values";
 import { BasicCommand } from "../lib/_Types";
 
-export function getTargetValueValueId(endpoint?: number): ValueID {
-	return {
-		commandClass: CommandClasses.Basic,
-		endpoint,
-		property: "targetValue",
-	};
-}
-
-export function getCurrentValueValueId(endpoint?: number): ValueID {
-	return {
-		commandClass: CommandClasses.Basic,
-		endpoint,
-		property: "currentValue",
-	};
-}
-
-export function getCompatEventValueId(endpoint?: number): ValueID {
-	return {
-		commandClass: CommandClasses.Basic,
-		endpoint,
-		property: "event",
-	};
-}
+export const BasicCCValues = Object.freeze({
+	...V.defineStaticCCValues(CommandClasses.Basic, {
+		...V.staticProperty("currentValue", {
+			...ValueMetadata.ReadOnlyLevel,
+			label: "Current value" as const,
+		}),
+		...V.staticProperty("targetValue", {
+			...ValueMetadata.UInt8,
+			label: "Target value" as const,
+			forceCreation: true,
+		}),
+		...V.staticProperty("duration", {
+			...ValueMetadata.ReadOnlyDuration,
+			label: "Remaining duration" as const,
+			minVersion: 2,
+		}),
+		// TODO: This should really not be a static CC value, but depend on compat flags:
+		...V.staticPropertyWithName(
+			"compatEvent",
+			"event",
+			{
+				...ValueMetadata.ReadOnlyUInt8,
+				label: "Event value",
+			} as const,
+			{
+				stateful: false,
+				autoCreate: (applHost, endpoint) =>
+					!!applHost.getDeviceConfig?.(endpoint.nodeId)?.compat
+						?.treatBasicSetAsEvent,
+			},
+		),
+	}),
+});
 
 @API(CommandClasses.Basic)
 export class BasicCCAPI extends CCAPI {
@@ -99,7 +109,7 @@ export class BasicCCAPI extends CCAPI {
 				value <= 99
 			) {
 				this.getValueDB().setValue(
-					getCurrentValueValueId(this.endpoint.index),
+					BasicCCValues.currentValue.endpoint(this.endpoint.index),
 					value,
 				);
 			}
@@ -127,7 +137,9 @@ export class BasicCCAPI extends CCAPI {
 					this.applHost
 						.tryGetValueDB(node.id)
 						?.setValue(
-							getCurrentValueValueId(this.endpoint.index),
+							BasicCCValues.currentValue.endpoint(
+								this.endpoint.index,
+							),
 							value,
 						);
 				}
@@ -169,7 +181,7 @@ export class BasicCCAPI extends CCAPI {
 		);
 		if (response) {
 			this.tryGetValueDB()?.setValue(
-				getCurrentValueValueId(this.endpoint.index),
+				BasicCCValues.currentValue.endpoint(this.endpoint.index),
 				response.currentValue,
 			);
 			return pick(response, ["currentValue", "targetValue", "duration"]);
@@ -191,13 +203,13 @@ export class BasicCCAPI extends CCAPI {
 
 @commandClass(CommandClasses.Basic)
 @implementedVersion(2) // Update tests in CommandClass.test.ts when changing this
+@ccValues(BasicCCValues)
 export class BasicCC extends CommandClass {
 	declare ccCommand: BasicCommand;
 
 	public async interview(applHost: ZWaveApplicationHost): Promise<void> {
 		const node = this.getNode(applHost)!;
 		const endpoint = this.getEndpoint(applHost)!;
-		const valueDB = this.getValueDB(applHost);
 
 		applHost.controllerLog.logNode(node.id, {
 			endpoint: this.endpointIndex,
@@ -210,16 +222,9 @@ export class BasicCC extends CommandClass {
 
 		// create compat event value if necessary
 		if (applHost.getDeviceConfig?.(node.id)?.compat?.treatBasicSetAsEvent) {
-			const valueId = getCompatEventValueId(this.endpointIndex);
-			if (!valueDB.hasMetadata(valueId)) {
-				valueDB.setMetadata(valueId, {
-					...ValueMetadata.ReadOnlyUInt8,
-					label: "Event value",
-				});
-			}
+			this.ensureMetadata(applHost, BasicCCValues.compatEvent);
 		} else if (
-			valueDB.getValue(getCurrentValueValueId(this.endpointIndex)) ==
-			undefined
+			this.getValue(applHost, BasicCCValues.currentValue) == undefined
 		) {
 			applHost.controllerLog.logNode(node.id, {
 				endpoint: this.endpointIndex,
@@ -352,27 +357,15 @@ export class BasicCCReport extends BasicCC {
 	}
 
 	private _currentValue: Maybe<number> | undefined;
-	@ccValue()
-	@ccValueMetadata({
-		...ValueMetadata.ReadOnlyLevel,
-		label: "Current value",
-	})
+	@ccValue(BasicCCValues.currentValue)
 	public get currentValue(): Maybe<number> | undefined {
 		return this._currentValue;
 	}
 
-	@ccValue({ forceCreation: true })
-	@ccValueMetadata({
-		...ValueMetadata.Level,
-		label: "Target value",
-	})
+	@ccValue(BasicCCValues.targetValue)
 	public readonly targetValue: number | undefined;
 
-	@ccValue({ minVersion: 2 })
-	@ccValueMetadata({
-		...ValueMetadata.ReadOnlyDuration,
-		label: "Remaining duration",
-	})
+	@ccValue(BasicCCValues.duration)
 	public readonly duration: Duration | undefined;
 
 	public serialize(): Buffer {
diff --git a/packages/cc/src/cc/BatteryCC.ts b/packages/cc/src/cc/BatteryCC.ts
index 34303803840..d867b4b9f20 100644
--- a/packages/cc/src/cc/BatteryCC.ts
+++ b/packages/cc/src/cc/BatteryCC.ts
@@ -1,8 +1,4 @@
-import type {
-	MessageOrCCLogEntry,
-	MessageRecord,
-	ValueID,
-} from "@zwave-js/core/safe";
+import type { MessageOrCCLogEntry, MessageRecord } from "@zwave-js/core/safe";
 import {
 	CommandClasses,
 	enumValuesToMetadataStates,
@@ -22,24 +18,155 @@ import {
 	throwUnsupportedProperty,
 } from "../lib/API";
 import {
-	ccValue,
-	ccValueMetadata,
 	CommandClass,
 	type CommandClassDeserializationOptions,
 } from "../lib/CommandClass";
 import {
 	API,
 	CCCommand,
+	ccValue,
+	ccValues,
 	commandClass,
 	expectedCCResponse,
 	implementedVersion,
 } from "../lib/CommandClassDecorators";
+import { V } from "../lib/Values";
 import {
 	BatteryChargingStatus,
 	BatteryCommand,
 	BatteryReplacementStatus,
 } from "../lib/_Types";
 
+export const BatteryCCValues = Object.freeze({
+	...V.defineStaticCCValues(CommandClasses.Battery, {
+		...V.staticProperty("level", {
+			...ValueMetadata.ReadOnlyUInt8,
+			max: 100,
+			unit: "%",
+			label: "Battery level",
+		} as const),
+
+		...V.staticProperty("isLow", {
+			...ValueMetadata.ReadOnlyBoolean,
+			label: "Low battery level",
+		} as const),
+
+		...V.staticProperty(
+			"maximumCapacity",
+			{
+				...ValueMetadata.ReadOnlyUInt8,
+				max: 100,
+				unit: "%",
+				label: "Maximum capacity",
+			} as const,
+			{
+				minVersion: 2,
+			} as const,
+		),
+
+		...V.staticProperty(
+			"temperature",
+			{
+				...ValueMetadata.ReadOnlyInt8,
+				label: "Temperature",
+			} as const,
+			{
+				minVersion: 2,
+			} as const,
+		),
+
+		...V.staticProperty(
+			"chargingStatus",
+			{
+				...ValueMetadata.ReadOnlyUInt8,
+				label: "Charging status",
+				states: enumValuesToMetadataStates(BatteryChargingStatus),
+			} as const,
+			{
+				minVersion: 2,
+			} as const,
+		),
+
+		...V.staticProperty(
+			"rechargeable",
+			{
+				...ValueMetadata.ReadOnlyBoolean,
+				label: "Rechargeable",
+			} as const,
+			{
+				minVersion: 2,
+			} as const,
+		),
+
+		...V.staticProperty(
+			"backup",
+			{
+				...ValueMetadata.ReadOnlyBoolean,
+				label: "Used as backup",
+			} as const,
+			{
+				minVersion: 2,
+			} as const,
+		),
+
+		...V.staticProperty(
+			"overheating",
+			{
+				...ValueMetadata.ReadOnlyBoolean,
+				label: "Overheating",
+			} as const,
+			{
+				minVersion: 2,
+			} as const,
+		),
+
+		...V.staticProperty(
+			"lowFluid",
+			{
+				...ValueMetadata.ReadOnlyBoolean,
+				label: "Fluid is low",
+			} as const,
+			{
+				minVersion: 2,
+			} as const,
+		),
+
+		...V.staticProperty(
+			"rechargeOrReplace",
+			{
+				...ValueMetadata.ReadOnlyUInt8,
+				label: "Recharge or replace",
+				states: enumValuesToMetadataStates(BatteryReplacementStatus),
+			} as const,
+			{
+				minVersion: 2,
+			} as const,
+		),
+
+		...V.staticProperty(
+			"disconnected",
+			{
+				...ValueMetadata.ReadOnlyBoolean,
+				label: "Battery is disconnected",
+			} as const,
+			{
+				minVersion: 2,
+			} as const,
+		),
+
+		...V.staticProperty(
+			"lowTemperatureStatus",
+			{
+				...ValueMetadata.ReadOnlyBoolean,
+				label: "Battery temperature is low",
+			} as const,
+			{
+				minVersion: 3,
+			} as const,
+		),
+	}),
+});
+
 // @noSetValueAPI This CC is read-only
 
 @API(CommandClasses.Battery)
@@ -127,6 +254,7 @@ export class BatteryCCAPI extends PhysicalCCAPI {
 
 @commandClass(CommandClasses.Battery)
 @implementedVersion(3)
+@ccValues(BatteryCCValues)
 export class BatteryCC extends CommandClass {
 	declare ccCommand: BatteryCommand;
 
@@ -223,139 +351,65 @@ export class BatteryCCReport extends BatteryCC {
 		super(host, options);
 
 		validatePayload(this.payload.length >= 1);
-		this._level = this.payload[0];
-		if (this._level === 0xff) {
-			this._level = 0;
-			this._isLow = true;
+		this.level = this.payload[0];
+		if (this.level === 0xff) {
+			this.level = 0;
+			this.isLow = true;
 		} else {
-			this._isLow = false;
+			this.isLow = false;
 		}
 
 		if (this.payload.length >= 3) {
 			// Starting with V2
-			this._chargingStatus = this.payload[1] >>> 6;
-			this._rechargeable = !!(this.payload[1] & 0b0010_0000);
-			this._backup = !!(this.payload[1] & 0b0001_0000);
-			this._overheating = !!(this.payload[1] & 0b1000);
-			this._lowFluid = !!(this.payload[1] & 0b0100);
-			this._rechargeOrReplace = !!(this.payload[1] & 0b10)
+			this.chargingStatus = this.payload[1] >>> 6;
+			this.rechargeable = !!(this.payload[1] & 0b0010_0000);
+			this.backup = !!(this.payload[1] & 0b0001_0000);
+			this.overheating = !!(this.payload[1] & 0b1000);
+			this.lowFluid = !!(this.payload[1] & 0b0100);
+			this.rechargeOrReplace = !!(this.payload[1] & 0b10)
 				? BatteryReplacementStatus.Now
 				: !!(this.payload[1] & 0b1)
 				? BatteryReplacementStatus.Soon
 				: BatteryReplacementStatus.No;
-			this._lowTemperatureStatus = !!(this.payload[2] & 0b10);
-			this._disconnected = !!(this.payload[2] & 0b1);
+			this.lowTemperatureStatus = !!(this.payload[2] & 0b10);
+			this.disconnected = !!(this.payload[2] & 0b1);
 		}
 	}
 
-	private _level: number;
-	@ccValue()
-	@ccValueMetadata({
-		...ValueMetadata.ReadOnlyUInt8,
-		max: 100,
-		unit: "%",
-		label: "Battery level",
-	})
-	public get level(): number {
-		return this._level;
-	}
+	@ccValue(BatteryCCValues.level)
+	public readonly level: number;
 
-	private _isLow: boolean;
-	@ccValue()
-	@ccValueMetadata({
-		...ValueMetadata.ReadOnlyBoolean,
-		label: "Low battery level",
-	})
-	public get isLow(): boolean {
-		return this._isLow;
-	}
+	@ccValue(BatteryCCValues.isLow)
+	public readonly isLow: boolean;
 
-	private _chargingStatus: BatteryChargingStatus | undefined;
-	@ccValue({ minVersion: 2 })
-	@ccValueMetadata({
-		...ValueMetadata.ReadOnlyUInt8,
-		label: "Charging status",
-		states: enumValuesToMetadataStates(BatteryChargingStatus),
-	})
-	public get chargingStatus(): BatteryChargingStatus | undefined {
-		return this._chargingStatus;
-	}
+	@ccValue(BatteryCCValues.chargingStatus)
+	public readonly chargingStatus: BatteryChargingStatus | undefined;
 
-	private _rechargeable: boolean | undefined;
-	@ccValue({ minVersion: 2 })
-	@ccValueMetadata({
-		...ValueMetadata.ReadOnlyBoolean,
-		label: "Rechargeable",
-	})
-	public get rechargeable(): boolean | undefined {
-		return this._rechargeable;
-	}
+	@ccValue(BatteryCCValues.rechargeable)
+	public readonly rechargeable: boolean | undefined;
 
-	private _backup: boolean | undefined;
-	@ccValue({ minVersion: 2 })
-	@ccValueMetadata({
-		...ValueMetadata.ReadOnlyBoolean,
-		label: "Used as backup",
-	})
-	public get backup(): boolean | undefined {
-		return this._backup;
-	}
+	@ccValue(BatteryCCValues.backup)
+	public readonly backup: boolean | undefined;
 
-	private _overheating: boolean | undefined;
-	@ccValue({ minVersion: 2 })
-	@ccValueMetadata({
-		...ValueMetadata.ReadOnlyBoolean,
-		label: "Overheating",
-	})
-	public get overheating(): boolean | undefined {
-		return this._overheating;
-	}
+	@ccValue(BatteryCCValues.overheating)
+	public readonly overheating: boolean | undefined;
 
-	private _lowFluid: boolean | undefined;
-	@ccValue({ minVersion: 2 })
-	@ccValueMetadata({
-		...ValueMetadata.ReadOnlyBoolean,
-		label: "Fluid is low",
-	})
-	public get lowFluid(): boolean | undefined {
-		return this._lowFluid;
-	}
+	@ccValue(BatteryCCValues.lowFluid)
+	public readonly lowFluid: boolean | undefined;
 
-	private _rechargeOrReplace: BatteryReplacementStatus | undefined;
-	@ccValue({ minVersion: 2 })
-	@ccValueMetadata({
-		...ValueMetadata.ReadOnlyUInt8,
-		label: "Recharge or replace",
-		states: enumValuesToMetadataStates(BatteryReplacementStatus),
-	})
-	public get rechargeOrReplace(): BatteryReplacementStatus | undefined {
-		return this._rechargeOrReplace;
-	}
+	@ccValue(BatteryCCValues.rechargeOrReplace)
+	public readonly rechargeOrReplace: BatteryReplacementStatus | undefined;
 
-	private _disconnected: boolean | undefined;
-	@ccValue({ minVersion: 2 })
-	@ccValueMetadata({
-		...ValueMetadata.ReadOnlyBoolean,
-		label: "Battery is disconnected",
-	})
-	public get disconnected(): boolean | undefined {
-		return this._disconnected;
-	}
+	@ccValue(BatteryCCValues.disconnected)
+	public readonly disconnected: boolean | undefined;
 
-	private _lowTemperatureStatus: boolean | undefined;
-	@ccValue({ minVersion: 3 })
-	@ccValueMetadata({
-		...ValueMetadata.ReadOnlyBoolean,
-		label: "Battery temperature is low",
-	})
-	public get lowTemperatureStatus(): boolean | undefined {
-		return this._lowTemperatureStatus;
-	}
+	@ccValue(BatteryCCValues.lowTemperatureStatus)
+	public readonly lowTemperatureStatus: boolean | undefined;
 
 	public toLogEntry(applHost: ZWaveApplicationHost): MessageOrCCLogEntry {
 		const message: MessageRecord = {
-			level: this._level,
-			"is low": this._isLow,
+			level: this.level,
+			"is low": this.isLow,
 		};
 		if (this.chargingStatus != undefined) {
 			message["charging status"] = getEnumMemberName(
@@ -409,57 +463,35 @@ export class BatteryCCHealthReport extends BatteryCC {
 		validatePayload(this.payload.length >= 2);
 
 		// Parse maximum capacity. 0xff means unknown
-		this._maximumCapacity = this.payload[0];
-		if (this._maximumCapacity === 0xff) this._maximumCapacity = undefined;
+		this.maximumCapacity = this.payload[0];
+		if (this.maximumCapacity === 0xff) this.maximumCapacity = undefined;
 
 		const { value: temperature, scale } = parseFloatWithScale(
 			this.payload.slice(1),
 			true, // The temperature field may be omitted
 		);
-		this._temperature = temperature;
+		this.temperature = temperature;
 		this.temperatureScale = scale;
 	}
 
 	public persistValues(applHost: ZWaveApplicationHost): boolean {
 		if (!super.persistValues(applHost)) return false;
-		const valueDB = this.getValueDB(applHost);
 
 		// Update the temperature unit in the value DB
-		const valueId: ValueID = {
-			commandClass: this.ccId,
-			endpoint: this.endpointIndex,
-			property: "temperature",
-		};
-		valueDB.setMetadata(valueId, {
-			...ValueMetadata.ReadOnlyNumber,
-			label: "Temperature",
+		const temperatureValue = BatteryCCValues.temperature;
+		this.setMetadata(applHost, temperatureValue, {
+			...temperatureValue.meta,
 			unit: this.temperatureScale === 0x00 ? "°C" : undefined,
 		});
 
 		return true;
 	}
 
-	private _maximumCapacity: number | undefined;
-	@ccValue({ minVersion: 2 })
-	@ccValueMetadata({
-		...ValueMetadata.ReadOnlyUInt8,
-		max: 100,
-		unit: "%",
-		label: "Maximum capacity",
-	})
-	public get maximumCapacity(): number | undefined {
-		return this._maximumCapacity;
-	}
+	@ccValue(BatteryCCValues.maximumCapacity)
+	public readonly maximumCapacity: number | undefined;
 
-	private _temperature: number | undefined;
-	@ccValue({ minVersion: 2 })
-	@ccValueMetadata({
-		...ValueMetadata.ReadOnlyUInt8,
-		label: "Temperature",
-	})
-	public get temperature(): number | undefined {
-		return this._temperature;
-	}
+	@ccValue(BatteryCCValues.temperature)
+	public readonly temperature: number | undefined;
 
 	private readonly temperatureScale: number | undefined;
 
diff --git a/packages/cc/src/cc/BinarySensorCC.ts b/packages/cc/src/cc/BinarySensorCC.ts
index be93c7de2ef..6704983f44d 100644
--- a/packages/cc/src/cc/BinarySensorCC.ts
+++ b/packages/cc/src/cc/BinarySensorCC.ts
@@ -5,7 +5,6 @@ import {
 	MessagePriority,
 	parseBitMask,
 	validatePayload,
-	ValueID,
 	ValueMetadata,
 	ZWaveError,
 	ZWaveErrorCodes,
@@ -21,7 +20,6 @@ import {
 	throwUnsupportedProperty,
 } from "../lib/API";
 import {
-	ccValue,
 	CommandClass,
 	gotDeserializationOptions,
 	type CCCommandOptions,
@@ -30,30 +28,41 @@ import {
 import {
 	API,
 	CCCommand,
+	ccValue,
+	ccValues,
 	commandClass,
 	expectedCCResponse,
 	implementedVersion,
 } from "../lib/CommandClassDecorators";
+import { V } from "../lib/Values";
 import { BinarySensorCommand, BinarySensorType } from "../lib/_Types";
 
-export function getBinarySensorValueId(
-	endpointIndex: number | undefined,
-	sensorType: BinarySensorType,
-): ValueID {
-	return {
-		commandClass: CommandClasses["Binary Sensor"],
-		endpoint: endpointIndex,
-		property: getEnumMemberName(BinarySensorType, sensorType),
-	};
-}
-
-export function getSupportedSensorTypesValueId(endpointIndex: number): ValueID {
-	return {
-		commandClass: CommandClasses["Binary Sensor"],
-		endpoint: endpointIndex,
-		property: "supportedSensorTypes",
-	};
-}
+export const BinarySensorCCValues = Object.freeze({
+	...V.defineStaticCCValues(CommandClasses["Binary Sensor"], {
+		...V.staticProperty("supportedSensorTypes", undefined, {
+			internal: true,
+		}),
+	}),
+
+	...V.defineDynamicCCValues(CommandClasses["Binary Sensor"], {
+		...V.dynamicPropertyWithName(
+			"state",
+			/* property */ (sensorType: BinarySensorType) =>
+				getEnumMemberName(BinarySensorType, sensorType),
+			({ property }) =>
+				typeof property === "string" && property in BinarySensorType,
+			/* meta */ (sensorType: BinarySensorType) =>
+				({
+					...ValueMetadata.ReadOnlyBoolean,
+					label: `Sensor state (${getEnumMemberName(
+						BinarySensorType,
+						sensorType,
+					)})`,
+					ccSpecific: { sensorType },
+				} as const),
+		),
+	}),
+});
 
 // @noSetValueAPI This CC is read-only
 
@@ -130,6 +139,7 @@ export class BinarySensorCCAPI extends PhysicalCCAPI {
 
 @commandClass(CommandClasses["Binary Sensor"])
 @implementedVersion(2)
+@ccValues(BinarySensorCCValues)
 export class BinarySensorCC extends CommandClass {
 	declare ccCommand: BinarySensorCommand;
 
@@ -195,7 +205,6 @@ export class BinarySensorCC extends CommandClass {
 		).withOptions({
 			priority: MessagePriority.NodeQuery,
 		});
-		const valueDB = this.getValueDB(applHost);
 
 		// Query (all of) the sensor's current value(s)
 		if (this.version === 1) {
@@ -214,8 +223,9 @@ export class BinarySensorCC extends CommandClass {
 			}
 		} else {
 			const supportedSensorTypes: readonly BinarySensorType[] =
-				valueDB.getValue(
-					getSupportedSensorTypesValueId(this.endpointIndex),
+				this.getValue(
+					applHost,
+					BinarySensorCCValues.supportedSensorTypes,
 				) ?? [];
 
 			for (const type of supportedSensorTypes) {
@@ -241,8 +251,9 @@ export class BinarySensorCC extends CommandClass {
 		applHost: ZWaveApplicationHost,
 		value: number,
 	): boolean {
-		this.getValueDB(applHost).setValue(
-			getBinarySensorValueId(this.endpointIndex, BinarySensorType.Any),
+		this.setValue(
+			applHost,
+			BinarySensorCCValues.state(BinarySensorType.Any),
 			value > 0,
 		);
 		return true;
@@ -267,18 +278,11 @@ export class BinarySensorCCReport extends BinarySensorCC {
 
 	public persistValues(applHost: ZWaveApplicationHost): boolean {
 		if (!super.persistValues(applHost)) return false;
-		const valueDB = this.getValueDB(applHost);
 
-		const valueId: ValueID = getBinarySensorValueId(
-			this.endpointIndex,
-			this._type,
-		);
-		valueDB.setMetadata(valueId, {
-			...ValueMetadata.ReadOnlyBoolean,
-			label: getEnumMemberName(BinarySensorType, this._type),
-			ccSpecific: { sensorType: this._type },
-		});
-		valueDB.setValue(valueId, this._value);
+		const binarySensorValue = BinarySensorCCValues.state(this._type);
+		this.setMetadata(applHost, binarySensorValue, binarySensorValue.meta);
+		this.setValue(applHost, binarySensorValue, this._value);
+
 		return true;
 	}
 
@@ -370,22 +374,19 @@ export class BinarySensorCCSupportedReport extends BinarySensorCC {
 		validatePayload(this.payload.length >= 1);
 		// The enumeration starts at 1, but the first (reserved) bit is included
 		// in the report
-		this._supportedSensorTypes = parseBitMask(this.payload, 0).filter(
+		this.supportedSensorTypes = parseBitMask(this.payload, 0).filter(
 			(t) => t !== 0,
 		);
 	}
 
-	private _supportedSensorTypes: BinarySensorType[];
-	@ccValue({ internal: true })
-	public get supportedSensorTypes(): readonly BinarySensorType[] {
-		return this._supportedSensorTypes;
-	}
+	@ccValue(BinarySensorCCValues.supportedSensorTypes)
+	public readonly supportedSensorTypes: readonly BinarySensorType[];
 
 	public toLogEntry(applHost: ZWaveApplicationHost): MessageOrCCLogEntry {
 		return {
 			...super.toLogEntry(applHost),
 			message: {
-				"supported types": this._supportedSensorTypes
+				"supported types": this.supportedSensorTypes
 					.map((type) => getEnumMemberName(BinarySensorType, type))
 					.join(", "),
 			},
diff --git a/packages/cc/src/cc/BinarySwitchCC.ts b/packages/cc/src/cc/BinarySwitchCC.ts
index c09a26d2144..e812d68bbe3 100644
--- a/packages/cc/src/cc/BinarySwitchCC.ts
+++ b/packages/cc/src/cc/BinarySwitchCC.ts
@@ -8,7 +8,6 @@ import {
 	parseBoolean,
 	parseMaybeBoolean,
 	validatePayload,
-	ValueID,
 	ValueMetadata,
 	ZWaveError,
 	ZWaveErrorCodes,
@@ -25,8 +24,6 @@ import {
 	throwWrongValueType,
 } from "../lib/API";
 import {
-	ccValue,
-	ccValueMetadata,
 	CommandClass,
 	gotDeserializationOptions,
 	type CCCommandOptions,
@@ -35,19 +32,38 @@ import {
 import {
 	API,
 	CCCommand,
+	ccValue,
+	ccValues,
 	commandClass,
 	expectedCCResponse,
 	implementedVersion,
 } from "../lib/CommandClassDecorators";
+import { V } from "../lib/Values";
 import { BinarySwitchCommand } from "../lib/_Types";
 
-function getCurrentValueValueId(endpoint?: number): ValueID {
-	return {
-		commandClass: CommandClasses["Binary Switch"],
-		endpoint,
-		property: "currentValue",
-	};
-}
+export const BinarySwitchCCValues = Object.freeze({
+	...V.defineStaticCCValues(CommandClasses["Binary Switch"], {
+		...V.staticProperty("currentValue", {
+			...ValueMetadata.ReadOnlyBoolean,
+			label: "Current value",
+		} as const),
+
+		...V.staticProperty("targetValue", {
+			...ValueMetadata.Boolean,
+			label: "Target value",
+			valueChangeOptions: ["transitionDuration"],
+		} as const),
+
+		...V.staticProperty(
+			"duration",
+			{
+				...ValueMetadata.ReadOnlyDuration,
+				label: "Remaining duration",
+			} as const,
+			{ minVersion: 2 } as const,
+		),
+	}),
+});
 
 @API(CommandClasses["Binary Switch"])
 export class BinarySwitchCCAPI extends CCAPI {
@@ -124,14 +140,15 @@ export class BinarySwitchCCAPI extends CCAPI {
 		const duration = Duration.from(options?.transitionDuration);
 		await this.set(value, duration);
 
+		const currentValueValueId = BinarySwitchCCValues.currentValue.endpoint(
+			this.endpoint.index,
+		);
+
 		// If the command did not fail, assume that it succeeded and update the currentValue accordingly
 		// so UIs have immediate feedback
 		if (this.isSinglecast()) {
 			if (!this.applHost.options.disableOptimisticValueUpdate) {
-				this.getValueDB().setValue(
-					getCurrentValueValueId(this.endpoint.index),
-					value,
-				);
+				this.getValueDB().setValue(currentValueValueId, value);
 			}
 
 			// Verify the current value after a delay
@@ -155,10 +172,7 @@ export class BinarySwitchCCAPI extends CCAPI {
 				for (const node of affectedNodes) {
 					this.applHost
 						.tryGetValueDB(node.id)
-						?.setValue(
-							getCurrentValueValueId(this.endpoint.index),
-							value,
-						);
+						?.setValue(currentValueValueId, value);
 				}
 			}
 			// For multicasts, do not schedule a refresh - this could cause a LOT of traffic
@@ -181,6 +195,7 @@ export class BinarySwitchCCAPI extends CCAPI {
 
 @commandClass(CommandClasses["Binary Switch"])
 @implementedVersion(2)
+@ccValues(BinarySwitchCCValues)
 export class BinarySwitchCC extends CommandClass {
 	declare ccCommand: BinarySwitchCommand;
 
@@ -238,14 +253,7 @@ remaining duration: ${resp.duration?.toString() ?? "undefined"}`;
 		applHost: ZWaveApplicationHost,
 		value: number,
 	): boolean {
-		this.getValueDB(applHost).setValue(
-			{
-				commandClass: this.ccId,
-				endpoint: this.endpointIndex,
-				property: "currentValue",
-			},
-			value > 0,
-		);
+		this.setValue(applHost, BinarySwitchCCValues.currentValue, value > 0);
 		return true;
 	}
 }
@@ -308,45 +316,23 @@ export class BinarySwitchCCReport extends BinarySwitchCC {
 		super(host, options);
 
 		validatePayload(this.payload.length >= 1);
-		this._currentValue = parseMaybeBoolean(this.payload[0]);
+		this.currentValue = parseMaybeBoolean(this.payload[0]);
 
 		if (this.version >= 2 && this.payload.length >= 3) {
 			// V2
-			this._targetValue = parseBoolean(this.payload[1]);
-			this._duration = Duration.parseReport(this.payload[2]);
+			this.targetValue = parseBoolean(this.payload[1]);
+			this.duration = Duration.parseReport(this.payload[2]);
 		}
 	}
 
-	private _currentValue: Maybe<boolean> | undefined;
-	@ccValue()
-	@ccValueMetadata({
-		...ValueMetadata.ReadOnlyBoolean,
-		label: "Current value",
-	})
-	public get currentValue(): Maybe<boolean> | undefined {
-		return this._currentValue;
-	}
+	@ccValue(BinarySwitchCCValues.currentValue)
+	public readonly currentValue: Maybe<boolean> | undefined;
 
-	private _targetValue: boolean | undefined;
-	@ccValue({ forceCreation: true })
-	@ccValueMetadata({
-		...ValueMetadata.Boolean,
-		label: "Target value",
-		valueChangeOptions: ["transitionDuration"],
-	})
-	public get targetValue(): boolean | undefined {
-		return this._targetValue;
-	}
+	@ccValue(BinarySwitchCCValues.targetValue)
+	public readonly targetValue: boolean | undefined;
 
-	private _duration: Duration | undefined;
-	@ccValue({ minVersion: 2 })
-	@ccValueMetadata({
-		...ValueMetadata.ReadOnlyDuration,
-		label: "Remaining duration",
-	})
-	public get duration(): Duration | undefined {
-		return this._duration;
-	}
+	@ccValue(BinarySwitchCCValues.duration)
+	public readonly duration: Duration | undefined;
 
 	public toLogEntry(applHost: ZWaveApplicationHost): MessageOrCCLogEntry {
 		const message: MessageRecord = {
diff --git a/packages/cc/src/cc/CentralSceneCC.ts b/packages/cc/src/cc/CentralSceneCC.ts
index 7be819e647d..31b178d146c 100644
--- a/packages/cc/src/cc/CentralSceneCC.ts
+++ b/packages/cc/src/cc/CentralSceneCC.ts
@@ -1,8 +1,4 @@
-import type {
-	MessageOrCCLogEntry,
-	MessageRecord,
-	ValueID,
-} from "@zwave-js/core/safe";
+import type { MessageOrCCLogEntry, MessageRecord } from "@zwave-js/core/safe";
 import {
 	CommandClasses,
 	enumValuesToMetadataStates,
@@ -28,8 +24,6 @@ import {
 	throwWrongValueType,
 } from "../lib/API";
 import {
-	ccValue,
-	ccValueMetadata,
 	CommandClass,
 	gotDeserializationOptions,
 	type CCCommandOptions,
@@ -38,33 +32,54 @@ import {
 import {
 	API,
 	CCCommand,
+	ccValue,
+	ccValues,
 	commandClass,
 	expectedCCResponse,
 	implementedVersion,
 } from "../lib/CommandClassDecorators";
 import * as ccUtils from "../lib/utils";
+import { V } from "../lib/Values";
 import { CentralSceneCommand, CentralSceneKeys } from "../lib/_Types";
 import { AssociationGroupInfoCC } from "./AssociationGroupInfoCC";
 
-/** Returns the ValueID used to store the current value of a Central Scene */
-export function getSceneValueId(sceneNumber: number): ValueID {
-	return {
-		commandClass: CommandClasses["Central Scene"],
-		property: "scene",
-		propertyKey: padStart(sceneNumber.toString(), 3, "0"),
-	};
-}
-
-function getSceneLabel(sceneNumber: number): string {
-	return `Scene ${padStart(sceneNumber.toString(), 3, "0")}`;
-}
-
-export function getSlowRefreshValueId(): ValueID {
-	return {
-		commandClass: CommandClasses["Central Scene"],
-		property: "slowRefresh",
-	};
-}
+export const CentralSceneCCValues = Object.freeze({
+	...V.defineStaticCCValues(CommandClasses["Central Scene"], {
+		...V.staticProperty("sceneCount", undefined, {
+			internal: true,
+		}),
+		...V.staticProperty("supportsSlowRefresh", undefined, {
+			internal: true,
+		}),
+		...V.staticProperty("supportedKeyAttributes", undefined, {
+			internal: true,
+		}),
+
+		...V.staticProperty("slowRefresh", {
+			...ValueMetadata.Boolean,
+			label: "Send held down notifications at a slow rate",
+			description:
+				"When this is true, KeyHeldDown notifications are sent every 55s. When this is false, the notifications are sent every 200ms.",
+		} as const),
+	}),
+
+	...V.defineDynamicCCValues(CommandClasses["Central Scene"], {
+		...V.dynamicPropertyAndKeyWithName(
+			"scene",
+			"scene",
+			(sceneNumber: number) => padStart(sceneNumber.toString(), 3, "0"),
+			({ property, propertyKey }) =>
+				property === "scene" &&
+				typeof propertyKey === "string" &&
+				/^\d{3}$/.test(propertyKey),
+			(sceneNumber: number) =>
+				({
+					...ValueMetadata.ReadOnlyUInt8,
+					label: `Scene ${padStart(sceneNumber.toString(), 3, "0")}`,
+				} as const),
+		),
+	}),
+});
 
 @API(CommandClasses["Central Scene"])
 export class CentralSceneCCAPI extends CCAPI {
@@ -166,6 +181,7 @@ export class CentralSceneCCAPI extends CCAPI {
 
 @commandClass(CommandClasses["Central Scene"])
 @implementedVersion(3)
+@ccValues(CentralSceneCCValues)
 export class CentralSceneCC extends CommandClass {
 	declare ccCommand: CentralSceneCommand;
 
@@ -287,31 +303,25 @@ export class CentralSceneCCNotification extends CentralSceneCC {
 		super(host, options);
 
 		validatePayload(this.payload.length >= 3);
-		this._sequenceNumber = this.payload[0];
-		this._keyAttribute = this.payload[1] & 0b111;
-		this._sceneNumber = this.payload[2];
+		this.sequenceNumber = this.payload[0];
+		this.keyAttribute = this.payload[1] & 0b111;
+		this.sceneNumber = this.payload[2];
 		if (
-			this._keyAttribute === CentralSceneKeys.KeyHeldDown &&
+			this.keyAttribute === CentralSceneKeys.KeyHeldDown &&
 			this.version >= 3
 		) {
 			// A receiving node MUST ignore this field if the command is not
 			// carrying the Key Held Down key attribute.
-			this._slowRefresh = !!(this.payload[1] & 0b1000_0000);
+			this.slowRefresh = !!(this.payload[1] & 0b1000_0000);
 		}
 	}
 
 	public persistValues(applHost: ZWaveApplicationHost): boolean {
 		if (!super.persistValues(applHost)) return false;
-		const valueDB = this.getValueDB(applHost);
 
 		// In case the interview is not yet completed, we still create some basic metadata
-		const valueId = getSceneValueId(this._sceneNumber);
-		if (!valueDB.hasMetadata(valueId)) {
-			valueDB.setMetadata(valueId, {
-				...ValueMetadata.ReadOnlyUInt8,
-				label: getSceneLabel(this._sceneNumber),
-			});
-		}
+		const sceneValue = CentralSceneCCValues.scene(this.sceneNumber);
+		this.ensureMetadata(applHost, sceneValue);
 
 		// The spec behavior is pretty complicated, so we cannot just store
 		// the value and call it a day. Handling of these notifications will
@@ -320,25 +330,10 @@ export class CentralSceneCCNotification extends CentralSceneCC {
 		return true;
 	}
 
-	private _sequenceNumber: number;
-	public get sequenceNumber(): number {
-		return this._sequenceNumber;
-	}
-
-	private _keyAttribute: CentralSceneKeys;
-	public get keyAttribute(): CentralSceneKeys {
-		return this._keyAttribute;
-	}
-
-	private _sceneNumber: number;
-	public get sceneNumber(): number {
-		return this._sceneNumber;
-	}
-
-	private _slowRefresh: boolean | undefined;
-	public get slowRefresh(): boolean | undefined {
-		return this._slowRefresh;
-	}
+	public readonly sequenceNumber: number;
+	public readonly keyAttribute: CentralSceneKeys;
+	public readonly sceneNumber: number;
+	public readonly slowRefresh: boolean | undefined;
 
 	public toLogEntry(applHost: ZWaveApplicationHost): MessageOrCCLogEntry {
 		const message: MessageRecord = {
@@ -368,8 +363,8 @@ export class CentralSceneCCSupportedReport extends CentralSceneCC {
 		super(host, options);
 
 		validatePayload(this.payload.length >= 2);
-		this._sceneCount = this.payload[0];
-		this._supportsSlowRefresh =
+		this.sceneCount = this.payload[0];
+		this.supportsSlowRefresh =
 			this.version >= 3 ? !!(this.payload[1] & 0b1000_0000) : undefined;
 		const bitMaskBytes = (this.payload[1] & 0b110) >>> 1;
 		const identicalKeyAttributes = !!(this.payload[1] & 0b1);
@@ -388,7 +383,7 @@ export class CentralSceneCCSupportedReport extends CentralSceneCC {
 		}
 		if (identicalKeyAttributes) {
 			// The key attributes are only transmitted for scene 1, copy them to the others
-			for (let i = 2; i <= this._sceneCount; i++) {
+			for (let i = 2; i <= this.sceneCount; i++) {
 				this._supportedKeyAttributes.set(
 					i,
 					this._supportedKeyAttributes.get(1)!,
@@ -400,13 +395,11 @@ export class CentralSceneCCSupportedReport extends CentralSceneCC {
 	public persistValues(applHost: ZWaveApplicationHost): boolean {
 		if (!super.persistValues(applHost)) return false;
 
-		// Create metadata for all scenes
-		const valueDB = this.getValueDB(applHost);
-		for (let i = 1; i <= this._sceneCount; i++) {
-			const valueId = getSceneValueId(i);
-			valueDB.setMetadata(valueId, {
-				...ValueMetadata.ReadOnlyUInt8,
-				label: getSceneLabel(i),
+		// Create/extend metadata for all scenes
+		for (let i = 1; i <= this.sceneCount; i++) {
+			const sceneValue = CentralSceneCCValues.scene(i);
+			this.setMetadata(applHost, sceneValue, {
+				...sceneValue.meta,
 				states: enumValuesToMetadataStates(
 					CentralSceneKeys,
 					this._supportedKeyAttributes.get(i),
@@ -417,24 +410,19 @@ export class CentralSceneCCSupportedReport extends CentralSceneCC {
 		return true;
 	}
 
-	private _sceneCount: number;
-	@ccValue({ internal: true })
-	public get sceneCount(): number {
-		return this._sceneCount;
-	}
+	@ccValue(CentralSceneCCValues.sceneCount)
+	public readonly sceneCount: number;
 
 	// TODO: Only offer `slowRefresh` if this is true
-	private _supportsSlowRefresh: boolean | undefined;
-	@ccValue({ internal: true })
-	public get supportsSlowRefresh(): boolean | undefined {
-		return this._supportsSlowRefresh;
-	}
+	@ccValue(CentralSceneCCValues.supportsSlowRefresh)
+	public readonly supportsSlowRefresh: boolean | undefined;
 
 	private _supportedKeyAttributes = new Map<
 		number,
 		readonly CentralSceneKeys[]
 	>();
-	@ccValue({ internal: true })
+
+	@ccValue(CentralSceneCCValues.supportedKeyAttributes)
 	public get supportedKeyAttributes(): ReadonlyMap<
 		number,
 		readonly CentralSceneKeys[]
@@ -457,24 +445,6 @@ export class CentralSceneCCSupportedReport extends CentralSceneCC {
 			message,
 		};
 	}
-
-	// private _keyAttributesHaveIdenticalSupport: boolean;
-	// @ccValue({ internal: true })
-	// public get keyAttributesHaveIdenticalSupport(): boolean {
-	// 	return this._keyAttributesHaveIdenticalSupport;
-	// }
-
-	// public supportsKeyAttribute(
-	// 	sceneNumber: number,
-	// 	keyAttribute: CentralSceneKeys,
-	// ): boolean {
-	// 	const mapIndex = this._keyAttributesHaveIdenticalSupport
-	// 		? 1
-	// 		: sceneNumber;
-	// 	return this._supportedKeyAttributes
-	// 		.get(mapIndex)!
-	// 		.includes(keyAttribute);
-	// }
 }
 
 @CCCommand(CentralSceneCommand.SupportedGet)
@@ -490,26 +460,16 @@ export class CentralSceneCCConfigurationReport extends CentralSceneCC {
 		super(host, options);
 
 		validatePayload(this.payload.length >= 1);
-		this._slowRefresh = !!(this.payload[0] & 0b1000_0000);
+		this.slowRefresh = !!(this.payload[0] & 0b1000_0000);
 	}
 
-	private _slowRefresh: boolean;
-	@ccValue()
-	@ccValueMetadata({
-		...ValueMetadata.Boolean,
-		label: "Send held down notifications at a slow rate",
-		description:
-			"When this is true, KeyHeldDown notifications are sent every 55s. " +
-			"When this is false, the notifications are sent every 200ms.",
-	})
-	public get slowRefresh(): boolean {
-		return this._slowRefresh;
-	}
+	@ccValue(CentralSceneCCValues.slowRefresh)
+	public readonly slowRefresh: boolean;
 
 	public toLogEntry(applHost: ZWaveApplicationHost): MessageOrCCLogEntry {
 		return {
 			...super.toLogEntry(applHost),
-			message: { "slow refresh": this._slowRefresh },
+			message: { "slow refresh": this.slowRefresh },
 		};
 	}
 }
diff --git a/packages/cc/src/cc/ClimateControlScheduleCC.ts b/packages/cc/src/cc/ClimateControlScheduleCC.ts
index 2a169609c72..0ab68f8e8a2 100644
--- a/packages/cc/src/cc/ClimateControlScheduleCC.ts
+++ b/packages/cc/src/cc/ClimateControlScheduleCC.ts
@@ -1,7 +1,10 @@
-import type { Maybe, MessageOrCCLogEntry } from "@zwave-js/core/safe";
 import {
 	CommandClasses,
+	enumValuesToMetadataStates,
+	Maybe,
+	MessageOrCCLogEntry,
 	validatePayload,
+	ValueMetadata,
 	ZWaveError,
 	ZWaveErrorCodes,
 } from "@zwave-js/core/safe";
@@ -11,8 +14,6 @@ import { validateArgs } from "@zwave-js/transformers";
 import { padStart } from "alcalzone-shared/strings";
 import { CCAPI } from "../lib/API";
 import {
-	ccKeyValuePair,
-	ccValue,
 	CommandClass,
 	gotDeserializationOptions,
 	type CCCommandOptions,
@@ -21,6 +22,8 @@ import {
 import {
 	API,
 	CCCommand,
+	ccValue,
+	ccValues,
 	commandClass,
 	expectedCCResponse,
 	implementedVersion,
@@ -31,6 +34,7 @@ import {
 	encodeSetbackState,
 	encodeSwitchpoint,
 } from "../lib/serializers";
+import { V } from "../lib/Values";
 import {
 	ClimateControlScheduleCommand,
 	ScheduleOverrideType,
@@ -39,6 +43,39 @@ import {
 	Weekday,
 } from "../lib/_Types";
 
+export const ClimateControlScheduleCCValues = Object.freeze({
+	...V.defineStaticCCValues(CommandClasses["Climate Control Schedule"], {
+		...V.staticProperty("overrideType", {
+			...ValueMetadata.Number,
+			label: "Override type",
+			states: enumValuesToMetadataStates(ScheduleOverrideType),
+		} as const),
+		...V.staticProperty("overrideState", {
+			...ValueMetadata.Number,
+			label: "Override state",
+			min: -12.8,
+		} as const),
+	}),
+
+	...V.defineDynamicCCValues(CommandClasses["Climate Control Schedule"], {
+		...V.dynamicPropertyAndKeyWithName(
+			"schedule",
+			"schedule",
+			(weekday: Weekday) => weekday,
+			({ property, propertyKey }) =>
+				property === "switchPoints" &&
+				typeof propertyKey === "number" &&
+				propertyKey >= Weekday.Monday &&
+				propertyKey <= Weekday.Sunday,
+			(weekday: Weekday) =>
+				({
+					...ValueMetadata.Any,
+					label: `Schedule (${getEnumMemberName(Weekday, weekday)})`,
+				} as const),
+		),
+	}),
+});
+
 @API(CommandClasses["Climate Control Schedule"])
 export class ClimateControlScheduleCCAPI extends CCAPI {
 	public supportsCommand(cmd: ClimateControlScheduleCommand): Maybe<boolean> {
@@ -92,7 +129,7 @@ export class ClimateControlScheduleCCAPI extends CCAPI {
 				cc,
 				this.commandOptions,
 			);
-		return response?.switchPoints;
+		return response?.schedule;
 	}
 
 	public async getChangeCounter(): Promise<number | undefined> {
@@ -159,6 +196,7 @@ export class ClimateControlScheduleCCAPI extends CCAPI {
 
 @commandClass(CommandClasses["Climate Control Schedule"])
 @implementedVersion(1)
+@ccValues(ClimateControlScheduleCCValues)
 export class ClimateControlScheduleCC extends CommandClass {
 	declare ccCommand: ClimateControlScheduleCommand;
 }
@@ -237,37 +275,30 @@ export class ClimateControlScheduleCCReport extends ClimateControlScheduleCC {
 		super(host, options);
 
 		validatePayload(this.payload.length >= 28); // 1 + 9 * 3
-		const weekday = this.payload[0] & 0b111;
+		this.weekday = this.payload[0] & 0b111;
 		const allSwitchpoints: Switchpoint[] = [];
 		for (let i = 0; i <= 8; i++) {
 			allSwitchpoints.push(
 				decodeSwitchpoint(this.payload.slice(1 + 3 * i)),
 			);
 		}
-		const switchPoints = allSwitchpoints.filter(
-			(sp) => sp.state !== "Unused",
-		);
-
-		this.schedule = [weekday, switchPoints];
+		this.schedule = allSwitchpoints.filter((sp) => sp.state !== "Unused");
 	}
 
-	@ccKeyValuePair()
-	private schedule: [Weekday, Switchpoint[]];
-
-	public get switchPoints(): readonly Switchpoint[] {
-		return this.schedule[1];
-	}
+	public readonly weekday: Weekday;
 
-	public get weekday(): Weekday {
-		return this.schedule[0];
-	}
+	@ccValue(
+		ClimateControlScheduleCCValues.schedule,
+		(self: ClimateControlScheduleCCReport) => [self.weekday] as const,
+	)
+	public readonly schedule: readonly Switchpoint[];
 
 	public toLogEntry(applHost: ZWaveApplicationHost): MessageOrCCLogEntry {
 		return {
 			...super.toLogEntry(applHost),
 			message: {
 				weekday: getEnumMemberName(Weekday, this.weekday),
-				switchpoints: `${this.switchPoints
+				schedule: `${this.schedule
 					.map(
 						(sp) => `
 · ${padStart(sp.hour.toString(), 2, "0")}:${padStart(
@@ -330,13 +361,10 @@ export class ClimateControlScheduleCCChangedReport extends ClimateControlSchedul
 		super(host, options);
 
 		validatePayload(this.payload.length >= 1);
-		this._changeCounter = this.payload[0];
+		this.changeCounter = this.payload[0];
 	}
 
-	private _changeCounter: number;
-	@ccValue() public get changeCounter(): number {
-		return this._changeCounter;
-	}
+	public readonly changeCounter: number;
 
 	public toLogEntry(applHost: ZWaveApplicationHost): MessageOrCCLogEntry {
 		return {
@@ -359,20 +387,16 @@ export class ClimateControlScheduleCCOverrideReport extends ClimateControlSchedu
 		super(host, options);
 
 		validatePayload(this.payload.length >= 2);
-		this._overrideType = this.payload[0] & 0b11;
-		this._overrideState =
+		this.overrideType = this.payload[0] & 0b11;
+		this.overrideState =
 			decodeSetbackState(this.payload[1]) || this.payload[1];
 	}
 
-	private _overrideType: ScheduleOverrideType;
-	@ccValue() public get overrideType(): ScheduleOverrideType {
-		return this._overrideType;
-	}
+	@ccValue(ClimateControlScheduleCCValues.overrideType)
+	public readonly overrideType: ScheduleOverrideType;
 
-	private _overrideState: SetbackState;
-	@ccValue() public get overrideState(): SetbackState {
-		return this._overrideState;
-	}
+	@ccValue(ClimateControlScheduleCCValues.overrideState)
+	public readonly overrideState: SetbackState;
 
 	public toLogEntry(applHost: ZWaveApplicationHost): MessageOrCCLogEntry {
 		return {
@@ -380,9 +404,9 @@ export class ClimateControlScheduleCCOverrideReport extends ClimateControlSchedu
 			message: {
 				"override type": getEnumMemberName(
 					ScheduleOverrideType,
-					this._overrideType,
+					this.overrideType,
 				),
-				"override state": this._overrideState,
+				"override state": this.overrideState,
 			},
 		};
 	}
diff --git a/packages/cc/src/cc/ColorSwitchCC.ts b/packages/cc/src/cc/ColorSwitchCC.ts
index b6294a3ad19..467a8059527 100644
--- a/packages/cc/src/cc/ColorSwitchCC.ts
+++ b/packages/cc/src/cc/ColorSwitchCC.ts
@@ -31,21 +31,21 @@ import {
 	throwWrongValueType,
 } from "../lib/API";
 import {
-	ccValue,
-	ccValueMetadata,
 	CommandClass,
 	gotDeserializationOptions,
 	type CCCommandOptions,
 	type CommandClassDeserializationOptions,
-	type CommandClassOptions,
 } from "../lib/CommandClass";
 import {
 	API,
 	CCCommand,
+	ccValue,
+	ccValues,
 	commandClass,
 	expectedCCResponse,
 	implementedVersion,
 } from "../lib/CommandClassDecorators";
+import { V } from "../lib/Values";
 import {
 	ColorComponent,
 	ColorComponentMap,
@@ -85,53 +85,75 @@ function colorComponentToTableKey(
 	}
 }
 
-function getSupportedColorComponentsValueID(endpointIndex: number): ValueID {
-	return {
-		commandClass: CommandClasses["Color Switch"],
-		endpoint: endpointIndex,
-		property: "supportedColorComponents",
-	};
-}
-
-function getCurrentColorValueID(
-	endpointIndex: number,
-	component?: ColorComponent,
-): ValueID {
-	return {
-		commandClass: CommandClasses["Color Switch"],
-		property: "currentColor",
-		endpoint: endpointIndex,
-		propertyKey: component,
-	};
-}
-
-function getTargetColorValueID(
-	endpointIndex: number,
-	component?: ColorComponent,
-): ValueID {
-	return {
-		commandClass: CommandClasses["Color Switch"],
-		property: "targetColor",
-		endpoint: endpointIndex,
-		propertyKey: component,
-	};
-}
-
-function getSupportsHexColorValueID(endpointIndex: number): ValueID {
-	return {
-		commandClass: CommandClasses["Color Switch"],
-		property: "supportsHexColor",
-		endpoint: endpointIndex,
-	};
-}
+export const ColorSwitchCCValues = Object.freeze({
+	...V.defineStaticCCValues(CommandClasses["Color Switch"], {
+		...V.staticProperty("supportedColorComponents", undefined, {
+			internal: true,
+		}),
+		...V.staticProperty("supportsHexColor", undefined, {
+			internal: true,
+		}),
 
-function getHexColorValueID(endpointIndex: number): ValueID {
-	return {
-		commandClass: CommandClasses["Color Switch"],
-		property: "hexColor",
-		endpoint: endpointIndex,
-	};
-}
+		// The compound color (static)
+		...V.staticPropertyWithName("currentColor", "currentColor", {
+			...ValueMetadata.ReadOnly,
+			label: `Current color`,
+		} as const),
+		...V.staticPropertyWithName("targetColor", "targetColor", {
+			...ValueMetadata.Any,
+			label: `Target color`,
+			valueChangeOptions: ["transitionDuration"],
+		} as const),
+		...V.staticProperty("duration", {
+			...ValueMetadata.ReadOnlyDuration,
+			label: "Remaining duration",
+		} as const),
+
+		// The compound color as HEX
+		...V.staticProperty("hexColor", {
+			...ValueMetadata.Color,
+			minLength: 6,
+			maxLength: 7, // to allow #rrggbb
+			label: `RGB Color`,
+			valueChangeOptions: ["transitionDuration"],
+		} as const),
+	}),
+
+	...V.defineDynamicCCValues(CommandClasses["Color Switch"], {
+		// The individual color channels (dynamic)
+		...V.dynamicPropertyAndKeyWithName(
+			"currentColorChannel",
+			"currentColor",
+			(component: ColorComponent) => component,
+			({ property, propertyKey }) =>
+				property === "currentColor" && typeof propertyKey === "number",
+			(component: ColorComponent) => {
+				const colorName = getEnumMemberName(ColorComponent, component);
+				return {
+					...ValueMetadata.ReadOnlyUInt8,
+					label: `Current value (${colorName})`,
+					description: `The current value of the ${colorName} channel.`,
+				} as const;
+			},
+		),
+		...V.dynamicPropertyAndKeyWithName(
+			"targetColorChannel",
+			"targetColor",
+			(component: ColorComponent) => component,
+			({ property, propertyKey }) =>
+				property === "targetColor" && typeof propertyKey === "number",
+			(component: ColorComponent) => {
+				const colorName = getEnumMemberName(ColorComponent, component);
+				return {
+					...ValueMetadata.UInt8,
+					label: `Target value (${colorName})`,
+					description: `The target value of the ${colorName} channel.`,
+					valueChangeOptions: ["transitionDuration"],
+				} as const;
+			},
+		),
+	}),
+});
 
 @API(CommandClasses["Color Switch"])
 export class ColorSwitchCCAPI extends CCAPI {
@@ -226,14 +248,21 @@ export class ColorSwitchCCAPI extends CCAPI {
 	/** Updates the current color for a given node by merging in the given changes */
 	private updateCurrentColor(valueDB: ValueDB, colorTable: ColorTable) {
 		let updatedRGB = false;
-		const currentCompoundValue =
+		const currentColorValueId = ColorSwitchCCValues.currentColor.endpoint(
+			this.endpoint.index,
+		);
+		const targetColorValueId = ColorSwitchCCValues.targetColor.endpoint(
+			this.endpoint.index,
+		);
+		const currentCompoundColor =
 			valueDB.getValue<Partial<Record<ColorKey, number>>>(
-				getCurrentColorValueID(this.endpoint.index),
+				currentColorValueId,
 			) ?? {};
-		const targetCompoundValue =
+		const targetCompoundColor =
 			valueDB.getValue<Partial<Record<ColorKey, number>>>(
-				getCurrentColorValueID(this.endpoint.index),
+				targetColorValueId,
 			) ?? {};
+
 		for (const [key, value] of entries(colorTable)) {
 			const component = colorTableKeyToComponent(key);
 			if (
@@ -245,32 +274,30 @@ export class ColorSwitchCCAPI extends CCAPI {
 			}
 
 			valueDB.setValue(
-				getCurrentColorValueID(this.endpoint.index, component),
+				ColorSwitchCCValues.currentColorChannel(component).endpoint(
+					this.endpoint.index,
+				),
 				value,
 			);
 
 			// Update the compound value
 			if (key in ColorComponentMap) {
-				currentCompoundValue[key as ColorKey] = value;
-				targetCompoundValue[key as ColorKey] = value;
+				currentCompoundColor[key as ColorKey] = value;
+				targetCompoundColor[key as ColorKey] = value;
 			}
 		}
 		// And store the updated compound values
-		valueDB.setValue(
-			getCurrentColorValueID(this.endpoint.index),
-			currentCompoundValue,
-		);
-		valueDB.setValue(
-			getTargetColorValueID(this.endpoint.index),
-			targetCompoundValue,
-		);
+		valueDB.setValue(currentColorValueId, currentCompoundColor);
+		valueDB.setValue(targetColorValueId, targetCompoundColor);
 
 		// and hex color if necessary
 		const supportsHex = valueDB.getValue<boolean>(
-			getSupportsHexColorValueID(this.endpoint.index),
+			ColorSwitchCCValues.supportsHexColor.endpoint(this.endpoint.index),
 		);
 		if (supportsHex && updatedRGB) {
-			const hexValueId = getHexColorValueID(this.endpoint.index);
+			const hexValueId = ColorSwitchCCValues.hexColor.endpoint(
+				this.endpoint.index,
+			);
 			const [r, g, b] = [
 				ColorComponent.Red,
 				ColorComponent.Green,
@@ -278,7 +305,9 @@ export class ColorSwitchCCAPI extends CCAPI {
 			].map(
 				(c) =>
 					valueDB.getValue<number>(
-						getCurrentColorValueID(this.endpoint.index, c),
+						ColorSwitchCCValues.currentColorChannel(c).endpoint(
+							this.endpoint.index,
+						),
 					) ?? 0,
 			);
 			const hexValue = (r << 16) | (g << 8) | b;
@@ -375,7 +404,11 @@ export class ColorSwitchCCAPI extends CCAPI {
 				if (this.isSinglecast()) {
 					const supportedColors = this.tryGetValueDB()?.getValue<
 						readonly ColorComponent[]
-					>(getSupportedColorComponentsValueID(this.endpoint.index));
+					>(
+						ColorSwitchCCValues.supportedColorComponents.endpoint(
+							this.endpoint.index,
+						),
+					);
 					if (supportedColors) {
 						value = pick(
 							value,
@@ -440,16 +473,10 @@ export class ColorSwitchCCAPI extends CCAPI {
 
 @commandClass(CommandClasses["Color Switch"])
 @implementedVersion(3)
+@ccValues(ColorSwitchCCValues)
 export class ColorSwitchCC extends CommandClass {
 	declare ccCommand: ColorSwitchCommand;
 
-	public constructor(host: ZWaveHost, options: CommandClassOptions) {
-		super(host, options);
-		this.registerValue(getSupportsHexColorValueID(0).property, {
-			internal: true,
-		});
-	}
-
 	public async interview(applHost: ZWaveApplicationHost): Promise<void> {
 		const node = this.getNode(applHost)!;
 		const endpoint = this.getEndpoint(applHost)!;
@@ -460,7 +487,6 @@ export class ColorSwitchCC extends CommandClass {
 		).withOptions({
 			priority: MessagePriority.NodeQuery,
 		});
-		const valueDB = this.getValueDB(applHost);
 
 		applHost.controllerLog.logNode(node.id, {
 			endpoint: this.endpointIndex,
@@ -494,34 +520,19 @@ export class ColorSwitchCC extends CommandClass {
 
 		// Create metadata for the separate color channels
 		for (const color of supportedColors) {
-			const colorName = getEnumMemberName(ColorComponent, color);
-			valueDB.setMetadata(
-				getCurrentColorValueID(this.endpointIndex, color),
-				{
-					...ValueMetadata.ReadOnlyUInt8,
-					label: `Current value (${colorName})`,
-					description: `The current value of the ${colorName} color.`,
-				},
-			);
-			valueDB.setMetadata(
-				getTargetColorValueID(this.endpointIndex, color),
-				{
-					...ValueMetadata.UInt8,
-					label: `Target value (${colorName})`,
-					description: `The target value of the ${colorName} color.`,
-				},
-			);
+			const currentColorChannelValue =
+				ColorSwitchCCValues.currentColorChannel(color);
+			this.setMetadata(applHost, currentColorChannelValue);
+
+			const targetColorChannelValue =
+				ColorSwitchCCValues.targetColorChannel(color);
+			this.setMetadata(applHost, targetColorChannelValue);
 		}
 		// And the compound one
-		valueDB.setMetadata(getCurrentColorValueID(this.endpointIndex), {
-			...ValueMetadata.ReadOnly,
-			label: `Current Color`,
-		});
-		valueDB.setMetadata(getTargetColorValueID(this.endpointIndex), {
-			...ValueMetadata.Any,
-			label: `Target Color`,
-			valueChangeOptions: ["transitionDuration"],
-		});
+		const currentColorValue = ColorSwitchCCValues.currentColor;
+		this.setMetadata(applHost, currentColorValue);
+		const targetColorValue = ColorSwitchCCValues.targetColor;
+		this.setMetadata(applHost, targetColorValue);
 
 		// Create the collective HEX color values
 		const supportsHex = [
@@ -529,18 +540,14 @@ export class ColorSwitchCC extends CommandClass {
 			ColorComponent.Green,
 			ColorComponent.Blue,
 		].every((c) => supportedColors.includes(c));
-		valueDB.setValue(
-			getSupportsHexColorValueID(this.endpointIndex),
+		this.setValue(
+			applHost,
+			ColorSwitchCCValues.supportsHexColor,
 			supportsHex,
 		);
 		if (supportsHex) {
-			valueDB.setMetadata(getHexColorValueID(this.endpointIndex), {
-				...ValueMetadata.Color,
-				minLength: 6,
-				maxLength: 7, // to allow #rrggbb
-				label: `RGB Color`,
-				valueChangeOptions: ["transitionDuration"],
-			});
+			const hexColorValue = ColorSwitchCCValues.hexColor;
+			this.setMetadata(applHost, hexColorValue);
 		}
 
 		// Query all color components
@@ -560,11 +567,11 @@ export class ColorSwitchCC extends CommandClass {
 		).withOptions({
 			priority: MessagePriority.NodeQuery,
 		});
-		const valueDB = this.getValueDB(applHost);
 
 		const supportedColors: readonly ColorComponent[] =
-			valueDB.getValue(
-				getSupportedColorComponentsValueID(this.endpointIndex),
+			this.getValue(
+				applHost,
+				ColorSwitchCCValues.supportedColorComponents,
 			) ?? [];
 
 		for (const color of supportedColors) {
@@ -611,7 +618,7 @@ export class ColorSwitchCCSupportedReport extends ColorSwitchCC {
 		);
 	}
 
-	@ccValue({ internal: true })
+	@ccValue(ColorSwitchCCValues.supportedColorComponents)
 	public readonly supportedColorComponents: readonly ColorComponent[];
 
 	public toLogEntry(applHost: ZWaveApplicationHost): MessageOrCCLogEntry {
@@ -651,47 +658,39 @@ export class ColorSwitchCCReport extends ColorSwitchCC {
 	public persistValues(applHost: ZWaveApplicationHost): boolean {
 		// Duration is stored globally instead of per component
 		if (!super.persistValues(applHost)) return false;
-		const valueDB = this.getValueDB(applHost);
-
-		const valueId = getCurrentColorValueID(
-			this.endpointIndex,
-			this.colorComponent,
-		);
-		valueDB.setValue(valueId, this.currentValue);
-
-		// Update target value if required
-		if (this.targetValue != undefined) {
-			const targetValueId = getTargetColorValueID(
-				this.endpointIndex,
-				this.colorComponent,
-			);
-			valueDB.setValue(targetValueId, this.targetValue);
-		}
 
 		// Update compound current value
 		const colorTableKey = colorComponentToTableKey(this.colorComponent);
 		if (colorTableKey) {
-			const compoundValueId = getCurrentColorValueID(this.endpointIndex);
-			const compoundValue: Partial<Record<ColorKey, number>> =
-				valueDB.getValue(compoundValueId) ?? {};
-			compoundValue[colorTableKey] = this.currentValue;
-			valueDB.setValue(compoundValueId, compoundValue);
+			const compoundCurrentColorValue = ColorSwitchCCValues.currentColor;
+			const compoundCurrentColor: Partial<Record<ColorKey, number>> =
+				this.getValue(applHost, compoundCurrentColorValue) ?? {};
+			compoundCurrentColor[colorTableKey] = this.currentValue;
+			this.setValue(
+				applHost,
+				compoundCurrentColorValue,
+				compoundCurrentColor,
+			);
 
 			// and target value
 			if (this.targetValue != undefined) {
-				const compoundTargetValueId = getTargetColorValueID(
-					this.endpointIndex,
+				const compoundTargetColorValue =
+					ColorSwitchCCValues.targetColor;
+				const compoundTargetColor: Partial<Record<ColorKey, number>> =
+					this.getValue(applHost, compoundTargetColorValue) ?? {};
+				compoundTargetColor[colorTableKey] = this.targetValue;
+				this.setValue(
+					applHost,
+					compoundTargetColorValue,
+					compoundTargetColor,
 				);
-				const compoundTargetValue: Partial<Record<ColorKey, number>> =
-					valueDB.getValue(compoundTargetValueId) ?? {};
-				compoundTargetValue[colorTableKey] = this.targetValue;
-				valueDB.setValue(compoundTargetValueId, compoundTargetValue);
 			}
 		}
 
 		// Update collective hex value if required
-		const supportsHex = valueDB.getValue<boolean>(
-			getSupportsHexColorValueID(this.endpointIndex),
+		const supportsHex = !!this.getValue(
+			applHost,
+			ColorSwitchCCValues.supportsHexColor,
 		);
 		if (
 			supportsHex &&
@@ -699,16 +698,19 @@ export class ColorSwitchCCReport extends ColorSwitchCC {
 				this.colorComponent === ColorComponent.Green ||
 				this.colorComponent === ColorComponent.Blue)
 		) {
-			const hexValueId = getHexColorValueID(this.endpointIndex);
-			const hexValue = valueDB.getValue<string>(hexValueId) ?? "000000";
+			const hexColorValue = ColorSwitchCCValues.hexColor;
+
+			const hexValue: string =
+				this.getValue(applHost, hexColorValue) ?? "000000";
 			const byteOffset = ColorComponent.Blue - this.colorComponent;
 			const byteMask = 0xff << (byteOffset * 8);
 			let hexValueNumeric = parseInt(hexValue, 16);
 			hexValueNumeric =
 				(hexValueNumeric & ~byteMask) |
 				(this.currentValue << (byteOffset * 8));
-			valueDB.setValue(
-				hexValueId,
+			this.setValue(
+				applHost,
+				hexColorValue,
 				hexValueNumeric.toString(16).padStart(6, "0"),
 			);
 		}
@@ -717,14 +719,19 @@ export class ColorSwitchCCReport extends ColorSwitchCC {
 	}
 
 	public readonly colorComponent: ColorComponent;
+	@ccValue(
+		ColorSwitchCCValues.currentColorChannel,
+		(self: ColorSwitchCCReport) => [self.colorComponent] as const,
+	)
 	public readonly currentValue: number;
+
+	@ccValue(
+		ColorSwitchCCValues.targetColorChannel,
+		(self: ColorSwitchCCReport) => [self.colorComponent] as const,
+	)
 	public readonly targetValue: number | undefined;
 
-	@ccValue()
-	@ccValueMetadata({
-		...ValueMetadata.ReadOnlyDuration,
-		label: "Remaining duration",
-	})
+	@ccValue(ColorSwitchCCValues.duration)
 	public readonly duration: Duration | undefined;
 
 	public toLogEntry(applHost: ZWaveApplicationHost): MessageOrCCLogEntry {
diff --git a/packages/cc/src/cc/ConfigurationCC.ts b/packages/cc/src/cc/ConfigurationCC.ts
index 997856a5419..7c1fb01f53e 100644
--- a/packages/cc/src/cc/ConfigurationCC.ts
+++ b/packages/cc/src/cc/ConfigurationCC.ts
@@ -42,7 +42,6 @@ import {
 } from "../lib/API";
 import {
 	CommandClass,
-	CommandClassOptions,
 	gotDeserializationOptions,
 	type CCCommandOptions,
 	type CommandClassDeserializationOptions,
@@ -50,10 +49,12 @@ import {
 import {
 	API,
 	CCCommand,
+	ccValues,
 	commandClass,
 	expectedCCResponse,
 	implementedVersion,
 } from "../lib/CommandClassDecorators";
+import { V } from "../lib/Values";
 import { ConfigurationCommand, ConfigValue } from "../lib/_Types";
 
 function configValueToString(value: ConfigValue): string {
@@ -74,21 +75,30 @@ export class ConfigurationCCError extends ZWaveError {
 	}
 }
 
-export function getParamInformationValueID(
-	parameter: number,
-	bitMask?: number,
-): ValueID {
-	return {
-		commandClass: CommandClasses.Configuration,
-		property: parameter,
-		propertyKey: bitMask,
-	};
-}
-
-const isParamInfoFromConfigValueId: ValueID = {
-	commandClass: CommandClasses.Configuration,
-	property: "isParamInformationFromConfig",
-};
+export const ConfigurationCCValues = Object.freeze({
+	...V.defineStaticCCValues(CommandClasses.Configuration, {
+		...V.staticProperty(
+			"isParamInformationFromConfig",
+			undefined, // meta
+			{ internal: true, supportsEndpoints: false }, // value options
+		),
+	}),
+
+	...V.defineDynamicCCValues(CommandClasses.Configuration, {
+		...V.dynamicPropertyAndKeyWithName(
+			"paramInformation",
+			// eslint-disable-next-line @typescript-eslint/no-unused-vars
+			(parameter: number, bitMask?: number) => parameter,
+			(parameter: number, bitMask?: number) => bitMask,
+			({ property, propertyKey }) =>
+				typeof property === "number" &&
+				(typeof propertyKey === "number" || propertyKey == undefined),
+			// Metadata is determined dynamically depending on other factors
+			undefined,
+			{ supportsEndpoints: false },
+		),
+	}),
+});
 
 export type ConfigurationCCAPISetOptions = {
 	parameter: number;
@@ -914,16 +924,10 @@ export class ConfigurationCCAPI extends CCAPI {
 
 @commandClass(CommandClasses.Configuration)
 @implementedVersion(4)
+@ccValues(ConfigurationCCValues)
 export class ConfigurationCC extends CommandClass {
 	declare ccCommand: ConfigurationCommand;
 
-	public constructor(host: ZWaveHost, options: CommandClassOptions) {
-		super(host, options);
-		this.registerValue("isParamInformationFromConfig" as any, {
-			internal: true,
-		});
-	}
-
 	public async interview(applHost: ZWaveApplicationHost): Promise<void> {
 		const node = this.getNode(applHost)!;
 		const endpoint = this.getEndpoint(applHost)!;
@@ -1149,8 +1153,10 @@ alters capabilities: ${!!properties.altersCapabilities}`;
 		applHost: ZWaveApplicationHost,
 	): boolean {
 		return (
-			this.getValueDB(applHost).getValue(isParamInfoFromConfigValueId) ===
-			true
+			this.getValue(
+				applHost,
+				ConfigurationCCValues.isParamInformationFromConfig,
+			) === true
 		);
 	}
 
@@ -1168,7 +1174,10 @@ alters capabilities: ${!!properties.altersCapabilities}`;
 		if (this.isParamInformationFromConfig(applHost)) return;
 
 		const valueDB = this.getValueDB(applHost);
-		const valueId = getParamInformationValueID(parameter, valueBitMask);
+		const valueId = ConfigurationCCValues.paramInformation(
+			parameter,
+			valueBitMask,
+		).id;
 		// Retrieve the base metadata
 		const metadata = this.getParamInformation(
 			applHost,
@@ -1190,11 +1199,14 @@ alters capabilities: ${!!properties.altersCapabilities}`;
 		parameter: number,
 		valueBitMask?: number,
 	): ConfigurationMetadata {
-		const valueDB = this.getValueDB(applHost);
-		const valueId = getParamInformationValueID(parameter, valueBitMask);
-		return (valueDB.getMetadata(valueId) ?? {
-			...ValueMetadata.Any,
-		}) as ConfigurationMetadata;
+		return (
+			this.getMetadata(
+				applHost,
+				ConfigurationCCValues.paramInformation(parameter, valueBitMask),
+			) ?? {
+				...ValueMetadata.Any,
+			}
+		);
 	}
 
 	/**
@@ -1301,7 +1313,11 @@ alters capabilities: ${!!properties.altersCapabilities}`;
 		}
 
 		// Allow overwriting the param info (mark it as unloaded)
-		valueDB.setValue(isParamInfoFromConfigValueId, false);
+		this.setValue(
+			applHost,
+			ConfigurationCCValues.isParamInformationFromConfig,
+			false,
+		);
 
 		for (const [param, info] of config.entries()) {
 			// We need to make the config information compatible with the
@@ -1342,7 +1358,11 @@ alters capabilities: ${!!properties.altersCapabilities}`;
 		}
 
 		// Remember that we loaded the param information from a config file
-		valueDB.setValue(isParamInfoFromConfigValueId, true);
+		this.setValue(
+			applHost,
+			ConfigurationCCValues.isParamInformationFromConfig,
+			true,
+		);
 	}
 
 	public translatePropertyKey(
diff --git a/packages/cc/src/cc/DoorLockCC.ts b/packages/cc/src/cc/DoorLockCC.ts
index c2dbf4c6c2b..9cb97b34c29 100644
--- a/packages/cc/src/cc/DoorLockCC.ts
+++ b/packages/cc/src/cc/DoorLockCC.ts
@@ -1,8 +1,4 @@
-import type {
-	MessageOrCCLogEntry,
-	MessageRecord,
-	ValueID,
-} from "@zwave-js/core/safe";
+import type { MessageOrCCLogEntry, MessageRecord } from "@zwave-js/core/safe";
 import {
 	CommandClasses,
 	Duration,
@@ -30,8 +26,6 @@ import {
 	throwWrongValueType,
 } from "../lib/API";
 import {
-	ccValue,
-	ccValueMetadata,
 	CommandClass,
 	gotDeserializationOptions,
 	type CCCommandOptions,
@@ -40,10 +34,13 @@ import {
 import {
 	API,
 	CCCommand,
+	ccValue,
+	ccValues,
 	commandClass,
 	expectedCCResponse,
 	implementedVersion,
 } from "../lib/CommandClassDecorators";
+import { V } from "../lib/Values";
 import {
 	DoorHandleStatus,
 	DoorLockCommand,
@@ -51,95 +48,141 @@ import {
 	DoorLockOperationType,
 } from "../lib/_Types";
 
-export function getTargetModeValueId(endpoint: number): ValueID {
-	return {
-		commandClass: CommandClasses["Door Lock"],
-		endpoint,
-		property: "targetMode",
-	};
-}
-
-export function getCurrentModeValueId(endpoint: number): ValueID {
-	return {
-		commandClass: CommandClasses["Door Lock"],
-		endpoint,
-		property: "currentMode",
-	};
-}
-
-export function getOperationTypeValueId(endpoint: number): ValueID {
-	return {
-		commandClass: CommandClasses["Door Lock"],
-		endpoint,
-		property: "operationType",
-	};
-}
-
-export function getLatchSupportedValueId(endpoint: number): ValueID {
-	return {
-		commandClass: CommandClasses["Door Lock"],
-		endpoint,
-		property: "latchSupported",
-	};
-}
-
-export function getBoltSupportedValueId(endpoint: number): ValueID {
-	return {
-		commandClass: CommandClasses["Door Lock"],
-		endpoint,
-		property: "boltSupported",
-	};
-}
-
-export function getDoorSupportedValueId(endpoint: number): ValueID {
-	return {
-		commandClass: CommandClasses["Door Lock"],
-		endpoint,
-		property: "doorSupported",
-	};
-}
-
-export function getLatchStatusValueId(endpoint: number): ValueID {
-	return {
-		commandClass: CommandClasses["Door Lock"],
-		endpoint,
-		property: "latchStatus",
-	};
-}
-function getLatchStatusValueMetadata(): ValueMetadata {
-	return {
-		...ValueMetadata.ReadOnly,
-		label: "The current status of the latch",
-	};
-}
-
-export function getBoltStatusValueId(endpoint: number): ValueID {
-	return {
-		commandClass: CommandClasses["Door Lock"],
-		endpoint,
-		property: "boltStatus",
-	};
-}
-function getBoltStatusValueMetadata(): ValueMetadata {
-	return {
-		...ValueMetadata.ReadOnly,
-		label: "The current status of the bolt",
-	};
-}
-
-export function getDoorStatusValueId(endpoint: number): ValueID {
-	return {
-		commandClass: CommandClasses["Door Lock"],
-		endpoint,
-		property: "doorStatus",
-	};
-}
-function getDoorStatusValueMetadata(): ValueMetadata {
-	return {
-		...ValueMetadata.ReadOnly,
-		label: "The current status of the door",
-	};
-}
+export const DoorLockCCValues = Object.freeze({
+	...V.defineStaticCCValues(CommandClasses["Door Lock"], {
+		...V.staticProperty("targetMode", {
+			...ValueMetadata.UInt8,
+			label: "Target lock mode",
+			states: enumValuesToMetadataStates(DoorLockMode),
+		} as const),
+
+		...V.staticProperty("currentMode", {
+			...ValueMetadata.UInt8,
+			label: "Current lock mode",
+			states: enumValuesToMetadataStates(DoorLockMode),
+		} as const),
+
+		...V.staticProperty(
+			"duration",
+			{
+				...ValueMetadata.ReadOnlyDuration,
+				label: "Remaining duration until target lock mode",
+			} as const,
+			{ minVersion: 3 } as const,
+		),
+
+		...V.staticProperty("supportedOutsideHandles", undefined, {
+			internal: true,
+			minVersion: 4,
+		}),
+		...V.staticProperty("outsideHandlesCanOpenDoorConfiguration", {
+			...ValueMetadata.Any,
+			label: "Which outside handles can open the door (configuration)",
+		} as const),
+		...V.staticProperty("outsideHandlesCanOpenDoor", {
+			...ValueMetadata.ReadOnly,
+			label: "Which outside handles can open the door (actual status)",
+		} as const),
+
+		...V.staticProperty("supportedInsideHandles", undefined, {
+			internal: true,
+			minVersion: 4,
+		}),
+		...V.staticProperty("insideHandlesCanOpenDoorConfiguration", {
+			...ValueMetadata.Any,
+			label: "Which inside handles can open the door (configuration)",
+		} as const),
+		...V.staticProperty("insideHandlesCanOpenDoor", {
+			...ValueMetadata.ReadOnly,
+			label: "Which inside handles can open the door (actual status)",
+		} as const),
+
+		...V.staticProperty("operationType", {
+			...ValueMetadata.UInt8,
+			label: "Lock operation type",
+			states: enumValuesToMetadataStates(DoorLockOperationType),
+		} as const),
+
+		...V.staticProperty("lockTimeoutConfiguration", {
+			...ValueMetadata.UInt16,
+			label: "Duration of timed mode in seconds",
+		} as const),
+		...V.staticProperty("lockTimeout", {
+			...ValueMetadata.ReadOnlyUInt16,
+			label: "Seconds until lock mode times out",
+		} as const),
+
+		...V.staticProperty("autoRelockSupported", undefined, {
+			internal: true,
+			minVersion: 4,
+		}),
+		...V.staticProperty(
+			"autoRelockTime",
+			{
+				...ValueMetadata.UInt16,
+				label: "Duration in seconds until lock returns to secure state",
+			} as const,
+			{ minVersion: 4 } as const,
+		),
+
+		...V.staticProperty("holdAndReleaseSupported", undefined, {
+			internal: true,
+			minVersion: 4,
+		}),
+		...V.staticProperty(
+			"holdAndReleaseTime",
+			{
+				...ValueMetadata.UInt16,
+				label: "Duration in seconds the latch stays retracted",
+			} as const,
+			{ minVersion: 4 } as const,
+		),
+
+		...V.staticProperty("twistAssistSupported", undefined, {
+			internal: true,
+			minVersion: 4,
+		}),
+		...V.staticProperty(
+			"twistAssist",
+			{
+				...ValueMetadata.Boolean,
+				label: "Twist Assist enabled",
+			} as const,
+			{ minVersion: 4 } as const,
+		),
+
+		...V.staticProperty("blockToBlockSupported", undefined, {
+			internal: true,
+			minVersion: 4,
+		}),
+		...V.staticProperty(
+			"blockToBlock",
+			{
+				...ValueMetadata.Boolean,
+				label: "Block-to-block functionality enabled",
+			} as const,
+			{ minVersion: 4 } as const,
+		),
+
+		...V.staticProperty("latchSupported", undefined, { internal: true }),
+		...V.staticProperty("latchStatus", {
+			...ValueMetadata.ReadOnly,
+			label: "Current status of the latch",
+		} as const),
+
+		...V.staticProperty("boltSupported", undefined, { internal: true }),
+		...V.staticProperty("boltStatus", {
+			...ValueMetadata.ReadOnly,
+			label: "Current status of the bolt",
+		} as const),
+
+		...V.staticProperty("doorSupported", undefined, { internal: true }),
+		...V.staticProperty("doorStatus", {
+			...ValueMetadata.ReadOnly,
+			label: "Current status of the door",
+		} as const),
+	}),
+});
 
 const configurationSetParameters = [
 	"operationType",
@@ -382,6 +425,7 @@ export class DoorLockCCAPI extends PhysicalCCAPI {
 
 @commandClass(CommandClasses["Door Lock"])
 @implementedVersion(4)
+@ccValues(DoorLockCCValues)
 export class DoorLockCC extends CommandClass {
 	declare ccCommand: DoorLockCommand;
 
@@ -395,7 +439,6 @@ export class DoorLockCC extends CommandClass {
 		).withOptions({
 			priority: MessagePriority.NodeQuery,
 		});
-		const valueDB = this.getValueDB(applHost);
 
 		applHost.controllerLog.logNode(node.id, {
 			endpoint: this.endpointIndex,
@@ -450,23 +493,23 @@ supports block to block:   ${resp.blockToBlockSupported}`;
 				latchSupported = resp.latchSupported;
 
 				// Update metadata of settable states
-				valueDB.setMetadata(getTargetModeValueId(this.endpointIndex), {
-					...ValueMetadata.UInt8,
+				const targetModeValue = DoorLockCCValues.targetMode;
+				this.setMetadata(applHost, targetModeValue, {
+					...targetModeValue.meta,
 					states: enumValuesToMetadataStates(
 						DoorLockMode,
 						resp.supportedDoorLockModes,
 					),
 				});
-				valueDB.setMetadata(
-					getOperationTypeValueId(this.endpointIndex),
-					{
-						...ValueMetadata.UInt8,
-						states: enumValuesToMetadataStates(
-							DoorLockOperationType,
-							resp.supportedOperationTypes,
-						),
-					},
-				);
+
+				const operationTypeValue = DoorLockCCValues.operationType;
+				this.setMetadata(applHost, operationTypeValue, {
+					...operationTypeValue.meta,
+					states: enumValuesToMetadataStates(
+						DoorLockOperationType,
+						resp.supportedOperationTypes,
+					),
+				});
 			} else {
 				hadCriticalTimeout = true;
 			}
@@ -474,28 +517,39 @@ supports block to block:   ${resp.blockToBlockSupported}`;
 
 		if (!hadCriticalTimeout) {
 			// Save support information for the status values
-			valueDB.setMetadata(
-				getDoorStatusValueId(this.endpointIndex),
-				doorSupported ? getDoorStatusValueMetadata() : undefined,
+			const doorStatusValue = DoorLockCCValues.doorStatus;
+			this.setMetadata(
+				applHost,
+				doorStatusValue,
+				doorSupported ? doorStatusValue.meta : undefined,
 			);
-			valueDB.setValue(
-				getDoorSupportedValueId(this.endpointIndex),
+			this.setValue(
+				applHost,
+				DoorLockCCValues.doorSupported,
 				doorSupported,
 			);
-			valueDB.setMetadata(
-				getLatchStatusValueId(this.endpointIndex),
-				latchSupported ? getLatchStatusValueMetadata() : undefined,
+
+			const latchStatusValue = DoorLockCCValues.latchStatus;
+			this.setMetadata(
+				applHost,
+				latchStatusValue,
+				latchSupported ? latchStatusValue.meta : undefined,
 			);
-			valueDB.setValue(
-				getLatchSupportedValueId(this.endpointIndex),
+			this.setValue(
+				applHost,
+				DoorLockCCValues.latchSupported,
 				latchSupported,
 			);
-			valueDB.setMetadata(
-				getBoltStatusValueId(this.endpointIndex),
-				boltSupported ? getBoltStatusValueMetadata() : undefined,
+
+			const boltStatusValue = DoorLockCCValues.boltStatus;
+			this.setMetadata(
+				applHost,
+				boltStatusValue,
+				boltSupported ? boltStatusValue.meta : undefined,
 			);
-			valueDB.setValue(
-				getBoltSupportedValueId(this.endpointIndex),
+			this.setValue(
+				applHost,
+				DoorLockCCValues.boltSupported,
 				boltSupported,
 			);
 		}
@@ -684,80 +738,65 @@ export class DoorLockCCOperationReport extends DoorLockCC {
 
 	public persistValues(applHost: ZWaveApplicationHost): boolean {
 		if (!super.persistValues(applHost)) return false;
-		const valueDB = this.getValueDB(applHost);
 
 		// Only store the door/bolt/latch status if the lock supports it
-		const supportsDoorStatus = !!valueDB.getValue(
-			getDoorSupportedValueId(this.endpointIndex),
+		const supportsDoorStatus = !!this.getValue(
+			applHost,
+			DoorLockCCValues.doorSupported,
 		);
 		if (supportsDoorStatus) {
-			const valueId = getDoorStatusValueId(this.endpointIndex);
-			valueDB.setValue(valueId, this.doorStatus);
+			this.setValue(
+				applHost,
+				DoorLockCCValues.doorStatus,
+				this.doorStatus,
+			);
 		}
-		const supportsBoltStatus = !!valueDB.getValue(
-			getBoltSupportedValueId(this.endpointIndex),
+		const supportsBoltStatus = !!this.getValue(
+			applHost,
+			DoorLockCCValues.boltSupported,
 		);
 		if (supportsBoltStatus) {
-			const valueId = getBoltStatusValueId(this.endpointIndex);
-			valueDB.setValue(valueId, this.boltStatus);
+			this.setValue(
+				applHost,
+				DoorLockCCValues.boltStatus,
+				this.boltStatus,
+			);
 		}
-		const supportsLatchStatus = !!valueDB.getValue(
-			getLatchSupportedValueId(this.endpointIndex),
+		const supportsLatchStatus = !!this.getValue(
+			applHost,
+			DoorLockCCValues.latchSupported,
 		);
 		if (supportsLatchStatus) {
-			const valueId = getLatchStatusValueId(this.endpointIndex);
-			valueDB.setValue(valueId, this.latchStatus);
+			this.setValue(
+				applHost,
+				DoorLockCCValues.latchStatus,
+				this.latchStatus,
+			);
 		}
 
 		return true;
 	}
 
-	@ccValue()
-	@ccValueMetadata({
-		...ValueMetadata.ReadOnlyUInt8,
-		label: "Current lock mode",
-		states: enumValuesToMetadataStates(DoorLockMode),
-	})
+	@ccValue(DoorLockCCValues.currentMode)
 	public readonly currentMode: DoorLockMode;
 
-	@ccValue()
-	@ccValueMetadata({
-		...ValueMetadata.UInt8,
-		label: "Target lock mode",
-		states: enumValuesToMetadataStates(DoorLockMode),
-	})
+	@ccValue(DoorLockCCValues.targetMode)
 	public readonly targetMode?: DoorLockMode;
 
-	@ccValue({ minVersion: 3 })
-	@ccValueMetadata({
-		...ValueMetadata.ReadOnlyDuration,
-		label: "Remaining duration until target lock mode",
-	})
+	@ccValue(DoorLockCCValues.duration)
 	public readonly duration?: Duration;
 
-	@ccValue()
-	@ccValueMetadata({
-		...ValueMetadata.ReadOnly,
-		label: "Which outside handles can open the door (actual status)",
-	})
+	@ccValue(DoorLockCCValues.outsideHandlesCanOpenDoor)
 	public readonly outsideHandlesCanOpenDoor: DoorHandleStatus;
 
-	@ccValue()
-	@ccValueMetadata({
-		...ValueMetadata.ReadOnly,
-		label: "Which inside handles can open the door (actual status)",
-	})
+	@ccValue(DoorLockCCValues.insideHandlesCanOpenDoor)
 	public readonly insideHandlesCanOpenDoor: DoorHandleStatus;
 
 	public readonly latchStatus?: "open" | "closed";
 	public readonly boltStatus?: "locked" | "unlocked";
 	public readonly doorStatus?: "open" | "closed";
 
-	@ccValue()
-	@ccValueMetadata({
-		...ValueMetadata.ReadOnlyNumber,
-		label: "Seconds until lock mode times out",
-	})
+	@ccValue(DoorLockCCValues.lockTimeout)
 	public readonly lockTimeout?: number; // in seconds
 
 	public toLogEntry(applHost: ZWaveApplicationHost): MessageOrCCLogEntry {
@@ -840,61 +879,28 @@ export class DoorLockCCConfigurationReport extends DoorLockCC {
 		}
 	}
 
-	@ccValue()
-	@ccValueMetadata({
-		...ValueMetadata.UInt8,
-		label: "Lock operation type",
-		states: enumValuesToMetadataStates(DoorLockOperationType),
-	})
+	@ccValue(DoorLockCCValues.operationType)
 	public readonly operationType: DoorLockOperationType;
 
-	@ccValue()
-	@ccValueMetadata({
-		...ValueMetadata.Any,
-		label: "Which outside handles can open the door (configuration)",
-	})
+	@ccValue(DoorLockCCValues.outsideHandlesCanOpenDoorConfiguration)
 	public readonly outsideHandlesCanOpenDoorConfiguration: DoorHandleStatus;
 
-	@ccValue()
-	@ccValueMetadata({
-		...ValueMetadata.Any,
-		label: "Which inside handles can open the door (configuration)",
-	})
+	@ccValue(DoorLockCCValues.insideHandlesCanOpenDoorConfiguration)
 	public readonly insideHandlesCanOpenDoorConfiguration: DoorHandleStatus;
 
-	@ccValue()
-	@ccValueMetadata({
-		...ValueMetadata.UInt16,
-		label: "Duration of timed mode in seconds",
-	})
+	@ccValue(DoorLockCCValues.lockTimeoutConfiguration)
 	public readonly lockTimeoutConfiguration?: number;
 
-	@ccValue({ minVersion: 4 })
-	@ccValueMetadata({
-		...ValueMetadata.UInt16,
-		label: "Duration in seconds until lock returns to secure state",
-	})
+	@ccValue(DoorLockCCValues.autoRelockTime)
 	public readonly autoRelockTime?: number;
 
-	@ccValue({ minVersion: 4 })
-	@ccValueMetadata({
-		...ValueMetadata.UInt16,
-		label: "Duration in seconds the latch stays retracted",
-	})
+	@ccValue(DoorLockCCValues.holdAndReleaseTime)
 	public readonly holdAndReleaseTime?: number;
 
-	@ccValue({ minVersion: 4 })
-	@ccValueMetadata({
-		...ValueMetadata.Boolean,
-		label: "Twist Assist enabled",
-	})
+	@ccValue(DoorLockCCValues.twistAssist)
 	public readonly twistAssist?: boolean;
 
-	@ccValue({ minVersion: 4 })
-	@ccValueMetadata({
-		...ValueMetadata.Boolean,
-		label: "Block-to-block functionality enabled",
-	})
+	@ccValue(DoorLockCCValues.blockToBlock)
 	public readonly blockToBlock?: boolean;
 
 	public toLogEntry(applHost: ZWaveApplicationHost): MessageOrCCLogEntry {
@@ -1156,26 +1162,26 @@ export class DoorLockCCCapabilitiesReport extends DoorLockCC {
 	public readonly supportedOperationTypes: readonly DoorLockOperationType[];
 	public readonly supportedDoorLockModes: readonly DoorLockMode[];
 
-	@ccValue({ internal: true, minVersion: 4 })
+	@ccValue(DoorLockCCValues.supportedOutsideHandles)
 	public readonly supportedOutsideHandles: DoorHandleStatus;
 
-	@ccValue({ internal: true, minVersion: 4 })
+	@ccValue(DoorLockCCValues.supportedInsideHandles)
 	public readonly supportedInsideHandles: DoorHandleStatus;
 
 	public readonly latchSupported: boolean;
 	public readonly boltSupported: boolean;
 	public readonly doorSupported: boolean;
 
-	@ccValue({ internal: true, minVersion: 4 })
+	@ccValue(DoorLockCCValues.autoRelockSupported)
 	public readonly autoRelockSupported: boolean;
 
-	@ccValue({ internal: true, minVersion: 4 })
+	@ccValue(DoorLockCCValues.holdAndReleaseSupported)
 	public readonly holdAndReleaseSupported: boolean;
 
-	@ccValue({ internal: true, minVersion: 4 })
+	@ccValue(DoorLockCCValues.twistAssistSupported)
 	public readonly twistAssistSupported: boolean;
 
-	@ccValue({ internal: true, minVersion: 4 })
+	@ccValue(DoorLockCCValues.blockToBlockSupported)
 	public readonly blockToBlockSupported: boolean;
 
 	public toLogEntry(applHost: ZWaveApplicationHost): MessageOrCCLogEntry {
diff --git a/packages/cc/src/cc/DoorLockLoggingCC.ts b/packages/cc/src/cc/DoorLockLoggingCC.ts
index 538defee54d..a1b8fa5108b 100644
--- a/packages/cc/src/cc/DoorLockLoggingCC.ts
+++ b/packages/cc/src/cc/DoorLockLoggingCC.ts
@@ -13,7 +13,6 @@ import { isPrintableASCII, num2hex } from "@zwave-js/shared/safe";
 import { validateArgs } from "@zwave-js/transformers";
 import { CCAPI, PhysicalCCAPI } from "../lib/API";
 import {
-	ccValue,
 	CommandClass,
 	gotDeserializationOptions,
 	type CCCommandOptions,
@@ -22,10 +21,13 @@ import {
 import {
 	API,
 	CCCommand,
+	ccValue,
+	ccValues,
 	commandClass,
 	expectedCCResponse,
 	implementedVersion,
 } from "../lib/CommandClassDecorators";
+import { V } from "../lib/Values";
 import {
 	DoorLockLoggingCommand,
 	DoorLockLoggingEventType,
@@ -93,6 +95,12 @@ const eventTypeLabel = {
 
 const LATEST_RECORD_NUMBER_KEY = 0;
 
+export const DoorLockLoggingCCValues = Object.freeze({
+	...V.defineStaticCCValues(CommandClasses["Door Lock Logging"], {
+		...V.staticProperty("recordsCount", undefined, { internal: true }),
+	}),
+});
+
 @API(CommandClasses["Door Lock Logging"])
 export class DoorLockLoggingCCAPI extends PhysicalCCAPI {
 	public supportsCommand(cmd: DoorLockLoggingCommand): Maybe<boolean> {
@@ -150,6 +158,7 @@ export class DoorLockLoggingCCAPI extends PhysicalCCAPI {
 
 @commandClass(CommandClasses["Door Lock Logging"])
 @implementedVersion(1)
+@ccValues(DoorLockLoggingCCValues)
 export class DoorLockLoggingCC extends CommandClass {
 	declare ccCommand: DoorLockLoggingCommand;
 
@@ -219,7 +228,7 @@ export class DoorLockLoggingCCRecordsSupportedReport extends DoorLockLoggingCC {
 		this.recordsCount = this.payload[0];
 	}
 
-	@ccValue({ internal: true })
+	@ccValue(DoorLockLoggingCCValues.recordsCount)
 	public readonly recordsCount: number;
 
 	public toLogEntry(applHost: ZWaveApplicationHost): MessageOrCCLogEntry {
diff --git a/packages/cc/src/cc/EntryControlCC.ts b/packages/cc/src/cc/EntryControlCC.ts
index bd555ceb3e2..3f5dd6f19f5 100644
--- a/packages/cc/src/cc/EntryControlCC.ts
+++ b/packages/cc/src/cc/EntryControlCC.ts
@@ -2,7 +2,6 @@ import type {
 	Maybe,
 	MessageOrCCLogEntry,
 	MessageRecord,
-	ValueID,
 } from "@zwave-js/core/safe";
 import {
 	CommandClasses,
@@ -26,8 +25,6 @@ import {
 	throwWrongValueType,
 } from "../lib/API";
 import {
-	ccValue,
-	ccValueMetadata,
 	CommandClass,
 	gotDeserializationOptions,
 	type CCCommandOptions,
@@ -36,31 +33,51 @@ import {
 import {
 	API,
 	CCCommand,
+	ccValue,
+	ccValues,
 	commandClass,
 	expectedCCResponse,
 	implementedVersion,
 } from "../lib/CommandClassDecorators";
+import { V } from "../lib/Values";
 import {
 	EntryControlCommand,
 	EntryControlDataTypes,
 	EntryControlEventTypes,
 } from "../lib/_Types";
 
-function getValueID(property: string, endpoint: number): ValueID {
-	return {
-		commandClass: CommandClasses["Entry Control"],
-		endpoint,
-		property: property,
-	};
-}
-
-export function getKeyCacheSizeStateValueID(endpoint: number): ValueID {
-	return getValueID("keyCacheSize", endpoint);
-}
-
-export function getKeyCacheTimeoutStateValueID(endpoint: number): ValueID {
-	return getValueID("keyCacheTimeout", endpoint);
-}
+export const EntryControlCCValues = Object.freeze({
+	...V.defineStaticCCValues(CommandClasses["Entry Control"], {
+		...V.staticProperty("keyCacheSize", {
+			...ValueMetadata.UInt8,
+			label: "Key cache size",
+			description:
+				"Number of character that must be stored before sending",
+			min: 1,
+			max: 32,
+		} as const),
+
+		...V.staticProperty("keyCacheTimeout", {
+			...ValueMetadata.UInt8,
+			label: "Key cache timeout",
+			unit: "seconds",
+			description:
+				"How long the key cache must wait for additional characters",
+			min: 1,
+			max: 10,
+		} as const),
+
+		...V.staticProperty("supportedDataTypes", undefined, {
+			internal: true,
+		}),
+		...V.staticProperty("supportedEventTypes", undefined, {
+			internal: true,
+		}),
+		...V.staticProperty("supportedKeys", undefined, {
+			internal: true,
+		}),
+	}),
+});
 
 @API(CommandClasses["Entry Control"])
 export class EntryControlCCAPI extends CCAPI {
@@ -188,7 +205,7 @@ export class EntryControlCCAPI extends CCAPI {
 			keyCacheTimeout = value;
 
 			const oldKeyCacheSize = this.tryGetValueDB()?.getValue<number>(
-				getKeyCacheSizeStateValueID(this.endpoint.index),
+				EntryControlCCValues.keyCacheSize.endpoint(this.endpoint.index),
 			);
 			if (oldKeyCacheSize == undefined) {
 				throw new ZWaveError(
@@ -215,6 +232,7 @@ export class EntryControlCCAPI extends CCAPI {
 
 @commandClass(CommandClasses["Entry Control"])
 @implementedVersion(1)
+@ccValues(EntryControlCCValues)
 export class EntryControlCC extends CommandClass {
 	declare ccCommand: EntryControlCommand;
 
@@ -419,7 +437,7 @@ export class EntryControlCCKeySupportedReport extends EntryControlCC {
 		this.supportedKeys = parseBitMask(this.payload.slice(1, 1 + length), 0);
 	}
 
-	@ccValue({ internal: true })
+	@ccValue(EntryControlCCValues.supportedKeys)
 	public readonly supportedKeys: readonly number[];
 
 	public toLogEntry(applHost: ZWaveApplicationHost): MessageOrCCLogEntry {
@@ -480,23 +498,18 @@ export class EntryControlCCEventSupportedReport extends EntryControlCC {
 
 	public persistValues(applHost: ZWaveApplicationHost): boolean {
 		if (!super.persistValues(applHost)) return false;
-		const valueDB = this.getValueDB(applHost);
 
 		// Store min/max cache size and timeout as metadata
-		const keyCacheSizeValueId = getKeyCacheSizeStateValueID(
-			this.endpointIndex,
-		);
-		valueDB.setMetadata(keyCacheSizeValueId, {
-			...ValueMetadata.UInt8,
+		const keyCacheSizeValue = EntryControlCCValues.keyCacheSize;
+		this.setMetadata(applHost, keyCacheSizeValue, {
+			...keyCacheSizeValue.meta,
 			min: this.minKeyCacheSize,
 			max: this.maxKeyCacheSize,
 		});
 
-		const keyCacheTimeoutValueId = getKeyCacheTimeoutStateValueID(
-			this.endpointIndex,
-		);
-		valueDB.setMetadata(keyCacheTimeoutValueId, {
-			...ValueMetadata.UInt8,
+		const keyCacheTimeoutValue = EntryControlCCValues.keyCacheTimeout;
+		this.setMetadata(applHost, keyCacheTimeoutValue, {
+			...keyCacheTimeoutValue.meta,
 			min: this.minKeyCacheTimeout,
 			max: this.maxKeyCacheTimeout,
 		});
@@ -504,10 +517,10 @@ export class EntryControlCCEventSupportedReport extends EntryControlCC {
 		return true;
 	}
 
-	@ccValue({ internal: true })
+	@ccValue(EntryControlCCValues.supportedDataTypes)
 	public readonly supportedDataTypes: readonly EntryControlDataTypes[];
 
-	@ccValue({ internal: true })
+	@ccValue(EntryControlCCValues.supportedEventTypes)
 	public readonly supportedEventTypes: readonly EntryControlEventTypes[];
 
 	public readonly minKeyCacheSize: number;
@@ -553,26 +566,10 @@ export class EntryControlCCConfigurationReport extends EntryControlCC {
 		this.keyCacheTimeout = this.payload[1];
 	}
 
-	@ccValue()
-	@ccValueMetadata({
-		...ValueMetadata.UInt8,
-		label: "Key cache size",
-		description: "Number of character that must be stored before sending",
-		min: 1,
-		max: 32,
-	})
+	@ccValue(EntryControlCCValues.keyCacheSize)
 	public readonly keyCacheSize: number;
 
-	@ccValue()
-	@ccValueMetadata({
-		...ValueMetadata.UInt8,
-		label: "Key cache timeout",
-		unit: "seconds",
-		description:
-			"How long the key cache must wait for additional characters",
-		min: 1,
-		max: 10,
-	})
+	@ccValue(EntryControlCCValues.keyCacheTimeout)
 	public readonly keyCacheTimeout: number;
 
 	public toLogEntry(applHost: ZWaveApplicationHost): MessageOrCCLogEntry {
diff --git a/packages/cc/src/cc/FirmwareUpdateMetaDataCC.ts b/packages/cc/src/cc/FirmwareUpdateMetaDataCC.ts
index 36a92042aa2..fd6c8ba8290 100644
--- a/packages/cc/src/cc/FirmwareUpdateMetaDataCC.ts
+++ b/packages/cc/src/cc/FirmwareUpdateMetaDataCC.ts
@@ -1,4 +1,4 @@
-import type { MessageRecord, ValueID } from "@zwave-js/core/safe";
+import type { MessageRecord } from "@zwave-js/core/safe";
 import {
 	CommandClasses,
 	CRC16_CCITT,
@@ -19,7 +19,6 @@ import {
 import { validateArgs } from "@zwave-js/transformers";
 import { PhysicalCCAPI } from "../lib/API";
 import {
-	ccValue,
 	CommandClass,
 	gotDeserializationOptions,
 	type CCCommandOptions,
@@ -28,10 +27,13 @@ import {
 import {
 	API,
 	CCCommand,
+	ccValue,
+	ccValues,
 	commandClass,
 	expectedCCResponse,
 	implementedVersion,
 } from "../lib/CommandClassDecorators";
+import { V } from "../lib/Values";
 import {
 	FirmwareDownloadStatus,
 	FirmwareUpdateActivationStatus,
@@ -43,12 +45,13 @@ import {
 // @noSetValueAPI There are no values to set here
 // @noInterview   The "interview" is part of the update process
 
-function getSupportsActivationValueId(): ValueID {
-	return {
-		commandClass: CommandClasses["Firmware Update Meta Data"],
-		property: "supportsActivation",
-	};
-}
+export const FirmwareUpdateMetaDataCCValues = Object.freeze({
+	...V.defineStaticCCValues(CommandClasses["Firmware Update Meta Data"], {
+		...V.staticProperty("supportsActivation", undefined, {
+			internal: true,
+		}),
+	}),
+});
 
 @API(CommandClasses["Firmware Update Meta Data"])
 export class FirmwareUpdateMetaDataCCAPI extends PhysicalCCAPI {
@@ -65,7 +68,9 @@ export class FirmwareUpdateMetaDataCCAPI extends PhysicalCCAPI {
 					this.version >= 4 &&
 					(this.version < 7 ||
 						this.tryGetValueDB()?.getValue(
-							getSupportsActivationValueId(),
+							FirmwareUpdateMetaDataCCValues.supportsActivation.endpoint(
+								this.endpoint.index,
+							),
 						) === true)
 				);
 
@@ -191,6 +196,7 @@ export class FirmwareUpdateMetaDataCCAPI extends PhysicalCCAPI {
 
 @commandClass(CommandClasses["Firmware Update Meta Data"])
 @implementedVersion(7)
+@ccValues(FirmwareUpdateMetaDataCCValues)
 export class FirmwareUpdateMetaDataCC extends CommandClass {
 	declare ccCommand: FirmwareUpdateMetaDataCommand;
 }
@@ -248,11 +254,9 @@ export class FirmwareUpdateMetaDataCCMetaDataReport extends FirmwareUpdateMetaDa
 	public readonly maxFragmentSize?: number;
 	public readonly additionalFirmwareIDs: readonly number[] = [];
 	public readonly hardwareVersion?: number;
-
-	@ccValue({ internal: true })
 	public readonly continuesToFunction: Maybe<boolean> = unknownBoolean;
 
-	@ccValue({ internal: true })
+	@ccValue(FirmwareUpdateMetaDataCCValues.supportsActivation)
 	public readonly supportsActivation: Maybe<boolean> = unknownBoolean;
 
 	public toLogEntry(applHost: ZWaveApplicationHost): MessageOrCCLogEntry {
diff --git a/packages/cc/src/cc/HumidityControlModeCC.ts b/packages/cc/src/cc/HumidityControlModeCC.ts
index 5182dec4de5..d8f3ad3f1ce 100644
--- a/packages/cc/src/cc/HumidityControlModeCC.ts
+++ b/packages/cc/src/cc/HumidityControlModeCC.ts
@@ -1,4 +1,3 @@
-import type { ValueID } from "@zwave-js/core/safe";
 import {
 	CommandClasses,
 	enumValuesToMetadataStates,
@@ -24,8 +23,6 @@ import {
 	throwWrongValueType,
 } from "../lib/API";
 import {
-	ccValue,
-	ccValueMetadata,
 	CommandClass,
 	gotDeserializationOptions,
 	type CCCommandOptions,
@@ -34,12 +31,27 @@ import {
 import {
 	API,
 	CCCommand,
+	ccValue,
+	ccValues,
 	commandClass,
 	expectedCCResponse,
 	implementedVersion,
 } from "../lib/CommandClassDecorators";
+import { V } from "../lib/Values";
 import { HumidityControlMode, HumidityControlModeCommand } from "../lib/_Types";
 
+export const HumidityControlModeCCValues = Object.freeze({
+	...V.defineStaticCCValues(CommandClasses["Humidity Control Mode"], {
+		...V.staticProperty("mode", {
+			...ValueMetadata.UInt8,
+			states: enumValuesToMetadataStates(HumidityControlMode),
+			label: "Humidity control mode",
+		} as const),
+
+		...V.staticProperty("supportedModes", undefined, { internal: true }),
+	}),
+});
+
 @API(CommandClasses["Humidity Control Mode"])
 export class HumidityControlModeCCAPI extends CCAPI {
 	public supportsCommand(cmd: HumidityControlModeCommand): Maybe<boolean> {
@@ -146,6 +158,7 @@ export class HumidityControlModeCCAPI extends CCAPI {
 
 @commandClass(CommandClasses["Humidity Control Mode"])
 @implementedVersion(2)
+@ccValues(HumidityControlModeCCValues)
 export class HumidityControlModeCC extends CommandClass {
 	declare ccCommand: HumidityControlModeCommand;
 
@@ -282,19 +295,11 @@ export class HumidityControlModeCCReport extends HumidityControlModeCC {
 		super(host, options);
 
 		validatePayload(this.payload.length >= 1);
-		this._mode = this.payload[0] & 0b1111;
+		this.mode = this.payload[0] & 0b1111;
 	}
 
-	private _mode: HumidityControlMode;
-	@ccValue()
-	@ccValueMetadata({
-		...ValueMetadata.UInt8,
-		states: enumValuesToMetadataStates(HumidityControlMode),
-		label: "Humidity control mode",
-	})
-	public get mode(): HumidityControlMode {
-		return this._mode;
-	}
+	@ccValue(HumidityControlModeCCValues.mode)
+	public readonly mode: HumidityControlMode;
 
 	public toLogEntry(applHost: ZWaveApplicationHost): MessageOrCCLogEntry {
 		return {
@@ -331,17 +336,11 @@ export class HumidityControlModeCCSupportedReport extends HumidityControlModeCC
 
 	public persistValues(applHost: ZWaveApplicationHost): boolean {
 		if (!super.persistValues(applHost)) return false;
-		const valueDB = this.getValueDB(applHost);
 
 		// Use this information to create the metadata for the mode property
-		const valueId: ValueID = {
-			commandClass: this.ccId,
-			endpoint: this.endpointIndex,
-			property: "mode",
-		};
-		// Only update the dynamic part
-		valueDB.setMetadata(valueId, {
-			...ValueMetadata.UInt8,
+		const modeValue = HumidityControlModeCCValues.mode;
+		this.setMetadata(applHost, modeValue, {
+			...modeValue.meta,
 			states: enumValuesToMetadataStates(
 				HumidityControlMode,
 				this._supportedModes,
@@ -352,7 +351,7 @@ export class HumidityControlModeCCSupportedReport extends HumidityControlModeCC
 	}
 
 	private _supportedModes: HumidityControlMode[];
-	@ccValue({ internal: true })
+	@ccValue(HumidityControlModeCCValues.supportedModes)
 	public get supportedModes(): readonly HumidityControlMode[] {
 		return this._supportedModes;
 	}
diff --git a/packages/cc/src/cc/HumidityControlOperatingStateCC.ts b/packages/cc/src/cc/HumidityControlOperatingStateCC.ts
index 886108cad7c..fc3d39bbb96 100644
--- a/packages/cc/src/cc/HumidityControlOperatingStateCC.ts
+++ b/packages/cc/src/cc/HumidityControlOperatingStateCC.ts
@@ -16,23 +16,39 @@ import {
 	throwUnsupportedProperty,
 } from "../lib/API";
 import {
-	ccValue,
-	ccValueMetadata,
 	CommandClass,
 	type CommandClassDeserializationOptions,
 } from "../lib/CommandClass";
 import {
 	API,
 	CCCommand,
+	ccValue,
+	ccValues,
 	commandClass,
 	expectedCCResponse,
 	implementedVersion,
 } from "../lib/CommandClassDecorators";
+import { V } from "../lib/Values";
 import {
 	HumidityControlOperatingState,
 	HumidityControlOperatingStateCommand,
 } from "../lib/_Types";
 
+export const HumidityControlOperatingStateCCValues = Object.freeze({
+	...V.defineStaticCCValues(
+		CommandClasses["Humidity Control Operating State"],
+		{
+			...V.staticProperty("state", {
+				...ValueMetadata.ReadOnlyUInt8,
+				states: enumValuesToMetadataStates(
+					HumidityControlOperatingState,
+				),
+				label: "Humidity control operating state",
+			} as const),
+		},
+	),
+});
+
 @API(CommandClasses["Humidity Control Operating State"])
 export class HumidityControlOperatingStateCCAPI extends CCAPI {
 	public supportsCommand(
@@ -80,6 +96,7 @@ export class HumidityControlOperatingStateCCAPI extends CCAPI {
 
 @commandClass(CommandClasses["Humidity Control Operating State"])
 @implementedVersion(1)
+@ccValues(HumidityControlOperatingStateCCValues)
 export class HumidityControlOperatingStateCC extends CommandClass {
 	declare ccCommand: HumidityControlOperatingStateCommand;
 
@@ -140,19 +157,11 @@ export class HumidityControlOperatingStateCCReport extends HumidityControlOperat
 		super(host, options);
 
 		validatePayload(this.payload.length >= 1);
-		this._state = this.payload[0] & 0b1111;
+		this.state = this.payload[0] & 0b1111;
 	}
 
-	private _state: HumidityControlOperatingState;
-	@ccValue()
-	@ccValueMetadata({
-		...ValueMetadata.ReadOnlyUInt8,
-		states: enumValuesToMetadataStates(HumidityControlOperatingState),
-		label: "Humidity control operating state",
-	})
-	public get state(): HumidityControlOperatingState {
-		return this._state;
-	}
+	@ccValue(HumidityControlOperatingStateCCValues.state)
+	public readonly state: HumidityControlOperatingState;
 
 	public toLogEntry(applHost: ZWaveApplicationHost): MessageOrCCLogEntry {
 		return {
diff --git a/packages/cc/src/cc/HumidityControlSetpointCC.ts b/packages/cc/src/cc/HumidityControlSetpointCC.ts
index 203926012c1..ceca3d23399 100644
--- a/packages/cc/src/cc/HumidityControlSetpointCC.ts
+++ b/packages/cc/src/cc/HumidityControlSetpointCC.ts
@@ -1,5 +1,5 @@
 import type { ConfigManager, Scale } from "@zwave-js/config";
-import type { ValueID, ValueMetadataNumeric } from "@zwave-js/core/safe";
+import type { ValueMetadataNumeric } from "@zwave-js/core/safe";
 import {
 	CommandClasses,
 	encodeFloatWithScale,
@@ -26,7 +26,6 @@ import {
 	throwWrongValueType,
 } from "../lib/API";
 import {
-	ccValue,
 	CommandClass,
 	gotDeserializationOptions,
 	type CCCommandOptions,
@@ -35,10 +34,13 @@ import {
 import {
 	API,
 	CCCommand,
+	ccValue,
+	ccValues,
 	commandClass,
 	expectedCCResponse,
 	implementedVersion,
 } from "../lib/CommandClassDecorators";
+import { V } from "../lib/Values";
 import {
 	HumidityControlSetpointCapabilities,
 	HumidityControlSetpointCommand,
@@ -46,6 +48,50 @@ import {
 	HumidityControlSetpointValue,
 } from "../lib/_Types";
 
+export const HumidityControlSetpointCCValues = Object.freeze({
+	...V.defineStaticCCValues(CommandClasses["Humidity Control Setpoint"], {
+		...V.staticProperty("supportedSetpointTypes", undefined, {
+			internal: true,
+		}),
+	}),
+
+	...V.defineDynamicCCValues(CommandClasses["Humidity Control Setpoint"], {
+		...V.dynamicPropertyAndKeyWithName(
+			"setpoint",
+			"setpoint",
+			(setpointType: number) => setpointType,
+			({ property, propertyKey }) =>
+				property === "setpoint" && typeof propertyKey === "number",
+			(setpointType: number) =>
+				({
+					// This is the base metadata that will be extended on the fly
+					...ValueMetadata.Number,
+					label: `Setpoint (${getEnumMemberName(
+						HumidityControlSetpointType,
+						setpointType,
+					)})`,
+					ccSpecific: { setpointType },
+				} as const),
+		),
+
+		...V.dynamicPropertyAndKeyWithName(
+			"setpointScale",
+			"setpointScale",
+			(setpointType: number) => setpointType,
+			({ property, propertyKey }) =>
+				property === "setpointScale" && typeof propertyKey === "number",
+			(setpointType: number) =>
+				({
+					...ValueMetadata.ReadOnlyUInt8,
+					label: `Setpoint scale (${getEnumMemberName(
+						HumidityControlSetpointType,
+						setpointType,
+					)})`,
+				} as const),
+		),
+	}),
+});
+
 const humidityControlSetpointScaleName = "humidity";
 function getScale(configManager: ConfigManager, scale: number): Scale {
 	return configManager.lookupNamedScale(
@@ -57,35 +103,6 @@ function getSetpointUnit(configManager: ConfigManager, scale: number): string {
 	return getScale(configManager, scale).unit ?? "";
 }
 
-function getSupportedSetpointTypesValueID(endpoint: number): ValueID {
-	return {
-		commandClass: CommandClasses["Humidity Control Setpoint"],
-		property: "supportedSetpointTypes",
-		endpoint,
-	};
-}
-
-function getSetpointValueID(endpoint: number, setpointType: number): ValueID {
-	return {
-		commandClass: CommandClasses["Humidity Control Setpoint"],
-		endpoint,
-		property: "setpoint",
-		propertyKey: setpointType,
-	};
-}
-
-function getSetpointScaleValueID(
-	endpoint: number,
-	setpointType: number,
-): ValueID {
-	return {
-		commandClass: CommandClasses["Humidity Control Setpoint"],
-		endpoint,
-		property: "setpointScale",
-		propertyKey: setpointType,
-	};
-}
-
 @API(CommandClasses["Humidity Control Setpoint"])
 export class HumidityControlSetpointCCAPI extends CCAPI {
 	public supportsCommand(
@@ -121,9 +138,11 @@ export class HumidityControlSetpointCCAPI extends CCAPI {
 			throwWrongValueType(this.ccId, property, "number", typeof value);
 		}
 
-		const preferredScale = this.tryGetValueDB()?.getValue<number>(
-			getSetpointScaleValueID(this.endpoint.index, propertyKey),
-		);
+		const scaleValueId = HumidityControlSetpointCCValues.setpointScale(
+			propertyKey,
+		).endpoint(this.endpoint.index);
+		const preferredScale =
+			this.tryGetValueDB()?.getValue<number>(scaleValueId);
 		await this.set(propertyKey, value, preferredScale ?? 0);
 
 		if (this.isSinglecast()) {
@@ -285,6 +304,7 @@ export class HumidityControlSetpointCCAPI extends CCAPI {
 
 @commandClass(CommandClasses["Humidity Control Setpoint"])
 @implementedVersion(2)
+@ccValues(HumidityControlSetpointCCValues)
 export class HumidityControlSetpointCC extends CommandClass {
 	declare ccCommand: HumidityControlSetpointCommand;
 
@@ -313,7 +333,6 @@ export class HumidityControlSetpointCC extends CommandClass {
 		).withOptions({
 			priority: MessagePriority.NodeQuery,
 		});
-		const valueDB = this.getValueDB(applHost);
 
 		applHost.controllerLog.logNode(node.id, {
 			endpoint: this.endpointIndex,
@@ -377,17 +396,16 @@ ${setpointScaleSupported
 					message: logMessage,
 					direction: "inbound",
 				});
-				const scaleValueId = getSetpointScaleValueID(
-					this.endpointIndex,
-					type,
-				);
+
+				const scaleValue =
+					HumidityControlSetpointCCValues.setpointScale(type);
 				const states: Record<number, string> = {};
 				for (const scale of setpointScaleSupported) {
 					if (scale.unit) states[scale.key] = scale.unit;
 				}
-				valueDB.setMetadata(scaleValueId, {
-					...ValueMetadata.ReadOnlyUInt8,
-					states: states,
+				this.setMetadata(applHost, scaleValue, {
+					...scaleValue.meta,
+					states,
 				});
 			}
 			const setpointCaps = await api.getCapabilities(type);
@@ -428,11 +446,11 @@ maximum value: ${setpointCaps.maxValue} ${maxValueUnit}`;
 		).withOptions({
 			priority: MessagePriority.NodeQuery,
 		});
-		const valueDB = this.getValueDB(applHost);
 
 		const setpointTypes: HumidityControlSetpointType[] =
-			valueDB.getValue(
-				getSupportedSetpointTypesValueID(this.endpointIndex),
+			this.getValue(
+				applHost,
+				HumidityControlSetpointCCValues.supportedSetpointTypes,
 			) ?? [];
 
 		// Query each setpoint's current value
@@ -548,35 +566,29 @@ export class HumidityControlSetpointCCReport extends HumidityControlSetpointCC {
 
 		const scale = getScale(applHost.configManager, this.scale);
 
-		const valueDB = this.getValueDB(applHost);
-		const setpointValueId = getSetpointValueID(
-			this.endpointIndex,
-			this._type,
+		const setpointValue = HumidityControlSetpointCCValues.setpoint(
+			this.type,
+		);
+		const existingMetadata = this.getMetadata<ValueMetadataNumeric>(
+			applHost,
+			setpointValue,
 		);
+
 		// Update the metadata when it is missing or the unit has changed
-		if (
-			(
-				valueDB.getMetadata(setpointValueId) as
-					| ValueMetadataNumeric
-					| undefined
-			)?.unit !== scale.unit
-		) {
-			valueDB.setMetadata(setpointValueId, {
-				...ValueMetadata.Number,
+		if (existingMetadata?.unit !== scale.unit) {
+			this.setMetadata(applHost, setpointValue, {
+				...(existingMetadata ?? setpointValue.meta),
 				unit: scale.unit,
-				ccSpecific: {
-					setpointType: this._type,
-				},
 			});
 		}
-		valueDB.setValue(setpointValueId, this._value);
+		this.setValue(applHost, setpointValue, this._value);
 
 		// Remember the device-preferred setpoint scale so it can be used in SET commands
-		const scaleValueId = getSetpointScaleValueID(
-			this.endpointIndex,
-			this._type,
+		this.setValue(
+			applHost,
+			HumidityControlSetpointCCValues.setpointScale(this.type),
+			this.scale,
 		);
-		valueDB.setValue(scaleValueId, this.scale);
 		return true;
 	}
 
@@ -672,17 +684,14 @@ export class HumidityControlSetpointCCSupportedReport extends HumidityControlSet
 		super(host, options);
 
 		validatePayload(this.payload.length >= 1);
-		this._supportedSetpointTypes = parseBitMask(
+		this.supportedSetpointTypes = parseBitMask(
 			this.payload,
 			HumidityControlSetpointType["N/A"],
 		);
 	}
 
-	private _supportedSetpointTypes: HumidityControlSetpointType[];
-	@ccValue({ internal: true })
-	public get supportedSetpointTypes(): readonly HumidityControlSetpointType[] {
-		return this._supportedSetpointTypes;
-	}
+	@ccValue(HumidityControlSetpointCCValues.supportedSetpointTypes)
+	public readonly supportedSetpointTypes: readonly HumidityControlSetpointType[];
 
 	public toLogEntry(applHost: ZWaveApplicationHost): MessageOrCCLogEntry {
 		return {
@@ -808,20 +817,18 @@ export class HumidityControlSetpointCCCapabilitiesReport extends HumidityControl
 
 	public persistValues(applHost: ZWaveApplicationHost): boolean {
 		if (!super.persistValues(applHost)) return false;
-		const valueDB = this.getValueDB(applHost);
 
 		// Predefine the metadata
-		const valueId = getSetpointValueID(this.endpointIndex, this.type);
-		valueDB.setMetadata(valueId, {
-			...ValueMetadata.Number,
+		const setpointValue = HumidityControlSetpointCCValues.setpoint(
+			this.type,
+		);
+		this.setMetadata(applHost, setpointValue, {
+			...setpointValue.meta,
 			min: this._minValue,
 			max: this._maxValue,
 			unit:
 				getSetpointUnit(applHost.configManager, this._minValueScale) ||
 				getSetpointUnit(applHost.configManager, this._maxValueScale),
-			ccSpecific: {
-				setpointType: this._type,
-			},
 		});
 
 		return true;
diff --git a/packages/cc/src/cc/IndicatorCC.ts b/packages/cc/src/cc/IndicatorCC.ts
index 96d85ce4a5b..fc58c9777b4 100644
--- a/packages/cc/src/cc/IndicatorCC.ts
+++ b/packages/cc/src/cc/IndicatorCC.ts
@@ -1,9 +1,5 @@
 import type { ConfigManager } from "@zwave-js/config";
-import type {
-	MessageOrCCLogEntry,
-	MessageRecord,
-	ValueID,
-} from "@zwave-js/core/safe";
+import type { MessageOrCCLogEntry, MessageRecord } from "@zwave-js/core/safe";
 import {
 	CommandClasses,
 	Maybe,
@@ -28,7 +24,6 @@ import {
 } from "../lib/API";
 import {
 	CommandClass,
-	CommandClassOptions,
 	gotDeserializationOptions,
 	type CCCommandOptions,
 	type CommandClassDeserializationOptions,
@@ -36,56 +31,61 @@ import {
 import {
 	API,
 	CCCommand,
+	ccValues,
 	commandClass,
 	expectedCCResponse,
 	implementedVersion,
 } from "../lib/CommandClassDecorators";
+import { V } from "../lib/Values";
 import { IndicatorCommand } from "../lib/_Types";
 
-export function getSupportedIndicatorIDsValueID(
-	endpoint: number | undefined,
-): ValueID {
-	return {
-		commandClass: CommandClasses.Indicator,
-		endpoint,
-		property: "supportedIndicatorIds",
-	};
-}
-
-export function getSupportedPropertyIDsValueID(
-	endpoint: number | undefined,
-	indicatorId: number,
-): ValueID {
-	return {
-		commandClass: CommandClasses.Indicator,
-		endpoint,
-		property: "supportedPropertyIDs",
-		propertyKey: indicatorId,
-	};
-}
+export const IndicatorCCValues = Object.freeze({
+	...V.defineStaticCCValues(CommandClasses.Indicator, {
+		...V.staticProperty("supportedIndicatorIds", undefined, {
+			internal: true,
+		}),
 
-export function getIndicatorValueValueID(
-	endpoint: number | undefined,
-	indicatorId: number,
-	propertyId: number,
-): ValueID {
-	if (indicatorId === 0) {
-		// V1
-		return {
-			commandClass: CommandClasses.Indicator,
-			endpoint,
-			property: "value",
-		};
-	} else {
-		// V2+
-		return {
-			commandClass: CommandClasses.Indicator,
-			endpoint,
-			property: indicatorId,
-			propertyKey: propertyId,
-		};
-	}
-}
+		...V.staticPropertyWithName("valueV1", "value", {
+			...ValueMetadata.UInt8,
+			label: "Indicator value",
+			ccSpecific: {
+				indicatorId: 0,
+			},
+		} as const),
+	}),
+
+	...V.defineDynamicCCValues(CommandClasses.Indicator, {
+		...V.dynamicPropertyAndKeyWithName(
+			"supportedPropertyIDs",
+			"supportedPropertyIDs",
+			(indicatorId: number) => indicatorId,
+			({ property, propertyKey }) =>
+				property === "supportedPropertyIDs" &&
+				typeof propertyKey === "number",
+			undefined,
+			{ internal: true },
+		),
+
+		...V.dynamicPropertyAndKeyWithName(
+			"valueV2",
+			// eslint-disable-next-line @typescript-eslint/no-unused-vars
+			(indicatorId: number, propertyId: number) => indicatorId,
+			(indicatorId: number, propertyId: number) => propertyId,
+			({ property, propertyKey }) =>
+				typeof property === "number" && typeof propertyKey === "number",
+			// The metadata is highly dependent on the indicator and property
+			// so this is just a baseline
+			(indicatorId: number, propertyId: number) => ({
+				...ValueMetadata.Any,
+				ccSpecific: {
+					indicatorId,
+					propertyId,
+				},
+			}),
+			{ minVersion: 2 } as const,
+		),
+	}),
+});
 
 /**
  * Looks up the configured metadata for the given indicator and property
@@ -97,48 +97,40 @@ function getIndicatorMetadata(
 ): ValueMetadata {
 	const label = configManager.lookupIndicator(indicatorId);
 	const prop = configManager.lookupProperty(propertyId);
+	const baseMetadata = IndicatorCCValues.valueV2(
+		indicatorId,
+		propertyId,
+	).meta;
 	if (!label && !prop) {
 		return {
+			...baseMetadata,
 			...ValueMetadata.UInt8,
-			ccSpecific: {
-				indicatorId,
-				propertyId,
-			},
 		};
 	} else if (!prop) {
 		return {
+			...baseMetadata,
 			...ValueMetadata.UInt8,
 			label,
-			ccSpecific: {
-				indicatorId,
-				propertyId,
-			},
 		};
 	} else {
 		if (prop.type === "boolean") {
 			return {
+				...baseMetadata,
 				...ValueMetadata.Boolean,
 				label: `${label} - ${prop.label}`,
 				description: prop.description,
 				readable: !prop.readonly,
-				ccSpecific: {
-					indicatorId,
-					propertyId,
-				},
 			};
 		} else {
 			// UInt8
 			return {
+				...baseMetadata,
 				...ValueMetadata.UInt8,
 				label: `${label} - ${prop.label}`,
 				description: prop.description,
 				min: prop.min,
 				max: prop.max,
 				readable: !prop.readonly,
-				ccSpecific: {
-					indicatorId,
-					propertyId,
-				},
 			};
 		}
 	}
@@ -332,21 +324,10 @@ export class IndicatorCCAPI extends CCAPI {
 
 @commandClass(CommandClasses.Indicator)
 @implementedVersion(3)
+@ccValues(IndicatorCCValues)
 export class IndicatorCC extends CommandClass {
 	declare ccCommand: IndicatorCommand;
 
-	public constructor(host: ZWaveHost, options: CommandClassOptions) {
-		super(host, options);
-		this.registerValue(
-			getSupportedIndicatorIDsValueID(undefined).property,
-			{ internal: true },
-		);
-		this.registerValue(
-			getSupportedPropertyIDsValueID(undefined, 0).property,
-			{ internal: true },
-		);
-	}
-
 	public async interview(applHost: ZWaveApplicationHost): Promise<void> {
 		const node = this.getNode(applHost)!;
 		const endpoint = this.getEndpoint(applHost)!;
@@ -357,7 +338,6 @@ export class IndicatorCC extends CommandClass {
 		).withOptions({
 			priority: MessagePriority.NodeQuery,
 		});
-		const valueDB = this.getValueDB(applHost);
 
 		applHost.controllerLog.logNode(node.id, {
 			endpoint: this.endpointIndex,
@@ -393,8 +373,9 @@ export class IndicatorCC extends CommandClass {
 			} while (curId !== 0x00);
 
 			// The IDs are not stored by the report CCs so store them here once we have all of them
-			valueDB.setValue(
-				getSupportedIndicatorIDsValueID(this.endpointIndex),
+			this.setValue(
+				applHost,
+				IndicatorCCValues.supportedIndicatorIds,
 				supportedIndicatorIds,
 			);
 			const logMessage = `supported indicator IDs: ${supportedIndicatorIds.join(
@@ -424,7 +405,6 @@ export class IndicatorCC extends CommandClass {
 		).withOptions({
 			priority: MessagePriority.NodeQuery,
 		});
-		const valueDB = this.getValueDB(applHost);
 
 		if (this.version === 1) {
 			applHost.controllerLog.logNode(node.id, {
@@ -435,8 +415,9 @@ export class IndicatorCC extends CommandClass {
 			await api.get();
 		} else {
 			const supportedIndicatorIds: number[] =
-				valueDB.getValue(
-					getSupportedIndicatorIDsValueID(this.endpointIndex),
+				this.getValue(
+					applHost,
+					IndicatorCCValues.supportedIndicatorIds,
 				) ?? [];
 			for (const indicatorId of supportedIndicatorIds) {
 				applHost.controllerLog.logNode(node.id, {
@@ -484,20 +465,18 @@ export class IndicatorCC extends CommandClass {
 	}
 
 	protected supportsV2Indicators(applHost: ZWaveApplicationHost): boolean {
-		const valueDB = this.getValueDB(applHost);
 		// First test if there are any indicator ids defined
-		const supportedIndicatorIds = valueDB.getValue<number[]>(
-			getSupportedIndicatorIDsValueID(this.endpointIndex),
+		const supportedIndicatorIds = this.getValue<number[]>(
+			applHost,
+			IndicatorCCValues.supportedIndicatorIds,
 		);
 		if (!supportedIndicatorIds?.length) return false;
 		// Then test if there are any property ids defined
 		return supportedIndicatorIds.some(
 			(indicatorId) =>
-				!!valueDB.getValue<number[]>(
-					getSupportedPropertyIDsValueID(
-						this.endpointIndex,
-						indicatorId,
-					),
+				!!this.getValue<number[]>(
+					applHost,
+					IndicatorCCValues.supportedPropertyIDs(indicatorId),
 				)?.length,
 		);
 	}
@@ -671,24 +650,12 @@ export class IndicatorCCReport extends IndicatorCC {
 	public persistValues(applHost: ZWaveApplicationHost): boolean {
 		if (!super.persistValues(applHost)) return false;
 
-		const valueDB = this.getValueDB(applHost);
-
 		if (this.value != undefined) {
 			if (!this.supportsV2Indicators(applHost)) {
 				// Publish the value
-				const valueId = getIndicatorValueValueID(
-					this.endpointIndex,
-					0,
-					1,
-				);
-				valueDB.setMetadata(valueId, {
-					...ValueMetadata.UInt8,
-					label: "Indicator value",
-					ccSpecific: {
-						indicatorId: 0,
-					},
-				});
-				valueDB.setValue(valueId, this.value);
+				const valueV1 = IndicatorCCValues.valueV1;
+				this.setMetadata(applHost, valueV1);
+				this.setValue(applHost, valueV1, this.value);
 			} else {
 				if (this.isSinglecast()) {
 					// Don't!
@@ -715,8 +682,6 @@ export class IndicatorCCReport extends IndicatorCC {
 		applHost: ZWaveApplicationHost,
 		value: IndicatorObject,
 	): void {
-		const valueDB = this.getValueDB(applHost);
-
 		const metadata = getIndicatorMetadata(
 			applHost.configManager,
 			value.indicatorId,
@@ -728,13 +693,12 @@ export class IndicatorCCReport extends IndicatorCC {
 		}
 
 		// Publish the value
-		const valueId = getIndicatorValueValueID(
-			this.endpointIndex,
+		const valueV2 = IndicatorCCValues.valueV2(
 			value.indicatorId,
 			value.propertyId,
 		);
-		valueDB.setMetadata(valueId, metadata);
-		valueDB.setValue(valueId, value.value);
+		this.setMetadata(applHost, valueV2, metadata);
+		this.setValue(applHost, valueV2, value.value);
 	}
 
 	public toLogEntry(applHost: ZWaveApplicationHost): MessageOrCCLogEntry {
@@ -833,11 +797,9 @@ export class IndicatorCCSupportedReport extends IndicatorCC {
 
 		if (this.indicatorId !== 0x00) {
 			// Remember which property IDs are supported
-			this.getValueDB(applHost).setValue(
-				getSupportedPropertyIDsValueID(
-					this.endpointIndex,
-					this.indicatorId,
-				),
+			this.setValue(
+				applHost,
+				IndicatorCCValues.supportedPropertyIDs(this.indicatorId),
 				this.supportedProperties,
 			);
 		}
diff --git a/packages/cc/src/cc/IrrigationCC.ts b/packages/cc/src/cc/IrrigationCC.ts
index 94c1b262c98..845b3746c70 100644
--- a/packages/cc/src/cc/IrrigationCC.ts
+++ b/packages/cc/src/cc/IrrigationCC.ts
@@ -30,8 +30,6 @@ import {
 	throwWrongValueType,
 } from "../lib/API";
 import {
-	ccValue,
-	ccValueMetadata,
 	CommandClass,
 	gotDeserializationOptions,
 	type CCCommandOptions,
@@ -40,10 +38,13 @@ import {
 import {
 	API,
 	CCCommand,
+	ccValue,
+	ccValues,
 	commandClass,
 	expectedCCResponse,
 	implementedVersion,
 } from "../lib/CommandClassDecorators";
+import { V } from "../lib/Values";
 import {
 	IrrigationCommand,
 	IrrigationSensorPolarity,
@@ -52,446 +53,422 @@ import {
 	ValveType,
 } from "../lib/_Types";
 
-function testResponseForIrrigationCommandWithValveId(
-	sent: {
-		valveId: ValveId;
-	},
-	received: {
-		valveId: ValveId;
-	},
-) {
-	return received.valveId === sent.valveId;
-}
+export const IrrigationCCValues = Object.freeze({
+	...V.defineStaticCCValues(CommandClasses.Irrigation, {
+		...V.staticProperty("numValves", undefined, { internal: true }),
+		...V.staticProperty("numValveTables", undefined, { internal: true }),
+		...V.staticProperty("supportsMasterValve", undefined, {
+			internal: true,
+		}),
+		...V.staticProperty("maxValveTableSize", undefined, { internal: true }),
+
+		...V.staticProperty("systemVoltage", {
+			...ValueMetadata.ReadOnlyUInt8,
+			label: "System voltage",
+			unit: "V",
+		} as const),
+
+		...V.staticProperty("masterValveDelay", {
+			...ValueMetadata.UInt8,
+			label: "Master valve delay",
+			description:
+				"The delay between turning on the master valve and turning on any zone valve",
+			unit: "seconds",
+		} as const),
+
+		...V.staticProperty("flowSensorActive", {
+			...ValueMetadata.ReadOnlyBoolean,
+			label: "Flow sensor active",
+		} as const),
+
+		...V.staticProperty("pressureSensorActive", {
+			...ValueMetadata.ReadOnlyBoolean,
+			label: "Pressure sensor active",
+		} as const),
+
+		...V.staticProperty("rainSensorActive", {
+			...ValueMetadata.ReadOnlyBoolean,
+			label: "Rain sensor attached and active",
+		} as const),
+
+		...V.staticProperty("rainSensorPolarity", {
+			...ValueMetadata.Number,
+			label: "Rain sensor polarity",
+			min: 0,
+			max: 1,
+			states: enumValuesToMetadataStates(IrrigationSensorPolarity),
+		} as const),
+
+		...V.staticProperty("moistureSensorActive", {
+			...ValueMetadata.ReadOnlyBoolean,
+			label: "Moisture sensor attached and active",
+		} as const),
+
+		...V.staticProperty("moistureSensorPolarity", {
+			...ValueMetadata.Number,
+			label: "Moisture sensor polarity",
+			min: 0,
+			max: 1,
+			states: enumValuesToMetadataStates(IrrigationSensorPolarity),
+		} as const),
+
+		...V.staticProperty("flow", {
+			...ValueMetadata.ReadOnlyNumber,
+			label: "Flow",
+			unit: "l/h",
+		} as const),
+
+		...V.staticProperty("pressure", {
+			...ValueMetadata.ReadOnlyNumber,
+			label: "Pressure",
+			unit: "kPa",
+		} as const),
+
+		...V.staticProperty("shutoffDuration", {
+			...ValueMetadata.ReadOnlyUInt8,
+			label: "Remaining shutoff duration",
+			unit: "hours",
+		} as const),
+
+		...V.staticProperty("errorNotProgrammed", {
+			...ValueMetadata.ReadOnlyBoolean,
+			label: "Error: device not programmed",
+		} as const),
+
+		...V.staticProperty("errorEmergencyShutdown", {
+			...ValueMetadata.ReadOnlyBoolean,
+			label: "Error: emergency shutdown",
+		} as const),
+
+		...V.staticProperty("errorHighPressure", {
+			...ValueMetadata.ReadOnlyBoolean,
+			label: "Error: high pressure",
+		} as const),
+
+		...V.staticProperty("highPressureThreshold", {
+			...ValueMetadata.Number,
+			label: "High pressure threshold",
+			unit: "kPa",
+		} as const),
+
+		...V.staticProperty("errorLowPressure", {
+			...ValueMetadata.ReadOnlyBoolean,
+			label: "Error: low pressure",
+		} as const),
+
+		...V.staticProperty("lowPressureThreshold", {
+			...ValueMetadata.Number,
+			label: "Low pressure threshold",
+			unit: "kPa",
+		} as const),
+
+		...V.staticProperty("errorValve", {
+			...ValueMetadata.ReadOnlyBoolean,
+			label: "Error: valve reporting error",
+		} as const),
+
+		...V.staticProperty("masterValveOpen", {
+			...ValueMetadata.ReadOnlyBoolean,
+			label: "Master valve is open",
+		} as const),
+
+		...V.staticProperty("firstOpenZoneId", {
+			...ValueMetadata.ReadOnlyNumber,
+			label: "First open zone valve ID",
+		} as const),
+
+		...V.staticPropertyWithName("shutoffSystem", "shutoff", {
+			...ValueMetadata.WriteOnlyBoolean,
+			label: `Shutoff system`,
+		} as const),
+	}),
+
+	...V.defineDynamicCCValues(CommandClasses.Irrigation, {
+		...V.dynamicPropertyAndKeyWithName(
+			"valveConnected",
+			(valveId: ValveId) => valveId,
+			"valveConnected",
+			({ property, propertyKey }) =>
+				(typeof property === "number" || property === "master") &&
+				propertyKey === "valveConnected",
+			(valveId: ValveId) =>
+				({
+					...ValueMetadata.ReadOnlyBoolean,
+					label: `${valveIdToMetadataPrefix(valveId)}: Connected`,
+				} as const),
+		),
+		...V.dynamicPropertyAndKeyWithName(
+			"nominalCurrent",
+			(valveId: ValveId) => valveId,
+			"nominalCurrent",
+			({ property, propertyKey }) =>
+				(typeof property === "number" || property === "master") &&
+				propertyKey === "nominalCurrent",
+			(valveId: ValveId) =>
+				({
+					...ValueMetadata.ReadOnlyBoolean,
+					label: `${valveIdToMetadataPrefix(
+						valveId,
+					)}: Nominal current`,
+					unit: "mA",
+				} as const),
+		),
+
+		...V.dynamicPropertyAndKeyWithName(
+			"nominalCurrentHighThreshold",
+			(valveId: ValveId) => valveId,
+			"nominalCurrentHighThreshold",
+			({ property, propertyKey }) =>
+				(typeof property === "number" || property === "master") &&
+				propertyKey === "nominalCurrentHighThreshold",
+			(valveId: ValveId) =>
+				({
+					...ValueMetadata.Number,
+					label: `${valveIdToMetadataPrefix(
+						valveId,
+					)}: Nominal current - high threshold`,
+					min: 0,
+					max: 2550,
+					unit: "mA",
+				} as const),
+		),
+
+		...V.dynamicPropertyAndKeyWithName(
+			"nominalCurrentLowThreshold",
+			(valveId: ValveId) => valveId,
+			"nominalCurrentLowThreshold",
+			({ property, propertyKey }) =>
+				(typeof property === "number" || property === "master") &&
+				propertyKey === "nominalCurrentLowThreshold",
+			(valveId: ValveId) =>
+				({
+					...ValueMetadata.Number,
+					label: `${valveIdToMetadataPrefix(
+						valveId,
+					)}: Nominal current - low threshold`,
+					min: 0,
+					max: 2550,
+					unit: "mA",
+				} as const),
+		),
+
+		...V.dynamicPropertyAndKeyWithName(
+			"errorShortCircuit",
+			(valveId: ValveId) => valveId,
+			"errorShortCircuit",
+			({ property, propertyKey }) =>
+				(typeof property === "number" || property === "master") &&
+				propertyKey === "errorShortCircuit",
+			(valveId: ValveId) =>
+				({
+					...ValueMetadata.ReadOnlyBoolean,
+					label: `${valveIdToMetadataPrefix(
+						valveId,
+					)}: Error - Short circuit detected`,
+				} as const),
+		),
+
+		...V.dynamicPropertyAndKeyWithName(
+			"errorHighCurrent",
+			(valveId: ValveId) => valveId,
+			"errorHighCurrent",
+			({ property, propertyKey }) =>
+				(typeof property === "number" || property === "master") &&
+				propertyKey === "errorHighCurrent",
+			(valveId: ValveId) =>
+				({
+					...ValueMetadata.ReadOnlyBoolean,
+					label: `${valveIdToMetadataPrefix(
+						valveId,
+					)}: Error - Current above high threshold`,
+				} as const),
+		),
+
+		...V.dynamicPropertyAndKeyWithName(
+			"errorLowCurrent",
+			(valveId: ValveId) => valveId,
+			"errorLowCurrent",
+			({ property, propertyKey }) =>
+				(typeof property === "number" || property === "master") &&
+				propertyKey === "errorLowCurrent",
+			(valveId: ValveId) =>
+				({
+					...ValueMetadata.ReadOnlyBoolean,
+					label: `${valveIdToMetadataPrefix(
+						valveId,
+					)}: Error - Current below low threshold`,
+				} as const),
+		),
+
+		...V.dynamicPropertyAndKeyWithName(
+			"maximumFlow",
+			(valveId: ValveId) => valveId,
+			"maximumFlow",
+			({ property, propertyKey }) =>
+				(typeof property === "number" || property === "master") &&
+				propertyKey === "maximumFlow",
+			(valveId: ValveId) =>
+				({
+					...ValueMetadata.Number,
+					label: `${valveIdToMetadataPrefix(valveId)}: Maximum flow`,
+					min: 0,
+					unit: "l/h",
+				} as const),
+		),
+
+		...V.dynamicPropertyAndKeyWithName(
+			"errorMaximumFlow",
+			(valveId: ValveId) => valveId,
+			"errorMaximumFlow",
+			({ property, propertyKey }) =>
+				(typeof property === "number" || property === "master") &&
+				propertyKey === "errorMaximumFlow",
+			(valveId: ValveId) =>
+				({
+					...ValueMetadata.ReadOnlyBoolean,
+					label: `${valveIdToMetadataPrefix(
+						valveId,
+					)}: Error - Maximum flow detected`,
+				} as const),
+		),
+
+		...V.dynamicPropertyAndKeyWithName(
+			"highFlowThreshold",
+			(valveId: ValveId) => valveId,
+			"highFlowThreshold",
+			({ property, propertyKey }) =>
+				(typeof property === "number" || property === "master") &&
+				propertyKey === "highFlowThreshold",
+			(valveId: ValveId) =>
+				({
+					...ValueMetadata.Number,
+					label: `${valveIdToMetadataPrefix(
+						valveId,
+					)}: High flow threshold`,
+					min: 0,
+					unit: "l/h",
+				} as const),
+		),
+
+		...V.dynamicPropertyAndKeyWithName(
+			"errorHighFlow",
+			(valveId: ValveId) => valveId,
+			"errorHighFlow",
+			({ property, propertyKey }) =>
+				(typeof property === "number" || property === "master") &&
+				propertyKey === "errorHighFlow",
+			(valveId: ValveId) =>
+				({
+					...ValueMetadata.ReadOnlyBoolean,
+					label: `${valveIdToMetadataPrefix(
+						valveId,
+					)}: Error - Flow above high threshold`,
+				} as const),
+		),
+
+		...V.dynamicPropertyAndKeyWithName(
+			"lowFlowThreshold",
+			(valveId: ValveId) => valveId,
+			"lowFlowThreshold",
+			({ property, propertyKey }) =>
+				(typeof property === "number" || property === "master") &&
+				propertyKey === "lowFlowThreshold",
+			(valveId: ValveId) =>
+				({
+					...ValueMetadata.Number,
+					label: `${valveIdToMetadataPrefix(
+						valveId,
+					)}: Low flow threshold`,
+					min: 0,
+					unit: "l/h",
+				} as const),
+		),
+
+		...V.dynamicPropertyAndKeyWithName(
+			"errorLowFlow",
+			(valveId: ValveId) => valveId,
+			"errorLowFlow",
+			({ property, propertyKey }) =>
+				(typeof property === "number" || property === "master") &&
+				propertyKey === "errorLowFlow",
+			(valveId: ValveId) =>
+				({
+					...ValueMetadata.ReadOnlyBoolean,
+					label: `${valveIdToMetadataPrefix(
+						valveId,
+					)}: Error - Flow below high threshold`,
+				} as const),
+		),
+
+		...V.dynamicPropertyAndKeyWithName(
+			"useRainSensor",
+			(valveId: ValveId) => valveId,
+			"useRainSensor",
+			({ property, propertyKey }) =>
+				(typeof property === "number" || property === "master") &&
+				propertyKey === "useRainSensor",
+			(valveId: ValveId) =>
+				({
+					...ValueMetadata.Boolean,
+					label: `${valveIdToMetadataPrefix(
+						valveId,
+					)}: Use rain sensor`,
+				} as const),
+		),
+
+		...V.dynamicPropertyAndKeyWithName(
+			"useMoistureSensor",
+			(valveId: ValveId) => valveId,
+			"useMoistureSensor",
+			({ property, propertyKey }) =>
+				(typeof property === "number" || property === "master") &&
+				propertyKey === "useMoistureSensor",
+			(valveId: ValveId) =>
+				({
+					...ValueMetadata.Boolean,
+					label: `${valveIdToMetadataPrefix(
+						valveId,
+					)}: Use moisture sensor`,
+				} as const),
+		),
+
+		...V.dynamicPropertyAndKeyWithName(
+			"valveRunDuration",
+			(valveId: ValveId) => valveId,
+			"duration",
+			({ property, propertyKey }) =>
+				(typeof property === "number" || property === "master") &&
+				propertyKey === "duration",
+			(valveId: ValveId) =>
+				({
+					...ValueMetadata.UInt16,
+					label: `${valveIdToMetadataPrefix(valveId)}: Run duration`,
+					min: 1,
+					unit: "s",
+				} as const),
+		),
+
+		...V.dynamicPropertyAndKeyWithName(
+			"valveRunStartStop",
+			(valveId: ValveId) => valveId,
+			"startStop",
+			({ property, propertyKey }) =>
+				(typeof property === "number" || property === "master") &&
+				propertyKey === "startStop",
+			(valveId: ValveId) =>
+				({
+					...ValueMetadata.Boolean,
+					label: `${valveIdToMetadataPrefix(valveId)}: Start/Stop`,
+				} as const),
+		),
+	}),
+});
 
 function valveIdToMetadataPrefix(valveId: ValveId): string {
 	if (valveId === "master") return "Master valve";
 	return `Valve ${padStart(valveId.toString(), 3, "0")}`;
 }
 
-export function getNumValvesValueId(endpointIndex?: number): ValueID {
-	return {
-		commandClass: CommandClasses.Irrigation,
-		endpoint: endpointIndex,
-		property: "numValves",
-	};
-}
-
-export function getSupportsMasterValveValueId(endpointIndex?: number): ValueID {
-	return {
-		commandClass: CommandClasses.Irrigation,
-		endpoint: endpointIndex,
-		property: "supportsMasterValve",
-	};
-}
-
-export function getMaxValveTableSizeValueId(endpointIndex?: number): ValueID {
-	return {
-		commandClass: CommandClasses.Irrigation,
-		endpoint: endpointIndex,
-		property: "maxValveTableSize",
-	};
-}
-
-export function getValveConnectedValueId(
-	valveId: ValveId,
-	endpointIndex?: number,
-): ValueID {
-	return {
-		commandClass: CommandClasses.Irrigation,
-		endpoint: endpointIndex,
-		property: valveId,
-		propertyKey: "connected",
-	};
-}
-
-export function getValveConnectedValueMetadata(
-	valveId: ValveId,
-): ValueMetadata {
-	return {
-		...ValueMetadata.ReadOnlyBoolean,
-		label: `${valveIdToMetadataPrefix(valveId)}: Connected`,
-	};
-}
-
-export function getValveNominalCurrentValueId(
-	valveId: ValveId,
-	endpointIndex?: number,
-): ValueID {
-	return {
-		commandClass: CommandClasses.Irrigation,
-		endpoint: endpointIndex,
-		property: valveId,
-		propertyKey: "nominalCurrent",
-	};
-}
-
-export function getValveNominalCurrentValueMetadata(
-	valveId: ValveId,
-): ValueMetadata {
-	return {
-		...ValueMetadata.ReadOnlyBoolean,
-		label: `${valveIdToMetadataPrefix(valveId)}: Nominal current`,
-		unit: "mA",
-	};
-}
-
-export function getValveErrorShortCircuitValueId(
-	valveId: ValveId,
-	endpointIndex?: number,
-): ValueID {
-	return {
-		commandClass: CommandClasses.Irrigation,
-		endpoint: endpointIndex,
-		property: valveId,
-		propertyKey: "errorShortCircuit",
-	};
-}
-
-export function getValveErrorShortCircuitValueMetadata(
-	valveId: ValveId,
-): ValueMetadata {
-	return {
-		...ValueMetadata.ReadOnlyBoolean,
-		label: `${valveIdToMetadataPrefix(
-			valveId,
-		)}: Error - Short circuit detected`,
-	};
-}
-
-export function getValveErrorHighCurrentValueId(
-	valveId: ValveId,
-	endpointIndex?: number,
-): ValueID {
-	return {
-		commandClass: CommandClasses.Irrigation,
-		endpoint: endpointIndex,
-		property: valveId,
-		propertyKey: "errorHighCurrent",
-	};
-}
-
-export function getValveErrorHighCurrentValueMetadata(
-	valveId: ValveId,
-): ValueMetadata {
-	return {
-		...ValueMetadata.ReadOnlyBoolean,
-		label: `${valveIdToMetadataPrefix(
-			valveId,
-		)}: Error - Current above high threshold`,
-	};
-}
-
-export function getValveErrorLowCurrentValueId(
-	valveId: ValveId,
-	endpointIndex?: number,
-): ValueID {
-	return {
-		commandClass: CommandClasses.Irrigation,
-		endpoint: endpointIndex,
-		property: valveId,
-		propertyKey: "errorLowCurrent",
-	};
-}
-
-export function getValveErrorLowCurrentValueMetadata(
-	valveId: ValveId,
-): ValueMetadata {
-	return {
-		...ValueMetadata.ReadOnlyBoolean,
-		label: `${valveIdToMetadataPrefix(
-			valveId,
-		)}: Error - Current below low threshold`,
-	};
-}
-
-export function getValveErrorMaximumFlowValueId(
-	valveId: ValveId,
-	endpointIndex?: number,
-): ValueID {
-	return {
-		commandClass: CommandClasses.Irrigation,
-		endpoint: endpointIndex,
-		property: valveId,
-		propertyKey: "errorMaximumFlow",
-	};
-}
-
-export function getValveErrorMaximumFlowValueMetadata(
-	valveId: ValveId,
-): ValueMetadata {
-	return {
-		...ValueMetadata.ReadOnlyBoolean,
-		label: `${valveIdToMetadataPrefix(
-			valveId,
-		)}: Error - Maximum flow detected`,
-	};
-}
-
-export function getValveErrorHighFlowValueId(
-	valveId: ValveId,
-	endpointIndex?: number,
-): ValueID {
-	return {
-		commandClass: CommandClasses.Irrigation,
-		endpoint: endpointIndex,
-		property: valveId,
-		propertyKey: "errorHighFlow",
-	};
-}
-
-export function getValveErrorHighFlowValueMetadata(
-	valveId: ValveId,
-): ValueMetadata {
-	return {
-		...ValueMetadata.ReadOnlyBoolean,
-		label: `${valveIdToMetadataPrefix(
-			valveId,
-		)}: Error - Flow above high threshold`,
-	};
-}
-
-export function getValveErrorLowFlowValueId(
-	valveId: ValveId,
-	endpointIndex?: number,
-): ValueID {
-	return {
-		commandClass: CommandClasses.Irrigation,
-		endpoint: endpointIndex,
-		property: valveId,
-		propertyKey: "errorLowFlow",
-	};
-}
-
-export function getValveErrorLowFlowValueMetadata(
-	valveId: ValveId,
-): ValueMetadata {
-	return {
-		...ValueMetadata.ReadOnlyBoolean,
-		label: `${valveIdToMetadataPrefix(
-			valveId,
-		)}: Error - Flow below high threshold`,
-	};
-}
-
-export function getNominalCurrentHighThresholdValueId(
-	valveId: ValveId,
-	endpointIndex?: number,
-): ValueID {
-	return {
-		commandClass: CommandClasses.Irrigation,
-		endpoint: endpointIndex,
-		property: valveId,
-		propertyKey: "nominalCurrentHighThreshold",
-	};
-}
-
-export function getNominalCurrentHighThresholdValueMetadata(
-	valveId: ValveId,
-): ValueMetadata {
-	return {
-		...ValueMetadata.Number,
-		label: `${valveIdToMetadataPrefix(
-			valveId,
-		)}: Nominal current - high threshold`,
-		min: 0,
-		max: 2550,
-		unit: "mA",
-	};
-}
-
-export function getNominalCurrentLowThresholdValueId(
-	valveId: ValveId,
-	endpointIndex?: number,
-): ValueID {
-	return {
-		commandClass: CommandClasses.Irrigation,
-		endpoint: endpointIndex,
-		property: valveId,
-		propertyKey: "nominalCurrentLowThreshold",
-	};
-}
-
-export function getNominalCurrentLowThresholdValueMetadata(
-	valveId: ValveId,
-): ValueMetadata {
-	return {
-		...ValueMetadata.Number,
-		label: `${valveIdToMetadataPrefix(
-			valveId,
-		)}: Nominal current - low threshold`,
-		min: 0,
-		max: 2550,
-		unit: "mA",
-	};
-}
-
-export function getMaximumFlowValueId(
-	valveId: ValveId,
-	endpointIndex?: number,
-): ValueID {
-	return {
-		commandClass: CommandClasses.Irrigation,
-		endpoint: endpointIndex,
-		property: valveId,
-		propertyKey: "maximumFlow",
-	};
-}
-
-export function getMaximumFlowValueMetadata(valveId: ValveId): ValueMetadata {
-	return {
-		...ValueMetadata.Number,
-		label: `${valveIdToMetadataPrefix(valveId)}: Maximum flow`,
-		min: 0,
-		unit: "l/h",
-	};
-}
-
-export function getHighFlowThresholdValueId(
-	valveId: ValveId,
-	endpointIndex?: number,
-): ValueID {
-	return {
-		commandClass: CommandClasses.Irrigation,
-		endpoint: endpointIndex,
-		property: valveId,
-		propertyKey: "highFlowThreshold",
-	};
-}
-
-export function getHighFlowThresholdValueMetadata(
-	valveId: ValveId,
-): ValueMetadata {
-	return {
-		...ValueMetadata.Number,
-		label: `${valveIdToMetadataPrefix(valveId)}: High flow threshold`,
-		min: 0,
-		unit: "l/h",
-	};
-}
-
-export function getLowFlowThresholdValueId(
-	valveId: ValveId,
-	endpointIndex?: number,
-): ValueID {
-	return {
-		commandClass: CommandClasses.Irrigation,
-		endpoint: endpointIndex,
-		property: valveId,
-		propertyKey: "lowFlowThreshold",
-	};
-}
-
-export function getLowFlowThresholdValueMetadata(
-	valveId: ValveId,
-): ValueMetadata {
-	return {
-		...ValueMetadata.Number,
-		label: `${valveIdToMetadataPrefix(valveId)}: Low flow threshold`,
-		min: 0,
-		unit: "l/h",
-	};
-}
-
-export function getUseRainSensorValueId(
-	valveId: ValveId,
-	endpointIndex?: number,
-): ValueID {
-	return {
-		commandClass: CommandClasses.Irrigation,
-		endpoint: endpointIndex,
-		property: valveId,
-		propertyKey: "useRainSensor",
-	};
-}
-
-export function getUseRainSensorValueMetadata(valveId: ValveId): ValueMetadata {
-	return {
-		...ValueMetadata.Boolean,
-		label: `${valveIdToMetadataPrefix(valveId)}: Use rain sensor`,
-	};
-}
-
-export function getUseMoistureSensorValueId(
-	valveId: ValveId,
-	endpointIndex?: number,
-): ValueID {
-	return {
-		commandClass: CommandClasses.Irrigation,
-		endpoint: endpointIndex,
-		property: valveId,
-		propertyKey: "useMoistureSensor",
-	};
-}
-
-export function getUseMoistureSensorValueMetadata(
-	valveId: ValveId,
-): ValueMetadata {
-	return {
-		...ValueMetadata.Boolean,
-		label: `${valveIdToMetadataPrefix(valveId)}: Use moisture sensor`,
-	};
-}
-
-export function getValveRunDurationValueId(
-	valveId: ValveId,
-	endpointIndex?: number,
-): ValueID {
-	return {
-		commandClass: CommandClasses.Irrigation,
-		endpoint: endpointIndex,
-		property: valveId,
-		propertyKey: "duration",
-	};
-}
-
-export function getValveRunDurationValueMetadata(
-	valveId: ValveId,
-): ValueMetadata {
-	return {
-		...ValueMetadata.Number,
-		label: `${valveIdToMetadataPrefix(valveId)}: Run duration`,
-		min: 1,
-		max: 0xffff,
-		unit: "s",
-	};
-}
-
-export function getValveRunStartStopValueId(
-	valveId: ValveId,
-	endpointIndex?: number,
-): ValueID {
-	return {
-		commandClass: CommandClasses.Irrigation,
-		endpoint: endpointIndex,
-		property: valveId,
-		propertyKey: "startStop",
-	};
-}
-
-export function getValveRunStartStopValueMetadata(
-	valveId: ValveId,
-): ValueMetadata {
-	return {
-		...ValueMetadata.Boolean,
-		label: `${valveIdToMetadataPrefix(valveId)}: Start/Stop`,
-	};
-}
-
-export function getShutoffValueId(endpointIndex?: number): ValueID {
-	return {
-		commandClass: CommandClasses.Irrigation,
-		endpoint: endpointIndex,
-		property: "shutoff",
-	};
-}
-
-export function getShutoffValueMetadata(): ValueMetadata {
-	return {
-		...ValueMetadata.WriteOnlyBoolean,
-		label: `Shutoff`,
-	};
-}
-
 const systemConfigProperties = [
 	"masterValveDelay",
 	"highPressureThreshold",
@@ -926,8 +903,7 @@ export class IrrigationCCAPI extends CCAPI {
 				if (value) {
 					// Start a valve run
 					const duration = valueDB.getValue<number>(
-						getValveRunDurationValueId(
-							property,
+						IrrigationCCValues.valveRunDuration(property).endpoint(
 							this.endpoint.index,
 						),
 					);
@@ -1019,6 +995,7 @@ export class IrrigationCCAPI extends CCAPI {
 
 @commandClass(CommandClasses.Irrigation)
 @implementedVersion(1)
+@ccValues(IrrigationCCValues)
 export class IrrigationCC extends CommandClass {
 	declare ccCommand: IrrigationCommand;
 
@@ -1032,7 +1009,9 @@ export class IrrigationCC extends CommandClass {
 	): number | undefined {
 		return applHost
 			.getValueDB(endpoint.nodeId)
-			.getValue(getMaxValveTableSizeValueId(endpoint.index));
+			.getValue(
+				IrrigationCCValues.maxValveTableSize.endpoint(endpoint.index),
+			);
 	}
 
 	/**
@@ -1045,7 +1024,7 @@ export class IrrigationCC extends CommandClass {
 	): number | undefined {
 		return applHost
 			.getValueDB(endpoint.nodeId)
-			.getValue(getNumValvesValueId(endpoint.index));
+			.getValue(IrrigationCCValues.numValves.endpoint(endpoint.index));
 	}
 
 	/**
@@ -1058,7 +1037,9 @@ export class IrrigationCC extends CommandClass {
 	): boolean {
 		return !!applHost
 			.getValueDB(endpoint.nodeId)
-			.getValue(getSupportsMasterValveValueId(endpoint.index));
+			.getValue(
+				IrrigationCCValues.supportsMasterValve.endpoint(endpoint.index),
+			);
 	}
 
 	public async interview(applHost: ZWaveApplicationHost): Promise<void> {
@@ -1105,22 +1086,18 @@ max. valve table size: ${systemInfo.maxValveTableSize}`;
 		});
 
 		// For each valve, create the values to start/stop a run
-		const valueDB = this.getValueDB(applHost);
 		for (let i = 1; i <= systemInfo.numValves; i++) {
-			valueDB.setMetadata(
-				getValveRunDurationValueId(i, this.endpointIndex),
-				getValveRunDurationValueMetadata(i),
+			this.ensureMetadata(
+				applHost,
+				IrrigationCCValues.valveRunDuration(i),
 			);
-			valueDB.setMetadata(
-				getValveRunStartStopValueId(i, this.endpointIndex),
-				getValveRunStartStopValueMetadata(i),
+			this.ensureMetadata(
+				applHost,
+				IrrigationCCValues.valveRunStartStop(i),
 			);
 		}
 		// And create a shutoff value
-		valueDB.setMetadata(
-			getShutoffValueId(this.endpointIndex),
-			getShutoffValueMetadata(),
-		);
+		this.ensureMetadata(applHost, IrrigationCCValues.shutoffSystem);
 
 		// Query current values
 		await this.refreshValues(applHost);
@@ -1256,16 +1233,16 @@ export class IrrigationCCSystemInfoReport extends IrrigationCC {
 		this.maxValveTableSize = this.payload[3] & 0b1111;
 	}
 
-	@ccValue({ internal: true })
+	@ccValue(IrrigationCCValues.numValves)
 	public readonly numValves: number;
 
-	@ccValue({ internal: true })
+	@ccValue(IrrigationCCValues.numValveTables)
 	public readonly numValveTables: number;
 
-	@ccValue({ internal: true })
+	@ccValue(IrrigationCCValues.supportsMasterValve)
 	public readonly supportsMasterValve: boolean;
 
-	@ccValue({ internal: true })
+	@ccValue(IrrigationCCValues.maxValveTableSize)
 	public readonly maxValveTableSize: number;
 
 	public toLogEntry(applHost: ZWaveApplicationHost): MessageOrCCLogEntry {
@@ -1330,113 +1307,49 @@ export class IrrigationCCSystemStatusReport extends IrrigationCC {
 		}
 	}
 
-	@ccValue()
-	@ccValueMetadata({
-		...ValueMetadata.ReadOnlyUInt8,
-		label: "System voltage",
-		unit: "V",
-	})
+	@ccValue(IrrigationCCValues.systemVoltage)
 	public systemVoltage: number;
 
-	@ccValue()
-	@ccValueMetadata({
-		...ValueMetadata.ReadOnlyBoolean,
-		label: "Flow sensor active",
-	})
+	@ccValue(IrrigationCCValues.flowSensorActive)
 	public flowSensorActive: boolean;
 
-	@ccValue()
-	@ccValueMetadata({
-		...ValueMetadata.ReadOnlyBoolean,
-		label: "Pressure sensor active",
-	})
+	@ccValue(IrrigationCCValues.pressureSensorActive)
 	public pressureSensorActive: boolean;
 
-	@ccValue()
-	@ccValueMetadata({
-		...ValueMetadata.ReadOnlyBoolean,
-		label: "Rain sensor attached and active",
-	})
+	@ccValue(IrrigationCCValues.rainSensorActive)
 	public rainSensorActive: boolean;
 
-	@ccValue()
-	@ccValueMetadata({
-		...ValueMetadata.ReadOnlyBoolean,
-		label: "Moisture sensor attached and active",
-	})
+	@ccValue(IrrigationCCValues.moistureSensorActive)
 	public moistureSensorActive: boolean;
 
-	@ccValue()
-	@ccValueMetadata({
-		...ValueMetadata.ReadOnlyNumber,
-		label: "Flow",
-		unit: "l/h",
-	})
+	@ccValue(IrrigationCCValues.flow)
 	public flow?: number;
 
-	@ccValue()
-	@ccValueMetadata({
-		...ValueMetadata.ReadOnlyNumber,
-		label: "Pressure",
-		unit: "kPa",
-	})
+	@ccValue(IrrigationCCValues.pressure)
 	public pressure?: number;
 
-	@ccValue()
-	@ccValueMetadata({
-		...ValueMetadata.ReadOnlyUInt8,
-		label: "Remaining shutoff duration",
-		unit: "hours",
-	})
+	@ccValue(IrrigationCCValues.shutoffDuration)
 	public shutoffDuration: number;
 
-	@ccValue()
-	@ccValueMetadata({
-		...ValueMetadata.ReadOnlyBoolean,
-		label: "Error: device not programmed",
-	})
+	@ccValue(IrrigationCCValues.errorNotProgrammed)
 	public errorNotProgrammed: boolean;
 
-	@ccValue()
-	@ccValueMetadata({
-		...ValueMetadata.ReadOnlyBoolean,
-		label: "Error: emergency shutdown",
-	})
+	@ccValue(IrrigationCCValues.errorEmergencyShutdown)
 	public errorEmergencyShutdown: boolean;
 
-	@ccValue()
-	@ccValueMetadata({
-		...ValueMetadata.ReadOnlyBoolean,
-		label: "Error: high pressure",
-	})
+	@ccValue(IrrigationCCValues.errorHighPressure)
 	public errorHighPressure: boolean;
 
-	@ccValue()
-	@ccValueMetadata({
-		...ValueMetadata.ReadOnlyBoolean,
-		label: "Error: low pressure",
-	})
+	@ccValue(IrrigationCCValues.errorLowPressure)
 	public errorLowPressure: boolean;
 
-	@ccValue()
-	@ccValueMetadata({
-		...ValueMetadata.ReadOnlyBoolean,
-		label: "Error: valve reporting error",
-	})
+	@ccValue(IrrigationCCValues.errorValve)
 	public errorValve: boolean;
 
-	@ccValue()
-	@ccValueMetadata({
-		...ValueMetadata.ReadOnlyBoolean,
-		label: "Master valve is open",
-	})
+	@ccValue(IrrigationCCValues.masterValveOpen)
 	public masterValveOpen: boolean;
 
-	@ccValue()
-	@ccValueMetadata({
-		...ValueMetadata.ReadOnlyNumber,
-		label: "First open zone valve ID",
-	})
+	@ccValue(IrrigationCCValues.firstOpenZoneId)
 	public firstOpenZoneId?: number;
 
 	public toLogEntry(applHost: ZWaveApplicationHost): MessageOrCCLogEntry {
@@ -1609,50 +1522,19 @@ export class IrrigationCCSystemConfigReport extends IrrigationCC {
 		}
 	}
 
-	@ccValue()
-	@ccValueMetadata({
-		...ValueMetadata.UInt8,
-		label: "Master valve delay",
-		description:
-			"The delay between turning on the master valve and turning on any zone valve",
-		unit: "seconds",
-	})
+	@ccValue(IrrigationCCValues.masterValveDelay)
 	public readonly masterValveDelay: number;
 
-	@ccValue()
-	@ccValueMetadata({
-		...ValueMetadata.Number,
-		label: "High pressure threshold",
-		unit: "kPa",
-	})
+	@ccValue(IrrigationCCValues.highPressureThreshold)
 	public readonly highPressureThreshold: number;
 
-	@ccValue()
-	@ccValueMetadata({
-		...ValueMetadata.Number,
-		label: "Low pressure threshold",
-		unit: "kPa",
-	})
+	@ccValue(IrrigationCCValues.lowPressureThreshold)
 	public readonly lowPressureThreshold: number;
 
-	@ccValue()
-	@ccValueMetadata({
-		...ValueMetadata.Number,
-		label: "Rain sensor polarity",
-		min: 0,
-		max: 1,
-		states: enumValuesToMetadataStates(IrrigationSensorPolarity),
-	})
+	@ccValue(IrrigationCCValues.rainSensorPolarity)
 	public readonly rainSensorPolarity?: IrrigationSensorPolarity;
 
-	@ccValue()
-	@ccValueMetadata({
-		...ValueMetadata.Number,
-		label: "Moisture sensor polarity",
-		min: 0,
-		max: 1,
-		states: enumValuesToMetadataStates(IrrigationSensorPolarity),
-	})
+	@ccValue(IrrigationCCValues.moistureSensorPolarity)
 	public readonly moistureSensorPolarity?: IrrigationSensorPolarity;
 
 	public toLogEntry(applHost: ZWaveApplicationHost): MessageOrCCLogEntry {
@@ -1724,113 +1606,67 @@ export class IrrigationCCValveInfoReport extends IrrigationCC {
 	public persistValues(applHost: ZWaveApplicationHost): boolean {
 		if (!super.persistValues(applHost)) return false;
 
-		const valueDB = this.getValueDB(applHost);
-
 		// connected
-		let valueId = getValveConnectedValueId(
+		const valveConnectedValue = IrrigationCCValues.valveConnected(
 			this.valveId,
-			this.endpointIndex,
 		);
-		if (!valueDB.hasMetadata(valueId)) {
-			valueDB.setMetadata(
-				valueId,
-				getValveConnectedValueMetadata(this.valveId),
-			);
-		}
-		valueDB.setValue(valueId, this.connected);
+		this.ensureMetadata(applHost, valveConnectedValue);
+		this.setValue(applHost, valveConnectedValue, this.connected);
 
 		// nominalCurrent
-		valueId = getValveNominalCurrentValueId(
+		const nominalCurrentValue = IrrigationCCValues.nominalCurrent(
 			this.valveId,
-			this.endpointIndex,
 		);
-		if (!valueDB.hasMetadata(valueId)) {
-			valueDB.setMetadata(
-				valueId,
-				getValveNominalCurrentValueMetadata(this.valveId),
-			);
-		}
-		valueDB.setValue(valueId, this.nominalCurrent);
+		this.ensureMetadata(applHost, nominalCurrentValue);
+		this.setValue(applHost, nominalCurrentValue, this.nominalCurrent);
 
 		// errorShortCircuit
-		valueId = getValveErrorShortCircuitValueId(
+		const errorShortCircuitValue = IrrigationCCValues.errorShortCircuit(
 			this.valveId,
-			this.endpointIndex,
 		);
-		if (!valueDB.hasMetadata(valueId)) {
-			valueDB.setMetadata(
-				valueId,
-				getValveErrorShortCircuitValueMetadata(this.valveId),
-			);
-		}
-		valueDB.setValue(valueId, this.errorShortCircuit);
+		this.ensureMetadata(applHost, errorShortCircuitValue);
+		this.setValue(applHost, errorShortCircuitValue, this.errorShortCircuit);
 
 		// errorHighCurrent
-		valueId = getValveErrorHighCurrentValueId(
+		const errorHighCurrentValue = IrrigationCCValues.errorHighCurrent(
 			this.valveId,
-			this.endpointIndex,
 		);
-		if (!valueDB.hasMetadata(valueId)) {
-			valueDB.setMetadata(
-				valueId,
-				getValveErrorHighCurrentValueMetadata(this.valveId),
-			);
-		}
-		valueDB.setValue(valueId, this.errorHighCurrent);
+		this.ensureMetadata(applHost, errorHighCurrentValue);
+		this.setValue(applHost, errorHighCurrentValue, this.errorHighCurrent);
 
 		// errorLowCurrent
-		valueId = getValveErrorLowCurrentValueId(
+		const errorLowCurrentValue = IrrigationCCValues.errorLowCurrent(
 			this.valveId,
-			this.endpointIndex,
 		);
-		if (!valueDB.hasMetadata(valueId)) {
-			valueDB.setMetadata(
-				valueId,
-				getValveErrorLowCurrentValueMetadata(this.valveId),
-			);
-		}
-		valueDB.setValue(valueId, this.errorLowCurrent);
+		this.ensureMetadata(applHost, errorLowCurrentValue);
+		this.setValue(applHost, errorLowCurrentValue, this.errorLowCurrent);
 
 		if (this.errorMaximumFlow != undefined) {
-			valueId = getValveErrorMaximumFlowValueId(
+			const errorMaximumFlowValue = IrrigationCCValues.errorMaximumFlow(
 				this.valveId,
-				this.endpointIndex,
 			);
-			if (!valueDB.hasMetadata(valueId)) {
-				valueDB.setMetadata(
-					valueId,
-					getValveErrorMaximumFlowValueMetadata(this.valveId),
-				);
-			}
-			valueDB.setValue(valueId, this.errorMaximumFlow);
+			this.ensureMetadata(applHost, errorMaximumFlowValue);
+			this.setValue(
+				applHost,
+				errorMaximumFlowValue,
+				this.errorMaximumFlow,
+			);
 		}
 
 		if (this.errorHighFlow != undefined) {
-			valueId = getValveErrorHighFlowValueId(
+			const errorHighFlowValue = IrrigationCCValues.errorHighFlow(
 				this.valveId,
-				this.endpointIndex,
 			);
-			if (!valueDB.hasMetadata(valueId)) {
-				valueDB.setMetadata(
-					valueId,
-					getValveErrorHighFlowValueMetadata(this.valveId),
-				);
-			}
-			valueDB.setValue(valueId, this.errorHighFlow);
+			this.ensureMetadata(applHost, errorHighFlowValue);
+			this.setValue(applHost, errorHighFlowValue, this.errorHighFlow);
 		}
 
 		if (this.errorLowFlow != undefined) {
-			valueId = getValveErrorLowFlowValueId(
+			const errorLowFlowValue = IrrigationCCValues.errorLowFlow(
 				this.valveId,
-				this.endpointIndex,
 			);
-			if (!valueDB.hasMetadata(valueId)) {
-				valueDB.setMetadata(
-					valueId,
-					getValveErrorLowFlowValueMetadata(this.valveId),
-				);
-			}
-			valueDB.setValue(valueId, this.errorLowFlow);
+			this.ensureMetadata(applHost, errorLowFlowValue);
+			this.setValue(applHost, errorLowFlowValue, this.errorLowFlow);
 		}
 
 		return true;
@@ -1864,6 +1700,17 @@ export interface IrrigationCCValveInfoGetOptions extends CCCommandOptions {
 	valveId: ValveId;
 }
 
+function testResponseForIrrigationCommandWithValveId(
+	sent: {
+		valveId: ValveId;
+	},
+	received: {
+		valveId: ValveId;
+	},
+) {
+	return received.valveId === sent.valveId;
+}
+
 @CCCommand(IrrigationCommand.ValveInfoGet)
 @expectedCCResponse(
 	IrrigationCCValveInfoReport,
@@ -2043,83 +1890,58 @@ export class IrrigationCCValveConfigReport extends IrrigationCC {
 	public persistValues(applHost: ZWaveApplicationHost): boolean {
 		if (!super.persistValues(applHost)) return false;
 
-		const valueDB = this.getValueDB(applHost);
-
 		// nominalCurrentHighThreshold
-		let valueId = getNominalCurrentHighThresholdValueId(
-			this.valveId,
-			this.endpointIndex,
+		const nominalCurrentHighThresholdValue =
+			IrrigationCCValues.nominalCurrentHighThreshold(this.valveId);
+		this.ensureMetadata(applHost, nominalCurrentHighThresholdValue);
+		this.setValue(
+			applHost,
+			nominalCurrentHighThresholdValue,
+			this.nominalCurrentHighThreshold,
 		);
-		if (!valueDB.hasMetadata(valueId)) {
-			valueDB.setMetadata(
-				valueId,
-				getNominalCurrentHighThresholdValueMetadata(this.valveId),
-			);
-		}
-		valueDB.setValue(valueId, this.nominalCurrentHighThreshold);
 
 		// nominalCurrentLowThreshold
-		valueId = getNominalCurrentLowThresholdValueId(
-			this.valveId,
-			this.endpointIndex,
+		const nominalCurrentLowThresholdValue =
+			IrrigationCCValues.nominalCurrentLowThreshold(this.valveId);
+		this.ensureMetadata(applHost, nominalCurrentLowThresholdValue);
+		this.setValue(
+			applHost,
+			nominalCurrentLowThresholdValue,
+			this.nominalCurrentLowThreshold,
 		);
-		if (!valueDB.hasMetadata(valueId)) {
-			valueDB.setMetadata(
-				valueId,
-				getNominalCurrentLowThresholdValueMetadata(this.valveId),
-			);
-		}
-		valueDB.setValue(valueId, this.nominalCurrentLowThreshold);
 
 		// maximumFlow
-		valueId = getMaximumFlowValueId(this.valveId, this.endpointIndex);
-		if (!valueDB.hasMetadata(valueId)) {
-			valueDB.setMetadata(
-				valueId,
-				getMaximumFlowValueMetadata(this.valveId),
-			);
-		}
-		valueDB.setValue(valueId, this.maximumFlow);
+		const maximumFlowValue = IrrigationCCValues.maximumFlow(this.valveId);
+		this.ensureMetadata(applHost, maximumFlowValue);
+		this.setValue(applHost, maximumFlowValue, this.maximumFlow);
 
 		// highFlowThreshold
-		valueId = getHighFlowThresholdValueId(this.valveId, this.endpointIndex);
-		if (!valueDB.hasMetadata(valueId)) {
-			valueDB.setMetadata(
-				valueId,
-				getHighFlowThresholdValueMetadata(this.valveId),
-			);
-		}
-		valueDB.setValue(valueId, this.highFlowThreshold);
+		const highFlowThresholdValue = IrrigationCCValues.highFlowThreshold(
+			this.valveId,
+		);
+		this.ensureMetadata(applHost, highFlowThresholdValue);
+		this.setValue(applHost, highFlowThresholdValue, this.highFlowThreshold);
 
 		// lowFlowThreshold
-		valueId = getLowFlowThresholdValueId(this.valveId, this.endpointIndex);
-		if (!valueDB.hasMetadata(valueId)) {
-			valueDB.setMetadata(
-				valueId,
-				getLowFlowThresholdValueMetadata(this.valveId),
-			);
-		}
-		valueDB.setValue(valueId, this.lowFlowThreshold);
+		const lowFlowThresholdValue = IrrigationCCValues.lowFlowThreshold(
+			this.valveId,
+		);
+		this.ensureMetadata(applHost, lowFlowThresholdValue);
+		this.setValue(applHost, lowFlowThresholdValue, this.lowFlowThreshold);
 
 		// useRainSensor
-		valueId = getUseRainSensorValueId(this.valveId, this.endpointIndex);
-		if (!valueDB.hasMetadata(valueId)) {
-			valueDB.setMetadata(
-				valueId,
-				getUseRainSensorValueMetadata(this.valveId),
-			);
-		}
-		valueDB.setValue(valueId, this.useRainSensor);
+		const useRainSensorValue = IrrigationCCValues.useRainSensor(
+			this.valveId,
+		);
+		this.ensureMetadata(applHost, useRainSensorValue);
+		this.setValue(applHost, useRainSensorValue, this.useRainSensor);
 
 		// useMoistureSensor
-		valueId = getUseMoistureSensorValueId(this.valveId, this.endpointIndex);
-		if (!valueDB.hasMetadata(valueId)) {
-			valueDB.setMetadata(
-				valueId,
-				getUseMoistureSensorValueMetadata(this.valveId),
-			);
-		}
-		valueDB.setValue(valueId, this.useMoistureSensor);
+		const useMoistureSensorValue = IrrigationCCValues.useMoistureSensor(
+			this.valveId,
+		);
+		this.ensureMetadata(applHost, useMoistureSensorValue);
+		this.setValue(applHost, useMoistureSensorValue, this.useMoistureSensor);
 
 		return true;
 	}
diff --git a/packages/cc/src/cc/LanguageCC.ts b/packages/cc/src/cc/LanguageCC.ts
index ab919124c92..e71c10c2244 100644
--- a/packages/cc/src/cc/LanguageCC.ts
+++ b/packages/cc/src/cc/LanguageCC.ts
@@ -16,8 +16,6 @@ import { pick } from "@zwave-js/shared/safe";
 import { validateArgs } from "@zwave-js/transformers";
 import { CCAPI } from "../lib/API";
 import {
-	ccValue,
-	ccValueMetadata,
 	CommandClass,
 	gotDeserializationOptions,
 	type CCCommandOptions,
@@ -26,12 +24,29 @@ import {
 import {
 	API,
 	CCCommand,
+	ccValue,
+	ccValues,
 	commandClass,
 	expectedCCResponse,
 	implementedVersion,
 } from "../lib/CommandClassDecorators";
+import { V } from "../lib/Values";
 import { LanguageCommand } from "../lib/_Types";
 
+export const LanguageCCValues = Object.freeze({
+	...V.defineStaticCCValues(CommandClasses.Language, {
+		...V.staticProperty("language", {
+			...ValueMetadata.ReadOnlyString,
+			label: "Language code",
+		} as const),
+
+		...V.staticProperty("country", {
+			...ValueMetadata.ReadOnlyString,
+			label: "Country code",
+		} as const),
+	}),
+});
+
 // @noSetValueAPI It doesn't make sense
 
 @API(CommandClasses.Language)
@@ -79,6 +94,7 @@ export class LanguageCCAPI extends CCAPI {
 
 @commandClass(CommandClasses.Language)
 @implementedVersion(1)
+@ccValues(LanguageCCValues)
 export class LanguageCC extends CommandClass {
 	declare ccCommand: LanguageCommand;
 
@@ -217,18 +233,10 @@ export class LanguageCCReport extends LanguageCC {
 		// }
 	}
 
-	@ccValue()
-	@ccValueMetadata({
-		...ValueMetadata.ReadOnly,
-		label: "Language code",
-	})
+	@ccValue(LanguageCCValues.language)
 	public readonly language: string;
 
-	@ccValue()
-	@ccValueMetadata({
-		...ValueMetadata.ReadOnly,
-		label: "Country code",
-	})
+	@ccValue(LanguageCCValues.country)
 	public readonly country: string | undefined;
 
 	public toLogEntry(applHost: ZWaveApplicationHost): MessageOrCCLogEntry {
diff --git a/packages/cc/src/cc/LockCC.ts b/packages/cc/src/cc/LockCC.ts
index 022abc3d999..283ea80f7cc 100644
--- a/packages/cc/src/cc/LockCC.ts
+++ b/packages/cc/src/cc/LockCC.ts
@@ -1,4 +1,4 @@
-import type { Maybe, MessageOrCCLogEntry, ValueID } from "@zwave-js/core/safe";
+import type { Maybe, MessageOrCCLogEntry } from "@zwave-js/core/safe";
 import {
 	CommandClasses,
 	MessagePriority,
@@ -20,8 +20,6 @@ import {
 	throwWrongValueType,
 } from "../lib/API";
 import {
-	ccValue,
-	ccValueMetadata,
 	CommandClass,
 	gotDeserializationOptions,
 	type CCCommandOptions,
@@ -30,19 +28,24 @@ import {
 import {
 	API,
 	CCCommand,
+	ccValue,
+	ccValues,
 	commandClass,
 	expectedCCResponse,
 	implementedVersion,
 } from "../lib/CommandClassDecorators";
+import { V } from "../lib/Values";
 import { LockCommand } from "../lib/_Types";
 
-export function getLockedValueId(endpoint: number): ValueID {
-	return {
-		commandClass: CommandClasses.Lock,
-		endpoint,
-		property: "locked",
-	};
-}
+export const LockCCValues = Object.freeze({
+	...V.defineStaticCCValues(CommandClasses.Lock, {
+		...V.staticProperty("locked", {
+			...ValueMetadata.Boolean,
+			label: "Locked",
+			description: "Whether the lock is locked",
+		} as const),
+	}),
+});
 
 @API(CommandClasses.Lock)
 export class LockCCAPI extends PhysicalCCAPI {
@@ -111,6 +114,7 @@ export class LockCCAPI extends PhysicalCCAPI {
 
 @commandClass(CommandClasses.Lock)
 @implementedVersion(1)
+@ccValues(LockCCValues)
 export class LockCC extends CommandClass {
 	declare ccCommand: LockCommand;
 
@@ -201,12 +205,7 @@ export class LockCCReport extends LockCC {
 		this.locked = this.payload[0] === 1;
 	}
 
-	@ccValue()
-	@ccValueMetadata({
-		...ValueMetadata.Boolean,
-		label: "Locked",
-		description: "Whether the lock is locked",
-	})
+	@ccValue(LockCCValues.locked)
 	public readonly locked: boolean;
 
 	public toLogEntry(applHost: ZWaveApplicationHost): MessageOrCCLogEntry {
diff --git a/packages/cc/src/cc/ManufacturerProprietaryCC.ts b/packages/cc/src/cc/ManufacturerProprietaryCC.ts
index aff3a10b871..fb94fa8186a 100644
--- a/packages/cc/src/cc/ManufacturerProprietaryCC.ts
+++ b/packages/cc/src/cc/ManufacturerProprietaryCC.ts
@@ -27,7 +27,7 @@ import {
 	getManufacturerProprietaryAPI,
 	getManufacturerProprietaryCCConstructor,
 } from "./manufacturerProprietary/Decorators";
-import { getManufacturerIdValueId } from "./ManufacturerSpecificCC";
+import { ManufacturerSpecificCCValues } from "./ManufacturerSpecificCC";
 
 export type ManufacturerProprietaryCCConstructor<
 	T extends typeof ManufacturerProprietaryCC = typeof ManufacturerProprietaryCC,
@@ -46,7 +46,7 @@ export class ManufacturerProprietaryCCAPI extends CCAPI {
 
 		// Read the manufacturer ID from Manufacturer Specific CC
 		const manufacturerId = this.getValueDB().getValue<number>(
-			getManufacturerIdValueId(),
+			ManufacturerSpecificCCValues.manufacturerId.id,
 		);
 		// If possible, try to defer to a specific subclass of this API
 		if (manufacturerId != undefined) {
@@ -223,8 +223,9 @@ export class ManufacturerProprietaryCC extends CommandClass {
 		const node = this.getNode(applHost)!;
 
 		// Read the manufacturer ID from Manufacturer Specific CC
-		this.manufacturerId = this.getValueDB(applHost).getValue<number>(
-			getManufacturerIdValueId(),
+		this.manufacturerId = this.getValue(
+			applHost,
+			ManufacturerSpecificCCValues.manufacturerId,
 		)!;
 		const pcInstance = this.createSpecificInstance();
 		if (pcInstance) {
@@ -245,8 +246,9 @@ export class ManufacturerProprietaryCC extends CommandClass {
 
 		if (this.manufacturerId == undefined) {
 			// Read the manufacturer ID from Manufacturer Specific CC
-			this.manufacturerId = this.getValueDB(applHost).getValue<number>(
-				getManufacturerIdValueId(),
+			this.manufacturerId = this.getValue(
+				applHost,
+				ManufacturerSpecificCCValues.manufacturerId,
 			)!;
 		}
 		const pcInstance = this.createSpecificInstance();
diff --git a/packages/cc/src/cc/ManufacturerSpecificCC.ts b/packages/cc/src/cc/ManufacturerSpecificCC.ts
index d3ca8f1b5bc..6e6421dd305 100644
--- a/packages/cc/src/cc/ManufacturerSpecificCC.ts
+++ b/packages/cc/src/cc/ManufacturerSpecificCC.ts
@@ -12,8 +12,6 @@ import { getEnumMemberName, num2hex, pick } from "@zwave-js/shared/safe";
 import { validateArgs } from "@zwave-js/transformers";
 import { CCAPI, PhysicalCCAPI } from "../lib/API";
 import {
-	ccValue,
-	ccValueMetadata,
 	CommandClass,
 	gotDeserializationOptions,
 	type CCCommandOptions,
@@ -22,59 +20,45 @@ import {
 import {
 	API,
 	CCCommand,
+	ccValue,
+	ccValues,
 	commandClass,
 	expectedCCResponse,
 	implementedVersion,
 } from "../lib/CommandClassDecorators";
+import { V } from "../lib/Values";
 import { DeviceIdType, ManufacturerSpecificCommand } from "../lib/_Types";
 
-/** @publicAPI */
-export function getManufacturerIdValueId(): ValueID {
-	return {
-		commandClass: CommandClasses["Manufacturer Specific"],
-		property: "manufacturerId",
-	};
-}
-
-/** @publicAPI */
-export function getProductTypeValueId(): ValueID {
-	return {
-		commandClass: CommandClasses["Manufacturer Specific"],
-		property: "productType",
-	};
-}
-
-/** @publicAPI */
-export function getProductIdValueId(): ValueID {
-	return {
-		commandClass: CommandClasses["Manufacturer Specific"],
-		property: "productId",
-	};
-}
-
-/** @publicAPI */
-export function getManufacturerIdValueMetadata(): ValueMetadata {
-	return {
-		...ValueMetadata.ReadOnlyUInt16,
-		label: "Manufacturer ID",
-	};
-}
-
-/** @publicAPI */
-export function getProductTypeValueMetadata(): ValueMetadata {
-	return {
-		...ValueMetadata.ReadOnlyUInt16,
-		label: "Product type",
-	};
-}
-
-/** @publicAPI */
-export function getProductIdValueMetadata(): ValueMetadata {
-	return {
-		...ValueMetadata.ReadOnlyUInt16,
-		label: "Product ID",
-	};
-}
+export const ManufacturerSpecificCCValues = Object.freeze({
+	...V.defineStaticCCValues(CommandClasses["Manufacturer Specific"], {
+		...V.staticProperty(
+			"manufacturerId",
+			{
+				...ValueMetadata.ReadOnlyUInt16,
+				label: "Manufacturer ID",
+			} as const,
+			{ supportsEndpoints: false },
+		),
+
+		...V.staticProperty(
+			"productType",
+			{
+				...ValueMetadata.ReadOnlyUInt16,
+				label: "Product type",
+			} as const,
+			{ supportsEndpoints: false },
+		),
+
+		...V.staticProperty(
+			"productId",
+			{
+				...ValueMetadata.ReadOnlyUInt16,
+				label: "Product ID",
+			} as const,
+			{ supportsEndpoints: false },
+		),
+	}),
+});
 
 // @noSetValueAPI This CC is read-only
 
@@ -140,6 +124,7 @@ export class ManufacturerSpecificCCAPI extends PhysicalCCAPI {
 
 @commandClass(CommandClasses["Manufacturer Specific"])
 @implementedVersion(2)
+@ccValues(ManufacturerSpecificCCValues)
 export class ManufacturerSpecificCC extends CommandClass {
 	declare ccCommand: ManufacturerSpecificCommand;
 
@@ -200,39 +185,27 @@ export class ManufacturerSpecificCCReport extends ManufacturerSpecificCC {
 		super(host, options);
 
 		validatePayload(this.payload.length >= 6);
-		this._manufacturerId = this.payload.readUInt16BE(0);
-		this._productType = this.payload.readUInt16BE(2);
-		this._productId = this.payload.readUInt16BE(4);
+		this.manufacturerId = this.payload.readUInt16BE(0);
+		this.productType = this.payload.readUInt16BE(2);
+		this.productId = this.payload.readUInt16BE(4);
 	}
 
-	private _manufacturerId: number;
-	@ccValue()
-	@ccValueMetadata(getManufacturerIdValueMetadata())
-	public get manufacturerId(): number {
-		return this._manufacturerId;
-	}
+	@ccValue(ManufacturerSpecificCCValues.manufacturerId)
+	public readonly manufacturerId: number;
 
-	private _productType: number;
-	@ccValue()
-	@ccValueMetadata(getProductTypeValueMetadata())
-	public get productType(): number {
-		return this._productType;
-	}
+	@ccValue(ManufacturerSpecificCCValues.productType)
+	public readonly productType: number;
 
-	private _productId: number;
-	@ccValue()
-	@ccValueMetadata(getProductIdValueMetadata())
-	public get productId(): number {
-		return this._productId;
-	}
+	@ccValue(ManufacturerSpecificCCValues.productId)
+	public readonly productId: number;
 
 	public toLogEntry(applHost: ZWaveApplicationHost): MessageOrCCLogEntry {
 		return {
 			...super.toLogEntry(applHost),
 			message: {
-				"manufacturer id": num2hex(this._manufacturerId),
-				"product type": num2hex(this._productType),
-				"product id": num2hex(this._productId),
+				"manufacturer id": num2hex(this.manufacturerId),
+				"product type": num2hex(this.productType),
+				"product id": num2hex(this.productId),
 			},
 		};
 	}
diff --git a/packages/cc/src/cc/MeterCC.ts b/packages/cc/src/cc/MeterCC.ts
index 0154bca808e..f7d21b50068 100644
--- a/packages/cc/src/cc/MeterCC.ts
+++ b/packages/cc/src/cc/MeterCC.ts
@@ -3,11 +3,7 @@ import {
 	getDefaultMeterScale,
 	MeterScale,
 } from "@zwave-js/config";
-import type {
-	MessageOrCCLogEntry,
-	MessageRecord,
-	ValueID,
-} from "@zwave-js/core/safe";
+import type { MessageOrCCLogEntry, MessageRecord } from "@zwave-js/core/safe";
 import {
 	CommandClasses,
 	getMinIntegerSize,
@@ -37,7 +33,6 @@ import {
 	throwWrongValueType,
 } from "../lib/API";
 import {
-	ccValue,
 	CommandClass,
 	gotDeserializationOptions,
 	type CCCommandOptions,
@@ -46,13 +41,68 @@ import {
 import {
 	API,
 	CCCommand,
+	ccValue,
+	ccValues,
 	commandClass,
 	expectedCCResponse,
 	getCommandClass,
 	implementedVersion,
 } from "../lib/CommandClassDecorators";
+import { V } from "../lib/Values";
 import { MeterCommand, RateType } from "../lib/_Types";
 
+export const MeterCCValues = Object.freeze({
+	...V.defineStaticCCValues(CommandClasses.Meter, {
+		...V.staticProperty("type", undefined, { internal: true }),
+		...V.staticProperty("supportsReset", undefined, { internal: true }),
+		...V.staticProperty("supportedScales", undefined, { internal: true }),
+		...V.staticProperty("supportedRateTypes", undefined, {
+			internal: true,
+		}),
+
+		...V.staticPropertyWithName("resetAll", "reset", {
+			...ValueMetadata.WriteOnlyBoolean,
+			label: `Reset accumulated values`,
+		} as const),
+	}),
+
+	...V.defineDynamicCCValues(CommandClasses.Meter, {
+		...V.dynamicPropertyAndKeyWithName(
+			"resetSingle",
+			"reset",
+			(meterType: number) => meterType,
+			({ property, propertyKey }) =>
+				property === "reset" && typeof propertyKey === "number",
+			(meterType: number) =>
+				({
+					...ValueMetadata.WriteOnlyBoolean,
+					// This is only a placeholder label. A config manager is needed to
+					// determine the actual label.
+					label: `Reset (${num2hex(meterType)})`,
+					ccSpecific: { meterType },
+				} as const),
+		),
+
+		...V.dynamicPropertyAndKeyWithName(
+			"value",
+			"value",
+			toPropertyKey,
+			({ property, propertyKey }) =>
+				property === "value" && typeof propertyKey === "number",
+			(meterType: number, rateType: RateType, scale: number) =>
+				({
+					...ValueMetadata.ReadOnlyNumber,
+					// Label and unit can only be determined with a config manager
+					ccSpecific: {
+						meterType,
+						rateType,
+						scale,
+					},
+				} as const),
+		),
+	}),
+});
+
 function toPropertyKey(
 	meterType: number,
 	rateType: RateType,
@@ -79,47 +129,6 @@ function getMeterTypeName(configManager: ConfigManager, type: number): string {
 	);
 }
 
-export function getTypeValueId(endpoint: number): ValueID {
-	return {
-		commandClass: CommandClasses.Meter,
-		endpoint,
-		property: "type",
-	};
-}
-
-export function getSupportsResetValueId(endpoint: number): ValueID {
-	return {
-		commandClass: CommandClasses.Meter,
-		endpoint,
-		property: "supportsReset",
-	};
-}
-
-export function getSupportedScalesValueId(endpoint: number): ValueID {
-	return {
-		commandClass: CommandClasses.Meter,
-		endpoint,
-		property: "supportedScales",
-	};
-}
-
-export function getSupportedRateTypesValueId(endpoint: number): ValueID {
-	return {
-		commandClass: CommandClasses.Meter,
-		endpoint,
-		property: "supportedRateTypes",
-	};
-}
-
-export function getResetValueId(endpoint: number, type?: number): ValueID {
-	return {
-		commandClass: CommandClasses.Meter,
-		endpoint,
-		property: "reset",
-		propertyKey: type,
-	};
-}
-
 function getValueLabel(
 	configManager: ConfigManager,
 	meterType: number,
@@ -233,11 +242,13 @@ export class MeterCCAPI extends PhysicalCCAPI {
 		if (this.version >= 2) {
 			const supportedScales =
 				valueDB?.getValue<number[]>(
-					getSupportedScalesValueId(this.endpoint.index),
+					MeterCCValues.supportedScales.endpoint(this.endpoint.index),
 				) ?? [];
 			const supportedRateTypes =
 				valueDB?.getValue<RateType[]>(
-					getSupportedRateTypesValueId(this.endpoint.index),
+					MeterCCValues.supportedRateTypes.endpoint(
+						this.endpoint.index,
+					),
 				) ?? [];
 
 			const rateTypes = supportedRateTypes.length
@@ -332,6 +343,7 @@ export class MeterCCAPI extends PhysicalCCAPI {
 
 @commandClass(CommandClasses.Meter)
 @implementedVersion(6)
+@ccValues(MeterCCValues)
 export class MeterCC extends CommandClass {
 	declare ccCommand: MeterCommand;
 
@@ -411,7 +423,6 @@ supports reset:       ${suppResp.supportsReset}`;
 		).withOptions({
 			priority: MessagePriority.NodeQuery,
 		});
-		const valueDB = this.getValueDB(applHost);
 
 		if (this.version === 1) {
 			applHost.controllerLog.logNode(node.id, {
@@ -422,15 +433,13 @@ supports reset:       ${suppResp.supportsReset}`;
 			await api.get();
 		} else {
 			const type: number =
-				valueDB.getValue(getTypeValueId(this.endpointIndex)) ?? 0;
+				this.getValue(applHost, MeterCCValues.type) ?? 0;
+
 			const supportedScales: readonly number[] =
-				valueDB.getValue(
-					getSupportedScalesValueId(this.endpointIndex),
-				) ?? [];
+				this.getValue(applHost, MeterCCValues.supportedScales) ?? [];
+
 			const supportedRateTypes: readonly RateType[] =
-				valueDB.getValue(
-					getSupportedRateTypesValueId(this.endpointIndex),
-				) ?? [];
+				this.getValue(applHost, MeterCCValues.supportedRateTypes) ?? [];
 
 			const rateTypes = supportedRateTypes.length
 				? supportedRateTypes
@@ -552,7 +561,6 @@ export class MeterCCReport extends MeterCC {
 
 	public persistValues(applHost: ZWaveApplicationHost): boolean {
 		if (!super.persistValues(applHost)) return false;
-		const valueDB = this.getValueDB(applHost);
 
 		const meterType = applHost.configManager.lookupMeter(this._type);
 		const scale = applHost.configManager.lookupMeterScale(
@@ -575,8 +583,9 @@ export class MeterCCReport extends MeterCC {
 
 			// Filter out unsupported meter types, scales and rate types if possible
 			if (this.version >= 2) {
-				const expectedType = valueDB.getValue<number>(
-					getTypeValueId(this.endpointIndex),
+				const expectedType = this.getValue<number>(
+					applHost,
+					MeterCCValues.type,
 				);
 				if (expectedType != undefined) {
 					validatePayload.withReason(
@@ -584,8 +593,9 @@ export class MeterCCReport extends MeterCC {
 					)(this._type === expectedType);
 				}
 
-				const supportedScales = valueDB.getValue<number[]>(
-					getSupportedScalesValueId(this.endpointIndex),
+				const supportedScales = this.getValue<number[]>(
+					applHost,
+					MeterCCValues.supportedScales,
 				);
 				if (supportedScales?.length) {
 					validatePayload.withReason(
@@ -593,8 +603,9 @@ export class MeterCCReport extends MeterCC {
 					)(supportedScales.includes(this.scale));
 				}
 
-				const supportedRateTypes = valueDB.getValue<RateType[]>(
-					getSupportedRateTypesValueId(this.endpointIndex),
+				const supportedRateTypes = this.getValue<RateType[]>(
+					applHost,
+					MeterCCValues.supportedRateTypes,
 				);
 				if (supportedRateTypes?.length) {
 					validatePayload.withReason(
@@ -606,31 +617,24 @@ export class MeterCCReport extends MeterCC {
 				}
 			}
 		}
-		const valueId = {
-			commandClass: this.ccId,
-			endpoint: this.endpointIndex,
-			property: "value",
-			propertyKey: toPropertyKey(this._type, this._rateType, this.scale),
-		};
-		// Always create metadata if it does not exist
-		if (!valueDB.hasMetadata(valueId)) {
-			valueDB.setMetadata(valueId, {
-				...ValueMetadata.ReadOnlyNumber,
-				label: getValueLabel(
-					applHost.configManager,
-					this._type,
-					scale,
-					this._rateType,
-				),
-				unit: scale.label,
-				ccSpecific: {
-					meterType: this._type,
-					rateType: this._rateType,
-					scale: this.scale,
-				},
-			});
-		}
-		valueDB.setValue(valueId, this._value);
+
+		const valueValue = MeterCCValues.value(
+			this._type,
+			this._rateType,
+			this.scale,
+		);
+		this.ensureMetadata(applHost, valueValue, {
+			...valueValue.meta,
+			label: getValueLabel(
+				applHost.configManager,
+				this._type,
+				scale,
+				this._rateType,
+			),
+			unit: scale.label,
+		});
+		this.setValue(applHost, valueValue, this._value);
+
 		return true;
 	}
 
@@ -767,9 +771,7 @@ export class MeterCCGet extends MeterCC {
 		}
 		if (this.scale != undefined) {
 			// Try to lookup the meter type to translate the scale
-			const type = this.getValueDB(applHost).getValue<number>(
-				getTypeValueId(this.endpointIndex),
-			);
+			const type = this.getValue<number>(applHost, MeterCCValues.type);
 			if (type != undefined) {
 				message.scale = applHost.configManager.lookupMeterScale(
 					type,
@@ -792,8 +794,8 @@ export class MeterCCSupportedReport extends MeterCC {
 	) {
 		super(host, options);
 		validatePayload(this.payload.length >= 2);
-		this._type = this.payload[0] & 0b0_00_11111;
-		this._supportsReset = !!(this.payload[0] & 0b1_00_00000);
+		this.type = this.payload[0] & 0b0_00_11111;
+		this.supportsReset = !!(this.payload[0] & 0b1_00_00000);
 		const hasMoreScales = !!(this.payload[1] & 0b1_0000000);
 		if (hasMoreScales) {
 			// The bitmask is spread out
@@ -802,7 +804,7 @@ export class MeterCCSupportedReport extends MeterCC {
 			validatePayload(this.payload.length >= 3 + extraBytes);
 			// The bitmask is the original payload byte plus all following bytes
 			// Since the first byte only has 7 bits, we need to reduce all following bits by 1
-			this._supportedScales = parseBitMask(
+			this.supportedScales = parseBitMask(
 				Buffer.concat([
 					Buffer.from([this.payload[1] & 0b0_1111111]),
 					this.payload.slice(3, 3 + extraBytes),
@@ -811,75 +813,46 @@ export class MeterCCSupportedReport extends MeterCC {
 			).map((scale) => (scale >= 8 ? scale - 1 : scale));
 		} else {
 			// only 7 bits in the bitmask. Bit 7 is 0, so no need to mask it out
-			this._supportedScales = parseBitMask(
+			this.supportedScales = parseBitMask(
 				Buffer.from([this.payload[1]]),
 				0,
 			);
 		}
 		// This is only present in V4+
-		this._supportedRateTypes = parseBitMask(
+		this.supportedRateTypes = parseBitMask(
 			Buffer.from([(this.payload[0] & 0b0_11_00000) >>> 5]),
 			1,
 		);
 	}
 
-	private _type: number;
-	@ccValue({ internal: true })
-	public get type(): number {
-		return this._type;
-	}
+	@ccValue(MeterCCValues.type)
+	public readonly type: number;
 
-	private _supportsReset: boolean;
-	@ccValue({ internal: true })
-	public get supportsReset(): boolean {
-		return this._supportsReset;
-	}
+	@ccValue(MeterCCValues.supportsReset)
+	public readonly supportsReset: boolean;
 
-	private _supportedScales: number[];
-	@ccValue({ internal: true })
-	public get supportedScales(): readonly number[] {
-		return this._supportedScales;
-	}
+	@ccValue(MeterCCValues.supportedScales)
+	public readonly supportedScales: readonly number[];
 
-	private _supportedRateTypes: RateType[];
-	@ccValue({ internal: true })
-	public get supportedRateTypes(): readonly RateType[] {
-		return this._supportedRateTypes;
-	}
+	@ccValue(MeterCCValues.supportedRateTypes)
+	public readonly supportedRateTypes: readonly RateType[];
 
 	public persistValues(applHost: ZWaveApplicationHost): boolean {
 		if (!super.persistValues(applHost)) return false;
-		if (!this._supportsReset) return true;
+		if (!this.supportsReset) return true;
 
-		const valueDB = this.getValueDB(applHost);
 		// Create reset values
 		if (this.version < 6) {
-			const resetAllValueId: ValueID = getResetValueId(
-				this.endpointIndex,
-			);
-			if (!valueDB.hasMetadata(resetAllValueId)) {
-				valueDB.setMetadata(resetAllValueId, {
-					...ValueMetadata.WriteOnlyBoolean,
-					label: `Reset accumulated values`,
-				});
-			}
+			this.ensureMetadata(applHost, MeterCCValues.resetAll);
 		} else {
-			const resetSingle: ValueID = getResetValueId(
-				this.endpointIndex,
-				this._type,
-			);
-			if (!valueDB.hasMetadata(resetSingle)) {
-				valueDB.setMetadata(resetSingle, {
-					...ValueMetadata.WriteOnlyBoolean,
-					label: `Reset (${getMeterTypeName(
-						applHost.configManager,
-						this._type,
-					)})`,
-					ccSpecific: {
-						meterType: this._type,
-					},
-				});
-			}
+			const resetSingleValue = MeterCCValues.resetSingle(this.type);
+			this.ensureMetadata(applHost, resetSingleValue, {
+				...resetSingleValue.meta,
+				label: `Reset (${getMeterTypeName(
+					applHost.configManager,
+					this.type,
+				)})`,
+			});
 		}
 		return true;
 	}
@@ -890,14 +863,14 @@ export class MeterCCSupportedReport extends MeterCC {
 				applHost.configManager.lookupMeter(this.type)?.name ??
 				`Unknown (${num2hex(this.type)})`
 			}`,
-			"supports reset": this._supportsReset,
-			"supported scales": `${this._supportedScales
+			"supports reset": this.supportsReset,
+			"supported scales": `${this.supportedScales
 				.map(
 					(scale) => `
 · ${applHost.configManager.lookupMeterScale(this.type, scale).label}`,
 				)
 				.join("")}`,
-			"supported rate types": this._supportedRateTypes
+			"supported rate types": this.supportedRateTypes
 				.map((rt) => getEnumMemberName(RateType, rt))
 				.join(", "),
 		};
diff --git a/packages/cc/src/cc/MultiChannelAssociationCC.ts b/packages/cc/src/cc/MultiChannelAssociationCC.ts
index b8471518eda..46a73cf4ad6 100644
--- a/packages/cc/src/cc/MultiChannelAssociationCC.ts
+++ b/packages/cc/src/cc/MultiChannelAssociationCC.ts
@@ -1,8 +1,4 @@
-import type {
-	IZWaveEndpoint,
-	MessageRecord,
-	ValueID,
-} from "@zwave-js/core/safe";
+import type { IZWaveEndpoint, MessageRecord } from "@zwave-js/core/safe";
 import {
 	CommandClasses,
 	encodeBitMask,
@@ -20,75 +16,70 @@ import { pick } from "@zwave-js/shared/safe";
 import { validateArgs } from "@zwave-js/transformers";
 import { CCAPI, PhysicalCCAPI } from "../lib/API";
 import {
-	ccValue,
 	CommandClass,
 	gotDeserializationOptions,
 	type CCCommandOptions,
 	type CommandClassDeserializationOptions,
-	type CommandClassOptions,
 } from "../lib/CommandClass";
 import {
 	API,
 	CCCommand,
+	ccValue,
+	ccValues,
 	commandClass,
 	expectedCCResponse,
 	implementedVersion,
 } from "../lib/CommandClassDecorators";
 import * as ccUtils from "../lib/utils";
+import { V } from "../lib/Values";
 import {
 	AssociationAddress,
 	EndpointAddress,
 	MultiChannelAssociationCommand,
 } from "../lib/_Types";
-import { getGroupCountValueId as getAssociationGroupCountValueId } from "./AssociationCC";
-
-/** Returns the ValueID used to store the maximum number of nodes of an association group */
-export function getMaxNodesValueId(
-	endpointIndex: number,
-	groupId: number,
-): ValueID {
-	return {
-		commandClass: CommandClasses["Multi Channel Association"],
-		endpoint: endpointIndex,
-		property: "maxNodes",
-		propertyKey: groupId,
-	};
-}
-
-/** Returns the ValueID used to store the node IDs of a multi channel association group */
-export function getNodeIdsValueId(
-	endpointIndex: number,
-	groupId: number,
-): ValueID {
-	return {
-		commandClass: CommandClasses["Multi Channel Association"],
-		endpoint: endpointIndex,
-		property: "nodeIds",
-		propertyKey: groupId,
-	};
-}
-
-/** Returns the ValueID used to store the endpoint addresses of a multi channel association group */
-export function getEndpointsValueId(
-	endpointIndex: number,
-	groupId: number,
-): ValueID {
-	return {
-		commandClass: CommandClasses["Multi Channel Association"],
-		endpoint: endpointIndex,
-		property: "endpoints",
-		propertyKey: groupId,
-	};
-}
-
-/** Returns the ValueID used to store the number of multi channel association group */
-export function getGroupCountValueId(endpointIndex: number): ValueID {
-	return {
-		commandClass: CommandClasses["Multi Channel Association"],
-		endpoint: endpointIndex,
-		property: "groupCount",
-	};
-}
+import { AssociationCCValues } from "./AssociationCC";
+
+export const MultiChannelAssociationCCValues = Object.freeze({
+	...V.defineStaticCCValues(CommandClasses["Multi Channel Association"], {
+		// number multi channel association groups
+		...V.staticProperty("groupCount", undefined, { internal: true }),
+	}),
+
+	...V.defineDynamicCCValues(CommandClasses["Multi Channel Association"], {
+		// maximum number of nodes of a multi channel association group
+		...V.dynamicPropertyAndKeyWithName(
+			"maxNodes",
+			"maxNodes",
+			(groupId: number) => groupId,
+			({ property, propertyKey }) =>
+				property === "maxNodes" && typeof propertyKey === "number",
+			undefined,
+			{ internal: true },
+		),
+
+		// node IDs of a multi channel association group
+		...V.dynamicPropertyAndKeyWithName(
+			"nodeIds",
+			"nodeIds",
+			(groupId: number) => groupId,
+			({ property, propertyKey }) =>
+				property === "nodeIds" && typeof propertyKey === "number",
+			undefined,
+			{ internal: true },
+		),
+
+		// Endpoint addresses of a multi channel association group
+		...V.dynamicPropertyAndKeyWithName(
+			"endpoints",
+			"endpoints",
+			(groupId: number) => groupId,
+			({ property, propertyKey }) =>
+				property === "endpoints" && typeof propertyKey === "number",
+			undefined,
+			{ internal: true },
+		),
+	}),
+});
 
 function endpointAddressesToString(
 	endpoints: readonly EndpointAddress[],
@@ -310,23 +301,10 @@ export class MultiChannelAssociationCCAPI extends PhysicalCCAPI {
 
 @commandClass(CommandClasses["Multi Channel Association"])
 @implementedVersion(4)
+@ccValues(MultiChannelAssociationCCValues)
 export class MultiChannelAssociationCC extends CommandClass {
 	declare ccCommand: MultiChannelAssociationCommand;
 
-	public constructor(host: ZWaveHost, options: CommandClassOptions) {
-		super(host, options);
-		// Make valueIDs internal
-		this.registerValue(getMaxNodesValueId(0, 0).property, {
-			internal: true,
-		});
-		this.registerValue(getNodeIdsValueId(0, 0).property, {
-			internal: true,
-		});
-		this.registerValue(getEndpointsValueId(0, 0).property, {
-			internal: true,
-		});
-	}
-
 	public determineRequiredCCInterviews(): readonly CommandClasses[] {
 		// MultiChannelAssociationCC must be interviewed after Z-Wave+ if that is supported
 		return [
@@ -350,7 +328,11 @@ export class MultiChannelAssociationCC extends CommandClass {
 		return (
 			applHost
 				.getValueDB(endpoint.nodeId)
-				.getValue(getGroupCountValueId(endpoint.index)) || 0
+				.getValue(
+					MultiChannelAssociationCCValues.groupCount.endpoint(
+						endpoint.index,
+					),
+				) || 0
 		);
 	}
 
@@ -366,7 +348,11 @@ export class MultiChannelAssociationCC extends CommandClass {
 		return (
 			applHost
 				.getValueDB(endpoint.nodeId)
-				.getValue(getMaxNodesValueId(endpoint.index, groupId)) ?? 0
+				.getValue(
+					MultiChannelAssociationCCValues.maxNodes(groupId).endpoint(
+						endpoint.index,
+					),
+				) ?? 0
 		);
 	}
 
@@ -386,13 +372,17 @@ export class MultiChannelAssociationCC extends CommandClass {
 			// Add all node destinations
 			const nodes =
 				valueDB.getValue<number[]>(
-					getNodeIdsValueId(endpoint.index, i),
+					MultiChannelAssociationCCValues.nodeIds(i).endpoint(
+						endpoint.index,
+					),
 				) ?? [];
 			groupDestinations.push(...nodes.map((nodeId) => ({ nodeId })));
 			// And all endpoint destinations
 			const endpoints =
 				valueDB.getValue<EndpointAddress[]>(
-					getEndpointsValueId(endpoint.index, i),
+					MultiChannelAssociationCCValues.endpoints(i).endpoint(
+						endpoint.index,
+					),
 				) ?? [];
 			for (const ep of endpoints) {
 				if (typeof ep.endpoint === "number") {
@@ -491,16 +481,17 @@ export class MultiChannelAssociationCC extends CommandClass {
 		).withOptions({
 			priority: MessagePriority.NodeQuery,
 		});
-		const valueDB = this.getValueDB(applHost);
 
 		const mcGroupCount: number =
-			valueDB.getValue(getGroupCountValueId(this.endpointIndex)) ?? 0;
+			this.getValue(
+				applHost,
+				MultiChannelAssociationCCValues.groupCount,
+			) ?? 0;
 
 		// Some devices report more association groups than multi channel association groups, so we need this info here
-		const assocGroupCount =
-			valueDB.getValue<number>(
-				getAssociationGroupCountValueId(this.endpointIndex),
-			) || mcGroupCount;
+		const assocGroupCount: number =
+			this.getValue(applHost, AssociationCCValues.groupCount) ||
+			mcGroupCount;
 
 		// Then query each multi channel association group
 		for (let groupId = 1; groupId <= mcGroupCount; groupId++) {
@@ -721,50 +712,50 @@ export class MultiChannelAssociationCCReport extends MultiChannelAssociationCC {
 		super(host, options);
 
 		validatePayload(this.payload.length >= 3);
-		this._groupId = this.payload[0];
-		this._maxNodes = this.payload[1];
-		this._reportsToFollow = this.payload[2];
+		this.groupId = this.payload[0];
+		this.maxNodes = this.payload[1];
+		this.reportsToFollow = this.payload[2];
 		({ nodeIds: this._nodeIds, endpoints: this._endpoints } =
 			deserializeMultiChannelAssociationDestination(
 				this.payload.slice(3),
 			));
 	}
 
-	private _groupId: number;
-	public get groupId(): number {
-		return this._groupId;
-	}
+	public readonly groupId: number;
 
-	private _maxNodes: number;
-	@ccValue({ internal: true })
-	public get maxNodes(): number {
-		return this._maxNodes;
-	}
+	@ccValue(
+		MultiChannelAssociationCCValues.maxNodes,
+		(self: MultiChannelAssociationCCReport) => [self.groupId] as const,
+	)
+	public readonly maxNodes: number;
 
 	private _nodeIds: number[];
-	@ccValue({ internal: true })
+	@ccValue(
+		MultiChannelAssociationCCValues.nodeIds,
+		(self: MultiChannelAssociationCCReport) => [self.groupId] as const,
+	)
 	public get nodeIds(): readonly number[] {
 		return this._nodeIds;
 	}
 
 	private _endpoints: EndpointAddress[];
-	@ccValue({ internal: true })
+	@ccValue(
+		MultiChannelAssociationCCValues.endpoints,
+		(self: MultiChannelAssociationCCReport) => [self.groupId] as const,
+	)
 	public get endpoints(): readonly EndpointAddress[] {
 		return this._endpoints;
 	}
 
-	private _reportsToFollow: number;
-	public get reportsToFollow(): number {
-		return this._reportsToFollow;
-	}
+	public readonly reportsToFollow: number;
 
 	public getPartialCCSessionId(): Record<string, any> | undefined {
 		// Distinguish sessions by the association group ID
-		return { groupId: this._groupId };
+		return { groupId: this.groupId };
 	}
 
 	public expectMoreMessages(): boolean {
-		return this._reportsToFollow > 0;
+		return this.reportsToFollow > 0;
 	}
 
 	public mergePartialCCs(
@@ -773,11 +764,11 @@ export class MultiChannelAssociationCCReport extends MultiChannelAssociationCC {
 	): void {
 		// Concat the list of nodes
 		this._nodeIds = [...partials, this]
-			.map((report) => report._nodeIds)
+			.map((report) => [...report.nodeIds])
 			.reduce((prev, cur) => prev.concat(...cur), []);
 		// Concat the list of endpoints
 		this._endpoints = [...partials, this]
-			.map((report) => report._endpoints)
+			.map((report) => [...report.endpoints])
 			.reduce((prev, cur) => prev.concat(...cur), []);
 	}
 
@@ -849,14 +840,11 @@ export class MultiChannelAssociationCCSupportedGroupingsReport extends MultiChan
 		super(host, options);
 
 		validatePayload(this.payload.length >= 1);
-		this._groupCount = this.payload[0];
+		this.groupCount = this.payload[0];
 	}
 
-	private _groupCount: number;
-	@ccValue({ internal: true })
-	public get groupCount(): number {
-		return this._groupCount;
-	}
+	@ccValue(MultiChannelAssociationCCValues.groupCount)
+	public readonly groupCount: number;
 
 	public toLogEntry(applHost: ZWaveApplicationHost): MessageOrCCLogEntry {
 		return {
diff --git a/packages/cc/src/cc/MultiChannelCC.ts b/packages/cc/src/cc/MultiChannelCC.ts
index d3e2458a173..07a88f7aed3 100644
--- a/packages/cc/src/cc/MultiChannelCC.ts
+++ b/packages/cc/src/cc/MultiChannelCC.ts
@@ -12,7 +12,6 @@ import {
 	parseApplicationNodeInformation,
 	parseBitMask,
 	validatePayload,
-	ValueID,
 	ZWaveError,
 	ZWaveErrorCodes,
 } from "@zwave-js/core/safe";
@@ -21,74 +20,101 @@ import { num2hex } from "@zwave-js/shared/safe";
 import { validateArgs } from "@zwave-js/transformers";
 import { CCAPI } from "../lib/API";
 import {
-	ccKeyValuePair,
-	ccValue,
 	CommandClass,
 	gotDeserializationOptions,
 	type CCCommandOptions,
 	type CommandClassDeserializationOptions,
-	type CommandClassOptions,
 } from "../lib/CommandClass";
 import {
 	API,
 	CCCommand,
+	ccValue,
+	ccValues,
 	commandClass,
 	expectedCCResponse,
 	implementedVersion,
 } from "../lib/CommandClassDecorators";
+import { V } from "../lib/Values";
 import { MultiChannelCommand } from "../lib/_Types";
 
 // TODO: Handle removal reports of dynamic endpoints
 
-// @noSetValueAPI
-
-export function getEndpointIndizesValueId(): ValueID {
-	return {
-		commandClass: CommandClasses["Multi Channel"],
-		property: "endpointIndizes",
-	};
-}
-
-export function getEndpointCCsValueId(endpointIndex: number): ValueID {
-	return {
-		commandClass: CommandClasses["Multi Channel"],
-		endpoint: endpointIndex,
-		property: "commandClasses",
-	};
-}
-
-export function getEndpointDeviceClassValueId(endpointIndex: number): ValueID {
-	return {
-		commandClass: CommandClasses["Multi Channel"],
-		endpoint: endpointIndex,
-		property: "deviceClass",
-	};
-}
+export const MultiChannelCCValues = Object.freeze({
+	...V.defineStaticCCValues(CommandClasses["Multi Channel"], {
+		...V.staticProperty("endpointIndizes", undefined, {
+			internal: true,
+			supportsEndpoints: false,
+		}),
+
+		...V.staticPropertyWithName(
+			"individualEndpointCount",
+			"individualCount",
+			undefined,
+			{
+				internal: true,
+				supportsEndpoints: false,
+			},
+		),
+
+		...V.staticPropertyWithName(
+			"aggregatedEndpointCount",
+			"aggregatedCount",
+			undefined,
+			{
+				internal: true,
+				supportsEndpoints: false,
+			},
+		),
+
+		...V.staticPropertyWithName(
+			"endpointCountIsDynamic",
+			"countIsDynamic",
+			undefined,
+			{
+				internal: true,
+				supportsEndpoints: false,
+			},
+		),
+
+		...V.staticPropertyWithName(
+			"endpointsHaveIdenticalCapabilities",
+			"identicalCapabilities",
+			undefined,
+			{
+				internal: true,
+				supportsEndpoints: false,
+			},
+		),
+
+		...V.staticPropertyWithName(
+			"endpointCCs",
+			"commandClasses",
+			undefined,
+			{ internal: true },
+		),
+
+		...V.staticPropertyWithName(
+			"endpointDeviceClass",
+			"deviceClass",
+			undefined,
+			{ internal: true },
+		),
+	}),
+
+	...V.defineDynamicCCValues(CommandClasses["Multi Channel"], {
+		...V.dynamicPropertyAndKeyWithName(
+			"aggregatedEndpointMembers",
+			"members",
+			(endpointIndex: number) => endpointIndex,
+			({ property, propertyKey }) =>
+				property === "members" && typeof propertyKey === "number",
+			undefined,
+			{ internal: true },
+		),
+	}),
+});
 
-export function getCountIsDynamicValueId(): ValueID {
-	return {
-		commandClass: CommandClasses["Multi Channel"],
-		property: "countIsDynamic",
-	};
-}
-export function getIdenticalCapabilitiesValueId(): ValueID {
-	return {
-		commandClass: CommandClasses["Multi Channel"],
-		property: "identicalCapabilities",
-	};
-}
-export function getIndividualCountValueId(): ValueID {
-	return {
-		commandClass: CommandClasses["Multi Channel"],
-		property: "individualCount",
-	};
-}
-export function getAggregatedCountValueId(): ValueID {
-	return {
-		commandClass: CommandClasses["Multi Channel"],
-		property: "aggregatedCount",
-	};
-}
+// @noSetValueAPI
 
 /**
  * Many devices unnecessarily use endpoints when they could (or do) provide all functionality via the root device.
@@ -102,7 +128,8 @@ function areAllEndpointsDifferent(
 	// Endpoints are useless if all of them have different device classes
 	const deviceClasses = new Set<number>();
 	for (const endpoint of endpointIndizes) {
-		const devClassValueId = getEndpointDeviceClassValueId(endpoint);
+		const devClassValueId =
+			MultiChannelCCValues.endpointDeviceClass.endpoint(endpoint);
 		const deviceClass = applHost.getValueDB(node.id).getValue<{
 			generic: number;
 			specific: number;
@@ -317,22 +344,10 @@ export interface EndpointCapability {
 
 @commandClass(CommandClasses["Multi Channel"])
 @implementedVersion(4)
+@ccValues(MultiChannelCCValues)
 export class MultiChannelCC extends CommandClass {
 	declare ccCommand: MultiChannelCommand;
 
-	public constructor(host: ZWaveHost, options: CommandClassOptions) {
-		super(host, options);
-		this.registerValue(getEndpointIndizesValueId().property, {
-			internal: true,
-		});
-		this.registerValue(getEndpointCCsValueId(0).property, {
-			internal: true,
-		});
-		this.registerValue(getEndpointDeviceClassValueId(0).property, {
-			internal: true,
-		});
-	}
-
 	/** Tests if a command targets a specific endpoint and thus requires encapsulation */
 	public static requiresEncapsulation(cc: CommandClass): boolean {
 		return (
@@ -508,16 +523,21 @@ identical capabilities:      ${multiResponse.identicalCapabilities}`;
 
 				// copy the capabilities from the first endpoint
 				const devClass = valueDB.getValue(
-					getEndpointDeviceClassValueId(allEndpoints[0]),
+					MultiChannelCCValues.endpointDeviceClass.endpoint(
+						allEndpoints[0],
+					),
 				);
 				valueDB.setValue(
-					getEndpointDeviceClassValueId(endpoint),
+					MultiChannelCCValues.endpointDeviceClass.endpoint(endpoint),
 					devClass,
 				);
 				const ep1Caps = valueDB.getValue<CommandClasses[]>(
-					getEndpointCCsValueId(allEndpoints[0]),
+					MultiChannelCCValues.endpointCCs.endpoint(allEndpoints[0]),
 				)!;
-				valueDB.setValue(getEndpointCCsValueId(endpoint), [...ep1Caps]);
+				valueDB.setValue(
+					MultiChannelCCValues.endpointCCs.endpoint(endpoint),
+					[...ep1Caps],
+				);
 
 				continue;
 			}
@@ -583,7 +603,11 @@ supported CCs:`;
 				});
 			}
 		}
-		valueDB.setValue(getEndpointIndizesValueId(), allEndpoints);
+		this.setValue(
+			applHost,
+			MultiChannelCCValues.endpointIndizes,
+			allEndpoints,
+		);
 
 		// Remember that the interview is complete
 		this.setInterviewComplete(applHost, true);
@@ -638,12 +662,28 @@ supported CCs:`;
 		// Store the collected information
 		// We have only individual and no dynamic and no aggregated endpoints
 		const numEndpoints = Math.max(...endpointCounts.values());
-		valueDB.setValue(getCountIsDynamicValueId(), false);
-		valueDB.setValue(getAggregatedCountValueId(), 0);
-		valueDB.setValue(getIndividualCountValueId(), numEndpoints);
+		this.setValue(
+			applHost,
+			MultiChannelCCValues.endpointCountIsDynamic,
+			false,
+		);
+		this.setValue(
+			applHost,
+			MultiChannelCCValues.aggregatedEndpointCount,
+			0,
+		);
+		this.setValue(
+			applHost,
+			MultiChannelCCValues.individualEndpointCount,
+			numEndpoints,
+		);
 		// Since we queried all CCs separately, we can assume that all
 		// endpoints have different capabilities
-		valueDB.setValue(getIdenticalCapabilitiesValueId(), false);
+		this.setValue(
+			applHost,
+			MultiChannelCCValues.endpointsHaveIdenticalCapabilities,
+			false,
+		);
 
 		for (let endpoint = 1; endpoint <= numEndpoints; endpoint++) {
 			// Check which CCs exist on this endpoint
@@ -651,7 +691,10 @@ supported CCs:`;
 				.filter(([, ccEndpoints]) => ccEndpoints >= endpoint)
 				.map(([ccId]) => ccId);
 			// And store it per endpoint
-			valueDB.setValue(getEndpointCCsValueId(endpoint), endpointCCs);
+			valueDB.setValue(
+				MultiChannelCCValues.endpointCCs.endpoint(endpoint),
+				endpointCCs,
+			);
 		}
 
 		// Remember that the interview is complete
@@ -668,37 +711,25 @@ export class MultiChannelCCEndPointReport extends MultiChannelCC {
 		super(host, options);
 
 		validatePayload(this.payload.length >= 2);
-		this._countIsDynamic = !!(this.payload[0] & 0b10000000);
-		this._identicalCapabilities = !!(this.payload[0] & 0b01000000);
-		this._individualCount = this.payload[1] & 0b01111111;
+		this.countIsDynamic = !!(this.payload[0] & 0b10000000);
+		this.identicalCapabilities = !!(this.payload[0] & 0b01000000);
+		this.individualCount = this.payload[1] & 0b01111111;
 		if (this.version >= 4 && this.payload.length >= 3) {
-			this._aggregatedCount = this.payload[2] & 0b01111111;
+			this.aggregatedCount = this.payload[2] & 0b01111111;
 		}
 	}
 
-	private _countIsDynamic: boolean;
-	@ccValue({ internal: true })
-	public get countIsDynamic(): boolean {
-		return this._countIsDynamic;
-	}
+	@ccValue(MultiChannelCCValues.endpointCountIsDynamic)
+	public readonly countIsDynamic: boolean;
 
-	private _identicalCapabilities: boolean;
-	@ccValue({ internal: true })
-	public get identicalCapabilities(): boolean {
-		return this._identicalCapabilities;
-	}
+	@ccValue(MultiChannelCCValues.endpointsHaveIdenticalCapabilities)
+	public readonly identicalCapabilities: boolean;
 
-	private _individualCount: number;
-	@ccValue({ internal: true })
-	public get individualCount(): number {
-		return this._individualCount;
-	}
+	@ccValue(MultiChannelCCValues.individualEndpointCount)
+	public readonly individualCount: number;
 
-	private _aggregatedCount: number | undefined;
-	@ccValue({ internal: true })
-	public get aggregatedCount(): number | undefined {
-		return this._aggregatedCount;
-	}
+	@ccValue(MultiChannelCCValues.aggregatedEndpointCount)
+	public readonly aggregatedCount: number | undefined;
 
 	public toLogEntry(applHost: ZWaveApplicationHost): MessageOrCCLogEntry {
 		const message: MessageRecord = {
@@ -752,22 +783,19 @@ export class MultiChannelCCCapabilityReport
 
 	public persistValues(applHost: ZWaveApplicationHost): boolean {
 		if (!super.persistValues(applHost)) return false;
-		const valueDB = this.getValueDB(applHost);
 
-		const deviceClassValueId = getEndpointDeviceClassValueId(
-			this.endpointIndex,
-		);
-		const ccsValueId = getEndpointCCsValueId(this.endpointIndex);
+		const deviceClassValue = MultiChannelCCValues.endpointDeviceClass;
+		const ccsValue = MultiChannelCCValues.endpointCCs;
 
 		if (this.wasRemoved) {
-			valueDB.removeValue(deviceClassValueId);
-			valueDB.removeValue(ccsValueId);
+			this.removeValue(applHost, deviceClassValue);
+			this.removeValue(applHost, ccsValue);
 		} else {
-			valueDB.setValue(deviceClassValueId, {
+			this.setValue(applHost, deviceClassValue, {
 				generic: this.genericDeviceClass,
 				specific: this.specificDeviceClass,
 			});
-			valueDB.setValue(ccsValueId, this.supportedCCs);
+			this.setValue(applHost, ccsValue, this.supportedCCs);
 		}
 		return true;
 	}
@@ -985,30 +1013,27 @@ export class MultiChannelCCAggregatedMembersReport extends MultiChannelCC {
 		super(host, options);
 
 		validatePayload(this.payload.length >= 2);
-		const endpoint = this.payload[0] & 0b0111_1111;
+		this.aggregatedEndpointIndex = this.payload[0] & 0b0111_1111;
 		const bitMaskLength = this.payload[1];
 		validatePayload(this.payload.length >= 2 + bitMaskLength);
 		const bitMask = this.payload.slice(2, 2 + bitMaskLength);
-		const members = parseBitMask(bitMask);
-		this.aggregatedEndpointMembers = [endpoint, members];
+		this.members = parseBitMask(bitMask);
 	}
 
-	@ccKeyValuePair({ internal: true })
-	private aggregatedEndpointMembers: [number, number[]];
-
-	public get aggregatedEndpoint(): number {
-		return this.aggregatedEndpointMembers[0];
-	}
+	public readonly aggregatedEndpointIndex: number;
 
-	public get members(): readonly number[] {
-		return this.aggregatedEndpointMembers[1];
-	}
+	@ccValue(
+		MultiChannelCCValues.aggregatedEndpointMembers,
+		(self: MultiChannelCCAggregatedMembersReport) =>
+			[self.aggregatedEndpointIndex] as const,
+	)
+	public readonly members: readonly number[];
 
 	public toLogEntry(applHost: ZWaveApplicationHost): MessageOrCCLogEntry {
 		return {
 			...super.toLogEntry(applHost),
 			message: {
-				endpoint: this.endpointIndex,
+				"aggregated endpoint": this.aggregatedEndpointIndex,
 				members: this.members.join(", "),
 			},
 		};
diff --git a/packages/cc/src/cc/MultilevelSensorCC.ts b/packages/cc/src/cc/MultilevelSensorCC.ts
index 4bf8970e2ed..c2df6f95056 100644
--- a/packages/cc/src/cc/MultilevelSensorCC.ts
+++ b/packages/cc/src/cc/MultilevelSensorCC.ts
@@ -27,8 +27,6 @@ import {
 	throwUnsupportedProperty,
 } from "../lib/API";
 import {
-	ccKeyValuePair,
-	ccValue,
 	CommandClass,
 	gotDeserializationOptions,
 	type CCCommandOptions,
@@ -38,12 +36,50 @@ import {
 import {
 	API,
 	CCCommand,
+	ccValue,
+	ccValues,
 	commandClass,
 	expectedCCResponse,
 	implementedVersion,
 } from "../lib/CommandClassDecorators";
+import { V } from "../lib/Values";
 import { MultilevelSensorCommand, MultilevelSensorValue } from "../lib/_Types";
 
+export const MultilevelSensorCCValues = Object.freeze({
+	...V.defineStaticCCValues(CommandClasses["Multilevel Sensor"], {
+		...V.staticProperty("supportedSensorTypes", undefined, {
+			internal: true,
+		}),
+	}),
+
+	...V.defineDynamicCCValues(CommandClasses["Multilevel Sensor"], {
+		...V.dynamicPropertyAndKeyWithName(
+			"supportedScales",
+			"supportedScales",
+			(sensorType: number) => sensorType,
+			({ property, propertyKey }) =>
+				property === "supportedScales" &&
+				typeof propertyKey === "number",
+			undefined,
+			{ internal: true },
+		),
+
+		...V.dynamicPropertyWithName(
+			"value",
+			// This should have been the sensor type, but it is too late to change now
+			// Maybe we can migrate this without breaking in the future
+			(sensorTypeName: string) => sensorTypeName,
+			({ property }) => typeof property === "string",
+			(sensorTypeName: string) =>
+				({
+					// Just the base metadata, to be extended using a config manager
+					...ValueMetadata.ReadOnlyNumber,
+					label: sensorTypeName,
+				} as const),
+		),
+	}),
+});
+
 /**
  * Determine the scale to use to query a sensor reading. Uses the user-preferred scale if given,
  * otherwise falls back to the first supported one.
@@ -120,25 +156,6 @@ function getPreferredSensorScale(
 	}
 }
 
-export function getSupportedSensorTypesValueId(endpoint: number): ValueID {
-	return {
-		commandClass: CommandClasses["Multilevel Sensor"],
-		endpoint: endpoint,
-		property: "supportedSensorTypes",
-	};
-}
-export function getSupportedScalesValueId(
-	endpoint: number,
-	sensorType: number,
-): ValueID {
-	return {
-		commandClass: CommandClasses["Multilevel Sensor"],
-		endpoint: endpoint,
-		property: "supportedScales",
-		propertyKey: sensorType,
-	};
-}
-
 // @noSetValueAPI This CC is read-only
 
 @API(CommandClasses["Multilevel Sensor"])
@@ -292,7 +309,7 @@ export class MultilevelSensorCCAPI extends PhysicalCCAPI {
 				cc,
 				this.commandOptions,
 			);
-		return response?.sensorSupportedScales;
+		return response?.supportedScales;
 	}
 
 	@validateArgs()
@@ -319,6 +336,7 @@ export class MultilevelSensorCCAPI extends PhysicalCCAPI {
 
 @commandClass(CommandClasses["Multilevel Sensor"])
 @implementedVersion(11)
+@ccValues(MultilevelSensorCCValues)
 export class MultilevelSensorCC extends CommandClass {
 	declare ccCommand: MultilevelSensorCommand;
 
@@ -535,7 +553,6 @@ export class MultilevelSensorCCReport extends MultilevelSensorCC {
 
 	public persistValues(applHost: ZWaveApplicationHost): boolean {
 		if (!super.persistValues(applHost)) return false;
-		const valueDB = this.getValueDB(applHost);
 
 		const sensorType = applHost.configManager.lookupSensorType(this.type);
 		const scale = applHost.configManager.lookupSensorScale(
@@ -558,8 +575,9 @@ export class MultilevelSensorCCReport extends MultilevelSensorCC {
 
 			// Filter out unsupported sensor types and scales if possible
 			if (this.version >= 5) {
-				const supportedSensorTypes = valueDB.getValue<number[]>(
-					getSupportedSensorTypesValueId(this.endpointIndex),
+				const supportedSensorTypes = this.getValue<number[]>(
+					applHost,
+					MultilevelSensorCCValues.supportedSensorTypes,
 				);
 				if (supportedSensorTypes?.length) {
 					validatePayload.withReason(
@@ -569,8 +587,9 @@ export class MultilevelSensorCCReport extends MultilevelSensorCC {
 					)(supportedSensorTypes.includes(this.type));
 				}
 
-				const supportedScales = valueDB.getValue<number[]>(
-					getSupportedScalesValueId(this.endpointIndex, this.type),
+				const supportedScales = this.getValue<number[]>(
+					applHost,
+					MultilevelSensorCCValues.supportedScales(this.type),
 				);
 				if (supportedScales?.length) {
 					validatePayload.withReason(
@@ -581,21 +600,18 @@ export class MultilevelSensorCCReport extends MultilevelSensorCC {
 		}
 
 		const typeName = applHost.configManager.getSensorTypeName(this.type);
-		const valueId: ValueID = {
-			commandClass: this.ccId,
-			endpoint: this.endpointIndex,
-			property: typeName,
-		};
-		valueDB.setMetadata(valueId, {
-			...ValueMetadata.ReadOnlyNumber,
+		const sensorValue = MultilevelSensorCCValues.value(typeName);
+
+		this.setMetadata(applHost, sensorValue, {
+			...sensorValue.meta,
 			unit: scale.unit,
-			label: typeName,
 			ccSpecific: {
 				sensorType: this.type,
 				scale: scale.key,
 			},
 		});
-		valueDB.setValue(valueId, this.value);
+		this.setValue(applHost, sensorValue, this.value);
+
 		return true;
 	}
 
@@ -719,15 +735,12 @@ export class MultilevelSensorCCSupportedSensorReport extends MultilevelSensorCC
 	) {
 		super(host, options);
 		validatePayload(this.payload.length >= 1);
-		this._supportedSensorTypes = parseBitMask(this.payload);
+		this.supportedSensorTypes = parseBitMask(this.payload);
 	}
 
-	private _supportedSensorTypes: number[];
 	// TODO: Use this during interview to precreate values
-	@ccValue({ internal: true })
-	public get supportedSensorTypes(): readonly number[] {
-		return this._supportedSensorTypes;
-	}
+	@ccValue(MultilevelSensorCCValues.supportedSensorTypes)
+	public readonly supportedSensorTypes: readonly number[];
 
 	public toLogEntry(applHost: ZWaveApplicationHost): MessageOrCCLogEntry {
 		return {
@@ -759,24 +772,21 @@ export class MultilevelSensorCCSupportedScaleReport extends MultilevelSensorCC {
 		super(host, options);
 
 		validatePayload(this.payload.length >= 2);
-		const sensorType = this.payload[0];
-		const supportedScales = parseBitMask(
+		this.sensorType = this.payload[0];
+		this.supportedScales = parseBitMask(
 			Buffer.from([this.payload[1] & 0b1111]),
 			0,
 		);
-		this.supportedScales = [sensorType, supportedScales];
 	}
 
-	@ccKeyValuePair({ internal: true })
-	private supportedScales: [number, number[]];
-
-	public get sensorType(): number {
-		return this.supportedScales[0];
-	}
+	public readonly sensorType: number;
 
-	public get sensorSupportedScales(): readonly number[] {
-		return this.supportedScales[1];
-	}
+	@ccValue(
+		MultilevelSensorCCValues.supportedScales,
+		(self: MultilevelSensorCCSupportedScaleReport) =>
+			[self.sensorType] as const,
+	)
+	public readonly supportedScales: readonly number[];
 
 	public toLogEntry(applHost: ZWaveApplicationHost): MessageOrCCLogEntry {
 		return {
@@ -785,7 +795,7 @@ export class MultilevelSensorCCSupportedScaleReport extends MultilevelSensorCC {
 				"sensor type": applHost.configManager.getSensorTypeName(
 					this.sensorType,
 				),
-				"supported scales": this.sensorSupportedScales
+				"supported scales": this.supportedScales
 					.map(
 						(s) =>
 							`\n· ${
diff --git a/packages/cc/src/cc/MultilevelSwitchCC.ts b/packages/cc/src/cc/MultilevelSwitchCC.ts
index 31f65e53aad..a0dc227506d 100644
--- a/packages/cc/src/cc/MultilevelSwitchCC.ts
+++ b/packages/cc/src/cc/MultilevelSwitchCC.ts
@@ -9,7 +9,6 @@ import {
 	parseNumber,
 	unknownNumber,
 	validatePayload,
-	ValueID,
 	ValueMetadata,
 } from "@zwave-js/core/safe";
 import type { ZWaveApplicationHost, ZWaveHost } from "@zwave-js/host/safe";
@@ -25,21 +24,21 @@ import {
 	throwWrongValueType,
 } from "../lib/API";
 import {
-	ccValue,
-	ccValueMetadata,
 	CommandClass,
 	gotDeserializationOptions,
 	type CCCommandOptions,
 	type CommandClassDeserializationOptions,
-	type CommandClassOptions,
 } from "../lib/CommandClass";
 import {
 	API,
 	CCCommand,
+	ccValue,
+	ccValues,
 	commandClass,
 	expectedCCResponse,
 	implementedVersion,
 } from "../lib/CommandClassDecorators";
+import { V } from "../lib/Values";
 import {
 	LevelChangeDirection,
 	MultilevelSwitchCommand,
@@ -53,34 +52,119 @@ function switchTypeToActions(switchType: string): [down: string, up: string] {
 	if (!switchType.includes("/")) switchType = SwitchType[0x02]; // Down/Up
 	return switchType.split("/", 2) as any;
 }
+
+/**
+ * The property names are organized so that positive motions are at odd indices and negative motions at even indices
+ */
 const switchTypeProperties = Object.keys(SwitchType)
 	.filter((key) => key.indexOf("/") > -1)
 	.map((key) => switchTypeToActions(key))
 	.reduce<string[]>((acc, cur) => acc.concat(...cur), []);
 
-function getCurrentValueValueId(endpoint: number): ValueID {
-	return {
-		commandClass: CommandClasses["Multilevel Switch"],
-		endpoint,
-		property: "currentValue",
-	};
-}
+export const MultilevelSwitchCCValues = Object.freeze({
+	...V.defineStaticCCValues(CommandClasses["Multilevel Switch"], {
+		...V.staticProperty("currentValue", {
+			...ValueMetadata.ReadOnlyLevel,
+			label: "Current value",
+		} as const),
+
+		...V.staticProperty("targetValue", {
+			...ValueMetadata.Level,
+			label: "Target value",
+			valueChangeOptions: ["transitionDuration"],
+		} as const),
+
+		...V.staticProperty("duration", {
+			...ValueMetadata.ReadOnlyDuration,
+			label: "Remaining duration",
+		} as const),
+
+		...V.staticPropertyWithName(
+			"compatEvent",
+			"event",
+			{
+				...ValueMetadata.ReadOnlyUInt8,
+				label: "Event value",
+			} as const,
+			{
+				stateful: false,
+				autoCreate: (applHost, endpoint) =>
+					!!applHost.getDeviceConfig?.(endpoint.nodeId)?.compat
+						?.treatMultilevelSwitchSetAsEvent,
+			},
+		),
 
-/** Returns the ValueID used to remember whether a node supports supervision on the start/stop level change commands*/
-function getSuperviseStartStopLevelChangeValueId(): ValueID {
-	return {
-		commandClass: CommandClasses["Multilevel Switch"],
-		property: "superviseStartStopLevelChange",
-	};
-}
+		...V.staticProperty("switchType", undefined, { internal: true }),
 
-export function getCompatEventValueId(endpoint?: number): ValueID {
-	return {
-		commandClass: CommandClasses["Multilevel Switch"],
-		endpoint,
-		property: "event",
-	};
-}
+		// TODO: Solve this differently
+		...V.staticProperty("superviseStartStopLevelChange", undefined, {
+			internal: true,
+			supportsEndpoints: false,
+		}),
+	}),
+
+	...V.defineDynamicCCValues(CommandClasses["Multilevel Switch"], {
+		...V.dynamicPropertyWithName(
+			"levelChangeUp",
+			// This is called "up" here, but the actual property name will depend on
+			// the given switch type
+			(switchType: SwitchType) => {
+				const switchTypeName = getEnumMemberName(
+					SwitchType,
+					switchType,
+				);
+				const [, up] = switchTypeToActions(switchTypeName);
+				return up;
+			},
+			({ property }) =>
+				typeof property === "string" &&
+				switchTypeProperties.indexOf(property) % 2 === 1,
+			(switchType: SwitchType) => {
+				const switchTypeName = getEnumMemberName(
+					SwitchType,
+					switchType,
+				);
+				const [, up] = switchTypeToActions(switchTypeName);
+				return {
+					...ValueMetadata.Boolean,
+					label: `Perform a level change (${up})`,
+					valueChangeOptions: ["transitionDuration"],
+					ccSpecific: { switchType },
+				} as const;
+			},
+		),
+
+		...V.dynamicPropertyWithName(
+			"levelChangeDown",
+			// This is called "down" here, but the actual property name will depend on
+			// the given switch type
+			(switchType: SwitchType) => {
+				const switchTypeName = getEnumMemberName(
+					SwitchType,
+					switchType,
+				);
+				const [down] = switchTypeToActions(switchTypeName);
+				return down;
+			},
+			({ property }) =>
+				typeof property === "string" &&
+				switchTypeProperties.indexOf(property) % 2 === 0,
+			(switchType: SwitchType) => {
+				const switchTypeName = getEnumMemberName(
+					SwitchType,
+					switchType,
+				);
+				const [down] = switchTypeToActions(switchTypeName);
+				return {
+					...ValueMetadata.Boolean,
+					label: `Perform a level change (${down})`,
+					valueChangeOptions: ["transitionDuration"],
+					ccSpecific: { switchType },
+				} as const;
+			},
+		),
+	}),
+});
 
 @API(CommandClasses["Multilevel Switch"])
 export class MultilevelSwitchCCAPI extends CCAPI {
@@ -311,7 +395,9 @@ export class MultilevelSwitchCCAPI extends CCAPI {
 						value <= 99
 					) {
 						this.tryGetValueDB()?.setValue(
-							getCurrentValueValueId(this.endpoint.index),
+							MultilevelSwitchCCValues.currentValue.endpoint(
+								this.endpoint.index,
+							),
 							value,
 						);
 					}
@@ -352,7 +438,9 @@ export class MultilevelSwitchCCAPI extends CCAPI {
 							this.applHost
 								.tryGetValueDB(node.id)
 								?.setValue(
-									getCurrentValueValueId(this.endpoint.index),
+									MultilevelSwitchCCValues.currentValue.endpoint(
+										this.endpoint.index,
+									),
 									value,
 								);
 						}
@@ -392,7 +480,9 @@ export class MultilevelSwitchCCAPI extends CCAPI {
 				// even if the target node is going to ignore it. There might
 				// be some bugged devices that ignore the ignore start level flag.
 				const startLevel = this.tryGetValueDB()?.getValue<number>(
-					getCurrentValueValueId(this.endpoint.index),
+					MultilevelSwitchCCValues.currentValue.endpoint(
+						this.endpoint.index,
+					),
 				);
 				// And perform the level change
 				const duration = Duration.from(options?.transitionDuration);
@@ -426,16 +516,10 @@ export class MultilevelSwitchCCAPI extends CCAPI {
 
 @commandClass(CommandClasses["Multilevel Switch"])
 @implementedVersion(4)
+@ccValues(MultilevelSwitchCCValues)
 export class MultilevelSwitchCC extends CommandClass {
 	declare ccCommand: MultilevelSwitchCommand;
 
-	public constructor(host: ZWaveHost, options: CommandClassOptions) {
-		super(host, options);
-		this.registerValue(getSuperviseStartStopLevelChangeValueId().property, {
-			internal: true,
-		});
-	}
-
 	public async interview(applHost: ZWaveApplicationHost): Promise<void> {
 		const node = this.getNode(applHost)!;
 		const endpoint = this.getEndpoint(applHost)!;
@@ -484,14 +568,7 @@ export class MultilevelSwitchCC extends CommandClass {
 			applHost.getDeviceConfig?.(node.id)?.compat
 				?.treatMultilevelSwitchSetAsEvent
 		) {
-			const valueId = getCompatEventValueId(this.endpointIndex);
-			const valueDB = this.getValueDB(applHost);
-			if (!valueDB.hasMetadata(valueId)) {
-				valueDB.setMetadata(valueId, {
-					...ValueMetadata.ReadOnlyUInt8,
-					label: "Event value",
-				});
-			}
+			this.ensureMetadata(applHost, MultilevelSwitchCCValues.compatEvent);
 		}
 
 		// Remember that the interview is complete
@@ -521,14 +598,7 @@ export class MultilevelSwitchCC extends CommandClass {
 		applHost: ZWaveApplicationHost,
 		value: number,
 	): boolean {
-		this.getValueDB(applHost).setValue(
-			{
-				commandClass: this.ccId,
-				endpoint: this.endpointIndex,
-				property: "currentValue",
-			},
-			value,
-		);
+		this.setValue(applHost, MultilevelSwitchCCValues.currentValue, value);
 		return true;
 	}
 
@@ -537,38 +607,14 @@ export class MultilevelSwitchCC extends CommandClass {
 		// SDS13781: The Primary Switch Type SHOULD be 0x02 (Up/Down)
 		switchType: SwitchType = SwitchType["Down/Up"],
 	): void {
-		const valueDB = this.getValueDB(applHost);
-
-		// Create metadata for the control values if necessary
-		const switchTypeName = getEnumMemberName(SwitchType, switchType);
-		const [down, up] = switchTypeToActions(switchTypeName);
-		const upValueId: ValueID = {
-			commandClass: this.ccId,
-			endpoint: this.endpointIndex,
-			property: up,
-		};
-		const downValueId: ValueID = {
-			commandClass: this.ccId,
-			endpoint: this.endpointIndex,
-			property: down,
-		};
-
-		if (!valueDB.hasMetadata(upValueId)) {
-			valueDB.setMetadata(upValueId, {
-				...ValueMetadata.Boolean,
-				label: `Perform a level change (${up})`,
-				valueChangeOptions: ["transitionDuration"],
-				ccSpecific: { switchType },
-			});
-		}
-		if (!valueDB.hasMetadata(downValueId)) {
-			valueDB.setMetadata(downValueId, {
-				...ValueMetadata.Boolean,
-				label: `Perform a level change (${down})`,
-				valueChangeOptions: ["transitionDuration"],
-				ccSpecific: { switchType },
-			});
-		}
+		this.ensureMetadata(
+			applHost,
+			MultilevelSwitchCCValues.levelChangeUp(switchType),
+		);
+		this.ensureMetadata(
+			applHost,
+			MultilevelSwitchCCValues.levelChangeDown(switchType),
+		);
 	}
 }
 
@@ -653,27 +699,14 @@ export class MultilevelSwitchCCReport extends MultilevelSwitchCC {
 		return super.persistValues(applHost);
 	}
 
-	@ccValue({ forceCreation: true })
-	@ccValueMetadata({
-		...ValueMetadata.Level,
-		label: "Target value",
-		valueChangeOptions: ["transitionDuration"],
-	})
+	@ccValue(MultilevelSwitchCCValues.targetValue)
 	public readonly targetValue: number | undefined;
 
-	@ccValue()
-	@ccValueMetadata({
-		...ValueMetadata.ReadOnlyDuration,
-		label: "Remaining duration",
-	})
+	@ccValue(MultilevelSwitchCCValues.duration)
 	public readonly duration: Duration | undefined;
 
 	private _currentValue: Maybe<number> | undefined;
-	@ccValue()
-	@ccValueMetadata({
-		...ValueMetadata.ReadOnlyLevel,
-		label: "Current value",
-	})
+	@ccValue(MultilevelSwitchCCValues.currentValue)
 	public get currentValue(): Maybe<number> | undefined {
 		return this._currentValue;
 	}
@@ -788,19 +821,16 @@ export class MultilevelSwitchCCSupportedReport extends MultilevelSwitchCC {
 		super(host, options);
 
 		validatePayload(this.payload.length >= 2);
-		this._switchType = this.payload[0] & 0b11111;
+		this.switchType = this.payload[0] & 0b11111;
 	}
 
 	// This is the primary switch type. We're not supporting secondary switch types
-	private _switchType: SwitchType;
-	@ccValue({ internal: true })
-	public get switchType(): SwitchType {
-		return this._switchType;
-	}
+	@ccValue(MultilevelSwitchCCValues.switchType)
+	public readonly switchType: SwitchType;
 
 	public persistValues(applHost: ZWaveApplicationHost): boolean {
 		if (!super.persistValues(applHost)) return false;
-		this.createMetadataForLevelChangeActions(applHost, this._switchType);
+		this.createMetadataForLevelChangeActions(applHost, this.switchType);
 		return true;
 	}
 
diff --git a/packages/cc/src/cc/NodeNamingCC.ts b/packages/cc/src/cc/NodeNamingCC.ts
index 62a7bfb9ad1..394fdb530d5 100644
--- a/packages/cc/src/cc/NodeNamingCC.ts
+++ b/packages/cc/src/cc/NodeNamingCC.ts
@@ -2,11 +2,11 @@ import {
 	CommandClasses,
 	MessagePriority,
 	validatePayload,
+	ValueMetadata,
 	ZWaveError,
 	ZWaveErrorCodes,
 	type Maybe,
 	type MessageOrCCLogEntry,
-	type ValueID,
 } from "@zwave-js/core/safe";
 import type { ZWaveApplicationHost, ZWaveHost } from "@zwave-js/host/safe";
 import { validateArgs } from "@zwave-js/transformers";
@@ -21,7 +21,6 @@ import {
 	throwWrongValueType,
 } from "../lib/API";
 import {
-	ccValue,
 	CommandClass,
 	gotDeserializationOptions,
 	type CCCommandOptions,
@@ -30,30 +29,41 @@ import {
 import {
 	API,
 	CCCommand,
+	ccValue,
+	ccValues,
 	commandClass,
 	expectedCCResponse,
 	implementedVersion,
 } from "../lib/CommandClassDecorators";
+import { V } from "../lib/Values";
 import { NodeNamingAndLocationCommand } from "../lib/_Types";
 
+export const NodeNamingAndLocationCCValues = Object.freeze({
+	...V.defineStaticCCValues(CommandClasses["Node Naming and Location"], {
+		...V.staticProperty(
+			"name",
+			{
+				...ValueMetadata.String,
+				label: "Node name",
+			} as const,
+			{ supportsEndpoints: false },
+		),
+
+		...V.staticProperty(
+			"location",
+			{
+				...ValueMetadata.String,
+				label: "Node location",
+			} as const,
+			{ supportsEndpoints: false },
+		),
+	}),
+});
+
 function isASCII(str: string): boolean {
 	return /^[\x00-\x7F]*$/.test(str);
 }
 
-export function getNodeNameValueId(): ValueID {
-	return {
-		commandClass: CommandClasses["Node Naming and Location"],
-		property: "name",
-	};
-}
-
-export function getNodeLocationValueId(): ValueID {
-	return {
-		commandClass: CommandClasses["Node Naming and Location"],
-		property: "location",
-	};
-}
-
 @API(CommandClasses["Node Naming and Location"])
 export class NodeNamingAndLocationCCAPI extends PhysicalCCAPI {
 	public supportsCommand(cmd: NodeNamingAndLocationCommand): Maybe<boolean> {
@@ -170,6 +180,7 @@ export class NodeNamingAndLocationCCAPI extends PhysicalCCAPI {
 
 @commandClass(CommandClasses["Node Naming and Location"])
 @implementedVersion(1)
+@ccValues(NodeNamingAndLocationCCValues)
 export class NodeNamingAndLocationCC extends CommandClass {
 	declare ccCommand: NodeNamingAndLocationCommand;
 
@@ -302,7 +313,7 @@ export class NodeNamingAndLocationCCNameReport extends NodeNamingAndLocationCC {
 		this.name = nameBuffer.toString(encoding);
 	}
 
-	@ccValue({ internal: true })
+	@ccValue(NodeNamingAndLocationCCValues.name)
 	public readonly name: string;
 
 	public toLogEntry(applHost: ZWaveApplicationHost): MessageOrCCLogEntry {
@@ -389,7 +400,7 @@ export class NodeNamingAndLocationCCLocationReport extends NodeNamingAndLocation
 		this.location = locationBuffer.toString(encoding);
 	}
 
-	@ccValue({ internal: true })
+	@ccValue(NodeNamingAndLocationCCValues.location)
 	public readonly location: string;
 
 	public toLogEntry(applHost: ZWaveApplicationHost): MessageOrCCLogEntry {
diff --git a/packages/cc/src/cc/NotificationCC.ts b/packages/cc/src/cc/NotificationCC.ts
index 61dcb437ac0..2fa1cd0838d 100644
--- a/packages/cc/src/cc/NotificationCC.ts
+++ b/packages/cc/src/cc/NotificationCC.ts
@@ -1,5 +1,4 @@
 import {
-	ConfigManager,
 	Notification,
 	NotificationParameterWithCommandClass,
 	NotificationParameterWithDuration,
@@ -29,73 +28,113 @@ import { validateArgs } from "@zwave-js/transformers";
 import { isArray } from "alcalzone-shared/typeguards";
 import { CCAPI, PhysicalCCAPI } from "../lib/API";
 import {
-	ccValue,
 	CommandClass,
 	gotDeserializationOptions,
 	InvalidCC,
 	type CCCommandOptions,
 	type CommandClassDeserializationOptions,
-	type CommandClassOptions,
 } from "../lib/CommandClass";
 import {
 	API,
 	CCCommand,
+	ccValue,
+	ccValues,
 	commandClass,
 	expectedCCResponse,
 	implementedVersion,
 } from "../lib/CommandClassDecorators";
 import { isNotificationEventPayload } from "../lib/NotificationEventPayload";
 import * as ccUtils from "../lib/utils";
+import { V } from "../lib/Values";
 import { NotificationCommand, UserCodeCommand } from "../lib/_Types";
 
-/** Returns the ValueID used to store whether a node supports V1 Alarms */
-export function getSupportsV1AlarmValueId(): ValueID {
-	return {
-		commandClass: CommandClasses.Notification,
-		property: "supportsV1Alarm",
-	};
-}
-
-/** Returns the ValueID used to store the supported notification types of a node */
-export function getSupportedNotificationTypesValueId(): ValueID {
-	return {
-		commandClass: CommandClasses.Notification,
-		property: "supportedNotificationTypes",
-	};
-}
-
-/** Returns the ValueID used to store the supported notification events of a node */
-export function getSupportedNotificationEventsValueId(type: number): ValueID {
-	return {
-		commandClass: CommandClasses.Notification,
-		property: "supportedNotificationEvents",
-		propertyKey: type,
-	};
-}
-
-/** Returns the ValueID used to store whether a node supports push or pull */
-export function getNotificationModeValueId(): ValueID {
-	return {
-		commandClass: CommandClasses.Notification,
-		property: "notificationMode",
-	};
-}
-
-export function getAlarmTypeValueId(endpoint?: number): ValueID {
-	return {
-		commandClass: CommandClasses.Notification,
-		endpoint,
-		property: "alarmType",
-	};
-}
-
-export function getAlarmLevelValueId(endpoint?: number): ValueID {
-	return {
-		commandClass: CommandClasses.Notification,
-		endpoint,
-		property: "alarmLevel",
-	};
-}
+export const NotificationCCValues = Object.freeze({
+	...V.defineStaticCCValues(CommandClasses.Notification, {
+		...V.staticProperty("supportsV1Alarm", undefined, {
+			internal: true,
+			supportsEndpoints: false,
+		}),
+		...V.staticProperty("supportedNotificationTypes", undefined, {
+			internal: true,
+			supportsEndpoints: false,
+		}),
+		...V.staticProperty("notificationMode", undefined, {
+			internal: true,
+			supportsEndpoints: false,
+		}),
+
+		// V1 Alarm values
+		...V.staticProperty("alarmType", {
+			...ValueMetadata.ReadOnlyUInt8,
+			label: "Alarm Type",
+		} as const),
+		...V.staticProperty("alarmLevel", {
+			...ValueMetadata.ReadOnlyUInt8,
+			label: "Alarm Level",
+		} as const),
+	}),
+
+	...V.defineDynamicCCValues(CommandClasses.Notification, {
+		...V.dynamicPropertyAndKeyWithName(
+			"supportedNotificationEvents",
+			"supportedNotificationEvents",
+			(notificationType: number) => notificationType,
+			({ property, propertyKey }) =>
+				property === "supportedNotificationEvents" &&
+				typeof propertyKey === "number",
+			undefined,
+			{ internal: true, supportsEndpoints: false },
+		),
+
+		// Different variants of the V2 notification values:
+		// Unknown type
+		...V.dynamicPropertyWithName(
+			"unknownNotificationType",
+			(notificationType: number) =>
+				`UNKNOWN_${num2hex(notificationType)}`,
+			({ property }) =>
+				typeof property === "string" && /^UNKNOWN_0x/.test(property),
+			(notificationType: number) =>
+				({
+					...ValueMetadata.ReadOnlyUInt8,
+					label: `Unknown notification (${num2hex(
+						notificationType,
+					)})`,
+					ccSpecific: { notificationType },
+				} as const),
+		),
+
+		// Known type, unknown variable
+		...V.dynamicPropertyAndKeyWithName(
+			"unknownNotificationVariable",
+			(notificationType: number, notificationName: string) =>
+				notificationName,
+			"unknown",
+			({ property, propertyKey }) =>
+				typeof property === "string" && propertyKey === "unknown",
+			(notificationType: number, notificationName: string) =>
+				({
+					...ValueMetadata.ReadOnlyUInt8,
+					label: `${notificationName}: Unknown value`,
+					ccSpecific: { notificationType },
+				} as const),
+		),
+
+		// (Stateful) notification variable
+		...V.dynamicPropertyAndKeyWithName(
+			"notificationVariable",
+			// eslint-disable-next-line @typescript-eslint/no-unused-vars
+			(notificationName: string, variableName: string) =>
+				notificationName,
+			(notificationName: string, variableName: string) => variableName,
+			({ property, propertyKey }) =>
+				typeof property === "string" && typeof propertyKey === "string",
+
+			// Notification metadata is so dynamic, it does not make sense to define it here
+			undefined,
+		),
+	}),
+});
 
 function lookupNotificationNames(
 	applHost: ZWaveApplicationHost,
@@ -250,19 +289,6 @@ export class NotificationCCAPI extends PhysicalCCAPI {
 	}
 }
 
-/** Returns the metadata to use for a notification value with an unknown notification type */
-export function getNotificationValueMetadataUnknownType(
-	type: number,
-): ValueMetadataNumeric {
-	return {
-		...ValueMetadata.ReadOnlyUInt8,
-		label: `Unknown notification (${num2hex(type)})`,
-		ccSpecific: {
-			notificationType: type,
-		},
-	};
-}
-
 /**
  * Returns the metadata to use for a known notification value.
  * Can be used to extend a previously defined metadata,
@@ -288,74 +314,14 @@ export function getNotificationValueMetadata(
 	return metadata;
 }
 
-function defineMetadataForNotificationEvents(
-	configManager: ConfigManager,
-	endpoint: number,
-	type: number,
-	events: readonly number[],
-): ReadonlyMap<string, ValueMetadata> {
-	const ret = new Map<string, ValueMetadataNumeric>();
-	const notificationConfig = configManager.lookupNotification(type);
-	if (!notificationConfig) {
-		// This is an unknown notification
-		const property = `UNKNOWN_${num2hex(type)}`;
-		const valueId: ValueID = {
-			commandClass: CommandClasses.Notification,
-			endpoint,
-			property,
-		};
-		ret.set(
-			JSON.stringify(valueId),
-			getNotificationValueMetadataUnknownType(type),
-		);
-		return ret;
-	}
-
-	const property = notificationConfig.name;
-	for (const value of events) {
-		// Find out which property we need to update
-		const valueConfig = notificationConfig.lookupValue(value);
-		if (valueConfig?.type === "state") {
-			const valueId: ValueID = {
-				commandClass: CommandClasses.Notification,
-				endpoint,
-				property,
-				propertyKey: valueConfig.variableName,
-			};
-
-			const dictKey = JSON.stringify(valueId);
-			const metadata = getNotificationValueMetadata(
-				ret.get(dictKey),
-				notificationConfig,
-				valueConfig,
-			);
-			ret.set(dictKey, metadata);
-		}
-	}
-	return ret;
-}
-
 @commandClass(CommandClasses.Notification)
 @implementedVersion(8)
+@ccValues(NotificationCCValues)
 export class NotificationCC extends CommandClass {
 	declare ccCommand: NotificationCommand;
 
 	// former AlarmCC (v1..v2)
 
-	public constructor(host: ZWaveHost, options: CommandClassOptions) {
-		super(host, options);
-		// mark some value IDs as internal
-		this.registerValue(getNotificationModeValueId().property, {
-			internal: true,
-		});
-		this.registerValue(getSupportedNotificationTypesValueId().property, {
-			internal: true,
-		});
-		this.registerValue(getSupportedNotificationEventsValueId(0).property, {
-			internal: true,
-		});
-	}
-
 	public determineRequiredCCInterviews(): readonly CommandClasses[] {
 		return [
 			...super.determineRequiredCCInterviews(),
@@ -437,7 +403,7 @@ export class NotificationCC extends CommandClass {
 	): "push" | "pull" | undefined {
 		return applHost
 			.getValueDB(node.id)
-			.getValue(getNotificationModeValueId());
+			.getValue(NotificationCCValues.notificationMode.id);
 	}
 
 	public async interview(applHost: ZWaveApplicationHost): Promise<void> {
@@ -523,8 +489,9 @@ export class NotificationCC extends CommandClass {
 			}
 
 			// Determine whether the node is a push or pull node
-			let notificationMode = valueDB.getValue<"push" | "pull">(
-				getNotificationModeValueId(),
+			let notificationMode = this.getValue<"push" | "pull">(
+				applHost,
+				NotificationCCValues.notificationMode,
 			);
 			if (notificationMode !== "push" && notificationMode !== "pull") {
 				notificationMode = await this.determineNotificationMode(
@@ -532,8 +499,9 @@ export class NotificationCC extends CommandClass {
 					api,
 					supportedNotificationEvents,
 				);
-				valueDB.setValue(
-					getNotificationModeValueId(),
+				this.setValue(
+					applHost,
+					NotificationCCValues.notificationMode,
 					notificationMode,
 				);
 			}
@@ -596,14 +564,8 @@ export class NotificationCC extends CommandClass {
 
 		// Only create metadata for V1 values if necessary
 		if (this.version === 1 || supportsV1Alarm) {
-			valueDB.setMetadata(getAlarmTypeValueId(this.endpointIndex), {
-				...ValueMetadata.ReadOnlyUInt8,
-				label: "Alarm Type",
-			});
-			valueDB.setMetadata(getAlarmLevelValueId(this.endpointIndex), {
-				...ValueMetadata.ReadOnlyUInt8,
-				label: "Alarm Level",
-			});
+			this.ensureMetadata(applHost, NotificationCCValues.alarmType);
+			this.ensureMetadata(applHost, NotificationCCValues.alarmLevel);
 		}
 
 		// Remember that the interview is complete
@@ -622,12 +584,12 @@ export class NotificationCC extends CommandClass {
 			).withOptions({
 				priority: MessagePriority.NodeQuery,
 			});
-			const valueDB = this.getValueDB(applHost);
 
 			// Load supported notification types and events from cache
 			const supportedNotificationTypes =
-				valueDB.getValue<readonly number[]>(
-					getSupportedNotificationTypesValueId(),
+				this.getValue<readonly number[]>(
+					applHost,
+					NotificationCCValues.supportedNotificationTypes,
 				) ?? [];
 			const supportedNotificationNames = lookupNotificationNames(
 				applHost,
@@ -782,7 +744,6 @@ export class NotificationCCReport extends NotificationCC {
 
 	public persistValues(applHost: ZWaveApplicationHost): boolean {
 		if (!super.persistValues(applHost)) return false;
-		const valueDB = this.getValueDB(applHost);
 
 		// Check if we need to re-interpret the alarm values somehow
 		if (
@@ -793,16 +754,21 @@ export class NotificationCCReport extends NotificationCC {
 			if (this.version >= 2) {
 				// Check if the device actually supports Notification CC, but chooses
 				// to send Alarm frames instead (GH#1034)
-				const supportedNotificationTypes = valueDB.getValue<number[]>(
-					getSupportedNotificationTypesValueId(),
-				);
+				const supportedNotificationTypes = this.getValue<
+					readonly number[]
+				>(applHost, NotificationCCValues.supportedNotificationTypes);
 				if (
 					isArray(supportedNotificationTypes) &&
 					supportedNotificationTypes.includes(this.alarmType)
 				) {
-					const supportedNotificationEvents = valueDB.getValue<
-						number[]
-					>(getSupportedNotificationEventsValueId(this.alarmType));
+					const supportedNotificationEvents = this.getValue<
+						readonly number[]
+					>(
+						applHost,
+						NotificationCCValues.supportedNotificationEvents(
+							this.alarmType,
+						),
+					);
 					if (
 						isArray(supportedNotificationEvents) &&
 						supportedNotificationEvents.includes(this.alarmLevel)
@@ -858,24 +824,14 @@ export class NotificationCCReport extends NotificationCC {
 		this.parseEventParameters(applHost);
 
 		if (this.alarmType != undefined) {
-			const valueId = getAlarmTypeValueId(this.endpointIndex);
-			if (!valueDB.hasMetadata(valueId)) {
-				valueDB.setMetadata(valueId, {
-					...ValueMetadata.ReadOnlyUInt8,
-					label: "Alarm Type",
-				});
-			}
-			valueDB.setValue(valueId, this.alarmType);
+			const alarmTypeValue = NotificationCCValues.alarmType;
+			this.ensureMetadata(applHost, alarmTypeValue);
+			this.setValue(applHost, alarmTypeValue, this.alarmType);
 		}
 		if (this.alarmLevel != undefined) {
-			const valueId = getAlarmLevelValueId(this.endpointIndex);
-			if (!valueDB.hasMetadata(valueId)) {
-				valueDB.setMetadata(valueId, {
-					...ValueMetadata.ReadOnlyUInt8,
-					label: "Alarm Level",
-				});
-			}
-			valueDB.setValue(valueId, this.alarmLevel);
+			const alarmLevelValue = NotificationCCValues.alarmLevel;
+			this.ensureMetadata(applHost, alarmLevelValue);
+			this.setValue(applHost, alarmLevelValue, this.alarmLevel);
 		}
 
 		return true;
@@ -1230,31 +1186,25 @@ export class NotificationCCSupportedReport extends NotificationCC {
 		super(host, options);
 
 		validatePayload(this.payload.length >= 1);
-		this._supportsV1Alarm = !!(this.payload[0] & 0b1000_0000);
+		this.supportsV1Alarm = !!(this.payload[0] & 0b1000_0000);
 		const numBitMaskBytes = this.payload[0] & 0b0001_1111;
 		validatePayload(
 			numBitMaskBytes > 0,
 			this.payload.length >= 1 + numBitMaskBytes,
 		);
 		const notificationBitMask = this.payload.slice(1, 1 + numBitMaskBytes);
-		this._supportedNotificationTypes = parseBitMask(
+		this.supportedNotificationTypes = parseBitMask(
 			notificationBitMask,
 			// bit 0 is ignored, but counting still starts at 1, so the first bit must have the value 0
 			0,
 		);
 	}
 
-	private _supportsV1Alarm: boolean;
-	@ccValue({ internal: true })
-	public get supportsV1Alarm(): boolean {
-		return this._supportsV1Alarm;
-	}
+	@ccValue(NotificationCCValues.supportsV1Alarm)
+	public readonly supportsV1Alarm: boolean;
 
-	private _supportedNotificationTypes: number[];
-	@ccValue({ internal: true })
-	public get supportedNotificationTypes(): readonly number[] {
-		return this._supportedNotificationTypes;
-	}
+	@ccValue(NotificationCCValues.supportedNotificationTypes)
+	public readonly supportedNotificationTypes: readonly number[];
 
 	public toLogEntry(applHost: ZWaveApplicationHost): MessageOrCCLogEntry {
 		return {
@@ -1306,25 +1256,52 @@ export class NotificationCCEventSupportedReport extends NotificationCC {
 
 	public persistValues(applHost: ZWaveApplicationHost): boolean {
 		if (!super.persistValues(applHost)) return false;
-		const valueDB = this.getValueDB(applHost);
 
 		// Store which events this notification supports
-		valueDB.setValue(
-			getSupportedNotificationEventsValueId(this._notificationType),
+		this.setValue(
+			applHost,
+			NotificationCCValues.supportedNotificationEvents(
+				this._notificationType,
+			),
 			this._supportedEvents,
 		);
 
 		// For each event, predefine the value metadata
-		const metadataMap = defineMetadataForNotificationEvents(
-			applHost.configManager,
-			this.endpointIndex,
+		const notificationConfig = applHost.configManager.lookupNotification(
 			this._notificationType,
-			this._supportedEvents,
 		);
-		for (const [key, metadata] of metadataMap.entries()) {
-			const valueId = JSON.parse(key) as ValueID;
-			valueDB.setMetadata(valueId, metadata);
+
+		if (!notificationConfig) {
+			// This is an unknown notification
+			this.setMetadata(
+				applHost,
+				NotificationCCValues.unknownNotificationType(
+					this._notificationType,
+				),
+			);
+		} else {
+			// This is a standardized notification
+			for (const value of this._supportedEvents) {
+				// Find out which property we need to update
+				const valueConfig = notificationConfig.lookupValue(value);
+				if (valueConfig?.type === "state") {
+					const notificationValue =
+						NotificationCCValues.notificationVariable(
+							notificationConfig.name,
+							valueConfig.variableName,
+						);
+
+					const metadata = getNotificationValueMetadata(
+						undefined,
+						notificationConfig,
+						valueConfig,
+					);
+
+					this.setMetadata(applHost, notificationValue, metadata);
+				}
+			}
 		}
+
 		return true;
 	}
 
diff --git a/packages/cc/src/cc/ProtectionCC.ts b/packages/cc/src/cc/ProtectionCC.ts
index f9b80ed25e1..f5ed4eb613e 100644
--- a/packages/cc/src/cc/ProtectionCC.ts
+++ b/packages/cc/src/cc/ProtectionCC.ts
@@ -1,13 +1,11 @@
-import type {
-	MessageOrCCLogEntry,
-	MessageRecord,
-	ValueID,
-} from "@zwave-js/core/safe";
 import {
 	CommandClasses,
 	enumValuesToMetadataStates,
+	MAX_NODES,
 	Maybe,
+	MessageOrCCLogEntry,
 	MessagePriority,
+	MessageRecord,
 	parseBitMask,
 	Timeout,
 	unknownBoolean,
@@ -30,8 +28,6 @@ import {
 	throwWrongValueType,
 } from "../lib/API";
 import {
-	ccValue,
-	ccValueMetadata,
 	CommandClass,
 	gotDeserializationOptions,
 	type CCCommandOptions,
@@ -40,63 +36,72 @@ import {
 import {
 	API,
 	CCCommand,
+	ccValue,
+	ccValues,
 	commandClass,
 	expectedCCResponse,
 	implementedVersion,
 } from "../lib/CommandClassDecorators";
+import { V } from "../lib/Values";
 import {
 	LocalProtectionState,
 	ProtectionCommand,
 	RFProtectionState,
 } from "../lib/_Types";
 
-export function getExclusiveControlNodeIdValueID(endpoint: number): ValueID {
-	return {
-		commandClass: CommandClasses.Protection,
-		endpoint,
-		property: "exclusiveControlNodeId",
-	};
-}
-
-export function getLocalStateValueID(endpoint: number): ValueID {
-	return {
-		commandClass: CommandClasses.Protection,
-		endpoint,
-		property: "local",
-	};
-}
-
-export function getRFStateValueID(endpoint: number): ValueID {
-	return {
-		commandClass: CommandClasses.Protection,
-		endpoint,
-		property: "rf",
-	};
-}
-
-export function getTimeoutValueID(endpoint: number): ValueID {
-	return {
-		commandClass: CommandClasses.Protection,
-		endpoint,
-		property: "timeout",
-	};
-}
-
-export function getSupportsExclusiveControlValueID(endpoint: number): ValueID {
-	return {
-		commandClass: CommandClasses.Protection,
-		endpoint,
-		property: "supportsExclusiveControl",
-	};
-}
-
-export function getSupportsTimeoutValueID(endpoint: number): ValueID {
-	return {
-		commandClass: CommandClasses.Protection,
-		endpoint,
-		property: "supportsTimeout",
-	};
-}
+export const ProtectionCCValues = Object.freeze({
+	...V.defineStaticCCValues(CommandClasses.Protection, {
+		...V.staticProperty(
+			"exclusiveControlNodeId",
+			{
+				...ValueMetadata.UInt8,
+				min: 1,
+				max: MAX_NODES,
+				label: "Node ID with exclusive control",
+			} as const,
+			{ minVersion: 2 } as const,
+		),
+
+		...V.staticPropertyWithName("localProtectionState", "local", {
+			...ValueMetadata.Number,
+			label: "Local protection state",
+			states: enumValuesToMetadataStates(LocalProtectionState),
+		} as const),
+
+		...V.staticPropertyWithName(
+			"rfProtectionState",
+			"rf",
+			{
+				...ValueMetadata.Number,
+				label: "RF protection state",
+				states: enumValuesToMetadataStates(RFProtectionState),
+			} as const,
+			{ minVersion: 2 } as const,
+		),
+
+		...V.staticProperty(
+			"timeout",
+			{
+				...ValueMetadata.UInt8,
+				label: "RF protection timeout",
+			} as const,
+			{ minVersion: 2 } as const,
+		),
+
+		...V.staticProperty("supportsExclusiveControl", undefined, {
+			internal: true,
+		}),
+		...V.staticProperty("supportsTimeout", undefined, {
+			internal: true,
+		}),
+		...V.staticProperty("supportedLocalStates", undefined, {
+			internal: true,
+		}),
+		...V.staticProperty("supportedRFStates", undefined, {
+			internal: true,
+		}),
+	}),
+});
 
 @API(CommandClasses.Protection)
 export class ProtectionCCAPI extends CCAPI {
@@ -113,7 +118,9 @@ export class ProtectionCCAPI extends CCAPI {
 				return (
 					this.isSinglecast() &&
 					(this.tryGetValueDB()?.getValue<Maybe<boolean>>(
-						getSupportsTimeoutValueID(this.endpoint.index),
+						ProtectionCCValues.supportsTimeout.endpoint(
+							this.endpoint.index,
+						),
 					) ??
 						unknownBoolean)
 				);
@@ -123,7 +130,9 @@ export class ProtectionCCAPI extends CCAPI {
 				return (
 					this.isSinglecast() &&
 					(this.tryGetValueDB()?.getValue<Maybe<boolean>>(
-						getSupportsExclusiveControlValueID(this.endpoint.index),
+						ProtectionCCValues.supportsExclusiveControl.endpoint(
+							this.endpoint.index,
+						),
 					) ??
 						unknownBoolean)
 				);
@@ -148,7 +157,9 @@ export class ProtectionCCAPI extends CCAPI {
 			}
 			// We need to set both values together, so retrieve the other one from the value DB
 			const rf = valueDB?.getValue<RFProtectionState>(
-				getRFStateValueID(this.endpoint.index),
+				ProtectionCCValues.rfProtectionState.endpoint(
+					this.endpoint.index,
+				),
 			);
 			await this.set(value, rf);
 		} else if (property === "rf") {
@@ -162,7 +173,9 @@ export class ProtectionCCAPI extends CCAPI {
 			}
 			// We need to set both values together, so retrieve the other one from the value DB
 			const local = valueDB?.getValue<LocalProtectionState>(
-				getLocalStateValueID(this.endpoint.index),
+				ProtectionCCValues.localProtectionState.endpoint(
+					this.endpoint.index,
+				),
 			);
 			await this.set(local ?? LocalProtectionState.Unprotected, value);
 		} else if (property === "exclusiveControlNodeId") {
@@ -322,6 +335,7 @@ export class ProtectionCCAPI extends CCAPI {
 
 @commandClass(CommandClasses.Protection)
 @implementedVersion(2)
+@ccValues(ProtectionCCValues)
 export class ProtectionCC extends CommandClass {
 	declare ccCommand: ProtectionCommand;
 
@@ -392,13 +406,14 @@ RF protection states:    ${resp.supportedRFStates
 		).withOptions({
 			priority: MessagePriority.NodeQuery,
 		});
-		const valueDB = this.getValueDB(applHost);
 
-		const supportsExclusiveControl = !!valueDB.getValue<boolean>(
-			getSupportsExclusiveControlValueID(this.endpointIndex),
+		const supportsExclusiveControl = !!this.getValue(
+			applHost,
+			ProtectionCCValues.supportsExclusiveControl,
 		);
-		const supportsTimeout = !!valueDB.getValue<boolean>(
-			getSupportsTimeoutValueID(this.endpointIndex),
+		const supportsTimeout = !!this.getValue(
+			applHost,
+			ProtectionCCValues.supportsTimeout,
 		);
 
 		// Query the current state
@@ -519,21 +534,10 @@ export class ProtectionCCReport extends ProtectionCC {
 		}
 	}
 
-	// TODO: determine possible states during interview
-	@ccValue()
-	@ccValueMetadata({
-		...ValueMetadata.Number,
-		label: "Local protection state",
-		states: enumValuesToMetadataStates(LocalProtectionState),
-	})
+	@ccValue(ProtectionCCValues.localProtectionState)
 	public readonly local: LocalProtectionState;
 
-	@ccValue({ minVersion: 2 })
-	@ccValueMetadata({
-		...ValueMetadata.Number,
-		label: "RF protection state",
-		states: enumValuesToMetadataStates(RFProtectionState),
-	})
+	@ccValue(ProtectionCCValues.rfProtectionState)
 	public readonly rf?: RFProtectionState;
 
 	public toLogEntry(applHost: ZWaveApplicationHost): MessageOrCCLogEntry {
@@ -576,36 +580,39 @@ export class ProtectionCCSupportedReport extends ProtectionCC {
 
 	public persistValues(applHost: ZWaveApplicationHost): boolean {
 		if (!super.persistValues(applHost)) return false;
-		const valueDb = this.getValueDB(applHost);
+
 		// update metadata (partially) for the local and rf values
-		valueDb.setMetadata(getLocalStateValueID(this.endpointIndex), {
-			...ValueMetadata.Number,
+		const localStateValue = ProtectionCCValues.localProtectionState;
+		this.setMetadata(applHost, localStateValue, {
+			...localStateValue.meta,
 			states: enumValuesToMetadataStates(
 				LocalProtectionState,
 				this.supportedLocalStates,
 			),
 		});
-		// update metadata (partially) for the local and rf values
-		valueDb.setMetadata(getRFStateValueID(this.endpointIndex), {
-			...ValueMetadata.Number,
+
+		const rfStateValue = ProtectionCCValues.rfProtectionState;
+		this.setMetadata(applHost, rfStateValue, {
+			...rfStateValue.meta,
 			states: enumValuesToMetadataStates(
 				RFProtectionState,
 				this.supportedRFStates,
 			),
 		});
+
 		return true;
 	}
 
-	@ccValue({ internal: true })
+	@ccValue(ProtectionCCValues.supportsExclusiveControl)
 	public readonly supportsExclusiveControl: boolean;
 
-	@ccValue({ internal: true })
+	@ccValue(ProtectionCCValues.supportsTimeout)
 	public readonly supportsTimeout: boolean;
 
-	@ccValue({ internal: true })
+	@ccValue(ProtectionCCValues.supportedLocalStates)
 	public readonly supportedLocalStates: LocalProtectionState[];
 
-	@ccValue({ internal: true })
+	@ccValue(ProtectionCCValues.supportedRFStates)
 	public readonly supportedRFStates: RFProtectionState[];
 
 	public toLogEntry(applHost: ZWaveApplicationHost): MessageOrCCLogEntry {
@@ -644,7 +651,7 @@ export class ProtectionCCExclusiveControlReport extends ProtectionCC {
 		this.exclusiveControlNodeId = this.payload[0];
 	}
 
-	@ccValue({ minVersion: 2 })
+	@ccValue(ProtectionCCValues.exclusiveControlNodeId)
 	public readonly exclusiveControlNodeId: number;
 
 	public toLogEntry(applHost: ZWaveApplicationHost): MessageOrCCLogEntry {
@@ -714,7 +721,7 @@ export class ProtectionCCTimeoutReport extends ProtectionCC {
 		this.timeout = Timeout.parse(this.payload[0]);
 	}
 
-	@ccValue({ minVersion: 2 })
+	@ccValue(ProtectionCCValues.timeout)
 	public readonly timeout: Timeout;
 
 	public toLogEntry(applHost: ZWaveApplicationHost): MessageOrCCLogEntry {
diff --git a/packages/cc/src/cc/SceneActivationCC.ts b/packages/cc/src/cc/SceneActivationCC.ts
index 1876e066fa5..a7a1c6b6739 100644
--- a/packages/cc/src/cc/SceneActivationCC.ts
+++ b/packages/cc/src/cc/SceneActivationCC.ts
@@ -2,7 +2,6 @@ import type {
 	Maybe,
 	MessageOrCCLogEntry,
 	MessageRecord,
-	ValueID,
 } from "@zwave-js/core/safe";
 import {
 	CommandClasses,
@@ -20,8 +19,6 @@ import {
 	throwWrongValueType,
 } from "../lib/API";
 import {
-	ccValue,
-	ccValueMetadata,
 	CommandClass,
 	gotDeserializationOptions,
 	type CCCommandOptions,
@@ -30,28 +27,35 @@ import {
 import {
 	API,
 	CCCommand,
+	ccValue,
+	ccValues,
 	commandClass,
 	implementedVersion,
 } from "../lib/CommandClassDecorators";
+import { V } from "../lib/Values";
 import { SceneActivationCommand } from "../lib/_Types";
 
-// @noInterview This CC is write-only
+export const SceneActivationCCValues = Object.freeze({
+	...V.defineStaticCCValues(CommandClasses["Scene Activation"], {
+		...V.staticProperty(
+			"sceneId",
+			{
+				...ValueMetadata.UInt8,
+				min: 1,
+				label: "Scene ID",
+				valueChangeOptions: ["transitionDuration"],
+			} as const,
+			{ stateful: false },
+		),
 
-export function getSceneIdValueID(endpoint: number): ValueID {
-	return {
-		commandClass: CommandClasses["Scene Activation"],
-		endpoint,
-		property: "sceneId",
-	};
-}
+		...V.staticProperty("dimmingDuration", {
+			...ValueMetadata.Duration,
+			label: "Dimming duration",
+		} as const),
+	}),
+});
 
-export function getDimmingDurationValueID(endpoint: number): ValueID {
-	return {
-		commandClass: CommandClasses["Scene Activation"],
-		endpoint,
-		property: "dimmingDuration",
-	};
-}
+// @noInterview This CC is write-only
 
 @API(CommandClasses["Scene Activation"])
 export class SceneActivationCCAPI extends CCAPI {
@@ -101,6 +105,7 @@ export class SceneActivationCCAPI extends CCAPI {
 
 @commandClass(CommandClasses["Scene Activation"])
 @implementedVersion(1)
+@ccValues(SceneActivationCCValues)
 export class SceneActivationCC extends CommandClass {
 	declare ccCommand: SceneActivationCommand;
 }
@@ -136,20 +141,10 @@ export class SceneActivationCCSet extends SceneActivationCC {
 		}
 	}
 
-	@ccValue({ stateful: false })
-	@ccValueMetadata({
-		...ValueMetadata.UInt8,
-		min: 1,
-		label: "Scene ID",
-		valueChangeOptions: ["transitionDuration"],
-	})
+	@ccValue(SceneActivationCCValues.sceneId)
 	public sceneId: number;
 
-	@ccValue()
-	@ccValueMetadata({
-		...ValueMetadata.Duration,
-		label: "Dimming duration",
-	})
+	@ccValue(SceneActivationCCValues.dimmingDuration)
 	public dimmingDuration: Duration | undefined;
 
 	public serialize(): Buffer {
diff --git a/packages/cc/src/cc/SceneActuatorConfigurationCC.ts b/packages/cc/src/cc/SceneActuatorConfigurationCC.ts
index 6b583c34cfd..9d89550c2f2 100644
--- a/packages/cc/src/cc/SceneActuatorConfigurationCC.ts
+++ b/packages/cc/src/cc/SceneActuatorConfigurationCC.ts
@@ -5,7 +5,6 @@ import {
 	Maybe,
 	MessageOrCCLogEntry,
 	validatePayload,
-	ValueID,
 	ValueMetadata,
 	ZWaveError,
 	ZWaveErrorCodes,
@@ -33,89 +32,45 @@ import {
 import {
 	API,
 	CCCommand,
+	ccValues,
 	commandClass,
 	expectedCCResponse,
 	implementedVersion,
 } from "../lib/CommandClassDecorators";
+import { V } from "../lib/Values";
 import { SceneActuatorConfigurationCommand } from "../lib/_Types";
 
-export function getLevelValueID(
-	endpoint: number | undefined,
-	sceneId: number,
-): ValueID {
-	return {
-		commandClass: CommandClasses["Scene Actuator Configuration"],
-		endpoint,
-		property: "level",
-		propertyKey: sceneId,
-	};
-}
-
-export function getDimmingDurationValueID(
-	endpoint: number | undefined,
-	sceneId: number,
-): ValueID {
-	return {
-		commandClass: CommandClasses["Scene Actuator Configuration"],
-		endpoint,
-		property: "dimmingDuration",
-		propertyKey: sceneId,
-	};
-}
-
-function setSceneActuatorConfigMetaData(
-	this: SceneActuatorConfigurationCC,
-	applHost: ZWaveApplicationHost,
-	sceneId: number,
-) {
-	const valueDB = this.getValueDB(applHost);
-	const levelValueId = getLevelValueID(this.endpointIndex, sceneId);
-	const dimmingDurationValueId = getDimmingDurationValueID(
-		this.endpointIndex,
-		sceneId,
-	);
-
-	if (!valueDB.hasMetadata(levelValueId)) {
-		valueDB.setMetadata(levelValueId, {
-			...ValueMetadata.UInt8,
-			label: `Level (${sceneId})`,
-			valueChangeOptions: ["transitionDuration"],
-		});
-	}
-	if (!valueDB.hasMetadata(dimmingDurationValueId)) {
-		valueDB.setMetadata(dimmingDurationValueId, {
-			...ValueMetadata.Duration,
-			label: `Dimming duration (${sceneId})`,
-		});
-	}
-}
-
-function persistSceneActuatorConfig(
-	this: SceneActuatorConfigurationCC,
-	applHost: ZWaveApplicationHost,
-	sceneId: number,
-	level: number,
-	dimmingDuration: Duration,
-): boolean {
-	const valueDB = this.getValueDB(applHost);
-	const levelValueId = getLevelValueID(this.endpointIndex, sceneId);
-	const dimmingDurationValueId = getDimmingDurationValueID(
-		this.endpointIndex,
-		sceneId,
-	);
-
-	if (
-		!valueDB.hasMetadata(levelValueId) ||
-		!valueDB.hasMetadata(dimmingDurationValueId)
-	) {
-		setSceneActuatorConfigMetaData.call(this, applHost, sceneId);
-	}
-
-	valueDB.setValue(levelValueId, level);
-	valueDB.setValue(dimmingDurationValueId, dimmingDuration);
-
-	return true;
-}
+export const SceneActuatorConfigurationCCValues = Object.freeze({
+	...V.defineDynamicCCValues(CommandClasses["Scene Actuator Configuration"], {
+		...V.dynamicPropertyAndKeyWithName(
+			"level",
+			"level",
+			(sceneId: number) => sceneId,
+			({ property, propertyKey }) =>
+				property === "level" && typeof propertyKey === "number",
+			(sceneId: number) =>
+				({
+					...ValueMetadata.UInt8,
+					label: `Level (${sceneId})`,
+					valueChangeOptions: ["transitionDuration"],
+				} as const),
+		),
+
+		...V.dynamicPropertyAndKeyWithName(
+			"dimmingDuration",
+			"dimmingDuration",
+			(sceneId: number) => sceneId,
+			({ property, propertyKey }) =>
+				property === "dimmingDuration" &&
+				typeof propertyKey === "number",
+			(sceneId: number) =>
+				({
+					...ValueMetadata.Duration,
+					label: `Dimming duration (${sceneId})`,
+				} as const),
+		),
+	}),
+});
 
 @API(CommandClasses["Scene Actuator Configuration"])
 export class SceneActuatorConfigurationCCAPI extends CCAPI {
@@ -159,7 +114,9 @@ export class SceneActuatorConfigurationCCAPI extends CCAPI {
 			const dimmingDuration =
 				Duration.from(options?.transitionDuration) ??
 				this.tryGetValueDB()?.getValue<Duration>(
-					getDimmingDurationValueID(this.endpoint.index, propertyKey),
+					SceneActuatorConfigurationCCValues.dimmingDuration(
+						propertyKey,
+					).endpoint(this.endpoint.index),
 				);
 			await this.set(propertyKey, dimmingDuration, value);
 		} else if (property === "dimmingDuration") {
@@ -188,7 +145,9 @@ export class SceneActuatorConfigurationCCAPI extends CCAPI {
 			// Use saved value, if it's defined. Otherwise the default
 			// will be used.
 			const level = this.tryGetValueDB()?.getValue<number>(
-				getLevelValueID(this.endpoint.index, propertyKey),
+				SceneActuatorConfigurationCCValues.level(propertyKey).endpoint(
+					this.endpoint.index,
+				),
 			);
 
 			await this.set(propertyKey, dimmingDuration, level);
@@ -312,6 +271,7 @@ export class SceneActuatorConfigurationCCAPI extends CCAPI {
 
 @commandClass(CommandClasses["Scene Actuator Configuration"])
 @implementedVersion(1)
+@ccValues(SceneActuatorConfigurationCCValues)
 export class SceneActuatorConfigurationCC extends CommandClass {
 	declare ccCommand: SceneActuatorConfigurationCommand;
 
@@ -324,8 +284,15 @@ export class SceneActuatorConfigurationCC extends CommandClass {
 			direction: "none",
 		});
 
+		// Create Metadata for all scenes
 		for (let sceneId = 1; sceneId <= 255; sceneId++) {
-			setSceneActuatorConfigMetaData.call(this, applHost, sceneId);
+			const levelValue =
+				SceneActuatorConfigurationCCValues.level(sceneId);
+			this.ensureMetadata(applHost, levelValue);
+
+			const dimmingDurationValue =
+				SceneActuatorConfigurationCCValues.dimmingDuration(sceneId);
+			this.ensureMetadata(applHost, dimmingDurationValue);
 		}
 
 		this.setInterviewComplete(applHost, true);
@@ -446,13 +413,19 @@ export class SceneActuatorConfigurationCCReport extends SceneActuatorConfigurati
 			return false;
 		}
 
-		return persistSceneActuatorConfig.call(
-			this,
-			applHost,
+		const levelValue = SceneActuatorConfigurationCCValues.level(
 			this.sceneId,
-			this.level,
-			this.dimmingDuration,
 		);
+		this.ensureMetadata(applHost, levelValue);
+
+		const dimmingDurationValue =
+			SceneActuatorConfigurationCCValues.dimmingDuration(this.sceneId);
+		this.ensureMetadata(applHost, dimmingDurationValue);
+
+		this.setValue(applHost, levelValue, this.level);
+		this.setValue(applHost, dimmingDurationValue, this.dimmingDuration);
+
+		return true;
 	}
 
 	public toLogEntry(applHost: ZWaveApplicationHost): MessageOrCCLogEntry {
diff --git a/packages/cc/src/cc/SceneControllerConfigurationCC.ts b/packages/cc/src/cc/SceneControllerConfigurationCC.ts
index 3685cba8bd7..9fdead842d8 100644
--- a/packages/cc/src/cc/SceneControllerConfigurationCC.ts
+++ b/packages/cc/src/cc/SceneControllerConfigurationCC.ts
@@ -7,7 +7,6 @@ import {
 	MessageOrCCLogEntry,
 	MessagePriority,
 	validatePayload,
-	ValueID,
 	ValueMetadata,
 	ZWaveError,
 	ZWaveErrorCodes,
@@ -35,90 +34,49 @@ import {
 import {
 	API,
 	CCCommand,
+	ccValues,
 	commandClass,
 	expectedCCResponse,
 	implementedVersion,
 } from "../lib/CommandClassDecorators";
+import { V } from "../lib/Values";
 import { SceneControllerConfigurationCommand } from "../lib/_Types";
 import { AssociationCC } from "./AssociationCC";
 
-export function getSceneIdValueID(
-	endpoint: number | undefined,
-	groupId: number,
-): ValueID {
-	return {
-		commandClass: CommandClasses["Scene Controller Configuration"],
-		endpoint,
-		property: "sceneId",
-		propertyKey: groupId,
-	};
-}
-
-export function getDimmingDurationValueID(
-	endpoint: number | undefined,
-	groupId: number,
-): ValueID {
-	return {
-		commandClass: CommandClasses["Scene Controller Configuration"],
-		endpoint,
-		property: "dimmingDuration",
-		propertyKey: groupId,
-	};
-}
-
-function setSceneConfigurationMetadata(
-	this: SceneControllerConfigurationCC,
-	applHost: ZWaveApplicationHost,
-	groupId: number,
-) {
-	const valueDB = this.getValueDB(applHost);
-	const sceneIdValueId = getSceneIdValueID(this.endpointIndex, groupId);
-	const dimmingDurationValueId = getDimmingDurationValueID(
-		this.endpointIndex,
-		groupId,
-	);
-
-	if (!valueDB.hasMetadata(sceneIdValueId)) {
-		valueDB.setMetadata(sceneIdValueId, {
-			...ValueMetadata.UInt8,
-			label: `Associated Scene ID (${groupId})`,
-			valueChangeOptions: ["transitionDuration"],
-		});
-	}
-	if (!valueDB.hasMetadata(dimmingDurationValueId)) {
-		valueDB.setMetadata(dimmingDurationValueId, {
-			...ValueMetadata.Duration,
-			label: `Dimming duration (${groupId})`,
-		});
-	}
-}
-
-function persistSceneConfig(
-	this: SceneControllerConfigurationCC,
-	applHost: ZWaveApplicationHost,
-	groupId: number,
-	sceneId: number,
-	dimmingDuration: Duration,
-) {
-	const valueDB = this.getValueDB(applHost);
-	const sceneIdValueId = getSceneIdValueID(this.endpointIndex, groupId);
-	const dimmingDurationValueId = getDimmingDurationValueID(
-		this.endpointIndex,
-		groupId,
-	);
-
-	if (
-		!valueDB.hasMetadata(sceneIdValueId) ||
-		!valueDB.hasMetadata(dimmingDurationValueId)
-	) {
-		setSceneConfigurationMetadata.call(this, applHost, groupId);
-	}
-
-	valueDB.setValue(sceneIdValueId, sceneId);
-	valueDB.setValue(dimmingDurationValueId, dimmingDuration);
-
-	return true;
-}
+export const SceneControllerConfigurationCCValues = Object.freeze({
+	...V.defineDynamicCCValues(
+		CommandClasses["Scene Controller Configuration"],
+		{
+			...V.dynamicPropertyAndKeyWithName(
+				"sceneId",
+				"sceneId",
+				(groupId: number) => groupId,
+				({ property, propertyKey }) =>
+					property === "sceneId" && typeof propertyKey === "number",
+				(groupId: number) =>
+					({
+						...ValueMetadata.UInt8,
+						label: `Associated Scene ID (${groupId})`,
+						valueChangeOptions: ["transitionDuration"],
+					} as const),
+			),
+
+			...V.dynamicPropertyAndKeyWithName(
+				"dimmingDuration",
+				"dimmingDuration",
+				(groupId: number) => groupId,
+				({ property, propertyKey }) =>
+					property === "dimmingDuration" &&
+					typeof propertyKey === "number",
+				(groupId: number) =>
+					({
+						...ValueMetadata.Duration,
+						label: `Dimming duration (${groupId})`,
+					} as const),
+			),
+		},
+	),
+});
 
 @API(CommandClasses["Scene Controller Configuration"])
 export class SceneControllerConfigurationCCAPI extends CCAPI {
@@ -166,10 +124,9 @@ export class SceneControllerConfigurationCCAPI extends CCAPI {
 				const dimmingDuration =
 					Duration.from(options?.transitionDuration) ??
 					this.tryGetValueDB()?.getValue<Duration>(
-						getDimmingDurationValueID(
-							this.endpoint.index,
+						SceneControllerConfigurationCCValues.dimmingDuration(
 							propertyKey,
-						),
+						).endpoint(this.endpoint.index),
 					) ??
 					new Duration(0, "default");
 				await this.set(propertyKey, value, dimmingDuration);
@@ -198,16 +155,18 @@ export class SceneControllerConfigurationCCAPI extends CCAPI {
 
 			const valueDB = this.tryGetValueDB();
 			const sceneId = valueDB?.getValue<number>(
-				getSceneIdValueID(this.endpoint.index, propertyKey),
+				SceneControllerConfigurationCCValues.sceneId(
+					propertyKey,
+				).endpoint(this.endpoint.index),
 			);
 			if (sceneId == undefined || sceneId === 0) {
 				if (valueDB) {
 					// Can't actually send dimmingDuration without valid sceneId
 					// So we save it in the valueDB without sending it to the node
-					const dimmingDurationValueId = getDimmingDurationValueID(
-						this.endpoint.index,
-						propertyKey,
-					);
+					const dimmingDurationValueId =
+						SceneControllerConfigurationCCValues.dimmingDuration(
+							propertyKey,
+						).endpoint(this.endpoint.index);
 					valueDB.setValue(dimmingDurationValueId, dimmingDuration);
 				}
 				return;
@@ -377,6 +336,7 @@ export class SceneControllerConfigurationCCAPI extends CCAPI {
 
 @commandClass(CommandClasses["Scene Controller Configuration"])
 @implementedVersion(1)
+@ccValues(SceneControllerConfigurationCCValues)
 export class SceneControllerConfigurationCC extends CommandClass {
 	declare ccCommand: SceneControllerConfigurationCommand;
 
@@ -417,7 +377,13 @@ export class SceneControllerConfigurationCC extends CommandClass {
 		// Create metadata for each scene, but don't query their actual configuration
 		// since some devices only support setting scenes
 		for (let groupId = 1; groupId <= groupCount; groupId++) {
-			setSceneConfigurationMetadata.call(this, applHost, groupId);
+			const sceneIdValue =
+				SceneControllerConfigurationCCValues.sceneId(groupId);
+			this.ensureMetadata(applHost, sceneIdValue);
+
+			const dimmingDurationValue =
+				SceneControllerConfigurationCCValues.dimmingDuration(groupId);
+			this.ensureMetadata(applHost, dimmingDurationValue);
 		}
 
 		// Remember that the interview is complete
@@ -561,13 +527,19 @@ export class SceneControllerConfigurationCCReport extends SceneControllerConfigu
 
 		// If groupId = 0, values are meaningless
 		if (this.groupId === 0) return false;
-		return persistSceneConfig.call(
-			this,
-			applHost,
+
+		const sceneIdValue = SceneControllerConfigurationCCValues.sceneId(
 			this.groupId,
-			this.sceneId,
-			this.dimmingDuration,
 		);
+		this.ensureMetadata(applHost, sceneIdValue);
+		const dimmingDurationValue =
+			SceneControllerConfigurationCCValues.dimmingDuration(this.groupId);
+		this.ensureMetadata(applHost, dimmingDurationValue);
+
+		this.setValue(applHost, sceneIdValue, this.sceneId);
+		this.setValue(applHost, dimmingDurationValue, this.dimmingDuration);
+
+		return true;
 	}
 
 	public toLogEntry(applHost: ZWaveApplicationHost): MessageOrCCLogEntry {
diff --git a/packages/cc/src/cc/SoundSwitchCC.ts b/packages/cc/src/cc/SoundSwitchCC.ts
index 0b590b633de..7e2c66ddce6 100644
--- a/packages/cc/src/cc/SoundSwitchCC.ts
+++ b/packages/cc/src/cc/SoundSwitchCC.ts
@@ -5,7 +5,6 @@ import {
 	MessagePriority,
 	MessageRecord,
 	validatePayload,
-	ValueID,
 	ValueMetadata,
 	ZWaveError,
 	ZWaveErrorCodes,
@@ -24,8 +23,6 @@ import {
 	throwWrongValueType,
 } from "../lib/API";
 import {
-	ccValue,
-	ccValueMetadata,
 	CommandClass,
 	gotDeserializationOptions,
 	type CCCommandOptions,
@@ -35,27 +32,50 @@ import {
 import {
 	API,
 	CCCommand,
+	ccValue,
+	ccValues,
 	commandClass,
 	expectedCCResponse,
 	implementedVersion,
 } from "../lib/CommandClassDecorators";
+import { V } from "../lib/Values";
 import { SoundSwitchCommand, ToneId } from "../lib/_Types";
 
-export function getVolumeValueId(endpointIndex: number | undefined): ValueID {
-	return {
-		commandClass: CommandClasses["Sound Switch"],
-		endpoint: endpointIndex,
-		property: "volume",
-	};
-}
+export const SoundSwitchCCValues = Object.freeze({
+	...V.defineStaticCCValues(CommandClasses["Sound Switch"], {
+		...V.staticProperty("volume", {
+			...ValueMetadata.UInt8,
+			min: 0,
+			max: 100,
+			unit: "%",
+			label: "Volume",
+			states: {
+				0: "default",
+			},
+		} as const),
 
-export function getToneIdValueId(endpointIndex: number | undefined): ValueID {
-	return {
-		commandClass: CommandClasses["Sound Switch"],
-		endpoint: endpointIndex,
-		property: "toneId",
-	};
-}
+		...V.staticProperty("toneId", {
+			...ValueMetadata.UInt8,
+			label: "Play Tone",
+			valueChangeOptions: ["volume"],
+		} as const),
+
+		...V.staticProperty("defaultVolume", {
+			...ValueMetadata.Number,
+			min: 0,
+			max: 100,
+			unit: "%",
+			label: "Default volume",
+		} as const),
+
+		...V.staticProperty("defaultToneId", {
+			...ValueMetadata.Number,
+			min: 0,
+			max: 254,
+			label: "Default tone ID",
+		} as const),
+	}),
+});
 
 @API(CommandClasses["Sound Switch"])
 export class SoundSwitchCCAPI extends CCAPI {
@@ -251,7 +271,9 @@ export class SoundSwitchCCAPI extends CCAPI {
 					options?.volume !== undefined
 						? options.volume
 						: this.tryGetValueDB()?.getValue<number>(
-								getVolumeValueId(this.endpoint.index),
+								SoundSwitchCCValues.volume.endpoint(
+									this.endpoint.index,
+								),
 						  );
 				await this.play(value, volume);
 			} else {
@@ -286,6 +308,7 @@ export class SoundSwitchCCAPI extends CCAPI {
 
 @commandClass(CommandClasses["Sound Switch"])
 @implementedVersion(2)
+@ccValues(SoundSwitchCCValues)
 export class SoundSwitchCC extends CommandClass {
 	declare ccCommand: SoundSwitchCommand;
 
@@ -299,7 +322,6 @@ export class SoundSwitchCC extends CommandClass {
 		).withOptions({
 			priority: MessagePriority.NodeQuery,
 		});
-		const valueDB = this.getValueDB(applHost);
 
 		applHost.controllerLog.logNode(node.id, {
 			endpoint: this.endpointIndex,
@@ -363,13 +385,12 @@ duration: ${info.duration} seconds`;
 		}
 		metadataStates[0xff] = "default";
 
-		// Store tone count and info as a single metadata
-		valueDB.setMetadata(getToneIdValueId(this.endpointIndex), {
-			...ValueMetadata.Number,
+		// Remember tone count and info on the tone ID metadata
+		this.setMetadata(applHost, SoundSwitchCCValues.toneId, {
+			...SoundSwitchCCValues.toneId.meta,
 			min: 0,
 			max: toneCount,
 			states: metadataStates,
-			label: "Play Tone",
 		});
 
 		// Remember that the interview is complete
@@ -540,23 +561,10 @@ export class SoundSwitchCCConfigurationReport extends SoundSwitchCC {
 		this.defaultToneId = this.payload[1];
 	}
 
-	@ccValue()
-	@ccValueMetadata({
-		...ValueMetadata.Number,
-		min: 0,
-		max: 100,
-		unit: "%",
-		label: "Default volume",
-	})
+	@ccValue(SoundSwitchCCValues.defaultVolume)
 	public readonly defaultVolume: number;
 
-	@ccValue()
-	@ccValueMetadata({
-		...ValueMetadata.Number,
-		min: 0,
-		max: 254,
-		label: "Default tone ID",
-	})
+	@ccValue(SoundSwitchCCValues.defaultToneId)
 	public readonly defaultToneId: number;
 
 	public toLogEntry(applHost: ZWaveApplicationHost): MessageOrCCLogEntry {
@@ -643,25 +651,10 @@ export class SoundSwitchCCTonePlayReport extends SoundSwitchCC {
 		}
 	}
 
-	@ccValue()
-	@ccValueMetadata({
-		...ValueMetadata.UInt8,
-		label: "Tone ID",
-		valueChangeOptions: ["volume"],
-	})
+	@ccValue(SoundSwitchCCValues.toneId)
 	public readonly toneId: ToneId | number;
 
-	@ccValue()
-	@ccValueMetadata({
-		...ValueMetadata.UInt8,
-		min: 0,
-		max: 100,
-		unit: "%",
-		label: "Volume",
-		states: {
-			0: "default",
-		},
-	})
+	@ccValue(SoundSwitchCCValues.volume)
 	public volume?: number;
 
 	public toLogEntry(applHost: ZWaveApplicationHost): MessageOrCCLogEntry {
diff --git a/packages/cc/src/cc/ThermostatFanModeCC.ts b/packages/cc/src/cc/ThermostatFanModeCC.ts
index 479f6b6e478..1d1441ad384 100644
--- a/packages/cc/src/cc/ThermostatFanModeCC.ts
+++ b/packages/cc/src/cc/ThermostatFanModeCC.ts
@@ -2,7 +2,6 @@ import type {
 	Maybe,
 	MessageOrCCLogEntry,
 	MessageRecord,
-	ValueID,
 } from "@zwave-js/core/safe";
 import {
 	CommandClasses,
@@ -27,8 +26,6 @@ import {
 	throwWrongValueType,
 } from "../lib/API";
 import {
-	ccValue,
-	ccValueMetadata,
 	CommandClass,
 	gotDeserializationOptions,
 	type CCCommandOptions,
@@ -37,27 +34,41 @@ import {
 import {
 	API,
 	CCCommand,
+	ccValue,
+	ccValues,
 	commandClass,
 	expectedCCResponse,
 	implementedVersion,
 } from "../lib/CommandClassDecorators";
+import { V } from "../lib/Values";
 import { ThermostatFanMode, ThermostatFanModeCommand } from "../lib/_Types";
 
-export function getOffStateValueID(endpoint: number): ValueID {
-	return {
-		commandClass: CommandClasses["Thermostat Fan Mode"],
-		endpoint,
-		property: "off",
-	};
-}
-
-export function getModeStateValueID(endpoint: number): ValueID {
-	return {
-		commandClass: CommandClasses["Thermostat Fan Mode"],
-		endpoint,
-		property: "mode",
-	};
-}
+export const ThermostatFanModeCCValues = Object.freeze({
+	...V.defineStaticCCValues(CommandClasses["Thermostat Fan Mode"], {
+		...V.staticPropertyWithName(
+			"turnedOff",
+			"off",
+			{
+				...ValueMetadata.Boolean,
+				label: "Thermostat fan turned off",
+			} as const,
+			{ minVersion: 3 } as const,
+		),
+
+		...V.staticPropertyWithName("fanMode", "mode", {
+			...ValueMetadata.UInt8,
+			states: enumValuesToMetadataStates(ThermostatFanMode),
+			label: "Thermostat fan mode",
+		} as const),
+
+		...V.staticPropertyWithName(
+			"supportedFanModes",
+			"supportedModes",
+			undefined,
+			{ internal: true },
+		),
+	}),
+});
 
 @API(CommandClasses["Thermostat Fan Mode"])
 export class ThermostatFanModeCCAPI extends CCAPI {
@@ -88,7 +99,9 @@ export class ThermostatFanModeCCAPI extends CCAPI {
 			}
 			// Preserve the value of the "off" flag
 			const off = valueDB.getValue<boolean>(
-				getOffStateValueID(this.endpoint.index),
+				ThermostatFanModeCCValues.turnedOff.endpoint(
+					this.endpoint.index,
+				),
 			);
 			await this.set(value, off);
 		} else if (property === "off") {
@@ -101,7 +114,7 @@ export class ThermostatFanModeCCAPI extends CCAPI {
 				);
 			}
 			const mode = valueDB.getValue<ThermostatFanMode>(
-				getModeStateValueID(this.endpoint.index),
+				ThermostatFanModeCCValues.fanMode.endpoint(this.endpoint.index),
 			);
 			if (mode == undefined) {
 				throw new ZWaveError(
@@ -195,6 +208,7 @@ export class ThermostatFanModeCCAPI extends CCAPI {
 
 @commandClass(CommandClasses["Thermostat Fan Mode"])
 @implementedVersion(5)
+@ccValues(ThermostatFanModeCCValues)
 export class ThermostatFanModeCC extends CommandClass {
 	declare ccCommand: ThermostatFanModeCommand;
 
@@ -342,33 +356,18 @@ export class ThermostatFanModeCCReport extends ThermostatFanModeCC {
 		super(host, options);
 
 		validatePayload(this.payload.length >= 1);
-		this._mode = this.payload[0] & 0b1111;
+		this.mode = this.payload[0] & 0b1111;
 
 		if (this.version >= 3) {
-			this._off = !!(this.payload[0] & 0b1000_0000);
+			this.off = !!(this.payload[0] & 0b1000_0000);
 		}
 	}
 
-	private _mode: ThermostatFanMode;
-	@ccValue()
-	@ccValueMetadata({
-		...ValueMetadata.UInt8,
-		states: enumValuesToMetadataStates(ThermostatFanMode),
-		label: "Thermostat fan mode",
-	})
-	public get mode(): ThermostatFanMode {
-		return this._mode;
-	}
+	@ccValue(ThermostatFanModeCCValues.fanMode)
+	public readonly mode: ThermostatFanMode;
 
-	private _off: boolean | undefined;
-	@ccValue({ minVersion: 3 })
-	@ccValueMetadata({
-		...ValueMetadata.Boolean,
-		label: "Thermostat fan turned off",
-	})
-	public get off(): boolean | undefined {
-		return this._off;
-	}
+	@ccValue(ThermostatFanModeCCValues.turnedOff)
+	public readonly off: boolean | undefined;
 
 	public toLogEntry(applHost: ZWaveApplicationHost): MessageOrCCLogEntry {
 		const message: MessageRecord = {
@@ -395,7 +394,7 @@ export class ThermostatFanModeCCSupportedReport extends ThermostatFanModeCC {
 		options: CommandClassDeserializationOptions,
 	) {
 		super(host, options);
-		this._supportedModes = parseBitMask(
+		this.supportedModes = parseBitMask(
 			this.payload,
 			ThermostatFanMode["Auto low"],
 		);
@@ -403,31 +402,22 @@ export class ThermostatFanModeCCSupportedReport extends ThermostatFanModeCC {
 
 	public persistValues(applHost: ZWaveApplicationHost): boolean {
 		if (!super.persistValues(applHost)) return false;
-		const valueDB = this.getValueDB(applHost);
 
-		// Use this information to create the metadata for the mode property
-		const valueId: ValueID = {
-			commandClass: this.ccId,
-			endpoint: this.endpointIndex,
-			property: "mode",
-		};
-		// Only update the dynamic part
-		valueDB.setMetadata(valueId, {
-			...ValueMetadata.UInt8,
+		// Remember which fan modes are supported
+		const fanModeValue = ThermostatFanModeCCValues.fanMode;
+		this.setMetadata(applHost, fanModeValue, {
+			...fanModeValue.meta,
 			states: enumValuesToMetadataStates(
 				ThermostatFanMode,
-				this._supportedModes,
+				this.supportedModes,
 			),
 		});
 
 		return true;
 	}
 
-	private _supportedModes: ThermostatFanMode[];
-	@ccValue({ internal: true })
-	public get supportedModes(): readonly ThermostatFanMode[] {
-		return this._supportedModes;
-	}
+	@ccValue(ThermostatFanModeCCValues.supportedFanModes)
+	public readonly supportedModes: ThermostatFanMode[];
 
 	public toLogEntry(applHost: ZWaveApplicationHost): MessageOrCCLogEntry {
 		return {
diff --git a/packages/cc/src/cc/ThermostatFanStateCC.ts b/packages/cc/src/cc/ThermostatFanStateCC.ts
index 6d1289620bf..7bd3e151e88 100644
--- a/packages/cc/src/cc/ThermostatFanStateCC.ts
+++ b/packages/cc/src/cc/ThermostatFanStateCC.ts
@@ -17,20 +17,31 @@ import {
 	throwUnsupportedProperty,
 } from "../lib/API";
 import {
-	ccValue,
-	ccValueMetadata,
 	CommandClass,
 	type CommandClassDeserializationOptions,
 } from "../lib/CommandClass";
 import {
 	API,
 	CCCommand,
+	ccValue,
+	ccValues,
 	commandClass,
 	expectedCCResponse,
 	implementedVersion,
 } from "../lib/CommandClassDecorators";
+import { V } from "../lib/Values";
 import { ThermostatFanState, ThermostatFanStateCommand } from "../lib/_Types";
 
+export const ThermostatFanStateCCValues = Object.freeze({
+	...V.defineStaticCCValues(CommandClasses["Thermostat Fan State"], {
+		...V.staticPropertyWithName("fanState", "state", {
+			...ValueMetadata.ReadOnlyUInt8,
+			states: enumValuesToMetadataStates(ThermostatFanState),
+			label: "Thermostat fan state",
+		} as const),
+	}),
+});
+
 @API(CommandClasses["Thermostat Fan State"])
 export class ThermostatFanStateCCAPI extends CCAPI {
 	public supportsCommand(cmd: ThermostatFanStateCommand): Maybe<boolean> {
@@ -77,6 +88,7 @@ export class ThermostatFanStateCCAPI extends CCAPI {
 
 @commandClass(CommandClasses["Thermostat Fan State"])
 @implementedVersion(2)
+@ccValues(ThermostatFanStateCCValues)
 export class ThermostatFanStateCC extends CommandClass {
 	declare ccCommand: ThermostatFanStateCommand;
 
@@ -134,19 +146,11 @@ export class ThermostatFanStateCCReport extends ThermostatFanStateCC {
 		super(host, options);
 
 		validatePayload(this.payload.length == 1);
-		this._state = this.payload[0] & 0b1111;
+		this.state = this.payload[0] & 0b1111;
 	}
 
-	private _state: ThermostatFanState;
-	@ccValue()
-	@ccValueMetadata({
-		...ValueMetadata.ReadOnlyUInt8,
-		states: enumValuesToMetadataStates(ThermostatFanState),
-		label: "Thermostat fan state",
-	})
-	public get state(): ThermostatFanState {
-		return this._state;
-	}
+	@ccValue(ThermostatFanStateCCValues.fanState)
+	public readonly state: ThermostatFanState;
 
 	public toLogEntry(applHost: ZWaveApplicationHost): MessageOrCCLogEntry {
 		const message: MessageRecord = {
diff --git a/packages/cc/src/cc/ThermostatModeCC.ts b/packages/cc/src/cc/ThermostatModeCC.ts
index 0da2ad13a8d..abfa4eb00bb 100644
--- a/packages/cc/src/cc/ThermostatModeCC.ts
+++ b/packages/cc/src/cc/ThermostatModeCC.ts
@@ -1,8 +1,4 @@
-import type {
-	MessageOrCCLogEntry,
-	MessageRecord,
-	ValueID,
-} from "@zwave-js/core/safe";
+import type { MessageOrCCLogEntry, MessageRecord } from "@zwave-js/core/safe";
 import {
 	CommandClasses,
 	enumValuesToMetadataStates,
@@ -27,8 +23,6 @@ import {
 	throwWrongValueType,
 } from "../lib/API";
 import {
-	ccValue,
-	ccValueMetadata,
 	CommandClass,
 	gotDeserializationOptions,
 	type CCCommandOptions,
@@ -37,27 +31,31 @@ import {
 import {
 	API,
 	CCCommand,
+	ccValue,
+	ccValues,
 	commandClass,
 	expectedCCResponse,
 	implementedVersion,
 } from "../lib/CommandClassDecorators";
+import { V } from "../lib/Values";
 import { ThermostatMode, ThermostatModeCommand } from "../lib/_Types";
 
-export function getThermostatModeValueId(endpointIndex: number): ValueID {
-	return {
-		commandClass: CommandClasses["Thermostat Mode"],
-		endpoint: endpointIndex,
-		property: "mode",
-	};
-}
+export const ThermostatModeCCValues = Object.freeze({
+	...V.defineStaticCCValues(CommandClasses["Thermostat Mode"], {
+		...V.staticPropertyWithName("thermostatMode", "mode", {
+			...ValueMetadata.UInt8,
+			states: enumValuesToMetadataStates(ThermostatMode),
+			label: "Thermostat mode",
+		} as const),
 
-export function getSupportedModesValueId(endpointIndex: number): ValueID {
-	return {
-		commandClass: CommandClasses["Thermostat Mode"],
-		endpoint: endpointIndex,
-		property: "supportedModes",
-	};
-}
+		...V.staticProperty("manufacturerData", {
+			...ValueMetadata.ReadOnlyBuffer,
+			label: "Manufacturer data",
+		} as const),
+
+		...V.staticProperty("supportedModes", undefined, { internal: true }),
+	}),
+});
 
 @API(CommandClasses["Thermostat Mode"])
 export class ThermostatModeCCAPI extends CCAPI {
@@ -178,6 +176,7 @@ export class ThermostatModeCCAPI extends CCAPI {
 
 @commandClass(CommandClasses["Thermostat Mode"])
 @implementedVersion(3)
+@ccValues(ThermostatModeCCValues)
 export class ThermostatModeCC extends CommandClass {
 	declare ccCommand: ThermostatModeCommand;
 
@@ -340,14 +339,14 @@ export class ThermostatModeCCReport extends ThermostatModeCC {
 		super(host, options);
 
 		validatePayload(this.payload.length >= 1);
-		this._mode = this.payload[0] & 0b11111;
+		this.mode = this.payload[0] & 0b11111;
 
 		if (this.version >= 3) {
 			const manufacturerDataLength = this.payload[0] >>> 5;
 
 			validatePayload(this.payload.length >= 1 + manufacturerDataLength);
 			if (manufacturerDataLength) {
-				this._manufacturerData = this.payload.slice(
+				this.manufacturerData = this.payload.slice(
 					1,
 					1 + manufacturerDataLength,
 				);
@@ -360,52 +359,40 @@ export class ThermostatModeCCReport extends ThermostatModeCC {
 
 		// Update the supported modes if a mode is used that wasn't previously
 		// reported to be supported. This shouldn't happen, but well... it does anyways
-		const valueDB = this.getValueDB(applHost);
-		const modeValueId = getThermostatModeValueId(this.endpointIndex);
-		const supportedModesValueId = getSupportedModesValueId(
-			this.endpointIndex,
-		);
-		const supportedModes = valueDB.getValue<ThermostatMode[]>(
-			supportedModesValueId,
+		const thermostatModeValue = ThermostatModeCCValues.thermostatMode;
+		const supportedModesValue = ThermostatModeCCValues.supportedModes;
+
+		const supportedModes = this.getValue<ThermostatMode[]>(
+			applHost,
+			supportedModesValue,
 		);
 
 		if (
 			supportedModes &&
-			this._mode in ThermostatMode &&
-			!supportedModes.includes(this._mode)
+			this.mode in ThermostatMode &&
+			!supportedModes.includes(this.mode)
 		) {
-			supportedModes.push(this._mode);
+			supportedModes.push(this.mode);
 			supportedModes.sort();
 
-			valueDB.setValue(supportedModesValueId, supportedModes);
-			valueDB.setMetadata(modeValueId, {
-				...ValueMetadata.UInt8,
+			this.setMetadata(applHost, thermostatModeValue, {
+				...thermostatModeValue.meta,
 				states: enumValuesToMetadataStates(
 					ThermostatMode,
 					supportedModes,
 				),
 			});
+			this.setValue(applHost, supportedModesValue, supportedModes);
 		}
 
 		return super.persistValues(applHost);
 	}
 
-	private _mode: ThermostatMode;
-	@ccValue()
-	@ccValueMetadata({
-		...ValueMetadata.UInt8,
-		states: enumValuesToMetadataStates(ThermostatMode),
-		label: "Thermostat mode",
-	})
-	public get mode(): ThermostatMode {
-		return this._mode;
-	}
+	@ccValue(ThermostatModeCCValues.thermostatMode)
+	public readonly mode: ThermostatMode;
 
-	private _manufacturerData: Buffer | undefined;
-	@ccValue()
-	public get manufacturerData(): Buffer | undefined {
-		return this._manufacturerData;
-	}
+	@ccValue(ThermostatModeCCValues.manufacturerData)
+	public readonly manufacturerData: Buffer | undefined;
 
 	public toLogEntry(applHost: ZWaveApplicationHost): MessageOrCCLogEntry {
 		const message: MessageRecord = {
@@ -432,31 +419,27 @@ export class ThermostatModeCCSupportedReport extends ThermostatModeCC {
 		options: CommandClassDeserializationOptions,
 	) {
 		super(host, options);
-		this._supportedModes = parseBitMask(this.payload, ThermostatMode.Off);
+		this.supportedModes = parseBitMask(this.payload, ThermostatMode.Off);
 	}
 
 	public persistValues(applHost: ZWaveApplicationHost): boolean {
 		if (!super.persistValues(applHost)) return false;
-		const valueDB = this.getValueDB(applHost);
 
 		// Use this information to create the metadata for the mode property
-		const valueId: ValueID = getThermostatModeValueId(this.endpointIndex);
-		valueDB.setMetadata(valueId, {
-			...ValueMetadata.UInt8,
+		const thermostatModeValue = ThermostatModeCCValues.thermostatMode;
+		this.setMetadata(applHost, thermostatModeValue, {
+			...thermostatModeValue.meta,
 			states: enumValuesToMetadataStates(
 				ThermostatMode,
-				this._supportedModes,
+				this.supportedModes,
 			),
 		});
 
 		return true;
 	}
 
-	private _supportedModes: ThermostatMode[];
-	@ccValue({ internal: true })
-	public get supportedModes(): readonly ThermostatMode[] {
-		return this._supportedModes;
-	}
+	@ccValue(ThermostatModeCCValues.supportedModes)
+	public readonly supportedModes: ThermostatMode[];
 
 	public toLogEntry(applHost: ZWaveApplicationHost): MessageOrCCLogEntry {
 		return {
diff --git a/packages/cc/src/cc/ThermostatOperatingStateCC.ts b/packages/cc/src/cc/ThermostatOperatingStateCC.ts
index 01a7eba34db..c5af6b591a8 100644
--- a/packages/cc/src/cc/ThermostatOperatingStateCC.ts
+++ b/packages/cc/src/cc/ThermostatOperatingStateCC.ts
@@ -16,23 +16,34 @@ import {
 	throwUnsupportedProperty,
 } from "../lib/API";
 import {
-	ccValue,
-	ccValueMetadata,
 	CommandClass,
 	type CommandClassDeserializationOptions,
 } from "../lib/CommandClass";
 import {
 	API,
 	CCCommand,
+	ccValue,
+	ccValues,
 	commandClass,
 	expectedCCResponse,
 	implementedVersion,
 } from "../lib/CommandClassDecorators";
+import { V } from "../lib/Values";
 import {
 	ThermostatOperatingState,
 	ThermostatOperatingStateCommand,
 } from "../lib/_Types";
 
+export const ThermostatOperatingStateCCValues = Object.freeze({
+	...V.defineStaticCCValues(CommandClasses["Thermostat Operating State"], {
+		...V.staticPropertyWithName("operatingState", "state", {
+			...ValueMetadata.ReadOnlyUInt8,
+			label: "Operating state",
+			states: enumValuesToMetadataStates(ThermostatOperatingState),
+		} as const),
+	}),
+});
+
 // @noSetValueAPI This CC is read-only
 
 @API(CommandClasses["Thermostat Operating State"])
@@ -79,6 +90,7 @@ export class ThermostatOperatingStateCCAPI extends PhysicalCCAPI {
 
 @commandClass(CommandClasses["Thermostat Operating State"])
 @implementedVersion(2)
+@ccValues(ThermostatOperatingStateCCValues)
 export class ThermostatOperatingStateCC extends CommandClass {
 	declare ccCommand: ThermostatOperatingStateCommand;
 
@@ -138,19 +150,11 @@ export class ThermostatOperatingStateCCReport extends ThermostatOperatingStateCC
 		super(host, options);
 
 		validatePayload(this.payload.length >= 1);
-		this._state = this.payload[0];
+		this.state = this.payload[0];
 	}
 
-	private _state: ThermostatOperatingState;
-	@ccValue()
-	@ccValueMetadata({
-		...ValueMetadata.ReadOnlyUInt8,
-		label: "Operating state",
-		states: enumValuesToMetadataStates(ThermostatOperatingState),
-	})
-	public get state(): ThermostatOperatingState {
-		return this._state;
-	}
+	@ccValue(ThermostatOperatingStateCCValues.operatingState)
+	public readonly state: ThermostatOperatingState;
 
 	public toLogEntry(applHost: ZWaveApplicationHost): MessageOrCCLogEntry {
 		return {
diff --git a/packages/cc/src/cc/ThermostatSetbackCC.ts b/packages/cc/src/cc/ThermostatSetbackCC.ts
index c7536ff9929..89b7ac22115 100644
--- a/packages/cc/src/cc/ThermostatSetbackCC.ts
+++ b/packages/cc/src/cc/ThermostatSetbackCC.ts
@@ -17,8 +17,6 @@ import {
 	throwUnsupportedProperty,
 } from "../lib/API";
 import {
-	ccValue,
-	ccValueMetadata,
 	CommandClass,
 	gotDeserializationOptions,
 	type CCCommandOptions,
@@ -27,17 +25,37 @@ import {
 import {
 	API,
 	CCCommand,
+	ccValue,
+	ccValues,
 	commandClass,
 	expectedCCResponse,
 	implementedVersion,
 } from "../lib/CommandClassDecorators";
 import { decodeSetbackState, encodeSetbackState } from "../lib/serializers";
+import { V } from "../lib/Values";
 import {
 	SetbackState,
 	SetbackType,
 	ThermostatSetbackCommand,
 } from "../lib/_Types";
 
+export const ThermostatSetbackCCValues = Object.freeze({
+	...V.defineStaticCCValues(CommandClasses["Thermostat Setback"], {
+		...V.staticProperty("setbackType", {
+			// TODO: This should be a value list
+			...ValueMetadata.Any,
+			label: "Setback type",
+		} as const),
+
+		...V.staticProperty("setbackState", {
+			...ValueMetadata.Int8,
+			min: -12.8,
+			max: 12,
+			label: "Setback state",
+		} as const),
+	}),
+});
+
 // @noSetValueAPI
 // The setback state consist of two values that must be set together
 
@@ -109,6 +127,7 @@ export class ThermostatSetbackCCAPI extends CCAPI {
 
 @commandClass(CommandClasses["Thermostat Setback"])
 @implementedVersion(1)
+@ccValues(ThermostatSetbackCCValues)
 export class ThermostatSetbackCC extends CommandClass {
 	declare ccCommand: ThermostatSetbackCommand;
 
@@ -219,35 +238,18 @@ export class ThermostatSetbackCCReport extends ThermostatSetbackCC {
 		super(host, options);
 
 		validatePayload(this.payload.length >= 2);
-		this._setbackType = this.payload[0] & 0b11;
+		this.setbackType = this.payload[0] & 0b11;
 		// If we receive an unknown setback state, return the raw value
-		this._setbackState =
+		this.setbackState =
 			decodeSetbackState(this.payload[1]) || this.payload[1];
 	}
 
-	private _setbackType: SetbackType;
-	@ccValue()
-	@ccValueMetadata({
-		// TODO: This should be a value list
-		...ValueMetadata.Any,
-		label: "Setback type",
-	})
-	public get setbackType(): SetbackType {
-		return this._setbackType;
-	}
+	@ccValue(ThermostatSetbackCCValues.setbackType)
+	public readonly setbackType: SetbackType;
 
-	private _setbackState: SetbackState;
+	@ccValue(ThermostatSetbackCCValues.setbackState)
 	/** The offset from the setpoint in 0.1 Kelvin or a special mode */
-	@ccValue()
-	@ccValueMetadata({
-		...ValueMetadata.Int8,
-		min: -12.8,
-		max: 12,
-		label: "Setback state",
-	})
-	public get setbackState(): SetbackState {
-		return this._setbackState;
-	}
+	public readonly setbackState: SetbackState;
 
 	public toLogEntry(applHost: ZWaveApplicationHost): MessageOrCCLogEntry {
 		return {
diff --git a/packages/cc/src/cc/ThermostatSetpointCC.ts b/packages/cc/src/cc/ThermostatSetpointCC.ts
index 5d937aa1a9e..d79426d7510 100644
--- a/packages/cc/src/cc/ThermostatSetpointCC.ts
+++ b/packages/cc/src/cc/ThermostatSetpointCC.ts
@@ -1,7 +1,6 @@
 import type { ConfigManager, Scale } from "@zwave-js/config";
 import type {
 	MessageOrCCLogEntry,
-	ValueID,
 	ValueMetadataNumeric,
 } from "@zwave-js/core/safe";
 import {
@@ -29,20 +28,21 @@ import {
 	throwWrongValueType,
 } from "../lib/API";
 import {
-	ccValue,
 	CommandClass,
 	gotDeserializationOptions,
 	type CCCommandOptions,
 	type CommandClassDeserializationOptions,
-	type CommandClassOptions,
 } from "../lib/CommandClass";
 import {
 	API,
 	CCCommand,
+	ccValue,
+	ccValues,
 	commandClass,
 	expectedCCResponse,
 	implementedVersion,
 } from "../lib/CommandClassDecorators";
+import { V } from "../lib/Values";
 import {
 	ThermostatSetpointCommand,
 	ThermostatSetpointType,
@@ -61,42 +61,47 @@ function getSetpointUnit(configManager: ConfigManager, scale: number): string {
 	return getScale(configManager, scale).unit ?? "";
 }
 
-function getSupportedSetpointTypesValueID(endpoint: number): ValueID {
-	return {
-		commandClass: CommandClasses["Thermostat Setpoint"],
-		property: "supportedSetpointTypes",
-		endpoint,
-	};
-}
-
-function getSetpointTypesInterpretationValueID(endpoint: number): ValueID {
-	return {
-		commandClass: CommandClasses["Thermostat Setpoint"],
-		property: "setpointTypesInterpretation",
-		endpoint,
-	};
-}
+export const ThermostatSetpointCCValues = Object.freeze({
+	...V.defineStaticCCValues(CommandClasses["Thermostat Setpoint"], {
+		...V.staticProperty("supportedSetpointTypes", undefined, {
+			internal: true,
+		}),
 
-function getSetpointValueID(endpoint: number, setpointType: number): ValueID {
-	return {
-		commandClass: CommandClasses["Thermostat Setpoint"],
-		endpoint,
-		property: "setpoint",
-		propertyKey: setpointType,
-	};
-}
+		...V.staticProperty("setpointTypesInterpretation", undefined, {
+			internal: true,
+		}),
+	}),
+
+	...V.defineDynamicCCValues(CommandClasses["Thermostat Setpoint"], {
+		...V.dynamicPropertyAndKeyWithName(
+			"setpoint",
+			"setpoint",
+			(setpointType: ThermostatSetpointType) => setpointType,
+			({ property, propertyKey }) =>
+				property === "setpoint" && typeof propertyKey === "number",
+			(setpointType: ThermostatSetpointType) =>
+				({
+					...ValueMetadata.Number,
+					label: `Setpoint (${getEnumMemberName(
+						ThermostatSetpointType,
+						setpointType,
+					)})`,
+					ccSpecific: { setpointType },
+				} as const),
+		),
 
-function getSetpointScaleValueID(
-	endpoint: number,
-	setpointType: number,
-): ValueID {
-	return {
-		commandClass: CommandClasses["Thermostat Setpoint"],
-		endpoint,
-		property: "setpointScale",
-		propertyKey: setpointType,
-	};
-}
+		// The setpoint scale is only used internally
+		...V.dynamicPropertyAndKeyWithName(
+			"setpointScale",
+			"setpointScale",
+			(setpointType: ThermostatSetpointType) => setpointType,
+			({ property, propertyKey }) =>
+				property === "setpointScale" && typeof propertyKey === "number",
+			undefined,
+			{ internal: true },
+		),
+	}),
+});
 
 @API(CommandClasses["Thermostat Setpoint"])
 export class ThermostatSetpointCCAPI extends CCAPI {
@@ -135,7 +140,9 @@ export class ThermostatSetpointCCAPI extends CCAPI {
 		// SDS14223: The Scale field value MUST be identical to the value received in the Thermostat Setpoint Report for the
 		// actual Setpoint Type during the node interview. Fall back to the first scale if none is known
 		const preferredScale = this.tryGetValueDB()?.getValue<number>(
-			getSetpointScaleValueID(this.endpoint.index, propertyKey),
+			ThermostatSetpointCCValues.setpointScale(propertyKey).endpoint(
+				this.endpoint.index,
+			),
 		);
 		await this.set(propertyKey, value, preferredScale ?? 0);
 
@@ -275,20 +282,10 @@ export class ThermostatSetpointCCAPI extends CCAPI {
 
 @commandClass(CommandClasses["Thermostat Setpoint"])
 @implementedVersion(3)
+@ccValues(ThermostatSetpointCCValues)
 export class ThermostatSetpointCC extends CommandClass {
 	declare ccCommand: ThermostatSetpointCommand;
 
-	public constructor(host: ZWaveHost, options: CommandClassOptions) {
-		super(host, options);
-		this.registerValue(getSetpointTypesInterpretationValueID(0).property, {
-			internal: true,
-		});
-		// The setpoint scale is only used internally
-		this.registerValue(getSetpointScaleValueID(0, 0).property, {
-			internal: true,
-		});
-	}
-
 	public translatePropertyKey(
 		applHost: ZWaveApplicationHost,
 		property: string | number,
@@ -314,7 +311,6 @@ export class ThermostatSetpointCC extends CommandClass {
 		).withOptions({
 			priority: MessagePriority.NodeQuery,
 		});
-		const valueDB = this.getValueDB(applHost);
 
 		applHost.controllerLog.logNode(node.id, {
 			endpoint: this.endpointIndex,
@@ -328,9 +324,6 @@ export class ThermostatSetpointCC extends CommandClass {
 			// Whether our tests changed the assumed bitmask interpretation
 			let interpretationChanged = false;
 
-			const supportedSetpointTypesValueId =
-				getSupportedSetpointTypesValueID(this.endpointIndex);
-
 			// Query the supported setpoint types
 			applHost.controllerLog.logNode(node.id, {
 				endpoint: this.endpointIndex,
@@ -435,15 +428,17 @@ export class ThermostatSetpointCC extends CommandClass {
 
 			// Remember which setpoint types are actually supported, so we don't
 			// need to do this guesswork again
-			valueDB.setValue(
-				supportedSetpointTypesValueId,
+			this.setValue(
+				applHost,
+				ThermostatSetpointCCValues.supportedSetpointTypes,
 				supportedSetpointTypes,
 			);
 
 			// Also save the bitmap interpretation if we know it now
 			if (interpretationChanged) {
-				valueDB.setValue(
-					getSetpointTypesInterpretationValueID(this.endpointIndex),
+				this.setValue(
+					applHost,
+					ThermostatSetpointCCValues.setpointTypesInterpretation,
 					interpretation,
 				);
 			}
@@ -533,11 +528,11 @@ maximum value: ${setpointCaps.maxValue} ${maxValueUnit}`;
 		).withOptions({
 			priority: MessagePriority.NodeQuery,
 		});
-		const valueDB = this.getValueDB(applHost);
 
 		const setpointTypes: ThermostatSetpointType[] =
-			valueDB.getValue(
-				getSupportedSetpointTypesValueID(this.endpointIndex),
+			this.getValue(
+				applHost,
+				ThermostatSetpointCCValues.supportedSetpointTypes,
 			) ?? [];
 
 		// Query each setpoint's current value
@@ -653,35 +648,27 @@ export class ThermostatSetpointCCReport extends ThermostatSetpointCC {
 
 		const scale = getScale(applHost.configManager, this.scale);
 
-		const valueDB = this.getValueDB(applHost);
-		const setpointValueId = getSetpointValueID(
-			this.endpointIndex,
-			this._type,
+		const setpointValue = ThermostatSetpointCCValues.setpoint(this.type);
+		const existingMetadata = this.getMetadata<ValueMetadataNumeric>(
+			applHost,
+			setpointValue,
 		);
+
 		// Update the metadata when it is missing or the unit has changed
-		if (
-			(
-				valueDB.getMetadata(setpointValueId) as
-					| ValueMetadataNumeric
-					| undefined
-			)?.unit !== scale.unit
-		) {
-			valueDB.setMetadata(setpointValueId, {
-				...ValueMetadata.Number,
+		if (existingMetadata?.unit !== scale.unit) {
+			this.setMetadata(applHost, setpointValue, {
+				...(existingMetadata ?? setpointValue.meta),
 				unit: scale.unit,
-				ccSpecific: {
-					setpointType: this._type,
-				},
 			});
 		}
-		valueDB.setValue(setpointValueId, this._value);
+		this.setValue(applHost, setpointValue, this._value);
 
 		// Remember the device-preferred setpoint scale so it can be used in SET commands
-		const scaleValueId = getSetpointScaleValueID(
-			this.endpointIndex,
-			this._type,
+		this.setValue(
+			applHost,
+			ThermostatSetpointCCValues.setpointScale(this.type),
+			scale.key,
 		);
-		valueDB.setValue(scaleValueId, scale.key);
 		return true;
 	}
 
@@ -793,17 +780,14 @@ export class ThermostatSetpointCCCapabilitiesReport extends ThermostatSetpointCC
 		if (!super.persistValues(applHost)) return false;
 
 		// Predefine the metadata
-		const valueId = getSetpointValueID(this.endpointIndex, this._type);
-		this.getValueDB(applHost).setMetadata(valueId, {
-			...ValueMetadata.Number,
+		const setpointValue = ThermostatSetpointCCValues.setpoint(this.type);
+		this.setMetadata(applHost, setpointValue, {
+			...setpointValue.meta,
 			min: this._minValue,
 			max: this._maxValue,
 			unit:
 				getSetpointUnit(applHost.configManager, this._minValueScale) ||
 				getSetpointUnit(applHost.configManager, this._maxValueScale),
-			ccSpecific: {
-				setpointType: this._type,
-			},
 		});
 
 		return true;
@@ -915,13 +899,13 @@ export class ThermostatSetpointCCSupportedReport extends ThermostatSetpointCC {
 		const supported = parseBitMask(bitMask, ThermostatSetpointType["N/A"]);
 		if (this.version >= 3) {
 			// Interpretation A
-			this._supportedSetpointTypes = supported.map(
+			this.supportedSetpointTypes = supported.map(
 				(i) => thermostatSetpointTypeMap[i],
 			);
 		} else {
 			// It is unknown which interpretation the device complies to.
 			// This must be tested during the interview
-			this._supportedSetpointTypes = supported;
+			this.supportedSetpointTypes = supported;
 		}
 		// TODO:
 		// Some devices skip the gaps in the ThermostatSetpointType (Interpretation A), some don't (Interpretation B)
@@ -935,11 +919,8 @@ export class ThermostatSetpointCCSupportedReport extends ThermostatSetpointCC {
 		// node MUST conclude that the actual Setpoint Type is not supported.
 	}
 
-	private _supportedSetpointTypes: ThermostatSetpointType[];
-	@ccValue({ internal: true })
-	public get supportedSetpointTypes(): readonly ThermostatSetpointType[] {
-		return this._supportedSetpointTypes;
-	}
+	@ccValue(ThermostatSetpointCCValues.supportedSetpointTypes)
+	public readonly supportedSetpointTypes: readonly ThermostatSetpointType[];
 
 	public toLogEntry(applHost: ZWaveApplicationHost): MessageOrCCLogEntry {
 		return {
diff --git a/packages/cc/src/cc/TimeParametersCC.ts b/packages/cc/src/cc/TimeParametersCC.ts
index 4e370ab3fa4..c52753429e4 100644
--- a/packages/cc/src/cc/TimeParametersCC.ts
+++ b/packages/cc/src/cc/TimeParametersCC.ts
@@ -6,6 +6,7 @@ import {
 	MessageOrCCLogEntry,
 	MessagePriority,
 	validatePayload,
+	ValueMetadata,
 } from "@zwave-js/core";
 import type { ZWaveApplicationHost, ZWaveHost } from "@zwave-js/host/safe";
 import { validateArgs } from "@zwave-js/transformers";
@@ -19,7 +20,6 @@ import {
 	throwWrongValueType,
 } from "../lib/API";
 import {
-	ccValue,
 	CommandClass,
 	gotDeserializationOptions,
 	type CCCommandOptions,
@@ -28,12 +28,24 @@ import {
 import {
 	API,
 	CCCommand,
+	ccValue,
+	ccValues,
 	commandClass,
 	expectedCCResponse,
 	implementedVersion,
 } from "../lib/CommandClassDecorators";
+import { V } from "../lib/Values";
 import { TimeParametersCommand } from "../lib/_Types";
 
+export const TimeParametersCCValues = Object.freeze({
+	...V.defineStaticCCValues(CommandClasses["Time Parameters"], {
+		...V.staticProperty("dateAndTime", {
+			...ValueMetadata.Any,
+			label: "Date and Time",
+		} as const),
+	}),
+});
+
 /**
  * Determines if the node expects local time instead of UTC.
  */
@@ -179,6 +191,7 @@ export class TimeParametersCCAPI extends CCAPI {
 
 @commandClass(CommandClasses["Time Parameters"])
 @implementedVersion(1)
+@ccValues(TimeParametersCCValues)
 export class TimeParametersCC extends CommandClass {
 	declare ccCommand: TimeParametersCommand;
 
@@ -244,7 +257,7 @@ export class TimeParametersCCReport extends TimeParametersCC {
 		);
 		if (local) {
 			// The initial assumption was incorrect, re-interpret the time
-			const segments = dateToSegments(this._dateAndTime, false);
+			const segments = dateToSegments(this.dateAndTime, false);
 			this._dateAndTime = segmentsToDate(segments, local);
 		}
 
@@ -252,7 +265,7 @@ export class TimeParametersCCReport extends TimeParametersCC {
 	}
 
 	private _dateAndTime: Date;
-	@ccValue()
+	@ccValue(TimeParametersCCValues.dateAndTime)
 	public get dateAndTime(): Date {
 		return this._dateAndTime;
 	}
diff --git a/packages/cc/src/cc/UserCodeCC.ts b/packages/cc/src/cc/UserCodeCC.ts
index a336e52bc50..2b0f63c7008 100644
--- a/packages/cc/src/cc/UserCodeCC.ts
+++ b/packages/cc/src/cc/UserCodeCC.ts
@@ -9,7 +9,6 @@ import {
 	parseBitMask,
 	unknownBoolean,
 	validatePayload,
-	ValueID,
 	ValueMetadata,
 	ZWaveError,
 	ZWaveErrorCodes,
@@ -37,144 +36,102 @@ import {
 	throwWrongValueType,
 } from "../lib/API";
 import {
-	ccValue,
-	ccValueMetadata,
 	CommandClass,
 	type CCCommandOptions,
 	type CommandClassDeserializationOptions,
-	type CommandClassOptions,
 } from "../lib/CommandClass";
 import {
 	API,
 	CCCommand,
+	ccValue,
+	ccValues,
 	commandClass,
 	expectedCCResponse,
 	implementedVersion,
 } from "../lib/CommandClassDecorators";
 import type { NotificationEventPayload } from "../lib/NotificationEventPayload";
+import { V } from "../lib/Values";
 import { KeypadMode, UserCodeCommand, UserIDStatus } from "../lib/_Types";
 
-export function getSupportedUsersValueID(
-	endpoint: number | undefined,
-): ValueID {
-	return {
-		commandClass: CommandClasses["User Code"],
-		endpoint,
-		property: "supportedUsers",
-	};
-}
-
-export function getUserIdStatusValueID(
-	endpoint: number | undefined,
-	userId: number,
-): ValueID {
-	return {
-		commandClass: CommandClasses["User Code"],
-		endpoint,
-		property: "userIdStatus",
-		propertyKey: userId,
-	};
-}
-
-export function getUserCodeValueID(
-	endpoint: number | undefined,
-	userId: number,
-): ValueID {
-	return {
-		commandClass: CommandClasses["User Code"],
-		endpoint,
-		property: "userCode",
-		propertyKey: userId,
-	};
-}
-
-export function getUserCodeChecksumValueID(
-	endpoint: number | undefined,
-): ValueID {
-	return {
-		commandClass: CommandClasses["User Code"],
-		endpoint,
-		property: "userCodeChecksum",
-	};
-}
-
-export function getSupportsMasterCodeValueID(
-	endpoint: number | undefined,
-): ValueID {
-	return {
-		commandClass: CommandClasses["User Code"],
-		endpoint,
-		property: "supportsMasterCode",
-	};
-}
-
-export function getSupportsMasterCodeDeactivationValueID(
-	endpoint: number | undefined,
-): ValueID {
-	return {
-		commandClass: CommandClasses["User Code"],
-		endpoint,
-		property: "supportsMasterCodeDeactivation",
-	};
-}
-
-export function getSupportsUserCodeChecksumValueID(
-	endpoint: number | undefined,
-): ValueID {
-	return {
-		commandClass: CommandClasses["User Code"],
-		endpoint,
-		property: "supportsUserCodeChecksum",
-	};
-}
-
-export function getSupportedUserIDStatusesValueID(
-	endpoint: number | undefined,
-): ValueID {
-	return {
-		commandClass: CommandClasses["User Code"],
-		endpoint,
-		property: "supportedUserIDStatuses",
-	};
-}
-
-export function getSupportedKeypadModesValueID(
-	endpoint: number | undefined,
-): ValueID {
-	return {
-		commandClass: CommandClasses["User Code"],
-		endpoint,
-		property: "supportedKeypadModes",
-	};
-}
-
-export function getKeypadModeValueID(endpoint: number | undefined): ValueID {
-	return {
-		commandClass: CommandClasses["User Code"],
-		endpoint,
-		property: "keypadMode",
-	};
-}
-
-export function getSupportedASCIICharsValueID(
-	endpoint: number | undefined,
-): ValueID {
-	return {
-		commandClass: CommandClasses["User Code"],
-		endpoint,
-		property: "supportedASCIIChars",
-	};
-}
-
-export function getSupportsMultipleUserCodeSetValueID(
-	endpoint: number | undefined,
-): ValueID {
-	return {
-		commandClass: CommandClasses["User Code"],
-		endpoint,
-		property: "supportsMultipleUserCodeSet",
-	};
-}
+export const UserCodeCCValues = Object.freeze({
+	...V.defineStaticCCValues(CommandClasses["User Code"], {
+		...V.staticProperty("supportedUsers", undefined, { internal: true }),
+		...V.staticProperty("supportsMasterCode", undefined, {
+			internal: true,
+		}),
+		...V.staticProperty("supportsMasterCodeDeactivation", undefined, {
+			internal: true,
+		}),
+		...V.staticProperty("supportsUserCodeChecksum", undefined, {
+			internal: true,
+		}),
+		...V.staticProperty("supportsMultipleUserCodeReport", undefined, {
+			internal: true,
+		}),
+		...V.staticProperty("supportsMultipleUserCodeSet", undefined, {
+			internal: true,
+		}),
+		...V.staticProperty("supportedUserIDStatuses", undefined, {
+			internal: true,
+		}),
+		...V.staticProperty("supportedKeypadModes", undefined, {
+			internal: true,
+		}),
+		...V.staticProperty("supportedASCIIChars", undefined, {
+			internal: true,
+		}),
+		...V.staticProperty("userCodeChecksum", undefined, { internal: true }),
+
+		...V.staticProperty(
+			"keypadMode",
+			{
+				...ValueMetadata.ReadOnlyNumber,
+				label: "Keypad Mode",
+			} as const,
+			{ minVersion: 2 } as const,
+		),
+
+		...V.staticProperty(
+			"masterCode",
+			{
+				...ValueMetadata.String,
+				label: "Master Code",
+				minLength: 4,
+				maxLength: 10,
+			} as const,
+			{
+				minVersion: 2,
+				secret: true,
+			} as const,
+		),
+	}),
+
+	...V.defineDynamicCCValues(CommandClasses["User Code"], {
+		...V.dynamicPropertyAndKeyWithName(
+			"userIdStatus",
+			"userIdStatus",
+			(userId: number) => userId,
+			({ property, propertyKey }) =>
+				property === "userIdStatus" && typeof propertyKey === "number",
+			(userId: number) =>
+				({
+					...ValueMetadata.Number,
+					label: `User ID status (${userId})`,
+				} as const),
+		),
+
+		...V.dynamicPropertyAndKeyWithName(
+			"userCode",
+			"userCode",
+			(userId: number) => userId,
+			({ property, propertyKey }) =>
+				property === "userCode" && typeof propertyKey === "number",
+			// The user code metadata is dynamically created
+			undefined,
+			{ secret: true },
+		),
+	}),
+});
 
 function parseExtendedUserCode(payload: Buffer): {
 	code: UserCode;
@@ -207,13 +164,11 @@ function setUserCodeMetadata(
 	userId: number,
 	userCode?: string | Buffer,
 ) {
-	const valueDB = this.getValueDB(applHost);
-	const statusValueId = getUserIdStatusValueID(this.endpointIndex, userId);
-	const codeValueId = getUserCodeValueID(this.endpointIndex, userId);
-	const supportedUserIDStatuses =
-		valueDB.getValue<UserIDStatus[]>(
-			getSupportedUserIDStatusesValueID(this.endpointIndex),
-		) ??
+	const statusValue = UserCodeCCValues.userIdStatus(userId);
+	const codeValue = UserCodeCCValues.userCode(userId);
+
+	const supportedUserIDStatuses: UserIDStatus[] =
+		this.getValue(applHost, UserCodeCCValues.supportedUserIDStatuses) ??
 		(this.version === 1
 			? [
 					UserIDStatus.Available,
@@ -227,16 +182,15 @@ function setUserCodeMetadata(
 					UserIDStatus.Messaging,
 					UserIDStatus.PassageMode,
 			  ]);
-	if (!valueDB.hasMetadata(statusValueId)) {
-		valueDB.setMetadata(statusValueId, {
-			...ValueMetadata.Number,
-			label: `User ID status (${userId})`,
-			states: enumValuesToMetadataStates(
-				UserIDStatus,
-				supportedUserIDStatuses,
-			),
-		});
-	}
+
+	this.ensureMetadata(applHost, statusValue, {
+		...statusValue.meta,
+		states: enumValuesToMetadataStates(
+			UserIDStatus,
+			supportedUserIDStatuses,
+		),
+	});
+
 	const codeMetadata: ValueMetadata = {
 		...(Buffer.isBuffer(userCode)
 			? ValueMetadata.Buffer
@@ -245,8 +199,8 @@ function setUserCodeMetadata(
 		maxLength: 10,
 		label: `User Code (${userId})`,
 	};
-	if (valueDB.getMetadata(codeValueId)?.type !== codeMetadata.type) {
-		valueDB.setMetadata(codeValueId, codeMetadata);
+	if (this.getMetadata(applHost, codeValue)?.type !== codeMetadata.type) {
+		this.setMetadata(applHost, codeValue, codeMetadata);
 	}
 }
 
@@ -257,22 +211,21 @@ function persistUserCode(
 	userIdStatus: UserIDStatus,
 	userCode: string | Buffer,
 ) {
-	const statusValueId = getUserIdStatusValueID(this.endpointIndex, userId);
-	const codeValueId = getUserCodeValueID(this.endpointIndex, userId);
-	const valueDB = this.getValueDB(applHost);
+	const statusValue = UserCodeCCValues.userIdStatus(userId);
+	const codeValue = UserCodeCCValues.userCode(userId);
 
 	// Check if this code is supported
 	if (userIdStatus === UserIDStatus.StatusNotAvailable) {
 		// It is not, remove all values if any exist
-		valueDB.removeValue(statusValueId);
-		valueDB.removeValue(codeValueId);
-		valueDB.setMetadata(statusValueId, undefined);
-		valueDB.setMetadata(codeValueId, undefined);
+		this.removeValue(applHost, statusValue);
+		this.removeValue(applHost, codeValue);
+		this.removeMetadata(applHost, statusValue);
+		this.removeMetadata(applHost, codeValue);
 	} else {
 		// Always create metadata in case it does not exist
 		setUserCodeMetadata.call(this, applHost, userId, userCode);
-		valueDB.setValue(statusValueId, userIdStatus);
-		valueDB.setValue(codeValueId, userCode);
+		this.setValue(applHost, statusValue, userIdStatus);
+		this.setValue(applHost, codeValue, userCode);
 	}
 
 	return true;
@@ -305,7 +258,9 @@ export class UserCodeCCAPI extends PhysicalCCAPI {
 				if (this.version < 2) return false;
 				return (
 					this.tryGetValueDB()?.getValue<Maybe<boolean>>(
-						getSupportsMasterCodeValueID(this.endpoint.index),
+						UserCodeCCValues.supportsMasterCode.endpoint(
+							this.endpoint.index,
+						),
 					) ?? unknownBoolean
 				);
 			}
@@ -314,7 +269,9 @@ export class UserCodeCCAPI extends PhysicalCCAPI {
 				if (this.version < 2) return false;
 				return (
 					this.tryGetValueDB()?.getValue<Maybe<boolean>>(
-						getSupportsUserCodeChecksumValueID(this.endpoint.index),
+						UserCodeCCValues.supportsUserCodeChecksum.endpoint(
+							this.endpoint.index,
+						),
 					) ?? unknownBoolean
 				);
 			}
@@ -367,7 +324,9 @@ export class UserCodeCCAPI extends PhysicalCCAPI {
 			} else {
 				// We need to set the user code along with the status
 				const userCode = this.getValueDB().getValue<string>(
-					getUserCodeValueID(this.endpoint.index, propertyKey),
+					UserCodeCCValues.userCode(propertyKey).endpoint(
+						this.endpoint.index,
+					),
 				);
 				await this.set(propertyKey, value, userCode!);
 			}
@@ -388,7 +347,9 @@ export class UserCodeCCAPI extends PhysicalCCAPI {
 
 			// We need to set the user id status along with the code
 			let userIdStatus = this.getValueDB().getValue<UserIDStatus>(
-				getUserIdStatusValueID(this.endpoint.index, propertyKey),
+				UserCodeCCValues.userIdStatus(propertyKey).endpoint(
+					this.endpoint.index,
+				),
 			);
 			if (
 				userIdStatus === UserIDStatus.Available ||
@@ -855,17 +816,10 @@ export class UserCodeCCAPI extends PhysicalCCAPI {
 
 @commandClass(CommandClasses["User Code"])
 @implementedVersion(2)
+@ccValues(UserCodeCCValues)
 export class UserCodeCC extends CommandClass {
 	declare ccCommand: UserCodeCommand;
 
-	public constructor(host: ZWaveHost, options: CommandClassOptions) {
-		super(host, options);
-		// Hide user codes from value logs
-		this.registerValue(getUserCodeValueID(undefined, 0).property, {
-			secret: true,
-		});
-	}
-
 	public async interview(applHost: ZWaveApplicationHost): Promise<void> {
 		const node = this.getNode(applHost)!;
 		const endpoint = this.getEndpoint(applHost)!;
@@ -939,24 +893,20 @@ export class UserCodeCC extends CommandClass {
 		).withOptions({
 			priority: MessagePriority.NodeQuery,
 		});
-		const valueDB = this.getValueDB(applHost);
 
-		const supportsMasterCode =
-			valueDB.getValue<boolean>(
-				getSupportsMasterCodeValueID(this.endpointIndex),
-			) ?? false;
-		const supportsUserCodeChecksum =
-			valueDB.getValue<boolean>(
-				getSupportsUserCodeChecksumValueID(this.endpointIndex),
+		const supportsMasterCode: boolean =
+			this.getValue(applHost, UserCodeCCValues.supportsMasterCode) ??
+			false;
+		const supportsUserCodeChecksum: boolean =
+			this.getValue(
+				applHost,
+				UserCodeCCValues.supportsUserCodeChecksum,
 			) ?? false;
-		const supportedKeypadModes =
-			valueDB.getValue<readonly KeypadMode[]>(
-				getSupportedKeypadModesValueID(this.endpointIndex),
-			) ?? [];
-		const supportedUsers =
-			valueDB.getValue<number>(
-				getSupportedUsersValueID(this.endpointIndex),
-			) ?? 0;
+		const supportedKeypadModes: readonly KeypadMode[] =
+			this.getValue(applHost, UserCodeCCValues.supportedKeypadModes) ??
+			[];
+		const supportedUsers: number =
+			this.getValue(applHost, UserCodeCCValues.supportedUsers) ?? 0;
 
 		// Check for changed values and codes
 		if (this.version >= 2) {
@@ -974,10 +924,9 @@ export class UserCodeCC extends CommandClass {
 				});
 				await api.getKeypadMode();
 			}
-			const storedUserCodeChecksum =
-				valueDB.getValue<number>(
-					getUserCodeChecksumValueID(this.endpointIndex),
-				) ?? 0;
+			const storedUserCodeChecksum: number =
+				this.getValue(applHost, UserCodeCCValues.userCodeChecksum) ?? 0;
+
 			let currentUserCodeChecksum: number | undefined = 0;
 			if (supportsUserCodeChecksum) {
 				applHost.controllerLog.logNode(node.id, {
@@ -1032,7 +981,7 @@ export class UserCodeCC extends CommandClass {
 	): number | undefined {
 		return applHost
 			.getValueDB(endpoint.nodeId)
-			.getValue(getSupportedUsersValueID(endpoint.index));
+			.getValue(UserCodeCCValues.supportedUsers.endpoint(endpoint.index));
 	}
 
 	/**
@@ -1045,7 +994,9 @@ export class UserCodeCC extends CommandClass {
 	): KeypadMode[] | undefined {
 		return applHost
 			.getValueDB(endpoint.nodeId)
-			.getValue(getSupportedKeypadModesValueID(endpoint.index));
+			.getValue(
+				UserCodeCCValues.supportedKeypadModes.endpoint(endpoint.index),
+			);
 	}
 
 	/**
@@ -1058,7 +1009,11 @@ export class UserCodeCC extends CommandClass {
 	): UserIDStatus[] | undefined {
 		return applHost
 			.getValueDB(endpoint.nodeId)
-			.getValue(getSupportedUserIDStatusesValueID(endpoint.index));
+			.getValue(
+				UserCodeCCValues.supportedUserIDStatuses.endpoint(
+					endpoint.index,
+				),
+			);
 	}
 
 	/**
@@ -1071,7 +1026,9 @@ export class UserCodeCC extends CommandClass {
 	): string | undefined {
 		return applHost
 			.getValueDB(endpoint.nodeId)
-			.getValue(getSupportedASCIICharsValueID(endpoint.index));
+			.getValue(
+				UserCodeCCValues.supportedASCIIChars.endpoint(endpoint.index),
+			);
 	}
 
 	/**
@@ -1085,7 +1042,9 @@ export class UserCodeCC extends CommandClass {
 		return !!applHost
 			.getValueDB(endpoint.nodeId)
 			.getValue<boolean>(
-				getSupportsMasterCodeDeactivationValueID(endpoint.index),
+				UserCodeCCValues.supportsMasterCodeDeactivation.endpoint(
+					endpoint.index,
+				),
 			);
 	}
 
@@ -1100,7 +1059,9 @@ export class UserCodeCC extends CommandClass {
 		return !!applHost
 			.getValueDB(endpoint.nodeId)
 			.getValue<boolean>(
-				getSupportsMultipleUserCodeSetValueID(endpoint.index),
+				UserCodeCCValues.supportsMultipleUserCodeSet.endpoint(
+					endpoint.index,
+				),
 			);
 	}
 }
@@ -1343,7 +1304,7 @@ export class UserCodeCCUsersNumberReport extends UserCodeCC {
 		}
 	}
 
-	@ccValue({ internal: true })
+	@ccValue(UserCodeCCValues.supportedUsers)
 	public readonly supportedUsers: number;
 
 	public toLogEntry(applHost: ZWaveApplicationHost): MessageOrCCLogEntry {
@@ -1415,21 +1376,28 @@ export class UserCodeCCCapabilitiesReport extends UserCodeCC {
 		).toString("ascii");
 	}
 
-	@ccValue({ internal: true })
+	@ccValue(UserCodeCCValues.supportsMasterCode)
 	public readonly supportsMasterCode: boolean;
-	@ccValue({ internal: true })
+
+	@ccValue(UserCodeCCValues.supportsMasterCodeDeactivation)
 	public readonly supportsMasterCodeDeactivation: boolean;
-	@ccValue({ internal: true })
+
+	@ccValue(UserCodeCCValues.supportsUserCodeChecksum)
 	public readonly supportsUserCodeChecksum: boolean;
-	@ccValue({ internal: true })
+
+	@ccValue(UserCodeCCValues.supportsMultipleUserCodeReport)
 	public readonly supportsMultipleUserCodeReport: boolean;
-	@ccValue({ internal: true })
+
+	@ccValue(UserCodeCCValues.supportsMultipleUserCodeSet)
 	public readonly supportsMultipleUserCodeSet: boolean;
-	@ccValue({ internal: true })
+
+	@ccValue(UserCodeCCValues.supportedUserIDStatuses)
 	public readonly supportedUserIDStatuses: readonly UserIDStatus[];
-	@ccValue({ internal: true })
+
+	@ccValue(UserCodeCCValues.supportedKeypadModes)
 	public readonly supportedKeypadModes: readonly KeypadMode[];
-	@ccValue({ internal: true })
+
+	@ccValue(UserCodeCCValues.supportedASCIIChars)
 	public readonly supportedASCIIChars: string;
 
 	public toLogEntry(applHost: ZWaveApplicationHost): MessageOrCCLogEntry {
@@ -1515,17 +1483,16 @@ export class UserCodeCCKeypadModeReport extends UserCodeCC {
 
 	public persistValues(applHost: ZWaveApplicationHost): boolean {
 		if (!super.persistValues(applHost)) return false;
-		const valueDB = this.getValueDB(applHost);
 
 		// Update the keypad modes metadata
-		const supportedKeypadModes = valueDB.getValue<KeypadMode[]>(
-			getSupportedKeypadModesValueID(this.endpointIndex),
+		const supportedKeypadModes: KeypadMode[] = this.getValue(
+			applHost,
+			UserCodeCCValues.supportedKeypadModes,
 		) ?? [this.keypadMode];
 
-		const valueId = getKeypadModeValueID(this.endpointIndex);
-		valueDB.setMetadata(valueId, {
-			...ValueMetadata.ReadOnlyNumber,
-			label: "Keypad Mode",
+		const keypadModeValue = UserCodeCCValues.keypadMode;
+		this.setMetadata(applHost, keypadModeValue, {
+			...keypadModeValue.meta,
 			states: enumValuesToMetadataStates(
 				KeypadMode,
 				supportedKeypadModes,
@@ -1535,7 +1502,7 @@ export class UserCodeCCKeypadModeReport extends UserCodeCC {
 		return true;
 	}
 
-	@ccValue({ minVersion: 2 })
+	@ccValue(UserCodeCCValues.keypadMode)
 	public readonly keypadMode: KeypadMode;
 
 	public toLogEntry(applHost: ZWaveApplicationHost): MessageOrCCLogEntry {
@@ -1609,16 +1576,7 @@ export class UserCodeCCMasterCodeReport extends UserCodeCC {
 			.toString("ascii");
 	}
 
-	@ccValue({
-		minVersion: 2,
-		secret: true,
-	})
-	@ccValueMetadata({
-		...ValueMetadata.String,
-		label: "Master Code",
-		minLength: 4,
-		maxLength: 10,
-	})
+	@ccValue(UserCodeCCValues.masterCode)
 	public readonly masterCode: string;
 
 	public toLogEntry(applHost: ZWaveApplicationHost): MessageOrCCLogEntry {
@@ -1644,7 +1602,7 @@ export class UserCodeCCUserCodeChecksumReport extends UserCodeCC {
 		this.userCodeChecksum = this.payload.readUInt16BE(0);
 	}
 
-	@ccValue({ internal: true })
+	@ccValue(UserCodeCCValues.userCodeChecksum)
 	public readonly userCodeChecksum: number;
 
 	public toLogEntry(applHost: ZWaveApplicationHost): MessageOrCCLogEntry {
diff --git a/packages/cc/src/cc/VersionCC.ts b/packages/cc/src/cc/VersionCC.ts
index 0b22934850a..11afed7f8c5 100644
--- a/packages/cc/src/cc/VersionCC.ts
+++ b/packages/cc/src/cc/VersionCC.ts
@@ -8,7 +8,6 @@ import {
 	MessageRecord,
 	unknownBoolean,
 	validatePayload,
-	ValueID,
 	ValueMetadata,
 	ZWaveError,
 	ZWaveErrorCodes,
@@ -19,8 +18,6 @@ import { getEnumMemberName, num2hex, pick } from "@zwave-js/shared/safe";
 import { validateArgs } from "@zwave-js/transformers";
 import { CCAPI, PhysicalCCAPI } from "../lib/API";
 import {
-	ccValue,
-	ccValueMetadata,
 	CommandClass,
 	gotDeserializationOptions,
 	type CCCommandOptions,
@@ -29,46 +26,175 @@ import {
 import {
 	API,
 	CCCommand,
+	ccValue,
+	ccValues,
 	commandClass,
 	expectedCCResponse,
-	getCommandClass,
 	getImplementedVersion,
 	implementedVersion,
 } from "../lib/CommandClassDecorators";
+import { V } from "../lib/Values";
 import { VersionCommand } from "../lib/_Types";
 
-/** @publicAPI */
-export function getFirmwareVersionsValueId(): ValueID {
-	return {
-		commandClass: CommandClasses.Version,
-		property: "firmwareVersions",
-	};
-}
-
-/** @publicAPI */
-export function getFirmwareVersionsMetadata(): ValueMetadata {
-	return {
-		...ValueMetadata.ReadOnly,
-		type: "string[]",
-		label: "Z-Wave chip firmware versions",
-	};
-}
-
-/** @publicAPI */
-export function getSDKVersionValueId(): ValueID {
-	return {
-		commandClass: CommandClasses.Version,
-		property: "sdkVersion",
-	};
-}
-
-/** @publicAPI */
-export function getSDKVersionMetadata(): ValueMetadata {
-	return {
-		...ValueMetadata.ReadOnlyString,
-		label: "SDK version",
-	};
-}
+export const VersionCCValues = Object.freeze({
+	...V.defineStaticCCValues(CommandClasses.Version, {
+		...V.staticProperty(
+			"firmwareVersions",
+			{
+				...ValueMetadata.ReadOnly,
+				type: "string[]",
+				label: "Z-Wave chip firmware versions",
+			} as const,
+			{ supportsEndpoints: false },
+		),
+
+		...V.staticProperty(
+			"libraryType",
+			{
+				...ValueMetadata.ReadOnlyNumber,
+				label: "Library type",
+				states: enumValuesToMetadataStates(ZWaveLibraryTypes),
+			} as const,
+			{ supportsEndpoints: false },
+		),
+
+		...V.staticProperty(
+			"protocolVersion",
+			{
+				...ValueMetadata.ReadOnlyString,
+				label: "Z-Wave protocol version",
+			} as const,
+			{ supportsEndpoints: false },
+		),
+
+		...V.staticProperty(
+			"hardwareVersion",
+			{
+				...ValueMetadata.ReadOnlyNumber,
+				label: "Z-Wave chip hardware version",
+			} as const,
+			{
+				minVersion: 2,
+				supportsEndpoints: false,
+			} as const,
+		),
+
+		...V.staticProperty("supportsZWaveSoftwareGet", undefined, {
+			minVersion: 3,
+			internal: true,
+		} as const),
+
+		...V.staticProperty(
+			"sdkVersion",
+			{
+				...ValueMetadata.ReadOnlyString,
+				label: "SDK version",
+			} as const,
+			{
+				minVersion: 3,
+				supportsEndpoints: false,
+			} as const,
+		),
+
+		...V.staticProperty(
+			"applicationFrameworkAPIVersion",
+			{
+				...ValueMetadata.ReadOnlyString,
+				label: "Z-Wave application framework API version",
+			} as const,
+			{
+				minVersion: 3,
+				supportsEndpoints: false,
+			} as const,
+		),
+
+		...V.staticProperty(
+			"applicationFrameworkBuildNumber",
+			{
+				...ValueMetadata.ReadOnlyString,
+				label: "Z-Wave application framework API build number",
+			} as const,
+			{
+				minVersion: 3,
+				supportsEndpoints: false,
+			} as const,
+		),
+
+		...V.staticPropertyWithName(
+			"serialAPIVersion",
+			"hostInterfaceVersion",
+			{
+				...ValueMetadata.ReadOnlyString,
+				label: "Serial API version",
+			} as const,
+			{
+				minVersion: 3,
+				supportsEndpoints: false,
+			} as const,
+		),
+
+		...V.staticPropertyWithName(
+			"serialAPIBuildNumber",
+			"hostInterfaceBuildNumber",
+			{
+				...ValueMetadata.ReadOnlyString,
+				label: "Serial API build number",
+			} as const,
+			{
+				minVersion: 3,
+				supportsEndpoints: false,
+			} as const,
+		),
+
+		...V.staticProperty(
+			"zWaveProtocolVersion",
+			{
+				...ValueMetadata.ReadOnlyString,
+				label: "Z-Wave protocol version",
+			} as const,
+			{
+				minVersion: 3,
+				supportsEndpoints: false,
+			} as const,
+		),
+
+		...V.staticProperty(
+			"zWaveProtocolBuildNumber",
+			{
+				...ValueMetadata.ReadOnlyString,
+				label: "Z-Wave protocol build number",
+			} as const,
+			{
+				minVersion: 3,
+				supportsEndpoints: false,
+			} as const,
+		),
+
+		...V.staticProperty(
+			"applicationVersion",
+			{
+				...ValueMetadata.ReadOnlyString,
+				label: "Application version",
+			} as const,
+			{
+				minVersion: 3,
+				supportsEndpoints: false,
+			} as const,
+		),
+
+		...V.staticProperty(
+			"applicationBuildNumber",
+			{
+				...ValueMetadata.ReadOnlyString,
+				label: "Application build number",
+			} as const,
+			{
+				minVersion: 3,
+				supportsEndpoints: false,
+			} as const,
+		),
+	}),
+});
 
 function parseVersion(buffer: Buffer): string {
 	if (buffer[0] === 0 && buffer[1] === 0 && buffer[2] === 0) return "unused";
@@ -95,11 +221,11 @@ export class VersionCCAPI extends PhysicalCCAPI {
 					) >= 3
 				);
 			case VersionCommand.ZWaveSoftwareGet: {
-				let ret = this.getValueDB().getValue<Maybe<boolean>>({
-					commandClass: getCommandClass(this),
-					endpoint: this.endpoint.index,
-					property: "supportsZWaveSoftwareGet",
-				});
+				let ret = this.getValueDB().getValue<Maybe<boolean>>(
+					VersionCCValues.supportsZWaveSoftwareGet.endpoint(
+						this.endpoint.index,
+					),
+				);
 				if (ret == undefined) ret = unknownBoolean;
 				return ret;
 			}
@@ -206,6 +332,7 @@ export class VersionCCAPI extends PhysicalCCAPI {
 
 @commandClass(CommandClasses.Version)
 @implementedVersion(3)
+@ccValues(VersionCCValues)
 export class VersionCC extends CommandClass {
 	declare ccCommand: VersionCommand;
 
@@ -410,11 +537,11 @@ export class VersionCCReport extends VersionCC {
 		super(host, options);
 
 		validatePayload(this.payload.length >= 5);
-		this._libraryType = this.payload[0];
-		this._protocolVersion = `${this.payload[1]}.${this.payload[2]}`;
-		this._firmwareVersions = [`${this.payload[3]}.${this.payload[4]}`];
+		this.libraryType = this.payload[0];
+		this.protocolVersion = `${this.payload[1]}.${this.payload[2]}`;
+		this.firmwareVersions = [`${this.payload[3]}.${this.payload[4]}`];
 		if (this.version >= 2 && this.payload.length >= 7) {
-			this._hardwareVersion = this.payload[5];
+			this.hardwareVersion = this.payload[5];
 			const additionalFirmwares = this.payload[6];
 			validatePayload(this.payload.length >= 7 + 2 * additionalFirmwares);
 			for (let i = 0; i < additionalFirmwares; i++) {
@@ -425,55 +552,29 @@ export class VersionCCReport extends VersionCC {
 		}
 	}
 
-	private _libraryType: ZWaveLibraryTypes;
-	@ccValue()
-	@ccValueMetadata({
-		...ValueMetadata.ReadOnlyNumber,
-		label: "Library type",
-		states: enumValuesToMetadataStates(ZWaveLibraryTypes),
-	})
-	public get libraryType(): ZWaveLibraryTypes {
-		return this._libraryType;
-	}
+	@ccValue(VersionCCValues.libraryType)
+	public readonly libraryType: ZWaveLibraryTypes;
 
-	private _protocolVersion: string;
-	@ccValue()
-	@ccValueMetadata({
-		...ValueMetadata.ReadOnlyString,
-		label: "Z-Wave protocol version",
-	})
-	public get protocolVersion(): string {
-		return this._protocolVersion;
-	}
+	@ccValue(VersionCCValues.protocolVersion)
+	public readonly protocolVersion: string;
 
-	private _firmwareVersions: string[];
-	@ccValue()
-	@ccValueMetadata(getFirmwareVersionsMetadata())
-	public get firmwareVersions(): string[] {
-		return this._firmwareVersions;
-	}
+	@ccValue(VersionCCValues.firmwareVersions)
+	public readonly firmwareVersions: string[];
 
-	private _hardwareVersion: number | undefined;
-	@ccValue({ minVersion: 2 })
-	@ccValueMetadata({
-		...ValueMetadata.ReadOnlyNumber,
-		label: "Z-Wave chip hardware version",
-	})
-	public get hardwareVersion(): number | undefined {
-		return this._hardwareVersion;
-	}
+	@ccValue(VersionCCValues.hardwareVersion)
+	public readonly hardwareVersion: number | undefined;
 
 	public toLogEntry(applHost: ZWaveApplicationHost): MessageOrCCLogEntry {
 		const message: MessageRecord = {
 			"library type": getEnumMemberName(
 				ZWaveLibraryTypes,
-				this._libraryType,
+				this.libraryType,
 			),
-			"protocol version": this._protocolVersion,
-			"firmware versions": this._firmwareVersions.join(", "),
+			"protocol version": this.protocolVersion,
+			"firmware versions": this.firmwareVersions.join(", "),
 		};
-		if (this._hardwareVersion != undefined) {
-			message["hardware version"] = this._hardwareVersion;
+		if (this.hardwareVersion != undefined) {
+			message["hardware version"] = this.hardwareVersion;
 		}
 		return {
 			...super.toLogEntry(applHost),
@@ -581,24 +682,18 @@ export class VersionCCCapabilitiesReport extends VersionCC {
 
 		validatePayload(this.payload.length >= 1);
 		const capabilities = this.payload[0];
-		this._supportsZWaveSoftwareGet = !!(capabilities & 0b100);
+		this.supportsZWaveSoftwareGet = !!(capabilities & 0b100);
 	}
 
-	private _supportsZWaveSoftwareGet: boolean;
-	@ccValue({
-		minVersion: 3,
-		internal: true,
-	})
-	public get supportsZWaveSoftwareGet(): boolean {
-		return this._supportsZWaveSoftwareGet;
-	}
+	@ccValue(VersionCCValues.supportsZWaveSoftwareGet)
+	public readonly supportsZWaveSoftwareGet: boolean;
 
 	public toLogEntry(applHost: ZWaveApplicationHost): MessageOrCCLogEntry {
 		return {
 			...super.toLogEntry(applHost),
 			message: {
 				"supports Z-Wave Software Get command":
-					this._supportsZWaveSoftwareGet,
+					this.supportsZWaveSoftwareGet,
 			},
 		};
 	}
@@ -617,146 +712,85 @@ export class VersionCCZWaveSoftwareReport extends VersionCC {
 		super(host, options);
 
 		validatePayload(this.payload.length >= 23);
-		this._sdkVersion = parseVersion(this.payload);
-		this._applicationFrameworkAPIVersion = parseVersion(
+		this.sdkVersion = parseVersion(this.payload);
+		this.applicationFrameworkAPIVersion = parseVersion(
 			this.payload.slice(3),
 		);
-		if (this._applicationFrameworkAPIVersion !== "unused") {
-			this._applicationFrameworkBuildNumber =
-				this.payload.readUInt16BE(6);
+		if (this.applicationFrameworkAPIVersion !== "unused") {
+			this.applicationFrameworkBuildNumber = this.payload.readUInt16BE(6);
 		} else {
-			this._applicationFrameworkBuildNumber = 0;
+			this.applicationFrameworkBuildNumber = 0;
 		}
-		this._hostInterfaceVersion = parseVersion(this.payload.slice(8));
-		if (this._hostInterfaceVersion !== "unused") {
-			this._hostInterfaceBuildNumber = this.payload.readUInt16BE(11);
+		this.hostInterfaceVersion = parseVersion(this.payload.slice(8));
+		if (this.hostInterfaceVersion !== "unused") {
+			this.hostInterfaceBuildNumber = this.payload.readUInt16BE(11);
 		} else {
-			this._hostInterfaceBuildNumber = 0;
+			this.hostInterfaceBuildNumber = 0;
 		}
-		this._zWaveProtocolVersion = parseVersion(this.payload.slice(13));
-		if (this._zWaveProtocolVersion !== "unused") {
-			this._zWaveProtocolBuildNumber = this.payload.readUInt16BE(16);
+		this.zWaveProtocolVersion = parseVersion(this.payload.slice(13));
+		if (this.zWaveProtocolVersion !== "unused") {
+			this.zWaveProtocolBuildNumber = this.payload.readUInt16BE(16);
 		} else {
-			this._zWaveProtocolBuildNumber = 0;
+			this.zWaveProtocolBuildNumber = 0;
 		}
-		this._applicationVersion = parseVersion(this.payload.slice(18));
-		if (this._applicationVersion !== "unused") {
-			this._applicationBuildNumber = this.payload.readUInt16BE(21);
+		this.applicationVersion = parseVersion(this.payload.slice(18));
+		if (this.applicationVersion !== "unused") {
+			this.applicationBuildNumber = this.payload.readUInt16BE(21);
 		} else {
-			this._applicationBuildNumber = 0;
+			this.applicationBuildNumber = 0;
 		}
 	}
 
-	private _sdkVersion: string;
-	@ccValue({ minVersion: 3 })
-	@ccValueMetadata(getSDKVersionMetadata())
-	public get sdkVersion(): string {
-		return this._sdkVersion;
-	}
+	@ccValue(VersionCCValues.sdkVersion)
+	public readonly sdkVersion: string;
 
-	private _applicationFrameworkAPIVersion: string;
-	@ccValue({ minVersion: 3 })
-	@ccValueMetadata({
-		...ValueMetadata.ReadOnlyString,
-		label: "Z-Wave application framework API version",
-	})
-	public get applicationFrameworkAPIVersion(): string {
-		return this._applicationFrameworkAPIVersion;
-	}
+	@ccValue(VersionCCValues.applicationFrameworkAPIVersion)
+	public readonly applicationFrameworkAPIVersion: string;
 
-	private _applicationFrameworkBuildNumber: number;
-	@ccValue({ minVersion: 3 })
-	@ccValueMetadata({
-		...ValueMetadata.ReadOnlyString,
-		label: "Z-Wave application framework API build number",
-	})
-	public get applicationFrameworkBuildNumber(): number {
-		return this._applicationFrameworkBuildNumber;
-	}
+	@ccValue(VersionCCValues.applicationFrameworkBuildNumber)
+	public readonly applicationFrameworkBuildNumber: number;
 
-	private _hostInterfaceVersion: string;
-	@ccValue({ minVersion: 3 })
-	@ccValueMetadata({
-		...ValueMetadata.ReadOnlyString,
-		label: "Serial API version",
-	})
-	public get hostInterfaceVersion(): string {
-		return this._hostInterfaceVersion;
-	}
+	@ccValue(VersionCCValues.serialAPIVersion)
+	public readonly hostInterfaceVersion: string;
 
-	private _hostInterfaceBuildNumber: number;
-	@ccValue({ minVersion: 3 })
-	@ccValueMetadata({
-		...ValueMetadata.ReadOnlyString,
-		label: "Serial API build number",
-	})
-	public get hostInterfaceBuildNumber(): number {
-		return this._hostInterfaceBuildNumber;
-	}
+	@ccValue(VersionCCValues.serialAPIBuildNumber)
+	public readonly hostInterfaceBuildNumber: number;
 
-	private _zWaveProtocolVersion: string;
-	@ccValue({ minVersion: 3 })
-	@ccValueMetadata({
-		...ValueMetadata.ReadOnlyString,
-		label: "Z-Wave protocol version",
-	})
-	public get zWaveProtocolVersion(): string {
-		return this._zWaveProtocolVersion;
-	}
+	@ccValue(VersionCCValues.zWaveProtocolVersion)
+	public readonly zWaveProtocolVersion: string;
 
-	private _zWaveProtocolBuildNumber: number;
-	@ccValue({ minVersion: 3 })
-	@ccValueMetadata({
-		...ValueMetadata.ReadOnlyString,
-		label: "Z-Wave protocol build number",
-	})
-	public get zWaveProtocolBuildNumber(): number {
-		return this._zWaveProtocolBuildNumber;
-	}
+	@ccValue(VersionCCValues.zWaveProtocolBuildNumber)
+	public readonly zWaveProtocolBuildNumber: number;
 
-	private _applicationVersion: string;
-	@ccValue({ minVersion: 3 })
-	@ccValueMetadata({
-		...ValueMetadata.ReadOnlyString,
-		label: "Application version",
-	})
-	public get applicationVersion(): string {
-		return this._applicationVersion;
-	}
+	@ccValue(VersionCCValues.applicationVersion)
+	public readonly applicationVersion: string;
 
-	private _applicationBuildNumber: number;
-	@ccValue({ minVersion: 3 })
-	@ccValueMetadata({
-		...ValueMetadata.ReadOnlyString,
-		label: "Application build number",
-	})
-	public get applicationBuildNumber(): number {
-		return this._applicationBuildNumber;
-	}
+	@ccValue(VersionCCValues.applicationBuildNumber)
+	public readonly applicationBuildNumber: number;
 
 	public toLogEntry(applHost: ZWaveApplicationHost): MessageOrCCLogEntry {
 		const message: MessageRecord = {
-			"SDK version": this._sdkVersion,
+			"SDK version": this.sdkVersion,
 		};
 		message["appl. framework API version"] =
-			this._applicationFrameworkAPIVersion;
-		if (this._applicationFrameworkAPIVersion !== "unused") {
+			this.applicationFrameworkAPIVersion;
+		if (this.applicationFrameworkAPIVersion !== "unused") {
 			message["appl. framework build number"] =
-				this._applicationFrameworkBuildNumber;
+				this.applicationFrameworkBuildNumber;
 		}
-		message["host interface version"] = this._hostInterfaceVersion;
-		if (this._hostInterfaceVersion !== "unused") {
+		message["host interface version"] = this.hostInterfaceVersion;
+		if (this.hostInterfaceVersion !== "unused") {
 			message["host interface  build number"] =
-				this._hostInterfaceBuildNumber;
+				this.hostInterfaceBuildNumber;
 		}
-		message["Z-Wave protocol version"] = this._zWaveProtocolVersion;
-		if (this._zWaveProtocolVersion !== "unused") {
+		message["Z-Wave protocol version"] = this.zWaveProtocolVersion;
+		if (this.zWaveProtocolVersion !== "unused") {
 			message["Z-Wave protocol build number"] =
-				this._zWaveProtocolBuildNumber;
+				this.zWaveProtocolBuildNumber;
 		}
-		message["application version"] = this._applicationVersion;
-		if (this._applicationVersion !== "unused") {
-			message["application build number"] = this._applicationBuildNumber;
+		message["application version"] = this.applicationVersion;
+		if (this.applicationVersion !== "unused") {
+			message["application build number"] = this.applicationBuildNumber;
 		}
 		return {
 			...super.toLogEntry(applHost),
diff --git a/packages/cc/src/cc/WakeUpCC.ts b/packages/cc/src/cc/WakeUpCC.ts
index 888d262bdc4..7225fba7c4b 100644
--- a/packages/cc/src/cc/WakeUpCC.ts
+++ b/packages/cc/src/cc/WakeUpCC.ts
@@ -4,7 +4,6 @@ import {
 	MessageOrCCLogEntry,
 	MessagePriority,
 	validatePayload,
-	ValueID,
 	ValueMetadata,
 	ZWaveError,
 	ZWaveErrorCodes,
@@ -22,8 +21,6 @@ import {
 	type SetValueImplementation,
 } from "../lib/API";
 import {
-	ccValue,
-	ccValueMetadata,
 	CommandClass,
 	gotDeserializationOptions,
 	type CCCommandOptions,
@@ -32,33 +29,46 @@ import {
 import {
 	API,
 	CCCommand,
+	ccValue,
+	ccValues,
 	commandClass,
 	expectedCCResponse,
 	implementedVersion,
 } from "../lib/CommandClassDecorators";
+import { V } from "../lib/Values";
 import { WakeUpCommand } from "../lib/_Types";
 
-export function getControllerNodeIdValueId(): ValueID {
-	return {
-		commandClass: CommandClasses["Wake Up"],
-		property: "controllerNodeId",
-	};
-}
+export const WakeUpCCValues = Object.freeze({
+	...V.defineStaticCCValues(CommandClasses["Wake Up"], {
+		...V.staticProperty(
+			"controllerNodeId",
+			{
+				...ValueMetadata.ReadOnly,
+				label: "Node ID of the controller",
+			} as const,
+			{
+				supportsEndpoints: false,
+			},
+		),
 
-/** @publicAPI */
-export function getWakeUpIntervalValueId(): ValueID {
-	return {
-		commandClass: CommandClasses["Wake Up"],
-		property: "wakeUpInterval",
-	};
-}
+		...V.staticProperty(
+			"wakeUpInterval",
+			{
+				...ValueMetadata.UInt24,
+				label: "Wake Up interval",
+			} as const,
+			{
+				supportsEndpoints: false,
+			},
+		),
 
-export function getWakeUpOnDemandSupportedValueId(): ValueID {
-	return {
-		commandClass: CommandClasses["Wake Up"],
-		property: "wakeUpOnDemandSupported",
-	};
-}
+		...V.staticProperty("wakeUpOnDemandSupported", undefined, {
+			internal: true,
+			supportsEndpoints: false,
+			minVersion: 3,
+		}),
+	}),
+});
 
 @API(CommandClasses["Wake Up"])
 export class WakeUpCCAPI extends CCAPI {
@@ -187,6 +197,7 @@ export class WakeUpCCAPI extends CCAPI {
 
 @commandClass(CommandClasses["Wake Up"])
 @implementedVersion(3)
+@ccValues(WakeUpCCValues)
 export class WakeUpCC extends CommandClass {
 	declare ccCommand: WakeUpCommand;
 
@@ -200,7 +211,6 @@ export class WakeUpCC extends CommandClass {
 		).withOptions({
 			priority: MessagePriority.NodeQuery,
 		});
-		const valueDB = this.getValueDB(applHost);
 
 		applHost.controllerLog.logNode(node.id, {
 			endpoint: this.endpointIndex,
@@ -278,7 +288,11 @@ controller node: ${wakeupResp.controllerNodeId}`;
 						direction: "outbound",
 					});
 					await api.setInterval(wakeupResp.wakeUpInterval, ownNodeId);
-					valueDB.setValue(getControllerNodeIdValueId(), ownNodeId);
+					this.setValue(
+						applHost,
+						WakeUpCCValues.controllerNodeId,
+						ownNodeId,
+					);
 					applHost.controllerLog.logNode(
 						node.id,
 						"wakeup destination node changed!",
@@ -358,36 +372,22 @@ export class WakeUpCCIntervalReport extends WakeUpCC {
 		super(host, options);
 
 		validatePayload(this.payload.length >= 4);
-		this._wakeUpInterval = this.payload.readUIntBE(0, 3);
-		this._controllerNodeId = this.payload[3];
+		this.wakeUpInterval = this.payload.readUIntBE(0, 3);
+		this.controllerNodeId = this.payload[3];
 	}
 
-	private _wakeUpInterval: number;
-	@ccValue()
-	@ccValueMetadata({
-		...ValueMetadata.UInt24,
-		label: "Wake Up interval",
-	})
-	public get wakeUpInterval(): number {
-		return this._wakeUpInterval;
-	}
+	@ccValue(WakeUpCCValues.wakeUpInterval)
+	public readonly wakeUpInterval: number;
 
-	private _controllerNodeId: number;
-	@ccValue()
-	@ccValueMetadata({
-		...ValueMetadata.ReadOnly,
-		label: "Node ID of the controller",
-	})
-	public get controllerNodeId(): number {
-		return this._controllerNodeId;
-	}
+	@ccValue(WakeUpCCValues.controllerNodeId)
+	public readonly controllerNodeId: number;
 
 	public toLogEntry(applHost: ZWaveApplicationHost): MessageOrCCLogEntry {
 		return {
 			...super.toLogEntry(applHost),
 			message: {
 				"wake-up interval": `${this.wakeUpInterval} seconds`,
-				"controller node id": this._controllerNodeId,
+				"controller node id": this.controllerNodeId,
 			},
 		};
 	}
@@ -412,16 +412,16 @@ export class WakeUpCCIntervalCapabilitiesReport extends WakeUpCC {
 		super(host, options);
 
 		validatePayload(this.payload.length >= 12);
-		this._minWakeUpInterval = this.payload.readUIntBE(0, 3);
-		this._maxWakeUpInterval = this.payload.readUIntBE(3, 3);
-		this._defaultWakeUpInterval = this.payload.readUIntBE(6, 3);
-		this._wakeUpIntervalSteps = this.payload.readUIntBE(9, 3);
+		this.minWakeUpInterval = this.payload.readUIntBE(0, 3);
+		this.maxWakeUpInterval = this.payload.readUIntBE(3, 3);
+		this.defaultWakeUpInterval = this.payload.readUIntBE(6, 3);
+		this.wakeUpIntervalSteps = this.payload.readUIntBE(9, 3);
 
 		// Get 'Wake Up on Demand Support' if node supports V3 and sends 13th byte
 		if (this.version >= 3 && this.payload.length >= 13) {
-			this._wakeUpOnDemandSupported = !!(this.payload[12] & 0b1);
+			this.wakeUpOnDemandSupported = !!(this.payload[12] & 0b1);
 		} else {
-			this._wakeUpOnDemandSupported = false;
+			this.wakeUpOnDemandSupported = false;
 		}
 	}
 
@@ -438,10 +438,10 @@ export class WakeUpCCIntervalCapabilitiesReport extends WakeUpCC {
 			},
 			{
 				...ValueMetadata.WriteOnlyUInt24,
-				min: this._minWakeUpInterval,
-				max: this._maxWakeUpInterval,
-				steps: this._wakeUpIntervalSteps,
-				default: this._defaultWakeUpInterval,
+				min: this.minWakeUpInterval,
+				max: this.maxWakeUpInterval,
+				steps: this.wakeUpIntervalSteps,
+				default: this.defaultWakeUpInterval,
 			},
 		);
 
@@ -450,45 +450,23 @@ export class WakeUpCCIntervalCapabilitiesReport extends WakeUpCC {
 		return true;
 	}
 
-	private _minWakeUpInterval: number;
-	public get minWakeUpInterval(): number {
-		return this._minWakeUpInterval;
-	}
+	public readonly minWakeUpInterval: number;
+	public readonly maxWakeUpInterval: number;
+	public readonly defaultWakeUpInterval: number;
+	public readonly wakeUpIntervalSteps: number;
 
-	private _maxWakeUpInterval: number;
-	public get maxWakeUpInterval(): number {
-		return this._maxWakeUpInterval;
-	}
-
-	private _defaultWakeUpInterval: number;
-	public get defaultWakeUpInterval(): number {
-		return this._defaultWakeUpInterval;
-	}
-
-	private _wakeUpIntervalSteps: number;
-	public get wakeUpIntervalSteps(): number {
-		return this._wakeUpIntervalSteps;
-	}
-
-	private _wakeUpOnDemandSupported: boolean;
-	@ccValue({ minVersion: 3 })
-	@ccValueMetadata({
-		...ValueMetadata.ReadOnlyBoolean,
-		label: "Wake Up On Demand supported",
-	})
-	public get wakeUpOnDemandSupported(): boolean {
-		return this._wakeUpOnDemandSupported;
-	}
+	@ccValue(WakeUpCCValues.wakeUpOnDemandSupported)
+	public readonly wakeUpOnDemandSupported: boolean;
 
 	public toLogEntry(applHost: ZWaveApplicationHost): MessageOrCCLogEntry {
 		return {
 			...super.toLogEntry(applHost),
 			message: {
-				"default interval": `${this._defaultWakeUpInterval} seconds`,
-				"minimum interval": `${this._minWakeUpInterval} seconds`,
-				"maximum interval": `${this._maxWakeUpInterval} seconds`,
-				"interval steps": `${this._wakeUpIntervalSteps} seconds`,
-				"wake up on demand supported": `${this._wakeUpOnDemandSupported}`,
+				"default interval": `${this.defaultWakeUpInterval} seconds`,
+				"minimum interval": `${this.minWakeUpInterval} seconds`,
+				"maximum interval": `${this.maxWakeUpInterval} seconds`,
+				"interval steps": `${this.wakeUpIntervalSteps} seconds`,
+				"wake up on demand supported": `${this.wakeUpOnDemandSupported}`,
 			},
 		};
 	}
diff --git a/packages/cc/src/cc/ZWavePlusCC.ts b/packages/cc/src/cc/ZWavePlusCC.ts
index 606a7b72c45..9b05047bf4f 100644
--- a/packages/cc/src/cc/ZWavePlusCC.ts
+++ b/packages/cc/src/cc/ZWavePlusCC.ts
@@ -1,4 +1,4 @@
-import type { Maybe, MessageOrCCLogEntry, ValueID } from "@zwave-js/core/safe";
+import type { Maybe, MessageOrCCLogEntry } from "@zwave-js/core/safe";
 import {
 	CommandClasses,
 	MessagePriority,
@@ -9,7 +9,6 @@ import { getEnumMemberName, num2hex, pick } from "@zwave-js/shared/safe";
 import { validateArgs } from "@zwave-js/transformers";
 import { CCAPI, PhysicalCCAPI } from "../lib/API";
 import {
-	ccValue,
 	CommandClass,
 	gotDeserializationOptions,
 	type CCCommandOptions,
@@ -18,10 +17,13 @@ import {
 import {
 	API,
 	CCCommand,
+	ccValue,
+	ccValues,
 	commandClass,
 	expectedCCResponse,
 	implementedVersion,
 } from "../lib/CommandClassDecorators";
+import { V } from "../lib/Values";
 import {
 	ZWavePlusCommand,
 	ZWavePlusNodeType,
@@ -32,42 +34,32 @@ import {
 // MUST be identical for the Root Device and all Multi Channel End Points
 // --> We only access endpoint 0
 
-export function getZWavePlusVersionValueId(): ValueID {
-	return {
-		commandClass: CommandClasses["Z-Wave Plus Info"],
-		property: "zwavePlusVersion",
-	};
-}
-
-export function getNodeTypeValueId(): ValueID {
-	return {
-		commandClass: CommandClasses["Z-Wave Plus Info"],
-		property: "nodeType",
-	};
-}
-
-export function getRoleTypeValueId(): ValueID {
-	return {
-		commandClass: CommandClasses["Z-Wave Plus Info"],
-		property: "roleType",
-	};
-}
-
-export function getInstallerIconValueId(endpoint: number = 0): ValueID {
-	return {
-		commandClass: CommandClasses["Z-Wave Plus Info"],
-		endpoint,
-		property: "installerIcon",
-	};
-}
-
-export function getUserIconValueId(endpoint: number = 0): ValueID {
-	return {
-		commandClass: CommandClasses["Z-Wave Plus Info"],
-		endpoint,
-		property: "userIcon",
-	};
-}
+export const ZWavePlusCCValues = Object.freeze({
+	...V.defineStaticCCValues(CommandClasses["Z-Wave Plus Info"], {
+		...V.staticProperty("zwavePlusVersion", undefined, {
+			supportsEndpoints: false,
+			internal: true,
+		}),
+
+		...V.staticProperty("nodeType", undefined, {
+			supportsEndpoints: false,
+			internal: true,
+		}),
+
+		...V.staticProperty("roleType", undefined, {
+			supportsEndpoints: false,
+			internal: true,
+		}),
+
+		...V.staticProperty("userIcon", undefined, {
+			internal: true,
+		}),
+
+		...V.staticProperty("installerIcon", undefined, {
+			internal: true,
+		}),
+	}),
+});
 
 // @noSetValueAPI This CC is read-only
 
@@ -120,6 +112,7 @@ export class ZWavePlusCCAPI extends PhysicalCCAPI {
 
 @commandClass(CommandClasses["Z-Wave Plus Info"])
 @implementedVersion(2)
+@ccValues(ZWavePlusCCValues)
 export class ZWavePlusCC extends CommandClass {
 	declare ccCommand: ZWavePlusCommand;
 
@@ -199,15 +192,19 @@ export class ZWavePlusCCReport extends ZWavePlusCC {
 		}
 	}
 
-	@ccValue({ internal: true })
+	@ccValue(ZWavePlusCCValues.zwavePlusVersion)
 	public zwavePlusVersion: number;
-	@ccValue({ internal: true })
+
+	@ccValue(ZWavePlusCCValues.nodeType)
 	public nodeType: ZWavePlusNodeType;
-	@ccValue({ internal: true })
+
+	@ccValue(ZWavePlusCCValues.roleType)
 	public roleType: ZWavePlusRoleType;
-	@ccValue({ internal: true })
+
+	@ccValue(ZWavePlusCCValues.installerIcon)
 	public installerIcon: number;
-	@ccValue({ internal: true })
+
+	@ccValue(ZWavePlusCCValues.userIcon)
 	public userIcon: number;
 
 	public serialize(): Buffer {
diff --git a/packages/cc/src/cc/index.ts b/packages/cc/src/cc/index.ts
index 25da5db70ad..029eb8d1bed 100644
--- a/packages/cc/src/cc/index.ts
+++ b/packages/cc/src/cc/index.ts
@@ -7,6 +7,7 @@ export {
 	AlarmSensorCCReport,
 	AlarmSensorCCSupportedGet,
 	AlarmSensorCCSupportedReport,
+	AlarmSensorCCValues,
 } from "./AlarmSensorCC";
 export {
 	AssociationCC,
@@ -16,6 +17,7 @@ export {
 	AssociationCCSet,
 	AssociationCCSupportedGroupingsGet,
 	AssociationCCSupportedGroupingsReport,
+	AssociationCCValues,
 } from "./AssociationCC";
 export {
 	AssociationGroupInfoCC,
@@ -25,6 +27,7 @@ export {
 	AssociationGroupInfoCCInfoReport,
 	AssociationGroupInfoCCNameGet,
 	AssociationGroupInfoCCNameReport,
+	AssociationGroupInfoCCValues,
 } from "./AssociationGroupInfoCC";
 export {
 	BarrierOperatorCC,
@@ -36,14 +39,22 @@ export {
 	BarrierOperatorCCSet,
 	BarrierOperatorCCSignalingCapabilitiesGet,
 	BarrierOperatorCCSignalingCapabilitiesReport,
+	BarrierOperatorCCValues,
 } from "./BarrierOperatorCC";
-export { BasicCC, BasicCCGet, BasicCCReport, BasicCCSet } from "./BasicCC";
+export {
+	BasicCC,
+	BasicCCGet,
+	BasicCCReport,
+	BasicCCSet,
+	BasicCCValues,
+} from "./BasicCC";
 export {
 	BatteryCC,
 	BatteryCCGet,
 	BatteryCCHealthGet,
 	BatteryCCHealthReport,
 	BatteryCCReport,
+	BatteryCCValues,
 } from "./BatteryCC";
 export {
 	BinarySensorCC,
@@ -51,12 +62,14 @@ export {
 	BinarySensorCCReport,
 	BinarySensorCCSupportedGet,
 	BinarySensorCCSupportedReport,
+	BinarySensorCCValues,
 } from "./BinarySensorCC";
 export {
 	BinarySwitchCC,
 	BinarySwitchCCGet,
 	BinarySwitchCCReport,
 	BinarySwitchCCSet,
+	BinarySwitchCCValues,
 } from "./BinarySwitchCC";
 export {
 	CentralSceneCC,
@@ -66,6 +79,7 @@ export {
 	CentralSceneCCNotification,
 	CentralSceneCCSupportedGet,
 	CentralSceneCCSupportedReport,
+	CentralSceneCCValues,
 } from "./CentralSceneCC";
 export {
 	ClimateControlScheduleCC,
@@ -77,6 +91,7 @@ export {
 	ClimateControlScheduleCCOverrideSet,
 	ClimateControlScheduleCCReport,
 	ClimateControlScheduleCCSet,
+	ClimateControlScheduleCCValues,
 } from "./ClimateControlScheduleCC";
 export { ClockCC, ClockCCGet, ClockCCReport, ClockCCSet } from "./ClockCC";
 export {
@@ -88,6 +103,7 @@ export {
 	ColorSwitchCCStopLevelChange,
 	ColorSwitchCCSupportedGet,
 	ColorSwitchCCSupportedReport,
+	ColorSwitchCCValues,
 } from "./ColorSwitchCC";
 export {
 	ConfigurationCC,
@@ -104,6 +120,7 @@ export {
 	ConfigurationCCPropertiesReport,
 	ConfigurationCCReport,
 	ConfigurationCCSet,
+	ConfigurationCCValues,
 } from "./ConfigurationCC";
 export { CRC16CC, CRC16CCCommandEncapsulation } from "./CRC16CC";
 export {
@@ -120,6 +137,7 @@ export {
 	DoorLockCCOperationGet,
 	DoorLockCCOperationReport,
 	DoorLockCCOperationSet,
+	DoorLockCCValues,
 } from "./DoorLockCC";
 export {
 	DoorLockLoggingCC,
@@ -127,6 +145,7 @@ export {
 	DoorLockLoggingCCRecordReport,
 	DoorLockLoggingCCRecordsSupportedGet,
 	DoorLockLoggingCCRecordsSupportedReport,
+	DoorLockLoggingCCValues,
 } from "./DoorLockLoggingCC";
 export {
 	EntryControlCC,
@@ -138,6 +157,7 @@ export {
 	EntryControlCCKeySupportedGet,
 	EntryControlCCKeySupportedReport,
 	EntryControlCCNotification,
+	EntryControlCCValues,
 } from "./EntryControlCC";
 export {
 	FirmwareUpdateMetaDataCC,
@@ -152,6 +172,7 @@ export {
 	FirmwareUpdateMetaDataCCRequestGet,
 	FirmwareUpdateMetaDataCCRequestReport,
 	FirmwareUpdateMetaDataCCStatusReport,
+	FirmwareUpdateMetaDataCCValues,
 } from "./FirmwareUpdateMetaDataCC";
 export { HailCC } from "./HailCC";
 export {
@@ -161,11 +182,13 @@ export {
 	HumidityControlModeCCSet,
 	HumidityControlModeCCSupportedGet,
 	HumidityControlModeCCSupportedReport,
+	HumidityControlModeCCValues,
 } from "./HumidityControlModeCC";
 export {
 	HumidityControlOperatingStateCC,
 	HumidityControlOperatingStateCCGet,
 	HumidityControlOperatingStateCCReport,
+	HumidityControlOperatingStateCCValues,
 } from "./HumidityControlOperatingStateCC";
 export {
 	HumidityControlSetpointCC,
@@ -178,6 +201,7 @@ export {
 	HumidityControlSetpointCCSet,
 	HumidityControlSetpointCCSupportedGet,
 	HumidityControlSetpointCCSupportedReport,
+	HumidityControlSetpointCCValues,
 } from "./HumidityControlSetpointCC";
 export {
 	IndicatorCC,
@@ -186,6 +210,7 @@ export {
 	IndicatorCCSet,
 	IndicatorCCSupportedGet,
 	IndicatorCCSupportedReport,
+	IndicatorCCValues,
 } from "./IndicatorCC";
 export {
 	IrrigationCC,
@@ -197,6 +222,7 @@ export {
 	IrrigationCCSystemShutoff,
 	IrrigationCCSystemStatusGet,
 	IrrigationCCSystemStatusReport,
+	IrrigationCCValues,
 	IrrigationCCValveConfigGet,
 	IrrigationCCValveConfigReport,
 	IrrigationCCValveConfigSet,
@@ -217,8 +243,15 @@ export {
 	LanguageCCGet,
 	LanguageCCReport,
 	LanguageCCSet,
+	LanguageCCValues,
 } from "./LanguageCC";
-export { LockCC, LockCCGet, LockCCReport, LockCCSet } from "./LockCC";
+export {
+	LockCC,
+	LockCCGet,
+	LockCCReport,
+	LockCCSet,
+	LockCCValues,
+} from "./LockCC";
 export {
 	fibaroCC,
 	fibaroCCCommand,
@@ -242,17 +275,12 @@ export {
 } from "./manufacturerProprietary/FibaroCC";
 export { ManufacturerProprietaryCC } from "./ManufacturerProprietaryCC";
 export {
-	getManufacturerIdValueId,
-	getManufacturerIdValueMetadata,
-	getProductIdValueId,
-	getProductIdValueMetadata,
-	getProductTypeValueId,
-	getProductTypeValueMetadata,
 	ManufacturerSpecificCC,
 	ManufacturerSpecificCCDeviceSpecificGet,
 	ManufacturerSpecificCCDeviceSpecificReport,
 	ManufacturerSpecificCCGet,
 	ManufacturerSpecificCCReport,
+	ManufacturerSpecificCCValues,
 } from "./ManufacturerSpecificCC";
 export {
 	MeterCC,
@@ -261,6 +289,7 @@ export {
 	MeterCCReset,
 	MeterCCSupportedGet,
 	MeterCCSupportedReport,
+	MeterCCValues,
 } from "./MeterCC";
 export {
 	MultiChannelAssociationCC,
@@ -270,6 +299,7 @@ export {
 	MultiChannelAssociationCCSet,
 	MultiChannelAssociationCCSupportedGroupingsGet,
 	MultiChannelAssociationCCSupportedGroupingsReport,
+	MultiChannelAssociationCCValues,
 } from "./MultiChannelAssociationCC";
 export {
 	MultiChannelCC,
@@ -285,6 +315,7 @@ export {
 	MultiChannelCCV1CommandEncapsulation,
 	MultiChannelCCV1Get,
 	MultiChannelCCV1Report,
+	MultiChannelCCValues,
 } from "./MultiChannelCC";
 export {
 	MultiCommandCC,
@@ -298,6 +329,7 @@ export {
 	MultilevelSensorCCReport,
 	MultilevelSensorCCSupportedScaleReport,
 	MultilevelSensorCCSupportedSensorReport,
+	MultilevelSensorCCValues,
 } from "./MultilevelSensorCC";
 export type { MultilevelSensorCCReportOptions } from "./MultilevelSensorCC";
 export {
@@ -309,6 +341,7 @@ export {
 	MultilevelSwitchCCStopLevelChange,
 	MultilevelSwitchCCSupportedGet,
 	MultilevelSwitchCCSupportedReport,
+	MultilevelSwitchCCValues,
 } from "./MultilevelSwitchCC";
 export {
 	NodeNamingAndLocationCC,
@@ -318,6 +351,7 @@ export {
 	NodeNamingAndLocationCCNameGet,
 	NodeNamingAndLocationCCNameReport,
 	NodeNamingAndLocationCCNameSet,
+	NodeNamingAndLocationCCValues,
 } from "./NodeNamingCC";
 export { messageIsPing, NoOperationCC } from "./NoOperationCC";
 export {
@@ -329,6 +363,7 @@ export {
 	NotificationCCSet,
 	NotificationCCSupportedGet,
 	NotificationCCSupportedReport,
+	NotificationCCValues,
 } from "./NotificationCC";
 export {
 	PowerlevelCC,
@@ -352,19 +387,26 @@ export {
 	ProtectionCCTimeoutGet,
 	ProtectionCCTimeoutReport,
 	ProtectionCCTimeoutSet,
+	ProtectionCCValues,
 } from "./ProtectionCC";
-export { SceneActivationCC, SceneActivationCCSet } from "./SceneActivationCC";
+export {
+	SceneActivationCC,
+	SceneActivationCCSet,
+	SceneActivationCCValues,
+} from "./SceneActivationCC";
 export {
 	SceneActuatorConfigurationCC,
 	SceneActuatorConfigurationCCGet,
 	SceneActuatorConfigurationCCReport,
 	SceneActuatorConfigurationCCSet,
+	SceneActuatorConfigurationCCValues,
 } from "./SceneActuatorConfigurationCC";
 export {
 	SceneControllerConfigurationCC,
 	SceneControllerConfigurationCCGet,
 	SceneControllerConfigurationCCReport,
 	SceneControllerConfigurationCCSet,
+	SceneControllerConfigurationCCValues,
 } from "./SceneControllerConfigurationCC";
 export {
 	Security2CC,
@@ -409,6 +451,7 @@ export {
 	SoundSwitchCCTonePlaySet,
 	SoundSwitchCCTonesNumberGet,
 	SoundSwitchCCTonesNumberReport,
+	SoundSwitchCCValues,
 } from "./SoundSwitchCC";
 export {
 	SupervisionCC,
@@ -422,11 +465,13 @@ export {
 	ThermostatFanModeCCSet,
 	ThermostatFanModeCCSupportedGet,
 	ThermostatFanModeCCSupportedReport,
+	ThermostatFanModeCCValues,
 } from "./ThermostatFanModeCC";
 export {
 	ThermostatFanStateCC,
 	ThermostatFanStateCCGet,
 	ThermostatFanStateCCReport,
+	ThermostatFanStateCCValues,
 } from "./ThermostatFanStateCC";
 export {
 	ThermostatModeCC,
@@ -435,17 +480,20 @@ export {
 	ThermostatModeCCSet,
 	ThermostatModeCCSupportedGet,
 	ThermostatModeCCSupportedReport,
+	ThermostatModeCCValues,
 } from "./ThermostatModeCC";
 export {
 	ThermostatOperatingStateCC,
 	ThermostatOperatingStateCCGet,
 	ThermostatOperatingStateCCReport,
+	ThermostatOperatingStateCCValues,
 } from "./ThermostatOperatingStateCC";
 export {
 	ThermostatSetbackCC,
 	ThermostatSetbackCCGet,
 	ThermostatSetbackCCReport,
 	ThermostatSetbackCCSet,
+	ThermostatSetbackCCValues,
 } from "./ThermostatSetbackCC";
 export {
 	ThermostatSetpointCC,
@@ -456,6 +504,7 @@ export {
 	ThermostatSetpointCCSet,
 	ThermostatSetpointCCSupportedGet,
 	ThermostatSetpointCCSupportedReport,
+	ThermostatSetpointCCValues,
 } from "./ThermostatSetpointCC";
 export {
 	TimeCC,
@@ -472,6 +521,7 @@ export {
 	TimeParametersCCGet,
 	TimeParametersCCReport,
 	TimeParametersCCSet,
+	TimeParametersCCValues,
 } from "./TimeParametersCC";
 export {
 	isTransportServiceEncapsulation,
@@ -503,12 +553,9 @@ export {
 	UserCodeCCUserCodeChecksumReport,
 	UserCodeCCUsersNumberGet,
 	UserCodeCCUsersNumberReport,
+	UserCodeCCValues,
 } from "./UserCodeCC";
 export {
-	getFirmwareVersionsMetadata,
-	getFirmwareVersionsValueId,
-	getSDKVersionMetadata,
-	getSDKVersionValueId,
 	VersionCC,
 	VersionCCCapabilitiesGet,
 	VersionCCCapabilitiesReport,
@@ -516,11 +563,11 @@ export {
 	VersionCCCommandClassReport,
 	VersionCCGet,
 	VersionCCReport,
+	VersionCCValues,
 	VersionCCZWaveSoftwareGet,
 	VersionCCZWaveSoftwareReport,
 } from "./VersionCC";
 export {
-	getWakeUpIntervalValueId,
 	WakeUpCC,
 	WakeUpCCIntervalCapabilitiesGet,
 	WakeUpCCIntervalCapabilitiesReport,
@@ -528,9 +575,15 @@ export {
 	WakeUpCCIntervalReport,
 	WakeUpCCIntervalSet,
 	WakeUpCCNoMoreInformation,
+	WakeUpCCValues,
 	WakeUpCCWakeUpNotification,
 } from "./WakeUpCC";
-export { ZWavePlusCC, ZWavePlusCCGet, ZWavePlusCCReport } from "./ZWavePlusCC";
+export {
+	ZWavePlusCC,
+	ZWavePlusCCGet,
+	ZWavePlusCCReport,
+	ZWavePlusCCValues,
+} from "./ZWavePlusCC";
 export {
 	ZWaveProtocolCC,
 	ZWaveProtocolCCAcceptLost,
diff --git a/packages/cc/src/lib/CommandClass.ts b/packages/cc/src/lib/CommandClass.ts
index 151f5083e59..ab59082006f 100644
--- a/packages/cc/src/lib/CommandClass.ts
+++ b/packages/cc/src/lib/CommandClass.ts
@@ -29,13 +29,15 @@ import {
 	staticExtends,
 } from "@zwave-js/shared";
 import { isArray } from "alcalzone-shared/typeguards";
+import type { ValueIDProperties } from "./API";
 import {
 	getCCCommand,
 	getCCCommandConstructor,
 	getCCConstructor,
 	getCCResponsePredicate,
+	getCCValueProperties,
+	getCCValues,
 	getCommandClass,
-	getCommandClassStatic,
 	getExpectedCCResponse,
 	getImplementedVersion,
 } from "./CommandClassDecorators";
@@ -47,6 +49,12 @@ import {
 	ICommandClassContainer,
 	isCommandClassContainer,
 } from "./ICommandClassContainer";
+import {
+	CCValue,
+	defaultCCValueOptions,
+	DynamicCCValue,
+	StaticCCValue,
+} from "./Values";
 
 export type CommandClassDeserializationOptions = {
 	data: Buffer;
@@ -105,7 +113,7 @@ export class CommandClass implements ICommandClass {
 			("supervised" in options ? options.supervised : undefined) ?? false;
 
 		// We cannot use @ccValue for non-derived classes, so register interviewComplete as an internal value here
-		this.registerValue("interviewComplete", { internal: true });
+		// this.registerValue("interviewComplete", { internal: true });
 
 		if (gotDeserializationOptions(options)) {
 			// For deserialized commands, try to invoke the correct subclass constructor
@@ -559,23 +567,134 @@ export class CommandClass implements ICommandClass {
 		);
 	}
 
-	/** Which variables should be persisted when requested */
-	private _registeredCCValues = new Map<
-		string | number,
-		Pick<CCValueOptions, "internal" | "secret">
-	>();
 	/**
-	 * Creates a value that will be stored in the valueDB alongside with the ones marked with `@ccValue()`
-	 * @param property The property the value belongs to
-	 * @param internal Whether the value should be exposed to library users
+	 * Ensures that the metadata for the given CC value exists in the Value DB or creates it if it does not.
+	 * The endpoint index of the current CC instance is automatically taken into account.
+	 * @param meta Will be used in place of the predefined metadata when given
 	 */
-	public registerValue(
-		property: string | number,
-		options: Pick<CCValueOptions, "internal" | "secret"> = {},
+	protected ensureMetadata(
+		applHost: ZWaveApplicationHost,
+		ccValue: CCValue,
+		meta?: ValueMetadata,
+	): void {
+		const valueDB = this.getValueDB(applHost);
+		const valueId = ccValue.endpoint(this.endpointIndex);
+		if (!valueDB.hasMetadata(valueId)) {
+			valueDB.setMetadata(valueId, meta ?? ccValue.meta);
+		}
+	}
+
+	/**
+	 * Removes the metadata for the given CC value from the value DB.
+	 * The endpoint index of the current CC instance is automatically taken into account.
+	 */
+	protected removeMetadata(
+		applHost: ZWaveApplicationHost,
+		ccValue: CCValue,
+	): void {
+		const valueDB = this.getValueDB(applHost);
+		const valueId = ccValue.endpoint(this.endpointIndex);
+		valueDB.setMetadata(valueId, undefined);
+	}
+
+	/**
+	 * Writes the metadata for the given CC value into the Value DB.
+	 * The endpoint index of the current CC instance is automatically taken into account.
+	 * @param meta Will be used in place of the predefined metadata when given
+	 */
+	protected setMetadata(
+		applHost: ZWaveApplicationHost,
+		ccValue: CCValue,
+		meta?: ValueMetadata,
 	): void {
-		options.internal ??= false;
-		options.secret ??= false;
-		this._registeredCCValues.set(property, options);
+		const valueDB = this.getValueDB(applHost);
+		const valueId = ccValue.endpoint(this.endpointIndex);
+		valueDB.setMetadata(valueId, meta ?? ccValue.meta);
+	}
+
+	/**
+	 * Reads the metadata for the given CC value from the Value DB.
+	 * The endpoint index of the current CC instance is automatically taken into account.
+	 */
+	protected getMetadata<T extends ValueMetadata>(
+		applHost: ZWaveApplicationHost,
+		ccValue: CCValue,
+	): T | undefined {
+		const valueDB = this.getValueDB(applHost);
+		const valueId = ccValue.endpoint(this.endpointIndex);
+		return valueDB.getMetadata(valueId) as any;
+	}
+
+	/**
+	 * Stores the given value under the value ID for the given CC value in the value DB.
+	 * The endpoint index of the current CC instance is automatically taken into account.
+	 */
+	protected setValue(
+		applHost: ZWaveApplicationHost,
+		ccValue: CCValue,
+		value: unknown,
+	): void {
+		const valueDB = this.getValueDB(applHost);
+		const valueId = ccValue.endpoint(this.endpointIndex);
+		valueDB.setValue(valueId, value);
+	}
+
+	/**
+	 * Removes the value for the given CC value from the value DB.
+	 * The endpoint index of the current CC instance is automatically taken into account.
+	 */
+	protected removeValue(
+		applHost: ZWaveApplicationHost,
+		ccValue: CCValue,
+	): void {
+		const valueDB = this.getValueDB(applHost);
+		const valueId = ccValue.endpoint(this.endpointIndex);
+		valueDB.removeValue(valueId);
+	}
+
+	/**
+	 * Reads the value stored for the value ID of the given CC value from the value DB.
+	 * The endpoint index of the current CC instance is automatically taken into account.
+	 */
+	protected getValue<T>(
+		applHost: ZWaveApplicationHost,
+		ccValue: CCValue,
+	): T | undefined {
+		const valueDB = this.getValueDB(applHost);
+		const valueId = ccValue.endpoint(this.endpointIndex);
+		return valueDB.getValue(valueId);
+	}
+
+	/** Returns the CC value definition for the current CC which matches the given value ID */
+	protected getCCValue(
+		valueId: ValueID,
+	): StaticCCValue | DynamicCCValue | undefined {
+		const ccValues = getCCValues(this);
+		if (!ccValues) return;
+
+		for (const value of Object.values(ccValues)) {
+			if (value?.is(valueId)) {
+				return value;
+			}
+		}
+	}
+
+	private getAllCCValues(): (StaticCCValue | DynamicCCValue)[] {
+		return Object.values(getCCValues(this) ?? {}) as (
+			| StaticCCValue
+			| DynamicCCValue
+		)[];
+	}
+
+	private getCCValueForValueId(
+		properties: ValueIDProperties,
+	): StaticCCValue | DynamicCCValue | undefined {
+		return this.getAllCCValues().find((value) =>
+			value.is({
+				commandClass: this.ccId,
+				...properties,
+			}),
+		);
 	}
 
 	/** Returns a list of all value names that are defined for this CommandClass */
@@ -597,218 +716,129 @@ export class CommandClass implements ICommandClass {
 			if (!ret.has(dbKey)) ret.set(dbKey, valueId);
 		};
 
-		// Return all manually registered CC values that are not internal
-		const registeredCCValueNames = [...this._registeredCCValues]
-			.filter(([, isInternal]) => !isInternal)
-			.map(([key]) => key);
-		registeredCCValueNames.forEach((property) => addValueId(property));
-
-		// Return all defined non-internal CC values that are available in the current version of this CC
-		const valueDefinitions = getCCValueDefinitions(this);
-		const definedCCValueNames = [...valueDefinitions]
-			.filter(
-				([, options]) =>
-					options.internal !== true &&
-					(options.minVersion == undefined ||
-						options.minVersion <= this.version),
-			)
-			.map(([key]) => key);
-		definedCCValueNames.forEach((property) => addValueId(property));
-
-		const kvpDefinitions = getCCKeyValuePairDefinitions(this);
-
-		// Also return all existing value ids that are not internal (values AND metadata without values!)
+		// Return all value IDs for this CC...
 		const valueDB = this.getValueDB(applHost);
-		const existingValueIds = [
+		// ...which either have metadata or a value
+		const existingValueIds: ValueID[] = [
 			...valueDB.getValues(this.ccId),
 			...valueDB.getAllMetadata(this.ccId),
-		]
-			.filter((valueId) => valueId.endpoint === this.endpointIndex)
-			// allow the value id if it is NOT registered or it is registered as non-internal
-			.filter(
-				(valueId) =>
-					this._registeredCCValues.get(valueId.property)?.internal !==
-					true,
-			)
-			// allow the value ID if it is NOT defined or it is defined as non-internal
-			.filter(
-				(valueId) =>
-					valueDefinitions.get(valueId.property)?.internal !== true,
-			)
-			.filter(
-				(valueId) =>
-					kvpDefinitions.get(valueId.property)?.internal !== true,
-			);
-		existingValueIds.forEach(({ property, propertyKey }) =>
-			addValueId(property, propertyKey),
-		);
+		];
+
+		// ...or which are statically defined using @ccValues(...)
+		for (const value of Object.values(getCCValues(this) ?? {})) {
+			// Skip dynamic CC values - they need a specific subclass instance to be evaluated
+			if (!value || typeof value === "function") continue;
+
+			// Skip those values that are only supported in higher versions of the CC
+			if (
+				value.options.minVersion != undefined &&
+				value.options.minVersion > this.version
+			) {
+				continue;
+			}
+
+			// Skip internal values
+			if (value.options.internal) continue;
+
+			// And determine if this value should be automatically "created"
+			if (
+				value.options.autoCreate === false ||
+				(typeof value.options.autoCreate === "function" &&
+					!value.options.autoCreate(
+						applHost,
+						this.getEndpoint(applHost)!,
+					))
+			) {
+				continue;
+			}
+
+			existingValueIds.push(value.endpoint(this.endpointIndex));
+		}
+
+		// TODO: this is a bit awkward for the statically defined ones
+		const ccValues = this.getAllCCValues();
+		for (const valueId of existingValueIds) {
+			// ...belonging to the current endpoint
+			if ((valueId.endpoint ?? 0) !== this.endpointIndex) continue;
+
+			// Hard-coded: interviewComplete is always internal
+			if (valueId.property === "interviewComplete") continue;
+
+			// ... which don't have a CC value definition
+			// ... or one that does not mark the value ID as internal
+			const ccValue = ccValues.find((value) => value.is(valueId));
+			if (!ccValue || !ccValue.options.internal) {
+				addValueId(valueId.property, valueId.propertyKey);
+			}
+		}
 
 		return [...ret.values()];
 	}
 
 	/** Determines if the given value is an internal value */
-	public isInternalValue(property: keyof this): boolean {
-		// A value is internal if any of the possible definitions say so (true)
-		if (this._registeredCCValues.get(property as string)?.internal) {
-			return true;
-		}
-		const ccValueDefinition = getCCValueDefinitions(this).get(
-			property as string,
-		);
-		if (ccValueDefinition?.internal === true) return true;
-		const ccKeyValuePairDefinition = getCCKeyValuePairDefinitions(this).get(
-			property as string,
-		);
-		if (ccKeyValuePairDefinition?.internal === true) return true;
-		return false;
-	}
+	public isInternalValue(properties: ValueIDProperties): boolean {
+		// Hard-coded: interviewComplete is always internal
+		if (properties.property === "interviewComplete") return true;
 
-	/** Determines if the given value is an secret value */
-	public isSecretValue(property: keyof this): boolean {
-		// A value is secret if any of the possible definitions say so (true)
-		if (this._registeredCCValues.get(property as string)?.secret) {
-			return true;
-		}
-		const ccValueDefinition = getCCValueDefinitions(this).get(
-			property as string,
-		);
-		if (ccValueDefinition?.secret === true) return true;
-		const ccKeyValuePairDefinition = getCCKeyValuePairDefinitions(this).get(
-			property as string,
-		);
-		if (ccKeyValuePairDefinition?.secret === true) return true;
-		return false;
+		const ccValue = this.getCCValueForValueId(properties);
+		return ccValue?.options.internal ?? defaultCCValueOptions.internal;
 	}
 
-	/** Determines if the given value should always be persisted */
-	public shouldValueAlwaysBeCreated(property: keyof this): boolean {
-		const ccValueDefinition = getCCValueDefinitions(this).get(
-			property as string,
-		);
-		if (ccValueDefinition?.forceCreation === true) return true;
-		const ccKeyValuePairDefinition = getCCKeyValuePairDefinitions(this).get(
-			property as string,
-		);
-		if (ccKeyValuePairDefinition?.forceCreation === true) return true;
-		return false;
+	/** Determines if the given value is an secret value */
+	public isSecretValue(properties: ValueIDProperties): boolean {
+		const ccValue = this.getCCValueForValueId(properties);
+		return ccValue?.options.secret ?? defaultCCValueOptions.secret;
 	}
 
 	/** Determines if the given value should be persisted or represents an event */
-	public isStatefulValue(property: keyof this): boolean {
-		const ccValueDefinition = getCCValueDefinitions(this).get(
-			property as string,
-		);
-		if (ccValueDefinition?.stateful === false) return false;
-		const ccKeyValuePairDefinition = getCCKeyValuePairDefinitions(this).get(
-			property as string,
-		);
-		if (ccKeyValuePairDefinition?.stateful === false) return false;
-		return true;
+	public isStatefulValue(properties: ValueIDProperties): boolean {
+		const ccValue = this.getCCValueForValueId(properties);
+		return ccValue?.options.stateful ?? defaultCCValueOptions.stateful;
 	}
 
-	/** Persists all values on the given node into the value. Returns true if the process succeeded, false otherwise */
-	public persistValues(
-		applHost: ZWaveApplicationHost,
-		valueNames?: (keyof this)[],
-	): boolean {
-		// In order to avoid cluttering applications with heaps of unsupported properties,
-		// we filter out those that are only available in future versions of this CC
-		// or have no version constraint
-		const keyValuePairDefinitions = getCCKeyValuePairDefinitions(this);
-		const keyValuePairs = [...keyValuePairDefinitions].filter(
-			([, options]) =>
-				options.minVersion == undefined ||
-				options.minVersion <= this.version,
-		);
-		const ccValueDefinitions = [...getCCValueDefinitions(this)].filter(
-			([, options]) =>
-				options.minVersion == undefined ||
-				options.minVersion <= this.version,
-		);
-		// If not specified otherwise, persist all registered values in the value db
-		// But filter out those that don't match the minimum version
-		if (!valueNames) {
-			valueNames = [
-				...this._registeredCCValues.keys(),
-				...ccValueDefinitions.map(([key]) => key),
-				...keyValuePairs.map(([key]) => key),
-			] as unknown as (keyof this)[];
-		}
-		let db: ValueDB;
+	/**
+	 * Persists all values for this CC instance into the value DB which are annotated with @ccValue.
+	 * Returns `true` if the process succeeded, `false` if the value DB cannot be accessed.
+	 */
+	public persistValues(applHost: ZWaveApplicationHost): boolean {
+		let valueDB: ValueDB;
 		try {
-			db = this.getValueDB(applHost);
+			valueDB = this.getValueDB(applHost);
 		} catch {
 			return false;
 		}
 
-		const cc = getCommandClass(this);
-		for (const variable of valueNames as string[]) {
-			// interviewComplete automatically updates the value DB, so no need to persist again
-			if (variable === "interviewComplete") continue;
-			// Only persist non-undefined values and things that are not functions
-			const sourceValue = this[variable as keyof this];
-			if (typeof sourceValue === "function") continue;
+		// Get all properties of this CC which are annotated with a @ccValue decorator and store them.
+		for (const [prop, _value] of getCCValueProperties(this)) {
+			// Evaluate dynamic CC values first
+			const value = typeof _value === "function" ? _value(this) : _value;
+
+			// Skip those values that are only supported in higher versions of the CC
 			if (
-				sourceValue == undefined &&
-				!this.shouldValueAlwaysBeCreated(variable as keyof this)
+				value.options.minVersion != undefined &&
+				value.options.minVersion > this.version
 			) {
 				continue;
 			}
 
-			if (keyValuePairDefinitions.has(variable)) {
-				// This value is one or more key value pair(s) to be stored in a map
-				if (sourceValue instanceof Map) {
-					// Just copy the entries
-					for (const [propertyKey, value] of (
-						sourceValue as Map<string | number, unknown>
-					).entries()) {
-						db.setValue(
-							{
-								commandClass: cc,
-								endpoint: this.endpointIndex,
-								property: variable,
-								propertyKey,
-							},
-							value,
-						);
-					}
-				} else if (isArray(sourceValue)) {
-					const [propertyKey, value] = sourceValue as any as [
-						string | number,
-						unknown,
-					];
-					db.setValue(
-						{
-							commandClass: cc,
-							endpoint: this.endpointIndex,
-							property: variable,
-							propertyKey,
-						},
-						value,
-					);
-				} else {
-					throw new ZWaveError(
-						`ccKeyValuePairs can only be Maps or [key, value]-tuples`,
-						ZWaveErrorCodes.Argument_Invalid,
-					);
-				}
-			} else {
-				// This value belongs to a simple property
-				const valueId: ValueID = {
-					commandClass: cc,
-					endpoint: this.endpointIndex,
-					property: variable,
-				};
-				// Avoid overwriting existing values with undefined if forceCreation is true
-				if (sourceValue != undefined || !db.hasValue(valueId)) {
-					// Tell the value DB if this is a stateful value
-					const stateful = this.isStatefulValue(
-						variable as keyof this,
-					);
-					db.setValue(valueId, sourceValue, { stateful });
+			const valueId: ValueID = value.endpoint(this.endpointIndex);
+
+			// Metadata always gets created for non-internal values, regardless of the actual value being defined
+			if (!value.options.internal) {
+				if (!valueDB.hasMetadata(valueId)) {
+					valueDB.setMetadata(valueId, value.meta);
 				}
 			}
+
+			// The value only gets written if it is not undefined
+			const sourceValue = this[prop as keyof this];
+			if (sourceValue == undefined) continue;
+
+			valueDB.setValue(valueId, sourceValue, {
+				stateful: value.options.stateful,
+			});
 		}
+
 		return true;
 	}
 
@@ -1056,13 +1086,6 @@ export function assertValidCCs(container: ICommandClassContainer): void {
 	}
 }
 
-// =======================
-// use decorators to link command class values to actual command classes
-
-const METADATA_ccValues = Symbol("ccValues");
-const METADATA_ccKeyValuePairs = Symbol("ccKeyValuePairs");
-const METADATA_ccValueMeta = Symbol("ccValueMeta");
-
 export type CCConstructor<T extends CommandClass> = typeof CommandClass & {
 	// I don't like the any, but we need it to support half-implemented CCs (e.g. report classes)
 	new (host: ZWaveHost, options: any): T;
@@ -1092,158 +1115,3 @@ export type CCResponsePredicate<
 	TSent extends CommandClass,
 	TReceived extends CommandClass = CommandClass,
 > = (sentCommand: TSent, receivedCommand: TReceived) => CCResponseRole;
-
-/** @publicAPI */
-export interface CCValueOptions {
-	/**
-	 * Whether the decorated CC value is internal. Internal values are not exposed to the user.
-	 */
-	internal?: boolean;
-	/**
-	 * The minimum CC version required for this value to exist.
-	 */
-	minVersion?: number;
-	/**
-	 * Whether this value should always be created/persisted, even if it is undefined. Default: false
-	 */
-	forceCreation?: boolean;
-	/**
-	 * Whether this value represents a state (`true`) or a notification/event (`false`). Default: `true`
-	 */
-	stateful?: boolean;
-	/**
-	 * Omit this value from value logs. Default: `false`
-	 */
-	secret?: boolean;
-}
-
-/**
- * @publicAPI
- * Marks the decorated property as a value of the Command Class. This allows saving it on the node with persistValues()
- * @param internal Whether the value should be exposed to library users
- */
-export function ccValue(options?: CCValueOptions): PropertyDecorator {
-	return (target: unknown, property: string | number | symbol) => {
-		if (!target || !(target instanceof CommandClass)) return;
-		// Set default arguments
-		if (!options) options = {};
-		if (options.internal == undefined) options.internal = false;
-		if (options.minVersion == undefined) options.minVersion = 1;
-		if (options.forceCreation == undefined) options.forceCreation = false;
-		// get the class constructor
-		const constr = target.constructor as typeof CommandClass;
-		const cc = getCommandClassStatic(constr);
-		// retrieve the current metadata
-		const metadata =
-			Reflect.getMetadata(METADATA_ccValues, CommandClass) ?? {};
-		if (!(cc in metadata)) metadata[cc] = new Map();
-		// And add the variable
-		const variables: Map<string | number, CCValueOptions> = metadata[cc];
-		variables.set(property as string | number, options);
-		// store back to the object
-		Reflect.defineMetadata(METADATA_ccValues, metadata, CommandClass);
-	};
-}
-
-/**
- * Returns all CC values and their definitions that have been defined with @ccValue()
- */
-function getCCValueDefinitions(
-	commandClass: CommandClass,
-): ReadonlyMap<string | number, CCValueOptions> {
-	// get the class constructor
-	const constr = commandClass.constructor as typeof CommandClass;
-	const cc = getCommandClassStatic(constr);
-	// retrieve the current metadata
-	const metadata = Reflect.getMetadata(METADATA_ccValues, CommandClass) ?? {};
-	if (!(cc in metadata)) return new Map();
-	return metadata[cc] as Map<string | number, CCValueOptions>;
-}
-
-/**
- * @publicAPI
- * Marks the decorated property as the key of a Command Class's key value pair,
- * which can later be saved with persistValues()
- * @param internal Whether the key value pair should be exposed to library users
- */
-export function ccKeyValuePair(options?: CCValueOptions): PropertyDecorator {
-	return (target: unknown, property: string | number | symbol) => {
-		if (!target || !(target instanceof CommandClass)) return;
-		// Set default arguments
-		if (!options) options = {};
-		if (options.internal == undefined) options.internal = false;
-		if (options.minVersion == undefined) options.minVersion = 1;
-		if (options.forceCreation == undefined) options.forceCreation = false;
-		// get the class constructor
-		const constr = target.constructor as typeof CommandClass;
-		const cc = getCommandClassStatic(constr);
-		// retrieve the current metadata
-		const metadata =
-			Reflect.getMetadata(METADATA_ccKeyValuePairs, CommandClass) || {};
-		if (!(cc in metadata)) metadata[cc] = new Map();
-		// And add the variable
-		const variables: Map<string | number, CCValueOptions> = metadata[cc];
-		variables.set(property as string | number, options);
-		// store back to the object
-		Reflect.defineMetadata(
-			METADATA_ccKeyValuePairs,
-			metadata,
-			CommandClass,
-		);
-	};
-}
-
-/**
- * Returns all CC key value pairs and their definitions that have been defined with @ccKeyValuePair()
- */
-function getCCKeyValuePairDefinitions(
-	commandClass: CommandClass,
-): ReadonlyMap<string | number, CCValueOptions> {
-	// get the class constructor
-	const constr = commandClass.constructor as typeof CommandClass;
-	const cc = getCommandClassStatic(constr);
-	// retrieve the current metadata
-	const metadata =
-		Reflect.getMetadata(METADATA_ccKeyValuePairs, CommandClass) || {};
-	if (!(cc in metadata)) return new Map();
-	return metadata[cc] as Map<string | number, CCValueOptions>;
-}
-
-/**
- * @publicAPI
- * Defines additional metadata for the given CC value
- */
-export function ccValueMetadata(meta: ValueMetadata): PropertyDecorator {
-	return (target: unknown, property: string | number | symbol) => {
-		if (!target || !(target instanceof CommandClass)) return;
-		// get the class constructor
-		const constr = target.constructor as typeof CommandClass;
-		const cc = getCommandClassStatic(constr);
-		// retrieve the current metadata
-		const metadata =
-			Reflect.getMetadata(METADATA_ccValueMeta, CommandClass) || {};
-		if (!(cc in metadata)) metadata[cc] = new Map();
-		// And add the variable
-		const variables: Map<string | number, ValueMetadata> = metadata[cc];
-		variables.set(property as string | number, meta);
-		// store back to the object
-		Reflect.defineMetadata(METADATA_ccValueMeta, metadata, CommandClass);
-	};
-}
-
-/**
- * @publicAPI
- * Retrieves defined metadata for the given CC value. If none is found, the default settings are returned.
- */
-export function getCCValueMetadata(
-	cc: CommandClasses,
-	property: string | number,
-): ValueMetadata {
-	// retrieve the current metadata
-	const metadata =
-		Reflect.getMetadata(METADATA_ccValueMeta, CommandClass) || {};
-	if (!(cc in metadata)) return ValueMetadata.Any;
-	const map = metadata[cc] as Map<string | number, ValueMetadata>;
-	if (map.has(property)) return map.get(property)!;
-	return ValueMetadata.Any;
-}
diff --git a/packages/cc/src/lib/CommandClassDecorators.ts b/packages/cc/src/lib/CommandClassDecorators.ts
index aaa9c1767fb..b9751ed6e85 100644
--- a/packages/cc/src/lib/CommandClassDecorators.ts
+++ b/packages/cc/src/lib/CommandClassDecorators.ts
@@ -5,7 +5,10 @@ import {
 	ZWaveErrorCodes,
 	type CommandClasses,
 } from "@zwave-js/core";
-import type { TypedClassDecorator } from "@zwave-js/shared";
+import type {
+	TypedClassDecorator,
+	TypedPropertyDecorator,
+} from "@zwave-js/shared";
 import type { APIConstructor, CCAPI } from "./API";
 import type {
 	CCConstructor,
@@ -13,6 +16,11 @@ import type {
 	CommandClass,
 	DynamicCCResponse,
 } from "./CommandClass";
+import type {
+	DynamicCCValue,
+	StaticCCValue,
+	StaticCCValueFactory,
+} from "./Values";
 
 const CCAndCommandDecorator = createReflectionDecoratorPair<
 	CommandClass,
@@ -214,3 +222,131 @@ export function getCCResponsePredicate<T extends CommandClass>(
 ): CCResponsePredicate<T> | undefined {
 	return expectedCCResponseDecorator.lookupValue(ccClass)?.predicate;
 }
+
+const ccValuesDecorator = createReflectionDecorator<
+	CommandClass,
+	[valueDefinition: Record<string, StaticCCValue | DynamicCCValue>],
+	Record<string, StaticCCValue | DynamicCCValue | undefined>
+>({
+	name: "ccValues",
+	valueFromArgs: (valueDefinition) => valueDefinition,
+	// We don't need reverse lookup
+	constructorLookupKey: false,
+});
+
+/**
+ * @publicAPI
+ * Defines which CC value definitions belong to a Z-Wave command class
+ */
+export const ccValues = ccValuesDecorator.decorator;
+
+/**
+ * @publicAPI
+ * Retrieves the CC value definitions which belong to a Z-Wave command class
+ */
+export function getCCValues<T extends CommandClass>(
+	cc: T | CommandClasses,
+): Record<string, StaticCCValue | DynamicCCValue | undefined> | undefined {
+	// get the class constructor
+	let constr: CCConstructor<CommandClass> | undefined;
+	if (typeof cc === "number") {
+		constr = getCCConstructor(cc);
+	} else {
+		constr = cc.constructor as CCConstructor<CommandClass>;
+	}
+
+	if (constr) return ccValuesDecorator.lookupValueStatic(constr);
+}
+
+const ccValue_METADATA = Symbol.for(`METADATA_ccValue`);
+
+/**
+ * @publicAPI
+ * Defines which CC value a Z-Wave command class property belongs to
+ */
+export function ccValue<TTarget extends CommandClass>(
+	value: StaticCCValue,
+): TypedPropertyDecorator<TTarget>;
+
+export function ccValue<TTarget extends CommandClass, TArgs extends any[]>(
+	value: DynamicCCValue<TArgs>,
+	getArgs: (self: TTarget) => Readonly<TArgs>,
+): TypedPropertyDecorator<TTarget>;
+
+// Ideally this should use the PropertyReflectionDecorator, but we cannot reuse the
+// target type in the getArgs function then.
+export function ccValue<TTarget extends CommandClass, TArgs extends any[]>(
+	...args:
+		| [value: StaticCCValue]
+		| [value: DynamicCCValue<TArgs>, getArgs: (self: TTarget) => TArgs]
+): TypedPropertyDecorator<TTarget> {
+	// Normalize the arguments to the expected format
+	let valueOrFactory: StaticCCValue | StaticCCValueFactory<TTarget>;
+	if (args.length === 1) {
+		valueOrFactory = args[0];
+	} else {
+		const [value, getArgs] = args;
+		valueOrFactory = (self: TTarget) => {
+			const args = getArgs(self);
+			const base = value(...args);
+			return {
+				...base,
+				is: value.is,
+				options: value.options,
+			};
+		};
+	}
+
+	return function decoratorBody_ccValue(
+		target: TTarget,
+		property: string | number | symbol,
+	): void {
+		// get the class constructor
+		const constr = target.constructor;
+
+		// retrieve the current metadata
+		const metadata: Map<
+			string | number,
+			StaticCCValue | StaticCCValueFactory<TTarget>
+		> = Reflect.getMetadata(ccValue_METADATA, constr) ?? new Map();
+
+		// Add the variable
+		metadata.set(property as string | number, valueOrFactory);
+
+		// And store it back
+		Reflect.defineMetadata(ccValue_METADATA, metadata, constr);
+	};
+}
+
+/**
+ * @publicAPI
+ * Retrieves the defined mapping between properties and CC values of a Z-Wave command class instance
+ */
+export function getCCValueProperties<TTarget extends CommandClass>(
+	target: TTarget,
+): ReadonlyMap<string | number, StaticCCValue | StaticCCValueFactory<TTarget>> {
+	return (
+		Reflect.getMetadata(ccValue_METADATA, target.constructor) ?? new Map()
+	);
+}
+
+// const ccValueDecorator = createPropertyReflectionDecorator<
+// 	CommandClass,
+// 	[value: StaticCCValue | StaticCCValueFactory<CommandClass>],
+// 	StaticCCValue | StaticCCValueFactory<CommandClass>
+// >({
+// 	name: "ccValue",
+// 	valueFromArgs: (valueDefinition) => valueDefinition,
+// });
+
+// /**
+//  * @publicAPI
+//  * Defines which CC value a Z-Wave command class property belongs to
+//  */
+// export const ccValue = ccValueDecorator.decorator;
+
+// /**
+//  * @publicAPI
+//  * Retrieves the defined mapping between properties and CC values of a Z-Wave command class instance
+//  */
+// export const getCCValueDefinitions = ccValueDecorator.lookupValues;
diff --git a/packages/cc/src/lib/Values.test.ts b/packages/cc/src/lib/Values.test.ts
new file mode 100644
index 00000000000..745a34b5da3
--- /dev/null
+++ b/packages/cc/src/lib/Values.test.ts
@@ -0,0 +1,207 @@
+import { CommandClasses, ValueMetadata } from "@zwave-js/core";
+import { getEnumMemberName } from "@zwave-js/shared";
+import { V } from "./Values";
+import { AlarmSensorType } from "./_Types";
+
+describe("Value ID definitions", () => {
+	it("defineDynamicCCValues, dynamic property and meta", () => {
+		const dfn = V.defineDynamicCCValues(CommandClasses.Basic, {
+			...V.dynamicPropertyAndKeyWithName(
+				"prop1",
+				(valueType: string) => valueType,
+				(valueType: string) => valueType,
+				({ property, propertyKey }: any) =>
+					typeof property === "string" && property === propertyKey,
+				(valueType: string) =>
+					({
+						...ValueMetadata.Any,
+						readable: valueType === "readable",
+					} as const),
+				{ internal: true },
+			),
+			...V.dynamicPropertyAndKeyWithName(
+				"prop2",
+				(valueType: string) => valueType + "2",
+				(valueType: string) => valueType + "2",
+				({ property, propertyKey }: any) =>
+					typeof property === "string" &&
+					property.endsWith("2") &&
+					property === propertyKey,
+				(valueType: string) => ({
+					...ValueMetadata.Any,
+					writeable: valueType !== "not-writeable",
+				}),
+				{ secret: true },
+			),
+		});
+
+		const actual1a = dfn.prop1("bar");
+		expect(actual1a.id).toEqual({
+			commandClass: CommandClasses.Basic,
+			property: "bar",
+			propertyKey: "bar",
+		});
+		expect(actual1a.meta).toMatchObject({
+			readable: false,
+		});
+		const actual1b = dfn.prop1("readable");
+		expect(actual1b.id).toEqual({
+			commandClass: CommandClasses.Basic,
+			property: "readable",
+			propertyKey: "readable",
+		});
+		expect(actual1b.meta).toMatchObject({
+			readable: true,
+		});
+		expect(dfn.prop1.options).toMatchObject({
+			internal: true,
+			secret: false,
+		});
+
+		const actual2a = dfn.prop2("bar");
+		expect(actual2a.id).toEqual({
+			commandClass: CommandClasses.Basic,
+			property: "bar2",
+			propertyKey: "bar2",
+		});
+		expect(actual2a.meta).toMatchObject({
+			writeable: true,
+		});
+		const actual2b = dfn.prop2("not-writeable");
+		expect(actual2b.id).toEqual({
+			commandClass: CommandClasses.Basic,
+			property: "not-writeable2",
+			propertyKey: "not-writeable2",
+		});
+		expect(actual2b.meta).toMatchObject({
+			writeable: false,
+		});
+		expect(dfn.prop2.options).toMatchObject({
+			internal: false,
+			secret: true,
+		});
+
+		expect(
+			dfn.prop1.is({
+				commandClass: CommandClasses.Basic,
+				property: "the same",
+				propertyKey: "the same",
+			}),
+		).toBeTrue();
+
+		expect(
+			dfn.prop1.is({
+				commandClass: CommandClasses.Basic,
+				property: "the same",
+				propertyKey: "not the same",
+			}),
+		).toBeFalse();
+	});
+
+	// This is a copy of the Basic CC value definitions, for resiliency
+	const BasicCCValues = Object.freeze({
+		...V.defineStaticCCValues(CommandClasses.Basic, {
+			...V.staticProperty("currentValue"),
+			...V.staticProperty("targetValue"),
+			// TODO: This should really not be a static CC value:
+			...V.staticPropertyWithName("compatEvent", "event"),
+		}),
+	});
+
+	it("Basic CC, current value, no endpoint", () => {
+		const actual = BasicCCValues.currentValue.id;
+		expect(actual).toEqual({
+			commandClass: CommandClasses.Basic,
+			property: "currentValue",
+		});
+	});
+
+	it("Basic CC, current value, endpoint 2", () => {
+		const actual = BasicCCValues.currentValue.endpoint(2);
+		expect(actual).toEqual({
+			commandClass: CommandClasses.Basic,
+			endpoint: 2,
+			property: "currentValue",
+		});
+	});
+
+	it("Basic CC, compat event, endpoint 2", () => {
+		const actual = BasicCCValues.compatEvent.endpoint(2);
+		expect(actual).toEqual({
+			commandClass: CommandClasses.Basic,
+			endpoint: 2,
+			property: "event",
+		});
+	});
+
+	const AlarmSensorCCValues = Object.freeze({
+		...V.defineDynamicCCValues(CommandClasses["Alarm Sensor"], {
+			...V.dynamicPropertyAndKeyWithName(
+				"state",
+				"state",
+				(sensorType: number) => sensorType,
+				({ property, propertyKey }) =>
+					property === "state" && typeof propertyKey === "number",
+				(sensorType: AlarmSensorType) => {
+					const alarmName = getEnumMemberName(
+						AlarmSensorType,
+						sensorType,
+					);
+					return {
+						...ValueMetadata.ReadOnlyBoolean,
+						label: `${alarmName} state`,
+						description: "Whether the alarm is active",
+						ccSpecific: { sensorType },
+					} as const;
+				},
+			),
+			...V.dynamicPropertyWithName(
+				"type",
+				(sensorType: number) => sensorType,
+				({ property, propertyKey }) =>
+					typeof property === "number" && propertyKey == undefined,
+			),
+			// TODO: others
+		}),
+	});
+
+	it("(fake) Alarm Sensor CC, state (type 1), no endpoint", () => {
+		const actual = AlarmSensorCCValues.state(1).id;
+		expect(actual).toEqual({
+			commandClass: CommandClasses["Alarm Sensor"],
+			property: "state",
+			propertyKey: 1,
+		});
+	});
+
+	it("(fake) Alarm Sensor CC, state (type 1), endpoint 5", () => {
+		const actual = AlarmSensorCCValues.state(1).endpoint(5);
+		expect(actual).toEqual({
+			commandClass: CommandClasses["Alarm Sensor"],
+			endpoint: 5,
+			property: "state",
+			propertyKey: 1,
+		});
+	});
+
+	it("(fake) Alarm Sensor CC, type (4), endpoint 5", () => {
+		const actual = AlarmSensorCCValues.type(4).endpoint(5);
+		expect(actual).toEqual({
+			commandClass: CommandClasses["Alarm Sensor"],
+			endpoint: 5,
+			property: 4,
+		});
+	});
+
+	it("(fake) Alarm Sensor CC, dynamic metadata", () => {
+		const actual = AlarmSensorCCValues.state(1).meta;
+		expect(actual).toEqual({
+			type: "boolean",
+			readable: true,
+			writeable: false,
+			label: "Smoke state",
+			description: "Whether the alarm is active",
+			ccSpecific: { sensorType: 1 },
+		});
+	});
+});
diff --git a/packages/cc/src/lib/Values.ts b/packages/cc/src/lib/Values.ts
new file mode 100644
index 00000000000..b2516f64fed
--- /dev/null
+++ b/packages/cc/src/lib/Values.ts
@@ -0,0 +1,624 @@
+import {
+	CommandClasses,
+	IZWaveEndpoint,
+	ValueID,
+	ValueMetadata,
+} from "@zwave-js/core";
+import type { ZWaveApplicationHost } from "@zwave-js/host";
+import type { Overwrite } from "alcalzone-shared/types";
+import type { ValueIDProperties } from "./API";
+
+// HINT: To fully view types for definitions created by this, open
+// node_modules/typescript/lib/tsserver.js and change the definition of
+// ts.defaultMaximumTruncationLength = 160
+// to something higher like
+// ts.defaultMaximumTruncationLength = 1000
+// Then restart TS Server
+
+export interface CCValueOptions {
+	/**
+	 * Whether the CC value is internal. Internal values are not exposed to the user.
+	 */
+	internal?: boolean;
+	/**
+	 * The minimum CC version required for this value to exist.
+	 */
+	minVersion?: number;
+	/**
+	 * Whether this value represents a state (`true`) or a notification/event (`false`). Default: `true`
+	 */
+	stateful?: boolean;
+	/**
+	 * Omit this value from value logs. Default: `false`
+	 */
+	secret?: boolean;
+
+	/** Whether the CC value may exist on endpoints. Default: `true` */
+	supportsEndpoints?: boolean;
+
+	/**
+	 * Can be used to dynamically decide if this value should be created automatically.
+	 * This is ignored for dynamic values and defaults to `true` if not given.
+	 */
+	autoCreate?:
+		| boolean
+		| ((
+				applHost: ZWaveApplicationHost,
+				endpoint: IZWaveEndpoint,
+		  ) => boolean);
+}
+
+export const defaultCCValueOptions = {
+	internal: false,
+	minVersion: 1,
+	secret: false,
+	stateful: true,
+	supportsEndpoints: true,
+	autoCreate: true,
+} as const;
+
+type DefaultOptions = typeof defaultCCValueOptions;
+
+// expands object types recursively
+export type ExpandRecursively<T> =
+	// Split functions with properties into the function and object parts
+	T extends (...args: infer A) => infer R
+		? [keyof T] extends [never]
+			? (...args: A) => ExpandRecursively<R>
+			: ((...args: A) => ExpandRecursively<R>) & {
+					[P in keyof T]: ExpandRecursively<T[P]>;
+			  }
+		: // Expand object types
+		T extends object
+		? T extends infer O
+			? { [K in keyof O]: ExpandRecursively<O[K]> }
+			: never
+		: // Fallback to the type itself if no match
+		  T;
+
+export type ExpandRecursivelySkipMeta<T> =
+	// Split functions with properties into the function and object parts
+	T extends (...args: infer A) => infer R
+		? [keyof T] extends [never]
+			? (...args: A) => ExpandRecursivelySkipMeta<R>
+			: ((...args: A) => ExpandRecursivelySkipMeta<R>) & {
+					[P in keyof T]: ExpandRecursivelySkipMeta<T[P]>;
+			  }
+		: // Ignore the ValueMetadata type
+		T extends ValueMetadata
+		? T
+		: // Expand object types
+		T extends object
+		? T extends infer O
+			? { [K in keyof O]: ExpandRecursivelySkipMeta<O[K]> }
+			: never
+		: // Fallback to the type itself if no match
+		  T;
+
+type InferValueIDBase<
+	TCommandClass extends CommandClasses,
+	TBlueprint extends CCValueBlueprint,
+	TWorker = {
+		commandClass: TCommandClass;
+	} & Pick<TBlueprint, "property" | "propertyKey">,
+> = {
+	[K in keyof TWorker as unknown extends TWorker[K] ? never : K]: TWorker[K];
+};
+
+type ToStaticCCValues<
+	TCommandClass extends CommandClasses,
+	TValues extends Record<keyof TValues, CCValueBlueprint>,
+> = Readonly<{
+	[K in keyof TValues]: ExpandRecursively<
+		InferStaticCCValue<TCommandClass, TValues[K]>
+	>;
+}>;
+
+type ToDynamicCCValues<
+	TCommandClass extends CommandClasses,
+	TValues extends Record<keyof TValues, DynamicCCValueBlueprint<any>>,
+> = Readonly<{
+	[K in keyof TValues]: ExpandRecursively<
+		InferDynamicCCValue<TCommandClass, TValues[K]>
+	>;
+}>;
+
+type FnOrStatic<TArgs extends any[], TReturn> =
+	| ((...args: TArgs) => TReturn)
+	| TReturn;
+
+type ReturnTypeOrStatic<T> = T extends (...args: any[]) => infer R ? R : T;
+
+type InferArgs<T extends FnOrStatic<any, any>[]> = T extends [
+	(...args: infer A) => any,
+	...any,
+]
+	? A
+	: T extends [any, ...infer R]
+	? InferArgs<R>
+	: [];
+
+function evalOrStatic<T>(fnOrConst: T, ...args: any[]): ReturnTypeOrStatic<T> {
+	return typeof fnOrConst === "function" ? fnOrConst(...args) : fnOrConst;
+}
+
+/** Defines a single static CC values that belong to a CC */
+function defineStaticCCValue<
+	TCommandClass extends CommandClasses,
+	TBlueprint extends CCValueBlueprint,
+>(
+	commandClass: TCommandClass,
+	blueprint: TBlueprint,
+): ExpandRecursively<InferStaticCCValue<TCommandClass, TBlueprint>> {
+	// Normalize value options
+	const _blueprint = {
+		...blueprint,
+		options: {
+			...defaultCCValueOptions,
+			...blueprint.options,
+		},
+	};
+
+	const valueId = {
+		commandClass,
+		property: _blueprint.property,
+		propertyKey: _blueprint.propertyKey,
+	};
+
+	const ret: InferStaticCCValue<TCommandClass, TBlueprint> = {
+		get id() {
+			return { ...valueId };
+		},
+		endpoint: (endpoint: number = 0) => {
+			if (!_blueprint.options.supportsEndpoints) endpoint = 0;
+			return { ...valueId, endpoint };
+		},
+		is: (testValueId) => {
+			return (
+				valueId.commandClass === testValueId.commandClass &&
+				valueId.property === testValueId.property &&
+				valueId.propertyKey === testValueId.propertyKey
+			);
+		},
+		get meta() {
+			return { ...ValueMetadata.Any, ..._blueprint.meta } as any;
+		},
+		get options() {
+			return { ..._blueprint.options } as any;
+		},
+	};
+
+	return ret as any;
+}
+
+/** Defines a single CC value which depends on one or more parameters */
+function defineDynamicCCValue<
+	TCommandClass extends CommandClasses,
+	TBlueprint extends DynamicCCValueBlueprint<any[]>,
+>(
+	commandClass: TCommandClass,
+	blueprint: TBlueprint,
+): ExpandRecursively<InferDynamicCCValue<TCommandClass, TBlueprint>> {
+	const options = {
+		...defaultCCValueOptions,
+		...blueprint.options,
+	};
+
+	const ret: ExpandRecursively<
+		InferDynamicCCValue<TCommandClass, TBlueprint>
+	> = ((...args: Parameters<TBlueprint>) => {
+		const _blueprint = blueprint(...args);
+
+		// Normalize value options
+		const actualBlueprint = {
+			..._blueprint,
+		};
+
+		const valueId = {
+			commandClass,
+			property: actualBlueprint.property,
+			propertyKey: actualBlueprint.propertyKey,
+		};
+
+		const value: Omit<
+			InferStaticCCValue<TCommandClass, ReturnType<TBlueprint>>,
+			"options" | "is"
+		> = {
+			get id() {
+				return { ...valueId };
+			},
+			endpoint: (endpoint: number = 0) => {
+				if (!options.supportsEndpoints) endpoint = 0;
+				return { ...valueId, endpoint };
+			},
+			get meta() {
+				return { ...ValueMetadata.Any, ...actualBlueprint.meta } as any;
+			},
+		};
+
+		return value;
+	}) as any;
+
+	Object.defineProperty(ret, "options", {
+		configurable: false,
+		enumerable: true,
+		get() {
+			return { ...options };
+		},
+	});
+
+	Object.defineProperty(ret, "is", {
+		configurable: false,
+		enumerable: false,
+		writable: false,
+		value: (id: ValueID) =>
+			id.commandClass === commandClass && blueprint.is(id),
+	});
+
+	return ret;
+}
+
+// Namespace for utilities to define CC values
+export const V = {
+	/** Defines multiple static CC values that belong to the same CC */
+	defineStaticCCValues<
+		TCommandClass extends CommandClasses,
+		TValues extends Record<keyof TValues, CCValueBlueprint>,
+	>(
+		commandClass: TCommandClass,
+		values: TValues,
+	): TValues extends Record<keyof TValues, CCValueBlueprint>
+		? ExpandRecursively<ToStaticCCValues<TCommandClass, TValues>>
+		: never {
+		return Object.fromEntries(
+			Object.entries<CCValueBlueprint>(values).map(([key, blueprint]) => [
+				key,
+				defineStaticCCValue(commandClass, blueprint),
+			]),
+		) as any;
+	},
+
+	/** Defines multiple static CC values that belong to the same CC */
+	defineDynamicCCValues<
+		TCommandClass extends CommandClasses,
+		TValues extends Record<keyof TValues, DynamicCCValueBlueprint<any>>,
+	>(
+		commandClass: TCommandClass,
+		values: TValues,
+	): TValues extends Record<keyof TValues, DynamicCCValueBlueprint<any>>
+		? ExpandRecursively<ToDynamicCCValues<TCommandClass, TValues>>
+		: never {
+		return Object.fromEntries(
+			Object.entries<DynamicCCValueBlueprint<any>>(values).map(
+				([key, blueprint]) => [
+					key,
+					defineDynamicCCValue(commandClass, blueprint),
+				],
+			),
+		) as any;
+	},
+
+	/** Returns a CC value definition that is named like the value `property` */
+	staticProperty<
+		TProp extends string | number,
+		TMeta extends ValueMetadata,
+		TOptions extends CCValueOptions,
+	>(
+		property: TProp,
+		meta?: TMeta,
+		options?: TOptions,
+	): {
+		[K in TProp]: {
+			property: TProp;
+			meta: TMeta;
+			options: TOptions;
+		};
+	} {
+		return {
+			[property]: {
+				property,
+				meta,
+				options,
+			},
+		} as any;
+	},
+
+	/** Returns a CC value definition with the given name and `property` */
+	staticPropertyWithName<
+		TName extends string,
+		TProp extends string | number,
+		TMeta extends ValueMetadata,
+		TOptions extends CCValueOptions,
+	>(
+		name: TName,
+		property: TProp,
+		meta?: TMeta,
+		options?: TOptions,
+	): {
+		[K in TName]: {
+			property: TProp;
+			meta: TMeta;
+			options: TOptions;
+		};
+	} {
+		return {
+			[name]: {
+				property,
+				meta,
+				options,
+			},
+		} as any;
+	},
+
+	/** Returns a CC value definition with the given name, `property` and `propertyKey` */
+	staticPropertyAndKeyWithName<
+		TName extends string,
+		TProp extends string | number,
+		TKey extends string | number,
+		TMeta extends ValueMetadata,
+		TOptions extends CCValueOptions,
+	>(
+		name: TName,
+		property: TProp,
+		propertyKey: TKey,
+		meta?: TMeta,
+		options?: TOptions,
+	): {
+		[K in TName]: {
+			property: TProp;
+			propertyKey: TKey;
+			meta: TMeta;
+			options: TOptions;
+		};
+	} {
+		return {
+			[name]: {
+				property,
+				propertyKey,
+				meta,
+				options,
+			},
+		} as any;
+	},
+
+	/** Returns a CC value definition with the given name and a dynamic `property` */
+	dynamicPropertyWithName<
+		TName extends string,
+		TProp extends FnOrStatic<any[], ValueIDProperties["property"]>,
+		TMeta extends FnOrStatic<any[], ValueMetadata> = ValueMetadata,
+		TOptions extends CCValueOptions = CCValueOptions,
+	>(
+		name: TName,
+		property: TProp,
+		is: PartialCCValuePredicate,
+		meta?: TMeta,
+		options?: TOptions | undefined,
+	): {
+		[K in TName]: {
+			(...args: InferArgs<[TProp, TMeta]>): {
+				property: ReturnTypeOrStatic<TProp>;
+				meta: ReturnTypeOrStatic<TMeta>;
+			};
+			is: PartialCCValuePredicate;
+			options: TOptions;
+		};
+	} {
+		return {
+			[name]: Object.assign(
+				(...args: InferArgs<[TProp, TMeta]>) => ({
+					property: evalOrStatic(property, ...args),
+					meta: evalOrStatic(meta, ...args),
+				}),
+				{ is, options },
+			),
+		} as any;
+	},
+
+	/** Returns a CC value definition with the given name and a dynamic `property` */
+	dynamicPropertyAndKeyWithName<
+		TName extends string,
+		TProp extends FnOrStatic<any[], ValueIDProperties["property"]>,
+		TKey extends FnOrStatic<any[], ValueIDProperties["propertyKey"]>,
+		TMeta extends FnOrStatic<any[], ValueMetadata> = ValueMetadata,
+		TOptions extends FnOrStatic<any[], CCValueOptions> = CCValueOptions,
+	>(
+		name: TName,
+		property: TProp,
+		propertyKey: TKey,
+		is: PartialCCValuePredicate,
+		meta?: TMeta,
+		options?: TOptions | undefined,
+	): {
+		[K in TName]: {
+			(...args: InferArgs<[TProp, TKey, TMeta]>): {
+				property: ReturnTypeOrStatic<TProp>;
+				propertyKey: ReturnTypeOrStatic<TKey>;
+				meta: ReturnTypeOrStatic<TMeta>;
+			};
+			is: PartialCCValuePredicate;
+			options: TOptions;
+		};
+	} {
+		return {
+			[name]: Object.assign(
+				(...args: any[]) => {
+					return {
+						property: evalOrStatic(property, ...args),
+						propertyKey: evalOrStatic(propertyKey, ...args),
+						meta: evalOrStatic(meta, ...args),
+					};
+				},
+				{ is, options },
+			),
+		} as any;
+	},
+};
+
+export interface CCValueBlueprint extends Readonly<ValueIDProperties> {
+	readonly meta?: Readonly<ValueMetadata>;
+	readonly options?: Readonly<CCValueOptions>;
+}
+
+export type CCValuePredicate = (valueId: ValueID) => boolean;
+export type PartialCCValuePredicate = (
+	properties: ValueIDProperties,
+) => boolean;
+
+/** A blueprint for a CC value which depends on one or more parameters */
+export interface DynamicCCValueBlueprint<TArgs extends any[]> {
+	(...args: TArgs): Omit<CCValueBlueprint, "options">;
+	is: PartialCCValuePredicate;
+	readonly options?: Readonly<CCValueOptions>;
+}
+
+type DropOptional<T> = {
+	[K in keyof T as [undefined] extends [T[K]] ? never : K]: T[K];
+};
+
+type MergeOptions<TOptions extends CCValueOptions> = DropOptional<
+	CCValueOptions extends TOptions
+		? // When the type cannot be inferred exactly (not given), default to DefaultOptions
+		  DefaultOptions
+		: Overwrite<DefaultOptions, TOptions>
+>;
+
+type MergeMeta<TMeta extends ValueMetadata> = DropOptional<
+	ValueMetadata extends TMeta
+		? // When the type cannot be inferred exactly (not given), default to ValueMetadata.Any
+		  typeof ValueMetadata["Any"]
+		: Overwrite<typeof ValueMetadata["Any"], TMeta>
+>;
+
+/** The common base type of all CC value definitions */
+export interface CCValue {
+	readonly id: Omit<ValueID, "endpoint">;
+	endpoint(endpoint?: number): ValueID;
+	readonly meta: ValueMetadata;
+}
+
+type AddCCValueProperties<
+	TCommandClass extends CommandClasses,
+	TBlueprint extends CCValueBlueprint,
+	ValueIDBase extends Record<string, any> = InferValueIDBase<
+		TCommandClass,
+		TBlueprint
+	>,
+> = {
+	/** Returns the value ID of this CC value, without endpoint information */
+	get id(): ValueIDBase;
+
+	/** Returns the value ID, specialized to the given endpoint */
+	endpoint(
+		endpoint?: number,
+	): Readonly<
+		Pick<ValueIDBase, "commandClass"> & { endpoint: number } & Omit<
+				ValueIDBase,
+				"commandClass"
+			>
+	>;
+
+	/** Whether the given value ID matches this value definition */
+	is: CCValuePredicate;
+
+	/** Returns the metadata for this value ID */
+	get meta(): Readonly<MergeMeta<NonNullable<TBlueprint["meta"]>>>;
+	/** Returns the value options for this value ID */
+	get options(): Readonly<MergeOptions<NonNullable<TBlueprint["options"]>>>;
+};
+
+/** A CC value definition which depends on one or more parameters, transparently inferred from its arguments */
+export type InferDynamicCCValue<
+	TCommandClass extends CommandClasses,
+	TBlueprint extends DynamicCCValueBlueprint<any[]>,
+> = TBlueprint extends DynamicCCValueBlueprint<infer TArgs>
+	? {
+			(...args: TArgs): Omit<
+				InferStaticCCValue<TCommandClass, ReturnType<TBlueprint>>,
+				"options" | "is"
+			>;
+
+			/** Whether the given value ID matches this value definition */
+			is: CCValuePredicate;
+
+			readonly options: InferStaticCCValue<
+				TCommandClass,
+				ReturnType<TBlueprint> & { options: TBlueprint["options"] }
+			>["options"];
+	  }
+	: never;
+
+/** A static or evaluated CC value definition, transparently inferred from its arguments */
+export type InferStaticCCValue<
+	TCommandClass extends CommandClasses,
+	TBlueprint extends CCValueBlueprint,
+> = Readonly<AddCCValueProperties<TCommandClass, TBlueprint>>;
+
+/** The generic variant of {@link InferStaticCCValue}, without inferring arguments */
+export interface StaticCCValue extends CCValue {
+	/** Whether the given value ID matches this value definition */
+	is: CCValuePredicate;
+	readonly options: Required<CCValueOptions>;
+}
+
+/** The generic variant of {@link InferDynamicCCValue}, without inferring arguments */
+export type DynamicCCValue<TArgs extends any[] = any[]> =
+	ExpandRecursivelySkipMeta<(...args: TArgs) => CCValue> & {
+		/** Whether the given value ID matches this value definition */
+		is: CCValuePredicate;
+		readonly options: Required<CCValueOptions>;
+	};
+
+export type StaticCCValueFactory<T> = (self: T) => StaticCCValue;
+
+// This interface is auto-generated by maintenance/generateCCValuesInterface.ts
+// Do not edit it by hand or your changes will be lost
+export interface CCValues {
+	// AUTO GENERATION BELOW
+	"Alarm Sensor": typeof import("../cc/AlarmSensorCC").AlarmSensorCCValues;
+	Association: typeof import("../cc/AssociationCC").AssociationCCValues;
+	"Association Group Information": typeof import("../cc/AssociationGroupInfoCC").AssociationGroupInfoCCValues;
+	"Barrier Operator": typeof import("../cc/BarrierOperatorCC").BarrierOperatorCCValues;
+	Basic: typeof import("../cc/BasicCC").BasicCCValues;
+	Battery: typeof import("../cc/BatteryCC").BatteryCCValues;
+	"Binary Sensor": typeof import("../cc/BinarySensorCC").BinarySensorCCValues;
+	"Binary Switch": typeof import("../cc/BinarySwitchCC").BinarySwitchCCValues;
+	"Central Scene": typeof import("../cc/CentralSceneCC").CentralSceneCCValues;
+	"Climate Control Schedule": typeof import("../cc/ClimateControlScheduleCC").ClimateControlScheduleCCValues;
+	"Color Switch": typeof import("../cc/ColorSwitchCC").ColorSwitchCCValues;
+	Configuration: typeof import("../cc/ConfigurationCC").ConfigurationCCValues;
+	"Door Lock": typeof import("../cc/DoorLockCC").DoorLockCCValues;
+	"Door Lock Logging": typeof import("../cc/DoorLockLoggingCC").DoorLockLoggingCCValues;
+	"Entry Control": typeof import("../cc/EntryControlCC").EntryControlCCValues;
+	"Firmware Update Meta Data": typeof import("../cc/FirmwareUpdateMetaDataCC").FirmwareUpdateMetaDataCCValues;
+	"Humidity Control Mode": typeof import("../cc/HumidityControlModeCC").HumidityControlModeCCValues;
+	"Humidity Control Operating State": typeof import("../cc/HumidityControlOperatingStateCC").HumidityControlOperatingStateCCValues;
+	"Humidity Control Setpoint": typeof import("../cc/HumidityControlSetpointCC").HumidityControlSetpointCCValues;
+	Indicator: typeof import("../cc/IndicatorCC").IndicatorCCValues;
+	Irrigation: typeof import("../cc/IrrigationCC").IrrigationCCValues;
+	Language: typeof import("../cc/LanguageCC").LanguageCCValues;
+	Lock: typeof import("../cc/LockCC").LockCCValues;
+	"Manufacturer Specific": typeof import("../cc/ManufacturerSpecificCC").ManufacturerSpecificCCValues;
+	Meter: typeof import("../cc/MeterCC").MeterCCValues;
+	"Multi Channel Association": typeof import("../cc/MultiChannelAssociationCC").MultiChannelAssociationCCValues;
+	"Multi Channel": typeof import("../cc/MultiChannelCC").MultiChannelCCValues;
+	"Multilevel Sensor": typeof import("../cc/MultilevelSensorCC").MultilevelSensorCCValues;
+	"Multilevel Switch": typeof import("../cc/MultilevelSwitchCC").MultilevelSwitchCCValues;
+	"Node Naming and Location": typeof import("../cc/NodeNamingCC").NodeNamingAndLocationCCValues;
+	Notification: typeof import("../cc/NotificationCC").NotificationCCValues;
+	Protection: typeof import("../cc/ProtectionCC").ProtectionCCValues;
+	"Scene Activation": typeof import("../cc/SceneActivationCC").SceneActivationCCValues;
+	"Scene Actuator Configuration": typeof import("../cc/SceneActuatorConfigurationCC").SceneActuatorConfigurationCCValues;
+	"Scene Controller Configuration": typeof import("../cc/SceneControllerConfigurationCC").SceneControllerConfigurationCCValues;
+	"Sound Switch": typeof import("../cc/SoundSwitchCC").SoundSwitchCCValues;
+	"Thermostat Fan Mode": typeof import("../cc/ThermostatFanModeCC").ThermostatFanModeCCValues;
+	"Thermostat Fan State": typeof import("../cc/ThermostatFanStateCC").ThermostatFanStateCCValues;
+	"Thermostat Mode": typeof import("../cc/ThermostatModeCC").ThermostatModeCCValues;
+	"Thermostat Operating State": typeof import("../cc/ThermostatOperatingStateCC").ThermostatOperatingStateCCValues;
+	"Thermostat Setback": typeof import("../cc/ThermostatSetbackCC").ThermostatSetbackCCValues;
+	"Thermostat Setpoint": typeof import("../cc/ThermostatSetpointCC").ThermostatSetpointCCValues;
+	"Time Parameters": typeof import("../cc/TimeParametersCC").TimeParametersCCValues;
+	"User Code": typeof import("../cc/UserCodeCC").UserCodeCCValues;
+	Version: typeof import("../cc/VersionCC").VersionCCValues;
+	"Wake Up": typeof import("../cc/WakeUpCC").WakeUpCCValues;
+	"Z-Wave Plus Info": typeof import("../cc/ZWavePlusCC").ZWavePlusCCValues;
+}
diff --git a/packages/cc/src/lib/utils.ts b/packages/cc/src/lib/utils.ts
index 21bfdc67273..95149156e89 100644
--- a/packages/cc/src/lib/utils.ts
+++ b/packages/cc/src/lib/utils.ts
@@ -11,14 +11,13 @@ import { ObjectKeyMap, type ReadonlyObjectKeyMap } from "@zwave-js/shared/safe";
 import { distinct } from "alcalzone-shared/arrays";
 import {
 	AssociationCC,
-	getHasLifelineValueId,
+	AssociationCCValues,
 	getLifelineGroupIds,
 } from "../cc/AssociationCC";
 import { AssociationGroupInfoCC } from "../cc/AssociationGroupInfoCC";
 import {
-	getEndpointsValueId,
-	getNodeIdsValueId,
 	MultiChannelAssociationCC,
+	MultiChannelAssociationCCValues,
 } from "../cc/MultiChannelAssociationCC";
 import { CCAPI } from "./API";
 import type {
@@ -553,7 +552,10 @@ export async function configureLifelineAssociations(
 			level: "warn",
 		});
 		// Remember that we have NO lifeline association
-		valueDB.setValue(getHasLifelineValueId(endpoint.index), false);
+		valueDB.setValue(
+			AssociationCCValues.hasLifeline.endpoint(endpoint.index),
+			false,
+		);
 		return;
 	}
 
@@ -897,11 +899,13 @@ must use node association:     ${rootMustUseNodeAssociation}`,
 			});
 
 			if (!rootMustUseNodeAssociation) {
-				const rootNodesValueId = getNodeIdsValueId(0, group);
+				const rootNodesValueId =
+					MultiChannelAssociationCCValues.nodeIds(group).id;
 				const rootHasNodeAssociation = !!valueDB
 					.getValue<number[]>(rootNodesValueId)
 					?.some((a) => a === ownNodeId);
-				const rootEndpointsValueId = getEndpointsValueId(0, group);
+				const rootEndpointsValueId =
+					MultiChannelAssociationCCValues.endpoints(group).id;
 				const rootHasEndpointAssociation = !!valueDB
 					.getValue<EndpointAddress[]>(rootEndpointsValueId)
 					?.some((a) => a.nodeId === ownNodeId && a.endpoint === 0);
@@ -957,5 +961,8 @@ must use node association:     ${rootMustUseNodeAssociation}`,
 	}
 
 	// Remember that we did the association assignment
-	valueDB.setValue(getHasLifelineValueId(endpoint.index), true);
+	valueDB.setValue(
+		AssociationCCValues.hasLifeline.endpoint(endpoint.index),
+		true,
+	);
 }
diff --git a/packages/core/src/util/decorators.ts b/packages/core/src/util/decorators.ts
index 85edbde35fb..b93f55bccd6 100644
--- a/packages/core/src/util/decorators.ts
+++ b/packages/core/src/util/decorators.ts
@@ -319,3 +319,84 @@ export function createReflectionDecoratorPair<
 
 	return ret;
 }
+
+// export interface PropertyReflectionDecorator<
+// 	// eslint-disable-next-line @typescript-eslint/ban-types
+// 	TTarget extends Object,
+// 	TArgs extends any[],
+// 	TValue,
+// > {
+// 	/** The decorator which is used to decorate properties */
+// 	decorator: (...args: TArgs) => TypedPropertyDecorator<TTarget>;
+// 	/** Looks up all decorated properties and the decorator arguments for a class instance */
+// 	lookupValues: (target: TTarget) => ReadonlyMap<string | number, TValue>;
+// }
+
+// export interface CreatePropertyReflectionDecoratorOptions<
+// 	TArgs extends any[],
+// 	TValue,
+// > {
+// 	/** The name of this decorator */
+// 	name: string;
+// 	/** Determines the value to be stored for the given arguments */
+// 	valueFromArgs: (...args: TArgs) => TValue;
+// }
+
+// /** Creates a reflection decorator for a class property and the corresponding method for reverse lookup of defined values */
+// export function createPropertyReflectionDecorator<
+// 	// eslint-disable-next-line @typescript-eslint/ban-types
+// 	TTarget extends Object,
+// 	TArgs extends any[],
+// 	TValue,
+// >({
+// 	name,
+// 	valueFromArgs,
+// }: CreatePropertyReflectionDecoratorOptions<
+// 	TArgs,
+// 	TValue
+// >): PropertyReflectionDecorator<TTarget, TArgs, TValue> {
+// 	const key = Symbol.for(`METADATA_${name}`);
+
+// 	const prp: PropertyReflectionDecorator<TTarget, TArgs, TValue> = {
+// 		decorator: (...args) => {
+// 			const value = valueFromArgs(...args);
+// 			let body = (
+// 				target: TTarget,
+// 				property: string | number | symbol,
+// 			) => {
+// 				// get the class constructor
+// 				const constr = target.constructor;
+
+// 				// retrieve the current metadata
+// 				const metadata: Map<string | number, TValue> =
+// 					Reflect.getMetadata(key, constr) ?? new Map();
+
+// 				// Add the variable
+// 				metadata.set(property as string | number, value);
+
+// 				// And store it back
+// 				Reflect.defineMetadata(key, metadata, constr);
+// 			};
+
+// 			// Rename the decorator body so it is easier to identify in stack traces
+// 			body = Object.defineProperty(body, "name", {
+// 				value: "decoratorBody_" + name,
+// 			});
+
+// 			return body;
+// 		},
+
+// 		lookupValues: (target) => {
+// 			return Reflect.getMetadata(key, target.constructor);
+// 		},
+// 	};
+
+// 	// Rename the decorator functions so they are easier to identify in stack traces
+// 	for (const property of ["decorator", "lookupValues"] as const) {
+// 		prp[property] = Object.defineProperty(prp[property], "name", {
+// 			value: `${property}_${name}`,
+// 		}) as any;
+// 	}
+
+// 	return prp;
+// }
diff --git a/packages/core/src/values/Metadata.ts b/packages/core/src/values/Metadata.ts
index f4d6f2fa9c9..dab950108a6 100644
--- a/packages/core/src/values/Metadata.ts
+++ b/packages/core/src/values/Metadata.ts
@@ -65,9 +65,22 @@ export interface ValueMetadataAny {
 	/** CC-specific information to help identify this value */
 	ccSpecific?: Record<string, any>;
 	/** Options that can be provided when changing this value on a device via its value ID. */
-	valueChangeOptions?: (keyof ValueChangeOptions)[];
+	valueChangeOptions?: readonly (keyof ValueChangeOptions)[];
 }
 
+/**
+ * Helper function to define metadata templates while checking that they satify a constraint.
+ */
+// TODO: Revisit this when https://github.com/microsoft/TypeScript/issues/47920 is solved
+const define =
+	<TBase extends ValueMetadataAny>() =>
+	// The chained function pattern is necessary for partial application of generic types
+	<T extends TBase>(definition: T): T => {
+		return definition;
+	};
+
+const defineAny = define<ValueMetadataAny>();
+
 export interface ValueMetadataNumeric extends ValueMetadataAny {
 	type: "number";
 	/** The minimum value that can be assigned to a CC value (optional) */
@@ -84,12 +97,16 @@ export interface ValueMetadataNumeric extends ValueMetadataAny {
 	unit?: string;
 }
 
+const defineNumeric = define<ValueMetadataNumeric>();
+
 export interface ValueMetadataBoolean extends ValueMetadataAny {
 	type: "boolean";
 	/** The default value */
 	default?: number;
 }
 
+const defineBoolean = define<ValueMetadataBoolean>();
+
 export interface ValueMetadataString extends ValueMetadataAny {
 	type: "string" | "color";
 	/** The minimum length this string must have (optional) */
@@ -100,6 +117,8 @@ export interface ValueMetadataString extends ValueMetadataAny {
 	default?: string;
 }
 
+const defineString = define<ValueMetadataString>();
+
 export interface ValueMetadataBuffer extends ValueMetadataAny {
 	type: "buffer";
 	/** The minimum length this buffer must have (optional) */
@@ -108,11 +127,15 @@ export interface ValueMetadataBuffer extends ValueMetadataAny {
 	maxLength?: number;
 }
 
+const defineBuffer = define<ValueMetadataBuffer>();
+
 export interface ValueMetadataDuration extends ValueMetadataAny {
 	type: "duration";
 	default?: Duration;
 }
 
+const defineDuration = define<ValueMetadataDuration>();
+
 /**
  * Defines how a configuration value is encoded
  */
@@ -162,316 +185,316 @@ export type ValueMetadata =
 // TODO: lists of allowed values, etc...
 
 // Mixins for value metadata
-const _default: ValueMetadataAny = {
+const _default = defineAny({
 	type: "any",
 	readable: true,
 	writeable: true,
-};
+} as const);
 
 const _readonly = {
 	writeable: false,
-};
+} as const;
 
 const _writeonly = {
 	readable: false,
-};
+} as const;
 
 /** The default value for metadata: readable and writeable */
-const Any: ValueMetadataAny = {
+const Any = defineAny({
 	..._default,
-};
+} as const);
 
 /** The default value for readonly metadata */
-const ReadOnly: ValueMetadataAny = {
+const ReadOnly = defineAny({
 	..._default,
 	..._readonly,
-};
+} as const);
 
 /** The default value for writeonly metadata */
-const WriteOnly: ValueMetadataAny = {
+const WriteOnly = defineAny({
 	..._default,
 	..._writeonly,
-};
+} as const);
 
 /** A boolean value */
-const Boolean: ValueMetadataBoolean = {
+const Boolean = defineBoolean({
 	..._default,
 	type: "boolean",
-};
+} as const);
 
 /** A boolean value (readonly) */
-const ReadOnlyBoolean: ValueMetadataBoolean = {
+const ReadOnlyBoolean = defineBoolean({
 	...Boolean,
 	..._readonly,
-};
+} as const);
 
 /** A boolean value (writeonly) */
-const WriteOnlyBoolean: ValueMetadataBoolean = {
+const WriteOnlyBoolean = defineBoolean({
 	...Boolean,
 	..._writeonly,
-};
+} as const);
 
 /** Any number */
-const Number: ValueMetadataNumeric = {
+const Number = defineNumeric({
 	..._default,
 	type: "number",
-};
+} as const);
 
 /** Unsigned number (readonly) */
-const ReadOnlyNumber: ValueMetadataNumeric = {
+const ReadOnlyNumber = defineNumeric({
 	...Number,
 	..._readonly,
-};
+} as const);
 
 /** Unsigned number (writeonly) */
-const WriteOnlyNumber: ValueMetadataNumeric = {
+const WriteOnlyNumber = defineNumeric({
 	...Number,
 	..._writeonly,
-};
+} as const);
 
 /** Unsigned 8-bit integer */
-const UInt8: ValueMetadataNumeric = {
+const UInt8 = defineNumeric({
 	..._default,
 	type: "number",
 	...IntegerLimits.UInt8,
-};
+} as const);
 
 /** Unsigned 8-bit integer (readonly) */
-const ReadOnlyUInt8: ValueMetadataNumeric = {
+const ReadOnlyUInt8 = defineNumeric({
 	...UInt8,
 	..._readonly,
-};
+} as const);
 
 /** Unsigned 8-bit integer (writeonly) */
-const WriteOnlyUInt8: ValueMetadataNumeric = {
+const WriteOnlyUInt8 = defineNumeric({
 	...UInt8,
 	..._writeonly,
-};
+} as const);
 
 /** Unsigned 16-bit integer */
-const UInt16: ValueMetadataNumeric = {
+const UInt16 = defineNumeric({
 	..._default,
 	type: "number",
 	...IntegerLimits.UInt16,
-};
+} as const);
 
 /** Unsigned 16-bit integer (readonly) */
-const ReadOnlyUInt16: ValueMetadataNumeric = {
+const ReadOnlyUInt16 = defineNumeric({
 	...UInt16,
 	..._readonly,
-};
+} as const);
 
 /** Unsigned 16-bit integer (writeonly) */
-const WriteOnlyUInt16: ValueMetadataNumeric = {
+const WriteOnlyUInt16 = defineNumeric({
 	...UInt16,
 	..._writeonly,
-};
+} as const);
 
 /** Unsigned 24-bit integer */
-const UInt24: ValueMetadataNumeric = {
+const UInt24 = defineNumeric({
 	..._default,
 	type: "number",
 	...IntegerLimits.UInt24,
-};
+} as const);
 
 /** Unsigned 24-bit integer (readonly) */
-const ReadOnlyUInt24: ValueMetadataNumeric = {
+const ReadOnlyUInt24 = defineNumeric({
 	...UInt24,
 	..._readonly,
-};
+} as const);
 
 /** Unsigned 24-bit integer (writeonly) */
-const WriteOnlyUInt24: ValueMetadataNumeric = {
+const WriteOnlyUInt24 = defineNumeric({
 	...UInt24,
 	..._writeonly,
-};
+} as const);
 
 /** Unsigned 32-bit integer */
-const UInt32: ValueMetadataNumeric = {
+const UInt32 = defineNumeric({
 	..._default,
 	type: "number",
 	...IntegerLimits.UInt32,
-};
+} as const);
 
 /** Unsigned 32-bit integer (readonly) */
-const ReadOnlyUInt32: ValueMetadataNumeric = {
+const ReadOnlyUInt32 = defineNumeric({
 	...UInt32,
 	..._readonly,
-};
+} as const);
 
 /** Unsigned 32-bit integer (writeonly) */
-const WriteOnlyUInt32: ValueMetadataNumeric = {
+const WriteOnlyUInt32 = defineNumeric({
 	...UInt32,
 	..._writeonly,
-};
+} as const);
 
 /** Signed 8-bit integer */
-const Int8: ValueMetadataNumeric = {
+const Int8 = defineNumeric({
 	..._default,
 	type: "number",
 	...IntegerLimits.Int8,
-};
+} as const);
 
 /** Signed 8-bit integer (readonly) */
-const ReadOnlyInt8: ValueMetadataNumeric = {
+const ReadOnlyInt8 = defineNumeric({
 	...Int8,
 	..._readonly,
-};
+} as const);
 
 /** Signed 8-bit integer (writeonly) */
-const WriteOnlyInt8: ValueMetadataNumeric = {
+const WriteOnlyInt8 = defineNumeric({
 	...Int8,
 	..._writeonly,
-};
+} as const);
 
 /** Signed 16-bit integer */
-const Int16: ValueMetadataNumeric = {
+const Int16 = defineNumeric({
 	..._default,
 	type: "number",
 	...IntegerLimits.Int16,
-};
+} as const);
 
 /** Signed 16-bit integer (readonly) */
-const ReadOnlyInt16: ValueMetadataNumeric = {
+const ReadOnlyInt16 = defineNumeric({
 	...Int16,
 	..._readonly,
-};
+} as const);
 
 /** Signed 16-bit integer (writeonly) */
-const WriteOnlyInt16: ValueMetadataNumeric = {
+const WriteOnlyInt16 = defineNumeric({
 	...Int16,
 	..._writeonly,
-};
+} as const);
 
 /** Signed 24-bit integer */
-const Int24: ValueMetadataNumeric = {
+const Int24 = defineNumeric({
 	..._default,
 	type: "number",
 	...IntegerLimits.Int24,
-};
+} as const);
 
 /** Signed 24-bit integer (readonly) */
-const ReadOnlyInt24: ValueMetadataNumeric = {
+const ReadOnlyInt24 = defineNumeric({
 	...Int24,
 	..._readonly,
-};
+} as const);
 
 /** Signed 24-bit integer (writeonly) */
-const WriteOnlyInt24: ValueMetadataNumeric = {
+const WriteOnlyInt24 = defineNumeric({
 	...Int24,
 	..._writeonly,
-};
+} as const);
 
 /** Signed 32-bit integer */
-const Int32: ValueMetadataNumeric = {
+const Int32 = defineNumeric({
 	..._default,
 	type: "number",
 	...IntegerLimits.Int32,
-};
+} as const);
 
 /** Signed 32-bit integer (readonly) */
-const ReadOnlyInt32: ValueMetadataNumeric = {
+const ReadOnlyInt32 = defineNumeric({
 	...Int32,
 	..._readonly,
-};
+} as const);
 
 /** Signed 32-bit integer (writeonly) */
-const WriteOnlyInt32: ValueMetadataNumeric = {
+const WriteOnlyInt32 = defineNumeric({
 	...Int32,
 	..._writeonly,
-};
+} as const);
 
 /** Any string */
-const String: ValueMetadataString = {
+const String = defineString({
 	..._default,
 	type: "string",
-};
+} as const);
 
 /** Any string (readonly) */
-const ReadOnlyString: ValueMetadataString = {
+const ReadOnlyString = defineString({
 	...String,
 	..._readonly,
-};
+} as const);
 
 /** Any string (writeonly) */
-const WriteOnlyString: ValueMetadataString = {
+const WriteOnlyString = defineString({
 	...String,
 	..._writeonly,
-};
+} as const);
 
 /** A (hex) string that represents a color */
-const Color: ValueMetadataString = {
+const Color = defineString({
 	...String,
 	type: "color",
-};
+} as const);
 
 /** A (hex) string that represents a color (readonly) */
-const ReadOnlyColor: ValueMetadataString = {
+const ReadOnlyColor = defineString({
 	...Color,
 	..._readonly,
-};
+} as const);
 
 /** A (hex) string that represents a color (writeonly) */
-const WriteOnlyColor: ValueMetadataString = {
+const WriteOnlyColor = defineString({
 	...Color,
 	..._writeonly,
-};
+} as const);
 
 // Some predefined CC-specific metadata
 
 /** The level of a Switch */
-const Level: ValueMetadataNumeric = {
+const Level = defineNumeric({
 	...UInt8,
 	max: 99,
-};
+} as const);
 
 /** The level of a Switch (readonly) */
-const ReadOnlyLevel: ValueMetadataNumeric = {
+const ReadOnlyLevel = defineNumeric({
 	...Level,
 	..._readonly,
-};
+} as const);
 
 /** The level of a Switch (writeonly) */
-const WriteOnlyLevel: ValueMetadataNumeric = {
+const WriteOnlyLevel = defineNumeric({
 	...Level,
 	..._writeonly,
-};
+} as const);
 
 /** A duration value */
-const _Duration: ValueMetadataDuration = {
+const _Duration = defineDuration({
 	..._default,
 	type: "duration",
-};
+} as const);
 
 /** A duration value (readonly) */
-const ReadOnlyDuration: ValueMetadataDuration = {
+const ReadOnlyDuration = defineDuration({
 	..._Duration,
 	..._readonly,
-};
+} as const);
 
 /** A duration value (writeonly) */
-const WriteOnlyDuration: ValueMetadataDuration = {
+const WriteOnlyDuration = defineDuration({
 	..._Duration,
 	..._writeonly,
-};
+} as const);
 
 /** A buffer */
-const _Buffer: ValueMetadataBuffer = {
+const _Buffer = defineBuffer({
 	..._default,
 	type: "buffer",
-};
+} as const);
 
 /** A buffer (readonly) */
-const ReadOnlyBuffer: ValueMetadataBuffer = {
+const ReadOnlyBuffer = defineBuffer({
 	..._Buffer,
 	..._readonly,
-};
+} as const);
 
 /** A buffer (writeonly) */
-const WriteOnlyBuffer: ValueMetadataBuffer = {
+const WriteOnlyBuffer = defineBuffer({
 	..._Buffer,
 	..._writeonly,
-};
+});
 
 /** A collection of predefined CC value metadata */
 export const ValueMetadata = {
diff --git a/packages/maintenance/src/generateTypedDocs.ts b/packages/maintenance/src/generateTypedDocs.ts
index 6f439f98c74..ff88d5940e1 100644
--- a/packages/maintenance/src/generateTypedDocs.ts
+++ b/packages/maintenance/src/generateTypedDocs.ts
@@ -4,7 +4,7 @@
 
 import { CommandClasses, getCCName } from "@zwave-js/core";
 import { enumFilesRecursive, num2hex } from "@zwave-js/shared";
-import { red } from "ansi-colors";
+import { red, yellow } from "ansi-colors";
 import * as fs from "fs-extra";
 import * as path from "path";
 import Piscina from "piscina";
@@ -21,6 +21,9 @@ import {
 	PropertySignatureStructure,
 	SourceFile,
 	SyntaxKind,
+	ts,
+	Type,
+	TypeFormatFlags,
 	TypeLiteralNode,
 } from "ts-morph";
 import { isMainThread } from "worker_threads";
@@ -214,6 +217,30 @@ export function findImportRanges(docFile: string): ImportRange[] {
 	}));
 }
 
+function stripQuotes(str: string): string {
+	return str.replace(/^['"]|['"]$/g, "");
+}
+
+function expectLiteralString(strType: string, context: string): void {
+	if (strType === "string") {
+		console.warn(
+			yellow(`WARNING: Received type "string" where a string literal was expected.
+		Make sure to define this string or the entire object using "as const".
+		Context: ${context}`),
+		);
+	}
+}
+
+function expectLiteralNumber(numType: string, context: string): void {
+	if (numType === "number") {
+		console.warn(
+			yellow(`WARNING: Received type "number" where a number literal was expected.
+Make sure to define this number or the entire object using "as const".
+Context: ${context}`),
+		);
+	}
+}
+
 const docsDir = path.join(projectRoot, "docs");
 const ccDocsDir = path.join(docsDir, "api/CCs");
 
@@ -237,7 +264,7 @@ export async function processDocFile(
 		if (!sourceNode) {
 			console.error(
 				red(
-					`Cannot find symbol ${range.symbol} in module ${range.module}!`,
+					`${docFile}: Cannot find symbol ${range.symbol} in module ${range.module}!`,
 				),
 			);
 			hasErrors = true;
@@ -401,6 +428,184 @@ ${
 		}
 	}
 
+	// List defined value IDs
+	const valueIDsConst = (() => {
+		for (const stmt of file.getVariableStatements()) {
+			if (!stmt.hasExportKeyword()) continue;
+			for (const decl of stmt.getDeclarations()) {
+				if (decl.getName()?.endsWith("CCValues")) {
+					return decl;
+				}
+			}
+		}
+	})();
+	if (valueIDsConst) {
+		let hasPrintedHeader = false;
+
+		const type = valueIDsConst.getType();
+		const formatValueType = (type: Type<ts.Type>): string => {
+			const prefix = "type _ = ";
+			let ret = formatWithPrettier(
+				"type.ts",
+				prefix +
+					type.getText(valueIDsConst, TypeFormatFlags.NoTruncation),
+			)
+				.trim()
+				.slice(prefix.length, -1);
+
+			// There is probably an official way to do this, but I can't find it
+			ret = ret
+				.replace(/typeof CommandClasses/g, "CommandClasses")
+				.replace(/^(\s+)readonly /gm, "$1")
+				.replace(/;$/gm, ",");
+
+			return ret;
+		};
+
+		const sortedProperties = type
+			.getProperties()
+			.sort((a, b) => a.getName().localeCompare(b.getName()));
+
+		for (const value of sortedProperties) {
+			let valueType = value.getTypeAtLocation(valueIDsConst);
+			let callSignature = "";
+
+			// Remember the options type before resolving dynamic values
+			const optionsType = valueType
+				.getPropertyOrThrow("options")
+				.getTypeAtLocation(valueIDsConst);
+
+			const getOptions = (prop: string): string =>
+				optionsType
+					.getPropertyOrThrow(prop)
+					.getTypeAtLocation(valueIDsConst)
+					.getText(valueIDsConst);
+
+			// Do not document internal CC values
+			if (getOptions("internal") === "true") continue;
+
+			// "Unwrap" dynamic value IDs
+			if (valueType.getCallSignatures().length === 1) {
+				const signature = valueType.getCallSignatures()[0];
+
+				// The call signature has a single argument
+				// args: [arg1: type1, arg2: type2, ...]
+				callSignature = `(${signature
+					.getParameters()[0]
+					.getTypeAtLocation(valueIDsConst)
+					.getText(valueIDsConst)
+					// Remove the [] from the tuple
+					.slice(1, -1)})`;
+
+				valueType = signature.getReturnType();
+			} else if (valueType.getCallSignatures().length > 1) {
+				throw new Error(
+					"Type of value ID had more than 1 call signature",
+				);
+			}
+
+			const idType = valueType
+				.getPropertyOrThrow("endpoint")
+				.getTypeAtLocation(valueIDsConst)
+				.getCallSignatures()[0]
+				.getReturnType();
+
+			const metaType = valueType
+				.getPropertyOrThrow("meta")
+				.getTypeAtLocation(valueIDsConst);
+
+			const getMeta = (prop: string): string =>
+				metaType
+					.getPropertyOrThrow(prop)
+					.getTypeAtLocation(valueIDsConst)
+					.getText(valueIDsConst);
+
+			const tryGetMeta = (
+				prop: string,
+				onSuccess: (meta: string) => void,
+			): void => {
+				const symbol = metaType.getProperty(prop);
+				if (symbol) {
+					const type = symbol
+						.getTypeAtLocation(valueIDsConst)
+						.getText(valueIDsConst);
+					onSuccess(type);
+				}
+			};
+
+			if (!hasPrintedHeader) {
+				text += `## ${ccName} CC values\n\n`;
+				hasPrintedHeader = true;
+			}
+
+			text += `### \`${value.getName()}${callSignature}\`
+
+\`\`\`ts
+${formatValueType(idType)}
+\`\`\`
+`;
+
+			tryGetMeta("label", (label) => {
+				// If the label is definitely not dynamic, ensure it has a literal type
+				if (!callSignature) {
+					expectLiteralString(
+						label,
+						`label of value "${value.getName()}"`,
+					);
+				} else if (label === "string") {
+					label = "_(dynamic)_";
+				}
+				text += `\n* **label:** ${stripQuotes(label)}`;
+			});
+			tryGetMeta("description", (description) => {
+				// If the description is definitely not dynamic, ensure it has a literal type
+				if (!callSignature) {
+					expectLiteralString(
+						description,
+						`description of value "${value.getName()}"`,
+					);
+				} else if (description === "string") {
+					description = "_(dynamic)_";
+				}
+				text += `\n* **description:** ${stripQuotes(description)}`;
+			});
+
+			// TODO: This should be moved to TypeScript somehow
+			const minVersion = getOptions("minVersion");
+			expectLiteralNumber(
+				minVersion,
+				`minVersion of value "${value.getName()}"`,
+			);
+
+			text += `
+* **min. CC version:** ${minVersion}
+* **readable:** ${getMeta("readable")}
+* **writeable:** ${getMeta("writeable")}
+* **stateful:** ${getOptions("stateful")}
+* **secret:** ${getOptions("secret")}
+`;
+
+			tryGetMeta("type", (meta) => {
+				text += `* **value type:** \`${meta}\`\n`;
+			});
+			tryGetMeta("default", (meta) => {
+				text += `* **default value:** ${meta}\n`;
+			});
+			tryGetMeta("min", (meta) => {
+				text += `* **min. value:** ${meta}\n`;
+			});
+			tryGetMeta("max", (meta) => {
+				text += `* **max. value:** ${meta}\n`;
+			});
+			tryGetMeta("minLength", (meta) => {
+				text += `* **min. length:** ${meta}\n`;
+			});
+			tryGetMeta("maxLength", (meta) => {
+				text += `* **max. length:** ${meta}\n`;
+			});
+		}
+	}
+
 	text = text.replace(/\r\n/g, "\n");
 	text = formatWithPrettier(filename, text);
 
@@ -433,6 +638,11 @@ async function generateCCDocs(
 
 	// Find CC APIs
 	const ccFiles = program.getSourceFiles("packages/cc/src/cc/**/*CC.ts");
+	// .filter(
+	// 	(s) =>
+	// 		s.getFilePath().includes("BasicCC") ||
+	// 		s.getFilePath().includes("AssociationCC"),
+	// );
 	let generatedIndex = "";
 	let generatedSidebar = "";
 
@@ -491,10 +701,14 @@ async function main(): Promise<void> {
 	});
 
 	let hasErrors = false;
-	// Replace all imports
-	hasErrors ||= await processImports(piscina);
-	// Regenerate all CC documentation files
-	if (!hasErrors) hasErrors ||= await generateCCDocs(program, piscina);
+	if (!process.argv.includes("--no-imports")) {
+		// Replace all imports
+		hasErrors ||= await processImports(piscina);
+	}
+	if (!process.argv.includes("--no-cc")) {
+		// Regenerate all CC documentation files
+		if (!hasErrors) hasErrors ||= await generateCCDocs(program, piscina);
+	}
 
 	if (hasErrors) {
 		process.exit(1);
@@ -514,11 +728,15 @@ export function processImport(filename: string): Promise<boolean> {
 	return processDocFile(getProgram(), filename);
 }
 
-export function processCC(
+export async function processCC(
 	filename: string,
 ): Promise<{ generatedIndex: string; generatedSidebar: any } | undefined> {
 	const sourceFile = getProgram().getSourceFileOrThrow(filename);
-	return processCCDocFile(sourceFile);
+	try {
+		return await processCCDocFile(sourceFile);
+	} catch (e: any) {
+		throw new Error(`Error processing CC file: ${filename}\n${e.stack}`);
+	}
 }
 
 // If this is NOT run as a worker thread, execute the main function
diff --git a/packages/shared/src/types.ts b/packages/shared/src/types.ts
index b9c71793f2f..6f18d7d8a65 100644
--- a/packages/shared/src/types.ts
+++ b/packages/shared/src/types.ts
@@ -18,6 +18,14 @@ export type TypedClassDecorator<TTarget extends Object> = <
 	apiClass: TConstructor,
 ) => TConstructor | void;
 
+// eslint-disable-next-line @typescript-eslint/ban-types
+export type TypedPropertyDecorator<TTarget extends Object> = <
+	T extends TTarget,
+>(
+	target: T,
+	propertyKey: string | symbol,
+) => void;
+
 export type UnionToIntersection<T> = (
 	T extends any ? (x: T) => any : never
 ) extends (x: infer R) => any
diff --git a/packages/transformers/src/index.test.ts b/packages/transformers/src/index.test.ts
index 13c1e4e35e4..1a70b24869c 100644
--- a/packages/transformers/src/index.test.ts
+++ b/packages/transformers/src/index.test.ts
@@ -13,7 +13,7 @@ describe("TypeScript transformers", () => {
 			(f) => f.startsWith("test") && f.endsWith(".js"),
 		);
 		files.push(...jsFiles);
-	}, 60000);
+	}, 180000);
 
 	it("run fixtures", async () => {
 		for (const file of files) {
diff --git a/packages/zwave-js/src/lib/controller/Controller.test.ts b/packages/zwave-js/src/lib/controller/Controller.test.ts
index 3ab96a56d40..0bb40294090 100644
--- a/packages/zwave-js/src/lib/controller/Controller.test.ts
+++ b/packages/zwave-js/src/lib/controller/Controller.test.ts
@@ -1,4 +1,4 @@
-import { getGroupCountValueId } from "@zwave-js/cc/AssociationCC";
+import { AssociationCCValues } from "@zwave-js/cc/AssociationCC";
 import {
 	assertZWaveError,
 	CommandClasses,
@@ -72,7 +72,7 @@ describe("lib/controller/Controller", () => {
 				isSupported: true,
 				version: 3,
 			});
-			node1.valueDB.setValue(getGroupCountValueId(0), 14);
+			node1.valueDB.setValue(AssociationCCValues.groupCount.id, 14);
 
 			const deviceConfig = await fakeDriver.configManager.lookupDevice(
 				// Logic Group ZDB5100
@@ -98,7 +98,7 @@ describe("lib/controller/Controller", () => {
 				isSupported: true,
 				version: 3,
 			});
-			node1.valueDB.setValue(getGroupCountValueId(0), 14);
+			node1.valueDB.setValue(AssociationCCValues.groupCount.id, 14);
 
 			const deviceConfig = await fakeDriver.configManager.lookupDevice(
 				// Logic Group ZDB5100
diff --git a/packages/zwave-js/src/lib/controller/Controller.ts b/packages/zwave-js/src/lib/controller/Controller.ts
index cf00e51c663..a03863a0632 100644
--- a/packages/zwave-js/src/lib/controller/Controller.ts
+++ b/packages/zwave-js/src/lib/controller/Controller.ts
@@ -1,18 +1,9 @@
 import {
 	ECDHProfiles,
-	getFirmwareVersionsMetadata,
-	getFirmwareVersionsValueId,
-	getManufacturerIdValueId,
-	getManufacturerIdValueMetadata,
-	getProductIdValueId,
-	getProductIdValueMetadata,
-	getProductTypeValueId,
-	getProductTypeValueMetadata,
-	getSDKVersionMetadata,
-	getSDKVersionValueId,
 	inclusionTimeouts,
 	KEXFailType,
 	KEXSchemes,
+	ManufacturerSpecificCCValues,
 	Security2CCKEXFail,
 	Security2CCKEXSet,
 	Security2CCNetworkKeyGet,
@@ -20,6 +11,7 @@ import {
 	Security2CCPublicKeyReport,
 	Security2CCTransferEnd,
 	utils as ccUtils,
+	VersionCCValues,
 	type AssociationAddress,
 	type AssociationGroup,
 } from "@zwave-js/cc";
@@ -994,37 +986,46 @@ export class ZWaveController extends TypedEventEmitter<ControllerEventCallbacks>
 		// Set manufacturer information for the controller node
 		const controllerValueDB = this.valueDB;
 		controllerValueDB.setMetadata(
-			getManufacturerIdValueId(),
-			getManufacturerIdValueMetadata(),
+			ManufacturerSpecificCCValues.manufacturerId.id,
+			ManufacturerSpecificCCValues.manufacturerId.meta,
 		);
 		controllerValueDB.setMetadata(
-			getProductTypeValueId(),
-			getProductTypeValueMetadata(),
+			ManufacturerSpecificCCValues.productType.id,
+			ManufacturerSpecificCCValues.productType.meta,
 		);
 		controllerValueDB.setMetadata(
-			getProductIdValueId(),
-			getProductIdValueMetadata(),
+			ManufacturerSpecificCCValues.productId.id,
+			ManufacturerSpecificCCValues.productId.meta,
 		);
 		controllerValueDB.setValue(
-			getManufacturerIdValueId(),
+			ManufacturerSpecificCCValues.manufacturerId.id,
 			this._manufacturerId,
 		);
-		controllerValueDB.setValue(getProductTypeValueId(), this._productType);
-		controllerValueDB.setValue(getProductIdValueId(), this._productId);
+		controllerValueDB.setValue(
+			ManufacturerSpecificCCValues.productType.id,
+			this._productType,
+		);
+		controllerValueDB.setValue(
+			ManufacturerSpecificCCValues.productId.id,
+			this._productId,
+		);
 
 		// Set firmware version information for the controller node
 		controllerValueDB.setMetadata(
-			getFirmwareVersionsValueId(),
-			getFirmwareVersionsMetadata(),
+			VersionCCValues.firmwareVersions.id,
+			VersionCCValues.firmwareVersions.meta,
 		);
-		controllerValueDB.setValue(getFirmwareVersionsValueId(), [
+		controllerValueDB.setValue(VersionCCValues.firmwareVersions.id, [
 			this._firmwareVersion,
 		]);
 		controllerValueDB.setMetadata(
-			getSDKVersionValueId(),
-			getSDKVersionMetadata(),
+			VersionCCValues.sdkVersion.id,
+			VersionCCValues.sdkVersion.meta,
+		);
+		controllerValueDB.setValue(
+			VersionCCValues.sdkVersion.id,
+			this._sdkVersion,
 		);
-		controllerValueDB.setValue(getSDKVersionValueId(), this._sdkVersion);
 
 		if (
 			this.type !== ZWaveLibraryTypes["Bridge Controller"] &&
diff --git a/packages/zwave-js/src/lib/driver/Driver.ts b/packages/zwave-js/src/lib/driver/Driver.ts
index 587539370f9..bf71c632471 100644
--- a/packages/zwave-js/src/lib/driver/Driver.ts
+++ b/packages/zwave-js/src/lib/driver/Driver.ts
@@ -6,7 +6,6 @@ import {
 	DeviceResetLocallyCCNotification,
 	FirmwareUpdateStatus,
 	getImplementedVersion,
-	getWakeUpIntervalValueId,
 	ICommandClassContainer,
 	InvalidCC,
 	isCommandClassContainer,
@@ -32,6 +31,7 @@ import {
 	TransportServiceCCSubsequentSegment,
 	TransportServiceTimeouts,
 	WakeUpCCNoMoreInformation,
+	WakeUpCCValues,
 } from "@zwave-js/cc";
 import {
 	ConfigManager,
@@ -4235,7 +4235,7 @@ ${handlers.length} left`,
 			!this.hasPendingMessages(node)
 		) {
 			const wakeUpInterval = node.getValue<number>(
-				getWakeUpIntervalValueId(),
+				WakeUpCCValues.wakeUpInterval.id,
 			);
 			// GH#2179: when a device only wakes up manually, don't send it back to sleep
 			// Best case, the user wanted to interact with it.
diff --git a/packages/zwave-js/src/lib/node/Endpoint.ts b/packages/zwave-js/src/lib/node/Endpoint.ts
index 7be8f93a5ce..827ce372deb 100644
--- a/packages/zwave-js/src/lib/node/Endpoint.ts
+++ b/packages/zwave-js/src/lib/node/Endpoint.ts
@@ -7,10 +7,7 @@ import {
 	CommandClass,
 	getCommandClassStatic,
 } from "@zwave-js/cc";
-import {
-	getInstallerIconValueId,
-	getUserIconValueId,
-} from "@zwave-js/cc/ZWavePlusCC";
+import { ZWavePlusCCValues } from "@zwave-js/cc/ZWavePlusCC";
 import type { IZWaveEndpoint } from "@zwave-js/core";
 import {
 	actuatorCCs,
@@ -481,12 +478,14 @@ export class Endpoint implements IZWaveEndpoint {
 	/** Z-Wave+ Icon (for management) */
 	public get installerIcon(): number | undefined {
 		return this.getNodeUnsafe()?.getValue(
-			getInstallerIconValueId(this.index),
+			ZWavePlusCCValues.installerIcon.endpoint(this.index),
 		);
 	}
 
 	/** Z-Wave+ Icon (for end users) */
 	public get userIcon(): number | undefined {
-		return this.getNodeUnsafe()?.getValue(getUserIconValueId(this.index));
+		return this.getNodeUnsafe()?.getValue(
+			ZWavePlusCCValues.userIcon.endpoint(this.index),
+		);
 	}
 }
diff --git a/packages/zwave-js/src/lib/node/Node.test.ts b/packages/zwave-js/src/lib/node/Node.test.ts
index b1f1e4d3bb9..b36947fd8f5 100644
--- a/packages/zwave-js/src/lib/node/Node.test.ts
+++ b/packages/zwave-js/src/lib/node/Node.test.ts
@@ -1809,26 +1809,14 @@ describe("lib/node/Node", () => {
 			});
 		});
 
-		it("dynamic metadata is merged with static metadata", () => {
+		it("writing to the value DB overwrites the statically defined metadata", () => {
 			// Create dynamic metadata
 			node.valueDB.setMetadata(valueId, ValueMetadata.WriteOnlyInt32);
 
 			const currentValueMeta = node.getValueMetadata(valueId);
 
 			// The label should be preserved from the static metadata
-			expect(currentValueMeta).toMatchObject({ label: "Current value" });
-		});
-
-		it("dynamic metadata is prioritized", () => {
-			// Update the dynamic metadata
-			node.valueDB.setMetadata(valueId, ValueMetadata.WriteOnlyInt32);
-
-			const currentValueMeta = node.getValueMetadata(valueId);
-
-			// But the dynamic metadata properties are preferred over statically defined ones
-			expect(currentValueMeta).toMatchObject(
-				ValueMetadata.WriteOnlyInt32,
-			);
+			expect(currentValueMeta).toEqual(ValueMetadata.WriteOnlyInt32);
 		});
 	});
 
diff --git a/packages/zwave-js/src/lib/node/Node.ts b/packages/zwave-js/src/lib/node/Node.ts
index a5e393199e3..a343c44caf5 100644
--- a/packages/zwave-js/src/lib/node/Node.ts
+++ b/packages/zwave-js/src/lib/node/Node.ts
@@ -8,7 +8,7 @@ import {
 	FirmwareUpdateCapabilities,
 	FirmwareUpdateRequestStatus,
 	FirmwareUpdateStatus,
-	getCCValueMetadata,
+	getCCValues,
 	isCommandClassContainer,
 	MultilevelSwitchCommand,
 	PollValueImplementation,
@@ -18,21 +18,19 @@ import {
 	ZWavePlusNodeType,
 	ZWavePlusRoleType,
 } from "@zwave-js/cc";
-import { getHasLifelineValueId } from "@zwave-js/cc/AssociationCC";
+import { AssociationCCValues } from "@zwave-js/cc/AssociationCC";
 import {
 	BasicCC,
 	BasicCCReport,
 	BasicCCSet,
-	getCompatEventValueId as getBasicCCCompatEventValueId,
-	getCurrentValueValueId as getBasicCCCurrentValueValueId,
+	BasicCCValues,
 } from "@zwave-js/cc/BasicCC";
 import {
 	CentralSceneCCNotification,
-	getSceneValueId,
-	getSlowRefreshValueId,
+	CentralSceneCCValues,
 } from "@zwave-js/cc/CentralSceneCC";
 import { ClockCCReport } from "@zwave-js/cc/ClockCC";
-import { getCurrentModeValueId as getCurrentLockModeValueId } from "@zwave-js/cc/DoorLockCC";
+import { DoorLockCCValues } from "@zwave-js/cc/DoorLockCC";
 import { EntryControlCCNotification } from "@zwave-js/cc/EntryControlCC";
 import {
 	FirmwareUpdateMetaDataCC,
@@ -41,32 +39,22 @@ import {
 	FirmwareUpdateMetaDataCCStatusReport,
 } from "@zwave-js/cc/FirmwareUpdateMetaDataCC";
 import { HailCC } from "@zwave-js/cc/HailCC";
-import { getLockedValueId } from "@zwave-js/cc/LockCC";
+import { LockCCValues } from "@zwave-js/cc/LockCC";
+import { ManufacturerSpecificCCValues } from "@zwave-js/cc/ManufacturerSpecificCC";
+import { MultiChannelCCValues } from "@zwave-js/cc/MultiChannelCC";
 import {
-	getManufacturerIdValueId,
-	getProductIdValueId,
-	getProductTypeValueId,
-} from "@zwave-js/cc/ManufacturerSpecificCC";
-import {
-	getEndpointCCsValueId,
-	getEndpointDeviceClassValueId,
-} from "@zwave-js/cc/MultiChannelCC";
-import {
-	getCompatEventValueId as getMultilevelSwitchCCCompatEventValueId,
 	MultilevelSwitchCC,
 	MultilevelSwitchCCSet,
 	MultilevelSwitchCCStartLevelChange,
 	MultilevelSwitchCCStopLevelChange,
+	MultilevelSwitchCCValues,
 } from "@zwave-js/cc/MultilevelSwitchCC";
-import {
-	getNodeLocationValueId,
-	getNodeNameValueId,
-} from "@zwave-js/cc/NodeNamingCC";
+import { NodeNamingAndLocationCCValues } from "@zwave-js/cc/NodeNamingCC";
 import {
 	getNotificationValueMetadata,
-	getNotificationValueMetadataUnknownType,
 	NotificationCC,
 	NotificationCCReport,
+	NotificationCCValues,
 } from "@zwave-js/cc/NotificationCC";
 import { PowerlevelCCTestNodeReport } from "@zwave-js/cc/PowerlevelCC";
 import { SceneActivationCCSet } from "@zwave-js/cc/SceneActivationCC";
@@ -78,21 +66,12 @@ import {
 	SecurityCCNonceGet,
 	SecurityCCNonceReport,
 } from "@zwave-js/cc/SecurityCC";
+import { VersionCCValues } from "@zwave-js/cc/VersionCC";
 import {
-	getFirmwareVersionsValueId,
-	getSDKVersionValueId,
-} from "@zwave-js/cc/VersionCC";
-import {
-	getWakeUpIntervalValueId,
-	getWakeUpOnDemandSupportedValueId,
+	WakeUpCCValues,
 	WakeUpCCWakeUpNotification,
 } from "@zwave-js/cc/WakeUpCC";
-import {
-	getNodeTypeValueId,
-	getRoleTypeValueId,
-	getZWavePlusVersionValueId,
-	ZWavePlusCCGet,
-} from "@zwave-js/cc/ZWavePlusCC";
+import { ZWavePlusCCGet, ZWavePlusCCValues } from "@zwave-js/cc/ZWavePlusCC";
 import type {
 	DeviceConfig,
 	Notification,
@@ -368,11 +347,9 @@ export class ZWaveNode
 			this,
 			arg.commandClass,
 		);
-		const isInternalValue = ccInstance?.isInternalValue(
-			arg.property as any,
-		);
+		const isInternalValue = ccInstance?.isInternalValue(arg);
 		// Check whether this value change may be logged
-		const isSecretValue = !!ccInstance?.isSecretValue(arg.property as any);
+		const isSecretValue = !!ccInstance?.isSecretValue(arg);
 		if (
 			!isSecretValue &&
 			(arg as any as ValueUpdatedArgs).source !== "driver"
@@ -662,20 +639,22 @@ export class ZWaveNode
 	}
 
 	public get manufacturerId(): number | undefined {
-		return this.getValue(getManufacturerIdValueId());
+		return this.getValue(ManufacturerSpecificCCValues.manufacturerId.id);
 	}
 
 	public get productId(): number | undefined {
-		return this.getValue(getProductIdValueId());
+		return this.getValue(ManufacturerSpecificCCValues.productId.id);
 	}
 
 	public get productType(): number | undefined {
-		return this.getValue(getProductTypeValueId());
+		return this.getValue(ManufacturerSpecificCCValues.productType.id);
 	}
 
 	public get firmwareVersion(): string | undefined {
 		// We're only interested in the first (main) firmware
-		const ret = this.getValue<string[]>(getFirmwareVersionsValueId())?.[0];
+		const ret = this.getValue<string[]>(
+			VersionCCValues.firmwareVersions.id,
+		)?.[0];
 
 		// Special case for the official 700 series firmwares which are aligned with the SDK version
 		// We want to work with the full x.y.z firmware version here.
@@ -690,23 +669,23 @@ export class ZWaveNode
 	}
 
 	public get sdkVersion(): string | undefined {
-		return this.getValue(getSDKVersionValueId());
+		return this.getValue(VersionCCValues.sdkVersion.id);
 	}
 
 	public get zwavePlusVersion(): number | undefined {
-		return this.getValue(getZWavePlusVersionValueId());
+		return this.getValue(ZWavePlusCCValues.zwavePlusVersion.id);
 	}
 
 	public get zwavePlusNodeType(): ZWavePlusNodeType | undefined {
-		return this.getValue(getNodeTypeValueId());
+		return this.getValue(ZWavePlusCCValues.nodeType.id);
 	}
 
 	public get zwavePlusRoleType(): ZWavePlusRoleType | undefined {
-		return this.getValue(getRoleTypeValueId());
+		return this.getValue(ZWavePlusCCValues.roleType.id);
 	}
 
 	public get supportsWakeUpOnDemand(): boolean | undefined {
-		return this.getValue(getWakeUpOnDemandSupportedValueId());
+		return this.getValue(WakeUpCCValues.wakeUpOnDemandSupported.id);
 	}
 
 	/**
@@ -716,13 +695,16 @@ export class ZWaveNode
 	 * the `commandClasses` API.
 	 */
 	public get name(): string | undefined {
-		return this.getValue(getNodeNameValueId());
+		return this.getValue(NodeNamingAndLocationCCValues.name.id);
 	}
 	public set name(value: string | undefined) {
 		if (value != undefined) {
-			this._valueDB.setValue(getNodeNameValueId(), value);
+			this._valueDB.setValue(
+				NodeNamingAndLocationCCValues.name.id,
+				value,
+			);
 		} else {
-			this._valueDB.removeValue(getNodeNameValueId());
+			this._valueDB.removeValue(NodeNamingAndLocationCCValues.name.id);
 		}
 	}
 
@@ -733,13 +715,18 @@ export class ZWaveNode
 	 * the `commandClasses` API.
 	 */
 	public get location(): string | undefined {
-		return this.getValue(getNodeLocationValueId());
+		return this.getValue(NodeNamingAndLocationCCValues.location.id);
 	}
 	public set location(value: string | undefined) {
 		if (value != undefined) {
-			this._valueDB.setValue(getNodeLocationValueId(), value);
+			this._valueDB.setValue(
+				NodeNamingAndLocationCCValues.location.id,
+				value,
+			);
 		} else {
-			this._valueDB.removeValue(getNodeLocationValueId());
+			this._valueDB.removeValue(
+				NodeNamingAndLocationCCValues.location.id,
+			);
 		}
 	}
 
@@ -801,13 +788,22 @@ export class ZWaveNode
 	 * This can be used to enhance the user interface of an application
 	 */
 	public getValueMetadata(valueId: ValueID): ValueMetadata {
-		const { commandClass, property } = valueId;
-		return {
-			// Merge static metadata
-			...getCCValueMetadata(commandClass, property),
-			// with potentially existing dynamic metadata
-			...this._valueDB.getMetadata(valueId),
-		};
+		// First attempt: look in the value DB
+		if (this._valueDB.hasMetadata(valueId)) {
+			return this._valueDB.getMetadata(valueId)!;
+		}
+
+		// Second attempt: check if a corresponding CC value is defined for this value ID
+		const definedCCValues = getCCValues(valueId.commandClass);
+		if (definedCCValues) {
+			const value = Object.values(definedCCValues).find((v) =>
+				v?.is(valueId),
+			);
+			if (value && typeof value !== "function") return value.meta;
+		}
+
+		// Default: Any
+		return ValueMetadata.Any;
 	}
 
 	/** Returns a list of all value names that are defined on all endpoints of this node */
@@ -1036,7 +1032,7 @@ export class ZWaveNode
 			generic: number;
 			specific: number;
 		}>(
-			getEndpointDeviceClassValueId(
+			MultiChannelCCValues.endpointDeviceClass.endpoint(
 				this.endpointsHaveIdenticalCapabilities ? 1 : index,
 			),
 		);
@@ -1054,7 +1050,7 @@ export class ZWaveNode
 
 	private getEndpointCCs(index: number): CommandClasses[] | undefined {
 		const ret = this.getValue(
-			getEndpointCCsValueId(
+			MultiChannelCCValues.endpointCCs.endpoint(
 				this.endpointsHaveIdenticalCapabilities ? 1 : index,
 			),
 		);
@@ -1910,7 +1906,7 @@ protocol version:      ${this.protocolVersion}`;
 		return (
 			this.interviewStage === InterviewStage.Complete &&
 			!this.supportsCC(CommandClasses["Z-Wave Plus Info"]) &&
-			!this.valueDB.getValue(getHasLifelineValueId())
+			!this.valueDB.getValue(AssociationCCValues.hasLifeline.id)
 		);
 	}
 
@@ -2448,7 +2444,7 @@ protocol version:      ${this.protocolVersion}`;
 			sceneNumber: number,
 			key: CentralSceneKeys,
 		): void => {
-			const valueId = getSceneValueId(sceneNumber);
+			const valueId = CentralSceneCCValues.scene(sceneNumber).id;
 			this.valueDB.setValue(valueId, key, { stateful: false });
 		};
 
@@ -2474,6 +2470,9 @@ protocol version:      ${this.protocolVersion}`;
 			forceKeyUp();
 		}
 
+		const slowRefreshValueId = CentralSceneCCValues.slowRefresh.endpoint(
+			this.index,
+		);
 		if (command.keyAttribute === CentralSceneKeys.KeyHeldDown) {
 			// Set or refresh timer to force a release of the key
 			this.centralSceneForcedKeyUp = false;
@@ -2484,7 +2483,7 @@ protocol version:      ${this.protocolVersion}`;
 			// slow refresh node. We use the stored value for fallback behavior
 			const slowRefresh =
 				command.slowRefresh ??
-				this.valueDB.getValue<boolean>(getSlowRefreshValueId());
+				this.valueDB.getValue<boolean>(slowRefreshValueId);
 			this.centralSceneKeyHeldDownContext = {
 				sceneNumber: command.sceneNumber,
 				// Unref'ing long running timers allows the process to exit mid-timeout
@@ -2501,7 +2500,7 @@ protocol version:      ${this.protocolVersion}`;
 			} else if (this.centralSceneForcedKeyUp) {
 				// If we timed out and the controller subsequently receives a Key Released Notification,
 				// we SHOULD consider the sending node to be operating with the Slow Refresh capability enabled.
-				this.valueDB.setValue(getSlowRefreshValueId(), true);
+				this.valueDB.setValue(slowRefreshValueId, true);
 				// Do not raise the duplicate event
 				return;
 			}
@@ -2541,7 +2540,7 @@ protocol version:      ${this.protocolVersion}`;
 		if (this.lastWakeUp) {
 			// we've already measured the wake up interval, so we can check whether a refresh is necessary
 			const wakeUpInterval =
-				this.getValue<number>(getWakeUpIntervalValueId()) ?? 1;
+				this.getValue<number>(WakeUpCCValues.wakeUpInterval.id) ?? 1;
 			// The wakeup interval is specified in seconds. Also add 5 minutes tolerance to avoid
 			// unnecessary queries since there might be some delay. A wakeup interval of 0 means manual wakeup,
 			// so the interval shouldn't be verified
@@ -2733,7 +2732,7 @@ protocol version:      ${this.protocolVersion}`;
 					message: "treating BasicCC::Set as a value event",
 				});
 				this._valueDB.setValue(
-					getBasicCCCompatEventValueId(command.endpointIndex),
+					BasicCCValues.compatEvent.endpoint(command.endpointIndex),
 					command.targetValue,
 					{
 						stateful: false,
@@ -2760,7 +2759,9 @@ protocol version:      ${this.protocolVersion}`;
 				if (!didSetMappedValue) {
 					// Basic Set commands cannot store their value automatically, so store the values manually
 					this._valueDB.setValue(
-						getBasicCCCurrentValueValueId(command.endpointIndex),
+						BasicCCValues.currentValue.endpoint(
+							command.endpointIndex,
+						),
 						command.targetValue,
 					);
 					// Since the node sent us a Basic command, we are sure that it is at least controlled
@@ -2783,7 +2784,9 @@ protocol version:      ${this.protocolVersion}`;
 				message: "treating MultiLevelSwitchCCSet::Set as a value event",
 			});
 			this._valueDB.setValue(
-				getMultilevelSwitchCCCompatEventValueId(command.endpointIndex),
+				MultilevelSwitchCCValues.compatEvent.endpoint(
+					command.endpointIndex,
+				),
 				command.targetValue,
 				{
 					stateful: false,
@@ -2897,17 +2900,6 @@ protocol version:      ${this.protocolVersion}`;
 				this.valueDB.setMetadata(valueId, metadata);
 			}
 		};
-		const ensureValueMetadataUnknownType = (
-			valueId: ValueID,
-			notificationConfig: Notification,
-		) => {
-			if (command.version === 2 && !this.valueDB.hasMetadata(valueId)) {
-				const metadata = getNotificationValueMetadataUnknownType(
-					notificationConfig.id,
-				);
-				this.valueDB.setMetadata(valueId, metadata);
-			}
-		};
 
 		// Look up the received notification in the config
 		const notificationConfig = this.driver.configManager.lookupNotification(
@@ -2916,7 +2908,7 @@ protocol version:      ${this.protocolVersion}`;
 
 		if (notificationConfig) {
 			// This is a known notification (status or event)
-			const property = notificationConfig.name;
+			const notificationName = notificationConfig.name;
 
 			/** Returns a single notification state to idle */
 			const setStateIdle = (prevValue: number): void => {
@@ -2926,13 +2918,12 @@ protocol version:      ${this.protocolVersion}`;
 				// Some properties may not be reset to idle
 				if (!valueConfig.idle) return;
 
-				const propertyKey = valueConfig.variableName;
-				const valueId: ValueID = {
-					commandClass: command.ccId,
-					endpoint: command.endpointIndex,
-					property,
-					propertyKey,
-				};
+				const variableName = valueConfig.variableName;
+				const valueId = NotificationCCValues.notificationVariable(
+					notificationName,
+					variableName,
+				).endpoint(command.endpointIndex);
+
 				// Since the node has reset the notification itself, we don't need the idle reset
 				this.clearNotificationIdleReset(valueId);
 				extendValueMetadata(valueId, notificationConfig, valueConfig);
@@ -2955,7 +2946,7 @@ protocol version:      ${this.protocolVersion}`;
 						.filter(
 							(v) =>
 								(v.endpoint || 0) === command.endpointIndex &&
-								v.property === property &&
+								v.property === notificationName &&
 								typeof v.value === "number" &&
 								v.value !== 0,
 						);
@@ -2966,7 +2957,6 @@ protocol version:      ${this.protocolVersion}`;
 				return;
 			}
 
-			let propertyKey: string;
 			// Find out which property we need to update
 			const valueConfig = notificationConfig.lookupValue(value);
 
@@ -2975,12 +2965,9 @@ protocol version:      ${this.protocolVersion}`;
 
 			let allowIdleReset: boolean;
 			if (!valueConfig) {
-				// This is an unknown value, collect it in an unknown bucket
-				propertyKey = "unknown";
 				// We don't know what this notification refers to, so we don't force a reset
 				allowIdleReset = false;
 			} else if (valueConfig.type === "state") {
-				propertyKey = valueConfig.variableName;
 				allowIdleReset = valueConfig.idle;
 			} else {
 				this.emit("notification", this, CommandClasses.Notification, {
@@ -2994,16 +2981,28 @@ protocol version:      ${this.protocolVersion}`;
 			}
 
 			// Now that we've gathered all we need to know, update the value in our DB
-			const valueId: ValueID = {
-				commandClass: command.ccId,
-				endpoint: command.endpointIndex,
-				property,
-				propertyKey,
-			};
+			let valueId: ValueID;
 			if (valueConfig) {
+				valueId = NotificationCCValues.notificationVariable(
+					notificationName,
+					valueConfig.variableName,
+				).endpoint(command.endpointIndex);
+
 				extendValueMetadata(valueId, notificationConfig, valueConfig);
 			} else {
-				ensureValueMetadataUnknownType(valueId, notificationConfig);
+				// Collect unknown values in an "unknown" bucket
+				const unknownValue =
+					NotificationCCValues.unknownNotificationVariable(
+						command.notificationType,
+						notificationName,
+					);
+				valueId = unknownValue.endpoint(command.endpointIndex);
+
+				if (command.version === 2) {
+					if (!this.valueDB.hasMetadata(valueId)) {
+						this.valueDB.setMetadata(valueId, unknownValue.meta);
+					}
+				}
 			}
 			this.valueDB.setValue(valueId, value);
 
@@ -3021,12 +3020,10 @@ protocol version:      ${this.protocolVersion}`;
 			}
 		} else {
 			// This is an unknown notification
-			const property = `UNKNOWN_${num2hex(command.notificationType)}`;
-			const valueId: ValueID = {
-				commandClass: command.ccId,
-				endpoint: command.endpointIndex,
-				property,
-			};
+			const valueId = NotificationCCValues.unknownNotificationType(
+				command.notificationType,
+			).endpoint(command.endpointIndex);
+
 			this.valueDB.setValue(valueId, command.notificationEvent);
 			// We don't know what this notification refers to, so we don't force a reset
 		}
@@ -3055,13 +3052,15 @@ protocol version:      ${this.protocolVersion}`;
 			// Update the current lock status
 			if (this.supportsCC(CommandClasses["Door Lock"])) {
 				this.valueDB.setValue(
-					getCurrentLockModeValueId(command.endpointIndex),
+					DoorLockCCValues.currentMode.endpoint(
+						command.endpointIndex,
+					),
 					isLocked ? DoorLockMode.Secured : DoorLockMode.Unsecured,
 				);
 			}
 			if (this.supportsCC(CommandClasses.Lock)) {
 				this.valueDB.setValue(
-					getLockedValueId(command.endpointIndex),
+					LockCCValues.locked.endpoint(command.endpointIndex),
 					isLocked,
 				);
 			}
diff --git a/packages/zwave-js/src/lib/node/utils.ts b/packages/zwave-js/src/lib/node/utils.ts
index b05b5febd68..6d195f81d3c 100644
--- a/packages/zwave-js/src/lib/node/utils.ts
+++ b/packages/zwave-js/src/lib/node/utils.ts
@@ -1,11 +1,5 @@
 import { CommandClass } from "@zwave-js/cc";
-import {
-	getAggregatedCountValueId,
-	getCountIsDynamicValueId,
-	getEndpointIndizesValueId,
-	getIdenticalCapabilitiesValueId,
-	getIndividualCountValueId,
-} from "@zwave-js/cc/MultiChannelCC";
+import { MultiChannelCCValues } from "@zwave-js/cc/MultiChannelCC";
 import {
 	allCCs,
 	applicationCCs,
@@ -43,28 +37,44 @@ export function endpointCountIsDynamic(
 	applHost: ZWaveApplicationHost,
 	node: IZWaveNode,
 ): boolean | undefined {
-	return getValue(applHost, node, getCountIsDynamicValueId());
+	return getValue(
+		applHost,
+		node,
+		MultiChannelCCValues.endpointCountIsDynamic.id,
+	);
 }
 
 export function endpointsHaveIdenticalCapabilities(
 	applHost: ZWaveApplicationHost,
 	node: IZWaveNode,
 ): boolean | undefined {
-	return getValue(applHost, node, getIdenticalCapabilitiesValueId());
+	return getValue(
+		applHost,
+		node,
+		MultiChannelCCValues.endpointsHaveIdenticalCapabilities.id,
+	);
 }
 
 export function getIndividualEndpointCount(
 	applHost: ZWaveApplicationHost,
 	node: IZWaveNode,
 ): number | undefined {
-	return getValue(applHost, node, getIndividualCountValueId());
+	return getValue(
+		applHost,
+		node,
+		MultiChannelCCValues.individualEndpointCount.id,
+	);
 }
 
 export function getAggregatedEndpointCount(
 	applHost: ZWaveApplicationHost,
 	node: IZWaveNode,
 ): number | undefined {
-	return getValue(applHost, node, getAggregatedCountValueId());
+	return getValue(
+		applHost,
+		node,
+		MultiChannelCCValues.aggregatedEndpointCount.id,
+	);
 }
 
 export function getEndpointCount(
@@ -82,7 +92,12 @@ export function setIndividualEndpointCount(
 	node: IZWaveNode,
 	count: number,
 ): void {
-	setValue(applHost, node, getIndividualCountValueId(), count);
+	setValue(
+		applHost,
+		node,
+		MultiChannelCCValues.individualEndpointCount.id,
+		count,
+	);
 }
 
 export function setAggregatedEndpointCount(
@@ -90,14 +105,23 @@ export function setAggregatedEndpointCount(
 	node: IZWaveNode,
 	count: number,
 ): void {
-	setValue(applHost, node, getAggregatedCountValueId(), count);
+	setValue(
+		applHost,
+		node,
+		MultiChannelCCValues.aggregatedEndpointCount.id,
+		count,
+	);
 }
 
 export function getEndpointIndizes(
 	applHost: ZWaveApplicationHost,
 	node: IZWaveNode,
 ): number[] {
-	let ret = getValue<number[]>(applHost, node, getEndpointIndizesValueId());
+	let ret = getValue<number[]>(
+		applHost,
+		node,
+		MultiChannelCCValues.endpointIndizes.id,
+	);
 	if (!ret) {
 		// Endpoint indizes not stored, assume sequential endpoints
 		ret = [];
@@ -113,7 +137,7 @@ export function setEndpointIndizes(
 	node: IZWaveNode,
 	indizes: number[],
 ): void {
-	setValue(applHost, node, getEndpointIndizesValueId(), indizes);
+	setValue(applHost, node, MultiChannelCCValues.endpointIndizes.id, indizes);
 }
 
 export function isMultiChannelInterviewComplete(
diff --git a/packages/zwave-js/src/lib/serialapi/application/BridgeApplicationCommandRequest.test.ts b/packages/zwave-js/src/lib/serialapi/application/BridgeApplicationCommandRequest.test.ts
index 487c41274a5..636a1bad884 100644
--- a/packages/zwave-js/src/lib/serialapi/application/BridgeApplicationCommandRequest.test.ts
+++ b/packages/zwave-js/src/lib/serialapi/application/BridgeApplicationCommandRequest.test.ts
@@ -7,7 +7,7 @@ describe("BridgeApplicationCommandRequest", () => {
 	beforeAll(async () => {
 		host = createTestingHost();
 		await host.configManager.loadMeters();
-	});
+	}, 30000);
 
 	describe("regression tests", () => {
 		it("parsing without RSSI", async () => {
diff --git a/packages/zwave-js/src/lib/test/cc-specific/mapNotificationDoorLock.test.ts b/packages/zwave-js/src/lib/test/cc-specific/mapNotificationDoorLock.test.ts
index 1781e751c7a..4766155e828 100644
--- a/packages/zwave-js/src/lib/test/cc-specific/mapNotificationDoorLock.test.ts
+++ b/packages/zwave-js/src/lib/test/cc-specific/mapNotificationDoorLock.test.ts
@@ -1,5 +1,5 @@
 import { DoorLockMode } from "@zwave-js/cc";
-import { getCurrentModeValueId as getCurrentLockModeValueId } from "@zwave-js/cc/DoorLockCC";
+import { DoorLockCCValues } from "@zwave-js/cc/DoorLockCC";
 import { NotificationCCReport } from "@zwave-js/cc/NotificationCC";
 import { CommandClasses } from "@zwave-js/core";
 import type { ThrowingMap } from "@zwave-js/shared";
@@ -44,7 +44,7 @@ describe("map Notification CC to Door Lock CC", () => {
 	});
 
 	it("When receiving a NotificationCC::Report with a lock operation, the current value for Door Lock CC should be updated accordingly", () => {
-		const valueId = getCurrentLockModeValueId(0);
+		const valueId = DoorLockCCValues.currentMode.id;
 
 		let cmd = new NotificationCCReport(driver, {
 			nodeId: node2.id,
diff --git a/packages/zwave-js/src/lib/test/cc-specific/sceneActivationValueID.test.ts b/packages/zwave-js/src/lib/test/cc-specific/sceneActivationValueID.test.ts
index 6c4dd7a522c..96e6e0e59b5 100644
--- a/packages/zwave-js/src/lib/test/cc-specific/sceneActivationValueID.test.ts
+++ b/packages/zwave-js/src/lib/test/cc-specific/sceneActivationValueID.test.ts
@@ -1,3 +1,4 @@
+import "@zwave-js/cc";
 import { CommandClasses } from "@zwave-js/core";
 import type { ThrowingMap } from "@zwave-js/shared";
 import { MockController } from "@zwave-js/testing";
diff --git a/packages/zwave-js/src/lib/test/cc/BasicCC.test.ts b/packages/zwave-js/src/lib/test/cc/BasicCC.test.ts
index f0053d6c381..b2104fd174e 100644
--- a/packages/zwave-js/src/lib/test/cc/BasicCC.test.ts
+++ b/packages/zwave-js/src/lib/test/cc/BasicCC.test.ts
@@ -3,11 +3,18 @@ import {
 	BasicCCGet,
 	BasicCCReport,
 	BasicCCSet,
+	BasicCCValues,
 	BasicCommand,
-	getCCValueMetadata,
+	getCCValues,
 } from "@zwave-js/cc";
 import { CommandClasses } from "@zwave-js/core";
 import { createTestingHost } from "@zwave-js/host";
+import type { ThrowingMap } from "@zwave-js/shared";
+import { MockController } from "@zwave-js/testing";
+import { createDefaultMockControllerBehaviors } from "../../../Utils";
+import type { Driver } from "../../driver/Driver";
+import { createAndStartTestingDriver } from "../../driver/DriverMock";
+import { ZWaveNode } from "../../node/Node";
 import * as nodeUtils from "../../node/utils";
 import { createTestNode } from "../mocks";
 
@@ -95,31 +102,31 @@ describe("lib/commandclass/BasicCC => ", () => {
 		expect(basicCC.constructor).toBe(BasicCC);
 	});
 
-	it("the CC values should have the correct metadata", () => {
-		// Readonly, 0-99
-		const currentValueMeta = getCCValueMetadata(
-			CommandClasses.Basic,
-			"currentValue",
-		);
-		expect(currentValueMeta).toMatchObject({
-			readable: true,
-			writeable: false,
-			min: 0,
-			max: 99,
-		});
+	// it("the CC values should have the correct metadata", () => {
+	// 	// Readonly, 0-99
+	// 	const currentValueMeta = getCCValueMetadata(
+	// 		CommandClasses.Basic,
+	// 		"currentValue",
+	// 	);
+	// 	expect(currentValueMeta).toMatchObject({
+	// 		readable: true,
+	// 		writeable: false,
+	// 		min: 0,
+	// 		max: 99,
+	// 	});
 
-		// Writeable, 0-99
-		const targetValueMeta = getCCValueMetadata(
-			CommandClasses.Basic,
-			"targetValue",
-		);
-		expect(targetValueMeta).toMatchObject({
-			readable: true,
-			writeable: true,
-			min: 0,
-			max: 99,
-		});
-	});
+	// 	// Writeable, 0-99
+	// 	const targetValueMeta = getCCValueMetadata(
+	// 		CommandClasses.Basic,
+	// 		"targetValue",
+	// 	);
+	// 	expect(targetValueMeta).toMatchObject({
+	// 		readable: true,
+	// 		writeable: true,
+	// 		min: 0,
+	// 		max: 99,
+	// 	});
+	// });
 
 	describe("getDefinedValueIDs()", () => {
 		it("should include the target value for all endpoints except the node itself", () => {
@@ -160,6 +167,59 @@ describe("lib/commandclass/BasicCC => ", () => {
 		});
 	});
 
+	describe("getDefinedValueIDs() part 2", () => {
+		let driver: Driver;
+		let node2: ZWaveNode;
+		let controller: MockController;
+
+		beforeAll(async () => {
+			({ driver } = await createAndStartTestingDriver({
+				skipNodeInterview: true,
+				loadConfiguration: false,
+				beforeStartup(mockPort) {
+					controller = new MockController({ serial: mockPort });
+					controller.defineBehavior(
+						...createDefaultMockControllerBehaviors(),
+					);
+				},
+			}));
+			node2 = new ZWaveNode(2, driver);
+			(driver.controller.nodes as ThrowingMap<number, ZWaveNode>).set(
+				node2.id,
+				node2,
+			);
+
+			node2.addCC(CommandClasses.Basic, {
+				isSupported: true,
+			});
+		}, 30000);
+
+		afterAll(async () => {
+			await driver.destroy();
+		});
+
+		it("should NOT include the compat event value", () => {
+			const valueIDs = node2.getDefinedValueIDs();
+			expect(valueIDs.map(({ property }) => property)).not.toContain(
+				BasicCCValues.compatEvent.id.property,
+			);
+		});
+
+		it("except when the corresponding compat flag is set", () => {
+			// @ts-expect-error
+			node2["_deviceConfig"] = {
+				compat: {
+					treatBasicSetAsEvent: true,
+				},
+			};
+
+			const valueIDs = node2.getDefinedValueIDs();
+			expect(valueIDs.map(({ property }) => property)).toContain(
+				BasicCCValues.compatEvent.id.property,
+			);
+		});
+	});
+
 	describe("responses should be detected correctly", () => {
 		it("BasicCCSet should expect no response", () => {
 			const cc = new BasicCCSet(host, {
@@ -227,4 +287,17 @@ describe("lib/commandclass/BasicCC => ", () => {
 			expect(ccRequest.isExpectedCCResponse(ccResponse)).toBeFalse();
 		});
 	});
+
+	describe("Looking up CC values for a CC instance", () => {
+		it("should work", () => {
+			const cc = new BasicCCGet(host, {
+				nodeId: 2,
+			});
+			const values = getCCValues(cc) as typeof BasicCCValues;
+			expect(values.currentValue.id).toMatchObject({
+				commandClass: CommandClasses.Basic,
+				property: "currentValue",
+			});
+		});
+	});
 });
diff --git a/packages/zwave-js/src/lib/test/cc/DoorLockCC.test.ts b/packages/zwave-js/src/lib/test/cc/DoorLockCC.test.ts
index c37ad8f7112..c1c6764f107 100644
--- a/packages/zwave-js/src/lib/test/cc/DoorLockCC.test.ts
+++ b/packages/zwave-js/src/lib/test/cc/DoorLockCC.test.ts
@@ -11,12 +11,7 @@ import {
 	DoorLockMode,
 	DoorLockOperationType,
 } from "@zwave-js/cc";
-import {
-	getBoltSupportedValueId,
-	getDoorStatusValueId,
-	getDoorSupportedValueId,
-	getLatchSupportedValueId,
-} from "@zwave-js/cc/DoorLockCC";
+import { DoorLockCCValues } from "@zwave-js/cc/DoorLockCC";
 import { CommandClasses, Duration } from "@zwave-js/core";
 import { createTestingHost, TestingHost } from "@zwave-js/host";
 
@@ -37,15 +32,15 @@ describe("lib/commandclass/DoorLockCC => ", () => {
 
 		// Node 1 supports all Door Lock sensors
 		const valueDB1 = host.getValueDB(1);
-		valueDB1.setValue(getDoorSupportedValueId(0), true);
-		valueDB1.setValue(getBoltSupportedValueId(0), true);
-		valueDB1.setValue(getLatchSupportedValueId(0), true);
+		valueDB1.setValue(DoorLockCCValues.doorSupported.id, true);
+		valueDB1.setValue(DoorLockCCValues.boltSupported.id, true);
+		valueDB1.setValue(DoorLockCCValues.latchSupported.id, true);
 
 		// Node 2 doesn't support the door sensor
 		const valueDB2 = host.getValueDB(2);
-		valueDB2.setValue(getDoorSupportedValueId(0), false);
-		valueDB2.setValue(getBoltSupportedValueId(0), true);
-		valueDB2.setValue(getLatchSupportedValueId(0), true);
+		valueDB2.setValue(DoorLockCCValues.doorSupported.id, false);
+		valueDB2.setValue(DoorLockCCValues.boltSupported.id, true);
+		valueDB2.setValue(DoorLockCCValues.latchSupported.id, true);
 	});
 
 	it("the OperationGet command should serialize correctly", () => {
@@ -144,7 +139,9 @@ describe("lib/commandclass/DoorLockCC => ", () => {
 		expect(
 			host
 				.getValueDB(cc.nodeId as number)
-				.getValue(getDoorStatusValueId(cc.endpointIndex)),
+				.getValue(
+					DoorLockCCValues.doorStatus.endpoint(cc.endpointIndex),
+				),
 		).toBe(undefined);
 		expect(cc.targetMode).toBe(DoorLockMode.Secured);
 		expect(cc.duration).toEqual(new Duration(1, "seconds"));
diff --git a/packages/zwave-js/src/lib/test/cc/Fibaro.test.ts b/packages/zwave-js/src/lib/test/cc/Fibaro.test.ts
index cc7939a9715..e46a97cc211 100644
--- a/packages/zwave-js/src/lib/test/cc/Fibaro.test.ts
+++ b/packages/zwave-js/src/lib/test/cc/Fibaro.test.ts
@@ -3,9 +3,7 @@ import {
 	FibaroVenetianBlindCCGet,
 	FibaroVenetianBlindCCReport,
 	FibaroVenetianBlindCCSet,
-	getManufacturerIdValueId,
-	getProductIdValueId,
-	getProductTypeValueId,
+	ManufacturerSpecificCCValues,
 } from "@zwave-js/cc";
 import {
 	FibaroCCIDs,
@@ -35,7 +33,10 @@ describe("lib/commandclass/manufacturerProprietary/Fibaro => ", () => {
 
 	beforeAll(async () => {
 		const manufacturerId = 0x10f;
-		node2.valueDB.setValue(getManufacturerIdValueId(), manufacturerId);
+		node2.valueDB.setValue(
+			ManufacturerSpecificCCValues.manufacturerId.id,
+			manufacturerId,
+		);
 
 		node2.addCC(CommandClasses["Manufacturer Proprietary"], {
 			isSupported: true,
@@ -133,8 +134,14 @@ describe("lib/commandclass/manufacturerProprietary/Fibaro => ", () => {
 			const productId = 0x1000;
 			const firmwareVersion = "25.25";
 
-			node2.valueDB.setValue(getProductTypeValueId(), productType);
-			node2.valueDB.setValue(getProductIdValueId(), productId);
+			node2.valueDB.setValue(
+				ManufacturerSpecificCCValues.productType.id,
+				productType,
+			);
+			node2.valueDB.setValue(
+				ManufacturerSpecificCCValues.productId.id,
+				productId,
+			);
 			node2.valueDB.setValue(
 				{
 					commandClass: CommandClasses.Version,
diff --git a/packages/zwave-js/src/lib/test/cc/HumidityControlModeCC.test.ts b/packages/zwave-js/src/lib/test/cc/HumidityControlModeCC.test.ts
index ca1e09e56d4..c6d3cc10860 100644
--- a/packages/zwave-js/src/lib/test/cc/HumidityControlModeCC.test.ts
+++ b/packages/zwave-js/src/lib/test/cc/HumidityControlModeCC.test.ts
@@ -1,5 +1,4 @@
 import {
-	getCCValueMetadata,
 	HumidityControlMode,
 	HumidityControlModeCC,
 	HumidityControlModeCCGet,
@@ -9,6 +8,7 @@ import {
 	HumidityControlModeCCSupportedReport,
 	HumidityControlModeCommand,
 } from "@zwave-js/cc";
+import { HumidityControlModeCCValues } from "@zwave-js/cc/HumidityControlModeCC";
 import { CommandClasses, enumValuesToMetadataStates } from "@zwave-js/core";
 import { createTestingHost } from "@zwave-js/host";
 import { assertCC } from "../assertCC";
@@ -95,15 +95,16 @@ describe("lib/commandclass/HumidityControlModeCC => ", () => {
 				HumidityControlMode.Auto, // current value
 			]),
 		);
-		new HumidityControlModeCCReport(host, {
+		const cc = new HumidityControlModeCCReport(host, {
 			nodeId,
 			data: ccData,
 		});
+		cc.persistValues(host);
+
+		const currentValueMeta = host
+			.getValueDB(nodeId)
+			.getMetadata(HumidityControlModeCCValues.mode.id);
 
-		const currentValueMeta = getCCValueMetadata(
-			CommandClasses["Humidity Control Mode"],
-			"mode",
-		);
 		expect(currentValueMeta).toMatchObject({
 			states: enumValuesToMetadataStates(HumidityControlMode),
 			label: "Humidity control mode",
@@ -149,15 +150,16 @@ describe("lib/commandclass/HumidityControlModeCC => ", () => {
 					(1 << HumidityControlMode.Auto),
 			]),
 		);
-		new HumidityControlModeCCSupportedReport(host, {
+		const cc = new HumidityControlModeCCSupportedReport(host, {
 			nodeId,
 			data: ccData,
 		});
+		cc.persistValues(host);
+
+		const currentValueMeta = host
+			.getValueDB(nodeId)
+			.getMetadata(HumidityControlModeCCValues.mode.id);
 
-		const currentValueMeta = getCCValueMetadata(
-			CommandClasses["Humidity Control Mode"],
-			"mode",
-		);
 		expect(currentValueMeta).toMatchObject({
 			states: {
 				0: "Off",
@@ -231,24 +233,24 @@ describe("lib/commandclass/HumidityControlModeCC => ", () => {
 			expect(currentValue).toEqual(HumidityControlMode.Auto);
 		});
 
-		it("should set mode metadata", async () => {
-			const cc = node.createCCInstance(
-				CommandClasses["Humidity Control Mode"],
-			)!;
-			await cc.interview(host);
+		// it("should set mode metadata", async () => {
+		// 	const cc = node.createCCInstance(
+		// 		CommandClasses["Humidity Control Mode"],
+		// 	)!;
+		// 	await cc.interview(host);
 
-			const currentValueMeta = getCCValueMetadata(
-				CommandClasses["Humidity Control Mode"],
-				"mode",
-			);
-			expect(currentValueMeta).toMatchObject({
-				states: {
-					0: "Off",
-					1: "Humidify",
-					3: "Auto",
-				},
-				label: "Humidity control mode",
-			});
-		});
+		// 	const currentValueMeta = getCCValueMetadata(
+		// 		CommandClasses["Humidity Control Mode"],
+		// 		"mode",
+		// 	);
+		// 	expect(currentValueMeta).toMatchObject({
+		// 		states: {
+		// 			0: "Off",
+		// 			1: "Humidify",
+		// 			3: "Auto",
+		// 		},
+		// 		label: "Humidity control mode",
+		// 	});
+		// });
 	});
 });
diff --git a/packages/zwave-js/src/lib/test/cc/HumidityControlOperatingStateCC.test.ts b/packages/zwave-js/src/lib/test/cc/HumidityControlOperatingStateCC.test.ts
index 89da7376c38..54bde345d62 100644
--- a/packages/zwave-js/src/lib/test/cc/HumidityControlOperatingStateCC.test.ts
+++ b/packages/zwave-js/src/lib/test/cc/HumidityControlOperatingStateCC.test.ts
@@ -1,12 +1,11 @@
 import {
-	getCCValueMetadata,
 	HumidityControlOperatingState,
 	HumidityControlOperatingStateCC,
 	HumidityControlOperatingStateCCGet,
 	HumidityControlOperatingStateCCReport,
 	HumidityControlOperatingStateCommand,
 } from "@zwave-js/cc";
-import { CommandClasses, enumValuesToMetadataStates } from "@zwave-js/core";
+import { CommandClasses } from "@zwave-js/core";
 import { createTestingHost } from "@zwave-js/host";
 import type { Driver } from "../../driver/Driver";
 import { ZWaveNode } from "../../node/Node";
@@ -52,17 +51,17 @@ describe("lib/commandclass/HumidityControlOperatingStateCC => ", () => {
 		expect(cc.state).toBe(HumidityControlOperatingState.Humidifying);
 	});
 
-	it("the CC values should have the correct metadata", () => {
-		// Readonly, 0-99
-		const currentValueMeta = getCCValueMetadata(
-			CommandClasses["Humidity Control Operating State"],
-			"state",
-		);
-		expect(currentValueMeta).toMatchObject({
-			states: enumValuesToMetadataStates(HumidityControlOperatingState),
-			label: "Humidity control operating state",
-		});
-	});
+	// it("the CC values should have the correct metadata", () => {
+	// 	// Readonly, 0-99
+	// 	const currentValueMeta = getCCValueMetadata(
+	// 		CommandClasses["Humidity Control Operating State"],
+	// 		"state",
+	// 	);
+	// 	expect(currentValueMeta).toMatchObject({
+	// 		states: enumValuesToMetadataStates(HumidityControlOperatingState),
+	// 		label: "Humidity control operating state",
+	// 	});
+	// });
 
 	describe.skip(`interview()`, () => {
 		const host = createEmptyMockDriver();
diff --git a/packages/zwave-js/src/lib/test/cc/IndicatorCC.test.ts b/packages/zwave-js/src/lib/test/cc/IndicatorCC.test.ts
index cdfabfaa0cd..72a94295cb5 100644
--- a/packages/zwave-js/src/lib/test/cc/IndicatorCC.test.ts
+++ b/packages/zwave-js/src/lib/test/cc/IndicatorCC.test.ts
@@ -6,10 +6,7 @@ import {
 	IndicatorCCSet,
 	IndicatorCommand,
 } from "@zwave-js/cc";
-import {
-	getIndicatorValueValueID,
-	getSupportedIndicatorIDsValueID,
-} from "@zwave-js/cc/IndicatorCC";
+import { IndicatorCCValues } from "@zwave-js/cc/IndicatorCC";
 import { CommandClasses } from "@zwave-js/core";
 import { createTestingHost, TestingHost } from "@zwave-js/host";
 import { createTestNode } from "../mocks";
@@ -175,7 +172,7 @@ describe("lib/commandclass/IndicatorCC => ", () => {
 	});
 
 	it("the value IDs should be translated properly", () => {
-		const valueId = getIndicatorValueValueID(2, 0x43, 2);
+		const valueId = IndicatorCCValues.valueV2(0x43, 2).endpoint(2);
 		const testNode = createTestNode(host, { id: 2 });
 		const ccInstance = CommandClass.createInstanceUnchecked(
 			host,
@@ -190,7 +187,7 @@ describe("lib/commandclass/IndicatorCC => ", () => {
 		const translatedPropertyKey = ccInstance.translatePropertyKey(
 			host,
 			valueId.property,
-			valueId.propertyKey!,
+			valueId.propertyKey,
 		);
 		expect(translatedProperty).toBe("Button 1 indication");
 		expect(translatedPropertyKey).toBe("Binary");
diff --git a/packages/zwave-js/src/lib/test/cc/SceneControllerConfigurationCC.test.ts b/packages/zwave-js/src/lib/test/cc/SceneControllerConfigurationCC.test.ts
index 46bb245bdcd..8221141378a 100644
--- a/packages/zwave-js/src/lib/test/cc/SceneControllerConfigurationCC.test.ts
+++ b/packages/zwave-js/src/lib/test/cc/SceneControllerConfigurationCC.test.ts
@@ -5,7 +5,7 @@ import {
 	SceneControllerConfigurationCCSet,
 	SceneControllerConfigurationCommand,
 } from "@zwave-js/cc";
-import { getGroupCountValueId } from "@zwave-js/cc/AssociationCC";
+import { AssociationCCValues } from "@zwave-js/cc/AssociationCC";
 import { CommandClasses, Duration } from "@zwave-js/core";
 import { createTestingHost, TestingHost } from "@zwave-js/host";
 import { createTestNode } from "../mocks";
@@ -21,7 +21,7 @@ function buildCCBuffer(payload: Buffer): Buffer {
 
 describe("lib/commandclass/SceneControllerConfigurationCC => ", () => {
 	const fakeGroupCount = 5;
-	const groupCountValueId = getGroupCountValueId();
+	const groupCountValueId = AssociationCCValues.groupCount.id;
 	let host: TestingHost;
 
 	beforeAll(() => {
diff --git a/packages/zwave-js/src/lib/test/cc/ThermostatFanStateCC.test.ts b/packages/zwave-js/src/lib/test/cc/ThermostatFanStateCC.test.ts
index 71c492cbbf7..8cd24716979 100644
--- a/packages/zwave-js/src/lib/test/cc/ThermostatFanStateCC.test.ts
+++ b/packages/zwave-js/src/lib/test/cc/ThermostatFanStateCC.test.ts
@@ -1,12 +1,11 @@
 import {
-	getCCValueMetadata,
 	ThermostatFanState,
 	ThermostatFanStateCC,
 	ThermostatFanStateCCGet,
 	ThermostatFanStateCCReport,
 	ThermostatFanStateCommand,
 } from "@zwave-js/cc";
-import { CommandClasses, enumValuesToMetadataStates } from "@zwave-js/core";
+import { CommandClasses } from "@zwave-js/core";
 import { createTestingHost } from "@zwave-js/host";
 
 const host = createTestingHost();
@@ -57,15 +56,15 @@ describe("lib/commandclass/ThermostatFanStateCC => ", () => {
 		expect(cc.constructor).toBe(ThermostatFanStateCC);
 	});
 
-	it("the CC values should have the correct metadata", () => {
-		// Readonly, 0-99
-		const currentValueMeta = getCCValueMetadata(
-			CommandClasses["Thermostat Fan State"],
-			"state",
-		);
-		expect(currentValueMeta).toMatchObject({
-			states: enumValuesToMetadataStates(ThermostatFanState),
-			label: "Thermostat fan state",
-		});
-	});
+	// it("the CC values should have the correct metadata", () => {
+	// 	// Readonly, 0-99
+	// 	const currentValueMeta = getCCValueMetadata(
+	// 		CommandClasses["Thermostat Fan State"],
+	// 		"state",
+	// 	);
+	// 	expect(currentValueMeta).toMatchObject({
+	// 		states: enumValuesToMetadataStates(ThermostatFanState),
+	// 		label: "Thermostat fan state",
+	// 	});
+	// });
 });
diff --git a/packages/zwave-js/src/lib/test/compat/notificationAlarmMapping.test.ts b/packages/zwave-js/src/lib/test/compat/notificationAlarmMapping.test.ts
index e5e511635e6..26d85b1e17f 100644
--- a/packages/zwave-js/src/lib/test/compat/notificationAlarmMapping.test.ts
+++ b/packages/zwave-js/src/lib/test/compat/notificationAlarmMapping.test.ts
@@ -1,9 +1,5 @@
 import { CommandClass } from "@zwave-js/cc";
-import {
-	getManufacturerIdValueId,
-	getProductIdValueId,
-	getProductTypeValueId,
-} from "@zwave-js/cc/ManufacturerSpecificCC";
+import { ManufacturerSpecificCCValues } from "@zwave-js/cc/ManufacturerSpecificCC";
 import { NotificationCCReport } from "@zwave-js/cc/NotificationCC";
 import { CommandClasses } from "@zwave-js/core";
 import type { ThrowingMap } from "@zwave-js/shared";
@@ -45,9 +41,15 @@ describe("compat flags", () => {
 	});
 
 	it("the alarmMapping compat flag works correctly (using the example Kwikset 910)", async () => {
-		node2.valueDB.setValue(getManufacturerIdValueId(), 0x90);
-		node2.valueDB.setValue(getProductTypeValueId(), 0x01);
-		node2.valueDB.setValue(getProductIdValueId(), 0x01);
+		node2.valueDB.setValue(
+			ManufacturerSpecificCCValues.manufacturerId.id,
+			0x90,
+		);
+		node2.valueDB.setValue(
+			ManufacturerSpecificCCValues.productType.id,
+			0x01,
+		);
+		node2.valueDB.setValue(ManufacturerSpecificCCValues.productId.id, 0x01);
 		await node2["loadDeviceConfig"]();
 
 		const rawNotification = new NotificationCCReport(driver, {
diff --git a/packages/zwave-js/src/lib/test/driver/handleUnsolicited.test.ts b/packages/zwave-js/src/lib/test/driver/handleUnsolicited.test.ts
index 103d7561e6c..e540b7d0098 100644
--- a/packages/zwave-js/src/lib/test/driver/handleUnsolicited.test.ts
+++ b/packages/zwave-js/src/lib/test/driver/handleUnsolicited.test.ts
@@ -1,4 +1,4 @@
-import { getCurrentValueValueId as getBasicCCCurrentValueValueId } from "@zwave-js/cc/BasicCC";
+import { BasicCCValues } from "@zwave-js/cc/BasicCC";
 import { MessageHeaders, MockSerialPort } from "@zwave-js/serial";
 import { createThrowingMap, ThrowingMap } from "@zwave-js/shared";
 import { wait } from "alcalzone-shared/async";
@@ -46,7 +46,7 @@ describe("regression tests", () => {
 		node2["isFrequentListening"] = false;
 		node2.markAsAlive();
 
-		const valueId = getBasicCCCurrentValueValueId(0);
+		const valueId = BasicCCValues.currentValue.id;
 		expect(node2.getValue(valueId)).toBeUndefined();
 
 		const ACK = Buffer.from([MessageHeaders.ACK]);
@@ -76,7 +76,7 @@ describe("regression tests", () => {
 		node2["isFrequentListening"] = false;
 		node2.markAsAlive();
 
-		const valueId = getBasicCCCurrentValueValueId(0);
+		const valueId = BasicCCValues.currentValue.id;
 		expect(node2.getValue(valueId)).toBeUndefined();
 
 		const ACK = Buffer.from([MessageHeaders.ACK]);
@@ -124,7 +124,7 @@ describe("regression tests", () => {
 		node2["isFrequentListening"] = false;
 		node2.markAsAlive();
 
-		const valueId = getBasicCCCurrentValueValueId(0);
+		const valueId = BasicCCValues.currentValue.id;
 		expect(node2.getValue(valueId)).toBeUndefined();
 
 		const ACK = Buffer.from([MessageHeaders.ACK]);