@matter/model 0.11.9-alpha.0-20241206-22f233334 → 0.11.9-alpha.0-20241207-b604cfa44

package/src/standard/elements/WindowCoveringControllerDT.ts

@@ -9,37 +9,36 @@
 import { MatterDefinition } from "../MatterDefinition.js";
 import { DeviceTypeElement as DeviceType, RequirementElement as Requirement } from "../../elements/index.js";
 
-export const WindowCoveringControllerDt = DeviceType({
-    name: "WindowCoveringController", id: 0x203, category: "Closure", classification: "simple",
-    details: "A Window Covering Controller is a device that controls an automatic window covering.",
-    xref: { document: "device", section: "8.4" },
-
-    children: [
-        Requirement({
-            name: "Descriptor", id: 0x1d, element: "serverCluster",
-            children: [Requirement({ name: "DeviceTypeList", default: [ { deviceType: 515, revision: 3 } ], element: "attribute" })]
-        }),
-        Requirement({
-            name: "Identify", id: 0x3, conformance: "O", element: "serverCluster",
-            xref: { document: "device", section: "8.4.4" }
-        }),
-        Requirement({
-            name: "Identify", id: 0x3, conformance: "O", element: "clientCluster",
-            xref: { document: "device", section: "8.4.4" }
-        }),
-        Requirement({
-            name: "Groups", id: 0x4, conformance: "Active, O", element: "clientCluster",
-            xref: { document: "device", section: "8.4.4" }
-        }),
-        Requirement({
-            name: "ScenesManagement", id: 0x62, conformance: "P, Active, O", element: "clientCluster",
-            xref: { document: "device", section: "8.4.4" }
-        }),
-        Requirement({
-            name: "WindowCovering", id: 0x102, conformance: "M", element: "clientCluster",
-            xref: { document: "device", section: "8.4.4" }
-        })
-    ]
-});
+export const WindowCoveringControllerDt = DeviceType(
+    {
+        name: "WindowCoveringController", id: 0x203, category: "Closure", classification: "simple",
+        details: "A Window Covering Controller is a device that controls an automatic window covering.",
+        xref: { document: "device", section: "8.4" }
+    },
+    Requirement(
+        { name: "Descriptor", id: 0x1d, element: "serverCluster" },
+        Requirement({ name: "DeviceTypeList", default: [ { deviceType: 515, revision: 3 } ], element: "attribute" })
+    ),
+    Requirement({
+        name: "Identify", id: 0x3, conformance: "O", element: "serverCluster",
+        xref: { document: "device", section: "8.4.4" }
+    }),
+    Requirement({
+        name: "Identify", id: 0x3, conformance: "O", element: "clientCluster",
+        xref: { document: "device", section: "8.4.4" }
+    }),
+    Requirement({
+        name: "Groups", id: 0x4, conformance: "Active, O", element: "clientCluster",
+        xref: { document: "device", section: "8.4.4" }
+    }),
+    Requirement({
+        name: "ScenesManagement", id: 0x62, conformance: "P, Active, O", element: "clientCluster",
+        xref: { document: "device", section: "8.4.4" }
+    }),
+    Requirement({
+        name: "WindowCovering", id: 0x102, conformance: "M", element: "clientCluster",
+        xref: { document: "device", section: "8.4.4" }
+    })
+);
 
 MatterDefinition.children.push(WindowCoveringControllerDt);

package/src/standard/elements/WindowCoveringDT.ts

@@ -9,43 +9,37 @@
 import { MatterDefinition } from "../MatterDefinition.js";
 import { DeviceTypeElement as DeviceType, RequirementElement as Requirement } from "../../elements/index.js";
 
