@matterbridge/core 3.7.10 → 3.8.0-dev-20260524-eed6b4a

package/dist/clusters/closure-dimension.js

@@ -1,202 +1,15 @@
-import { Attribute, ClusterRegistry, Command, FixedAttribute, MutableCluster, TlvNoResponse } from '@matter/types/cluster';
-import { BitFlag } from '@matter/types/schema';
-import { TlvBitmap, TlvBoolean, TlvEnum, TlvField, TlvInt16, TlvNullable, TlvObject, TlvOptionalField, TlvPercent100ths, TlvUInt8, TlvUInt16, } from '@matter/types/tlv';
-export var ClosureDimension;
-(function (ClosureDimension) {
-    let Feature;
-    (function (Feature) {
-        Feature["Positioning"] = "Positioning";
-        Feature["MotionLatching"] = "MotionLatching";
-        Feature["Unit"] = "Unit";
-        Feature["Limitation"] = "Limitation";
-        Feature["Speed"] = "Speed";
-        Feature["Translation"] = "Translation";
-        Feature["Rotation"] = "Rotation";
-        Feature["Modulation"] = "Modulation";
-    })(Feature = ClosureDimension.Feature || (ClosureDimension.Feature = {}));
-    let ClosureUnit;
-    (function (ClosureUnit) {
-        ClosureUnit[ClosureUnit["Millimeter"] = 0] = "Millimeter";
-        ClosureUnit[ClosureUnit["Degree"] = 1] = "Degree";
-    })(ClosureUnit = ClosureDimension.ClosureUnit || (ClosureDimension.ClosureUnit = {}));
-    let ModulationType;
-    (function (ModulationType) {
-        ModulationType[ModulationType["SlatsOrientation"] = 0] = "SlatsOrientation";
-        ModulationType[ModulationType["SlatsOpenwork"] = 1] = "SlatsOpenwork";
-        ModulationType[ModulationType["StripesAlignment"] = 2] = "StripesAlignment";
-        ModulationType[ModulationType["Opacity"] = 3] = "Opacity";
-        ModulationType[ModulationType["Ventilation"] = 4] = "Ventilation";
-    })(ModulationType = ClosureDimension.ModulationType || (ClosureDimension.ModulationType = {}));
-    let Overflow;
-    (function (Overflow) {
-        Overflow[Overflow["NoOverflow"] = 0] = "NoOverflow";
-        Overflow[Overflow["Inside"] = 1] = "Inside";
-        Overflow[Overflow["Outside"] = 2] = "Outside";
-        Overflow[Overflow["TopInside"] = 3] = "TopInside";
-        Overflow[Overflow["TopOutside"] = 4] = "TopOutside";
-        Overflow[Overflow["BottomInside"] = 5] = "BottomInside";
-        Overflow[Overflow["BottomOutside"] = 6] = "BottomOutside";
-        Overflow[Overflow["LeftInside"] = 7] = "LeftInside";
-        Overflow[Overflow["LeftOutside"] = 8] = "LeftOutside";
-        Overflow[Overflow["RightInside"] = 9] = "RightInside";
-        Overflow[Overflow["RightOutside"] = 10] = "RightOutside";
-    })(Overflow = ClosureDimension.Overflow || (ClosureDimension.Overflow = {}));
-    let RotationAxis;
-    (function (RotationAxis) {
-        RotationAxis[RotationAxis["Left"] = 0] = "Left";
-        RotationAxis[RotationAxis["CenteredVertical"] = 1] = "CenteredVertical";
-        RotationAxis[RotationAxis["LeftAndRight"] = 2] = "LeftAndRight";
-        RotationAxis[RotationAxis["Right"] = 3] = "Right";
-        RotationAxis[RotationAxis["Top"] = 4] = "Top";
-        RotationAxis[RotationAxis["CenteredHorizontal"] = 5] = "CenteredHorizontal";
-        RotationAxis[RotationAxis["TopAndBottom"] = 6] = "TopAndBottom";
-        RotationAxis[RotationAxis["Bottom"] = 7] = "Bottom";
-        RotationAxis[RotationAxis["LeftBarrier"] = 8] = "LeftBarrier";
-        RotationAxis[RotationAxis["LeftAndRightBarriers"] = 9] = "LeftAndRightBarriers";
-        RotationAxis[RotationAxis["RightBarrier"] = 10] = "RightBarrier";
-    })(RotationAxis = ClosureDimension.RotationAxis || (ClosureDimension.RotationAxis = {}));
-    let StepDirection;
-    (function (StepDirection) {
-        StepDirection[StepDirection["Decrease"] = 0] = "Decrease";
-        StepDirection[StepDirection["Increase"] = 1] = "Increase";
-    })(StepDirection = ClosureDimension.StepDirection || (ClosureDimension.StepDirection = {}));
-    let TranslationDirection;
-    (function (TranslationDirection) {
-        TranslationDirection[TranslationDirection["Downward"] = 0] = "Downward";
-        TranslationDirection[TranslationDirection["Upward"] = 1] = "Upward";
-        TranslationDirection[TranslationDirection["VerticalMask"] = 2] = "VerticalMask";
-        TranslationDirection[TranslationDirection["VerticalSymmetry"] = 3] = "VerticalSymmetry";
-        TranslationDirection[TranslationDirection["Leftward"] = 4] = "Leftward";
-        TranslationDirection[TranslationDirection["Rightward"] = 5] = "Rightward";
-        TranslationDirection[TranslationDirection["HorizontalMask"] = 6] = "HorizontalMask";
-        TranslationDirection[TranslationDirection["HorizontalSymmetry"] = 7] = "HorizontalSymmetry";
-        TranslationDirection[TranslationDirection["Forward"] = 8] = "Forward";
-        TranslationDirection[TranslationDirection["Backward"] = 9] = "Backward";
-        TranslationDirection[TranslationDirection["DepthMask"] = 10] = "DepthMask";
-        TranslationDirection[TranslationDirection["DepthSymmetry"] = 11] = "DepthSymmetry";
-    })(TranslationDirection = ClosureDimension.TranslationDirection || (ClosureDimension.TranslationDirection = {}));
-    ClosureDimension.LatchControlModes = {
-        remoteLatching: BitFlag(0),
-        remoteUnlatching: BitFlag(1),
-    };
-    ClosureDimension.TlvDimensionState = TlvObject({
-        position: TlvOptionalField(0, TlvNullable(TlvPercent100ths)),
-        latch: TlvOptionalField(1, TlvNullable(TlvBoolean)),
-        speed: TlvOptionalField(2, TlvEnum()),
-    });
-    ClosureDimension.TlvRangePercent100ths = TlvObject({
-        min: TlvField(0, TlvPercent100ths),
-        max: TlvField(1, TlvPercent100ths),
-    });
-    ClosureDimension.TlvUnitRange = TlvObject({
-        min: TlvField(0, TlvInt16),
-        max: TlvField(1, TlvInt16),
-    });
-    ClosureDimension.TlvSetTargetRequest = TlvObject({
-        position: TlvOptionalField(0, TlvPercent100ths),
-        latch: TlvOptionalField(1, TlvBoolean),
-        speed: TlvOptionalField(2, TlvEnum()),
-    });
-    ClosureDimension.TlvStepRequest = TlvObject({
-        direction: TlvField(0, TlvEnum()),
-        numberOfSteps: TlvField(1, TlvUInt16.bound({ min: 1 })),
-        speed: TlvOptionalField(2, TlvEnum()),
-    });
-    ClosureDimension.PositioningComponent = MutableCluster.Component({
-        attributes: {
-            resolution: FixedAttribute(0x2, TlvPercent100ths, { default: 1 }),
-            stepValue: FixedAttribute(0x3, TlvPercent100ths, { default: 1 }),
-        },
-        commands: {
-            step: Command(0x1, ClosureDimension.TlvStepRequest, 0x1, TlvNoResponse, { timed: true }),
-        },
-    });
-    ClosureDimension.MotionLatchingComponent = MutableCluster.Component({
-        attributes: {
-            latchControlModes: FixedAttribute(0xb, TlvBitmap(TlvUInt8, ClosureDimension.LatchControlModes)),
-        },
-    });
-    ClosureDimension.UnitComponent = MutableCluster.Component({
-        attributes: {
-            unit: FixedAttribute(0x4, TlvEnum()),
-            unitRange: Attribute(0x5, TlvNullable(ClosureDimension.TlvUnitRange), { default: null }),
-        },
-    });
-    ClosureDimension.LimitationComponent = MutableCluster.Component({
-        attributes: {
-            limitRange: Attribute(0x6, ClosureDimension.TlvRangePercent100ths),
-        },
-    });
-    ClosureDimension.TranslationComponent = MutableCluster.Component({
-        attributes: {
-            translationDirection: FixedAttribute(0x7, TlvEnum()),
-        },
-    });
-    ClosureDimension.RotationComponent = MutableCluster.Component({
-        attributes: {
-            rotationAxis: FixedAttribute(0x8, TlvEnum()),
-            overflow: FixedAttribute(0x9, TlvEnum()),
-        },
-    });
-    ClosureDimension.ModulationComponent = MutableCluster.Component({
-        attributes: {
-            modulationType: FixedAttribute(0xa, TlvEnum()),
-        },
-    });
-    ClosureDimension.Base = MutableCluster.Component({
-        id: 0x0105,
-        name: 'ClosureDimension',
-        revision: 1,
-        features: {
-            positioning: BitFlag(0),
-            motionLatching: BitFlag(1),
-            unit: BitFlag(2),
-            limitation: BitFlag(3),
-            speed: BitFlag(4),
-            translation: BitFlag(5),
-            rotation: BitFlag(6),
-            modulation: BitFlag(7),
-        },
-        attributes: {
-            currentState: Attribute(0x0, TlvNullable(ClosureDimension.TlvDimensionState), { default: null }),
-            targetState: Attribute(0x1, TlvNullable(ClosureDimension.TlvDimensionState), { default: null }),
-        },
-        commands: {
-            setTarget: Command(0x0, ClosureDimension.TlvSetTargetRequest, 0x0, TlvNoResponse, { timed: true }),
-        },
-        extensions: MutableCluster.Extensions({ flags: { positioning: true }, component: ClosureDimension.PositioningComponent }, { flags: { motionLatching: true }, component: ClosureDimension.MotionLatchingComponent }, { flags: { unit: true }, component: ClosureDimension.UnitComponent }, { flags: { limitation: true }, component: ClosureDimension.LimitationComponent }, { flags: { translation: true }, component: ClosureDimension.TranslationComponent }, { flags: { rotation: true }, component: ClosureDimension.RotationComponent }, { flags: { modulation: true }, component: ClosureDimension.ModulationComponent }, { flags: { positioning: false, motionLatching: false }, component: false }, { flags: { unit: true, positioning: false }, component: false }, { flags: { limitation: true, positioning: false }, component: false }, { flags: { speed: true, positioning: false }, component: false }, { flags: { translation: true, positioning: false }, component: false }, { flags: { rotation: true, positioning: false }, component: false }, { flags: { modulation: true, positioning: false }, component: false }, { flags: { translation: true, rotation: true }, component: false }, { flags: { translation: true, modulation: true }, component: false }, { flags: { rotation: true, modulation: true }, component: false }),
-    });
-    ClosureDimension.Cluster = MutableCluster.ExtensibleOnly(ClosureDimension.Base);
-    const PS = { positioning: true };
-    const LT = { motionLatching: true };
-    const UT = { unit: true };
-    const LM = { limitation: true };
-    const TR = { translation: true };
-    const RO = { rotation: true };
-    const MD = { modulation: true };
-    ClosureDimension.Complete = MutableCluster({
-        id: ClosureDimension.Base.id,
-        name: ClosureDimension.Base.name,
-        revision: ClosureDimension.Base.revision,
-        features: ClosureDimension.Base.features,
-        attributes: {
-            ...ClosureDimension.Base.attributes,
-            resolution: MutableCluster.AsConditional(ClosureDimension.PositioningComponent.attributes.resolution, { mandatoryIf: [PS] }),
-            stepValue: MutableCluster.AsConditional(ClosureDimension.PositioningComponent.attributes.stepValue, { mandatoryIf: [PS] }),
-            unit: MutableCluster.AsConditional(ClosureDimension.UnitComponent.attributes.unit, { mandatoryIf: [UT] }),
-            unitRange: MutableCluster.AsConditional(ClosureDimension.UnitComponent.attributes.unitRange, { mandatoryIf: [UT] }),
-            limitRange: MutableCluster.AsConditional(ClosureDimension.LimitationComponent.attributes.limitRange, { mandatoryIf: [LM] }),
-            translationDirection: MutableCluster.AsConditional(ClosureDimension.TranslationComponent.attributes.translationDirection, { mandatoryIf: [TR] }),
-            rotationAxis: MutableCluster.AsConditional(ClosureDimension.RotationComponent.attributes.rotationAxis, { mandatoryIf: [RO] }),
-            overflow: MutableCluster.AsConditional(ClosureDimension.RotationComponent.attributes.overflow, { mandatoryIf: [RO] }),
-            modulationType: MutableCluster.AsConditional(ClosureDimension.ModulationComponent.attributes.modulationType, { mandatoryIf: [MD] }),
-            latchControlModes: MutableCluster.AsConditional(ClosureDimension.MotionLatchingComponent.attributes.latchControlModes, { mandatoryIf: [LT] }),
-        },
-        commands: {
-            ...ClosureDimension.Base.commands,
-            step: MutableCluster.AsConditional(ClosureDimension.PositioningComponent.commands.step, { mandatoryIf: [PS] }),
-        },
-    });
-})(ClosureDimension || (ClosureDimension = {}));
-export const ClosureDimensionCluster = ClosureDimension.Cluster;
-ClusterRegistry.register(ClosureDimension.Complete);
+import { AttributeElement, ClusterElement, ClusterModel, CommandElement, DatatypeElement, FieldElement, Matter, MatterDefinition } from '@matter/main/model';
+import { ClusterType } from '@matter/types/cluster';
+export const ClosureDimensionDefinition = ClusterElement({
+    name: 'ClosureDimension',
+    id: 0x0105,
+    classification: 'application',
+}, AttributeElement({ name: 'ClusterRevision', id: 0xfffd, type: 'ClusterRevision', default: 1 }), AttributeElement({ name: 'FeatureMap', id: 0xfffc, type: 'FeatureMap' }, FieldElement({ name: 'PS', conformance: 'O', constraint: '0', title: 'Positioning' }), FieldElement({ name: 'LT', conformance: 'O', constraint: '1', title: 'MotionLatching' }), FieldElement({ name: 'UT', conformance: '[PS]', constraint: '2', title: 'Unit' }), FieldElement({ name: 'LM', conformance: '[PS]', constraint: '3', title: 'Limitation' }), FieldElement({ name: 'SP', conformance: '[PS]', constraint: '4', title: 'Speed' }), FieldElement({ name: 'TR', conformance: '[PS]', constraint: '5', title: 'Translation' }), FieldElement({ name: 'RO', conformance: '[PS]', constraint: '6', title: 'Rotation' }), FieldElement({ name: 'MD', conformance: '[PS]', constraint: '7', title: 'Modulation' })), AttributeElement({ name: 'CurrentState', id: 0x0000, type: 'DimensionStateStruct', access: 'R V', conformance: 'M', default: null, quality: 'X' }), AttributeElement({ name: 'TargetState', id: 0x0001, type: 'DimensionStateStruct', access: 'R V', conformance: 'M', default: null, quality: 'X' }), AttributeElement({ name: 'Resolution', id: 0x0002, type: 'percent100ths', access: 'R V', conformance: 'PS', default: 1, quality: 'F' }), AttributeElement({ name: 'StepValue', id: 0x0003, type: 'percent100ths', access: 'R V', conformance: 'PS', default: 1, quality: 'F' }), AttributeElement({ name: 'Unit', id: 0x0004, type: 'ClosureUnitEnum', access: 'R V', conformance: 'UT', quality: 'F' }), AttributeElement({ name: 'UnitRange', id: 0x0005, type: 'UnitRangeStruct', access: 'R V', conformance: 'UT', default: null, quality: 'X' }), AttributeElement({ name: 'LimitRange', id: 0x0006, type: 'RangePercent100thsStruct', access: 'R V', conformance: 'LM' }), AttributeElement({ name: 'TranslationDirection', id: 0x0007, type: 'TranslationDirectionEnum', access: 'R V', conformance: 'TR', quality: 'F' }), AttributeElement({ name: 'RotationAxis', id: 0x0008, type: 'RotationAxisEnum', access: 'R V', conformance: 'RO', quality: 'F' }), AttributeElement({ name: 'Overflow', id: 0x0009, type: 'OverflowEnum', access: 'R V', conformance: 'RO', quality: 'F' }), AttributeElement({ name: 'ModulationType', id: 0x000a, type: 'ModulationTypeEnum', access: 'R V', conformance: 'MD', quality: 'F' }), AttributeElement({ name: 'LatchControlModes', id: 0x000b, type: 'LatchControlModesBitmap', access: 'R V', conformance: 'LT', quality: 'F' }), CommandElement({ name: 'SetTarget', id: 0x0000, access: 'O T', conformance: 'M', direction: 'request', response: 'status' }, FieldElement({ name: 'Position', id: 0x0, type: 'percent100ths', conformance: 'O' }), FieldElement({ name: 'Latch', id: 0x1, type: 'bool', conformance: 'O' }), FieldElement({ name: 'Speed', id: 0x2, type: 'ThreeLevelAutoEnum', conformance: 'O' })), CommandElement({ name: 'Step', id: 0x0001, access: 'O T', conformance: 'PS', direction: 'request', response: 'status' }, FieldElement({ name: 'Direction', id: 0x0, type: 'StepDirectionEnum', conformance: 'M' }), FieldElement({ name: 'NumberOfSteps', id: 0x1, type: 'uint16', conformance: 'M', constraint: 'min 1' }), FieldElement({ name: 'Speed', id: 0x2, type: 'ThreeLevelAutoEnum', conformance: 'O' })), DatatypeElement({ name: 'ClosureUnitEnum', type: 'enum8' }, FieldElement({ name: 'Millimeter', id: 0x0, conformance: 'M' }), FieldElement({ name: 'Degree', id: 0x1, conformance: 'M' })), DatatypeElement({ name: 'ModulationTypeEnum', type: 'enum8' }, FieldElement({ name: 'SlatsOrientation', id: 0x0, conformance: 'M' }), FieldElement({ name: 'SlatsOpenwork', id: 0x1, conformance: 'M' }), FieldElement({ name: 'StripesAlignment', id: 0x2, conformance: 'M' }), FieldElement({ name: 'Opacity', id: 0x3, conformance: 'M' }), FieldElement({ name: 'Ventilation', id: 0x4, conformance: 'M' })), DatatypeElement({ name: 'OverflowEnum', type: 'enum8' }, FieldElement({ name: 'NoOverflow', id: 0x0, conformance: 'M' }), FieldElement({ name: 'Inside', id: 0x1, conformance: 'M' }), FieldElement({ name: 'Outside', id: 0x2, conformance: 'M' }), FieldElement({ name: 'TopInside', id: 0x3, conformance: 'M' }), FieldElement({ name: 'TopOutside', id: 0x4, conformance: 'M' }), FieldElement({ name: 'BottomInside', id: 0x5, conformance: 'M' }), FieldElement({ name: 'BottomOutside', id: 0x6, conformance: 'M' }), FieldElement({ name: 'LeftInside', id: 0x7, conformance: 'M' }), FieldElement({ name: 'LeftOutside', id: 0x8, conformance: 'M' }), FieldElement({ name: 'RightInside', id: 0x9, conformance: 'M' }), FieldElement({ name: 'RightOutside', id: 0x0a, conformance: 'M' })), DatatypeElement({ name: 'RotationAxisEnum', type: 'enum8' }, FieldElement({ name: 'Left', id: 0x0, conformance: 'M' }), FieldElement({ name: 'CenteredVertical', id: 0x1, conformance: 'M' }), FieldElement({ name: 'LeftAndRight', id: 0x2, conformance: 'M' }), FieldElement({ name: 'Right', id: 0x3, conformance: 'M' }), FieldElement({ name: 'Top', id: 0x4, conformance: 'M' }), FieldElement({ name: 'CenteredHorizontal', id: 0x5, conformance: 'M' }), FieldElement({ name: 'TopAndBottom', id: 0x6, conformance: 'M' }), FieldElement({ name: 'Bottom', id: 0x7, conformance: 'M' }), FieldElement({ name: 'LeftBarrier', id: 0x8, conformance: 'M' }), FieldElement({ name: 'LeftAndRightBarriers', id: 0x9, conformance: 'M' }), FieldElement({ name: 'RightBarrier', id: 0x0a, conformance: 'M' })), DatatypeElement({ name: 'StepDirectionEnum', type: 'enum8' }, FieldElement({ name: 'Decrease', id: 0x0, conformance: 'M' }), FieldElement({ name: 'Increase', id: 0x1, conformance: 'M' })), DatatypeElement({ name: 'TranslationDirectionEnum', type: 'enum8' }, FieldElement({ name: 'Downward', id: 0x0, conformance: 'M' }), FieldElement({ name: 'Upward', id: 0x1, conformance: 'M' }), FieldElement({ name: 'VerticalMask', id: 0x2, conformance: 'M' }), FieldElement({ name: 'VerticalSymmetry', id: 0x3, conformance: 'M' }), FieldElement({ name: 'Leftward', id: 0x4, conformance: 'M' }), FieldElement({ name: 'Rightward', id: 0x5, conformance: 'M' }), FieldElement({ name: 'HorizontalMask', id: 0x6, conformance: 'M' }), FieldElement({ name: 'HorizontalSymmetry', id: 0x7, conformance: 'M' }), FieldElement({ name: 'Forward', id: 0x8, conformance: 'M' }), FieldElement({ name: 'Backward', id: 0x9, conformance: 'M' }), FieldElement({ name: 'DepthMask', id: 0x0a, conformance: 'M' }), FieldElement({ name: 'DepthSymmetry', id: 0x0b, conformance: 'M' })), DatatypeElement({ name: 'LatchControlModesBitmap', type: 'map8' }, FieldElement({ name: 'RemoteLatching', constraint: '0' }), FieldElement({ name: 'RemoteUnlatching', constraint: '1' })), DatatypeElement({ name: 'DimensionStateStruct', type: 'struct' }, FieldElement({ name: 'Position', id: 0x0, type: 'percent100ths', conformance: 'O', default: null, quality: 'X' }), FieldElement({ name: 'Latch', id: 0x1, type: 'bool', conformance: 'O', default: null, quality: 'X' }), FieldElement({ name: 'Speed', id: 0x2, type: 'ThreeLevelAutoEnum', conformance: 'O' })), DatatypeElement({ name: 'RangePercent100thsStruct', type: 'struct' }, FieldElement({ name: 'Min', id: 0x0, type: 'percent100ths', conformance: 'M' }), FieldElement({ name: 'Max', id: 0x1, type: 'percent100ths', conformance: 'M' })), DatatypeElement({ name: 'UnitRangeStruct', type: 'struct' }, FieldElement({ name: 'Min', id: 0x0, type: 'int16', conformance: 'M' }), FieldElement({ name: 'Max', id: 0x1, type: 'int16', conformance: 'M' })));
+export const ClosureDimensionModel = new ClusterModel(ClosureDimensionDefinition);
+if (!MatterDefinition.children.some((child) => child.id === ClosureDimensionDefinition.id)) {
+    MatterDefinition.children.push(ClosureDimensionDefinition);
+}
+if (Matter.clusters(ClosureDimensionModel.id) === undefined) {
+    Matter.children.push(ClosureDimensionModel);
+}
+export const ClosureDimension = ClusterType(ClosureDimensionModel);