-export const WindowCoveringDt = DeviceType({
-    name: "WindowCovering", id: 0x202, category: "Closure", classification: "simple",
-    details: "This defines conformance to the Window Covering device type.",
-    xref: { document: "device", section: "8.3" },
+export const WindowCoveringDt = DeviceType(
+    {
+        name: "WindowCovering", id: 0x202, category: "Closure", classification: "simple",
+        details: "This defines conformance to the Window Covering device type.",
+        xref: { document: "device", section: "8.3" }
+    },
+    Requirement(
+        { name: "Descriptor", id: 0x1d, element: "serverCluster" },
+        Requirement({ name: "DeviceTypeList", default: [ { deviceType: 514, revision: 3 } ], element: "attribute" })
+    ),
+    Requirement({
+        name: "Identify", id: 0x3, conformance: "M", element: "serverCluster",
+        xref: { document: "device", section: "8.3.4" }
+    }),
+    Requirement({
+        name: "Groups", id: 0x4, conformance: "Active, O", element: "serverCluster",
+        xref: { document: "device", section: "8.3.4" }
+    }),
+    Requirement({
+        name: "ScenesManagement", id: 0x62, conformance: "P, Active, O", element: "serverCluster",
+        xref: { document: "device", section: "8.3.4" }
+    }),
 
-    children: [
-        Requirement({
-            name: "Descriptor", id: 0x1d, element: "serverCluster",
-            children: [Requirement({ name: "DeviceTypeList", default: [ { deviceType: 514, revision: 3 } ], element: "attribute" })]
-        }),
-        Requirement({
-            name: "Identify", id: 0x3, conformance: "M", element: "serverCluster",
-            xref: { document: "device", section: "8.3.4" }
-        }),
-        Requirement({
-            name: "Groups", id: 0x4, conformance: "Active, O", element: "serverCluster",
-            xref: { document: "device", section: "8.3.4" }
-        }),
-        Requirement({
-            name: "ScenesManagement", id: 0x62, conformance: "P, Active, O", element: "serverCluster",
-            xref: { document: "device", section: "8.3.4" }
-        }),
-
-        Requirement({
+    Requirement(
+        {
             name: "WindowCovering", id: 0x102, conformance: "M", element: "serverCluster",
-            xref: { document: "device", section: "8.3.4" },
-
-            children: [
-                Requirement({
-                    name: "GoToLiftPercentageLiftPercent100thsValue", conformance: "Matter", element: "commandField"
-                }),
-                Requirement({
-                    name: "GoToTiltPercentageTiltPercent100thsValue", conformance: "Matter", element: "commandField"
-                })
-            ]
-        })
-    ]
-});
+            xref: { document: "device", section: "8.3.4" }
+        },
+        Requirement({ name: "GoToLiftPercentageLiftPercent100thsValue", conformance: "Matter", element: "commandField" }),
+        Requirement({ name: "GoToTiltPercentageTiltPercent100thsValue", conformance: "Matter", element: "commandField" })
+    )
+);
 
 MatterDefinition.children.push(WindowCoveringDt);

package/src/standard/elements/date.ts

@@ -9,40 +9,39 @@
 import { MatterDefinition } from "../MatterDefinition.js";
 import { DatatypeElement as Datatype, FieldElement as Field } from "../../elements/index.js";
 
-export const date = Datatype({
-    name: "date", type: "struct", description: "Date", isSeed: true, metatype: "date",
-    details: "This data type shall be a struct as defined below.",
-    xref: { document: "core", section: "7.18.2.4" },
-
-    children: [
-        Field({
-            name: "Year", id: 0x0, type: "uint8", conformance: "M", default: null, quality: "X",
-            details: "The year subfield represents years from 1900 (0) to 2155 (255).",
-            xref: { document: "core", section: "7.18.2.4.1" }
-        }),
-
-        Field({
-            name: "Month", id: 0x1, type: "uint8", conformance: "M", constraint: "1 to 12", default: null,
-            quality: "X",
-            details: "This field represents months January (1) to December (12).",
-            xref: { document: "core", section: "7.18.2.4.2" }
-        }),
-
-        Field({
-            name: "Day", id: 0x2, type: "uint8", conformance: "M", constraint: "1 to 31", default: null,
-            quality: "X",
-            details: "This field represents the day of the month. Note that values in the range 29 to 31 may be invalid, " +
-                "depending on the month and year.",
-            xref: { document: "core", section: "7.18.2.4.3" }
-        }),
-
-        Field({
-            name: "DayOfWeek", id: 0x3, type: "uint8", conformance: "M", constraint: "1 to 7", default: null,
-            quality: "X",
-            details: "This represents the day of the week from Monday (1) to Sunday (7).",
-            xref: { document: "core", section: "7.18.2.4.4" }
-        })
-    ]
-});
+export const date = Datatype(
+    {
+        name: "date", type: "struct", description: "Date", isSeed: true, metatype: "date",
+        details: "This data type shall be a struct as defined below.",
+        xref: { document: "core", section: "7.18.2.4" }
+    },
+    Field({
+        name: "Year", id: 0x0, type: "uint8", conformance: "M", default: null, quality: "X",
+        details: "The year subfield represents years from 1900 (0) to 2155 (255).",
+        xref: { document: "core", section: "7.18.2.4.1" }
+    }),
+
+    Field({
+        name: "Month", id: 0x1, type: "uint8", conformance: "M", constraint: "1 to 12", default: null,
+        quality: "X",
+        details: "This field represents months January (1) to December (12).",
+        xref: { document: "core", section: "7.18.2.4.2" }
+    }),
+
+    Field({
+        name: "Day", id: 0x2, type: "uint8", conformance: "M", constraint: "1 to 31", default: null,
+        quality: "X",
+        details: "This field represents the day of the month. Note that values in the range 29 to 31 may be invalid, " +
+            "depending on the month and year.",
+        xref: { document: "core", section: "7.18.2.4.3" }
+    }),
+
+    Field({
+        name: "DayOfWeek", id: 0x3, type: "uint8", conformance: "M", constraint: "1 to 7", default: null,
+        quality: "X",
+        details: "This represents the day of the week from Monday (1) to Sunday (7).",
+        xref: { document: "core", section: "7.18.2.4.4" }
+    })
+);
 
 MatterDefinition.children.push(date);

package/src/standard/elements/epoch-us.ts

@@ -9,68 +9,70 @@
 import { MatterDefinition } from "../MatterDefinition.js";
 import { DatatypeElement as Datatype } from "../../elements/index.js";
 
-export const epochUs = Datatype({
-    name: "epoch-us", type: "uint64", description: "Epoch Time in microseconds", isSeed: true,
+export const epochUs = Datatype(
+    {
+        name: "epoch-us", type: "uint64", description: "Epoch Time in microseconds", isSeed: true,
 
-    details: "This type represents an offset, in microseconds, from 0 hours, 0 minutes, 0 seconds, on the 1st of " +
-        "January, 2000 UTC (the Epoch), encoded as an unsigned 64-bit scalar value." +
-        "\n" +
-        "This offset is the sum of two parts: time elapsed, not counting leap-seconds, and a local time " +
-        "offset. The local time offset may include a timezone offset and a may include a DST offset." +
-        "\n" +
-        "Any use of this type shall indicate how the associated local time offset is determined in the " +
-        "specific context of that use. This may be done, for example, by simply saying the time is a UTC " +
-        "time, in which case the local time offset is 0." +
-        "\n" +
-        "A given Epoch Time value may be interpreted in at least two ways:" +
-        "\n" +
-        "  1. The value can be converted to a local clock date/time (year, month, day, hours, minutes, " +
-        "     seconds, microseconds) by treating the local time offset as 0 and finding the UTC (year, " +
-        "     month, day, hours, minutes, seconds, microseconds) tuple that corresponds to an elapsed time " +
-        "     since the epoch time equal to the given value. The value then represents that tuple, but " +
-        "     interpreted in the specific timezone and DST situation associated with the value. This " +
-        "     procedure does not require knowing the local time offset of the value." +
-        "\n" +
-        "  2. The value can be converted to a UTC time by subtracting the associated local time offset from " +
-        "     the Epoch Time value and then treating the resulting value as an elapsed count of microseconds " +
-        "     since the epoch time." +
-        "\n" +
-        "For example, an Epoch Time value of 0x0000_0BF1_B7E1_0000 corresponds to an offset of exactly 152 " +
-        "days. This can be interpreted as \"00:00:00 on June 1, 2000\" in whatever local time zone is " +
-        "associated with the value. That corresponds to the following times in ISO 8601 notation:" +
-        "\n" +
-        "  • 2000-06-01T00:00Z if the associated local time offset is 0 (i.e. the value is in UTC)." +
-        "\n" +
-        "  • 2000-05-31T23:00Z if the associated local time offset is +1 hour (e.g. the CET timezone, " +
-        "    without daylight savings)." +
-        "\n" +
-        "  • 2000-06-01T00:00+02 if the associated local time offset is +1 hour." +
-        "\n" +
-        "  • 2000-06-01T04:00Z if the associated local time offset is -4 hours (e.g. the EDT time zone, " +
-        "    which includes daylight savings)." +
-        "\n" +
-        "  • 2000-06-01T00:00-04 if the associated local time offset is -4 hours." +
-        "\n" +
-        "Conversion from NTP timestamps" +
-        "\n" +
-        "Timestamps from NTP also do not count leap seconds, but have a different epoch. NTP 128-bit " +
-        "timestamps consist of a 64-bit seconds portion (NTP(s)) and a 64-bit fractional seconds portion " +
-        "(NTP(frac)). NTP(s) at 00:00:00 can be calculated from the Modified Julian Day (MJD) as follows:" +
-        "\n" +
-        "NTP(s) = (MJD-15020) * (24*60*60)" +
-        "\n" +
-        "where 15020 is the MJD on January 1, 1900 (the NTP epoch)" +
-        "\n" +
-        "NTP(s) on January 1, 2000 00:00:00 UTC (MJD = 51544) is 3155673600 (0xBC17C200)" +
-        "\n" +
-        "Epoch Time has a microsecond precision, and this precision can be achieved by using the most " +
-        "significant 32 bits of the fractional portion (NTP(frac32)). Conversion between the 128-bit NTP " +
-        "timestamps and a UTC Epoch Time in Microseconds is as follows:" +
-        "\n" +
-        "UTC Epoch Time = (NTP(s) - 0xBC17C200)*10^6 + ((NTP(frac32)*10^6) / 2^32) where all numbers are " +
-        "treated as unsigned 64-bit integers and the division is integer division.",
+        details: "This type represents an offset, in microseconds, from 0 hours, 0 minutes, 0 seconds, on the 1st of " +
+            "January, 2000 UTC (the Epoch), encoded as an unsigned 64-bit scalar value." +
+            "\n" +
+            "This offset is the sum of two parts: time elapsed, not counting leap-seconds, and a local time " +
+            "offset. The local time offset may include a timezone offset and a may include a DST offset." +
+            "\n" +
+            "Any use of this type shall indicate how the associated local time offset is determined in the " +
+            "specific context of that use. This may be done, for example, by simply saying the time is a UTC " +
+            "time, in which case the local time offset is 0." +
+            "\n" +
+            "A given Epoch Time value may be interpreted in at least two ways:" +
+            "\n" +
+            "  1. The value can be converted to a local clock date/time (year, month, day, hours, minutes, " +
+            "     seconds, microseconds) by treating the local time offset as 0 and finding the UTC (year, " +
+            "     month, day, hours, minutes, seconds, microseconds) tuple that corresponds to an elapsed time " +
+            "     since the epoch time equal to the given value. The value then represents that tuple, but " +
+            "     interpreted in the specific timezone and DST situation associated with the value. This " +
+            "     procedure does not require knowing the local time offset of the value." +
+            "\n" +
+            "  2. The value can be converted to a UTC time by subtracting the associated local time offset from " +
+            "     the Epoch Time value and then treating the resulting value as an elapsed count of microseconds " +
+            "     since the epoch time." +
+            "\n" +
+            "For example, an Epoch Time value of 0x0000_0BF1_B7E1_0000 corresponds to an offset of exactly 152 " +
+            "days. This can be interpreted as \"00:00:00 on June 1, 2000\" in whatever local time zone is " +
+            "associated with the value. That corresponds to the following times in ISO 8601 notation:" +
+            "\n" +
+            "  • 2000-06-01T00:00Z if the associated local time offset is 0 (i.e. the value is in UTC)." +
+            "\n" +
+            "  • 2000-05-31T23:00Z if the associated local time offset is +1 hour (e.g. the CET timezone, " +
+            "    without daylight savings)." +
+            "\n" +
+            "  • 2000-06-01T00:00+02 if the associated local time offset is +1 hour." +
+            "\n" +
+            "  • 2000-06-01T04:00Z if the associated local time offset is -4 hours (e.g. the EDT time zone, " +
+            "    which includes daylight savings)." +
+            "\n" +
+            "  • 2000-06-01T00:00-04 if the associated local time offset is -4 hours." +
+            "\n" +
+            "Conversion from NTP timestamps" +
+            "\n" +
+            "Timestamps from NTP also do not count leap seconds, but have a different epoch. NTP 128-bit " +
+            "timestamps consist of a 64-bit seconds portion (NTP(s)) and a 64-bit fractional seconds portion " +
+            "(NTP(frac)). NTP(s) at 00:00:00 can be calculated from the Modified Julian Day (MJD) as follows:" +
+            "\n" +
+            "NTP(s) = (MJD-15020) * (24*60*60)" +
+            "\n" +
+            "where 15020 is the MJD on January 1, 1900 (the NTP epoch)" +
+            "\n" +
+            "NTP(s) on January 1, 2000 00:00:00 UTC (MJD = 51544) is 3155673600 (0xBC17C200)" +
+            "\n" +
+            "Epoch Time has a microsecond precision, and this precision can be achieved by using the most " +
+            "significant 32 bits of the fractional portion (NTP(frac32)). Conversion between the 128-bit NTP " +
+            "timestamps and a UTC Epoch Time in Microseconds is as follows:" +
+            "\n" +
+            "UTC Epoch Time = (NTP(s) - 0xBC17C200)*10^6 + ((NTP(frac32)*10^6) / 2^32) where all numbers are " +
+            "treated as unsigned 64-bit integers and the division is integer division.",
 
-    xref: { document: "core", section: "7.18.2.5" }
-});
+        xref: { document: "core", section: "7.18.2.5" }
+    }
+);
 
 MatterDefinition.children.push(epochUs);