package/dist/clusters/export.d.ts

@@ -1,3 +1 @@
-export * from './closure-control.js';
-export * from './closure-dimension.js';
-export * from './soil-measurement.js';
+export {};

package/dist/clusters/export.js

@@ -1,3 +1 @@
-export * from './closure-control.js';
-export * from './closure-dimension.js';
-export * from './soil-measurement.js';
+export {};

package/dist/clusters/soil-measurement.d.ts

@@ -1,34 +1,34 @@
-import { Identity } from '@matter/general';
-import { Attribute, FixedAttribute, MutableCluster } from '@matter/types/cluster';
+import { ClusterElement, ClusterModel } from '@matter/main/model';
+import { ClusterType, type ClusterTyping } from '@matter/types/cluster';
+import { type ClusterId } from '@matter/types/datatype';
+import { type MeasurementAccuracy } from '@matter/types/globals';
+export declare const SoilMeasurementDefinition: ClusterElement;
+export declare const SoilMeasurementModel: ClusterModel;
 export declare namespace SoilMeasurement {
-    const ClusterInstance: MutableCluster<{
-        readonly id: 1072;
-        readonly name: "SoilMeasurement";
-        readonly revision: 1;
-        readonly attributes: {
-            readonly soilMoistureMeasurementLimits: FixedAttribute<import("@matter/types/tlv").TypeFromFields<{
-                measurementType: import("@matter/types/tlv").FieldType<import("@matter/types/globals").MeasurementType>;
-                measured: import("@matter/types/tlv").FieldType<boolean>;
-                minMeasuredValue: import("@matter/types/tlv").FieldType<number | bigint>;
-                maxMeasuredValue: import("@matter/types/tlv").FieldType<number | bigint>;
-                accuracyRanges: import("@matter/types/tlv").FieldType<import("@matter/types/tlv").TypeFromFields<{
-                    rangeMin: import("@matter/types/tlv").FieldType<number | bigint>;
-                    rangeMax: import("@matter/types/tlv").FieldType<number | bigint>;
-                    percentMax: import("@matter/types/tlv").OptionalFieldType<number>;
-                    percentMin: import("@matter/types/tlv").OptionalFieldType<number>;
-                    percentTypical: import("@matter/types/tlv").OptionalFieldType<number>;
-                    fixedMax: import("@matter/types/tlv").OptionalFieldType<number | bigint>;
-                    fixedMin: import("@matter/types/tlv").OptionalFieldType<number | bigint>;
-                    fixedTypical: import("@matter/types/tlv").OptionalFieldType<number | bigint>;
-                }>[]>;
-            }>, any>;
-            readonly soilMoistureMeasuredValue: Attribute<number | null, any>;
-        };
-    }, []>;
-    interface Cluster extends Identity<typeof ClusterInstance> {
+    interface BaseAttributes {
+        soilMoistureMeasurementLimits: MeasurementAccuracy;
+        soilMoistureMeasuredValue: number | null;
+    }
+    interface Attributes {
+        soilMoistureMeasurementLimits: MeasurementAccuracy;
+        soilMoistureMeasuredValue: number | null;
+    }
+    type Components = [{
+        flags: {};
+        attributes: BaseAttributes;
+    }];
+    interface Typing extends ClusterTyping {
+        Attributes: Attributes;
+        Components: Components;
     }
-    const Cluster: Cluster;
-    const Complete: Cluster;
 }
-export type SoilMeasurementCluster = SoilMeasurement.Cluster;
-export declare const SoilMeasurementCluster: SoilMeasurement.Cluster;
+export declare const SoilMeasurement: ClusterType.Concrete & {
+    readonly id: ClusterId & 1072;
+    readonly name: "SoilMeasurement";
+    readonly revision: 1;
+    readonly schema: ClusterModel;
+    readonly attributes: ClusterType.AttributeObjects<SoilMeasurement.Attributes>;
+    readonly Typing: SoilMeasurement.Typing;
+    readonly Cluster: typeof SoilMeasurement;
+    readonly Complete: typeof SoilMeasurement;
+};

package/dist/clusters/soil-measurement.js

@@ -1,19 +1,29 @@
-import { Attribute, ClusterRegistry, FixedAttribute, MutableCluster } from '@matter/types/cluster';
-import { TlvMeasurementAccuracy } from '@matter/types/globals';
-import { TlvNullable, TlvPercent } from '@matter/types/tlv';
-export var SoilMeasurement;
-(function (SoilMeasurement) {
-    SoilMeasurement.ClusterInstance = MutableCluster({
-        id: 0x0430,
-        name: 'SoilMeasurement',
-        revision: 1,
-        attributes: {
-            soilMoistureMeasurementLimits: FixedAttribute(0x0, TlvMeasurementAccuracy),
-            soilMoistureMeasuredValue: Attribute(0x1, TlvNullable(TlvPercent)),
-        },
-    });
-    SoilMeasurement.Cluster = SoilMeasurement.ClusterInstance;
-    SoilMeasurement.Complete = SoilMeasurement.Cluster;
-})(SoilMeasurement || (SoilMeasurement = {}));
-export const SoilMeasurementCluster = SoilMeasurement.Cluster;
-ClusterRegistry.register(SoilMeasurement.Complete);
+import { AttributeElement, ClusterElement, ClusterModel, Matter, MatterDefinition } from '@matter/main/model';
+import { ClusterType } from '@matter/types/cluster';
+export const SoilMeasurementDefinition = ClusterElement({
+    name: 'SoilMeasurement',
+    id: 0x0430,
+    classification: 'application',
+}, AttributeElement({ name: 'ClusterRevision', id: 0xfffd, type: 'ClusterRevision', default: 1 }), AttributeElement({ name: 'FeatureMap', id: 0xfffc, type: 'FeatureMap' }), AttributeElement({
+    name: 'SoilMoistureMeasurementLimits',
+    id: 0x0000,
+    type: 'MeasurementAccuracyStruct',
+    access: 'R V',
+    conformance: 'M',
+}), AttributeElement({
+    name: 'SoilMoistureMeasuredValue',
+    id: 0x0001,
+    type: 'percent',
+    access: 'R V',
+    conformance: 'M',
+    quality: 'X',
+    default: null,
+}));
+export const SoilMeasurementModel = new ClusterModel(SoilMeasurementDefinition);
+if (!MatterDefinition.children.some((child) => child.id === SoilMeasurementDefinition.id)) {
+    MatterDefinition.children.push(SoilMeasurementDefinition);
+}
+if (Matter.clusters(SoilMeasurementModel.id) === undefined) {
+    Matter.children.push(SoilMeasurementModel);
+}
+export const SoilMeasurement = ClusterType(SoilMeasurementModel);