package/src/standard/elements/list.ts

@@ -9,96 +9,98 @@
 import { MatterDefinition } from "../MatterDefinition.js";
 import { DatatypeElement as Datatype } from "../../elements/index.js";
 
-export const list = Datatype({
-    name: "list", description: "List", isSeed: true, metatype: "array",
+export const list = Datatype(
+    {
+        name: "list", description: "List", isSeed: true, metatype: "array",
 
-    details: "A list is defined as a collection of entries of the same data type, with a finite count from 0 to " +
-        "65534. A cluster specification may define further constraints on the maximum possible count. The " +
-        "list entry data type shall be any defined data type, except a list data type, or any data type " +
-        "derived from a list." +
-        "\n" +
-        "The quality columns for a list definition are for the list." +
-        "\n" +
-        "The list entries are indicated with an index that is an unsigned integer starting at 0 (zero). The " +
-        "maintained order of entries, by index, is defined in the cluster specification, or undefined. Data " +
-        "that is defined as a list is indicated with \"list[X]\" where X is the entry type. The data type of " +
-        "the list entry has its own qualities, constraints, and conformance." +
-        "\n" +
-        "### To define qualities for the list entry data type, make the list entry data type a defined local " +
-        "derived data type, with a table including the columns required to define and constrain the data " +
-        "type." +
-        "\n" +
-        "There is an inline shortcut to define the list entry data type constraints. See List Constraints." +
-        "\n" +
-        "It is recommended to put a maximum constraint on the list and list entry data types." +
-        "\n" +
-        "It is recommended that a list entry data type be a struct, to enable the addition of new fields to " +
-        "the list’s entries in the future." +
-        "\n" +
-        "  • The cluster data version shall be incremented when the list order or entries change." +
-        "\n" +
-        "  • An entry shall NOT be null." +
-        "\n" +
-        "  • The list shall support reading and reporting all entries." +
-        "\n" +
-        "  • The list shall support reporting, updates, and/or deletion of one or more entries." +
-        "\n" +
-        "  • If the list is writable, it shall support writing or deleting the entire list." +
-        "\n" +
-        "  • If the list is writable, it shall support updating one or more individual entries by indicating " +
-        "    an index per updated entry." +
-        "\n" +
-        "  • If the list is writable, it shall support deleting one or more individual entries by indicating " +
-        "    an index per deleted entry." +
-        "\n" +
-        "  • If the list is writable, it shall support adding one or more individual entries." +
-        "\n" +
-        "  • A list may define an entry that is a struct that is fabric-scoped (see Fabric-Scoped Quality)." +
-        "\n" +
-        "### Fabric-Scoped List" +
-        "\n" +
-        "  • A fabric-scoped list shall define an entry data type that is a struct, which shall also be " +
-        "    fabric-scoped (see Fabric-Scoped Struct)." +
-        "\n" +
-        "Each entry in a fabric-scoped list shall be fabric-scoped to a particular fabric or no fabric." +
-        "\n" +
-        "### A fabric-scoped list supports a fabric-filter that filters the view of the list for read and " +
-        "write interactions. This filter simplifies client side logic that does not want to read or write " +
-        "fabric data that is not associated with the accessing fabric." +
-        "\n" +
-        "  • An interaction upon a list with fabric-filtering shall only indicate and access entries where " +
-        "    the associated fabric matches the accessing fabric, and all other entries shall be ignored." +
-        "\n" +
-        "  • Fabric-filtered list entries shall be in the same order as the full list." +
-        "\n" +
-        "  • Fabric-filtered list entries shall be indexed from 0 with no gaps, as if the other entries did " +
-        "    not exist." +
-        "\n" +
-        "  • For a write interaction, fabric-filtering shall be enabled." +
-        "\n" +
-        "  • When writing to a fabric-scoped list, the write interaction shall be on an accessing fabric, " +
-        "    otherwise, the write interaction shall fail (see Interaction Model)." +
-        "\n" +
-        "  • For a read interaction on a list, fabric-filtering may be enabled." +
-        "\n" +
-        "  • For a read interaction on a list, with fabric-filtering disabled, the list shall be reported as " +
-        "    a full list with all entries." +
-        "\n" +
-        "list[1] = [ { FabricIndex = B, Value = 55 } ]" +
-        "\n" +
-        "changes the full list to:" +
-        "\n" +
-        "list = [ { FabricIndex = A, Value = 20 }," +
-        "\n" +
-        "{ FabricIndex = B, Value = 30 }," +
-        "\n" +
-        "{ FabricIndex = A, Value = 40 }," +
-        "\n" +
-        "{ FabricIndex = B, Value = 55 }," +
-        "\n" +
-        "{ FabricIndex = B, Value = 60 } ]",
+        details: "A list is defined as a collection of entries of the same data type, with a finite count from 0 to " +
+            "65534. A cluster specification may define further constraints on the maximum possible count. The " +
+            "list entry data type shall be any defined data type, except a list data type, or any data type " +
+            "derived from a list." +
+            "\n" +
+            "The quality columns for a list definition are for the list." +
+            "\n" +
+            "The list entries are indicated with an index that is an unsigned integer starting at 0 (zero). The " +
+            "maintained order of entries, by index, is defined in the cluster specification, or undefined. Data " +
+            "that is defined as a list is indicated with \"list[X]\" where X is the entry type. The data type of " +
+            "the list entry has its own qualities, constraints, and conformance." +
+            "\n" +
+            "### To define qualities for the list entry data type, make the list entry data type a defined local " +
+            "derived data type, with a table including the columns required to define and constrain the data " +
+            "type." +
+            "\n" +
+            "There is an inline shortcut to define the list entry data type constraints. See List Constraints." +
+            "\n" +
+            "It is recommended to put a maximum constraint on the list and list entry data types." +
+            "\n" +
+            "It is recommended that a list entry data type be a struct, to enable the addition of new fields to " +
+            "the list’s entries in the future." +
+            "\n" +
+            "  • The cluster data version shall be incremented when the list order or entries change." +
+            "\n" +
+            "  • An entry shall NOT be null." +
+            "\n" +
+            "  • The list shall support reading and reporting all entries." +
+            "\n" +
+            "  • The list shall support reporting, updates, and/or deletion of one or more entries." +
+            "\n" +
+            "  • If the list is writable, it shall support writing or deleting the entire list." +
+            "\n" +
+            "  • If the list is writable, it shall support updating one or more individual entries by indicating " +
+            "    an index per updated entry." +
+            "\n" +
+            "  • If the list is writable, it shall support deleting one or more individual entries by indicating " +
+            "    an index per deleted entry." +
+            "\n" +
+            "  • If the list is writable, it shall support adding one or more individual entries." +
+            "\n" +
+            "  • A list may define an entry that is a struct that is fabric-scoped (see Fabric-Scoped Quality)." +
+            "\n" +
+            "### Fabric-Scoped List" +
+            "\n" +
+            "  • A fabric-scoped list shall define an entry data type that is a struct, which shall also be " +
+            "    fabric-scoped (see Fabric-Scoped Struct)." +
+            "\n" +
+            "Each entry in a fabric-scoped list shall be fabric-scoped to a particular fabric or no fabric." +
+            "\n" +
+            "### A fabric-scoped list supports a fabric-filter that filters the view of the list for read and " +
+            "write interactions. This filter simplifies client side logic that does not want to read or write " +
+            "fabric data that is not associated with the accessing fabric." +
+            "\n" +
+            "  • An interaction upon a list with fabric-filtering shall only indicate and access entries where " +
+            "    the associated fabric matches the accessing fabric, and all other entries shall be ignored." +
+            "\n" +
+            "  • Fabric-filtered list entries shall be in the same order as the full list." +
+            "\n" +
+            "  • Fabric-filtered list entries shall be indexed from 0 with no gaps, as if the other entries did " +
+            "    not exist." +
+            "\n" +
+            "  • For a write interaction, fabric-filtering shall be enabled." +
+            "\n" +
+            "  • When writing to a fabric-scoped list, the write interaction shall be on an accessing fabric, " +
+            "    otherwise, the write interaction shall fail (see Interaction Model)." +
+            "\n" +
+            "  • For a read interaction on a list, fabric-filtering may be enabled." +
+            "\n" +
+            "  • For a read interaction on a list, with fabric-filtering disabled, the list shall be reported as " +
+            "    a full list with all entries." +
+            "\n" +
+            "list[1] = [ { FabricIndex = B, Value = 55 } ]" +
+            "\n" +
+            "changes the full list to:" +
+            "\n" +
+            "list = [ { FabricIndex = A, Value = 20 }," +
+            "\n" +
+            "{ FabricIndex = B, Value = 30 }," +
+            "\n" +
+            "{ FabricIndex = A, Value = 40 }," +
+            "\n" +
+            "{ FabricIndex = B, Value = 55 }," +
+            "\n" +
+            "{ FabricIndex = B, Value = 60 } ]",
 
-    xref: { document: "core", section: "7.18.1.8" }
-});
+        xref: { document: "core", section: "7.18.1.8" }
+    }
+);
 
 MatterDefinition.children.push(list);

package/src/standard/elements/priority.ts

@@ -9,24 +9,24 @@
 import { MatterDefinition } from "../MatterDefinition.js";
 import { DatatypeElement as Datatype, FieldElement as Field } from "../../elements/index.js";
 
-export const priority = Datatype({
-    name: "priority", type: "enum8", description: "Priority", isSeed: true,
-    details: "This is an enumeration of priority used to tag events and possibly other data. The data type does " +
-        "not define any particular ordering among the values. Specific uses of the data type may assign " +
-        "semantics to the values that imply an ordering relationship.",
-    xref: { document: "core", section: "7.18.2.17" },
+export const priority = Datatype(
+    {
+        name: "priority", type: "enum8", description: "Priority", isSeed: true,
+        details: "This is an enumeration of priority used to tag events and possibly other data. The data type does " +
+            "not define any particular ordering among the values. Specific uses of the data type may assign " +
+            "semantics to the values that imply an ordering relationship.",
+        xref: { document: "core", section: "7.18.2.17" }
+    },
 
-    children: [
-        Field({ name: "Debug", id: 0x0, description: "Information for engineering debugging/troubleshooting" }),
-        Field({
-            name: "Info", id: 0x1,
-            description: "Information that either drives customer facing features or provides insights into device functions that are used to drive analytics use cases"
-        }),
-        Field({
-            name: "Critical", id: 0x2,
-            description: "Information or notification that impacts safety, a critical function, or ongoing reliable operation of the node or application supported on an endpoint."
-        })
-    ]
-});
+    Field({ name: "Debug", id: 0x0, description: "Information for engineering debugging/troubleshooting" }),
+    Field({
+        name: "Info", id: 0x1,
+        description: "Information that either drives customer facing features or provides insights into device functions that are used to drive analytics use cases"
+    }),
+    Field({
+        name: "Critical", id: 0x2,
+        description: "Information or notification that impacts safety, a critical function, or ongoing reliable operation of the node or application supported on an endpoint."
+    })
+);
 
 MatterDefinition.children.push(priority);